From a5d7e68af96d9b62821d8fd47f5039c5bae5d421 Mon Sep 17 00:00:00 2001 From: Reiner Herrmann Date: Fri, 10 Feb 2012 14:25:38 +0100 Subject: added original sam_player code --- c64/c64.c | 207 +++++++++ c64/c64.h | 18 + c64/cia.c | 279 ++++++++++++ c64/cia.h | 55 +++ c64/cpu.c | 678 +++++++++++++++++++++++++++++ c64/cpu.h | 38 ++ c64/kbd.c | 248 +++++++++++ c64/kbd.h | 90 ++++ c64/mem.c | 1314 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ c64/mem.h | 18 + c64/prg_file.c | 1105 +++++++++++++++++++++++++++++++++++++++++++++++ c64/prg_file.h | 14 + c64/sid.c | 91 ++++ c64/sid.h | 16 + c64/tape.c | 172 ++++++++ c64/tape.h | 10 + sam.c | 53 +++ sam.h | 12 + sam_player.c | 46 ++ wave.h | 31 ++ 20 files changed, 4495 insertions(+) create mode 100644 c64/c64.c create mode 100644 c64/c64.h create mode 100644 c64/cia.c create mode 100644 c64/cia.h create mode 100644 c64/cpu.c create mode 100644 c64/cpu.h create mode 100644 c64/kbd.c create mode 100644 c64/kbd.h create mode 100644 c64/mem.c create mode 100644 c64/mem.h create mode 100644 c64/prg_file.c create mode 100644 c64/prg_file.h create mode 100644 c64/sid.c create mode 100644 c64/sid.h create mode 100644 c64/tape.c create mode 100644 c64/tape.h create mode 100644 sam.c create mode 100644 sam.h create mode 100644 sam_player.c create mode 100644 wave.h diff --git a/c64/c64.c b/c64/c64.c new file mode 100644 index 0000000..2cbbfe9 --- /dev/null +++ b/c64/c64.c @@ -0,0 +1,207 @@ +// c64.c +// +// 20060803 Markku Alén + +#include "c64.h" +#include "cpu.h" +#include "mem.h" +#include "sid.h" +#include "cia.h" +#include "tape.h" + +unsigned int total_cycles; + +static cia_t cia1; + +static int on_chip_port_pins; +static int on_chip_port_input; +static int on_chip_port_output; +static int on_chip_port_direction; +#define UPDATE_ON_CHIP_PORT_PINS() (on_chip_port_pins = (on_chip_port_output & on_chip_port_direction) | (on_chip_port_input & ~on_chip_port_direction)) + +static int page_read(int address) +{ + switch(address & 0xffff) + { + case 0x0000: + return on_chip_port_direction; + case 0x0001: + return on_chip_port_output; + default: + return ram[address & 0xffff]; + } +} + +static void page_write(int address, int data) +{ + switch(address & 0xffff) + { + case 0x0000: + on_chip_port_direction = data; + UPDATE_ON_CHIP_PORT_PINS(); + break; + case 0x0001: + on_chip_port_output = data; + UPDATE_ON_CHIP_PORT_PINS(); + break; + default: + ram[address & 0xffff] = data; + } +} + +static int io_read(int address) +{ + switch(address & 0x0c00) + { + case 0x0000: + return 0; + case 0x0400: + return sid_read(address); + case 0x0800: + return color[address % sizeof(color)]; + default: + switch(address & 0x0300) + { + case 0x0000: + return cia_read(&cia1, address); + case 0x0100: + return 0; + default: + return 0x00; + } + } +} + +static void io_write(int address, int data) +{ + switch(address & 0x0c00) + { + case 0x0000: + break; + case 0x0400: + sid_write(address, data); + break; + case 0x0800: + color[address % sizeof(color)] = data; + break; + default: + switch(address & 0x0300) + { + case 0x0000: + cia_write(&cia1, address, data); + if((address & 0x000f) == 0x00) + cia_port_b_input(&cia1, kbd_data(cia_a_port_output(&cia1))); + break; + case 0x0100: + break; + } + } +} + +static int cpu_read(int address) +{ + switch(address & 0xf000) + { + case 0xa000: + case 0xb000: + switch(on_chip_port_pins & 0x07) + { + case 0x03: + case 0x07: + return basic[address % sizeof(basic)]; + default: + return page_read(address); + } + break; + case 0xd000: + switch(on_chip_port_pins & 0x07) + { + case 0x01: + case 0x02: + case 0x03: + return chars[address % sizeof(chars)]; + case 0x05: + case 0x06: + case 0x07: + return io_read(address); + default: + return page_read(address); + } + break; + case 0xe000: + case 0xf000: + switch(on_chip_port_pins & 0x07) + { + case 0x02: + case 0x03: + case 0x06: + case 0x07: + return kernel[address % sizeof(kernel)]; + default: + return page_read(address); + } + break; + default: + return page_read(address); + } +} + +static void cpu_write(int address, int data) +{ + switch(address & 0xf000) + { + case 0xd000: + switch(on_chip_port_pins & 0x07) + { + case 0x05: + case 0x06: + case 0x07: + io_write(address, data); + break; + default: + page_write(address, data); + } + break; + default: + page_write(address, data); + } +} + +static void cpu_jam(int address, int op_code) +{ + reset_cpu(); +} + +void c64_init(void) +{ + total_cycles = 0; + on_chip_port_input = 0xff; + on_chip_port_output = 0x00; + on_chip_port_direction = 0x00; + UPDATE_ON_CHIP_PORT_PINS(); + kbd_init(); + sid_init(); + cia_init(&cia1); + init_cpu(cpu_read, cpu_write, page_read, page_write, cpu_jam); + init_tape(); + reset_cpu(); +} + +void c64_run(unsigned int cycle_count) +{ + unsigned int elapsed_cycles; + for(;;) + { + elapsed_cycles = cycles; + exec_cpu(); + elapsed_cycles = cycles - elapsed_cycles; + if(cycle_count <= elapsed_cycles) + break; + cycle_count -= elapsed_cycles; + total_cycles += elapsed_cycles; + cia_exec(&cia1, elapsed_cycles); + if(cia1.irq_pin) + raise_irq(); + } +} + diff --git a/c64/c64.h b/c64/c64.h new file mode 100644 index 0000000..9b9c298 --- /dev/null +++ b/c64/c64.h @@ -0,0 +1,18 @@ +// c64.h +// +// 20060803 Markku Alén + +#ifndef __C64_H__ +#define __C64_H__ 1 + +#include "kbd.h" + +#define F_CPU 984375L + +extern unsigned int total_cycles; + +void c64_init(void); + +void c64_run(unsigned int cycle_count); + +#endif diff --git a/c64/cia.c b/c64/cia.c new file mode 100644 index 0000000..cf0d2c0 --- /dev/null +++ b/c64/cia.c @@ -0,0 +1,279 @@ +// cia.c +// +// 20060803 Markku Alén + +#include "cia.h" + +#define TA_BIT 0 +#define TA_MASK (1<mask = 0; + cia_interrupt->request = 0; +} + +static void cia_interrupt_raise(cia_interrupt_t *cia_interrupt) +{ + cia_interrupt->request = 1; +} + +static int cia_interrupt_get_request(cia_interrupt_t *cia_interrupt) +{ + int request; + request = cia_interrupt->request; + cia_interrupt->request = 0; + return request; +} + +static void cia_port_init(cia_port_t *cia_port) +{ + cia_port->input = 0x00; + cia_port->output = 0x00; + cia_port->direction = 0x00; + UPDATE_CIA_PORT_PINS(cia_port); +} + +static void cia_port_set_data(cia_port_t *cia_port, int data) +{ + cia_port->output = data; + UPDATE_CIA_PORT_PINS(cia_port); +} + +static void cia_port_set_direction(cia_port_t *cia_port, int direction) +{ + cia_port->direction = direction; + UPDATE_CIA_PORT_PINS(cia_port); +} + +static void cia_timer_init(cia_timer_t *cia_timer) +{ + cia_timer->latch = 0x0000; + cia_timer->counter = 0x0000; + cia_timer->running = 0; + cia_timer->toggle_mode = 0; + cia_timer->one_shot = 0; + cia_interrupt_init(&cia_timer->interrupt); +} + +static int cia_timer_exec(cia_timer_t *cia_timer, unsigned int cycles) +{ + if(!cia_timer->running) + return 0; + cia_timer->counter -= cycles; + if(cia_timer->counter >= 0) + return 0; + cia_timer->counter += cia_timer->latch; + cia_interrupt_raise(&cia_timer->interrupt); + if(cia_timer->one_shot) + cia_timer->running = 0; + return 1; +} + +void cia_init(cia_t *cia) +{ + cia_port_init(&cia->port_a); + cia_port_init(&cia->port_b); + cia_timer_init(&cia->timer_a); + cia_timer_init(&cia->timer_b); + cia->inmode_a = 0; + cia->inmode_b = 0; + cia->irq_pin = 0; +} + +int cia_read(cia_t *cia, int address) +{ + switch(address & 0x000f) + { + case 0x0000: + return cia->port_a.pins; + case 0x0001: + return cia->port_b.pins; + case 0x0002: + return cia->port_a.direction; + case 0x0003: + return cia->port_b.direction; + case 0x0004: + return cia->timer_a.counter % 256; + case 0x0005: + return cia->timer_a.counter / 256; + case 0x0006: + return cia->timer_b.counter % 256; + case 0x0007: + return cia->timer_b.counter / 256; + case 0x000d: + return 0 + | (cia_interrupt_get_request(&cia->timer_a.interrupt) != 0 ? TA_MASK : 0) + | (cia_interrupt_get_request(&cia->timer_b.interrupt) != 0 ? TB_MASK : 0) + | (cia->irq_pin != 0 ? IR_MASK : 0) + ; + case 0x000e: + return 0 + | cia->timer_a.running + | cia->timer_a.toggle_mode + | cia->timer_a.one_shot + | cia->inmode_a + ; + case 0x000f: + return 0 + | cia->timer_b.running + | cia->timer_b.toggle_mode + | cia->timer_b.one_shot + | cia->inmode_b + ; + default: + return regs[address % sizeof(regs)]; + } +} + +void cia_write(cia_t *cia, int address, int data) +{ + switch(address & 0x000f) + { + case 0x0000: + cia_port_set_data(&cia->port_a, data); + break; + case 0x0001: + cia_port_set_data(&cia->port_b, data); + break; + case 0x0002: + cia_port_set_direction(&cia->port_a, data); + break; + case 0x0003: + cia_port_set_direction(&cia->port_b, data); + break; + case 0x0004: + cia->timer_a.latch = (cia->timer_a.latch & 0xff00) | (data & 0xff); + break; + case 0x0005: + cia->timer_a.latch = (cia->timer_a.latch & 0x00ff) | ((data & 0xff) << 8); + if(!cia->timer_a.running) + cia->timer_a.counter = cia->timer_a.latch; + break; + case 0x0006: + cia->timer_b.latch = (cia->timer_b.latch & 0xff00) | (data & 0xff); + break; + case 0x0007: + cia->timer_b.latch = (cia->timer_b.latch & 0x00ff) | ((data & 0xff) << 8); + if(!cia->timer_b.running) + cia->timer_b.counter = cia->timer_b.latch; + break; + case 0x000d: + if((data & TA_MASK) != 0) + cia->timer_a.interrupt.mask = data & SC_MASK; + if((data & TB_MASK) != 0) + cia->timer_b.interrupt.mask = data & SC_MASK; + break; + case 0x000e: + cia->timer_a.running = data & START_MASK; + cia->timer_a.toggle_mode = data & OUTMODE_MASK; + cia->timer_a.one_shot = data & RUNMODE_MASK; + if((data & LOAD_MASK) != 0) + cia->timer_a.counter = cia->timer_a.latch; + cia->inmode_a = data & INMODEA_MASK; + break; + case 0x000f: + cia->timer_b.running = data & START_MASK; + cia->timer_b.toggle_mode = data & OUTMODE_MASK; + cia->timer_b.one_shot = data & RUNMODE_MASK; + if((data & LOAD_MASK) != 0) + cia->timer_b.counter = cia->timer_b.latch; + cia->inmode_b = data & INMODEB_MASK; + break; + default: + regs[address % sizeof(regs)] = data; + } +} + +int cia_a_port_output(cia_t *cia) +{ + return cia->port_a.pins; +} + +int cia_b_port_output(cia_t *cia) +{ + return cia->port_b.pins; +} + +void cia_port_a_input(cia_t *cia, int data) +{ + cia->port_a.input = data; + UPDATE_CIA_PORT_PINS(&cia->port_a); +} + +void cia_port_b_input(cia_t *cia, int data) +{ + cia->port_b.input = data; + UPDATE_CIA_PORT_PINS(&cia->port_b); +} + +void cia_exec(cia_t *cia, unsigned int cycles) +{ + int timer_a_underflowed; + switch(cia->inmode_a) + { + case TA_CLK: + timer_a_underflowed = cia_timer_exec(&cia->timer_a, cycles); + break; + default: + timer_a_underflowed = 0; + } + switch(cia->inmode_b) + { + case TB_CLK: + cia_timer_exec(&cia->timer_b, cycles); + break; + case TB_TMRA: + if(timer_a_underflowed) + cia_timer_exec(&cia->timer_b, 1); + break; + } + cia->irq_pin = 0 + | (cia->timer_a.interrupt.mask != 0 ? cia->timer_a.interrupt.request : 0) + | (cia->timer_b.interrupt.mask != 0 ? cia->timer_b.interrupt.request : 0) + ; +} diff --git a/c64/cia.h b/c64/cia.h new file mode 100644 index 0000000..8272c25 --- /dev/null +++ b/c64/cia.h @@ -0,0 +1,55 @@ +// cia.h +// +// 20060803 Markku Alén + +#ifndef __CIA_H__ +#define __CIA_H__ 1 + +typedef struct __cia_interrupt +{ + int mask; + int request; +}cia_interrupt_t; + +typedef struct __cia_port +{ + int pins; + int input; + int output; + int direction; +}cia_port_t; + +#define UPDATE_CIA_PORT_PINS(CIA_PORT) ((CIA_PORT)->pins = ((CIA_PORT)->output & (CIA_PORT)->direction) | ((CIA_PORT)->input & ~((CIA_PORT)->direction))) + +typedef struct __cia_timer +{ + int latch; + int counter; + int running; + int toggle_mode; + int one_shot; + cia_interrupt_t interrupt; +}cia_timer_t; + +typedef struct __cia +{ + cia_port_t port_a, port_b; + cia_timer_t timer_a, timer_b; + int inmode_a, inmode_b; + int irq_pin; +}cia_t; + +void cia_init(cia_t *cia); + +int cia_read(cia_t *cia, int address); +void cia_write(cia_t *cia, int address, int data); + +int cia_a_port_output(cia_t *cia); +int cia_b_port_output(cia_t *cia); + +void cia_port_a_input(cia_t *cia, int data); +void cia_port_b_input(cia_t *cia, int data); + +void cia_exec(cia_t *cia, unsigned int cycles); + +#endif diff --git a/c64/cpu.c b/c64/cpu.c new file mode 100644 index 0000000..ba206fe --- /dev/null +++ b/c64/cpu.c @@ -0,0 +1,678 @@ +// cpu.c +// +// 20050125 Markku Alén + +#include "cpu.h" + +#define NMI_VECTOR 0xfffa +#define RST_VECTOR 0xfffc +#define IRQ_VECTOR 0xfffe + +static int (*read_bus)(int); +static void (*write_bus)(int, int); +static int (*read_page)(int); +static void (*write_page)(int, int); +static void (*jam_handler)(int, int); + +unsigned int cycles; + +void (*reset_cpu)(void); +void (*raise_nmi)(void); +void (*raise_irq)(void); +void (*exec_cpu)(void); + +static trap_t *first_trap; + +static int ea, tmp1, tmp2; +static int accumulator; +static int register_x; +static int register_y; +static int pc, sp; +static int sr, c, nz; + +#define FLAG_N 0x80 +#define FLAG_V 0x40 +#define FLAG_X 0x20 +#define FLAG_B 0x10 +#define FLAG_D 0x08 +#define FLAG_I 0x04 +#define FLAG_Z 0x02 +#define FLAG_C 0x01 + +#define TEST_N() ((nz & 0x8080) != 0) +#define TEST_V() ((sr & 0x40) != 0) +#define TEST_X() ((sr & 0x20) != 0) +#define TEST_B() ((sr & 0x10) != 0) +#define TEST_D() ((sr & 0x08) != 0) +#define TEST_I() ((sr & 0x04) != 0) +#define TEST_Z() ((nz & 0xff) == 0) +#define TEST_C() ((c & 0x100) != 0) + +#define SET_V() sr |= 0x40; +#define SET_D() sr |= 0x08; +#define SET_I() sr |= 0x04; +#define SET_C() c = 0x100; + +#define CLEAR_V() sr &= 0xbf; +#define CLEAR_D() sr &= 0xf7; +#define CLEAR_I() sr &= 0xfb; +#define CLEAR_C() c = 0; + +static const int z_tbl[4] = { 0xffff, 0xffff, 0x8000, 0x8000 }; + +#define get_sr() ((nz & 0x80) | ((nz & 0x8000) >> 8) | (sr & 0x7c) | ((((nz & 0xff) == 0) & 1) << 1) | ((c & 0x100) >> 8)) +#define set_sr(SR) { c = sr = (SR); c <<= 8; nz = (sr | (c & 0x8000)) & z_tbl[sr & 0x02]; } + +#define DECL(NAME) static void NAME(void); +#define BEGIN(NAME) static void NAME(void) { +#define END exec_cpu = op_code[read_bus(pc++)]; } + +DECL(jam) DECL(nmi) DECL(rst) DECL(irq) +DECL(brk_imm) DECL(nop) +DECL(rti) DECL(rts) DECL(jsr_abs) DECL(jmp_abs) DECL(jmp_ind) +DECL(php) DECL(plp) DECL(pha) DECL(pla) +DECL(tax) DECL(txa) DECL(tay) DECL(tya) DECL(txs) DECL(tsx) +DECL(clc) DECL(sec) DECL(cli) DECL(sei) DECL(clv) DECL(cld) DECL(sed) +DECL(bpl) DECL(bmi) DECL(bvc) DECL(bvs) DECL(bcc) DECL(bcs) DECL(bne) DECL(beq) +DECL(lda_imm) DECL(lda_zp) DECL(lda_zp_x) DECL(lda_abs) DECL(lda_abs_x) DECL(lda_abs_y) DECL(lda_ind_x) DECL(lda_ind_y) +DECL(ldx_imm) DECL(ldx_zp) DECL(ldx_zp_y) DECL(ldx_abs) DECL(ldx_abs_y) +DECL(ldy_imm) DECL(ldy_zp) DECL(ldy_zp_x) DECL(ldy_abs) DECL(ldy_abs_x) +DECL(sta_zp) DECL(sta_zp_x) DECL(sta_abs) DECL(sta_abs_x) DECL(sta_abs_y) DECL(sta_ind_x) DECL(sta_ind_y) +DECL(stx_zp) DECL(stx_zp_y) DECL(stx_abs) +DECL(sty_zp) DECL(sty_zp_x) DECL(sty_abs) +DECL(cmp_imm) DECL(cmp_zp) DECL(cmp_zp_x) DECL(cmp_abs) DECL(cmp_abs_x) DECL(cmp_abs_y) DECL(cmp_ind_x) DECL(cmp_ind_y) +DECL(cpx_imm) DECL(cpx_zp) DECL(cpx_abs) +DECL(cpy_imm) DECL(cpy_zp) DECL(cpy_abs) +DECL(ora_imm) DECL(ora_zp) DECL(ora_zp_x) DECL(ora_abs) DECL(ora_abs_x) DECL(ora_abs_y) DECL(ora_ind_x) DECL(ora_ind_y) +DECL(eor_imm) DECL(eor_zp) DECL(eor_zp_x) DECL(eor_abs) DECL(eor_abs_x) DECL(eor_abs_y) DECL(eor_ind_x) DECL(eor_ind_y) +DECL(and_imm) DECL(and_zp) DECL(and_zp_x) DECL(and_abs) DECL(and_abs_x) DECL(and_abs_y) DECL(and_ind_x) DECL(and_ind_y) +DECL(adc_imm) DECL(adc_zp) DECL(adc_zp_x) DECL(adc_abs) DECL(adc_abs_x) DECL(adc_abs_y) DECL(adc_ind_x) DECL(adc_ind_y) +DECL(sbc_imm) DECL(sbc_zp) DECL(sbc_zp_x) DECL(sbc_abs) DECL(sbc_abs_x) DECL(sbc_abs_y) DECL(sbc_ind_x) DECL(sbc_ind_y) +DECL(bit_zp) DECL(bit_abs) +DECL(inc_zp) DECL(inc_zp_x) DECL(inc_abs) DECL(inc_abs_x) +DECL(dec_zp) DECL(dec_zp_x) DECL(dec_abs) DECL(dec_abs_x) +DECL(asl_a) DECL(asl_zp) DECL(asl_zp_x) DECL(asl_abs) DECL(asl_abs_x) +DECL(lsr_a) DECL(lsr_zp) DECL(lsr_zp_x) DECL(lsr_abs) DECL(lsr_abs_x) +DECL(rol_a) DECL(rol_zp) DECL(rol_zp_x) DECL(rol_abs) DECL(rol_abs_x) +DECL(ror_a) DECL(ror_zp) DECL(ror_zp_x) DECL(ror_abs) DECL(ror_abs_x) +DECL(inx) DECL(dex) DECL(iny) DECL(dey) + +static void (* const (op_code[256]))(void) = +{ + brk_imm ,ora_ind_x ,jam ,jam ,jam ,ora_zp ,asl_zp ,jam , + php ,ora_imm ,asl_a ,jam ,jam ,ora_abs ,asl_abs ,jam , + bpl ,ora_ind_y ,jam ,jam ,jam ,ora_zp_x ,asl_zp_x ,jam , + clc ,ora_abs_y ,jam ,jam ,jam ,ora_abs_x ,asl_abs_x ,jam , + jsr_abs ,and_ind_x ,jam ,jam ,bit_zp ,and_zp ,rol_zp ,jam , + plp ,and_imm ,rol_a ,jam ,bit_abs ,and_abs ,rol_abs ,jam , + bmi ,and_ind_y ,jam ,jam ,jam ,and_zp_x ,rol_zp_x ,jam , + sec ,and_abs_y ,jam ,jam ,jam ,and_abs_x ,rol_abs_x ,jam , + rti ,eor_ind_x ,jam ,jam ,jam ,eor_zp ,lsr_zp ,jam , + pha ,eor_imm ,lsr_a ,jam ,jmp_abs ,eor_abs ,lsr_abs ,jam , + bvc ,eor_ind_y ,jam ,jam ,jam ,eor_zp_x ,lsr_zp_x ,jam , + cli ,eor_abs_y ,jam ,jam ,jam ,eor_abs_x ,lsr_abs_x ,jam , + rts ,adc_ind_x ,jam ,jam ,jam ,adc_zp ,ror_zp ,jam , + pla ,adc_imm ,ror_a ,jam ,jmp_ind ,adc_abs ,ror_abs ,jam , + bvs ,adc_ind_y ,jam ,jam ,jam ,adc_zp_x ,ror_zp_x ,jam , + sei ,adc_abs_y ,jam ,jam ,jam ,adc_abs_x ,ror_abs_x ,jam , + jam ,sta_ind_x ,jam ,jam ,sty_zp ,sta_zp ,stx_zp ,jam , + dey ,jam ,txa ,jam ,sty_abs ,sta_abs ,stx_abs ,jam , + bcc ,sta_ind_y ,jam ,jam ,sty_zp_x ,sta_zp_x ,stx_zp_y ,jam , + tya ,sta_abs_y ,txs ,jam ,jam ,sta_abs_x ,jam ,jam , + ldy_imm ,lda_ind_x ,ldx_imm ,jam ,ldy_zp ,lda_zp ,ldx_zp ,jam , + tay ,lda_imm ,tax ,jam ,ldy_abs ,lda_abs ,ldx_abs ,jam , + bcs ,lda_ind_y ,jam ,jam ,ldy_zp_x ,lda_zp_x ,ldx_zp_y ,jam , + clv ,lda_abs_y ,tsx ,jam ,ldy_abs_x ,lda_abs_x ,ldx_abs_y ,jam , + cpy_imm ,cmp_ind_x ,jam ,jam ,cpy_zp ,cmp_zp ,dec_zp ,jam , + iny ,cmp_imm ,dex ,jam ,cpy_abs ,cmp_abs ,dec_abs ,jam , + bne ,cmp_ind_y ,jam ,jam ,jam ,cmp_zp_x ,dec_zp_x ,jam , + cld ,cmp_abs_y ,jam ,jam ,jam ,cmp_abs_x ,dec_abs_x ,jam , + cpx_imm ,sbc_ind_x ,jam ,jam ,cpx_zp ,sbc_zp ,inc_zp ,jam , + inx ,sbc_imm ,nop ,jam ,cpx_abs ,sbc_abs ,inc_abs ,jam , + beq ,sbc_ind_y ,jam ,jam ,jam ,sbc_zp_x ,inc_zp_x ,jam , + sed ,sbc_abs_y ,jam ,jam ,jam ,sbc_abs_x ,inc_abs_x ,jam , +}; + +void set_c_flag(int enable) +{ + int tmp; + tmp = get_sr(); + tmp &= ~FLAG_C; + if(enable) + tmp |= FLAG_C; + set_sr(tmp); +} + +void set_z_flag(int enable) +{ + int tmp; + tmp = get_sr(); + tmp &= ~FLAG_Z; + if(enable) + tmp |= FLAG_Z; + set_sr(tmp); +} + +void set_pc(int addr) +{ + pc = addr; +} + +int get_pc(void) +{ + return pc; +} + +int get_a(void) +{ + return accumulator; +} + +int get_x(void) +{ + return register_x; +} + +int get_y(void) +{ + return register_y; +} + +void init_cpu(int (*cpu_read)(int), void (*cpu_write)(int, int), int (*cpu_read_page)(int), void (*cpu_write_page)(int, int), void (*cpu_jam)(int, int)) +{ + read_bus = cpu_read; + write_bus = cpu_write; + read_page = cpu_read_page; + write_page = cpu_write_page; + jam_handler = cpu_jam; + accumulator = 0; + register_x = 0; + register_y = 0; + pc = sp = 0; + set_sr(FLAG_X | FLAG_B | FLAG_I); + cycles = 0; + reset_cpu = rst; + raise_nmi = nmi; + raise_irq = irq; + exec_cpu = jam; + first_trap = 0; +} + +static int trap(void) +{ + trap_t *trap; + for(trap = first_trap;trap != 0;trap = trap->next_trap) + { + if(trap->addr == (pc - 1)) + return trap->handler(); + } + return -1; +} + +static int install_trap(trap_t *trap, void (*poke)(int, int), int (*peek)(int)) +{ + int i; + for(i = sizeof(trap->org) / sizeof(trap->org[0]);i-- > 0;) + { + if(peek(trap->addr + i) != trap->org[i]) + return -1; + } + poke(trap->addr, 0x00); + trap->next_trap = first_trap; + first_trap = trap; + return 0; +} + +void install_traps(int cnt, trap_t *tbl, void (*poke)(int, int), int (*peek)(int)) +{ + while(cnt-- > 0) + (void)install_trap(&tbl[cnt], poke, peek); +} + +#define CYCLES(AMOUNT) cycles += AMOUNT; + +#define PUSH(DATA) { write_page(sp | 0x0100, DATA); sp = (sp - 1) & 0xff; } +#define POP() read_page((sp = (sp + 1) & 0xff) | 0x0100) + +#define JMP_ABSOLUTE(EA) \ +{ \ + (EA) = read_bus(tmp1 = pc); \ + (EA) |= read_bus(tmp1 + 1) << 8; \ + CYCLES(3); \ +} + +#define JMP_INDIRECT(EA) \ +{ \ + tmp2 = read_bus(pc++); \ + tmp1 = read_bus(pc++) << 8; \ + (EA) = read_bus(tmp2 | tmp1); \ + (EA) |= read_bus((((tmp2 + 1) & 0x00ff) | tmp1)) << 8; \ + CYCLES(5); \ +} + +#define READ_IMMEDIATE(EA) \ +{ \ + (EA) = pc++; \ + CYCLES(2); \ +} + +#define READ_ZERO_PAGE(EA) \ +{ \ + (EA) = read_bus(pc++); \ + CYCLES(3); \ +} + +#define READ_ZERO_PAGE_X(EA) \ +{ \ + (EA) = (read_bus(pc++) + register_x) & 0xff; \ + CYCLES(4); \ +} + +#define READ_ZERO_PAGE_Y(EA) \ +{ \ + (EA) = (read_bus(pc++) + register_y) & 0xff; \ + CYCLES(4); \ +} + +#define READ_ABSOLUTE(EA) \ +{ \ + tmp1 = read_bus(pc++); \ + (EA) = tmp1 + (read_bus(pc++) << 8); \ + CYCLES(4); \ +} + +#define READ_ABSOLUTE_X(EA) \ +{ \ + tmp1 = read_bus(pc++) + register_x; \ + (EA) = tmp1 + (read_bus(pc++) << 8); \ + CYCLES(tmp1 > 0xff ? 5 : 4); \ +} + +#define READ_ABSOLUTE_Y(EA) \ +{ \ + tmp1 = read_bus(pc++) + register_y; \ + (EA) = tmp1 + (read_bus(pc++) << 8); \ + CYCLES(tmp1 > 0xff ? 5 : 4); \ +} + +#define READ_INDIRECT_X(EA) \ +{ \ + tmp1 = read_bus(pc++) + register_x; \ + (EA) = read_page(tmp1) + (read_page((tmp1 + 1) & 0xff) << 8); \ + CYCLES(6); \ +} + +#define READ_INDIRECT_Y(EA) \ +{ \ + tmp1 = read_bus(pc++); \ + tmp2 = read_page(tmp1++) + register_y; \ + (EA) = tmp2 + ((read_page(tmp1 & 0xff)) << 8); \ + CYCLES(tmp2 > 0xff ? 6 : 5); \ +} + +#define WRITE_ZERO_PAGE(EA) READ_ZERO_PAGE(EA) +#define WRITE_ZERO_PAGE_X(EA) READ_ZERO_PAGE_X(EA) +#define WRITE_ZERO_PAGE_Y(EA) READ_ZERO_PAGE_Y(EA) +#define WRITE_ABSOLUTE(EA) READ_ABSOLUTE(EA) + +#define WRITE_ABSOLUTE_X(EA) \ +{ \ + tmp1 = read_bus(pc++) + register_x; \ + (EA) = tmp1 + (read_bus(pc++) << 8); \ + CYCLES(5); \ +} + +#define WRITE_ABSOLUTE_Y(EA) \ +{ \ + tmp1 = read_bus(pc++) + register_y; \ + (EA) = tmp1 + (read_bus(pc++) << 8); \ + CYCLES(5); \ +} + +#define WRITE_INDIRECT_X(EA) READ_INDIRECT_X(EA) + +#define WRITE_INDIRECT_Y(EA) \ +{ \ + tmp1 = read_bus(pc++); \ + tmp2 = read_page(tmp1++) + register_y; \ + (EA) = tmp2 + (read_page(tmp1 & 0xff) << 8); \ + CYCLES(6); \ +} + +#define RELATIVE(S) \ +{ \ + tmp1 = read_bus(pc++); \ + if((S) != 0) \ + { \ + if((tmp1 & 0x0080) != 0) tmp1 -= 0x100; \ + CYCLES((((pc ^ (pc + tmp1)) & 0xff00) != 0) ? 4 : 3); \ + pc += tmp1; \ + } \ + else \ + { \ + CYCLES(2); \ + } \ +} + +BEGIN(jam) + --pc; + if(jam_handler != 0) + jam_handler(pc, read_bus(pc)); + CYCLES(1); +END + +BEGIN(nmi) + --pc; + PUSH(pc >> 8); + PUSH(pc); + PUSH(get_sr() & ~FLAG_B); + pc = read_bus(NMI_VECTOR) | (read_bus(NMI_VECTOR + 1) << 8); + CYCLES(7); +END + +BEGIN(rst) + PUSH(get_sr() & ~FLAG_B); + pc = read_bus(RST_VECTOR) | (read_bus(RST_VECTOR + 1) << 8); + CYCLES(5); +END + +BEGIN(irq) + if(TEST_I()) return; + --pc; + PUSH(pc >> 8); + PUSH(pc); + PUSH(get_sr() & ~FLAG_B); + SET_I(); + pc = read_bus(IRQ_VECTOR) | (read_bus(IRQ_VECTOR + 1) << 8); + CYCLES(7); +END + +BEGIN(brk_imm) + if(trap() != 0) + { + pc++; + PUSH(get_sr()); + PUSH(pc >> 8); + PUSH(pc); + SET_I(); + pc = read_bus(IRQ_VECTOR) | (read_bus(IRQ_VECTOR + 1) << 8); + CYCLES(7); + } +END + +BEGIN(nop) CYCLES(2) END + +BEGIN(rti) + set_sr(POP() | FLAG_B); + tmp1 = POP(); + pc = tmp1 | (POP() << 8); + CYCLES(6); +END + +BEGIN(rts) + tmp1 = POP(); + pc = (tmp1 | (POP() << 8)) + 1; +CYCLES(6) END + +BEGIN(jsr_abs) + tmp1 = read_bus(pc++); + PUSH(pc >> 8); + PUSH(pc); + pc = tmp1 | (read_bus(pc++) << 8); + CYCLES(6); +END + +BEGIN(jmp_abs) JMP_ABSOLUTE(pc) END +BEGIN(jmp_ind) JMP_INDIRECT(pc) END + +BEGIN(php) PUSH(get_sr()) CYCLES(3) END +BEGIN(plp) set_sr(POP() | FLAG_B); CYCLES(4) END +BEGIN(pha) PUSH(accumulator) CYCLES(3) END +BEGIN(pla) nz = accumulator = POP(); CYCLES(4) END + +BEGIN(tax) nz = register_x = accumulator; CYCLES(2) END +BEGIN(txa) nz = accumulator = register_x; CYCLES(2) END +BEGIN(tay) nz = register_y = accumulator; CYCLES(2) END +BEGIN(tya) nz = accumulator = register_y; CYCLES(2) END +BEGIN(txs) sp = register_x; CYCLES(2) END +BEGIN(tsx) nz = register_x = sp; CYCLES(2) END + +BEGIN(inx) nz = register_x = (register_x + 1) & 0xff; CYCLES(2) END +BEGIN(dex) nz = register_x = (register_x - 1) & 0xff; CYCLES(2) END +BEGIN(iny) nz = register_y = (register_y + 1) & 0xff; CYCLES(2) END +BEGIN(dey) nz = register_y = (register_y - 1) & 0xff; CYCLES(2) END + +BEGIN(clc) CLEAR_C() CYCLES(2) END +BEGIN(sec) SET_C() CYCLES(2) END +BEGIN(cli) CLEAR_I() CYCLES(2) END +BEGIN(sei) SET_I() CYCLES(2) END +BEGIN(clv) CLEAR_V() CYCLES(2) END +BEGIN(cld) CLEAR_D() CYCLES(2) END +BEGIN(sed) SET_D() CYCLES(2) END + +BEGIN(bpl) RELATIVE(!TEST_N()) END +BEGIN(bmi) RELATIVE(TEST_N()) END +BEGIN(bvc) RELATIVE(!TEST_V()) END +BEGIN(bvs) RELATIVE(TEST_V()) END +BEGIN(bcc) RELATIVE(!TEST_C()) END +BEGIN(bcs) RELATIVE(TEST_C()) END +BEGIN(bne) RELATIVE(!TEST_Z()) END +BEGIN(beq) RELATIVE(TEST_Z()) END + +BEGIN(lda_imm) READ_IMMEDIATE(ea) nz = accumulator = read_bus(ea); END +BEGIN(lda_zp) READ_ZERO_PAGE(ea) nz = accumulator = read_page(ea); END +BEGIN(lda_zp_x) READ_ZERO_PAGE_X(ea) nz = accumulator = read_page(ea); END +BEGIN(lda_abs) READ_ABSOLUTE(ea) nz = accumulator = read_bus(ea); END +BEGIN(lda_abs_x) READ_ABSOLUTE_X(ea) nz = accumulator = read_bus(ea); END +BEGIN(lda_abs_y) READ_ABSOLUTE_Y(ea) nz = accumulator = read_bus(ea); END +BEGIN(lda_ind_x) READ_INDIRECT_X(ea) nz = accumulator = read_bus(ea); END +BEGIN(lda_ind_y) READ_INDIRECT_Y(ea) nz = accumulator = read_bus(ea); END + +BEGIN(ldx_imm) READ_IMMEDIATE(ea) nz = register_x = read_bus(ea); END +BEGIN(ldx_zp) READ_ZERO_PAGE(ea) nz = register_x = read_page(ea); END +BEGIN(ldx_zp_y) READ_ZERO_PAGE_Y(ea) nz = register_x = read_page(ea); END +BEGIN(ldx_abs) READ_ABSOLUTE(ea) nz = register_x = read_bus(ea); END +BEGIN(ldx_abs_y) READ_ABSOLUTE_Y(ea) nz = register_x = read_bus(ea); END + +BEGIN(ldy_imm) READ_IMMEDIATE(ea) nz = register_y = read_bus(ea); END +BEGIN(ldy_zp) READ_ZERO_PAGE(ea) nz = register_y = read_page(ea); END +BEGIN(ldy_zp_x) READ_ZERO_PAGE_X(ea) nz = register_y = read_page(ea); END +BEGIN(ldy_abs) READ_ABSOLUTE(ea) nz = register_y = read_bus(ea); END +BEGIN(ldy_abs_x) READ_ABSOLUTE_X(ea) nz = register_y = read_bus(ea); END + +BEGIN(sta_zp) WRITE_ZERO_PAGE(ea) write_page(ea, accumulator); END +BEGIN(sta_zp_x) WRITE_ZERO_PAGE_X(ea) write_page(ea, accumulator); END +BEGIN(sta_abs) WRITE_ABSOLUTE(ea) write_bus(ea, accumulator); END +BEGIN(sta_abs_x) WRITE_ABSOLUTE_X(ea) write_bus(ea, accumulator); END +BEGIN(sta_abs_y) WRITE_ABSOLUTE_Y(ea) write_bus(ea, accumulator); END +BEGIN(sta_ind_x) WRITE_INDIRECT_X(ea) write_bus(ea, accumulator); END +BEGIN(sta_ind_y) WRITE_INDIRECT_Y(ea) write_bus(ea, accumulator); END + +BEGIN(stx_zp) WRITE_ZERO_PAGE(ea) write_page(ea, register_x); END +BEGIN(stx_zp_y) WRITE_ZERO_PAGE_Y(ea) write_page(ea, register_x); END +BEGIN(stx_abs) WRITE_ABSOLUTE(ea) write_bus(ea, register_x); END + +BEGIN(sty_zp) WRITE_ZERO_PAGE(ea) write_page(ea, register_y); END +BEGIN(sty_zp_x) WRITE_ZERO_PAGE_X(ea) write_page(ea, register_y); END +BEGIN(sty_abs) WRITE_ABSOLUTE(ea) write_bus(ea, register_y); END + +#define COMPARE(A, B) \ +{ \ + nz = ((A) & 0xff) - ((B) & 0xff); \ + c = ~nz; \ + nz &= 0xff;\ +} + +BEGIN(cmp_imm) READ_IMMEDIATE(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_zp) READ_ZERO_PAGE(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_zp_x) READ_ZERO_PAGE_X(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_abs) READ_ABSOLUTE(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_abs_x) READ_ABSOLUTE_X(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_abs_y) READ_ABSOLUTE_Y(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_ind_x) READ_INDIRECT_X(ea) COMPARE(accumulator, read_bus(ea)) END +BEGIN(cmp_ind_y) READ_INDIRECT_Y(ea) COMPARE(accumulator, read_bus(ea)) END + +BEGIN(cpx_imm) READ_IMMEDIATE(ea) COMPARE(register_x, read_bus(ea)) END +BEGIN(cpx_zp) READ_ZERO_PAGE(ea) COMPARE(register_x, read_bus(ea)) END +BEGIN(cpx_abs) READ_ABSOLUTE(ea) COMPARE(register_x, read_bus(ea)) END + +BEGIN(cpy_imm) READ_IMMEDIATE(ea) COMPARE(register_y, read_bus(ea)) END +BEGIN(cpy_zp) READ_ZERO_PAGE(ea) COMPARE(register_y, read_bus(ea)) END +BEGIN(cpy_abs) READ_ABSOLUTE(ea) COMPARE(register_y, read_bus(ea)) END + +#define ORA(A, B) \ +{ \ + (A) |= (B); \ + nz = (A) & 0xff; \ +} + +BEGIN(ora_imm) READ_IMMEDIATE(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_zp) READ_ZERO_PAGE(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_zp_x) READ_ZERO_PAGE_X(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_abs) READ_ABSOLUTE(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_abs_x) READ_ABSOLUTE_X(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_abs_y) READ_ABSOLUTE_Y(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_ind_x) READ_INDIRECT_X(ea) ORA(accumulator, read_bus(ea)) END +BEGIN(ora_ind_y) READ_INDIRECT_Y(ea) ORA(accumulator, read_bus(ea)) END + +#define EOR(A, B) \ +{ \ + (A) ^= (B); \ + nz = (A) & 0xff; \ +} + +BEGIN(eor_imm) READ_IMMEDIATE(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_zp) READ_ZERO_PAGE(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_zp_x) READ_ZERO_PAGE_X(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_abs) READ_ABSOLUTE(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_abs_x) READ_ABSOLUTE_X(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_abs_y) READ_ABSOLUTE_Y(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_ind_x) READ_INDIRECT_X(ea) EOR(accumulator, read_bus(ea)) END +BEGIN(eor_ind_y) READ_INDIRECT_Y(ea) EOR(accumulator, read_bus(ea)) END + +#define AND(A, B) \ +{ \ + (A) &= (B); \ + nz = (A) & 0xff; \ +} + +BEGIN(and_imm) READ_IMMEDIATE(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_zp) READ_ZERO_PAGE(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_zp_x) READ_ZERO_PAGE_X(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_abs) READ_ABSOLUTE(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_abs_x) READ_ABSOLUTE_X(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_abs_y) READ_ABSOLUTE_Y(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_ind_x) READ_INDIRECT_X(ea) AND(accumulator, read_bus(ea)) END +BEGIN(and_ind_y) READ_INDIRECT_Y(ea) AND(accumulator, read_bus(ea)) END + +#define ADC(B)\ +{\ + tmp2 = (B) & 0xff;\ + c = nz = tmp1 = (accumulator & 0xff) + tmp2 + ((c & 0x100) >> 8);\ + sr = ((~(accumulator ^ tmp2)) & (accumulator ^ tmp1) & 0x80) ? sr | FLAG_V : sr & ~FLAG_V; \ + accumulator = tmp1;\ + nz &= 0xff;\ +} + +BEGIN(adc_imm) READ_IMMEDIATE(ea) ADC(read_bus(ea)) END +BEGIN(adc_zp) READ_ZERO_PAGE(ea) ADC(read_bus(ea)) END +BEGIN(adc_zp_x) READ_ZERO_PAGE_X(ea) ADC(read_bus(ea)) END +BEGIN(adc_abs) READ_ABSOLUTE(ea) ADC(read_bus(ea)) END +BEGIN(adc_abs_x) READ_ABSOLUTE_X(ea) ADC(read_bus(ea)) END +BEGIN(adc_abs_y) READ_ABSOLUTE_Y(ea) ADC(read_bus(ea)) END +BEGIN(adc_ind_x) READ_INDIRECT_X(ea) ADC(read_bus(ea)) END +BEGIN(adc_ind_y) READ_INDIRECT_Y(ea) ADC(read_bus(ea)) END + +#define SBC(B)\ +{\ + tmp2 = (B) & 0xff;\ + c = nz = tmp1 = (accumulator & 0xff) - tmp2 - (((~c) & 0x100) >> 8);\ + c = ~c;\ + sr = ((accumulator ^ (B)) & (accumulator ^ tmp1) & 0x80) ? sr | FLAG_V : sr & ~FLAG_V; \ + accumulator = tmp1;\ + nz &= 0xff;\ +} + +BEGIN(sbc_imm) READ_IMMEDIATE(ea) SBC(read_bus(ea)) END +BEGIN(sbc_zp) READ_ZERO_PAGE(ea) SBC(read_bus(ea)) END +BEGIN(sbc_zp_x) READ_ZERO_PAGE_X(ea) SBC(read_bus(ea)) END +BEGIN(sbc_abs) READ_ABSOLUTE(ea) SBC(read_bus(ea)) END +BEGIN(sbc_abs_x) READ_ABSOLUTE_X(ea) SBC(read_bus(ea)) END +BEGIN(sbc_abs_y) READ_ABSOLUTE_Y(ea) SBC(read_bus(ea)) END +BEGIN(sbc_ind_x) READ_INDIRECT_X(ea) SBC(read_bus(ea)) END +BEGIN(sbc_ind_y) READ_INDIRECT_Y(ea) SBC(read_bus(ea)) END + +#define BIT(B) \ +{ \ + tmp2 = (B);\ + sr = get_sr();\ + sr = (tmp2 & 0x40) != 0 ? sr | FLAG_V : sr & ~FLAG_V; \ + sr = (tmp2 & 0x80) != 0 ? sr | FLAG_N : sr & ~FLAG_N; \ + sr = ((accumulator & 0xff) & tmp2) == 0 ? sr | FLAG_Z : sr & ~FLAG_Z; \ + set_sr(sr);\ +} + +BEGIN(bit_zp) READ_ZERO_PAGE(ea) BIT(read_page(ea)) END +BEGIN(bit_abs) READ_ABSOLUTE(ea) BIT(read_page(ea)) END + +BEGIN(inc_zp) READ_ZERO_PAGE(ea) nz = (read_page(ea) + 1) & 0xff; write_page(ea, nz); END +BEGIN(inc_zp_x) READ_ZERO_PAGE_X(ea) nz = (read_page(ea) + 1) & 0xff; write_page(ea, nz); END +BEGIN(inc_abs) READ_ABSOLUTE(ea) nz = (read_bus(ea) + 1) & 0xff; write_bus(ea, nz); END +BEGIN(inc_abs_x) READ_ABSOLUTE_X(ea) nz = (read_bus(ea) + 1) & 0xff; write_bus(ea, nz); END + +BEGIN(dec_zp) READ_ZERO_PAGE(ea) nz = (read_page(ea) - 1) & 0xff; write_page(ea, nz); END +BEGIN(dec_zp_x) READ_ZERO_PAGE_X(ea) nz = (read_page(ea) - 1) & 0xff; write_page(ea, nz); END +BEGIN(dec_abs) READ_ABSOLUTE(ea) nz = (read_bus(ea) - 1) & 0xff; write_bus(ea, nz); END +BEGIN(dec_abs_x) READ_ABSOLUTE_X(ea) nz = (read_bus(ea) - 1) & 0xff; write_bus(ea, nz); END + +#define ASL(A) \ +{\ + (A) = nz = c = (((A) & 0xff) << 1);\ + nz &= 0xff;\ +} + +BEGIN(asl_a) ASL(accumulator) CYCLES(2) END +BEGIN(asl_zp) READ_ZERO_PAGE(ea) tmp1 = read_page(ea); ASL(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(asl_zp_x) READ_ZERO_PAGE_X(ea) tmp1 = read_page(ea); ASL(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(asl_abs) READ_ABSOLUTE(ea) tmp1 = read_bus(ea); ASL(tmp1) write_bus(ea, tmp1); CYCLES(2) END +BEGIN(asl_abs_x) READ_ABSOLUTE_X(ea) tmp1 = read_bus(ea); ASL(tmp1) write_bus(ea, tmp1); CYCLES(2) END + +#define LSR(A)\ +{\ + nz = ((A) & 0xff);\ + c = nz << 8;\ + nz = (A) = nz >> 1;\ +} + +BEGIN(lsr_a) LSR(accumulator) CYCLES(2) END +BEGIN(lsr_zp) READ_ZERO_PAGE(ea) tmp1 = read_page(ea); LSR(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(lsr_zp_x) READ_ZERO_PAGE_X(ea) tmp1 = read_page(ea); LSR(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(lsr_abs) READ_ABSOLUTE(ea) tmp1 = read_bus(ea); LSR(tmp1) write_bus(ea, tmp1); CYCLES(2) END +BEGIN(lsr_abs_x) READ_ABSOLUTE_X(ea) tmp1 = read_bus(ea); LSR(tmp1) write_bus(ea, tmp1); CYCLES(2) END + +#define ROL(A) \ +{\ + (A) = nz = c = (((A) & 0xff) << 1) | ((c & 0x100) >> 8);\ + nz &= 0xff;\ +} + +BEGIN(rol_a) ROL(accumulator) CYCLES(2) END +BEGIN(rol_zp) READ_ZERO_PAGE(ea) tmp1 = read_page(ea); ROL(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(rol_zp_x) READ_ZERO_PAGE_X(ea) tmp1 = read_page(ea); ROL(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(rol_abs) READ_ABSOLUTE(ea) tmp1 = read_bus(ea); ROL(tmp1) write_bus(ea, tmp1); CYCLES(2) END +BEGIN(rol_abs_x) READ_ABSOLUTE_X(ea) tmp1 = read_bus(ea); ROL(tmp1) write_bus(ea, tmp1); CYCLES(2) END + +#define ROR(A)\ +{\ + nz = ((A) & 0xff) | (c & 0x100);\ + c = nz << 8; \ + nz = (A) = nz >> 1;\ +} + +BEGIN(ror_a) ROR(accumulator) CYCLES(2) END +BEGIN(ror_zp) READ_ZERO_PAGE(ea) tmp1 = read_page(ea); ROR(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(ror_zp_x) READ_ZERO_PAGE_X(ea) tmp1 = read_page(ea); ROR(tmp1) write_page(ea, tmp1); CYCLES(2) END +BEGIN(ror_abs) READ_ABSOLUTE(ea) tmp1 = read_bus(ea); ROR(tmp1) write_bus(ea, tmp1); CYCLES(2) END +BEGIN(ror_abs_x) READ_ABSOLUTE_X(ea) tmp1 = read_bus(ea); ROR(tmp1) write_bus(ea, tmp1); CYCLES(2) END + + diff --git a/c64/cpu.h b/c64/cpu.h new file mode 100644 index 0000000..4db4591 --- /dev/null +++ b/c64/cpu.h @@ -0,0 +1,38 @@ +// cpu.h +// +// 20050125 Markku Alén + +#ifndef __CPU_H__ +#define __CPU_H__ 1 + +extern unsigned int cycles; + +void init_cpu(int (*cpu_read)(int), void (*cpu_write)(int, int), int (*cpu_read_page)(int), void (*cpu_write_page)(int, int), void (*cpu_jam)(int, int)); + +extern void (*reset_cpu)(void); +extern void (*raise_nmi)(void); +extern void (*raise_irq)(void); +extern void (*exec_cpu)(void); + +void set_c_flag(int enable); +void set_z_flag(int enable); +void set_pc(int addr); + +int get_pc(void); +int get_a(void); +int get_x(void); +int get_y(void); + +typedef struct __trap +{ + struct __trap *next_trap; + int addr; + int org[3]; + int (*handler)(void); +}trap_t; + +#define TRAP_INIT(ADDR, D1, D2, D3, HANDLER) { 0, ADDR, D1, D2, D3, HANDLER } + +void install_traps(int cnt, trap_t *tbl, void (*poke)(int, int), int (*peek)(int)); + +#endif diff --git a/c64/kbd.c b/c64/kbd.c new file mode 100644 index 0000000..827d808 --- /dev/null +++ b/c64/kbd.c @@ -0,0 +1,248 @@ +// kbd.c +// +// 20060803 Markku Alén + +#include "kbd.h" + +static int row_tbl[256]; +static int col_tbl[256]; + +static int matrix[8]; + +static void init_key(int key, int row, int col) +{ + row_tbl[key % sizeof(row_tbl)] = row; + col_tbl[key % sizeof(col_tbl)] = col; +} + +void kbd_init(void) +{ + int i; + for(i = sizeof(matrix) / sizeof(matrix[0]);i-- > 0;) + matrix[i] = 0; + for(i = sizeof(row_tbl) / sizeof(row_tbl[0]);i-- > 0;) + row_tbl[i] = 0; + for(i = sizeof(col_tbl) / sizeof(col_tbl[0]);i-- > 0;) + col_tbl[i] = 0; + init_key(KEY_COMMODORE, 7, 5); + init_key(KEY_INST_DEL, 0, 0); + init_key(KEY_LEFT_SHIFT, 1, 7); + init_key(KEY_RIGHT_SHIFT, 6, 4); + init_key(KEY_VER_CURSOR, 0, 7); + init_key(KEY_HOR_CURSOR, 0, 2); + init_key(KEY_F1, 0, 4); + init_key(KEY_F3, 0, 5); + init_key(KEY_F5, 0, 6); + init_key(KEY_F7, 0, 3); + init_key(KEY_CTRL, 7, 2); + init_key(KEY_CLR_HOME, 6, 3); + init_key(KEY_RUN_STOP, 7, 7); + init_key(KEY_RETURN, 0, 1); + init_key(KEY_SPACE, 7, 4); + init_key(KEY_ARROW_LEFT, 7, 1); + init_key(KEY_ARROW_UP, 6, 6); + init_key(KEY_PLUS, 5, 0); + init_key(KEY_MINUS, 5, 3); + init_key(KEY_MULTIPLY, 6, 1); + init_key(KEY_DIVIDE, 6, 7); + init_key(KEY_COLON, 5, 5); + init_key(KEY_SEMICOLON, 6, 2); + init_key(KEY_EQUAL, 6, 5); + init_key(KEY_COMMA, 5, 7); + init_key(KEY_DOT, 5, 4); + init_key(KEY_POUND, 6, 0); + init_key(KEY_AT, 5, 6); + init_key(KEY_NUMBER_0, 4, 3); + init_key(KEY_NUMBER_1, 7, 0); + init_key(KEY_NUMBER_2, 7, 3); + init_key(KEY_NUMBER_3, 1, 0); + init_key(KEY_NUMBER_4, 1, 3); + init_key(KEY_NUMBER_5, 2, 0); + init_key(KEY_NUMBER_6, 2, 3); + init_key(KEY_NUMBER_7, 3, 0); + init_key(KEY_NUMBER_8, 3, 3); + init_key(KEY_NUMBER_9, 4, 0); + init_key(KEY_LETTER_A, 1, 2); + init_key(KEY_LETTER_B, 3, 4); + init_key(KEY_LETTER_C, 2, 4); + init_key(KEY_LETTER_D, 2, 2); + init_key(KEY_LETTER_E, 1, 6); + init_key(KEY_LETTER_F, 2, 5); + init_key(KEY_LETTER_G, 3, 2); + init_key(KEY_LETTER_H, 3, 5); + init_key(KEY_LETTER_I, 4, 1); + init_key(KEY_LETTER_J, 4, 2); + init_key(KEY_LETTER_K, 4, 5); + init_key(KEY_LETTER_L, 5, 2); + init_key(KEY_LETTER_M, 4, 4); + init_key(KEY_LETTER_N, 4, 7); + init_key(KEY_LETTER_O, 4, 6); + init_key(KEY_LETTER_P, 5, 1); + init_key(KEY_LETTER_Q, 7, 6); + init_key(KEY_LETTER_R, 2, 1); + init_key(KEY_LETTER_S, 1, 5); + init_key(KEY_LETTER_T, 2, 6); + init_key(KEY_LETTER_U, 3, 6); + init_key(KEY_LETTER_V, 3, 7); + init_key(KEY_LETTER_W, 1, 1); + init_key(KEY_LETTER_X, 2, 7); + init_key(KEY_LETTER_Y, 3, 1); + init_key(KEY_LETTER_Z, 1, 4); +} + +void kbd_down(int key) +{ + int row, col; + row = row_tbl[key]; + col = col_tbl[key]; + matrix[row] |= (1 << col); +} + +void kbd_up(int key) +{ + int row, col; + row = row_tbl[key]; + col = col_tbl[key]; + matrix[row] &= ~(1 << col); +} + +void kbd_push(int key, int down) +{ + (void)(down ? kbd_down(key) : kbd_up(key)); +} + +void kbd_ascii_push(int c, int down) +{ + int i, j, key; + static const struct __ascii_key + { + int c; + int key[2]; + }ascii_key_tbl[] = + { + {'\x09', KEY_CTRL}, + {'\x07', KEY_INST_DEL}, + {'\x08', KEY_CLR_HOME}, + {'\x1b', KEY_RUN_STOP}, + {'\x0d', KEY_RETURN}, + {' ', KEY_SPACE}, + {'!', KEY_LEFT_SHIFT, KEY_NUMBER_1}, + {'\"', KEY_LEFT_SHIFT, KEY_NUMBER_2}, + {'#', KEY_POUND}, + {'$', KEY_LEFT_SHIFT, KEY_NUMBER_4}, + {'%', KEY_LEFT_SHIFT, KEY_NUMBER_5}, + {'&', KEY_LEFT_SHIFT, KEY_NUMBER_6}, + {'\'', KEY_LEFT_SHIFT, KEY_NUMBER_7}, + {'(', KEY_LEFT_SHIFT, KEY_NUMBER_8}, + {')', KEY_LEFT_SHIFT, KEY_NUMBER_9}, + {'*', KEY_MULTIPLY}, + {'+', KEY_PLUS}, + {',', KEY_COMMA}, + {'-', KEY_MINUS}, + {'.', KEY_DOT}, + {'/', KEY_DIVIDE}, + {'0', KEY_NUMBER_0}, + {'1', KEY_NUMBER_1}, + {'2', KEY_NUMBER_2}, + {'3', KEY_NUMBER_3}, + {'4', KEY_NUMBER_4}, + {'5', KEY_NUMBER_5}, + {'6', KEY_NUMBER_6}, + {'7', KEY_NUMBER_7}, + {'8', KEY_NUMBER_8}, + {'9', KEY_NUMBER_9}, + {':', KEY_COLON}, + {';', KEY_SEMICOLON}, + {'<', KEY_LEFT_SHIFT, KEY_COMMA}, + {'=', KEY_EQUAL}, + {'>', KEY_LEFT_SHIFT, KEY_DOT}, + {'?', KEY_LEFT_SHIFT, KEY_DIVIDE}, + {'@', KEY_AT}, + {'A', KEY_LETTER_A}, + {'B', KEY_LETTER_B}, + {'C', KEY_LETTER_C}, + {'D', KEY_LETTER_D}, + {'E', KEY_LETTER_E}, + {'F', KEY_LETTER_F}, + {'G', KEY_LETTER_G}, + {'H', KEY_LETTER_H}, + {'I', KEY_LETTER_I}, + {'J', KEY_LETTER_J}, + {'K', KEY_LETTER_K}, + {'L', KEY_LETTER_L}, + {'M', KEY_LETTER_M}, + {'N', KEY_LETTER_N}, + {'O', KEY_LETTER_O}, + {'P', KEY_LETTER_P}, + {'Q', KEY_LETTER_Q}, + {'R', KEY_LETTER_R}, + {'S', KEY_LETTER_S}, + {'T', KEY_LETTER_T}, + {'U', KEY_LETTER_U}, + {'V', KEY_LETTER_V}, + {'W', KEY_LETTER_W}, + {'X', KEY_LETTER_X}, + {'Y', KEY_LETTER_Y}, + {'Z', KEY_LETTER_Z}, + {'[', KEY_LEFT_SHIFT, KEY_COLON}, + {']', KEY_LEFT_SHIFT, KEY_SEMICOLON}, + {'^', KEY_ARROW_UP}, + {'a', KEY_LETTER_A}, + {'b', KEY_LETTER_B}, + {'c', KEY_LETTER_C}, + {'d', KEY_LETTER_D}, + {'e', KEY_LETTER_E}, + {'f', KEY_LETTER_F}, + {'g', KEY_LETTER_G}, + {'h', KEY_LETTER_H}, + {'i', KEY_LETTER_I}, + {'j', KEY_LETTER_J}, + {'k', KEY_LETTER_K}, + {'l', KEY_LETTER_L}, + {'m', KEY_LETTER_M}, + {'n', KEY_LETTER_N}, + {'o', KEY_LETTER_O}, + {'p', KEY_LETTER_P}, + {'q', KEY_LETTER_Q}, + {'r', KEY_LETTER_R}, + {'s', KEY_LETTER_S}, + {'t', KEY_LETTER_T}, + {'u', KEY_LETTER_U}, + {'v', KEY_LETTER_V}, + {'w', KEY_LETTER_W}, + {'x', KEY_LETTER_X}, + {'y', KEY_LETTER_Y}, + {'z', KEY_LETTER_Z}, + {'~', KEY_ARROW_LEFT}, + {'\0'}, + }; + for(i = sizeof(ascii_key_tbl) / sizeof(ascii_key_tbl[0]);i-- > 0;) + { + if(ascii_key_tbl[i].c == c) + { + for(j = sizeof(ascii_key_tbl[0].key) / sizeof(ascii_key_tbl[0].key[0]);j-- > 0;) + { + key = ascii_key_tbl[i].key[j]; + if(key != 0) + { + kbd_push(key, down); + } + } + } + } +} + +int kbd_data(int row_data) +{ + int i; + int col_data; + col_data = 0xff; + for(i = 8;i-- > 0;) + { + if((row_data & (1 << i)) == 0) + { + col_data &= ~matrix[i]; + } + } + return col_data; +} diff --git a/c64/kbd.h b/c64/kbd.h new file mode 100644 index 0000000..13df996 --- /dev/null +++ b/c64/kbd.h @@ -0,0 +1,90 @@ +// kbd.h +// +// 20060803 Markku Alén + +#ifndef __KBD_H__ +#define __KBD_H__ 1 + +#define KEY_COMMODORE 1 + +#define KEY_LEFT_SHIFT 3 +#define KEY_RIGHT_SHIFT 4 +#define KEY_VER_CURSOR 5 +#define KEY_HOR_CURSOR 6 + +#define KEY_F1 28 +#define KEY_F3 29 +#define KEY_F5 30 +#define KEY_F7 31 + +#define KEY_CTRL '\x09' +#define KEY_INST_DEL '\x07' +#define KEY_CLR_HOME '\x08' +#define KEY_RUN_STOP '\x1b' +#define KEY_RETURN '\x0d' +#define KEY_SPACE ' ' + +#define KEY_ARROW_LEFT '~' +#define KEY_ARROW_UP '^' +#define KEY_PLUS '+' +#define KEY_MINUS '-' +#define KEY_MULTIPLY '*' +#define KEY_DIVIDE '/' +#define KEY_COLON ':' +#define KEY_SEMICOLON ';' +#define KEY_EQUAL '=' +#define KEY_COMMA ',' +#define KEY_DOT '.' + +#define KEY_POUND '#' +#define KEY_AT '@' + +#define KEY_NUMBER_0 '0' +#define KEY_NUMBER_1 '1' +#define KEY_NUMBER_2 '2' +#define KEY_NUMBER_3 '3' +#define KEY_NUMBER_4 '4' +#define KEY_NUMBER_5 '5' +#define KEY_NUMBER_6 '6' +#define KEY_NUMBER_7 '7' +#define KEY_NUMBER_8 '8' +#define KEY_NUMBER_9 '9' + +#define KEY_LETTER_A 'A' +#define KEY_LETTER_B 'B' +#define KEY_LETTER_C 'C' +#define KEY_LETTER_D 'D' +#define KEY_LETTER_E 'E' +#define KEY_LETTER_F 'F' +#define KEY_LETTER_G 'G' +#define KEY_LETTER_H 'H' +#define KEY_LETTER_I 'I' +#define KEY_LETTER_J 'J' +#define KEY_LETTER_K 'K' +#define KEY_LETTER_L 'L' +#define KEY_LETTER_M 'M' +#define KEY_LETTER_N 'N' +#define KEY_LETTER_O 'O' +#define KEY_LETTER_P 'P' +#define KEY_LETTER_Q 'Q' +#define KEY_LETTER_R 'R' +#define KEY_LETTER_S 'S' +#define KEY_LETTER_T 'T' +#define KEY_LETTER_U 'U' +#define KEY_LETTER_V 'V' +#define KEY_LETTER_W 'W' +#define KEY_LETTER_X 'X' +#define KEY_LETTER_Y 'Y' +#define KEY_LETTER_Z 'Z' + +void kbd_init(void); + +void kbd_down(int key); +void kbd_up(int key); +void kbd_push(int key, int down); + +void kbd_ascii_push(int c, int down); + +int kbd_data(int row_data); + +#endif diff --git a/c64/mem.c b/c64/mem.c new file mode 100644 index 0000000..f46c8e0 --- /dev/null +++ b/c64/mem.c @@ -0,0 +1,1314 @@ +// mem.c +// +// 20060803 Markku Alén + +#include "mem.h" + +unsigned char color[1024]; + +unsigned char ram[65536]; + +unsigned char chars[4096] = +{ + 0x3c, 0x66, 0x6e, 0x6e, 0x60, 0x62, 0x3c, 0x00, 0x18, 0x3c, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3c, 0x00, + 0x78, 0x6c, 0x66, 0x66, 0x66, 0x6c, 0x78, 0x00, 0x7e, 0x60, 0x60, 0x78, 0x60, 0x60, 0x7e, 0x00, + 0x7e, 0x60, 0x60, 0x78, 0x60, 0x60, 0x60, 0x00, 0x3c, 0x66, 0x60, 0x6e, 0x66, 0x66, 0x3c, 0x00, + 0x66, 0x66, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, + 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x6c, 0x38, 0x00, 0x66, 0x6c, 0x78, 0x70, 0x78, 0x6c, 0x66, 0x00, + 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7e, 0x00, 0x63, 0x77, 0x7f, 0x6b, 0x63, 0x63, 0x63, 0x00, + 0x66, 0x76, 0x7e, 0x7e, 0x6e, 0x66, 0x66, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x0e, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x78, 0x6c, 0x66, 0x00, 0x3c, 0x66, 0x60, 0x3c, 0x06, 0x66, 0x3c, 0x00, + 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x63, 0x63, 0x63, 0x6b, 0x7f, 0x77, 0x63, 0x00, + 0x66, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0x66, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00, + 0x7e, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x7e, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00, + 0x0c, 0x12, 0x30, 0x7c, 0x30, 0x62, 0xfc, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00, + 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00, 0x10, 0x30, 0x7f, 0x7f, 0x30, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00, + 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0xff, 0x66, 0x66, 0x00, + 0x18, 0x3e, 0x60, 0x3c, 0x06, 0x7c, 0x18, 0x00, 0x62, 0x66, 0x0c, 0x18, 0x30, 0x66, 0x46, 0x00, + 0x3c, 0x66, 0x3c, 0x38, 0x67, 0x66, 0x3f, 0x00, 0x06, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x18, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, + 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, + 0x3c, 0x66, 0x6e, 0x76, 0x66, 0x66, 0x3c, 0x00, 0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00, + 0x3c, 0x66, 0x06, 0x0c, 0x30, 0x60, 0x7e, 0x00, 0x3c, 0x66, 0x06, 0x1c, 0x06, 0x66, 0x3c, 0x00, + 0x06, 0x0e, 0x1e, 0x66, 0x7f, 0x06, 0x06, 0x00, 0x7e, 0x60, 0x7c, 0x06, 0x06, 0x66, 0x3c, 0x00, + 0x3c, 0x66, 0x60, 0x7c, 0x66, 0x66, 0x3c, 0x00, 0x7e, 0x66, 0x0c, 0x18, 0x18, 0x18, 0x18, 0x00, + 0x3c, 0x66, 0x66, 0x3c, 0x66, 0x66, 0x3c, 0x00, 0x3c, 0x66, 0x66, 0x3e, 0x06, 0x66, 0x3c, 0x00, + 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, + 0x0e, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x7e, 0x00, 0x00, 0x00, + 0x70, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x70, 0x00, 0x3c, 0x66, 0x06, 0x0c, 0x18, 0x00, 0x18, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x08, 0x1c, 0x3e, 0x7f, 0x7f, 0x1c, 0x3e, 0x00, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0xe0, 0xf0, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x1c, 0x0f, 0x07, 0x00, 0x00, 0x00, 0x18, 0x18, 0x38, 0xf0, 0xe0, 0x00, 0x00, 0x00, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xff, 0xff, 0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x03, + 0x03, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xc0, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0x3c, 0x7e, 0x7e, 0x7e, 0x7e, 0x3c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x36, 0x7f, 0x7f, 0x7f, 0x3e, 0x1c, 0x08, 0x00, + 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x07, 0x0f, 0x1c, 0x18, 0x18, + 0xc3, 0xe7, 0x7e, 0x3c, 0x3c, 0x7e, 0xe7, 0xc3, 0x00, 0x3c, 0x7e, 0x66, 0x66, 0x7e, 0x3c, 0x00, + 0x18, 0x18, 0x66, 0x66, 0x18, 0x18, 0x3c, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x08, 0x1c, 0x3e, 0x7f, 0x3e, 0x1c, 0x08, 0x00, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, + 0xc0, 0xc0, 0x30, 0x30, 0xc0, 0xc0, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x03, 0x3e, 0x76, 0x36, 0x36, 0x00, 0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0x33, 0x33, 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, + 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x00, 0x00, 0x00, + 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, + 0xc3, 0x99, 0x91, 0x91, 0x9f, 0x99, 0xc3, 0xff, 0xe7, 0xc3, 0x99, 0x81, 0x99, 0x99, 0x99, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x99, 0x99, 0x83, 0xff, 0xc3, 0x99, 0x9f, 0x9f, 0x9f, 0x99, 0xc3, 0xff, + 0x87, 0x93, 0x99, 0x99, 0x99, 0x93, 0x87, 0xff, 0x81, 0x9f, 0x9f, 0x87, 0x9f, 0x9f, 0x81, 0xff, + 0x81, 0x9f, 0x9f, 0x87, 0x9f, 0x9f, 0x9f, 0xff, 0xc3, 0x99, 0x9f, 0x91, 0x99, 0x99, 0xc3, 0xff, + 0x99, 0x99, 0x99, 0x81, 0x99, 0x99, 0x99, 0xff, 0xc3, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xc3, 0xff, + 0xe1, 0xf3, 0xf3, 0xf3, 0xf3, 0x93, 0xc7, 0xff, 0x99, 0x93, 0x87, 0x8f, 0x87, 0x93, 0x99, 0xff, + 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x81, 0xff, 0x9c, 0x88, 0x80, 0x94, 0x9c, 0x9c, 0x9c, 0xff, + 0x99, 0x89, 0x81, 0x81, 0x91, 0x99, 0x99, 0xff, 0xc3, 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x9f, 0x9f, 0x9f, 0xff, 0xc3, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xf1, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x87, 0x93, 0x99, 0xff, 0xc3, 0x99, 0x9f, 0xc3, 0xf9, 0x99, 0xc3, 0xff, + 0x81, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xff, + 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xe7, 0xff, 0x9c, 0x9c, 0x9c, 0x94, 0x80, 0x88, 0x9c, 0xff, + 0x99, 0x99, 0xc3, 0xe7, 0xc3, 0x99, 0x99, 0xff, 0x99, 0x99, 0x99, 0xc3, 0xe7, 0xe7, 0xe7, 0xff, + 0x81, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x81, 0xff, 0xc3, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xc3, 0xff, + 0xf3, 0xed, 0xcf, 0x83, 0xcf, 0x9d, 0x03, 0xff, 0xc3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xc3, 0xff, + 0xff, 0xe7, 0xc3, 0x81, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0xef, 0xcf, 0x80, 0x80, 0xcf, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xe7, 0xff, + 0x99, 0x99, 0x99, 0xff, 0xff, 0xff, 0xff, 0xff, 0x99, 0x99, 0x00, 0x99, 0x00, 0x99, 0x99, 0xff, + 0xe7, 0xc1, 0x9f, 0xc3, 0xf9, 0x83, 0xe7, 0xff, 0x9d, 0x99, 0xf3, 0xe7, 0xcf, 0x99, 0xb9, 0xff, + 0xc3, 0x99, 0xc3, 0xc7, 0x98, 0x99, 0xc0, 0xff, 0xf9, 0xf3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0xe7, 0xcf, 0xcf, 0xcf, 0xe7, 0xf3, 0xff, 0xcf, 0xe7, 0xf3, 0xf3, 0xf3, 0xe7, 0xcf, 0xff, + 0xff, 0x99, 0xc3, 0x00, 0xc3, 0x99, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0x81, 0xe7, 0xe7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xcf, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xff, 0xff, 0xfc, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0xff, + 0xc3, 0x99, 0x91, 0x89, 0x99, 0x99, 0xc3, 0xff, 0xe7, 0xe7, 0xc7, 0xe7, 0xe7, 0xe7, 0x81, 0xff, + 0xc3, 0x99, 0xf9, 0xf3, 0xcf, 0x9f, 0x81, 0xff, 0xc3, 0x99, 0xf9, 0xe3, 0xf9, 0x99, 0xc3, 0xff, + 0xf9, 0xf1, 0xe1, 0x99, 0x80, 0xf9, 0xf9, 0xff, 0x81, 0x9f, 0x83, 0xf9, 0xf9, 0x99, 0xc3, 0xff, + 0xc3, 0x99, 0x9f, 0x83, 0x99, 0x99, 0xc3, 0xff, 0x81, 0x99, 0xf3, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, + 0xc3, 0x99, 0x99, 0xc3, 0x99, 0x99, 0xc3, 0xff, 0xc3, 0x99, 0x99, 0xc1, 0xf9, 0x99, 0xc3, 0xff, + 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xe7, 0xcf, + 0xf1, 0xe7, 0xcf, 0x9f, 0xcf, 0xe7, 0xf1, 0xff, 0xff, 0xff, 0x81, 0xff, 0x81, 0xff, 0xff, 0xff, + 0x8f, 0xe7, 0xf3, 0xf9, 0xf3, 0xe7, 0x8f, 0xff, 0xc3, 0x99, 0xf9, 0xf3, 0xe7, 0xff, 0xe7, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf7, 0xe3, 0xc1, 0x80, 0x80, 0xe3, 0xc1, 0xff, + 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xff, 0xff, 0xff, 0x1f, 0x0f, 0xc7, 0xe7, 0xe7, + 0xe7, 0xe7, 0xe3, 0xf0, 0xf8, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xc7, 0x0f, 0x1f, 0xff, 0xff, 0xff, + 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x00, 0x00, 0x3f, 0x1f, 0x8f, 0xc7, 0xe3, 0xf1, 0xf8, 0xfc, + 0xfc, 0xf8, 0xf1, 0xe3, 0xc7, 0x8f, 0x1f, 0x3f, 0x00, 0x00, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, + 0x00, 0x00, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xff, 0xc3, 0x81, 0x81, 0x81, 0x81, 0xc3, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xc9, 0x80, 0x80, 0x80, 0xc1, 0xe3, 0xf7, 0xff, + 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0xff, 0xff, 0xff, 0xf8, 0xf0, 0xe3, 0xe7, 0xe7, + 0x3c, 0x18, 0x81, 0xc3, 0xc3, 0x81, 0x18, 0x3c, 0xff, 0xc3, 0x81, 0x99, 0x99, 0x81, 0xc3, 0xff, + 0xe7, 0xe7, 0x99, 0x99, 0xe7, 0xe7, 0xc3, 0xff, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf7, 0xe3, 0xc1, 0x80, 0xc1, 0xe3, 0xf7, 0xff, 0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xe7, 0xe7, 0xe7, + 0x3f, 0x3f, 0xcf, 0xcf, 0x3f, 0x3f, 0xcf, 0xcf, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xff, 0xff, 0xfc, 0xc1, 0x89, 0xc9, 0xc9, 0xff, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, + 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0xcc, 0xcc, 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xe7, 0xe7, 0xe7, 0xe0, 0xe0, 0xe7, 0xe7, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xe7, 0xe7, 0xe7, 0xe0, 0xe0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x07, 0x07, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xe0, 0xe0, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0x07, 0x07, 0xe7, 0xe7, 0xe7, + 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, + 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xe7, 0x07, 0x07, 0xff, 0xff, 0xff, + 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, + 0x3c, 0x66, 0x6e, 0x6e, 0x60, 0x62, 0x3c, 0x00, 0x00, 0x00, 0x3c, 0x06, 0x3e, 0x66, 0x3e, 0x00, + 0x00, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x3c, 0x60, 0x60, 0x60, 0x3c, 0x00, + 0x00, 0x06, 0x06, 0x3e, 0x66, 0x66, 0x3e, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x7e, 0x60, 0x3c, 0x00, + 0x00, 0x0e, 0x18, 0x3e, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x3e, 0x66, 0x66, 0x3e, 0x06, 0x7c, + 0x00, 0x60, 0x60, 0x7c, 0x66, 0x66, 0x66, 0x00, 0x00, 0x18, 0x00, 0x38, 0x18, 0x18, 0x3c, 0x00, + 0x00, 0x06, 0x00, 0x06, 0x06, 0x06, 0x06, 0x3c, 0x00, 0x60, 0x60, 0x6c, 0x78, 0x6c, 0x66, 0x00, + 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x66, 0x7f, 0x7f, 0x6b, 0x63, 0x00, + 0x00, 0x00, 0x7c, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x3c, 0x00, + 0x00, 0x00, 0x7c, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x00, 0x00, 0x3e, 0x66, 0x66, 0x3e, 0x06, 0x06, + 0x00, 0x00, 0x7c, 0x66, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x3e, 0x60, 0x3c, 0x06, 0x7c, 0x00, + 0x00, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3e, 0x00, + 0x00, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x63, 0x6b, 0x7f, 0x3e, 0x36, 0x00, + 0x00, 0x00, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x3e, 0x0c, 0x78, + 0x00, 0x00, 0x7e, 0x0c, 0x18, 0x30, 0x7e, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c, 0x00, + 0x0c, 0x12, 0x30, 0x7c, 0x30, 0x62, 0xfc, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 0x00, + 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00, 0x10, 0x30, 0x7f, 0x7f, 0x30, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00, + 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0xff, 0x66, 0x66, 0x00, + 0x18, 0x3e, 0x60, 0x3c, 0x06, 0x7c, 0x18, 0x00, 0x62, 0x66, 0x0c, 0x18, 0x30, 0x66, 0x46, 0x00, + 0x3c, 0x66, 0x3c, 0x38, 0x67, 0x66, 0x3f, 0x00, 0x06, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x18, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, + 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, + 0x3c, 0x66, 0x6e, 0x76, 0x66, 0x66, 0x3c, 0x00, 0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00, + 0x3c, 0x66, 0x06, 0x0c, 0x30, 0x60, 0x7e, 0x00, 0x3c, 0x66, 0x06, 0x1c, 0x06, 0x66, 0x3c, 0x00, + 0x06, 0x0e, 0x1e, 0x66, 0x7f, 0x06, 0x06, 0x00, 0x7e, 0x60, 0x7c, 0x06, 0x06, 0x66, 0x3c, 0x00, + 0x3c, 0x66, 0x60, 0x7c, 0x66, 0x66, 0x3c, 0x00, 0x7e, 0x66, 0x0c, 0x18, 0x18, 0x18, 0x18, 0x00, + 0x3c, 0x66, 0x66, 0x3c, 0x66, 0x66, 0x3c, 0x00, 0x3c, 0x66, 0x66, 0x3e, 0x06, 0x66, 0x3c, 0x00, + 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x18, 0x30, + 0x0e, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x7e, 0x00, 0x00, 0x00, + 0x70, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x70, 0x00, 0x3c, 0x66, 0x06, 0x0c, 0x18, 0x00, 0x18, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x7c, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3c, 0x00, + 0x78, 0x6c, 0x66, 0x66, 0x66, 0x6c, 0x78, 0x00, 0x7e, 0x60, 0x60, 0x78, 0x60, 0x60, 0x7e, 0x00, + 0x7e, 0x60, 0x60, 0x78, 0x60, 0x60, 0x60, 0x00, 0x3c, 0x66, 0x60, 0x6e, 0x66, 0x66, 0x3c, 0x00, + 0x66, 0x66, 0x66, 0x7e, 0x66, 0x66, 0x66, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, + 0x1e, 0x0c, 0x0c, 0x0c, 0x0c, 0x6c, 0x38, 0x00, 0x66, 0x6c, 0x78, 0x70, 0x78, 0x6c, 0x66, 0x00, + 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7e, 0x00, 0x63, 0x77, 0x7f, 0x6b, 0x63, 0x63, 0x63, 0x00, + 0x66, 0x76, 0x7e, 0x7e, 0x6e, 0x66, 0x66, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x0e, 0x00, + 0x7c, 0x66, 0x66, 0x7c, 0x78, 0x6c, 0x66, 0x00, 0x3c, 0x66, 0x60, 0x3c, 0x06, 0x66, 0x3c, 0x00, + 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x00, + 0x66, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x00, 0x63, 0x63, 0x63, 0x6b, 0x7f, 0x77, 0x63, 0x00, + 0x66, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0x66, 0x00, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x00, + 0x7e, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x7e, 0x00, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, + 0xc0, 0xc0, 0x30, 0x30, 0xc0, 0xc0, 0x30, 0x30, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99, 0xcc, 0x66, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, + 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0x99, 0x33, 0x66, 0xcc, 0x99, 0x33, 0x66, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x18, 0x18, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x18, 0x18, 0x18, 0x1f, 0x1f, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x18, 0x18, 0x18, + 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x01, 0x03, 0x06, 0x6c, 0x78, 0x70, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, + 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xf8, 0xf8, 0x00, 0x00, 0x00, + 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, + 0xc3, 0x99, 0x91, 0x91, 0x9f, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xc3, 0xf9, 0xc1, 0x99, 0xc1, 0xff, + 0xff, 0x9f, 0x9f, 0x83, 0x99, 0x99, 0x83, 0xff, 0xff, 0xff, 0xc3, 0x9f, 0x9f, 0x9f, 0xc3, 0xff, + 0xff, 0xf9, 0xf9, 0xc1, 0x99, 0x99, 0xc1, 0xff, 0xff, 0xff, 0xc3, 0x99, 0x81, 0x9f, 0xc3, 0xff, + 0xff, 0xf1, 0xe7, 0xc1, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xff, 0xc1, 0x99, 0x99, 0xc1, 0xf9, 0x83, + 0xff, 0x9f, 0x9f, 0x83, 0x99, 0x99, 0x99, 0xff, 0xff, 0xe7, 0xff, 0xc7, 0xe7, 0xe7, 0xc3, 0xff, + 0xff, 0xf9, 0xff, 0xf9, 0xf9, 0xf9, 0xf9, 0xc3, 0xff, 0x9f, 0x9f, 0x93, 0x87, 0x93, 0x99, 0xff, + 0xff, 0xc7, 0xe7, 0xe7, 0xe7, 0xe7, 0xc3, 0xff, 0xff, 0xff, 0x99, 0x80, 0x80, 0x94, 0x9c, 0xff, + 0xff, 0xff, 0x83, 0x99, 0x99, 0x99, 0x99, 0xff, 0xff, 0xff, 0xc3, 0x99, 0x99, 0x99, 0xc3, 0xff, + 0xff, 0xff, 0x83, 0x99, 0x99, 0x83, 0x9f, 0x9f, 0xff, 0xff, 0xc1, 0x99, 0x99, 0xc1, 0xf9, 0xf9, + 0xff, 0xff, 0x83, 0x99, 0x9f, 0x9f, 0x9f, 0xff, 0xff, 0xff, 0xc1, 0x9f, 0xc3, 0xf9, 0x83, 0xff, + 0xff, 0xe7, 0x81, 0xe7, 0xe7, 0xe7, 0xf1, 0xff, 0xff, 0xff, 0x99, 0x99, 0x99, 0x99, 0xc1, 0xff, + 0xff, 0xff, 0x99, 0x99, 0x99, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0x9c, 0x94, 0x80, 0xc1, 0xc9, 0xff, + 0xff, 0xff, 0x99, 0xc3, 0xe7, 0xc3, 0x99, 0xff, 0xff, 0xff, 0x99, 0x99, 0x99, 0xc1, 0xf3, 0x87, + 0xff, 0xff, 0x81, 0xf3, 0xe7, 0xcf, 0x81, 0xff, 0xc3, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xc3, 0xff, + 0xf3, 0xed, 0xcf, 0x83, 0xcf, 0x9d, 0x03, 0xff, 0xc3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xc3, 0xff, + 0xff, 0xe7, 0xc3, 0x81, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0xef, 0xcf, 0x80, 0x80, 0xcf, 0xef, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xe7, 0xff, + 0x99, 0x99, 0x99, 0xff, 0xff, 0xff, 0xff, 0xff, 0x99, 0x99, 0x00, 0x99, 0x00, 0x99, 0x99, 0xff, + 0xe7, 0xc1, 0x9f, 0xc3, 0xf9, 0x83, 0xe7, 0xff, 0x9d, 0x99, 0xf3, 0xe7, 0xcf, 0x99, 0xb9, 0xff, + 0xc3, 0x99, 0xc3, 0xc7, 0x98, 0x99, 0xc0, 0xff, 0xf9, 0xf3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf3, 0xe7, 0xcf, 0xcf, 0xcf, 0xe7, 0xf3, 0xff, 0xcf, 0xe7, 0xf3, 0xf3, 0xf3, 0xe7, 0xcf, 0xff, + 0xff, 0x99, 0xc3, 0x00, 0xc3, 0x99, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0x81, 0xe7, 0xe7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xcf, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xff, 0xff, 0xfc, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0xff, + 0xc3, 0x99, 0x91, 0x89, 0x99, 0x99, 0xc3, 0xff, 0xe7, 0xe7, 0xc7, 0xe7, 0xe7, 0xe7, 0x81, 0xff, + 0xc3, 0x99, 0xf9, 0xf3, 0xcf, 0x9f, 0x81, 0xff, 0xc3, 0x99, 0xf9, 0xe3, 0xf9, 0x99, 0xc3, 0xff, + 0xf9, 0xf1, 0xe1, 0x99, 0x80, 0xf9, 0xf9, 0xff, 0x81, 0x9f, 0x83, 0xf9, 0xf9, 0x99, 0xc3, 0xff, + 0xc3, 0x99, 0x9f, 0x83, 0x99, 0x99, 0xc3, 0xff, 0x81, 0x99, 0xf3, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, + 0xc3, 0x99, 0x99, 0xc3, 0x99, 0x99, 0xc3, 0xff, 0xc3, 0x99, 0x99, 0xc1, 0xf9, 0x99, 0xc3, 0xff, + 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff, 0xe7, 0xe7, 0xcf, + 0xf1, 0xe7, 0xcf, 0x9f, 0xcf, 0xe7, 0xf1, 0xff, 0xff, 0xff, 0x81, 0xff, 0x81, 0xff, 0xff, 0xff, + 0x8f, 0xe7, 0xf3, 0xf9, 0xf3, 0xe7, 0x8f, 0xff, 0xc3, 0x99, 0xf9, 0xf3, 0xe7, 0xff, 0xe7, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe7, 0xc3, 0x99, 0x81, 0x99, 0x99, 0x99, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x99, 0x99, 0x83, 0xff, 0xc3, 0x99, 0x9f, 0x9f, 0x9f, 0x99, 0xc3, 0xff, + 0x87, 0x93, 0x99, 0x99, 0x99, 0x93, 0x87, 0xff, 0x81, 0x9f, 0x9f, 0x87, 0x9f, 0x9f, 0x81, 0xff, + 0x81, 0x9f, 0x9f, 0x87, 0x9f, 0x9f, 0x9f, 0xff, 0xc3, 0x99, 0x9f, 0x91, 0x99, 0x99, 0xc3, 0xff, + 0x99, 0x99, 0x99, 0x81, 0x99, 0x99, 0x99, 0xff, 0xc3, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xc3, 0xff, + 0xe1, 0xf3, 0xf3, 0xf3, 0xf3, 0x93, 0xc7, 0xff, 0x99, 0x93, 0x87, 0x8f, 0x87, 0x93, 0x99, 0xff, + 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x81, 0xff, 0x9c, 0x88, 0x80, 0x94, 0x9c, 0x9c, 0x9c, 0xff, + 0x99, 0x89, 0x81, 0x81, 0x91, 0x99, 0x99, 0xff, 0xc3, 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x9f, 0x9f, 0x9f, 0xff, 0xc3, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xf1, 0xff, + 0x83, 0x99, 0x99, 0x83, 0x87, 0x93, 0x99, 0xff, 0xc3, 0x99, 0x9f, 0xc3, 0xf9, 0x99, 0xc3, 0xff, + 0x81, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xff, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xff, + 0x99, 0x99, 0x99, 0x99, 0x99, 0xc3, 0xe7, 0xff, 0x9c, 0x9c, 0x9c, 0x94, 0x80, 0x88, 0x9c, 0xff, + 0x99, 0x99, 0xc3, 0xe7, 0xc3, 0x99, 0x99, 0xff, 0x99, 0x99, 0x99, 0xc3, 0xe7, 0xe7, 0xe7, 0xff, + 0x81, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x81, 0xff, 0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xe7, 0xe7, 0xe7, + 0x3f, 0x3f, 0xcf, 0xcf, 0x3f, 0x3f, 0xcf, 0xcf, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0x66, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, + 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xff, 0xff, 0xff, 0xff, 0x33, 0x33, 0xcc, 0xcc, 0x33, 0x66, 0xcc, 0x99, 0x33, 0x66, 0xcc, 0x99, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xe7, 0xe7, 0xe7, 0xe0, 0xe0, 0xe7, 0xe7, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0xe7, 0xe7, 0xe7, 0xe0, 0xe0, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x07, 0x07, 0xe7, 0xe7, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xe0, 0xe0, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0x07, 0x07, 0xe7, 0xe7, 0xe7, + 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xfe, 0xfc, 0xf9, 0x93, 0x87, 0x8f, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, + 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xe7, 0xe7, 0x07, 0x07, 0xff, 0xff, 0xff, + 0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, +}; + +unsigned char basic[8192] = +{ + 0x94, 0xe3, 0x7b, 0xe3, 0x43, 0x42, 0x4d, 0x42, 0x41, 0x53, 0x49, 0x43, 0x30, 0xa8, 0x41, 0xa7, + 0x1d, 0xad, 0xf7, 0xa8, 0xa4, 0xab, 0xbe, 0xab, 0x80, 0xb0, 0x05, 0xac, 0xa4, 0xa9, 0x9f, 0xa8, + 0x70, 0xa8, 0x27, 0xa9, 0x1c, 0xa8, 0x82, 0xa8, 0xd1, 0xa8, 0x3a, 0xa9, 0x2e, 0xa8, 0x4a, 0xa9, + 0x2c, 0xb8, 0x67, 0xe1, 0x55, 0xe1, 0x64, 0xe1, 0xb2, 0xb3, 0x23, 0xb8, 0x7f, 0xaa, 0x9f, 0xaa, + 0x56, 0xa8, 0x9b, 0xa6, 0x5d, 0xa6, 0x85, 0xaa, 0x29, 0xe1, 0xbd, 0xe1, 0xc6, 0xe1, 0x7a, 0xab, + 0x41, 0xa6, 0x39, 0xbc, 0xcc, 0xbc, 0x58, 0xbc, 0x10, 0x03, 0x7d, 0xb3, 0x9e, 0xb3, 0x71, 0xbf, + 0x97, 0xe0, 0xea, 0xb9, 0xed, 0xbf, 0x64, 0xe2, 0x6b, 0xe2, 0xb4, 0xe2, 0x0e, 0xe3, 0x0d, 0xb8, + 0x7c, 0xb7, 0x65, 0xb4, 0xad, 0xb7, 0x8b, 0xb7, 0xec, 0xb6, 0x00, 0xb7, 0x2c, 0xb7, 0x37, 0xb7, + 0x79, 0x69, 0xb8, 0x79, 0x52, 0xb8, 0x7b, 0x2a, 0xba, 0x7b, 0x11, 0xbb, 0x7f, 0x7a, 0xbf, 0x50, + 0xe8, 0xaf, 0x46, 0xe5, 0xaf, 0x7d, 0xb3, 0xbf, 0x5a, 0xd3, 0xae, 0x64, 0x15, 0xb0, 0x45, 0x4e, + 0xc4, 0x46, 0x4f, 0xd2, 0x4e, 0x45, 0x58, 0xd4, 0x44, 0x41, 0x54, 0xc1, 0x49, 0x4e, 0x50, 0x55, + 0x54, 0xa3, 0x49, 0x4e, 0x50, 0x55, 0xd4, 0x44, 0x49, 0xcd, 0x52, 0x45, 0x41, 0xc4, 0x4c, 0x45, + 0xd4, 0x47, 0x4f, 0x54, 0xcf, 0x52, 0x55, 0xce, 0x49, 0xc6, 0x52, 0x45, 0x53, 0x54, 0x4f, 0x52, + 0xc5, 0x47, 0x4f, 0x53, 0x55, 0xc2, 0x52, 0x45, 0x54, 0x55, 0x52, 0xce, 0x52, 0x45, 0xcd, 0x53, + 0x54, 0x4f, 0xd0, 0x4f, 0xce, 0x57, 0x41, 0x49, 0xd4, 0x4c, 0x4f, 0x41, 0xc4, 0x53, 0x41, 0x56, + 0xc5, 0x56, 0x45, 0x52, 0x49, 0x46, 0xd9, 0x44, 0x45, 0xc6, 0x50, 0x4f, 0x4b, 0xc5, 0x50, 0x52, + 0x49, 0x4e, 0x54, 0xa3, 0x50, 0x52, 0x49, 0x4e, 0xd4, 0x43, 0x4f, 0x4e, 0xd4, 0x4c, 0x49, 0x53, + 0xd4, 0x43, 0x4c, 0xd2, 0x43, 0x4d, 0xc4, 0x53, 0x59, 0xd3, 0x4f, 0x50, 0x45, 0xce, 0x43, 0x4c, + 0x4f, 0x53, 0xc5, 0x47, 0x45, 0xd4, 0x4e, 0x45, 0xd7, 0x54, 0x41, 0x42, 0xa8, 0x54, 0xcf, 0x46, + 0xce, 0x53, 0x50, 0x43, 0xa8, 0x54, 0x48, 0x45, 0xce, 0x4e, 0x4f, 0xd4, 0x53, 0x54, 0x45, 0xd0, + 0xab, 0xad, 0xaa, 0xaf, 0xde, 0x41, 0x4e, 0xc4, 0x4f, 0xd2, 0xbe, 0xbd, 0xbc, 0x53, 0x47, 0xce, + 0x49, 0x4e, 0xd4, 0x41, 0x42, 0xd3, 0x55, 0x53, 0xd2, 0x46, 0x52, 0xc5, 0x50, 0x4f, 0xd3, 0x53, + 0x51, 0xd2, 0x52, 0x4e, 0xc4, 0x4c, 0x4f, 0xc7, 0x45, 0x58, 0xd0, 0x43, 0x4f, 0xd3, 0x53, 0x49, + 0xce, 0x54, 0x41, 0xce, 0x41, 0x54, 0xce, 0x50, 0x45, 0x45, 0xcb, 0x4c, 0x45, 0xce, 0x53, 0x54, + 0x52, 0xa4, 0x56, 0x41, 0xcc, 0x41, 0x53, 0xc3, 0x43, 0x48, 0x52, 0xa4, 0x4c, 0x45, 0x46, 0x54, + 0xa4, 0x52, 0x49, 0x47, 0x48, 0x54, 0xa4, 0x4d, 0x49, 0x44, 0xa4, 0x47, 0xcf, 0x00, 0x54, 0x4f, + 0x4f, 0x20, 0x4d, 0x41, 0x4e, 0x59, 0x20, 0x46, 0x49, 0x4c, 0x45, 0xd3, 0x46, 0x49, 0x4c, 0x45, + 0x20, 0x4f, 0x50, 0x45, 0xce, 0x46, 0x49, 0x4c, 0x45, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4f, 0x50, + 0x45, 0xce, 0x46, 0x49, 0x4c, 0x45, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x46, 0x4f, 0x55, 0x4e, 0xc4, + 0x44, 0x45, 0x56, 0x49, 0x43, 0x45, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x50, 0x52, 0x45, 0x53, 0x45, + 0x4e, 0xd4, 0x4e, 0x4f, 0x54, 0x20, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x20, 0x46, 0x49, 0x4c, 0xc5, + 0x4e, 0x4f, 0x54, 0x20, 0x4f, 0x55, 0x54, 0x50, 0x55, 0x54, 0x20, 0x46, 0x49, 0x4c, 0xc5, 0x4d, + 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x20, 0x46, 0x49, 0x4c, 0x45, 0x20, 0x4e, 0x41, 0x4d, 0xc5, + 0x49, 0x4c, 0x4c, 0x45, 0x47, 0x41, 0x4c, 0x20, 0x44, 0x45, 0x56, 0x49, 0x43, 0x45, 0x20, 0x4e, + 0x55, 0x4d, 0x42, 0x45, 0xd2, 0x4e, 0x45, 0x58, 0x54, 0x20, 0x57, 0x49, 0x54, 0x48, 0x4f, 0x55, + 0x54, 0x20, 0x46, 0x4f, 0xd2, 0x53, 0x59, 0x4e, 0x54, 0x41, 0xd8, 0x52, 0x45, 0x54, 0x55, 0x52, + 0x4e, 0x20, 0x57, 0x49, 0x54, 0x48, 0x4f, 0x55, 0x54, 0x20, 0x47, 0x4f, 0x53, 0x55, 0xc2, 0x4f, + 0x55, 0x54, 0x20, 0x4f, 0x46, 0x20, 0x44, 0x41, 0x54, 0xc1, 0x49, 0x4c, 0x4c, 0x45, 0x47, 0x41, + 0x4c, 0x20, 0x51, 0x55, 0x41, 0x4e, 0x54, 0x49, 0x54, 0xd9, 0x4f, 0x56, 0x45, 0x52, 0x46, 0x4c, + 0x4f, 0xd7, 0x4f, 0x55, 0x54, 0x20, 0x4f, 0x46, 0x20, 0x4d, 0x45, 0x4d, 0x4f, 0x52, 0xd9, 0x55, + 0x4e, 0x44, 0x45, 0x46, 0x27, 0x44, 0x20, 0x53, 0x54, 0x41, 0x54, 0x45, 0x4d, 0x45, 0x4e, 0xd4, + 0x42, 0x41, 0x44, 0x20, 0x53, 0x55, 0x42, 0x53, 0x43, 0x52, 0x49, 0x50, 0xd4, 0x52, 0x45, 0x44, + 0x49, 0x4d, 0x27, 0x44, 0x20, 0x41, 0x52, 0x52, 0x41, 0xd9, 0x44, 0x49, 0x56, 0x49, 0x53, 0x49, + 0x4f, 0x4e, 0x20, 0x42, 0x59, 0x20, 0x5a, 0x45, 0x52, 0xcf, 0x49, 0x4c, 0x4c, 0x45, 0x47, 0x41, + 0x4c, 0x20, 0x44, 0x49, 0x52, 0x45, 0x43, 0xd4, 0x54, 0x59, 0x50, 0x45, 0x20, 0x4d, 0x49, 0x53, + 0x4d, 0x41, 0x54, 0x43, 0xc8, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x20, 0x54, 0x4f, 0x4f, 0x20, + 0x4c, 0x4f, 0x4e, 0xc7, 0x46, 0x49, 0x4c, 0x45, 0x20, 0x44, 0x41, 0x54, 0xc1, 0x46, 0x4f, 0x52, + 0x4d, 0x55, 0x4c, 0x41, 0x20, 0x54, 0x4f, 0x4f, 0x20, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0xd8, + 0x43, 0x41, 0x4e, 0x27, 0x54, 0x20, 0x43, 0x4f, 0x4e, 0x54, 0x49, 0x4e, 0x55, 0xc5, 0x55, 0x4e, + 0x44, 0x45, 0x46, 0x27, 0x44, 0x20, 0x46, 0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0xce, 0x56, 0x45, + 0x52, 0x49, 0x46, 0xd9, 0x4c, 0x4f, 0x41, 0xc4, 0x9e, 0xa1, 0xac, 0xa1, 0xb5, 0xa1, 0xc2, 0xa1, + 0xd0, 0xa1, 0xe2, 0xa1, 0xf0, 0xa1, 0xff, 0xa1, 0x10, 0xa2, 0x25, 0xa2, 0x35, 0xa2, 0x3b, 0xa2, + 0x4f, 0xa2, 0x5a, 0xa2, 0x6a, 0xa2, 0x72, 0xa2, 0x7f, 0xa2, 0x90, 0xa2, 0x9d, 0xa2, 0xaa, 0xa2, + 0xba, 0xa2, 0xc8, 0xa2, 0xd5, 0xa2, 0xe4, 0xa2, 0xed, 0xa2, 0x00, 0xa3, 0x0e, 0xa3, 0x1e, 0xa3, + 0x24, 0xa3, 0x83, 0xa3, 0x0d, 0x4f, 0x4b, 0x0d, 0x00, 0x20, 0x20, 0x45, 0x52, 0x52, 0x4f, 0x52, + 0x00, 0x20, 0x49, 0x4e, 0x20, 0x00, 0x0d, 0x0a, 0x52, 0x45, 0x41, 0x44, 0x59, 0x2e, 0x0d, 0x0a, + 0x00, 0x0d, 0x0a, 0x42, 0x52, 0x45, 0x41, 0x4b, 0x00, 0xa0, 0xba, 0xe8, 0xe8, 0xe8, 0xe8, 0xbd, + 0x01, 0x01, 0xc9, 0x81, 0xd0, 0x21, 0xa5, 0x4a, 0xd0, 0x0a, 0xbd, 0x02, 0x01, 0x85, 0x49, 0xbd, + 0x03, 0x01, 0x85, 0x4a, 0xdd, 0x03, 0x01, 0xd0, 0x07, 0xa5, 0x49, 0xdd, 0x02, 0x01, 0xf0, 0x07, + 0x8a, 0x18, 0x69, 0x12, 0xaa, 0xd0, 0xd8, 0x60, 0x20, 0x08, 0xa4, 0x85, 0x31, 0x84, 0x32, 0x38, + 0xa5, 0x5a, 0xe5, 0x5f, 0x85, 0x22, 0xa8, 0xa5, 0x5b, 0xe5, 0x60, 0xaa, 0xe8, 0x98, 0xf0, 0x23, + 0xa5, 0x5a, 0x38, 0xe5, 0x22, 0x85, 0x5a, 0xb0, 0x03, 0xc6, 0x5b, 0x38, 0xa5, 0x58, 0xe5, 0x22, + 0x85, 0x58, 0xb0, 0x08, 0xc6, 0x59, 0x90, 0x04, 0xb1, 0x5a, 0x91, 0x58, 0x88, 0xd0, 0xf9, 0xb1, + 0x5a, 0x91, 0x58, 0xc6, 0x5b, 0xc6, 0x59, 0xca, 0xd0, 0xf2, 0x60, 0x0a, 0x69, 0x3e, 0xb0, 0x35, + 0x85, 0x22, 0xba, 0xe4, 0x22, 0x90, 0x2e, 0x60, 0xc4, 0x34, 0x90, 0x28, 0xd0, 0x04, 0xc5, 0x33, + 0x90, 0x22, 0x48, 0xa2, 0x09, 0x98, 0x48, 0xb5, 0x57, 0xca, 0x10, 0xfa, 0x20, 0x26, 0xb5, 0xa2, + 0xf7, 0x68, 0x95, 0x61, 0xe8, 0x30, 0xfa, 0x68, 0xa8, 0x68, 0xc4, 0x34, 0x90, 0x06, 0xd0, 0x05, + 0xc5, 0x33, 0xb0, 0x01, 0x60, 0xa2, 0x10, 0x6c, 0x00, 0x03, 0x8a, 0x0a, 0xaa, 0xbd, 0x26, 0xa3, + 0x85, 0x22, 0xbd, 0x27, 0xa3, 0x85, 0x23, 0x20, 0xcc, 0xff, 0xa9, 0x00, 0x85, 0x13, 0x20, 0xd7, + 0xaa, 0x20, 0x45, 0xab, 0xa0, 0x00, 0xb1, 0x22, 0x48, 0x29, 0x7f, 0x20, 0x47, 0xab, 0xc8, 0x68, + 0x10, 0xf4, 0x20, 0x7a, 0xa6, 0xa9, 0x69, 0xa0, 0xa3, 0x20, 0x1e, 0xab, 0xa4, 0x3a, 0xc8, 0xf0, + 0x03, 0x20, 0xc2, 0xbd, 0xa9, 0x76, 0xa0, 0xa3, 0x20, 0x1e, 0xab, 0xa9, 0x80, 0x20, 0x90, 0xff, + 0x6c, 0x02, 0x03, 0x20, 0x60, 0xa5, 0x86, 0x7a, 0x84, 0x7b, 0x20, 0x73, 0x00, 0xaa, 0xf0, 0xf0, + 0xa2, 0xff, 0x86, 0x3a, 0x90, 0x06, 0x20, 0x79, 0xa5, 0x4c, 0xe1, 0xa7, 0x20, 0x6b, 0xa9, 0x20, + 0x79, 0xa5, 0x84, 0x0b, 0x20, 0x13, 0xa6, 0x90, 0x44, 0xa0, 0x01, 0xb1, 0x5f, 0x85, 0x23, 0xa5, + 0x2d, 0x85, 0x22, 0xa5, 0x60, 0x85, 0x25, 0xa5, 0x5f, 0x88, 0xf1, 0x5f, 0x18, 0x65, 0x2d, 0x85, + 0x2d, 0x85, 0x24, 0xa5, 0x2e, 0x69, 0xff, 0x85, 0x2e, 0xe5, 0x60, 0xaa, 0x38, 0xa5, 0x5f, 0xe5, + 0x2d, 0xa8, 0xb0, 0x03, 0xe8, 0xc6, 0x25, 0x18, 0x65, 0x22, 0x90, 0x03, 0xc6, 0x23, 0x18, 0xb1, + 0x22, 0x91, 0x24, 0xc8, 0xd0, 0xf9, 0xe6, 0x23, 0xe6, 0x25, 0xca, 0xd0, 0xf2, 0x20, 0x59, 0xa6, + 0x20, 0x33, 0xa5, 0xad, 0x00, 0x02, 0xf0, 0x88, 0x18, 0xa5, 0x2d, 0x85, 0x5a, 0x65, 0x0b, 0x85, + 0x58, 0xa4, 0x2e, 0x84, 0x5b, 0x90, 0x01, 0xc8, 0x84, 0x59, 0x20, 0xb8, 0xa3, 0xa5, 0x14, 0xa4, + 0x15, 0x8d, 0xfe, 0x01, 0x8c, 0xff, 0x01, 0xa5, 0x31, 0xa4, 0x32, 0x85, 0x2d, 0x84, 0x2e, 0xa4, + 0x0b, 0x88, 0xb9, 0xfc, 0x01, 0x91, 0x5f, 0x88, 0x10, 0xf8, 0x20, 0x59, 0xa6, 0x20, 0x33, 0xa5, + 0x4c, 0x80, 0xa4, 0xa5, 0x2b, 0xa4, 0x2c, 0x85, 0x22, 0x84, 0x23, 0x18, 0xa0, 0x01, 0xb1, 0x22, + 0xf0, 0x1d, 0xa0, 0x04, 0xc8, 0xb1, 0x22, 0xd0, 0xfb, 0xc8, 0x98, 0x65, 0x22, 0xaa, 0xa0, 0x00, + 0x91, 0x22, 0xa5, 0x23, 0x69, 0x00, 0xc8, 0x91, 0x22, 0x86, 0x22, 0x85, 0x23, 0x90, 0xdd, 0x60, + 0xa2, 0x00, 0x20, 0x12, 0xe1, 0xc9, 0x0d, 0xf0, 0x0d, 0x9d, 0x00, 0x02, 0xe8, 0xe0, 0x59, 0x90, + 0xf1, 0xa2, 0x17, 0x4c, 0x37, 0xa4, 0x4c, 0xca, 0xaa, 0x6c, 0x04, 0x03, 0xa6, 0x7a, 0xa0, 0x04, + 0x84, 0x0f, 0xbd, 0x00, 0x02, 0x10, 0x07, 0xc9, 0xff, 0xf0, 0x3e, 0xe8, 0xd0, 0xf4, 0xc9, 0x20, + 0xf0, 0x37, 0x85, 0x08, 0xc9, 0x22, 0xf0, 0x56, 0x24, 0x0f, 0x70, 0x2d, 0xc9, 0x3f, 0xd0, 0x04, + 0xa9, 0x99, 0xd0, 0x25, 0xc9, 0x30, 0x90, 0x04, 0xc9, 0x3c, 0x90, 0x1d, 0x84, 0x71, 0xa0, 0x00, + 0x84, 0x0b, 0x88, 0x86, 0x7a, 0xca, 0xc8, 0xe8, 0xbd, 0x00, 0x02, 0x38, 0xf9, 0x9e, 0xa0, 0xf0, + 0xf5, 0xc9, 0x80, 0xd0, 0x30, 0x05, 0x0b, 0xa4, 0x71, 0xe8, 0xc8, 0x99, 0xfb, 0x01, 0xb9, 0xfb, + 0x01, 0xf0, 0x36, 0x38, 0xe9, 0x3a, 0xf0, 0x04, 0xc9, 0x49, 0xd0, 0x02, 0x85, 0x0f, 0x38, 0xe9, + 0x55, 0xd0, 0x9f, 0x85, 0x08, 0xbd, 0x00, 0x02, 0xf0, 0xdf, 0xc5, 0x08, 0xf0, 0xdb, 0xc8, 0x99, + 0xfb, 0x01, 0xe8, 0xd0, 0xf0, 0xa6, 0x7a, 0xe6, 0x0b, 0xc8, 0xb9, 0x9d, 0xa0, 0x10, 0xfa, 0xb9, + 0x9e, 0xa0, 0xd0, 0xb4, 0xbd, 0x00, 0x02, 0x10, 0xbe, 0x99, 0xfd, 0x01, 0xc6, 0x7b, 0xa9, 0xff, + 0x85, 0x7a, 0x60, 0xa5, 0x2b, 0xa6, 0x2c, 0xa0, 0x01, 0x85, 0x5f, 0x86, 0x60, 0xb1, 0x5f, 0xf0, + 0x1f, 0xc8, 0xc8, 0xa5, 0x15, 0xd1, 0x5f, 0x90, 0x18, 0xf0, 0x03, 0x88, 0xd0, 0x09, 0xa5, 0x14, + 0x88, 0xd1, 0x5f, 0x90, 0x0c, 0xf0, 0x0a, 0x88, 0xb1, 0x5f, 0xaa, 0x88, 0xb1, 0x5f, 0xb0, 0xd7, + 0x18, 0x60, 0xd0, 0xfd, 0xa9, 0x00, 0xa8, 0x91, 0x2b, 0xc8, 0x91, 0x2b, 0xa5, 0x2b, 0x18, 0x69, + 0x02, 0x85, 0x2d, 0xa5, 0x2c, 0x69, 0x00, 0x85, 0x2e, 0x20, 0x8e, 0xa6, 0xa9, 0x00, 0xd0, 0x2d, + 0x20, 0xe7, 0xff, 0xa5, 0x37, 0xa4, 0x38, 0x85, 0x33, 0x84, 0x34, 0xa5, 0x2d, 0xa4, 0x2e, 0x85, + 0x2f, 0x84, 0x30, 0x85, 0x31, 0x84, 0x32, 0x20, 0x1d, 0xa8, 0xa2, 0x19, 0x86, 0x16, 0x68, 0xa8, + 0x68, 0xa2, 0xfa, 0x9a, 0x48, 0x98, 0x48, 0xa9, 0x00, 0x85, 0x3e, 0x85, 0x10, 0x60, 0x18, 0xa5, + 0x2b, 0x69, 0xff, 0x85, 0x7a, 0xa5, 0x2c, 0x69, 0xff, 0x85, 0x7b, 0x60, 0x90, 0x06, 0xf0, 0x04, + 0xc9, 0xab, 0xd0, 0xe9, 0x20, 0x6b, 0xa9, 0x20, 0x13, 0xa6, 0x20, 0x79, 0x00, 0xf0, 0x0c, 0xc9, + 0xab, 0xd0, 0x8e, 0x20, 0x73, 0x00, 0x20, 0x6b, 0xa9, 0xd0, 0x86, 0x68, 0x68, 0xa5, 0x14, 0x05, + 0x15, 0xd0, 0x06, 0xa9, 0xff, 0x85, 0x14, 0x85, 0x15, 0xa0, 0x01, 0x84, 0x0f, 0xb1, 0x5f, 0xf0, + 0x43, 0x20, 0x2c, 0xa8, 0x20, 0xd7, 0xaa, 0xc8, 0xb1, 0x5f, 0xaa, 0xc8, 0xb1, 0x5f, 0xc5, 0x15, + 0xd0, 0x04, 0xe4, 0x14, 0xf0, 0x02, 0xb0, 0x2c, 0x84, 0x49, 0x20, 0xcd, 0xbd, 0xa9, 0x20, 0xa4, + 0x49, 0x29, 0x7f, 0x20, 0x47, 0xab, 0xc9, 0x22, 0xd0, 0x06, 0xa5, 0x0f, 0x49, 0xff, 0x85, 0x0f, + 0xc8, 0xf0, 0x11, 0xb1, 0x5f, 0xd0, 0x10, 0xa8, 0xb1, 0x5f, 0xaa, 0xc8, 0xb1, 0x5f, 0x86, 0x5f, + 0x85, 0x60, 0xd0, 0xb5, 0x4c, 0x86, 0xe3, 0x6c, 0x06, 0x03, 0x10, 0xd7, 0xc9, 0xff, 0xf0, 0xd3, + 0x24, 0x0f, 0x30, 0xcf, 0x38, 0xe9, 0x7f, 0xaa, 0x84, 0x49, 0xa0, 0xff, 0xca, 0xf0, 0x08, 0xc8, + 0xb9, 0x9e, 0xa0, 0x10, 0xfa, 0x30, 0xf5, 0xc8, 0xb9, 0x9e, 0xa0, 0x30, 0xb2, 0x20, 0x47, 0xab, + 0xd0, 0xf5, 0xa9, 0x80, 0x85, 0x10, 0x20, 0xa5, 0xa9, 0x20, 0x8a, 0xa3, 0xd0, 0x05, 0x8a, 0x69, + 0x0f, 0xaa, 0x9a, 0x68, 0x68, 0xa9, 0x09, 0x20, 0xfb, 0xa3, 0x20, 0x06, 0xa9, 0x18, 0x98, 0x65, + 0x7a, 0x48, 0xa5, 0x7b, 0x69, 0x00, 0x48, 0xa5, 0x3a, 0x48, 0xa5, 0x39, 0x48, 0xa9, 0xa4, 0x20, + 0xff, 0xae, 0x20, 0x8d, 0xad, 0x20, 0x8a, 0xad, 0xa5, 0x66, 0x09, 0x7f, 0x25, 0x62, 0x85, 0x62, + 0xa9, 0x8b, 0xa0, 0xa7, 0x85, 0x22, 0x84, 0x23, 0x4c, 0x43, 0xae, 0xa9, 0xbc, 0xa0, 0xb9, 0x20, + 0xa2, 0xbb, 0x20, 0x79, 0x00, 0xc9, 0xa9, 0xd0, 0x06, 0x20, 0x73, 0x00, 0x20, 0x8a, 0xad, 0x20, + 0x2b, 0xbc, 0x20, 0x38, 0xae, 0xa5, 0x4a, 0x48, 0xa5, 0x49, 0x48, 0xa9, 0x81, 0x48, 0x20, 0x2c, + 0xa8, 0xa5, 0x7a, 0xa4, 0x7b, 0xc0, 0x02, 0xea, 0xf0, 0x04, 0x85, 0x3d, 0x84, 0x3e, 0xa0, 0x00, + 0xb1, 0x7a, 0xd0, 0x43, 0xa0, 0x02, 0xb1, 0x7a, 0x18, 0xd0, 0x03, 0x4c, 0x4b, 0xa8, 0xc8, 0xb1, + 0x7a, 0x85, 0x39, 0xc8, 0xb1, 0x7a, 0x85, 0x3a, 0x98, 0x65, 0x7a, 0x85, 0x7a, 0x90, 0x02, 0xe6, + 0x7b, 0x6c, 0x08, 0x03, 0x20, 0x73, 0x00, 0x20, 0xed, 0xa7, 0x4c, 0xae, 0xa7, 0xf0, 0x3c, 0xe9, + 0x80, 0x90, 0x11, 0xc9, 0x23, 0xb0, 0x17, 0x0a, 0xa8, 0xb9, 0x0d, 0xa0, 0x48, 0xb9, 0x0c, 0xa0, + 0x48, 0x4c, 0x73, 0x00, 0x4c, 0xa5, 0xa9, 0xc9, 0x3a, 0xf0, 0xd6, 0x4c, 0x08, 0xaf, 0xc9, 0x4b, + 0xd0, 0xf9, 0x20, 0x73, 0x00, 0xa9, 0xa4, 0x20, 0xff, 0xae, 0x4c, 0xa0, 0xa8, 0x38, 0xa5, 0x2b, + 0xe9, 0x01, 0xa4, 0x2c, 0xb0, 0x01, 0x88, 0x85, 0x41, 0x84, 0x42, 0x60, 0x20, 0xe1, 0xff, 0xb0, + 0x01, 0x18, 0xd0, 0x3c, 0xa5, 0x7a, 0xa4, 0x7b, 0xa6, 0x3a, 0xe8, 0xf0, 0x0c, 0x85, 0x3d, 0x84, + 0x3e, 0xa5, 0x39, 0xa4, 0x3a, 0x85, 0x3b, 0x84, 0x3c, 0x68, 0x68, 0xa9, 0x81, 0xa0, 0xa3, 0x90, + 0x03, 0x4c, 0x69, 0xa4, 0x4c, 0x86, 0xe3, 0xd0, 0x17, 0xa2, 0x1a, 0xa4, 0x3e, 0xd0, 0x03, 0x4c, + 0x37, 0xa4, 0xa5, 0x3d, 0x85, 0x7a, 0x84, 0x7b, 0xa5, 0x3b, 0xa4, 0x3c, 0x85, 0x39, 0x84, 0x3a, + 0x60, 0x08, 0xa9, 0x00, 0x20, 0x90, 0xff, 0x28, 0xd0, 0x03, 0x4c, 0x59, 0xa6, 0x20, 0x60, 0xa6, + 0x4c, 0x97, 0xa8, 0xa9, 0x03, 0x20, 0xfb, 0xa3, 0xa5, 0x7b, 0x48, 0xa5, 0x7a, 0x48, 0xa5, 0x3a, + 0x48, 0xa5, 0x39, 0x48, 0xa9, 0x8d, 0x48, 0x20, 0x79, 0x00, 0x20, 0xa0, 0xa8, 0x4c, 0xae, 0xa7, + 0x20, 0x6b, 0xa9, 0x20, 0x09, 0xa9, 0x38, 0xa5, 0x39, 0xe5, 0x14, 0xa5, 0x3a, 0xe5, 0x15, 0xb0, + 0x0b, 0x98, 0x38, 0x65, 0x7a, 0xa6, 0x7b, 0x90, 0x07, 0xe8, 0xb0, 0x04, 0xa5, 0x2b, 0xa6, 0x2c, + 0x20, 0x17, 0xa6, 0x90, 0x1e, 0xa5, 0x5f, 0xe9, 0x01, 0x85, 0x7a, 0xa5, 0x60, 0xe9, 0x00, 0x85, + 0x7b, 0x60, 0xd0, 0xfd, 0xa9, 0xff, 0x85, 0x4a, 0x20, 0x8a, 0xa3, 0x9a, 0xc9, 0x8d, 0xf0, 0x0b, + 0xa2, 0x0c, 0x2c, 0xa2, 0x11, 0x4c, 0x37, 0xa4, 0x4c, 0x08, 0xaf, 0x68, 0x68, 0x85, 0x39, 0x68, + 0x85, 0x3a, 0x68, 0x85, 0x7a, 0x68, 0x85, 0x7b, 0x20, 0x06, 0xa9, 0x98, 0x18, 0x65, 0x7a, 0x85, + 0x7a, 0x90, 0x02, 0xe6, 0x7b, 0x60, 0xa2, 0x3a, 0x2c, 0xa2, 0x00, 0x86, 0x07, 0xa0, 0x00, 0x84, + 0x08, 0xa5, 0x08, 0xa6, 0x07, 0x85, 0x07, 0x86, 0x08, 0xb1, 0x7a, 0xf0, 0xe8, 0xc5, 0x08, 0xf0, + 0xe4, 0xc8, 0xc9, 0x22, 0xd0, 0xf3, 0xf0, 0xe9, 0x20, 0x9e, 0xad, 0x20, 0x79, 0x00, 0xc9, 0x89, + 0xf0, 0x05, 0xa9, 0xa7, 0x20, 0xff, 0xae, 0xa5, 0x61, 0xd0, 0x05, 0x20, 0x09, 0xa9, 0xf0, 0xbb, + 0x20, 0x79, 0x00, 0xb0, 0x03, 0x4c, 0xa0, 0xa8, 0x4c, 0xed, 0xa7, 0x20, 0x9e, 0xb7, 0x48, 0xc9, + 0x8d, 0xf0, 0x04, 0xc9, 0x89, 0xd0, 0x91, 0xc6, 0x65, 0xd0, 0x04, 0x68, 0x4c, 0xef, 0xa7, 0x20, + 0x73, 0x00, 0x20, 0x6b, 0xa9, 0xc9, 0x2c, 0xf0, 0xee, 0x68, 0x60, 0xa2, 0x00, 0x86, 0x14, 0x86, + 0x15, 0xb0, 0xf7, 0xe9, 0x2f, 0x85, 0x07, 0xa5, 0x15, 0x85, 0x22, 0xc9, 0x19, 0xb0, 0xd4, 0xa5, + 0x14, 0x0a, 0x26, 0x22, 0x0a, 0x26, 0x22, 0x65, 0x14, 0x85, 0x14, 0xa5, 0x22, 0x65, 0x15, 0x85, + 0x15, 0x06, 0x14, 0x26, 0x15, 0xa5, 0x14, 0x65, 0x07, 0x85, 0x14, 0x90, 0x02, 0xe6, 0x15, 0x20, + 0x73, 0x00, 0x4c, 0x71, 0xa9, 0x20, 0x8b, 0xb0, 0x85, 0x49, 0x84, 0x4a, 0xa9, 0xb2, 0x20, 0xff, + 0xae, 0xa5, 0x0e, 0x48, 0xa5, 0x0d, 0x48, 0x20, 0x9e, 0xad, 0x68, 0x2a, 0x20, 0x90, 0xad, 0xd0, + 0x18, 0x68, 0x10, 0x12, 0x20, 0x1b, 0xbc, 0x20, 0xbf, 0xb1, 0xa0, 0x00, 0xa5, 0x64, 0x91, 0x49, + 0xc8, 0xa5, 0x65, 0x91, 0x49, 0x60, 0x4c, 0xd0, 0xbb, 0x68, 0xa4, 0x4a, 0xc0, 0xbf, 0xd0, 0x4c, + 0x20, 0xa6, 0xb6, 0xc9, 0x06, 0xd0, 0x3d, 0xa0, 0x00, 0x84, 0x61, 0x84, 0x66, 0x84, 0x71, 0x20, + 0x1d, 0xaa, 0x20, 0xe2, 0xba, 0xe6, 0x71, 0xa4, 0x71, 0x20, 0x1d, 0xaa, 0x20, 0x0c, 0xbc, 0xaa, + 0xf0, 0x05, 0xe8, 0x8a, 0x20, 0xed, 0xba, 0xa4, 0x71, 0xc8, 0xc0, 0x06, 0xd0, 0xdf, 0x20, 0xe2, + 0xba, 0x20, 0x9b, 0xbc, 0xa6, 0x64, 0xa4, 0x63, 0xa5, 0x65, 0x4c, 0xdb, 0xff, 0xb1, 0x22, 0x20, + 0x80, 0x00, 0x90, 0x03, 0x4c, 0x48, 0xb2, 0xe9, 0x2f, 0x4c, 0x7e, 0xbd, 0xa0, 0x02, 0xb1, 0x64, + 0xc5, 0x34, 0x90, 0x17, 0xd0, 0x07, 0x88, 0xb1, 0x64, 0xc5, 0x33, 0x90, 0x0e, 0xa4, 0x65, 0xc4, + 0x2e, 0x90, 0x08, 0xd0, 0x0d, 0xa5, 0x64, 0xc5, 0x2d, 0xb0, 0x07, 0xa5, 0x64, 0xa4, 0x65, 0x4c, + 0x68, 0xaa, 0xa0, 0x00, 0xb1, 0x64, 0x20, 0x75, 0xb4, 0xa5, 0x50, 0xa4, 0x51, 0x85, 0x6f, 0x84, + 0x70, 0x20, 0x7a, 0xb6, 0xa9, 0x61, 0xa0, 0x00, 0x85, 0x50, 0x84, 0x51, 0x20, 0xdb, 0xb6, 0xa0, + 0x00, 0xb1, 0x50, 0x91, 0x49, 0xc8, 0xb1, 0x50, 0x91, 0x49, 0xc8, 0xb1, 0x50, 0x91, 0x49, 0x60, + 0x20, 0x86, 0xaa, 0x4c, 0xb5, 0xab, 0x20, 0x9e, 0xb7, 0xf0, 0x05, 0xa9, 0x2c, 0x20, 0xff, 0xae, + 0x08, 0x86, 0x13, 0x20, 0x18, 0xe1, 0x28, 0x4c, 0xa0, 0xaa, 0x20, 0x21, 0xab, 0x20, 0x79, 0x00, + 0xf0, 0x35, 0xf0, 0x43, 0xc9, 0xa3, 0xf0, 0x50, 0xc9, 0xa6, 0x18, 0xf0, 0x4b, 0xc9, 0x2c, 0xf0, + 0x37, 0xc9, 0x3b, 0xf0, 0x5e, 0x20, 0x9e, 0xad, 0x24, 0x0d, 0x30, 0xde, 0x20, 0xdd, 0xbd, 0x20, + 0x87, 0xb4, 0x20, 0x21, 0xab, 0x20, 0x3b, 0xab, 0xd0, 0xd3, 0xa9, 0x00, 0x9d, 0x00, 0x02, 0xa2, + 0xff, 0xa0, 0x01, 0xa5, 0x13, 0xd0, 0x10, 0xa9, 0x0d, 0x20, 0x47, 0xab, 0x24, 0x13, 0x10, 0x05, + 0xa9, 0x0a, 0x20, 0x47, 0xab, 0x49, 0xff, 0x60, 0x38, 0x20, 0xf0, 0xff, 0x98, 0x38, 0xe9, 0x0a, + 0xb0, 0xfc, 0x49, 0xff, 0x69, 0x01, 0xd0, 0x16, 0x08, 0x38, 0x20, 0xf0, 0xff, 0x84, 0x09, 0x20, + 0x9b, 0xb7, 0xc9, 0x29, 0xd0, 0x59, 0x28, 0x90, 0x06, 0x8a, 0xe5, 0x09, 0x90, 0x05, 0xaa, 0xe8, + 0xca, 0xd0, 0x06, 0x20, 0x73, 0x00, 0x4c, 0xa2, 0xaa, 0x20, 0x3b, 0xab, 0xd0, 0xf2, 0x20, 0x87, + 0xb4, 0x20, 0xa6, 0xb6, 0xaa, 0xa0, 0x00, 0xe8, 0xca, 0xf0, 0xbc, 0xb1, 0x22, 0x20, 0x47, 0xab, + 0xc8, 0xc9, 0x0d, 0xd0, 0xf3, 0x20, 0xe5, 0xaa, 0x4c, 0x28, 0xab, 0xa5, 0x13, 0xf0, 0x03, 0xa9, + 0x20, 0x2c, 0xa9, 0x1d, 0x2c, 0xa9, 0x3f, 0x20, 0x0c, 0xe1, 0x29, 0xff, 0x60, 0xa5, 0x11, 0xf0, + 0x11, 0x30, 0x04, 0xa0, 0xff, 0xd0, 0x04, 0xa5, 0x3f, 0xa4, 0x40, 0x85, 0x39, 0x84, 0x3a, 0x4c, + 0x08, 0xaf, 0xa5, 0x13, 0xf0, 0x05, 0xa2, 0x18, 0x4c, 0x37, 0xa4, 0xa9, 0x0c, 0xa0, 0xad, 0x20, + 0x1e, 0xab, 0xa5, 0x3d, 0xa4, 0x3e, 0x85, 0x7a, 0x84, 0x7b, 0x60, 0x20, 0xa6, 0xb3, 0xc9, 0x23, + 0xd0, 0x10, 0x20, 0x73, 0x00, 0x20, 0x9e, 0xb7, 0xa9, 0x2c, 0x20, 0xff, 0xae, 0x86, 0x13, 0x20, + 0x1e, 0xe1, 0xa2, 0x01, 0xa0, 0x02, 0xa9, 0x00, 0x8d, 0x01, 0x02, 0xa9, 0x40, 0x20, 0x0f, 0xac, + 0xa6, 0x13, 0xd0, 0x13, 0x60, 0x20, 0x9e, 0xb7, 0xa9, 0x2c, 0x20, 0xff, 0xae, 0x86, 0x13, 0x20, + 0x1e, 0xe1, 0x20, 0xce, 0xab, 0xa5, 0x13, 0x20, 0xcc, 0xff, 0xa2, 0x00, 0x86, 0x13, 0x60, 0xc9, + 0x22, 0xd0, 0x0b, 0x20, 0xbd, 0xae, 0xa9, 0x3b, 0x20, 0xff, 0xae, 0x20, 0x21, 0xab, 0x20, 0xa6, + 0xb3, 0xa9, 0x2c, 0x8d, 0xff, 0x01, 0x20, 0xf9, 0xab, 0xa5, 0x13, 0xf0, 0x0d, 0x20, 0xb7, 0xff, + 0x29, 0x02, 0xf0, 0x06, 0x20, 0xb5, 0xab, 0x4c, 0xf8, 0xa8, 0xad, 0x00, 0x02, 0xd0, 0x1e, 0xa5, + 0x13, 0xd0, 0xe3, 0x20, 0x06, 0xa9, 0x4c, 0xfb, 0xa8, 0xa5, 0x13, 0xd0, 0x06, 0x20, 0x45, 0xab, + 0x20, 0x3b, 0xab, 0x4c, 0x60, 0xa5, 0xa6, 0x41, 0xa4, 0x42, 0xa9, 0x98, 0x2c, 0xa9, 0x00, 0x85, + 0x11, 0x86, 0x43, 0x84, 0x44, 0x20, 0x8b, 0xb0, 0x85, 0x49, 0x84, 0x4a, 0xa5, 0x7a, 0xa4, 0x7b, + 0x85, 0x4b, 0x84, 0x4c, 0xa6, 0x43, 0xa4, 0x44, 0x86, 0x7a, 0x84, 0x7b, 0x20, 0x79, 0x00, 0xd0, + 0x20, 0x24, 0x11, 0x50, 0x0c, 0x20, 0x24, 0xe1, 0x8d, 0x00, 0x02, 0xa2, 0xff, 0xa0, 0x01, 0xd0, + 0x0c, 0x30, 0x75, 0xa5, 0x13, 0xd0, 0x03, 0x20, 0x45, 0xab, 0x20, 0xf9, 0xab, 0x86, 0x7a, 0x84, + 0x7b, 0x20, 0x73, 0x00, 0x24, 0x0d, 0x10, 0x31, 0x24, 0x11, 0x50, 0x09, 0xe8, 0x86, 0x7a, 0xa9, + 0x00, 0x85, 0x07, 0xf0, 0x0c, 0x85, 0x07, 0xc9, 0x22, 0xf0, 0x07, 0xa9, 0x3a, 0x85, 0x07, 0xa9, + 0x2c, 0x18, 0x85, 0x08, 0xa5, 0x7a, 0xa4, 0x7b, 0x69, 0x00, 0x90, 0x01, 0xc8, 0x20, 0x8d, 0xb4, + 0x20, 0xe2, 0xb7, 0x20, 0xda, 0xa9, 0x4c, 0x91, 0xac, 0x20, 0xf3, 0xbc, 0xa5, 0x0e, 0x20, 0xc2, + 0xa9, 0x20, 0x79, 0x00, 0xf0, 0x07, 0xc9, 0x2c, 0xf0, 0x03, 0x4c, 0x4d, 0xab, 0xa5, 0x7a, 0xa4, + 0x7b, 0x85, 0x43, 0x84, 0x44, 0xa5, 0x4b, 0xa4, 0x4c, 0x85, 0x7a, 0x84, 0x7b, 0x20, 0x79, 0x00, + 0xf0, 0x2d, 0x20, 0xfd, 0xae, 0x4c, 0x15, 0xac, 0x20, 0x06, 0xa9, 0xc8, 0xaa, 0xd0, 0x12, 0xa2, + 0x0d, 0xc8, 0xb1, 0x7a, 0xf0, 0x6c, 0xc8, 0xb1, 0x7a, 0x85, 0x3f, 0xc8, 0xb1, 0x7a, 0xc8, 0x85, + 0x40, 0x20, 0xfb, 0xa8, 0x20, 0x79, 0x00, 0xaa, 0xe0, 0x83, 0xd0, 0xdc, 0x4c, 0x51, 0xac, 0xa5, + 0x43, 0xa4, 0x44, 0xa6, 0x11, 0x10, 0x03, 0x4c, 0x27, 0xa8, 0xa0, 0x00, 0xb1, 0x43, 0xf0, 0x0b, + 0xa5, 0x13, 0xd0, 0x07, 0xa9, 0xfc, 0xa0, 0xac, 0x4c, 0x1e, 0xab, 0x60, 0x3f, 0x45, 0x58, 0x54, + 0x52, 0x41, 0x20, 0x49, 0x47, 0x4e, 0x4f, 0x52, 0x45, 0x44, 0x0d, 0x00, 0x3f, 0x52, 0x45, 0x44, + 0x4f, 0x20, 0x46, 0x52, 0x4f, 0x4d, 0x20, 0x53, 0x54, 0x41, 0x52, 0x54, 0x0d, 0x00, 0xd0, 0x04, + 0xa0, 0x00, 0xf0, 0x03, 0x20, 0x8b, 0xb0, 0x85, 0x49, 0x84, 0x4a, 0x20, 0x8a, 0xa3, 0xf0, 0x05, + 0xa2, 0x0a, 0x4c, 0x37, 0xa4, 0x9a, 0x8a, 0x18, 0x69, 0x04, 0x48, 0x69, 0x06, 0x85, 0x24, 0x68, + 0xa0, 0x01, 0x20, 0xa2, 0xbb, 0xba, 0xbd, 0x09, 0x01, 0x85, 0x66, 0xa5, 0x49, 0xa4, 0x4a, 0x20, + 0x67, 0xb8, 0x20, 0xd0, 0xbb, 0xa0, 0x01, 0x20, 0x5d, 0xbc, 0xba, 0x38, 0xfd, 0x09, 0x01, 0xf0, + 0x17, 0xbd, 0x0f, 0x01, 0x85, 0x39, 0xbd, 0x10, 0x01, 0x85, 0x3a, 0xbd, 0x12, 0x01, 0x85, 0x7a, + 0xbd, 0x11, 0x01, 0x85, 0x7b, 0x4c, 0xae, 0xa7, 0x8a, 0x69, 0x11, 0xaa, 0x9a, 0x20, 0x79, 0x00, + 0xc9, 0x2c, 0xd0, 0xf1, 0x20, 0x73, 0x00, 0x20, 0x24, 0xad, 0x20, 0x9e, 0xad, 0x18, 0x24, 0x38, + 0x24, 0x0d, 0x30, 0x03, 0xb0, 0x03, 0x60, 0xb0, 0xfd, 0xa2, 0x16, 0x4c, 0x37, 0xa4, 0xa6, 0x7a, + 0xd0, 0x02, 0xc6, 0x7b, 0xc6, 0x7a, 0xa2, 0x00, 0x24, 0x48, 0x8a, 0x48, 0xa9, 0x01, 0x20, 0xfb, + 0xa3, 0x20, 0x83, 0xae, 0xa9, 0x00, 0x85, 0x4d, 0x20, 0x79, 0x00, 0x38, 0xe9, 0xb1, 0x90, 0x17, + 0xc9, 0x03, 0xb0, 0x13, 0xc9, 0x01, 0x2a, 0x49, 0x01, 0x45, 0x4d, 0xc5, 0x4d, 0x90, 0x61, 0x85, + 0x4d, 0x20, 0x73, 0x00, 0x4c, 0xbb, 0xad, 0xa6, 0x4d, 0xd0, 0x2c, 0xb0, 0x7b, 0x69, 0x07, 0x90, + 0x77, 0x65, 0x0d, 0xd0, 0x03, 0x4c, 0x3d, 0xb6, 0x69, 0xff, 0x85, 0x22, 0x0a, 0x65, 0x22, 0xa8, + 0x68, 0xd9, 0x80, 0xa0, 0xb0, 0x67, 0x20, 0x8d, 0xad, 0x48, 0x20, 0x20, 0xae, 0x68, 0xa4, 0x4b, + 0x10, 0x17, 0xaa, 0xf0, 0x56, 0xd0, 0x5f, 0x46, 0x0d, 0x8a, 0x2a, 0xa6, 0x7a, 0xd0, 0x02, 0xc6, + 0x7b, 0xc6, 0x7a, 0xa0, 0x1b, 0x85, 0x4d, 0xd0, 0xd7, 0xd9, 0x80, 0xa0, 0xb0, 0x48, 0x90, 0xd9, + 0xb9, 0x82, 0xa0, 0x48, 0xb9, 0x81, 0xa0, 0x48, 0x20, 0x33, 0xae, 0xa5, 0x4d, 0x4c, 0xa9, 0xad, + 0x4c, 0x08, 0xaf, 0xa5, 0x66, 0xbe, 0x80, 0xa0, 0xa8, 0x68, 0x85, 0x22, 0xe6, 0x22, 0x68, 0x85, + 0x23, 0x98, 0x48, 0x20, 0x1b, 0xbc, 0xa5, 0x65, 0x48, 0xa5, 0x64, 0x48, 0xa5, 0x63, 0x48, 0xa5, + 0x62, 0x48, 0xa5, 0x61, 0x48, 0x6c, 0x22, 0x00, 0xa0, 0xff, 0x68, 0xf0, 0x23, 0xc9, 0x64, 0xf0, + 0x03, 0x20, 0x8d, 0xad, 0x84, 0x4b, 0x68, 0x4a, 0x85, 0x12, 0x68, 0x85, 0x69, 0x68, 0x85, 0x6a, + 0x68, 0x85, 0x6b, 0x68, 0x85, 0x6c, 0x68, 0x85, 0x6d, 0x68, 0x85, 0x6e, 0x45, 0x66, 0x85, 0x6f, + 0xa5, 0x61, 0x60, 0x6c, 0x0a, 0x03, 0xa9, 0x00, 0x85, 0x0d, 0x20, 0x73, 0x00, 0xb0, 0x03, 0x4c, + 0xf3, 0xbc, 0x20, 0x13, 0xb1, 0x90, 0x03, 0x4c, 0x28, 0xaf, 0xc9, 0xff, 0xd0, 0x0f, 0xa9, 0xa8, + 0xa0, 0xae, 0x20, 0xa2, 0xbb, 0x4c, 0x73, 0x00, 0x82, 0x49, 0x0f, 0xda, 0xa1, 0xc9, 0x2e, 0xf0, + 0xde, 0xc9, 0xab, 0xf0, 0x58, 0xc9, 0xaa, 0xf0, 0xd1, 0xc9, 0x22, 0xd0, 0x0f, 0xa5, 0x7a, 0xa4, + 0x7b, 0x69, 0x00, 0x90, 0x01, 0xc8, 0x20, 0x87, 0xb4, 0x4c, 0xe2, 0xb7, 0xc9, 0xa8, 0xd0, 0x13, + 0xa0, 0x18, 0xd0, 0x3b, 0x20, 0xbf, 0xb1, 0xa5, 0x65, 0x49, 0xff, 0xa8, 0xa5, 0x64, 0x49, 0xff, + 0x4c, 0x91, 0xb3, 0xc9, 0xa5, 0xd0, 0x03, 0x4c, 0xf4, 0xb3, 0xc9, 0xb4, 0x90, 0x03, 0x4c, 0xa7, + 0xaf, 0x20, 0xfa, 0xae, 0x20, 0x9e, 0xad, 0xa9, 0x29, 0x2c, 0xa9, 0x28, 0x2c, 0xa9, 0x2c, 0xa0, + 0x00, 0xd1, 0x7a, 0xd0, 0x03, 0x4c, 0x73, 0x00, 0xa2, 0x0b, 0x4c, 0x37, 0xa4, 0xa0, 0x15, 0x68, + 0x68, 0x4c, 0xfa, 0xad, 0x38, 0xa5, 0x64, 0xe9, 0x00, 0xa5, 0x65, 0xe9, 0xa0, 0x90, 0x08, 0xa9, + 0xa2, 0xe5, 0x64, 0xa9, 0xe3, 0xe5, 0x65, 0x60, 0x20, 0x8b, 0xb0, 0x85, 0x64, 0x84, 0x65, 0xa6, + 0x45, 0xa4, 0x46, 0xa5, 0x0d, 0xf0, 0x26, 0xa9, 0x00, 0x85, 0x70, 0x20, 0x14, 0xaf, 0x90, 0x1c, + 0xe0, 0x54, 0xd0, 0x18, 0xc0, 0xc9, 0xd0, 0x14, 0x20, 0x84, 0xaf, 0x84, 0x5e, 0x88, 0x84, 0x71, + 0xa0, 0x06, 0x84, 0x5d, 0xa0, 0x24, 0x20, 0x68, 0xbe, 0x4c, 0x6f, 0xb4, 0x60, 0x24, 0x0e, 0x10, + 0x0d, 0xa0, 0x00, 0xb1, 0x64, 0xaa, 0xc8, 0xb1, 0x64, 0xa8, 0x8a, 0x4c, 0x91, 0xb3, 0x20, 0x14, + 0xaf, 0x90, 0x2d, 0xe0, 0x54, 0xd0, 0x1b, 0xc0, 0x49, 0xd0, 0x25, 0x20, 0x84, 0xaf, 0x98, 0xa2, + 0xa0, 0x4c, 0x4f, 0xbc, 0x20, 0xde, 0xff, 0x86, 0x64, 0x84, 0x63, 0x85, 0x65, 0xa0, 0x00, 0x84, + 0x62, 0x60, 0xe0, 0x53, 0xd0, 0x0a, 0xc0, 0x54, 0xd0, 0x06, 0x20, 0xb7, 0xff, 0x4c, 0x3c, 0xbc, + 0xa5, 0x64, 0xa4, 0x65, 0x4c, 0xa2, 0xbb, 0x0a, 0x48, 0xaa, 0x20, 0x73, 0x00, 0xe0, 0x8f, 0x90, + 0x20, 0x20, 0xfa, 0xae, 0x20, 0x9e, 0xad, 0x20, 0xfd, 0xae, 0x20, 0x8f, 0xad, 0x68, 0xaa, 0xa5, + 0x65, 0x48, 0xa5, 0x64, 0x48, 0x8a, 0x48, 0x20, 0x9e, 0xb7, 0x68, 0xa8, 0x8a, 0x48, 0x4c, 0xd6, + 0xaf, 0x20, 0xf1, 0xae, 0x68, 0xa8, 0xb9, 0xea, 0x9f, 0x85, 0x55, 0xb9, 0xeb, 0x9f, 0x85, 0x56, + 0x20, 0x54, 0x00, 0x4c, 0x8d, 0xad, 0xa0, 0xff, 0x2c, 0xa0, 0x00, 0x84, 0x0b, 0x20, 0xbf, 0xb1, + 0xa5, 0x64, 0x45, 0x0b, 0x85, 0x07, 0xa5, 0x65, 0x45, 0x0b, 0x85, 0x08, 0x20, 0xfc, 0xbb, 0x20, + 0xbf, 0xb1, 0xa5, 0x65, 0x45, 0x0b, 0x25, 0x08, 0x45, 0x0b, 0xa8, 0xa5, 0x64, 0x45, 0x0b, 0x25, + 0x07, 0x45, 0x0b, 0x4c, 0x91, 0xb3, 0x20, 0x90, 0xad, 0xb0, 0x13, 0xa5, 0x6e, 0x09, 0x7f, 0x25, + 0x6a, 0x85, 0x6a, 0xa9, 0x69, 0xa0, 0x00, 0x20, 0x5b, 0xbc, 0xaa, 0x4c, 0x61, 0xb0, 0xa9, 0x00, + 0x85, 0x0d, 0xc6, 0x4d, 0x20, 0xa6, 0xb6, 0x85, 0x61, 0x86, 0x62, 0x84, 0x63, 0xa5, 0x6c, 0xa4, + 0x6d, 0x20, 0xaa, 0xb6, 0x86, 0x6c, 0x84, 0x6d, 0xaa, 0x38, 0xe5, 0x61, 0xf0, 0x08, 0xa9, 0x01, + 0x90, 0x04, 0xa6, 0x61, 0xa9, 0xff, 0x85, 0x66, 0xa0, 0xff, 0xe8, 0xc8, 0xca, 0xd0, 0x07, 0xa6, + 0x66, 0x30, 0x0f, 0x18, 0x90, 0x0c, 0xb1, 0x6c, 0xd1, 0x62, 0xf0, 0xef, 0xa2, 0xff, 0xb0, 0x02, + 0xa2, 0x01, 0xe8, 0x8a, 0x2a, 0x25, 0x12, 0xf0, 0x02, 0xa9, 0xff, 0x4c, 0x3c, 0xbc, 0x20, 0xfd, + 0xae, 0xaa, 0x20, 0x90, 0xb0, 0x20, 0x79, 0x00, 0xd0, 0xf4, 0x60, 0xa2, 0x00, 0x20, 0x79, 0x00, + 0x86, 0x0c, 0x85, 0x45, 0x20, 0x79, 0x00, 0x20, 0x13, 0xb1, 0xb0, 0x03, 0x4c, 0x08, 0xaf, 0xa2, + 0x00, 0x86, 0x0d, 0x86, 0x0e, 0x20, 0x73, 0x00, 0x90, 0x05, 0x20, 0x13, 0xb1, 0x90, 0x0b, 0xaa, + 0x20, 0x73, 0x00, 0x90, 0xfb, 0x20, 0x13, 0xb1, 0xb0, 0xf6, 0xc9, 0x24, 0xd0, 0x06, 0xa9, 0xff, + 0x85, 0x0d, 0xd0, 0x10, 0xc9, 0x25, 0xd0, 0x13, 0xa5, 0x10, 0xd0, 0xd0, 0xa9, 0x80, 0x85, 0x0e, + 0x05, 0x45, 0x85, 0x45, 0x8a, 0x09, 0x80, 0xaa, 0x20, 0x73, 0x00, 0x86, 0x46, 0x38, 0x05, 0x10, + 0xe9, 0x28, 0xd0, 0x03, 0x4c, 0xd1, 0xb1, 0xa0, 0x00, 0x84, 0x10, 0xa5, 0x2d, 0xa6, 0x2e, 0x86, + 0x60, 0x85, 0x5f, 0xe4, 0x30, 0xd0, 0x04, 0xc5, 0x2f, 0xf0, 0x22, 0xa5, 0x45, 0xd1, 0x5f, 0xd0, + 0x08, 0xa5, 0x46, 0xc8, 0xd1, 0x5f, 0xf0, 0x7d, 0x88, 0x18, 0xa5, 0x5f, 0x69, 0x07, 0x90, 0xe1, + 0xe8, 0xd0, 0xdc, 0xc9, 0x41, 0x90, 0x05, 0xe9, 0x5b, 0x38, 0xe9, 0xa5, 0x60, 0x68, 0x48, 0xc9, + 0x2a, 0xd0, 0x05, 0xa9, 0x13, 0xa0, 0xbf, 0x60, 0xa5, 0x45, 0xa4, 0x46, 0xc9, 0x54, 0xd0, 0x0b, + 0xc0, 0xc9, 0xf0, 0xef, 0xc0, 0x49, 0xd0, 0x03, 0x4c, 0x08, 0xaf, 0xc9, 0x53, 0xd0, 0x04, 0xc0, + 0x54, 0xf0, 0xf5, 0xa5, 0x2f, 0xa4, 0x30, 0x85, 0x5f, 0x84, 0x60, 0xa5, 0x31, 0xa4, 0x32, 0x85, + 0x5a, 0x84, 0x5b, 0x18, 0x69, 0x07, 0x90, 0x01, 0xc8, 0x85, 0x58, 0x84, 0x59, 0x20, 0xb8, 0xa3, + 0xa5, 0x58, 0xa4, 0x59, 0xc8, 0x85, 0x2f, 0x84, 0x30, 0xa0, 0x00, 0xa5, 0x45, 0x91, 0x5f, 0xc8, + 0xa5, 0x46, 0x91, 0x5f, 0xa9, 0x00, 0xc8, 0x91, 0x5f, 0xc8, 0x91, 0x5f, 0xc8, 0x91, 0x5f, 0xc8, + 0x91, 0x5f, 0xc8, 0x91, 0x5f, 0xa5, 0x5f, 0x18, 0x69, 0x02, 0xa4, 0x60, 0x90, 0x01, 0xc8, 0x85, + 0x47, 0x84, 0x48, 0x60, 0xa5, 0x0b, 0x0a, 0x69, 0x05, 0x65, 0x5f, 0xa4, 0x60, 0x90, 0x01, 0xc8, + 0x85, 0x58, 0x84, 0x59, 0x60, 0x90, 0x80, 0x00, 0x00, 0x00, 0x20, 0xbf, 0xb1, 0xa5, 0x64, 0xa4, + 0x65, 0x60, 0x20, 0x73, 0x00, 0x20, 0x9e, 0xad, 0x20, 0x8d, 0xad, 0xa5, 0x66, 0x30, 0x0d, 0xa5, + 0x61, 0xc9, 0x90, 0x90, 0x09, 0xa9, 0xa5, 0xa0, 0xb1, 0x20, 0x5b, 0xbc, 0xd0, 0x7a, 0x4c, 0x9b, + 0xbc, 0xa5, 0x0c, 0x05, 0x0e, 0x48, 0xa5, 0x0d, 0x48, 0xa0, 0x00, 0x98, 0x48, 0xa5, 0x46, 0x48, + 0xa5, 0x45, 0x48, 0x20, 0xb2, 0xb1, 0x68, 0x85, 0x45, 0x68, 0x85, 0x46, 0x68, 0xa8, 0xba, 0xbd, + 0x02, 0x01, 0x48, 0xbd, 0x01, 0x01, 0x48, 0xa5, 0x64, 0x9d, 0x02, 0x01, 0xa5, 0x65, 0x9d, 0x01, + 0x01, 0xc8, 0x20, 0x79, 0x00, 0xc9, 0x2c, 0xf0, 0xd2, 0x84, 0x0b, 0x20, 0xf7, 0xae, 0x68, 0x85, + 0x0d, 0x68, 0x85, 0x0e, 0x29, 0x7f, 0x85, 0x0c, 0xa6, 0x2f, 0xa5, 0x30, 0x86, 0x5f, 0x85, 0x60, + 0xc5, 0x32, 0xd0, 0x04, 0xe4, 0x31, 0xf0, 0x39, 0xa0, 0x00, 0xb1, 0x5f, 0xc8, 0xc5, 0x45, 0xd0, + 0x06, 0xa5, 0x46, 0xd1, 0x5f, 0xf0, 0x16, 0xc8, 0xb1, 0x5f, 0x18, 0x65, 0x5f, 0xaa, 0xc8, 0xb1, + 0x5f, 0x65, 0x60, 0x90, 0xd7, 0xa2, 0x12, 0x2c, 0xa2, 0x0e, 0x4c, 0x37, 0xa4, 0xa2, 0x13, 0xa5, + 0x0c, 0xd0, 0xf7, 0x20, 0x94, 0xb1, 0xa5, 0x0b, 0xa0, 0x04, 0xd1, 0x5f, 0xd0, 0xe7, 0x4c, 0xea, + 0xb2, 0x20, 0x94, 0xb1, 0x20, 0x08, 0xa4, 0xa0, 0x00, 0x84, 0x72, 0xa2, 0x05, 0xa5, 0x45, 0x91, + 0x5f, 0x10, 0x01, 0xca, 0xc8, 0xa5, 0x46, 0x91, 0x5f, 0x10, 0x02, 0xca, 0xca, 0x86, 0x71, 0xa5, + 0x0b, 0xc8, 0xc8, 0xc8, 0x91, 0x5f, 0xa2, 0x0b, 0xa9, 0x00, 0x24, 0x0c, 0x50, 0x08, 0x68, 0x18, + 0x69, 0x01, 0xaa, 0x68, 0x69, 0x00, 0xc8, 0x91, 0x5f, 0xc8, 0x8a, 0x91, 0x5f, 0x20, 0x4c, 0xb3, + 0x86, 0x71, 0x85, 0x72, 0xa4, 0x22, 0xc6, 0x0b, 0xd0, 0xdc, 0x65, 0x59, 0xb0, 0x5d, 0x85, 0x59, + 0xa8, 0x8a, 0x65, 0x58, 0x90, 0x03, 0xc8, 0xf0, 0x52, 0x20, 0x08, 0xa4, 0x85, 0x31, 0x84, 0x32, + 0xa9, 0x00, 0xe6, 0x72, 0xa4, 0x71, 0xf0, 0x05, 0x88, 0x91, 0x58, 0xd0, 0xfb, 0xc6, 0x59, 0xc6, + 0x72, 0xd0, 0xf5, 0xe6, 0x59, 0x38, 0xa5, 0x31, 0xe5, 0x5f, 0xa0, 0x02, 0x91, 0x5f, 0xa5, 0x32, + 0xc8, 0xe5, 0x60, 0x91, 0x5f, 0xa5, 0x0c, 0xd0, 0x62, 0xc8, 0xb1, 0x5f, 0x85, 0x0b, 0xa9, 0x00, + 0x85, 0x71, 0x85, 0x72, 0xc8, 0x68, 0xaa, 0x85, 0x64, 0x68, 0x85, 0x65, 0xd1, 0x5f, 0x90, 0x0e, + 0xd0, 0x06, 0xc8, 0x8a, 0xd1, 0x5f, 0x90, 0x07, 0x4c, 0x45, 0xb2, 0x4c, 0x35, 0xa4, 0xc8, 0xa5, + 0x72, 0x05, 0x71, 0x18, 0xf0, 0x0a, 0x20, 0x4c, 0xb3, 0x8a, 0x65, 0x64, 0xaa, 0x98, 0xa4, 0x22, + 0x65, 0x65, 0x86, 0x71, 0xc6, 0x0b, 0xd0, 0xca, 0x85, 0x72, 0xa2, 0x05, 0xa5, 0x45, 0x10, 0x01, + 0xca, 0xa5, 0x46, 0x10, 0x02, 0xca, 0xca, 0x86, 0x28, 0xa9, 0x00, 0x20, 0x55, 0xb3, 0x8a, 0x65, + 0x58, 0x85, 0x47, 0x98, 0x65, 0x59, 0x85, 0x48, 0xa8, 0xa5, 0x47, 0x60, 0x84, 0x22, 0xb1, 0x5f, + 0x85, 0x28, 0x88, 0xb1, 0x5f, 0x85, 0x29, 0xa9, 0x10, 0x85, 0x5d, 0xa2, 0x00, 0xa0, 0x00, 0x8a, + 0x0a, 0xaa, 0x98, 0x2a, 0xa8, 0xb0, 0xa4, 0x06, 0x71, 0x26, 0x72, 0x90, 0x0b, 0x18, 0x8a, 0x65, + 0x28, 0xaa, 0x98, 0x65, 0x29, 0xa8, 0xb0, 0x93, 0xc6, 0x5d, 0xd0, 0xe3, 0x60, 0xa5, 0x0d, 0xf0, + 0x03, 0x20, 0xa6, 0xb6, 0x20, 0x26, 0xb5, 0x38, 0xa5, 0x33, 0xe5, 0x31, 0xa8, 0xa5, 0x34, 0xe5, + 0x32, 0xa2, 0x00, 0x86, 0x0d, 0x85, 0x62, 0x84, 0x63, 0xa2, 0x90, 0x4c, 0x44, 0xbc, 0x38, 0x20, + 0xf0, 0xff, 0xa9, 0x00, 0xf0, 0xeb, 0xa6, 0x3a, 0xe8, 0xd0, 0xa0, 0xa2, 0x15, 0x2c, 0xa2, 0x1b, + 0x4c, 0x37, 0xa4, 0x20, 0xe1, 0xb3, 0x20, 0xa6, 0xb3, 0x20, 0xfa, 0xae, 0xa9, 0x80, 0x85, 0x10, + 0x20, 0x8b, 0xb0, 0x20, 0x8d, 0xad, 0x20, 0xf7, 0xae, 0xa9, 0xb2, 0x20, 0xff, 0xae, 0x48, 0xa5, + 0x48, 0x48, 0xa5, 0x47, 0x48, 0xa5, 0x7b, 0x48, 0xa5, 0x7a, 0x48, 0x20, 0xf8, 0xa8, 0x4c, 0x4f, + 0xb4, 0xa9, 0xa5, 0x20, 0xff, 0xae, 0x09, 0x80, 0x85, 0x10, 0x20, 0x92, 0xb0, 0x85, 0x4e, 0x84, + 0x4f, 0x4c, 0x8d, 0xad, 0x20, 0xe1, 0xb3, 0xa5, 0x4f, 0x48, 0xa5, 0x4e, 0x48, 0x20, 0xf1, 0xae, + 0x20, 0x8d, 0xad, 0x68, 0x85, 0x4e, 0x68, 0x85, 0x4f, 0xa0, 0x02, 0xb1, 0x4e, 0x85, 0x47, 0xaa, + 0xc8, 0xb1, 0x4e, 0xf0, 0x99, 0x85, 0x48, 0xc8, 0xb1, 0x47, 0x48, 0x88, 0x10, 0xfa, 0xa4, 0x48, + 0x20, 0xd4, 0xbb, 0xa5, 0x7b, 0x48, 0xa5, 0x7a, 0x48, 0xb1, 0x4e, 0x85, 0x7a, 0xc8, 0xb1, 0x4e, + 0x85, 0x7b, 0xa5, 0x48, 0x48, 0xa5, 0x47, 0x48, 0x20, 0x8a, 0xad, 0x68, 0x85, 0x4e, 0x68, 0x85, + 0x4f, 0x20, 0x79, 0x00, 0xf0, 0x03, 0x4c, 0x08, 0xaf, 0x68, 0x85, 0x7a, 0x68, 0x85, 0x7b, 0xa0, + 0x00, 0x68, 0x91, 0x4e, 0x68, 0xc8, 0x91, 0x4e, 0x68, 0xc8, 0x91, 0x4e, 0x68, 0xc8, 0x91, 0x4e, + 0x68, 0xc8, 0x91, 0x4e, 0x60, 0x20, 0x8d, 0xad, 0xa0, 0x00, 0x20, 0xdf, 0xbd, 0x68, 0x68, 0xa9, + 0xff, 0xa0, 0x00, 0xf0, 0x12, 0xa6, 0x64, 0xa4, 0x65, 0x86, 0x50, 0x84, 0x51, 0x20, 0xf4, 0xb4, + 0x86, 0x62, 0x84, 0x63, 0x85, 0x61, 0x60, 0xa2, 0x22, 0x86, 0x07, 0x86, 0x08, 0x85, 0x6f, 0x84, + 0x70, 0x85, 0x62, 0x84, 0x63, 0xa0, 0xff, 0xc8, 0xb1, 0x6f, 0xf0, 0x0c, 0xc5, 0x07, 0xf0, 0x04, + 0xc5, 0x08, 0xd0, 0xf3, 0xc9, 0x22, 0xf0, 0x01, 0x18, 0x84, 0x61, 0x98, 0x65, 0x6f, 0x85, 0x71, + 0xa6, 0x70, 0x90, 0x01, 0xe8, 0x86, 0x72, 0xa5, 0x70, 0xf0, 0x04, 0xc9, 0x02, 0xd0, 0x0b, 0x98, + 0x20, 0x75, 0xb4, 0xa6, 0x6f, 0xa4, 0x70, 0x20, 0x88, 0xb6, 0xa6, 0x16, 0xe0, 0x22, 0xd0, 0x05, + 0xa2, 0x19, 0x4c, 0x37, 0xa4, 0xa5, 0x61, 0x95, 0x00, 0xa5, 0x62, 0x95, 0x01, 0xa5, 0x63, 0x95, + 0x02, 0xa0, 0x00, 0x86, 0x64, 0x84, 0x65, 0x84, 0x70, 0x88, 0x84, 0x0d, 0x86, 0x17, 0xe8, 0xe8, + 0xe8, 0x86, 0x16, 0x60, 0x46, 0x0f, 0x48, 0x49, 0xff, 0x38, 0x65, 0x33, 0xa4, 0x34, 0xb0, 0x01, + 0x88, 0xc4, 0x32, 0x90, 0x11, 0xd0, 0x04, 0xc5, 0x31, 0x90, 0x0b, 0x85, 0x33, 0x84, 0x34, 0x85, + 0x35, 0x84, 0x36, 0xaa, 0x68, 0x60, 0xa2, 0x10, 0xa5, 0x0f, 0x30, 0xb6, 0x20, 0x26, 0xb5, 0xa9, + 0x80, 0x85, 0x0f, 0x68, 0xd0, 0xd0, 0xa6, 0x37, 0xa5, 0x38, 0x86, 0x33, 0x85, 0x34, 0xa0, 0x00, + 0x84, 0x4f, 0x84, 0x4e, 0xa5, 0x31, 0xa6, 0x32, 0x85, 0x5f, 0x86, 0x60, 0xa9, 0x19, 0xa2, 0x00, + 0x85, 0x22, 0x86, 0x23, 0xc5, 0x16, 0xf0, 0x05, 0x20, 0xc7, 0xb5, 0xf0, 0xf7, 0xa9, 0x07, 0x85, + 0x53, 0xa5, 0x2d, 0xa6, 0x2e, 0x85, 0x22, 0x86, 0x23, 0xe4, 0x30, 0xd0, 0x04, 0xc5, 0x2f, 0xf0, + 0x05, 0x20, 0xbd, 0xb5, 0xf0, 0xf3, 0x85, 0x58, 0x86, 0x59, 0xa9, 0x03, 0x85, 0x53, 0xa5, 0x58, + 0xa6, 0x59, 0xe4, 0x32, 0xd0, 0x07, 0xc5, 0x31, 0xd0, 0x03, 0x4c, 0x06, 0xb6, 0x85, 0x22, 0x86, + 0x23, 0xa0, 0x00, 0xb1, 0x22, 0xaa, 0xc8, 0xb1, 0x22, 0x08, 0xc8, 0xb1, 0x22, 0x65, 0x58, 0x85, + 0x58, 0xc8, 0xb1, 0x22, 0x65, 0x59, 0x85, 0x59, 0x28, 0x10, 0xd3, 0x8a, 0x30, 0xd0, 0xc8, 0xb1, + 0x22, 0xa0, 0x00, 0x0a, 0x69, 0x05, 0x65, 0x22, 0x85, 0x22, 0x90, 0x02, 0xe6, 0x23, 0xa6, 0x23, + 0xe4, 0x59, 0xd0, 0x04, 0xc5, 0x58, 0xf0, 0xba, 0x20, 0xc7, 0xb5, 0xf0, 0xf3, 0xb1, 0x22, 0x30, + 0x35, 0xc8, 0xb1, 0x22, 0x10, 0x30, 0xc8, 0xb1, 0x22, 0xf0, 0x2b, 0xc8, 0xb1, 0x22, 0xaa, 0xc8, + 0xb1, 0x22, 0xc5, 0x34, 0x90, 0x06, 0xd0, 0x1e, 0xe4, 0x33, 0xb0, 0x1a, 0xc5, 0x60, 0x90, 0x16, + 0xd0, 0x04, 0xe4, 0x5f, 0x90, 0x10, 0x86, 0x5f, 0x85, 0x60, 0xa5, 0x22, 0xa6, 0x23, 0x85, 0x4e, + 0x86, 0x4f, 0xa5, 0x53, 0x85, 0x55, 0xa5, 0x53, 0x18, 0x65, 0x22, 0x85, 0x22, 0x90, 0x02, 0xe6, + 0x23, 0xa6, 0x23, 0xa0, 0x00, 0x60, 0xa5, 0x4f, 0x05, 0x4e, 0xf0, 0xf5, 0xa5, 0x55, 0x29, 0x04, + 0x4a, 0xa8, 0x85, 0x55, 0xb1, 0x4e, 0x65, 0x5f, 0x85, 0x5a, 0xa5, 0x60, 0x69, 0x00, 0x85, 0x5b, + 0xa5, 0x33, 0xa6, 0x34, 0x85, 0x58, 0x86, 0x59, 0x20, 0xbf, 0xa3, 0xa4, 0x55, 0xc8, 0xa5, 0x58, + 0x91, 0x4e, 0xaa, 0xe6, 0x59, 0xa5, 0x59, 0xc8, 0x91, 0x4e, 0x4c, 0x2a, 0xb5, 0xa5, 0x65, 0x48, + 0xa5, 0x64, 0x48, 0x20, 0x83, 0xae, 0x20, 0x8f, 0xad, 0x68, 0x85, 0x6f, 0x68, 0x85, 0x70, 0xa0, + 0x00, 0xb1, 0x6f, 0x18, 0x71, 0x64, 0x90, 0x05, 0xa2, 0x17, 0x4c, 0x37, 0xa4, 0x20, 0x75, 0xb4, + 0x20, 0x7a, 0xb6, 0xa5, 0x50, 0xa4, 0x51, 0x20, 0xaa, 0xb6, 0x20, 0x8c, 0xb6, 0xa5, 0x6f, 0xa4, + 0x70, 0x20, 0xaa, 0xb6, 0x20, 0xca, 0xb4, 0x4c, 0xb8, 0xad, 0xa0, 0x00, 0xb1, 0x6f, 0x48, 0xc8, + 0xb1, 0x6f, 0xaa, 0xc8, 0xb1, 0x6f, 0xa8, 0x68, 0x86, 0x22, 0x84, 0x23, 0xa8, 0xf0, 0x0a, 0x48, + 0x88, 0xb1, 0x22, 0x91, 0x35, 0x98, 0xd0, 0xf8, 0x68, 0x18, 0x65, 0x35, 0x85, 0x35, 0x90, 0x02, + 0xe6, 0x36, 0x60, 0x20, 0x8f, 0xad, 0xa5, 0x64, 0xa4, 0x65, 0x85, 0x22, 0x84, 0x23, 0x20, 0xdb, + 0xb6, 0x08, 0xa0, 0x00, 0xb1, 0x22, 0x48, 0xc8, 0xb1, 0x22, 0xaa, 0xc8, 0xb1, 0x22, 0xa8, 0x68, + 0x28, 0xd0, 0x13, 0xc4, 0x34, 0xd0, 0x0f, 0xe4, 0x33, 0xd0, 0x0b, 0x48, 0x18, 0x65, 0x33, 0x85, + 0x33, 0x90, 0x02, 0xe6, 0x34, 0x68, 0x86, 0x22, 0x84, 0x23, 0x60, 0xc4, 0x18, 0xd0, 0x0c, 0xc5, + 0x17, 0xd0, 0x08, 0x85, 0x16, 0xe9, 0x03, 0x85, 0x17, 0xa0, 0x00, 0x60, 0x20, 0xa1, 0xb7, 0x8a, + 0x48, 0xa9, 0x01, 0x20, 0x7d, 0xb4, 0x68, 0xa0, 0x00, 0x91, 0x62, 0x68, 0x68, 0x4c, 0xca, 0xb4, + 0x20, 0x61, 0xb7, 0xd1, 0x50, 0x98, 0x90, 0x04, 0xb1, 0x50, 0xaa, 0x98, 0x48, 0x8a, 0x48, 0x20, + 0x7d, 0xb4, 0xa5, 0x50, 0xa4, 0x51, 0x20, 0xaa, 0xb6, 0x68, 0xa8, 0x68, 0x18, 0x65, 0x22, 0x85, + 0x22, 0x90, 0x02, 0xe6, 0x23, 0x98, 0x20, 0x8c, 0xb6, 0x4c, 0xca, 0xb4, 0x20, 0x61, 0xb7, 0x18, + 0xf1, 0x50, 0x49, 0xff, 0x4c, 0x06, 0xb7, 0xa9, 0xff, 0x85, 0x65, 0x20, 0x79, 0x00, 0xc9, 0x29, + 0xf0, 0x06, 0x20, 0xfd, 0xae, 0x20, 0x9e, 0xb7, 0x20, 0x61, 0xb7, 0xf0, 0x4b, 0xca, 0x8a, 0x48, + 0x18, 0xa2, 0x00, 0xf1, 0x50, 0xb0, 0xb6, 0x49, 0xff, 0xc5, 0x65, 0x90, 0xb1, 0xa5, 0x65, 0xb0, + 0xad, 0x20, 0xf7, 0xae, 0x68, 0xa8, 0x68, 0x85, 0x55, 0x68, 0x68, 0x68, 0xaa, 0x68, 0x85, 0x50, + 0x68, 0x85, 0x51, 0xa5, 0x55, 0x48, 0x98, 0x48, 0xa0, 0x00, 0x8a, 0x60, 0x20, 0x82, 0xb7, 0x4c, + 0xa2, 0xb3, 0x20, 0xa3, 0xb6, 0xa2, 0x00, 0x86, 0x0d, 0xa8, 0x60, 0x20, 0x82, 0xb7, 0xf0, 0x08, + 0xa0, 0x00, 0xb1, 0x22, 0xa8, 0x4c, 0xa2, 0xb3, 0x4c, 0x48, 0xb2, 0x20, 0x73, 0x00, 0x20, 0x8a, + 0xad, 0x20, 0xb8, 0xb1, 0xa6, 0x64, 0xd0, 0xf0, 0xa6, 0x65, 0x4c, 0x79, 0x00, 0x20, 0x82, 0xb7, + 0xd0, 0x03, 0x4c, 0xf7, 0xb8, 0xa6, 0x7a, 0xa4, 0x7b, 0x86, 0x71, 0x84, 0x72, 0xa6, 0x22, 0x86, + 0x7a, 0x18, 0x65, 0x22, 0x85, 0x24, 0xa6, 0x23, 0x86, 0x7b, 0x90, 0x01, 0xe8, 0x86, 0x25, 0xa0, + 0x00, 0xb1, 0x24, 0x48, 0x98, 0x91, 0x24, 0x20, 0x79, 0x00, 0x20, 0xf3, 0xbc, 0x68, 0xa0, 0x00, + 0x91, 0x24, 0xa6, 0x71, 0xa4, 0x72, 0x86, 0x7a, 0x84, 0x7b, 0x60, 0x20, 0x8a, 0xad, 0x20, 0xf7, + 0xb7, 0x20, 0xfd, 0xae, 0x4c, 0x9e, 0xb7, 0xa5, 0x66, 0x30, 0x9d, 0xa5, 0x61, 0xc9, 0x91, 0xb0, + 0x97, 0x20, 0x9b, 0xbc, 0xa5, 0x64, 0xa4, 0x65, 0x84, 0x14, 0x85, 0x15, 0x60, 0xa5, 0x15, 0x48, + 0xa5, 0x14, 0x48, 0x20, 0xf7, 0xb7, 0xa0, 0x00, 0xb1, 0x14, 0xa8, 0x68, 0x85, 0x14, 0x68, 0x85, + 0x15, 0x4c, 0xa2, 0xb3, 0x20, 0xeb, 0xb7, 0x8a, 0xa0, 0x00, 0x91, 0x14, 0x60, 0x20, 0xeb, 0xb7, + 0x86, 0x49, 0xa2, 0x00, 0x20, 0x79, 0x00, 0xf0, 0x03, 0x20, 0xf1, 0xb7, 0x86, 0x4a, 0xa0, 0x00, + 0xb1, 0x14, 0x45, 0x4a, 0x25, 0x49, 0xf0, 0xf8, 0x60, 0xa9, 0x11, 0xa0, 0xbf, 0x4c, 0x67, 0xb8, + 0x20, 0x8c, 0xba, 0xa5, 0x66, 0x49, 0xff, 0x85, 0x66, 0x45, 0x6e, 0x85, 0x6f, 0xa5, 0x61, 0x4c, + 0x6a, 0xb8, 0x20, 0x99, 0xb9, 0x90, 0x3c, 0x20, 0x8c, 0xba, 0xd0, 0x03, 0x4c, 0xfc, 0xbb, 0xa6, + 0x70, 0x86, 0x56, 0xa2, 0x69, 0xa5, 0x69, 0xa8, 0xf0, 0xce, 0x38, 0xe5, 0x61, 0xf0, 0x24, 0x90, + 0x12, 0x84, 0x61, 0xa4, 0x6e, 0x84, 0x66, 0x49, 0xff, 0x69, 0x00, 0xa0, 0x00, 0x84, 0x56, 0xa2, + 0x61, 0xd0, 0x04, 0xa0, 0x00, 0x84, 0x70, 0xc9, 0xf9, 0x30, 0xc7, 0xa8, 0xa5, 0x70, 0x56, 0x01, + 0x20, 0xb0, 0xb9, 0x24, 0x6f, 0x10, 0x57, 0xa0, 0x61, 0xe0, 0x69, 0xf0, 0x02, 0xa0, 0x69, 0x38, + 0x49, 0xff, 0x65, 0x56, 0x85, 0x70, 0xb9, 0x04, 0x00, 0xf5, 0x04, 0x85, 0x65, 0xb9, 0x03, 0x00, + 0xf5, 0x03, 0x85, 0x64, 0xb9, 0x02, 0x00, 0xf5, 0x02, 0x85, 0x63, 0xb9, 0x01, 0x00, 0xf5, 0x01, + 0x85, 0x62, 0xb0, 0x03, 0x20, 0x47, 0xb9, 0xa0, 0x00, 0x98, 0x18, 0xa6, 0x62, 0xd0, 0x4a, 0xa6, + 0x63, 0x86, 0x62, 0xa6, 0x64, 0x86, 0x63, 0xa6, 0x65, 0x86, 0x64, 0xa6, 0x70, 0x86, 0x65, 0x84, + 0x70, 0x69, 0x08, 0xc9, 0x20, 0xd0, 0xe4, 0xa9, 0x00, 0x85, 0x61, 0x85, 0x66, 0x60, 0x65, 0x56, + 0x85, 0x70, 0xa5, 0x65, 0x65, 0x6d, 0x85, 0x65, 0xa5, 0x64, 0x65, 0x6c, 0x85, 0x64, 0xa5, 0x63, + 0x65, 0x6b, 0x85, 0x63, 0xa5, 0x62, 0x65, 0x6a, 0x85, 0x62, 0x4c, 0x36, 0xb9, 0x69, 0x01, 0x06, + 0x70, 0x26, 0x65, 0x26, 0x64, 0x26, 0x63, 0x26, 0x62, 0x10, 0xf2, 0x38, 0xe5, 0x61, 0xb0, 0xc7, + 0x49, 0xff, 0x69, 0x01, 0x85, 0x61, 0x90, 0x0e, 0xe6, 0x61, 0xf0, 0x42, 0x66, 0x62, 0x66, 0x63, + 0x66, 0x64, 0x66, 0x65, 0x66, 0x70, 0x60, 0xa5, 0x66, 0x49, 0xff, 0x85, 0x66, 0xa5, 0x62, 0x49, + 0xff, 0x85, 0x62, 0xa5, 0x63, 0x49, 0xff, 0x85, 0x63, 0xa5, 0x64, 0x49, 0xff, 0x85, 0x64, 0xa5, + 0x65, 0x49, 0xff, 0x85, 0x65, 0xa5, 0x70, 0x49, 0xff, 0x85, 0x70, 0xe6, 0x70, 0xd0, 0x0e, 0xe6, + 0x65, 0xd0, 0x0a, 0xe6, 0x64, 0xd0, 0x06, 0xe6, 0x63, 0xd0, 0x02, 0xe6, 0x62, 0x60, 0xa2, 0x0f, + 0x4c, 0x37, 0xa4, 0xa2, 0x25, 0xb4, 0x04, 0x84, 0x70, 0xb4, 0x03, 0x94, 0x04, 0xb4, 0x02, 0x94, + 0x03, 0xb4, 0x01, 0x94, 0x02, 0xa4, 0x68, 0x94, 0x01, 0x69, 0x08, 0x30, 0xe8, 0xf0, 0xe6, 0xe9, + 0x08, 0xa8, 0xa5, 0x70, 0xb0, 0x14, 0x16, 0x01, 0x90, 0x02, 0xf6, 0x01, 0x76, 0x01, 0x76, 0x01, + 0x76, 0x02, 0x76, 0x03, 0x76, 0x04, 0x6a, 0xc8, 0xd0, 0xec, 0x18, 0x60, 0x81, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x7f, 0x5e, 0x56, 0xcb, 0x79, 0x80, 0x13, 0x9b, 0x0b, 0x64, 0x80, 0x76, 0x38, 0x93, + 0x16, 0x82, 0x38, 0xaa, 0x3b, 0x20, 0x80, 0x35, 0x04, 0xf3, 0x34, 0x81, 0x35, 0x04, 0xf3, 0x34, + 0x80, 0x80, 0x00, 0x00, 0x00, 0x80, 0x31, 0x72, 0x17, 0xf8, 0x20, 0x2b, 0xbc, 0xf0, 0x02, 0x10, + 0x03, 0x4c, 0x48, 0xb2, 0xa5, 0x61, 0xe9, 0x7f, 0x48, 0xa9, 0x80, 0x85, 0x61, 0xa9, 0xd6, 0xa0, + 0xb9, 0x20, 0x67, 0xb8, 0xa9, 0xdb, 0xa0, 0xb9, 0x20, 0x0f, 0xbb, 0xa9, 0xbc, 0xa0, 0xb9, 0x20, + 0x50, 0xb8, 0xa9, 0xc1, 0xa0, 0xb9, 0x20, 0x43, 0xe0, 0xa9, 0xe0, 0xa0, 0xb9, 0x20, 0x67, 0xb8, + 0x68, 0x20, 0x7e, 0xbd, 0xa9, 0xe5, 0xa0, 0xb9, 0x20, 0x8c, 0xba, 0xd0, 0x03, 0x4c, 0x8b, 0xba, + 0x20, 0xb7, 0xba, 0xa9, 0x00, 0x85, 0x26, 0x85, 0x27, 0x85, 0x28, 0x85, 0x29, 0xa5, 0x70, 0x20, + 0x59, 0xba, 0xa5, 0x65, 0x20, 0x59, 0xba, 0xa5, 0x64, 0x20, 0x59, 0xba, 0xa5, 0x63, 0x20, 0x59, + 0xba, 0xa5, 0x62, 0x20, 0x5e, 0xba, 0x4c, 0x8f, 0xbb, 0xd0, 0x03, 0x4c, 0x83, 0xb9, 0x4a, 0x09, + 0x80, 0xa8, 0x90, 0x19, 0x18, 0xa5, 0x29, 0x65, 0x6d, 0x85, 0x29, 0xa5, 0x28, 0x65, 0x6c, 0x85, + 0x28, 0xa5, 0x27, 0x65, 0x6b, 0x85, 0x27, 0xa5, 0x26, 0x65, 0x6a, 0x85, 0x26, 0x66, 0x26, 0x66, + 0x27, 0x66, 0x28, 0x66, 0x29, 0x66, 0x70, 0x98, 0x4a, 0xd0, 0xd6, 0x60, 0x85, 0x22, 0x84, 0x23, + 0xa0, 0x04, 0xb1, 0x22, 0x85, 0x6d, 0x88, 0xb1, 0x22, 0x85, 0x6c, 0x88, 0xb1, 0x22, 0x85, 0x6b, + 0x88, 0xb1, 0x22, 0x85, 0x6e, 0x45, 0x66, 0x85, 0x6f, 0xa5, 0x6e, 0x09, 0x80, 0x85, 0x6a, 0x88, + 0xb1, 0x22, 0x85, 0x69, 0xa5, 0x61, 0x60, 0xa5, 0x69, 0xf0, 0x1f, 0x18, 0x65, 0x61, 0x90, 0x04, + 0x30, 0x1d, 0x18, 0x2c, 0x10, 0x14, 0x69, 0x80, 0x85, 0x61, 0xd0, 0x03, 0x4c, 0xfb, 0xb8, 0xa5, + 0x6f, 0x85, 0x66, 0x60, 0xa5, 0x66, 0x49, 0xff, 0x30, 0x05, 0x68, 0x68, 0x4c, 0xf7, 0xb8, 0x4c, + 0x7e, 0xb9, 0x20, 0x0c, 0xbc, 0xaa, 0xf0, 0x10, 0x18, 0x69, 0x02, 0xb0, 0xf2, 0xa2, 0x00, 0x86, + 0x6f, 0x20, 0x77, 0xb8, 0xe6, 0x61, 0xf0, 0xe7, 0x60, 0x84, 0x20, 0x00, 0x00, 0x00, 0x20, 0x0c, + 0xbc, 0xa9, 0xf9, 0xa0, 0xba, 0xa2, 0x00, 0x86, 0x6f, 0x20, 0xa2, 0xbb, 0x4c, 0x12, 0xbb, 0x20, + 0x8c, 0xba, 0xf0, 0x76, 0x20, 0x1b, 0xbc, 0xa9, 0x00, 0x38, 0xe5, 0x61, 0x85, 0x61, 0x20, 0xb7, + 0xba, 0xe6, 0x61, 0xf0, 0xba, 0xa2, 0xfc, 0xa9, 0x01, 0xa4, 0x6a, 0xc4, 0x62, 0xd0, 0x10, 0xa4, + 0x6b, 0xc4, 0x63, 0xd0, 0x0a, 0xa4, 0x6c, 0xc4, 0x64, 0xd0, 0x04, 0xa4, 0x6d, 0xc4, 0x65, 0x08, + 0x2a, 0x90, 0x09, 0xe8, 0x95, 0x29, 0xf0, 0x32, 0x10, 0x34, 0xa9, 0x01, 0x28, 0xb0, 0x0e, 0x06, + 0x6d, 0x26, 0x6c, 0x26, 0x6b, 0x26, 0x6a, 0xb0, 0xe6, 0x30, 0xce, 0x10, 0xe2, 0xa8, 0xa5, 0x6d, + 0xe5, 0x65, 0x85, 0x6d, 0xa5, 0x6c, 0xe5, 0x64, 0x85, 0x6c, 0xa5, 0x6b, 0xe5, 0x63, 0x85, 0x6b, + 0xa5, 0x6a, 0xe5, 0x62, 0x85, 0x6a, 0x98, 0x4c, 0x4f, 0xbb, 0xa9, 0x40, 0xd0, 0xce, 0x0a, 0x0a, + 0x0a, 0x0a, 0x0a, 0x0a, 0x85, 0x70, 0x28, 0x4c, 0x8f, 0xbb, 0xa2, 0x14, 0x4c, 0x37, 0xa4, 0xa5, + 0x26, 0x85, 0x62, 0xa5, 0x27, 0x85, 0x63, 0xa5, 0x28, 0x85, 0x64, 0xa5, 0x29, 0x85, 0x65, 0x4c, + 0xd7, 0xb8, 0x85, 0x22, 0x84, 0x23, 0xa0, 0x04, 0xb1, 0x22, 0x85, 0x65, 0x88, 0xb1, 0x22, 0x85, + 0x64, 0x88, 0xb1, 0x22, 0x85, 0x63, 0x88, 0xb1, 0x22, 0x85, 0x66, 0x09, 0x80, 0x85, 0x62, 0x88, + 0xb1, 0x22, 0x85, 0x61, 0x84, 0x70, 0x60, 0xa2, 0x5c, 0x2c, 0xa2, 0x57, 0xa0, 0x00, 0xf0, 0x04, + 0xa6, 0x49, 0xa4, 0x4a, 0x20, 0x1b, 0xbc, 0x86, 0x22, 0x84, 0x23, 0xa0, 0x04, 0xa5, 0x65, 0x91, + 0x22, 0x88, 0xa5, 0x64, 0x91, 0x22, 0x88, 0xa5, 0x63, 0x91, 0x22, 0x88, 0xa5, 0x66, 0x09, 0x7f, + 0x25, 0x62, 0x91, 0x22, 0x88, 0xa5, 0x61, 0x91, 0x22, 0x84, 0x70, 0x60, 0xa5, 0x6e, 0x85, 0x66, + 0xa2, 0x05, 0xb5, 0x68, 0x95, 0x60, 0xca, 0xd0, 0xf9, 0x86, 0x70, 0x60, 0x20, 0x1b, 0xbc, 0xa2, + 0x06, 0xb5, 0x60, 0x95, 0x68, 0xca, 0xd0, 0xf9, 0x86, 0x70, 0x60, 0xa5, 0x61, 0xf0, 0xfb, 0x06, + 0x70, 0x90, 0xf7, 0x20, 0x6f, 0xb9, 0xd0, 0xf2, 0x4c, 0x38, 0xb9, 0xa5, 0x61, 0xf0, 0x09, 0xa5, + 0x66, 0x2a, 0xa9, 0xff, 0xb0, 0x02, 0xa9, 0x01, 0x60, 0x20, 0x2b, 0xbc, 0x85, 0x62, 0xa9, 0x00, + 0x85, 0x63, 0xa2, 0x88, 0xa5, 0x62, 0x49, 0xff, 0x2a, 0xa9, 0x00, 0x85, 0x65, 0x85, 0x64, 0x86, + 0x61, 0x85, 0x70, 0x85, 0x66, 0x4c, 0xd2, 0xb8, 0x46, 0x66, 0x60, 0x85, 0x24, 0x84, 0x25, 0xa0, + 0x00, 0xb1, 0x24, 0xc8, 0xaa, 0xf0, 0xc4, 0xb1, 0x24, 0x45, 0x66, 0x30, 0xc2, 0xe4, 0x61, 0xd0, + 0x21, 0xb1, 0x24, 0x09, 0x80, 0xc5, 0x62, 0xd0, 0x19, 0xc8, 0xb1, 0x24, 0xc5, 0x63, 0xd0, 0x12, + 0xc8, 0xb1, 0x24, 0xc5, 0x64, 0xd0, 0x0b, 0xc8, 0xa9, 0x7f, 0xc5, 0x70, 0xb1, 0x24, 0xe5, 0x65, + 0xf0, 0x28, 0xa5, 0x66, 0x90, 0x02, 0x49, 0xff, 0x4c, 0x31, 0xbc, 0xa5, 0x61, 0xf0, 0x4a, 0x38, + 0xe9, 0xa0, 0x24, 0x66, 0x10, 0x09, 0xaa, 0xa9, 0xff, 0x85, 0x68, 0x20, 0x4d, 0xb9, 0x8a, 0xa2, + 0x61, 0xc9, 0xf9, 0x10, 0x06, 0x20, 0x99, 0xb9, 0x84, 0x68, 0x60, 0xa8, 0xa5, 0x66, 0x29, 0x80, + 0x46, 0x62, 0x05, 0x62, 0x85, 0x62, 0x20, 0xb0, 0xb9, 0x84, 0x68, 0x60, 0xa5, 0x61, 0xc9, 0xa0, + 0xb0, 0x20, 0x20, 0x9b, 0xbc, 0x84, 0x70, 0xa5, 0x66, 0x84, 0x66, 0x49, 0x80, 0x2a, 0xa9, 0xa0, + 0x85, 0x61, 0xa5, 0x65, 0x85, 0x07, 0x4c, 0xd2, 0xb8, 0x85, 0x62, 0x85, 0x63, 0x85, 0x64, 0x85, + 0x65, 0xa8, 0x60, 0xa0, 0x00, 0xa2, 0x0a, 0x94, 0x5d, 0xca, 0x10, 0xfb, 0x90, 0x0f, 0xc9, 0x2d, + 0xd0, 0x04, 0x86, 0x67, 0xf0, 0x04, 0xc9, 0x2b, 0xd0, 0x05, 0x20, 0x73, 0x00, 0x90, 0x5b, 0xc9, + 0x2e, 0xf0, 0x2e, 0xc9, 0x45, 0xd0, 0x30, 0x20, 0x73, 0x00, 0x90, 0x17, 0xc9, 0xab, 0xf0, 0x0e, + 0xc9, 0x2d, 0xf0, 0x0a, 0xc9, 0xaa, 0xf0, 0x08, 0xc9, 0x2b, 0xf0, 0x04, 0xd0, 0x07, 0x66, 0x60, + 0x20, 0x73, 0x00, 0x90, 0x5c, 0x24, 0x60, 0x10, 0x0e, 0xa9, 0x00, 0x38, 0xe5, 0x5e, 0x4c, 0x49, + 0xbd, 0x66, 0x5f, 0x24, 0x5f, 0x50, 0xc3, 0xa5, 0x5e, 0x38, 0xe5, 0x5d, 0x85, 0x5e, 0xf0, 0x12, + 0x10, 0x09, 0x20, 0xfe, 0xba, 0xe6, 0x5e, 0xd0, 0xf9, 0xf0, 0x07, 0x20, 0xe2, 0xba, 0xc6, 0x5e, + 0xd0, 0xf9, 0xa5, 0x67, 0x30, 0x01, 0x60, 0x4c, 0xb4, 0xbf, 0x48, 0x24, 0x5f, 0x10, 0x02, 0xe6, + 0x5d, 0x20, 0xe2, 0xba, 0x68, 0x38, 0xe9, 0x30, 0x20, 0x7e, 0xbd, 0x4c, 0x0a, 0xbd, 0x48, 0x20, + 0x0c, 0xbc, 0x68, 0x20, 0x3c, 0xbc, 0xa5, 0x6e, 0x45, 0x66, 0x85, 0x6f, 0xa6, 0x61, 0x4c, 0x6a, + 0xb8, 0xa5, 0x5e, 0xc9, 0x0a, 0x90, 0x09, 0xa9, 0x64, 0x24, 0x60, 0x30, 0x11, 0x4c, 0x7e, 0xb9, + 0x0a, 0x0a, 0x18, 0x65, 0x5e, 0x0a, 0x18, 0xa0, 0x00, 0x71, 0x7a, 0x38, 0xe9, 0x30, 0x85, 0x5e, + 0x4c, 0x30, 0xbd, 0x9b, 0x3e, 0xbc, 0x1f, 0xfd, 0x9e, 0x6e, 0x6b, 0x27, 0xfd, 0x9e, 0x6e, 0x6b, + 0x28, 0x00, 0xa9, 0x71, 0xa0, 0xa3, 0x20, 0xda, 0xbd, 0xa5, 0x3a, 0xa6, 0x39, 0x85, 0x62, 0x86, + 0x63, 0xa2, 0x90, 0x38, 0x20, 0x49, 0xbc, 0x20, 0xdf, 0xbd, 0x4c, 0x1e, 0xab, 0xa0, 0x01, 0xa9, + 0x20, 0x24, 0x66, 0x10, 0x02, 0xa9, 0x2d, 0x99, 0xff, 0x00, 0x85, 0x66, 0x84, 0x71, 0xc8, 0xa9, + 0x30, 0xa6, 0x61, 0xd0, 0x03, 0x4c, 0x04, 0xbf, 0xa9, 0x00, 0xe0, 0x80, 0xf0, 0x02, 0xb0, 0x09, + 0xa9, 0xbd, 0xa0, 0xbd, 0x20, 0x28, 0xba, 0xa9, 0xf7, 0x85, 0x5d, 0xa9, 0xb8, 0xa0, 0xbd, 0x20, + 0x5b, 0xbc, 0xf0, 0x1e, 0x10, 0x12, 0xa9, 0xb3, 0xa0, 0xbd, 0x20, 0x5b, 0xbc, 0xf0, 0x02, 0x10, + 0x0e, 0x20, 0xe2, 0xba, 0xc6, 0x5d, 0xd0, 0xee, 0x20, 0xfe, 0xba, 0xe6, 0x5d, 0xd0, 0xdc, 0x20, + 0x49, 0xb8, 0x20, 0x9b, 0xbc, 0xa2, 0x01, 0xa5, 0x5d, 0x18, 0x69, 0x0a, 0x30, 0x09, 0xc9, 0x0b, + 0xb0, 0x06, 0x69, 0xff, 0xaa, 0xa9, 0x02, 0x38, 0xe9, 0x02, 0x85, 0x5e, 0x86, 0x5d, 0x8a, 0xf0, + 0x02, 0x10, 0x13, 0xa4, 0x71, 0xa9, 0x2e, 0xc8, 0x99, 0xff, 0x00, 0x8a, 0xf0, 0x06, 0xa9, 0x30, + 0xc8, 0x99, 0xff, 0x00, 0x84, 0x71, 0xa0, 0x00, 0xa2, 0x80, 0xa5, 0x65, 0x18, 0x79, 0x19, 0xbf, + 0x85, 0x65, 0xa5, 0x64, 0x79, 0x18, 0xbf, 0x85, 0x64, 0xa5, 0x63, 0x79, 0x17, 0xbf, 0x85, 0x63, + 0xa5, 0x62, 0x79, 0x16, 0xbf, 0x85, 0x62, 0xe8, 0xb0, 0x04, 0x10, 0xde, 0x30, 0x02, 0x30, 0xda, + 0x8a, 0x90, 0x04, 0x49, 0xff, 0x69, 0x0a, 0x69, 0x2f, 0xc8, 0xc8, 0xc8, 0xc8, 0x84, 0x47, 0xa4, + 0x71, 0xc8, 0xaa, 0x29, 0x7f, 0x99, 0xff, 0x00, 0xc6, 0x5d, 0xd0, 0x06, 0xa9, 0x2e, 0xc8, 0x99, + 0xff, 0x00, 0x84, 0x71, 0xa4, 0x47, 0x8a, 0x49, 0xff, 0x29, 0x80, 0xaa, 0xc0, 0x24, 0xf0, 0x04, + 0xc0, 0x3c, 0xd0, 0xa6, 0xa4, 0x71, 0xb9, 0xff, 0x00, 0x88, 0xc9, 0x30, 0xf0, 0xf8, 0xc9, 0x2e, + 0xf0, 0x01, 0xc8, 0xa9, 0x2b, 0xa6, 0x5e, 0xf0, 0x2e, 0x10, 0x08, 0xa9, 0x00, 0x38, 0xe5, 0x5e, + 0xaa, 0xa9, 0x2d, 0x99, 0x01, 0x01, 0xa9, 0x45, 0x99, 0x00, 0x01, 0x8a, 0xa2, 0x2f, 0x38, 0xe8, + 0xe9, 0x0a, 0xb0, 0xfb, 0x69, 0x3a, 0x99, 0x03, 0x01, 0x8a, 0x99, 0x02, 0x01, 0xa9, 0x00, 0x99, + 0x04, 0x01, 0xf0, 0x08, 0x99, 0xff, 0x00, 0xa9, 0x00, 0x99, 0x00, 0x01, 0xa9, 0x00, 0xa0, 0x01, + 0x60, 0x80, 0x00, 0x00, 0x00, 0x00, 0xfa, 0x0a, 0x1f, 0x00, 0x00, 0x98, 0x96, 0x80, 0xff, 0xf0, + 0xbd, 0xc0, 0x00, 0x01, 0x86, 0xa0, 0xff, 0xff, 0xd8, 0xf0, 0x00, 0x00, 0x03, 0xe8, 0xff, 0xff, + 0xff, 0x9c, 0x00, 0x00, 0x00, 0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x0a, 0x80, 0x00, 0x03, + 0x4b, 0xc0, 0xff, 0xff, 0x73, 0x60, 0x00, 0x00, 0x0e, 0x10, 0xff, 0xff, 0xfd, 0xa8, 0x00, 0x00, + 0x00, 0x3c, 0xec, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0x20, 0x0c, 0xbc, 0xa9, 0x11, 0xa0, 0xbf, 0x20, 0xa2, 0xbb, 0xf0, 0x70, 0xa5, 0x69, 0xd0, + 0x03, 0x4c, 0xf9, 0xb8, 0xa2, 0x4e, 0xa0, 0x00, 0x20, 0xd4, 0xbb, 0xa5, 0x6e, 0x10, 0x0f, 0x20, + 0xcc, 0xbc, 0xa9, 0x4e, 0xa0, 0x00, 0x20, 0x5b, 0xbc, 0xd0, 0x03, 0x98, 0xa4, 0x07, 0x20, 0xfe, + 0xbb, 0x98, 0x48, 0x20, 0xea, 0xb9, 0xa9, 0x4e, 0xa0, 0x00, 0x20, 0x28, 0xba, 0x20, 0xed, 0xbf, + 0x68, 0x4a, 0x90, 0x0a, 0xa5, 0x61, 0xf0, 0x06, 0xa5, 0x66, 0x49, 0xff, 0x85, 0x66, 0x60, 0x81, + 0x38, 0xaa, 0x3b, 0x29, 0x07, 0x71, 0x34, 0x58, 0x3e, 0x56, 0x74, 0x16, 0x7e, 0xb3, 0x1b, 0x77, + 0x2f, 0xee, 0xe3, 0x85, 0x7a, 0x1d, 0x84, 0x1c, 0x2a, 0x7c, 0x63, 0x59, 0x58, 0x0a, 0x7e, 0x75, + 0xfd, 0xe7, 0xc6, 0x80, 0x31, 0x72, 0x18, 0x10, 0x81, 0x00, 0x00, 0x00, 0x00, 0xa9, 0xbf, 0xa0, + 0xbf, 0x20, 0x28, 0xba, 0xa5, 0x70, 0x69, 0x50, 0x90, 0x03, 0x20, 0x23, 0xbc, 0x4c, 0x00, 0xe0, +}; + +unsigned char kernel[8192] = +{ + 0x85, 0x56, 0x20, 0x0f, 0xbc, 0xa5, 0x61, 0xc9, 0x88, 0x90, 0x03, 0x20, 0xd4, 0xba, 0x20, 0xcc, + 0xbc, 0xa5, 0x07, 0x18, 0x69, 0x81, 0xf0, 0xf3, 0x38, 0xe9, 0x01, 0x48, 0xa2, 0x05, 0xb5, 0x69, + 0xb4, 0x61, 0x95, 0x61, 0x94, 0x69, 0xca, 0x10, 0xf5, 0xa5, 0x56, 0x85, 0x70, 0x20, 0x53, 0xb8, + 0x20, 0xb4, 0xbf, 0xa9, 0xc4, 0xa0, 0xbf, 0x20, 0x59, 0xe0, 0xa9, 0x00, 0x85, 0x6f, 0x68, 0x20, + 0xb9, 0xba, 0x60, 0x85, 0x71, 0x84, 0x72, 0x20, 0xca, 0xbb, 0xa9, 0x57, 0x20, 0x28, 0xba, 0x20, + 0x5d, 0xe0, 0xa9, 0x57, 0xa0, 0x00, 0x4c, 0x28, 0xba, 0x85, 0x71, 0x84, 0x72, 0x20, 0xc7, 0xbb, + 0xb1, 0x71, 0x85, 0x67, 0xa4, 0x71, 0xc8, 0x98, 0xd0, 0x02, 0xe6, 0x72, 0x85, 0x71, 0xa4, 0x72, + 0x20, 0x28, 0xba, 0xa5, 0x71, 0xa4, 0x72, 0x18, 0x69, 0x05, 0x90, 0x01, 0xc8, 0x85, 0x71, 0x84, + 0x72, 0x20, 0x67, 0xb8, 0xa9, 0x5c, 0xa0, 0x00, 0xc6, 0x67, 0xd0, 0xe4, 0x60, 0x98, 0x35, 0x44, + 0x7a, 0x00, 0x68, 0x28, 0xb1, 0x46, 0x00, 0x20, 0x2b, 0xbc, 0x30, 0x37, 0xd0, 0x20, 0x20, 0xf3, + 0xff, 0x86, 0x22, 0x84, 0x23, 0xa0, 0x04, 0xb1, 0x22, 0x85, 0x62, 0xc8, 0xb1, 0x22, 0x85, 0x64, + 0xa0, 0x08, 0xb1, 0x22, 0x85, 0x63, 0xc8, 0xb1, 0x22, 0x85, 0x65, 0x4c, 0xe3, 0xe0, 0xa9, 0x8b, + 0xa0, 0x00, 0x20, 0xa2, 0xbb, 0xa9, 0x8d, 0xa0, 0xe0, 0x20, 0x28, 0xba, 0xa9, 0x92, 0xa0, 0xe0, + 0x20, 0x67, 0xb8, 0xa6, 0x65, 0xa5, 0x62, 0x85, 0x65, 0x86, 0x62, 0xa6, 0x63, 0xa5, 0x64, 0x85, + 0x63, 0x86, 0x64, 0xa9, 0x00, 0x85, 0x66, 0xa5, 0x61, 0x85, 0x70, 0xa9, 0x80, 0x85, 0x61, 0x20, + 0xd7, 0xb8, 0xa2, 0x8b, 0xa0, 0x00, 0x4c, 0xd4, 0xbb, 0xc9, 0xf0, 0xd0, 0x07, 0x84, 0x38, 0x86, + 0x37, 0x4c, 0x63, 0xa6, 0xaa, 0xd0, 0x02, 0xa2, 0x1e, 0x4c, 0x37, 0xa4, 0x20, 0xd2, 0xff, 0xb0, + 0xe8, 0x60, 0x20, 0xcf, 0xff, 0xb0, 0xe2, 0x60, 0x20, 0xad, 0xe4, 0xb0, 0xdc, 0x60, 0x20, 0xc6, + 0xff, 0xb0, 0xd6, 0x60, 0x20, 0xe4, 0xff, 0xb0, 0xd0, 0x60, 0x20, 0x8a, 0xad, 0x20, 0xf7, 0xb7, + 0xa9, 0xe1, 0x48, 0xa9, 0x46, 0x48, 0xad, 0x0f, 0x03, 0x48, 0xad, 0x0c, 0x03, 0xae, 0x0d, 0x03, + 0xac, 0x0e, 0x03, 0x28, 0x6c, 0x14, 0x00, 0x08, 0x8d, 0x0c, 0x03, 0x8e, 0x0d, 0x03, 0x8c, 0x0e, + 0x03, 0x68, 0x8d, 0x0f, 0x03, 0x60, 0x20, 0xd4, 0xe1, 0xa6, 0x2d, 0xa4, 0x2e, 0xa9, 0x2b, 0x20, + 0xd8, 0xff, 0xb0, 0x95, 0x60, 0xa9, 0x01, 0x2c, 0xa9, 0x00, 0x85, 0x0a, 0x20, 0xd4, 0xe1, 0xa5, + 0x0a, 0xa6, 0x2b, 0xa4, 0x2c, 0x20, 0xd5, 0xff, 0xb0, 0x57, 0xa5, 0x0a, 0xf0, 0x17, 0xa2, 0x1c, + 0x20, 0xb7, 0xff, 0x29, 0x10, 0xd0, 0x17, 0xa5, 0x7a, 0xc9, 0x02, 0xf0, 0x07, 0xa9, 0x64, 0xa0, + 0xa3, 0x4c, 0x1e, 0xab, 0x60, 0x20, 0xb7, 0xff, 0x29, 0xbf, 0xf0, 0x05, 0xa2, 0x1d, 0x4c, 0x37, + 0xa4, 0xa5, 0x7b, 0xc9, 0x02, 0xd0, 0x0e, 0x86, 0x2d, 0x84, 0x2e, 0xa9, 0x76, 0xa0, 0xa3, 0x20, + 0x1e, 0xab, 0x4c, 0x2a, 0xa5, 0x20, 0x8e, 0xa6, 0x20, 0x33, 0xa5, 0x4c, 0x77, 0xa6, 0x20, 0x19, + 0xe2, 0x20, 0xc0, 0xff, 0xb0, 0x0b, 0x60, 0x20, 0x19, 0xe2, 0xa5, 0x49, 0x20, 0xc3, 0xff, 0x90, + 0xc3, 0x4c, 0xf9, 0xe0, 0xa9, 0x00, 0x20, 0xbd, 0xff, 0xa2, 0x01, 0xa0, 0x00, 0x20, 0xba, 0xff, + 0x20, 0x06, 0xe2, 0x20, 0x57, 0xe2, 0x20, 0x06, 0xe2, 0x20, 0x00, 0xe2, 0xa0, 0x00, 0x86, 0x49, + 0x20, 0xba, 0xff, 0x20, 0x06, 0xe2, 0x20, 0x00, 0xe2, 0x8a, 0xa8, 0xa6, 0x49, 0x4c, 0xba, 0xff, + 0x20, 0x0e, 0xe2, 0x4c, 0x9e, 0xb7, 0x20, 0x79, 0x00, 0xd0, 0x02, 0x68, 0x68, 0x60, 0x20, 0xfd, + 0xae, 0x20, 0x79, 0x00, 0xd0, 0xf7, 0x4c, 0x08, 0xaf, 0xa9, 0x00, 0x20, 0xbd, 0xff, 0x20, 0x11, + 0xe2, 0x20, 0x9e, 0xb7, 0x86, 0x49, 0x8a, 0xa2, 0x01, 0xa0, 0x00, 0x20, 0xba, 0xff, 0x20, 0x06, + 0xe2, 0x20, 0x00, 0xe2, 0x86, 0x4a, 0xa0, 0x00, 0xa5, 0x49, 0xe0, 0x03, 0x90, 0x01, 0x88, 0x20, + 0xba, 0xff, 0x20, 0x06, 0xe2, 0x20, 0x00, 0xe2, 0x8a, 0xa8, 0xa6, 0x4a, 0xa5, 0x49, 0x20, 0xba, + 0xff, 0x20, 0x06, 0xe2, 0x20, 0x0e, 0xe2, 0x20, 0x9e, 0xad, 0x20, 0xa3, 0xb6, 0xa6, 0x22, 0xa4, + 0x23, 0x4c, 0xbd, 0xff, 0xa9, 0xe0, 0xa0, 0xe2, 0x20, 0x67, 0xb8, 0x20, 0x0c, 0xbc, 0xa9, 0xe5, + 0xa0, 0xe2, 0xa6, 0x6e, 0x20, 0x07, 0xbb, 0x20, 0x0c, 0xbc, 0x20, 0xcc, 0xbc, 0xa9, 0x00, 0x85, + 0x6f, 0x20, 0x53, 0xb8, 0xa9, 0xea, 0xa0, 0xe2, 0x20, 0x50, 0xb8, 0xa5, 0x66, 0x48, 0x10, 0x0d, + 0x20, 0x49, 0xb8, 0xa5, 0x66, 0x30, 0x09, 0xa5, 0x12, 0x49, 0xff, 0x85, 0x12, 0x20, 0xb4, 0xbf, + 0xa9, 0xea, 0xa0, 0xe2, 0x20, 0x67, 0xb8, 0x68, 0x10, 0x03, 0x20, 0xb4, 0xbf, 0xa9, 0xef, 0xa0, + 0xe2, 0x4c, 0x43, 0xe0, 0x20, 0xca, 0xbb, 0xa9, 0x00, 0x85, 0x12, 0x20, 0x6b, 0xe2, 0xa2, 0x4e, + 0xa0, 0x00, 0x20, 0xf6, 0xe0, 0xa9, 0x57, 0xa0, 0x00, 0x20, 0xa2, 0xbb, 0xa9, 0x00, 0x85, 0x66, + 0xa5, 0x12, 0x20, 0xdc, 0xe2, 0xa9, 0x4e, 0xa0, 0x00, 0x4c, 0x0f, 0xbb, 0x48, 0x4c, 0x9d, 0xe2, + 0x81, 0x49, 0x0f, 0xda, 0xa2, 0x83, 0x49, 0x0f, 0xda, 0xa2, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x05, + 0x84, 0xe6, 0x1a, 0x2d, 0x1b, 0x86, 0x28, 0x07, 0xfb, 0xf8, 0x87, 0x99, 0x68, 0x89, 0x01, 0x87, + 0x23, 0x35, 0xdf, 0xe1, 0x86, 0xa5, 0x5d, 0xe7, 0x28, 0x83, 0x49, 0x0f, 0xda, 0xa2, 0xa5, 0x66, + 0x48, 0x10, 0x03, 0x20, 0xb4, 0xbf, 0xa5, 0x61, 0x48, 0xc9, 0x81, 0x90, 0x07, 0xa9, 0xbc, 0xa0, + 0xb9, 0x20, 0x0f, 0xbb, 0xa9, 0x3e, 0xa0, 0xe3, 0x20, 0x43, 0xe0, 0x68, 0xc9, 0x81, 0x90, 0x07, + 0xa9, 0xe0, 0xa0, 0xe2, 0x20, 0x50, 0xb8, 0x68, 0x10, 0x03, 0x4c, 0xb4, 0xbf, 0x60, 0x0b, 0x76, + 0xb3, 0x83, 0xbd, 0xd3, 0x79, 0x1e, 0xf4, 0xa6, 0xf5, 0x7b, 0x83, 0xfc, 0xb0, 0x10, 0x7c, 0x0c, + 0x1f, 0x67, 0xca, 0x7c, 0xde, 0x53, 0xcb, 0xc1, 0x7d, 0x14, 0x64, 0x70, 0x4c, 0x7d, 0xb7, 0xea, + 0x51, 0x7a, 0x7d, 0x63, 0x30, 0x88, 0x7e, 0x7e, 0x92, 0x44, 0x99, 0x3a, 0x7e, 0x4c, 0xcc, 0x91, + 0xc7, 0x7f, 0xaa, 0xaa, 0xaa, 0x13, 0x81, 0x00, 0x00, 0x00, 0x00, 0x20, 0xcc, 0xff, 0xa9, 0x00, + 0x85, 0x13, 0x20, 0x7a, 0xa6, 0x58, 0xa2, 0x80, 0x6c, 0x00, 0x03, 0x8a, 0x30, 0x03, 0x4c, 0x3a, + 0xa4, 0x4c, 0x74, 0xa4, 0x20, 0x53, 0xe4, 0x20, 0xbf, 0xe3, 0x20, 0x22, 0xe4, 0xa2, 0xfb, 0x9a, + 0xd0, 0xe4, 0xe6, 0x7a, 0xd0, 0x02, 0xe6, 0x7b, 0xad, 0x60, 0xea, 0xc9, 0x3a, 0xb0, 0x0a, 0xc9, + 0x20, 0xf0, 0xef, 0x38, 0xe9, 0x30, 0x38, 0xe9, 0xd0, 0x60, 0x80, 0x4f, 0xc7, 0x52, 0x58, 0xa9, + 0x4c, 0x85, 0x54, 0x8d, 0x10, 0x03, 0xa9, 0x48, 0xa0, 0xb2, 0x8d, 0x11, 0x03, 0x8c, 0x12, 0x03, + 0xa9, 0x91, 0xa0, 0xb3, 0x85, 0x05, 0x84, 0x06, 0xa9, 0xaa, 0xa0, 0xb1, 0x85, 0x03, 0x84, 0x04, + 0xa2, 0x1c, 0xbd, 0xa2, 0xe3, 0x95, 0x73, 0xca, 0x10, 0xf8, 0xa9, 0x03, 0x85, 0x53, 0xa9, 0x00, + 0x85, 0x68, 0x85, 0x13, 0x85, 0x18, 0xa2, 0x01, 0x8e, 0xfd, 0x01, 0x8e, 0xfc, 0x01, 0xa2, 0x19, + 0x86, 0x16, 0x38, 0x20, 0x9c, 0xff, 0x86, 0x2b, 0x84, 0x2c, 0x38, 0x20, 0x99, 0xff, 0x86, 0x37, + 0x84, 0x38, 0x86, 0x33, 0x84, 0x34, 0xa0, 0x00, 0x98, 0x91, 0x2b, 0xe6, 0x2b, 0xd0, 0x02, 0xe6, + 0x2c, 0x60, 0xa5, 0x2b, 0xa4, 0x2c, 0x20, 0x08, 0xa4, 0xa9, 0x73, 0xa0, 0xe4, 0x20, 0x1e, 0xab, + 0xa5, 0x37, 0x38, 0xe5, 0x2b, 0xaa, 0xa5, 0x38, 0xe5, 0x2c, 0x20, 0xcd, 0xbd, 0xa9, 0x60, 0xa0, + 0xe4, 0x20, 0x1e, 0xab, 0x4c, 0x44, 0xa6, 0x8b, 0xe3, 0x83, 0xa4, 0x7c, 0xa5, 0x1a, 0xa7, 0xe4, + 0xa7, 0x86, 0xae, 0xa2, 0x0b, 0xbd, 0x47, 0xe4, 0x9d, 0x00, 0x03, 0xca, 0x10, 0xf7, 0x60, 0x00, + 0x20, 0x42, 0x41, 0x53, 0x49, 0x43, 0x20, 0x42, 0x59, 0x54, 0x45, 0x53, 0x20, 0x46, 0x52, 0x45, + 0x45, 0x0d, 0x00, 0x93, 0x0d, 0x20, 0x20, 0x20, 0x20, 0x2a, 0x2a, 0x2a, 0x2a, 0x20, 0x43, 0x4f, + 0x4d, 0x4d, 0x4f, 0x44, 0x4f, 0x52, 0x45, 0x20, 0x36, 0x34, 0x20, 0x42, 0x41, 0x53, 0x49, 0x43, + 0x20, 0x56, 0x32, 0x20, 0x2a, 0x2a, 0x2a, 0x2a, 0x0d, 0x0d, 0x20, 0x36, 0x34, 0x4b, 0x20, 0x52, + 0x41, 0x4d, 0x20, 0x53, 0x59, 0x53, 0x54, 0x45, 0x4d, 0x20, 0x20, 0x00, 0x81, 0x48, 0x20, 0xc9, + 0xff, 0xaa, 0x68, 0x90, 0x01, 0x8a, 0x60, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0x85, 0xa9, 0xa9, 0x01, 0x85, 0xab, 0x60, 0xad, 0x86, 0x02, 0x91, 0xf3, 0x60, + 0x69, 0x02, 0xa4, 0x91, 0xc8, 0xd0, 0x04, 0xc5, 0xa1, 0xd0, 0xf7, 0x60, 0x19, 0x26, 0x44, 0x19, + 0x1a, 0x11, 0xe8, 0x0d, 0x70, 0x0c, 0x06, 0x06, 0xd1, 0x02, 0x37, 0x01, 0xae, 0x00, 0x69, 0x00, + 0xa2, 0x00, 0xa0, 0xdc, 0x60, 0xa2, 0x28, 0xa0, 0x19, 0x60, 0xb0, 0x07, 0x86, 0xd6, 0x84, 0xd3, + 0x20, 0x6c, 0xe5, 0xa6, 0xd6, 0xa4, 0xd3, 0x60, 0x20, 0xa0, 0xe5, 0xa9, 0x00, 0x8d, 0x91, 0x02, + 0x85, 0xcf, 0xa9, 0x48, 0x8d, 0x8f, 0x02, 0xa9, 0xeb, 0x8d, 0x90, 0x02, 0xa9, 0x0a, 0x8d, 0x89, + 0x02, 0x8d, 0x8c, 0x02, 0xa9, 0x0e, 0x8d, 0x86, 0x02, 0xa9, 0x04, 0x8d, 0x8b, 0x02, 0xa9, 0x0c, + 0x85, 0xcd, 0x85, 0xcc, 0xad, 0x88, 0x02, 0x09, 0x80, 0xa8, 0xa9, 0x00, 0xaa, 0x94, 0xd9, 0x18, + 0x69, 0x28, 0x90, 0x01, 0xc8, 0xe8, 0xe0, 0x1a, 0xd0, 0xf3, 0xa9, 0xff, 0x95, 0xd9, 0xa2, 0x18, + 0x20, 0xff, 0xe9, 0xca, 0x10, 0xfa, 0xa0, 0x00, 0x84, 0xd3, 0x84, 0xd6, 0xa6, 0xd6, 0xa5, 0xd3, + 0xb4, 0xd9, 0x30, 0x08, 0x18, 0x69, 0x28, 0x85, 0xd3, 0xca, 0x10, 0xf4, 0x20, 0xf0, 0xe9, 0xa9, + 0x27, 0xe8, 0xb4, 0xd9, 0x30, 0x06, 0x18, 0x69, 0x28, 0xe8, 0x10, 0xf6, 0x85, 0xd5, 0x4c, 0x24, + 0xea, 0xe4, 0xc9, 0xf0, 0x03, 0x4c, 0xed, 0xe6, 0x60, 0xea, 0x20, 0xa0, 0xe5, 0x4c, 0x66, 0xe5, + 0xa9, 0x03, 0x85, 0x9a, 0xa9, 0x00, 0x85, 0x99, 0xa2, 0x2f, 0xbd, 0xb8, 0xec, 0x9d, 0xff, 0xcf, + 0xca, 0xd0, 0xf7, 0x60, 0xac, 0x77, 0x02, 0xa2, 0x00, 0xbd, 0x78, 0x02, 0x9d, 0x77, 0x02, 0xe8, + 0xe4, 0xc6, 0xd0, 0xf5, 0xc6, 0xc6, 0x98, 0x58, 0x18, 0x60, 0x20, 0x16, 0xe7, 0xa5, 0xc6, 0x85, + 0xcc, 0x8d, 0x92, 0x02, 0xf0, 0xf7, 0x78, 0xa5, 0xcf, 0xf0, 0x0c, 0xa5, 0xce, 0xae, 0x87, 0x02, + 0xa0, 0x00, 0x84, 0xcf, 0x20, 0x13, 0xea, 0x20, 0xb4, 0xe5, 0xc9, 0x83, 0xd0, 0x10, 0xa2, 0x09, + 0x78, 0x86, 0xc6, 0xbd, 0xe6, 0xec, 0x9d, 0x76, 0x02, 0xca, 0xd0, 0xf7, 0xf0, 0xcf, 0xc9, 0x0d, + 0xd0, 0xc8, 0xa4, 0xd5, 0x84, 0xd0, 0xb1, 0xd1, 0xc9, 0x20, 0xd0, 0x03, 0x88, 0xd0, 0xf7, 0xc8, + 0x84, 0xc8, 0xa0, 0x00, 0x8c, 0x92, 0x02, 0x84, 0xd3, 0x84, 0xd4, 0xa5, 0xc9, 0x30, 0x1b, 0xa6, + 0xd6, 0x20, 0x91, 0xe5, 0xe4, 0xc9, 0xd0, 0x12, 0xa5, 0xca, 0x85, 0xd3, 0xc5, 0xc8, 0x90, 0x0a, + 0xb0, 0x2b, 0x98, 0x48, 0x8a, 0x48, 0xa5, 0xd0, 0xf0, 0x93, 0xa4, 0xd3, 0xb1, 0xd1, 0x85, 0xd7, + 0x29, 0x3f, 0x06, 0xd7, 0x24, 0xd7, 0x10, 0x02, 0x09, 0x80, 0x90, 0x04, 0xa6, 0xd4, 0xd0, 0x04, + 0x70, 0x02, 0x09, 0x40, 0xe6, 0xd3, 0x20, 0x84, 0xe6, 0xc4, 0xc8, 0xd0, 0x17, 0xa9, 0x00, 0x85, + 0xd0, 0xa9, 0x0d, 0xa6, 0x99, 0xe0, 0x03, 0xf0, 0x06, 0xa6, 0x9a, 0xe0, 0x03, 0xf0, 0x03, 0x20, + 0x16, 0xe7, 0xa9, 0x0d, 0x85, 0xd7, 0x68, 0xaa, 0x68, 0xa8, 0xa5, 0xd7, 0xc9, 0xde, 0xd0, 0x02, + 0xa9, 0xff, 0x18, 0x60, 0xc9, 0x22, 0xd0, 0x08, 0xa5, 0xd4, 0x49, 0x01, 0x85, 0xd4, 0xa9, 0x22, + 0x60, 0x09, 0x40, 0xa6, 0xc7, 0xf0, 0x02, 0x09, 0x80, 0xa6, 0xd8, 0xf0, 0x02, 0xc6, 0xd8, 0xae, + 0x86, 0x02, 0x20, 0x13, 0xea, 0x20, 0xb6, 0xe6, 0x68, 0xa8, 0xa5, 0xd8, 0xf0, 0x02, 0x46, 0xd4, + 0x68, 0xaa, 0x68, 0x18, 0x58, 0x60, 0x20, 0xb3, 0xe8, 0xe6, 0xd3, 0xa5, 0xd5, 0xc5, 0xd3, 0xb0, + 0x3f, 0xc9, 0x4f, 0xf0, 0x32, 0xad, 0x92, 0x02, 0xf0, 0x03, 0x4c, 0x67, 0xe9, 0xa6, 0xd6, 0xe0, + 0x19, 0x90, 0x07, 0x20, 0xea, 0xe8, 0xc6, 0xd6, 0xa6, 0xd6, 0x16, 0xd9, 0x56, 0xd9, 0xe8, 0xb5, + 0xd9, 0x09, 0x80, 0x95, 0xd9, 0xca, 0xa5, 0xd5, 0x18, 0x69, 0x28, 0x85, 0xd5, 0xb5, 0xd9, 0x30, + 0x03, 0xca, 0xd0, 0xf9, 0x4c, 0xf0, 0xe9, 0xc6, 0xd6, 0x20, 0x7c, 0xe8, 0xa9, 0x00, 0x85, 0xd3, + 0x60, 0xa6, 0xd6, 0xd0, 0x06, 0x86, 0xd3, 0x68, 0x68, 0xd0, 0x9d, 0xca, 0x86, 0xd6, 0x20, 0x6c, + 0xe5, 0xa4, 0xd5, 0x84, 0xd3, 0x60, 0x48, 0x85, 0xd7, 0x8a, 0x48, 0x98, 0x48, 0xa9, 0x00, 0x85, + 0xd0, 0xa4, 0xd3, 0xa5, 0xd7, 0x10, 0x03, 0x4c, 0xd4, 0xe7, 0xc9, 0x0d, 0xd0, 0x03, 0x4c, 0x91, + 0xe8, 0xc9, 0x20, 0x90, 0x10, 0xc9, 0x60, 0x90, 0x04, 0x29, 0xdf, 0xd0, 0x02, 0x29, 0x3f, 0x20, + 0x84, 0xe6, 0x4c, 0x93, 0xe6, 0xa6, 0xd8, 0xf0, 0x03, 0x4c, 0x97, 0xe6, 0xc9, 0x14, 0xd0, 0x2e, + 0x98, 0xd0, 0x06, 0x20, 0x01, 0xe7, 0x4c, 0x73, 0xe7, 0x20, 0xa1, 0xe8, 0x88, 0x84, 0xd3, 0x20, + 0x24, 0xea, 0xc8, 0xb1, 0xd1, 0x88, 0x91, 0xd1, 0xc8, 0xb1, 0xf3, 0x88, 0x91, 0xf3, 0xc8, 0xc4, + 0xd5, 0xd0, 0xef, 0xa9, 0x20, 0x91, 0xd1, 0xad, 0x86, 0x02, 0x91, 0xf3, 0x10, 0x4d, 0xa6, 0xd4, + 0xf0, 0x03, 0x4c, 0x97, 0xe6, 0xc9, 0x12, 0xd0, 0x02, 0x85, 0xc7, 0xc9, 0x13, 0xd0, 0x03, 0x20, + 0x66, 0xe5, 0xc9, 0x1d, 0xd0, 0x17, 0xc8, 0x20, 0xb3, 0xe8, 0x84, 0xd3, 0x88, 0xc4, 0xd5, 0x90, + 0x09, 0xc6, 0xd6, 0x20, 0x7c, 0xe8, 0xa0, 0x00, 0x84, 0xd3, 0x4c, 0xa8, 0xe6, 0xc9, 0x11, 0xd0, + 0x1d, 0x18, 0x98, 0x69, 0x28, 0xa8, 0xe6, 0xd6, 0xc5, 0xd5, 0x90, 0xec, 0xf0, 0xea, 0xc6, 0xd6, + 0xe9, 0x28, 0x90, 0x04, 0x85, 0xd3, 0xd0, 0xf8, 0x20, 0x7c, 0xe8, 0x4c, 0xa8, 0xe6, 0x20, 0xcb, + 0xe8, 0x4c, 0x44, 0xec, 0x29, 0x7f, 0xc9, 0x7f, 0xd0, 0x02, 0xa9, 0x5e, 0xc9, 0x20, 0x90, 0x03, + 0x4c, 0x91, 0xe6, 0xc9, 0x0d, 0xd0, 0x03, 0x4c, 0x91, 0xe8, 0xa6, 0xd4, 0xd0, 0x3f, 0xc9, 0x14, + 0xd0, 0x37, 0xa4, 0xd5, 0xb1, 0xd1, 0xc9, 0x20, 0xd0, 0x04, 0xc4, 0xd3, 0xd0, 0x07, 0xc0, 0x4f, + 0xf0, 0x24, 0x20, 0x65, 0xe9, 0xa4, 0xd5, 0x20, 0x24, 0xea, 0x88, 0xb1, 0xd1, 0xc8, 0x91, 0xd1, + 0x88, 0xb1, 0xf3, 0xc8, 0x91, 0xf3, 0x88, 0xc4, 0xd3, 0xd0, 0xef, 0xa9, 0x20, 0x91, 0xd1, 0xad, + 0x86, 0x02, 0x91, 0xf3, 0xe6, 0xd8, 0x4c, 0xa8, 0xe6, 0xa6, 0xd8, 0xf0, 0x05, 0x09, 0x40, 0x4c, + 0x97, 0xe6, 0xc9, 0x11, 0xd0, 0x16, 0xa6, 0xd6, 0xf0, 0x37, 0xc6, 0xd6, 0xa5, 0xd3, 0x38, 0xe9, + 0x28, 0x90, 0x04, 0x85, 0xd3, 0x10, 0x2a, 0x20, 0x6c, 0xe5, 0xd0, 0x25, 0xc9, 0x12, 0xd0, 0x04, + 0xa9, 0x00, 0x85, 0xc7, 0xc9, 0x1d, 0xd0, 0x12, 0x98, 0xf0, 0x09, 0x20, 0xa1, 0xe8, 0x88, 0x84, + 0xd3, 0x4c, 0xa8, 0xe6, 0x20, 0x01, 0xe7, 0x4c, 0xa8, 0xe6, 0xc9, 0x13, 0xd0, 0x06, 0x20, 0x44, + 0xe5, 0x4c, 0xa8, 0xe6, 0x09, 0x80, 0x20, 0xcb, 0xe8, 0x4c, 0x4f, 0xec, 0x46, 0xc9, 0xa6, 0xd6, + 0xe8, 0xe0, 0x19, 0xd0, 0x03, 0x20, 0xea, 0xe8, 0xb5, 0xd9, 0x10, 0xf4, 0x86, 0xd6, 0x4c, 0x6c, + 0xe5, 0xa2, 0x00, 0x86, 0xd8, 0x86, 0xc7, 0x86, 0xd4, 0x86, 0xd3, 0x20, 0x7c, 0xe8, 0x4c, 0xa8, + 0xe6, 0xa2, 0x02, 0xa9, 0x00, 0xc5, 0xd3, 0xf0, 0x07, 0x18, 0x69, 0x28, 0xca, 0xd0, 0xf6, 0x60, + 0xc6, 0xd6, 0x60, 0xa2, 0x02, 0xa9, 0x27, 0xc5, 0xd3, 0xf0, 0x07, 0x18, 0x69, 0x28, 0xca, 0xd0, + 0xf6, 0x60, 0xa6, 0xd6, 0xe0, 0x19, 0xf0, 0x02, 0xe6, 0xd6, 0x60, 0xa2, 0x0f, 0xdd, 0xda, 0xe8, + 0xf0, 0x04, 0xca, 0x10, 0xf8, 0x60, 0x8e, 0x86, 0x02, 0x60, 0x90, 0x05, 0x1c, 0x9f, 0x9c, 0x1e, + 0x1f, 0x9e, 0x81, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0xa5, 0xac, 0x48, 0xa5, 0xad, 0x48, + 0xa5, 0xae, 0x48, 0xa5, 0xaf, 0x48, 0xa2, 0xff, 0xc6, 0xd6, 0xc6, 0xc9, 0xce, 0xa5, 0x02, 0xe8, + 0x20, 0xf0, 0xe9, 0xe0, 0x18, 0xb0, 0x0c, 0xbd, 0xf1, 0xec, 0x85, 0xac, 0xb5, 0xda, 0x20, 0xc8, + 0xe9, 0x30, 0xec, 0x20, 0xff, 0xe9, 0xa2, 0x00, 0xb5, 0xd9, 0x29, 0x7f, 0xb4, 0xda, 0x10, 0x02, + 0x09, 0x80, 0x95, 0xd9, 0xe8, 0xe0, 0x18, 0xd0, 0xef, 0xa5, 0xf1, 0x09, 0x80, 0x85, 0xf1, 0xa5, + 0xd9, 0x10, 0xc3, 0xe6, 0xd6, 0xee, 0xa5, 0x02, 0xa9, 0x7f, 0x8d, 0x00, 0xdc, 0xad, 0x01, 0xdc, + 0xc9, 0xfb, 0x08, 0xa9, 0x7f, 0x8d, 0x00, 0xdc, 0x28, 0xd0, 0x0b, 0xa0, 0x00, 0xea, 0xca, 0xd0, + 0xfc, 0x88, 0xd0, 0xf9, 0x84, 0xc6, 0xa6, 0xd6, 0x68, 0x85, 0xaf, 0x68, 0x85, 0xae, 0x68, 0x85, + 0xad, 0x68, 0x85, 0xac, 0x60, 0xa6, 0xd6, 0xe8, 0xb5, 0xd9, 0x10, 0xfb, 0x8e, 0xa5, 0x02, 0xe0, + 0x18, 0xf0, 0x0e, 0x90, 0x0c, 0x20, 0xea, 0xe8, 0xae, 0xa5, 0x02, 0xca, 0xc6, 0xd6, 0x4c, 0xda, + 0xe6, 0xa5, 0xac, 0x48, 0xa5, 0xad, 0x48, 0xa5, 0xae, 0x48, 0xa5, 0xaf, 0x48, 0xa2, 0x19, 0xca, + 0x20, 0xf0, 0xe9, 0xec, 0xa5, 0x02, 0x90, 0x0e, 0xf0, 0x0c, 0xbd, 0xef, 0xec, 0x85, 0xac, 0xb5, + 0xd8, 0x20, 0xc8, 0xe9, 0x30, 0xe9, 0x20, 0xff, 0xe9, 0xa2, 0x17, 0xec, 0xa5, 0x02, 0x90, 0x0f, + 0xb5, 0xda, 0x29, 0x7f, 0xb4, 0xd9, 0x10, 0x02, 0x09, 0x80, 0x95, 0xda, 0xca, 0xd0, 0xec, 0xae, + 0xa5, 0x02, 0x20, 0xda, 0xe6, 0x4c, 0x58, 0xe9, 0x29, 0x03, 0x0d, 0x88, 0x02, 0x85, 0xad, 0x20, + 0xe0, 0xe9, 0xa0, 0x27, 0xb1, 0xac, 0x91, 0xd1, 0xb1, 0xae, 0x91, 0xf3, 0x88, 0x10, 0xf5, 0x60, + 0x20, 0x24, 0xea, 0xa5, 0xac, 0x85, 0xae, 0xa5, 0xad, 0x29, 0x03, 0x09, 0xd8, 0x85, 0xaf, 0x60, + 0xbd, 0xf0, 0xec, 0x85, 0xd1, 0xb5, 0xd9, 0x29, 0x03, 0x0d, 0x88, 0x02, 0x85, 0xd2, 0x60, 0xa0, + 0x27, 0x20, 0xf0, 0xe9, 0x20, 0x24, 0xea, 0x20, 0xda, 0xe4, 0xa9, 0x20, 0x91, 0xd1, 0x88, 0x10, + 0xf6, 0x60, 0xea, 0xa8, 0xa9, 0x02, 0x85, 0xcd, 0x20, 0x24, 0xea, 0x98, 0xa4, 0xd3, 0x91, 0xd1, + 0x8a, 0x91, 0xf3, 0x60, 0xa5, 0xd1, 0x85, 0xf3, 0xa5, 0xd2, 0x29, 0x03, 0x09, 0xd8, 0x85, 0xf4, + 0x60, 0x20, 0xea, 0xff, 0xa5, 0xcc, 0xd0, 0x29, 0xc6, 0xcd, 0xd0, 0x25, 0xa9, 0x14, 0x85, 0xcd, + 0xa4, 0xd3, 0x46, 0xcf, 0xae, 0x87, 0x02, 0xb1, 0xd1, 0xb0, 0x11, 0xe6, 0xcf, 0x85, 0xce, 0x20, + 0x24, 0xea, 0xb1, 0xf3, 0x8d, 0x87, 0x02, 0xae, 0x86, 0x02, 0xa5, 0xce, 0x49, 0x80, 0x20, 0x1c, + 0xea, 0xa5, 0x01, 0x29, 0x10, 0xf0, 0x0a, 0xa0, 0x00, 0x84, 0xc0, 0xa5, 0x01, 0x09, 0x20, 0xd0, + 0x08, 0xa5, 0xc0, 0xd0, 0x06, 0xa5, 0x01, 0x29, 0x1f, 0x85, 0x01, 0x20, 0x87, 0xea, 0xad, 0x0d, + 0xdc, 0x68, 0xa8, 0x68, 0xaa, 0x68, 0x40, 0xa9, 0x00, 0x8d, 0x8d, 0x02, 0xa0, 0x40, 0x84, 0xcb, + 0x8d, 0x00, 0xdc, 0xae, 0x01, 0xdc, 0xe0, 0xff, 0xf0, 0x61, 0xa8, 0xa9, 0x81, 0x85, 0xf5, 0xa9, + 0xeb, 0x85, 0xf6, 0xa9, 0xfe, 0x8d, 0x00, 0xdc, 0xa2, 0x08, 0x48, 0xad, 0x01, 0xdc, 0xcd, 0x01, + 0xdc, 0xd0, 0xf8, 0x4a, 0xb0, 0x16, 0x48, 0xb1, 0xf5, 0xc9, 0x05, 0xb0, 0x0c, 0xc9, 0x03, 0xf0, + 0x08, 0x0d, 0x8d, 0x02, 0x8d, 0x8d, 0x02, 0x10, 0x02, 0x84, 0xcb, 0x68, 0xc8, 0xc0, 0x41, 0xb0, + 0x0b, 0xca, 0xd0, 0xdf, 0x38, 0x68, 0x2a, 0x8d, 0x00, 0xdc, 0xd0, 0xcc, 0x68, 0x6c, 0x8f, 0x02, + 0xa4, 0xcb, 0xb1, 0xf5, 0xaa, 0xc4, 0xc5, 0xf0, 0x07, 0xa0, 0x10, 0x8c, 0x8c, 0x02, 0xd0, 0x36, + 0x29, 0x7f, 0x2c, 0x8a, 0x02, 0x30, 0x16, 0x70, 0x49, 0xc9, 0x7f, 0xf0, 0x29, 0xc9, 0x14, 0xf0, + 0x0c, 0xc9, 0x20, 0xf0, 0x08, 0xc9, 0x1d, 0xf0, 0x04, 0xc9, 0x11, 0xd0, 0x35, 0xac, 0x8c, 0x02, + 0xf0, 0x05, 0xce, 0x8c, 0x02, 0xd0, 0x2b, 0xce, 0x8b, 0x02, 0xd0, 0x26, 0xa0, 0x04, 0x8c, 0x8b, + 0x02, 0xa4, 0xc6, 0x88, 0x10, 0x1c, 0xa4, 0xcb, 0x84, 0xc5, 0xac, 0x8d, 0x02, 0x8c, 0x8e, 0x02, + 0xe0, 0xff, 0xf0, 0x0e, 0x8a, 0xa6, 0xc6, 0xec, 0x89, 0x02, 0xb0, 0x06, 0x9d, 0x77, 0x02, 0xe8, + 0x86, 0xc6, 0xa9, 0x7f, 0x8d, 0x00, 0xdc, 0x60, 0xad, 0x8d, 0x02, 0xc9, 0x03, 0xd0, 0x15, 0xcd, + 0x8e, 0x02, 0xf0, 0xee, 0xad, 0x91, 0x02, 0x30, 0x1d, 0xad, 0x18, 0xd0, 0x49, 0x02, 0x8d, 0x18, + 0xd0, 0x4c, 0x76, 0xeb, 0x0a, 0xc9, 0x08, 0x90, 0x02, 0xa9, 0x06, 0xaa, 0xbd, 0x79, 0xeb, 0x85, + 0xf5, 0xbd, 0x7a, 0xeb, 0x85, 0xf6, 0x4c, 0xe0, 0xea, 0x81, 0xeb, 0xc2, 0xeb, 0x03, 0xec, 0x78, + 0xec, 0x14, 0x0d, 0x1d, 0x88, 0x85, 0x86, 0x87, 0x11, 0x33, 0x57, 0x41, 0x34, 0x5a, 0x53, 0x45, + 0x01, 0x35, 0x52, 0x44, 0x36, 0x43, 0x46, 0x54, 0x58, 0x37, 0x59, 0x47, 0x38, 0x42, 0x48, 0x55, + 0x56, 0x39, 0x49, 0x4a, 0x30, 0x4d, 0x4b, 0x4f, 0x4e, 0x2b, 0x50, 0x4c, 0x2d, 0x2e, 0x3a, 0x40, + 0x2c, 0x5c, 0x2a, 0x3b, 0x13, 0x01, 0x3d, 0x5e, 0x2f, 0x31, 0x5f, 0x04, 0x32, 0x20, 0x02, 0x51, + 0x03, 0xff, 0x94, 0x8d, 0x9d, 0x8c, 0x89, 0x8a, 0x8b, 0x91, 0x23, 0xd7, 0xc1, 0x24, 0xda, 0xd3, + 0xc5, 0x01, 0x25, 0xd2, 0xc4, 0x26, 0xc3, 0xc6, 0xd4, 0xd8, 0x27, 0xd9, 0xc7, 0x28, 0xc2, 0xc8, + 0xd5, 0xd6, 0x29, 0xc9, 0xca, 0x30, 0xcd, 0xcb, 0xcf, 0xce, 0xdb, 0xd0, 0xcc, 0xdd, 0x3e, 0x5b, + 0xba, 0x3c, 0xa9, 0xc0, 0x5d, 0x93, 0x01, 0x3d, 0xde, 0x3f, 0x21, 0x5f, 0x04, 0x22, 0xa0, 0x02, + 0xd1, 0x83, 0xff, 0x94, 0x8d, 0x9d, 0x8c, 0x89, 0x8a, 0x8b, 0x91, 0x96, 0xb3, 0xb0, 0x97, 0xad, + 0xae, 0xb1, 0x01, 0x98, 0xb2, 0xac, 0x99, 0xbc, 0xbb, 0xa3, 0xbd, 0x9a, 0xb7, 0xa5, 0x9b, 0xbf, + 0xb4, 0xb8, 0xbe, 0x29, 0xa2, 0xb5, 0x30, 0xa7, 0xa1, 0xb9, 0xaa, 0xa6, 0xaf, 0xb6, 0xdc, 0x3e, + 0x5b, 0xa4, 0x3c, 0xa8, 0xdf, 0x5d, 0x93, 0x01, 0x3d, 0xde, 0x3f, 0x81, 0x5f, 0x04, 0x95, 0xa0, + 0x02, 0xab, 0x83, 0xff, 0xc9, 0x0e, 0xd0, 0x07, 0xad, 0x18, 0xd0, 0x09, 0x02, 0xd0, 0x09, 0xc9, + 0x8e, 0xd0, 0x0b, 0xad, 0x18, 0xd0, 0x29, 0xfd, 0x8d, 0x18, 0xd0, 0x4c, 0xa8, 0xe6, 0xc9, 0x08, + 0xd0, 0x07, 0xa9, 0x80, 0x0d, 0x91, 0x02, 0x30, 0x09, 0xc9, 0x09, 0xd0, 0xee, 0xa9, 0x7f, 0x2d, + 0x91, 0x02, 0x8d, 0x91, 0x02, 0x4c, 0xa8, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x1c, 0x17, 0x01, 0x9f, 0x1a, 0x13, 0x05, 0xff, 0x9c, 0x12, 0x04, 0x1e, 0x03, 0x06, 0x14, 0x18, + 0x1f, 0x19, 0x07, 0x9e, 0x02, 0x08, 0x15, 0x16, 0x12, 0x09, 0x0a, 0x92, 0x0d, 0x0b, 0x0f, 0x0e, + 0xff, 0x10, 0x0c, 0xff, 0xff, 0x1b, 0x00, 0xff, 0x1c, 0xff, 0x1d, 0xff, 0xff, 0x1f, 0x1e, 0xff, + 0x90, 0x06, 0xff, 0x05, 0xff, 0xff, 0x11, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9b, 0x37, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x14, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x06, 0x01, 0x02, 0x03, 0x04, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x4c, 0x4f, 0x41, 0x44, 0x0d, 0x52, 0x55, 0x4e, 0x0d, + 0x00, 0x28, 0x50, 0x78, 0xa0, 0xc8, 0xf0, 0x18, 0x40, 0x68, 0x90, 0xb8, 0xe0, 0x08, 0x30, 0x58, + 0x80, 0xa8, 0xd0, 0xf8, 0x20, 0x48, 0x70, 0x98, 0xc0, 0x09, 0x40, 0x2c, 0x09, 0x20, 0x20, 0xa4, + 0xf0, 0x48, 0x24, 0x94, 0x10, 0x0a, 0x38, 0x66, 0xa3, 0x20, 0x40, 0xed, 0x46, 0x94, 0x46, 0xa3, + 0x68, 0x85, 0x95, 0x78, 0x20, 0x97, 0xee, 0xc9, 0x3f, 0xd0, 0x03, 0x20, 0x85, 0xee, 0xad, 0x00, + 0xdd, 0x09, 0x08, 0x8d, 0x00, 0xdd, 0x78, 0x20, 0x8e, 0xee, 0x20, 0x97, 0xee, 0x20, 0xb3, 0xee, + 0x78, 0x20, 0x97, 0xee, 0x20, 0xa9, 0xee, 0xb0, 0x64, 0x20, 0x85, 0xee, 0x24, 0xa3, 0x10, 0x0a, + 0x20, 0xa9, 0xee, 0x90, 0xfb, 0x20, 0xa9, 0xee, 0xb0, 0xfb, 0x20, 0xa9, 0xee, 0x90, 0xfb, 0x20, + 0x8e, 0xee, 0xa9, 0x08, 0x85, 0xa5, 0xad, 0x00, 0xdd, 0xcd, 0x00, 0xdd, 0xd0, 0xf8, 0x0a, 0x90, + 0x3f, 0x66, 0x95, 0xb0, 0x05, 0x20, 0xa0, 0xee, 0xd0, 0x03, 0x20, 0x97, 0xee, 0x20, 0x85, 0xee, + 0xea, 0xea, 0xea, 0xea, 0xad, 0x00, 0xdd, 0x29, 0xdf, 0x09, 0x10, 0x8d, 0x00, 0xdd, 0xc6, 0xa5, + 0xd0, 0xd4, 0xa9, 0x04, 0x8d, 0x07, 0xdc, 0xa9, 0x19, 0x8d, 0x0f, 0xdc, 0xad, 0x0d, 0xdc, 0xad, + 0x0d, 0xdc, 0x29, 0x02, 0xd0, 0x0a, 0x20, 0xa9, 0xee, 0xb0, 0xf4, 0x58, 0x60, 0xa9, 0x80, 0x2c, + 0xa9, 0x03, 0x20, 0x1c, 0xfe, 0x58, 0x18, 0x90, 0x4a, 0x85, 0x95, 0x20, 0x36, 0xed, 0xad, 0x00, + 0xdd, 0x29, 0xf7, 0x8d, 0x00, 0xdd, 0x60, 0x85, 0x95, 0x20, 0x36, 0xed, 0x78, 0x20, 0xa0, 0xee, + 0x20, 0xbe, 0xed, 0x20, 0x85, 0xee, 0x20, 0xa9, 0xee, 0x30, 0xfb, 0x58, 0x60, 0x24, 0x94, 0x30, + 0x05, 0x38, 0x66, 0x94, 0xd0, 0x05, 0x48, 0x20, 0x40, 0xed, 0x68, 0x85, 0x95, 0x18, 0x60, 0x78, + 0x20, 0x8e, 0xee, 0xad, 0x00, 0xdd, 0x09, 0x08, 0x8d, 0x00, 0xdd, 0xa9, 0x5f, 0x2c, 0xa9, 0x3f, + 0x20, 0x11, 0xed, 0x20, 0xbe, 0xed, 0x8a, 0xa2, 0x0a, 0xca, 0xd0, 0xfd, 0xaa, 0x20, 0x85, 0xee, + 0x4c, 0x97, 0xee, 0x78, 0xa9, 0x00, 0x85, 0xa5, 0x20, 0x85, 0xee, 0x20, 0xa9, 0xee, 0x10, 0xfb, + 0xa9, 0x01, 0x8d, 0x07, 0xdc, 0xa9, 0x19, 0x8d, 0x0f, 0xdc, 0x20, 0x97, 0xee, 0xad, 0x0d, 0xdc, + 0xad, 0x0d, 0xdc, 0x29, 0x02, 0xd0, 0x07, 0x20, 0xa9, 0xee, 0x30, 0xf4, 0x10, 0x18, 0xa5, 0xa5, + 0xf0, 0x05, 0xa9, 0x02, 0x4c, 0xb2, 0xed, 0x20, 0xa0, 0xee, 0x20, 0x85, 0xee, 0xa9, 0x40, 0x20, + 0x1c, 0xfe, 0xe6, 0xa5, 0xd0, 0xca, 0xa9, 0x08, 0x85, 0xa5, 0xad, 0x00, 0xdd, 0xcd, 0x00, 0xdd, + 0xd0, 0xf8, 0x0a, 0x10, 0xf5, 0x66, 0xa4, 0xad, 0x00, 0xdd, 0xcd, 0x00, 0xdd, 0xd0, 0xf8, 0x0a, + 0x30, 0xf5, 0xc6, 0xa5, 0xd0, 0xe4, 0x20, 0xa0, 0xee, 0x24, 0x90, 0x50, 0x03, 0x20, 0x06, 0xee, + 0xa5, 0xa4, 0x58, 0x18, 0x60, 0xad, 0x00, 0xdd, 0x29, 0xef, 0x8d, 0x00, 0xdd, 0x60, 0xad, 0x00, + 0xdd, 0x09, 0x10, 0x8d, 0x00, 0xdd, 0x60, 0xad, 0x00, 0xdd, 0x29, 0xdf, 0x8d, 0x00, 0xdd, 0x60, + 0xad, 0x00, 0xdd, 0x09, 0x20, 0x8d, 0x00, 0xdd, 0x60, 0xad, 0x00, 0xdd, 0xcd, 0x00, 0xdd, 0xd0, + 0xf8, 0x0a, 0x60, 0x8a, 0xa2, 0xb8, 0xca, 0xd0, 0xfd, 0xaa, 0x60, 0xa5, 0xb4, 0xf0, 0x47, 0x30, + 0x3f, 0x46, 0xb6, 0xa2, 0x00, 0x90, 0x01, 0xca, 0x8a, 0x45, 0xbd, 0x85, 0xbd, 0xc6, 0xb4, 0xf0, + 0x06, 0x8a, 0x29, 0x04, 0x85, 0xb5, 0x60, 0xa9, 0x20, 0x2c, 0x94, 0x02, 0xf0, 0x14, 0x30, 0x1c, + 0x70, 0x14, 0xa5, 0xbd, 0xd0, 0x01, 0xca, 0xc6, 0xb4, 0xad, 0x93, 0x02, 0x10, 0xe3, 0xc6, 0xb4, + 0xd0, 0xdf, 0xe6, 0xb4, 0xd0, 0xf0, 0xa5, 0xbd, 0xf0, 0xed, 0xd0, 0xea, 0x70, 0xe9, 0x50, 0xe6, + 0xe6, 0xb4, 0xa2, 0xff, 0xd0, 0xcb, 0xad, 0x94, 0x02, 0x4a, 0x90, 0x07, 0x2c, 0x01, 0xdd, 0x10, + 0x1d, 0x50, 0x1e, 0xa9, 0x00, 0x85, 0xbd, 0x85, 0xb5, 0xae, 0x98, 0x02, 0x86, 0xb4, 0xac, 0x9d, + 0x02, 0xcc, 0x9e, 0x02, 0xf0, 0x13, 0xb1, 0xf9, 0x85, 0xb6, 0xee, 0x9d, 0x02, 0x60, 0xa9, 0x40, + 0x2c, 0xa9, 0x10, 0x0d, 0x97, 0x02, 0x8d, 0x97, 0x02, 0xa9, 0x01, 0x8d, 0x0d, 0xdd, 0x4d, 0xa1, + 0x02, 0x09, 0x80, 0x8d, 0xa1, 0x02, 0x8d, 0x0d, 0xdd, 0x60, 0xa2, 0x09, 0xa9, 0x20, 0x2c, 0x93, + 0x02, 0xf0, 0x01, 0xca, 0x50, 0x02, 0xca, 0xca, 0x60, 0xa6, 0xa9, 0xd0, 0x33, 0xc6, 0xa8, 0xf0, + 0x36, 0x30, 0x0d, 0xa5, 0xa7, 0x45, 0xab, 0x85, 0xab, 0x46, 0xa7, 0x66, 0xaa, 0x60, 0xc6, 0xa8, + 0xa5, 0xa7, 0xf0, 0x67, 0xad, 0x93, 0x02, 0x0a, 0xa9, 0x01, 0x65, 0xa8, 0xd0, 0xef, 0xa9, 0x90, + 0x8d, 0x0d, 0xdd, 0x0d, 0xa1, 0x02, 0x8d, 0xa1, 0x02, 0x85, 0xa9, 0xa9, 0x02, 0x4c, 0x3b, 0xef, + 0xa5, 0xa7, 0xd0, 0xea, 0x4c, 0xd3, 0xe4, 0xac, 0x9b, 0x02, 0xc8, 0xcc, 0x9c, 0x02, 0xf0, 0x2a, + 0x8c, 0x9b, 0x02, 0x88, 0xa5, 0xaa, 0xae, 0x98, 0x02, 0xe0, 0x09, 0xf0, 0x04, 0x4a, 0xe8, 0xd0, + 0xf8, 0x91, 0xf7, 0xa9, 0x20, 0x2c, 0x94, 0x02, 0xf0, 0xb4, 0x30, 0xb1, 0xa5, 0xa7, 0x45, 0xab, + 0xf0, 0x03, 0x70, 0xa9, 0x2c, 0x50, 0xa6, 0xa9, 0x01, 0x2c, 0xa9, 0x04, 0x2c, 0xa9, 0x80, 0x2c, + 0xa9, 0x02, 0x0d, 0x97, 0x02, 0x8d, 0x97, 0x02, 0x4c, 0x7e, 0xef, 0xa5, 0xaa, 0xd0, 0xf1, 0xf0, + 0xec, 0x85, 0x9a, 0xad, 0x94, 0x02, 0x4a, 0x90, 0x29, 0xa9, 0x02, 0x2c, 0x01, 0xdd, 0x10, 0x1d, + 0xd0, 0x20, 0xad, 0xa1, 0x02, 0x29, 0x02, 0xd0, 0xf9, 0x2c, 0x01, 0xdd, 0x70, 0xfb, 0xad, 0x01, + 0xdd, 0x09, 0x02, 0x8d, 0x01, 0xdd, 0x2c, 0x01, 0xdd, 0x70, 0x07, 0x30, 0xf9, 0xa9, 0x40, 0x8d, + 0x97, 0x02, 0x18, 0x60, 0x20, 0x28, 0xf0, 0xac, 0x9e, 0x02, 0xc8, 0xcc, 0x9d, 0x02, 0xf0, 0xf4, + 0x8c, 0x9e, 0x02, 0x88, 0xa5, 0x9e, 0x91, 0xf9, 0xad, 0xa1, 0x02, 0x4a, 0xb0, 0x1e, 0xa9, 0x10, + 0x8d, 0x0e, 0xdd, 0xad, 0x99, 0x02, 0x8d, 0x04, 0xdd, 0xad, 0x9a, 0x02, 0x8d, 0x05, 0xdd, 0xa9, + 0x81, 0x20, 0x3b, 0xef, 0x20, 0x06, 0xef, 0xa9, 0x11, 0x8d, 0x0e, 0xdd, 0x60, 0x85, 0x99, 0xad, + 0x94, 0x02, 0x4a, 0x90, 0x28, 0x29, 0x08, 0xf0, 0x24, 0xa9, 0x02, 0x2c, 0x01, 0xdd, 0x10, 0xad, + 0xf0, 0x22, 0xad, 0xa1, 0x02, 0x4a, 0xb0, 0xfa, 0xad, 0x01, 0xdd, 0x29, 0xfd, 0x8d, 0x01, 0xdd, + 0xad, 0x01, 0xdd, 0x29, 0x04, 0xf0, 0xf9, 0xa9, 0x90, 0x18, 0x4c, 0x3b, 0xef, 0xad, 0xa1, 0x02, + 0x29, 0x12, 0xf0, 0xf3, 0x18, 0x60, 0xad, 0x97, 0x02, 0xac, 0x9c, 0x02, 0xcc, 0x9b, 0x02, 0xf0, + 0x0b, 0x29, 0xf7, 0x8d, 0x97, 0x02, 0xb1, 0xf7, 0xee, 0x9c, 0x02, 0x60, 0x09, 0x08, 0x8d, 0x97, + 0x02, 0xa9, 0x00, 0x60, 0x48, 0xad, 0xa1, 0x02, 0xf0, 0x11, 0xad, 0xa1, 0x02, 0x29, 0x03, 0xd0, + 0xf9, 0xa9, 0x10, 0x8d, 0x0d, 0xdd, 0xa9, 0x00, 0x8d, 0xa1, 0x02, 0x68, 0x60, 0x0d, 0x49, 0x2f, + 0x4f, 0x20, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x20, 0xa3, 0x0d, 0x53, 0x45, 0x41, 0x52, 0x43, 0x48, + 0x49, 0x4e, 0x47, 0xa0, 0x46, 0x4f, 0x52, 0xa0, 0x0d, 0x50, 0x52, 0x45, 0x53, 0x53, 0x20, 0x50, + 0x4c, 0x41, 0x59, 0x20, 0x4f, 0x4e, 0x20, 0x54, 0x41, 0x50, 0xc5, 0x50, 0x52, 0x45, 0x53, 0x53, + 0x20, 0x52, 0x45, 0x43, 0x4f, 0x52, 0x44, 0x20, 0x26, 0x20, 0x50, 0x4c, 0x41, 0x59, 0x20, 0x4f, + 0x4e, 0x20, 0x54, 0x41, 0x50, 0xc5, 0x0d, 0x4c, 0x4f, 0x41, 0x44, 0x49, 0x4e, 0xc7, 0x0d, 0x53, + 0x41, 0x56, 0x49, 0x4e, 0x47, 0xa0, 0x0d, 0x56, 0x45, 0x52, 0x49, 0x46, 0x59, 0x49, 0x4e, 0xc7, + 0x0d, 0x46, 0x4f, 0x55, 0x4e, 0x44, 0xa0, 0x0d, 0x4f, 0x4b, 0x8d, 0x24, 0x9d, 0x10, 0x0d, 0xb9, + 0xbd, 0xf0, 0x08, 0x29, 0x7f, 0x20, 0xd2, 0xff, 0xc8, 0x28, 0x10, 0xf3, 0x18, 0x60, 0xa5, 0x99, + 0xd0, 0x08, 0xa5, 0xc6, 0xf0, 0x0f, 0x78, 0x4c, 0xb4, 0xe5, 0xc9, 0x02, 0xd0, 0x18, 0x84, 0x97, + 0x20, 0x86, 0xf0, 0xa4, 0x97, 0x18, 0x60, 0xa5, 0x99, 0xd0, 0x0b, 0xa5, 0xd3, 0x85, 0xca, 0xa5, + 0xd6, 0x85, 0xc9, 0x4c, 0x32, 0xe6, 0xc9, 0x03, 0xd0, 0x09, 0x85, 0xd0, 0xa5, 0xd5, 0x85, 0xc8, + 0x4c, 0x32, 0xe6, 0xb0, 0x38, 0xc9, 0x02, 0xf0, 0x3f, 0x86, 0x97, 0x20, 0x99, 0xf1, 0xb0, 0x16, + 0x48, 0x20, 0x99, 0xf1, 0xb0, 0x0d, 0xd0, 0x05, 0xa9, 0x40, 0x20, 0x1c, 0xfe, 0xc6, 0xa6, 0xa6, + 0x97, 0x68, 0x60, 0xaa, 0x68, 0x8a, 0xa6, 0x97, 0x60, 0x20, 0x0d, 0xf8, 0xd0, 0x0b, 0x20, 0x41, + 0xf8, 0xb0, 0x11, 0xa9, 0x00, 0x85, 0xa6, 0xf0, 0xf0, 0xb1, 0xb2, 0x18, 0x60, 0xa5, 0x90, 0xf0, + 0x04, 0xa9, 0x0d, 0x18, 0x60, 0x4c, 0x13, 0xee, 0x20, 0x4e, 0xf1, 0xb0, 0xf7, 0xc9, 0x00, 0xd0, + 0xf2, 0xad, 0x97, 0x02, 0x29, 0x60, 0xd0, 0xe9, 0xf0, 0xee, 0x48, 0xa5, 0x9a, 0xc9, 0x03, 0xd0, + 0x04, 0x68, 0x4c, 0x16, 0xe7, 0x90, 0x04, 0x68, 0x4c, 0xdd, 0xed, 0x4a, 0x68, 0x85, 0x9e, 0x8a, + 0x48, 0x98, 0x48, 0x90, 0x23, 0x20, 0x0d, 0xf8, 0xd0, 0x0e, 0x20, 0x64, 0xf8, 0xb0, 0x0e, 0xa9, + 0x02, 0xa0, 0x00, 0x91, 0xb2, 0xc8, 0x84, 0xa6, 0xa5, 0x9e, 0x91, 0xb2, 0x18, 0x68, 0xa8, 0x68, + 0xaa, 0xa5, 0x9e, 0x90, 0x02, 0xa9, 0x00, 0x60, 0x20, 0x17, 0xf0, 0x4c, 0xfc, 0xf1, 0x20, 0x0f, + 0xf3, 0xf0, 0x03, 0x4c, 0x01, 0xf7, 0x20, 0x1f, 0xf3, 0xa5, 0xba, 0xf0, 0x16, 0xc9, 0x03, 0xf0, + 0x12, 0xb0, 0x14, 0xc9, 0x02, 0xd0, 0x03, 0x4c, 0x4d, 0xf0, 0xa6, 0xb9, 0xe0, 0x60, 0xf0, 0x03, + 0x4c, 0x0a, 0xf7, 0x85, 0x99, 0x18, 0x60, 0xaa, 0x20, 0x09, 0xed, 0xa5, 0xb9, 0x10, 0x06, 0x20, + 0xcc, 0xed, 0x4c, 0x48, 0xf2, 0x20, 0xc7, 0xed, 0x8a, 0x24, 0x90, 0x10, 0xe6, 0x4c, 0x07, 0xf7, + 0x20, 0x0f, 0xf3, 0xf0, 0x03, 0x4c, 0x01, 0xf7, 0x20, 0x1f, 0xf3, 0xa5, 0xba, 0xd0, 0x03, 0x4c, + 0x0d, 0xf7, 0xc9, 0x03, 0xf0, 0x0f, 0xb0, 0x11, 0xc9, 0x02, 0xd0, 0x03, 0x4c, 0xe1, 0xef, 0xa6, + 0xb9, 0xe0, 0x60, 0xf0, 0xea, 0x85, 0x9a, 0x18, 0x60, 0xaa, 0x20, 0x0c, 0xed, 0xa5, 0xb9, 0x10, + 0x05, 0x20, 0xbe, 0xed, 0xd0, 0x03, 0x20, 0xb9, 0xed, 0x8a, 0x24, 0x90, 0x10, 0xe7, 0x4c, 0x07, + 0xf7, 0x20, 0x14, 0xf3, 0xf0, 0x02, 0x18, 0x60, 0x20, 0x1f, 0xf3, 0x8a, 0x48, 0xa5, 0xba, 0xf0, + 0x50, 0xc9, 0x03, 0xf0, 0x4c, 0xb0, 0x47, 0xc9, 0x02, 0xd0, 0x1d, 0x68, 0x20, 0xf2, 0xf2, 0x20, + 0x83, 0xf4, 0x20, 0x27, 0xfe, 0xa5, 0xf8, 0xf0, 0x01, 0xc8, 0xa5, 0xfa, 0xf0, 0x01, 0xc8, 0xa9, + 0x00, 0x85, 0xf8, 0x85, 0xfa, 0x4c, 0x7d, 0xf4, 0xa5, 0xb9, 0x29, 0x0f, 0xf0, 0x23, 0x20, 0xd0, + 0xf7, 0xa9, 0x00, 0x38, 0x20, 0xdd, 0xf1, 0x20, 0x64, 0xf8, 0x90, 0x04, 0x68, 0xa9, 0x00, 0x60, + 0xa5, 0xb9, 0xc9, 0x62, 0xd0, 0x0b, 0xa9, 0x05, 0x20, 0x6a, 0xf7, 0x4c, 0xf1, 0xf2, 0x20, 0x42, + 0xf6, 0x68, 0xaa, 0xc6, 0x98, 0xe4, 0x98, 0xf0, 0x14, 0xa4, 0x98, 0xb9, 0x59, 0x02, 0x9d, 0x59, + 0x02, 0xb9, 0x63, 0x02, 0x9d, 0x63, 0x02, 0xb9, 0x6d, 0x02, 0x9d, 0x6d, 0x02, 0x18, 0x60, 0xa9, + 0x00, 0x85, 0x90, 0x8a, 0xa6, 0x98, 0xca, 0x30, 0x15, 0xdd, 0x59, 0x02, 0xd0, 0xf8, 0x60, 0xbd, + 0x59, 0x02, 0x85, 0xb8, 0xbd, 0x63, 0x02, 0x85, 0xba, 0xbd, 0x6d, 0x02, 0x85, 0xb9, 0x60, 0xa9, + 0x00, 0x85, 0x98, 0xa2, 0x03, 0xe4, 0x9a, 0xb0, 0x03, 0x20, 0xfe, 0xed, 0xe4, 0x99, 0xb0, 0x03, + 0x20, 0xef, 0xed, 0x86, 0x9a, 0xa9, 0x00, 0x85, 0x99, 0x60, 0xa6, 0xb8, 0xd0, 0x03, 0x4c, 0x0a, + 0xf7, 0x20, 0x0f, 0xf3, 0xd0, 0x03, 0x4c, 0xfe, 0xf6, 0xa6, 0x98, 0xe0, 0x0a, 0x90, 0x03, 0x4c, + 0xfb, 0xf6, 0xe6, 0x98, 0xa5, 0xb8, 0x9d, 0x59, 0x02, 0xa5, 0xb9, 0x09, 0x60, 0x85, 0xb9, 0x9d, + 0x6d, 0x02, 0xa5, 0xba, 0x9d, 0x63, 0x02, 0xf0, 0x5a, 0xc9, 0x03, 0xf0, 0x56, 0x90, 0x05, 0x20, + 0xd5, 0xf3, 0x90, 0x4f, 0xc9, 0x02, 0xd0, 0x03, 0x4c, 0x09, 0xf4, 0x20, 0xd0, 0xf7, 0xb0, 0x03, + 0x4c, 0x13, 0xf7, 0xa5, 0xb9, 0x29, 0x0f, 0xd0, 0x1f, 0x20, 0x17, 0xf8, 0xb0, 0x36, 0x20, 0xaf, + 0xf5, 0xa5, 0xb7, 0xf0, 0x0a, 0x20, 0xea, 0xf7, 0x90, 0x18, 0xf0, 0x28, 0x4c, 0x04, 0xf7, 0x20, + 0x2c, 0xf7, 0xf0, 0x20, 0x90, 0x0c, 0xb0, 0xf4, 0x20, 0x38, 0xf8, 0xb0, 0x17, 0xa9, 0x04, 0x20, + 0x6a, 0xf7, 0xa9, 0xbf, 0xa4, 0xb9, 0xc0, 0x60, 0xf0, 0x07, 0xa0, 0x00, 0xa9, 0x02, 0x91, 0xb2, + 0x98, 0x85, 0xa6, 0x18, 0x60, 0xa5, 0xb9, 0x30, 0xfa, 0xa4, 0xb7, 0xf0, 0xf6, 0xa9, 0x00, 0x85, + 0x90, 0xa5, 0xba, 0x20, 0x0c, 0xed, 0xa5, 0xb9, 0x09, 0xf0, 0x20, 0xb9, 0xed, 0xa5, 0x90, 0x10, + 0x05, 0x68, 0x68, 0x4c, 0x07, 0xf7, 0xa5, 0xb7, 0xf0, 0x0c, 0xa0, 0x00, 0xb1, 0xbb, 0x20, 0xdd, + 0xed, 0xc8, 0xc4, 0xb7, 0xd0, 0xf6, 0x4c, 0x54, 0xf6, 0x20, 0x83, 0xf4, 0x8c, 0x97, 0x02, 0xc4, + 0xb7, 0xf0, 0x0a, 0xb1, 0xbb, 0x99, 0x93, 0x02, 0xc8, 0xc0, 0x04, 0xd0, 0xf2, 0x20, 0x4a, 0xef, + 0x8e, 0x98, 0x02, 0xad, 0x93, 0x02, 0x29, 0x0f, 0xf0, 0x1c, 0x0a, 0xaa, 0xad, 0xa6, 0x02, 0xd0, + 0x09, 0xbc, 0xc1, 0xfe, 0xbd, 0xc0, 0xfe, 0x4c, 0x40, 0xf4, 0xbc, 0xeb, 0xe4, 0xbd, 0xea, 0xe4, + 0x8c, 0x96, 0x02, 0x8d, 0x95, 0x02, 0xad, 0x95, 0x02, 0x0a, 0x20, 0x2e, 0xff, 0xad, 0x94, 0x02, + 0x4a, 0x90, 0x09, 0xad, 0x01, 0xdd, 0x0a, 0xb0, 0x03, 0x20, 0x0d, 0xf0, 0xad, 0x9b, 0x02, 0x8d, + 0x9c, 0x02, 0xad, 0x9e, 0x02, 0x8d, 0x9d, 0x02, 0x20, 0x27, 0xfe, 0xa5, 0xf8, 0xd0, 0x05, 0x88, + 0x84, 0xf8, 0x86, 0xf7, 0xa5, 0xfa, 0xd0, 0x05, 0x88, 0x84, 0xfa, 0x86, 0xf9, 0x38, 0xa9, 0xf0, + 0x4c, 0x2d, 0xfe, 0xa9, 0x7f, 0x8d, 0x0d, 0xdd, 0xa9, 0x06, 0x8d, 0x03, 0xdd, 0x8d, 0x01, 0xdd, + 0xa9, 0x04, 0x0d, 0x00, 0xdd, 0x8d, 0x00, 0xdd, 0xa0, 0x00, 0x8c, 0xa1, 0x02, 0x60, 0x86, 0xc3, + 0x84, 0xc4, 0x6c, 0x30, 0x03, 0x85, 0x93, 0xa9, 0x00, 0x85, 0x90, 0xa5, 0xba, 0xd0, 0x03, 0x4c, + 0x13, 0xf7, 0xc9, 0x03, 0xf0, 0xf9, 0x90, 0x7b, 0xa4, 0xb7, 0xd0, 0x03, 0x4c, 0x10, 0xf7, 0xa6, + 0xb9, 0x20, 0xaf, 0xf5, 0xa9, 0x60, 0x85, 0xb9, 0x20, 0xd5, 0xf3, 0xa5, 0xba, 0x20, 0x09, 0xed, + 0xa5, 0xb9, 0x20, 0xc7, 0xed, 0x20, 0x13, 0xee, 0x85, 0xae, 0xa5, 0x90, 0x4a, 0x4a, 0xb0, 0x50, + 0x20, 0x13, 0xee, 0x85, 0xaf, 0x8a, 0xd0, 0x08, 0xa5, 0xc3, 0x85, 0xae, 0xa5, 0xc4, 0x85, 0xaf, + 0x20, 0xd2, 0xf5, 0xa9, 0xfd, 0x25, 0x90, 0x85, 0x90, 0x20, 0xe1, 0xff, 0xd0, 0x03, 0x4c, 0x33, + 0xf6, 0x20, 0x13, 0xee, 0xaa, 0xa5, 0x90, 0x4a, 0x4a, 0xb0, 0xe8, 0x8a, 0xa4, 0x93, 0xf0, 0x0c, + 0xa0, 0x00, 0xd1, 0xae, 0xf0, 0x08, 0xa9, 0x10, 0x20, 0x1c, 0xfe, 0x2c, 0x91, 0xae, 0xe6, 0xae, + 0xd0, 0x02, 0xe6, 0xaf, 0x24, 0x90, 0x50, 0xcb, 0x20, 0xef, 0xed, 0x20, 0x42, 0xf6, 0x90, 0x79, + 0x4c, 0x04, 0xf7, 0x4a, 0xb0, 0x03, 0x4c, 0x13, 0xf7, 0x20, 0xd0, 0xf7, 0xb0, 0x03, 0x4c, 0x13, + 0xf7, 0x20, 0x17, 0xf8, 0xb0, 0x68, 0x20, 0xaf, 0xf5, 0xa5, 0xb7, 0xf0, 0x09, 0x20, 0xea, 0xf7, + 0x90, 0x0b, 0xf0, 0x5a, 0xb0, 0xda, 0x20, 0x2c, 0xf7, 0xf0, 0x53, 0xb0, 0xd3, 0xa5, 0x90, 0x29, + 0x10, 0x38, 0xd0, 0x4a, 0xe0, 0x01, 0xf0, 0x11, 0xe0, 0x03, 0xd0, 0xdd, 0xa0, 0x01, 0xb1, 0xb2, + 0x85, 0xc3, 0xc8, 0xb1, 0xb2, 0x85, 0xc4, 0xb0, 0x04, 0xa5, 0xb9, 0xd0, 0xef, 0xa0, 0x03, 0xb1, + 0xb2, 0xa0, 0x01, 0xf1, 0xb2, 0xaa, 0xa0, 0x04, 0xb1, 0xb2, 0xa0, 0x02, 0xf1, 0xb2, 0xa8, 0x18, + 0x8a, 0x65, 0xc3, 0x85, 0xae, 0x98, 0x65, 0xc4, 0x85, 0xaf, 0xa5, 0xc3, 0x85, 0xc1, 0xa5, 0xc4, + 0x85, 0xc2, 0x20, 0xd2, 0xf5, 0x20, 0x4a, 0xf8, 0x24, 0x18, 0xa6, 0xae, 0xa4, 0xaf, 0x60, 0xa5, + 0x9d, 0x10, 0x1e, 0xa0, 0x0c, 0x20, 0x2f, 0xf1, 0xa5, 0xb7, 0xf0, 0x15, 0xa0, 0x17, 0x20, 0x2f, + 0xf1, 0xa4, 0xb7, 0xf0, 0x0c, 0xa0, 0x00, 0xb1, 0xbb, 0x20, 0xd2, 0xff, 0xc8, 0xc4, 0xb7, 0xd0, + 0xf6, 0x60, 0xa0, 0x49, 0xa5, 0x93, 0xf0, 0x02, 0xa0, 0x59, 0x4c, 0x2b, 0xf1, 0x86, 0xae, 0x84, + 0xaf, 0xaa, 0xb5, 0x00, 0x85, 0xc1, 0xb5, 0x01, 0x85, 0xc2, 0x6c, 0x32, 0x03, 0xa5, 0xba, 0xd0, + 0x03, 0x4c, 0x13, 0xf7, 0xc9, 0x03, 0xf0, 0xf9, 0x90, 0x5f, 0xa9, 0x61, 0x85, 0xb9, 0xa4, 0xb7, + 0xd0, 0x03, 0x4c, 0x10, 0xf7, 0x20, 0xd5, 0xf3, 0x20, 0x8f, 0xf6, 0xa5, 0xba, 0x20, 0x0c, 0xed, + 0xa5, 0xb9, 0x20, 0xb9, 0xed, 0xa0, 0x00, 0x20, 0x8e, 0xfb, 0xa5, 0xac, 0x20, 0xdd, 0xed, 0xa5, + 0xad, 0x20, 0xdd, 0xed, 0x20, 0xd1, 0xfc, 0xb0, 0x16, 0xb1, 0xac, 0x20, 0xdd, 0xed, 0x20, 0xe1, + 0xff, 0xd0, 0x07, 0x20, 0x42, 0xf6, 0xa9, 0x00, 0x38, 0x60, 0x20, 0xdb, 0xfc, 0xd0, 0xe5, 0x20, + 0xfe, 0xed, 0x24, 0xb9, 0x30, 0x11, 0xa5, 0xba, 0x20, 0x0c, 0xed, 0xa5, 0xb9, 0x29, 0xef, 0x09, + 0xe0, 0x20, 0xb9, 0xed, 0x20, 0xfe, 0xed, 0x18, 0x60, 0x4a, 0xb0, 0x03, 0x4c, 0x13, 0xf7, 0x20, + 0xd0, 0xf7, 0x90, 0x8d, 0x20, 0x38, 0xf8, 0xb0, 0x25, 0x20, 0x8f, 0xf6, 0xa2, 0x03, 0xa5, 0xb9, + 0x29, 0x01, 0xd0, 0x02, 0xa2, 0x01, 0x8a, 0x20, 0x6a, 0xf7, 0xb0, 0x12, 0x20, 0x67, 0xf8, 0xb0, + 0x0d, 0xa5, 0xb9, 0x29, 0x02, 0xf0, 0x06, 0xa9, 0x05, 0x20, 0x6a, 0xf7, 0x24, 0x18, 0x60, 0xa5, + 0x9d, 0x10, 0xfb, 0xa0, 0x51, 0x20, 0x2f, 0xf1, 0x4c, 0xc1, 0xf5, 0xa2, 0x00, 0xe6, 0xa2, 0xd0, + 0x06, 0xe6, 0xa1, 0xd0, 0x02, 0xe6, 0xa0, 0x38, 0xa5, 0xa2, 0xe9, 0x01, 0xa5, 0xa1, 0xe9, 0x1a, + 0xa5, 0xa0, 0xe9, 0x4f, 0x90, 0x06, 0x86, 0xa0, 0x86, 0xa1, 0x86, 0xa2, 0xad, 0x01, 0xdc, 0xcd, + 0x01, 0xdc, 0xd0, 0xf8, 0xaa, 0x30, 0x13, 0xa2, 0xbd, 0x8e, 0x00, 0xdc, 0xae, 0x01, 0xdc, 0xec, + 0x01, 0xdc, 0xd0, 0xf8, 0x8d, 0x00, 0xdc, 0xe8, 0xd0, 0x02, 0x85, 0x91, 0x60, 0x78, 0xa5, 0xa2, + 0xa6, 0xa1, 0xa4, 0xa0, 0x78, 0x85, 0xa2, 0x86, 0xa1, 0x84, 0xa0, 0x58, 0x60, 0xa5, 0x91, 0xc9, + 0x7f, 0xd0, 0x07, 0x08, 0x20, 0xcc, 0xff, 0x85, 0xc6, 0x28, 0x60, 0xa9, 0x01, 0x2c, 0xa9, 0x02, + 0x2c, 0xa9, 0x03, 0x2c, 0xa9, 0x04, 0x2c, 0xa9, 0x05, 0x2c, 0xa9, 0x06, 0x2c, 0xa9, 0x07, 0x2c, + 0xa9, 0x08, 0x2c, 0xa9, 0x09, 0x48, 0x20, 0xcc, 0xff, 0xa0, 0x00, 0x24, 0x9d, 0x50, 0x0a, 0x20, + 0x2f, 0xf1, 0x68, 0x48, 0x09, 0x30, 0x20, 0xd2, 0xff, 0x68, 0x38, 0x60, 0xa5, 0x93, 0x48, 0x20, + 0x41, 0xf8, 0x68, 0x85, 0x93, 0xb0, 0x32, 0xa0, 0x00, 0xb1, 0xb2, 0xc9, 0x05, 0xf0, 0x2a, 0xc9, + 0x01, 0xf0, 0x08, 0xc9, 0x03, 0xf0, 0x04, 0xc9, 0x04, 0xd0, 0xe1, 0xaa, 0x24, 0x9d, 0x10, 0x17, + 0xa0, 0x63, 0x20, 0x2f, 0xf1, 0xa0, 0x05, 0xb1, 0xb2, 0x20, 0xd2, 0xff, 0xc8, 0xc0, 0x15, 0xd0, + 0xf6, 0xa5, 0xa1, 0x20, 0xe0, 0xe4, 0xea, 0x18, 0x88, 0x60, 0x85, 0x9e, 0x20, 0xd0, 0xf7, 0x90, + 0x5e, 0xa5, 0xc2, 0x48, 0xa5, 0xc1, 0x48, 0xa5, 0xaf, 0x48, 0xa5, 0xae, 0x48, 0xa0, 0xbf, 0xa9, + 0x20, 0x91, 0xb2, 0x88, 0xd0, 0xfb, 0xa5, 0x9e, 0x91, 0xb2, 0xc8, 0xa5, 0xc1, 0x91, 0xb2, 0xc8, + 0xa5, 0xc2, 0x91, 0xb2, 0xc8, 0xa5, 0xae, 0x91, 0xb2, 0xc8, 0xa5, 0xaf, 0x91, 0xb2, 0xc8, 0x84, + 0x9f, 0xa0, 0x00, 0x84, 0x9e, 0xa4, 0x9e, 0xc4, 0xb7, 0xf0, 0x0c, 0xb1, 0xbb, 0xa4, 0x9f, 0x91, + 0xb2, 0xe6, 0x9e, 0xe6, 0x9f, 0xd0, 0xee, 0x20, 0xd7, 0xf7, 0xa9, 0x69, 0x85, 0xab, 0x20, 0x6b, + 0xf8, 0xa8, 0x68, 0x85, 0xae, 0x68, 0x85, 0xaf, 0x68, 0x85, 0xc1, 0x68, 0x85, 0xc2, 0x98, 0x60, + 0xa6, 0xb2, 0xa4, 0xb3, 0xc0, 0x02, 0x60, 0x20, 0xd0, 0xf7, 0x8a, 0x85, 0xc1, 0x18, 0x69, 0xc0, + 0x85, 0xae, 0x98, 0x85, 0xc2, 0x69, 0x00, 0x85, 0xaf, 0x60, 0x20, 0x2c, 0xf7, 0xb0, 0x1d, 0xa0, + 0x05, 0x84, 0x9f, 0xa0, 0x00, 0x84, 0x9e, 0xc4, 0xb7, 0xf0, 0x10, 0xb1, 0xbb, 0xa4, 0x9f, 0xd1, + 0xb2, 0xd0, 0xe7, 0xe6, 0x9e, 0xe6, 0x9f, 0xa4, 0x9e, 0xd0, 0xec, 0x18, 0x60, 0x20, 0xd0, 0xf7, + 0xe6, 0xa6, 0xa4, 0xa6, 0xc0, 0xc0, 0x60, 0x20, 0x2e, 0xf8, 0xf0, 0x1a, 0xa0, 0x1b, 0x20, 0x2f, + 0xf1, 0x20, 0xd0, 0xf8, 0x20, 0x2e, 0xf8, 0xd0, 0xf8, 0xa0, 0x6a, 0x4c, 0x2f, 0xf1, 0xa9, 0x10, + 0x24, 0x01, 0xd0, 0x02, 0x24, 0x01, 0x18, 0x60, 0x20, 0x2e, 0xf8, 0xf0, 0xf9, 0xa0, 0x2e, 0xd0, + 0xdd, 0xa9, 0x00, 0x85, 0x90, 0x85, 0x93, 0x20, 0xd7, 0xf7, 0x20, 0x17, 0xf8, 0xb0, 0x1f, 0x78, + 0xa9, 0x00, 0x85, 0xaa, 0x85, 0xb4, 0x85, 0xb0, 0x85, 0x9e, 0x85, 0x9f, 0x85, 0x9c, 0xa9, 0x90, + 0xa2, 0x0e, 0xd0, 0x11, 0x20, 0xd7, 0xf7, 0xa9, 0x14, 0x85, 0xab, 0x20, 0x38, 0xf8, 0xb0, 0x6c, + 0x78, 0xa9, 0x82, 0xa2, 0x08, 0xa0, 0x7f, 0x8c, 0x0d, 0xdc, 0x8d, 0x0d, 0xdc, 0xad, 0x0e, 0xdc, + 0x09, 0x19, 0x8d, 0x0f, 0xdc, 0x29, 0x91, 0x8d, 0xa2, 0x02, 0x20, 0xa4, 0xf0, 0xad, 0x11, 0xd0, + 0x29, 0xef, 0x8d, 0x11, 0xd0, 0xad, 0x14, 0x03, 0x8d, 0x9f, 0x02, 0xad, 0x15, 0x03, 0x8d, 0xa0, + 0x02, 0x20, 0xbd, 0xfc, 0xa9, 0x02, 0x85, 0xbe, 0x20, 0x97, 0xfb, 0xa5, 0x01, 0x29, 0x1f, 0x85, + 0x01, 0x85, 0xc0, 0xa2, 0xff, 0xa0, 0xff, 0x88, 0xd0, 0xfd, 0xca, 0xd0, 0xf8, 0x58, 0xad, 0xa0, + 0x02, 0xcd, 0x15, 0x03, 0x18, 0xf0, 0x15, 0x20, 0xd0, 0xf8, 0x20, 0xbc, 0xf6, 0x4c, 0xbe, 0xf8, + 0x20, 0xe1, 0xff, 0x18, 0xd0, 0x0b, 0x20, 0x93, 0xfc, 0x38, 0x68, 0x68, 0xa9, 0x00, 0x8d, 0xa0, + 0x02, 0x60, 0x86, 0xb1, 0xa5, 0xb0, 0x0a, 0x0a, 0x18, 0x65, 0xb0, 0x18, 0x65, 0xb1, 0x85, 0xb1, + 0xa9, 0x00, 0x24, 0xb0, 0x30, 0x01, 0x2a, 0x06, 0xb1, 0x2a, 0x06, 0xb1, 0x2a, 0xaa, 0xad, 0x06, + 0xdc, 0xc9, 0x16, 0x90, 0xf9, 0x65, 0xb1, 0x8d, 0x04, 0xdc, 0x8a, 0x6d, 0x07, 0xdc, 0x8d, 0x05, + 0xdc, 0xad, 0xa2, 0x02, 0x8d, 0x0e, 0xdc, 0x8d, 0xa4, 0x02, 0xad, 0x0d, 0xdc, 0x29, 0x10, 0xf0, + 0x09, 0xa9, 0xf9, 0x48, 0xa9, 0x2a, 0x48, 0x4c, 0x43, 0xff, 0x58, 0x60, 0xae, 0x07, 0xdc, 0xa0, + 0xff, 0x98, 0xed, 0x06, 0xdc, 0xec, 0x07, 0xdc, 0xd0, 0xf2, 0x86, 0xb1, 0xaa, 0x8c, 0x06, 0xdc, + 0x8c, 0x07, 0xdc, 0xa9, 0x19, 0x8d, 0x0f, 0xdc, 0xad, 0x0d, 0xdc, 0x8d, 0xa3, 0x02, 0x98, 0xe5, + 0xb1, 0x86, 0xb1, 0x4a, 0x66, 0xb1, 0x4a, 0x66, 0xb1, 0xa5, 0xb0, 0x18, 0x69, 0x3c, 0xc5, 0xb1, + 0xb0, 0x4a, 0xa6, 0x9c, 0xf0, 0x03, 0x4c, 0x60, 0xfa, 0xa6, 0xa3, 0x30, 0x1b, 0xa2, 0x00, 0x69, + 0x30, 0x65, 0xb0, 0xc5, 0xb1, 0xb0, 0x1c, 0xe8, 0x69, 0x26, 0x65, 0xb0, 0xc5, 0xb1, 0xb0, 0x17, + 0x69, 0x2c, 0x65, 0xb0, 0xc5, 0xb1, 0x90, 0x03, 0x4c, 0x10, 0xfa, 0xa5, 0xb4, 0xf0, 0x1d, 0x85, + 0xa8, 0xd0, 0x19, 0xe6, 0xa9, 0xb0, 0x02, 0xc6, 0xa9, 0x38, 0xe9, 0x13, 0xe5, 0xb1, 0x65, 0x92, + 0x85, 0x92, 0xa5, 0xa4, 0x49, 0x01, 0x85, 0xa4, 0xf0, 0x2b, 0x86, 0xd7, 0xa5, 0xb4, 0xf0, 0x22, + 0xad, 0xa3, 0x02, 0x29, 0x01, 0xd0, 0x05, 0xad, 0xa4, 0x02, 0xd0, 0x16, 0xa9, 0x00, 0x85, 0xa4, + 0x8d, 0xa4, 0x02, 0xa5, 0xa3, 0x10, 0x30, 0x30, 0xbf, 0xa2, 0xa6, 0x20, 0xe2, 0xf8, 0xa5, 0x9b, + 0xd0, 0xb9, 0x4c, 0xbc, 0xfe, 0xa5, 0x92, 0xf0, 0x07, 0x30, 0x03, 0xc6, 0xb0, 0x2c, 0xe6, 0xb0, + 0xa9, 0x00, 0x85, 0x92, 0xe4, 0xd7, 0xd0, 0x0f, 0x8a, 0xd0, 0xa0, 0xa5, 0xa9, 0x30, 0xbd, 0xc9, + 0x10, 0x90, 0xb9, 0x85, 0x96, 0xb0, 0xb5, 0x8a, 0x45, 0x9b, 0x85, 0x9b, 0xa5, 0xb4, 0xf0, 0xd2, + 0xc6, 0xa3, 0x30, 0xc5, 0x46, 0xd7, 0x66, 0xbf, 0xa2, 0xda, 0x20, 0xe2, 0xf8, 0x4c, 0xbc, 0xfe, + 0xa5, 0x96, 0xf0, 0x04, 0xa5, 0xb4, 0xf0, 0x07, 0xa5, 0xa3, 0x30, 0x03, 0x4c, 0x97, 0xf9, 0x46, + 0xb1, 0xa9, 0x93, 0x38, 0xe5, 0xb1, 0x65, 0xb0, 0x0a, 0xaa, 0x20, 0xe2, 0xf8, 0xe6, 0x9c, 0xa5, + 0xb4, 0xd0, 0x11, 0xa5, 0x96, 0xf0, 0x26, 0x85, 0xa8, 0xa9, 0x00, 0x85, 0x96, 0xa9, 0x81, 0x8d, + 0x0d, 0xdc, 0x85, 0xb4, 0xa5, 0x96, 0x85, 0xb5, 0xf0, 0x09, 0xa9, 0x00, 0x85, 0xb4, 0xa9, 0x01, + 0x8d, 0x0d, 0xdc, 0xa5, 0xbf, 0x85, 0xbd, 0xa5, 0xa8, 0x05, 0xa9, 0x85, 0xb6, 0x4c, 0xbc, 0xfe, + 0x20, 0x97, 0xfb, 0x85, 0x9c, 0xa2, 0xda, 0x20, 0xe2, 0xf8, 0xa5, 0xbe, 0xf0, 0x02, 0x85, 0xa7, + 0xa9, 0x0f, 0x24, 0xaa, 0x10, 0x17, 0xa5, 0xb5, 0xd0, 0x0c, 0xa6, 0xbe, 0xca, 0xd0, 0x0b, 0xa9, + 0x08, 0x20, 0x1c, 0xfe, 0xd0, 0x04, 0xa9, 0x00, 0x85, 0xaa, 0x4c, 0xbc, 0xfe, 0x70, 0x31, 0xd0, + 0x18, 0xa5, 0xb5, 0xd0, 0xf5, 0xa5, 0xb6, 0xd0, 0xf1, 0xa5, 0xa7, 0x4a, 0xa5, 0xbd, 0x30, 0x03, + 0x90, 0x18, 0x18, 0xb0, 0x15, 0x29, 0x0f, 0x85, 0xaa, 0xc6, 0xaa, 0xd0, 0xdd, 0xa9, 0x40, 0x85, + 0xaa, 0x20, 0x8e, 0xfb, 0xa9, 0x00, 0x85, 0xab, 0xf0, 0xd0, 0xa9, 0x80, 0x85, 0xaa, 0xd0, 0xca, + 0xa5, 0xb5, 0xf0, 0x0a, 0xa9, 0x04, 0x20, 0x1c, 0xfe, 0xa9, 0x00, 0x4c, 0x4a, 0xfb, 0x20, 0xd1, + 0xfc, 0x90, 0x03, 0x4c, 0x48, 0xfb, 0xa6, 0xa7, 0xca, 0xf0, 0x2d, 0xa5, 0x93, 0xf0, 0x0c, 0xa0, + 0x00, 0xa5, 0xbd, 0xd1, 0xac, 0xf0, 0x04, 0xa9, 0x01, 0x85, 0xb6, 0xa5, 0xb6, 0xf0, 0x4b, 0xa2, + 0x3d, 0xe4, 0x9e, 0x90, 0x3e, 0xa6, 0x9e, 0xa5, 0xad, 0x9d, 0x01, 0x01, 0xa5, 0xac, 0x9d, 0x00, + 0x01, 0xe8, 0xe8, 0x86, 0x9e, 0x4c, 0x3a, 0xfb, 0xa6, 0x9f, 0xe4, 0x9e, 0xf0, 0x35, 0xa5, 0xac, + 0xdd, 0x00, 0x01, 0xd0, 0x2e, 0xa5, 0xad, 0xdd, 0x01, 0x01, 0xd0, 0x27, 0xe6, 0x9f, 0xe6, 0x9f, + 0xa5, 0x93, 0xf0, 0x0b, 0xa5, 0xbd, 0xa0, 0x00, 0xd1, 0xac, 0xf0, 0x17, 0xc8, 0x84, 0xb6, 0xa5, + 0xb6, 0xf0, 0x07, 0xa9, 0x10, 0x20, 0x1c, 0xfe, 0xd0, 0x09, 0xa5, 0x93, 0xd0, 0x05, 0xa8, 0xa5, + 0xbd, 0x91, 0xac, 0x20, 0xdb, 0xfc, 0xd0, 0x43, 0xa9, 0x80, 0x85, 0xaa, 0x78, 0xa2, 0x01, 0x8e, + 0x0d, 0xdc, 0xae, 0x0d, 0xdc, 0xa6, 0xbe, 0xca, 0x30, 0x02, 0x86, 0xbe, 0xc6, 0xa7, 0xf0, 0x08, + 0xa5, 0x9e, 0xd0, 0x27, 0x85, 0xbe, 0xf0, 0x23, 0x20, 0x93, 0xfc, 0x20, 0x8e, 0xfb, 0xa0, 0x00, + 0x84, 0xab, 0xb1, 0xac, 0x45, 0xab, 0x85, 0xab, 0x20, 0xdb, 0xfc, 0x20, 0xd1, 0xfc, 0x90, 0xf2, + 0xa5, 0xab, 0x45, 0xbd, 0xf0, 0x05, 0xa9, 0x20, 0x20, 0x1c, 0xfe, 0x4c, 0xbc, 0xfe, 0xa5, 0xc2, + 0x85, 0xad, 0xa5, 0xc1, 0x85, 0xac, 0x60, 0xa9, 0x08, 0x85, 0xa3, 0xa9, 0x00, 0x85, 0xa4, 0x85, + 0xa8, 0x85, 0x9b, 0x85, 0xa9, 0x60, 0xa5, 0xbd, 0x4a, 0xa9, 0x60, 0x90, 0x02, 0xa9, 0xb0, 0xa2, + 0x00, 0x8d, 0x06, 0xdc, 0x8e, 0x07, 0xdc, 0xad, 0x0d, 0xdc, 0xa9, 0x19, 0x8d, 0x0f, 0xdc, 0xa5, + 0x01, 0x49, 0x08, 0x85, 0x01, 0x29, 0x08, 0x60, 0x38, 0x66, 0xb6, 0x30, 0x3c, 0xa5, 0xa8, 0xd0, + 0x12, 0xa9, 0x10, 0xa2, 0x01, 0x20, 0xb1, 0xfb, 0xd0, 0x2f, 0xe6, 0xa8, 0xa5, 0xb6, 0x10, 0x29, + 0x4c, 0x57, 0xfc, 0xa5, 0xa9, 0xd0, 0x09, 0x20, 0xad, 0xfb, 0xd0, 0x1d, 0xe6, 0xa9, 0xd0, 0x19, + 0x20, 0xa6, 0xfb, 0xd0, 0x14, 0xa5, 0xa4, 0x49, 0x01, 0x85, 0xa4, 0xf0, 0x0f, 0xa5, 0xbd, 0x49, + 0x01, 0x85, 0xbd, 0x29, 0x01, 0x45, 0x9b, 0x85, 0x9b, 0x4c, 0xbc, 0xfe, 0x46, 0xbd, 0xc6, 0xa3, + 0xa5, 0xa3, 0xf0, 0x3a, 0x10, 0xf3, 0x20, 0x97, 0xfb, 0x58, 0xa5, 0xa5, 0xf0, 0x12, 0xa2, 0x00, + 0x86, 0xd7, 0xc6, 0xa5, 0xa6, 0xbe, 0xe0, 0x02, 0xd0, 0x02, 0x09, 0x80, 0x85, 0xbd, 0xd0, 0xd9, + 0x20, 0xd1, 0xfc, 0x90, 0x0a, 0xd0, 0x91, 0xe6, 0xad, 0xa5, 0xd7, 0x85, 0xbd, 0xb0, 0xca, 0xa0, + 0x00, 0xb1, 0xac, 0x85, 0xbd, 0x45, 0xd7, 0x85, 0xd7, 0x20, 0xdb, 0xfc, 0xd0, 0xbb, 0xa5, 0x9b, + 0x49, 0x01, 0x85, 0xbd, 0x4c, 0xbc, 0xfe, 0xc6, 0xbe, 0xd0, 0x03, 0x20, 0xca, 0xfc, 0xa9, 0x50, + 0x85, 0xa7, 0xa2, 0x08, 0x78, 0x20, 0xbd, 0xfc, 0xd0, 0xea, 0xa9, 0x78, 0x20, 0xaf, 0xfb, 0xd0, + 0xe3, 0xc6, 0xa7, 0xd0, 0xdf, 0x20, 0x97, 0xfb, 0xc6, 0xab, 0x10, 0xd8, 0xa2, 0x0a, 0x20, 0xbd, + 0xfc, 0x58, 0xe6, 0xab, 0xa5, 0xbe, 0xf0, 0x30, 0x20, 0x8e, 0xfb, 0xa2, 0x09, 0x86, 0xa5, 0x86, + 0xb6, 0xd0, 0x83, 0x08, 0x78, 0xad, 0x11, 0xd0, 0x09, 0x10, 0x8d, 0x11, 0xd0, 0x20, 0xca, 0xfc, + 0xa9, 0x7f, 0x8d, 0x0d, 0xdc, 0x20, 0xdd, 0xfd, 0xad, 0xa0, 0x02, 0xf0, 0x09, 0x8d, 0x15, 0x03, + 0xad, 0x9f, 0x02, 0x8d, 0x14, 0x03, 0x28, 0x60, 0x20, 0x93, 0xfc, 0xf0, 0x97, 0xbd, 0x93, 0xfd, + 0x8d, 0x14, 0x03, 0xbd, 0x94, 0xfd, 0x8d, 0x15, 0x03, 0x60, 0xa5, 0x01, 0x09, 0x20, 0x85, 0x01, + 0x60, 0x38, 0xa5, 0xac, 0xe5, 0xae, 0xa5, 0xad, 0xe5, 0xaf, 0x60, 0xe6, 0xac, 0xd0, 0x02, 0xe6, + 0xad, 0x60, 0xa2, 0xff, 0x78, 0x9a, 0xd8, 0x20, 0x02, 0xfd, 0xd0, 0x03, 0x6c, 0x00, 0x80, 0x8e, + 0x16, 0xd0, 0x20, 0xa3, 0xfd, 0x20, 0x50, 0xfd, 0x20, 0x15, 0xfd, 0x20, 0x5b, 0xff, 0x58, 0x6c, + 0x00, 0xa0, 0xa2, 0x05, 0xbd, 0x0f, 0xfd, 0xdd, 0x03, 0x80, 0xd0, 0x03, 0xca, 0xd0, 0xf5, 0x60, + 0xc3, 0xc2, 0xcd, 0x38, 0x30, 0xa2, 0x30, 0xa0, 0xfd, 0x18, 0x86, 0xc3, 0x84, 0xc4, 0xa0, 0x1f, + 0xb9, 0x14, 0x03, 0xb0, 0x02, 0xb1, 0xc3, 0x91, 0xc3, 0x99, 0x14, 0x03, 0x88, 0x10, 0xf1, 0x60, + 0x31, 0xea, 0x66, 0xfe, 0x47, 0xfe, 0x4a, 0xf3, 0x91, 0xf2, 0x0e, 0xf2, 0x50, 0xf2, 0x33, 0xf3, + 0x57, 0xf1, 0xca, 0xf1, 0xed, 0xf6, 0x3e, 0xf1, 0x2f, 0xf3, 0x66, 0xfe, 0xa5, 0xf4, 0xed, 0xf5, + 0xa9, 0x00, 0xa8, 0x99, 0x02, 0x00, 0x99, 0x00, 0x02, 0x99, 0x00, 0x03, 0xc8, 0xd0, 0xf4, 0xa2, + 0x3c, 0xa0, 0x03, 0x86, 0xb2, 0x84, 0xb3, 0xa8, 0xa9, 0x03, 0x85, 0xc2, 0xe6, 0xc2, 0xb1, 0xc1, + 0xaa, 0xa9, 0x55, 0x91, 0xc1, 0xd1, 0xc1, 0xd0, 0x0f, 0x2a, 0x91, 0xc1, 0xd1, 0xc1, 0xd0, 0x08, + 0x8a, 0x91, 0xc1, 0xc8, 0xd0, 0xe8, 0xf0, 0xe4, 0x98, 0xaa, 0xa4, 0xc2, 0x18, 0x20, 0x2d, 0xfe, + 0xa9, 0x08, 0x8d, 0x82, 0x02, 0xa9, 0x04, 0x8d, 0x88, 0x02, 0x60, 0x6a, 0xfc, 0xcd, 0xfb, 0x31, + 0xea, 0x2c, 0xf9, 0xa9, 0x7f, 0x8d, 0x0d, 0xdc, 0x8d, 0x0d, 0xdd, 0x8d, 0x00, 0xdc, 0xa9, 0x08, + 0x8d, 0x0e, 0xdc, 0x8d, 0x0e, 0xdd, 0x8d, 0x0f, 0xdc, 0x8d, 0x0f, 0xdd, 0xa2, 0x00, 0x8e, 0x03, + 0xdc, 0x8e, 0x03, 0xdd, 0x8e, 0x18, 0xd4, 0xca, 0x8e, 0x02, 0xdc, 0xa9, 0x07, 0x8d, 0x00, 0xdd, + 0xa9, 0x3f, 0x8d, 0x02, 0xdd, 0xa9, 0xe7, 0x85, 0x01, 0xa9, 0x2f, 0x85, 0x00, 0xad, 0xa6, 0x02, + 0xf0, 0x0a, 0xa9, 0x25, 0x8d, 0x04, 0xdc, 0xa9, 0x40, 0x4c, 0xf3, 0xfd, 0xa9, 0x95, 0x8d, 0x04, + 0xdc, 0xa9, 0x42, 0x8d, 0x05, 0xdc, 0x4c, 0x6e, 0xff, 0x85, 0xb7, 0x86, 0xbb, 0x84, 0xbc, 0x60, + 0x85, 0xb8, 0x86, 0xba, 0x84, 0xb9, 0x60, 0xa5, 0xba, 0xc9, 0x02, 0xd0, 0x0d, 0xad, 0x97, 0x02, + 0x48, 0xa9, 0x00, 0x8d, 0x97, 0x02, 0x68, 0x60, 0x85, 0x9d, 0xa5, 0x90, 0x05, 0x90, 0x85, 0x90, + 0x60, 0x8d, 0x85, 0x02, 0x60, 0x90, 0x06, 0xae, 0x83, 0x02, 0xac, 0x84, 0x02, 0x8e, 0x83, 0x02, + 0x8c, 0x84, 0x02, 0x60, 0x90, 0x06, 0xae, 0x81, 0x02, 0xac, 0x82, 0x02, 0x8e, 0x81, 0x02, 0x8c, + 0x82, 0x02, 0x60, 0x78, 0x6c, 0x18, 0x03, 0x48, 0x8a, 0x48, 0x98, 0x48, 0xa9, 0x7f, 0x8d, 0x0d, + 0xdd, 0xac, 0x0d, 0xdd, 0x30, 0x1c, 0x20, 0x02, 0xfd, 0xd0, 0x03, 0x6c, 0x02, 0x80, 0x20, 0xbc, + 0xf6, 0x20, 0xe1, 0xff, 0xd0, 0x0c, 0x20, 0x15, 0xfd, 0x20, 0xa3, 0xfd, 0x20, 0x18, 0xe5, 0x6c, + 0x02, 0xa0, 0x98, 0x2d, 0xa1, 0x02, 0xaa, 0x29, 0x01, 0xf0, 0x28, 0xad, 0x00, 0xdd, 0x29, 0xfb, + 0x05, 0xb5, 0x8d, 0x00, 0xdd, 0xad, 0xa1, 0x02, 0x8d, 0x0d, 0xdd, 0x8a, 0x29, 0x12, 0xf0, 0x0d, + 0x29, 0x02, 0xf0, 0x06, 0x20, 0xd6, 0xfe, 0x4c, 0x9d, 0xfe, 0x20, 0x07, 0xff, 0x20, 0xbb, 0xee, + 0x4c, 0xb6, 0xfe, 0x8a, 0x29, 0x02, 0xf0, 0x06, 0x20, 0xd6, 0xfe, 0x4c, 0xb6, 0xfe, 0x8a, 0x29, + 0x10, 0xf0, 0x03, 0x20, 0x07, 0xff, 0xad, 0xa1, 0x02, 0x8d, 0x0d, 0xdd, 0x68, 0xa8, 0x68, 0xaa, + 0x68, 0x40, 0xc1, 0x27, 0x3e, 0x1a, 0xc5, 0x11, 0x74, 0x0e, 0xed, 0x0c, 0x45, 0x06, 0xf0, 0x02, + 0x46, 0x01, 0xb8, 0x00, 0x71, 0x00, 0xad, 0x01, 0xdd, 0x29, 0x01, 0x85, 0xa7, 0xad, 0x06, 0xdd, + 0xe9, 0x1c, 0x6d, 0x99, 0x02, 0x8d, 0x06, 0xdd, 0xad, 0x07, 0xdd, 0x6d, 0x9a, 0x02, 0x8d, 0x07, + 0xdd, 0xa9, 0x11, 0x8d, 0x0f, 0xdd, 0xad, 0xa1, 0x02, 0x8d, 0x0d, 0xdd, 0xa9, 0xff, 0x8d, 0x06, + 0xdd, 0x8d, 0x07, 0xdd, 0x4c, 0x59, 0xef, 0xad, 0x95, 0x02, 0x8d, 0x06, 0xdd, 0xad, 0x96, 0x02, + 0x8d, 0x07, 0xdd, 0xa9, 0x11, 0x8d, 0x0f, 0xdd, 0xa9, 0x12, 0x4d, 0xa1, 0x02, 0x8d, 0xa1, 0x02, + 0xa9, 0xff, 0x8d, 0x06, 0xdd, 0x8d, 0x07, 0xdd, 0xae, 0x98, 0x02, 0x86, 0xa8, 0x60, 0xaa, 0xad, + 0x96, 0x02, 0x2a, 0xa8, 0x8a, 0x69, 0xc8, 0x8d, 0x99, 0x02, 0x98, 0x69, 0x00, 0x8d, 0x9a, 0x02, + 0x60, 0xea, 0xea, 0x08, 0x68, 0x29, 0xef, 0x48, 0x48, 0x8a, 0x48, 0x98, 0x48, 0xba, 0xbd, 0x04, + 0x01, 0x29, 0x10, 0xf0, 0x03, 0x6c, 0x16, 0x03, 0x6c, 0x14, 0x03, 0x20, 0x18, 0xe5, 0xad, 0x12, + 0xd0, 0xd0, 0xfb, 0xad, 0x19, 0xd0, 0x29, 0x01, 0x8d, 0xa6, 0x02, 0x4c, 0xdd, 0xfd, 0xa9, 0x81, + 0x8d, 0x0d, 0xdc, 0xad, 0x0e, 0xdc, 0x29, 0x80, 0x09, 0x11, 0x8d, 0x0e, 0xdc, 0x4c, 0x8e, 0xee, + 0x03, 0x4c, 0x5b, 0xff, 0x4c, 0xa3, 0xfd, 0x4c, 0x50, 0xfd, 0x4c, 0x15, 0xfd, 0x4c, 0x1a, 0xfd, + 0x4c, 0x18, 0xfe, 0x4c, 0xb9, 0xed, 0x4c, 0xc7, 0xed, 0x4c, 0x25, 0xfe, 0x4c, 0x34, 0xfe, 0x4c, + 0x87, 0xea, 0x4c, 0x21, 0xfe, 0x4c, 0x13, 0xee, 0x4c, 0xdd, 0xed, 0x4c, 0xef, 0xed, 0x4c, 0xfe, + 0xed, 0x4c, 0x0c, 0xed, 0x4c, 0x09, 0xed, 0x4c, 0x07, 0xfe, 0x4c, 0x00, 0xfe, 0x4c, 0xf9, 0xfd, + 0x6c, 0x1a, 0x03, 0x6c, 0x1c, 0x03, 0x6c, 0x1e, 0x03, 0x6c, 0x20, 0x03, 0x6c, 0x22, 0x03, 0x6c, + 0x24, 0x03, 0x6c, 0x26, 0x03, 0x4c, 0x9e, 0xf4, 0x4c, 0xdd, 0xf5, 0x4c, 0xe4, 0xf6, 0x4c, 0xdd, + 0xf6, 0x6c, 0x28, 0x03, 0x6c, 0x2a, 0x03, 0x6c, 0x2c, 0x03, 0x4c, 0x9b, 0xf6, 0x4c, 0x05, 0xe5, + 0x4c, 0x0a, 0xe5, 0x4c, 0x00, 0xe5, 0x52, 0x52, 0x42, 0x59, 0x43, 0xfe, 0xe2, 0xfc, 0x48, 0xff, +}; + +void poke(int addr, int data) +{ + if(addr >= 0xe000 && addr <= 0xffff) + kernel[addr - 0xe000] = data; +} + +int peek(int addr) +{ + if(addr >= 0xe000 && addr <= 0xffff) + return kernel[addr - 0xe000]; + return 0; +} diff --git a/c64/mem.h b/c64/mem.h new file mode 100644 index 0000000..bd8ad67 --- /dev/null +++ b/c64/mem.h @@ -0,0 +1,18 @@ +// mem.h +// +// 20060803 Markku Alén + +#ifndef __MEM_H__ +#define __MEM_H__ 1 + +extern unsigned char color[1024]; +extern unsigned char ram[65536]; + +extern unsigned char chars[4096]; +extern unsigned char basic[8192]; +extern unsigned char kernel[8192]; + +void poke(int addr, int data); +int peek(int addr); + +#endif diff --git a/c64/prg_file.c b/c64/prg_file.c new file mode 100644 index 0000000..6a6558e --- /dev/null +++ b/c64/prg_file.c @@ -0,0 +1,1105 @@ +// prg_file.c +// +// 20060803 Markku Alén + +#include "prg_file.h" + +int prg_addr = 0x0801; +unsigned char prg_data[65536] = +{ + /*0x01, 0x08,*/ 0x0D, 0x08, 0x4F, 0x04, 0x9E, 0x32, 0x30, 0x36, 0x34, 0x3A, 0xA2, 0x00, 0x00, 0x00, + 0x00, 0xA9, 0x09, 0x85, 0xFF, 0xA9, 0x7D, 0x85, 0xFD, 0xA0, 0x00, 0x84, 0xFC, 0x84, 0xFE, 0xB1, + 0xFE, 0x91, 0xFC, 0xC8, 0xD0, 0xF9, 0xE6, 0xFF, 0xE6, 0xFD, 0xA5, 0xFD, 0xC9, 0xC0, 0xD0, 0xEF, + 0x20, 0x79, 0x99, 0x20, 0x00, 0x95, 0xA0, 0x00, 0xB9, 0xA0, 0x08, 0x99, 0x15, 0x9A, 0xC8, 0xC0, + 0x20, 0xD0, 0xF5, 0x20, 0x09, 0x9A, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x47, 0x4F, 0x4F, 0x44, 0x45, 0x4E, 0x20, 0x54, 0x41, 0x47, 0x2E, 0x9B, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x5D, 0xC1, 0x20, 0x28, 0x41, 0x2E, 0x29, 0x3D, 0x45, 0x48, 0x34, 0x59, 0x2E, 0xA0, 0x28, + 0x41, 0x29, 0x20, 0x3D, 0x41, 0xC8, 0x20, 0x28, 0x41, 0x52, 0x45, 0x29, 0x20, 0x3D, 0x41, 0x41, + 0xD2, 0x20, 0x28, 0x41, 0x52, 0x29, 0x4F, 0x3D, 0x41, 0x58, 0xD2, 0x28, 0x41, 0x52, 0x29, 0x23, + 0x3D, 0x45, 0x48, 0x34, 0xD2, 0x20, 0x5E, 0x28, 0x41, 0x53, 0x29, 0x23, 0x3D, 0x45, 0x59, 0x34, + 0xD3, 0x28, 0x41, 0x29, 0x57, 0x41, 0x3D, 0x41, 0xD8, 0x28, 0x41, 0x57, 0x29, 0x3D, 0x41, 0x4F, + 0xB5, 0x20, 0x3A, 0x28, 0x41, 0x4E, 0x59, 0x29, 0x3D, 0x45, 0x48, 0x34, 0x4E, 0x49, 0xD9, 0x28, + 0x41, 0x29, 0x5E, 0x2B, 0x23, 0x3D, 0x45, 0x59, 0xB5, 0x23, 0x3A, 0x28, 0x41, 0x4C, 0x4C, 0x59, + 0x29, 0x3D, 0x55, 0x4C, 0x49, 0xD9, 0x20, 0x28, 0x41, 0x4C, 0x29, 0x23, 0x3D, 0x55, 0xCC, 0x28, + 0x41, 0x47, 0x41, 0x49, 0x4E, 0x29, 0x3D, 0x41, 0x58, 0x47, 0x45, 0x48, 0x34, 0xCE, 0x23, 0x3A, + 0x28, 0x41, 0x47, 0x29, 0x45, 0x3D, 0x49, 0x48, 0xCA, 0x28, 0x41, 0x29, 0x5E, 0x25, 0x3D, 0x45, + 0xD9, 0x28, 0x41, 0x29, 0x5E, 0x2B, 0x3A, 0x23, 0x3D, 0x41, 0xC5, 0x20, 0x3A, 0x28, 0x41, 0x29, + 0x5E, 0x2B, 0x20, 0x3D, 0x45, 0x59, 0xB4, 0x20, 0x28, 0x41, 0x52, 0x52, 0x29, 0x3D, 0x41, 0x58, + 0xD2, 0x28, 0x41, 0x52, 0x52, 0x29, 0x3D, 0x41, 0x45, 0x34, 0xD2, 0x20, 0x5E, 0x28, 0x41, 0x52, + 0x29, 0x20, 0x3D, 0x41, 0x41, 0x35, 0xD2, 0x28, 0x41, 0x52, 0x29, 0x3D, 0x41, 0x41, 0x35, 0xD2, + 0x28, 0x41, 0x49, 0x52, 0x29, 0x3D, 0x45, 0x48, 0x34, 0xD2, 0x28, 0x41, 0x49, 0x29, 0x3D, 0x45, + 0x59, 0xB4, 0x28, 0x41, 0x59, 0x29, 0x3D, 0x45, 0x59, 0xB5, 0x28, 0x41, 0x55, 0x29, 0x3D, 0x41, + 0x4F, 0xB4, 0x23, 0x3A, 0x28, 0x41, 0x4C, 0x29, 0x20, 0x3D, 0x55, 0xCC, 0x23, 0x3A, 0x28, 0x41, + 0x4C, 0x53, 0x29, 0x20, 0x3D, 0x55, 0x4C, 0xDA, 0x28, 0x41, 0x4C, 0x4B, 0x29, 0x3D, 0x41, 0x4F, + 0x34, 0xCB, 0x28, 0x41, 0x4C, 0x29, 0x5E, 0x3D, 0x41, 0x4F, 0xCC, 0x20, 0x3A, 0x28, 0x41, 0x42, + 0x4C, 0x45, 0x29, 0x3D, 0x45, 0x59, 0x34, 0x42, 0x55, 0xCC, 0x28, 0x41, 0x42, 0x4C, 0x45, 0x29, + 0x3D, 0x41, 0x58, 0x42, 0x55, 0xCC, 0x28, 0x41, 0x29, 0x56, 0x4F, 0x3D, 0x45, 0x59, 0xB4, 0x28, + 0x41, 0x4E, 0x47, 0x29, 0x2B, 0x3D, 0x45, 0x59, 0x34, 0x4E, 0xCA, 0x28, 0x41, 0x54, 0x41, 0x52, + 0x49, 0x29, 0x3D, 0x41, 0x48, 0x54, 0x41, 0x41, 0x34, 0x52, 0x49, 0xD9, 0x28, 0x41, 0x29, 0x54, + 0x4F, 0x4D, 0x3D, 0x41, 0xC5, 0x28, 0x41, 0x29, 0x54, 0x54, 0x49, 0x3D, 0x41, 0xC5, 0x20, 0x28, + 0x41, 0x54, 0x29, 0x20, 0x3D, 0x41, 0x45, 0xD4, 0x20, 0x28, 0x41, 0x29, 0x54, 0x3D, 0x41, 0xC8, + 0x28, 0x41, 0x29, 0x3D, 0x41, 0xC5, 0x5D, 0xC2, 0x20, 0x28, 0x42, 0x29, 0x20, 0x3D, 0x42, 0x49, + 0x59, 0xB4, 0x20, 0x28, 0x42, 0x45, 0x29, 0x5E, 0x23, 0x3D, 0x42, 0x49, 0xC8, 0x28, 0x42, 0x45, + 0x49, 0x4E, 0x47, 0x29, 0x3D, 0x42, 0x49, 0x59, 0x34, 0x49, 0x48, 0x4E, 0xD8, 0x20, 0x28, 0x42, + 0x4F, 0x54, 0x48, 0x29, 0x20, 0x3D, 0x42, 0x4F, 0x57, 0x34, 0x54, 0xC8, 0x20, 0x28, 0x42, 0x55, + 0x53, 0x29, 0x23, 0x3D, 0x42, 0x49, 0x48, 0x34, 0xDA, 0x28, 0x42, 0x52, 0x45, 0x41, 0x4B, 0x29, + 0x3D, 0x42, 0x52, 0x45, 0x59, 0x35, 0xCB, 0x28, 0x42, 0x55, 0x49, 0x4C, 0x29, 0x3D, 0x42, 0x49, + 0x48, 0x34, 0xCC, 0x28, 0x42, 0x29, 0x3D, 0xC2, 0x5D, 0xC3, 0x20, 0x28, 0x43, 0x29, 0x20, 0x3D, + 0x53, 0x49, 0x59, 0xB4, 0x20, 0x28, 0x43, 0x48, 0x29, 0x5E, 0x3D, 0xCB, 0x5E, 0x45, 0x28, 0x43, + 0x48, 0x29, 0x3D, 0xCB, 0x28, 0x43, 0x48, 0x41, 0x29, 0x52, 0x23, 0x3D, 0x4B, 0x45, 0x48, 0xB5, + 0x28, 0x43, 0x48, 0x29, 0x3D, 0x43, 0xC8, 0x20, 0x53, 0x28, 0x43, 0x49, 0x29, 0x23, 0x3D, 0x53, + 0x41, 0x59, 0xB4, 0x28, 0x43, 0x49, 0x29, 0x41, 0x3D, 0x53, 0xC8, 0x28, 0x43, 0x49, 0x29, 0x4F, + 0x3D, 0x53, 0xC8, 0x28, 0x43, 0x49, 0x29, 0x45, 0x4E, 0x3D, 0x53, 0xC8, 0x28, 0x43, 0x49, 0x54, + 0x59, 0x29, 0x3D, 0x53, 0x49, 0x48, 0x54, 0x49, 0xD9, 0x28, 0x43, 0x29, 0x2B, 0x3D, 0xD3, 0x28, + 0x43, 0x4B, 0x29, 0x3D, 0xCB, 0x28, 0x43, 0x4F, 0x4D, 0x4D, 0x4F, 0x44, 0x4F, 0x52, 0x45, 0x29, + 0x3D, 0x4B, 0x41, 0x41, 0x34, 0x4D, 0x41, 0x48, 0x44, 0x4F, 0x48, 0xD2, 0x28, 0x43, 0x4F, 0x4D, + 0x29, 0x3D, 0x4B, 0x41, 0x48, 0xCD, 0x28, 0x43, 0x55, 0x49, 0x54, 0x29, 0x3D, 0x4B, 0x49, 0x48, + 0xD4, 0x28, 0x43, 0x52, 0x45, 0x41, 0x29, 0x3D, 0x4B, 0x52, 0x49, 0x59, 0x45, 0xD9, 0x28, 0x43, + 0x29, 0x3D, 0xCB, 0x5D, 0xC4, 0x20, 0x28, 0x44, 0x29, 0x20, 0x3D, 0x44, 0x49, 0x59, 0xB4, 0x20, + 0x28, 0x44, 0x52, 0x2E, 0x29, 0x20, 0x3D, 0x44, 0x41, 0x41, 0x34, 0x4B, 0x54, 0x45, 0xD2, 0x23, + 0x3A, 0x28, 0x44, 0x45, 0x44, 0x29, 0x20, 0x3D, 0x44, 0x49, 0x48, 0xC4, 0x2E, 0x45, 0x28, 0x44, + 0x29, 0x20, 0x3D, 0xC4, 0x23, 0x3A, 0x5E, 0x45, 0x28, 0x44, 0x29, 0x20, 0x3D, 0xD4, 0x20, 0x28, + 0x44, 0x45, 0x29, 0x5E, 0x23, 0x3D, 0x44, 0x49, 0xC8, 0x20, 0x28, 0x44, 0x4F, 0x29, 0x20, 0x3D, + 0x44, 0x55, 0xD7, 0x20, 0x28, 0x44, 0x4F, 0x45, 0x53, 0x29, 0x3D, 0x44, 0x41, 0x48, 0xDA, 0x28, + 0x44, 0x4F, 0x4E, 0x45, 0x29, 0x20, 0x3D, 0x44, 0x41, 0x48, 0x35, 0xCE, 0x28, 0x44, 0x4F, 0x49, + 0x4E, 0x47, 0x29, 0x3D, 0x44, 0x55, 0x57, 0x34, 0x49, 0x48, 0x4E, 0xD8, 0x20, 0x28, 0x44, 0x4F, + 0x57, 0x29, 0x3D, 0x44, 0x41, 0xD7, 0x23, 0x28, 0x44, 0x55, 0x29, 0x41, 0x3D, 0x4A, 0x55, 0xD7, + 0x23, 0x28, 0x44, 0x55, 0x29, 0x5E, 0x23, 0x3D, 0x4A, 0x41, 0xD8, 0x28, 0x44, 0x29, 0x3D, 0xC4, + 0x5D, 0xC5, 0x20, 0x28, 0x45, 0x29, 0x20, 0x3D, 0x49, 0x59, 0x49, 0x59, 0xB4, 0x23, 0x3A, 0x28, + 0x45, 0x29, 0x20, 0xBD, 0x27, 0x3A, 0x5E, 0x28, 0x45, 0x29, 0x20, 0xBD, 0x20, 0x3A, 0x28, 0x45, + 0x29, 0x20, 0x3D, 0x49, 0xD9, 0x23, 0x28, 0x45, 0x44, 0x29, 0x20, 0x3D, 0xC4, 0x23, 0x3A, 0x28, + 0x45, 0x29, 0x44, 0x20, 0xBD, 0x28, 0x45, 0x56, 0x29, 0x45, 0x52, 0x3D, 0x45, 0x48, 0x34, 0xD6, + 0x28, 0x45, 0x29, 0x5E, 0x25, 0x3D, 0x49, 0x59, 0xB4, 0x28, 0x45, 0x52, 0x49, 0x29, 0x23, 0x3D, + 0x49, 0x59, 0x34, 0x52, 0x49, 0xD9, 0x28, 0x45, 0x52, 0x49, 0x29, 0x3D, 0x45, 0x48, 0x34, 0x52, + 0x49, 0xC8, 0x23, 0x3A, 0x28, 0x45, 0x52, 0x29, 0x23, 0x3D, 0x45, 0xD2, 0x28, 0x45, 0x52, 0x52, + 0x4F, 0x52, 0x29, 0x3D, 0x45, 0x48, 0x34, 0x52, 0x4F, 0x48, 0xD2, 0x28, 0x45, 0x52, 0x41, 0x53, + 0x45, 0x29, 0x3D, 0x49, 0x48, 0x52, 0x45, 0x59, 0x35, 0xD3, 0x28, 0x45, 0x52, 0x29, 0x23, 0x3D, + 0x45, 0x48, 0xD2, 0x28, 0x45, 0x52, 0x29, 0x3D, 0x45, 0xD2, 0x20, 0x28, 0x45, 0x56, 0x45, 0x4E, + 0x29, 0x3D, 0x49, 0x59, 0x56, 0x45, 0x48, 0xCE, 0x23, 0x3A, 0x28, 0x45, 0x29, 0x57, 0xBD, 0x40, + 0x28, 0x45, 0x57, 0x29, 0x3D, 0x55, 0xD7, 0x28, 0x45, 0x57, 0x29, 0x3D, 0x59, 0x55, 0xD7, 0x28, + 0x45, 0x29, 0x4F, 0x3D, 0x49, 0xD9, 0x23, 0x3A, 0x26, 0x28, 0x45, 0x53, 0x29, 0x20, 0x3D, 0x49, + 0x48, 0xDA, 0x23, 0x3A, 0x28, 0x45, 0x29, 0x53, 0x20, 0xBD, 0x23, 0x3A, 0x28, 0x45, 0x4C, 0x59, + 0x29, 0x20, 0x3D, 0x4C, 0x49, 0xD9, 0x23, 0x3A, 0x28, 0x45, 0x4D, 0x45, 0x4E, 0x54, 0x29, 0x3D, + 0x4D, 0x45, 0x48, 0x4E, 0xD4, 0x28, 0x45, 0x46, 0x55, 0x4C, 0x29, 0x3D, 0x46, 0x55, 0x48, 0xCC, + 0x28, 0x45, 0x45, 0x29, 0x3D, 0x49, 0x59, 0xB4, 0x28, 0x45, 0x41, 0x52, 0x4E, 0x29, 0x3D, 0x45, + 0x52, 0x35, 0xCE, 0x20, 0x28, 0x45, 0x41, 0x52, 0x29, 0x5E, 0x3D, 0x45, 0x52, 0xB5, 0x28, 0x45, + 0x41, 0x44, 0x29, 0x3D, 0x45, 0x48, 0xC4, 0x23, 0x3A, 0x28, 0x45, 0x41, 0x29, 0x20, 0x3D, 0x49, + 0x59, 0x41, 0xD8, 0x28, 0x45, 0x41, 0x29, 0x53, 0x55, 0x3D, 0x45, 0x48, 0xB5, 0x28, 0x45, 0x41, + 0x29, 0x3D, 0x49, 0x59, 0xB5, 0x28, 0x45, 0x49, 0x47, 0x48, 0x29, 0x3D, 0x45, 0x59, 0xB4, 0x28, + 0x45, 0x49, 0x29, 0x3D, 0x49, 0x59, 0xB4, 0x20, 0x28, 0x45, 0x59, 0x45, 0x29, 0x3D, 0x41, 0x59, + 0xB4, 0x28, 0x45, 0x59, 0x29, 0x3D, 0x49, 0xD9, 0x28, 0x45, 0x55, 0x29, 0x3D, 0x59, 0x55, 0x57, + 0xB5, 0x28, 0x45, 0x51, 0x55, 0x41, 0x4C, 0x29, 0x3D, 0x49, 0x59, 0x34, 0x4B, 0x57, 0x55, 0xCC, + 0x28, 0x45, 0x29, 0x3D, 0x45, 0xC8, 0x5D, 0xC6, 0x20, 0x28, 0x46, 0x29, 0x20, 0x3D, 0x45, 0x48, + 0x34, 0xC6, 0x28, 0x46, 0x55, 0x4C, 0x29, 0x3D, 0x46, 0x55, 0x48, 0xCC, 0x28, 0x46, 0x52, 0x49, + 0x45, 0x4E, 0x44, 0x29, 0x3D, 0x46, 0x52, 0x45, 0x48, 0x35, 0x4E, 0xC4, 0x28, 0x46, 0x41, 0x54, + 0x48, 0x45, 0x52, 0x29, 0x3D, 0x46, 0x41, 0x41, 0x34, 0x44, 0x48, 0x45, 0xD2, 0x28, 0x46, 0x29, + 0x46, 0xBD, 0x28, 0x46, 0x29, 0x3D, 0xC6, 0x5D, 0xC7, 0x20, 0x28, 0x47, 0x29, 0x20, 0x3D, 0x4A, + 0x49, 0x59, 0xB4, 0x28, 0x47, 0x49, 0x56, 0x29, 0x3D, 0x47, 0x49, 0x48, 0x35, 0xD6, 0x20, 0x28, + 0x47, 0x29, 0x49, 0x5E, 0x3D, 0xC7, 0x28, 0x47, 0x45, 0x29, 0x54, 0x3D, 0x47, 0x45, 0x48, 0xB5, + 0x53, 0x55, 0x28, 0x47, 0x47, 0x45, 0x53, 0x29, 0x3D, 0x47, 0x4A, 0x45, 0x48, 0x34, 0xD3, 0x28, + 0x47, 0x47, 0x29, 0x3D, 0xC7, 0x20, 0x42, 0x23, 0x28, 0x47, 0x29, 0x3D, 0xC7, 0x28, 0x47, 0x29, + 0x2B, 0x3D, 0xCA, 0x28, 0x47, 0x52, 0x45, 0x41, 0x54, 0x29, 0x3D, 0x47, 0x52, 0x45, 0x59, 0x34, + 0xD4, 0x28, 0x47, 0x4F, 0x4E, 0x29, 0x45, 0x3D, 0x47, 0x41, 0x4F, 0x35, 0xCE, 0x23, 0x28, 0x47, + 0x48, 0x29, 0xBD, 0x20, 0x28, 0x47, 0x4E, 0x29, 0x3D, 0xCE, 0x28, 0x47, 0x29, 0x3D, 0xC7, 0x5D, + 0xC8, 0x20, 0x28, 0x48, 0x29, 0x20, 0x3D, 0x45, 0x59, 0x34, 0x43, 0xC8, 0x20, 0x28, 0x48, 0x41, + 0x56, 0x29, 0x3D, 0x2F, 0x48, 0x41, 0x45, 0x36, 0xD6, 0x20, 0x28, 0x48, 0x45, 0x52, 0x45, 0x29, + 0x3D, 0x2F, 0x48, 0x49, 0x59, 0xD2, 0x20, 0x28, 0x48, 0x4F, 0x55, 0x52, 0x29, 0x3D, 0x41, 0x57, + 0x35, 0x45, 0xD2, 0x28, 0x48, 0x4F, 0x57, 0x29, 0x3D, 0x2F, 0x48, 0x41, 0xD7, 0x28, 0x48, 0x29, + 0x23, 0x3D, 0x2F, 0xC8, 0x28, 0x48, 0x29, 0xBD, 0x5D, 0xC9, 0x20, 0x28, 0x49, 0x4E, 0x29, 0x3D, + 0x49, 0x48, 0xCE, 0x20, 0x28, 0x49, 0x29, 0x20, 0x3D, 0x41, 0x59, 0xB4, 0x28, 0x49, 0x29, 0x20, + 0x3D, 0x41, 0xD9, 0x28, 0x49, 0x4E, 0x29, 0x44, 0x3D, 0x41, 0x59, 0x35, 0xCE, 0x53, 0x45, 0x4D, + 0x28, 0x49, 0x29, 0x3D, 0x49, 0xD9, 0x20, 0x41, 0x4E, 0x54, 0x28, 0x49, 0x29, 0x3D, 0x41, 0xD9, + 0x28, 0x49, 0x45, 0x52, 0x29, 0x3D, 0x49, 0x59, 0x45, 0xD2, 0x23, 0x3A, 0x52, 0x28, 0x49, 0x45, + 0x44, 0x29, 0x20, 0x3D, 0x49, 0x59, 0xC4, 0x28, 0x49, 0x45, 0x44, 0x29, 0x20, 0x3D, 0x41, 0x59, + 0x35, 0xC4, 0x28, 0x49, 0x45, 0x4E, 0x29, 0x3D, 0x49, 0x59, 0x45, 0x48, 0xCE, 0x28, 0x49, 0x45, + 0x29, 0x54, 0x3D, 0x41, 0x59, 0x34, 0x45, 0xC8, 0x28, 0x49, 0x27, 0x29, 0x3D, 0x41, 0x59, 0xB5, + 0x20, 0x3A, 0x28, 0x49, 0x29, 0x5E, 0x25, 0x3D, 0x41, 0x59, 0xB5, 0x20, 0x3A, 0x28, 0x49, 0x45, + 0x29, 0x20, 0x3D, 0x41, 0x59, 0xB4, 0x28, 0x49, 0x29, 0x25, 0x3D, 0x49, 0xD9, 0x28, 0x49, 0x45, + 0x29, 0x3D, 0x49, 0x59, 0xB4, 0x20, 0x28, 0x49, 0x44, 0x45, 0x41, 0x29, 0x3D, 0x41, 0x59, 0x44, + 0x49, 0x59, 0x35, 0x41, 0xC8, 0x28, 0x49, 0x29, 0x5E, 0x2B, 0x3A, 0x23, 0x3D, 0x49, 0xC8, 0x28, + 0x49, 0x52, 0x29, 0x23, 0x3D, 0x41, 0x59, 0xD2, 0x28, 0x49, 0x5A, 0x29, 0x25, 0x3D, 0x41, 0x59, + 0xDA, 0x28, 0x49, 0x53, 0x29, 0x25, 0x3D, 0x41, 0x59, 0xDA, 0x49, 0x5E, 0x28, 0x49, 0x29, 0x5E, + 0x23, 0x3D, 0x49, 0xC8, 0x2B, 0x5E, 0x28, 0x49, 0x29, 0x5E, 0x2B, 0x3D, 0x41, 0xD9, 0x23, 0x3A, + 0x5E, 0x28, 0x49, 0x29, 0x5E, 0x2B, 0x3D, 0x49, 0xC8, 0x28, 0x49, 0x29, 0x5E, 0x2B, 0x3D, 0x41, + 0xD9, 0x28, 0x49, 0x52, 0x29, 0x3D, 0x45, 0xD2, 0x28, 0x49, 0x47, 0x48, 0x29, 0x3D, 0x41, 0x59, + 0xB4, 0x28, 0x49, 0x4C, 0x44, 0x29, 0x3D, 0x41, 0x59, 0x35, 0x4C, 0xC4, 0x20, 0x28, 0x49, 0x47, + 0x4E, 0x29, 0x3D, 0x49, 0x48, 0x47, 0xCE, 0x28, 0x49, 0x47, 0x4E, 0x29, 0x20, 0x3D, 0x41, 0x59, + 0x34, 0xCE, 0x28, 0x49, 0x47, 0x4E, 0x29, 0x5E, 0x3D, 0x41, 0x59, 0x34, 0xCE, 0x28, 0x49, 0x47, + 0x4E, 0x29, 0x25, 0x3D, 0x41, 0x59, 0x34, 0xCE, 0x28, 0x49, 0x43, 0x52, 0x4F, 0x29, 0x3D, 0x41, + 0x59, 0x34, 0x4B, 0x52, 0x4F, 0xC8, 0x28, 0x49, 0x51, 0x55, 0x45, 0x29, 0x3D, 0x49, 0x59, 0x34, + 0xCB, 0x28, 0x49, 0x29, 0x3D, 0x49, 0xC8, 0x5D, 0xCA, 0x20, 0x28, 0x4A, 0x29, 0x20, 0x3D, 0x4A, + 0x45, 0x59, 0xB4, 0x28, 0x4A, 0x29, 0x3D, 0xCA, 0x5D, 0xCB, 0x20, 0x28, 0x4B, 0x29, 0x20, 0x3D, + 0x4B, 0x45, 0x59, 0xB4, 0x20, 0x28, 0x4B, 0x29, 0x4E, 0xBD, 0x28, 0x4B, 0x29, 0x3D, 0xCB, 0x5D, + 0xCC, 0x20, 0x28, 0x4C, 0x29, 0x20, 0x3D, 0x45, 0x48, 0x34, 0xCC, 0x28, 0x4C, 0x4F, 0x29, 0x43, + 0x23, 0x3D, 0x4C, 0x4F, 0xD7, 0x4C, 0x28, 0x4C, 0x29, 0xBD, 0x23, 0x3A, 0x5E, 0x28, 0x4C, 0x29, + 0x25, 0x3D, 0x55, 0xCC, 0x28, 0x4C, 0x45, 0x41, 0x44, 0x29, 0x3D, 0x4C, 0x49, 0x59, 0xC4, 0x20, + 0x28, 0x4C, 0x41, 0x55, 0x47, 0x48, 0x29, 0x3D, 0x4C, 0x41, 0x45, 0x34, 0xC6, 0x28, 0x4C, 0x29, + 0x3D, 0xCC, 0x5D, 0xCD, 0x20, 0x28, 0x4D, 0x29, 0x20, 0x3D, 0x45, 0x48, 0x34, 0xCD, 0x20, 0x28, + 0x4D, 0x52, 0x2E, 0x29, 0x20, 0x3D, 0x4D, 0x49, 0x48, 0x34, 0x53, 0x54, 0x45, 0xD2, 0x20, 0x28, + 0x4D, 0x53, 0x2E, 0x29, 0x3D, 0x4D, 0x49, 0x48, 0x35, 0xDA, 0x20, 0x28, 0x4D, 0x52, 0x53, 0x2E, + 0x29, 0x20, 0x3D, 0x4D, 0x49, 0x48, 0x34, 0x53, 0x49, 0x58, 0xDA, 0x28, 0x4D, 0x4F, 0x56, 0x29, + 0x3D, 0x4D, 0x55, 0x57, 0x34, 0xD6, 0x28, 0x4D, 0x41, 0x43, 0x48, 0x49, 0x4E, 0x29, 0x3D, 0x4D, + 0x41, 0x48, 0x53, 0x48, 0x49, 0x59, 0x35, 0xCE, 0x4D, 0x28, 0x4D, 0x29, 0xBD, 0x28, 0x4D, 0x29, + 0x3D, 0xCD, 0x5D, 0xCE, 0x20, 0x28, 0x4E, 0x29, 0x20, 0x3D, 0x45, 0x48, 0x34, 0xCE, 0x45, 0x28, + 0x4E, 0x47, 0x29, 0x2B, 0x3D, 0x4E, 0xCA, 0x28, 0x4E, 0x47, 0x29, 0x52, 0x3D, 0x4E, 0x58, 0xC7, + 0x28, 0x4E, 0x47, 0x29, 0x23, 0x3D, 0x4E, 0x58, 0xC7, 0x28, 0x4E, 0x47, 0x4C, 0x29, 0x25, 0x3D, + 0x4E, 0x58, 0x47, 0x55, 0xCC, 0x28, 0x4E, 0x47, 0x29, 0x3D, 0x4E, 0xD8, 0x28, 0x4E, 0x4B, 0x29, + 0x3D, 0x4E, 0x58, 0xCB, 0x20, 0x28, 0x4E, 0x4F, 0x57, 0x29, 0x20, 0x3D, 0x4E, 0x41, 0x57, 0xB4, + 0x4E, 0x28, 0x4E, 0x29, 0xBD, 0x28, 0x4E, 0x4F, 0x4E, 0x29, 0x45, 0x3D, 0x4E, 0x41, 0x48, 0x34, + 0xCE, 0x28, 0x4E, 0x29, 0x3D, 0xCE, 0x5D, 0xCF, 0x20, 0x28, 0x4F, 0x29, 0x20, 0x3D, 0x4F, 0x48, + 0x34, 0xD7, 0x28, 0x4F, 0x46, 0x29, 0x20, 0x3D, 0x41, 0x48, 0xD6, 0x20, 0x28, 0x4F, 0x48, 0x29, + 0x20, 0x3D, 0x4F, 0x57, 0xB5, 0x28, 0x4F, 0x52, 0x4F, 0x55, 0x47, 0x48, 0x29, 0x3D, 0x45, 0x52, + 0x34, 0x4F, 0xD7, 0x23, 0x3A, 0x28, 0x4F, 0x52, 0x29, 0x20, 0x3D, 0x45, 0xD2, 0x23, 0x3A, 0x28, + 0x4F, 0x52, 0x53, 0x29, 0x20, 0x3D, 0x45, 0x52, 0xDA, 0x28, 0x4F, 0x52, 0x29, 0x3D, 0x41, 0x4F, + 0xD2, 0x20, 0x28, 0x4F, 0x4E, 0x45, 0x29, 0x3D, 0x57, 0x41, 0x48, 0xCE, 0x23, 0x28, 0x4F, 0x4E, + 0x45, 0x29, 0x20, 0x3D, 0x57, 0x41, 0x48, 0xCE, 0x28, 0x4F, 0x57, 0x29, 0x3D, 0x4F, 0xD7, 0x20, + 0x28, 0x4F, 0x56, 0x45, 0x52, 0x29, 0x3D, 0x4F, 0x57, 0x35, 0x56, 0x45, 0xD2, 0x50, 0x52, 0x28, + 0x4F, 0x29, 0x56, 0x3D, 0x55, 0x57, 0xB4, 0x28, 0x4F, 0x56, 0x29, 0x3D, 0x41, 0x48, 0x34, 0xD6, + 0x28, 0x4F, 0x29, 0x5E, 0x25, 0x3D, 0x4F, 0x57, 0xB5, 0x28, 0x4F, 0x29, 0x5E, 0x45, 0x4E, 0x3D, + 0x4F, 0xD7, 0x28, 0x4F, 0x29, 0x5E, 0x49, 0x23, 0x3D, 0x4F, 0x57, 0xB5, 0x28, 0x4F, 0x4C, 0x29, + 0x44, 0x3D, 0x4F, 0x57, 0x34, 0xCC, 0x28, 0x4F, 0x55, 0x47, 0x48, 0x54, 0x29, 0x3D, 0x41, 0x4F, + 0x35, 0xD4, 0x28, 0x4F, 0x55, 0x47, 0x48, 0x29, 0x3D, 0x41, 0x48, 0x35, 0xC6, 0x20, 0x28, 0x4F, + 0x55, 0x29, 0x3D, 0x41, 0xD7, 0x48, 0x28, 0x4F, 0x55, 0x29, 0x53, 0x23, 0x3D, 0x41, 0x57, 0xB4, + 0x28, 0x4F, 0x55, 0x53, 0x29, 0x3D, 0x41, 0x58, 0xD3, 0x28, 0x4F, 0x55, 0x52, 0x29, 0x3D, 0x4F, + 0x48, 0xD2, 0x28, 0x4F, 0x55, 0x4C, 0x44, 0x29, 0x3D, 0x55, 0x48, 0x35, 0xC4, 0x28, 0x4F, 0x55, + 0x29, 0x5E, 0x4C, 0x3D, 0x41, 0x48, 0xB5, 0x28, 0x4F, 0x55, 0x50, 0x29, 0x3D, 0x55, 0x57, 0x35, + 0xD0, 0x28, 0x4F, 0x55, 0x29, 0x3D, 0x41, 0xD7, 0x28, 0x4F, 0x59, 0x29, 0x3D, 0x4F, 0xD9, 0x28, + 0x4F, 0x49, 0x4E, 0x47, 0x29, 0x3D, 0x4F, 0x57, 0x34, 0x49, 0x48, 0x4E, 0xD8, 0x28, 0x4F, 0x49, + 0x29, 0x3D, 0x4F, 0x59, 0xB5, 0x28, 0x4F, 0x4F, 0x52, 0x29, 0x3D, 0x4F, 0x48, 0x35, 0xD2, 0x28, + 0x4F, 0x4F, 0x4B, 0x29, 0x3D, 0x55, 0x48, 0x35, 0xCB, 0x46, 0x28, 0x4F, 0x4F, 0x44, 0x29, 0x3D, + 0x55, 0x57, 0x35, 0xC4, 0x4C, 0x28, 0x4F, 0x4F, 0x44, 0x29, 0x3D, 0x41, 0x48, 0x35, 0xC4, 0x4D, + 0x28, 0x4F, 0x4F, 0x44, 0x29, 0x3D, 0x55, 0x57, 0x35, 0xC4, 0x28, 0x4F, 0x4F, 0x44, 0x29, 0x3D, + 0x55, 0x48, 0x35, 0xC4, 0x46, 0x28, 0x4F, 0x4F, 0x54, 0x29, 0x3D, 0x55, 0x48, 0x35, 0xD4, 0x28, + 0x4F, 0x4F, 0x29, 0x3D, 0x55, 0x57, 0xB5, 0x28, 0x4F, 0x27, 0x29, 0x3D, 0x4F, 0xC8, 0x28, 0x4F, + 0x29, 0x45, 0x3D, 0x4F, 0xD7, 0x28, 0x4F, 0x29, 0x20, 0x3D, 0x4F, 0xD7, 0x28, 0x4F, 0x41, 0x29, + 0x3D, 0x4F, 0x57, 0xB4, 0x20, 0x28, 0x4F, 0x4E, 0x4C, 0x59, 0x29, 0x3D, 0x4F, 0x57, 0x34, 0x4E, + 0x4C, 0x49, 0xD9, 0x20, 0x28, 0x4F, 0x4E, 0x43, 0x45, 0x29, 0x3D, 0x57, 0x41, 0x48, 0x34, 0x4E, + 0xD3, 0x28, 0x4F, 0x4E, 0x27, 0x54, 0x29, 0x3D, 0x4F, 0x57, 0x34, 0x4E, 0xD4, 0x43, 0x28, 0x4F, + 0x29, 0x4E, 0x3D, 0x41, 0xC1, 0x28, 0x4F, 0x29, 0x4E, 0x47, 0x3D, 0x41, 0xCF, 0x20, 0x3A, 0x5E, + 0x28, 0x4F, 0x29, 0x4E, 0x3D, 0x41, 0xC8, 0x49, 0x28, 0x4F, 0x4E, 0x29, 0x3D, 0x55, 0xCE, 0x23, + 0x3A, 0x28, 0x4F, 0x4E, 0x29, 0x3D, 0x55, 0xCE, 0x23, 0x5E, 0x28, 0x4F, 0x4E, 0x29, 0x3D, 0x55, + 0xCE, 0x28, 0x4F, 0x29, 0x53, 0x54, 0x3D, 0x4F, 0xD7, 0x28, 0x4F, 0x46, 0x29, 0x5E, 0x3D, 0x41, + 0x4F, 0x34, 0xC6, 0x28, 0x4F, 0x54, 0x48, 0x45, 0x52, 0x29, 0x3D, 0x41, 0x48, 0x35, 0x44, 0x48, + 0x45, 0xD2, 0x52, 0x28, 0x4F, 0x29, 0x42, 0x3D, 0x52, 0x41, 0xC1, 0x5E, 0x52, 0x28, 0x4F, 0x29, + 0x3A, 0x23, 0x3D, 0x4F, 0x57, 0xB5, 0x28, 0x4F, 0x53, 0x53, 0x29, 0x20, 0x3D, 0x41, 0x4F, 0x35, + 0xD3, 0x23, 0x3A, 0x5E, 0x28, 0x4F, 0x4D, 0x29, 0x3D, 0x41, 0x48, 0xCD, 0x28, 0x4F, 0x29, 0x3D, + 0x41, 0xC1, 0x5D, 0xD0, 0x20, 0x28, 0x50, 0x29, 0x20, 0x3D, 0x50, 0x49, 0x59, 0xB4, 0x28, 0x50, + 0x48, 0x29, 0x3D, 0xC6, 0x28, 0x50, 0x45, 0x4F, 0x50, 0x4C, 0x29, 0x3D, 0x50, 0x49, 0x59, 0x35, + 0x50, 0x55, 0xCC, 0x28, 0x50, 0x4F, 0x57, 0x29, 0x3D, 0x50, 0x41, 0x57, 0xB4, 0x28, 0x50, 0x55, + 0x54, 0x29, 0x20, 0x3D, 0x50, 0x55, 0x48, 0xD4, 0x28, 0x50, 0x29, 0x50, 0xBD, 0x28, 0x50, 0x29, + 0x53, 0xBD, 0x28, 0x50, 0x29, 0x4E, 0xBD, 0x28, 0x50, 0x52, 0x4F, 0x46, 0x2E, 0x29, 0x3D, 0x50, + 0x52, 0x4F, 0x48, 0x46, 0x45, 0x48, 0x34, 0x53, 0x45, 0xD2, 0x28, 0x50, 0x29, 0x3D, 0xD0, 0x5D, + 0xD1, 0x20, 0x28, 0x51, 0x29, 0x20, 0x3D, 0x4B, 0x59, 0x55, 0x57, 0xB4, 0x28, 0x51, 0x55, 0x41, + 0x52, 0x29, 0x3D, 0x4B, 0x57, 0x4F, 0x48, 0x35, 0xD2, 0x28, 0x51, 0x55, 0x29, 0x3D, 0x4B, 0xD7, + 0x28, 0x51, 0x29, 0x3D, 0xCB, 0x5D, 0xD2, 0x20, 0x28, 0x52, 0x29, 0x20, 0x3D, 0x41, 0x41, 0x35, + 0xD2, 0x20, 0x28, 0x52, 0x45, 0x29, 0x5E, 0x23, 0x3D, 0x52, 0x49, 0xD9, 0x28, 0x52, 0x29, 0x52, + 0xBD, 0x28, 0x52, 0x29, 0x3D, 0xD2, 0x5D, 0xD3, 0x20, 0x28, 0x53, 0x29, 0x20, 0x3D, 0x45, 0x48, + 0x34, 0xD3, 0x28, 0x53, 0x48, 0x29, 0x3D, 0x53, 0xC8, 0x23, 0x28, 0x53, 0x49, 0x4F, 0x4E, 0x29, + 0x3D, 0x5A, 0x48, 0x55, 0xCE, 0x28, 0x53, 0x4F, 0x4D, 0x45, 0x29, 0x3D, 0x53, 0x41, 0x48, 0xCD, + 0x23, 0x28, 0x53, 0x55, 0x52, 0x29, 0x23, 0x3D, 0x5A, 0x48, 0x45, 0xD2, 0x28, 0x53, 0x55, 0x52, + 0x29, 0x23, 0x3D, 0x53, 0x48, 0x45, 0xD2, 0x23, 0x28, 0x53, 0x55, 0x29, 0x23, 0x3D, 0x5A, 0x48, + 0x55, 0xD7, 0x23, 0x28, 0x53, 0x53, 0x55, 0x29, 0x23, 0x3D, 0x53, 0x48, 0x55, 0xD7, 0x23, 0x28, + 0x53, 0x45, 0x44, 0x29, 0x3D, 0x5A, 0xC4, 0x23, 0x28, 0x53, 0x29, 0x23, 0x3D, 0xDA, 0x28, 0x53, + 0x41, 0x49, 0x44, 0x29, 0x3D, 0x53, 0x45, 0x48, 0xC4, 0x5E, 0x28, 0x53, 0x49, 0x4F, 0x4E, 0x29, + 0x3D, 0x53, 0x48, 0x55, 0xCE, 0x28, 0x53, 0x29, 0x53, 0xBD, 0x2E, 0x28, 0x53, 0x29, 0x20, 0x3D, + 0xDA, 0x23, 0x3A, 0x2E, 0x45, 0x28, 0x53, 0x29, 0x20, 0x3D, 0xDA, 0x23, 0x3A, 0x5E, 0x23, 0x28, + 0x53, 0x29, 0x20, 0x3D, 0xD3, 0x55, 0x28, 0x53, 0x29, 0x20, 0x3D, 0xD3, 0x20, 0x3A, 0x23, 0x28, + 0x53, 0x29, 0x20, 0x3D, 0xDA, 0x23, 0x23, 0x28, 0x53, 0x29, 0x20, 0x3D, 0xDA, 0x20, 0x28, 0x53, + 0x43, 0x48, 0x29, 0x3D, 0x53, 0xCB, 0x28, 0x53, 0x29, 0x43, 0x2B, 0xBD, 0x23, 0x28, 0x53, 0x4D, + 0x29, 0x3D, 0x5A, 0x55, 0xCD, 0x23, 0x28, 0x53, 0x4E, 0x29, 0x27, 0x3D, 0x5A, 0x55, 0xCD, 0x28, + 0x53, 0x54, 0x4C, 0x45, 0x29, 0x3D, 0x53, 0x55, 0xCC, 0x28, 0x53, 0x29, 0x3D, 0xD3, 0x5D, 0xD4, + 0x20, 0x28, 0x54, 0x29, 0x20, 0x3D, 0x54, 0x49, 0x59, 0xB4, 0x20, 0x28, 0x54, 0x48, 0x45, 0x29, + 0x20, 0x23, 0x3D, 0x44, 0x48, 0x49, 0xD9, 0x20, 0x28, 0x54, 0x48, 0x45, 0x29, 0x20, 0x3D, 0x44, + 0x48, 0x41, 0xD8, 0x28, 0x54, 0x4F, 0x29, 0x20, 0x3D, 0x54, 0x55, 0xD8, 0x20, 0x28, 0x54, 0x48, + 0x41, 0x54, 0x29, 0x3D, 0x44, 0x48, 0x41, 0x45, 0xD4, 0x20, 0x28, 0x54, 0x48, 0x49, 0x53, 0x29, + 0x20, 0x3D, 0x44, 0x48, 0x49, 0x48, 0xD3, 0x20, 0x28, 0x54, 0x48, 0x45, 0x59, 0x29, 0x3D, 0x44, + 0x48, 0x45, 0xD9, 0x20, 0x28, 0x54, 0x48, 0x45, 0x52, 0x45, 0x29, 0x3D, 0x44, 0x48, 0x45, 0x48, + 0xD2, 0x28, 0x54, 0x48, 0x45, 0x52, 0x29, 0x3D, 0x44, 0x48, 0x45, 0xD2, 0x28, 0x54, 0x48, 0x45, + 0x49, 0x52, 0x29, 0x3D, 0x44, 0x48, 0x45, 0x48, 0xD2, 0x20, 0x28, 0x54, 0x48, 0x41, 0x4E, 0x29, + 0x20, 0x3D, 0x44, 0x48, 0x41, 0x45, 0xCE, 0x20, 0x28, 0x54, 0x48, 0x45, 0x4D, 0x29, 0x20, 0x3D, + 0x44, 0x48, 0x41, 0x45, 0xCE, 0x28, 0x54, 0x48, 0x45, 0x53, 0x45, 0x29, 0x20, 0x3D, 0x44, 0x48, + 0x49, 0x59, 0xDA, 0x20, 0x28, 0x54, 0x48, 0x45, 0x4E, 0x29, 0x3D, 0x44, 0x48, 0x45, 0x48, 0xCE, + 0x28, 0x54, 0x48, 0x52, 0x4F, 0x55, 0x47, 0x48, 0x29, 0x3D, 0x54, 0x48, 0x52, 0x55, 0x57, 0xB4, + 0x28, 0x54, 0x48, 0x4F, 0x53, 0x45, 0x29, 0x3D, 0x44, 0x48, 0x4F, 0x48, 0xDA, 0x28, 0x54, 0x48, + 0x4F, 0x55, 0x47, 0x48, 0x29, 0x20, 0x3D, 0x44, 0x48, 0x4F, 0xD7, 0x28, 0x54, 0x4F, 0x44, 0x41, + 0x59, 0x29, 0x3D, 0x54, 0x55, 0x58, 0x44, 0x45, 0xD9, 0x28, 0x54, 0x4F, 0x4D, 0x4F, 0x29, 0x52, + 0x52, 0x4F, 0x57, 0x3D, 0x54, 0x55, 0x4D, 0x41, 0x41, 0xB5, 0x28, 0x54, 0x4F, 0x29, 0x54, 0x41, + 0x4C, 0x3D, 0x54, 0x4F, 0x57, 0xB5, 0x20, 0x28, 0x54, 0x48, 0x55, 0x53, 0x29, 0x3D, 0x44, 0x48, + 0x41, 0x48, 0x34, 0xD3, 0x28, 0x54, 0x48, 0x29, 0x3D, 0x54, 0xC8, 0x23, 0x3A, 0x28, 0x54, 0x45, + 0x44, 0x29, 0x3D, 0x54, 0x49, 0x58, 0xC4, 0x53, 0x28, 0x54, 0x49, 0x29, 0x23, 0x4E, 0x3D, 0x43, + 0xC8, 0x28, 0x54, 0x49, 0x29, 0x4F, 0x3D, 0x53, 0xC8, 0x28, 0x54, 0x49, 0x29, 0x41, 0x3D, 0x53, + 0xC8, 0x28, 0x54, 0x49, 0x45, 0x4E, 0x29, 0x3D, 0x53, 0x48, 0x55, 0xCE, 0x28, 0x54, 0x55, 0x52, + 0x29, 0x23, 0x3D, 0x43, 0x48, 0x45, 0xD2, 0x28, 0x54, 0x55, 0x29, 0x41, 0x3D, 0x43, 0x48, 0x55, + 0xD7, 0x20, 0x28, 0x54, 0x57, 0x4F, 0x29, 0x3D, 0x54, 0x55, 0xD7, 0x26, 0x28, 0x54, 0x29, 0x45, + 0x4E, 0x20, 0xBD, 0x28, 0x54, 0x29, 0x3D, 0xD4, 0x5D, 0xD5, 0x20, 0x28, 0x55, 0x29, 0x20, 0x3D, + 0x59, 0x55, 0x57, 0xB4, 0x20, 0x28, 0x55, 0x4E, 0x29, 0x49, 0x3D, 0x59, 0x55, 0x57, 0xCE, 0x20, + 0x28, 0x55, 0x4E, 0x29, 0x3D, 0x41, 0x48, 0xCE, 0x20, 0x28, 0x55, 0x50, 0x4F, 0x4E, 0x29, 0x3D, + 0x41, 0x58, 0x50, 0x41, 0x4F, 0xCE, 0x40, 0x28, 0x55, 0x52, 0x29, 0x23, 0x3D, 0x55, 0x48, 0x34, + 0xD2, 0x28, 0x55, 0x52, 0x29, 0x23, 0x3D, 0x59, 0x55, 0x48, 0x34, 0xD2, 0x28, 0x55, 0x52, 0x29, + 0x3D, 0x45, 0xD2, 0x28, 0x55, 0x29, 0x5E, 0x20, 0x3D, 0x41, 0xC8, 0x28, 0x55, 0x29, 0x5E, 0x5E, + 0x3D, 0x41, 0x48, 0xB5, 0x28, 0x55, 0x59, 0x29, 0x3D, 0x41, 0x59, 0xB5, 0x20, 0x47, 0x28, 0x55, + 0x29, 0x23, 0xBD, 0x47, 0x28, 0x55, 0x29, 0x25, 0xBD, 0x47, 0x28, 0x55, 0x29, 0x23, 0x3D, 0xD7, + 0x23, 0x4E, 0x28, 0x55, 0x29, 0x3D, 0x59, 0x55, 0xD7, 0x40, 0x28, 0x55, 0x29, 0x3D, 0x55, 0xD7, + 0x28, 0x55, 0x29, 0x3D, 0x59, 0x55, 0xD7, 0x5D, 0xD6, 0x20, 0x28, 0x56, 0x29, 0x20, 0x3D, 0x56, + 0x49, 0x59, 0xB4, 0x28, 0x56, 0x49, 0x45, 0x57, 0x29, 0x3D, 0x56, 0x59, 0x55, 0x57, 0xB5, 0x28, + 0x56, 0x29, 0x3D, 0xD6, 0x5D, 0xD7, 0x20, 0x28, 0x57, 0x29, 0x20, 0x3D, 0x44, 0x41, 0x48, 0x34, + 0x42, 0x55, 0x4C, 0x59, 0x55, 0xD7, 0x20, 0x28, 0x57, 0x45, 0x52, 0x45, 0x29, 0x3D, 0x57, 0x45, + 0xD2, 0x28, 0x57, 0x41, 0x29, 0x53, 0x48, 0x3D, 0x57, 0x41, 0xC1, 0x28, 0x57, 0x41, 0x29, 0x53, + 0x54, 0x3D, 0x57, 0x45, 0xD9, 0x28, 0x57, 0x41, 0x29, 0x53, 0x3D, 0x57, 0x41, 0xC8, 0x28, 0x57, + 0x41, 0x29, 0x54, 0x3D, 0x57, 0x41, 0xC1, 0x28, 0x57, 0x48, 0x45, 0x52, 0x45, 0x29, 0x3D, 0x57, + 0x48, 0x45, 0x48, 0xD2, 0x28, 0x57, 0x48, 0x41, 0x54, 0x29, 0x3D, 0x57, 0x48, 0x41, 0x48, 0xD4, + 0x28, 0x57, 0x48, 0x4F, 0x4C, 0x29, 0x3D, 0x2F, 0x48, 0x4F, 0x57, 0xCC, 0x28, 0x57, 0x48, 0x4F, + 0x29, 0x3D, 0x2F, 0x48, 0x55, 0xD7, 0x28, 0x57, 0x48, 0x29, 0x3D, 0x57, 0xC8, 0x28, 0x57, 0x41, + 0x52, 0x29, 0x23, 0x3D, 0x57, 0x45, 0x48, 0xD2, 0x28, 0x57, 0x41, 0x52, 0x29, 0x3D, 0x57, 0x41, + 0x4F, 0xD2, 0x28, 0x57, 0x4F, 0x52, 0x29, 0x5E, 0x3D, 0x57, 0x45, 0xD2, 0x28, 0x57, 0x52, 0x29, + 0x3D, 0xD2, 0x28, 0x57, 0x4F, 0x4D, 0x29, 0x41, 0x3D, 0x57, 0x55, 0x48, 0xCD, 0x28, 0x57, 0x4F, + 0x4D, 0x29, 0x45, 0x3D, 0x57, 0x49, 0x48, 0xCD, 0x28, 0x57, 0x45, 0x41, 0x29, 0x52, 0x3D, 0x57, + 0x45, 0xC8, 0x28, 0x57, 0x41, 0x4E, 0x54, 0x29, 0x3D, 0x57, 0x41, 0x41, 0x35, 0x4E, 0xD4, 0x41, + 0x4E, 0x53, 0x28, 0x57, 0x45, 0x52, 0x29, 0x3D, 0x45, 0xD2, 0x28, 0x57, 0x29, 0x3D, 0xD7, 0x5D, + 0xD8, 0x20, 0x28, 0x58, 0x29, 0x20, 0x3D, 0x45, 0x48, 0x34, 0x4B, 0xD2, 0x20, 0x28, 0x58, 0x29, + 0x3D, 0xDA, 0x28, 0x58, 0x29, 0x3D, 0x4B, 0xD3, 0x5D, 0xD9, 0x20, 0x28, 0x59, 0x29, 0x20, 0x3D, + 0x57, 0x41, 0x59, 0xB4, 0x28, 0x59, 0x4F, 0x55, 0x4E, 0x47, 0x29, 0x3D, 0x59, 0x41, 0x48, 0x4E, + 0xD8, 0x20, 0x28, 0x59, 0x4F, 0x55, 0x52, 0x29, 0x3D, 0x59, 0x4F, 0x48, 0xD2, 0x20, 0x28, 0x59, + 0x4F, 0x55, 0x29, 0x3D, 0x59, 0x55, 0xD7, 0x20, 0x28, 0x59, 0x45, 0x53, 0x29, 0x3D, 0x59, 0x45, + 0x48, 0xD3, 0x20, 0x28, 0x59, 0x29, 0x3D, 0xD9, 0x46, 0x28, 0x59, 0x29, 0x3D, 0x41, 0xD9, 0x50, + 0x53, 0x28, 0x59, 0x43, 0x48, 0x29, 0x3D, 0x41, 0x59, 0xCB, 0x23, 0x3A, 0x5E, 0x28, 0x59, 0x29, + 0x3D, 0x49, 0xD9, 0x23, 0x3A, 0x5E, 0x28, 0x59, 0x29, 0x49, 0x3D, 0x49, 0xD9, 0x20, 0x3A, 0x28, + 0x59, 0x29, 0x20, 0x3D, 0x41, 0xD9, 0x20, 0x3A, 0x28, 0x59, 0x29, 0x23, 0x3D, 0x41, 0xD9, 0x20, + 0x3A, 0x28, 0x59, 0x29, 0x5E, 0x2B, 0x3A, 0x23, 0x3D, 0x49, 0xC8, 0x20, 0x3A, 0x28, 0x59, 0x29, + 0x5E, 0x23, 0x3D, 0x41, 0xD9, 0x28, 0x59, 0x29, 0x3D, 0x49, 0xC8, 0x5D, 0xDA, 0x20, 0x28, 0x5A, + 0x29, 0x20, 0x3D, 0x5A, 0x49, 0x59, 0xB4, 0x28, 0x5A, 0x29, 0x3D, 0xDA, 0xEA, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xE6, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x47, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x46, 0x43, 0x4F, 0x50, 0x59, 0x52, 0x49, 0x47, 0x48, 0x54, 0x20, 0x31, 0x39, 0x38, 0x32, 0x20, + 0x44, 0x4F, 0x4E, 0x27, 0x54, 0x20, 0x41, 0x53, 0x4B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x82, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0xC0, 0xA8, 0xB0, 0xAC, 0xC0, 0xA0, + 0xB8, 0xA0, 0xC0, 0xBC, 0xA0, 0xAC, 0xA8, 0xAC, 0xC0, 0xA0, 0xA0, 0xAC, 0xB4, 0xA4, 0xC0, 0xA8, + 0xA8, 0xB0, 0xC0, 0xBC, 0x00, 0x00, 0x00, 0x02, 0x00, 0x20, 0x20, 0x9B, 0x20, 0xC0, 0xB9, 0x20, + 0xCD, 0xA3, 0x4C, 0x8A, 0x8E, 0x20, 0x20, 0x9B, 0x20, 0xC0, 0xB9, 0xA9, 0x20, 0x8D, 0x00, 0x8D, + 0xA2, 0x01, 0xA0, 0x00, 0xB9, 0x15, 0x9A, 0x29, 0x7F, 0xC9, 0x70, 0x90, 0x05, 0x29, 0x5F, 0x4C, + 0xA7, 0x8E, 0xC9, 0x60, 0x90, 0x02, 0x29, 0x4F, 0x9D, 0x00, 0x8D, 0xE8, 0xC8, 0xC0, 0xFF, 0xD0, + 0xE3, 0xA2, 0xFF, 0xA9, 0x1B, 0x9D, 0x00, 0x8D, 0x4C, 0xC2, 0x8E, 0x20, 0x61, 0x9B, 0x60, 0x20, + 0x61, 0x9B, 0x60, 0xA9, 0xFF, 0x85, 0x3D, 0xA9, 0xFF, 0x85, 0x38, 0xE6, 0x3D, 0xA6, 0x3D, 0xBD, + 0x00, 0x8D, 0x85, 0x40, 0xC9, 0x1B, 0xD0, 0x0C, 0xE6, 0x38, 0xA6, 0x38, 0xA9, 0x9B, 0x9D, 0x15, + 0x9A, 0x4C, 0xBE, 0x8E, 0xC9, 0x2E, 0xD0, 0x18, 0xE8, 0xBD, 0x00, 0x8D, 0xA8, 0xB9, 0x18, 0x8E, + 0x29, 0x01, 0xD0, 0x0C, 0xE6, 0x38, 0xA6, 0x38, 0xA9, 0x2E, 0x9D, 0x15, 0x9A, 0x4C, 0xCA, 0x8E, + 0xA5, 0x40, 0xA8, 0xB9, 0x18, 0x8E, 0x85, 0x39, 0x29, 0x02, 0xF0, 0x0B, 0xA9, 0xA5, 0x85, 0x3E, + 0xA9, 0x92, 0x85, 0x3F, 0x4C, 0x5C, 0x8F, 0xA5, 0x39, 0xD0, 0x2B, 0xA9, 0x20, 0x9D, 0x00, 0x8D, + 0xE6, 0x38, 0xA6, 0x38, 0xE0, 0x78, 0xB0, 0x07, 0x9D, 0x15, 0x9A, 0x4C, 0xCA, 0x8E, 0xFF, 0xA9, + 0x9B, 0x9D, 0x15, 0x9A, 0xA5, 0x3D, 0x8D, 0x2D, 0x8F, 0x85, 0x1D, 0x20, 0xBA, 0x8E, 0xAD, 0x2D, + 0x8F, 0x85, 0x3D, 0x4C, 0xC6, 0x8E, 0xA5, 0x39, 0x29, 0x80, 0xD0, 0x01, 0x00, 0xA5, 0x40, 0x38, + 0xE9, 0x41, 0xAA, 0xBD, 0x71, 0x92, 0x85, 0x3E, 0xBD, 0x8B, 0x92, 0x85, 0x3F, 0xA0, 0x00, 0x18, + 0xA5, 0x3E, 0x69, 0x01, 0x85, 0x3E, 0xA5, 0x3F, 0x69, 0x00, 0x85, 0x3F, 0xB1, 0x3E, 0x10, 0xEF, + 0xC8, 0xB1, 0x3E, 0xC9, 0x28, 0xF0, 0x04, 0xC8, 0x4C, 0x70, 0x8F, 0x84, 0x42, 0xC8, 0xB1, 0x3E, + 0xC9, 0x29, 0xD0, 0xF9, 0x84, 0x41, 0xC8, 0xB1, 0x3E, 0x29, 0x7F, 0xC9, 0x3D, 0xD0, 0xF7, 0x84, + 0x40, 0xA6, 0x3D, 0x86, 0x3C, 0xA4, 0x42, 0xC8, 0xBD, 0x00, 0x8D, 0x85, 0x39, 0xB1, 0x3E, 0xC5, + 0x39, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0xC8, 0xC4, 0x41, 0xD0, 0x03, 0x4C, 0xB3, 0x8F, 0xE8, 0x86, + 0x3C, 0x4C, 0x97, 0x8F, 0xA5, 0x3D, 0x85, 0x3B, 0xA4, 0x42, 0x88, 0x84, 0x42, 0xB1, 0x3E, 0x85, + 0x39, 0x10, 0x03, 0x4C, 0x3C, 0x91, 0x29, 0x7F, 0xAA, 0xBD, 0x18, 0x8E, 0x29, 0x80, 0xF0, 0x12, + 0xA6, 0x3B, 0xCA, 0xBD, 0x00, 0x8D, 0xC5, 0x39, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3B, 0x4C, + 0xB7, 0x8F, 0xA5, 0x39, 0xC9, 0x20, 0xD0, 0x03, 0x4C, 0x1F, 0x90, 0xC9, 0x23, 0xD0, 0x03, 0x4C, + 0x2E, 0x90, 0xC9, 0x2E, 0xD0, 0x03, 0x4C, 0x38, 0x90, 0xC9, 0x26, 0xD0, 0x03, 0x4C, 0x47, 0x90, + 0xC9, 0x40, 0xD0, 0x03, 0x4C, 0x67, 0x90, 0xC9, 0x5E, 0xD0, 0x03, 0x4C, 0x8C, 0x90, 0xC9, 0x2B, + 0xD0, 0x03, 0x4C, 0x9B, 0x90, 0xC9, 0x3A, 0xD0, 0x03, 0x4C, 0xB0, 0x90, 0x20, 0x39, 0xA4, 0x00, + 0x20, 0xBF, 0x90, 0x29, 0x80, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3B, 0x4C, 0xB7, 0x8F, 0x20, + 0xBF, 0x90, 0x29, 0x40, 0xD0, 0xF4, 0x4C, 0x5C, 0x8F, 0x20, 0xBF, 0x90, 0x29, 0x08, 0xD0, 0x03, + 0x4C, 0x5C, 0x8F, 0x86, 0x3B, 0x4C, 0xB7, 0x8F, 0x20, 0xBF, 0x90, 0x29, 0x10, 0xD0, 0xF4, 0xBD, + 0x00, 0x8D, 0xC9, 0x48, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0xCA, 0xBD, 0x00, 0x8D, 0xC9, 0x43, 0xF0, + 0xE2, 0xC9, 0x53, 0xF0, 0xDE, 0x4C, 0x5C, 0x8F, 0x20, 0xBF, 0x90, 0x29, 0x04, 0xD0, 0xD4, 0xBD, + 0x00, 0x8D, 0xC9, 0x48, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0xC9, 0x54, 0xF0, 0x0B, 0xC9, 0x43, 0xF0, + 0x07, 0xC9, 0x53, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3B, 0x4C, 0xB7, 0x8F, 0x20, 0xBF, 0x90, + 0x29, 0x20, 0xD0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3B, 0x4C, 0xB7, 0x8F, 0xA6, 0x3B, 0xCA, 0xBD, + 0x00, 0x8D, 0xC9, 0x45, 0xF0, 0xF1, 0xC9, 0x49, 0xF0, 0xED, 0xC9, 0x59, 0xF0, 0xE9, 0x4C, 0x5C, + 0x8F, 0x20, 0xBF, 0x90, 0x29, 0x20, 0xD0, 0x03, 0x4C, 0xB7, 0x8F, 0x86, 0x3B, 0x4C, 0xB0, 0x90, + 0xA6, 0x3B, 0xCA, 0xBD, 0x00, 0x8D, 0xA8, 0xB9, 0x18, 0x8E, 0x60, 0xA6, 0x3A, 0xE8, 0xBD, 0x00, + 0x8D, 0xA8, 0xB9, 0x18, 0x8E, 0x60, 0xA6, 0x3A, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x45, 0xD0, 0x46, + 0xE8, 0xBD, 0x00, 0x8D, 0xA8, 0xCA, 0xB9, 0x18, 0x8E, 0x29, 0x80, 0xF0, 0x08, 0xE8, 0xBD, 0x00, + 0x8D, 0xC9, 0x52, 0xD0, 0x05, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0xC9, 0x53, 0xF0, 0xF7, 0xC9, 0x44, + 0xF0, 0xF3, 0xC9, 0x4C, 0xD0, 0x0A, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x59, 0xD0, 0x2C, 0xF0, 0xE5, + 0xC9, 0x46, 0xD0, 0x26, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x55, 0xD0, 0x1E, 0xE8, 0xBD, 0x00, 0x8D, + 0xC9, 0x4C, 0xF0, 0xD1, 0xD0, 0x14, 0xC9, 0x49, 0xD0, 0x10, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x4E, + 0xD0, 0x08, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x47, 0xF0, 0xBB, 0x4C, 0x5C, 0x8F, 0xA5, 0x3C, 0x85, + 0x3A, 0xA4, 0x41, 0xC8, 0xC4, 0x40, 0xD0, 0x03, 0x4C, 0x4F, 0x92, 0x84, 0x41, 0xB1, 0x3E, 0x85, + 0x39, 0xAA, 0xBD, 0x18, 0x8E, 0x29, 0x80, 0xF0, 0x12, 0xA6, 0x3A, 0xE8, 0xBD, 0x00, 0x8D, 0xC5, + 0x39, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0xA5, 0x39, 0xC9, 0x20, 0xD0, + 0x03, 0x4C, 0xAF, 0x91, 0xC9, 0x23, 0xD0, 0x03, 0x4C, 0xBE, 0x91, 0xC9, 0x2E, 0xD0, 0x03, 0x4C, + 0xC8, 0x91, 0xC9, 0x26, 0xD0, 0x03, 0x4C, 0xD7, 0x91, 0xC9, 0x40, 0xD0, 0x03, 0x4C, 0xF7, 0x91, + 0xC9, 0x5E, 0xD0, 0x03, 0x4C, 0x1C, 0x92, 0xC9, 0x2B, 0xD0, 0x03, 0x4C, 0x2B, 0x92, 0xC9, 0x3A, + 0xD0, 0x03, 0x4C, 0x40, 0x92, 0xC9, 0x25, 0xD0, 0x03, 0x4C, 0xD5, 0x90, 0x20, 0x39, 0xA4, 0x00, + 0x20, 0xCA, 0x90, 0x29, 0x80, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0x20, + 0xCA, 0x90, 0x29, 0x40, 0xD0, 0xF4, 0x4C, 0x5C, 0x8F, 0x20, 0xCA, 0x90, 0x29, 0x08, 0xD0, 0x03, + 0x4C, 0x5C, 0x8F, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0x20, 0xCA, 0x90, 0x29, 0x10, 0xD0, 0xF4, 0xBD, + 0x00, 0x8D, 0xC9, 0x48, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0xE8, 0xBD, 0x00, 0x8D, 0xC9, 0x43, 0xF0, + 0xE2, 0xC9, 0x53, 0xF0, 0xDE, 0x4C, 0x5C, 0x8F, 0x20, 0xCA, 0x90, 0x29, 0x04, 0xD0, 0xD4, 0xBD, + 0x00, 0x8D, 0xC9, 0x48, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0xC9, 0x54, 0xF0, 0x0B, 0xC9, 0x43, 0xF0, + 0x07, 0xC9, 0x53, 0xF0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0x20, 0xCA, 0x90, + 0x29, 0x20, 0xD0, 0x03, 0x4C, 0x5C, 0x8F, 0x86, 0x3A, 0x4C, 0x40, 0x91, 0xA6, 0x3A, 0xE8, 0xBD, + 0x00, 0x8D, 0xC9, 0x45, 0xF0, 0xF1, 0xC9, 0x49, 0xF0, 0xED, 0xC9, 0x59, 0xF0, 0xE9, 0x4C, 0x5C, + 0x8F, 0x20, 0xCA, 0x90, 0x29, 0x20, 0xD0, 0x03, 0x4C, 0x40, 0x91, 0x86, 0x3A, 0x4C, 0x40, 0x92, + 0xA4, 0x40, 0xA5, 0x3C, 0x85, 0x3D, 0xB1, 0x3E, 0x85, 0x39, 0x29, 0x7F, 0xC9, 0x3D, 0xF0, 0x07, + 0xE6, 0x38, 0xA6, 0x38, 0x9D, 0x15, 0x9A, 0x24, 0x39, 0x10, 0x03, 0x4C, 0xCA, 0x8E, 0xC8, 0x4C, + 0x55, 0x92, 0x00, 0x95, 0xF7, 0xA2, 0x39, 0xC5, 0x06, 0x7E, 0xC7, 0x26, 0x37, 0x4E, 0x91, 0xF1, + 0x55, 0xA1, 0xFE, 0x24, 0x45, 0x2D, 0xA7, 0x36, 0x53, 0x2E, 0x47, 0xDA, 0x7D, 0x7E, 0x7E, 0x7F, + 0x80, 0x81, 0x82, 0x82, 0x82, 0x84, 0x84, 0x84, 0x84, 0x84, 0x85, 0x87, 0x87, 0x88, 0x88, 0x89, + 0x8A, 0x8B, 0x8B, 0x8C, 0x8C, 0x8C, 0x28, 0x41, 0x29, 0xBD, 0x28, 0x21, 0x29, 0x3D, 0xAE, 0x28, + 0x22, 0x29, 0x20, 0x3D, 0x2D, 0x41, 0x48, 0x35, 0x4E, 0x4B, 0x57, 0x4F, 0x57, 0x54, 0xAD, 0x28, + 0x22, 0x29, 0x3D, 0x4B, 0x57, 0x4F, 0x57, 0x34, 0x54, 0xAD, 0x28, 0x23, 0x29, 0x3D, 0x20, 0x4E, + 0x41, 0x48, 0x34, 0x4D, 0x42, 0x45, 0xD2, 0x28, 0x24, 0x29, 0x3D, 0x20, 0x44, 0x41, 0x41, 0x34, + 0x4C, 0x45, 0xD2, 0x28, 0x25, 0x29, 0x3D, 0x20, 0x50, 0x45, 0x52, 0x53, 0x45, 0x48, 0x34, 0x4E, + 0xD4, 0x28, 0x26, 0x29, 0x3D, 0x20, 0x41, 0x45, 0x4E, 0xC4, 0x28, 0x27, 0x29, 0xBD, 0x28, 0x2A, + 0x29, 0x3D, 0x20, 0x41, 0x45, 0x34, 0x53, 0x54, 0x45, 0x52, 0x49, 0x48, 0x53, 0xCB, 0x28, 0x2B, + 0x29, 0x3D, 0x20, 0x50, 0x4C, 0x41, 0x48, 0x34, 0xD3, 0x28, 0x2C, 0x29, 0x3D, 0xAC, 0x20, 0x28, + 0x2D, 0x29, 0x20, 0x3D, 0xAD, 0x28, 0x2D, 0x29, 0xBD, 0x28, 0x2E, 0x29, 0x3D, 0x20, 0x50, 0x4F, + 0x59, 0x4E, 0xD4, 0x28, 0x2F, 0x29, 0x3D, 0x20, 0x53, 0x4C, 0x41, 0x45, 0x34, 0x53, 0xC8, 0x28, + 0x30, 0x29, 0x3D, 0x20, 0x5A, 0x49, 0x59, 0x34, 0x52, 0x4F, 0xD7, 0x20, 0x28, 0x31, 0x53, 0x54, + 0x29, 0x3D, 0x46, 0x45, 0x52, 0x34, 0x53, 0xD4, 0x20, 0x28, 0x31, 0x30, 0x54, 0x48, 0x29, 0x3D, + 0x54, 0x45, 0x48, 0x34, 0x4E, 0x54, 0xC8, 0x28, 0x31, 0x29, 0x3D, 0x20, 0x57, 0x41, 0x48, 0x34, + 0xCE, 0x20, 0x28, 0x32, 0x4E, 0x44, 0x29, 0x3D, 0x53, 0x45, 0x48, 0x34, 0x4B, 0x55, 0x4E, 0xC4, + 0x28, 0x32, 0x29, 0x3D, 0x20, 0x54, 0x55, 0x57, 0xB4, 0x20, 0x28, 0x33, 0x52, 0x44, 0x29, 0x3D, + 0x54, 0x48, 0x45, 0x52, 0x34, 0xC4, 0x28, 0x33, 0x29, 0x3D, 0x20, 0x54, 0x48, 0x52, 0x49, 0x59, + 0xB4, 0x28, 0x34, 0x29, 0x3D, 0x20, 0x46, 0x4F, 0x48, 0x34, 0xD2, 0x20, 0x28, 0x35, 0x54, 0x48, + 0x29, 0x3D, 0x46, 0x49, 0x48, 0x34, 0x46, 0x54, 0xC8, 0x28, 0x35, 0x29, 0x3D, 0x20, 0x46, 0x41, + 0x59, 0x34, 0xD6, 0x20, 0x28, 0x36, 0x34, 0x29, 0x20, 0x3D, 0x53, 0x49, 0x48, 0x34, 0x4B, 0x53, + 0x54, 0x49, 0x59, 0x20, 0x46, 0x4F, 0x48, 0xD2, 0x28, 0x36, 0x29, 0x3D, 0x20, 0x53, 0x49, 0x48, + 0x34, 0x4B, 0xD3, 0x28, 0x37, 0x29, 0x3D, 0x20, 0x53, 0x45, 0x48, 0x34, 0x56, 0x55, 0xCE, 0x20, + 0x28, 0x38, 0x54, 0x48, 0x29, 0x3D, 0x45, 0x59, 0x34, 0x54, 0xC8, 0x28, 0x38, 0x29, 0x3D, 0x20, + 0x45, 0x59, 0x34, 0xD4, 0x28, 0x39, 0x29, 0x3D, 0x20, 0x4E, 0x41, 0x59, 0x34, 0xCE, 0x28, 0x3A, + 0x29, 0x3D, 0xAE, 0x28, 0x3B, 0x29, 0x3D, 0xAE, 0x28, 0x3C, 0x29, 0x3D, 0x20, 0x4C, 0x45, 0x48, + 0x34, 0x53, 0x20, 0x44, 0x48, 0x41, 0x45, 0xCE, 0x28, 0x3D, 0x29, 0x3D, 0x20, 0x49, 0x59, 0x34, + 0x4B, 0x57, 0x55, 0x4C, 0xDA, 0x28, 0x3E, 0x29, 0x3D, 0x20, 0x47, 0x52, 0x45, 0x59, 0x34, 0x54, + 0x45, 0x52, 0x20, 0x44, 0x48, 0x41, 0x45, 0xCE, 0x28, 0x3F, 0x29, 0x3D, 0xAE, 0x28, 0x40, 0x29, + 0x3D, 0x20, 0x41, 0x45, 0x36, 0xD4, 0x28, 0x5E, 0x29, 0x3D, 0x20, 0x4B, 0x41, 0x45, 0x34, 0x52, + 0x49, 0x58, 0xD4, 0x5D, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xA9, 0x43, 0x20, 0xD2, 0xFF, 0xA9, 0x52, 0x20, 0xD2, 0xFF, 0xA9, 0x41, 0x20, 0xD2, 0xFF, + 0xA9, 0x43, 0x20, 0xD2, 0xFF, 0xA9, 0x4B, 0x20, 0xD2, 0xFF, 0xA9, 0x45, 0x20, 0xD2, 0xFF, 0xA9, + 0x44, 0x20, 0xD2, 0xFF, 0xA9, 0x20, 0x20, 0xD2, 0xFF, 0xA9, 0x42, 0x20, 0xD2, 0xFF, 0xA9, 0x59, + 0x20, 0xD2, 0xFF, 0xA9, 0x20, 0x20, 0xD2, 0xFF, 0xA9, 0x31, 0x20, 0xD2, 0xFF, 0x20, 0xD2, 0xFF, + 0xA9, 0x30, 0x20, 0xD2, 0xFF, 0xA9, 0x33, 0x20, 0xD2, 0xFF, 0xA9, 0x0D, 0x20, 0xD2, 0xFF, 0x60, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xA9, 0x4C, 0x85, 0x73, 0xA9, 0x0D, 0x85, 0x74, 0xA9, 0x95, 0x85, 0x75, 0x60, 0xE6, 0x7A, + 0xD0, 0x02, 0xE6, 0x7B, 0x8C, 0x34, 0x99, 0x8E, 0x33, 0x99, 0xA0, 0x00, 0xBA, 0xBD, 0x01, 0x01, + 0xC9, 0xE6, 0xF0, 0x07, 0xC9, 0x8C, 0xF0, 0x03, 0x4C, 0x2D, 0x96, 0xBD, 0x02, 0x01, 0xC9, 0xA7, + 0xF0, 0x07, 0xC9, 0xA4, 0xF0, 0x03, 0x4C, 0x2D, 0x96, 0xB1, 0x7A, 0xC9, 0x53, 0xF0, 0x0A, 0xC9, + 0x5D, 0xD0, 0x03, 0x4C, 0x36, 0x96, 0x4C, 0x2D, 0x96, 0xA0, 0x01, 0xB1, 0x7A, 0xC9, 0x41, 0xF0, + 0x03, 0x4C, 0x2D, 0x96, 0xC8, 0xB1, 0x7A, 0xC9, 0x59, 0xF0, 0x03, 0x4C, 0x2D, 0x96, 0xA2, 0x00, + 0xC8, 0xB1, 0x7A, 0xC9, 0x20, 0xF0, 0xF9, 0xC9, 0x3A, 0xD0, 0x03, 0x4C, 0x03, 0x96, 0xC9, 0x00, + 0xD0, 0x03, 0x4C, 0x18, 0x96, 0xC9, 0x22, 0xF0, 0x03, 0x4C, 0xA4, 0x95, 0xC8, 0xB1, 0x7A, 0xC9, + 0x22, 0xF0, 0x07, 0x9D, 0x15, 0x9A, 0xE8, 0x4C, 0x7B, 0x95, 0xA9, 0x9B, 0x9D, 0x15, 0x9A, 0x8C, + 0x35, 0x99, 0x20, 0x03, 0x9A, 0xAC, 0x35, 0x99, 0xC8, 0xB1, 0x7A, 0xC9, 0x3A, 0xF0, 0x65, 0xC9, + 0x00, 0xF0, 0x76, 0xD0, 0xF3, 0xC9, 0x41, 0xB0, 0x03, 0x4C, 0x2D, 0x96, 0xC9, 0x5B, 0xB0, 0x7E, + 0x8D, 0x36, 0x99, 0xA9, 0x80, 0x8D, 0x37, 0x99, 0xC8, 0xB1, 0x7A, 0xC9, 0x24, 0xF0, 0x15, 0x8D, + 0x37, 0x99, 0xC8, 0xB1, 0x7A, 0xC9, 0x24, 0xF0, 0x0B, 0xC9, 0x00, 0xF0, 0x61, 0xC9, 0x3A, 0xF0, + 0x5D, 0x4C, 0xC1, 0x95, 0xAD, 0x36, 0x99, 0x8D, 0xDA, 0xA3, 0xAD, 0x37, 0x99, 0x09, 0x80, 0x8D, + 0xE1, 0xA3, 0x8C, 0x35, 0x99, 0x20, 0x00, 0x9A, 0xAC, 0x35, 0x99, 0xA9, 0x53, 0x8D, 0xDA, 0xA3, + 0xA9, 0xC1, 0x8D, 0xE1, 0xA3, 0xC8, 0xB1, 0x7A, 0xD0, 0x03, 0x4C, 0x18, 0x96, 0xC9, 0x3A, 0xD0, + 0xF4, 0x4C, 0x03, 0x96, 0x98, 0x18, 0x65, 0x7A, 0x85, 0x7A, 0xA5, 0x7B, 0x69, 0x00, 0x85, 0x7B, + 0xAE, 0x33, 0x99, 0xAC, 0x34, 0x99, 0x4C, 0x73, 0x00, 0x98, 0x18, 0x65, 0x7A, 0x85, 0x7A, 0xA5, + 0x7B, 0x69, 0x00, 0x85, 0x7B, 0xAE, 0x33, 0x99, 0xAC, 0x34, 0x99, 0x4C, 0x79, 0x00, 0xAE, 0x33, + 0x99, 0xAC, 0x34, 0x99, 0x4C, 0x79, 0x00, 0xC8, 0xB1, 0x7A, 0xC9, 0x45, 0xF0, 0x21, 0xC9, 0x4B, + 0xF0, 0x20, 0xC9, 0x4C, 0xF0, 0x4A, 0xC9, 0x50, 0xF0, 0x54, 0xC9, 0x52, 0xF0, 0x7E, 0xC9, 0x53, + 0xD0, 0x03, 0x4C, 0xD8, 0x96, 0xC9, 0x51, 0xD0, 0x03, 0x4C, 0x07, 0x97, 0x4C, 0x2D, 0x96, 0x4C, + 0x16, 0x97, 0x20, 0x79, 0x97, 0xAD, 0x39, 0x99, 0xD0, 0x03, 0x4C, 0x2D, 0x96, 0xAD, 0x38, 0x99, + 0x8D, 0xE0, 0x97, 0x20, 0x79, 0x97, 0xAD, 0x39, 0x99, 0xD0, 0x03, 0x4C, 0x2D, 0x96, 0xAD, 0x38, + 0x99, 0x8D, 0xE1, 0x97, 0x8C, 0x35, 0x99, 0x20, 0xE2, 0x97, 0xAC, 0x35, 0x99, 0x4C, 0xCC, 0x97, + 0xC8, 0xB1, 0x7A, 0xC9, 0x49, 0xF0, 0x1B, 0xC9, 0x4F, 0xF0, 0x2B, 0x4C, 0x2D, 0x96, 0x20, 0x79, + 0x97, 0xAD, 0x39, 0x99, 0xD0, 0x03, 0x4C, 0x2D, 0x96, 0xAD, 0x38, 0x99, 0x8D, 0x0F, 0x9A, 0x4C, + 0xCC, 0x97, 0x20, 0x79, 0x97, 0xAD, 0x39, 0x99, 0xD0, 0x03, 0x4C, 0x2D, 0x96, 0xAD, 0x38, 0x99, + 0x8D, 0x10, 0x9A, 0x4C, 0xCC, 0x97, 0x20, 0xA0, 0x94, 0x4C, 0xCC, 0x97, 0xA9, 0x09, 0x8D, 0x92, + 0x95, 0xA9, 0x06, 0x8D, 0xE5, 0x95, 0x4C, 0xCC, 0x97, 0xC8, 0xB1, 0x7A, 0xC9, 0x41, 0xF0, 0x07, + 0xC9, 0x50, 0xF0, 0x10, 0x4C, 0x2D, 0x96, 0xA9, 0x03, 0x8D, 0x92, 0x95, 0xA9, 0x00, 0x8D, 0xE5, + 0x95, 0x4C, 0xCC, 0x97, 0x20, 0x79, 0x97, 0xAD, 0x39, 0x99, 0xD0, 0x03, 0x4C, 0x2D, 0x96, 0xAD, + 0x38, 0x99, 0x8D, 0x0E, 0x9A, 0x4C, 0xCC, 0x97, 0xA9, 0xE6, 0x85, 0x73, 0xA9, 0x7A, 0x85, 0x74, + 0xA9, 0xD0, 0x85, 0x75, 0x4C, 0xCC, 0x97, 0xAD, 0x14, 0x9A, 0xC9, 0xFF, 0xD0, 0x03, 0x4C, 0xCC, + 0x97, 0xCE, 0x14, 0x9A, 0x20, 0xCC, 0xFF, 0xA2, 0x00, 0xBD, 0x15, 0x9A, 0xEC, 0x14, 0x9A, 0xD0, + 0x0A, 0x20, 0x4D, 0x97, 0xAD, 0x3A, 0x99, 0xC9, 0x9B, 0xF0, 0x34, 0xC9, 0x9B, 0xD0, 0x03, 0x4C, + 0x6E, 0x97, 0x20, 0xD2, 0xFF, 0xE8, 0xD0, 0xE1, 0xEE, 0x14, 0x9A, 0x4C, 0xCC, 0x97, 0x8D, 0x3A, + 0x99, 0xA9, 0x12, 0x20, 0xD2, 0xFF, 0xAD, 0x3A, 0x99, 0xC9, 0x9B, 0xD0, 0x02, 0xA9, 0x20, 0x20, + 0xD2, 0xFF, 0xA9, 0x92, 0x20, 0xD2, 0xFF, 0xE8, 0xBD, 0x15, 0x9A, 0x8D, 0x3A, 0x99, 0x60, 0xA9, + 0x0D, 0x20, 0xD2, 0xFF, 0xEE, 0x14, 0x9A, 0x4C, 0xCC, 0x97, 0xA9, 0x00, 0x8D, 0x38, 0x99, 0x8D, + 0x39, 0x99, 0xC8, 0xB1, 0x7A, 0xC9, 0x3B, 0xB0, 0xF9, 0xC9, 0x3A, 0xF0, 0x3F, 0xC9, 0x00, 0xF0, + 0x3B, 0xC9, 0x30, 0x90, 0xED, 0xA9, 0x01, 0x8D, 0x39, 0x99, 0xB1, 0x7A, 0x38, 0xE9, 0x30, 0x8D, + 0x38, 0x99, 0xC8, 0xB1, 0x7A, 0xC9, 0x30, 0xB0, 0x01, 0x60, 0xC9, 0x3A, 0x90, 0x01, 0x60, 0xAD, + 0x38, 0x99, 0x0E, 0x38, 0x99, 0x0E, 0x38, 0x99, 0x0E, 0x38, 0x99, 0x0A, 0x18, 0x6D, 0x38, 0x99, + 0x18, 0x71, 0x7A, 0x38, 0xE9, 0x30, 0x8D, 0x38, 0x99, 0x4C, 0xA1, 0x97, 0x60, 0xB1, 0x7A, 0xD0, + 0x03, 0x4C, 0x18, 0x96, 0xC9, 0x3A, 0xD0, 0x03, 0x4C, 0x03, 0x96, 0xC8, 0x4C, 0xCC, 0x97, 0x03, + 0x4C, 0x80, 0x80, 0xA5, 0x01, 0x29, 0xFE, 0x85, 0x01, 0xAD, 0x32, 0x99, 0xD0, 0x2C, 0xA2, 0x05, + 0xBD, 0x00, 0xB0, 0x9D, 0xE4, 0x98, 0xBD, 0x50, 0xB0, 0x9D, 0x02, 0x99, 0xE8, 0xE0, 0x1E, 0xD0, + 0xEF, 0xA2, 0x30, 0xA0, 0x00, 0xBD, 0x00, 0xB0, 0x99, 0x20, 0x99, 0xBD, 0x50, 0xB0, 0x99, 0x26, + 0x99, 0xE8, 0xC8, 0xE0, 0x36, 0xD0, 0xEE, 0xEE, 0x32, 0x99, 0xA9, 0x05, 0x8D, 0x30, 0x99, 0xAE, + 0x30, 0x99, 0xE0, 0x1E, 0xF0, 0x6E, 0xA9, 0x00, 0x8D, 0x31, 0x99, 0xAD, 0xE0, 0x97, 0x8D, 0x2C, + 0x99, 0xBD, 0xE4, 0x98, 0x8D, 0x2D, 0x99, 0xD0, 0x28, 0xAD, 0x2F, 0x99, 0xAE, 0x30, 0x99, 0x9D, + 0x00, 0xB0, 0xEE, 0x31, 0x99, 0xAD, 0xE1, 0x97, 0x8D, 0x2C, 0x99, 0xBD, 0x02, 0x99, 0x8D, 0x2D, + 0x99, 0xD0, 0x0E, 0xAD, 0x2F, 0x99, 0xAE, 0x30, 0x99, 0x9D, 0x50, 0xB0, 0xEE, 0x30, 0x99, 0xD0, + 0xBE, 0xA9, 0x00, 0x8D, 0x2F, 0x99, 0x8D, 0x2E, 0x99, 0xA2, 0x08, 0x4E, 0x2C, 0x99, 0x90, 0x0A, + 0x18, 0xAD, 0x2F, 0x99, 0x6D, 0x2D, 0x99, 0x8D, 0x2F, 0x99, 0x6E, 0x2F, 0x99, 0xCA, 0xD0, 0xEB, + 0x2E, 0x2E, 0x99, 0x2E, 0x2F, 0x99, 0xAE, 0x31, 0x99, 0xF0, 0xAE, 0xCA, 0xF0, 0xC5, 0xCA, 0xF0, + 0x24, 0xCA, 0xF0, 0x3B, 0xA9, 0x30, 0x8D, 0x30, 0x99, 0xA0, 0x00, 0xAE, 0x30, 0x99, 0xE0, 0x36, + 0xF0, 0x3C, 0xA9, 0x02, 0x8D, 0x31, 0x99, 0xAD, 0xE0, 0x97, 0x8D, 0x2C, 0x99, 0xB9, 0x20, 0x99, + 0x8D, 0x2D, 0x99, 0xD0, 0xAC, 0xAD, 0x2F, 0x99, 0xAE, 0x30, 0x99, 0x9D, 0x00, 0xB0, 0xEE, 0x31, + 0x99, 0xAD, 0xE1, 0x97, 0x8D, 0x2C, 0x99, 0xB9, 0x26, 0x99, 0x8D, 0x2D, 0x99, 0xD0, 0x92, 0xAD, + 0x2F, 0x99, 0xAE, 0x30, 0x99, 0x9D, 0x50, 0xB0, 0xC8, 0xEE, 0x30, 0x99, 0xD0, 0xBD, 0xA5, 0x01, + 0x09, 0x01, 0x85, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0E, 0x13, 0x18, 0x1B, 0x17, + 0x15, 0x10, 0x14, 0x0E, 0x12, 0x0E, 0x12, 0x12, 0x10, 0x0D, 0x0F, 0x0B, 0x12, 0x0E, 0x0B, 0x09, + 0x06, 0x06, 0x06, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0x49, 0x43, 0x3F, 0x28, 0x2C, 0x1F, 0x25, + 0x2D, 0x49, 0x31, 0x24, 0x1E, 0x33, 0x25, 0x1D, 0x45, 0x18, 0x32, 0x1E, 0x18, 0x53, 0x2E, 0x36, + 0x56, 0x13, 0x1B, 0x15, 0x1B, 0x12, 0x0D, 0x48, 0x27, 0x1F, 0x2B, 0x1E, 0x22, 0x00, 0x22, 0x00, + 0x22, 0x36, 0x03, 0x01, 0xFF, 0x01, 0x06, 0x53, 0x41, 0x48, 0x01, 0x45, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xA9, 0x08, 0xA2, 0x08, 0xA0, 0x00, 0x20, 0xBA, 0xFF, 0xA9, 0x07, 0xA2, 0xE0, 0xA0, 0x99, + 0x20, 0xBD, 0xFF, 0xA9, 0x00, 0xA2, 0x00, 0xA0, 0x7D, 0x18, 0x20, 0xD5, 0xFF, 0x90, 0x1B, 0x20, + 0xCC, 0xFF, 0xA2, 0x0C, 0xBD, 0x6C, 0x99, 0x20, 0xD2, 0xFF, 0xCA, 0xD0, 0xF7, 0x60, 0x0D, 0x52, + 0x4F, 0x52, 0x52, 0x45, 0x20, 0x45, 0x4C, 0x49, 0x46, 0x0D, 0x20, 0xCC, 0xFF, 0xA2, 0x15, 0xBD, + 0xE6, 0x99, 0x20, 0xD2, 0xFF, 0xCA, 0xD0, 0xF7, 0xA9, 0x00, 0x85, 0x33, 0x85, 0x35, 0x85, 0x37, + 0x20, 0xE4, 0xFF, 0x29, 0x7F, 0xC9, 0x4C, 0xF0, 0x07, 0xC9, 0x48, 0xF0, 0x0C, 0x4C, 0x8F, 0x99, + 0xA9, 0x7D, 0x85, 0x34, 0x85, 0x36, 0x85, 0x38, 0x60, 0xA2, 0x1A, 0xCA, 0xBD, 0x8B, 0x92, 0x18, + 0x69, 0x43, 0x9D, 0x8B, 0x92, 0xE0, 0x00, 0xD0, 0xF2, 0x86, 0xFB, 0x86, 0xFD, 0xA9, 0x7D, 0x85, + 0xFC, 0xA9, 0xC0, 0x85, 0xFE, 0xA0, 0x00, 0xB1, 0xFB, 0x91, 0xFD, 0xC8, 0xD0, 0xF9, 0xE6, 0xFC, + 0xE6, 0xFE, 0xA5, 0xFE, 0xC9, 0xD0, 0xD0, 0xEF, 0xA9, 0x8D, 0x85, 0x34, 0x85, 0x36, 0x85, 0x38, + 0x60, 0x52, 0x45, 0x43, 0x49, 0x54, 0x45, 0x52, 0x0D, 0x3F, 0x59, 0x52, 0x4F, 0x4D, 0x45, 0x4D, + 0x20, 0x48, 0x47, 0x49, 0x48, 0x20, 0x52, 0x4F, 0x20, 0x57, 0x4F, 0x4C, 0x0D, 0x00, 0x00, 0x00, + 0x00, 0x4C, 0x15, 0x9B, 0x4C, 0x5B, 0x9B, 0x4C, 0x78, 0x8E, 0x4C, 0x84, 0x8E, 0x41, 0x40, 0x48, + 0x40, 0x00, 0x00, 0x1B, 0x0C, 0xFF, 0x41, 0x45, 0x34, 0x4E, 0x49, 0x58, 0x4D, 0x55, 0x4C, 0x9B, + 0x54, 0x20, 0x49, 0x48, 0x5A, 0x20, 0x41, 0x48, 0x20, 0x53, 0x41, 0x4F, 0x34, 0x46, 0x54, 0x20, + 0x41, 0x45, 0x34, 0x4E, 0x49, 0x58, 0x4D, 0x55, 0x4C, 0x20, 0x20, 0x9B, 0x44, 0x20, 0x47, 0x41, + 0x4D, 0x45, 0x9B, 0x49, 0x48, 0x44, 0x20, 0x47, 0x45, 0x59, 0x4D, 0x9B, 0x48, 0x4F, 0x57, 0x36, + 0x4D, 0x3F, 0x9B, 0x20, 0x59, 0x49, 0x59, 0x34, 0x52, 0x2E, 0x9B, 0x9B, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x20, 0x39, 0x9B, 0x20, 0xCD, 0xA3, 0xA5, 0x1B, 0xF0, 0x3C, + 0x60, 0xAD, 0x10, 0x9A, 0xD0, 0x14, 0xAD, 0x11, 0xD0, 0x8D, 0x12, 0x9A, 0xAD, 0x15, 0xD0, 0x8D, + 0x13, 0x9A, 0xA9, 0x00, 0x8D, 0x11, 0xD0, 0x8D, 0x15, 0xD0, 0xA9, 0xFF, 0x8D, 0x02, 0xD4, 0x8D, + 0x03, 0xD4, 0x8D, 0x06, 0xD4, 0xA9, 0x00, 0x8D, 0x05, 0xD4, 0xA9, 0x41, 0x8D, 0x04, 0xD4, 0xAD, + 0x11, 0x9A, 0xD0, 0x01, 0x78, 0xA5, 0x01, 0x29, 0xFE, 0x85, 0x01, 0x60, 0x20, 0x20, 0x9B, 0x20, + 0xC0, 0xB9, 0xA9, 0xFF, 0x8D, 0x14, 0x9A, 0x20, 0x68, 0xA0, 0xAD, 0x14, 0x9A, 0xC9, 0xFF, 0xD0, + 0x4C, 0x20, 0xB5, 0xA1, 0x20, 0x9B, 0xA3, 0x20, 0xF3, 0xA0, 0x20, 0xEB, 0xBD, 0x20, 0x18, 0xA1, + 0xA9, 0x00, 0xA9, 0x07, 0x8D, 0xA9, 0xBC, 0xA9, 0x06, 0x8D, 0xD8, 0xBC, 0xAD, 0x0F, 0x9A, 0x8D, + 0x3F, 0xBA, 0xAD, 0x0E, 0x9A, 0x8D, 0x18, 0xBC, 0xBD, 0xE0, 0x9B, 0xC9, 0x50, 0xB0, 0x05, 0xE8, + 0xD0, 0xF6, 0xF0, 0x05, 0xA9, 0xFF, 0x9D, 0xE0, 0x9B, 0x20, 0x2F, 0xBD, 0xA9, 0xFF, 0x8D, 0xDE, + 0x9C, 0x20, 0xA3, 0xBD, 0xA2, 0x00, 0xE4, 0x1D, 0x86, 0x1D, 0xF0, 0x01, 0x60, 0xAD, 0x10, 0x9A, + 0xD0, 0x0C, 0xAD, 0x12, 0x9A, 0x8D, 0x11, 0xD0, 0xAD, 0x13, 0x9A, 0x8D, 0x15, 0xD0, 0x20, 0xCB, + 0xB9, 0xA5, 0x01, 0x09, 0x01, 0x85, 0x01, 0x58, 0x60, 0x20, 0x3B, 0xA4, 0xA9, 0x01, 0x85, 0x1B, + 0x60, 0x08, 0x1C, 0x0E, 0x1B, 0x0D, 0x13, 0xFF, 0x38, 0x0E, 0x1E, 0x00, 0x06, 0x26, 0x00, 0x0A, + 0x00, 0x20, 0x0B, 0x22, 0x45, 0x46, 0x47, 0x00, 0x08, 0x1C, 0x0E, 0x1B, 0x0D, 0x13, 0x00, 0x00, + 0xFF, 0x41, 0x00, 0x22, 0x0C, 0x45, 0x36, 0x37, 0x38, 0x0B, 0x13, 0x00, 0x06, 0x26, 0x00, 0x0A, + 0x00, 0x20, 0x39, 0x3A, 0x3B, 0x10, 0x14, 0x42, 0x43, 0x44, 0x06, 0x39, 0x3A, 0x3B, 0x00, 0x3C, + 0x3D, 0x3E, 0x30, 0x15, 0x1B, 0xFF, 0x4C, 0x4D, 0x01, 0xFE, 0xFF, 0x0A, 0x1E, 0x05, 0x01, 0xFE, + 0xFF, 0xFF, 0xFE, 0x00, 0x19, 0x11, 0x1C, 0x45, 0x46, 0x47, 0x00, 0x1A, 0x35, 0x14, 0x00, 0x42, + 0x43, 0x44, 0x18, 0x05, 0x26, 0x00, 0x45, 0x46, 0x47, 0x30, 0x15, 0x4B, 0x1B, 0x05, 0x00, 0x24, + 0x34, 0x14, 0x1B, 0x02, 0xFE, 0xFF, 0x0A, 0x4B, 0x45, 0x46, 0x47, 0x00, 0x04, 0xFE, 0x00, 0x0A, + 0x28, 0x00, 0x29, 0x06, 0x20, 0x00, 0x1A, 0x05, 0x12, 0x01, 0xFE, 0xFF, 0x13, 0x39, 0x3A, 0x3B, + 0x00, 0x42, 0x43, 0x44, 0x07, 0x42, 0x43, 0x44, 0x0F, 0x26, 0x04, 0xFE, 0x39, 0x3A, 0x3B, 0x06, + 0x39, 0x3A, 0x3B, 0x00, 0x42, 0x43, 0x44, 0x05, 0x1E, 0x0F, 0x00, 0x42, 0x43, 0x44, 0x31, 0x15, + 0x42, 0x43, 0x44, 0x0F, 0x00, 0x42, 0x43, 0x44, 0x06, 0x4B, 0x4C, 0x4D, 0x01, 0xFE, 0xFF, 0x4D, + 0x0D, 0x13, 0x39, 0x3A, 0x3B, 0x00, 0x42, 0x43, 0x44, 0x07, 0x42, 0x43, 0x44, 0x0F, 0x26, 0x01, + 0xFE, 0xFF, 0x4D, 0x18, 0x05, 0x01, 0xFE, 0xFF, 0x47, 0x10, 0x00, 0x0A, 0x00, 0x36, 0x37, 0x38, + 0x30, 0x15, 0x20, 0x06, 0x4B, 0x1F, 0x42, 0x43, 0x44, 0x17, 0x11, 0x3F, 0x40, 0x41, 0x17, 0x08, + 0x1B, 0x01, 0xFE, 0xFF, 0xFE, 0xFF, 0x29, 0x0D, 0x00, 0x42, 0x43, 0x44, 0x09, 0x20, 0x0D, 0xFF, + 0xFF, 0x12, 0x07, 0x07, 0x07, 0x04, 0x08, 0x01, 0x02, 0x05, 0x02, 0x00, 0x0B, 0x06, 0x00, 0x06, + 0x00, 0x02, 0x10, 0x02, 0x04, 0x02, 0x02, 0x00, 0x12, 0x07, 0x07, 0x07, 0x05, 0x09, 0x00, 0x00, + 0x01, 0x02, 0x00, 0x02, 0x0B, 0x03, 0x04, 0x01, 0x02, 0x0C, 0x09, 0x00, 0x0B, 0x06, 0x00, 0x06, + 0x00, 0x02, 0x05, 0x01, 0x01, 0x0A, 0x07, 0x08, 0x02, 0x02, 0x0B, 0x03, 0x01, 0x01, 0x00, 0x04, + 0x01, 0x02, 0x0D, 0x09, 0x07, 0x0A, 0x01, 0x04, 0x12, 0x04, 0x02, 0x0B, 0x02, 0x0D, 0x12, 0x02, + 0x01, 0x12, 0x02, 0x00, 0x08, 0x12, 0x05, 0x06, 0x02, 0x02, 0x00, 0x06, 0x09, 0x08, 0x00, 0x08, + 0x02, 0x02, 0x07, 0x0E, 0x06, 0x00, 0x06, 0x02, 0x02, 0x0E, 0x07, 0x06, 0x07, 0x08, 0x00, 0x02, + 0x0E, 0x11, 0x0B, 0x12, 0x02, 0x02, 0x09, 0x06, 0x04, 0x02, 0x02, 0x01, 0x08, 0x02, 0x00, 0x08, + 0x07, 0x00, 0x06, 0x08, 0x02, 0x00, 0x08, 0x0B, 0x10, 0x12, 0x02, 0x04, 0x0C, 0x03, 0x01, 0x01, + 0x00, 0x05, 0x02, 0x02, 0x0A, 0x08, 0x02, 0x02, 0x16, 0x0A, 0x08, 0x04, 0x05, 0x01, 0x01, 0x0B, + 0x03, 0x01, 0x01, 0x00, 0x05, 0x02, 0x02, 0x0B, 0x02, 0x0B, 0x00, 0x08, 0x02, 0x02, 0x0F, 0x07, + 0x08, 0x02, 0x02, 0x0B, 0x00, 0x08, 0x02, 0x02, 0x0D, 0x0A, 0x01, 0x04, 0x12, 0x04, 0x01, 0x04, + 0x04, 0x0C, 0x03, 0x01, 0x01, 0x00, 0x05, 0x02, 0x02, 0x0A, 0x08, 0x02, 0x02, 0x16, 0x0A, 0x12, + 0x02, 0x01, 0x04, 0x04, 0x0D, 0x12, 0x04, 0x02, 0x02, 0x0C, 0x00, 0x06, 0x00, 0x08, 0x01, 0x02, + 0x0E, 0x08, 0x02, 0x07, 0x06, 0x05, 0x08, 0x02, 0x02, 0x08, 0x12, 0x06, 0x01, 0x02, 0x05, 0x11, + 0x0B, 0x12, 0x02, 0x12, 0x02, 0x00, 0x06, 0x05, 0x00, 0x08, 0x02, 0x02, 0x0F, 0x02, 0x07, 0x06, + 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x2A, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x20, 0x2E, 0x3F, 0x2C, 0x2D, + 0x49, 0x49, 0x45, 0x41, 0x41, 0x41, 0x41, 0x55, 0x41, 0x49, 0x45, 0x55, 0x4F, 0x52, 0x4C, 0x57, + 0x59, 0x57, 0x52, 0x4C, 0x57, 0x59, 0x4D, 0x4E, 0x4E, 0x44, 0x51, 0x53, 0x53, 0x46, 0x54, 0x2F, + 0x2F, 0x5A, 0x5A, 0x56, 0x44, 0x43, 0x2A, 0x4A, 0x2A, 0x2A, 0x2A, 0x45, 0x41, 0x4F, 0x41, 0x4F, + 0x55, 0x42, 0x2A, 0x2A, 0x44, 0x2A, 0x2A, 0x47, 0x2A, 0x2A, 0x47, 0x2A, 0x2A, 0x50, 0x2A, 0x2A, + 0x54, 0x2A, 0x2A, 0x4B, 0x2A, 0x2A, 0x4B, 0x2A, 0x2A, 0x55, 0x55, 0x55, 0x2A, 0x2A, 0x2A, 0x2A, + 0x2A, 0x59, 0x48, 0x48, 0x45, 0x41, 0x48, 0x4F, 0x48, 0x58, 0x58, 0x52, 0x58, 0x48, 0x58, 0x58, + 0x58, 0x58, 0x48, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x58, 0x58, 0x2A, 0x2A, 0x48, 0x2A, 0x48, + 0x48, 0x58, 0x2A, 0x48, 0x2A, 0x48, 0x48, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x59, 0x59, 0x59, 0x57, + 0x57, 0x57, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x58, 0x2A, 0x2A, 0x2A, 0x2A, + 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x58, 0x2A, 0x2A, 0x4C, 0x4D, 0x4E, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0x84, 0x84, 0xA4, 0xA4, 0x84, 0x84, 0x84, 0x84, + 0x84, 0x84, 0x84, 0x44, 0x44, 0x44, 0x44, 0x44, 0x4C, 0x4C, 0x4C, 0x48, 0x4C, 0x40, 0x40, 0x40, + 0x40, 0x40, 0x40, 0x44, 0x44, 0x44, 0x44, 0x48, 0x40, 0x4C, 0x44, 0x00, 0x00, 0xB4, 0xB4, 0xB4, + 0x94, 0x94, 0x94, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4B, + 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x80, 0xC1, 0xC1, 0xC1, 0xC1, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x08, 0x0C, 0x08, 0x04, 0x40, 0x24, 0x20, 0x20, 0x24, 0x00, + 0x00, 0x24, 0x20, 0x20, 0x24, 0x20, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x3F, 0x86, 0x3E, 0x84, 0x3D, 0x60, + 0xA5, 0x3F, 0xA6, 0x3E, 0xA4, 0x3D, 0x60, 0x20, 0x28, 0xA0, 0xA2, 0xFF, 0xA0, 0x00, 0xCA, 0x88, + 0xBD, 0xE0, 0x9B, 0x99, 0xE0, 0x9B, 0xBD, 0xE0, 0x9C, 0x99, 0xE0, 0x9C, 0xBD, 0xE0, 0x9D, 0x99, + 0xE0, 0x9D, 0xE4, 0x39, 0xD0, 0xE8, 0xA5, 0x3C, 0x9D, 0xE0, 0x9B, 0xA5, 0x3B, 0x9D, 0xE0, 0x9C, + 0xA5, 0x3A, 0x9D, 0xE0, 0x9D, 0x20, 0x2F, 0xA0, 0x60, 0xA2, 0x00, 0x8A, 0xA8, 0x85, 0x42, 0x99, + 0xE0, 0x9D, 0xC8, 0xC0, 0xFF, 0xD0, 0xF8, 0xBD, 0x15, 0x9A, 0xC9, 0x9B, 0xF0, 0x6E, 0x85, 0x41, + 0xE8, 0xBD, 0x15, 0x9A, 0x85, 0x40, 0xA0, 0x00, 0xB9, 0xEA, 0x9E, 0xC5, 0x41, 0xD0, 0x0B, 0xB9, + 0x3B, 0x9F, 0xC9, 0x2A, 0xF0, 0x04, 0xC5, 0x40, 0xF0, 0x07, 0xC8, 0xC0, 0x51, 0xD0, 0xE9, 0xF0, + 0x0C, 0x98, 0xA4, 0x42, 0x99, 0xE0, 0x9B, 0xE6, 0x42, 0xE8, 0x4C, 0x76, 0xA0, 0xA0, 0x00, 0xB9, + 0x3B, 0x9F, 0xC9, 0x2A, 0xD0, 0x07, 0xB9, 0xEA, 0x9E, 0xC5, 0x41, 0xF0, 0x07, 0xC8, 0xC0, 0x51, + 0xD0, 0xED, 0xF0, 0x0B, 0x98, 0xA4, 0x42, 0x99, 0xE0, 0x9B, 0xE6, 0x42, 0x4C, 0x76, 0xA0, 0xA5, + 0x41, 0xA0, 0x08, 0xD9, 0xE0, 0x9E, 0xF0, 0x0A, 0x88, 0xD0, 0xF8, 0x8E, 0x14, 0x9A, 0x20, 0x3B, + 0xA4, 0x60, 0x98, 0xA4, 0x42, 0x88, 0x99, 0xE0, 0x9D, 0x4C, 0x76, 0xA0, 0xA9, 0xFF, 0xA4, 0x42, + 0x99, 0xE0, 0x9B, 0x60, 0xA0, 0x00, 0xB9, 0xE0, 0x9B, 0xC9, 0xFF, 0xF0, 0x1B, 0xAA, 0xB9, 0xE0, + 0x9D, 0xF0, 0x0B, 0x30, 0x09, 0xBD, 0xE0, 0xB1, 0x99, 0xE0, 0x9C, 0x4C, 0x13, 0xA1, 0xBD, 0x30, + 0xB2, 0x99, 0xE0, 0x9C, 0xC8, 0x4C, 0xF5, 0xA0, 0x60, 0xA9, 0x00, 0x85, 0x42, 0xA6, 0x42, 0xBD, + 0xE0, 0x9B, 0xC9, 0xFF, 0xD0, 0x01, 0x60, 0x85, 0x3C, 0xA8, 0xB9, 0x8C, 0x9F, 0xA8, 0x29, 0x02, + 0xD0, 0x05, 0xE6, 0x42, 0x4C, 0x1C, 0xA1, 0x98, 0x29, 0x01, 0xD0, 0x2C, 0xE6, 0x3C, 0xA4, 0x3C, + 0xBD, 0xE0, 0x9D, 0x85, 0x3A, 0xB9, 0x30, 0xB2, 0x85, 0x3B, 0xE8, 0x86, 0x39, 0x20, 0x36, 0xA0, + 0xE6, 0x3C, 0xA4, 0x3C, 0xB9, 0x30, 0xB2, 0x85, 0x3B, 0xE8, 0x86, 0x39, 0x20, 0x36, 0xA0, 0xE6, + 0x42, 0xE6, 0x42, 0xE6, 0x42, 0x4C, 0x1C, 0xA1, 0xE8, 0xBD, 0xE0, 0x9B, 0xF0, 0xFA, 0x85, 0x38, + 0xC9, 0xFF, 0xD0, 0x03, 0x4C, 0x88, 0xA1, 0xA8, 0xB9, 0x8C, 0x9F, 0x29, 0x08, 0xD0, 0x32, 0xA5, + 0x38, 0xC9, 0x24, 0xF0, 0x2C, 0xC9, 0x25, 0xF0, 0x28, 0xA6, 0x42, 0xBD, 0xE0, 0x9D, 0x85, 0x3A, + 0xE8, 0x86, 0x39, 0xA6, 0x3C, 0xE8, 0x86, 0x3C, 0xBD, 0x30, 0xB2, 0x85, 0x3B, 0x20, 0x36, 0xA0, + 0xE6, 0x39, 0xE8, 0x86, 0x3C, 0xBD, 0x30, 0xB2, 0x85, 0x3B, 0x20, 0x36, 0xA0, 0xE6, 0x42, 0xE6, + 0x42, 0xE6, 0x42, 0x4C, 0x1C, 0xA1, 0xA9, 0x00, 0x85, 0x42, 0xA6, 0x42, 0xBD, 0xE0, 0x9B, 0xD0, + 0x05, 0xE6, 0x42, 0x4C, 0xB9, 0xA1, 0xC9, 0xFF, 0xD0, 0x01, 0x60, 0xA8, 0xB9, 0x8C, 0x9F, 0x29, + 0x10, 0xF0, 0x1F, 0xBD, 0xE0, 0x9D, 0x85, 0x3A, 0xE8, 0x86, 0x39, 0xB9, 0x8C, 0x9F, 0x29, 0x20, + 0xF0, 0x0C, 0xA9, 0x15, 0x85, 0x3C, 0x20, 0x36, 0xA0, 0xA6, 0x42, 0x4C, 0x15, 0xA3, 0xA9, 0x14, + 0xD0, 0xF2, 0xBD, 0xE0, 0x9B, 0xC9, 0x4E, 0xD0, 0x17, 0xA9, 0x18, 0x85, 0x3C, 0xBD, 0xE0, 0x9D, + 0x85, 0x3A, 0xA9, 0x0D, 0x9D, 0xE0, 0x9B, 0xE8, 0x86, 0x39, 0x20, 0x36, 0xA0, 0x4C, 0x96, 0xA3, + 0xC9, 0x4F, 0xD0, 0x04, 0xA9, 0x1B, 0xD0, 0xE3, 0xC9, 0x50, 0xD0, 0x04, 0xA9, 0x1C, 0xD0, 0xDB, + 0xA8, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xF0, 0x2B, 0xBD, 0xE0, 0x9D, 0xF0, 0x26, 0xE8, 0xBD, 0xE0, + 0x9B, 0xD0, 0x20, 0xE8, 0xBC, 0xE0, 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xF0, 0x15, 0xBD, 0xE0, + 0x9D, 0xF0, 0x10, 0x86, 0x39, 0xA9, 0x00, 0x85, 0x3A, 0xA9, 0x1F, 0x85, 0x3C, 0x20, 0x36, 0xA0, + 0x4C, 0x96, 0xA3, 0xA6, 0x42, 0xBD, 0xE0, 0x9B, 0xC9, 0x17, 0xD0, 0x30, 0xCA, 0xBD, 0xE0, 0x9B, + 0xC9, 0x45, 0xD0, 0x08, 0xA9, 0x2A, 0x9D, 0xE0, 0x9B, 0x4C, 0x33, 0xA3, 0xC9, 0x39, 0xD0, 0x08, + 0xA9, 0x2C, 0x9D, 0xE0, 0x9B, 0x4C, 0x3C, 0xA3, 0xA8, 0xE8, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xD0, + 0x03, 0x4C, 0x96, 0xA3, 0xA9, 0x12, 0x9D, 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xC9, 0x18, 0xD0, 0x17, + 0xCA, 0xBC, 0xE0, 0x9B, 0xE8, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xD0, 0x03, 0x4C, 0x96, 0xA3, 0xA9, + 0x13, 0x9D, 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xC9, 0x20, 0xD0, 0x14, 0xCA, 0xBD, 0xE0, 0x9B, 0xC9, + 0x3C, 0xF0, 0x03, 0x4C, 0x96, 0xA3, 0xE8, 0xA9, 0x26, 0x9D, 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xC9, + 0x48, 0xD0, 0x17, 0xE8, 0xBC, 0xE0, 0x9B, 0xCA, 0xB9, 0x8C, 0x9F, 0x29, 0x20, 0xF0, 0x03, 0x4C, + 0xF4, 0xA2, 0xA9, 0x4B, 0x9D, 0xE0, 0x9B, 0x4C, 0xF4, 0xA2, 0xC9, 0x3C, 0xD0, 0x17, 0xE8, 0xBC, + 0xE0, 0x9B, 0xCA, 0xB9, 0x8C, 0x9F, 0x29, 0x20, 0xF0, 0x03, 0x4C, 0x96, 0xA3, 0xA9, 0x3F, 0x9D, + 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xBC, 0xE0, 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x01, 0xF0, 0x17, 0xCA, + 0xBD, 0xE0, 0x9B, 0xE8, 0xC9, 0x20, 0xF0, 0x04, 0x98, 0x4C, 0x54, 0xA3, 0x38, 0x98, 0xE9, 0x0C, + 0x9D, 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xBD, 0xE0, 0x9B, 0xC9, 0x35, 0xD0, 0x17, 0xCA, 0xBC, 0xE0, + 0x9B, 0xE8, 0xB9, 0xDA, 0x9F, 0x29, 0x04, 0xD0, 0x03, 0x4C, 0x96, 0xA3, 0xA9, 0x10, 0x9D, 0xE0, + 0x9B, 0x4C, 0x96, 0xA3, 0xC9, 0x2A, 0xD0, 0x05, 0xA8, 0xC8, 0x4C, 0x43, 0xA3, 0xC9, 0x2C, 0xF0, + 0xF7, 0x4C, 0x54, 0xA3, 0x84, 0x3C, 0xE8, 0x86, 0x39, 0xCA, 0xBD, 0xE0, 0x9D, 0x85, 0x3A, 0x20, + 0x36, 0xA0, 0x4C, 0x96, 0xA3, 0xC9, 0x45, 0xD0, 0x02, 0xF0, 0x07, 0xC9, 0x39, 0xF0, 0x03, 0x4C, + 0x96, 0xA3, 0xCA, 0xBC, 0xE0, 0x9B, 0xE8, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xF0, 0x29, 0xE8, 0xBD, + 0xE0, 0x9B, 0xF0, 0x17, 0xA8, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xF0, 0x1B, 0xBD, 0xE0, 0x9D, 0xD0, + 0x16, 0xA6, 0x42, 0xA9, 0x1E, 0x9D, 0xE0, 0x9B, 0x4C, 0x96, 0xA3, 0xE8, 0xBD, 0xE0, 0x9B, 0xA8, + 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xD0, 0xEA, 0xE6, 0x42, 0x4C, 0xB9, 0xA1, 0xA9, 0x00, 0x85, 0x42, + 0xA6, 0x42, 0xBC, 0xE0, 0x9B, 0xC0, 0xFF, 0xD0, 0x01, 0x60, 0xB9, 0x8C, 0x9F, 0x29, 0x40, 0xF0, + 0x18, 0xE8, 0xBC, 0xE0, 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xF0, 0x0D, 0xBC, 0xE0, 0x9D, 0xF0, + 0x08, 0x30, 0x06, 0xC8, 0xCA, 0x98, 0x9D, 0xE0, 0x9D, 0xE6, 0x42, 0x4C, 0x9F, 0xA3, 0xA5, 0x2D, + 0x85, 0x22, 0xA5, 0x2E, 0x85, 0x23, 0xA0, 0x00, 0xB1, 0x22, 0xC9, 0x53, 0xD0, 0x09, 0xC8, 0xB1, + 0x22, 0xC9, 0xC1, 0xD0, 0x02, 0xF0, 0x2B, 0xA0, 0x00, 0x18, 0xA5, 0x22, 0x69, 0x07, 0x85, 0x22, + 0xA5, 0x23, 0x69, 0x00, 0x85, 0x23, 0xC5, 0x30, 0x90, 0xDE, 0xD0, 0x0A, 0xA5, 0x22, 0xC5, 0x2F, + 0xB0, 0x04, 0xF0, 0x02, 0xD0, 0xD2, 0x20, 0x3B, 0xA4, 0xA9, 0x01, 0x85, 0x1B, 0x68, 0x68, 0x4C, + 0xD0, 0x9B, 0xA0, 0x04, 0xB1, 0x22, 0x85, 0x20, 0x88, 0xB1, 0x22, 0x85, 0x1F, 0x88, 0xB1, 0x22, + 0x85, 0x21, 0xA0, 0x00, 0xB1, 0x1F, 0x29, 0x7F, 0x99, 0x15, 0x9A, 0xC8, 0xC4, 0x21, 0xD0, 0xF4, + 0xA9, 0x9B, 0x99, 0x15, 0x9A, 0xA9, 0x00, 0x85, 0x1B, 0x85, 0x1D, 0x60, 0xA9, 0x02, 0x85, 0x1E, + 0x58, 0xA5, 0xA2, 0x18, 0x69, 0x08, 0xAA, 0xA9, 0x0F, 0x8D, 0x18, 0xD4, 0xA9, 0x00, 0xA0, 0xD0, + 0x88, 0xD0, 0xFD, 0x8D, 0x18, 0xD4, 0xA0, 0xD0, 0x88, 0xD0, 0xFD, 0xE4, 0xA2, 0xD0, 0xE8, 0xC6, + 0x1E, 0xF0, 0x0C, 0x8A, 0x18, 0x69, 0x05, 0xAA, 0xE4, 0xA2, 0xD0, 0xFC, 0x4C, 0x40, 0xA4, 0x60, + 0x00, 0x22, 0x79, 0x19, 0x16, 0x00, 0x09, 0xA5, 0x00, 0x01, 0x00, 0x0B, 0xA5, 0x8B, 0x09, 0xF2, + 0x19, 0x69, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x35, 0x19, 0x00, 0x1A, 0x1F, 0x22, + 0xA5, 0x8B, 0xAE, 0x8B, 0x00, 0x8D, 0x96, 0x00, 0x18, 0x00, 0x4B, 0x0C, 0xF8, 0xC5, 0xF7, 0x18, + 0x43, 0x4F, 0x50, 0x59, 0x52, 0x49, 0x47, 0x48, 0x54, 0x20, 0x31, 0x39, 0x38, 0x32, 0x20, 0x44, + 0x4F, 0x4E, 0x27, 0x54, 0x20, 0x41, 0x53, 0x4B, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x50, 0x50, + 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, + 0x60, 0x60, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x50, 0x50, 0x50, + 0x50, 0x50, 0x50, 0x50, 0x50, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x30, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, + 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xB0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xD0, 0xD0, 0xD0, 0xD0, + 0xD0, 0xD0, 0xD0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0x00, + 0x00, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, + 0x90, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, + 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, + 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, + 0x0F, 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0A, 0x0C, 0x0D, 0x0F, 0x10, 0x12, 0x13, 0x15, + 0x16, 0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0E, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1A, 0x1C, + 0x1E, 0x00, 0x02, 0x05, 0x07, 0x0A, 0x0C, 0x0F, 0x11, 0x14, 0x16, 0x19, 0x1B, 0x1E, 0x20, 0x23, + 0x25, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, + 0x2D, 0x00, 0x03, 0x07, 0x0A, 0x0E, 0x11, 0x15, 0x18, 0x1C, 0x1F, 0x23, 0x26, 0x2A, 0x2D, 0x31, + 0x34, 0x00, 0xFC, 0xF8, 0xF4, 0xF0, 0xEC, 0xE8, 0xE4, 0xE0, 0xDC, 0xD8, 0xD4, 0xD0, 0xCC, 0xC8, + 0xC4, 0x00, 0xFC, 0xF9, 0xF5, 0xF2, 0xEE, 0xEB, 0xE7, 0xE4, 0xE0, 0xDD, 0xD9, 0xD6, 0xD2, 0xCF, + 0xCB, 0x00, 0xFD, 0xFA, 0xF7, 0xF4, 0xF1, 0xEE, 0xEB, 0xE8, 0xE5, 0xE2, 0xDF, 0xDC, 0xD9, 0xD6, + 0xD3, 0x00, 0xFD, 0xFB, 0xF8, 0xF6, 0xF3, 0xF1, 0xEE, 0xEC, 0xE9, 0xE7, 0xE4, 0xE2, 0xDF, 0xDD, + 0xDA, 0x00, 0xFE, 0xFC, 0xFA, 0xF8, 0xF6, 0xF4, 0xF2, 0xF0, 0xEE, 0xEC, 0xEA, 0xE8, 0xE6, 0xE4, + 0xE2, 0x00, 0xFE, 0xFD, 0xFB, 0xFA, 0xF8, 0xF7, 0xF5, 0xF4, 0xF2, 0xF1, 0xEF, 0xEE, 0xEC, 0xEB, + 0xE9, 0x00, 0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8, 0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, + 0xF1, 0x00, 0xFF, 0xFF, 0xFE, 0xFE, 0xFD, 0xFD, 0xFC, 0xFC, 0xFB, 0xFB, 0xFA, 0xFA, 0xF9, 0xF9, + 0xF8, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, + 0x2D, 0x2E, 0x32, 0x36, 0x3A, 0x3B, 0x3D, 0x3D, 0x3D, 0x3D, 0x3C, 0x3B, 0x39, 0x39, 0x39, 0x39, + 0x39, 0x3B, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x3A, 0x36, 0x36, 0x37, 0x37, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x36, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x34, 0x34, 0x36, 0x36, + 0x38, 0x38, 0x38, 0x36, 0x32, 0x30, 0x2E, 0x2A, 0x2D, 0x2F, 0x31, 0x33, 0x31, 0x2C, 0x27, 0x23, + 0x22, 0x21, 0x21, 0x20, 0x1F, 0x20, 0x21, 0x23, 0x24, 0x26, 0x2B, 0x31, 0x34, 0x38, 0x38, 0x3A, + 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x33, 0x2C, 0x25, 0x23, 0x22, 0x21, 0x1F, 0x1E, 0x1D, 0x1B, + 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x29, 0x30, 0x37, 0x38, 0x3A, 0x3A, 0x3A, 0x3A, 0x38, + 0x36, 0x32, 0x32, 0x32, 0x32, 0x32, 0x36, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x3A, 0x34, 0x2C, 0x2C, + 0x2C, 0x2E, 0x2E, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x27, 0x2C, 0x2C, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x2C, 0x27, 0x22, + 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x22, 0x27, 0x2C, 0x31, 0x31, 0x31, 0x31, 0x31, + 0x31, 0x31, 0x31, 0x31, 0x31, 0x2C, 0x27, 0x22, 0x1D, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, + 0x18, 0x18, 0x18, 0x18, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x1D, 0x27, 0x31, 0x31, 0x31, 0x31, + 0x31, 0x31, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0xC8, 0xC8, 0xC8, 0x6E, 0x6E, 0xFF, 0xFF, 0x6E, + 0x6E, 0xFF, 0xFF, 0x6E, 0x6E, 0xFF, 0xFF, 0x6E, 0x6E, 0xFF, 0xFF, 0x6E, 0x6E, 0xFF, 0xFF, 0x6E, + 0x6E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x12, 0x0C, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x08, 0x0B, 0x0E, 0x0E, 0x0E, 0x0E, + 0x0E, 0x0A, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0D, 0x14, 0x14, 0x13, 0x12, 0x11, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x0B, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, + 0x09, 0x09, 0x09, 0x0B, 0x0E, 0x10, 0x13, 0x16, 0x12, 0x0E, 0x0A, 0x06, 0x09, 0x0D, 0x10, 0x14, + 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x11, 0x0D, 0x0A, 0x09, 0x08, 0x07, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0C, 0x12, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x12, 0x0C, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x08, + 0x0B, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0A, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0D, 0x14, 0x14, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0D, 0x0D, 0x0D, 0x0D, 0x0C, + 0x0C, 0x0B, 0x09, 0x08, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x08, 0x0A, 0x0C, + 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0C, 0x0A, 0x08, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x08, 0x0A, 0x0D, 0x0F, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, + 0x11, 0x11, 0x10, 0x10, 0x0F, 0x0F, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0A, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x11, 0x11, 0x11, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, + 0x3E, 0x3E, 0x3C, 0x39, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3C, 0x42, 0x48, 0x48, 0x48, 0x48, + 0x48, 0x3B, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2D, 0x2C, 0x2B, 0x29, 0x28, 0x26, 0x24, 0x24, + 0x24, 0x24, 0x24, 0x24, 0x42, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x44, 0x40, 0x3C, 0x38, + 0x33, 0x33, 0x33, 0x32, 0x31, 0x2F, 0x2E, 0x2C, 0x33, 0x3A, 0x41, 0x49, 0x3F, 0x34, 0x29, 0x1E, + 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1D, 0x1C, 0x1B, 0x24, 0x2E, 0x38, + 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x41, 0x40, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, + 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3C, 0x39, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3C, + 0x42, 0x48, 0x48, 0x48, 0x48, 0x48, 0x3B, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2D, 0x2C, 0x2C, + 0x2B, 0x29, 0x28, 0x26, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x20, 0x1F, 0x1E, 0x1D, 0x1C, + 0x1C, 0x1C, 0x1B, 0x1B, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x1A, 0x25, 0x31, 0x3C, + 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x47, 0x45, 0x44, 0x42, 0x42, 0x42, 0x4D, 0x58, + 0x63, 0x6E, 0x6E, 0x6E, 0x6E, 0x67, 0x5F, 0x58, 0x50, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, + 0x47, 0x47, 0x46, 0x46, 0x45, 0x45, 0x44, 0x44, 0x44, 0x44, 0x44, 0x39, 0x2E, 0x2E, 0x2E, 0x2E, + 0x2E, 0x2E, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, + 0x58, 0x58, 0x63, 0x6E, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x70, 0x67, 0x5D, 0x5D, 0x5D, 0x5D, + 0x5D, 0x57, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x55, 0x59, 0x5D, 0x61, 0x65, 0x69, 0x6E, 0x6E, + 0x6E, 0x6E, 0x6E, 0x6E, 0x67, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, + 0x5D, 0x5D, 0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x57, 0x5A, 0x5D, 0x60, 0x63, 0x61, 0x5E, 0x5B, 0x58, + 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x57, 0x55, 0x53, 0x5C, 0x66, 0x6F, + 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x6E, 0x63, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, + 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x63, 0x6E, 0x79, 0x79, 0x79, 0x79, 0x79, 0x79, 0x70, + 0x67, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x57, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x55, 0x59, 0x59, + 0x5D, 0x61, 0x65, 0x69, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E, 0x51, 0x51, 0x51, 0x51, 0x50, + 0x50, 0x50, 0x50, 0x50, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x54, 0x57, 0x5A, + 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x64, 0x6B, 0x72, 0x79, 0x79, 0x79, 0x77, 0x75, + 0x73, 0x70, 0x6E, 0x6E, 0x6E, 0x6A, 0x66, 0x62, 0x5E, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, + 0x5A, 0x5B, 0x5B, 0x5B, 0x5C, 0x5C, 0x5D, 0x5D, 0x5D, 0x5D, 0x5D, 0x57, 0x51, 0x51, 0x51, 0x51, + 0x51, 0x51, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, + 0x0F, 0x0F, 0x0B, 0x08, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x08, 0x0B, 0x0B, 0x0B, 0x0B, + 0x0B, 0x0B, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0B, 0x0B, + 0x0B, 0x0B, 0x0B, 0x0B, 0x02, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x05, 0x05, + 0x04, 0x04, 0x04, 0x04, 0x05, 0x08, 0x0B, 0x0F, 0x05, 0x02, 0x02, 0x00, 0x02, 0x02, 0x04, 0x0F, + 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x05, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, + 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x08, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x04, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x02, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, + 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, + 0x00, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, 0x0D, + 0x0D, 0x0D, 0x0B, 0x08, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x02, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x05, 0x03, 0x02, 0x02, 0x00, 0x02, 0x02, 0x03, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, + 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x08, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, + 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, + 0x02, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, + 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x02, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF1, 0xF1, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD3, 0xD3, 0x00, 0x00, + 0x00, 0x00, 0x19, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0x1B, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x13, 0x13, 0x13, 0x13, 0x0A, 0x0E, 0x12, 0x18, 0x1A, 0x16, 0x14, 0x10, 0x14, 0x0E, + 0x12, 0x0E, 0x12, 0x12, 0x10, 0x0C, 0x0E, 0x0A, 0x12, 0x0E, 0x0A, 0x08, 0x06, 0x06, 0x06, 0x06, + 0x11, 0x06, 0x06, 0x06, 0x06, 0x0E, 0x10, 0x09, 0x0A, 0x08, 0x0A, 0x06, 0x06, 0x06, 0x05, 0x06, + 0x00, 0x12, 0x1A, 0x14, 0x1A, 0x12, 0x0C, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0A, 0x0A, 0x06, 0x06, 0x06, 0x2C, + 0x13, 0x00, 0x43, 0x43, 0x43, 0x43, 0x54, 0x48, 0x42, 0x3E, 0x28, 0x2C, 0x1E, 0x24, 0x2C, 0x48, + 0x30, 0x24, 0x1E, 0x32, 0x24, 0x1C, 0x44, 0x18, 0x32, 0x1E, 0x18, 0x52, 0x2E, 0x36, 0x56, 0x36, + 0x43, 0x49, 0x4F, 0x1A, 0x42, 0x49, 0x25, 0x33, 0x42, 0x28, 0x2F, 0x4F, 0x4F, 0x42, 0x4F, 0x6E, + 0x00, 0x48, 0x26, 0x1E, 0x2A, 0x1E, 0x22, 0x1A, 0x1A, 0x1A, 0x42, 0x42, 0x42, 0x6E, 0x6E, 0x6E, + 0x54, 0x54, 0x54, 0x1A, 0x1A, 0x1A, 0x42, 0x42, 0x42, 0x6D, 0x56, 0x6D, 0x54, 0x54, 0x54, 0x7F, + 0x7F, 0x00, 0x5B, 0x5B, 0x5B, 0x5B, 0x6E, 0x5D, 0x5B, 0x58, 0x59, 0x57, 0x58, 0x52, 0x59, 0x5D, + 0x3E, 0x52, 0x58, 0x3E, 0x6E, 0x50, 0x5D, 0x5A, 0x3C, 0x6E, 0x5A, 0x6E, 0x51, 0x79, 0x65, 0x79, + 0x5B, 0x63, 0x6A, 0x51, 0x79, 0x5D, 0x52, 0x5D, 0x67, 0x4C, 0x5D, 0x65, 0x65, 0x79, 0x65, 0x79, + 0x00, 0x5A, 0x58, 0x58, 0x58, 0x58, 0x52, 0x51, 0x51, 0x51, 0x79, 0x79, 0x79, 0x70, 0x6E, 0x6E, + 0x5E, 0x5E, 0x5E, 0x51, 0x51, 0x51, 0x79, 0x79, 0x79, 0x65, 0x65, 0x70, 0x5E, 0x5E, 0x5E, 0x08, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0D, 0x0D, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0C, 0x0D, + 0x0C, 0x0F, 0x0F, 0x0D, 0x0D, 0x0D, 0x0E, 0x0D, 0x0C, 0x0D, 0x0D, 0x0D, 0x0C, 0x09, 0x09, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x0B, 0x0B, 0x0B, 0x00, 0x00, 0x01, 0x0B, 0x00, + 0x02, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F, 0x0D, 0x02, 0x04, 0x00, 0x02, 0x04, 0x00, 0x01, 0x04, 0x00, + 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x0F, + 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x0D, 0x0E, 0x0D, 0x0C, 0x0C, 0x0B, 0x09, 0x0B, + 0x0B, 0x0C, 0x0C, 0x0C, 0x08, 0x08, 0x0C, 0x08, 0x0A, 0x08, 0x08, 0x0A, 0x03, 0x09, 0x06, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x03, 0x04, 0x00, 0x00, 0x00, 0x05, 0x0A, + 0x02, 0x0E, 0x0D, 0x0C, 0x0D, 0x0C, 0x08, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x0A, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x07, 0x08, 0x08, 0x01, 0x01, 0x00, 0x01, 0x00, 0x07, + 0x05, 0x01, 0x00, 0x06, 0x01, 0x00, 0x07, 0x00, 0x05, 0x01, 0x00, 0x08, 0x00, 0x00, 0x03, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0E, + 0x01, 0x09, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x05, 0x00, 0x13, + 0x10, 0x00, 0x12, 0x12, 0x12, 0x08, 0x0B, 0x09, 0x0B, 0x0E, 0x0F, 0x0B, 0x10, 0x0C, 0x06, 0x06, + 0x0E, 0x0C, 0x0E, 0x0C, 0x0B, 0x08, 0x08, 0x0B, 0x0A, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x03, + 0x05, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x06, 0x06, 0x08, 0x06, 0x06, 0x02, 0x09, 0x04, 0x02, + 0x01, 0x0E, 0x0F, 0x0F, 0x0F, 0x0E, 0x0E, 0x08, 0x02, 0x02, 0x07, 0x02, 0x01, 0x07, 0x02, 0x02, + 0x07, 0x02, 0x02, 0x08, 0x02, 0x02, 0x06, 0x02, 0x02, 0x07, 0x02, 0x04, 0x07, 0x01, 0x04, 0x05, + 0x05, 0x00, 0x12, 0x12, 0x12, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0B, 0x06, 0x0C, 0x0A, 0x05, 0x05, + 0x0B, 0x0A, 0x0A, 0x0A, 0x09, 0x08, 0x07, 0x09, 0x07, 0x06, 0x08, 0x06, 0x07, 0x07, 0x07, 0x02, + 0x05, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x06, 0x06, 0x07, 0x06, 0x06, 0x02, 0x08, 0x03, 0x01, + 0x1E, 0x0D, 0x0C, 0x0C, 0x0C, 0x0E, 0x09, 0x06, 0x01, 0x02, 0x05, 0x01, 0x01, 0x06, 0x01, 0x02, + 0x06, 0x01, 0x02, 0x08, 0x02, 0x02, 0x04, 0x02, 0x02, 0x06, 0x01, 0x04, 0x06, 0x01, 0x04, 0xC7, + 0xFF, 0x00, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x03, 0x02, 0x04, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0x01, + 0x02, 0x00, 0x01, 0x02, 0x00, 0x02, 0x02, 0x00, 0x01, 0x03, 0x00, 0x02, 0x03, 0x00, 0x02, 0xA0, + 0xA0, 0x00, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x02, 0x03, 0x02, + 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x03, 0x03, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x00, + 0x00, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x02, 0x00, 0x02, 0x02, 0x00, 0x03, 0x02, 0x00, 0x04, + 0x02, 0x00, 0x03, 0x02, 0x00, 0x02, 0x02, 0x00, 0x02, 0x03, 0x00, 0x03, 0x03, 0x00, 0x03, 0xB0, + 0xA0, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05, + 0x05, 0x02, 0x0A, 0x02, 0x08, 0x05, 0x05, 0x0B, 0x0A, 0x09, 0x08, 0x08, 0xA0, 0x08, 0x08, 0x17, + 0x1F, 0x12, 0x12, 0x12, 0x12, 0x1E, 0x1E, 0x14, 0x14, 0x14, 0x14, 0x17, 0x17, 0x1A, 0x1A, 0x1D, + 0x1D, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x1A, 0x1D, 0x1B, 0x1A, 0x1D, 0x1B, 0x1A, 0x1D, 0x1B, + 0x1A, 0x1D, 0x1B, 0x17, 0x1D, 0x17, 0x17, 0x1D, 0x17, 0x17, 0x1D, 0x17, 0x17, 0x1D, 0x17, 0x17, + 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xF1, 0xE2, 0xD3, 0xBB, 0x7C, 0x95, 0x01, 0x02, 0x03, 0x03, 0x00, 0x72, 0x00, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x38, 0x84, 0x6B, 0x19, 0xC6, 0x63, 0x18, 0x86, 0x73, 0x98, 0xC6, 0xB1, 0x1C, 0xCA, 0x31, + 0x8C, 0xC7, 0x31, 0x88, 0xC2, 0x30, 0x98, 0x46, 0x31, 0x18, 0xC6, 0x35, 0x0C, 0xCA, 0x31, 0x0C, + 0xC6, 0x21, 0x10, 0x24, 0x69, 0x12, 0xC2, 0x31, 0x14, 0xC4, 0x71, 0x08, 0x4A, 0x22, 0x49, 0xAB, + 0x6A, 0xA8, 0xAC, 0x49, 0x51, 0x32, 0xD5, 0x52, 0x88, 0x93, 0x6C, 0x94, 0x22, 0x15, 0x54, 0xD2, + 0x25, 0x96, 0xD4, 0x50, 0xA5, 0x46, 0x21, 0x08, 0x85, 0x6B, 0x18, 0xC4, 0x63, 0x10, 0xCE, 0x6B, + 0x18, 0x8C, 0x71, 0x19, 0x8C, 0x63, 0x35, 0x0C, 0xC6, 0x33, 0x99, 0xCC, 0x6C, 0xB5, 0x4E, 0xA2, + 0x99, 0x46, 0x21, 0x28, 0x82, 0x95, 0x2E, 0xE3, 0x30, 0x9C, 0xC5, 0x30, 0x9C, 0xA2, 0xB1, 0x9C, + 0x67, 0x31, 0x88, 0x66, 0x59, 0x2C, 0x53, 0x18, 0x84, 0x67, 0x50, 0xCA, 0xE3, 0x0A, 0xAC, 0xAB, + 0x30, 0xAC, 0x62, 0x30, 0x8C, 0x63, 0x10, 0x94, 0x62, 0xB1, 0x8C, 0x82, 0x28, 0x96, 0x33, 0x98, + 0xD6, 0xB5, 0x4C, 0x62, 0x29, 0xA5, 0x4A, 0xB5, 0x9C, 0xC6, 0x31, 0x14, 0xD6, 0x38, 0x9C, 0x4B, + 0xB4, 0x86, 0x65, 0x18, 0xAE, 0x67, 0x1C, 0xA6, 0x63, 0x19, 0x96, 0x23, 0x19, 0x84, 0x13, 0x08, + 0xA6, 0x52, 0xAC, 0xCA, 0x22, 0x89, 0x6E, 0xAB, 0x19, 0x8C, 0x62, 0x34, 0xC4, 0x62, 0x19, 0x86, + 0x63, 0x18, 0xC4, 0x23, 0x58, 0xD6, 0xA3, 0x50, 0x42, 0x54, 0x4A, 0xAD, 0x4A, 0x25, 0x11, 0x6B, + 0x64, 0x89, 0x4A, 0x63, 0x39, 0x8A, 0x23, 0x31, 0x2A, 0xEA, 0xA2, 0xA9, 0x44, 0xC5, 0x12, 0xCD, + 0x42, 0x34, 0x8C, 0x62, 0x18, 0x8C, 0x63, 0x11, 0x48, 0x66, 0x31, 0x9D, 0x44, 0x33, 0x1D, 0x46, + 0x31, 0x9C, 0xC6, 0xB1, 0x0C, 0xCD, 0x32, 0x88, 0xC4, 0x73, 0x18, 0x86, 0x73, 0x08, 0xD6, 0x63, + 0x58, 0x07, 0x81, 0xE0, 0xF0, 0x3C, 0x07, 0x87, 0x90, 0x3C, 0x7C, 0x0F, 0xC7, 0xC0, 0xC0, 0xF0, + 0x7C, 0x1E, 0x07, 0x80, 0x80, 0x00, 0x1C, 0x78, 0x70, 0xF1, 0xC7, 0x1F, 0xC0, 0x0C, 0xFE, 0x1C, + 0x1F, 0x1F, 0x0E, 0x0A, 0x7A, 0xC0, 0x71, 0xF2, 0x83, 0x8F, 0x03, 0x0F, 0x0F, 0x0C, 0x00, 0x79, + 0xF8, 0x61, 0xE0, 0x43, 0x0F, 0x83, 0xE7, 0x18, 0xF9, 0xC1, 0x13, 0xDA, 0xE9, 0x63, 0x8F, 0x0F, + 0x83, 0x83, 0x87, 0xC3, 0x1F, 0x3C, 0x70, 0xF0, 0xE1, 0xE1, 0xE3, 0x87, 0xB8, 0x71, 0x0E, 0x20, + 0xE3, 0x8D, 0x48, 0x78, 0x1C, 0x93, 0x87, 0x30, 0xE1, 0xC1, 0xC1, 0xE4, 0x78, 0x21, 0x83, 0x83, + 0xC3, 0x87, 0x06, 0x39, 0xE5, 0xC3, 0x87, 0x07, 0x0E, 0x1C, 0x1C, 0x70, 0xF4, 0x71, 0x9C, 0x60, + 0x36, 0x32, 0xC3, 0x1E, 0x3C, 0xF3, 0x8F, 0x0E, 0x3C, 0x70, 0xE3, 0xC7, 0x8F, 0x0F, 0x0F, 0x0E, + 0x3C, 0x78, 0xF0, 0xE3, 0x87, 0x06, 0xF0, 0xE3, 0x07, 0xC1, 0x99, 0x87, 0x0F, 0x18, 0x78, 0x70, + 0x70, 0xFC, 0xF3, 0x10, 0xB1, 0x8C, 0x8C, 0x31, 0x7C, 0x70, 0xE1, 0x86, 0x3C, 0x64, 0x6C, 0xB0, + 0xE1, 0xE3, 0x0F, 0x23, 0x8F, 0x0F, 0x1E, 0x3E, 0x38, 0x3C, 0x38, 0x7B, 0x8F, 0x07, 0x0E, 0x3C, + 0xF4, 0x17, 0x1E, 0x3C, 0x78, 0xF2, 0x9E, 0x72, 0x49, 0xE3, 0x25, 0x36, 0x38, 0x58, 0x39, 0xE2, + 0xDE, 0x3C, 0x78, 0x78, 0xE1, 0xC7, 0x61, 0xE1, 0xE1, 0xB0, 0xF0, 0xF0, 0xC3, 0xC7, 0x0E, 0x38, + 0xC0, 0xF0, 0xCE, 0x73, 0x73, 0x18, 0x34, 0xB0, 0xE1, 0xC7, 0x8E, 0x1C, 0x3C, 0xF8, 0x38, 0xF0, + 0xE1, 0xC1, 0x8B, 0x86, 0x8F, 0x1C, 0x78, 0x70, 0xF0, 0x78, 0xAC, 0xB1, 0x8F, 0x39, 0x31, 0xDB, + 0x38, 0x61, 0xC3, 0x0E, 0x0E, 0x38, 0x78, 0x73, 0x17, 0x1E, 0x39, 0x1E, 0x38, 0x64, 0xE1, 0xF1, + 0xC1, 0x4E, 0x0F, 0x40, 0xA2, 0x02, 0xC5, 0x8F, 0x81, 0xA1, 0xFC, 0x12, 0x08, 0x64, 0xE0, 0x3C, + 0x22, 0xE0, 0x45, 0x07, 0x8E, 0x0C, 0x32, 0x90, 0xF0, 0x1F, 0x20, 0x49, 0xE0, 0xF8, 0x0C, 0x60, + 0xF0, 0x17, 0x1A, 0x41, 0xAA, 0xA4, 0xD0, 0x8D, 0x12, 0x82, 0x1E, 0x1E, 0x03, 0xF8, 0x3E, 0x03, + 0x0C, 0x73, 0x80, 0x70, 0x44, 0x26, 0x03, 0x24, 0xE1, 0x3E, 0x04, 0x4E, 0x04, 0x1C, 0xC1, 0x09, + 0xCC, 0x9E, 0x90, 0x21, 0x07, 0x90, 0x43, 0x64, 0xC0, 0x0F, 0xC6, 0x90, 0x9C, 0xC1, 0x5B, 0x03, + 0xE2, 0x1D, 0x81, 0xE0, 0x5E, 0x1D, 0x03, 0x84, 0xB8, 0x2C, 0x0F, 0x80, 0xB1, 0x83, 0xE0, 0x30, + 0x41, 0x1E, 0x43, 0x89, 0x83, 0x50, 0xFC, 0x24, 0x2E, 0x13, 0x83, 0xF1, 0x7C, 0x4C, 0x2C, 0xC9, + 0x0D, 0x83, 0xB0, 0xB5, 0x82, 0xE4, 0xE8, 0x06, 0x9C, 0x07, 0xA0, 0x99, 0x1D, 0x07, 0x3E, 0x82, + 0x8F, 0x70, 0x30, 0x74, 0x40, 0xCA, 0x10, 0xE4, 0xE8, 0x0F, 0x92, 0x14, 0x3F, 0x06, 0xF8, 0x84, + 0x88, 0x43, 0x81, 0x0A, 0x34, 0x39, 0x41, 0xC6, 0xE3, 0x1C, 0x47, 0x03, 0xB0, 0xB8, 0x13, 0x0A, + 0xC2, 0x64, 0xF8, 0x18, 0xF9, 0x60, 0xB3, 0xC0, 0x65, 0x20, 0x60, 0xA6, 0x8C, 0xC3, 0x81, 0x20, + 0x30, 0x26, 0x1E, 0x1C, 0x38, 0xD3, 0x01, 0xB0, 0x26, 0x40, 0xF4, 0x0B, 0xC3, 0x42, 0x1F, 0x85, + 0x32, 0x26, 0x60, 0x40, 0xC9, 0xCB, 0x01, 0xEC, 0x11, 0x28, 0x40, 0xFA, 0x04, 0x34, 0xE0, 0x70, + 0x4C, 0x8C, 0x1D, 0x07, 0x69, 0x03, 0x16, 0xC8, 0x04, 0x23, 0xE8, 0xC6, 0x9A, 0x0B, 0x1A, 0x03, + 0xE0, 0x76, 0x06, 0x05, 0xCF, 0x1E, 0xBC, 0x58, 0x31, 0x71, 0x66, 0x00, 0xF8, 0x3F, 0x04, 0xFC, + 0x0C, 0x74, 0x27, 0x8A, 0x80, 0x71, 0xC2, 0x3A, 0x26, 0x06, 0xC0, 0x1F, 0x05, 0x0F, 0x98, 0x40, + 0xAE, 0x01, 0x7F, 0xC0, 0x07, 0xFF, 0x00, 0x0E, 0xFE, 0x00, 0x03, 0xDF, 0x80, 0x03, 0xEF, 0x80, + 0x1B, 0xF1, 0xC2, 0x00, 0xE7, 0xE0, 0x18, 0xFC, 0xE0, 0x21, 0xFC, 0x80, 0x3C, 0xFC, 0x40, 0x0E, + 0x7E, 0x00, 0x3F, 0x3E, 0x00, 0x0F, 0xFE, 0x00, 0x1F, 0xFF, 0x00, 0x3E, 0xF0, 0x07, 0xFC, 0x00, + 0x7E, 0x10, 0x3F, 0xFF, 0x00, 0x3F, 0x38, 0x0E, 0x7C, 0x01, 0x87, 0x0C, 0xFC, 0xC7, 0x00, 0x3E, + 0x04, 0x0F, 0x3E, 0x1F, 0x0F, 0x0F, 0x1F, 0x0F, 0x02, 0x83, 0x87, 0xCF, 0x03, 0x87, 0x0F, 0x3F, + 0xC0, 0x07, 0x9E, 0x60, 0x3F, 0xC0, 0x03, 0xFE, 0x00, 0x3F, 0xE0, 0x77, 0xE1, 0xC0, 0xFE, 0xE0, + 0xC3, 0xE0, 0x01, 0xDF, 0xF8, 0x03, 0x07, 0x00, 0x7E, 0x70, 0x00, 0x7C, 0x38, 0x18, 0xFE, 0x0C, + 0x1E, 0x78, 0x1C, 0x7C, 0x3E, 0x0E, 0x1F, 0x1E, 0x1E, 0x3E, 0x00, 0x7F, 0x83, 0x07, 0xDB, 0x87, + 0x83, 0x07, 0xC7, 0x07, 0x10, 0x71, 0xFF, 0x00, 0x3F, 0xE2, 0x01, 0xE0, 0xC1, 0xC3, 0xE1, 0x00, + 0x7F, 0xC0, 0x05, 0xF0, 0x20, 0xF8, 0xF0, 0x70, 0xFE, 0x78, 0x79, 0xF8, 0x02, 0x3F, 0x0C, 0x8F, + 0x03, 0x0F, 0x9F, 0xE0, 0xC1, 0xC7, 0x87, 0x03, 0xC3, 0xC3, 0xB0, 0xE1, 0xE1, 0xC1, 0xE3, 0xE0, + 0x71, 0xF0, 0x00, 0xFC, 0x70, 0x7C, 0x0C, 0x3E, 0x38, 0x0E, 0x1C, 0x70, 0xC3, 0xC7, 0x03, 0x81, + 0xC1, 0xC7, 0xE7, 0x00, 0x0F, 0xC7, 0x87, 0x19, 0x09, 0xEF, 0xC4, 0x33, 0xE0, 0xC1, 0xFC, 0xF8, + 0x70, 0xF0, 0x78, 0xF8, 0xF0, 0x61, 0xC7, 0x00, 0x1F, 0xF8, 0x01, 0x7C, 0xF8, 0xF0, 0x78, 0x70, + 0x3C, 0x7C, 0xCE, 0x0E, 0x21, 0x83, 0xCF, 0x08, 0x07, 0x8F, 0x08, 0xC1, 0x87, 0x8F, 0x80, 0xC7, + 0xE3, 0x00, 0x07, 0xF8, 0xE0, 0xEF, 0x00, 0x39, 0xF7, 0x80, 0x0E, 0xF8, 0xE1, 0xE3, 0xF8, 0x21, + 0x9F, 0xC0, 0xFF, 0x03, 0xF8, 0x07, 0xC0, 0x1F, 0xF8, 0xC4, 0x04, 0xFC, 0xC4, 0xC1, 0xBC, 0x87, + 0xF0, 0x0F, 0xC0, 0x7F, 0x05, 0xE0, 0x25, 0xEC, 0xC0, 0x3E, 0x84, 0x47, 0xF0, 0x8E, 0x03, 0xF8, + 0x03, 0xFB, 0xC0, 0x19, 0xF8, 0x07, 0x9C, 0x0C, 0x17, 0xF8, 0x07, 0xE0, 0x1F, 0xA1, 0xFC, 0x0F, + 0xFC, 0x01, 0xF0, 0x3F, 0x00, 0xFE, 0x03, 0xF0, 0x1F, 0x00, 0xFD, 0x00, 0xFF, 0x88, 0x0D, 0xF9, + 0x01, 0xFF, 0x00, 0x70, 0x07, 0xC0, 0x3E, 0x42, 0xF3, 0x0D, 0xC4, 0x7F, 0x80, 0xFC, 0x07, 0xF0, + 0x5E, 0xC0, 0x3F, 0x00, 0x78, 0x3F, 0x81, 0xFF, 0x01, 0xF8, 0x01, 0xC3, 0xE8, 0x0C, 0xE4, 0x64, + 0x8F, 0xE4, 0x0F, 0xF0, 0x07, 0xF0, 0xC2, 0x1F, 0x00, 0x7F, 0xC0, 0x6F, 0x80, 0x7E, 0x03, 0xF8, + 0x07, 0xF0, 0x3F, 0xC0, 0x78, 0x0F, 0x82, 0x07, 0xFE, 0x22, 0x77, 0x70, 0x02, 0x76, 0x03, 0xFE, + 0x00, 0xFE, 0x67, 0x00, 0x7C, 0xC7, 0xF1, 0x8E, 0xC6, 0x3B, 0xE0, 0x3F, 0x84, 0xF3, 0x19, 0xD8, + 0x03, 0x99, 0xFC, 0x09, 0xB8, 0x0F, 0xF8, 0x00, 0x9D, 0x24, 0x61, 0xF9, 0x0D, 0x00, 0xFD, 0x03, + 0xF0, 0x1F, 0x90, 0x3F, 0x01, 0xF8, 0x1F, 0xD0, 0x0F, 0xF8, 0x37, 0x01, 0xF8, 0x07, 0xF0, 0x0F, + 0xC0, 0x3F, 0x00, 0xFE, 0x03, 0xF8, 0x0F, 0xC0, 0x3F, 0x00, 0xFA, 0x03, 0xF0, 0x0F, 0x80, 0xFF, + 0x01, 0xB8, 0x07, 0xF0, 0x01, 0xFC, 0x01, 0xBC, 0x80, 0x13, 0x1E, 0x00, 0x7F, 0xE1, 0x40, 0x7F, + 0xA0, 0x7F, 0xB0, 0x00, 0x3F, 0xC0, 0x1F, 0xC0, 0x38, 0x0F, 0xF0, 0x1F, 0x80, 0xFF, 0x01, 0xFC, + 0x03, 0xF1, 0x7E, 0x01, 0xFE, 0x01, 0xF0, 0xFF, 0x00, 0x7F, 0xC0, 0x1D, 0x07, 0xF0, 0x0F, 0xC0, + 0x7E, 0x06, 0xE0, 0x07, 0xE0, 0x0F, 0xF8, 0x06, 0xC1, 0xFE, 0x01, 0xFC, 0x03, 0xE0, 0x0F, 0x00, + 0xFC, 0x08, 0x1C, 0x0E, 0x1B, 0x0D, 0x13, 0xFF, 0x1E, 0x06, 0x26, 0x0A, 0x20, 0x0B, 0x22, 0x45, + 0x46, 0x47, 0x08, 0x1C, 0x0E, 0x1B, 0x0D, 0x13, 0xFF, 0x3A, 0x3B, 0x10, 0x14, 0x42, 0x43, 0x44, + 0x06, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x30, 0x15, 0x1B, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, + 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x12, 0x07, 0x07, 0x07, 0x04, 0x08, 0x05, + 0x02, 0x0B, 0x06, 0x06, 0x02, 0x10, 0x02, 0x04, 0x02, 0x02, 0x12, 0x07, 0x07, 0x07, 0x05, 0x09, + 0x05, 0x01, 0x01, 0x0A, 0x07, 0x08, 0x02, 0x02, 0x0B, 0x03, 0x01, 0x01, 0x04, 0x01, 0x02, 0x0D, + 0x09, 0x07, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x06, + 0x08, 0x09, 0x0B, 0x0D, 0x0F, 0x00, 0x00, 0xE0, 0xE6, 0xEC, 0xF3, 0xF9, 0x00, 0x06, 0x0C, 0x06, + 0xA0, 0x00, 0x24, 0x35, 0x10, 0x09, 0x38, 0xA9, 0x00, 0xE5, 0x35, 0x85, 0x35, 0xA0, 0x80, 0x84, + 0x32, 0xA9, 0x00, 0xA2, 0x08, 0x06, 0x35, 0x2A, 0xC5, 0x34, 0x90, 0x04, 0xE5, 0x34, 0xE6, 0x35, + 0xCA, 0xD0, 0xF2, 0x85, 0x33, 0x24, 0x32, 0x10, 0x07, 0x38, 0xA9, 0x00, 0xE5, 0x35, 0x85, 0x35, + 0x60, 0xA2, 0x2F, 0xB5, 0x13, 0x9D, 0x6F, 0xA4, 0xCA, 0xD0, 0xF8, 0x60, 0xA2, 0x2F, 0xBD, 0x6F, + 0xA4, 0x95, 0x13, 0xCA, 0xD0, 0xF8, 0x60, 0xAD, 0xC0, 0xB8, 0xC9, 0xFF, 0xD0, 0x01, 0x60, 0xA9, + 0x00, 0xAA, 0x85, 0x2C, 0xA4, 0x2C, 0xB9, 0xC0, 0xB8, 0x85, 0x38, 0xC9, 0xFF, 0xD0, 0x03, 0x4C, + 0x4E, 0xBA, 0xC9, 0x01, 0xD0, 0x03, 0x4C, 0xEE, 0xBC, 0xC9, 0x02, 0xD0, 0x03, 0x4C, 0xF4, 0xBC, + 0xB9, 0xFC, 0xB8, 0x85, 0x2B, 0xB9, 0x38, 0xB9, 0x85, 0x2A, 0xA4, 0x2B, 0xC8, 0xB9, 0x84, 0xB9, + 0x85, 0x2B, 0xA4, 0x38, 0xB9, 0x00, 0xB0, 0x9D, 0x00, 0xA9, 0xB9, 0x50, 0xB0, 0x9D, 0x00, 0xAA, + 0xB9, 0xA0, 0xB0, 0x9D, 0x00, 0xAB, 0xB9, 0xF0, 0xB0, 0x9D, 0x00, 0xAC, 0xB9, 0x40, 0xB1, 0x9D, + 0x00, 0xAD, 0xB9, 0x90, 0xB1, 0x9D, 0x00, 0xAE, 0xB9, 0x70, 0xB3, 0x9D, 0x00, 0xAF, 0x18, 0xA9, + 0x40, 0x65, 0x2B, 0x9D, 0x00, 0xA8, 0xE8, 0xC6, 0x2A, 0xD0, 0xC9, 0xE6, 0x2C, 0xD0, 0x95, 0xA9, + 0x00, 0x85, 0x2C, 0x85, 0x31, 0xAA, 0xBC, 0xC0, 0xB8, 0xE8, 0xBD, 0xC0, 0xB8, 0xC9, 0xFF, 0xD0, + 0x03, 0x4C, 0x62, 0xBB, 0xAA, 0xBD, 0x20, 0xB3, 0x85, 0x38, 0xB9, 0x20, 0xB3, 0xC5, 0x38, 0xF0, + 0x1C, 0x90, 0x0D, 0xB9, 0x80, 0xB2, 0x85, 0x2B, 0xB9, 0xD0, 0xB2, 0x85, 0x2A, 0x4C, 0x96, 0xBA, + 0xBD, 0xD0, 0xB2, 0x85, 0x2B, 0xBD, 0x80, 0xB2, 0x85, 0x2A, 0x4C, 0x96, 0xBA, 0xB9, 0x80, 0xB2, + 0x85, 0x2B, 0xBD, 0x80, 0xB2, 0x85, 0x2A, 0x18, 0xA5, 0x31, 0xA4, 0x2C, 0x79, 0x38, 0xB9, 0x85, + 0x31, 0x65, 0x2A, 0x85, 0x2D, 0xA9, 0x00, 0x85, 0x2E, 0xA9, 0xA8, 0x85, 0x2F, 0x38, 0xA5, 0x31, + 0xE5, 0x2B, 0x85, 0x29, 0x18, 0xA5, 0x2B, 0x65, 0x2A, 0x85, 0x26, 0xAA, 0xCA, 0xCA, 0x10, 0x03, + 0x4C, 0x5B, 0xBB, 0xA5, 0x26, 0x85, 0x28, 0xA5, 0x2F, 0xC9, 0xA8, 0xD0, 0x3D, 0xA4, 0x2C, 0xB9, + 0x38, 0xB9, 0x4A, 0x85, 0x24, 0xC8, 0xB9, 0x38, 0xB9, 0x4A, 0x85, 0x25, 0x18, 0xA5, 0x24, 0x65, + 0x25, 0x85, 0x28, 0x18, 0xA5, 0x31, 0x65, 0x25, 0x85, 0x25, 0x38, 0xA5, 0x31, 0xE5, 0x24, 0x85, + 0x24, 0xA4, 0x25, 0xB1, 0x2E, 0x38, 0xA4, 0x24, 0xF1, 0x2E, 0x85, 0x35, 0xA5, 0x28, 0x85, 0x34, + 0x20, 0x8F, 0xB9, 0xA6, 0x28, 0xA4, 0x24, 0x4C, 0x1F, 0xBB, 0xA4, 0x2D, 0x38, 0xB1, 0x2E, 0xA4, + 0x29, 0xF1, 0x2E, 0x85, 0x35, 0xA5, 0x28, 0x85, 0x34, 0x20, 0x8F, 0xB9, 0xA6, 0x28, 0xA4, 0x29, + 0xA9, 0x00, 0x85, 0x38, 0x18, 0xB1, 0x2E, 0x65, 0x35, 0x85, 0x30, 0xC8, 0xCA, 0xF0, 0x22, 0x18, + 0xA5, 0x38, 0x65, 0x33, 0x85, 0x38, 0xC5, 0x28, 0x90, 0x10, 0xA5, 0x38, 0xE5, 0x28, 0x85, 0x38, + 0x24, 0x32, 0x30, 0x04, 0xE6, 0x30, 0xD0, 0x02, 0xC6, 0x30, 0xA5, 0x30, 0x91, 0x2E, 0x18, 0x90, + 0xD4, 0xE6, 0x2F, 0xA5, 0x2F, 0xC9, 0xAF, 0xF0, 0x03, 0x4C, 0xC2, 0xBA, 0xE6, 0x2C, 0xA6, 0x2C, + 0x4C, 0x55, 0xBA, 0xA5, 0x31, 0x18, 0xA4, 0x2C, 0x79, 0x38, 0xB9, 0x85, 0x30, 0xA2, 0x00, 0xBD, + 0x00, 0xA9, 0x4A, 0x85, 0x38, 0x38, 0xBD, 0x00, 0xA8, 0xE5, 0x38, 0x9D, 0x00, 0xA8, 0xCA, 0xD0, + 0xEE, 0xA9, 0x00, 0x85, 0x2B, 0x85, 0x2A, 0x85, 0x29, 0x85, 0x31, 0xA9, 0x48, 0x85, 0x2D, 0xA9, + 0x03, 0x85, 0x38, 0xA9, 0x00, 0x85, 0x2E, 0xA9, 0xAC, 0x85, 0x2F, 0xA0, 0x00, 0xB1, 0x2E, 0xAA, + 0xBD, 0x74, 0xB9, 0x91, 0x2E, 0x88, 0xD0, 0xF5, 0xE6, 0x2F, 0xC6, 0x38, 0xD0, 0xED, 0xA0, 0x00, + 0xB9, 0x00, 0xA8, 0x85, 0x2C, 0xAA, 0x4A, 0x4A, 0x85, 0x38, 0x38, 0x8A, 0xE5, 0x38, 0x85, 0x26, + 0x4C, 0xCE, 0xBB, 0x20, 0x63, 0xBC, 0xC8, 0xC8, 0xC6, 0x30, 0xC6, 0x30, 0x4C, 0x14, 0xBC, 0xB9, + 0x00, 0xAF, 0x85, 0x27, 0x29, 0xF8, 0xD0, 0xEB, 0xA6, 0x2B, 0x18, 0xBD, 0x00, 0xA5, 0x19, 0x00, + 0xAC, 0xAA, 0xBD, 0x00, 0xA7, 0x85, 0x38, 0xA6, 0x2A, 0xBD, 0x00, 0xA5, 0x19, 0x00, 0xAD, 0xAA, + 0xBD, 0x00, 0xA7, 0x65, 0x38, 0x85, 0x38, 0xA6, 0x29, 0xBD, 0x00, 0xA6, 0x19, 0x00, 0xAE, 0xAA, + 0xBD, 0x00, 0xA7, 0x65, 0x38, 0x69, 0x88, 0x4A, 0x4A, 0x4A, 0x4A, 0x8D, 0x18, 0xD4, 0xC6, 0x2D, + 0xD0, 0x0A, 0xC8, 0xC6, 0x30, 0xD0, 0x01, 0x60, 0xA9, 0x48, 0x85, 0x2D, 0xC6, 0x2C, 0xD0, 0x1B, + 0xB9, 0x00, 0xA8, 0x85, 0x2C, 0xAA, 0x4A, 0x4A, 0x85, 0x38, 0x38, 0x8A, 0xE5, 0x38, 0x85, 0x26, + 0xA9, 0x00, 0x85, 0x2B, 0x85, 0x2A, 0x85, 0x29, 0x4C, 0xCE, 0xBB, 0xC6, 0x26, 0xD0, 0x0A, 0xA5, + 0x27, 0xF0, 0x06, 0x20, 0x63, 0xBC, 0x4C, 0x1F, 0xBC, 0x18, 0xA5, 0x2B, 0x79, 0x00, 0xA9, 0x85, + 0x2B, 0x18, 0xA5, 0x2A, 0x79, 0x00, 0xAA, 0x85, 0x2A, 0x18, 0xA5, 0x29, 0x79, 0x00, 0xAB, 0x85, + 0x29, 0x4C, 0xCE, 0xBB, 0x84, 0x31, 0xA5, 0x27, 0xA8, 0x29, 0x07, 0xAA, 0xCA, 0x86, 0x38, 0xBD, + 0x2A, 0xBD, 0x85, 0x35, 0x18, 0xA9, 0xB3, 0x65, 0x38, 0x85, 0x2F, 0xA9, 0xC0, 0x85, 0x2E, 0x98, + 0x29, 0xF8, 0xD0, 0x0C, 0xA4, 0x31, 0xB9, 0x00, 0xA8, 0x4A, 0x4A, 0x4A, 0x4A, 0x4C, 0xBB, 0xBC, + 0x49, 0xFF, 0xA8, 0xA9, 0x08, 0x85, 0x38, 0xB1, 0x2E, 0x0A, 0x90, 0x07, 0xA6, 0x35, 0x8E, 0x18, + 0xD4, 0xD0, 0x06, 0xA2, 0x05, 0x8E, 0x18, 0xD4, 0xEA, 0xA2, 0x07, 0xCA, 0xD0, 0xFD, 0xC6, 0x38, + 0xD0, 0xE7, 0xC8, 0xD0, 0xDE, 0xA9, 0x01, 0x85, 0x2C, 0xA4, 0x31, 0x60, 0x49, 0xFF, 0x85, 0x2B, + 0xA4, 0x42, 0xA9, 0x08, 0x85, 0x38, 0xB1, 0x2E, 0x0A, 0x90, 0x07, 0xA2, 0x1A, 0x8E, 0x18, 0xD4, + 0xD0, 0x06, 0xA2, 0x06, 0x8E, 0x18, 0xD4, 0xEA, 0xA2, 0x06, 0xCA, 0xD0, 0xFD, 0xC6, 0x38, 0xD0, + 0xE7, 0xC8, 0xE6, 0x2B, 0xD0, 0xDC, 0xA9, 0x01, 0x85, 0x2C, 0x84, 0x42, 0xA4, 0x31, 0x60, 0xA9, + 0x01, 0x85, 0x30, 0xD0, 0x04, 0xA9, 0xFF, 0x85, 0x30, 0x86, 0x31, 0x8A, 0x38, 0xE9, 0x1E, 0xB0, + 0x02, 0xA9, 0x00, 0xAA, 0xBD, 0x00, 0xA8, 0xC9, 0x7F, 0xD0, 0x04, 0xE8, 0x4C, 0x03, 0xBD, 0x18, + 0x65, 0x30, 0x85, 0x2B, 0x9D, 0x00, 0xA8, 0xE8, 0xE4, 0x31, 0xF0, 0x0C, 0xBD, 0x00, 0xA8, 0xC9, + 0xFF, 0xF0, 0xF4, 0xA5, 0x2B, 0x4C, 0x0E, 0xBD, 0x4C, 0xFF, 0xB9, 0x18, 0x1A, 0x17, 0x17, 0x17, + 0xA2, 0xFF, 0x86, 0x36, 0xE8, 0x86, 0x37, 0x86, 0x42, 0xA6, 0x42, 0xBC, 0xE0, 0x9B, 0xC0, 0xFF, + 0xD0, 0x01, 0x60, 0x18, 0xA5, 0x37, 0x7D, 0xE0, 0x9C, 0x85, 0x37, 0xC9, 0xE8, 0x90, 0x03, 0x4C, + 0x7A, 0xBD, 0xB9, 0xDA, 0x9F, 0x29, 0x01, 0xF0, 0x17, 0xE8, 0x86, 0x39, 0xA9, 0x00, 0x85, 0x37, + 0x85, 0x3A, 0xA9, 0xFE, 0x85, 0x3C, 0x20, 0x36, 0xA0, 0xE6, 0x42, 0xE6, 0x42, 0x4C, 0x38, 0xBD, + 0xC0, 0x00, 0xD0, 0x02, 0x86, 0x36, 0xE6, 0x42, 0x4C, 0x38, 0xBD, 0xA6, 0x36, 0xA9, 0x1F, 0x9D, + 0xE0, 0x9B, 0xA9, 0x04, 0x9D, 0xE0, 0x9C, 0xA9, 0x00, 0x9D, 0xE0, 0x9D, 0xE8, 0x86, 0x39, 0xA9, + 0xFE, 0x85, 0x3C, 0xA9, 0x00, 0x85, 0x37, 0x85, 0x3A, 0x20, 0x36, 0xA0, 0xE8, 0x86, 0x42, 0x4C, + 0x38, 0xBD, 0xEA, 0x10, 0xA9, 0x00, 0xAA, 0xA8, 0xBD, 0xE0, 0x9B, 0xC9, 0xFF, 0xD0, 0x09, 0xA9, + 0xFF, 0x99, 0xC0, 0xB8, 0x20, 0xD6, 0xB9, 0x60, 0xC9, 0xFE, 0xD0, 0x14, 0xE8, 0x8E, 0xA2, 0xBD, + 0xA9, 0xFF, 0x99, 0xC0, 0xB8, 0x20, 0xD6, 0xB9, 0xAE, 0xA2, 0xBD, 0xA0, 0x00, 0x4C, 0xA7, 0xBD, + 0xC9, 0x00, 0xD0, 0x04, 0xE8, 0x4C, 0xA7, 0xBD, 0x99, 0xC0, 0xB8, 0xBD, 0xE0, 0x9C, 0x99, 0x38, + 0xB9, 0xBD, 0xE0, 0x9D, 0x99, 0xFC, 0xB8, 0xE8, 0xC8, 0x4C, 0xA7, 0xBD, 0xA2, 0x00, 0xBC, 0xE0, + 0x9B, 0xC0, 0xFF, 0xD0, 0x03, 0x4C, 0x39, 0xBE, 0xB9, 0xDA, 0x9F, 0x29, 0x01, 0xD0, 0x04, 0xE8, + 0x4C, 0xED, 0xBD, 0x86, 0x42, 0xCA, 0xF0, 0xED, 0xBC, 0xE0, 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x80, + 0xF0, 0xF3, 0xBC, 0xE0, 0x9B, 0xB9, 0xDA, 0x9F, 0x29, 0x20, 0xF0, 0x07, 0xB9, 0x8C, 0x9F, 0x29, + 0x04, 0xF0, 0x0E, 0xBD, 0xE0, 0x9C, 0x85, 0x38, 0x4A, 0x18, 0x65, 0x38, 0x69, 0x01, 0x9D, 0xE0, + 0x9C, 0xE8, 0xE4, 0x42, 0xD0, 0xDC, 0xE8, 0x4C, 0xED, 0xBD, 0xA2, 0x00, 0x86, 0x42, 0xA6, 0x42, + 0xBC, 0xE0, 0x9B, 0xC0, 0xFF, 0xD0, 0x01, 0x60, 0xB9, 0x8C, 0x9F, 0x29, 0x80, 0xD0, 0x03, 0x4C, + 0xB5, 0xBE, 0xE8, 0xBC, 0xE0, 0x9B, 0xB9, 0x8C, 0x9F, 0x85, 0x38, 0x29, 0x40, 0xF0, 0x33, 0xA5, + 0x38, 0x29, 0x04, 0xF0, 0x13, 0xCA, 0xBD, 0xE0, 0x9C, 0x85, 0x38, 0x4A, 0x4A, 0x18, 0x65, 0x38, + 0x69, 0x01, 0x9D, 0xE0, 0x9C, 0x4C, 0x21, 0xBF, 0xA5, 0x38, 0x29, 0x01, 0xF0, 0xF7, 0xCA, 0xBD, + 0xE0, 0x9C, 0xA8, 0x4A, 0x4A, 0x4A, 0x85, 0x38, 0x38, 0x98, 0xE5, 0x38, 0x9D, 0xE0, 0x9C, 0x4C, + 0x21, 0xBF, 0xC0, 0x12, 0xF0, 0x07, 0xC0, 0x13, 0xF0, 0x03, 0x4C, 0x21, 0xBF, 0xE8, 0xBC, 0xE0, + 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x40, 0xF0, 0xF2, 0xA6, 0x42, 0xBD, 0xE0, 0x9C, 0x38, 0xE9, 0x01, + 0x9D, 0xE0, 0x9C, 0x4C, 0x21, 0xBF, 0xB9, 0xDA, 0x9F, 0x29, 0x08, 0xF0, 0x1C, 0xE8, 0xBC, 0xE0, + 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x02, 0xD0, 0x03, 0x4C, 0x21, 0xBF, 0xA9, 0x06, 0x9D, 0xE0, 0x9C, + 0xCA, 0xA9, 0x05, 0x9D, 0xE0, 0x9C, 0x4C, 0x21, 0xBF, 0xB9, 0x8C, 0x9F, 0x29, 0x02, 0xF0, 0x26, + 0xE8, 0xBC, 0xE0, 0x9B, 0xF0, 0xFA, 0xB9, 0x8C, 0x9F, 0x29, 0x02, 0xF0, 0xDB, 0xBD, 0xE0, 0x9C, + 0x4A, 0x18, 0x69, 0x01, 0x9D, 0xE0, 0x9C, 0xA6, 0x42, 0xBD, 0xE0, 0x9C, 0x4A, 0x18, 0x69, 0x01, + 0x9D, 0xE0, 0x9C, 0x4C, 0x21, 0xBF, 0xB9, 0xDA, 0x9F, 0x29, 0x10, 0xF0, 0xF6, 0xCA, 0xBC, 0xE0, + 0x9B, 0xB9, 0x8C, 0x9F, 0x29, 0x02, 0xF0, 0xEB, 0xE8, 0xBD, 0xE0, 0x9C, 0x38, 0xE9, 0x02, 0x9D, + 0xE0, 0x9C, 0xE6, 0x42, 0x4C, 0x3D, 0xBE, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, + 0xFF, 0xFB, 0xED, 0x00, 0x00, 0x00, +}; +int prg_len = 17414; + +int prg_load(const char *filename) +{ + return 0; +} diff --git a/c64/prg_file.h b/c64/prg_file.h new file mode 100644 index 0000000..0cdf1de --- /dev/null +++ b/c64/prg_file.h @@ -0,0 +1,14 @@ +// prg_file.h +// +// 20060803 Markku Alén + +#ifndef __PRG_FILE_H__ +#define __PRG_FILE_H__ 1 + +extern int prg_addr; +extern unsigned char prg_data[65536]; +extern int prg_len; + +int prg_load(const char *filename); + +#endif diff --git a/c64/sid.c b/c64/sid.c new file mode 100644 index 0000000..845f799 --- /dev/null +++ b/c64/sid.c @@ -0,0 +1,91 @@ +// sid.c +// +// 20060803 Markku Alén + +#include "sid.h" +#include "c64.h" + +static int record_init; +static unsigned int record_freq; +static unsigned char *record_buffer; +static unsigned int record_max_len; +static unsigned int record_index; + +void start_record(unsigned int frequency, unsigned char *wave_buf, unsigned int wave_max_len) +{ + record_init = 1; + record_freq = frequency; + record_buffer = wave_buf; + record_max_len = wave_max_len; + record_index = 0; +} + +unsigned int stop_record(void) +{ + unsigned int len; + len = record_index; + record_freq = 0; + record_buffer = 0; + record_max_len = 0; + record_index = 0; + return len; +} + +static void record(unsigned int counter, unsigned int sample) +{ + static unsigned int last_counter; + static unsigned int last_sample; + unsigned int elapsed; + if(record_init) + { + record_init = 0; + last_counter = counter; + } + elapsed = ((record_freq * (counter - last_counter)) + (F_CPU / 2)) / F_CPU; + while(elapsed-- > 0) + { + if(record_index < record_max_len) + record_buffer[record_index] = sample; + record_index += 1; + } + last_counter = counter; +} + +static int volume; + +static unsigned char regs[32]; + +void sid_init(void) +{ + int i; + for(i = sizeof(regs);i-- > 0;) + regs[i] = 0x00; + (void)stop_record(); + volume = 0; +} + +int sid_read(int address) +{ + switch(address & 0x001f) + { + case 0x0018: + return volume; + default: + return regs[address % sizeof(regs)]; + } +} + +void sid_write(int address, int data) +{ + switch(address & 0x001f) + { + case 0x0018: + volume = data & 0x0f; + if(record_buffer != 0) + record(total_cycles, (volume << 4) | volume); + break; + default: + regs[address % sizeof(regs)] = data; + } +} + diff --git a/c64/sid.h b/c64/sid.h new file mode 100644 index 0000000..9b9eeb2 --- /dev/null +++ b/c64/sid.h @@ -0,0 +1,16 @@ +// sid.h +// +// 20060803 Markku Alén + +#ifndef __SID_H__ +#define __SID_H__ 1 + +void start_record(unsigned int frequency, unsigned char *wave_buf, unsigned int wave_max_len); +unsigned int stop_record(void); + +void sid_init(void); + +int sid_read(int address); +void sid_write(int address, int data); + +#endif diff --git a/c64/tape.c b/c64/tape.c new file mode 100644 index 0000000..725bf2f --- /dev/null +++ b/c64/tape.c @@ -0,0 +1,172 @@ +// tape.c +// +// 20060803 Markku Alén + +#include "tape.h" +#include "cpu.h" +#include "mem.h" + +#include "prg_file.h" + +#define STATUS (ram[0x90]) +#define VERCKK (ram[0x93]) + +#define EAL (ram[0xae] | (ram[0xaf] << 8)) + +#define TBUFFR (ram[0xb2] | (ram[0xb3] << 8)) + +#define FNLEN (ram[0xb7]) +#define FNADR (ram[0xbb] | (ram[0xbc] << 8)) + +#define STAL (ram[0xc1] | (ram[0xc2] << 8)) + +#define IRQTMP (ram[0x2a0]) + +#define OFFSET_TYPE 0 +#define OFFSET_START_ADDR 1 +#define OFFSET_END_ADDR 3 +#define OFFSET_NAME 5 + +#define TYPE_PRG 1 /* Binary Program */ +#define TYPE_BAS 3 /* Relocatable Program */ +#define TYPE_DATA 4 /* Data Record */ +#define TYPE_EOF 5 /* End of Tape marker */ + +#define FIND_RET 0xF732 +#define WRITE_RET 0xF7C1 +#define TRANSFER_RET 0xFC93 + +#define WRITE_LEADER 0x0a +#define WRITE_BLOCK 0x08 +#define READ_BLOCK 0x0e + +#define EOF 0x40 + +static void copy_to_ram(int addr, int len, const void *buf) +{ + while(len-- > 0) + ram[addr + len] = ((char *)buf)[len]; +} + +static void setup_tape_hdr(int type, const char *filename, int start_addr, int stop_addr) +{ + int i; + char c, *p; + p = &ram[TBUFFR]; + for(i = 0;i < 16;i++) + { + c = *filename; + if(c != '\0') + filename++; + p[OFFSET_NAME + i] = c; + } + p[OFFSET_TYPE] = type; + p[OFFSET_START_ADDR + 0] = start_addr % 256; + p[OFFSET_START_ADDR + 1] = start_addr / 256; + p[OFFSET_END_ADDR + 0] = stop_addr % 256; + p[OFFSET_END_ADDR + 1] = stop_addr / 256; +} + +static char filename[15 + 1]; + +static void get_filename(void) +{ + int i; + char c, *p; + p = &ram[FNADR]; + for(i = 0;i < (sizeof(filename) - 1);i++) + { + c = *(p++); + if(c < '0' || c > '9') + { + if(c < 'A' || c > 'Z') + { + if(c < 'a' || c > 'z') + { + if(c != '.' && c != '_') + c = '.'; + } + } + } + filename[i] = c; + } + if(i > FNLEN) + i = FNLEN; + filename[i] = '\0'; +} + +static int find_header(void) +{ + int err; + err = 0; + get_filename(); + if(prg_load(filename) != 0) + err = -1; + if(err == 0) + setup_tape_hdr(TYPE_BAS, filename, prg_addr, prg_addr + prg_len); + STATUS = 0x00; + VERCKK = 0x00; + IRQTMP = 0x00; + set_c_flag(err != 0); + set_z_flag(0); + set_pc(FIND_RET); + return 0; +} + +static int write_header(void) +{ + int i; + i=0; +} + +static int tape_transfer(void) +{ + int i; + int err; + int start, end, len; + int st; + err = 0; + start = STAL; + end = EAL; + len = end - start; + st = 0x00; + switch(get_x()) + { + case WRITE_LEADER: + break; + case WRITE_BLOCK: +// if (fwrite(ram + start, len, 1, tape->FileDs) == 1) { +// st |= 0x40; /* EOF */ +// } +// else { +// st |= 0xB4; /* All possible errors... */ +// +// fprintf(stderr, "Error: Tape write failed.\n"); +// } +// break; + i=0; + case READ_BLOCK: + copy_to_ram(start, len, prg_data); + st |= EOF; + break; + default: + err = -1; + } + IRQTMP = 0x00; + STATUS |= st; + set_c_flag(err != 0); + set_pc(TRANSFER_RET); + return 0; +} + +static trap_t traps[] = +{ + TRAP_INIT(0xF72F, 0x20, 0x41, 0xF8, &find_header), + TRAP_INIT(0xF7BE, 0x20, 0x6B, 0xF8, &write_header), + TRAP_INIT(0xF8A1, 0x20, 0xBD, 0xFC, &tape_transfer), +}; + +void init_tape(void) +{ + install_traps(sizeof(traps) / sizeof(traps[0]), traps, &poke, &peek); +} diff --git a/c64/tape.h b/c64/tape.h new file mode 100644 index 0000000..5776500 --- /dev/null +++ b/c64/tape.h @@ -0,0 +1,10 @@ +// tape.h +// +// 20060803 Markku Alén + +#ifndef __TAPE_H__ +#define __TAPE_H__ 1 + +void init_tape(void); + +#endif diff --git a/sam.c b/sam.c new file mode 100644 index 0000000..c921c48 --- /dev/null +++ b/sam.c @@ -0,0 +1,53 @@ +// sam.c +// +// 20060811 Markku Alén + +#include "sam.h" +#include "c64.h" +#include "cpu.h" +#include "sid.h" + +static void feed(const char *text) +{ + char c; + while((c = *(text++)) != '\0') + { + kbd_ascii_push(c, 1); + c64_run(20000); + kbd_ascii_push(c, 0); + c64_run(20000); + } +} + +static void run_to(int addr_start, int addr_stop) +{ + int pc; + for(;;) + { + pc = get_pc(); + if(pc >= addr_start && pc <= addr_stop) + break; + c64_run(20000); + } +} + +void sam_init(void) +{ + c64_init(); + run_to(0xe5cd, 0xe5d5); + feed("LOAD\"SAM.PRG\",1,1\r RUN\rH"); + run_to(0xe5cd, 0xe5d5); + feed("]RE\r"); + run_to(0xe5cd, 0xe5d5); +} + +void sam_say(const char *text, unsigned int frequency, unsigned char *wave_buf, unsigned int *wave_len_ref) +{ + feed("SAY\""); + feed(text); + feed("\"\r"); + start_record(frequency, wave_buf, *wave_len_ref); + run_to(0xe5cd, 0xe5d5); + *wave_len_ref = stop_record(); +} + diff --git a/sam.h b/sam.h new file mode 100644 index 0000000..4379978 --- /dev/null +++ b/sam.h @@ -0,0 +1,12 @@ +// sam.h +// +// 20060811 Markku Alén + +#ifndef __SAM_H__ +#define __SAM_H__ 1 + +void sam_init(void); +void sam_say(const char *text, unsigned int frequency, unsigned char *wave_buf, unsigned int *wave_len_ref); + +#endif + diff --git a/sam_player.c b/sam_player.c new file mode 100644 index 0000000..43baf40 --- /dev/null +++ b/sam_player.c @@ -0,0 +1,46 @@ +// sam_player.c +// +// 20060811 Markku Alén +// +// rel-0-2 + +#include "sam.h" +#include "wave.h" + +static unsigned char wave_buffer[200000]; +static wave_t wave = { 1, 44100, 8, 0, 1, wave_buffer }; + +int main(int argc, char **argv) +{ + int argi; + char *arg, c, buf[200], *p; + unsigned int wave_length; + p = buf; + for(argi = 1;argi < argc;argi++) + { + arg = argv[argi]; + do + { + c = *(arg++); + if(c >= 'a' && c <= 'z') + c = (c - 'a') + 'A'; + if(c != '\"') + { + if(p < &buf[sizeof(buf) - 1]) + *(p++) = (c != '\0') ? c : ' '; + } + }while(c != '\0'); + } + *p = '\0'; + sam_init(); + wave_length = sizeof(wave_buffer); + sam_say(buf, wave.samples_per_sec, wave_buffer, &wave_length); + if(wave_length > 0) + { + if(wave_length > sizeof(wave_buffer)) + wave_length = sizeof(wave_buffer); + wave.frame_size = wave_length; + (void)wave_out(&wave); + } + return 0; +} diff --git a/wave.h b/wave.h new file mode 100644 index 0000000..a28ff4e --- /dev/null +++ b/wave.h @@ -0,0 +1,31 @@ +// wave.h + +#ifndef __WAVE_H__ +#define __WAVE_H__ 1 + +#define WAVE_ERR_NONE 0 +#define WAVE_ERR_UNKNOWN_ERROR -1 +#define WAVE_ERR_RESOURCE_UNAVAILABLE -2 +#define WAVE_ERR_BAD_DEVICE_ID -3 +#define WAVE_ERR_DEVICE_DRIVER_UNAVAILABLE -4 +#define WAVE_ERR_OUT_OF_MEMORY -5 +#define WAVE_ERR_INVALID_WAVE -6 +#define WAVE_ERR_CANNOT_PLAY -7 +#define WAVE_ERR_INVALID_HANDLE -8 +#define WAVE_ERR_STILL_PLAYING -9 + +typedef struct __wave +{ + int channels; // audio channels, mono, stereo, etc... + int samples_per_sec; // sample output frequency + int bits_per_sample; // 8 or 16 + unsigned int frame_size; // ((bps + 7) / 8) * channels + unsigned int frame_count; // wave duration = (1 / frequency) * frame_count + const void *frame_data; // pointer to the buffer containing sample frames +}wave_t; + +int wave_out(wave_t *wave); + +const char *wave_err_to_str(int err); + +#endif -- cgit v1.2.3