commit 46078742c7f8dea8b5a0998c73b38ff970fb1b64 Author: graham sanderson Date: Wed Jan 20 10:49:34 2021 -0600 Initial Release diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6aa60eb --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +.idea +.vscode +_deps +cmake-* +build +.DS_Store +*.pdf diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..82ea832 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,43 @@ +cmake_minimum_required(VERSION 3.12) + +# Pull in PICO SDK (must be before project) +include(pico_sdk_import.cmake) + +project(pico_examples C CXX ASM) +set(CMAKE_C_STANDARD 11) +set(CMAKE_CXX_STANDARD 17) + +set(PICO_EXAMPLES_PATH ${PROJECT_SOURCE_DIR}) + +# Initialize the SDK +pico_sdk_init() + +include(example_auto_set_url.cmake) +# Add blink example +add_subdirectory(blink) + +# Add hello world example +add_subdirectory(hello_world) + +# Hardware-specific examples in subdirectories: +add_subdirectory(adc) +add_subdirectory(clocks) +add_subdirectory(cmake) +add_subdirectory(divider) +add_subdirectory(dma) +add_subdirectory(flash) +add_subdirectory(gpio) +add_subdirectory(i2c) +add_subdirectory(interp) +add_subdirectory(multicore) +add_subdirectory(picoboard) +add_subdirectory(pio) +add_subdirectory(pwm) +add_subdirectory(reset) +add_subdirectory(rtc) +add_subdirectory(spi) +add_subdirectory(system) +add_subdirectory(timer) +add_subdirectory(uart) +add_subdirectory(usb) +add_subdirectory(watchdog) diff --git a/LICENSE.TXT b/LICENSE.TXT new file mode 100644 index 0000000..e8a64f1 --- /dev/null +++ b/LICENSE.TXT @@ -0,0 +1,21 @@ +Copyright 2020 (c) 2020 Raspberry Pi (Trading) Ltd. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the +following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following + disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..33ae265 --- /dev/null +++ b/README.md @@ -0,0 +1,196 @@ +# PICO SDK Examples + +## Getting started + +See [Getting Started with the Raspberry Pi Pico](https://rptl.io/pico-get-started) and the README in the [pico-sdk](https://github.com/raspberrypi/pico-sdk) for information +on getting up and running. + +### First Examples + +App | Description | Link to prebuilt UF2 +---|---|--- +[hello_serial](hello_world/serial) | The obligatory Hello World program for Pico (Output over serial version) | https://rptl.io/pico-hello-serial +[hello_usb](hello_world/usb) | The obligatory Hello World program for Pico (Output over USB version) | https://rptl.io/pico-hello-usb +[blink](blink) | Blink an LED on and off. | https://rptl.io/pico-blink + +### ADC + +App|Description +---|--- +[hello_adc](adc/hello_adc)|Display the voltage from an ADC input. +[joystick_display](adc/joystick_display)|Display a Joystick X/Y input based on two ADC inputs. +[adc_console](adc/adc_console)|An interactive shell for playing with the ADC. Includes example of free-running capture mode. + +### Clocks + +App|Description +---|--- +[hello_48MHz](clocks/hello_48MHz)| Change the system clock frequency to 48 MHz while running. +[hello_gpout](clocks/hello_gpout)| Use the general purpose clock outputs (GPOUT) to drive divisions of internal clocks onto GPIO outputs. +[hello_resus](clocks/hello_resus)| Enable the clock resuscitate feature, "accidentally" stop the system clock, and show how we recover. + +### CMake + +App|Description +---|--- +[build_variants](cmake/build_variants)| Builds two version of the same app with different configurations + +### DMA + +App|Description +---|--- +[hello_dma](dma/hello_dma)| Use the DMA to copy data in memory. +[control_blocks](dma/control_blocks)| Build a control block list, to program a longer sequence of DMA transfers to the UART. +[channel_irq](dma/channel_irq)| Use an IRQ handler to reconfigure a DMA channel, in order to continuously drive data through a PIO state machine. + + +### Flash + +App|Description +---|--- +[cache_perfctr](flash/cache_perfctr)| Read and clear the cache performance counters. Show how they are affected by different types of flash reads. +[nuke](flash/nuke)| Obliterate the contents of flash. An example of a NO_FLASH binary (UF2 loaded directly into SRAM and runs in-place there). A useful utility to drag and drop onto your Pico if the need arises. +[program](flash/program)| Erase a flash sector, program one flash page, and read back the data. +[xip_stream](flash/xip_stream)| Stream data using the XIP stream hardware, which allows data to be DMA'd in the background whilst executing code from flash. +[ssi_dma](flash/ssi_dma)| DMA directly from the flash interface (continuous SCK clocking) for maximum bulk read performance. + +### GPIO + +App|Description +---|--- +[hello_7segment](gpio/hello_7segment) | Use the GPIOs to drive a seven segment LED display. +[hello_gpio_irq](gpio/hello_gpio_irq) | Register an interrupt handler to run when a GPIO is toggled. +[dht_sensor](gpio/dht_sensor) | Use GPIO to bitbang the serial protocol for a DHT temperature/humidity sensor. + +See also: [blink](blink), blinking an LED attached to a GPIO. + +### HW divider + +App|Description +---|--- +[hello_divider](divider) | Show how to directly access the hardware integer dividers, in case AEABI injection is disabled. + + +### I2C + +App|Description +---|--- +[bus_scan](i2c/bus_scan) | Scan the I2C bus for devices and display results. +[lcd_1602_i2c](i2c/lcd_1602_i2c) | Display some text on a generic 16x2 character LCD display, via I2C. +[mpu6050_i2c](i2c/mpu6050_i2c) | Read acceleration and angular rate values from a MPU6050 accelerometer/gyro, attached to an I2C bus. + +### Interpolator + +App|Description +---|--- +[hello_interp](interp/hello_interp) | A bundle of small examples, showing how to access the core-local interpolator hardware, and use most of its features. + +### Multicore + +App|Description +---|--- +[hello_multicore](multicore/hello_multicore) | Launch a function on the second core, printf some messages on each core, and pass data back and forth through the mailbox FIFOs. +[multicore_fifo_irqs](multicore/multicore_fifo_irqs) | On each core, register and interrupt handler for the mailbox FIFOs. Show how the interrupt fires when that core receives a message. +[multicore_runner](multicore/multicore_runner) | Set up the second core to accept, and run, any function pointer pushed into its mailbox FIFO. Push in a few pieces of code and get answers back. + +### Pico Board + +App|Description +---|--- +[blinky](picoboard/blinky)| Blink "hello, world" in Morse code on Pico's LED +[button](picoboard/button)| Use Pico's BOOTSEL button as a regular button input, by temporarily suspending flash access. + +### PIO + +App|Description +---|--- +[hello_pio](pio/hello_pio)| Absolutely minimal example showing how to control an LED by pushing values into a PIO FIFO. +[apa102](pio/apa102)| Rainbow pattern on on a string of APA102 addressable RGB LEDs. +[differential_manchester](pio/differential_manchester)| Send and receive differential Manchester-encoded serial (BMC). +[hub75](pio/hub75)| Display an image on a 128x64 HUB75 RGB LED matrix. +[i2c](pio/i2c)| Scan an I2C bus. +[logic_analyser](pio/logic_analyser)| Use PIO and DMA to capture a logic trace of some GPIOs, whilst a PWM unit is driving them. +[manchester_encoding](pio/manchester_encoding)| Send and receive Manchester-encoded serial. +[pio_blink](pio/pio_blink)| Set up some PIO state machines to blink LEDs at different frequencies, according to delay counts pushed into their FIFOs. +[pwm](pio/pwm)| Pulse width modulation on PIO. Use it to gradually fade the brightness of an LED. +[spi](pio/spi)| Use PIO to erase, program and read an external SPI flash chip. A second example runs a loopback test with all four CPHA/CPOL combinations. +[squarewave](pio/squarewave)| Drive a fast square wave onto a GPIO. This example accesses low-level PIO registers directly, instead of using the SDK functions. +[st7789_lcd](pio/st7789_lcd)| Set up PIO for 62.5 Mbps serial output, and use this to display a spinning image on a ST7789 serial LCD. +[uart_rx](pio/uart_rx)| Implement the receive component of a UART serial port. Attach it to the spare Arm UART to see it receive characters. +[uart_tx](pio/uart_tx)| Implement the transmit component of a UART serial port, and print hello world. +[ws2812](pio/ws2812)| Examples of driving WS2812 addressable RGB LEDs. +[addition](pio/addition)| Add two integers together using PIO. Only around 8 billion times slower than Cortex-M0+. + +### PWM + +App|Description +---|--- +[hello_pwm](pwm/hello_pwm) | Minimal example of driving PWM output on GPIOs. +[led_fade](pwm/led_fade) | Fade an LED between low and high brightness. An interrupt handler updates the PWM slice's output level each time the counter wraps. +[measure_duty_cycle](pwm/measure_duty_cycle) | Drives a PWM output at a range of duty cycles, and uses another PWM slice in input mode to measure the duty cycle. + +### Reset + +App|Description +---|--- +[hello_reset](reset/hello_reset) | Perform a hard reset on some peripherals, then bring them back up. + +### RTC + +App|Description +---|--- +[hello_rtc](rtc/hello_rtc) | Set a date/time on the RTC, then repeatedly print the current time, 10 times per second, to show it updating. +[rtc_alarm](rtc/rtc_alarm) | Set an alarm on the RTC to trigger an interrupt at a date/time 5 seconds into the future. +[rtc_alarm_repeat](rtc/rtc_alarm_repeat) | Trigger an RTC interrupt once per minute. + +### SPI + +App|Description +---|--- +[bme280_spi](spi/bme280_spi) | Attach a BME280 temperature/humidity/pressure sensor via SPI. +[mpu9250_spi](spi/mpu9250_spi) | Attach a MPU9250 accelerometer/gyoscope via SPI. +[spi_dma](spi/spi_dma) | Use DMA to transfer data both to and from the SPI simultaneously. The SPI is configured for loopback. +[spi_flash](spi/spi_flash) | Erase, program and read a serial flash device attached to one of the SPI controllers. + +### System + +App|Description +---|--- +[hello_double_tap](system/hello_double_tap) | On dev boards with a reset button (but no BOOTSEL), a magic number in RAM can be used to enter the USB bootloader, when the reset button is pressed twice quickly. +[narrow_io_write](system/narrow_io_write) | Demonstrate the effects of 8-bit and 16-bit writes on a 32-bit IO register. + +### Timer + +App|Description +---|--- +[hello_timer](timer/hello_timer) | Set callbacks on the system timer, which repeat at regular intervals. Cancel the timer when we're done. +[periodic_sampler](timer/periodic_sampler) | Sample GPIOs in a timer callback, and push the samples into a concurrency-safe queue. Pop data from the queue in code running in the foreground. +[timer_lowlevel](timer/timer_lowlevel) | Example of direct access to the timer hardware. Not generally recommended, as the SDK may use the timer for IO timeouts. + +### UART + +App|Description +---|--- +[hello_uart](uart/hello_uart) | Print some text from one of the UART serial ports, without going through `stdio`. +[uart_advanced](uart/uart_advanced) | Use some other UART features like RX interrupts, hardware control flow, and data formats other than 8n1. + +### USB Device + +App|Description +---|--- +[dev_audio_headset](usb/device/dev_audio_headset) | Audio headset example from TinyUSB +[dev_hid_composite](usb/device/dev_hid_composite) | Composite HID (mouse + keyboard) example from TinyUSB +[dev_hid_generic_inout](usb/device/dev_hid_generic_inout) | Generic HID device example from TinyUSB +[dev_lowlevel](usb/device/dev_lowlevel) | A USB Bulk loopback implemented with direct access to the USB hardware (no TinyUSB) + +### USB Host + +App|Description +---|--- +[host_hid](usb/host/host_hid) | Use USB in host mode to poll an attached HID keyboard (TinyUSB example) + +### Watchdog + +App|Description +---|--- +[hello_watchdog](watchdog/hello_watchdog) | Set the watchdog timer, and let it expire. Detect the reboot, and halt. diff --git a/adc/CMakeLists.txt b/adc/CMakeLists.txt new file mode 100644 index 0000000..c0e75fc --- /dev/null +++ b/adc/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(adc_console) + add_subdirectory(hello_adc) + add_subdirectory(joystick_display) +endif () diff --git a/adc/adc_console/CMakeLists.txt b/adc/adc_console/CMakeLists.txt new file mode 100644 index 0000000..944a93d --- /dev/null +++ b/adc/adc_console/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(adc_console + adc_console.c + ) + +target_link_libraries(adc_console pico_stdlib hardware_adc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(adc_console) + +# add url via pico_set_program_url +example_auto_set_url(adc_console) + diff --git a/adc/adc_console/adc_console.c b/adc/adc_console/adc_console.c new file mode 100644 index 0000000..b212847 --- /dev/null +++ b/adc/adc_console/adc_console.c @@ -0,0 +1,100 @@ +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" +#include "hardware/adc.h" + +#define N_SAMPLES 1000 +uint16_t sample_buf[N_SAMPLES]; + +void printhelp() { + puts("\nCommands:"); + puts("c0, ...\t: Select ADC channel n"); + puts("s\t: Sample once"); + puts("S\t: Sample many"); + puts("w\t: Wiggle pins"); +} + +void __not_in_flash_func(adc_capture)(uint16_t *buf, size_t count) { + adc_fifo_setup(true, false, 0, false, false); + adc_run(true); + for (int i = 0; i < count; i = i + 1) + buf[i] = adc_fifo_get_blocking(); + adc_run(false); + adc_fifo_drain(); +} + +int main(void) { + stdio_init_all(); + adc_init(); + adc_set_temp_sensor_enabled(true); + + // Set all pins to input (as far as SIO is concerned) + gpio_set_dir_all_bits(0); + for (int i = 2; i < 30; ++i) { + gpio_set_function(i, GPIO_FUNC_SIO); + if (i >= 26) { + gpio_disable_pulls(i); + gpio_set_input_enabled(i, false); + } + } + + printf("\n===========================\n"); + printf("RP2040 ADC and Test Console\n"); + printf("===========================\n"); + printhelp(); + + while (1) { + char c = getchar(); + printf("%c", c); + switch (c) { + case 'c': + c = getchar(); + printf("%c\n", c); + if (c < '0' || c > '7') { + printf("Unknown input channel\n"); + printhelp(); + } else { + adc_select_input(c - '0'); + printf("Switched to channel %c\n", c); + } + break; + case 's': { + uint32_t result = adc_read(); + const float conversion_factor = 3.3f / (1 << 12); + printf("\n0x%03x -> %f V\n", result, result * conversion_factor); + break; + } + case 'S': { + printf("\nStarting capture\n"); + adc_capture(sample_buf, N_SAMPLES); + printf("Done\n"); + for (int i = 0; i < N_SAMPLES; i = i + 1) + printf("%03x\n", sample_buf[i]); + break; + } + case 'w': + printf("\nPress any key to stop wiggling\n"); + int i = 1; + gpio_set_dir_all_bits(-1); + while (getchar_timeout_us(0) == PICO_ERROR_TIMEOUT) { + // Pattern: Flash all pins for a cycle, + // Then scan along pins for one cycle each + i = i ? i << 1 : 1; + gpio_put_all(i ? i : ~0); + } + gpio_set_dir_all_bits(0); + printf("Wiggling halted.\n"); + break; + case '\n': + case '\r': + break; + case 'h': + printhelp(); + break; + default: + printf("\nUnrecognised command: %c\n", c); + printhelp(); + break; + } + } +} diff --git a/adc/hello_adc/CMakeLists.txt b/adc/hello_adc/CMakeLists.txt new file mode 100644 index 0000000..1863182 --- /dev/null +++ b/adc/hello_adc/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(hello_adc + hello_adc.c + ) + +target_link_libraries(hello_adc pico_stdlib hardware_adc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_adc) + +# add url via pico_set_program_url +example_auto_set_url(hello_adc) diff --git a/adc/hello_adc/hello_adc.c b/adc/hello_adc/hello_adc.c new file mode 100644 index 0000000..9eeb455 --- /dev/null +++ b/adc/hello_adc/hello_adc.c @@ -0,0 +1,30 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" +#include "hardware/adc.h" + +int main() { + stdio_init_all(); + printf("ADC Example, measuring GPIO26\n"); + + adc_init(); + + // Make sure GPIO is high-impedance, no pullups etc + adc_gpio_init(26); + // Select ADC input 0 (GPIO26) + adc_select_input(0); + + while (1) { + // 12-bit conversion, assume max value == ADC_VREF == 3.3 V + const float conversion_factor = 3.3f / (1 << 12); + uint16_t result = adc_read(); + printf("Raw value: 0x%03x, voltage: %f V\n", result, result * conversion_factor); + sleep_ms(500); + } +} diff --git a/adc/joystick_display/CMakeLists.txt b/adc/joystick_display/CMakeLists.txt new file mode 100644 index 0000000..96bb475 --- /dev/null +++ b/adc/joystick_display/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(joystick_display + joystick_display.c + ) + +target_link_libraries(joystick_display pico_stdlib hardware_adc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(joystick_display) + +# add url via pico_set_program_url +example_auto_set_url(joystick_display) diff --git a/adc/joystick_display/joystick_display.c b/adc/joystick_display/joystick_display.c new file mode 100644 index 0000000..6b87377 --- /dev/null +++ b/adc/joystick_display/joystick_display.c @@ -0,0 +1,40 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/adc.h" + +int main() { + stdio_init_all(); + adc_init(); + // Make sure GPIO is high-impedance, no pullups etc + adc_gpio_init(26); + adc_gpio_init(27); + + while (1) { + adc_select_input(0); + uint adc_x_raw = adc_read(); + adc_select_input(1); + uint adc_y_raw = adc_read(); + + // Display the joystick position something like this: + // X: [ o ] Y: [ o ] + const uint bar_width = 40; + const uint adc_max = (1 << 12) - 1; + uint bar_x_pos = adc_x_raw * bar_width / adc_max; + uint bar_y_pos = adc_y_raw * bar_width / adc_max; + printf("\rX: ["); + for (int i = 0; i < bar_width; ++i) + putchar( i == bar_x_pos ? 'o' : ' '); + printf("] Y: ["); + for (int i = 0; i < bar_width; ++i) + putchar( i == bar_y_pos ? 'o' : ' '); + printf("]"); + sleep_ms(50); + + } +} diff --git a/blink/CMakeLists.txt b/blink/CMakeLists.txt new file mode 100644 index 0000000..1bf1d2a --- /dev/null +++ b/blink/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(blink + blink.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(blink pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(blink) + +# add url via pico_set_program_url +example_auto_set_url(blink) diff --git a/blink/blink.c b/blink/blink.c new file mode 100644 index 0000000..c6367f2 --- /dev/null +++ b/blink/blink.c @@ -0,0 +1,19 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" + +int main() { + const uint LED_PIN = 25; + gpio_init(LED_PIN); + gpio_set_dir(LED_PIN, GPIO_OUT); + while (true) { + gpio_put(LED_PIN, 1); + sleep_ms(250); + gpio_put(LED_PIN, 0); + sleep_ms(250); + } +} diff --git a/clocks/CMakeLists.txt b/clocks/CMakeLists.txt new file mode 100644 index 0000000..927a8c0 --- /dev/null +++ b/clocks/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_48MHz) + add_subdirectory(hello_gpout) + add_subdirectory(hello_resus) +endif () diff --git a/clocks/hello_48MHz/CMakeLists.txt b/clocks/hello_48MHz/CMakeLists.txt new file mode 100644 index 0000000..27290d7 --- /dev/null +++ b/clocks/hello_48MHz/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_48MHz + hello_48MHz.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_48MHz pico_stdlib hardware_clocks) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_48MHz) + +# add url via pico_set_program_url +example_auto_set_url(hello_48MHz) diff --git a/clocks/hello_48MHz/hello_48MHz.c b/clocks/hello_48MHz/hello_48MHz.c new file mode 100644 index 0000000..19d269b --- /dev/null +++ b/clocks/hello_48MHz/hello_48MHz.c @@ -0,0 +1,68 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/pll.h" +#include "hardware/clocks.h" +#include "hardware/structs/pll.h" +#include "hardware/structs/clocks.h" + +void measure_freqs(void) { + uint f_pll_sys = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_PLL_SYS_CLKSRC_PRIMARY); + uint f_pll_usb = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_PLL_USB_CLKSRC_PRIMARY); + uint f_rosc = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_ROSC_CLKSRC); + uint f_clk_sys = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_CLK_SYS); + uint f_clk_peri = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_CLK_PERI); + uint f_clk_usb = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_CLK_USB); + uint f_clk_adc = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_CLK_ADC); + uint f_clk_rtc = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_CLK_RTC); + + printf("pll_sys = %dkHz\n", f_pll_sys); + printf("pll_usb = %dkHz\n", f_pll_usb); + printf("rosc = %dkHz\n", f_rosc); + printf("clk_sys = %dkHz\n", f_clk_sys); + printf("clk_peri = %dkHz\n", f_clk_peri); + printf("clk_usb = %dkHz\n", f_clk_usb); + printf("clk_adc = %dkHz\n", f_clk_adc); + printf("clk_rtc = %dkHz\n", f_clk_rtc); + + // Can't measure clk_ref / xosc as it is the ref +} + +int main() { + stdio_init_all(); + + printf("Hello, world!\n"); + + measure_freqs(); + + // Change clk_sys to be 48MHz. The simplest way is to take this from PLL_USB + // which has a source frequency of 48MHz + clock_configure(clk_sys, + CLOCKS_CLK_SYS_CTRL_SRC_VALUE_CLKSRC_CLK_SYS_AUX, + CLOCKS_CLK_SYS_CTRL_AUXSRC_VALUE_CLKSRC_PLL_USB, + 48 * MHZ, + 48 * MHZ); + + // Turn off PLL sys for good measure + pll_deinit(pll_sys); + + // CLK peri is clocked from clk_sys so need to change clk_peri's freq + clock_configure(clk_peri, + 0, + CLOCKS_CLK_PERI_CTRL_AUXSRC_VALUE_CLK_SYS, + 48 * MHZ, + 48 * MHZ); + + // Re init uart now that clk_peri has changed + stdio_init_all(); + + measure_freqs(); + printf("Hello, 48MHz"); + + return 0; +} diff --git a/clocks/hello_gpout/CMakeLists.txt b/clocks/hello_gpout/CMakeLists.txt new file mode 100644 index 0000000..bce0eac --- /dev/null +++ b/clocks/hello_gpout/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_gpout + hello_gpout.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_gpout pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_gpout) + +# add url via pico_set_program_url +example_auto_set_url(hello_gpout) \ No newline at end of file diff --git a/clocks/hello_gpout/hello_gpout.c b/clocks/hello_gpout/hello_gpout.c new file mode 100644 index 0000000..b41e68f --- /dev/null +++ b/clocks/hello_gpout/hello_gpout.c @@ -0,0 +1,23 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/clocks.h" + + +int main() { + stdio_init_all(); + printf("Hello gpout\n"); + + // Output clk_sys / 10 to gpio 21, etc... + clock_gpio_init(21, CLOCKS_CLK_GPOUT0_CTRL_AUXSRC_VALUE_CLK_SYS, 10); + clock_gpio_init(23, CLOCKS_CLK_GPOUT0_CTRL_AUXSRC_VALUE_CLK_USB, 10); + clock_gpio_init(24, CLOCKS_CLK_GPOUT0_CTRL_AUXSRC_VALUE_CLK_ADC, 10); + clock_gpio_init(26, CLOCKS_CLK_GPOUT0_CTRL_AUXSRC_VALUE_CLK_RTC, 10); + + return 0; +} diff --git a/clocks/hello_resus/CMakeLists.txt b/clocks/hello_resus/CMakeLists.txt new file mode 100644 index 0000000..d7fc828 --- /dev/null +++ b/clocks/hello_resus/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_resus + hello_resus.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_resus pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_resus) + +# add url via pico_set_program_url +example_auto_set_url(hello_resus) \ No newline at end of file diff --git a/clocks/hello_resus/hello_resus.c b/clocks/hello_resus/hello_resus.c new file mode 100644 index 0000000..f7cfc2d --- /dev/null +++ b/clocks/hello_resus/hello_resus.c @@ -0,0 +1,48 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/clocks.h" +#include "hardware/pll.h" + +volatile bool seen_resus; + +void resus_callback(void) { + // Reconfigure PLL sys back to the default state of 1500 / 6 / 2 = 125MHz + pll_init(pll_sys, 1, 1500 * MHZ, 6, 2); + + // CLK SYS = PLL SYS (125MHz) / 1 = 125MHz + clock_configure(clk_sys, + CLOCKS_CLK_SYS_CTRL_SRC_VALUE_CLKSRC_CLK_SYS_AUX, + CLOCKS_CLK_SYS_CTRL_AUXSRC_VALUE_CLKSRC_PLL_SYS, + 125 * MHZ, + 125 * MHZ); + + // Reconfigure uart as clocks have changed + stdio_init_all(); + printf("Resus event fired\n"); + + // Wait for uart output to finish + uart_default_tx_wait_blocking(); + + seen_resus = true; +} + +int main() { + stdio_init_all(); + printf("Hello resus\n"); + + seen_resus = false; + + clocks_enable_resus(&resus_callback); + // Break PLL sys + pll_deinit(pll_sys); + + while(!seen_resus); + + return 0; +} diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt new file mode 100644 index 0000000..1e6dcff --- /dev/null +++ b/cmake/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(build_variants) \ No newline at end of file diff --git a/cmake/build_variants/CMakeLists.txt b/cmake/build_variants/CMakeLists.txt new file mode 100644 index 0000000..f40f806 --- /dev/null +++ b/cmake/build_variants/CMakeLists.txt @@ -0,0 +1,37 @@ +# 1 Create an INTERFACE library aggregating all the common parts of the application +add_library(common_stuff INTERFACE) + +# note cmake policy is to use absolute paths for interface libraries. +target_sources(common_stuff INTERFACE + ${CMAKE_CURRENT_LIST_DIR}/main.c + ${CMAKE_CURRENT_LIST_DIR}/other.c + ) + +target_compile_definitions(common_stuff INTERFACE + A_DEFINE_THAT_IS_SHARED=123 + ) + +# can include library dependencies here +target_link_libraries(common_stuff INTERFACE + pico_stdlib + ) + +# 2 Create the first executable including all the common stuff... +# we can set compile definitions for this executable here too. Because +# we depend on an INTERFACE library (common_stuff) we +# will pick up all of its definitions/dependencies too +add_executable(build_variant1) +target_link_libraries(build_variant1 common_stuff) +target_compile_definitions(build_variant1 PRIVATE + A_DEFINE_THAT_IS_NOT_SHARED=456) +pico_add_extra_outputs(build_variant1) + +# 3 Create a second executable including all the common stuff +# this version also sets the DO_EXTRA define +add_executable(build_variant2) +target_link_libraries(build_variant2 common_stuff) +target_compile_definitions(build_variant2 PRIVATE + A_DEFINE_THAT_IS_NOT_SHARED=789 + DO_EXTRA) +pico_add_extra_outputs(build_variant2) + diff --git a/cmake/build_variants/main.c b/cmake/build_variants/main.c new file mode 100644 index 0000000..10a18d8 --- /dev/null +++ b/cmake/build_variants/main.c @@ -0,0 +1,18 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "other.h" + +int main() { + stdio_init_all(); + do_other(); +#ifdef DO_EXTRA + printf("A little extra\n"); +#endif + return 0; +} \ No newline at end of file diff --git a/cmake/build_variants/other.c b/cmake/build_variants/other.c new file mode 100644 index 0000000..d805de3 --- /dev/null +++ b/cmake/build_variants/other.c @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "other.h" + +void do_other() { + printf("The common thing is %d\n", + A_DEFINE_THAT_IS_SHARED); + printf("The binary local thing is %d\n", + A_DEFINE_THAT_IS_NOT_SHARED); +} \ No newline at end of file diff --git a/cmake/build_variants/other.h b/cmake/build_variants/other.h new file mode 100644 index 0000000..9f997a4 --- /dev/null +++ b/cmake/build_variants/other.h @@ -0,0 +1,7 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +void do_other(); \ No newline at end of file diff --git a/divider/CMakeLists.txt b/divider/CMakeLists.txt new file mode 100644 index 0000000..bf9c0ab --- /dev/null +++ b/divider/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_divider + hello_divider.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_divider pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_divider) + +# add url via pico_set_program_url +example_auto_set_url(hello_divider) \ No newline at end of file diff --git a/divider/hello_divider.c b/divider/hello_divider.c new file mode 100644 index 0000000..5f934a7 --- /dev/null +++ b/divider/hello_divider.c @@ -0,0 +1,75 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/divider.h" + +// tag::hello_divider[] +int main() { + stdio_init_all(); + printf("Hello, divider!\n"); + + // This is the basic hardware divider function + int32_t dividend = 123456; + int32_t divisor = -321; + divmod_result_t result = hw_divider_divmod_s32(dividend, divisor); + + printf("%d/%d = %d remainder %d\n", dividend, divisor, to_quotient_s32(result), to_remainder_s32(result)); + + // Is it right? + + printf("Working backwards! Result %d should equal %d!\n\n", + to_quotient_s32(result) * divisor + to_remainder_s32(result), dividend); + + // This is the recommended unsigned fast divider for general use. + int32_t udividend = 123456; + int32_t udivisor = 321; + divmod_result_t uresult = hw_divider_divmod_u32(udividend, udivisor); + + printf("%d/%d = %d remainder %d\n", udividend, udivisor, to_quotient_u32(uresult), to_remainder_u32(uresult)); + + // Is it right? + + printf("Working backwards! Result %d should equal %d!\n\n", + to_quotient_u32(result) * divisor + to_remainder_u32(result), dividend); + + // You can also do divides asynchronously. Divides will be complete after 8 cyles. + + hw_divider_divmod_s32_start(dividend, divisor); + + // Do something for 8 cycles! + + // In this example, our results function will wait for completion. + // Use hw_divider_result_nowait() if you don't want to wait, but are sure you have delayed at least 8 cycles + + result = hw_divider_result_wait(); + + printf("Async result %d/%d = %d remainder %d\n", dividend, divisor, to_quotient_s32(result), + to_remainder_s32(result)); + + // For a really fast divide, you can use the inlined versions... the / involves a function call as / always does + // when using the ARM AEABI, so if you really want the best performance use the inlined versions. + // Note that the / operator function DOES use the hardware divider by default, although you can change + // that behavior by calling pico_set_divider_implementation in the cmake build for your target. + printf("%d / %d = (by operator %d) (inlined %d)\n", dividend, divisor, + dividend / divisor, hw_divider_s32_quotient_inlined(dividend, divisor)); + + // Note however you must manually save/restore the divider state if you call the inlined methods from within an IRQ + // handler. + hw_divider_state_t state; + hw_divider_divmod_s32_start(dividend, divisor); + hw_divider_save_state(&state); + + hw_divider_divmod_s32_start(123, 7); + printf("inner %d / %d = %d\n", 123, 7, hw_divider_s32_quotient_wait()); + + hw_divider_restore_state(&state); + int32_t tmp = hw_divider_s32_quotient_wait(); + printf("outer divide %d / %d = %d\n", dividend, divisor, tmp); + return 0; +} +// end::hello_divider[] diff --git a/dma/CMakeLists.txt b/dma/CMakeLists.txt new file mode 100644 index 0000000..e2cff3f --- /dev/null +++ b/dma/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(channel_irq) + add_subdirectory(control_blocks) + add_subdirectory(hello_dma) +endif () diff --git a/dma/channel_irq/CMakeLists.txt b/dma/channel_irq/CMakeLists.txt new file mode 100644 index 0000000..25dc64e --- /dev/null +++ b/dma/channel_irq/CMakeLists.txt @@ -0,0 +1,18 @@ +add_executable(dma_channel_irq + channel_irq.c + ) + +pico_generate_pio_header(dma_channel_irq ${CMAKE_CURRENT_LIST_DIR}/pio_serialiser.pio) + +target_link_libraries(dma_channel_irq + pico_stdlib + hardware_dma + hardware_irq + hardware_pio + ) + +# create map/bin/hex file etc. +pico_add_extra_outputs(dma_channel_irq) + +# add url via pico_set_program_url +example_auto_set_url(dma_channel_irq) diff --git a/dma/channel_irq/channel_irq.c b/dma/channel_irq/channel_irq.c new file mode 100644 index 0000000..bbb2ecb --- /dev/null +++ b/dma/channel_irq/channel_irq.c @@ -0,0 +1,91 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Show how to reconfigure and restart a channel in a channel completion +// interrupt handler. +// +// Our DMA channel will transfer data to a PIO state machine, which is +// configured to serialise the raw bits that we push, one by one. We're going +// to use this to do some crude LED PWM by repeatedly sending values with the +// right balance of 1s and 0s. (note there are better ways to do PWM with PIO +// -- see the PIO PWM example). +// +// Once the channel has sent a predetermined amount of data, it will halt, and +// raise an interrupt flag. The processor will enter the interrupt handler in +// response to this, where it will reconfigure and restart the channel. This +// repeats. + +#include +#include "hardware/dma.h" +#include "hardware/irq.h" +#include "pio_serialiser.pio.h" + +// PIO sends one bit per 10 system clock cycles. DMA sends the same 32-bit +// value 10 000 times before halting. This means we cycle through the 32 PWM +// levels roughly once per second. +#define PIO_SERIAL_CLKDIV 10.f +#define PWM_REPEAT_COUNT 10000 +#define N_PWM_LEVELS 32 + +int dma_chan; + +void dma_handler() { + static int pwm_level = 0; + static uint32_t wavetable[N_PWM_LEVELS]; + static bool first_run = true; + // Entry number `i` has `i` one bits and `(32 - i)` zero bits. + if (first_run) { + first_run = false; + for (int i = 0; i < N_PWM_LEVELS; ++i) + wavetable[i] = ~(~0u << i); + } + + // Clear the interrupt request. + dma_hw->ints0 = 1u << dma_chan; + // Give the channel a new wave table entry to read from, and re-trigger it + dma_channel_set_read_addr(dma_chan, &wavetable[pwm_level], true); + + pwm_level = (pwm_level + 1) % N_PWM_LEVELS; +} + +int main() { + // Set up a PIO state machine to serialise our bits + uint offset = pio_add_program(pio0, &pio_serialiser_program); + pio_serialiser_program_init(pio0, 0, offset, PICO_DEFAULT_LED_PIN, PIO_SERIAL_CLKDIV); + + // Configure a channel to write the same word (32 bits) repeatedly to PIO0 + // SM0's TX FIFO, paced by the data request signal from that peripheral. + dma_chan = dma_claim_unused_channel(true); + dma_channel_config c = dma_channel_get_default_config(dma_chan); + channel_config_set_transfer_data_size(&c, DMA_SIZE_32); + channel_config_set_read_increment(&c, false); + channel_config_set_dreq(&c, DREQ_PIO0_TX0); + + dma_channel_configure( + dma_chan, + &c, + &pio0_hw->txf[0], // Write address (only need to set this once) + NULL, // Don't provide a read address yet + PWM_REPEAT_COUNT, // Write the same value many times, then halt and interrupt + false // Don't start yet + ); + + // Tell the DMA to raise IRQ line 0 when the channel finishes a block + dma_channel_set_irq0_enabled(dma_chan, true); + + // Configure the processor to run dma_handler() when DMA IRQ 0 is asserted + irq_set_exclusive_handler(DMA_IRQ_0, dma_handler); + irq_set_enabled(DMA_IRQ_0, true); + + // Manually call the handler once, to trigger the first transfer + dma_handler(); + + // Everything else from this point is interrupt-driven. The processor has + // time to sit and think about its early retirement -- maybe open a bakery? + while (true) + tight_loop_contents(); + +} diff --git a/dma/channel_irq/pio_serialiser.pio b/dma/channel_irq/pio_serialiser.pio new file mode 100644 index 0000000..67a6866 --- /dev/null +++ b/dma/channel_irq/pio_serialiser.pio @@ -0,0 +1,27 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program pio_serialiser + +; Just serialise a stream of bits. Take 32 bits from each FIFO record. LSB-first. + +.wrap_target + out pins, 1 +.wrap + +% c-sdk { +static inline void pio_serialiser_program_init(PIO pio, uint sm, uint offset, uint data_pin, float clk_div) { + pio_gpio_init(pio, data_pin); + pio_sm_set_consecutive_pindirs(pio, sm, data_pin, 1, true); + pio_sm_config c = pio_serialiser_program_get_default_config(offset); + sm_config_set_out_pins(&c, data_pin, 1); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + sm_config_set_clkdiv(&c, clk_div); + sm_config_set_out_shift(&c, true, true, 32); + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/dma/control_blocks/CMakeLists.txt b/dma/control_blocks/CMakeLists.txt new file mode 100644 index 0000000..b551c7b --- /dev/null +++ b/dma/control_blocks/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(dma_control_blocks + control_blocks.c + ) + +target_link_libraries(dma_control_blocks pico_stdlib hardware_dma) + +# create map/bin/hex file etc. +pico_add_extra_outputs(dma_control_blocks) + +# add url via pico_set_program_url +example_auto_set_url(dma_control_blocks) diff --git a/dma/control_blocks/control_blocks.c b/dma/control_blocks/control_blocks.c new file mode 100644 index 0000000..cdeacfd --- /dev/null +++ b/dma/control_blocks/control_blocks.c @@ -0,0 +1,111 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Use two DMA channels to make a programmed sequence of data transfers to the +// UART (a data gather operation). One channel is responsible for transferring +// the actual data, the other repeatedly reprograms that channel. + +#include +#include "pico/stdlib.h" +#include "hardware/dma.h" +#include "hardware/structs/uart.h" + +// These buffers will be DMA'd to the UART, one after the other. + +const char word0[] = "Transferring "; +const char word1[] = "one "; +const char word2[] = "word "; +const char word3[] = "at "; +const char word4[] = "a "; +const char word5[] = "time.\n"; + +// Note the order of the fields here: it's important that the length is before +// the read address, because the control channel is going to write to the last +// two registers in alias 3 on the data channel: +// +0x0 +0x4 +0x8 +0xC (Trigger) +// Alias 0: READ_ADDR WRITE_ADDR TRANS_COUNT CTRL +// Alias 1: CTRL READ_ADDR WRITE_ADDR TRANS_COUNT +// Alias 2: CTRL TRANS_COUNT READ_ADDR WRITE_ADDR +// Alias 3: CTRL WRITE_ADDR TRANS_COUNT READ_ADDR +// +// This will program the transfer count and read address of the data channel, +// and trigger it. Once the data channel completes, it will restart the +// control channel (via CHAIN_TO) to load the next two words into its control +// registers. + +const struct {uint32_t len; const char *data;} control_blocks[] = { + {count_of(word0) - 1, word0}, // Skip null terminator + {count_of(word1) - 1, word1}, + {count_of(word2) - 1, word2}, + {count_of(word3) - 1, word3}, + {count_of(word4) - 1, word4}, + {count_of(word5) - 1, word5}, + {0, NULL} // Null trigger to end chain. +}; + +int main() { + stdio_init_all(); + puts("DMA control block example:"); + + // ctrl_chan loads control blocks into data_chan, which executes them. + int ctrl_chan = dma_claim_unused_channel(true); + int data_chan = dma_claim_unused_channel(true); + + // The control channel transfers two words into the data channel's control + // registers, then halts. The write address wraps on a two-word + // (eight-byte) boundary, so that the control channel writes the same two + // registers when it is next triggered. + + dma_channel_config c = dma_channel_get_default_config(ctrl_chan); + channel_config_set_transfer_data_size(&c, DMA_SIZE_32); + channel_config_set_read_increment(&c, true); + channel_config_set_write_increment(&c, true); + channel_config_set_ring(&c, true, 3); // 1 << 3 byte boundary on write ptr + + dma_channel_configure( + ctrl_chan, + &c, + &dma_hw->ch[data_chan].al3_transfer_count, // Initial write address + &control_blocks[0], // Initial read address + 2, // Halt after each control block + false // Don't start yet + ); + + // The data channel is set up to write to the UART FIFO (paced by the + // UART's TX data request signal) and then chain to the control channel + // once it completes. The control channel programs a new read address and + // data length, and retriggers the data channel. + + c = dma_channel_get_default_config(data_chan); + channel_config_set_transfer_data_size(&c, DMA_SIZE_8); + channel_config_set_dreq(&c, DREQ_UART0_TX + 2 * PICO_DEFAULT_UART); + // Trigger ctrl_chan when data_chan completes + channel_config_set_chain_to(&c, ctrl_chan); + // Raise the IRQ flag when 0 is written to a trigger register (end of chain): + channel_config_set_irq_quiet(&c, true); + + dma_channel_configure( + data_chan, + &c, + &(PICO_DEFAULT_UART ? uart1_hw : uart0_hw)->dr, + NULL, // Initial read address and transfer count are unimportant; + 0, // the control channel will reprogram them each time. + false // Don't start yet. + ); + + // Everything is ready to go. Tell the control channel to load the first + // control block. Everything is automatic from here. + dma_start_channel_mask(1u << ctrl_chan); + + // The data channel will assert its IRQ flag when it gets a null trigger, + // indicating the end of the control block list. We're just going to wait + // for the IRQ flag instead of setting up an interrupt handler. + while (!(dma_hw->intr & 1u << data_chan)) + tight_loop_contents(); + dma_hw->ints0 = 1u << data_chan; + + puts("DMA finished."); +} diff --git a/dma/hello_dma/CMakeLists.txt b/dma/hello_dma/CMakeLists.txt new file mode 100644 index 0000000..b513a2e --- /dev/null +++ b/dma/hello_dma/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(hello_dma + hello_dma.c + ) + +target_link_libraries(hello_dma pico_stdlib hardware_dma) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_dma) + +# add url via pico_set_program_url +example_auto_set_url(hello_dma) diff --git a/dma/hello_dma/hello_dma.c b/dma/hello_dma/hello_dma.c new file mode 100644 index 0000000..9e3831c --- /dev/null +++ b/dma/hello_dma/hello_dma.c @@ -0,0 +1,49 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Use the DMA to copy data between two buffers in memory. + +#include +#include "pico/stdlib.h" +#include "hardware/dma.h" + +// Data will be copied from src to dst +const char src[] = "Hello, world! (from DMA)"; +char dst[count_of(src)]; + +int main() { + stdio_init_all(); + + // Get a free channel, panic() if there are none + int chan = dma_claim_unused_channel(true); + + // 8 bit transfers. Both read and write address increment after each + // transfer (each pointing to a location in src or dst respectively). + // No DREQ is selected, so the DMA transfers as fast as it can. + + dma_channel_config c = dma_channel_get_default_config(chan); + channel_config_set_transfer_data_size(&c, DMA_SIZE_8); + channel_config_set_read_increment(&c, true); + channel_config_set_write_increment(&c, true); + + dma_channel_configure( + chan, // Channel to be configured + &c, // The configuration we just created + dst, // The initial write address + src, // The initial read address + count_of(src), // Number of transfers; in this case each is 1 byte. + true // Start immediately. + ); + + // We could choose to go and do something else whilst the DMA is doing its + // thing. In this case the processor has nothing else to do, so we just + // wait for the DMA to finish. + dma_channel_wait_for_finish_blocking(chan); + + // The DMA has now copied our text from the transmit buffer (src) to the + // receive buffer (dst), so we can print it out from there. + puts(dst); +} diff --git a/example_auto_set_url.cmake b/example_auto_set_url.cmake new file mode 100644 index 0000000..59e6c71 --- /dev/null +++ b/example_auto_set_url.cmake @@ -0,0 +1,5 @@ +set(PICO_EXAMPLE_URL_BASE "https://github.com/raspberrypi/pico-examples/tree/HEAD") +macro(example_auto_set_url TARGET) + file(RELATIVE_PATH URL_REL_PATH "${PICO_EXAMPLES_PATH}" "${CMAKE_CURRENT_LIST_DIR}") + pico_set_program_url(${TARGET} "${PICO_EXAMPLE_URL_BASE}/${URL_REL_PATH}") +endmacro() \ No newline at end of file diff --git a/flash/CMakeLists.txt b/flash/CMakeLists.txt new file mode 100644 index 0000000..9571559 --- /dev/null +++ b/flash/CMakeLists.txt @@ -0,0 +1,7 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(cache_perfctr) + add_subdirectory(nuke) + add_subdirectory(program) + add_subdirectory(ssi_dma) + add_subdirectory(xip_stream) +endif () diff --git a/flash/cache_perfctr/CMakeLists.txt b/flash/cache_perfctr/CMakeLists.txt new file mode 100644 index 0000000..2d065a2 --- /dev/null +++ b/flash/cache_perfctr/CMakeLists.txt @@ -0,0 +1,13 @@ +add_executable(flash_cache_perfctr + flash_cache_perfctr.c + ) + +target_link_libraries(flash_cache_perfctr + pico_stdlib + ) + +# create map/bin/hex file etc. +pico_add_extra_outputs(flash_cache_perfctr) + +# add url via pico_set_program_url +example_auto_set_url(flash_cache_perfctr) diff --git a/flash/cache_perfctr/flash_cache_perfctr.c b/flash/cache_perfctr/flash_cache_perfctr.c new file mode 100644 index 0000000..910dfbd --- /dev/null +++ b/flash/cache_perfctr/flash_cache_perfctr.c @@ -0,0 +1,88 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/structs/xip_ctrl.h" + +// Example of using cache hit/access counters, and showing the effect of +// invalidate on cache miss/hit. + + +const uint32_t test_data[8] = {0, 1, 2, 3, 4, 5, 6, 7}; + +void __no_inline_not_in_flash_func(check)(bool cond, const char *msg) { + if (!cond) { + puts(msg); + exit(-1); + } +} + +void __no_inline_not_in_flash_func(check_hit_miss_invalidate)() { + io_rw_32 *test_data_ptr = (io_rw_32 *) test_data; + + //tag::check_hit_miss_invalidate[] + // Flush cache to make sure we miss the first time we access test_data + xip_ctrl_hw->flush = 1; + while (!(xip_ctrl_hw->stat & XIP_STAT_FLUSH_READY_BITS)) + tight_loop_contents(); + + // Clear counters (write any value to clear) + xip_ctrl_hw->ctr_acc = 1; + xip_ctrl_hw->ctr_hit = 1; + + (void) *test_data_ptr; + check(xip_ctrl_hw->ctr_hit == 0 && xip_ctrl_hw->ctr_acc == 1, + "First access to data should miss"); + + (void) *test_data_ptr; + check(xip_ctrl_hw->ctr_hit == 1 && xip_ctrl_hw->ctr_acc == 2, + "Second access to data should hit"); + + // Write to invalidate individual cache lines (64 bits) + // Writes must be directed to the cacheable, allocatable alias (address 0x10.._....) + *test_data_ptr = 0; + (void) *test_data_ptr; + check(xip_ctrl_hw->ctr_hit == 1 && xip_ctrl_hw->ctr_acc == 3, + "Should miss after invalidation"); + (void) *test_data_ptr; + check(xip_ctrl_hw->ctr_hit == 2 && xip_ctrl_hw->ctr_acc == 4, + "Second access after invalidation should hit again"); + //end::check_hit_miss_invalidate[] +} + +// Some code which achieves a very high cache hit rate: +int recursive_fibonacci(int n) { + if (n <= 1) + return 1; + else + return recursive_fibonacci(n - 1) + recursive_fibonacci(n - 2); +} + +int main() { + stdio_init_all(); + + uint hit = xip_ctrl_hw->ctr_hit; + uint access = xip_ctrl_hw->ctr_acc; + + if (access == 0) + printf("It looks like you're running this example from SRAM. This probably won't go well!\n"); + + // Note the hit rate will appear quite low at boot, as the .data, + // .time_critical init in crt0 read a lot of read-once data from flash + printf("At boot: %d hits, %d accesses\n", hit, access); + printf("Hit rate so far: %.1f%%\n", hit * 100.f / access); + + printf("Calculate 25th fibonacci number: %d\n", recursive_fibonacci(25)); + printf("New hit rate after printf and fibonacci: %.1f%%\n", xip_ctrl_hw->ctr_hit * 100.f / xip_ctrl_hw->ctr_acc); + + check_hit_miss_invalidate(); + + printf("Hit/miss check passed\n"); + return 0; +} diff --git a/flash/nuke/CMakeLists.txt b/flash/nuke/CMakeLists.txt new file mode 100644 index 0000000..c8ae47a --- /dev/null +++ b/flash/nuke/CMakeLists.txt @@ -0,0 +1,18 @@ +add_executable(flash_nuke + nuke.c + ) + +target_link_libraries(flash_nuke + pico_stdlib + hardware_flash + ) + +# It doesn't make sense to run this program from flash. Always build a +# RAM-only binary. +pico_set_binary_type(flash_nuke no_flash) + +pico_add_extra_outputs(flash_nuke) + +# add url via pico_set_program_url +example_auto_set_url(flash_nuke) + diff --git a/flash/nuke/nuke.c b/flash/nuke/nuke.c new file mode 100644 index 0000000..d4637b1 --- /dev/null +++ b/flash/nuke/nuke.c @@ -0,0 +1,47 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Obliterate the contents of flash. This is a silly thing to do if you are +// trying to run this program from flash, so you should really load and run +// directly from SRAM. You can enable RAM-only builds for all targets by doing: +// +// cmake -DPICO_NO_FLASH=1 .. +// +// in your build directory. We've also forced no-flash builds for this app in +// particular by adding: +// +// pico_set_binary_type(flash_nuke no_flash) +// +// To the CMakeLists.txt app for this file. Just to be sure, we can check the +// define: +#if !PICO_NO_FLASH +#error "This example must be built to run from SRAM!" +#endif + +#include "pico/stdlib.h" +#include "hardware/flash.h" +#include "pico/bootrom.h" + +int main() { + flash_range_erase(0, PICO_FLASH_SIZE_BYTES); + // Leave an eyecatcher pattern in the first page of flash so picotool can + // more easily check the size: + static const uint8_t eyecatcher[FLASH_PAGE_SIZE] = "NUKE"; + flash_range_program(0, eyecatcher, FLASH_PAGE_SIZE); + + // Flash LED for success + gpio_init(PICO_DEFAULT_LED_PIN); + gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT); + for (int i = 0; i < 3; ++i) { + gpio_put(PICO_DEFAULT_LED_PIN, 1); + sleep_ms(100); + gpio_put(PICO_DEFAULT_LED_PIN, 0); + sleep_ms(100); + } + + // Pop back up as an MSD drive + reset_usb_boot(0, 0); +} diff --git a/flash/program/CMakeLists.txt b/flash/program/CMakeLists.txt new file mode 100644 index 0000000..a17bb0e --- /dev/null +++ b/flash/program/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(flash_program + flash_program.c + ) + +target_link_libraries(flash_program + pico_stdlib + hardware_flash + ) + +# create map/bin/hex file etc. +pico_add_extra_outputs(flash_program) + +# add url via pico_set_program_url +example_auto_set_url(flash_program) diff --git a/flash/program/flash_program.c b/flash/program/flash_program.c new file mode 100644 index 0000000..208ccb5 --- /dev/null +++ b/flash/program/flash_program.c @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/flash.h" + +// We're going to erase and reprogram a region 256k from the start of flash. +// Once done, we can access this at XIP_BASE + 256k. +#define FLASH_TARGET_OFFSET (256 * 1024) + +const uint8_t *flash_target_contents = (const uint8_t *) (XIP_BASE + FLASH_TARGET_OFFSET); + +void print_buf(const uint8_t *buf, size_t len) { + for (size_t i = 0; i < len; ++i) { + printf("%02x", buf[i]); + if (i % 16 == 15) + printf("\n"); + else + printf(" "); + } +} + +int main() { + stdio_init_all(); + uint8_t random_data[FLASH_PAGE_SIZE]; + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) + random_data[i] = rand() >> 16; + + printf("Generated random data:\n"); + print_buf(random_data, FLASH_PAGE_SIZE); + + // Note that a whole number of sectors must be erased at a time. + printf("\nErasing target region...\n"); + flash_range_erase(FLASH_TARGET_OFFSET, FLASH_SECTOR_SIZE); + printf("Done. Read back target region:\n"); + print_buf(flash_target_contents, FLASH_PAGE_SIZE); + + printf("\nProgramming target region...\n"); + flash_range_program(FLASH_TARGET_OFFSET, random_data, FLASH_PAGE_SIZE); + printf("Done. Read back target region:\n"); + print_buf(flash_target_contents, FLASH_PAGE_SIZE); + + bool mismatch = false; + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) { + if (random_data[i] != flash_target_contents[i]) + mismatch = true; + } + if (mismatch) + printf("Programming failed!\n"); + else + printf("Programming successful!\n"); +} diff --git a/flash/ssi_dma/CMakeLists.txt b/flash/ssi_dma/CMakeLists.txt new file mode 100644 index 0000000..b1091a4 --- /dev/null +++ b/flash/ssi_dma/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(flash_ssi_dma + flash_ssi_dma.c + ) + +target_link_libraries(flash_ssi_dma + pico_stdlib + hardware_dma + ) + +# create map/bin/hex file etc. +pico_add_extra_outputs(flash_ssi_dma) + +# add url via pico_set_program_url +example_auto_set_url(flash_ssi_dma) diff --git a/flash/ssi_dma/flash_ssi_dma.c b/flash/ssi_dma/flash_ssi_dma.c new file mode 100644 index 0000000..118513d --- /dev/null +++ b/flash/ssi_dma/flash_ssi_dma.c @@ -0,0 +1,90 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "pico/time.h" +#include "hardware/dma.h" +#include "hardware/structs/ssi.h" + +// This example DMAs 16kB of data from the start of flash to SRAM, and +// measures the transfer speed. +// +// The SSI (flash interface) inside the XIP block has DREQ logic, so we can +// DMA directly from its FIFOs. Unlike the XIP stream hardware (see +// flash_xip_stream.c) this can *not* be done whilst code is running from +// flash, without careful footwork like we do here. The tradeoff is that it's +// ~2.5x as fast in QSPI mode, ~2x as fast in SPI mode. + +void __no_inline_not_in_flash_func(flash_bulk_read)(uint32_t *rxbuf, uint32_t flash_offs, size_t len, + uint dma_chan) { + // SSI must be disabled to set transfer size. If software is executing + // from flash right now then it's about to have a bad time + ssi_hw->ssienr = 0; + ssi_hw->ctrlr1 = len - 1; // NDF, number of data frames + ssi_hw->dmacr = SSI_DMACR_TDMAE_BITS | SSI_DMACR_RDMAE_BITS; + ssi_hw->ssienr = 1; + // Other than NDF, the SSI configuration used for XIP is suitable for a bulk read too. + + // Configure and start the DMA. Note we are avoiding the dma_*() functions + // as we can't guarantee they'll be inlined + dma_hw->ch[dma_chan].read_addr = (uint32_t) &ssi_hw->dr0; + dma_hw->ch[dma_chan].write_addr = (uint32_t) rxbuf; + dma_hw->ch[dma_chan].transfer_count = len; + // Must enable DMA byteswap because non-XIP 32-bit flash transfers are + // big-endian on SSI (we added a hardware tweak to make XIP sensible) + dma_hw->ch[dma_chan].ctrl_trig = + DMA_CH0_CTRL_TRIG_BSWAP_BITS | + DREQ_XIP_SSIRX << DMA_CH0_CTRL_TRIG_TREQ_SEL_LSB | + dma_chan << DMA_CH0_CTRL_TRIG_CHAIN_TO_LSB | + DMA_CH0_CTRL_TRIG_INCR_WRITE_BITS | + DMA_CH0_CTRL_TRIG_DATA_SIZE_VALUE_SIZE_WORD << DMA_CH0_CTRL_TRIG_DATA_SIZE_LSB | + DMA_CH0_CTRL_TRIG_EN_BITS; + + // Now DMA is waiting, kick off the SSI transfer (mode continuation bits in LSBs) + ssi_hw->dr0 = (flash_offs << 8u) | 0xa0u; + + // Wait for DMA finish + while (dma_hw->ch[dma_chan].ctrl_trig & DMA_CH0_CTRL_TRIG_BUSY_BITS); + + // Reconfigure SSI before we jump back into flash! + ssi_hw->ssienr = 0; + ssi_hw->ctrlr1 = 0; // Single 32-bit data frame per transfer + ssi_hw->dmacr = 0; + ssi_hw->ssienr = 1; +} + +#define DATA_SIZE_WORDS 4096 + +uint32_t rxdata[DATA_SIZE_WORDS]; +uint32_t *expect = (uint32_t *) XIP_NOCACHE_NOALLOC_BASE; + +int main() { + stdio_init_all(); + memset(rxdata, 0, DATA_SIZE_WORDS * sizeof(uint32_t)); + + printf("Starting DMA\n"); + uint32_t start_time = time_us_32(); + flash_bulk_read(rxdata, 0, DATA_SIZE_WORDS, 0); + uint32_t finish_time = time_us_32(); + printf("DMA finished\n"); + + float elapsed_time_s = 1e-6f * (finish_time - start_time); + printf("Transfer speed: %.3f MB/s\n", (sizeof(uint32_t) * DATA_SIZE_WORDS / 1e6f) / elapsed_time_s); + + bool mismatch = false; + for (int i = 0; i < DATA_SIZE_WORDS; ++i) { + if (rxdata[i] != expect[i]) { + printf("Mismatch at %d: expected %08x, got %08x\n", i, expect[i], rxdata[i]); + mismatch = true; + break; + } + } + if (!mismatch) + printf("Data check ok\n"); +} \ No newline at end of file diff --git a/flash/xip_stream/CMakeLists.txt b/flash/xip_stream/CMakeLists.txt new file mode 100644 index 0000000..bd8b6dd --- /dev/null +++ b/flash/xip_stream/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(flash_xip_stream + flash_xip_stream.c + ) + +target_link_libraries(flash_xip_stream + pico_stdlib + hardware_dma + ) + +# create map/bin/hex file etc. +pico_add_extra_outputs(flash_xip_stream) + +# add url via pico_set_program_url +example_auto_set_url(flash_xip_stream) diff --git a/flash/xip_stream/flash_xip_stream.c b/flash/xip_stream/flash_xip_stream.c new file mode 100644 index 0000000..dfe33af --- /dev/null +++ b/flash/xip_stream/flash_xip_stream.c @@ -0,0 +1,88 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/dma.h" +#include "hardware/regs/addressmap.h" +#include "hardware/structs/xip_ctrl.h" + +#include "random_test_data.h" + +// The XIP has some internal hardware that can stream a linear access sequence +// to a DMAable FIFO, while the system is still doing random accesses on flash +// code + data. + +uint32_t buf[count_of(random_test_data)]; + +int main() { + stdio_init_all(); + for (int i = 0; i < count_of(random_test_data); ++i) + buf[i] = 0; + + // This example won't work with PICO_NO_FLASH builds. Note that XIP stream + // can be made to work in these cases, if you enable some XIP mode first + // (e.g. via calling flash_enter_cmd_xip() in ROM). However, you will get + // much better performance by DMAing directly from the SSI's FIFOs, as in + // this way you can clock data continuously on the QSPI bus, rather than a + // series of short transfers. + if ((uint32_t) &random_test_data[0] >= SRAM_BASE) { + printf("You need to run this example from flash!\n"); + exit(-1); + } + + // Transfer started by writing nonzero value to stream_ctr. stream_ctr + // will count down as the transfer progresses. Can terminate early by + // writing 0 to stream_ctr. + // It's a good idea to drain the FIFO first! + printf("Starting stream from %p\n", random_test_data); + //tag::start_stream[] + while (!(xip_ctrl_hw->stat & XIP_STAT_FIFO_EMPTY)) + (void) xip_ctrl_hw->stream_fifo; + xip_ctrl_hw->stream_addr = (uint32_t) &random_test_data[0]; + xip_ctrl_hw->stream_ctr = count_of(random_test_data); + //end::start_stream[] + + // Start DMA transfer from XIP stream FIFO to our buffer in memory. Use + // the auxiliary bus slave for the DMA<-FIFO accesses, to avoid stalling + // the DMA against general XIP traffic. Doesn't really matter for this + // example, but it can have a huge effect on DMA throughput. + + printf("Starting DMA\n"); + //tag::start_dma[] + const uint dma_chan = 0; + dma_channel_config cfg = dma_channel_get_default_config(dma_chan); + channel_config_set_read_increment(&cfg, false); + channel_config_set_write_increment(&cfg, true); + channel_config_set_dreq(&cfg, DREQ_XIP_STREAM); + dma_channel_configure( + dma_chan, + &cfg, + (void *) buf, // Write addr + (const void *) XIP_AUX_BASE, // Read addr + count_of(random_test_data), // Transfer count + true // Start immediately! + ); + //end::start_dma[] + + dma_channel_wait_for_finish_blocking(dma_chan); + + printf("DMA complete\n"); + + bool mismatch = false; + for (int i = 0; i < count_of(random_test_data); ++i) { + if (random_test_data[i] != buf[i]) { + printf("Data mismatch: %08x (actual) != %08x (expected)\n", buf[i], random_test_data[i]); + mismatch = true; + break; + } + printf("%08x%c", buf[i], i % 8 == 7 ? '\n' : ' '); + } + if (!mismatch) + printf("Data check OK\n"); +} \ No newline at end of file diff --git a/flash/xip_stream/random_test_data.h b/flash/xip_stream/random_test_data.h new file mode 100644 index 0000000..186b6d1 --- /dev/null +++ b/flash/xip_stream/random_test_data.h @@ -0,0 +1,160 @@ +const uint32_t random_test_data[] = { + 0x76654e22, 0x47207265, 0x616e6e6f, + 0x76694720, 0x6f592065, 0x70552075, + 0x570a0a22, 0x65722765, 0x206f6e20, + 0x61727473, 0x7265676e, 0x6f742073, + 0x766f6c20, 0x6f590a65, 0x6e6b2075, + 0x7420776f, 0x72206568, 0x73656c75, + 0x646e6120, 0x206f7320, 0x49206f64, + 0x6620410a, 0x206c6c75, 0x6d6d6f63, + 0x656d7469, 0x7327746e, 0x61687720, + 0x27492074, 0x6874206d, 0x696b6e69, + 0x6f20676e, 0x6f590a66, 0x6f772075, + 0x6e646c75, 0x67207427, 0x74207465, + 0x20736968, 0x6d6f7266, 0x796e6120, + 0x68746f20, 0x67207265, 0x0a0a7975, + 0x756a2049, 0x77207473, 0x616e6e61, + 0x6c657420, 0x6f79206c, 0x6f682075, + 0x27492077, 0x6566206d, 0x6e696c65, + 0x6f470a67, 0x20617474, 0x656b616d, + 0x756f7920, 0x646e7520, 0x74737265, + 0x0a646e61, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x76696720, 0x6f792065, + 0x70752075, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x74656c20, 0x756f7920, + 0x776f6420, 0x654e0a6e, 0x20726576, + 0x6e6e6f67, 0x75722061, 0x7261206e, + 0x646e756f, 0x646e6120, 0x73656420, + 0x20747265, 0x0a756f79, 0x6576654e, + 0x6f672072, 0x20616e6e, 0x656b616d, + 0x756f7920, 0x79726320, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x79617320, + 0x6f6f6720, 0x65796264, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x6c657420, + 0x2061206c, 0x2065696c, 0x20646e61, + 0x74727568, 0x756f7920, 0x65570a0a, + 0x20657627, 0x776f6e6b, 0x6165206e, + 0x6f206863, 0x72656874, 0x726f6620, + 0x206f7320, 0x676e6f6c, 0x756f590a, + 0x65682072, 0x27747261, 0x65622073, + 0x61206e65, 0x6e696863, 0x62202c67, + 0x590a7475, 0x7227756f, 0x6f742065, + 0x6873206f, 0x6f742079, 0x79617320, + 0x0a746920, 0x69736e49, 0x202c6564, + 0x62206577, 0x2068746f, 0x776f6e6b, + 0x61687720, 0x20732774, 0x6e656562, + 0x696f6720, 0x6f20676e, 0x65570a6e, + 0x6f6e6b20, 0x68742077, 0x61672065, + 0x6120656d, 0x7720646e, 0x65722765, + 0x6e6f6720, 0x7020616e, 0x2079616c, + 0x0a0a7469, 0x20646e41, 0x79206669, + 0x6120756f, 0x6d206b73, 0x6f682065, + 0x27492077, 0x6566206d, 0x6e696c65, + 0x6f440a67, 0x2074276e, 0x6c6c6574, + 0x20656d20, 0x27756f79, 0x74206572, + 0x62206f6f, 0x646e696c, 0x206f7420, + 0x0a656573, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x76696720, 0x6f792065, + 0x70752075, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x74656c20, 0x756f7920, + 0x776f6420, 0x654e0a6e, 0x20726576, + 0x6e6e6f67, 0x75722061, 0x7261206e, + 0x646e756f, 0x646e6120, 0x73656420, + 0x20747265, 0x0a756f79, 0x6576654e, + 0x6f672072, 0x20616e6e, 0x656b616d, + 0x756f7920, 0x79726320, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x79617320, + 0x6f6f6720, 0x65796264, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x6c657420, + 0x2061206c, 0x2065696c, 0x20646e61, + 0x74727568, 0x756f7920, 0x654e0a0a, + 0x20726576, 0x6e6e6f67, 0x69672061, + 0x79206576, 0x7520756f, 0x654e0a70, + 0x20726576, 0x6e6e6f67, 0x656c2061, + 0x6f792074, 0x6f642075, 0x4e0a6e77, + 0x72657665, 0x6e6f6720, 0x7220616e, + 0x61206e75, 0x6e756f72, 0x6e612064, + 0x65642064, 0x74726573, 0x756f7920, + 0x76654e0a, 0x67207265, 0x616e6e6f, + 0x6b616d20, 0x6f792065, 0x72632075, + 0x654e0a79, 0x20726576, 0x6e6e6f67, + 0x61732061, 0x6f672079, 0x7962646f, + 0x654e0a65, 0x20726576, 0x6e6e6f67, + 0x65742061, 0x61206c6c, 0x65696c20, + 0x646e6120, 0x72756820, 0x6f792074, + 0x280a0a75, 0x2c686f4f, 0x76696720, + 0x6f792065, 0x70752075, 0x4f280a29, + 0x202c686f, 0x65766967, 0x756f7920, + 0x29707520, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x76696720, 0x6e202c65, + 0x72657665, 0x6e6f6720, 0x6720616e, + 0x0a657669, 0x76694728, 0x6f792065, + 0x70752075, 0x654e0a29, 0x20726576, + 0x6e6e6f67, 0x69672061, 0x202c6576, + 0x6576656e, 0x6f672072, 0x20616e6e, + 0x65766967, 0x6947280a, 0x79206576, + 0x7520756f, 0x0a0a2970, 0x76276557, + 0x6e6b2065, 0x206e776f, 0x68636165, + 0x68746f20, 0x66207265, 0x7320726f, + 0x6f6c206f, 0x590a676e, 0x2072756f, + 0x72616568, 0x20732774, 0x6e656562, + 0x68636120, 0x2c676e69, 0x74756220, + 0x756f590a, 0x20657227, 0x206f6f74, + 0x20796873, 0x73206f74, 0x69207961, + 0x6e490a74, 0x65646973, 0x6577202c, + 0x746f6220, 0x6e6b2068, 0x7720776f, + 0x27746168, 0x65622073, 0x67206e65, + 0x676e696f, 0x0a6e6f20, 0x6b206557, + 0x20776f6e, 0x20656874, 0x656d6167, + 0x646e6120, 0x27657720, 0x67206572, + 0x616e6e6f, 0x616c7020, 0x74692079, + 0x20490a0a, 0x7473756a, 0x6e617720, + 0x7420616e, 0x206c6c65, 0x20756f79, + 0x20776f68, 0x206d2749, 0x6c656566, + 0x0a676e69, 0x74746f47, 0x616d2061, + 0x7920656b, 0x7520756f, 0x7265646e, + 0x6e617473, 0x4e0a0a64, 0x72657665, + 0x6e6f6720, 0x6720616e, 0x20657669, + 0x20756f79, 0x4e0a7075, 0x72657665, + 0x6e6f6720, 0x6c20616e, 0x79207465, + 0x6420756f, 0x0a6e776f, 0x6576654e, + 0x6f672072, 0x20616e6e, 0x206e7572, + 0x756f7261, 0x6120646e, 0x6420646e, + 0x72657365, 0x6f792074, 0x654e0a75, + 0x20726576, 0x6e6e6f67, 0x616d2061, + 0x7920656b, 0x6320756f, 0x4e0a7972, + 0x72657665, 0x6e6f6720, 0x7320616e, + 0x67207961, 0x62646f6f, 0x4e0a6579, + 0x72657665, 0x6e6f6720, 0x7420616e, + 0x206c6c65, 0x696c2061, 0x6e612065, + 0x75682064, 0x79207472, 0x0a0a756f, + 0x6576654e, 0x6f672072, 0x20616e6e, + 0x65766967, 0x756f7920, 0x0a707520, + 0x6576654e, 0x6f672072, 0x20616e6e, + 0x2074656c, 0x20756f79, 0x6e776f64, + 0x76654e0a, 0x67207265, 0x616e6e6f, + 0x6e757220, 0x6f726120, 0x20646e75, + 0x20646e61, 0x65736564, 0x79207472, + 0x4e0a756f, 0x72657665, 0x6e6f6720, + 0x6d20616e, 0x20656b61, 0x20756f79, + 0x0a797263, 0x6576654e, 0x6f672072, + 0x20616e6e, 0x20796173, 0x646f6f67, + 0x0a657962, 0x6576654e, 0x6f672072, + 0x20616e6e, 0x6c6c6574, 0x6c206120, + 0x61206569, 0x6820646e, 0x20747275, + 0x0a756f79, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x76696720, 0x6f792065, + 0x70752075, 0x76654e0a, 0x67207265, + 0x616e6e6f, 0x74656c20, 0x756f7920, + 0x776f6420, 0x654e0a6e, 0x20726576, + 0x6e6e6f67, 0x75722061, 0x7261206e, + 0x646e756f, 0x646e6120, 0x73656420, + 0x20747265, 0x0a756f79, 0x6576654e, + 0x6f672072, 0x20616e6e, 0x656b616d, + 0x756f7920, 0x79726320, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x79617320, + 0x6f6f6720, 0x65796264, 0x76654e0a, + 0x67207265, 0x616e6e6f, 0x6c657420, + 0x2061206c, 0x2065696c, 0x20646e61 +}; + diff --git a/gpio/CMakeLists.txt b/gpio/CMakeLists.txt new file mode 100644 index 0000000..f06bf41 --- /dev/null +++ b/gpio/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(dht_sensor) + add_subdirectory(hello_7segment) + add_subdirectory(hello_gpio_irq) +endif () diff --git a/gpio/dht_sensor/CMakeLists.txt b/gpio/dht_sensor/CMakeLists.txt new file mode 100644 index 0000000..33c72ea --- /dev/null +++ b/gpio/dht_sensor/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(dht + dht.c + ) + +target_link_libraries(dht pico_stdlib) + +pico_add_extra_outputs(dht) + +# add url via pico_set_program_url +example_auto_set_url(dht) + diff --git a/gpio/dht_sensor/README.adoc b/gpio/dht_sensor/README.adoc new file mode 100644 index 0000000..60cd9f8 --- /dev/null +++ b/gpio/dht_sensor/README.adoc @@ -0,0 +1,58 @@ += DHT-11, DHT-22, and AM2302 Sensors +:xrefstyle: short + +The DHT sensors are fairly well known hobbyist sensors for measuring relative humidity and temperature using a capacitive humidity sensor, and a thermistor. While they are slow, one reading every ~2 seconds, they are reliable and good for basic data logging. Communication is based on a custom protocol which uses a single wire for data. + +[NOTE] +====== +The DHT-11 and DHT-22 sensors are the most common. They use the same protocol but have different characteristics, the DHT-22 has better accuracy, and has a larger sensor range than the DHT-11. The sensor is available from a number of retailers. +====== + +== Wiring information + +See <> for wiring instructions. + +[[dht-wiring-diagram]] +[pdfwidth=75%] +.Wiring the DHT-22 temperature sensor to Raspberry Pi Pico, and connecting Pico's UART0 to the Raspberry Pi 4. +image::pi-and-pico-uart-and-dht-sensor.png[] + +NOTE: One of the pins (pin 3) on the DHT sensor will not be connected, it is not used. + +You will want to place a 10 kΩ resistor between VCC and the data pin, to act as a medium-strength pull up on the data line. + +Connecting UART0 of Pico to Raspberry Pi as in <> and you should see something similar to <> in `minicom` when connected to `/dev/serial0` on the Raspberry Pi. + +[[dht-serial-output-diagram]] +[pdfwidth=75%] +.Serial output over Pico's UART0 in a terminal window. +image::serial-output.png[] + +Connect to `/dev/serial0` by typing, + +---- +$ minicom -b 115200 -o -D /dev/serial0 +---- + +at the command line. + +== List of Files + +A list of files with descriptions of their function; + +CMakeLists.txt:: Make file to incorporate the example in to the examples build tree. +dht.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[dht-22-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| 10 kΩ resistor | 1 | generic part +| M/M Jumper wires | 4 | generic part +| DHT-22 sensor | 1 | generic part +|=== diff --git a/gpio/dht_sensor/dht.c b/gpio/dht_sensor/dht.c new file mode 100644 index 0000000..84a7836 --- /dev/null +++ b/gpio/dht_sensor/dht.c @@ -0,0 +1,83 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + **/ + +#include +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" + +const uint LED_PIN = PICO_DEFAULT_LED_PIN; +const uint DHT_PIN = 15; +const uint MAX_TIMINGS = 85; + +typedef struct { + float humidity; + float temp_celsius; +} dht_reading; + +void read_from_dht(dht_reading *result); + +int main() { + stdio_init_all(); + gpio_init(LED_PIN); + gpio_init(DHT_PIN); + gpio_set_dir(LED_PIN, GPIO_OUT); + while (1) { + dht_reading reading; + read_from_dht(&reading); + float fahrenheit = (reading.temp_celsius * 9 / 5) + 32; + printf("Humidity = %.1f%%, Temperature = %.1fC (%.1fF)\n", + reading.humidity, reading.temp_celsius, fahrenheit); + + sleep_ms(2000); + } +} + +void read_from_dht(dht_reading *result) { + int data[5] = {0, 0, 0, 0, 0}; + uint last = 1; + uint j = 0; + + gpio_set_dir(DHT_PIN, GPIO_OUT); + gpio_put(DHT_PIN, 0); + sleep_ms(20); + gpio_set_dir(DHT_PIN, GPIO_IN); + + gpio_put(LED_PIN, 1); + for (uint i = 0; i < MAX_TIMINGS; i++) { + uint count = 0; + while (gpio_get(DHT_PIN) == last) { + count++; + sleep_us(1); + if (count == 255) break; + } + last = gpio_get(DHT_PIN); + if (count == 255) break; + + if ((i >= 4) && (i % 2 == 0)) { + data[j / 8] <<= 1; + if (count > 16) data[j / 8] |= 1; + j++; + } + } + gpio_put(LED_PIN, 0); + + if ((j >= 40) && (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF))) { + result->humidity = (float) ((data[0] << 8) + data[1]) / 10; + if (result->humidity > 100) { + result->humidity = data[0]; + } + result->temp_celsius = (float) (((data[2] & 0x7F) << 8) + data[3]) / 10; + if (result->temp_celsius > 125) { + result->temp_celsius = data[2]; + } + if (data[2] & 0x80) { + result->temp_celsius = -result->temp_celsius; + } + } else { + printf("Bad data\n"); + } +} diff --git a/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.fzz b/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.fzz new file mode 100644 index 0000000..2560c02 Binary files /dev/null and b/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.fzz differ diff --git a/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.png b/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.png new file mode 100644 index 0000000..b8af2ab Binary files /dev/null and b/gpio/dht_sensor/pi-and-pico-uart-and-dht-sensor.png differ diff --git a/gpio/dht_sensor/serial-output.png b/gpio/dht_sensor/serial-output.png new file mode 100644 index 0000000..a267cd3 Binary files /dev/null and b/gpio/dht_sensor/serial-output.png differ diff --git a/gpio/hello_7segment/CMakeLists.txt b/gpio/hello_7segment/CMakeLists.txt new file mode 100644 index 0000000..bb23d7f --- /dev/null +++ b/gpio/hello_7segment/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_7segment + hello_7segment.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_7segment pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_7segment) + +# add url via pico_set_program_url +example_auto_set_url(hello_7segment) \ No newline at end of file diff --git a/gpio/hello_7segment/README.adoc b/gpio/hello_7segment/README.adoc new file mode 100644 index 0000000..a6680c7 --- /dev/null +++ b/gpio/hello_7segment/README.adoc @@ -0,0 +1,50 @@ += Attaching a 7 segment LED via GPIO + +This example code shows how to interface the Raspberry Pi Pico to a generic 7 segment LED device. It uses the LED to count from 0 to 9 and then repeat. If the button is pressed, then the numbers will count down instead of up. + +== Wiring information + +Our 7 Segment display has pins as follows. + +---- + --A-- + F B + --G-- + E C + --D-- +---- + +By default we are allocating GPIO 2 to A, 3 to B etc. +So, connect GPIO 2 to pin A on the 7 segment LED display and so on. You will need the appropriate resistors (68 ohm should be fine) for each segment. +The LED device used here is common anode, so the anode pin is connected to the 3.3v supply, and the GPIO's need to pull low (to ground) to complete the circuit. +The pull direction of the GPIO's is specified in the code itself. + +Connect the switch to connect on pressing. One side should be connected to ground, the other to GPIO 9. + + +[[hello_7segment_wiring]] +[pdfwidth=75%] +.Wiring Diagram for 7 segment LED. +image::hello_7segment_bb.png[] + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +hello_7segment.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[hello_7segment-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| 7 segment LED module | 1 | generic part +| 68 ohm resistor | 7 | generic part +| DIL push to make switch | 1 | generic switch +| M/M Jumper wires | 10 | generic part +|=== + + diff --git a/gpio/hello_7segment/hello_7segment.c b/gpio/hello_7segment/hello_7segment.c new file mode 100644 index 0000000..2f375be --- /dev/null +++ b/gpio/hello_7segment/hello_7segment.c @@ -0,0 +1,95 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" + +/* + Our 7 Segment display has pins as follows: + + --A-- + F B + --G-- + E C + --D-- + + By default we are allocating GPIO 2 to A, 3 to B etc. + So, connect GOIP 2 to pin A on the 7 segment LED display etc. Don't forget + the appropriate resistors, best to use one for each segment! + + Connect button so that pressing the switch connects the GPIO 9 (default) to + ground (pull down) +*/ + +#define FIRST_GPIO 2 +#define BUTTON_GPIO (FIRST_GPIO+7) + +// This array converts a number 0-9 to a bit pattern to send to the GPIO's +int bits[10] = { + 0x3f, // 0 + 0x06, // 1 + 0x5b, // 2 + 0x4f, // 3 + 0x66, // 4 + 0x6d, // 5 + 0x7d, // 6 + 0x07, // 7 + 0x7f, // 8 + 0x67 // 9 +}; + +// tag::hello_gpio[] +int main() { + stdio_init_all(); + printf("Hello, 7segment - press button to count down!\n"); + + // We could use gpio_set_dir_out_masked() here + for (int gpio = FIRST_GPIO; gpio < FIRST_GPIO + 7; gpio++) { + gpio_init(gpio); + gpio_set_dir(gpio, GPIO_OUT); + // Our bitmap above has a bit set where we need an LED on, BUT, we are pulling low to light + // so invert our output + gpio_set_outover(gpio, GPIO_OVERRIDE_INVERT); + } + + gpio_init(BUTTON_GPIO); + gpio_set_dir(BUTTON_GPIO, GPIO_IN); + // We are using the button to pull down to 0v when pressed, so ensure that when + // unpressed, it uses internal pull ups. Otherwise when unpressed, the input will + // be floating. + gpio_pull_up(BUTTON_GPIO); + + int val = 0; + while (true) { + // Count upwards or downwards depending on button input + // We are pulling down on switch active, so invert the get to make + // a press count downwards + if (!gpio_get(BUTTON_GPIO)) { + if (val == 9) { + val = 0; + } else { + val++; + } + } else if (val == 0) { + val = 9; + } else { + val--; + } + + // We are starting with GPIO 2, our bitmap starts at bit 0 so shift to start at 2. + int32_t mask = bits[val] << FIRST_GPIO; + + // Set all our GPIO's in one go! + // If something else is using GPIO, we might want to use gpio_put_masked() + gpio_set_mask(mask); + sleep_ms(250); + gpio_clr_mask(mask); + } + + return 0; +} +// end::hello_gpio[] diff --git a/gpio/hello_7segment/hello_7segment.fzz b/gpio/hello_7segment/hello_7segment.fzz new file mode 100644 index 0000000..e068990 Binary files /dev/null and b/gpio/hello_7segment/hello_7segment.fzz differ diff --git a/gpio/hello_7segment/hello_7segment_bb.png b/gpio/hello_7segment/hello_7segment_bb.png new file mode 100644 index 0000000..7e6f469 Binary files /dev/null and b/gpio/hello_7segment/hello_7segment_bb.png differ diff --git a/gpio/hello_gpio_irq/CMakeLists.txt b/gpio/hello_gpio_irq/CMakeLists.txt new file mode 100644 index 0000000..d12019b --- /dev/null +++ b/gpio/hello_gpio_irq/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_gpio_irq + hello_gpio_irq.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_gpio_irq pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_gpio_irq) + +# add url via pico_set_program_url +example_auto_set_url(hello_gpio_irq) diff --git a/gpio/hello_gpio_irq/hello_gpio_irq.c b/gpio/hello_gpio_irq/hello_gpio_irq.c new file mode 100644 index 0000000..8c63ba6 --- /dev/null +++ b/gpio/hello_gpio_irq/hello_gpio_irq.c @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" + +static char event_str[128]; + +void gpio_event_string(char *buf, uint32_t events); + +void gpio_callback(uint gpio, uint32_t events) { + // Put the GPIO event(s) that just happened into event_str + // so we can print it + gpio_event_string(event_str, events); + printf("GPIO %d %s\n", gpio, event_str); +} + +int main() { + stdio_init_all(); + + printf("Hello GPIO IRQ\n"); + gpio_set_irq_enabled_with_callback(2, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true, &gpio_callback); + + // Wait forever + while (1); + + return 0; +} + + +static const char *gpio_irq_str[] = { + "LEVEL_LOW", // 0x1 + "LEVEL_HIGH", // 0x2 + "EDGE_FALL", // 0x4 + "EDGE_RISE" // 0x8 +}; + +void gpio_event_string(char *buf, uint32_t events) { + for (uint i = 0; i < 4; i++) { + uint mask = (1 << i); + if (events & mask) { + // Copy this event string into the user string + const char *event_str = gpio_irq_str[i]; + while (*event_str != '\0') { + *buf++ = *event_str++; + } + events &= ~mask; + + // If more events add ", " + if (events) { + *buf++ = ','; + *buf++ = ' '; + } + } + } + *buf++ = '\0'; +} \ No newline at end of file diff --git a/hello_world/CMakeLists.txt b/hello_world/CMakeLists.txt new file mode 100644 index 0000000..ca3f6a5 --- /dev/null +++ b/hello_world/CMakeLists.txt @@ -0,0 +1,4 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(usb) + add_subdirectory(serial) +endif () diff --git a/hello_world/serial/CMakeLists.txt b/hello_world/serial/CMakeLists.txt new file mode 100644 index 0000000..a9e48e1 --- /dev/null +++ b/hello_world/serial/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_serial + hello_serial.c + ) + +# Pull in our pico_stdlib which aggregates commonly used features +target_link_libraries(hello_serial pico_stdlib) + +# create map/bin/hex/uf2 file etc. +pico_add_extra_outputs(hello_serial) + +# add url via pico_set_program_url +example_auto_set_url(hello_serial) diff --git a/hello_world/serial/hello_serial.c b/hello_world/serial/hello_serial.c new file mode 100644 index 0000000..e9a011a --- /dev/null +++ b/hello_world/serial/hello_serial.c @@ -0,0 +1,17 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" + +int main() { + stdio_init_all(); + while (true) { + printf("Hello, world!\n"); + sleep_ms(1000); + } + return 0; +} diff --git a/hello_world/usb/CMakeLists.txt b/hello_world/usb/CMakeLists.txt new file mode 100644 index 0000000..dbe031a --- /dev/null +++ b/hello_world/usb/CMakeLists.txt @@ -0,0 +1,16 @@ +add_executable(hello_usb + hello_usb.c + ) + +# Pull in our pico_stdlib which aggregates commonly used features +target_link_libraries(hello_usb pico_stdlib) + +# enable usb output, disable uart output +pico_enable_stdio_usb(hello_usb 1) +pico_enable_stdio_uart(hello_usb 0) + +# create map/bin/hex/uf2 file etc. +pico_add_extra_outputs(hello_usb) + +# add url via pico_set_program_url +example_auto_set_url(hello_usb) diff --git a/hello_world/usb/hello_usb.c b/hello_world/usb/hello_usb.c new file mode 100644 index 0000000..e9a011a --- /dev/null +++ b/hello_world/usb/hello_usb.c @@ -0,0 +1,17 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" + +int main() { + stdio_init_all(); + while (true) { + printf("Hello, world!\n"); + sleep_ms(1000); + } + return 0; +} diff --git a/i2c/CMakeLists.txt b/i2c/CMakeLists.txt new file mode 100644 index 0000000..080153f --- /dev/null +++ b/i2c/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(bus_scan) + add_subdirectory(lcd_1602_i2c) + add_subdirectory(mpu6050_i2c) +endif () diff --git a/i2c/bus_scan/CMakeLists.txt b/i2c/bus_scan/CMakeLists.txt new file mode 100644 index 0000000..b3bc9dc --- /dev/null +++ b/i2c/bus_scan/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(i2c_bus_scan + bus_scan.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(i2c_bus_scan pico_stdlib hardware_i2c) + +# create map/bin/hex file etc. +pico_add_extra_outputs(i2c_bus_scan) + +# add url via pico_set_program_url +example_auto_set_url(i2c_bus_scan) diff --git a/i2c/bus_scan/bus_scan.c b/i2c/bus_scan/bus_scan.c new file mode 100644 index 0000000..326ca2d --- /dev/null +++ b/i2c/bus_scan/bus_scan.c @@ -0,0 +1,70 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Sweep through all 7-bit I2C addresses, to see if any slaves are present on +// the I2C bus. Print out a table that looks like this: +// +// I2C Bus Scan +// 0 1 2 3 4 5 6 7 8 9 A B C D E F +// 0 +// 1 @ +// 2 +// 3 @ +// 4 +// 5 +// 6 +// 7 +// +// E.g. if slave addresses 0x12 and 0x34 were acknowledged. + +#include +#include "pico/stdlib.h" +#include "hardware/i2c.h" + +// I2C reserves some addresses for special purposes. We exclude these from the scan. +// These are any addresses of the form 000 0xxx or 111 1xxx +bool reserved_addr(uint8_t addr) { + return (addr & 0x78) == 0 || (addr & 0x78) == 0x78; +} + +int main() { + // Enable UART so we can print status output + stdio_init_all(); + + // This example will use I2C0 on GPIO4 (SDA) and GPIO5 (SCL) + i2c_init(i2c0, 100 * 1000); + gpio_set_function(4, GPIO_FUNC_I2C); + gpio_set_function(5, GPIO_FUNC_I2C); + gpio_pull_up(4); + gpio_pull_up(5); + + printf("\nI2C Bus Scan\n"); + printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n"); + + for (int addr = 0; addr < (1 << 7); ++addr) { + if (addr % 16 == 0) { + printf("%02x ", addr); + } + + // Perform a 1-byte dummy read from the probe address. If a slave + // acknowledges this address, the function returns the number of bytes + // transferred. If the address byte is ignored, the function returns + // -1. + + // Skip over any reserved addresses. + int ret; + uint8_t rxdata; + if (reserved_addr(addr)) + ret = PICO_ERROR_GENERIC; + else + ret = i2c_read_blocking(i2c0, addr, &rxdata, 1, false); + + printf(ret < 0 ? "." : "@"); + printf(addr % 16 == 15 ? "\n" : " "); + } + printf("Done.\n"); + return 0; +} diff --git a/i2c/lcd_1602_i2c/CMakeLists.txt b/i2c/lcd_1602_i2c/CMakeLists.txt new file mode 100644 index 0000000..c4eaf9f --- /dev/null +++ b/i2c/lcd_1602_i2c/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(lcd_1602_i2c + lcd_1602_i2c.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(lcd_1602_i2c pico_stdlib hardware_i2c) + +# create map/bin/hex file etc. +pico_add_extra_outputs(lcd_1602_i2c) + +# add url via pico_set_program_url +example_auto_set_url(lcd_1602_i2c) \ No newline at end of file diff --git a/i2c/lcd_1602_i2c/README.adoc b/i2c/lcd_1602_i2c/README.adoc new file mode 100644 index 0000000..f6a6d8b --- /dev/null +++ b/i2c/lcd_1602_i2c/README.adoc @@ -0,0 +1,41 @@ += Attaching a 16x2 LCD via I2C + +This example code shows how to interface the Raspberry Pi Pico to one of the very common 16x2 LCD character displays. The display will need a 3.3V I2C adapter board as this example uses I2C for communications. + +[NOTE] +====== +These LCD displays can also be driven directly using GPIO without the use of an adapter board. That is beyond the scope of this example. +====== + +== Wiring information + +Wiring up the device requires 4 jumpers, to connect VCC (3.3v), GND, SDA and SCL. The example here uses I2C port 0, which is assigned to GPIO 4 (SDA) and 5 (SCL) in software. Power is supplied from the 3.3V pin. + +WARNING: Many displays of this type are 5v. If you wish to use a 5v display you will need to use level shifters on the SDA and SCL lines to convert from the 3.3V used by the RP2040. Whilst a 5v display will just about work at 3.3v, the display will be dim. + + +[[lcd_1602_i2c_wiring]] +[pdfwidth=75%] +.Wiring Diagram for LCD1602A LCD with I2C bridge. +image::lcd_1602_i2c_bb.png[] + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +lcd_1602_i2c.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[lcd_1602_i2c-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| 1602A based LCD panel 3.3v | 1 | generic part +| 1602A to I2C bridge device 3.3v | 1 | generic part +| M/M Jumper wires | 4 | generic part +|=== + + diff --git a/i2c/lcd_1602_i2c/lcd_1602_i2c.c b/i2c/lcd_1602_i2c/lcd_1602_i2c.c new file mode 100644 index 0000000..268d6c4 --- /dev/null +++ b/i2c/lcd_1602_i2c/lcd_1602_i2c.c @@ -0,0 +1,164 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#include "pico/stdlib.h" +#include "hardware/i2c.h" +#include "pico/binary_info.h" + +/* Example code to drive a 16x2 LCD panel via a I2C bridge chip (e.g. PCF8574) + + NOTE: The panel must be capable of being driven at 3.3v NOT 5v. The Pico + GPIO (and therefor I2C) cannot be used at 5v. + + You will need to use a level shifter on the I2C lines if you want to run the + board at 5v. + + Connections on Raspberry Pi Pico board, other boards may vary. + + GPIO 4 (pin 6)-> SDA on LCD bridge board + GPIO 5 (pin 7)-> SCL on LCD bridge board + 3.3v (pin 36) -> VCC on LCD bridge board + GND (pin 38) -> GND on LCD bridge board +*/ +// commands +const int LCD_CLEARDISPLAY = 0x01; +const int LCD_RETURNHOME = 0x02; +const int LCD_ENTRYMODESET = 0x04; +const int LCD_DISPLAYCONTROL = 0x08; +const int LCD_CURSORSHIFT = 0x10; +const int LCD_FUNCTIONSET = 0x20; +const int LCD_SETCGRAMADDR = 0x40; +const int LCD_SETDDRAMADDR = 0x80; + +// flags for display entry mode +const int LCD_ENTRYSHIFTINCREMENT = 0x01; +const int LCD_ENTRYLEFT = 0x02; + +// flags for display and cursor control +const int LCD_BLINKON = 0x01; +const int LCD_CURSORON = 0x02; +const int LCD_DISPLAYON = 0x04; + +// flags for display and cursor shift +const int LCD_MOVERIGHT = 0x04; +const int LCD_DISPLAYMOVE = 0x08; + +// flags for function set +const int LCD_5x10DOTS = 0x04; +const int LCD_2LINE = 0x08; +const int LCD_8BITMODE = 0x10; + +// flag for backlight control +const int LCD_BACKLIGHT = 0x08; + +const int LCD_ENABLE_BIT = 0x04; + +#define I2C_PORT i2c0 +// By default these LCD display drivers are on bus address 0x27 +static int addr = 0x27; + +// Modes for lcd_send_byte +#define LCD_CHARACTER 1 +#define LCD_COMMAND 0 + +#define MAX_LINES 2 +#define MAX_CHARS 16 + +/* Quick helper function for single byte transfers */ +void i2c_write_byte(uint8_t val) { + i2c_write_blocking(I2C_PORT, addr, &val, 1, false); +} + +void lcd_toggle_enable(uint8_t val) { + // Toggle enable pin on LCD display + // We cannot do this too quickly or things don't work +#define DELAY_US 600 + sleep_us(DELAY_US); + i2c_write_byte(val | LCD_ENABLE_BIT); + sleep_us(DELAY_US); + i2c_write_byte(val & ~LCD_ENABLE_BIT); + sleep_us(DELAY_US); +} + +// The display is sent a byte as two separate nibble transfers +void lcd_send_byte(uint8_t val, int mode) { + uint8_t high = mode | (val & 0xF0) | LCD_BACKLIGHT; + uint8_t low = mode | ((val << 4) & 0xF0) | LCD_BACKLIGHT; + + i2c_write_byte(high); + lcd_toggle_enable(high); + i2c_write_byte(low); + lcd_toggle_enable(low); +} + +void lcd_clear(void) { + lcd_send_byte(LCD_CLEARDISPLAY, LCD_COMMAND); +} + +// go to location on LCD +void lcd_set_cursor(int line, int position) { + int val = (line == 0) ? 0x80 + position : 0xC0 + position; + lcd_send_byte(val, LCD_COMMAND); +} + +static void inline lcd_char(char val) { + lcd_send_byte(val, LCD_CHARACTER); +} + +void lcd_string(const char *s) { + while (*s) { + lcd_char(*s++); + } +} + +void lcd_init() { + lcd_send_byte(0x03, LCD_COMMAND); + lcd_send_byte(0x03, LCD_COMMAND); + lcd_send_byte(0x03, LCD_COMMAND); + lcd_send_byte(0x02, LCD_COMMAND); + + lcd_send_byte(LCD_ENTRYMODESET | LCD_ENTRYLEFT, LCD_COMMAND); + lcd_send_byte(LCD_FUNCTIONSET | LCD_2LINE, LCD_COMMAND); + lcd_send_byte(LCD_DISPLAYCONTROL | LCD_DISPLAYON, LCD_COMMAND); + lcd_clear(); +} + +int main() { + // This example will use I2C0 on GPIO4 (SDA) and GPIO5 (SCL) + i2c_init(I2C_PORT, 100 * 1000); + gpio_set_function(4, GPIO_FUNC_I2C); + gpio_set_function(5, GPIO_FUNC_I2C); + gpio_pull_up(4); + gpio_pull_up(5); + // Make the I2C pins available to picotool + bi_decl( bi_2pins_with_func(4, 5, GPIO_FUNC_I2C)); + + lcd_init(); + + static uint8_t *message[] = + { + "RP2040 by", "Raspberry Pi", + "A brand new", "microcontroller", + "Twin core M0", "Full C SDK", + "More power in", "your product", + "More beans", "than Heinz!" + }; + + while (1) { + for (int m = 0; m < sizeof(message) / sizeof(message[0]); m += MAX_LINES) { + for (int line = 0; line < MAX_LINES; line++) { + lcd_set_cursor(line, (MAX_CHARS / 2) - strlen(message[m + line]) / 2); + lcd_string(message[m + line]); + } + sleep_ms(2000); + lcd_clear(); + } + } + + return 0; +} diff --git a/i2c/lcd_1602_i2c/lcd_1602_i2c.fzz b/i2c/lcd_1602_i2c/lcd_1602_i2c.fzz new file mode 100644 index 0000000..66629d9 Binary files /dev/null and b/i2c/lcd_1602_i2c/lcd_1602_i2c.fzz differ diff --git a/i2c/lcd_1602_i2c/lcd_1602_i2c_bb.png b/i2c/lcd_1602_i2c/lcd_1602_i2c_bb.png new file mode 100644 index 0000000..98106cb Binary files /dev/null and b/i2c/lcd_1602_i2c/lcd_1602_i2c_bb.png differ diff --git a/i2c/mpu6050_i2c/CMakeLists.txt b/i2c/mpu6050_i2c/CMakeLists.txt new file mode 100644 index 0000000..e898856 --- /dev/null +++ b/i2c/mpu6050_i2c/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(mpu6050_i2c + mpu6050_i2c.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(mpu6050_i2c pico_stdlib hardware_i2c) + +# create map/bin/hex file etc. +pico_add_extra_outputs(mpu6050_i2c) + +# add url via pico_set_program_url +example_auto_set_url(mpu6050_i2c) diff --git a/i2c/mpu6050_i2c/README.adoc b/i2c/mpu6050_i2c/README.adoc new file mode 100644 index 0000000..f0fde51 --- /dev/null +++ b/i2c/mpu6050_i2c/README.adoc @@ -0,0 +1,43 @@ += Attaching a MPU6050 accelerometer/gyroscope via I2C + +This example code shows how to interface the Raspberry Pi Pico to the MPU6050 accelerometer/gyroscope board. This device uses I2C for communications, and most MPU6050 parts are happy running at either 3.3 or 5v. The Raspberry Pi RP2040 GPIO's work at 3.3v so that is what the example uses. + +[NOTE] +====== +This is a very basic example, and only recovers raw data from the sensor. There are various calibration options available that should be used to ensure that the final results are accurate. It is also possible to wire up the interrupt pin to a GPIO and read data only when it is ready, rather than using the polling approach in the example. +====== + +== Wiring information + +Wiring up the device requires 4 jumpers, to connect VCC (3.3v), GND, SDA and SCL. The example here uses I2C port 0, which is assigned to GPIO 4 (SDA) and 5 (SCL) in software. Power is supplied from the 3.3V pin. + +[NOTE] +====== +There are many different manufacturers who sell boards with the MPU6050. Whilst they all appear slightly different, they all have, at least, the same 4 pins required to power and communicate. When wiring up a board that is different to the one in the diagram, ensure you connect up as described in the previous paragraph. +====== + + +[[mpu6050_i2c_wiring]] +[pdfwidth=75%] +.Wiring Diagram for MPU6050. +image::mpu6050_i2c_bb.png[] + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +mpu6050_i2c.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[mpu6050-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| MPU6050 board| 1 | generic part +| M/M Jumper wires | 4 | generic part +|=== + + diff --git a/i2c/mpu6050_i2c/mpu6050_i2c.c b/i2c/mpu6050_i2c/mpu6050_i2c.c new file mode 100644 index 0000000..f47a0a1 --- /dev/null +++ b/i2c/mpu6050_i2c/mpu6050_i2c.c @@ -0,0 +1,110 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#include "pico/stdlib.h" +#include "hardware/i2c.h" + +/* Example code to talk to a MPU6050 MEMS accelerometer and gyroscope + + This is taking to simple approach of simply reading registers. It's perfectly + possible to link up an interrupt line and set things up to read from the + inbuilt FIFO to make it more useful. + + NOTE: Ensure the device is capable of being driven at 3.3v NOT 5v. The Pico + GPIO (and therefor I2C) cannot be used at 5v. + + You will need to use a level shifter on the I2C lines if you want to run the + board at 5v. + + Connections on Raspberry Pi Pico board, other boards may vary. + + GPIO 4 (pin 6)-> SDA on MPU6050 board + GPIO 5 (pin 7)-> SCL on MPU6050 board + 3.3v (pin 36) -> VCC on MPU6050 board + GND (pin 38) -> GND on MPU6050 board +*/ + +// By default these devices are on bus address 0x68 +static int addr = 0x68; + +#define I2C_PORT i2c0 + +static void mpu6050_reset() { + // Two byte reset. First byte register, second byte data + // There are a load more options to set up the device in different ways that could be added here + uint8_t buf[] = {0x6B, 0x00}; + i2c_write_blocking(I2C_PORT, addr, buf, 2, false); +} + +static void mpu6050_read_raw(int16_t accel[3], int16_t gyro[3], int16_t *temp) { + // For this particular device, we send the device the register we want to read + // first, then subsequently read from the device. The register is auto incrementing + // so we don't need to keep sending the register we want, just the first. + + uint8_t buffer[6]; + + // Start reading acceleration registers from register 0x3B for 6 bytes + uint8_t val = 0x3B; + i2c_write_blocking(I2C_PORT, addr, &val, 1, true); // true to keep master control of bus + i2c_read_blocking(I2C_PORT, addr, buffer, 6, false); + + for (int i = 0; i < 3; i++) { + accel[i] = (buffer[i * 2] << 8 | buffer[(i * 2) + 1]); + } + + // Now gyro data from reg 0x43 for 6 bytes + // The register is auto incrementing on each read + val = 0x43; + i2c_write_blocking(I2C_PORT, addr, &val, 1, true); + i2c_read_blocking(I2C_PORT, addr, buffer, 6, false); // False - finished with bus + + for (int i = 0; i < 3; i++) { + gyro[i] = (buffer[i * 2] << 8 | buffer[(i * 2) + 1]);; + } + + // Now temperature from reg 0x41 for 2 bytes + // The register is auto incrementing on each read + val = 0x41; + i2c_write_blocking(I2C_PORT, addr, &val, 1, true); + i2c_read_blocking(I2C_PORT, addr, buffer, 2, false); // False - finished with bus + + *temp = buffer[0] << 8 | buffer[1]; +} + +int main() { + stdio_init_all(); + + printf("Hello, MPU6050! Reading raw data from registers...\n"); + + // This example will use I2C0 on GPIO4 (SDA) and GPIO5 (SCL) running at 400kHz. + i2c_init(I2C_PORT, 400 * 1000); + gpio_set_function(4, GPIO_FUNC_I2C); + gpio_set_function(5, GPIO_FUNC_I2C); + gpio_pull_up(4); + gpio_pull_up(5); + + mpu6050_reset(); + + int16_t acceleration[3], gyro[3], temp; + + while (1) { + mpu6050_read_raw(acceleration, gyro, &temp); + + // These are the raw numbers from the chip, so will need tweaking to be really useful. + // See the datasheet for more information + printf("Acc. X = %d, Y = %d, Z = %d\n", acceleration[0], acceleration[1], acceleration[2]); + printf("Gyro. X = %d, Y = %d, Z = %d\n", gyro[0], gyro[1], gyro[2]); + // Temperature is simple so use the datasheet calculation to get deg C. + // Note this is chip temperature. + printf("Temp. = %f\n", (temp / 340.0) + 36.53); + + sleep_ms(100); + } + + return 0; +} diff --git a/i2c/mpu6050_i2c/mpu6050_i2c.fzz b/i2c/mpu6050_i2c/mpu6050_i2c.fzz new file mode 100644 index 0000000..e23a554 Binary files /dev/null and b/i2c/mpu6050_i2c/mpu6050_i2c.fzz differ diff --git a/i2c/mpu6050_i2c/mpu6050_i2c_bb.png b/i2c/mpu6050_i2c/mpu6050_i2c_bb.png new file mode 100644 index 0000000..782a38b Binary files /dev/null and b/i2c/mpu6050_i2c/mpu6050_i2c_bb.png differ diff --git a/ide/vscode/launch-raspberrypi-swd.json b/ide/vscode/launch-raspberrypi-swd.json new file mode 100644 index 0000000..870ddae --- /dev/null +++ b/ide/vscode/launch-raspberrypi-swd.json @@ -0,0 +1,27 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Pico Debug", + "cwd": "${workspaceRoot}", + "executable": "${command:cmake.launchTargetPath}", + "request": "launch", + "type": "cortex-debug", + "servertype": "openocd", + // This may need to be arm-none-eabi-gdb depending on your system + "gdbpath" : "gdb-multiarch", + "device": "RP2040", + "configFiles": [ + "interface/raspberrypi-swd.cfg", + "target/rp2040.cfg" + ], + "svdFile": "/home/pi/pico/pico-sdk/src/rp2040/hardware_regs/rp2040.svd", + "runToMain": true, + // Work around for stopping at main on restart + "postRestartCommands": [ + "break main", + "continue" + ] + } + ] +} diff --git a/ide/vscode/launch-remote-openocd.json b/ide/vscode/launch-remote-openocd.json new file mode 100644 index 0000000..3b5eed8 --- /dev/null +++ b/ide/vscode/launch-remote-openocd.json @@ -0,0 +1,24 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Pico Debug", + "type":"cortex-debug", + "cwd": "${workspaceRoot}", + "executable": "${command:cmake.launchTargetPath}", + "request": "launch", + "servertype": "external", + // This may need to be arm-none-eabi-gdb depending on your system + "gdbpath" : "gdb-multiarch", + // Connect to an already running OpenOCD instance + "gdbTarget": "your-openocd:3333", + "svdFile": "/home/liam/pico/pico-sdk/src/rp2040/hardware_regs/rp2040.svd", + "runToMain": true, + // Work around for stopping at main on restart + "postRestartCommands": [ + "break main", + "continue" + ] + } + ] +} \ No newline at end of file diff --git a/ide/vscode/settings.json b/ide/vscode/settings.json new file mode 100644 index 0000000..c8489b4 --- /dev/null +++ b/ide/vscode/settings.json @@ -0,0 +1,21 @@ +{ + // These settings tweaks to the cmake plugin will ensure + // that you debug using cortex-debug instead of trying to launch + // a Pico binary on the host + "cmake.statusbar.advanced": { + "debug": { + "visibility": "hidden" + }, + "launch": { + "visibility": "hidden" + }, + "build": { + "visibility": "hidden" + }, + "buildTarget": { + "visibility": "hidden" + } + }, + "cmake.buildBeforeRun": true, + "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools" +} \ No newline at end of file diff --git a/interp/CMakeLists.txt b/interp/CMakeLists.txt new file mode 100644 index 0000000..8261d1b --- /dev/null +++ b/interp/CMakeLists.txt @@ -0,0 +1,3 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_interp) +endif () diff --git a/interp/hello_interp/CMakeLists.txt b/interp/hello_interp/CMakeLists.txt new file mode 100644 index 0000000..4df3df2 --- /dev/null +++ b/interp/hello_interp/CMakeLists.txt @@ -0,0 +1,14 @@ +if (TARGET hardware_interp) + add_executable(hello_interp + hello_interp.c + ) + + # Pull in dependencies + target_link_libraries(hello_interp pico_stdlib hardware_interp) + + # create map/bin/hex file etc. + pico_add_extra_outputs(hello_interp) + + # add url via pico_set_program_url + example_auto_set_url(hello_interp) +endif () \ No newline at end of file diff --git a/interp/hello_interp/hello_interp.c b/interp/hello_interp/hello_interp.c new file mode 100644 index 0000000..3c3bf6e --- /dev/null +++ b/interp/hello_interp/hello_interp.c @@ -0,0 +1,286 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/interp.h" + +void times_table() { + puts("9 times table:"); + + // Initialise lane 0 on interp0 on this core + interp_config cfg = interp_default_config(); + interp_set_config(interp0, 0, &cfg); + + interp0->accum[0] = 0; + interp0->base[0] = 9; + + for (int i = 0; i < 10; ++i) + printf("%d\n", interp0->pop[0]); +} + +void moving_mask() { + interp_config cfg = interp_default_config(); + interp0->accum[0] = 0x1234abcd; + + puts("Masking:"); + printf("ACCUM0 = %08x\n", interp0->accum[0]); + for (int i = 0; i < 8; ++i) { + // LSB, then MSB. These are inclusive, so 0,31 means "the entire 32 bit register" + interp_config_set_mask(&cfg, i * 4, i * 4 + 3); + interp_set_config(interp0, 0, &cfg); + // Reading from ACCUMx_ADD returns the raw lane shift and mask value, without BASEx added + printf("Nibble %d: %08x\n", i, interp0->add_raw[0]); + } + + puts("Masking with sign extension:"); + interp_config_set_signed(&cfg, true); + for (int i = 0; i < 8; ++i) { + interp_config_set_mask(&cfg, i * 4, i * 4 + 3); + interp_set_config(interp0, 0, &cfg); + printf("Nibble %d: %08x\n", i, interp0->add_raw[0]); + } +} + +void cross_lanes() { + interp_config cfg = interp_default_config(); + interp_config_set_cross_result(&cfg, true); + // ACCUM0 gets lane 1 result: + interp_set_config(interp0, 0, &cfg); + // ACCUM1 gets lane 0 result: + interp_set_config(interp0, 1, &cfg); + + interp0->accum[0] = 123; + interp0->accum[1] = 456; + interp0->base[0] = 1; + interp0->base[1] = 0; + puts("Lane result crossover:"); + for (int i = 0; i < 10; ++i) + printf("PEEK0, POP1: %d, %d\n", interp0->peek[0], interp0->pop[1]); +} + +void simple_blend1() { + puts("Simple blend 1:"); + + interp_config cfg = interp_default_config(); + interp_config_set_blend(&cfg, true); + interp_set_config(interp0, 0, &cfg); + + cfg = interp_default_config(); + interp_set_config(interp0, 1, &cfg); + + interp0->base[0] = 500; + interp0->base[1] = 1000; + + for (int i = 0; i <= 6; i++) { + // set fraction to value between 0 and 255 + interp0->accum[1] = 255 * i / 6; + // ≈ 500 + (1000 - 500) * i / 6; + printf("%d\n", (int) interp0->peek[1]); + } +} + +/// \tag::simple_blend2[] +void print_simple_blend2_results(bool is_signed) { + // lane 1 signed flag controls whether base 0/1 are treated as signed or unsigned + interp_config cfg = interp_default_config(); + interp_config_set_signed(&cfg, is_signed); + interp_set_config(interp0, 1, &cfg); + + for (int i = 0; i <= 6; i++) { + interp0->accum[1] = 255 * i / 6; + if (is_signed) { + printf("%d\n", (int) interp0->peek[1]); + } else { + printf("0x%08x\n", (uint) interp0->peek[1]); + } + } +} + +void simple_blend2() { + puts("Simple blend 2:"); + + interp_config cfg = interp_default_config(); + interp_config_set_blend(&cfg, true); + interp_set_config(interp0, 0, &cfg); + + interp0->base[0] = -1000; + interp0->base[1] = 1000; + + puts("signed:"); + print_simple_blend2_results(true); + + puts("unsigned:"); + print_simple_blend2_results(false); +} +/// \end::simple_blend2[] + +void simple_blend3() { + puts("Simple blend 3:"); + + interp_config cfg = interp_default_config(); + interp_config_set_blend(&cfg, true); + interp_set_config(interp0, 0, &cfg); + + cfg = interp_default_config(); + interp_set_config(interp0, 1, &cfg); + + interp0->accum[1] = 128; + interp0->base01 = 0x30005000; + printf("0x%08x\n", (int) interp0->peek[1]); + interp0->base01 = 0xe000f000; + printf("0x%08x\n", (int) interp0->peek[1]); + + interp_config_set_signed(&cfg, true); + interp_set_config(interp0, 1, &cfg); + + interp0->base01 = 0xe000f000; + printf("0x%08x\n", (int) interp0->peek[1]); +} + +void linear_interpolation() { + puts("Linear interpolation:"); + const int uv_fractional_bits = 12; + + // for lane 0 + // shift and mask XXXX XXXX XXXX XXXX XXXX FFFF FFFF FFFF (accum 0) + // to 0000 0000 000X XXXX XXXX XXXX XXXX XXX0 + // i.e. non fractional part times 2 (for uint16_t) + interp_config cfg = interp_default_config(); + interp_config_set_shift(&cfg, uv_fractional_bits - 1); + interp_config_set_mask(&cfg, 1, 32 - uv_fractional_bits); + interp_config_set_blend(&cfg, true); + interp_set_config(interp0, 0, &cfg); + + // for lane 1 + // shift XXXX XXXX XXXX XXXX XXXX FFFF FFFF FFFF (accum 0 via cross input) + // to 0000 XXXX XXXX XXXX XXXX FFFF FFFF FFFF + + cfg = interp_default_config(); + interp_config_set_shift(&cfg, uv_fractional_bits - 8); + interp_config_set_signed(&cfg, true); + interp_config_set_cross_input(&cfg, true); // signed blending + interp_set_config(interp0, 1, &cfg); + + int16_t samples[] = {0, 10, -20, -1000, 500}; + + // step is 1/4 in our fractional representation + uint step = (1 << uv_fractional_bits) / 4; + + interp0->accum[0] = 0; // initial sample_offset; + interp0->base[2] = (uintptr_t) samples; + for (int i = 0; i < 16; i++) { + // result2 = samples + (lane0 raw result) + // i.e. ptr to the first of two samples to blend between + int16_t *sample_pair = (int16_t *) interp0->peek[2]; + interp0->base[0] = sample_pair[0]; + interp0->base[1] = sample_pair[1]; + printf("%d\t(%d%% between %d and %d)\n", (int) interp0->peek[1], + 100 * (interp0->add_raw[1] & 0xff) / 0xff, + sample_pair[0], sample_pair[1]); + interp0->add_raw[0] = step; + } +} + +void clamp() { + puts("Clamp:"); + interp_config cfg = interp_default_config(); + interp_config_set_clamp(&cfg, true); + interp_config_set_shift(&cfg, 2); + // set mask according to new position of sign bit.. + interp_config_set_mask(&cfg, 0, 29); + // ...so that the shifted value is correctly sign extended + interp_config_set_signed(&cfg, true); + interp_set_config(interp1, 0, &cfg); + + interp1->base[0] = 0; + interp1->base[1] = 255; + + for (int i = -1024; i <= 1024; i += 256) { + interp1->accum[0] = i; + printf("%d\t%d\n", i, (int) interp1->peek[0]); + } +} + +/// \tag::texture_mapping[] +void texture_mapping_setup(uint8_t *texture, uint texture_width_bits, uint texture_height_bits, + uint uv_fractional_bits) { + interp_config cfg = interp_default_config(); + // set add_raw flag to use raw (un-shifted and un-masked) lane accumulator value when adding + // it to the the lane base to make the lane result + interp_config_set_add_raw(&cfg, true); + interp_config_set_shift(&cfg, uv_fractional_bits); + interp_config_set_mask(&cfg, 0, texture_width_bits - 1); + interp_set_config(interp0, 0, &cfg); + + interp_config_set_shift(&cfg, uv_fractional_bits - texture_width_bits); + interp_config_set_mask(&cfg, texture_width_bits, texture_width_bits + texture_height_bits - 1); + interp_set_config(interp0, 1, &cfg); + + interp0->base[2] = (uintptr_t) texture; +} + +void texture_mapped_span(uint8_t *output, uint32_t u, uint32_t v, uint32_t du, uint32_t dv, uint count) { + // u, v are texture coordinates in fixed point with uv_fractional_bits fractional bits + // du, dv are texture coordinate steps across the span in same fixed point. + interp0->accum[0] = u; + interp0->base[0] = du; + interp0->accum[1] = v; + interp0->base[1] = dv; + for (uint i = 0; i < count; i++) { + // equivalent to + // uint32_t sm_result0 = (accum0 >> uv_fractional_bits) & (1 << (texture_width_bits - 1); + // uint32_t sm_result1 = (accum1 >> uv_fractional_bits) & (1 << (texture_height_bits - 1); + // uint8_t *address = texture + sm_result0 + (sm_result1 << texture_width_bits); + // output[i] = *address; + // accum0 = du + accum0; + // accum1 = dv + accum1; + + // result2 is the texture address for the current pixel; + // popping the result advances to the next iteration + output[i] = *(uint8_t *) interp0->pop[2]; + } +} + +void texture_mapping() { + puts("Affine Texture mapping (with texture wrap):"); + + uint8_t texture[] = { + 0x00, 0x01, 0x02, 0x03, + 0x10, 0x11, 0x12, 0x13, + 0x20, 0x21, 0x22, 0x23, + 0x30, 0x31, 0x32, 0x33, + }; + // 4x4 texture + texture_mapping_setup(texture, 2, 2, 16); + uint8_t output[12]; + uint32_t du = 65536 / 2; // step of 1/2 + uint32_t dv = 65536 / 3; // step of 1/3 + texture_mapped_span(output, 0, 0, du, dv, 12); + + for (uint i = 0; i < 12; i++) { + printf("0x%02x\n", output[i]); + } +} +/// \end::texture_mapping[] + +int main() { + stdio_init_all(); + puts("Interpolator example"); + + times_table(); + moving_mask(); + cross_lanes(); + simple_blend1(); + simple_blend2(); + simple_blend3(); + clamp(); + + linear_interpolation(); + texture_mapping(); + + return 0; +} \ No newline at end of file diff --git a/multicore/CMakeLists.txt b/multicore/CMakeLists.txt new file mode 100644 index 0000000..ea7420d --- /dev/null +++ b/multicore/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_multicore) + add_subdirectory(multicore_runner) + add_subdirectory(multicore_fifo_irqs) +endif () \ No newline at end of file diff --git a/multicore/hello_multicore/CMakeLists.txt b/multicore/hello_multicore/CMakeLists.txt new file mode 100644 index 0000000..540d679 --- /dev/null +++ b/multicore/hello_multicore/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(hello_multicore + multicore.c + ) + +# Add pico_multicore which is required for multicore functionality +target_link_libraries(hello_multicore + pico_stdlib + pico_multicore) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_multicore) + +# add url via pico_set_program_url +example_auto_set_url(hello_multicore) \ No newline at end of file diff --git a/multicore/hello_multicore/multicore.c b/multicore/hello_multicore/multicore.c new file mode 100644 index 0000000..db4360c --- /dev/null +++ b/multicore/hello_multicore/multicore.c @@ -0,0 +1,48 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "pico/multicore.h" + +#define FLAG_VALUE 123 + +void core1_entry() { + + multicore_fifo_push_blocking(FLAG_VALUE); + + uint32_t g = multicore_fifo_pop_blocking(); + + if (g != FLAG_VALUE) + printf("Hmm, that's not right on core 1!\n"); + else + printf("Its all gone well on core 1!"); + + while (1) + tight_loop_contents(); +} + +int main() { + stdio_init_all(); + printf("Hello, multicore!\n"); + + ///tag::setup_multicore[] + + multicore_launch_core1(core1_entry); + + // Wait for it to start up + + uint32_t g = multicore_fifo_pop_blocking(); + + if (g != FLAG_VALUE) + printf("Hmm, that's not right on core 0!\n"); + else { + multicore_fifo_push_blocking(FLAG_VALUE); + printf("It's all gone well on core 0!"); + } + + ///end::setup_multicore[] +} \ No newline at end of file diff --git a/multicore/multicore_fifo_irqs/CMakeLists.txt b/multicore/multicore_fifo_irqs/CMakeLists.txt new file mode 100644 index 0000000..aa1097e --- /dev/null +++ b/multicore/multicore_fifo_irqs/CMakeLists.txt @@ -0,0 +1,13 @@ +add_executable(multicore_fifo_irqs + multicore_fifo_irqs.c + ) + +target_link_libraries(multicore_fifo_irqs + pico_multicore + pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(multicore_fifo_irqs) + +# add url via pico_set_program_url +example_auto_set_url(multicore_fifo_irqs) \ No newline at end of file diff --git a/multicore/multicore_fifo_irqs/multicore_fifo_irqs.c b/multicore/multicore_fifo_irqs/multicore_fifo_irqs.c new file mode 100644 index 0000000..d295435 --- /dev/null +++ b/multicore/multicore_fifo_irqs/multicore_fifo_irqs.c @@ -0,0 +1,76 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "pico/multicore.h" +#include "hardware/irq.h" + +///tag::multicore_fifo_irqs[] + +#define FLAG_VALUE1 123 +#define FLAG_VALUE2 321 + +static int core0_rx_val = 0, core1_rx_val = 0; + +void core0_sio_irq() { + // Just record the latest entry + while (multicore_fifo_rvalid()) + core0_rx_val = multicore_fifo_pop_blocking(); + + multicore_fifo_clear_irq(); +} + +void core1_sio_irq() { + // Just record the latest entry + while (multicore_fifo_rvalid()) + core1_rx_val = multicore_fifo_pop_blocking(); + + multicore_fifo_clear_irq(); +} + +void core1_entry() { + multicore_fifo_clear_irq(); + irq_set_exclusive_handler(SIO_IRQ_PROC1, core1_sio_irq); + + irq_set_enabled(SIO_IRQ_PROC1, true); + + // Send something to Core0, this should fire the interrupt. + multicore_fifo_push_blocking(FLAG_VALUE1); + + while (1) + tight_loop_contents(); +} + + +int main() { + stdio_init_all(); + printf("Hello, multicore_fifo_irqs!\n"); + + // We MUST start the other core before we enabled FIFO interrupts. + // This is because the launch uses the FIFO's, enabling interrupts before + // they are used for the launch will result in unexpected behaviour. + multicore_launch_core1(core1_entry); + + irq_set_exclusive_handler(SIO_IRQ_PROC0, core0_sio_irq); + irq_set_enabled(SIO_IRQ_PROC0, true); + + // Wait for a bit for things to happen + sleep_ms(10); + + // Send something back to the other core + multicore_fifo_push_blocking(FLAG_VALUE2); + + // Wait for a bit for things to happen + sleep_ms(10); + + printf("Irq handlers should have rx'd some stuff - core 0 got %d, core 1 got %d!\n", core0_rx_val, core1_rx_val); + + while (1) + tight_loop_contents(); +} + +///end::multicore_fifo_irqs[] diff --git a/multicore/multicore_runner/CMakeLists.txt b/multicore/multicore_runner/CMakeLists.txt new file mode 100644 index 0000000..a96db31 --- /dev/null +++ b/multicore/multicore_runner/CMakeLists.txt @@ -0,0 +1,13 @@ +add_executable(multicore_runner + multicore_runner.c + ) + +target_link_libraries(multicore_runner + pico_multicore + pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(multicore_runner) + +# add url via pico_set_program_url +example_auto_set_url(multicore_runner) \ No newline at end of file diff --git a/multicore/multicore_runner/multicore_runner.c b/multicore/multicore_runner/multicore_runner.c new file mode 100644 index 0000000..624128a --- /dev/null +++ b/multicore/multicore_runner/multicore_runner.c @@ -0,0 +1,83 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "pico/multicore.h" + +///tag::multicore_dispatch[] + +#define FLAG_VALUE 123 + +void core1_entry() { + while (1) { + // Function pointer is passed to us via the FIFO + // We have one incoming int32_t as a parameter, and will provide an + // int32_t return value by simply pushing it back on the FIFO + // which also indicates the result is ready. + int32_t (*func)() = (int32_t(*)()) multicore_fifo_pop_blocking(); + int32_t p = multicore_fifo_pop_blocking(); + int32_t result = (*func)(p); + multicore_fifo_push_blocking(result); + } +} + +int32_t factorial(int32_t n) { + int32_t f = 1; + for (int i = 2; i <= n; i++) { + f *= i; + } + return f; +} + +int32_t fibonacci(int32_t n) { + if (n == 0) return 0; + if (n == 1) return 1; + + int n1 = 0, n2 = 1, n3; + + for (int i = 2; i <= n; i++) { + n3 = n1 + n2; + n1 = n2; + n2 = n3; + } + return n3; +} + +#define TEST_NUM 10 + +int main() { + int res; + + stdio_init_all(); + printf("Hello, multicore_runner!\n"); + + // This example dispatches arbitrary functions to run on the second core + // To do this we run a dispatcher on the second core that accepts a function + // pointer and runs it + multicore_launch_core1(core1_entry); + + multicore_fifo_push_blocking((uintptr_t) &factorial); + multicore_fifo_push_blocking(TEST_NUM); + + // We could now do a load of stuff on core 0 and get our result later + + res = multicore_fifo_pop_blocking(); + + printf("Factorial %d is %d\n", TEST_NUM, res); + + // Now try a different function + multicore_fifo_push_blocking((uintptr_t) &fibonacci); + multicore_fifo_push_blocking(TEST_NUM); + + res = multicore_fifo_pop_blocking(); + + printf("Fibonacci %d is %d\n", TEST_NUM, res); + + +} + +///end::multicore_dispatch[] diff --git a/pico_sdk_import.cmake b/pico_sdk_import.cmake new file mode 100644 index 0000000..f63ee3f --- /dev/null +++ b/pico_sdk_import.cmake @@ -0,0 +1,64 @@ +# This is a copy of /external/pico_sdk_import.cmake + +# This can be dropped into an external project to help locate this SDK +# It should be include()ed prior to project() + +# todo document + +if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH)) + set(PICO_SDK_PATH $ENV{PICO_SDK_PATH}) + message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')") +endif () + +if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT} AND (NOT PICO_SDK_FETCH_FROM_GIT)) + set(PICO_SDK_FETCH_FROM_GIT $ENV{PICO_SDK_FETCH_FROM_GIT}) + message("Using PICO_SDK_FETCH_FROM_GIT from environment ('${PICO_SDK_FETCH_FROM_GIT}')") +endif () + +if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_PATH)) + set(PICO_SDK_FETCH_FROM_GIT_PATH $ENV{PICO_SDK_FETCH_FROM_GIT_PATH}) + message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')") +endif () + +set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the PICO SDK") +set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of PICO SDK from git if not otherwise locatable") +set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK") + +if (NOT PICO_SDK_PATH) + if (PICO_SDK_FETCH_FROM_GIT) + include(FetchContent) + set(FETCHCONTENT_BASE_DIR_SAVE ${FETCHCONTENT_BASE_DIR}) + if (PICO_SDK_FETCH_FROM_GIT_PATH) + get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_SDK_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}") + endif () + FetchContent_Declare( + pico_sdk + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG master + ) + if (NOT pico_sdk) + message("Downloading PICO SDK") + FetchContent_Populate(pico_sdk) + set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR}) + endif () + set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE}) + else () + message(FATAL_ERROR + "PICO SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git." + ) + endif () +endif () + +get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}") +if (NOT EXISTS ${PICO_SDK_PATH}) + message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' not found") +endif () + +set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake) +if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE}) + message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the PICO SDK") +endif () + +set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the PICO SDK" FORCE) + +include(${PICO_SDK_INIT_CMAKE_FILE}) diff --git a/picoboard/CMakeLists.txt b/picoboard/CMakeLists.txt new file mode 100644 index 0000000..3aaf099 --- /dev/null +++ b/picoboard/CMakeLists.txt @@ -0,0 +1,4 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(blinky) + add_subdirectory(button) +endif () diff --git a/picoboard/blinky/CMakeLists.txt b/picoboard/blinky/CMakeLists.txt new file mode 100644 index 0000000..fc7e939 --- /dev/null +++ b/picoboard/blinky/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(picoboard_blinky + blinky.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(picoboard_blinky pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(picoboard_blinky) + +# add url via pico_set_program_url +example_auto_set_url(picoboard_blinky) diff --git a/picoboard/blinky/blinky.c b/picoboard/blinky/blinky.c new file mode 100644 index 0000000..f9cafcd --- /dev/null +++ b/picoboard/blinky/blinky.c @@ -0,0 +1,75 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" + +const uint LED_PIN = 25; +const uint DOT_PERIOD_MS = 100; + +const char *morse_letters[] = { + ".-", // A + "-...", // B + "-.-.", // C + "-..", // D + ".", // E + "..-.", // F + "--.", // G + "....", // H + "..", // I + ".---", // J + "-.-", // K + ".-..", // L + "--", // M + "-.", // N + "---", // O + ".--.", // P + "--.-", // Q + ".-.", // R + "...", // S + "-", // T + "..-", // U + "...-", // V + ".--", // W + "-..-", // X + "-.--", // Y + "--.." // Z +}; + +void put_morse_letter(const char *pattern) { + for (; *pattern; ++pattern) { + gpio_put(LED_PIN, 1); + if (*pattern == '.') + sleep_ms(DOT_PERIOD_MS); + else + sleep_ms(DOT_PERIOD_MS * 3); + gpio_put(LED_PIN, 0); + sleep_ms(DOT_PERIOD_MS * 1); + } + sleep_ms(DOT_PERIOD_MS * 2); +} + +void put_morse_str(const char *str) { + for (; *str; ++str) { + if (*str >= 'A' && *str < 'Z') { + put_morse_letter(morse_letters[*str - 'A']); + } else if (*str >= 'a' && *str < 'z') { + put_morse_letter(morse_letters[*str - 'a']); + } else if (*str == ' ') { + sleep_ms(DOT_PERIOD_MS * 4); + } + } +} + +int main() { + gpio_init(LED_PIN); + gpio_set_dir(LED_PIN, GPIO_OUT); + while (true) { + put_morse_str("Hello world"); + sleep_ms(1000); + } +} diff --git a/picoboard/button/CMakeLists.txt b/picoboard/button/CMakeLists.txt new file mode 100644 index 0000000..e257a5d --- /dev/null +++ b/picoboard/button/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(picoboard_button + button.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(picoboard_button pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(picoboard_button) + +# add url via pico_set_program_url +example_auto_set_url(picoboard_button) diff --git a/picoboard/button/button.c b/picoboard/button/button.c new file mode 100644 index 0000000..dfa8a05 --- /dev/null +++ b/picoboard/button/button.c @@ -0,0 +1,62 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/gpio.h" +#include "hardware/sync.h" +#include "hardware/structs/ioqspi.h" +#include "hardware/structs/sio.h" + +// This example blinks the Picoboard LED when the BOOTSEL button is pressed. +// +// Picoboard has a button attached to the flash CS pin, which the bootrom +// checks, and jumps straight to the USB bootcode if the button is pressed +// (pulling flash CS low). We can check this pin in by jumping to some code in +// SRAM (so that the XIP interface is not required), floating the flash CS +// pin, and observing whether it is pulled low. +// +// This doesn't work if others are trying to access flash at the same time, +// e.g. XIP streamer, or the other core. + +bool __no_inline_not_in_flash_func(get_bootsel_button)() { + const uint CS_PIN_INDEX = 1; + + // Must disable interrupts, as interrupt handlers may be in flash, and we + // are about to temporarily disable flash access! + uint32_t flags = save_and_disable_interrupts(); + + // Set chip select to Hi-Z + hw_write_masked(&ioqspi_hw->io[CS_PIN_INDEX].ctrl, + GPIO_OVERRIDE_LOW << IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_LSB, + IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_BITS); + + // Note we can't call into any sleep functions in flash right now + for (volatile int i = 0; i < 1000; ++i); + + // The HI GPIO registers in SIO can observe and control the 6 QSPI pins. + // Note the button pulls the pin *low* when pressed. + bool button_state = !(sio_hw->gpio_hi_in & (1u << CS_PIN_INDEX)); + + // Need to restore the state of chip select, else we are going to have a + // bad time when we return to code in flash! + hw_write_masked(&ioqspi_hw->io[CS_PIN_INDEX].ctrl, + GPIO_OVERRIDE_NORMAL << IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_LSB, + IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_BITS); + + restore_interrupts(flags); + + return button_state; +} + +int main() { + gpio_init(PICO_DEFAULT_LED_PIN); + gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT); + while (true) { + gpio_put(PICO_DEFAULT_LED_PIN, get_bootsel_button()); + sleep_ms(10); + } +} \ No newline at end of file diff --git a/pio/CMakeLists.txt b/pio/CMakeLists.txt new file mode 100644 index 0000000..ff56da3 --- /dev/null +++ b/pio/CMakeLists.txt @@ -0,0 +1,18 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(addition) + add_subdirectory(apa102) + add_subdirectory(differential_manchester) + add_subdirectory(hello_pio) + add_subdirectory(hub75) + add_subdirectory(i2c) + add_subdirectory(logic_analyser) + add_subdirectory(manchester_encoding) + add_subdirectory(pio_blink) + add_subdirectory(pwm) + add_subdirectory(spi) + add_subdirectory(squarewave) + add_subdirectory(st7789_lcd) + add_subdirectory(uart_rx) + add_subdirectory(uart_tx) + add_subdirectory(ws2812) +endif () diff --git a/pio/addition/CMakeLists.txt b/pio/addition/CMakeLists.txt new file mode 100644 index 0000000..9ff9077 --- /dev/null +++ b/pio/addition/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_addition) + +pico_generate_pio_header(pio_addition ${CMAKE_CURRENT_LIST_DIR}/addition.pio) + +target_sources(pio_addition PRIVATE addition.c) + +target_link_libraries(pio_addition PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_addition) + +# add url via pico_set_program_url +example_auto_set_url(pio_addition) diff --git a/pio/addition/addition.c b/pio/addition/addition.c new file mode 100644 index 0000000..a63579f --- /dev/null +++ b/pio/addition/addition.c @@ -0,0 +1,35 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "addition.pio.h" + +// Pop quiz: how many additions does the processor do when calling this function +uint32_t do_addition(PIO pio, uint sm, uint32_t a, uint32_t b) { + pio_sm_put_blocking(pio, sm, a); + pio_sm_put_blocking(pio, sm, b); + return pio_sm_get_blocking(pio, sm); +} + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &addition_program); + addition_program_init(pio, sm, offset); + + printf("Doing some random additions:\n"); + for (int i = 0; i < 10; ++i) { + uint a = rand() % 100; + uint b = rand() % 100; + printf("%u + %u = %u\n", a, b, do_addition(pio, sm, a, b)); + } +} diff --git a/pio/addition/addition.pio b/pio/addition/addition.pio new file mode 100644 index 0000000..f369333 --- /dev/null +++ b/pio/addition/addition.pio @@ -0,0 +1,27 @@ +.program addition + +; Pop two 32 bit integers from the TX FIFO, add them together, and push the +; result to the TX FIFO. Autopush/pull should be disabled as we're using +; explicit push and pull instructions. +; +; This program uses the two's complement identity x + y == ~(~x - y) + + pull + mov x, ~osr + pull + mov y, osr + jmp test ; this loop is equivalent to the following C code: +incr: ; while (y--) + jmp x-- test ; x--; +test: ; This has the effect of subtracting y from x, eventually. + jmp y-- incr + mov isr, ~x + push + +% c-sdk { +static inline void addition_program_init(PIO pio, uint sm, uint offset) { + pio_sm_config c = addition_program_get_default_config(offset); + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/pio/apa102/CMakeLists.txt b/pio/apa102/CMakeLists.txt new file mode 100644 index 0000000..1522f55 --- /dev/null +++ b/pio/apa102/CMakeLists.txt @@ -0,0 +1,15 @@ +add_executable(pio_apa102) + +pico_generate_pio_header(pio_apa102 ${CMAKE_CURRENT_LIST_DIR}/apa102.pio) + +target_sources(pio_apa102 PRIVATE apa102.c) + +target_link_libraries(pio_apa102 PRIVATE + pico_stdlib + hardware_pio + ) + +pico_add_extra_outputs(pio_apa102) + +# add url via pico_set_program_url +example_auto_set_url(pio_apa102) diff --git a/pio/apa102/apa102.c b/pio/apa102/apa102.c new file mode 100644 index 0000000..152945a --- /dev/null +++ b/pio/apa102/apa102.c @@ -0,0 +1,69 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "apa102.pio.h" + +#define PIN_CLK 2 +#define PIN_DIN 3 + +#define N_LEDS 150 +#define SERIAL_FREQ (5 * 1000 * 1000) + +// Global brightness value 0->31 +#define BRIGHTNESS 16 + +void put_start_frame(PIO pio, uint sm) { + pio_sm_put_blocking(pio, sm, 0u); +} + +void put_end_frame(PIO pio, uint sm) { + pio_sm_put_blocking(pio, sm, ~0u); +} + +void put_rgb888(PIO pio, uint sm, uint8_t r, uint8_t g, uint8_t b) { + pio_sm_put_blocking(pio, sm, + 0x7 << 29 | // magic + (BRIGHTNESS & 0x1f) << 24 | // global brightness parameter + (uint32_t) b << 16 | + (uint32_t) g << 8 | + (uint32_t) r << 0 + ); +} + +#define TABLE_SIZE (1 << 8) +uint8_t wave_table[TABLE_SIZE]; + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &apa102_mini_program); + apa102_mini_program_init(pio, sm, offset, SERIAL_FREQ, PIN_CLK, PIN_DIN); + + for (int i = 0; i < TABLE_SIZE; ++i) + wave_table[i] = powf(sinf(i * M_PI / TABLE_SIZE), 5.f) * 255; + + uint t = 0; + while (true) { + put_start_frame(pio, sm); + for (int i = 0; i < N_LEDS; ++i) { + put_rgb888(pio, sm, + wave_table[(i + t) % TABLE_SIZE], + wave_table[(2 * i + 3 * 2) % TABLE_SIZE], + wave_table[(3 * i + 4 * t) % TABLE_SIZE] + ); + } + put_end_frame(pio, sm); + sleep_ms(10); + ++t; + } +} diff --git a/pio/apa102/apa102.pio b/pio/apa102/apa102.pio new file mode 100644 index 0000000..5d76f08 --- /dev/null +++ b/pio/apa102/apa102.pio @@ -0,0 +1,89 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program apa102_mini +.side_set 1 + +; This is really just a TX-only SPI. CLK is side-set pin 0, DIN is OUT pin 0. +; Autopull enabled, threshold 32. +; +; Every word (32 bits) written to the FIFO will be shifted out in its entirety, MSB-first. + + out pins, 1 side 0 ; Stall here when no data (still asserts clock low) + nop side 1 + +% c-sdk { +#include "hardware/clocks.h" +static inline void apa102_mini_program_init(PIO pio, uint sm, uint offset, + uint baud, uint pin_clk, uint pin_din) { + pio_sm_set_pins_with_mask(pio, sm, 0, (1u << pin_clk) | (1u << pin_din)); + pio_sm_set_pindirs_with_mask(pio, sm, ~0u, (1u << pin_clk) | (1u << pin_din)); + pio_gpio_init(pio, pin_clk); + pio_gpio_init(pio, pin_din); + + pio_sm_config c = apa102_mini_program_get_default_config(offset); + sm_config_set_out_pins(&c, pin_din, 1); + sm_config_set_sideset_pins(&c, pin_clk); + // Shift to right, autopull with threshold 32 + sm_config_set_out_shift(&c, false, true, 32); + // Deeper FIFO as we're not doing any RX + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + // We transmit 1 bit every 2 execution cycles + float div = (float)clock_get_hz(clk_sys) / (2 * baud); + sm_config_set_clkdiv(&c, div); + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} + +.program apa102_rgb555 + +; Alternative program to unpack two RGB555 pixels from a FIFO word and transmit. +; This makes it easier to DMA large buffers without processor involvement. + +; OSR: shift to right +; ISR: shift to right + +; To set brightness, set ISR to bit-reverse of 5-bit brightness, +; followed by 111. (00...00_b0b1b2b3b4_111) + +; DMA pixel format is 0RRRRRGGGGGBBBBB x2 (15 bpp, 2px per FIFO word) + +; APA102 command structure: +; increasing time ---->> +; | byte 3 | byte 2 | byte 1 | byte 0 | +; |7 0|7 0|7 0|7 0| +; ------------------------------------- +; Pixel |111bbbbb|BBBBBBBB|GGGGGGGG|RRRRRRRR| +; Start Frame |00000000|00000000|00000000|00000000| +; Stop Frame |11111111|11111111|11111111|11111111| + +.wrap_target +public pixel_out: + ; pixel_out formats an APA102 colour command in the ISR. + ; bit_run shifts 32 bits out of the ISR, with clock. + pull ifempty + set x, 2 +colour_loop: + in osr, 5 + out null, 5 + in null, 3 + jmp x-- colour_loop + in y, 8 + mov isr, ::isr ; reverse for msb-first wire order + out null, 1 +public bit_run: + ; in isr, n rotates ISR by n bits (right rotation only) + ; Use this to perform out shifts from ISR, via mov pins + set x, 31 +bit_out: + set pins, 0 + mov pins, isr [6] + set pins, 1 + in isr, 1 [6] + jmp x-- bit_out +.wrap diff --git a/pio/differential_manchester/CMakeLists.txt b/pio/differential_manchester/CMakeLists.txt new file mode 100644 index 0000000..6276f09 --- /dev/null +++ b/pio/differential_manchester/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_differential_manchester) + +pico_generate_pio_header(pio_differential_manchester ${CMAKE_CURRENT_LIST_DIR}/differential_manchester.pio) + +target_sources(pio_differential_manchester PRIVATE differential_manchester.c) + +target_link_libraries(pio_differential_manchester PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_differential_manchester) + +# add url via pico_set_program_url +example_auto_set_url(pio_differential_manchester) \ No newline at end of file diff --git a/pio/differential_manchester/differential_manchester.c b/pio/differential_manchester/differential_manchester.c new file mode 100644 index 0000000..c8b5612 --- /dev/null +++ b/pio/differential_manchester/differential_manchester.c @@ -0,0 +1,43 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "differential_manchester.pio.h" + +// Differential serial transmit/receive example +// Need to connect a wire from GPIO2 -> GPIO3 + +const uint pin_tx = 2; +const uint pin_rx = 3; + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm_tx = 0; + uint sm_rx = 1; + + uint offset_tx = pio_add_program(pio, &differential_manchester_tx_program); + uint offset_rx = pio_add_program(pio, &differential_manchester_rx_program); + printf("Transmit program loaded at %d\n", offset_tx); + printf("Receive program loaded at %d\n", offset_rx); + + // Configure state machines, set bit rate at 5 Mbps + differential_manchester_tx_program_init(pio, sm_tx, offset_tx, pin_tx, 125.f / (16 * 5)); + differential_manchester_rx_program_init(pio, sm_rx, offset_rx, pin_rx, 125.f / (16 * 5)); + + pio_sm_set_enabled(pio, sm_tx, false); + pio_sm_put_blocking(pio, sm_tx, 0); + pio_sm_put_blocking(pio, sm_tx, 0x0ff0a55a); + pio_sm_put_blocking(pio, sm_tx, 0x12345678); + pio_sm_set_enabled(pio, sm_tx, true); + + for (int i = 0; i < 3; ++i) + printf("%08x\n", pio_sm_get_blocking(pio, sm_rx)); +} diff --git a/pio/differential_manchester/differential_manchester.pio b/pio/differential_manchester/differential_manchester.pio new file mode 100644 index 0000000..b10f2b9 --- /dev/null +++ b/pio/differential_manchester/differential_manchester.pio @@ -0,0 +1,102 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program differential_manchester_tx +.side_set 1 opt + +; Transmit one bit every cycles. In each bit period: +; - A '0' is encoded as a transition at the start of the bit period +; - A '1' is encoded as a transition at the start *and* in the middle +; +; Side-set bit 0 must be mapped to the data output pin. +; Autopull must be enabled. + +public start: +initial_high: + out x, 1 side 1 ; Start of bit period: always assert transition + jmp !x high_0 [6] ; Test the data bit we just shifted out of OSR +high_1: + jmp initial_high side 0 [7] ; For `1` bits, also transition in the middle +high_0: + jmp initial_low [7] ; Otherwise, the line is stable in the middle + +initial_low: + out x, 1 side 0 ; Always shift 1 bit from OSR to X so we can + jmp !x low_0 [6] ; branch on it. Autopull refills OSR for us. +low_1: + jmp initial_low side 1 [7] ; If there are two transitions, return to +low_0: ; initial_low on the next bit. If just one, + jmp initial_high [7] ; the initial line state is flipped! + +% c-sdk { +static inline void differential_manchester_tx_program_init(PIO pio, uint sm, uint offset, uint pin, float div) { + pio_sm_set_pins_with_mask(pio, sm, 0, 1u << pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + pio_gpio_init(pio, pin); + + pio_sm_config c = differential_manchester_tx_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, pin); + sm_config_set_out_shift(&c, true, true, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + sm_config_set_clkdiv(&c, div); + pio_sm_init(pio, sm, offset + differential_manchester_tx_offset_start, &c); + + // Execute a blocking pull so that we maintain the initial line state until data is available + pio_sm_exec(pio, sm, pio_encode_pull(false, true)); + pio_sm_set_enabled(pio, sm, true); +} +%} +.program differential_manchester_rx + +; Assumes line is idle low +; One bit is 16 cycles. In each bit period: +; - A '0' is encoded as a transition at time 0 +; - A '1' is encoded as a transition at time 0 and a transition at time T/2 +; +; The IN mapping and the JMP pin select must both be mapped to the GPIO used for +; RX data. Autopush must be enabled. + +public start: +initial_high: ; Find rising edge at start of bit period + wait 1 pin, 0 [11] ; Delay to eye of second half-period (i.e 3/4 of way + jmp pin high_0 ; through bit) and branch on RX pin high/low. +high_1: + in x, 1 ; Second transition detected (a `1` data symbol) + jmp initial_high +high_0: + in y, 1 [1] ; Line still high, no centre transition (data is `0`) + ; Fall-through + +.wrap_target +initial_low: ; Find falling edge at start of bit period + wait 0 pin, 0 [11] ; Delay to eye of second half-period + jmp pin low_1 +low_0: + in y, 1 ; Line still low, no centre transition (data is `0`) + jmp initial_high +low_1: ; Second transition detected (data is `1`) + in x, 1 [1] +.wrap + +% c-sdk { +static inline void differential_manchester_rx_program_init(PIO pio, uint sm, uint offset, uint pin, float div) { + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); + pio_gpio_init(pio, pin); + + pio_sm_config c = differential_manchester_rx_program_get_default_config(offset); + sm_config_set_in_pins(&c, pin); // for WAIT + sm_config_set_jmp_pin(&c, pin); // for JMP + sm_config_set_in_shift(&c, true, true, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + sm_config_set_clkdiv(&c, div); + pio_sm_init(pio, sm, offset, &c); + + // X and Y are set to 0 and 1, to conveniently emit these to ISR/FIFO. + pio_sm_exec(pio, sm, pio_encode_set(pio_x, 1)); + pio_sm_exec(pio, sm, pio_encode_set(pio_y, 0)); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/pio/hello_pio/CMakeLists.txt b/pio/hello_pio/CMakeLists.txt new file mode 100644 index 0000000..35b80cf --- /dev/null +++ b/pio/hello_pio/CMakeLists.txt @@ -0,0 +1,15 @@ +add_executable(hello_pio) + +pico_generate_pio_header(hello_pio ${CMAKE_CURRENT_LIST_DIR}/hello.pio) + +target_sources(hello_pio PRIVATE hello.c) + +target_link_libraries(hello_pio PRIVATE + pico_stdlib + hardware_pio + ) + +pico_add_extra_outputs(hello_pio) + +# add url via pico_set_program_url +example_auto_set_url(hello_pio) diff --git a/pio/hello_pio/hello.c b/pio/hello_pio/hello.c new file mode 100644 index 0000000..456ac56 --- /dev/null +++ b/pio/hello_pio/hello.c @@ -0,0 +1,38 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" +#include "hardware/pio.h" +// Our assembled program: +#include "hello.pio.h" + +int main() { + // Choose which PIO instance to use (there are two instances) + PIO pio = pio0; + + // Our assembled program needs to be loaded into this PIO's instruction + // memory. This SDK function will find a location (offset) in the + // instruction memory where there is enough space for our program. We need + // to remember this location! + uint offset = pio_add_program(pio, &hello_program); + + // Find a free state machine on our chosen PIO (erroring if there are + // none). Configure it to run our program, and start it, using the + // helper function we included in our .pio file. + uint sm = pio_claim_unused_sm(pio, true); + hello_program_init(pio, sm, offset, PICO_DEFAULT_LED_PIN); + + // The state machine is now running. Any value we push to its TX FIFO will + // appear on the LED pin. + while (true) { + // Blink + pio_sm_put_blocking(pio, sm, 1); + sleep_ms(500); + // Blonk + pio_sm_put_blocking(pio, sm, 0); + sleep_ms(500); + } +} diff --git a/pio/hello_pio/hello.pio b/pio/hello_pio/hello.pio new file mode 100644 index 0000000..9eac4de --- /dev/null +++ b/pio/hello_pio/hello.pio @@ -0,0 +1,34 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program hello + +; Repeatedly get one word of data from the TX FIFO, stalling when the FIFO is +; empty. Write the least significant bit to the OUT pin group. + +loop: + pull + out pins, 1 + jmp loop + +% c-sdk { +static inline void hello_program_init(PIO pio, uint sm, uint offset, uint pin) { + pio_sm_config c = hello_program_get_default_config(offset); + + // Map the state machine's OUT pin group to one pin, namely the `pin` + // parameter to this function. + sm_config_set_out_pins(&c, pin, 1); + // Set this pin's GPIO function (connect PIO to the pad) + pio_gpio_init(pio, pin); + // Set the pin direction to output at the PIO + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + + // Load our configuration, and jump to the start of the program + pio_sm_init(pio, sm, offset, &c); + // Set the state machine running + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/pio/hub75/CMakeLists.txt b/pio/hub75/CMakeLists.txt new file mode 100644 index 0000000..a976f4e --- /dev/null +++ b/pio/hub75/CMakeLists.txt @@ -0,0 +1,16 @@ +add_executable(pio_hub75) + +pico_generate_pio_header(pio_hub75 ${CMAKE_CURRENT_LIST_DIR}/hub75.pio) + +target_sources(pio_hub75 PRIVATE hub75.c) + +target_compile_definitions(pio_hub75 PRIVATE + PICO_DEFAULT_UART_TX_PIN=28 + PICO_DEFAULT_UART_RX_PIN=29 +) + +target_link_libraries(pio_hub75 PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_hub75) + +# add url via pico_set_program_url +example_auto_set_url(pio_hub75) diff --git a/pio/hub75/Readme.md b/pio/hub75/Readme.md new file mode 100644 index 0000000..660d795 --- /dev/null +++ b/pio/hub75/Readme.md @@ -0,0 +1,45 @@ +HUB75E Pinout: + +``` + /-----\ +R0 | o o | G0 +B0 | o o | GND +R1 | o o | G1 +B1 \ o o | E +A / o o | B +C | o o | D +CLK | o o | STB +OEn | o o | GND + \-----/ +``` + +Wiring: + +``` +Must be contiguous, in order: +R0 - GPIO0 +G0 - GPIO1 +B0 - GPIO2 +R1 - GPIO3 +G1 - GPIO4 +B1 - GPIO5 + +Must be contiguous, somewhat ok to change order: +A - GPIO6 +B - GPIO7 +C - GPIO8 +D - GPIO9 +E - GPIO10 + +Can be anywhere: +CLK - GPIO11 + +Must be contiguous, in order: +STB - GPIO12 +OEn - GPIO13 +``` + +This is a 1/32nd scan panel. The inputs A, B, C, D, E select one of 32 rows, starting at the top and working down (assuming the first pixel to be shifted is the one on the left of the screen, even though this is the "far end" of the shift register). R0, B0, G0 contain pixel data for the upper half of the screen. R1, G1, B1 contain pixel data for the lower half of the screen, which is scanned simultaneously with the upper half. + +Image credit for mountains_128x64.png: Paul Gilmore, found on [this wikimedia page](https://commons.wikimedia.org/wiki/File:Mountain_lake_dam.jpg) + diff --git a/pio/hub75/hub75.c b/pio/hub75/hub75.c new file mode 100644 index 0000000..498ffa7 --- /dev/null +++ b/pio/hub75/hub75.c @@ -0,0 +1,78 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/gpio.h" +#include "hardware/pio.h" +#include "hub75.pio.h" + +#include "mountains_128x64_rgb565.h" + +#define DATA_BASE_PIN 0 +#define DATA_N_PINS 6 +#define ROWSEL_BASE_PIN 6 +#define ROWSEL_N_PINS 5 +#define CLK_PIN 11 +#define STROBE_PIN 12 +#define OEN_PIN 13 + +#define WIDTH 128 +#define HEIGHT 64 + +static inline uint32_t gamma_correct_565_888(uint16_t pix) { + uint32_t r_gamma = pix & 0xf800u; + r_gamma *= r_gamma; + uint32_t g_gamma = pix & 0x07e0u; + g_gamma *= g_gamma; + uint32_t b_gamma = pix & 0x001fu; + b_gamma *= b_gamma; + return (b_gamma >> 2 << 16) | (g_gamma >> 14 << 8) | (r_gamma >> 24 << 0); +} + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm_data = 0; + uint sm_row = 1; + + uint data_prog_offs = pio_add_program(pio, &hub75_data_rgb888_program); + uint row_prog_offs = pio_add_program(pio, &hub75_row_program); + hub75_data_rgb888_program_init(pio, sm_data, data_prog_offs, DATA_BASE_PIN, CLK_PIN); + hub75_row_program_init(pio, sm_row, row_prog_offs, ROWSEL_BASE_PIN, ROWSEL_N_PINS, STROBE_PIN); + + static uint32_t gc_row[2][WIDTH]; + const uint16_t *img = (const uint16_t*)mountains_128x64; + + while (1) { + for (int rowsel = 0; rowsel < (1 << ROWSEL_N_PINS); ++rowsel) { + for (int x = 0; x < WIDTH; ++x) { + gc_row[0][x] = gamma_correct_565_888(img[rowsel * WIDTH + x]); + gc_row[1][x] = gamma_correct_565_888(img[((1u << ROWSEL_N_PINS) + rowsel) * WIDTH + x]); + } + for (int bit = 0; bit < 8; ++bit) { + hub75_data_rgb888_set_shift(pio, sm_data, data_prog_offs, bit); + for (int x = 0; x < WIDTH; ++x) { + pio_sm_put_blocking(pio, sm_data, gc_row[0][x]); + pio_sm_put_blocking(pio, sm_data, gc_row[1][x]); + } + // Dummy pixel per lane + pio_sm_put_blocking(pio, sm_data, 0); + pio_sm_put_blocking(pio, sm_data, 0); + // SM is finished when it stalls on empty TX FIFO + hub75_wait_tx_stall(pio, sm_data); + // Also check that previous OEn pulse is finished, else things can get out of sequence + hub75_wait_tx_stall(pio, sm_row); + + // Latch row data, pulse output enable for new row. + pio_sm_put_blocking(pio, sm_row, rowsel | (100u * (1u << bit) << 5)); + } + } + } + +} diff --git a/pio/hub75/hub75.pio b/pio/hub75/hub75.pio new file mode 100644 index 0000000..2d685ef --- /dev/null +++ b/pio/hub75/hub75.pio @@ -0,0 +1,122 @@ +.program hub75_row + +; side-set pin 0 is LATCH +; side-set pin 1 is OEn +; OUT pins are row select A-E +; +; Each FIFO record consists of: +; - 5-bit row select (LSBs) +; - Pulse width - 1 (27 MSBs) +; +; Repeatedly select a row, pulse LATCH, and generate a pulse of a certain +; width on OEn. + +.side_set 2 + +.wrap_target + out pins, 5 [7] side 0x2 ; Deassert OEn, output row select + out x, 27 [7] side 0x3 ; Pulse LATCH, get OEn pulse width +pulse_loop: + jmp x-- pulse_loop side 0x0 ; Assert OEn for x+1 cycles +.wrap + +% c-sdk { +static inline void hub75_row_program_init(PIO pio, uint sm, uint offset, uint row_base_pin, uint n_row_pins, uint latch_base_pin) { + pio_sm_set_consecutive_pindirs(pio, sm, row_base_pin, n_row_pins, true); + pio_sm_set_consecutive_pindirs(pio, sm, latch_base_pin, 2, true); + for (uint i = row_base_pin; i < row_base_pin + n_row_pins; ++i) + pio_gpio_init(pio, i); + pio_gpio_init(pio, latch_base_pin); + pio_gpio_init(pio, latch_base_pin + 1); + + pio_sm_config c = hub75_row_program_get_default_config(offset); + sm_config_set_out_pins(&c, row_base_pin, n_row_pins); + sm_config_set_sideset_pins(&c, latch_base_pin); + sm_config_set_out_shift(&c, true, true, 32); + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + +static inline void hub75_wait_tx_stall(PIO pio, uint sm) { + uint32_t txstall_mask = 1u << (PIO_FDEBUG_TXSTALL_LSB + sm); + pio->fdebug = txstall_mask; + while (!(pio->fdebug & txstall_mask)) + tight_loop_contents(); +} +%} + +.program hub75_data_rgb888 +.side_set 1 + +; Each FIFO record consists of a RGB888 pixel. (This is ok for e.g. an RGB565 +; source which has been gamma-corrected) +; +; Even pixels are sent on R0, G0, B0 and odd pixels on R1, G1, B1 (typically +; these are for different parts of the screen, NOT for adjacent pixels, so the +; frame buffer must be interleaved before passing to PIO.) +; +; Each pass through, we take bit n, n + 8 and n + 16 from each pixel, for n in +; {0...7}. Therefore the pixels need to be transmitted 8 times (ouch) to build +; up the full 8 bit value for each channel, and perform bit-planed PWM by +; varying pulse widths on the other state machine, in ascending powers of 2. +; This avoids a lot of bit shuffling on the processors, at the cost of DMA +; bandwidth (which we have loads of). + +; Might want to close your eyes before you read this +public entry_point: +.wrap_target +public shift0: + pull side 0 ; gets patched to `out null, n` if n nonzero (otherwise the PULL is required for fencing) + in osr, 1 side 0 ; shuffle shuffle shuffle + out null, 8 side 0 + in osr, 1 side 0 + out null, 8 side 0 + in osr, 1 side 0 + out null, 32 side 0 ; Discard remainder of OSR contents +public shift1: + pull side 0 ; gets patched to out null, n if n is nonzero (otherwise PULL required) + in osr, 1 side 1 ; Note this posedge clocks in the data from the previous iteration + out null, 8 side 1 + in osr, 1 side 1 + out null, 8 side 1 + in osr, 1 side 1 + out null, 32 side 1 + in null, 26 side 1 ; Note we are just doing this little manoeuvre here to get GPIOs in the order + mov pins, ::isr side 1 ; R0, G0, B0, R1, G1, B1. Can go 1 cycle faster if reversed +.wrap +; Note that because the clock edge for pixel n is in the middle of pixel n + +; 1, a dummy pixel at the end is required to clock the last piece of genuine +; data. (Also 1 pixel of garbage is clocked out at the start, but this is +; harmless) + +% c-sdk { +static inline void hub75_data_rgb888_program_init(PIO pio, uint sm, uint offset, uint rgb_base_pin, uint clock_pin) { + pio_sm_set_consecutive_pindirs(pio, sm, rgb_base_pin, 6, true); + pio_sm_set_consecutive_pindirs(pio, sm, clock_pin, 1, true); + for (uint i = rgb_base_pin; i < rgb_base_pin + 6; ++i) + pio_gpio_init(pio, i); + pio_gpio_init(pio, clock_pin); + + pio_sm_config c = hub75_data_rgb888_program_get_default_config(offset); + sm_config_set_out_pins(&c, rgb_base_pin, 6); + sm_config_set_sideset_pins(&c, clock_pin); + sm_config_set_out_shift(&c, true, true, 24); + // ISR shift to left. R0 ends up at bit 5. We push it up to MSB and then flip the register. + sm_config_set_in_shift(&c, false, false, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + pio_sm_init(pio, sm, offset, &c); + pio_sm_exec(pio, sm, offset + hub75_data_rgb888_offset_entry_point); + pio_sm_set_enabled(pio, sm, true); +} + +// Patch a data program at `offset` to preshift pixels by `shamt` +static inline void hub75_data_rgb888_set_shift(PIO pio, uint sm, uint offset, uint shamt) { + uint16_t instr; + if (shamt == 0) + instr = pio_encode_pull(false, true); // blocking PULL + else + instr = pio_encode_out(pio_null, shamt); + pio->instr_mem[offset + hub75_data_rgb888_offset_shift0] = instr; + pio->instr_mem[offset + hub75_data_rgb888_offset_shift1] = instr; +} +%} diff --git a/pio/hub75/mountains_128x64.png b/pio/hub75/mountains_128x64.png new file mode 100644 index 0000000..be19ae2 Binary files /dev/null and b/pio/hub75/mountains_128x64.png differ diff --git a/pio/hub75/mountains_128x64_rgb565.h b/pio/hub75/mountains_128x64_rgb565.h new file mode 100644 index 0000000..337afb3 --- /dev/null +++ b/pio/hub75/mountains_128x64_rgb565.h @@ -0,0 +1,1027 @@ +static char __attribute__((aligned(4))) mountains_128x64[] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0x0d, 0xbf, 0x04, 0x9f, 0xaf, + 0xff, 0xe7, 0x5f, 0x9f, 0x9f, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, + 0xbf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, + 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xff, 0x04, + 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, + 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xbf, 0x04, 0xbf, 0x04, 0xdf, 0x04, + 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xff, 0x04, + 0xdf, 0x04, 0xdf, 0x04, 0x5f, 0x05, 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, 0x5f, 0x05, 0x1f, 0x05, 0xdf, 0x04, 0xdf, 0x04, + 0xbf, 0x04, 0xdf, 0x04, 0xbf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0xdf, 0x04, 0x3f, 0x3e, + 0xff, 0x7e, 0xff, 0xe7, 0xff, 0xd7, 0xff, 0x3d, 0x3f, 0x05, 0xff, 0x35, 0xff, 0xff, 0x9f, 0xaf, + 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x9f, 0xb7, 0x1f, 0x56, 0xff, 0x45, + 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0xbf, 0x05, 0x5f, 0x5e, 0xff, 0x25, 0x1f, 0x05, 0xff, 0x04, + 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, + 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0x0d, 0xbf, 0x04, 0xbf, 0x04, + 0x1f, 0x05, 0xff, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, + 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0xff, 0x04, + 0x1f, 0x05, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0xff, 0x04, + 0x1f, 0x05, 0xff, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, + 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, + 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, 0x3f, 0x05, 0x1f, 0x05, + 0x1f, 0x05, 0x1f, 0x05, 0x9f, 0x6e, 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, 0x3f, 0x56, 0x5f, 0x05, 0xdf, 0x04, + 0xff, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xdf, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x7f, 0x05, 0x3f, 0x05, + 0x7f, 0x9f, 0x9f, 0x66, 0x3f, 0x3e, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x7f, 0xff, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xdf, 0xcf, 0xff, 0xff, 0xff, 0xf7, 0x1f, 0x87, + 0xdf, 0x05, 0x5f, 0x05, 0xff, 0x0d, 0xdf, 0x15, 0xdf, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x1f, 0x05, + 0x1f, 0x05, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, + 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x9f, 0x1d, 0xbf, 0x04, 0xdf, 0x04, + 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x1f, 0x05, 0x1f, 0x05, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0xff, 0x04, 0xff, 0x04, 0x1f, 0x05, + 0x1f, 0x05, 0x1f, 0x05, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0xff, 0x04, 0xff, 0x04, + 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0x1f, 0x05, 0x5f, 0x05, 0x5f, 0x9f, 0xff, 0xff, + 0xff, 0xff, 0x9f, 0x76, 0x3f, 0x9f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xb7, 0xff, 0x04, + 0xdf, 0x04, 0xdf, 0x04, 0xff, 0x04, 0xff, 0x04, 0xff, 0x04, 0x1f, 0x05, 0x9f, 0x05, 0x9f, 0xa7, + 0xff, 0xff, 0xff, 0xe7, 0xff, 0x7e, 0x5f, 0x05, 0xff, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0xdf, 0x96, + 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x3f, 0x8f, 0x1f, 0x3e, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xbf, 0x0d, 0xff, 0x04, + 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x5f, 0x05, + 0x7f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, + 0x3f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x5f, 0x05, 0xdf, 0x7e, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0xff, 0xff, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0x04, + 0xff, 0x04, 0xff, 0x04, 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x9f, 0x05, 0xff, 0xbf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xcf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0x8e, + 0x3f, 0x4e, 0xbf, 0xbf, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x56, 0xff, 0xe7, 0x3f, 0x97, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0xdd, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xff, 0x25, 0x3f, 0x05, + 0x1f, 0x05, 0x3f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x5f, 0x4e, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x5f, 0xa7, 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, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0x35, 0x3f, 0x05, + 0x1f, 0x05, 0x1f, 0x05, 0x1f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x7f, 0x05, 0xdf, 0x76, 0xff, 0xdf, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x9f, 0x87, + 0x7f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, + 0x51, 0x53, 0x11, 0x4b, 0x75, 0x7c, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xdf, 0xdf, 0x7e, 0x7f, 0x6e, + 0xbf, 0x6e, 0x5f, 0x05, 0x9f, 0x05, 0x5f, 0x8f, 0x3f, 0x46, 0xff, 0x76, 0xbf, 0x76, 0xff, 0xcf, + 0xdf, 0x0d, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, + 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, + 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x3f, 0x05, + 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0xdf, 0x05, 0x1f, 0x8f, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x9f, 0x7e, 0x7f, 0x46, 0x7f, 0x05, 0x3f, 0x05, + 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x3f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0xff, 0xcf, 0xff, 0xff, + 0xff, 0xc7, 0xbf, 0x8e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xb7, 0x9f, 0xaf, 0xff, 0xc7, 0xff, 0xf7, 0xdf, 0xb7, 0xff, 0x05, 0x9f, 0x05, + 0x9f, 0x05, 0xff, 0x05, 0x5f, 0x26, 0x9f, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, + 0xff, 0xff, 0xfa, 0xb5, 0x53, 0x74, 0x51, 0x5b, 0x74, 0x7c, 0xd5, 0x6b, 0xdf, 0x9e, 0xbf, 0xb7, + 0x1f, 0x7f, 0x1f, 0x2e, 0x3f, 0x87, 0xdf, 0xb7, 0xdf, 0xb7, 0xff, 0xc7, 0x7f, 0x9f, 0x3f, 0x3e, + 0xff, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xdf, 0x05, + 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, + 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, + 0x7f, 0x05, 0x9f, 0x05, 0x5f, 0x2e, 0xbf, 0x5e, 0xff, 0xb7, 0x3f, 0x8f, 0xdf, 0x76, 0xff, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xbf, 0xc7, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xdf, 0x3f, 0x97, 0x3f, 0x8f, 0x7f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x3f, 0x87, 0xff, 0xf7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0xff, 0x76, 0x3f, 0x26, 0xbf, 0x05, 0x3f, 0x3e, + 0x5f, 0x4e, 0x5f, 0x16, 0x9f, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0x9f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, + 0x7f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, + 0xf6, 0x9c, 0x3e, 0xe7, 0xff, 0xff, 0xbf, 0xf7, 0xfb, 0xbd, 0xb5, 0x8c, 0x10, 0x4b, 0x9c, 0x34, + 0xdf, 0x1d, 0xbf, 0x05, 0xff, 0x0d, 0xff, 0x15, 0xff, 0x05, 0xff, 0x0d, 0xff, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, + 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, + 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, + 0xdf, 0x05, 0xff, 0x05, 0x1f, 0x06, 0x5f, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xaf, 0x1f, 0x97, + 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, + 0x5f, 0x5e, 0x5f, 0x66, 0xff, 0xcf, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7f, 0xb7, 0xbf, 0x05, 0x7f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, + 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xdf, 0x05, + 0x9f, 0x4e, 0xff, 0x76, 0xbf, 0x5e, 0x3f, 0x06, 0xdf, 0x05, 0xbf, 0x05, 0xff, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xdf, 0x05, 0xbf, 0x05, + 0xdf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, + 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, + 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, + 0x3a, 0xbe, 0x5e, 0xe7, 0x13, 0x7c, 0x17, 0x9d, 0x5b, 0xbe, 0x1d, 0xdf, 0xdf, 0xff, 0x9f, 0xf7, + 0x9f, 0xef, 0x7f, 0x9e, 0x9f, 0x3d, 0x9f, 0x0d, 0x9f, 0x15, 0xdf, 0x25, 0xff, 0x05, 0x1f, 0x06, + 0xdf, 0x05, 0xff, 0x05, 0xff, 0x05, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x3f, 0x06, + 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xdf, 0x05, 0x1f, 0x06, 0xdf, 0x05, + 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0x5f, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x9f, 0x4e, 0xff, 0x05, + 0xff, 0x0d, 0xff, 0xf7, 0xff, 0xd7, 0x7f, 0xa7, 0x9f, 0xc7, 0xff, 0xe7, 0xff, 0xef, 0xff, 0xd7, + 0x5f, 0x05, 0x3f, 0x05, 0x5f, 0x4e, 0xdf, 0xc7, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xf7, + 0xdf, 0xc7, 0x5f, 0x05, 0x5f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, + 0xbf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xdf, 0x05, + 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, + 0x9f, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0xbf, 0x05, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xe7, 0x54, 0x7c, 0x32, 0x5b, 0x3b, 0xbe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x98, 0xad, 0xb5, 0x94, 0x36, 0x9d, 0xb7, 0x33, 0x9f, 0x35, + 0x5f, 0x25, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0x3f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xdf, 0x05, + 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xbf, 0x05, 0x1f, 0x06, 0xbf, 0x05, 0x7f, 0x97, 0x5f, 0x97, 0xdf, 0x05, 0x9f, 0x05, + 0x9f, 0x36, 0xdf, 0x76, 0xbf, 0x05, 0x7f, 0x05, 0xff, 0x05, 0xff, 0x15, 0xbf, 0x05, 0xbf, 0x05, + 0x5f, 0x05, 0x5f, 0x05, 0x5f, 0x1e, 0x1f, 0x7f, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xcf, + 0xff, 0xf7, 0xdf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0xbf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xbf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0x52, 0x8e, 0x42, 0xb5, 0x94, 0x36, 0xa5, 0x8d, 0x42, + 0xaa, 0x21, 0x55, 0x2b, 0x1f, 0x2e, 0x5f, 0x16, 0x3f, 0x1e, 0xdf, 0x1d, 0x3f, 0x06, 0x3f, 0x06, + 0x3f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x0e, 0x5f, 0x06, 0x5f, 0x06, 0x1f, 0x06, 0x3f, 0x06, + 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xbf, 0x05, + 0xbf, 0x05, 0xbf, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x9f, 0x05, 0x7f, 0x05, 0xbf, 0x05, + 0x9f, 0x05, 0x7f, 0x05, 0x7f, 0x05, 0x9f, 0x3e, 0x3f, 0x97, 0xff, 0xff, 0xff, 0xdf, 0x1f, 0x8f, + 0xff, 0xb7, 0xbf, 0x05, 0x9f, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0x7f, 0x36, 0x9f, 0xa7, 0xdf, 0x6e, + 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, + 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, 0xdf, 0xf7, 0x91, 0x6b, 0x0b, 0x2a, + 0x2c, 0x32, 0xaa, 0x19, 0xec, 0x21, 0xec, 0x19, 0x29, 0x11, 0x49, 0x19, 0x3a, 0x34, 0x3f, 0x2e, + 0x7f, 0x16, 0x7f, 0x16, 0x7f, 0x1e, 0x7f, 0x0e, 0x9f, 0x0e, 0x5f, 0x0e, 0x5f, 0x0e, 0x3f, 0x06, + 0x5f, 0x0e, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xbf, 0x05, 0xdf, 0x05, 0xdf, 0x05, 0x9f, 0x4e, 0x7f, 0x2e, + 0xdf, 0x05, 0xbf, 0x05, 0xff, 0x05, 0xff, 0x05, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0x3f, 0x06, 0x3f, 0x06, 0xff, 0xaf, 0xff, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbf, 0x46, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, + 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, + 0x1f, 0x06, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, + 0x1f, 0x06, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, + 0xfb, 0xe6, 0xff, 0xff, 0x39, 0xce, 0x5a, 0xd6, 0x59, 0xce, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xd6, 0x0b, 0x2a, + 0x4c, 0x32, 0x49, 0x19, 0x28, 0x11, 0x6a, 0x21, 0x6a, 0x19, 0x4a, 0x19, 0x29, 0x11, 0x58, 0x64, + 0x9f, 0x36, 0x9f, 0x26, 0x9f, 0x16, 0x9f, 0x16, 0x9f, 0x0e, 0x7f, 0x16, 0x5f, 0x16, 0x7f, 0x06, + 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x0e, 0x3f, 0x0e, 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, + 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, 0xdf, 0x05, 0xff, 0x05, + 0xff, 0x05, 0xff, 0x05, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x3f, 0x06, + 0x1f, 0x06, 0xff, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xaf, 0x3f, 0x0e, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x3f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x3f, 0x1e, 0x5f, 0x26, + 0x3f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0xff, 0x05, 0xff, 0x05, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, 0xff, 0x05, + 0xf6, 0xc5, 0x33, 0xa5, 0x55, 0xb5, 0x3c, 0xef, 0xf7, 0xc5, 0x1b, 0xe7, 0xd3, 0xa4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x36, 0x64, + 0x0b, 0x2a, 0xaa, 0x21, 0x6a, 0x21, 0x49, 0x19, 0x49, 0x19, 0x49, 0x19, 0xab, 0x29, 0xb0, 0x73, + 0x36, 0x6c, 0x9f, 0x4e, 0xdf, 0x36, 0xbf, 0x2e, 0xbf, 0x2e, 0x9f, 0x1e, 0x9f, 0x16, 0x7f, 0x06, + 0x9f, 0x0e, 0x5f, 0x0e, 0x7f, 0x16, 0x5f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x06, + 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, + 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, + 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0xff, 0xaf, 0x5f, 0x7f, + 0x7f, 0x06, 0x3f, 0x0e, 0x3f, 0x06, 0x7f, 0x8f, 0x7f, 0x87, 0x9f, 0xbf, 0xff, 0xff, 0xbf, 0xaf, + 0xdf, 0x5e, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x77, + 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, + 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x76, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xdf, 0x7f, 0x3e, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x3f, 0x06, 0x1f, 0x06, + 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0x1f, 0x06, 0x1f, 0x06, 0xff, 0x05, 0x1f, 0x06, 0xff, 0x05, + 0x17, 0xc6, 0xb5, 0xb5, 0x13, 0xa5, 0x91, 0x94, 0x37, 0xce, 0x99, 0xde, 0x95, 0xb5, 0x9d, 0xf7, + 0x13, 0xa5, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x30, 0x4b, 0x2b, 0x32, 0x2b, 0x32, 0xca, 0x21, 0x89, 0x21, 0x89, 0x21, 0xeb, 0x29, 0xb8, 0xb5, + 0xcb, 0x52, 0x2f, 0x53, 0xbf, 0x6d, 0xff, 0x4e, 0xdf, 0x2e, 0xdf, 0x26, 0x9f, 0x0e, 0x9f, 0x0e, + 0x9f, 0x06, 0x9f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x7f, 0x06, + 0x5f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, + 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x7f, 0x06, + 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x7f, 0x06, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xef, 0xff, 0xaf, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xe7, 0xdf, 0xaf, 0x5f, 0x0e, 0xff, 0xaf, 0xff, 0xe7, 0xff, 0xdf, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, + 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x5f, 0x06, + 0x5f, 0x06, 0xbf, 0x36, 0xdf, 0x56, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, 0xdf, 0xbf, 0xff, 0xb7, 0xdf, 0x4e, 0x3f, 0x06, + 0x1f, 0x06, 0x3f, 0x06, 0x5f, 0x06, 0x5f, 0x06, 0x3f, 0x06, 0x3f, 0x06, 0x1f, 0x06, 0x1f, 0x06, + 0x14, 0xa5, 0x71, 0x94, 0x95, 0xbd, 0x98, 0xd6, 0x0e, 0x8c, 0xf2, 0xa4, 0xf2, 0xa4, 0xd5, 0xbd, + 0xb5, 0xbd, 0xd2, 0x9c, 0x17, 0xce, 0xb9, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x98, 0x74, 0xd5, 0x5b, 0xd4, 0x53, 0x52, 0x53, 0x28, 0x11, 0x2b, 0x42, 0xec, 0x52, + 0x6c, 0x42, 0x2e, 0x63, 0x4e, 0x6b, 0x1b, 0x6d, 0x3f, 0x47, 0xbf, 0x1e, 0xbf, 0x2e, 0xbf, 0x46, + 0xbf, 0x1e, 0x9f, 0x06, 0xbf, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x7f, 0x06, + 0x9f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0x7f, 0x06, + 0x9f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0x7f, 0x06, + 0x9f, 0x06, 0x7f, 0x06, 0x9f, 0x06, 0xff, 0x2e, 0xbf, 0x2e, 0xbf, 0x46, 0xff, 0xf7, 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, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xde, 0xc6, + 0x9a, 0xa5, 0x3c, 0xbe, 0xdf, 0xef, 0xff, 0xce, 0xff, 0xce, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x7f, 0x06, 0xdf, 0x46, 0xff, 0xc7, 0xff, 0xe7, 0xff, 0xbf, + 0xdf, 0x56, 0x9f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x9f, 0x0e, 0x5f, 0x6f, + 0xff, 0xef, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x1f, 0x06, + 0x3f, 0x06, 0x3f, 0x06, 0x7f, 0x2e, 0xff, 0xdf, 0xff, 0xef, 0xdf, 0x46, 0xdf, 0x4e, 0x5f, 0x0e, + 0x78, 0xd6, 0xf7, 0xc5, 0xf2, 0xa4, 0x70, 0x94, 0x2f, 0x8c, 0x58, 0xd6, 0x16, 0xc6, 0x12, 0xa5, + 0x33, 0xad, 0x91, 0x9c, 0x12, 0xa5, 0x53, 0xad, 0xb1, 0x9c, 0x95, 0xb5, 0x91, 0x94, 0xda, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xf7, 0x3e, 0xe7, 0x5e, 0xe7, 0x36, 0x9d, 0xd0, 0x73, 0xac, 0x52, + 0x6b, 0x3a, 0x8f, 0x7b, 0xad, 0x7b, 0x8e, 0x73, 0xf7, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xe7, 0x1f, 0x57, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x0e, + 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, 0x9f, 0x06, + 0x1f, 0x47, 0x1f, 0x4f, 0xbf, 0x8f, 0xbf, 0x97, 0x1f, 0x4f, 0x7f, 0x7f, 0xdf, 0xa7, 0xdf, 0xa7, + 0xff, 0xc7, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xd7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xf7, + 0xff, 0xe7, 0xff, 0xff, 0x3f, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb9, 0xad, 0x39, 0x95, + 0x37, 0x9d, 0x1a, 0xb6, 0xf8, 0x8c, 0x36, 0x6c, 0x3b, 0xb6, 0x1b, 0xb6, 0x3b, 0xbe, 0x9e, 0xc6, + 0x15, 0x5c, 0x13, 0x43, 0x1b, 0x5d, 0x1f, 0xaf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xc7, 0xbf, 0xa7, 0xbf, 0x16, 0x7f, 0x06, 0x7f, 0x06, 0x5f, 0x06, 0x5f, 0x06, + 0x7f, 0x06, 0xff, 0xbf, 0xff, 0xef, 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, 0x66, + 0xdf, 0x5e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, + 0x70, 0x94, 0x74, 0xb5, 0x12, 0xa5, 0xad, 0x7b, 0x3c, 0xef, 0x1b, 0xef, 0x95, 0xbd, 0xd5, 0xc5, + 0xf6, 0xc5, 0xee, 0x83, 0x12, 0xa5, 0x70, 0x94, 0xd9, 0xe6, 0x5b, 0xef, 0x59, 0xce, 0x75, 0xb5, + 0x51, 0x94, 0xb2, 0x9c, 0x95, 0xb5, 0x3d, 0xef, 0xdf, 0xff, 0x14, 0xa5, 0x9a, 0xde, 0x68, 0x21, + 0xaa, 0x29, 0xab, 0x52, 0xab, 0x5a, 0xef, 0x83, 0x8e, 0x73, 0x51, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x4e, 0xbf, 0x06, 0xbf, 0x06, 0xff, 0x26, 0x9f, 0x87, 0xff, 0xff, + 0xdf, 0x4e, 0x9f, 0x06, 0xbf, 0x06, 0xbf, 0x06, 0xbf, 0x1e, 0x1f, 0x47, 0xdf, 0x06, 0xbf, 0x16, + 0x1f, 0x3f, 0x7f, 0x6f, 0x7f, 0x67, 0x9f, 0x7f, 0x7f, 0x7f, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xbe, 0xff, 0xff, 0x7d, 0xb6, 0xff, 0xff, 0xff, 0xff, + 0x3f, 0xc7, 0x5c, 0x75, 0xdc, 0xa5, 0xd9, 0x7c, 0x5f, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xb8, 0x6c, 0xff, 0xc6, 0xff, 0xef, 0x3f, 0xe7, 0xf7, 0x8c, 0x38, 0x95, 0x17, 0x8d, + 0xd7, 0x7c, 0xd7, 0x84, 0xfa, 0xad, 0x96, 0x7c, 0xff, 0xff, 0x17, 0x9d, 0x38, 0x95, 0xb6, 0x84, + 0xd7, 0x84, 0xf5, 0x63, 0x38, 0x95, 0xb6, 0x84, 0xdd, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xc7, 0xff, 0xef, 0xff, 0xff, + 0xff, 0x5e, 0xff, 0x3e, 0x7f, 0x87, 0xdf, 0xcf, 0xff, 0xef, 0xbf, 0xe7, 0xbf, 0xe7, 0x9f, 0xdf, + 0xdf, 0xe7, 0xdf, 0xe7, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xd7, + 0xb9, 0xde, 0x38, 0xd6, 0x12, 0xa5, 0xd0, 0xa4, 0x98, 0xd6, 0x0f, 0x84, 0xcd, 0x7b, 0x70, 0x8c, + 0xd6, 0xbd, 0xce, 0x83, 0x37, 0xce, 0xf2, 0xa4, 0xb1, 0xa4, 0x37, 0xce, 0xd5, 0xbd, 0x54, 0xb5, + 0x1b, 0xe7, 0xff, 0xff, 0x5c, 0xef, 0xba, 0xde, 0x70, 0x94, 0x99, 0xde, 0xbd, 0xff, 0x78, 0xd6, + 0xd3, 0xa4, 0xcb, 0x52, 0x6d, 0x6b, 0x50, 0x84, 0x4c, 0x6b, 0x2f, 0x84, 0x50, 0x84, 0x38, 0xc6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x56, 0x9f, 0x06, 0xbf, 0x06, 0xff, 0x36, 0xff, 0xe7, + 0x7f, 0x87, 0x5f, 0x77, 0xdf, 0x8f, 0x7f, 0x77, 0x9f, 0x1e, 0x3f, 0x4f, 0xbf, 0x8f, 0xff, 0xa7, + 0xdf, 0x2e, 0xff, 0xd7, 0xff, 0x97, 0xdf, 0x9f, 0x5f, 0xaf, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xde, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xef, 0x9e, 0xb6, 0xf9, 0x7c, + 0x78, 0x64, 0x57, 0x64, 0x39, 0x85, 0xb5, 0x43, 0x37, 0x4c, 0x7b, 0x95, 0x1d, 0x96, 0xdb, 0x54, + 0xba, 0x6c, 0xd7, 0x43, 0x7a, 0x8d, 0x7c, 0xbe, 0x75, 0x84, 0xfa, 0xb5, 0x77, 0x9d, 0x3b, 0xbe, + 0x3d, 0xdf, 0xf7, 0x94, 0x96, 0x7c, 0xff, 0xf7, 0xf6, 0x8c, 0xf8, 0x8c, 0x35, 0x64, 0x55, 0x6c, + 0x32, 0x4b, 0x17, 0x8d, 0x3a, 0xbe, 0xb3, 0x5b, 0x17, 0x8d, 0x78, 0xa5, 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, 0xdf, 0xff, 0xd7, + 0xff, 0xf7, 0xff, 0xff, 0xff, 0xe7, 0xdf, 0xbf, 0x3f, 0x87, 0xdf, 0x4e, 0x1f, 0x7f, 0xff, 0xbf, + 0x4e, 0x8c, 0xee, 0x83, 0x0d, 0x8c, 0x6e, 0x9c, 0x33, 0xad, 0x6b, 0x6b, 0xee, 0x83, 0x2f, 0x84, + 0x70, 0x94, 0xad, 0x7b, 0x0e, 0x84, 0xad, 0x73, 0x90, 0x94, 0xcc, 0x7b, 0xd6, 0xbd, 0xd5, 0xc5, + 0x33, 0xad, 0x17, 0xce, 0x3a, 0xef, 0xf7, 0xc5, 0x99, 0xd6, 0x95, 0xad, 0xd2, 0x9c, 0xff, 0xff, + 0x51, 0x8c, 0x0c, 0x5b, 0x2c, 0x63, 0x30, 0x84, 0x6e, 0x6b, 0x30, 0x8c, 0xef, 0x83, 0x71, 0x8c, + 0x96, 0xb5, 0xbf, 0xcf, 0xff, 0xe7, 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, 0x3f, 0xd7, 0xff, 0xf7, 0x9f, 0xdf, 0xff, 0xef, 0xff, 0xf7, 0xff, 0xff, 0xbe, 0xbe, + 0x5d, 0xc6, 0x7f, 0xdf, 0xfe, 0xd6, 0x3f, 0xdf, 0xb8, 0x7c, 0x16, 0x54, 0xbd, 0x95, 0x9c, 0x8d, + 0xd6, 0x4b, 0xd5, 0x53, 0xf8, 0x74, 0x19, 0x7d, 0x76, 0x3b, 0x9b, 0x95, 0x7e, 0xb6, 0x5b, 0x85, + 0xba, 0x6c, 0x37, 0x5c, 0x36, 0x6c, 0xd6, 0x8c, 0xd9, 0xb5, 0xf6, 0x8c, 0x75, 0x7c, 0xd3, 0x5b, + 0x38, 0x95, 0xd9, 0xad, 0x14, 0x6c, 0x78, 0xa5, 0x11, 0x4b, 0xd6, 0x8c, 0xb4, 0x5b, 0x12, 0x3b, + 0x75, 0x7c, 0x10, 0x4b, 0x93, 0x5b, 0x54, 0x74, 0x96, 0x7c, 0xd4, 0x5b, 0xf4, 0x63, 0x5f, 0xe7, + 0x7f, 0xef, 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, 0xdf, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xf7, 0x7f, 0x9f, 0xff, 0xb7, 0x3f, 0x57, 0x5f, 0x06, 0x5f, 0x06, 0xff, 0xbf, + 0xff, 0xff, 0xff, 0xf7, 0x7f, 0x97, 0x7f, 0x06, 0x7f, 0x06, 0xbf, 0x16, 0x5f, 0x77, 0x5f, 0x8f, + 0x05, 0x32, 0xa5, 0x31, 0xc4, 0x39, 0x68, 0x52, 0xe6, 0x31, 0x09, 0x5b, 0xec, 0x83, 0x2f, 0x8c, + 0xb0, 0x94, 0xf1, 0xa4, 0x6c, 0x6b, 0x0a, 0x63, 0xd0, 0x94, 0xf1, 0x9c, 0xda, 0xde, 0x37, 0xc6, + 0x32, 0xa5, 0xb3, 0xc5, 0x71, 0xc5, 0xcd, 0x83, 0x09, 0x63, 0xed, 0x7b, 0x90, 0x94, 0x53, 0xad, + 0x89, 0x4a, 0xae, 0x73, 0x8d, 0x73, 0x2c, 0x6b, 0xcb, 0x52, 0x2c, 0x63, 0x8e, 0x73, 0xd2, 0x9c, + 0xae, 0x73, 0x73, 0x7c, 0x1d, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xd9, 0x64, 0xfd, 0x8d, 0xfb, 0x9d, 0xbf, 0xe7, 0xff, 0xff, 0xbf, 0xe7, + 0x3a, 0x7d, 0xbd, 0x85, 0xff, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xce, + 0xb9, 0x74, 0x1d, 0x9e, 0x97, 0x74, 0xf7, 0x53, 0xba, 0x6c, 0x17, 0x5c, 0x9b, 0x8d, 0x17, 0x5c, + 0xf7, 0x53, 0x33, 0x3b, 0xfd, 0x95, 0x14, 0x2b, 0xb5, 0x43, 0x9c, 0x85, 0x54, 0x3b, 0x1c, 0x75, + 0x3f, 0x96, 0x39, 0x8d, 0xf4, 0x63, 0xb6, 0x8c, 0x38, 0x8d, 0xb6, 0x84, 0xf7, 0x84, 0x1d, 0xd7, + 0x97, 0x84, 0x51, 0x4b, 0x14, 0x64, 0x96, 0x84, 0xb6, 0x7c, 0x96, 0x7c, 0x6f, 0x22, 0x12, 0x3b, + 0x93, 0x53, 0x53, 0x53, 0x37, 0x95, 0x3b, 0xb6, 0x72, 0x5b, 0xd4, 0x5b, 0x15, 0x64, 0x93, 0x53, + 0xf7, 0x84, 0x3c, 0xb6, 0x7f, 0xdf, 0xbf, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x06, 0xdf, 0xb7, 0xff, 0xef, + 0xff, 0xdf, 0x3f, 0x7f, 0x7f, 0x06, 0x5f, 0x6f, 0x5f, 0x06, 0xbf, 0x1e, 0xff, 0xcf, 0xff, 0xff, + 0xff, 0xd7, 0xff, 0xcf, 0xbf, 0xb7, 0xff, 0x5e, 0x7f, 0x06, 0x1f, 0x57, 0xff, 0xe7, 0xff, 0xff, + 0xc9, 0x5a, 0x64, 0x21, 0xca, 0x5a, 0xcc, 0x83, 0x2a, 0x6b, 0x46, 0x4a, 0x30, 0xb5, 0x30, 0xb5, + 0xaf, 0xa4, 0x53, 0xb5, 0x6f, 0x8c, 0x68, 0x4a, 0x27, 0x42, 0xe5, 0x31, 0xcd, 0x7b, 0x90, 0x94, + 0xee, 0x83, 0xd0, 0xa4, 0xed, 0x8b, 0x8d, 0x6b, 0x54, 0xad, 0x6b, 0x6b, 0x68, 0x4a, 0xaa, 0x52, + 0x28, 0x3a, 0x0c, 0x5b, 0x34, 0xad, 0x6d, 0x73, 0xf1, 0x7b, 0x8f, 0x6b, 0x31, 0x8c, 0xf0, 0x7b, + 0x8e, 0x73, 0x2c, 0x6b, 0xaf, 0x73, 0xaf, 0x6b, 0xd5, 0x84, 0x5e, 0xa6, 0xbf, 0xbe, 0xff, 0xff, + 0x1f, 0xd7, 0xff, 0xc6, 0xba, 0x64, 0x9a, 0x8d, 0xff, 0xc6, 0x5a, 0x7d, 0xff, 0xf7, 0x7f, 0xd7, + 0x5c, 0x7d, 0x19, 0x75, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5c, 0xb6, + 0x3b, 0x75, 0x98, 0x6c, 0xd3, 0x22, 0x13, 0x2b, 0x54, 0x33, 0x55, 0x33, 0x17, 0x5c, 0x7f, 0xcf, + 0x5f, 0xd7, 0xbf, 0xb6, 0x3b, 0x85, 0xd6, 0x43, 0x78, 0x64, 0xbd, 0x8d, 0x3d, 0x75, 0x1c, 0x75, + 0x37, 0x64, 0x52, 0x43, 0x96, 0x84, 0x55, 0x74, 0x31, 0x43, 0xd6, 0x84, 0xf7, 0x94, 0xda, 0xb5, + 0xbd, 0xd6, 0x32, 0x3b, 0xd1, 0x3a, 0x55, 0x74, 0x1f, 0xdf, 0xfb, 0xa5, 0xb4, 0x5b, 0x2f, 0x1a, + 0x50, 0x22, 0x0e, 0x12, 0xbf, 0xf7, 0x10, 0x43, 0xd0, 0x42, 0xd0, 0x42, 0x15, 0x64, 0x54, 0x7c, + 0xbd, 0xd6, 0xdc, 0xd6, 0xd8, 0x84, 0x16, 0x64, 0xba, 0xad, 0xdf, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5f, 0x7f, 0xbf, 0x97, 0x5f, 0x6f, + 0xbf, 0x97, 0x1f, 0x57, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xaf, 0x7f, 0x8f, 0xff, 0x3e, 0x3f, 0x77, + 0xa5, 0x29, 0x68, 0x4a, 0x09, 0x63, 0xab, 0x73, 0xc8, 0x52, 0xcb, 0x83, 0x2d, 0x8c, 0x2a, 0x6b, + 0xe8, 0x62, 0x8f, 0x9c, 0xed, 0x7b, 0x4f, 0x94, 0xa9, 0x52, 0xaa, 0x52, 0x43, 0x29, 0x6c, 0x6b, + 0xcd, 0x7b, 0x68, 0x4a, 0xe6, 0x31, 0xa4, 0x29, 0xa9, 0x52, 0x23, 0x19, 0x23, 0x11, 0xf3, 0x94, + 0xea, 0x52, 0xef, 0x7b, 0x90, 0x94, 0x6c, 0x6b, 0xb5, 0xb5, 0xb0, 0x73, 0x31, 0x84, 0x10, 0x7c, + 0x33, 0xa5, 0x31, 0x8c, 0x6e, 0x6b, 0x72, 0x8c, 0xca, 0x52, 0xd4, 0x8c, 0xde, 0xc6, 0x7c, 0xb6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xbc, 0x95, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd5, 0x4b, 0x54, 0x3b, 0x10, 0x0a, 0xb2, 0x12, 0x71, 0x12, 0xb3, 0x22, 0xde, 0x95, 0x9f, 0xdf, + 0xff, 0xff, 0xbf, 0xd7, 0x9f, 0xa6, 0x3f, 0x9e, 0x7f, 0xa6, 0x3f, 0x96, 0x1f, 0x86, 0x13, 0x3b, + 0xd0, 0x32, 0xb1, 0x32, 0xd4, 0x5b, 0x32, 0x4b, 0x16, 0x64, 0x73, 0x4b, 0x34, 0x6c, 0x14, 0x64, + 0x78, 0xa5, 0xf8, 0x84, 0x0e, 0x12, 0xf7, 0x8c, 0xff, 0xff, 0x1a, 0xbe, 0x6f, 0x2a, 0x31, 0x4b, + 0x3f, 0xdf, 0xd7, 0x8c, 0xf5, 0x8c, 0x17, 0x95, 0xd2, 0x63, 0xf5, 0xa4, 0xf5, 0x9c, 0xbe, 0xff, + 0x7a, 0xce, 0x1c, 0xef, 0xbc, 0xce, 0x17, 0x95, 0x79, 0x9d, 0xfb, 0xb5, 0x38, 0x8d, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbf, 0xa7, 0xff, 0xc7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xef, + 0xff, 0xff, 0xff, 0xf7, 0x1f, 0x8f, 0xff, 0xd7, 0xff, 0xdf, 0xbf, 0xa7, 0xff, 0x26, 0x7f, 0x87, + 0x43, 0x21, 0xc5, 0x31, 0xa9, 0x5a, 0xcc, 0x7b, 0x0b, 0x63, 0x2b, 0x63, 0xc6, 0x31, 0x24, 0x19, + 0xe7, 0x39, 0x88, 0x4a, 0x09, 0x53, 0x27, 0x42, 0x4b, 0x6b, 0x6b, 0x6b, 0x47, 0x42, 0xa4, 0x29, + 0x67, 0x42, 0xf1, 0x9c, 0xc5, 0x31, 0x47, 0x3a, 0x68, 0x4a, 0x6c, 0x6b, 0x0b, 0x5b, 0x6b, 0x6b, + 0xef, 0x83, 0x0c, 0x63, 0xb1, 0x94, 0x50, 0x8c, 0x0b, 0x63, 0x50, 0x8c, 0x10, 0x84, 0x0f, 0x7c, + 0xf3, 0xac, 0x2d, 0x6b, 0x4e, 0x6b, 0x6f, 0x73, 0x11, 0x84, 0x2c, 0x63, 0xce, 0x73, 0xdd, 0xd6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xd6, 0x3e, 0xef, 0xbf, 0xf7, 0xff, 0xff, 0x53, 0x43, + 0xfa, 0x7c, 0x10, 0x12, 0x93, 0x22, 0x71, 0x1a, 0x30, 0x0a, 0x9a, 0x5c, 0x5f, 0xc7, 0x5f, 0xbf, + 0x9f, 0xc7, 0x3f, 0xc7, 0xbf, 0xae, 0x7f, 0x9e, 0xff, 0xae, 0xdf, 0x9e, 0xda, 0x6c, 0x90, 0x22, + 0xb1, 0x2a, 0x4f, 0x22, 0x50, 0x22, 0x94, 0x4b, 0xd7, 0x8c, 0xd5, 0x84, 0x34, 0x74, 0x51, 0x53, + 0xb6, 0x84, 0x59, 0x95, 0xd7, 0x84, 0xff, 0xf7, 0xd9, 0xbd, 0xbf, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0x18, 0xc6, 0x32, 0x7c, 0x74, 0x84, 0x77, 0xa5, 0x95, 0x84, 0xd9, 0xbd, 0x5a, 0xce, 0x5e, 0xef, + 0x5f, 0xf7, 0x3d, 0xef, 0x19, 0xbe, 0x77, 0x9d, 0x74, 0x84, 0x74, 0x7c, 0x96, 0x84, 0x58, 0x95, + 0xdf, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x9f, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xd7, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x8f, 0x5f, 0xa7, 0xff, 0xff, + 0x6a, 0x63, 0x88, 0x4a, 0xe6, 0x31, 0x23, 0x19, 0x22, 0x11, 0x22, 0x19, 0xa5, 0x29, 0x45, 0x21, + 0x64, 0x21, 0x63, 0x21, 0xab, 0x73, 0xe9, 0x5a, 0x09, 0x63, 0xab, 0x7b, 0x2a, 0x63, 0x84, 0x29, + 0x83, 0x19, 0xac, 0x73, 0x27, 0x42, 0x85, 0x29, 0x84, 0x21, 0xa5, 0x29, 0x85, 0x29, 0x89, 0x52, + 0xcd, 0x73, 0x2b, 0x5b, 0xcd, 0x73, 0x50, 0x8c, 0x30, 0x84, 0xeb, 0x5a, 0xb5, 0xb5, 0xf6, 0xbd, + 0xf0, 0x7b, 0x6f, 0x6b, 0xac, 0x52, 0x8f, 0x73, 0x8b, 0x42, 0x8b, 0x4a, 0x29, 0x3a, 0x0c, 0x5b, + 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x5b, 0xc6, 0x7b, 0xc6, 0x18, 0x95, 0xdf, 0xf7, 0xff, 0xff, 0xf8, 0x8c, 0x55, 0x33, + 0x16, 0x5c, 0x10, 0x0a, 0xb2, 0x22, 0x31, 0x12, 0x92, 0x1a, 0xdf, 0xa6, 0xde, 0x85, 0xdf, 0x8d, + 0x3c, 0x7d, 0x9f, 0x9e, 0x7f, 0x96, 0xda, 0x6c, 0xbf, 0xa6, 0xbf, 0xa6, 0x18, 0x8d, 0x18, 0x95, + 0x6f, 0x22, 0xb3, 0x5b, 0x74, 0x84, 0xff, 0xff, 0xff, 0xff, 0xbc, 0xce, 0xf3, 0x63, 0x5a, 0xc6, + 0xbc, 0xce, 0xff, 0xff, 0x9a, 0xce, 0x55, 0x7c, 0x97, 0xad, 0xff, 0xff, 0xd1, 0x73, 0x16, 0xa5, + 0xb4, 0x8c, 0x37, 0x9d, 0x77, 0xa5, 0xb2, 0x63, 0x33, 0x7c, 0xf3, 0x73, 0x36, 0xa5, 0xb8, 0xb5, + 0x34, 0x74, 0x36, 0xa5, 0xd8, 0xb5, 0x9f, 0xf7, 0x73, 0x84, 0x97, 0xad, 0x74, 0x8c, 0xf9, 0xbd, + 0x96, 0x74, 0xda, 0xb5, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xef, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xf7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x96, 0xad, 0x0d, 0x63, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x52, 0x8c, 0xe6, 0x31, 0x4f, 0x8c, + 0xc5, 0x31, 0x87, 0x42, 0xa4, 0x29, 0xa4, 0x29, 0x63, 0x21, 0x83, 0x21, 0x05, 0x32, 0xa4, 0x21, + 0x88, 0x4a, 0x84, 0x21, 0xea, 0x62, 0xc5, 0x31, 0x44, 0x21, 0x22, 0x19, 0x47, 0x42, 0x06, 0x3a, + 0xa4, 0x21, 0x64, 0x21, 0x44, 0x21, 0x27, 0x3a, 0xca, 0x52, 0xe7, 0x39, 0x04, 0x21, 0xeb, 0x5a, + 0x6c, 0x6b, 0x6d, 0x63, 0x07, 0x3a, 0x6d, 0x6b, 0x8e, 0x6b, 0x2d, 0x63, 0x2f, 0x84, 0xad, 0x73, + 0xef, 0x83, 0x30, 0x84, 0x4e, 0x63, 0x0d, 0x5b, 0xaf, 0x73, 0xac, 0x4a, 0xac, 0x4a, 0x09, 0x2a, + 0xcc, 0x4a, 0x35, 0xa5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xef, 0x96, 0x74, + 0x17, 0x8d, 0xb7, 0x84, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xef, 0x39, 0x8d, 0x59, 0x8d, + 0xb9, 0x74, 0x51, 0x12, 0x31, 0x12, 0x72, 0x1a, 0x1c, 0x75, 0x3c, 0x75, 0x5c, 0x85, 0xfb, 0x7c, + 0xdf, 0x8d, 0x7f, 0x9e, 0x5d, 0x85, 0x37, 0x64, 0xf9, 0x7c, 0xb7, 0x7c, 0x37, 0xa5, 0xf9, 0xc5, + 0xd6, 0x8c, 0x57, 0x9d, 0x17, 0xa5, 0xd9, 0xb5, 0xd8, 0xb5, 0x94, 0x8c, 0xff, 0xff, 0x5e, 0xef, + 0xbf, 0xf7, 0x57, 0x9d, 0x7b, 0xd6, 0x7e, 0xf7, 0x3a, 0xc6, 0x7b, 0xc6, 0xce, 0x42, 0xcf, 0x42, + 0xb2, 0x63, 0x16, 0x9d, 0x58, 0xa5, 0x74, 0x84, 0xbc, 0xd6, 0x54, 0x84, 0xf5, 0xa4, 0x16, 0x9d, + 0x36, 0xa5, 0xd8, 0xbd, 0x34, 0x7c, 0x70, 0x63, 0x78, 0xa5, 0xb2, 0x6b, 0x78, 0xad, 0xd5, 0x94, + 0xb9, 0xad, 0x34, 0x6c, 0x39, 0x95, 0x3f, 0xd7, 0xdf, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xef, 0xff, 0xf7, 0xff, 0xff, + 0x97, 0xad, 0x8e, 0x73, 0xff, 0xff, 0x7f, 0xd7, 0xf2, 0x94, 0xe2, 0x29, 0xc3, 0x29, 0x42, 0x19, + 0xa5, 0x29, 0x45, 0x21, 0xc6, 0x31, 0xeb, 0x5a, 0x8a, 0x52, 0xc5, 0x29, 0x05, 0x32, 0x06, 0x32, + 0x63, 0x19, 0x84, 0x21, 0x63, 0x21, 0xe9, 0x5a, 0xa4, 0x31, 0x06, 0x42, 0x06, 0x32, 0x64, 0x21, + 0x22, 0x19, 0x23, 0x19, 0xa5, 0x29, 0x64, 0x21, 0x84, 0x29, 0xea, 0x5a, 0x07, 0x3a, 0x07, 0x3a, + 0xac, 0x73, 0x4c, 0x63, 0xa9, 0x52, 0xc6, 0x31, 0x44, 0x19, 0x6d, 0x6b, 0x51, 0x8c, 0x50, 0x84, + 0xcd, 0x73, 0x0b, 0x5b, 0x49, 0x42, 0x8f, 0x73, 0x0c, 0x5b, 0xed, 0x52, 0x0d, 0x53, 0x2a, 0x3a, + 0x0d, 0x4b, 0x8c, 0x42, 0xaf, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0x7c, 0x5b, 0xc6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xef, 0x57, 0xad, 0x38, 0x95, 0xfc, 0xad, 0x50, 0x12, + 0x0f, 0x02, 0x96, 0x43, 0xb2, 0x22, 0xd6, 0x4b, 0x77, 0x6c, 0x78, 0x9d, 0x7e, 0xe7, 0x3f, 0xd7, + 0xde, 0xc6, 0xff, 0x9d, 0xf6, 0x4b, 0xd4, 0x5b, 0xd3, 0x63, 0x11, 0x4b, 0xae, 0x3a, 0x98, 0xad, + 0xf6, 0x94, 0x13, 0x74, 0x36, 0x95, 0x14, 0x74, 0xcf, 0x42, 0x1a, 0xbe, 0xdb, 0xce, 0x91, 0x5b, + 0x9b, 0xce, 0x56, 0x9d, 0x16, 0x95, 0xd5, 0x8c, 0x33, 0x74, 0x30, 0x53, 0xeb, 0x19, 0xec, 0x19, + 0x8d, 0x32, 0x30, 0x4b, 0x4f, 0x5b, 0xb0, 0x63, 0x6f, 0x63, 0x90, 0x6b, 0xb1, 0x6b, 0x73, 0x84, + 0x53, 0x7c, 0x74, 0x8c, 0x35, 0xa5, 0xf1, 0x73, 0x97, 0xad, 0x12, 0x7c, 0xf9, 0xbd, 0x13, 0x7c, + 0x33, 0x7c, 0x37, 0x9d, 0x13, 0x74, 0x14, 0x74, 0x34, 0x74, 0x7b, 0xd6, 0x5e, 0xe7, 0xdb, 0xd6, + 0x7c, 0xbe, 0x3f, 0xdf, 0xff, 0xf7, 0xdf, 0xe7, 0xf0, 0x73, 0x1a, 0xbe, 0xcf, 0x73, 0xbb, 0xde, + 0x8a, 0x4a, 0xa6, 0x31, 0x91, 0x84, 0x05, 0x22, 0xa2, 0x21, 0x42, 0x19, 0xc2, 0x29, 0x01, 0x32, + 0x68, 0x4a, 0x2c, 0x63, 0x69, 0x4a, 0x48, 0x42, 0xc7, 0x39, 0xa6, 0x31, 0xa7, 0x31, 0xa5, 0x29, + 0x07, 0x3a, 0x64, 0x29, 0x02, 0x19, 0x26, 0x3a, 0x8b, 0x6b, 0x0a, 0x5b, 0xca, 0x5a, 0xa5, 0x29, + 0x85, 0x21, 0x27, 0x42, 0xe6, 0x31, 0xa4, 0x21, 0xa5, 0x29, 0x23, 0x19, 0x06, 0x32, 0xa5, 0x29, + 0xc2, 0x10, 0xe4, 0x18, 0xe7, 0x39, 0xe7, 0x31, 0x25, 0x19, 0xa6, 0x29, 0xcb, 0x5a, 0xae, 0x73, + 0xce, 0x7b, 0x69, 0x42, 0x89, 0x4a, 0x72, 0xb5, 0x6c, 0x7b, 0x2e, 0x5b, 0x4e, 0x63, 0xb1, 0x73, + 0x0e, 0x5b, 0x2e, 0x5b, 0x0b, 0x3a, 0x6f, 0x6b, 0x5d, 0xf7, 0x7e, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x8c, 0xd1, 0x42, 0x51, 0x1a, 0x30, 0x1a, 0xb2, 0x2a, + 0x51, 0x1a, 0x95, 0x43, 0x34, 0x3b, 0xf4, 0x5b, 0x99, 0xad, 0xd4, 0x5b, 0x55, 0x74, 0x36, 0xa5, + 0xff, 0xff, 0x1e, 0xd7, 0x52, 0x43, 0xb0, 0x32, 0x8f, 0x32, 0xf0, 0x3a, 0xf6, 0x8c, 0x53, 0x84, + 0x78, 0xa5, 0x30, 0x53, 0x55, 0x74, 0x54, 0x7c, 0xb9, 0xad, 0x91, 0x63, 0x6e, 0x2a, 0xcf, 0x3a, + 0x16, 0x9d, 0xf2, 0x73, 0x51, 0x5b, 0x4c, 0x32, 0xae, 0x4a, 0x71, 0x5b, 0x8c, 0x3a, 0x4c, 0x2a, + 0x6e, 0x3a, 0xb2, 0x63, 0x4f, 0x53, 0x2e, 0x53, 0x50, 0x63, 0xf2, 0x7b, 0xb1, 0x73, 0xd5, 0x94, + 0x37, 0x9d, 0xf2, 0x73, 0x12, 0x7c, 0xf1, 0x73, 0x94, 0x94, 0x98, 0xb5, 0xb8, 0xb5, 0xd6, 0x94, + 0xf6, 0x9c, 0xf6, 0x94, 0x12, 0x74, 0x74, 0x84, 0x56, 0x74, 0x32, 0x43, 0x5b, 0xc6, 0x3a, 0xc6, + 0x5a, 0xce, 0x7b, 0xd6, 0xb8, 0xbd, 0xd4, 0x94, 0x08, 0x42, 0xd7, 0xbd, 0xb7, 0xb5, 0xb1, 0x8c, + 0xe7, 0x31, 0x61, 0x21, 0x81, 0x21, 0xa0, 0x29, 0xa1, 0x21, 0xe1, 0x29, 0x81, 0x21, 0xe2, 0x29, + 0x22, 0x19, 0x23, 0x19, 0x23, 0x19, 0x23, 0x21, 0x03, 0x19, 0x44, 0x21, 0x44, 0x21, 0xc6, 0x31, + 0x03, 0x19, 0xa7, 0x31, 0x03, 0x19, 0xe9, 0x5a, 0x09, 0x5b, 0x03, 0x21, 0xc6, 0x39, 0x68, 0x4a, + 0x63, 0x19, 0x68, 0x42, 0x67, 0x3a, 0x06, 0x3a, 0xa5, 0x29, 0x63, 0x21, 0x83, 0x21, 0x65, 0x21, + 0x03, 0x11, 0xe3, 0x10, 0xe6, 0x31, 0x8d, 0x6b, 0x45, 0x21, 0x04, 0x19, 0x86, 0x21, 0xc8, 0x31, + 0xa7, 0x29, 0x8a, 0x42, 0x0f, 0x7c, 0xee, 0x7b, 0x0a, 0x5b, 0x49, 0x3a, 0xec, 0x52, 0xd0, 0x73, + 0x93, 0x8c, 0xed, 0x52, 0xed, 0x52, 0x6b, 0x42, 0x4e, 0x5b, 0xdb, 0xe6, 0xff, 0xff, 0xde, 0xff, + 0xff, 0xff, 0x9b, 0xde, 0xf3, 0x6b, 0xb2, 0x22, 0x30, 0x0a, 0x0f, 0x0a, 0x34, 0x3b, 0x55, 0x43, + 0xce, 0x01, 0xee, 0x01, 0xf2, 0x3a, 0x15, 0x74, 0xd7, 0x8c, 0x5b, 0xbe, 0x14, 0x6c, 0x95, 0x84, + 0xb2, 0x63, 0xb4, 0x8c, 0x95, 0x7c, 0xcc, 0x11, 0x8c, 0x01, 0x10, 0x43, 0x30, 0x53, 0x92, 0x5b, + 0x0f, 0x4b, 0xd2, 0x63, 0xb5, 0x8c, 0x37, 0x9d, 0x51, 0x5b, 0xcb, 0x19, 0x8b, 0x09, 0xcf, 0x3a, + 0xcf, 0x42, 0xb2, 0x63, 0x4d, 0x32, 0x10, 0x4b, 0x4c, 0x2a, 0x4c, 0x2a, 0x2b, 0x2a, 0x0b, 0x2a, + 0x8d, 0x32, 0xca, 0x21, 0x2b, 0x2a, 0xee, 0x42, 0xd1, 0x6b, 0xad, 0x42, 0xb0, 0x63, 0x6f, 0x63, + 0xd4, 0x94, 0xb0, 0x6b, 0x70, 0x63, 0x54, 0x84, 0x53, 0x84, 0xf5, 0xa4, 0x36, 0x9d, 0xf6, 0x94, + 0x33, 0x84, 0x57, 0xa5, 0xf6, 0x8c, 0xf3, 0x6b, 0x91, 0x5b, 0x53, 0x7c, 0x34, 0x74, 0x76, 0x84, + 0x94, 0x8c, 0x71, 0x94, 0xb7, 0xbd, 0x96, 0xb5, 0xab, 0x52, 0x95, 0xb5, 0x83, 0x21, 0xe0, 0x29, + 0xe0, 0x29, 0xc0, 0x21, 0xa0, 0x21, 0xc0, 0x29, 0x60, 0x19, 0x01, 0x2a, 0xa0, 0x21, 0xc1, 0x29, + 0xe4, 0x18, 0xc2, 0x10, 0xc3, 0x10, 0x44, 0x21, 0x24, 0x21, 0x24, 0x21, 0x44, 0x21, 0x07, 0x3a, + 0xa5, 0x31, 0xc3, 0x10, 0xc4, 0x10, 0x03, 0x11, 0x08, 0x42, 0xe4, 0x18, 0x66, 0x29, 0xe7, 0x31, + 0x69, 0x4a, 0xa5, 0x29, 0x65, 0x21, 0xe4, 0x18, 0x45, 0x21, 0x03, 0x11, 0x45, 0x21, 0xa4, 0x29, + 0x64, 0x21, 0xe3, 0x10, 0xe3, 0x10, 0x45, 0x19, 0xe4, 0x18, 0xe4, 0x10, 0xc5, 0x10, 0x86, 0x29, + 0x2d, 0x63, 0xe8, 0x31, 0x48, 0x3a, 0xc6, 0x29, 0x27, 0x3a, 0xaa, 0x4a, 0xa8, 0x29, 0xe8, 0x31, + 0xd9, 0xbd, 0x11, 0x7c, 0xac, 0x4a, 0xcb, 0x52, 0xc9, 0x29, 0x6e, 0x63, 0x36, 0xad, 0xd8, 0xc5, + 0x7b, 0xd6, 0x13, 0x6c, 0x94, 0x4b, 0x71, 0x22, 0xef, 0x11, 0xef, 0x11, 0x92, 0x2a, 0x0f, 0x0a, + 0xce, 0x09, 0xb1, 0x22, 0x34, 0x7c, 0x96, 0x7c, 0xcf, 0x3a, 0x33, 0x74, 0x93, 0x5b, 0x8f, 0x3a, + 0xb0, 0x3a, 0x51, 0x53, 0x71, 0x5b, 0xed, 0x19, 0xab, 0x09, 0xae, 0x3a, 0xb3, 0x5b, 0x2d, 0x22, + 0x51, 0x4b, 0x71, 0x5b, 0x6d, 0x3a, 0x30, 0x4b, 0xf3, 0x73, 0x91, 0x63, 0x8b, 0x11, 0x2d, 0x22, + 0x0c, 0x22, 0x8d, 0x32, 0x2d, 0x2a, 0x0f, 0x4b, 0xeb, 0x21, 0x90, 0x63, 0x0f, 0x53, 0x8d, 0x3a, + 0x4b, 0x2a, 0xeb, 0x19, 0x2c, 0x2a, 0x2b, 0x2a, 0xad, 0x3a, 0x6b, 0x32, 0xce, 0x42, 0x70, 0x5b, + 0xad, 0x42, 0xcd, 0x42, 0xee, 0x52, 0xb2, 0x63, 0x0f, 0x53, 0x52, 0x84, 0xf6, 0x9c, 0x13, 0x74, + 0x74, 0x84, 0x12, 0x74, 0xd9, 0xb5, 0x73, 0x7c, 0xf6, 0x8c, 0x53, 0x74, 0xf6, 0x94, 0x73, 0x84, + 0x66, 0x29, 0x44, 0x21, 0xe1, 0x10, 0x06, 0x3a, 0x62, 0x21, 0xa4, 0x42, 0x01, 0x2a, 0xc1, 0x21, + 0x61, 0x21, 0xc0, 0x08, 0xa1, 0x29, 0x61, 0x19, 0xc1, 0x21, 0xa0, 0x21, 0xe2, 0x31, 0xa1, 0x21, + 0x82, 0x08, 0x62, 0x08, 0xa3, 0x10, 0xa2, 0x10, 0x85, 0x29, 0x24, 0x21, 0xa2, 0x08, 0x03, 0x11, + 0xe3, 0x10, 0x04, 0x21, 0x04, 0x19, 0x04, 0x19, 0x86, 0x21, 0xc7, 0x31, 0x26, 0x19, 0xc7, 0x31, + 0xc4, 0x10, 0x83, 0x08, 0xa3, 0x10, 0xa3, 0x10, 0x04, 0x19, 0x65, 0x29, 0x27, 0x3a, 0x06, 0x32, + 0xc5, 0x29, 0x24, 0x19, 0x04, 0x19, 0x24, 0x19, 0x82, 0x08, 0xc4, 0x10, 0xc4, 0x08, 0x45, 0x21, + 0x8a, 0x4a, 0x46, 0x29, 0x04, 0x11, 0x05, 0x19, 0xc7, 0x29, 0xa6, 0x31, 0x45, 0x21, 0x05, 0x11, + 0xd0, 0x73, 0xd3, 0x94, 0xa7, 0x29, 0x2d, 0x5b, 0x2a, 0x3a, 0x09, 0x32, 0x2a, 0x32, 0xf1, 0x7b, + 0x33, 0x74, 0x95, 0x84, 0x52, 0x43, 0xef, 0x09, 0xcf, 0x09, 0xcf, 0x09, 0xad, 0x01, 0x8d, 0x01, + 0xad, 0x01, 0xad, 0x01, 0xac, 0x09, 0xf4, 0x5b, 0x0f, 0x4b, 0x91, 0x5b, 0xcf, 0x3a, 0x13, 0x6c, + 0x91, 0x63, 0x50, 0x5b, 0x74, 0x84, 0x0c, 0x22, 0x30, 0x4b, 0x54, 0x7c, 0xae, 0x32, 0x2d, 0x22, + 0x91, 0x5b, 0xae, 0x32, 0xcf, 0x3a, 0xef, 0x42, 0xb5, 0x8c, 0x30, 0x53, 0x8a, 0x11, 0x2d, 0x2a, + 0x4c, 0x2a, 0xae, 0x42, 0xab, 0x11, 0xab, 0x19, 0xae, 0x3a, 0x0f, 0x53, 0x6c, 0x32, 0xaa, 0x19, + 0xeb, 0x21, 0x4c, 0x2a, 0x4c, 0x32, 0x50, 0x4b, 0x0a, 0x2a, 0x6c, 0x32, 0x4b, 0x32, 0x6c, 0x42, + 0x50, 0x5b, 0xad, 0x3a, 0xae, 0x3a, 0xec, 0x4a, 0x8d, 0x3a, 0xb0, 0x6b, 0xb5, 0x8c, 0x73, 0x84, + 0x57, 0x9d, 0xf3, 0x6b, 0xf6, 0x8c, 0x92, 0x6b, 0xd2, 0x63, 0x0e, 0x53, 0xcb, 0x52, 0x49, 0x42, + 0x41, 0x08, 0xc6, 0x31, 0x63, 0x21, 0x03, 0x2a, 0xe0, 0x29, 0xe0, 0x29, 0x80, 0x11, 0x61, 0x19, + 0x02, 0x11, 0x20, 0x11, 0xe0, 0x10, 0xa2, 0x21, 0x60, 0x19, 0xa1, 0x21, 0x60, 0x19, 0x41, 0x19, + 0xc3, 0x18, 0x62, 0x08, 0x42, 0x08, 0x62, 0x08, 0xa3, 0x10, 0x82, 0x08, 0x83, 0x10, 0xa2, 0x08, + 0xc3, 0x18, 0xe3, 0x18, 0x04, 0x19, 0x82, 0x00, 0x04, 0x19, 0x27, 0x3a, 0xca, 0x5a, 0x4b, 0x6b, + 0x8a, 0x52, 0xa3, 0x10, 0xe4, 0x18, 0x83, 0x08, 0x04, 0x21, 0x86, 0x29, 0xc4, 0x18, 0xa6, 0x29, + 0x44, 0x21, 0x65, 0x29, 0xa6, 0x29, 0x04, 0x19, 0x45, 0x21, 0xa3, 0x08, 0xc4, 0x10, 0xe4, 0x10, + 0xe8, 0x39, 0x69, 0x4a, 0x66, 0x21, 0xc4, 0x08, 0x05, 0x19, 0x49, 0x3a, 0xe8, 0x31, 0x86, 0x21, + 0x67, 0x21, 0x31, 0x7c, 0x8b, 0x4a, 0xce, 0x6b, 0xab, 0x52, 0xeb, 0x52, 0x6a, 0x3a, 0x88, 0x21, + 0xd2, 0x6b, 0x55, 0x74, 0x2f, 0x12, 0xae, 0x01, 0xaf, 0x01, 0xae, 0x01, 0x6d, 0x01, 0x6c, 0x01, + 0xad, 0x01, 0xed, 0x09, 0x8f, 0x22, 0x2e, 0x22, 0xcf, 0x3a, 0x4e, 0x22, 0x51, 0x53, 0xee, 0x42, + 0x53, 0x7c, 0x2f, 0x53, 0xee, 0x4a, 0xaa, 0x09, 0xcf, 0x3a, 0x30, 0x53, 0xcf, 0x42, 0xab, 0x11, + 0x0f, 0x43, 0x2d, 0x22, 0x6a, 0x11, 0xab, 0x11, 0xd3, 0x63, 0xcb, 0x19, 0x6b, 0x09, 0xaa, 0x11, + 0xad, 0x3a, 0x30, 0x53, 0xcb, 0x19, 0x0c, 0x2a, 0xab, 0x11, 0x2c, 0x2a, 0x4c, 0x32, 0xca, 0x19, + 0xaa, 0x19, 0xeb, 0x21, 0x0b, 0x2a, 0xc9, 0x21, 0xeb, 0x19, 0x0b, 0x22, 0x2c, 0x2a, 0xef, 0x42, + 0x6d, 0x3a, 0x0b, 0x22, 0x0a, 0x2a, 0xa1, 0x10, 0x49, 0x3a, 0xce, 0x42, 0x6f, 0x5b, 0x12, 0x74, + 0x70, 0x5b, 0x12, 0x6c, 0x90, 0x63, 0xf1, 0x73, 0xaa, 0x4a, 0x81, 0x08, 0xe7, 0x39, 0x42, 0x19, + 0xe2, 0x31, 0xe2, 0x29, 0xc2, 0x29, 0x60, 0x19, 0xa1, 0x21, 0x61, 0x21, 0x81, 0x21, 0xa0, 0x19, + 0xe1, 0x29, 0xa0, 0x19, 0xa1, 0x21, 0xc0, 0x08, 0x22, 0x19, 0x00, 0x11, 0x21, 0x19, 0x61, 0x19, + 0x62, 0x00, 0xa3, 0x10, 0x42, 0x00, 0x42, 0x08, 0x82, 0x08, 0xa3, 0x18, 0x22, 0x00, 0x63, 0x08, + 0x04, 0x21, 0xe3, 0x18, 0x24, 0x21, 0xa3, 0x10, 0xc2, 0x10, 0x43, 0x19, 0x66, 0x42, 0xc6, 0x39, + 0xc9, 0x5a, 0x48, 0x4a, 0x62, 0x08, 0xa2, 0x10, 0x47, 0x42, 0x04, 0x21, 0x04, 0x19, 0x6a, 0x4a, + 0xa3, 0x10, 0xa3, 0x10, 0xe3, 0x10, 0xe3, 0x10, 0x45, 0x19, 0xa3, 0x08, 0xe4, 0x10, 0xc4, 0x10, + 0xe3, 0x10, 0x45, 0x21, 0xa3, 0x08, 0x05, 0x19, 0xa6, 0x29, 0x45, 0x21, 0x86, 0x21, 0x6a, 0x4a, + 0x86, 0x29, 0x25, 0x19, 0x52, 0x84, 0x75, 0xad, 0xd2, 0x94, 0x6a, 0x42, 0xeb, 0x52, 0x46, 0x19, + 0x88, 0x19, 0xaa, 0x11, 0xae, 0x01, 0xae, 0x01, 0x8d, 0x01, 0x6d, 0x01, 0x4c, 0x01, 0x8d, 0x01, + 0x8b, 0x01, 0xed, 0x09, 0x2e, 0x1a, 0xac, 0x01, 0x4d, 0x22, 0x0b, 0x1a, 0x4c, 0x22, 0xaa, 0x09, + 0x30, 0x53, 0xcf, 0x42, 0xab, 0x11, 0xab, 0x09, 0xeb, 0x19, 0x91, 0x5b, 0x0c, 0x22, 0xce, 0x42, + 0x49, 0x01, 0x2a, 0x01, 0x0d, 0x22, 0x4a, 0x09, 0xae, 0x3a, 0xcb, 0x11, 0x09, 0x01, 0x6a, 0x01, + 0x2b, 0x22, 0xf2, 0x6b, 0x69, 0x09, 0xeb, 0x21, 0xaa, 0x19, 0x8a, 0x19, 0x48, 0x09, 0x49, 0x11, + 0xaa, 0x11, 0x69, 0x11, 0xaa, 0x11, 0xea, 0x29, 0x6c, 0x3a, 0xca, 0x19, 0xee, 0x42, 0x0f, 0x4b, + 0x88, 0x09, 0x0b, 0x22, 0x02, 0x11, 0x40, 0x08, 0x04, 0x32, 0xaa, 0x3a, 0x4f, 0x5b, 0xe8, 0x31, + 0x50, 0x53, 0x91, 0x5b, 0xf1, 0x6b, 0x40, 0x00, 0x02, 0x19, 0x60, 0x00, 0x22, 0x19, 0x40, 0x19, + 0xa0, 0x21, 0xc0, 0x21, 0xa0, 0x21, 0x81, 0x21, 0x40, 0x19, 0xa1, 0x08, 0x01, 0x19, 0x61, 0x21, + 0x20, 0x19, 0xe2, 0x18, 0x00, 0x11, 0x02, 0x19, 0x40, 0x08, 0xa0, 0x08, 0xc1, 0x08, 0xa1, 0x10, + 0xe4, 0x18, 0x61, 0x08, 0xc4, 0x18, 0xc3, 0x18, 0xa6, 0x31, 0xa9, 0x52, 0x44, 0x21, 0x83, 0x08, + 0x04, 0x21, 0x85, 0x31, 0x04, 0x21, 0xc3, 0x18, 0xc3, 0x10, 0xa2, 0x08, 0xe6, 0x39, 0x05, 0x3a, + 0x67, 0x4a, 0x6a, 0x6b, 0x04, 0x21, 0xc3, 0x10, 0x04, 0x19, 0x23, 0x21, 0xa9, 0x52, 0x86, 0x29, + 0xc3, 0x10, 0xc3, 0x10, 0xc3, 0x10, 0xa3, 0x10, 0x45, 0x21, 0x24, 0x19, 0xc4, 0x10, 0x04, 0x19, + 0x66, 0x21, 0xc3, 0x08, 0x26, 0x19, 0xe4, 0x10, 0x05, 0x19, 0xc4, 0x10, 0xc8, 0x31, 0x25, 0x19, + 0x0a, 0x3a, 0x46, 0x19, 0x88, 0x29, 0x2d, 0x63, 0xf7, 0xbd, 0x2d, 0x5b, 0xc8, 0x31, 0x68, 0x21, + 0x47, 0x19, 0x67, 0x19, 0x69, 0x11, 0xad, 0x01, 0xae, 0x01, 0x4b, 0x01, 0x6c, 0x01, 0xac, 0x01, + 0xcd, 0x01, 0x2d, 0x12, 0x4e, 0x22, 0x8b, 0x01, 0x4b, 0x01, 0x6b, 0x01, 0x4a, 0x01, 0x6b, 0x01, + 0xd2, 0x63, 0x8c, 0x3a, 0x8d, 0x53, 0x31, 0x6c, 0xee, 0x4a, 0x4d, 0x32, 0xad, 0x3a, 0xcb, 0x19, + 0x2a, 0x01, 0x49, 0x01, 0xce, 0x42, 0xce, 0x3a, 0xca, 0x11, 0x29, 0x01, 0x29, 0x01, 0xcb, 0x19, + 0xea, 0x19, 0x6b, 0x32, 0x8a, 0x11, 0x69, 0x11, 0x8a, 0x19, 0x69, 0x11, 0x6a, 0x11, 0x28, 0x09, + 0x69, 0x11, 0x28, 0x09, 0x69, 0x09, 0x2b, 0x2a, 0x2b, 0x2a, 0x89, 0x01, 0xeb, 0x19, 0x89, 0x11, + 0x8a, 0x11, 0x08, 0x2a, 0xa1, 0x10, 0x82, 0x10, 0x62, 0x21, 0x47, 0x32, 0x4b, 0x42, 0x40, 0x08, + 0xcd, 0x4a, 0xcd, 0x4a, 0xec, 0x52, 0x40, 0x00, 0x02, 0x19, 0x21, 0x19, 0xc1, 0x29, 0xa1, 0x21, + 0x61, 0x21, 0x81, 0x21, 0x22, 0x19, 0xc2, 0x10, 0x21, 0x21, 0x00, 0x19, 0x61, 0x21, 0xe1, 0x18, + 0x80, 0x10, 0xa0, 0x08, 0x01, 0x19, 0x00, 0x19, 0xa0, 0x10, 0xa0, 0x08, 0x02, 0x19, 0x21, 0x08, + 0x41, 0x08, 0x45, 0x29, 0x04, 0x21, 0xa2, 0x10, 0x43, 0x21, 0x04, 0x21, 0xe3, 0x18, 0x04, 0x19, + 0x65, 0x29, 0x45, 0x21, 0xa2, 0x10, 0xa2, 0x10, 0xc3, 0x10, 0xe3, 0x10, 0x44, 0x21, 0x48, 0x42, + 0x85, 0x29, 0x67, 0x4a, 0xc2, 0x18, 0xe3, 0x10, 0x65, 0x29, 0x64, 0x29, 0xc2, 0x10, 0x85, 0x29, + 0xa2, 0x10, 0xa2, 0x10, 0xe4, 0x10, 0x04, 0x19, 0x82, 0x08, 0xc3, 0x10, 0xc3, 0x08, 0xc3, 0x10, + 0x04, 0x11, 0xc4, 0x10, 0xa3, 0x08, 0xe4, 0x10, 0x25, 0x19, 0xe5, 0x10, 0xc6, 0x29, 0xaa, 0x4a, + 0x25, 0x19, 0xe8, 0x31, 0x28, 0x3a, 0x25, 0x11, 0x75, 0xad, 0xb3, 0x94, 0x2a, 0x3a, 0xc8, 0x29, + 0x09, 0x32, 0x06, 0x11, 0x88, 0x21, 0x47, 0x09, 0x6c, 0x01, 0x8c, 0x01, 0xcd, 0x09, 0xac, 0x01, + 0xec, 0x09, 0xed, 0x11, 0xae, 0x2a, 0x4b, 0x01, 0x4b, 0x01, 0x2a, 0x01, 0x29, 0x01, 0xcb, 0x11, + 0xee, 0x42, 0x6e, 0x53, 0xed, 0x5b, 0x6e, 0x5b, 0x4f, 0x53, 0xeb, 0x11, 0xcb, 0x11, 0x49, 0x01, + 0x09, 0x01, 0x49, 0x09, 0x2c, 0x22, 0xaa, 0x11, 0x69, 0x01, 0x49, 0x09, 0x48, 0x01, 0xaa, 0x11, + 0xeb, 0x11, 0x4e, 0x4b, 0x0b, 0x22, 0xeb, 0x21, 0xeb, 0x21, 0xeb, 0x21, 0x48, 0x09, 0x49, 0x09, + 0x48, 0x09, 0x0b, 0x2a, 0x89, 0x11, 0x89, 0x11, 0xac, 0x42, 0x89, 0x11, 0x89, 0x09, 0x8a, 0x11, + 0x49, 0x11, 0x85, 0x21, 0x41, 0x00, 0x61, 0x08, 0x01, 0x11, 0x25, 0x32, 0x04, 0x11, 0x21, 0x08, + 0xe7, 0x29, 0xe8, 0x31, 0xc2, 0x21, 0xc1, 0x29, 0xe1, 0x29, 0x81, 0x21, 0x81, 0x19, 0x81, 0x21, + 0xc2, 0x29, 0x81, 0x21, 0x21, 0x11, 0xe0, 0x08, 0x40, 0x19, 0x62, 0x21, 0xe0, 0x10, 0xe1, 0x10, + 0x80, 0x08, 0x02, 0x19, 0xa1, 0x08, 0xa1, 0x10, 0x22, 0x19, 0x22, 0x19, 0x20, 0x00, 0x20, 0x00, + 0xe3, 0x18, 0xe4, 0x18, 0xc3, 0x18, 0xa2, 0x10, 0xc3, 0x18, 0xe3, 0x10, 0xa5, 0x29, 0x07, 0x32, + 0xc3, 0x10, 0xe3, 0x18, 0xc3, 0x10, 0xc3, 0x10, 0xc3, 0x18, 0xa2, 0x10, 0xe3, 0x18, 0xa2, 0x08, + 0xc3, 0x18, 0xe9, 0x5a, 0xe6, 0x39, 0x83, 0x08, 0x04, 0x21, 0xc3, 0x10, 0xa3, 0x10, 0xa2, 0x10, + 0x45, 0x29, 0x04, 0x19, 0xc3, 0x10, 0xe3, 0x10, 0x24, 0x19, 0xa2, 0x08, 0x04, 0x19, 0xe3, 0x10, + 0xc4, 0x10, 0xe4, 0x10, 0xc4, 0x10, 0xe4, 0x10, 0xc3, 0x10, 0x25, 0x19, 0x45, 0x19, 0x27, 0x42, + 0x65, 0x29, 0x66, 0x21, 0xc8, 0x31, 0xe8, 0x31, 0x09, 0x3a, 0x18, 0xc6, 0x6b, 0x42, 0xcc, 0x52, + 0x8b, 0x4a, 0xe9, 0x31, 0x46, 0x19, 0x26, 0x11, 0x48, 0x09, 0x2d, 0x1a, 0x2d, 0x12, 0x6e, 0x22, + 0x4d, 0x1a, 0x8e, 0x32, 0x8f, 0x4b, 0x6c, 0x2a, 0xd0, 0x32, 0xab, 0x09, 0x0c, 0x12, 0x4b, 0x22, + 0xee, 0x63, 0x8c, 0x4b, 0x4b, 0x2a, 0x0e, 0x4b, 0xad, 0x42, 0xb1, 0x5b, 0xcb, 0x11, 0x69, 0x09, + 0x8a, 0x11, 0x6a, 0x09, 0x4c, 0x22, 0xeb, 0x19, 0x49, 0x09, 0x49, 0x01, 0x69, 0x01, 0x2b, 0x1a, + 0xab, 0x19, 0x0b, 0x2a, 0x4c, 0x32, 0x69, 0x09, 0x69, 0x09, 0x89, 0x11, 0x89, 0x11, 0x69, 0x09, + 0x69, 0x11, 0x89, 0x11, 0x89, 0x11, 0xca, 0x21, 0x6c, 0x3a, 0xea, 0x21, 0xa9, 0x09, 0xa9, 0x19, + 0xe8, 0x21, 0x22, 0x19, 0x62, 0x08, 0x20, 0x00, 0xc1, 0x10, 0x62, 0x19, 0x43, 0x21, 0xa1, 0x10, + 0xc1, 0x29, 0xc0, 0x29, 0xa2, 0x29, 0x20, 0x11, 0x20, 0x11, 0x61, 0x21, 0xe2, 0x18, 0x41, 0x21, + 0x42, 0x21, 0x22, 0x19, 0x61, 0x21, 0xa0, 0x08, 0xc1, 0x10, 0xc1, 0x10, 0xa3, 0x21, 0x60, 0x21, + 0x42, 0x21, 0x82, 0x29, 0x21, 0x19, 0x02, 0x19, 0xe1, 0x18, 0xe1, 0x18, 0x41, 0x08, 0x81, 0x10, + 0x82, 0x08, 0xc3, 0x10, 0xa2, 0x10, 0xc3, 0x10, 0xa2, 0x08, 0xa2, 0x08, 0xa2, 0x08, 0x82, 0x08, + 0x81, 0x08, 0xa3, 0x10, 0xc2, 0x10, 0xc3, 0x10, 0x82, 0x10, 0xe2, 0x18, 0x84, 0x29, 0xa2, 0x10, + 0x02, 0x11, 0x83, 0x21, 0x06, 0x3a, 0xe3, 0x10, 0x82, 0x10, 0xc3, 0x10, 0xa2, 0x10, 0xc3, 0x18, + 0xa2, 0x10, 0x82, 0x08, 0xe3, 0x10, 0xe3, 0x10, 0xc2, 0x08, 0xa5, 0x29, 0x23, 0x19, 0x27, 0x3a, + 0xc2, 0x08, 0xe4, 0x10, 0x82, 0x08, 0xe4, 0x18, 0xc3, 0x08, 0xe4, 0x10, 0xc4, 0x10, 0x45, 0x19, + 0x48, 0x42, 0xe4, 0x10, 0x05, 0x11, 0x08, 0x3a, 0x28, 0x3a, 0x6e, 0x6b, 0x0d, 0x5b, 0x67, 0x21, + 0x2c, 0x5b, 0x67, 0x21, 0x87, 0x21, 0x2a, 0x3a, 0x25, 0x11, 0x47, 0x09, 0x11, 0x64, 0x75, 0x95, + 0xcd, 0x32, 0xb0, 0x5b, 0x4d, 0x43, 0x6e, 0x4b, 0x8c, 0x2a, 0x6d, 0x2a, 0x4b, 0x22, 0xad, 0x32, + 0xed, 0x3a, 0xeb, 0x19, 0xeb, 0x11, 0x2d, 0x4b, 0x72, 0x74, 0x4c, 0x32, 0x69, 0x01, 0x8a, 0x11, + 0x4c, 0x22, 0xeb, 0x19, 0x0b, 0x1a, 0x89, 0x09, 0x48, 0x01, 0x28, 0x01, 0x48, 0x09, 0xca, 0x19, + 0xea, 0x21, 0x6c, 0x3a, 0xcd, 0x42, 0xca, 0x21, 0x27, 0x01, 0x48, 0x09, 0x89, 0x11, 0x69, 0x11, + 0x48, 0x09, 0x89, 0x11, 0x48, 0x09, 0xeb, 0x21, 0xea, 0x21, 0x0b, 0x22, 0xa9, 0x09, 0x8c, 0x32, + 0xe9, 0x21, 0x02, 0x11, 0x21, 0x00, 0x20, 0x08, 0xa1, 0x10, 0xe2, 0x29, 0x80, 0x19, 0x81, 0x21, + 0xe1, 0x21, 0xe1, 0x29, 0x61, 0x19, 0x22, 0x19, 0x02, 0x19, 0x41, 0x21, 0x01, 0x19, 0x23, 0x21, + 0x01, 0x19, 0x62, 0x21, 0x01, 0x11, 0x02, 0x11, 0xe0, 0x08, 0x82, 0x21, 0x40, 0x19, 0x60, 0x21, + 0x61, 0x19, 0x61, 0x19, 0xc1, 0x21, 0x41, 0x21, 0x83, 0x21, 0x22, 0x19, 0x01, 0x11, 0x02, 0x19, + 0x82, 0x10, 0x04, 0x19, 0xe3, 0x18, 0x03, 0x19, 0x44, 0x21, 0xe3, 0x18, 0xc3, 0x10, 0xa2, 0x08, + 0x03, 0x19, 0xe2, 0x10, 0x04, 0x19, 0xc3, 0x18, 0xc3, 0x10, 0xe2, 0x10, 0x64, 0x21, 0xe3, 0x10, + 0xc3, 0x10, 0x23, 0x19, 0xe3, 0x10, 0xe4, 0x18, 0x04, 0x21, 0x82, 0x08, 0xa2, 0x10, 0xa3, 0x10, + 0xc3, 0x18, 0xa2, 0x10, 0xe3, 0x18, 0xe3, 0x18, 0x25, 0x21, 0xe3, 0x10, 0x04, 0x19, 0x65, 0x21, + 0x04, 0x11, 0xc3, 0x10, 0x04, 0x19, 0xe4, 0x18, 0x04, 0x19, 0xe3, 0x10, 0x04, 0x19, 0xe4, 0x10, + 0x86, 0x29, 0x86, 0x29, 0x25, 0x19, 0x86, 0x21, 0x66, 0x21, 0xcb, 0x52, 0x6e, 0x63, 0x47, 0x21, + 0x2c, 0x5b, 0x05, 0x11, 0xa7, 0x21, 0x09, 0x32, 0x28, 0x32, 0x87, 0x19, 0x6d, 0x5b, 0x50, 0x6c, + 0x70, 0x74, 0xad, 0x5b, 0x4d, 0x43, 0x8c, 0x2a, 0xee, 0x42, 0x76, 0x9d, 0x4d, 0x4b, 0x0c, 0x3b, + 0x8b, 0x32, 0x32, 0x74, 0xf8, 0xb5, 0x58, 0xbe, 0x4e, 0x53, 0xa9, 0x09, 0xab, 0x11, 0xeb, 0x21, + 0x2b, 0x22, 0x0a, 0x1a, 0x89, 0x09, 0x49, 0x01, 0x49, 0x09, 0xa9, 0x19, 0x2c, 0x2a, 0xea, 0x29, + 0xce, 0x42, 0xac, 0x3a, 0xd1, 0x63, 0x69, 0x11, 0x49, 0x09, 0x69, 0x11, 0x48, 0x09, 0xa9, 0x19, + 0x48, 0x11, 0x88, 0x09, 0xaa, 0x19, 0x68, 0x11, 0x0a, 0x2a, 0xaa, 0x11, 0xc9, 0x21, 0x07, 0x2a, + 0x06, 0x2a, 0xa1, 0x10, 0x41, 0x08, 0x21, 0x08, 0x81, 0x10, 0xa2, 0x29, 0x61, 0x21, 0x80, 0x19, + 0x20, 0x2a, 0x61, 0x19, 0x82, 0x21, 0x42, 0x21, 0x02, 0x11, 0x21, 0x19, 0x42, 0x21, 0x21, 0x19, + 0x41, 0x19, 0xa2, 0x21, 0x60, 0x21, 0xc1, 0x21, 0x41, 0x19, 0xa1, 0x21, 0x01, 0x11, 0xc1, 0x10, + 0x42, 0x21, 0x41, 0x19, 0x82, 0x21, 0xa2, 0x21, 0xa2, 0x21, 0x61, 0x21, 0xe4, 0x39, 0xc2, 0x29, + 0xc3, 0x10, 0xa2, 0x10, 0xe3, 0x18, 0x61, 0x08, 0x23, 0x19, 0xc2, 0x10, 0xe2, 0x18, 0xa2, 0x10, + 0x02, 0x19, 0xa2, 0x10, 0xa2, 0x08, 0xe3, 0x18, 0xa2, 0x10, 0xe3, 0x18, 0xc3, 0x10, 0x61, 0x08, + 0xc2, 0x08, 0xc6, 0x31, 0xe2, 0x10, 0x23, 0x21, 0x63, 0x21, 0x65, 0x29, 0x62, 0x08, 0xc3, 0x18, + 0xa2, 0x10, 0x04, 0x21, 0x82, 0x08, 0x04, 0x19, 0xc3, 0x10, 0xa3, 0x10, 0xa2, 0x10, 0xc3, 0x10, + 0xc3, 0x10, 0xe3, 0x10, 0xe4, 0x10, 0xe4, 0x10, 0xc3, 0x10, 0x04, 0x19, 0xe4, 0x10, 0xe4, 0x10, + 0xe3, 0x10, 0x46, 0x21, 0x2d, 0x5b, 0xa7, 0x29, 0x45, 0x19, 0x0d, 0x5b, 0x87, 0x29, 0xd3, 0x94, + 0x29, 0x42, 0xc8, 0x31, 0x87, 0x21, 0xa8, 0x29, 0xaa, 0x42, 0xe8, 0x31, 0x08, 0x32, 0xcf, 0x63, + 0x7a, 0xc6, 0x38, 0xc6, 0x34, 0x9d, 0x35, 0x95, 0x55, 0x9d, 0xef, 0x73, 0x4c, 0x4b, 0xef, 0x63, + 0x70, 0x74, 0xf4, 0x9c, 0x39, 0xc6, 0x75, 0xa5, 0xe9, 0x19, 0x0b, 0x1a, 0x4b, 0x22, 0x0a, 0x22, + 0xcf, 0x63, 0x93, 0x84, 0x2b, 0x2a, 0x68, 0x09, 0x88, 0x09, 0x4a, 0x2a, 0xeb, 0x3a, 0x4c, 0x4b, + 0xab, 0x3a, 0x74, 0x7c, 0xc9, 0x21, 0x68, 0x09, 0x68, 0x09, 0x49, 0x11, 0x68, 0x09, 0x48, 0x09, + 0x48, 0x09, 0x68, 0x09, 0x48, 0x09, 0x4b, 0x32, 0xea, 0x21, 0x29, 0x2a, 0x83, 0x19, 0xe2, 0x10, + 0xc4, 0x29, 0x41, 0x08, 0x20, 0x00, 0x61, 0x08, 0xc1, 0x10, 0xe2, 0x29, 0x41, 0x32, 0xc0, 0x29, + 0xc1, 0x21, 0x80, 0x21, 0xa1, 0x21, 0x81, 0x21, 0x81, 0x19, 0x21, 0x19, 0x81, 0x21, 0x40, 0x19, + 0xa2, 0x21, 0x02, 0x19, 0x21, 0x11, 0xa1, 0x21, 0x40, 0x00, 0x01, 0x19, 0x00, 0x11, 0x81, 0x08, + 0x22, 0x19, 0xe1, 0x18, 0xe0, 0x10, 0x82, 0x21, 0x81, 0x21, 0x62, 0x21, 0x00, 0x11, 0x03, 0x32, + 0xa3, 0x10, 0x61, 0x08, 0x62, 0x08, 0x62, 0x08, 0xc3, 0x18, 0xa2, 0x10, 0x24, 0x21, 0xa2, 0x10, + 0x27, 0x4a, 0xe3, 0x18, 0x82, 0x10, 0xe3, 0x10, 0xc3, 0x18, 0xa2, 0x10, 0xe6, 0x39, 0x49, 0x6b, + 0xc3, 0x10, 0x84, 0x21, 0xa3, 0x10, 0xe3, 0x18, 0x03, 0x19, 0x24, 0x21, 0x04, 0x21, 0x82, 0x08, + 0x04, 0x21, 0xe3, 0x18, 0x45, 0x21, 0xe3, 0x18, 0x04, 0x21, 0xc2, 0x10, 0x44, 0x21, 0xe4, 0x10, + 0x04, 0x19, 0x04, 0x19, 0x04, 0x19, 0xa2, 0x08, 0x04, 0x11, 0x24, 0x19, 0x45, 0x21, 0xe3, 0x10, + 0x05, 0x19, 0xc4, 0x10, 0x04, 0x19, 0x10, 0x7c, 0xab, 0x52, 0xa7, 0x29, 0xcb, 0x52, 0x66, 0x21, + 0x4d, 0x63, 0x8f, 0x73, 0xed, 0x5a, 0x88, 0x21, 0xca, 0x4a, 0xa6, 0x21, 0xaf, 0x6b, 0xc8, 0x29, + 0x55, 0xad, 0x5c, 0xef, 0xfe, 0xff, 0xdd, 0xff, 0x7c, 0xf7, 0xbf, 0xf7, 0x5e, 0xef, 0xdb, 0xde, + 0x1c, 0xdf, 0x5e, 0xe7, 0x39, 0xc6, 0x96, 0xb5, 0x14, 0x9d, 0xf0, 0x6b, 0xce, 0x63, 0x51, 0x7c, + 0xb3, 0x8c, 0x8b, 0x3a, 0xea, 0x21, 0x4a, 0x2a, 0xea, 0x21, 0x8a, 0x32, 0x4b, 0x4b, 0x29, 0x2a, + 0x90, 0x63, 0xcc, 0x42, 0x89, 0x19, 0x69, 0x11, 0x49, 0x09, 0x48, 0x09, 0x48, 0x09, 0x27, 0x09, + 0x69, 0x11, 0x69, 0x11, 0xa8, 0x11, 0x6b, 0x32, 0xe9, 0x21, 0xa5, 0x21, 0x60, 0x08, 0x20, 0x11, + 0xa4, 0x21, 0x82, 0x10, 0x41, 0x08, 0x20, 0x00, 0xc2, 0x18, 0x00, 0x19, 0x42, 0x32, 0x21, 0x32, + 0x61, 0x21, 0xa2, 0x21, 0xa2, 0x29, 0x81, 0x21, 0x22, 0x32, 0x61, 0x19, 0x22, 0x19, 0x01, 0x11, + 0x82, 0x21, 0xa2, 0x21, 0x41, 0x19, 0x81, 0x19, 0x42, 0x19, 0x40, 0x19, 0xa3, 0x29, 0xe1, 0x10, + 0x02, 0x19, 0x81, 0x08, 0xa3, 0x29, 0x42, 0x19, 0x65, 0x3a, 0xe2, 0x29, 0xa2, 0x21, 0x82, 0x32, + 0xa2, 0x08, 0x82, 0x10, 0x61, 0x08, 0x82, 0x10, 0x41, 0x08, 0x03, 0x19, 0xa2, 0x10, 0x44, 0x29, + 0xe3, 0x18, 0x04, 0x19, 0x82, 0x08, 0xe3, 0x18, 0xa1, 0x08, 0x04, 0x21, 0x43, 0x21, 0xc9, 0x5a, + 0xc2, 0x10, 0xc2, 0x18, 0xc3, 0x18, 0x04, 0x21, 0xc2, 0x10, 0x44, 0x21, 0x82, 0x10, 0x04, 0x21, + 0xe3, 0x10, 0x24, 0x21, 0x82, 0x10, 0x04, 0x19, 0xe3, 0x18, 0x23, 0x21, 0xc6, 0x31, 0xe3, 0x18, + 0xc3, 0x10, 0xa3, 0x10, 0x04, 0x19, 0x05, 0x19, 0xa2, 0x08, 0x04, 0x11, 0xc3, 0x10, 0xe4, 0x10, + 0x04, 0x19, 0xe4, 0x10, 0xc3, 0x10, 0x85, 0x29, 0xac, 0x6b, 0x07, 0x3a, 0xe4, 0x10, 0x6a, 0x42, + 0xe6, 0x31, 0x0c, 0x53, 0xf0, 0x7b, 0x08, 0x3a, 0xa6, 0x21, 0x2b, 0x53, 0xa9, 0x3a, 0x2d, 0x53, + 0x68, 0x3a, 0xb6, 0x7d, 0xdb, 0xbe, 0x9d, 0xe7, 0xdd, 0xf7, 0xff, 0xff, 0xfe, 0xff, 0xbe, 0xff, + 0xde, 0xff, 0x9e, 0xff, 0xde, 0xff, 0x9d, 0xff, 0x3b, 0xe7, 0xbe, 0xff, 0xbe, 0xff, 0x5c, 0xf7, + 0x59, 0xce, 0x38, 0xc6, 0x95, 0xad, 0x14, 0x95, 0xd0, 0x6b, 0x6c, 0x53, 0xeb, 0x4a, 0xd4, 0x94, + 0xcc, 0x4a, 0x87, 0x11, 0xaa, 0x42, 0x68, 0x11, 0x27, 0x09, 0x88, 0x19, 0x07, 0x09, 0x08, 0x09, + 0x47, 0x09, 0x68, 0x09, 0x68, 0x11, 0x89, 0x19, 0x46, 0x11, 0xa2, 0x08, 0x40, 0x08, 0x82, 0x21, + 0xa1, 0x08, 0x41, 0x08, 0x20, 0x00, 0x41, 0x08, 0x01, 0x11, 0x43, 0x32, 0xe1, 0x21, 0xc2, 0x29, + 0x81, 0x21, 0x02, 0x19, 0x22, 0x21, 0x62, 0x29, 0x21, 0x19, 0x82, 0x21, 0x41, 0x19, 0x02, 0x19, + 0x60, 0x08, 0x83, 0x29, 0x01, 0x19, 0xe2, 0x18, 0x41, 0x19, 0x41, 0x21, 0xa0, 0x08, 0x01, 0x19, + 0xc0, 0x10, 0x62, 0x19, 0xa1, 0x10, 0x82, 0x29, 0x01, 0x19, 0xe3, 0x31, 0xa2, 0x21, 0x41, 0x19, + 0x87, 0x4a, 0x47, 0x4a, 0xa5, 0x31, 0xa5, 0x31, 0x82, 0x10, 0xe2, 0x10, 0x24, 0x21, 0xe3, 0x18, + 0xc3, 0x10, 0xc3, 0x10, 0x64, 0x29, 0xa3, 0x10, 0xe5, 0x39, 0xe2, 0x18, 0xc2, 0x18, 0x67, 0x4a, + 0x44, 0x29, 0xc2, 0x10, 0x44, 0x21, 0x03, 0x19, 0xc2, 0x10, 0x03, 0x11, 0x45, 0x29, 0xe3, 0x18, + 0xc3, 0x18, 0xa2, 0x10, 0xc3, 0x10, 0xc3, 0x10, 0x24, 0x21, 0x44, 0x29, 0x65, 0x29, 0xc3, 0x10, + 0xe3, 0x18, 0xe3, 0x18, 0xc6, 0x39, 0xc3, 0x10, 0xc3, 0x10, 0xe3, 0x10, 0xe4, 0x10, 0x05, 0x19, + 0x04, 0x19, 0xe4, 0x10, 0x04, 0x19, 0xa3, 0x10, 0x86, 0x29, 0x8b, 0x6b, 0xa6, 0x31, 0xe5, 0x18, + 0x6a, 0x42, 0x47, 0x3a, 0x89, 0x42, 0x8a, 0x42, 0x46, 0x21, 0x04, 0x09, 0x49, 0x32, 0xea, 0x5b, + 0xaa, 0x6c, 0xcf, 0x7c, 0xba, 0x9e, 0x15, 0x05, 0x56, 0x0d, 0xd6, 0x4d, 0x19, 0x6e, 0x3a, 0x7e, + 0xdb, 0x8e, 0xdb, 0x96, 0xfb, 0xae, 0x1a, 0xbf, 0xbe, 0xef, 0xfe, 0xff, 0xfe, 0xff, 0x5a, 0xef, + 0x1a, 0xe7, 0x9c, 0xf7, 0x7c, 0xf7, 0x1a, 0xe7, 0x5c, 0xef, 0x9a, 0xd6, 0x59, 0xce, 0xf7, 0xc5, + 0xf3, 0x9c, 0xee, 0x73, 0x8b, 0x63, 0x89, 0x3a, 0x2a, 0x2a, 0x6a, 0x32, 0x28, 0x09, 0x68, 0x11, + 0x48, 0x11, 0x28, 0x09, 0x88, 0x19, 0x65, 0x21, 0xe5, 0x29, 0x61, 0x08, 0x41, 0x08, 0xe1, 0x18, + 0x81, 0x08, 0x20, 0x00, 0x41, 0x08, 0x40, 0x08, 0x02, 0x19, 0x82, 0x21, 0xa2, 0x29, 0x20, 0x19, + 0x02, 0x19, 0xe1, 0x18, 0x03, 0x19, 0xe1, 0x10, 0x01, 0x11, 0x02, 0x19, 0x43, 0x21, 0xe2, 0x18, + 0x61, 0x10, 0xe2, 0x10, 0x02, 0x19, 0x81, 0x10, 0x22, 0x21, 0x40, 0x00, 0x01, 0x21, 0x62, 0x21, + 0x62, 0x21, 0x20, 0x19, 0x02, 0x19, 0x62, 0x29, 0x43, 0x21, 0xe2, 0x31, 0xc1, 0x10, 0xa0, 0x08, + 0x43, 0x21, 0x45, 0x29, 0xc3, 0x10, 0x44, 0x21, 0x81, 0x10, 0xe3, 0x18, 0xc2, 0x10, 0xc3, 0x18, + 0xa2, 0x10, 0x62, 0x08, 0xe2, 0x18, 0xa2, 0x10, 0xe2, 0x10, 0xa3, 0x10, 0x81, 0x08, 0x84, 0x29, + 0x24, 0x21, 0x03, 0x11, 0xc2, 0x10, 0xa2, 0x08, 0xc2, 0x10, 0x03, 0x19, 0xc2, 0x08, 0xc4, 0x31, + 0xc3, 0x10, 0x03, 0x19, 0xc2, 0x10, 0x03, 0x19, 0xc3, 0x10, 0x44, 0x29, 0x44, 0x21, 0x04, 0x19, + 0xe3, 0x10, 0xe3, 0x18, 0x03, 0x19, 0x24, 0x21, 0xe3, 0x10, 0xe3, 0x10, 0x07, 0x3a, 0xc6, 0x31, + 0x85, 0x29, 0x46, 0x29, 0x65, 0x21, 0xa6, 0x31, 0x44, 0x19, 0x48, 0x42, 0x6b, 0x63, 0xe4, 0x10, + 0xe8, 0x31, 0x09, 0x3a, 0xa6, 0x21, 0xe7, 0x31, 0x68, 0x3a, 0x24, 0x11, 0x86, 0x19, 0xe8, 0x3a, + 0x49, 0x5c, 0x89, 0x6c, 0x32, 0x9d, 0xbe, 0xe7, 0x5a, 0x76, 0x98, 0x05, 0x97, 0x05, 0xd7, 0x05, + 0xd7, 0x0d, 0xf8, 0x15, 0xf7, 0x1d, 0xf7, 0x1d, 0x95, 0x15, 0xb6, 0x1d, 0xf6, 0x45, 0x78, 0x7e, + 0xf9, 0xae, 0x1a, 0xcf, 0xb9, 0xce, 0x3b, 0xe7, 0xd9, 0xde, 0xb9, 0xd6, 0xfa, 0xde, 0x3b, 0xef, + 0xda, 0xde, 0xda, 0xe6, 0x57, 0xd6, 0x73, 0xb5, 0xb0, 0x9c, 0x11, 0x9d, 0xed, 0x73, 0x6b, 0x5b, + 0x4b, 0x4b, 0xab, 0x42, 0xa6, 0x21, 0x01, 0x19, 0xc1, 0x10, 0x41, 0x08, 0x20, 0x00, 0x42, 0x19, + 0x42, 0x19, 0x20, 0x08, 0x20, 0x00, 0x61, 0x08, 0x02, 0x19, 0x01, 0x19, 0xc0, 0x10, 0x42, 0x21, + 0x81, 0x08, 0xe1, 0x18, 0xc1, 0x10, 0xc1, 0x10, 0x42, 0x19, 0x41, 0x08, 0xa1, 0x10, 0xc2, 0x18, + 0xc1, 0x10, 0xa1, 0x10, 0x40, 0x08, 0x61, 0x08, 0x20, 0x00, 0x21, 0x08, 0x80, 0x10, 0xe1, 0x10, + 0xa2, 0x29, 0x63, 0x21, 0xe1, 0x10, 0xe2, 0x18, 0x41, 0x08, 0xc4, 0x31, 0xe2, 0x18, 0x61, 0x08, + 0x03, 0x19, 0xe2, 0x18, 0xe3, 0x18, 0x64, 0x21, 0xa6, 0x39, 0xe3, 0x10, 0x04, 0x21, 0x82, 0x10, + 0xa2, 0x10, 0xc3, 0x18, 0x82, 0x08, 0x64, 0x29, 0xa2, 0x10, 0xa3, 0x10, 0xa3, 0x10, 0x23, 0x21, + 0xc3, 0x18, 0xa2, 0x10, 0x23, 0x19, 0xe2, 0x10, 0xe3, 0x18, 0xa3, 0x10, 0xc3, 0x18, 0x63, 0x29, + 0xc3, 0x18, 0xe3, 0x18, 0xe4, 0x18, 0xe3, 0x18, 0xc3, 0x18, 0x65, 0x29, 0x24, 0x21, 0xa2, 0x10, + 0x04, 0x21, 0xe3, 0x18, 0x04, 0x21, 0x04, 0x19, 0xc3, 0x18, 0xa2, 0x10, 0xa6, 0x31, 0xae, 0x73, + 0x8d, 0x6b, 0x68, 0x42, 0x0a, 0x5b, 0x88, 0x42, 0xa9, 0x4a, 0xe9, 0x52, 0xea, 0x6b, 0x6b, 0x63, + 0x04, 0x21, 0x49, 0x42, 0x07, 0x32, 0x2a, 0x53, 0xab, 0x5b, 0x68, 0x3a, 0xa8, 0x42, 0x8c, 0x6b, + 0x48, 0x53, 0x0e, 0x8d, 0xf9, 0xde, 0xde, 0xff, 0xbe, 0xef, 0x39, 0x5e, 0x99, 0x05, 0xf8, 0x05, + 0x19, 0x06, 0x19, 0x16, 0x39, 0x1e, 0x18, 0x16, 0xf7, 0x0d, 0xd7, 0x05, 0xf7, 0x15, 0xd6, 0x15, + 0xf6, 0x15, 0xf6, 0x0d, 0xd6, 0x25, 0xf5, 0x3d, 0x58, 0x7e, 0xba, 0xc6, 0x9c, 0xf7, 0x1a, 0xe7, + 0xd9, 0xe6, 0xf9, 0xe6, 0xb8, 0xe6, 0x97, 0xde, 0x98, 0xe6, 0xb7, 0xde, 0xd8, 0xee, 0xb0, 0x9c, + 0x6b, 0x73, 0xf4, 0xcd, 0x8c, 0x73, 0x02, 0x19, 0x82, 0x10, 0x21, 0x08, 0x41, 0x08, 0x62, 0x21, + 0xa0, 0x08, 0x21, 0x08, 0x41, 0x08, 0x23, 0x21, 0xc1, 0x10, 0xc3, 0x31, 0x23, 0x21, 0x22, 0x21, + 0xc1, 0x10, 0xe1, 0x18, 0x81, 0x10, 0xc2, 0x10, 0x02, 0x19, 0x41, 0x08, 0xe2, 0x18, 0xa1, 0x10, + 0xe1, 0x10, 0x61, 0x08, 0x20, 0x08, 0x20, 0x00, 0x41, 0x08, 0x21, 0x08, 0x41, 0x08, 0x01, 0x19, + 0x01, 0x19, 0xc7, 0x52, 0x83, 0x29, 0xa1, 0x10, 0x61, 0x10, 0x03, 0x21, 0x44, 0x29, 0x03, 0x21, + 0xc2, 0x10, 0xa2, 0x10, 0x03, 0x19, 0x44, 0x29, 0xc2, 0x10, 0xe3, 0x10, 0xe3, 0x18, 0x82, 0x10, + 0xa2, 0x10, 0x23, 0x21, 0xc2, 0x10, 0xe3, 0x18, 0x82, 0x10, 0xe3, 0x10, 0xc3, 0x10, 0xe2, 0x18, + 0x81, 0x08, 0xc2, 0x10, 0xa5, 0x31, 0xe3, 0x18, 0x82, 0x08, 0xe3, 0x18, 0xc2, 0x10, 0x45, 0x29, + 0xe3, 0x18, 0x23, 0x21, 0x84, 0x29, 0xe3, 0x18, 0xc2, 0x10, 0x23, 0x21, 0xc3, 0x18, 0x04, 0x21, + 0xc3, 0x10, 0xe3, 0x18, 0x65, 0x29, 0xe4, 0x18, 0x24, 0x21, 0xc3, 0x10, 0xc2, 0x08, 0x8c, 0x63, + 0xe9, 0x84, 0x48, 0x5b, 0xe6, 0x29, 0x6a, 0x63, 0x2c, 0x7c, 0xca, 0x63, 0xc7, 0x4a, 0x27, 0x53, + 0x8a, 0x5b, 0x67, 0x42, 0x86, 0x29, 0xe8, 0x4a, 0x08, 0x64, 0xcc, 0x7b, 0x72, 0xad, 0x57, 0xd6, + 0x98, 0xde, 0x9c, 0xff, 0xfc, 0xff, 0x9c, 0xff, 0xdd, 0xff, 0xfe, 0xf7, 0xfb, 0x9e, 0xf8, 0x05, + 0x19, 0x06, 0x3a, 0x0e, 0x39, 0x0e, 0x5a, 0x16, 0x19, 0x0e, 0x39, 0x06, 0x38, 0x16, 0x38, 0x16, + 0xf7, 0x15, 0xf7, 0x1d, 0xd6, 0x05, 0xb6, 0x1d, 0x95, 0x15, 0x95, 0x05, 0xb4, 0x45, 0x98, 0xa6, + 0xd9, 0xde, 0x1a, 0xf7, 0x97, 0xe6, 0x77, 0xde, 0xb3, 0xc5, 0xaf, 0x9c, 0x0d, 0x84, 0xa8, 0x52, + 0x61, 0x00, 0x6b, 0x6b, 0x40, 0x19, 0x41, 0x21, 0x41, 0x08, 0x41, 0x08, 0x61, 0x08, 0x60, 0x08, + 0x41, 0x08, 0x21, 0x08, 0x21, 0x00, 0x60, 0x08, 0x80, 0x08, 0xa2, 0x29, 0x41, 0x21, 0x03, 0x19, + 0x01, 0x19, 0xe1, 0x10, 0xc1, 0x10, 0x40, 0x08, 0xc1, 0x10, 0xe2, 0x10, 0xc1, 0x10, 0x02, 0x21, + 0x82, 0x21, 0xa1, 0x08, 0x20, 0x00, 0x21, 0x08, 0x20, 0x00, 0x21, 0x08, 0x40, 0x08, 0x02, 0x19, + 0xc2, 0x18, 0x63, 0x29, 0xa2, 0x10, 0x04, 0x21, 0x23, 0x21, 0xe3, 0x18, 0xe3, 0x18, 0xa2, 0x18, + 0xe2, 0x10, 0xe2, 0x10, 0xc3, 0x10, 0xa2, 0x10, 0xa2, 0x10, 0x43, 0x21, 0xc2, 0x18, 0xe6, 0x39, + 0xa2, 0x18, 0xa2, 0x08, 0xe3, 0x18, 0xa2, 0x10, 0xc3, 0x18, 0xa2, 0x10, 0xe3, 0x18, 0x24, 0x21, + 0xe3, 0x18, 0xe3, 0x18, 0x24, 0x21, 0x65, 0x29, 0x82, 0x10, 0xa3, 0x10, 0xc3, 0x18, 0xa3, 0x10, + 0xc2, 0x18, 0xa5, 0x29, 0xc3, 0x18, 0xc3, 0x18, 0xc3, 0x10, 0xe3, 0x18, 0xa3, 0x10, 0xa2, 0x10, + 0xe4, 0x18, 0x03, 0x19, 0xe6, 0x39, 0xa3, 0x10, 0xc3, 0x18, 0xe3, 0x10, 0x65, 0x21, 0x45, 0x32, + 0xa8, 0x7c, 0xa9, 0x63, 0xa4, 0x29, 0xa5, 0x29, 0x4a, 0x63, 0x76, 0xce, 0x89, 0x63, 0x68, 0x5b, + 0xa7, 0x5b, 0x07, 0x53, 0xeb, 0x5a, 0xb4, 0xbd, 0xd9, 0xe6, 0x1a, 0xef, 0x1b, 0xf7, 0x7c, 0xff, + 0x9c, 0xff, 0x5a, 0xf7, 0xbc, 0xff, 0xfc, 0xff, 0xdd, 0xff, 0xde, 0xf7, 0x3d, 0xb7, 0x3a, 0x2e, + 0x5b, 0x0e, 0x5a, 0x0e, 0x7b, 0x16, 0x5a, 0x06, 0x5a, 0x0e, 0x59, 0x1e, 0x59, 0x1e, 0x59, 0x1e, + 0x58, 0x16, 0x37, 0x16, 0x37, 0x16, 0xf6, 0x0d, 0xf6, 0x0d, 0x95, 0x0d, 0x95, 0x05, 0x33, 0x05, + 0x54, 0x55, 0x16, 0xae, 0x3a, 0xef, 0x93, 0xbd, 0xd5, 0xcd, 0x84, 0x31, 0xe3, 0x18, 0x23, 0x21, + 0x41, 0x08, 0x43, 0x21, 0x42, 0x21, 0x02, 0x19, 0x62, 0x10, 0x41, 0x08, 0x41, 0x08, 0x81, 0x10, + 0x41, 0x08, 0x40, 0x08, 0x41, 0x08, 0x82, 0x10, 0x82, 0x10, 0x00, 0x19, 0xa3, 0x31, 0x80, 0x08, + 0x02, 0x19, 0x23, 0x21, 0x44, 0x21, 0x41, 0x00, 0xe2, 0x18, 0x02, 0x19, 0x23, 0x21, 0xa3, 0x29, + 0xe3, 0x18, 0xa1, 0x10, 0x41, 0x08, 0x20, 0x08, 0x41, 0x08, 0x20, 0x00, 0x40, 0x08, 0x64, 0x29, + 0xc3, 0x18, 0x61, 0x08, 0x21, 0x08, 0x41, 0x08, 0x20, 0x08, 0x62, 0x10, 0x62, 0x10, 0x82, 0x10, + 0xa2, 0x10, 0xc2, 0x18, 0xc2, 0x10, 0x03, 0x19, 0x81, 0x08, 0x02, 0x19, 0xa1, 0x10, 0x85, 0x31, + 0x81, 0x10, 0xa3, 0x10, 0x81, 0x08, 0xa2, 0x10, 0x03, 0x19, 0xe3, 0x18, 0x45, 0x21, 0x84, 0x29, + 0xe6, 0x39, 0xc3, 0x10, 0x24, 0x21, 0xe3, 0x18, 0xc2, 0x10, 0xa2, 0x10, 0x04, 0x19, 0xc3, 0x10, + 0x82, 0x10, 0xc3, 0x18, 0x24, 0x21, 0xc3, 0x10, 0xc3, 0x10, 0x45, 0x29, 0x04, 0x19, 0xa2, 0x10, + 0x82, 0x08, 0x04, 0x19, 0x84, 0x29, 0x24, 0x21, 0x45, 0x21, 0x44, 0x21, 0xe4, 0x29, 0xc6, 0x42, + 0x65, 0x3a, 0xcb, 0x6b, 0x6a, 0x7c, 0x47, 0x3a, 0xaa, 0x63, 0x0b, 0x7c, 0x92, 0xad, 0xc8, 0x6b, + 0x6b, 0x84, 0xaf, 0x94, 0x99, 0xde, 0x1b, 0xf7, 0x7b, 0xf7, 0x5b, 0xef, 0xf9, 0xe6, 0x3b, 0xef, + 0x7b, 0xf7, 0x9d, 0xff, 0x3b, 0xf7, 0x9c, 0xf7, 0xfc, 0xf7, 0x18, 0x4e, 0xd8, 0x0d, 0x39, 0x06, + 0x39, 0x0e, 0x3a, 0x1e, 0x5a, 0x16, 0x5a, 0x16, 0x59, 0x16, 0x3a, 0x26, 0x39, 0x1e, 0x39, 0x1e, + 0x38, 0x16, 0x38, 0x16, 0x17, 0x06, 0xf7, 0x0d, 0xd6, 0x05, 0xd6, 0x0d, 0x95, 0x05, 0x75, 0x05, + 0x33, 0x05, 0xf2, 0x1c, 0xed, 0x3b, 0x67, 0x52, 0x2e, 0x84, 0x40, 0x10, 0x41, 0x08, 0xe2, 0x18, + 0x40, 0x00, 0x03, 0x19, 0x01, 0x19, 0xa1, 0x10, 0x21, 0x00, 0x41, 0x08, 0x20, 0x00, 0x22, 0x19, + 0x61, 0x08, 0x61, 0x08, 0x41, 0x08, 0x41, 0x08, 0x62, 0x10, 0xe2, 0x18, 0xe0, 0x18, 0xe2, 0x18, + 0xc2, 0x10, 0x23, 0x21, 0x84, 0x29, 0xa1, 0x08, 0xa1, 0x10, 0xe1, 0x10, 0x01, 0x19, 0x43, 0x21, + 0xc1, 0x10, 0x04, 0x3a, 0x80, 0x10, 0x21, 0x08, 0x21, 0x00, 0x21, 0x08, 0x41, 0x08, 0x61, 0x08, + 0x82, 0x10, 0x61, 0x08, 0x41, 0x08, 0x23, 0x29, 0x23, 0x29, 0xc3, 0x18, 0x20, 0x00, 0x48, 0x4a, + 0x82, 0x10, 0x82, 0x10, 0xa5, 0x31, 0xa1, 0x10, 0x65, 0x29, 0xc2, 0x10, 0xe3, 0x18, 0xe2, 0x18, + 0xa3, 0x10, 0x82, 0x10, 0x82, 0x10, 0xa2, 0x10, 0xc3, 0x18, 0xc3, 0x10, 0xa2, 0x10, 0x04, 0x19, + 0x25, 0x21, 0xa2, 0x10, 0xa2, 0x10, 0x44, 0x21, 0xc3, 0x18, 0xa2, 0x10, 0x04, 0x21, 0xa2, 0x10, + 0xc3, 0x18, 0xe3, 0x18, 0xc3, 0x18, 0xe3, 0x18, 0xa3, 0x18, 0xe3, 0x18, 0xe3, 0x10, 0x24, 0x19, + 0xe3, 0x10, 0xa2, 0x10, 0x67, 0x42, 0x63, 0x21, 0xa6, 0x31, 0xe6, 0x39, 0xe5, 0x31, 0x48, 0x53, + 0x24, 0x32, 0x49, 0x53, 0xa5, 0x29, 0xe7, 0x4a, 0x0d, 0x7c, 0x2d, 0x7c, 0xce, 0x94, 0x78, 0xd6, + 0x3b, 0xf7, 0x7c, 0xff, 0xd9, 0xe6, 0x3b, 0xef, 0x3a, 0xef, 0x3a, 0xef, 0x5b, 0xf7, 0xb8, 0xde, + 0xba, 0xde, 0xfa, 0xe6, 0x1b, 0xef, 0xf6, 0x95, 0x76, 0x55, 0x55, 0x2d, 0x75, 0x05, 0xb5, 0x1d, + 0x17, 0x26, 0xf7, 0x1d, 0x18, 0x1e, 0x96, 0x05, 0x96, 0x05, 0x75, 0x05, 0x75, 0x05, 0x33, 0x05, + 0x33, 0x05, 0xf2, 0x04, 0xf2, 0x04, 0xf2, 0x04, 0x34, 0x05, 0xf1, 0x04, 0x70, 0x04, 0x90, 0x04, + 0x6c, 0x13, 0x06, 0x22, 0xa5, 0x21, 0xe2, 0x18, 0x02, 0x11, 0x41, 0x08, 0x82, 0x10, 0xa1, 0x10, + 0xc1, 0x18, 0x81, 0x08, 0x63, 0x29, 0xe1, 0x10, 0x41, 0x08, 0x41, 0x08, 0x61, 0x08, 0xe1, 0x18, + 0x41, 0x08, 0x40, 0x08, 0x62, 0x10, 0x41, 0x08, 0x42, 0x08, 0x41, 0x08, 0x23, 0x21, 0xc2, 0x10, + 0x22, 0x21, 0xe1, 0x10, 0x42, 0x21, 0xe1, 0x18, 0xa1, 0x10, 0xe2, 0x18, 0x42, 0x21, 0x63, 0x29, + 0x02, 0x19, 0x62, 0x29, 0xe3, 0x39, 0xe2, 0x39, 0x03, 0x21, 0x21, 0x08, 0x42, 0x08, 0x40, 0x00, + 0x22, 0x08, 0x82, 0x18, 0x61, 0x10, 0x23, 0x31, 0x88, 0x5a, 0xaa, 0x5a, 0xa6, 0x39, 0xee, 0x83, + 0xc2, 0x10, 0x03, 0x19, 0x43, 0x21, 0xa2, 0x10, 0x82, 0x08, 0x23, 0x19, 0x64, 0x21, 0x81, 0x10, + 0x61, 0x08, 0xa2, 0x10, 0xc2, 0x10, 0xe3, 0x18, 0x82, 0x08, 0xe3, 0x18, 0x23, 0x19, 0xe5, 0x39, + 0xc2, 0x10, 0x03, 0x19, 0x44, 0x21, 0x85, 0x31, 0x03, 0x19, 0xa2, 0x10, 0xc2, 0x10, 0xa2, 0x10, + 0xe3, 0x10, 0x23, 0x19, 0xc2, 0x10, 0xe4, 0x20, 0x04, 0x21, 0xa6, 0x31, 0xc2, 0x10, 0xe4, 0x18, + 0x43, 0x19, 0x65, 0x21, 0x22, 0x11, 0x46, 0x3a, 0x26, 0x32, 0x63, 0x21, 0xe5, 0x31, 0xa4, 0x21, + 0xc6, 0x42, 0xe7, 0x5b, 0xa4, 0x29, 0x66, 0x3a, 0x4f, 0x84, 0x51, 0x8c, 0xcf, 0x7b, 0x51, 0x8c, + 0x8e, 0x6b, 0x0c, 0x63, 0x8b, 0x52, 0x6a, 0x52, 0x6a, 0x4a, 0x6a, 0x52, 0x28, 0x4a, 0x09, 0x4a, + 0xc7, 0x39, 0xe7, 0x39, 0xa7, 0x39, 0xc7, 0x39, 0xc7, 0x31, 0x29, 0x42, 0x69, 0x4a, 0xaa, 0x52, + 0x8a, 0x4a, 0x0c, 0x5b, 0x6e, 0x53, 0x11, 0x5c, 0xd3, 0x6c, 0x96, 0x6d, 0x17, 0x66, 0x38, 0x4e, + 0xd6, 0x25, 0xf7, 0x15, 0x95, 0x05, 0x75, 0x05, 0x75, 0x15, 0x95, 0x05, 0x0b, 0x33, 0xac, 0x33, + 0xa5, 0x11, 0x82, 0x08, 0x02, 0x19, 0x02, 0x19, 0x02, 0x19, 0x41, 0x08, 0xa2, 0x10, 0x22, 0x29, + 0xa5, 0x31, 0x03, 0x21, 0x43, 0x21, 0xa2, 0x10, 0x41, 0x00, 0x41, 0x08, 0x40, 0x08, 0xe3, 0x18, + 0x41, 0x08, 0xa2, 0x10, 0x41, 0x08, 0x41, 0x08, 0x20, 0x00, 0xa1, 0x18, 0xc1, 0x10, 0x81, 0x10, + 0x01, 0x19, 0x22, 0x21, 0x42, 0x21, 0x62, 0x21, 0x02, 0x19, 0x22, 0x21, 0x02, 0x19, 0x23, 0x21, + 0xe2, 0x18, 0xa4, 0x31, 0xc4, 0x52, 0x24, 0x42, 0xe2, 0x31, 0xe4, 0x39, 0xc2, 0x18, 0x80, 0x10, + 0xc1, 0x10, 0xa5, 0x39, 0x06, 0x4a, 0x03, 0x21, 0x03, 0x21, 0xaa, 0x5a, 0xca, 0x5a, 0x4c, 0x6b, + 0xc6, 0x31, 0xc2, 0x10, 0xe3, 0x10, 0xc2, 0x10, 0xa2, 0x10, 0xa4, 0x29, 0xe2, 0x18, 0x61, 0x08, + 0x82, 0x10, 0xc3, 0x18, 0x65, 0x29, 0xa2, 0x10, 0xc3, 0x18, 0xa2, 0x10, 0x44, 0x29, 0x23, 0x21, + 0xe3, 0x18, 0x24, 0x21, 0xc6, 0x31, 0xc4, 0x29, 0x03, 0x19, 0xe2, 0x18, 0x65, 0x29, 0xc3, 0x10, + 0xc3, 0x18, 0x23, 0x19, 0x06, 0x32, 0x44, 0x21, 0x65, 0x29, 0x24, 0x21, 0xe4, 0x18, 0xa2, 0x10, + 0x85, 0x21, 0xa5, 0x29, 0xa5, 0x29, 0x05, 0x32, 0x46, 0x3a, 0xa3, 0x42, 0x44, 0x21, 0xe6, 0x31, + 0xa4, 0x21, 0x05, 0x43, 0x07, 0x4b, 0xa5, 0x29, 0x45, 0x21, 0xe8, 0x31, 0x09, 0x42, 0xe5, 0x18, + 0x84, 0x08, 0x63, 0x00, 0x63, 0x08, 0x63, 0x08, 0x26, 0x21, 0xa8, 0x31, 0xe8, 0x41, 0xc7, 0x39, + 0xe7, 0x39, 0xc7, 0x39, 0xc7, 0x39, 0xa6, 0x31, 0xc7, 0x39, 0xa7, 0x31, 0xa7, 0x39, 0x67, 0x31, + 0x86, 0x31, 0x67, 0x31, 0x87, 0x31, 0xa6, 0x29, 0xa7, 0x31, 0xa7, 0x29, 0x67, 0x29, 0x4a, 0x4a, + 0xaf, 0x6b, 0x92, 0x6c, 0x55, 0x75, 0xf7, 0x75, 0x13, 0x25, 0x70, 0x34, 0x03, 0x11, 0xc5, 0x29, + 0x24, 0x19, 0x82, 0x08, 0x63, 0x31, 0x03, 0x42, 0x61, 0x10, 0xa2, 0x18, 0x04, 0x42, 0xc6, 0x5a, + 0x80, 0x10, 0xe2, 0x31, 0xe1, 0x18, 0x81, 0x10, 0x41, 0x08, 0x41, 0x08, 0x61, 0x10, 0xc2, 0x18, + 0x61, 0x10, 0x41, 0x08, 0x41, 0x08, 0x41, 0x08, 0x41, 0x08, 0x60, 0x08, 0x84, 0x29, 0xe5, 0x31, + 0xa2, 0x10, 0xa1, 0x10, 0xe3, 0x18, 0xe2, 0x18, 0xe2, 0x18, 0xe1, 0x18, 0xa2, 0x18, 0xc2, 0x18, + 0x64, 0x29, 0x44, 0x29, 0x46, 0x4a, 0x45, 0x4a, 0xe7, 0x5a, 0x46, 0x4a, 0xa5, 0x39, 0x01, 0x21, + 0x24, 0x21, 0x21, 0x32, 0x42, 0x3a, 0xa7, 0x52, 0x27, 0x4a, 0xc9, 0x5a, 0x4b, 0x73, 0x8c, 0x7b, + 0x82, 0x10, 0xa3, 0x18, 0x41, 0x08, 0xc2, 0x10, 0xa4, 0x21, 0x44, 0x21, 0x81, 0x10, 0xa2, 0x10, + 0x82, 0x10, 0xa2, 0x10, 0x82, 0x10, 0x82, 0x10, 0x82, 0x10, 0xa2, 0x10, 0xc2, 0x10, 0x82, 0x10, + 0x82, 0x08, 0xc5, 0x31, 0xa4, 0x29, 0x07, 0x3a, 0x03, 0x19, 0x02, 0x19, 0x24, 0x21, 0x04, 0x19, + 0xa2, 0x10, 0x03, 0x19, 0x64, 0x21, 0x85, 0x29, 0x43, 0x19, 0xe2, 0x18, 0xe3, 0x18, 0xc3, 0x10, + 0x24, 0x21, 0xe3, 0x18, 0xe6, 0x39, 0x43, 0x21, 0x63, 0x21, 0x05, 0x32, 0x03, 0x19, 0xe2, 0x10, + 0xe5, 0x31, 0x24, 0x19, 0xa7, 0x42, 0xc2, 0x10, 0x03, 0x19, 0xe3, 0x18, 0xea, 0x5a, 0xad, 0x73, + 0x49, 0x4a, 0x64, 0x08, 0x43, 0x00, 0x63, 0x08, 0x42, 0x08, 0x63, 0x10, 0xa4, 0x10, 0x46, 0x29, + 0x86, 0x31, 0xa7, 0x39, 0xa6, 0x31, 0x87, 0x39, 0x86, 0x31, 0x87, 0x31, 0x86, 0x31, 0x87, 0x31, + 0x86, 0x31, 0x87, 0x39, 0x66, 0x31, 0xa7, 0x39, 0x67, 0x31, 0xc8, 0x39, 0xa7, 0x31, 0xa8, 0x29, + 0xa7, 0x29, 0x86, 0x31, 0x45, 0x19, 0x25, 0x19, 0xa2, 0x08, 0x02, 0x19, 0x61, 0x08, 0xc2, 0x29, + 0x03, 0x3a, 0x81, 0x10, 0xe4, 0x39, 0xa4, 0x39, 0x61, 0x10, 0x25, 0x42, 0xc4, 0x52, 0x82, 0x31, + 0x42, 0x19, 0x23, 0x4b, 0xc2, 0x29, 0x61, 0x08, 0x21, 0x08, 0x41, 0x08, 0x20, 0x00, 0xa1, 0x10, + 0xc2, 0x18, 0xe4, 0x20, 0x40, 0x08, 0xa1, 0x10, 0x41, 0x08, 0x61, 0x10, 0x83, 0x29, 0xa4, 0x29, + 0x43, 0x21, 0x03, 0x21, 0x41, 0x08, 0x61, 0x08, 0x82, 0x10, 0x44, 0x29, 0x85, 0x29, 0xe4, 0x20, + 0x41, 0x08, 0xe7, 0x41, 0x47, 0x52, 0xc9, 0x62, 0x47, 0x4a, 0xa7, 0x52, 0x89, 0x6b, 0x85, 0x6b, + 0xc5, 0x6b, 0xe2, 0x6b, 0x08, 0x74, 0x09, 0x63, 0x09, 0x63, 0x48, 0x73, 0xa7, 0x5a, 0x89, 0x7b, + 0xa3, 0x18, 0x82, 0x10, 0x62, 0x10, 0xa3, 0x10, 0x24, 0x32, 0x22, 0x19, 0xa5, 0x31, 0x81, 0x08, + 0xe3, 0x18, 0xe3, 0x18, 0x04, 0x21, 0x82, 0x10, 0xa3, 0x18, 0xa3, 0x10, 0xe5, 0x31, 0x23, 0x19, + 0x23, 0x19, 0xe5, 0x31, 0x44, 0x21, 0x04, 0x32, 0x04, 0x21, 0xa4, 0x29, 0xa5, 0x31, 0x24, 0x19, + 0xa3, 0x18, 0x03, 0x19, 0xc3, 0x18, 0xe3, 0x18, 0x03, 0x19, 0xc4, 0x29, 0x85, 0x29, 0xa2, 0x08, + 0x04, 0x21, 0xc2, 0x10, 0x06, 0x3a, 0xc2, 0x10, 0x24, 0x21, 0xc3, 0x10, 0x03, 0x19, 0x65, 0x29, + 0x04, 0x21, 0x24, 0x21, 0x44, 0x29, 0x24, 0x19, 0x24, 0x21, 0xe3, 0x18, 0x04, 0x19, 0xc5, 0x29, + 0xcc, 0x6b, 0x29, 0x5b, 0x27, 0x3a, 0x62, 0x00, 0x63, 0x08, 0x63, 0x08, 0x43, 0x10, 0x43, 0x08, + 0xc4, 0x18, 0x05, 0x21, 0x47, 0x29, 0x67, 0x31, 0x87, 0x31, 0x66, 0x31, 0xa7, 0x39, 0x87, 0x31, + 0x87, 0x31, 0x87, 0x31, 0x67, 0x31, 0x87, 0x31, 0x88, 0x31, 0x68, 0x29, 0x67, 0x21, 0x06, 0x19, + 0xc4, 0x18, 0xa1, 0x10, 0xe2, 0x10, 0xe2, 0x10, 0x61, 0x08, 0xc2, 0x10, 0x61, 0x08, 0x43, 0x21, + 0x64, 0x31, 0x03, 0x42, 0xe4, 0x41, 0x83, 0x39, 0x64, 0x4a, 0xa2, 0x52, 0x63, 0x4a, 0xe2, 0x18, + 0x82, 0x10, 0x21, 0x19, 0x02, 0x19, 0x40, 0x08, 0x41, 0x08, 0x40, 0x00, 0x03, 0x19, 0xe2, 0x10, + 0x82, 0x10, 0x81, 0x10, 0x43, 0x21, 0x42, 0x21, 0x42, 0x21, 0xe1, 0x10, 0xa2, 0x10, 0xe3, 0x18, + 0x02, 0x19, 0xa4, 0x31, 0xa3, 0x18, 0x40, 0x08, 0x62, 0x10, 0x21, 0x08, 0x03, 0x21, 0x46, 0x52, + 0x2b, 0x7b, 0x2a, 0x73, 0x88, 0x62, 0xce, 0x83, 0x2e, 0x8c, 0x6c, 0x8c, 0xab, 0x7b, 0xcd, 0x9c, + 0x27, 0x6b, 0x29, 0x73, 0x6e, 0x9c, 0x22, 0x5b, 0xc5, 0x73, 0x85, 0x6b, 0x68, 0x6b, 0x47, 0x73, + 0x04, 0x21, 0xa2, 0x10, 0x82, 0x10, 0xa2, 0x10, 0x22, 0x19, 0x83, 0x21, 0x02, 0x19, 0x61, 0x10, + 0x81, 0x08, 0xa2, 0x08, 0xe3, 0x18, 0xe4, 0x20, 0x82, 0x10, 0xa4, 0x29, 0x26, 0x32, 0x64, 0x32, + 0x85, 0x32, 0x43, 0x21, 0xe2, 0x18, 0xa9, 0x4a, 0xa5, 0x31, 0x84, 0x21, 0xc2, 0x10, 0x45, 0x29, + 0x82, 0x10, 0x07, 0x3a, 0xa1, 0x10, 0x24, 0x21, 0x82, 0x08, 0x24, 0x32, 0x05, 0x32, 0xe3, 0x18, + 0xc3, 0x10, 0xe3, 0x18, 0x05, 0x3a, 0xa2, 0x10, 0xa2, 0x10, 0xe3, 0x18, 0xc2, 0x10, 0x24, 0x21, + 0x04, 0x19, 0x26, 0x3a, 0x02, 0x19, 0x24, 0x21, 0xa2, 0x08, 0x03, 0x19, 0x04, 0x19, 0xe4, 0x10, + 0x43, 0x19, 0xe6, 0x42, 0xc5, 0x3a, 0xe7, 0x4a, 0xa3, 0x21, 0xc3, 0x10, 0x43, 0x08, 0x43, 0x10, + 0x42, 0x08, 0x62, 0x08, 0x83, 0x08, 0xe5, 0x18, 0xe5, 0x18, 0x06, 0x19, 0x47, 0x21, 0xa8, 0x29, + 0x05, 0x21, 0x05, 0x21, 0x05, 0x19, 0x46, 0x19, 0xe5, 0x10, 0x05, 0x11, 0xe3, 0x10, 0x03, 0x11, + 0xc2, 0x10, 0x61, 0x08, 0x82, 0x10, 0xa2, 0x10, 0x41, 0x08, 0xc4, 0x31, 0x83, 0x29, 0xe3, 0x20, + 0x63, 0x42, 0xe2, 0x31, 0xa4, 0x52, 0x24, 0x4a, 0xe2, 0x39, 0xc2, 0x39, 0xe2, 0x18, 0xe2, 0x20, + 0x22, 0x21, 0x83, 0x31, 0x43, 0x29, 0x41, 0x08, 0x21, 0x00, 0xe2, 0x10, 0x42, 0x21, 0x83, 0x21, + 0x02, 0x19, 0x63, 0x21, 0x21, 0x11, 0x83, 0x21, 0x61, 0x19, 0xa2, 0x21, 0x05, 0x3a, 0xa1, 0x10, + 0x60, 0x08, 0x84, 0x39, 0x89, 0x7b, 0x65, 0x39, 0x80, 0x08, 0x27, 0x42, 0xee, 0x83, 0x2a, 0x63, + 0x05, 0x3a, 0x28, 0x63, 0x8a, 0x73, 0x49, 0x6b, 0x09, 0x5b, 0xa9, 0x5a, 0xa9, 0x62, 0xe9, 0x6a, + 0x49, 0x73, 0xa8, 0x7b, 0xc6, 0x73, 0x20, 0x4b, 0x20, 0x4b, 0xa0, 0x3a, 0x04, 0x84, 0x66, 0xbd, + 0xc2, 0x10, 0x03, 0x19, 0xe3, 0x10, 0x82, 0x08, 0xa2, 0x18, 0x82, 0x08, 0x82, 0x10, 0x61, 0x08, + 0x24, 0x21, 0x64, 0x21, 0xa3, 0x10, 0xa2, 0x10, 0xc2, 0x18, 0x03, 0x32, 0xc5, 0x29, 0xc4, 0x3a, + 0x44, 0x2a, 0x86, 0x42, 0xa2, 0x10, 0x86, 0x42, 0xe5, 0x31, 0x63, 0x21, 0xc6, 0x31, 0xe3, 0x18, + 0x04, 0x19, 0x43, 0x21, 0xa3, 0x10, 0xc2, 0x10, 0x24, 0x21, 0x64, 0x21, 0x43, 0x21, 0x65, 0x29, + 0x04, 0x19, 0xe3, 0x10, 0xa5, 0x29, 0x23, 0x21, 0xe3, 0x20, 0xc3, 0x10, 0xc3, 0x10, 0xe4, 0x18, + 0x84, 0x29, 0xc6, 0x42, 0x26, 0x3a, 0x24, 0x21, 0xa5, 0x29, 0xe6, 0x31, 0x04, 0x21, 0xe3, 0x18, + 0xe4, 0x18, 0xe5, 0x31, 0xa7, 0x4a, 0x28, 0x53, 0x05, 0x4b, 0x06, 0x4b, 0xc7, 0x42, 0xa2, 0x08, + 0x63, 0x10, 0x62, 0x08, 0x63, 0x10, 0x42, 0x08, 0x63, 0x08, 0x63, 0x08, 0xa4, 0x10, 0xa4, 0x10, + 0xa4, 0x10, 0x84, 0x08, 0xa4, 0x08, 0xe3, 0x10, 0x44, 0x21, 0x81, 0x08, 0x82, 0x10, 0x02, 0x11, + 0xc2, 0x10, 0x81, 0x08, 0x82, 0x10, 0x41, 0x08, 0x42, 0x08, 0x04, 0x3a, 0xa2, 0x31, 0xc4, 0x39, + 0xa3, 0x31, 0xc2, 0x31, 0x04, 0x5b, 0xc4, 0x52, 0x65, 0x52, 0x02, 0x21, 0x20, 0x21, 0x82, 0x52, + 0xe3, 0x39, 0x24, 0x42, 0x05, 0x4a, 0xa1, 0x10, 0xe1, 0x18, 0x22, 0x19, 0x43, 0x21, 0x21, 0x21, + 0xe4, 0x39, 0x60, 0x21, 0xe4, 0x31, 0x83, 0x29, 0x03, 0x21, 0xc4, 0x31, 0x65, 0x29, 0xe4, 0x20, + 0xe6, 0x41, 0x88, 0x52, 0x2a, 0x73, 0xea, 0x62, 0xea, 0x62, 0xc9, 0x5a, 0x4b, 0x73, 0xab, 0x7b, + 0x88, 0x73, 0x27, 0x63, 0x27, 0x63, 0x69, 0x6b, 0x69, 0x6b, 0x47, 0x6b, 0x07, 0x6b, 0x06, 0x63, + 0xe5, 0x62, 0x20, 0x5b, 0xe0, 0x42, 0x20, 0x32, 0x82, 0x63, 0x82, 0x84, 0x29, 0xa5, 0x68, 0x8c, + 0xa1, 0x08, 0xe3, 0x18, 0xc2, 0x10, 0xc2, 0x10, 0x43, 0x19, 0xa3, 0x21, 0xc2, 0x10, 0x62, 0x10, + 0xe3, 0x18, 0x61, 0x08, 0xc2, 0x10, 0x03, 0x19, 0xa4, 0x3a, 0x03, 0x32, 0xc2, 0x10, 0xa4, 0x29, + 0x85, 0x3a, 0x24, 0x32, 0xa5, 0x29, 0x64, 0x3a, 0x65, 0x3a, 0x66, 0x42, 0xc2, 0x18, 0xe1, 0x10, + 0x03, 0x11, 0x44, 0x21, 0x82, 0x10, 0xe5, 0x31, 0xa5, 0x31, 0xa3, 0x10, 0x45, 0x21, 0xe5, 0x31, + 0xa5, 0x31, 0xc3, 0x18, 0x02, 0x11, 0xa6, 0x4a, 0x04, 0x32, 0xc3, 0x18, 0xc2, 0x10, 0xe3, 0x18, + 0xa4, 0x29, 0x83, 0x29, 0xa6, 0x3a, 0x47, 0x42, 0xa4, 0x29, 0x44, 0x21, 0x24, 0x21, 0x24, 0x21, + 0xc3, 0x10, 0x85, 0x29, 0x4a, 0x5b, 0xc8, 0x4a, 0xc6, 0x4a, 0x89, 0x63, 0x84, 0x4b, 0x29, 0x64, + 0x85, 0x3a, 0xc3, 0x31, 0x41, 0x08, 0x62, 0x08, 0x41, 0x08, 0x62, 0x08, 0x42, 0x08, 0x83, 0x10, + 0x61, 0x08, 0xe3, 0x18, 0x03, 0x19, 0x24, 0x21, 0x21, 0x19, 0x81, 0x08, 0x40, 0x00, 0xe2, 0x10, + 0x81, 0x08, 0x44, 0x21, 0x81, 0x10, 0xc1, 0x18, 0xa3, 0x31, 0x64, 0x4a, 0xe2, 0x39, 0x82, 0x29, + 0x02, 0x19, 0x85, 0x52, 0xa2, 0x42, 0xa4, 0x52, 0x62, 0x21, 0x21, 0x21, 0x83, 0x4a, 0xc2, 0x39, + 0x81, 0x31, 0x63, 0x4a, 0xe2, 0x39, 0xa2, 0x29, 0x82, 0x21, 0x42, 0x21, 0xe5, 0x31, 0xc3, 0x31, + 0x81, 0x29, 0xe1, 0x18, 0x24, 0x3a, 0x83, 0x29, 0x64, 0x31, 0xe6, 0x41, 0x85, 0x52, 0x28, 0x6b, + 0xa4, 0x52, 0xa5, 0x52, 0x48, 0x6b, 0x48, 0x6b, 0xc7, 0x62, 0xa7, 0x5a, 0xae, 0x9c, 0x8d, 0x9c, + 0x09, 0x63, 0x66, 0x4a, 0x48, 0x63, 0xa4, 0x52, 0xc5, 0x52, 0xa7, 0x52, 0x8c, 0x73, 0xad, 0x7b, + 0x26, 0x42, 0xc8, 0x5a, 0x85, 0x52, 0xac, 0x94, 0x26, 0x63, 0x88, 0x73, 0xc9, 0x7b, 0xea, 0x62, + 0x22, 0x19, 0x24, 0x21, 0xa3, 0x18, 0xe2, 0x10, 0x25, 0x32, 0x84, 0x32, 0x82, 0x21, 0x03, 0x21, + 0x81, 0x10, 0x62, 0x10, 0xe6, 0x39, 0xa3, 0x21, 0x04, 0x2a, 0xe3, 0x29, 0x43, 0x21, 0xa2, 0x08, + 0x63, 0x19, 0xe4, 0x29, 0xc4, 0x29, 0x84, 0x32, 0x45, 0x3a, 0x83, 0x29, 0x24, 0x21, 0x64, 0x21, + 0xc3, 0x18, 0xa4, 0x29, 0x24, 0x21, 0x43, 0x21, 0x03, 0x19, 0xa2, 0x10, 0x43, 0x19, 0xc3, 0x29, + 0xe5, 0x39, 0x81, 0x08, 0xc2, 0x10, 0x25, 0x32, 0xa2, 0x29, 0xc3, 0x18, 0xc3, 0x18, 0xa4, 0x29, + 0x44, 0x21, 0xe6, 0x39, 0x66, 0x42, 0x67, 0x42, 0xc5, 0x31, 0xc3, 0x18, 0x24, 0x19, 0x03, 0x19, + 0xe7, 0x31, 0x45, 0x21, 0xe6, 0x31, 0x06, 0x32, 0x8a, 0x6b, 0x27, 0x53, 0x48, 0x53, 0xe6, 0x42, + 0xc7, 0x42, 0x27, 0x53, 0x47, 0x5b, 0x23, 0x21, 0x62, 0x10, 0x62, 0x10, 0xa2, 0x18, 0x82, 0x10, + 0xc2, 0x10, 0xc2, 0x18, 0xe2, 0x18, 0xc1, 0x08, 0x03, 0x21, 0xa1, 0x10, 0x61, 0x10, 0xe2, 0x10, + 0x61, 0x10, 0x02, 0x21, 0x63, 0x29, 0xe4, 0x39, 0xa4, 0x5a, 0xe1, 0x31, 0x42, 0x21, 0xa3, 0x29, + 0x42, 0x21, 0x61, 0x21, 0x61, 0x21, 0x61, 0x21, 0x42, 0x29, 0x42, 0x42, 0xc1, 0x31, 0x02, 0x3a, + 0xe3, 0x39, 0x61, 0x21, 0xa3, 0x29, 0x62, 0x21, 0x22, 0x21, 0x02, 0x19, 0x63, 0x21, 0x05, 0x3a, + 0x66, 0x4a, 0xc2, 0x18, 0x0a, 0x63, 0xcd, 0x83, 0xa6, 0x52, 0x07, 0x4a, 0xa6, 0x5a, 0x44, 0x4a, + 0x04, 0x5b, 0x4b, 0x84, 0x89, 0x73, 0x69, 0x73, 0x4e, 0x94, 0x4d, 0x8c, 0xea, 0x7b, 0xea, 0x83, + 0xeb, 0x7b, 0x27, 0x63, 0xae, 0x94, 0xad, 0x94, 0xe9, 0x83, 0xec, 0x7b, 0xc9, 0x5a, 0xe7, 0x41, + 0xeb, 0x62, 0x6c, 0x6b, 0x69, 0x5a, 0x0a, 0x63, 0x2b, 0x6b, 0x2b, 0x6b, 0x2a, 0x6b, 0x88, 0x5a, + 0x61, 0x19, 0x62, 0x21, 0x41, 0x19, 0x22, 0x19, 0xa5, 0x3a, 0x44, 0x21, 0xc3, 0x32, 0x22, 0x22, + 0x82, 0x10, 0xe3, 0x10, 0x61, 0x08, 0xc6, 0x31, 0xc2, 0x29, 0xe5, 0x42, 0x22, 0x32, 0x83, 0x21, + 0x83, 0x21, 0xe3, 0x18, 0xa4, 0x21, 0xc3, 0x42, 0xe4, 0x31, 0x65, 0x3a, 0xc2, 0x10, 0xa5, 0x31, + 0x61, 0x08, 0x84, 0x29, 0xa1, 0x10, 0x25, 0x21, 0x42, 0x21, 0xc6, 0x31, 0x23, 0x19, 0x05, 0x32, + 0x44, 0x3a, 0x64, 0x29, 0x82, 0x08, 0xa5, 0x29, 0xc4, 0x29, 0xe3, 0x18, 0x23, 0x19, 0x04, 0x32, + 0x04, 0x32, 0xc3, 0x10, 0x23, 0x19, 0x68, 0x4a, 0xa9, 0x4a, 0x44, 0x21, 0xe3, 0x10, 0x45, 0x19, + 0x03, 0x11, 0x44, 0x21, 0x08, 0x53, 0x85, 0x21, 0xa6, 0x42, 0x65, 0x3a, 0x05, 0x32, 0xe7, 0x4a, + 0x65, 0x32, 0xe7, 0x4a, 0xa3, 0x29, 0x46, 0x42, 0x88, 0x4a, 0x23, 0x21, 0xe2, 0x18, 0xa2, 0x10, + 0xa1, 0x08, 0xe2, 0x18, 0xc2, 0x10, 0x63, 0x21, 0x80, 0x10, 0xa1, 0x10, 0xa1, 0x10, 0xe2, 0x18, + 0x62, 0x21, 0x84, 0x4a, 0x02, 0x3a, 0x24, 0x42, 0x82, 0x29, 0x01, 0x19, 0x22, 0x19, 0x61, 0x21, + 0x01, 0x11, 0xa0, 0x10, 0x02, 0x19, 0x01, 0x19, 0xc2, 0x31, 0x02, 0x42, 0x22, 0x21, 0x21, 0x19, + 0x21, 0x19, 0x46, 0x42, 0x22, 0x21, 0x64, 0x29, 0x47, 0x4a, 0x85, 0x39, 0xc7, 0x62, 0x47, 0x4a, + 0x4b, 0x6b, 0xe9, 0x62, 0x8b, 0x73, 0x49, 0x73, 0x48, 0x6b, 0x8a, 0x7b, 0x88, 0x7b, 0x4d, 0x94, + 0x6e, 0x94, 0xa8, 0x73, 0xe7, 0x73, 0x08, 0x7c, 0x26, 0x7c, 0x68, 0x8c, 0x89, 0x73, 0x88, 0x73, + 0xc5, 0x6b, 0x0a, 0x84, 0x6b, 0x73, 0x28, 0x6b, 0x07, 0x63, 0x06, 0x42, 0x64, 0x29, 0xaa, 0x5a, + 0x64, 0x29, 0xc6, 0x41, 0x88, 0x5a, 0xa9, 0x62, 0x26, 0x4a, 0x2b, 0x73, 0xc8, 0x62, 0xca, 0x83, + 0x82, 0x21, 0x41, 0x19, 0xa2, 0x29, 0x02, 0x2a, 0xc2, 0x29, 0xa1, 0x29, 0xe3, 0x42, 0xa2, 0x3a, + 0x04, 0x3b, 0xe3, 0x21, 0x63, 0x21, 0x22, 0x19, 0xe6, 0x42, 0xa3, 0x32, 0xc6, 0x42, 0x23, 0x19, + 0x85, 0x3a, 0x83, 0x32, 0x04, 0x32, 0xc3, 0x21, 0x04, 0x21, 0x84, 0x3a, 0x85, 0x5b, 0xe3, 0x31, + 0x64, 0x29, 0x23, 0x19, 0x03, 0x19, 0xc3, 0x10, 0xc3, 0x18, 0x82, 0x10, 0xc3, 0x18, 0xe3, 0x18, + 0xc5, 0x29, 0xc2, 0x10, 0xc3, 0x10, 0x03, 0x19, 0xe3, 0x18, 0xe3, 0x18, 0xe6, 0x29, 0xa4, 0x29, + 0xe2, 0x29, 0x44, 0x21, 0xa3, 0x10, 0xe7, 0x39, 0xc5, 0x31, 0x45, 0x32, 0xe3, 0x18, 0xa4, 0x21, + 0x67, 0x3a, 0xa6, 0x29, 0x47, 0x42, 0xc3, 0x10, 0xe5, 0x29, 0xe5, 0x31, 0x27, 0x3a, 0x63, 0x21, + 0x24, 0x19, 0x02, 0x19, 0xe2, 0x10, 0x02, 0x19, 0x23, 0x19, 0x22, 0x19, 0x82, 0x10, 0x41, 0x08, + 0x03, 0x19, 0xa1, 0x08, 0xe3, 0x18, 0xa2, 0x10, 0x42, 0x08, 0x81, 0x10, 0x41, 0x19, 0xa4, 0x39, + 0x04, 0x4a, 0x44, 0x4a, 0xe4, 0x39, 0x21, 0x19, 0x21, 0x19, 0x21, 0x19, 0x02, 0x21, 0x22, 0x19, + 0x02, 0x19, 0xe4, 0x39, 0xc9, 0x5a, 0xc3, 0x31, 0x81, 0x29, 0x41, 0x3a, 0xe3, 0x31, 0xa3, 0x31, + 0xc8, 0x5a, 0x0a, 0x63, 0x8c, 0x73, 0xc9, 0x5a, 0x0a, 0x6b, 0x6a, 0x73, 0xe9, 0x83, 0xc3, 0x7b, + 0xa6, 0x83, 0xa8, 0x7b, 0xe9, 0x83, 0xa6, 0x73, 0x89, 0x6b, 0xcb, 0x7b, 0x2b, 0x73, 0xc9, 0x62, + 0xc8, 0x62, 0xeb, 0x83, 0x88, 0x7b, 0x6a, 0x94, 0xe9, 0xa4, 0x65, 0x8c, 0xe4, 0x5a, 0x22, 0x5b, + 0xc3, 0x4a, 0x63, 0x29, 0x49, 0x5a, 0xaa, 0x5a, 0x4d, 0x6b, 0xa4, 0x31, 0xc4, 0x39, 0x63, 0x31, + 0xa5, 0x39, 0x66, 0x52, 0xa6, 0x62, 0xea, 0x8b, 0xc9, 0x83, 0x47, 0x73, 0x47, 0x6b, 0x03, 0x5b, + 0x40, 0x11, 0x81, 0x21, 0x81, 0x21, 0x61, 0x21, 0x21, 0x11, 0x80, 0x21, 0xc1, 0x21, 0x03, 0x32, + 0xe1, 0x29, 0xe2, 0x29, 0x21, 0x11, 0x02, 0x2a, 0x02, 0x3b, 0xe3, 0x3a, 0xa4, 0x19, 0x02, 0x19, + 0xe4, 0x31, 0x03, 0x32, 0x62, 0x19, 0x65, 0x32, 0x02, 0x11, 0xa2, 0x19, 0xc2, 0x3a, 0x45, 0x42, + 0x24, 0x32, 0x24, 0x21, 0x22, 0x19, 0x85, 0x29, 0xa2, 0x10, 0xa3, 0x18, 0x03, 0x21, 0x23, 0x21, + 0x42, 0x11, 0xc5, 0x29, 0xa1, 0x10, 0x45, 0x21, 0xa4, 0x29, 0xe3, 0x18, 0xc4, 0x29, 0x03, 0x19, + 0x62, 0x19, 0x42, 0x19, 0x44, 0x19, 0x84, 0x29, 0x88, 0x42, 0x46, 0x42, 0xe2, 0x18, 0xe5, 0x31, + 0x83, 0x21, 0x67, 0x42, 0xe5, 0x31, 0xe2, 0x18, 0x03, 0x19, 0x02, 0x19, 0x64, 0x21, 0xe2, 0x18, + 0x81, 0x08, 0xe2, 0x18, 0xc2, 0x10, 0x03, 0x19, 0x81, 0x10, 0xe2, 0x18, 0x02, 0x21, 0x81, 0x10, + 0x82, 0x10, 0x61, 0x08, 0x81, 0x10, 0xc2, 0x18, 0x41, 0x08, 0x82, 0x10, 0x03, 0x42, 0x45, 0x52, + 0xa6, 0x52, 0x82, 0x29, 0xe1, 0x08, 0xe1, 0x10, 0xe1, 0x10, 0x22, 0x21, 0x21, 0x21, 0xc1, 0x10, + 0x42, 0x21, 0x42, 0x4a, 0x66, 0x4a, 0x66, 0x42, 0x43, 0x21, 0xa7, 0x52, 0xc7, 0x52, 0x6a, 0x73, + 0xeb, 0x83, 0x09, 0x7c, 0x02, 0x74, 0xc8, 0x73, 0x0b, 0x84, 0xe7, 0x5a, 0x07, 0x5b, 0x86, 0x6b, + 0x82, 0x63, 0x63, 0x74, 0x06, 0x53, 0x49, 0x84, 0x87, 0x8c, 0x22, 0x5b, 0x25, 0x63, 0xea, 0x7b, + 0x07, 0x84, 0xab, 0x94, 0x07, 0x84, 0x42, 0x63, 0x83, 0x6b, 0x80, 0x6b, 0x00, 0x53, 0x61, 0x42, + 0x43, 0x3a, 0x42, 0x21, 0xa6, 0x31, 0x43, 0x29, 0x48, 0x4a, 0xc7, 0x39, 0x49, 0x4a, 0x0a, 0x6b, + 0xc8, 0x62, 0xa6, 0x7b, 0x23, 0x63, 0x24, 0x63, 0xa6, 0x73, 0x07, 0x7c, 0x06, 0x7c, 0x85, 0x73, + 0x22, 0x21, 0x63, 0x21, 0x41, 0x19, 0x81, 0x21, 0xa2, 0x21, 0x81, 0x21, 0xe2, 0x29, 0x80, 0x21, + 0xa1, 0x29, 0x81, 0x21, 0xc1, 0x29, 0x61, 0x19, 0x82, 0x19, 0x44, 0x3a, 0x64, 0x21, 0xe0, 0x10, + 0x04, 0x32, 0xe4, 0x29, 0xc3, 0x18, 0xc1, 0x08, 0x06, 0x32, 0x03, 0x2a, 0x65, 0x3a, 0x23, 0x21, + 0xa5, 0x29, 0xc3, 0x18, 0x03, 0x21, 0xe2, 0x18, 0x07, 0x3a, 0xa2, 0x10, 0x64, 0x29, 0xe2, 0x18, + 0x03, 0x19, 0x24, 0x32, 0x03, 0x19, 0xe2, 0x10, 0x27, 0x3a, 0xa4, 0x29, 0xc5, 0x31, 0x81, 0x08, + 0xa3, 0x21, 0xa1, 0x21, 0xe6, 0x31, 0xe2, 0x10, 0x64, 0x21, 0x67, 0x3a, 0xa4, 0x29, 0xe5, 0x29, + 0x64, 0x29, 0xc4, 0x29, 0xc3, 0x18, 0x61, 0x08, 0xa2, 0x10, 0xc2, 0x10, 0xe3, 0x18, 0xc2, 0x10, + 0x03, 0x21, 0x61, 0x08, 0xe3, 0x18, 0xc2, 0x10, 0xa1, 0x10, 0xa1, 0x10, 0xc3, 0x18, 0xc3, 0x18, + 0x02, 0x21, 0xe2, 0x18, 0xc2, 0x18, 0xa4, 0x31, 0xe2, 0x18, 0x22, 0x29, 0x64, 0x4a, 0xa2, 0x31, + 0xc3, 0x31, 0x67, 0x42, 0xe1, 0x10, 0x22, 0x19, 0x26, 0x4a, 0x08, 0x63, 0x4a, 0x73, 0x09, 0x5b, + 0x0a, 0x63, 0x0c, 0x84, 0x27, 0x63, 0x0c, 0x84, 0x2c, 0x8c, 0x6a, 0x73, 0x27, 0x4a, 0x28, 0x63, + 0xe8, 0x94, 0x49, 0x9d, 0xa2, 0x74, 0x47, 0x7c, 0xe7, 0x7b, 0x24, 0x7c, 0x63, 0x63, 0xa1, 0x63, + 0xe1, 0x73, 0x27, 0xbe, 0x85, 0xb5, 0x6a, 0xd6, 0x43, 0xad, 0x2a, 0xce, 0x49, 0xb5, 0x64, 0x8c, + 0x05, 0x7c, 0x43, 0x63, 0x83, 0x4a, 0xa1, 0x42, 0x60, 0x4a, 0x24, 0x6b, 0x02, 0x5b, 0xa3, 0x6b, + 0x23, 0x84, 0xc8, 0x9c, 0xc9, 0x83, 0xa9, 0x7b, 0xcd, 0xa4, 0x6a, 0x94, 0x70, 0xbd, 0x26, 0x8c, + 0xe8, 0x83, 0x65, 0x73, 0x65, 0x6b, 0x66, 0x6b, 0x83, 0x52, 0x40, 0x5b, 0x03, 0x5b, 0xc4, 0x52, + 0x41, 0x21, 0x01, 0x19, 0x01, 0x19, 0x42, 0x21, 0xa1, 0x21, 0x82, 0x21, 0xc2, 0x29, 0xc2, 0x31, + 0x81, 0x21, 0xc2, 0x29, 0x81, 0x21, 0x82, 0x29, 0x61, 0x21, 0x20, 0x32, 0xe0, 0x29, 0x60, 0x32, + 0x60, 0x32, 0x83, 0x32, 0xe2, 0x21, 0xe3, 0x31, 0x22, 0x19, 0x45, 0x3a, 0x24, 0x21, 0xe4, 0x29, + 0x62, 0x21, 0x82, 0x10, 0x44, 0x21, 0x64, 0x29, 0xe2, 0x18, 0x63, 0x29, 0x03, 0x19, 0xc2, 0x10, + 0x82, 0x08, 0x45, 0x3a, 0xc2, 0x10, 0xa3, 0x18, 0x44, 0x21, 0x44, 0x21, 0xe2, 0x18, 0xe3, 0x18, + 0xc1, 0x10, 0x42, 0x19, 0xe2, 0x18, 0xe3, 0x18, 0xc2, 0x10, 0x07, 0x3a, 0x63, 0x21, 0x43, 0x21, + 0xe3, 0x18, 0xa1, 0x10, 0xc2, 0x18, 0xc2, 0x18, 0xe2, 0x18, 0xe2, 0x10, 0xa1, 0x10, 0xa2, 0x10, + 0x81, 0x10, 0xc2, 0x18, 0x81, 0x10, 0xe2, 0x18, 0xa1, 0x10, 0x23, 0x21, 0x02, 0x19, 0x01, 0x19, + 0xe1, 0x42, 0x03, 0x32, 0x83, 0x42, 0xa5, 0x52, 0x01, 0x19, 0xe2, 0x29, 0xc2, 0x31, 0x87, 0x52, + 0x46, 0x4a, 0x4a, 0x63, 0xa8, 0x52, 0xe8, 0x5a, 0x8f, 0x94, 0x09, 0x84, 0x28, 0x8c, 0x2c, 0x8c, + 0x4d, 0x84, 0x6a, 0x73, 0xaf, 0x9c, 0x91, 0xa4, 0x8f, 0x9c, 0x89, 0x73, 0xa1, 0x6b, 0x05, 0x74, + 0x24, 0x74, 0x67, 0x84, 0xc5, 0x94, 0xeb, 0xac, 0xb0, 0xee, 0xab, 0xe6, 0x80, 0x73, 0xe2, 0x83, + 0x03, 0x84, 0x65, 0x8c, 0x63, 0x94, 0xe5, 0xa4, 0x80, 0x8c, 0x28, 0xd6, 0x08, 0xd6, 0x28, 0xd6, + 0xcd, 0xe6, 0x8d, 0xde, 0x8b, 0x9c, 0x0b, 0xad, 0x2c, 0xad, 0xa6, 0x73, 0xe6, 0x83, 0xc7, 0x83, + 0x45, 0x73, 0x21, 0x63, 0x22, 0x3a, 0x83, 0x52, 0x89, 0x8c, 0xa0, 0x52, 0xcb, 0x9c, 0xc5, 0x83, + 0xc5, 0x5a, 0x24, 0x4a, 0x05, 0x5b, 0x24, 0x5b, 0xe4, 0x52, 0xe3, 0x5a, 0xc4, 0x52, 0x44, 0x42, + 0x63, 0x29, 0x42, 0x21, 0x02, 0x19, 0x02, 0x19, 0x22, 0x19, 0xa1, 0x19, 0x62, 0x21, 0xa4, 0x29, + 0x62, 0x21, 0x81, 0x21, 0x42, 0x21, 0x62, 0x29, 0xc1, 0x29, 0xc1, 0x21, 0x01, 0x32, 0xa0, 0x21, + 0xa3, 0x29, 0xa1, 0x21, 0x80, 0x3a, 0x41, 0x32, 0xe4, 0x29, 0x23, 0x32, 0x84, 0x29, 0xa3, 0x21, + 0xc5, 0x4a, 0xe4, 0x39, 0xc2, 0x18, 0x03, 0x19, 0xc2, 0x10, 0x84, 0x29, 0x04, 0x21, 0xe3, 0x18, + 0xc3, 0x10, 0xe5, 0x29, 0x44, 0x29, 0x43, 0x21, 0xa5, 0x31, 0x44, 0x21, 0x03, 0x21, 0x41, 0x08, + 0x82, 0x10, 0xc2, 0x29, 0x43, 0x19, 0xc2, 0x10, 0x44, 0x21, 0x02, 0x19, 0xc2, 0x10, 0x63, 0x29, + 0x03, 0x21, 0xc2, 0x10, 0xa2, 0x10, 0xc2, 0x10, 0xe2, 0x10, 0x02, 0x19, 0xa2, 0x10, 0xe3, 0x18, + 0xc3, 0x18, 0x22, 0x21, 0x03, 0x19, 0x02, 0x21, 0x62, 0x42, 0x40, 0x32, 0x41, 0x19, 0xe2, 0x18, + 0xa0, 0x42, 0xc4, 0x31, 0xa3, 0x31, 0x46, 0x42, 0xa4, 0x31, 0x87, 0x4a, 0x8c, 0x73, 0x50, 0x8c, + 0x71, 0x94, 0xad, 0x7b, 0x71, 0x94, 0x2f, 0x8c, 0xf2, 0xa4, 0x70, 0x94, 0xf1, 0xac, 0x8c, 0x73, + 0xaa, 0x5a, 0x8d, 0x83, 0x8c, 0x83, 0xe9, 0x72, 0x69, 0x73, 0xa9, 0x6b, 0xcc, 0x94, 0x68, 0x6b, + 0x0f, 0xa5, 0x0b, 0x7c, 0x08, 0xa5, 0x27, 0xb5, 0x2a, 0xd6, 0x87, 0xc5, 0xea, 0xb4, 0xe8, 0x83, + 0xc2, 0x7b, 0x48, 0x8c, 0x03, 0x84, 0x66, 0x84, 0xe2, 0x7b, 0x22, 0x84, 0x04, 0x9c, 0x67, 0xc5, + 0xcc, 0xcd, 0x07, 0xb5, 0x6a, 0xc5, 0xa6, 0xa4, 0x05, 0x8c, 0xe6, 0x83, 0xe5, 0x73, 0xe4, 0x52, + 0x47, 0x6b, 0xe2, 0x52, 0x82, 0x42, 0x83, 0x4a, 0x43, 0x52, 0x28, 0xa4, 0xec, 0xed, 0x8c, 0xee, + 0x24, 0x6b, 0x45, 0x4a, 0x28, 0x63, 0xc4, 0x52, 0x47, 0x63, 0xa4, 0x52, 0x24, 0x63, 0x03, 0x5b, + 0xa1, 0x10, 0x22, 0x21, 0x01, 0x11, 0x42, 0x21, 0xa1, 0x10, 0x21, 0x19, 0xa4, 0x31, 0xa5, 0x31, + 0xe5, 0x31, 0xa3, 0x31, 0x41, 0x19, 0x43, 0x21, 0x02, 0x19, 0x02, 0x11, 0x81, 0x21, 0xc1, 0x21, + 0x61, 0x19, 0x82, 0x21, 0xa1, 0x21, 0xe1, 0x29, 0xa0, 0x21, 0xc1, 0x29, 0xa1, 0x21, 0x00, 0x2a, + 0xa3, 0x42, 0xa3, 0x29, 0x83, 0x29, 0x63, 0x29, 0xa2, 0x10, 0xc2, 0x10, 0x61, 0x08, 0xe3, 0x10, + 0xa2, 0x10, 0x23, 0x21, 0x83, 0x29, 0x85, 0x3a, 0xc2, 0x10, 0x88, 0x4a, 0xc2, 0x10, 0xa2, 0x10, + 0x81, 0x10, 0x00, 0x22, 0x81, 0x21, 0x63, 0x21, 0xe2, 0x18, 0x03, 0x19, 0x81, 0x08, 0xa0, 0x10, + 0x02, 0x19, 0x42, 0x21, 0xc1, 0x10, 0x82, 0x10, 0xc2, 0x10, 0xe2, 0x10, 0xa1, 0x10, 0xa1, 0x10, + 0xc1, 0x08, 0x02, 0x32, 0xe2, 0x31, 0x42, 0x19, 0xc1, 0x29, 0xa3, 0x42, 0xc6, 0x52, 0x28, 0x6b, + 0xe7, 0x5a, 0x70, 0x94, 0xeb, 0x7b, 0x0d, 0x7c, 0xec, 0x83, 0x6e, 0x94, 0xee, 0x83, 0x0c, 0x6b, + 0xce, 0x83, 0x50, 0x94, 0xce, 0x83, 0x54, 0xb5, 0x6f, 0x94, 0x08, 0x6b, 0x03, 0x5b, 0x84, 0x53, + 0x49, 0x6b, 0x67, 0x52, 0xc1, 0x42, 0x23, 0x4b, 0x63, 0x42, 0x89, 0x73, 0x6c, 0x8c, 0x48, 0x63, + 0x49, 0x6b, 0xac, 0x94, 0x2a, 0xb5, 0x2f, 0xde, 0xeb, 0xa4, 0x88, 0x8c, 0x63, 0x6b, 0x60, 0x6b, + 0x60, 0x6b, 0xea, 0x83, 0xa0, 0x73, 0xc8, 0xcd, 0x68, 0xd6, 0x24, 0xad, 0x80, 0x73, 0x64, 0x7b, + 0x03, 0x8c, 0xc5, 0xa4, 0xa0, 0x7b, 0x85, 0x9c, 0x42, 0x6b, 0x86, 0x73, 0x25, 0x84, 0x2d, 0xb5, + 0xed, 0xd5, 0x28, 0xbd, 0xa6, 0xac, 0x46, 0xc5, 0x4c, 0xe6, 0xe9, 0xe5, 0x08, 0xde, 0x66, 0xbd, + 0x63, 0x73, 0xe7, 0x62, 0x86, 0x52, 0x0c, 0x8c, 0x48, 0x63, 0x44, 0x52, 0x27, 0x8c, 0xac, 0xc5, + 0x82, 0x10, 0xa1, 0x18, 0x84, 0x31, 0x63, 0x29, 0x03, 0x21, 0x64, 0x29, 0x65, 0x31, 0xa1, 0x10, + 0x64, 0x31, 0x64, 0x29, 0x63, 0x29, 0x23, 0x21, 0x83, 0x31, 0x43, 0x29, 0x22, 0x21, 0x61, 0x21, + 0x62, 0x21, 0x61, 0x29, 0xe3, 0x31, 0xa1, 0x21, 0x02, 0x2a, 0xe3, 0x31, 0xe2, 0x29, 0xe1, 0x29, + 0x21, 0x32, 0x00, 0x2a, 0xe2, 0x29, 0xa3, 0x29, 0x63, 0x29, 0xa4, 0x29, 0x03, 0x2a, 0x41, 0x21, + 0x23, 0x19, 0xe3, 0x10, 0x24, 0x21, 0x64, 0x29, 0xa1, 0x10, 0x23, 0x21, 0xc3, 0x18, 0x41, 0x08, + 0x81, 0x10, 0x21, 0x19, 0xc3, 0x18, 0xc1, 0x18, 0xa2, 0x10, 0x81, 0x10, 0x43, 0x21, 0x81, 0x10, + 0xc1, 0x18, 0xe2, 0x18, 0xc4, 0x29, 0xe2, 0x10, 0xc2, 0x10, 0x21, 0x19, 0x25, 0x3a, 0xe2, 0x18, + 0x42, 0x19, 0x81, 0x21, 0xe3, 0x31, 0xc6, 0x5a, 0xcb, 0x7b, 0xec, 0x83, 0x0f, 0x8c, 0xd0, 0xa4, + 0xef, 0xa4, 0xb0, 0x94, 0xd3, 0xbd, 0x8c, 0x73, 0xe8, 0x73, 0xca, 0x7b, 0xcb, 0x62, 0xa6, 0x39, + 0x31, 0x94, 0xae, 0x83, 0xce, 0x93, 0xea, 0x7b, 0x2d, 0x9d, 0x88, 0x7b, 0xa5, 0x63, 0x22, 0x3a, + 0xa6, 0x5a, 0xc4, 0x42, 0x80, 0x53, 0x86, 0xa5, 0x0d, 0xce, 0xab, 0x7b, 0xaa, 0x5a, 0x4b, 0x73, + 0x4b, 0x7b, 0x69, 0x52, 0x6e, 0x7b, 0x2a, 0x73, 0x4a, 0x7b, 0x28, 0x94, 0xc9, 0x83, 0xcb, 0x9c, + 0x23, 0x7c, 0xa1, 0x4a, 0x07, 0xce, 0x6d, 0xe6, 0x07, 0xb5, 0xa7, 0xd5, 0x67, 0xc5, 0x86, 0xcd, + 0x09, 0xe6, 0x8b, 0xfe, 0x48, 0xde, 0x86, 0xcd, 0xe6, 0xb4, 0x2f, 0xe6, 0x2c, 0xe6, 0x44, 0xbd, + 0xa9, 0xcd, 0xcc, 0xd5, 0x4a, 0xee, 0xe7, 0xd5, 0x47, 0xe6, 0x4a, 0xe6, 0x27, 0xbd, 0x2b, 0xb5, + 0xe7, 0x93, 0x67, 0x7b, 0x27, 0x9c, 0x68, 0x9c, 0x26, 0x9c, 0x49, 0xb5, 0x4a, 0xbd, 0xeb, 0xd5, + +}; diff --git a/pio/i2c/CMakeLists.txt b/pio/i2c/CMakeLists.txt new file mode 100644 index 0000000..d49b224 --- /dev/null +++ b/pio/i2c/CMakeLists.txt @@ -0,0 +1,16 @@ +add_executable(pio_i2c_bus_scan) + +pico_generate_pio_header(pio_i2c_bus_scan ${CMAKE_CURRENT_LIST_DIR}/i2c.pio) + +target_sources(pio_i2c_bus_scan PRIVATE + i2c_bus_scan.c + pio_i2c.c + pio_i2c.h + ) + +target_link_libraries(pio_i2c_bus_scan PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_i2c_bus_scan) + +# add url via pico_set_program_url +example_auto_set_url(pio_i2c_bus_scan) + diff --git a/pio/i2c/i2c.pio b/pio/i2c/i2c.pio new file mode 100644 index 0000000..8e9fae0 --- /dev/null +++ b/pio/i2c/i2c.pio @@ -0,0 +1,144 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program i2c +.side_set 1 opt pindirs + +; TX Encoding: +; | 15:10 | 9 | 8:1 | 0 | +; | Instr | Final | Data | NAK | +; +; If Instr has a value n > 0, then this FIFO word has no +; data payload, and the next n + 1 words will be executed as instructions. +; Otherwise, shift out the 8 data bits, followed by the ACK bit. +; +; The Instr mechanism allows stop/start/repstart sequences to be programmed +; by the processor, and then carried out by the state machine at defined points +; in the datastream. +; +; The "Final" field should be set for the final byte in a transfer. +; This tells the state machine to ignore a NAK: if this field is not +; set, then any NAK will cause the state machine to halt and interrupt. +; +; Autopull should be enabled, with a threshold of 16. +; Autopush should be enabled, with a threshold of 8. +; The TX FIFO should be accessed with halfword writes, to ensure +; the data is immediately available in the OSR. +; +; Pin mapping: +; - Input pin 0 is SDA, 1 is SCL (if clock stretching used) +; - Jump pin is SDA +; - Side-set pin 0 is SCL +; - Set pin 0 is SDA +; - OUT pin 0 is SDA +; - SCL must be SDA + 1 (for wait mapping) +; +; The OE outputs should be inverted in the system IO controls! +; (It's possible for the inversion to be done in this program, +; but costs 2 instructions: 1 for inversion, and one to cope +; with the side effect of the MOV on TX shift counter.) + +do_nack: + jmp y-- entry_point ; Continue if NAK was expected + irq wait 0 rel ; Otherwise stop, ask for help + +do_byte: + set x, 7 ; Loop 8 times +bitloop: + out pindirs, 1 [7] ; Serialise write data (all-ones if reading) + nop side 1 [2] ; SCL rising edge + wait 1 pin, 1 [4] ; Allow clock to be stretched + in pins, 1 [7] ; Sample read data in middle of SCL pulse + jmp x-- bitloop side 0 [7] ; SCL falling edge + + ; Handle ACK pulse + out pindirs, 1 [7] ; On reads, we provide the ACK. + nop side 1 [7] ; SCL rising edge + wait 1 pin, 1 [7] ; Allow clock to be stretched + jmp pin do_nack side 0 [2] ; Test SDA for ACK/NAK, fall through if ACK + +public entry_point: +.wrap_target + out x, 6 ; Unpack Instr count + out y, 1 ; Unpack the NAK ignore bit + jmp !x do_byte ; Instr == 0, this is a data record. + out null, 32 ; Instr > 0, remainder of this OSR is invalid +do_exec: + out exec, 16 ; Execute one instruction per FIFO word + jmp x-- do_exec ; Repeat n + 1 times +.wrap + +% c-sdk { + +#include "hardware/clocks.h" +#include "hardware/gpio.h" + + +static inline void i2c_program_init(PIO pio, uint sm, uint offset, uint pin_sda, uint pin_scl) { + assert(pin_scl == pin_sda + 1); + pio_sm_config c = i2c_program_get_default_config(offset); + + // IO mapping + sm_config_set_out_pins(&c, pin_sda, 1); + sm_config_set_set_pins(&c, pin_sda, 1); + sm_config_set_in_pins(&c, pin_sda); + sm_config_set_sideset_pins(&c, pin_scl); + sm_config_set_jmp_pin(&c, pin_sda); + + sm_config_set_out_shift(&c, false, true, 16); + sm_config_set_in_shift(&c, false, true, 8); + + float div = (float)clock_get_hz(clk_sys) / (32 * 100000); + sm_config_set_clkdiv(&c, div); + + // Try to avoid glitching the bus while connecting the IOs. Get things set + // up so that pin is driven down when PIO asserts OE low, and pulled up + // otherwise. + gpio_pull_up(pin_scl); + gpio_pull_up(pin_sda); + uint32_t both_pins = (1u << pin_sda) | (1u << pin_scl); + pio_sm_set_pins_with_mask(pio, sm, both_pins, both_pins); + pio_sm_set_pindirs_with_mask(pio, sm, both_pins, both_pins); + pio_gpio_init(pio, pin_sda); + gpio_set_oeover(pin_sda, GPIO_OVERRIDE_INVERT); + pio_gpio_init(pio, pin_scl); + gpio_set_oeover(pin_scl, GPIO_OVERRIDE_INVERT); + pio_sm_set_pins_with_mask(pio, sm, 0, both_pins); + + // Clear IRQ flag before starting + hw_clear_bits(&pio->inte0, 1u << sm); + hw_clear_bits(&pio->inte1, 1u << sm); + pio->irq = 1u << sm; + + // Configure and start SM + pio_sm_init(pio, sm, offset + i2c_offset_entry_point, &c); + pio_sm_set_enabled(pio, sm, true); +} + +%} + + +.program set_scl_sda +.side_set 1 opt + +; Assemble a table of instructions which software can select from, and pass +; into the FIFO, to issue START/STOP/RSTART. This isn't intended to be run as +; a complete program. + + set pindirs, 0 side 0 [7] ; SCL = 0, SDA = 0 + set pindirs, 1 side 0 [7] ; SCL = 0, SDA = 1 + set pindirs, 0 side 1 [7] ; SCL = 1, SDA = 0 + set pindirs, 1 side 1 [7] ; SCL = 1, SDA = 1 + +% c-sdk { +// Define order of our instruction table +enum { + I2C_SC0_SD0 = 0, + I2C_SC0_SD1, + I2C_SC1_SD0, + I2C_SC1_SD1 +}; +%} diff --git a/pio/i2c/i2c_bus_scan.c b/pio/i2c/i2c_bus_scan.c new file mode 100644 index 0000000..5e6db23 --- /dev/null +++ b/pio/i2c/i2c_bus_scan.c @@ -0,0 +1,42 @@ +#include + +#include "pico/stdlib.h" +#include "pio_i2c.h" + +#define PIN_SDA 2 +#define PIN_SCL 3 + +bool reserved_addr(uint8_t addr) { + return (addr & 0x78) == 0 || (addr & 0x78) == 0x78; +} + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &i2c_program); + i2c_program_init(pio, sm, offset, PIN_SDA, PIN_SCL); + + printf("\nPIO I2C Bus Scan\n"); + printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n"); + + for (int addr = 0; addr < (1 << 7); ++addr) { + if (addr % 16 == 0) { + printf("%02x ", addr); + } + // Perform a 0-byte read from the probe address. The read function + // returns a negative result NAK'd any time other than the last data + // byte. Skip over reserved addresses. + int result; + if (reserved_addr(addr)) + result = -1; + else + result = pio_i2c_read_blocking(pio, sm, addr, NULL, 0); + + printf(result < 0 ? "." : "@"); + printf(addr % 16 == 15 ? "\n" : " "); + } + printf("Done.\n"); + return 0; +} diff --git a/pio/i2c/pio_i2c.c b/pio/i2c/pio_i2c.c new file mode 100644 index 0000000..977553f --- /dev/null +++ b/pio/i2c/pio_i2c.c @@ -0,0 +1,139 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pio_i2c.h" + +const int PIO_I2C_ICOUNT_LSB = 10; +const int PIO_I2C_FINAL_LSB = 9; +const int PIO_I2C_DATA_LSB = 1; +const int PIO_I2C_NAK_LSB = 0; + + +bool pio_i2c_check_error(PIO pio, uint sm) { + return !!(pio->irq & (1u << sm)); +} + +void pio_i2c_resume_after_error(PIO pio, uint sm) { + pio_sm_drain_tx_fifo(pio, sm); + pio_sm_exec(pio, sm, (pio->sm[sm].execctrl & PIO_SM0_EXECCTRL_WRAP_BOTTOM_BITS) >> PIO_SM0_EXECCTRL_WRAP_BOTTOM_LSB); + pio->irq = 1u << sm; +} + +void pio_i2c_rx_enable(PIO pio, uint sm, bool en) { + if (en) + hw_set_bits(&pio->sm[sm].shiftctrl, PIO_SM0_SHIFTCTRL_AUTOPUSH_BITS); + else + hw_clear_bits(&pio->sm[sm].shiftctrl, PIO_SM0_SHIFTCTRL_AUTOPUSH_BITS); +} + +static inline void pio_i2c_put16(PIO pio, uint sm, uint16_t data) { + while (pio_sm_is_tx_fifo_full(pio, sm)) + ; + *(io_rw_16 *)&pio->txf[sm] = data; +} + + +// If I2C is ok, block and push data. Otherwise fall straight through. +void pio_i2c_put_or_err(PIO pio, uint sm, uint16_t data) { + while (pio_sm_is_tx_fifo_full(pio, sm)) + if (pio_i2c_check_error(pio, sm)) + return; + if (pio_i2c_check_error(pio, sm)) + return; + *(io_rw_16 *)&pio->txf[sm] = data; +} + +uint8_t pio_i2c_get(PIO pio, uint sm) { + return (uint8_t)pio_sm_get(pio, sm); +} + +void pio_i2c_start(PIO pio, uint sm) { + pio_i2c_put_or_err(pio, sm, 1u << PIO_I2C_ICOUNT_LSB); // Escape code for 2 instruction sequence + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC1_SD0]); // We are already in idle state, just pull SDA low + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC0_SD0]); // Also pull clock low so we can present data +} + +void pio_i2c_stop(PIO pio, uint sm) { + pio_i2c_put_or_err(pio, sm, 2u << PIO_I2C_ICOUNT_LSB); + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC0_SD0]); // SDA is unknown; pull it down + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC1_SD0]); // Release clock + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC1_SD1]); // Release SDA to return to idle state +}; + +void pio_i2c_repstart(PIO pio, uint sm) { + pio_i2c_put_or_err(pio, sm, 3u << PIO_I2C_ICOUNT_LSB); + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC0_SD1]); + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC1_SD1]); + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC1_SD0]); + pio_i2c_put_or_err(pio, sm, set_scl_sda_program_instructions[I2C_SC0_SD0]); +} + +static void pio_i2c_wait_idle(PIO pio, uint sm) { + // Finished when TX runs dry or SM hits an IRQ + pio->fdebug = 1u << (PIO_FDEBUG_TXSTALL_LSB + sm); + while (!(pio->fdebug & 1u << (PIO_FDEBUG_TXSTALL_LSB + sm) || pio_i2c_check_error(pio, sm))) + tight_loop_contents(); +} + +int pio_i2c_write_blocking(PIO pio, uint sm, uint8_t addr, uint8_t *txbuf, uint len) { + int err = 0; + pio_i2c_start(pio, sm); + pio_i2c_rx_enable(pio, sm, false); + pio_i2c_put16(pio, sm, (addr << 2) | 1u); + while (len && !pio_i2c_check_error(pio, sm)) { + if (!pio_sm_is_tx_fifo_full(pio, sm)) { + --len; + pio_i2c_put_or_err(pio, sm, (*txbuf++ << PIO_I2C_DATA_LSB) | ((len == 0) << PIO_I2C_FINAL_LSB) | 1u); + } + } + pio_i2c_stop(pio, sm); + pio_i2c_wait_idle(pio, sm); + if (pio_i2c_check_error(pio, sm)) { + err = -1; + pio_i2c_resume_after_error(pio, sm); + pio_i2c_stop(pio, sm); + } + return err; +} + +int pio_i2c_read_blocking(PIO pio, uint sm, uint8_t addr, uint8_t *rxbuf, uint len) { + int err = 0; + pio_i2c_start(pio, sm); + pio_i2c_rx_enable(pio, sm, true); + while (!pio_sm_is_rx_fifo_empty(pio, sm)) + (void)pio_i2c_get(pio, sm); + pio_i2c_put16(pio, sm, (addr << 2) | 3u); + uint32_t tx_remain = len; // Need to stuff 0xff bytes in to get clocks + + bool first = true; + + while ((tx_remain || len) && !pio_i2c_check_error(pio, sm)) { + if (tx_remain && !pio_sm_is_tx_fifo_full(pio, sm)) { + --tx_remain; + pio_i2c_put16(pio, sm, (0xffu << 1) | (tx_remain ? 0 : (1u << PIO_I2C_FINAL_LSB) | (1u << PIO_I2C_NAK_LSB))); + } + if (!pio_sm_is_rx_fifo_empty(pio, sm)) { + if (first) { + // Ignore returned address byte + (void)pio_i2c_get(pio, sm); + first = false; + } + else { + --len; + *rxbuf++ = pio_i2c_get(pio, sm); + } + } + } + pio_i2c_stop(pio, sm); + pio_i2c_wait_idle(pio, sm); + if (pio_i2c_check_error(pio, sm)) { + err = -1; + pio_i2c_resume_after_error(pio, sm); + pio_i2c_stop(pio, sm); + } + return err; +} + diff --git a/pio/i2c/pio_i2c.h b/pio/i2c/pio_i2c.h new file mode 100644 index 0000000..554c333 --- /dev/null +++ b/pio/i2c/pio_i2c.h @@ -0,0 +1,31 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef _PIO_I2C_H +#define _PIO_I2C_H + +#include "i2c.pio.h" + +// ---------------------------------------------------------------------------- +// Low-level functions + +void pio_i2c_start(PIO pio, uint sm); +void pio_i2c_stop(PIO pio, uint sm); +void pio_i2c_repstart(PIO pio, uint sm); + +bool pio_i2c_check_error(PIO pio, uint sm); +void pio_i2c_resume_after_error(PIO pio, uint sm); + +// If I2C is ok, block and push data. Otherwise fall straight through. +void pio_i2c_put_or_err(PIO pio, uint sm, uint16_t data); +uint8_t pio_i2c_get(PIO pio, uint sm); + +// ---------------------------------------------------------------------------- +// Transaction-level functions + +int pio_i2c_write_blocking(PIO pio, uint sm, uint8_t addr, uint8_t *txbuf, uint len); +int pio_i2c_read_blocking(PIO pio, uint sm, uint8_t addr, uint8_t *rxbuf, uint len); + +#endif diff --git a/pio/logic_analyser/CMakeLists.txt b/pio/logic_analyser/CMakeLists.txt new file mode 100644 index 0000000..8a65198 --- /dev/null +++ b/pio/logic_analyser/CMakeLists.txt @@ -0,0 +1,9 @@ +add_executable(pio_logic_analyser) + +target_sources(pio_logic_analyser PRIVATE logic_analyser.c) + +target_link_libraries(pio_logic_analyser PRIVATE pico_stdlib hardware_pio hardware_dma) +pico_add_extra_outputs(pio_logic_analyser) + +# add url via pico_set_program_url +example_auto_set_url(pio_logic_analyser) \ No newline at end of file diff --git a/pio/logic_analyser/logic_analyser.c b/pio/logic_analyser/logic_analyser.c new file mode 100644 index 0000000..faf9809 --- /dev/null +++ b/pio/logic_analyser/logic_analyser.c @@ -0,0 +1,125 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// PIO logic analyser example +// +// This program captures samples from a group of pins, at a fixed rate, once a +// trigger condition is detected (level condition on one pin). The samples are +// transferred to a capture buffer using the system DMA. +// +// 1 to 32 pins can be captured, at a sample rate no greater than system clock +// frequency. + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/dma.h" + +// Some logic to analyse: +#include "hardware/structs/pwm.h" + +const uint CAPTURE_PIN_BASE = 16; +const uint CAPTURE_PIN_COUNT = 2; +const uint CAPTURE_N_SAMPLES = 96; + +void logic_analyser_init(PIO pio, uint sm, uint pin_base, uint pin_count, float div) { + // Load a program to capture n pins. This is just a single `in pins, n` + // instruction with a wrap. + uint16_t capture_prog_instr = pio_encode_in(pio_pins, pin_count); + struct pio_program capture_prog = { + .instructions = &capture_prog_instr, + .length = 1, + .origin = -1 + }; + uint offset = pio_add_program(pio, &capture_prog); + + // Configure state machine to loop over this `in` instruction forever, + // with autopush enabled. + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_in_pins(&c, pin_base); + sm_config_set_wrap(&c, offset, offset); + sm_config_set_clkdiv(&c, div); + sm_config_set_in_shift(&c, true, true, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + pio_sm_init(pio, sm, offset, &c); +} + +void logic_analyser_arm(PIO pio, uint sm, uint dma_chan, uint32_t *capture_buf, size_t capture_size_words, + uint trigger_pin, bool trigger_level) { + pio_sm_set_enabled(pio, sm, false); + pio_sm_clear_fifos(pio, sm); + + dma_channel_config c = dma_channel_get_default_config(dma_chan); + channel_config_set_read_increment(&c, false); + channel_config_set_write_increment(&c, true); + channel_config_set_dreq(&c, pio_get_dreq(pio, sm, false)); + + dma_channel_configure(dma_chan, &c, + capture_buf, // Destinatinon pointer + &pio->rxf[sm], // Source pointer + capture_size_words, // Number of transfers + true // Start immediately + ); + + pio_sm_exec(pio, sm, pio_encode_wait_gpio(trigger_level, trigger_pin)); + pio_sm_set_enabled(pio, sm, true); +} + +void print_capture_buf(const uint32_t *buf, uint pin_base, uint pin_count, uint32_t n_samples) { + // Display the capture buffer in text form, like this: + // 00: __--__--__--__--__--__-- + // 01: ____----____----____---- + printf("Capture:\n"); + for (int pin = 0; pin < pin_count; ++pin) { + printf("%02d: ", pin + pin_base); + for (int sample = 0; sample < n_samples; ++sample) { + uint bit_index = pin + sample * pin_count; + bool level = !!(buf[bit_index / 32] & 1u << (bit_index % 32)); + printf(level ? "-" : "_"); + } + printf("\n"); + } +} + +int main() { + stdio_init_all(); + printf("PIO logic analyser example\n"); + + uint32_t capture_buf[(CAPTURE_PIN_COUNT * CAPTURE_N_SAMPLES + 31) / 32]; + + PIO pio = pio0; + uint sm = 0; + uint dma_chan = 0; + + logic_analyser_init(pio, sm, CAPTURE_PIN_BASE, CAPTURE_PIN_COUNT, 1.f); + + printf("Arming trigger\n"); + logic_analyser_arm(pio, sm, dma_chan, capture_buf, //; + (CAPTURE_PIN_COUNT * CAPTURE_N_SAMPLES + 31) / 32, + CAPTURE_PIN_BASE, true); + + printf("Starting PWM example\n"); + // PWM example: ----------------------------------------------------------- + gpio_set_function(CAPTURE_PIN_BASE, GPIO_FUNC_PWM); + gpio_set_function(CAPTURE_PIN_BASE + 1, GPIO_FUNC_PWM); + // Topmost value of 3: count from 0 to 3 and then wrap, so period is 4 cycles + pwm_hw->slice[0].top = 3; + // Divide frequency by two to slow things down a little + pwm_hw->slice[0].div = 4 << PWM_CH0_DIV_INT_LSB; + // Set channel A to be high for 1 cycle each period (duty cycle 1/4) and + // channel B for 3 cycles (duty cycle 3/4) + pwm_hw->slice[0].cc = + (1 << PWM_CH0_CC_A_LSB) | + (3 << PWM_CH0_CC_B_LSB); + // Enable this PWM slice + pwm_hw->slice[0].csr = PWM_CH0_CSR_EN_BITS; + // ------------------------------------------------------------------------ + + dma_channel_wait_for_finish_blocking(dma_chan); + + print_capture_buf(capture_buf, CAPTURE_PIN_BASE, CAPTURE_PIN_COUNT, CAPTURE_N_SAMPLES); +} diff --git a/pio/manchester_encoding/CMakeLists.txt b/pio/manchester_encoding/CMakeLists.txt new file mode 100644 index 0000000..70b8828 --- /dev/null +++ b/pio/manchester_encoding/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_manchester_encoding) + +pico_generate_pio_header(pio_manchester_encoding ${CMAKE_CURRENT_LIST_DIR}/manchester_encoding.pio) + +target_sources(pio_manchester_encoding PRIVATE manchester_encoding.c) + +target_link_libraries(pio_manchester_encoding PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_manchester_encoding) + +# add url via pico_set_program_url +example_auto_set_url(pio_manchester_encoding) \ No newline at end of file diff --git a/pio/manchester_encoding/manchester_encoding.c b/pio/manchester_encoding/manchester_encoding.c new file mode 100644 index 0000000..4eb0638 --- /dev/null +++ b/pio/manchester_encoding/manchester_encoding.c @@ -0,0 +1,43 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "manchester_encoding.pio.h" + +// Manchester serial transmit/receive example. This transmits and receives at +// 10 Mbps if sysclk is 120 MHz. + +// Need to connect a wire from GPIO2 -> GPIO3 +const uint pin_tx = 2; +const uint pin_rx = 3; + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm_tx = 0; + uint sm_rx = 1; + + uint offset_tx = pio_add_program(pio, &manchester_tx_program); + uint offset_rx = pio_add_program(pio, &manchester_rx_program); + printf("Transmit program loaded at %d\n", offset_tx); + printf("Receive program loaded at %d\n", offset_rx); + + manchester_tx_program_init(pio, sm_tx, offset_tx, pin_tx, 1.f); + manchester_rx_program_init(pio, sm_rx, offset_rx, pin_rx, 1.f); + + pio_sm_set_enabled(pio, sm_tx, false); + pio_sm_put_blocking(pio, sm_tx, 0); + pio_sm_put_blocking(pio, sm_tx, 0x0ff0a55a); + pio_sm_put_blocking(pio, sm_tx, 0x12345678); + pio_sm_set_enabled(pio, sm_tx, true); + + for (int i = 0; i < 3; ++i) + printf("%08x\n", pio_sm_get_blocking(pio, sm_rx)); +} diff --git a/pio/manchester_encoding/manchester_encoding.pio b/pio/manchester_encoding/manchester_encoding.pio new file mode 100644 index 0000000..0117d2a --- /dev/null +++ b/pio/manchester_encoding/manchester_encoding.pio @@ -0,0 +1,94 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program manchester_tx +.side_set 1 opt + +; Transmit one bit every 12 cycles. a '0' is encoded as a high-low sequence +; (each part lasting half a bit period, or 6 cycles) and a '1' is encoded as a +; low-high sequence. +; +; Side-set bit 0 must be mapped to the GPIO used for TX. +; Autopull must be enabled -- this program does not care about the threshold. +; The program starts at the public label 'start'. + +.wrap_target +do_1: + nop side 0 [5] ; Low for 6 cycles (5 delay, +1 for nop) + jmp get_bit side 1 [3] ; High for 4 cycles. 'get_bit' takes another 2 cycles +do_0: + nop side 1 [5] ; Output high for 6 cycles + nop side 0 [3] ; Output low for 4 cycles +public start: +get_bit: + out x, 1 ; Always shift out one bit from OSR to X, so we can + jmp !x do_0 ; branch on it. Autopull refills the OSR when empty. +.wrap + +% c-sdk { +static inline void manchester_tx_program_init(PIO pio, uint sm, uint offset, uint pin, float div) { + pio_sm_set_pins_with_mask(pio, sm, 0, 1u << pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + pio_gpio_init(pio, pin); + + pio_sm_config c = manchester_tx_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, pin); + sm_config_set_out_shift(&c, true, true, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + sm_config_set_clkdiv(&c, div); + pio_sm_init(pio, sm, offset + manchester_tx_offset_start, &c); + + pio_sm_set_enabled(pio, sm, true); +} +%} + +.program manchester_rx + +; Assumes line is idle low, first bit is 0 +; One bit is 12 cycles +; a '0' is encoded as 10 +; a '1' is encoded as 01 +; +; Both the IN base and the JMP pin mapping must be pointed at the GPIO used for RX. +; Autopush must be enabled. +; Before enabling the SM, it should be placed in a 'wait 1, pin` state, so that +; it will not start sampling until the initial line idle state ends. + +start_of_0: ; We are 0.25 bits into a 0 - signal is high + wait 0 pin 0 ; Wait for the 1->0 transition - at this point we are 0.5 into the bit + in y, 1 [8] ; Emit a 0, sleep 3/4 of a bit + jmp pin start_of_0 ; If signal is 1 again, it's another 0 bit, otherwise it's a 1 + +.wrap_target +start_of_1: ; We are 0.25 bits into a 1 - signal is 1 + wait 1 pin 0 ; Wait for the 0->1 transition - at this point we are 0.5 into the bit + in x, 1 [8] ; Emit a 1, sleep 3/4 of a bit + jmp pin start_of_0 ; If signal is 0 again, it's another 1 bit otherwise it's a 0 +.wrap + +% c-sdk { +static inline void manchester_rx_program_init(PIO pio, uint sm, uint offset, uint pin, float div) { + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); + pio_gpio_init(pio, pin); + + pio_sm_config c = manchester_rx_program_get_default_config(offset); + sm_config_set_in_pins(&c, pin); // for WAIT + sm_config_set_jmp_pin(&c, pin); // for JMP + sm_config_set_in_shift(&c, true, true, 32); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + sm_config_set_clkdiv(&c, div); + pio_sm_init(pio, sm, offset, &c); + + // X and Y are set to 0 and 1, to conveniently emit these to ISR/FIFO. + pio_sm_exec(pio, sm, pio_encode_set(pio_x, 1)); + pio_sm_exec(pio, sm, pio_encode_set(pio_y, 0)); + // Assume line is idle low, and first transmitted bit is 0. Put SM in a + // wait state before enabling. RX will begin once the first 0 symbol is + // detected. + pio_sm_exec(pio, sm, pio_encode_wait_pin(1, 0) | pio_encode_delay(2)); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/pio/pio_blink/CMakeLists.txt b/pio/pio_blink/CMakeLists.txt new file mode 100644 index 0000000..88b5584 --- /dev/null +++ b/pio/pio_blink/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(pio_blink) + +# by default the header is generated into the build dir +pico_generate_pio_header(pio_blink ${CMAKE_CURRENT_LIST_DIR}/blink.pio) +# however, alternatively you can choose to generate it somewhere else (in this case in the source tree for check in) +#pico_generate_pio_header(pio_blink ${CMAKE_CURRENT_LIST_DIR}/blink.pio OUTPUT_DIR ${CMAKE_CURRENT_LIST_DIR}) + +target_sources(pio_blink PRIVATE blink.c) + +target_link_libraries(pio_blink PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_blink) + +# add url via pico_set_program_url +example_auto_set_url(pio_blink) \ No newline at end of file diff --git a/pio/pio_blink/blink.c b/pio/pio_blink/blink.c new file mode 100644 index 0000000..e9427ea --- /dev/null +++ b/pio/pio_blink/blink.c @@ -0,0 +1,34 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "blink.pio.h" + +void blink_pin_forever(PIO pio, uint sm, uint offset, uint pin, uint freq); + +int main() { + setup_default_uart(); + + // todo get free sm + PIO pio = pio0; + uint offset = pio_add_program(pio, &blink_program); + printf("Loaded program at %d\n", offset); + + blink_pin_forever(pio, 0, offset, 0, 3); + blink_pin_forever(pio, 1, offset, 6, 4); + blink_pin_forever(pio, 2, offset, 11, 1); +} + +void blink_pin_forever(PIO pio, uint sm, uint offset, uint pin, uint freq) { + blink_program_init(pio, sm, offset, pin); + pio_sm_set_enabled(pio, sm, true); + + printf("Blinking pin %d at freq %d\n", pin, freq); + pio->txf[sm] = 24000000 / freq; +} diff --git a/pio/pio_blink/blink.pio b/pio/pio_blink/blink.pio new file mode 100644 index 0000000..ef30900 --- /dev/null +++ b/pio/pio_blink/blink.pio @@ -0,0 +1,34 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +; SET pin 0 should be mapped to your LED GPIO + +.program blink + pull block + out y, 32 +.wrap_target + mov x, y + set pins, 1 ; Turn LED on +lp1: + jmp x-- lp1 ; Delay for (x + 1) cycles, x is a 32 bit number + mov x, y + set pins, 0 ; Turn LED off +lp2: + jmp x-- lp2 ; Delay for the same number of cycles again +.wrap ; Blink forever! + + +% c-sdk { +// this is a raw helper function for use by the user which sets up the GPIO output, and configures the SM to output on a particular pin + +void blink_program_init(PIO pio, uint sm, uint offset, uint pin) { + pio_gpio_init(pio, pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + pio_sm_config c = blink_program_get_default_config(offset); + sm_config_set_set_pins(&c, pin, 1); + pio_sm_init(pio, sm, offset, &c); +} +%} diff --git a/pio/pwm/CMakeLists.txt b/pio/pwm/CMakeLists.txt new file mode 100644 index 0000000..7c6f2fc --- /dev/null +++ b/pio/pwm/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_pwm) + +pico_generate_pio_header(pio_pwm ${CMAKE_CURRENT_LIST_DIR}/pwm.pio) + +target_sources(pio_pwm PRIVATE pwm.c) + +target_link_libraries(pio_pwm PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_pwm) + +# add url via pico_set_program_url +example_auto_set_url(pio_pwm) \ No newline at end of file diff --git a/pio/pwm/pwm.c b/pio/pwm/pwm.c new file mode 100644 index 0000000..0eef2e0 --- /dev/null +++ b/pio/pwm/pwm.c @@ -0,0 +1,46 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "pwm.pio.h" + +// Write `period` to the input shift register +void pio_pwm_set_period(PIO pio, uint sm, uint32_t period) { + pio_sm_set_enabled(pio, sm, false); + pio_sm_put_blocking(pio, sm, period); + pio_sm_exec(pio, sm, pio_encode_pull(false, false)); + pio_sm_exec(pio, sm, pio_encode_out(pio_isr, 32)); + pio_sm_set_enabled(pio, sm, true); +} + +// Write `level` to TX FIFO. State machine will copy this into X. +void pio_pwm_set_level(PIO pio, uint sm, uint32_t level) { + pio_sm_put_blocking(pio, sm, level); +} + +int main() { + stdio_init_all(); + + // todo get free sm + PIO pio = pio0; + int sm = 0; + uint offset = pio_add_program(pio, &pwm_program); + printf("Loaded program at %d\n", offset); + + pwm_program_init(pio, sm, offset, 25); + pio_pwm_set_period(pio, sm, (1u << 16) - 1); + + int level = 0; + while (true) { + printf("Level = %d\n", level); + pio_pwm_set_level(pio, sm, level * level); + level = (level + 1) % 256; + sleep_ms(10); + } +} diff --git a/pio/pwm/pwm.pio b/pio/pwm/pwm.pio new file mode 100644 index 0000000..d0f2bcb --- /dev/null +++ b/pio/pwm/pwm.pio @@ -0,0 +1,31 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +; Side-set pin 0 is used for PWM output + +.program pwm +.side_set 1 opt + + pull noblock side 0 ; Pull from FIFO to OSR if available, else copy X to OSR. + mov x, osr ; Copy most-recently-pulled value back to scratch X + mov y, isr ; ISR contains PWM period. Y used as counter. +countloop: + jmp x!=y noset ; Set pin high if X == Y, keep the two paths length matched + jmp skip side 1 +noset: + nop ; Single dummy cycle to keep the two paths the same length +skip: + jmp y-- countloop ; Loop until Y hits 0, then pull a fresh PWM value from FIFO + +% c-sdk { +static inline void pwm_program_init(PIO pio, uint sm, uint offset, uint pin) { + pio_gpio_init(pio, pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + pio_sm_config c = pwm_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, pin); + pio_sm_init(pio, sm, offset, &c); +} +%} diff --git a/pio/spi/CMakeLists.txt b/pio/spi/CMakeLists.txt new file mode 100644 index 0000000..44c561a --- /dev/null +++ b/pio/spi/CMakeLists.txt @@ -0,0 +1,29 @@ +add_executable(pio_spi_flash) + +pico_generate_pio_header(pio_spi_flash ${CMAKE_CURRENT_LIST_DIR}/spi.pio) + +target_sources(pio_spi_flash PRIVATE + spi_flash.c + pio_spi.c + pio_spi.h + ) + +target_link_libraries(pio_spi_flash PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_spi_flash) + +example_auto_set_url(pio_spi_flash) + +add_executable(pio_spi_loopback) + +pico_generate_pio_header(pio_spi_loopback ${CMAKE_CURRENT_LIST_DIR}/spi.pio) + +target_sources(pio_spi_loopback PRIVATE + spi_loopback.c + pio_spi.c + pio_spi.h + ) + +target_link_libraries(pio_spi_loopback PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_spi_loopback) + +example_auto_set_url(pio_spi_loopback) diff --git a/pio/spi/pio_spi.c b/pio/spi/pio_spi.c new file mode 100644 index 0000000..6306b7d --- /dev/null +++ b/pio/spi/pio_spi.c @@ -0,0 +1,68 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pio_spi.h" + +// Just 8 bit functions provided here. The PIO program supports any frame size +// 1...32, but the software to do the necessary FIFO shuffling is left as an +// exercise for the reader :) +// +// Likewise we only provide MSB-first here. To do LSB-first, you need to +// - Do shifts when reading from the FIFO, for general case n != 8, 16, 32 +// - Do a narrow read at a one halfword or 3 byte offset for n == 16, 8 +// in order to get the read data correctly justified. + +void __time_critical_func(pio_spi_write8_blocking)(const pio_spi_inst_t *spi, const uint8_t *src, size_t len) { + size_t tx_remain = len, rx_remain = len; + // Do 8 bit accesses on FIFO, so that write data is byte-replicated. This + // gets us the left-justification for free (for MSB-first shift-out) + io_rw_8 *txfifo = (io_rw_8 *) &spi->pio->txf[spi->sm]; + io_rw_8 *rxfifo = (io_rw_8 *) &spi->pio->rxf[spi->sm]; + while (tx_remain || rx_remain) { + if (tx_remain && !pio_sm_is_tx_fifo_full(spi->pio, spi->sm)) { + *txfifo = *src++; + --tx_remain; + } + if (rx_remain && !pio_sm_is_rx_fifo_empty(spi->pio, spi->sm)) { + (void) *rxfifo; + --rx_remain; + } + } +} + +void __time_critical_func(pio_spi_read8_blocking)(const pio_spi_inst_t *spi, uint8_t *dst, size_t len) { + size_t tx_remain = len, rx_remain = len; + io_rw_8 *txfifo = (io_rw_8 *) &spi->pio->txf[spi->sm]; + io_rw_8 *rxfifo = (io_rw_8 *) &spi->pio->rxf[spi->sm]; + while (tx_remain || rx_remain) { + if (tx_remain && !pio_sm_is_tx_fifo_full(spi->pio, spi->sm)) { + *txfifo = 0; + --tx_remain; + } + if (rx_remain && !pio_sm_is_rx_fifo_empty(spi->pio, spi->sm)) { + *dst++ = *rxfifo; + --rx_remain; + } + } +} + +void __time_critical_func(pio_spi_write8_read8_blocking)(const pio_spi_inst_t *spi, uint8_t *src, uint8_t *dst, + size_t len) { + size_t tx_remain = len, rx_remain = len; + io_rw_8 *txfifo = (io_rw_8 *) &spi->pio->txf[spi->sm]; + io_rw_8 *rxfifo = (io_rw_8 *) &spi->pio->rxf[spi->sm]; + while (tx_remain || rx_remain) { + if (tx_remain && !pio_sm_is_tx_fifo_full(spi->pio, spi->sm)) { + *txfifo = *src++; + --tx_remain; + } + if (rx_remain && !pio_sm_is_rx_fifo_empty(spi->pio, spi->sm)) { + *dst++ = *rxfifo; + --rx_remain; + } + } +} + diff --git a/pio/spi/pio_spi.h b/pio/spi/pio_spi.h new file mode 100644 index 0000000..dfa929d --- /dev/null +++ b/pio/spi/pio_spi.h @@ -0,0 +1,24 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef _PIO_SPI_H +#define _PIO_SPI_H + +#include "hardware/pio.h" +#include "spi.pio.h" + +typedef struct pio_spi_inst { + PIO pio; + uint sm; + uint cs_pin; +} pio_spi_inst_t; + +void pio_spi_write8_blocking(const pio_spi_inst_t *spi, const uint8_t *src, size_t len); + +void pio_spi_read8_blocking(const pio_spi_inst_t *spi, uint8_t *dst, size_t len); + +void pio_spi_write8_read8_blocking(const pio_spi_inst_t *spi, uint8_t *src, uint8_t *dst, size_t len); + +#endif diff --git a/pio/spi/spi.pio b/pio/spi/spi.pio new file mode 100644 index 0000000..eba785e --- /dev/null +++ b/pio/spi/spi.pio @@ -0,0 +1,168 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +; These programs implement full-duplex SPI, with a SCK period of 4 clock +; cycles. A different program is provided for each value of CPHA, and CPOL is +; achieved using the hardware GPIO inversion available in the IO controls. +; +; Transmit-only SPI can go twice as fast -- see the ST7789 example! + + +.program spi_cpha0 +.side_set 1 + +; Pin assignments: +; - SCK is side-set pin 0 +; - MOSI is OUT pin 0 +; - MISO is IN pin 0 +; +; Autopush and autopull must be enabled, and the serial frame size is set by +; configuring the push/pull threshold. Shift left/right is fine, but you must +; justify the data yourself. This is done most conveniently for frame sizes of +; 8 or 16 bits by using the narrow store replication and narrow load byte +; picking behaviour of RP2040's IO fabric. + +; Clock phase = 0: data is captured on the leading edge of each SCK pulse, and +; transitions on the trailing edge, or some time before the first leading edge. + + out pins, 1 side 0 [1] ; Stall here on empty (sideset proceeds even if + in pins, 1 side 1 [1] ; instruction stalls, so we stall with SCK low) + +.program spi_cpha1 +.side_set 1 + +; Clock phase = 1: data transitions on the leading edge of each SCK pulse, and +; is captured on the trailing edge. + + out x, 1 side 0 ; Stall here on empty (keep SCK deasserted) + mov pins, x side 1 [1] ; Output data, assert SCK (mov pins uses OUT mapping) + in pins, 1 side 0 ; Input data, deassert SCK + +% c-sdk { +#include "hardware/gpio.h" +static inline void pio_spi_init(PIO pio, uint sm, uint prog_offs, uint n_bits, + float clkdiv, bool cpha, bool cpol, uint pin_sck, uint pin_mosi, uint pin_miso) { + pio_sm_config c = cpha ? spi_cpha1_program_get_default_config(prog_offs) : spi_cpha0_program_get_default_config(prog_offs); + sm_config_set_out_pins(&c, pin_mosi, 1); + sm_config_set_in_pins(&c, pin_miso); + sm_config_set_sideset_pins(&c, pin_sck); + // Only support MSB-first in this example code (shift to left, auto push/pull, threshold=nbits) + sm_config_set_out_shift(&c, false, true, n_bits); + sm_config_set_in_shift(&c, false, true, n_bits); + sm_config_set_clkdiv(&c, clkdiv); + + // MOSI, SCK output are low, MISO is input + pio_sm_set_pins_with_mask(pio, sm, 0, (1u << pin_sck) | (1u << pin_mosi)); + pio_sm_set_pindirs_with_mask(pio, sm, (1u << pin_sck) | (1u << pin_mosi), (1u << pin_sck) | (1u << pin_mosi) | (1u << pin_miso)); + pio_gpio_init(pio, pin_mosi); + pio_gpio_init(pio, pin_miso); + pio_gpio_init(pio, pin_sck); + + // The pin muxes can be configured to invert the output (among other things + // and this is a cheesy way to get CPOL=1 + gpio_set_outover(pin_sck, cpol ? GPIO_OVERRIDE_INVERT : GPIO_OVERRIDE_NORMAL); + // SPI is synchronous, so bypass input synchroniser to reduce input delay. + hw_set_bits(&pio->input_sync_bypass, 1u << pin_miso); + + pio_sm_init(pio, sm, prog_offs, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} + +; SPI with Chip Select +; ----------------------------------------------------------------------------- +; +; For your amusement, here are some SPI programs with an automatic chip select +; (asserted once data appears in TX FIFO, deasserts when FIFO bottoms out, has +; a nice front/back porch). +; +; The number of bits per FIFO entry is configured via the Y register +; and the autopush/pull threshold. From 2 to 32 bits. +; +; Pin assignments: +; - SCK is side-set bit 0 +; - CSn is side-set bit 1 +; - MOSI is OUT bit 0 (host-to-device) +; - MISO is IN bit 0 (device-to-host) +; +; This program only supports one chip select -- use GPIO if more are needed +; +; Provide a variation for each possibility of CPHA; for CPOL we can just +; invert SCK in the IO muxing controls (downstream from PIO) + + +; CPHA=0: data is captured on the leading edge of each SCK pulse (including +; the first pulse), and transitions on the trailing edge + +.program spi_cpha0_cs +.side_set 2 + +.wrap_target +bitloop: + out pins, 1 side 0x0 [1] + in pins, 1 side 0x1 + jmp x-- bitloop side 0x1 + + out pins, 1 side 0x0 + mov x, y side 0x0 ; Reload bit counter from Y + in pins, 1 side 0x1 + jmp !osre bitloop side 0x1 ; Fall-through if TXF empties + + nop side 0x0 [1] ; CSn back porch +public entry_point: ; Must set X,Y to n-2 before starting! + pull ifempty side 0x2 [1] ; Block with CSn high (minimum 2 cycles) +.wrap ; Note ifempty to avoid time-of-check race + +; CPHA=1: data transitions on the leading edge of each SCK pulse, and is +; captured on the trailing edge + +.program spi_cpha1_cs +.side_set 2 + +.wrap_target +bitloop: + out pins, 1 side 0x1 [1] + in pins, 1 side 0x0 + jmp x-- bitloop side 0x0 + + out pins, 1 side 0x1 + mov x, y side 0x1 + in pins, 1 side 0x0 + jmp !osre bitloop side 0x0 + +public entry_point: ; Must set X,Y to n-2 before starting! + pull ifempty side 0x2 [1] ; Block with CSn high (minimum 2 cycles) + nop side 0x0 [1]; CSn front porch +.wrap + +% c-sdk { +#include "hardware/gpio.h" +static inline void pio_spi_cs_init(PIO pio, uint sm, uint prog_offs, uint n_bits, float clkdiv, bool cpha, bool cpol, + uint pin_sck, uint pin_mosi, uint pin_miso) { + pio_sm_config c = cpha ? spi_cpha1_cs_program_get_default_config(prog_offs) : spi_cpha0_cs_program_get_default_config(prog_offs); + sm_config_set_out_pins(&c, pin_mosi, 1); + sm_config_set_in_pins(&c, pin_miso); + sm_config_set_sideset_pins(&c, pin_sck); + sm_config_set_out_shift(&c, false, true, n_bits); + sm_config_set_in_shift(&c, false, true, n_bits); + sm_config_set_clkdiv(&c, clkdiv); + + pio_sm_set_pins_with_mask(pio, sm, (2u << pin_sck), (3u << pin_sck) | (1u << pin_mosi)); + pio_sm_set_pindirs_with_mask(pio, sm, (3u << pin_sck) | (1u << pin_mosi), (3u << pin_sck) | (1u << pin_mosi) | (1u << pin_miso)); + pio_gpio_init(pio, pin_mosi); + pio_gpio_init(pio, pin_miso); + pio_gpio_init(pio, pin_sck); + pio_gpio_init(pio, pin_sck + 1); + gpio_set_outover(pin_sck, cpol ? GPIO_OVERRIDE_INVERT : GPIO_OVERRIDE_NORMAL); + hw_set_bits(&pio->input_sync_bypass, 1u << pin_miso); + + uint entry_point = prog_offs + (cpha ? spi_cpha1_cs_offset_entry_point : spi_cpha0_cs_offset_entry_point); + pio_sm_init(pio, sm, entry_point, &c); + pio_sm_exec(pio, sm, pio_encode_set(pio_x, n_bits - 2)); + pio_sm_exec(pio, sm, pio_encode_set(pio_y, n_bits - 2)); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/pio/spi/spi_flash.c b/pio/spi/spi_flash.c new file mode 100644 index 0000000..bc9192e --- /dev/null +++ b/pio/spi/spi_flash.c @@ -0,0 +1,155 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "pio_spi.h" + +// This example uses PIO to erase, program and read back a SPI serial flash +// memory. + +#define PIN_MISO 16 +#define PIN_MOSI 17 +#define PIN_SCK 18 +#define PIN_CS 19 + +// ---------------------------------------------------------------------------- +// Generic serial flash code + +#define FLASH_PAGE_SIZE 256 +#define FLASH_SECTOR_SIZE 4096 + +#define FLASH_CMD_PAGE_PROGRAM 0x02 +#define FLASH_CMD_READ 0x03 +#define FLASH_CMD_STATUS 0x05 +#define FLASH_CMD_WRITE_EN 0x06 +#define FLASH_CMD_SECTOR_ERASE 0x20 + +#define FLASH_STATUS_BUSY_MASK 0x01 + +void flash_read(const pio_spi_inst_t *spi, uint32_t addr, uint8_t *buf, size_t len) { + uint8_t cmd[4] = { + FLASH_CMD_READ, + addr >> 16, + addr >> 8, + addr + }; + gpio_put(spi->cs_pin, 0); + pio_spi_write8_blocking(spi, cmd, 4); + pio_spi_read8_blocking(spi, buf, len); + gpio_put(spi->cs_pin, 1); +} + + +void flash_write_enable(const pio_spi_inst_t *spi) { + uint8_t cmd = FLASH_CMD_WRITE_EN; + gpio_put(spi->cs_pin, 0); + pio_spi_write8_blocking(spi, &cmd, 1); + gpio_put(spi->cs_pin, 1); +} + +void flash_wait_done(const pio_spi_inst_t *spi) { + uint8_t status; + do { + gpio_put(spi->cs_pin, 0); + uint8_t cmd = FLASH_CMD_STATUS; + pio_spi_write8_blocking(spi, &cmd, 1); + pio_spi_read8_blocking(spi, &status, 1); + gpio_put(spi->cs_pin, 1); + } while (status & FLASH_STATUS_BUSY_MASK); +} + +void flash_sector_erase(const pio_spi_inst_t *spi, uint32_t addr) { + uint8_t cmd[4] = { + FLASH_CMD_SECTOR_ERASE, + addr >> 16, + addr >> 8, + addr + }; + flash_write_enable(spi); + gpio_put(spi->cs_pin, 0); + pio_spi_write8_blocking(spi, cmd, 4); + gpio_put(spi->cs_pin, 1); + flash_wait_done(spi); +} + +void flash_page_program(const pio_spi_inst_t *spi, uint32_t addr, uint8_t data[]) { + flash_write_enable(spi); + uint8_t cmd[4] = { + FLASH_CMD_PAGE_PROGRAM, + addr >> 16, + addr >> 8, + addr + }; + gpio_put(spi->cs_pin, 0); + pio_spi_write8_blocking(spi, cmd, 4); + pio_spi_write8_blocking(spi, data, FLASH_PAGE_SIZE); + gpio_put(spi->cs_pin, 1); + flash_wait_done(spi); +} + +// ---------------------------------------------------------------------------- +// Example program + +void printbuf(const uint8_t buf[FLASH_PAGE_SIZE]) { + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) + printf("%02x%c", buf[i], i % 16 == 15 ? '\n' : ' '); +} + +int main() { + stdio_init_all(); + puts("PIO SPI Example"); + + pio_spi_inst_t spi = { + .pio = pio0, + .sm = 0, + .cs_pin = PIN_CS + }; + + gpio_init(PIN_CS); + gpio_put(PIN_CS, 1); + gpio_set_dir(PIN_CS, GPIO_OUT); + + uint offset = pio_add_program(spi.pio, &spi_cpha0_program); + printf("Loaded program at %d\n", offset); + + pio_spi_init(spi.pio, spi.sm, offset, + 8, // 8 bits per SPI frame + 31.25f, // 1 MHz @ 125 clk_sys + false, // CPHA = 0 + false, // CPOL = 0 + PIN_SCK, + PIN_MOSI, + PIN_MISO + ); + + uint8_t page_buf[FLASH_PAGE_SIZE]; + + const uint32_t target_addr = 0; + + flash_sector_erase(&spi, target_addr); + flash_read(&spi, target_addr, page_buf, FLASH_PAGE_SIZE); + + puts("After erase:"); + printbuf(page_buf); + + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) + page_buf[i] = i; + flash_page_program(&spi, target_addr, page_buf); + flash_read(&spi, target_addr, page_buf, FLASH_PAGE_SIZE); + + puts("After program:"); + printbuf(page_buf); + + flash_sector_erase(&spi, target_addr); + flash_read(&spi, target_addr, page_buf, FLASH_PAGE_SIZE); + + puts("Erase again:"); + printbuf(page_buf); + + return 0; +} diff --git a/pio/spi/spi_loopback.c b/pio/spi/spi_loopback.c new file mode 100644 index 0000000..ac5897f --- /dev/null +++ b/pio/spi/spi_loopback.c @@ -0,0 +1,77 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "pio_spi.h" + +// This program instantiates a PIO SPI with each of the four possible +// CPOL/CPHA combinations, with the serial input and output pin mapped to the +// same GPIO. Any data written into the state machine's TX FIFO should then be +// serialised, deserialised, and reappear in the state machine's RX FIFO. + +#define PIN_SCK 18 +#define PIN_MOSI 16 +#define PIN_MISO 16 // same as MOSI, so we get loopback + +#define BUF_SIZE 20 + +void test(const pio_spi_inst_t *spi) { + static uint8_t txbuf[BUF_SIZE]; + static uint8_t rxbuf[BUF_SIZE]; + printf("TX:"); + for (int i = 0; i < BUF_SIZE; ++i) { + txbuf[i] = rand() >> 16; + rxbuf[i] = 0; + printf(" %02x", (int) txbuf[i]); + } + printf("\n"); + + pio_spi_write8_read8_blocking(spi, txbuf, rxbuf, BUF_SIZE); + + printf("RX:"); + bool mismatch = false; + for (int i = 0; i < BUF_SIZE; ++i) { + printf(" %02x", (int) rxbuf[i]); + mismatch = mismatch || rxbuf[i] != txbuf[i]; + } + if (mismatch) + printf("\nNope\n"); + else + printf("\nOK\n"); +} + +int main() { + stdio_init_all(); + + pio_spi_inst_t spi = { + .pio = pio0, + .sm = 0 + }; + float clkdiv = 31.25f; // 1 MHz @ 125 clk_sys + uint cpha0_prog_offs = pio_add_program(spi.pio, &spi_cpha0_program); + uint cpha1_prog_offs = pio_add_program(spi.pio, &spi_cpha1_program); + + for (int cpha = 0; cpha <= 1; ++cpha) { + for (int cpol = 0; cpol <= 1; ++cpol) { + printf("CPHA = %d, CPOL = %d\n", cpha, cpol); + pio_spi_init(spi.pio, spi.sm, + cpha ? cpha1_prog_offs : cpha0_prog_offs, + 8, // 8 bits per SPI frame + clkdiv, + cpha, + cpol, + PIN_SCK, + PIN_MOSI, + PIN_MISO + ); + test(&spi); + sleep_ms(10); + } + } +} diff --git a/pio/squarewave/CMakeLists.txt b/pio/squarewave/CMakeLists.txt new file mode 100644 index 0000000..ac86771 --- /dev/null +++ b/pio/squarewave/CMakeLists.txt @@ -0,0 +1,35 @@ +add_executable(pio_squarewave) + +pico_generate_pio_header(pio_squarewave ${CMAKE_CURRENT_LIST_DIR}/squarewave.pio) +pico_generate_pio_header(pio_squarewave ${CMAKE_CURRENT_LIST_DIR}/squarewave_wrap.pio) +pico_generate_pio_header(pio_squarewave ${CMAKE_CURRENT_LIST_DIR}/squarewave_fast.pio) + +target_sources(pio_squarewave PRIVATE squarewave.c) + +target_link_libraries(pio_squarewave PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_squarewave) + +# add url via pico_set_program_url +example_auto_set_url(pio_squarewave) + +# generate .hex file and .pio.h file for the RP2040 datasheet (to make sure +# the datasheet always shows the output of the latest pioasm version) +add_custom_target(pio_squarewave_datasheet DEPENDS + Pioasm + ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.hex + ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.pio.h + ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave_wrap.pio.h + ) +add_custom_command(OUTPUT ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.hex + DEPENDS ${CMAKE_CURRENT_LIST_DIR}/squarewave.pio + COMMAND Pioasm -o hex ${CMAKE_CURRENT_LIST_DIR}/squarewave.pio ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.hex + ) +add_custom_command(OUTPUT ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.pio.h + DEPENDS ${CMAKE_CURRENT_LIST_DIR}/squarewave.pio + COMMAND Pioasm ${CMAKE_CURRENT_LIST_DIR}/squarewave.pio ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave.pio.h + ) +add_custom_command(OUTPUT ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave_wrap.pio.h + DEPENDS ${CMAKE_CURRENT_LIST_DIR}/squarewave_wrap.pio + COMMAND Pioasm ${CMAKE_CURRENT_LIST_DIR}/squarewave_wrap.pio ${CMAKE_CURRENT_LIST_DIR}/generated/squarewave_wrap.pio.h + ) +add_dependencies(pio_squarewave pio_squarewave_datasheet) diff --git a/pio/squarewave/generated/squarewave.hex b/pio/squarewave/generated/squarewave.hex new file mode 100644 index 0000000..2449e29 --- /dev/null +++ b/pio/squarewave/generated/squarewave.hex @@ -0,0 +1,4 @@ +e081 +e101 +e000 +0001 diff --git a/pio/squarewave/generated/squarewave.pio.h b/pio/squarewave/generated/squarewave.pio.h new file mode 100644 index 0000000..627cb52 --- /dev/null +++ b/pio/squarewave/generated/squarewave.pio.h @@ -0,0 +1,38 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#if !PICO_NO_HARDWARE +#include "hardware/pio.h" +#endif + +// ---------- // +// squarewave // +// ---------- // + +#define squarewave_wrap_target 0 +#define squarewave_wrap 3 + +static const uint16_t squarewave_program_instructions[] = { + // .wrap_target + 0xe081, // 0: set pindirs, 1 + 0xe101, // 1: set pins, 1 [1] + 0xe000, // 2: set pins, 0 + 0x0001, // 3: jmp 1 + // .wrap +}; + +#if !PICO_NO_HARDWARE +static const struct pio_program squarewave_program = { + .instructions = squarewave_program_instructions, + .length = 4, + .origin = -1, +}; + +static inline pio_sm_config squarewave_program_get_default_config(uint offset) { + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_wrap(&c, offset + squarewave_wrap_target, offset + squarewave_wrap); + return c; +} +#endif + diff --git a/pio/squarewave/generated/squarewave_wrap.pio.h b/pio/squarewave/generated/squarewave_wrap.pio.h new file mode 100644 index 0000000..c1708ec --- /dev/null +++ b/pio/squarewave/generated/squarewave_wrap.pio.h @@ -0,0 +1,37 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#if !PICO_NO_HARDWARE +#include "hardware/pio.h" +#endif + +// --------------- // +// squarewave_wrap // +// --------------- // + +#define squarewave_wrap_wrap_target 1 +#define squarewave_wrap_wrap 2 + +static const uint16_t squarewave_wrap_program_instructions[] = { + 0xe081, // 0: set pindirs, 1 + // .wrap_target + 0xe101, // 1: set pins, 1 [1] + 0xe100, // 2: set pins, 0 [1] + // .wrap +}; + +#if !PICO_NO_HARDWARE +static const struct pio_program squarewave_wrap_program = { + .instructions = squarewave_wrap_program_instructions, + .length = 3, + .origin = -1, +}; + +static inline pio_sm_config squarewave_wrap_program_get_default_config(uint offset) { + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_wrap(&c, offset + squarewave_wrap_wrap_target, offset + squarewave_wrap_wrap); + return c; +} +#endif + diff --git a/pio/squarewave/squarewave.c b/pio/squarewave/squarewave.c new file mode 100644 index 0000000..40a7809 --- /dev/null +++ b/pio/squarewave/squarewave.c @@ -0,0 +1,72 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Output a 12.5 MHz square wave (if system clock frequency is 125 MHz). +// +// Note this program is accessing the PIO registers directly, for illustrative +// purposes. We pull this program into the datasheet so we can talk a little +// about PIO's hardware register interface. The `hardware_pio` SDK library +// provides simpler or better interfaces for all of these operations. +// +// _*This is not best practice! I don't want to see you copy/pasting this*_ +// +// For a minimal example of loading and running a program using the SDK +// functions (which is what you generally want to do) have a look at +// `hello_pio` instead. That example is also the subject of a tutorial in the +// SDK book, which walks you through building your first PIO program. + +#include "pico/stdlib.h" +#include "hardware/pio.h" + +// Our assembled program: +#include "squarewave.pio.h" + +int main() { + // Pick one PIO instance arbitrarily. We're also arbitrarily picking state + // machine 0 on this PIO instance (the state machines are numbered 0 to 3 + // inclusive). + PIO pio = pio0; + + /// \tag::load_program[] + // Load the assembled program directly into the PIO's instruction memory. + // Each PIO instance has a 32-slot instruction memory, which all 4 state + // machines can see. The system has write-only access. + for (int i = 0; i < count_of(squarewave_program_instructions); ++i) + pio->instr_mem[i] = squarewave_program_instructions[i]; + /// \end::load_program[] + + /// \tag::clock_divider[] + // Configure state machine 0 to run at sysclk/2.5. The state machines can + // run as fast as one instruction per clock cycle, but we can scale their + // speed down uniformly to meet some precise frequency target, e.g. for a + // UART baud rate. This register has 16 integer divisor bits and 8 + // fractional divisor bits. + pio->sm[0].clkdiv = (uint32_t) (2.5f * (1 << 16)); + /// \end::clock_divider[] + + /// \tag::setup_pins[] + // There are five pin mapping groups (out, in, set, side-set, jmp pin) + // which are used by different instructions or in different circumstances. + // Here we're just using SET instructions. Configure state machine 0 SETs + // to affect GPIO 0 only; then configure GPIO0 to be controlled by PIO0, + // as opposed to e.g. the processors. + pio->sm[0].pinctrl = + (1 << PIO_SM0_PINCTRL_SET_COUNT_LSB) | + (0 << PIO_SM0_PINCTRL_SET_BASE_LSB); + gpio_set_function(0, GPIO_FUNC_PIO0); + /// \end::setup_pins[] + + /// \tag::start_sm[] + // Set the state machine running. The PIO CTRL register is global within a + // PIO instance, so you can start/stop multiple state machines + // simultaneously. We're using the register's hardware atomic set alias to + // make one bit high without doing a read-modify-write on the register. + hw_set_bits(&pio->ctrl, 1 << (PIO_CTRL_SM_ENABLE_LSB + 0)); + /// \end::start_sm[] + + return 0; + +} diff --git a/pio/squarewave/squarewave.pio b/pio/squarewave/squarewave.pio new file mode 100644 index 0000000..405c899 --- /dev/null +++ b/pio/squarewave/squarewave.pio @@ -0,0 +1,13 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program squarewave + set pindirs, 1 ; Set pin to output +again: + set pins, 1 [1] ; Drive pin high and then delay for one cycle + set pins, 0 ; Drive pin low + jmp again ; Set PC to label `again` + diff --git a/pio/squarewave/squarewave_fast.pio b/pio/squarewave/squarewave_fast.pio new file mode 100644 index 0000000..26162fa --- /dev/null +++ b/pio/squarewave/squarewave_fast.pio @@ -0,0 +1,19 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +; Note that if you modify squarewave.c to include this program, you'll also +; need to set the wrap registers yourself. This would be handled for you by +; squarewave_program_get_default_config(). + + +.program squarewave_fast +; Like squarewave_wrap, but remove the delay cycles so we can run twice as fast. + set pindirs, 1 ; Set pin to output +.wrap_target + set pins, 1 ; Drive pin high + set pins, 0 ; Drive pin low +.wrap + diff --git a/pio/squarewave/squarewave_wrap.pio b/pio/squarewave/squarewave_wrap.pio new file mode 100644 index 0000000..100f09c --- /dev/null +++ b/pio/squarewave/squarewave_wrap.pio @@ -0,0 +1,19 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +; Note that if you modify squarewave.c to include this program, you'll also +; need to set the wrap registers yourself. This would be handled for you by +; squarewave_program_get_default_config(). + +.program squarewave_wrap +; Like squarewave, but use the state machine's .wrap hardware instead of an +; explicit jmp. This is a free (0-cycle) unconditional jump. + + set pindirs, 1 ; Set pin to output +.wrap_target + set pins, 1 [1] ; Drive pin high and then delay for one cycle + set pins, 0 [1] ; Drive pin low and then delay for one cycle +.wrap diff --git a/pio/st7789_lcd/CMakeLists.txt b/pio/st7789_lcd/CMakeLists.txt new file mode 100644 index 0000000..a6243e6 --- /dev/null +++ b/pio/st7789_lcd/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_st7789_lcd) + +pico_generate_pio_header(pio_st7789_lcd ${CMAKE_CURRENT_LIST_DIR}/st7789_lcd.pio) + +target_sources(pio_st7789_lcd PRIVATE st7789_lcd.c) + +target_link_libraries(pio_st7789_lcd PRIVATE pico_stdlib hardware_pio hardware_interp) +pico_add_extra_outputs(pio_st7789_lcd) + +# add url via pico_set_program_url +example_auto_set_url(pio_st7789_lcd) diff --git a/pio/st7789_lcd/raspberry_256x256.png b/pio/st7789_lcd/raspberry_256x256.png new file mode 100644 index 0000000..1f12d14 Binary files /dev/null and b/pio/st7789_lcd/raspberry_256x256.png differ diff --git a/pio/st7789_lcd/raspberry_256x256_rgb565.h b/pio/st7789_lcd/raspberry_256x256_rgb565.h new file mode 100644 index 0000000..15493b5 --- /dev/null +++ b/pio/st7789_lcd/raspberry_256x256_rgb565.h @@ -0,0 +1,8195 @@ +static char __attribute__((aligned(4))) raspberry_256x256[] = { + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0xbe, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbe, 0xf7, 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5a, 0xb6, 0xb5, 0xbf, 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, 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, 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, 0x7d, 0xef, 0x35, 0xad, 0x8a, 0x52, 0x8a, 0x52, 0x31, 0x8c, 0x9e, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, + 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, + 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, + 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, + 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, + 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, 0x9e, 0xf7, 0xcb, 0x5a, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0xbd, 0x9e, 0xf7, 0x72, 0x94, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x83, + 0xbe, 0xf7, 0xff, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 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, 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, 0xff, 0xff, + 0x9e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xff, 0xff, 0xbe, 0xf7, 0x18, 0xc6, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xab, 0x52, + 0xbe, 0xf7, 0x9a, 0xd6, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc3, 0x18, 0x7d, 0xef, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0x39, 0xce, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xe8, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xbf, 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, 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, 0xbf, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x51, 0x8c, 0xdf, 0xff, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbf, 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, 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, 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, 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, 0x9e, 0xf7, 0xa6, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x29, 0x4a, 0xbe, 0xf7, 0xdf, 0xff, 0x3c, 0xe7, 0x1c, 0xe7, 0xfb, 0xde, 0xdf, 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, 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, 0xdf, 0xff, + 0x9e, 0xf7, 0x1c, 0xe7, 0x3c, 0xe7, 0xdf, 0xff, 0xbe, 0xf7, 0xe7, 0x39, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 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, 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, 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, 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, 0x3c, 0xe7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xef, 0x04, 0x21, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x76, 0xb5, 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, 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, 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, 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, 0x96, 0xb5, 0xe7, 0x39, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xb2, 0x94, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, + 0xe7, 0x39, 0x96, 0xb5, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xc2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xae, 0x73, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xe2, 0x18, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x65, 0x29, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xa1, 0x08, 0x6a, 0x76, 0x86, 0x43, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x6e, 0x66, 0x43, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8e, 0x73, 0xff, 0xff, 0xff, 0xff, 0xbe, 0xf7, + 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, 0x9e, 0xf7, + 0xff, 0xff, 0xff, 0xff, 0x10, 0x84, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x05, 0x3b, 0xc9, 0x6d, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x64, 0x2a, 0x6a, 0x76, 0x40, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x59, 0xce, 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, 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, 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, 0x7e, 0xf7, 0xfc, 0xe6, + 0x3d, 0xef, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x01, 0x11, 0x4a, 0x76, 0x4a, 0x76, 0x6a, 0x76, 0x69, 0x65, 0x02, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0x01, 0x00, 0x6a, 0x76, 0x8b, 0x7e, 0x03, 0x2a, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x01, 0x00, 0x25, 0x3b, 0x04, 0x2a, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, + 0x66, 0x31, 0x3c, 0xe7, 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, 0x1c, 0xe7, 0x66, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xe3, 0x21, 0x84, 0x32, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x24, 0x2a, 0xaa, 0x7e, 0x6a, 0x7e, 0x01, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x42, 0x10, 0xa7, 0x54, 0x6a, 0x7e, 0x4a, 0x76, 0xab, 0x7e, 0x80, 0x08, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x1c, 0xe7, 0xbe, 0xf7, + 0x9e, 0xf7, 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, 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, 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, 0xfb, 0xde, 0xeb, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x81, 0x10, 0x09, 0x6e, 0xa9, 0x6d, 0xc6, 0x43, 0x01, 0x08, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x76, 0x0a, 0x6e, 0x09, 0x6e, 0x4a, 0x76, + 0x8a, 0x76, 0x24, 0x2a, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x28, 0x65, 0xe9, 0x6d, 0x4a, 0x76, + 0x09, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x81, 0x08, 0x0b, 0x7f, 0xa9, 0x65, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x41, 0x10, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x84, 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, 0x92, 0x94, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x88, 0x65, 0xeb, 0x7e, 0xa0, 0x08, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x6a, 0x76, + 0x29, 0x6e, 0xe9, 0x6d, 0x48, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x2a, 0x6a, 0x76, + 0x29, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0xaa, 0x7e, 0x40, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xc6, 0x43, 0x48, 0x5d, 0x0a, 0x76, 0x81, 0x08, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0x5a, 0xd7, 0xbd, 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, 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, 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, 0xaf, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x2a, 0x76, 0x2a, 0x76, 0x2a, 0x76, 0x6a, 0x76, 0x29, 0x6e, + 0x07, 0x4c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x54, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x4a, 0x76, 0x4a, 0x76, 0xc2, 0x10, 0x00, 0x00, 0x09, 0x6e, 0x0a, 0x6e, 0x09, 0x6e, + 0x0a, 0x76, 0x6a, 0x76, 0x24, 0x2a, 0x20, 0x00, 0x21, 0x08, 0xa0, 0x08, 0xcb, 0x7e, 0x09, 0x6e, + 0x6a, 0x7e, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x01, 0x00, 0xe8, 0x5c, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x39, 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, 0x69, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x48, 0x65, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x76, + 0x2a, 0x76, 0x8a, 0x76, 0x41, 0x08, 0x00, 0x00, 0x20, 0x00, 0x23, 0x2a, 0x6a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x89, 0x6d, 0x00, 0x00, 0x03, 0x19, 0x4a, 0x76, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x87, 0x54, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0xa7, 0x54, + 0xea, 0x6d, 0x6a, 0x76, 0x4a, 0x76, 0x09, 0x6e, 0x6a, 0x7e, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x41, 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, 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, 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, + 0xd3, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x21, 0x10, 0x01, 0x00, + 0xc4, 0x32, 0xc6, 0x43, 0xe6, 0x43, 0x06, 0x4c, 0x03, 0x22, 0xe2, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x2a, 0x8a, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0x09, 0x6e, 0x4a, 0x76, 0x6a, 0x76, 0x06, 0x4c, 0x29, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, 0x29, 0x6e, 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x6a, 0x76, 0x27, 0x4c, 0x00, 0x00, 0x67, 0x54, 0xe9, 0x6d, 0x0a, 0x6e, + 0x09, 0x6e, 0xaa, 0x7e, 0x62, 0x10, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x76, 0x89, 0x65, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 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, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe9, 0x6d, 0x6a, 0x76, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x62, 0x10, 0x4a, 0x76, 0x0a, 0x6e, + 0xe9, 0x6d, 0x2a, 0x76, 0xa4, 0x32, 0x00, 0x00, 0x26, 0x4c, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x49, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe6, 0x43, 0x4a, 0x76, 0x29, 0x76, 0x2a, 0x76, + 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0x23, 0x22, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa1, 0x10, 0x44, 0x2a, 0xe4, 0x32, 0xc6, 0x43, 0xc6, 0x43, 0xe5, 0x32, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5a, 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, 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, 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, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x09, 0x6e, + 0x6a, 0x76, 0x2a, 0x76, 0x4a, 0x76, 0x2a, 0x76, 0x4a, 0x76, 0x4a, 0x76, 0x4a, 0x76, 0x29, 0x76, + 0x28, 0x65, 0xc3, 0x21, 0x00, 0x00, 0xe2, 0x21, 0x8a, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x2a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, 0x69, 0x65, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xe9, 0x6d, 0xab, 0x7e, 0xe2, 0x10, 0x21, 0x08, 0x00, 0x00, 0x4a, 0x76, 0x09, 0x6e, + 0x89, 0x6d, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xbf, 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, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0x6d, + 0x2a, 0x76, 0x29, 0x6e, 0x00, 0x00, 0x20, 0x00, 0x02, 0x19, 0xaa, 0x7e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0x48, 0x65, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xcb, 0x7e, 0x61, 0x08, 0x00, 0x00, 0xe3, 0x21, 0xe8, 0x5c, + 0xe9, 0x6d, 0x4a, 0x76, 0x6a, 0x76, 0x2a, 0x76, 0x4a, 0x76, 0x29, 0x76, 0x4a, 0x76, 0x4a, 0x76, + 0x89, 0x6d, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x39, 0xce, + 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, + 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, + 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, 0x96, 0xb5, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x65, 0x2a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x09, 0x6e, 0x6a, 0x76, 0x29, 0x6e, 0x4a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x8a, 0x7e, 0x00, 0x00, 0x87, 0x54, 0x29, 0x6e, 0x09, 0x6e, + 0x29, 0x6e, 0x89, 0x65, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc9, 0x65, 0x2a, 0x76, + 0xe9, 0x6d, 0x4a, 0x76, 0xa5, 0x43, 0xe1, 0x08, 0x8a, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0x2a, 0x76, 0x49, 0x76, 0x2a, 0x76, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0xc9, 0x6d, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x51, 0x8c, + 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, + 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, + 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, 0x14, 0xa5, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xa9, 0x6d, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x4a, 0x76, 0x2a, 0x76, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x2a, 0x76, 0x49, 0x65, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x23, 0x2a, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 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, 0x24, 0x21, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x40, 0x00, + 0x44, 0x2a, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x28, 0x65, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xe9, 0x6d, 0x4a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x89, 0x65, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x2c, 0x63, + 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, + 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, + 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, 0x34, 0xad, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x4c, 0xa9, 0x6d, + 0xa8, 0x65, 0xc9, 0x6d, 0xe9, 0x6d, 0x0a, 0x76, 0xa9, 0x65, 0xc9, 0x6d, 0xe9, 0x6d, 0xe9, 0x6d, + 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x29, 0x6e, 0xe8, 0x5c, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xeb, 0x7e, + 0x84, 0x32, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, + 0xcb, 0x5a, 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, 0xae, 0x73, 0x21, 0x08, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x64, 0x32, + 0xaa, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x54, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xc9, 0x6d, 0xe9, 0x6d, + 0xe9, 0x6d, 0x0a, 0x6e, 0xa9, 0x65, 0xc9, 0x6d, 0xa9, 0x65, 0x68, 0x65, 0x88, 0x65, 0x89, 0x65, + 0x68, 0x65, 0xc6, 0x43, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xaf, 0x7b, + 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, + 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, + 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, 0x39, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0x00, 0x00, 0x6a, 0x76, + 0xea, 0x6d, 0xe9, 0x6d, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x76, 0xe9, 0x6d, + 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, 0xe6, 0x4b, 0x00, 0x00, 0xa4, 0x32, 0x8a, 0x76, + 0x8a, 0x7e, 0x42, 0x11, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x41, 0x08, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x63, 0x21, 0xaa, 0x7e, + 0xcb, 0x7e, 0x82, 0x19, 0x00, 0x00, 0x67, 0x54, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, + 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, + 0x4a, 0x76, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xf3, 0x9c, + 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, + 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, + 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x64, 0x2a, + 0x6a, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x6a, 0x76, 0x45, 0x3b, 0x48, 0x5d, 0xe9, 0x6d, + 0xe9, 0x6d, 0xcb, 0x7e, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x76, 0x09, 0x6e, + 0xe9, 0x6d, 0x28, 0x65, 0x04, 0x33, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0xaa, 0x7e, + 0x23, 0x2a, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xbb, 0xd6, + 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, + 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, + 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, + 0xf4, 0xa4, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x08, 0x5d, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x25, 0x29, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x63, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x67, 0x54, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xeb, 0x5a, 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, 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, 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, + 0xb2, 0x94, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x41, 0x11, 0xcb, 0x7e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0xc8, 0x5c, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xde, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x65, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xaa, 0x7e, 0xa1, 0x08, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x52, 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, 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, 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, 0x3d, 0xef, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xa7, 0x54, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x6a, 0x76, 0x64, 0x32, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x44, 0x2a, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0xa8, 0x5c, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x14, 0xa5, + 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, + 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, + 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, 0x2d, 0x6b, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xc2, 0x21, 0x49, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xaa, 0x7e, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x39, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xcb, 0x7e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0xcb, 0x7e, 0x41, 0x11, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 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, + 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, + 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, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x28, 0x65, 0x01, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x49, 0x65, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xd7, 0xbd, 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, 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, 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, 0x1c, 0xe7, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x81, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x45, 0x3b, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0xe9, 0x6d, 0x65, 0x3b, 0x89, 0x65, 0x6a, 0x76, 0x2a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0xa2, 0x21, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x7a, 0xd6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7a, 0xd6, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xa3, 0x21, 0x29, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0x8a, 0x7e, 0x68, 0x65, 0x47, 0x4c, 0x09, 0x6e, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0xc4, 0x32, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf4, 0x9c, 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, 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, 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, 0x5d, 0xef, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x61, 0x08, 0x4c, 0x87, 0x2a, 0x76, + 0xa9, 0x6d, 0x89, 0x65, 0xab, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xe9, 0x6d, 0x8b, 0x7e, 0x68, 0x65, 0x63, 0x21, 0x25, 0x3b, 0x4a, 0x76, 0x6a, 0x76, + 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x6a, 0x76, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x8a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x6a, 0x76, 0x4a, 0x76, 0x25, 0x3b, 0xe2, 0x18, 0xa9, 0x6d, 0x29, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x6a, 0x76, 0x08, 0x65, 0x89, 0x65, + 0x89, 0x6d, 0x0b, 0x87, 0x81, 0x10, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x35, 0xad, 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, 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, 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, 0xc3, 0x18, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x43, 0x2a, 0x76, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x4a, 0x76, 0xe9, 0x6d, 0x80, 0x00, 0x00, 0x00, + 0xc6, 0x43, 0x6a, 0x76, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x49, 0x76, 0x24, 0x2a, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdb, 0xde, 0xff, 0xff, + 0xfc, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa4, 0x32, 0x2a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x09, 0x6e, 0x2a, 0x76, 0xaa, 0x76, 0xc6, 0x43, + 0x00, 0x00, 0x02, 0x19, 0xc9, 0x65, 0x4a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x4a, 0x76, 0x86, 0x43, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x5d, 0xef, 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, 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, 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, 0x14, 0xa5, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x68, 0x65, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x6a, 0x7e, 0x28, 0x5d, + 0x21, 0x08, 0x00, 0x00, 0xe3, 0x21, 0xe9, 0x6d, 0xcb, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x29, 0x6e, + 0x01, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xf0, 0x83, 0xff, 0xff, + 0x76, 0xb5, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x8a, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xaa, 0x7e, 0x69, 0x65, 0xc3, 0x21, 0x00, 0x00, 0x21, 0x10, + 0xea, 0x6d, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, + 0xe8, 0x5c, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x4d, 0x6b, + 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, + 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, + 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe9, 0x6d, 0xe9, 0x6d, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0x8a, 0x76, 0x87, 0x54, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa6, 0x43, 0x8a, 0x76, 0x4a, 0x76, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x8a, 0x7e, + 0xc2, 0x21, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x64, 0x2a, + 0x29, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0x49, 0x6e, 0x4a, 0x76, 0x85, 0x43, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc9, 0x6d, 0x6a, 0x76, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0xe9, 0x6d, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xbb, 0xde, + 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, + 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, + 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, + 0xbb, 0xde, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xe9, 0x6d, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0xcb, 0x7e, 0xa6, 0x43, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x03, 0x22, + 0x0a, 0x76, 0x8a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, + 0xe8, 0x5c, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x75, 0xad, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x89, 0x65, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0xab, 0x7e, 0xc9, 0x6d, + 0xe3, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa8, 0x54, 0xaa, 0x7e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x49, 0x65, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x76, 0xb5, 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, 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, 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, + 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xe6, 0x43, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x8a, 0x76, 0xa6, 0x43, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x22, 0x19, 0x46, 0x4c, 0xcb, 0x7e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x8a, 0x76, 0x21, 0x11, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x41, 0x08, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x01, 0x09, 0x0b, 0x87, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xea, 0x7e, 0x08, 0x5d, 0x01, 0x09, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xe4, 0x32, 0xaa, 0x7e, 0x09, 0x6e, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x6a, 0x76, 0x06, 0x4c, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79, 0xce, 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, 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, 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, + 0x59, 0xce, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x45, 0x3b, 0x8b, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x8a, 0x7e, 0x23, 0x19, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe1, 0x08, 0xa6, 0x43, 0x8a, 0x7e, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x4a, 0x76, 0x05, 0x33, 0x01, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x45, 0x3b, 0xe9, 0x6d, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x29, 0x6e, 0xab, 0x7e, 0x65, 0x3b, 0x22, 0x11, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x05, 0x3b, 0x4a, 0x76, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x6a, 0x76, 0xe5, 0x3a, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x92, 0x94, 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, 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, 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, + 0x55, 0xad, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x3b, 0x2a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, + 0x49, 0x6e, 0x21, 0x10, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x40, 0x00, 0x85, 0x43, 0x4a, 0x76, + 0x49, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0xe8, 0x5c, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x65, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x2a, 0x76, + 0x8a, 0x76, 0x86, 0x43, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0x2a, 0x76, + 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x25, 0x3b, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x08, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x6d, 0x6b, 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, 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, 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, + 0xf8, 0xc5, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x01, 0x00, 0x64, 0x2a, + 0x4a, 0x76, 0xc6, 0x43, 0x25, 0x3b, 0xe8, 0x5c, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x4a, 0x76, 0xe8, 0x5c, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x65, 0x43, 0x29, 0x6e, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x6a, 0x76, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x60, 0x08, 0x8b, 0x7e, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, 0x2a, 0x76, 0xa5, 0x43, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x5c, 0x6a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x29, 0x6e, 0x27, 0x4c, 0xc3, 0x21, 0xe6, 0x4b, 0x29, 0x76, + 0x44, 0x2a, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x31, 0x8c, 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, 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, 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, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe7, 0x54, 0x4a, 0x76, 0x49, 0x6e, 0x2a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0x29, 0x6e, 0x4a, 0x76, 0x45, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x85, 0x3b, 0x0a, 0x76, 0x4a, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x8a, 0x7e, 0x21, 0x11, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe3, 0x21, 0x8a, 0x76, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0x09, 0x6e, 0x66, 0x43, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x45, 0x3b, 0x4a, 0x76, 0x2a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x29, 0x6e, 0x4a, 0x76, 0x29, 0x6e, 0x87, 0x54, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0xad, 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, 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, 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, 0x69, 0x4a, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x61, 0x08, 0xe9, 0x6d, 0xea, 0x6d, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x6a, 0x76, 0xe9, 0x6d, 0x43, 0x19, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x4b, 0x6a, 0x76, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x8a, 0x76, 0x64, 0x32, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x01, 0x08, 0xe5, 0x32, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x2a, 0x76, 0x6a, 0x76, 0xe6, 0x43, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x02, 0x11, 0x2a, 0x76, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xdf, 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, 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, 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, 0x3c, 0xe7, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x4a, 0x76, 0xe9, 0x6d, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x4a, 0x76, 0xe8, 0x5c, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x01, 0x08, 0x87, 0x54, 0xaa, 0x7e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x6a, 0x76, 0x84, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x25, 0x3b, 0x09, 0x6e, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0xe9, 0x6d, + 0x8a, 0x76, 0x47, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x48, 0x5d, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x20, 0x00, 0xf4, 0xa4, 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, 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, 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, 0xd3, 0x9c, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x20, 0x00, 0x01, 0x00, 0x09, 0x6e, 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x2a, 0x76, + 0x2a, 0x76, 0x25, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x28, 0x5d, 0x8a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x2a, 0x76, 0x25, 0x3b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x85, 0x43, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0xab, 0x7e, 0x08, 0x5d, + 0x01, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x66, 0x43, 0x4a, 0x76, + 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x4a, 0x76, 0x01, 0x08, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x21, 0x00, 0x00, 0x00, 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, 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, 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, 0xdf, 0xff, 0xe8, 0x41, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0x6d, 0x0a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x8a, 0x7e, 0x48, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x03, 0x22, 0xc9, 0x65, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x4a, 0x76, 0xc4, 0x32, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x45, 0x3b, 0x09, 0x6e, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0x4a, 0x76, 0xe9, 0x6d, 0x61, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x69, 0x65, 0x6a, 0x76, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0x09, 0x6e, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0xef, 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, 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, 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, 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x89, 0x65, 0x2a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x6a, 0x76, 0xe6, 0x4b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xa5, 0x43, 0x4a, 0x76, 0x2a, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x8a, 0x76, 0x43, 0x2a, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xc4, 0x32, 0x4a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x4a, 0x76, 0x47, 0x54, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x43, 0x8b, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x6e, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xf7, 0xbd, 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, 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, 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, 0x9a, 0xd6, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x65, 0x0a, 0x76, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x6a, 0x76, 0x28, 0x5d, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0xe1, 0x10, 0x48, 0x65, 0x6a, 0x76, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0xaa, 0x7e, 0x21, 0x11, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xc2, 0x21, 0xaa, 0x76, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x6a, 0x76, 0x48, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xa1, 0x08, 0x88, 0x65, 0x6a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0x09, 0x6e, 0x48, 0x65, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xd7, 0xbd, 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, 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, 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, 0x79, 0xce, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x22, 0x19, 0xa2, 0x19, 0x02, 0x11, 0xc2, 0x21, 0xe6, 0x4b, 0x2a, 0x76, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x8b, 0x7e, 0x25, 0x3b, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc5, 0x32, 0x2a, 0x76, + 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xc9, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x4a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x2a, 0x76, + 0x2a, 0x76, 0xc4, 0x32, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xa6, 0x43, 0x8a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x6a, 0x76, 0x85, 0x43, 0xe2, 0x10, 0x01, 0x11, 0xc3, 0x21, 0xe1, 0x10, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0xf3, 0x9c, 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, 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, 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, 0xdb, 0xde, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0xa1, 0x10, 0x6a, 0x76, 0xaa, 0x76, 0xab, 0x7e, 0x09, 0x6e, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, + 0x67, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x48, 0x5d, 0x4a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x09, 0x6e, 0x86, 0x43, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x44, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x49, 0x76, 0xe8, 0x5c, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x5d, + 0x6a, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x2a, 0x76, 0xaa, 0x76, 0x6a, 0x76, 0x6a, 0x76, 0xc1, 0x08, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x18, 0xc6, 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, 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, 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, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xea, 0x6d, 0x2a, 0x76, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x2a, 0x76, 0x4a, 0x76, 0xe3, 0x21, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x84, 0x32, 0x6a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0xcb, 0x7e, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x62, 0x19, 0xaa, 0x7e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x6a, 0x76, 0x84, 0x32, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x01, 0x00, 0x63, 0x2a, 0x6a, 0x76, 0xe9, 0x6d, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0xe9, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfb, 0xde, 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, 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, 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, 0x75, 0xad, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xc8, 0x5c, 0x29, 0x6e, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0x8a, 0x76, 0x66, 0x43, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x48, 0x65, 0x29, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x2a, 0x76, + 0x04, 0x33, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x87, 0x54, + 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, 0x48, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x43, 0xaa, 0x7e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x2a, 0x76, 0xc7, 0x54, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x66, 0x31, 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, 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, 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, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x07, 0x4c, 0x6a, 0x76, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x6a, 0x76, 0x08, 0x5d, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe5, 0x3a, 0xaa, 0x7e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0xc9, 0x6d, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x8b, 0x7e, 0xe5, 0x32, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x41, 0x08, 0x08, 0x5d, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x6a, 0x76, 0x04, 0x33, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x3d, 0xef, 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, 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, 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, 0x5d, 0xef, 0x20, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x41, 0x08, + 0x6a, 0x76, 0x0a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x76, 0xc1, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x76, 0x0a, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x76, 0x8a, 0x76, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x60, 0x00, 0x8a, 0x7e, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x09, 0x6e, 0x6a, 0x76, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x22, 0x11, 0x6a, 0x76, 0xe9, 0x6d, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0x8a, 0x76, + 0x41, 0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x9a, 0xd6, 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, 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, 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, 0xbe, 0xf7, 0x03, 0x19, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xc8, 0x5c, 0x6a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0xeb, 0x7e, 0x23, 0x22, + 0x01, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x08, 0x5d, + 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0x28, 0x65, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xe9, 0x6d, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x29, 0x6e, + 0x49, 0x65, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x44, 0x32, 0xcb, 0x7e, 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, 0x89, 0x65, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x61, 0x08, + 0xdb, 0xde, 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, 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, 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, 0x7e, 0xf7, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc1, 0x10, 0xe9, 0x6d, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, + 0x85, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x04, 0x33, 0xaa, 0x7e, 0x09, 0x6e, 0xab, 0x7e, 0x84, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x84, 0x32, 0xaa, 0x76, 0x09, 0x6e, 0x6a, 0x76, 0x05, 0x3b, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x86, 0x43, + 0x8a, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0x41, 0x08, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xbb, 0xde, + 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, + 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, + 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, 0x7d, 0xef, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x02, 0x10, 0xc4, 0x32, + 0xc5, 0x32, 0xa5, 0x43, 0x28, 0x65, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0xab, 0x7e, 0xc6, 0x43, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x61, 0x11, 0x88, 0x5c, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x87, 0x54, 0x62, 0x19, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x47, 0x54, 0x4a, 0x76, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x67, 0x54, 0xc5, 0x32, 0xc3, 0x21, + 0xe3, 0x21, 0x21, 0x10, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xba, 0xd6, + 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, + 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, + 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, 0xdf, 0xff, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xe3, 0x21, + 0x8a, 0x76, 0x0a, 0x6e, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x4a, 0x76, 0xc7, 0x54, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x89, 0x65, 0x29, 0x6e, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0xcb, 0x7e, + 0xc3, 0x21, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x7e, 0xf7, + 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, + 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, + 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, + 0x0c, 0x63, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x22, 0x19, 0x6a, 0x76, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x48, 0x5d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xa9, 0x6d, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0xeb, 0x86, 0xc1, 0x10, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, + 0x9e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc6, 0x43, 0x8a, 0x7e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x2a, 0x76, 0xe7, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x69, 0x65, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0xe9, 0x6d, 0x8a, 0x76, 0x87, 0x54, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x7a, 0xd6, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0x39, 0xce, 0x41, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xa2, 0x21, 0x48, 0x65, 0x8a, 0x76, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0x08, 0x5d, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x89, 0x6d, 0x2a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xe9, 0x6d, 0x8b, 0x7e, 0xa9, 0x65, 0xa2, 0x19, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x30, 0x84, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe3, 0x21, 0x88, 0x65, 0x8a, 0x7e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x49, 0x76, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0xe9, 0x6d, + 0x8a, 0x76, 0xa9, 0x6d, 0x43, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x38, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x84, 0x2a, + 0xc9, 0x6d, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xc9, 0x6d, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x8a, 0x7e, 0xa9, 0x65, + 0x84, 0x32, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xec, 0x62, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xde, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x67, 0x54, 0x09, 0x6e, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x49, 0x76, 0x85, 0x43, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x26, 0x4c, 0x4a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x4a, 0x76, 0x65, 0x3b, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x38, 0xc6, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0x39, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x43, 0x28, 0x65, 0xa7, 0x54, + 0x2a, 0x76, 0x4a, 0x76, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x2a, 0x76, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x76, 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x4a, 0x76, 0x09, 0x6e, + 0xc8, 0x5c, 0x28, 0x5d, 0xe7, 0x4b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x04, 0x21, 0x1c, 0xe7, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xb5, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0x43, 0x8a, 0x76, + 0x29, 0x6e, 0xe9, 0x6d, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0xa5, 0x43, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xa6, 0x43, 0x4a, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, + 0x6a, 0x76, 0xa6, 0x43, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x69, 0x4a, 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, 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, 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, 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, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe6, 0x4b, 0xc9, 0x6d, 0x8b, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xc9, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x2a, 0x76, 0xaa, 0x7e, 0xc9, 0x6d, 0x45, 0x3b, + 0x00, 0x00, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x7a, 0xd6, 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, 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, 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, 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, 0x6d, 0x6b, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x03, 0x22, 0xc8, 0x5c, 0x29, 0x6e, 0x8a, 0x76, 0x09, 0x6e, 0xe9, 0x6d, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0xe9, 0x6d, 0x8a, 0x76, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x8a, 0x7e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x2a, 0x76, 0x6a, 0x76, 0x2a, 0x76, 0xc7, 0x54, 0x82, 0x19, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x25, 0x29, + 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, + 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, + 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, + 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, + 0x25, 0x21, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe3, 0x21, 0xe8, 0x5c, 0xe9, 0x6d, + 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x6e, 0x8a, 0x76, 0x84, 0x32, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x41, 0x08, 0x84, 0x2a, 0x8b, 0x7e, 0xe9, 0x6d, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x2a, 0x76, + 0xc9, 0x6d, 0xc7, 0x54, 0x02, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xe7, + 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, + 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, + 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, + 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, 0xc7, 0x39, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x67, 0x54, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x8a, 0x76, 0x64, 0x2a, 0x20, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x64, 0x2a, 0x8a, 0x7e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x06, 0x4c, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xc6, 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, 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, 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, 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, 0xf3, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x08, 0x42, 0x19, 0xa7, 0x54, + 0x6a, 0x7e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x4a, 0x76, 0x4a, 0x76, + 0x01, 0x00, 0x40, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xa3, 0x21, + 0x6a, 0x76, 0x29, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x4a, 0x76, + 0x47, 0x54, 0x21, 0x11, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x62, 0x9e, 0xf7, 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, 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, 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, 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, 0x14, 0xa5, 0xab, 0x5a, 0x00, 0x00, 0x21, 0x08, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xc3, 0x21, 0x8a, 0x76, 0x4a, 0x76, + 0x49, 0x6e, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x6a, 0x76, 0x28, 0x5d, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x28, 0x65, 0x6a, 0x76, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, + 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0x09, 0x6e, 0x09, 0x6e, 0x09, 0x6e, 0x4a, 0x76, + 0x6a, 0x76, 0x6a, 0x76, 0xc2, 0x21, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xa6, 0x31, 0x51, 0x8c, 0x3c, 0xe7, 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, 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, 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, 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, 0x39, 0xce, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x04, 0x2a, 0xe7, 0x5c, 0x89, 0x65, 0x09, 0x6e, 0x6a, 0x76, 0x6a, 0x76, 0x6a, 0x7e, 0x4a, 0x76, + 0x4a, 0x76, 0x29, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x4a, 0x76, 0x2a, 0x76, 0xc1, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x03, 0x19, 0x09, 0x6e, 0x4a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x2a, 0x76, + 0x4a, 0x76, 0x6a, 0x76, 0x8b, 0x7e, 0x4a, 0x76, 0xe9, 0x6d, 0xa9, 0x65, 0xe8, 0x5c, 0x03, 0x22, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xf4, 0xa4, 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, 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, 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, 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0xa3, 0x19, 0x47, 0x54, 0x09, 0x6e, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0x29, 0x6e, 0xab, 0x7e, 0xa8, 0x65, 0x02, 0x19, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x10, 0xe9, 0x6d, 0x6a, 0x76, 0x2a, 0x76, + 0x09, 0x6e, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, + 0xe9, 0x6d, 0x0a, 0x6e, 0xe9, 0x6d, 0x09, 0x6e, 0xe9, 0x6d, 0x0a, 0x76, 0x85, 0x3b, 0x01, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xba, 0xd6, 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, 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, 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, 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, 0x18, 0xc6, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x42, 0x10, 0x6a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x2a, 0x76, 0x2a, 0x6e, 0xab, 0x7e, 0xe9, 0x6d, + 0x66, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x45, 0x3b, + 0xea, 0x6d, 0x8a, 0x7e, 0x2a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, + 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x76, 0x2a, 0x76, 0xe2, 0x18, 0x20, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x2d, 0x63, + 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, + 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, + 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, + 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, + 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe3, 0x21, 0x6a, 0x76, 0xe9, 0x6d, 0x0a, 0x76, 0x09, 0x6e, 0x0a, 0x6e, 0x09, 0x6e, 0x2a, 0x76, + 0x49, 0x76, 0xaa, 0x7e, 0x4a, 0x76, 0xc9, 0x6d, 0x26, 0x4c, 0x02, 0x19, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa2, 0x10, 0x47, 0x54, 0xc9, 0x6d, 0x4a, 0x76, 0xaa, 0x76, 0x4a, 0x76, + 0x29, 0x6e, 0x0a, 0x6e, 0x09, 0x6e, 0x0a, 0x76, 0x09, 0x6e, 0x09, 0x6e, 0x6a, 0x76, 0xe2, 0x18, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0xbb, 0xde, 0x82, 0x10, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x65, 0x3b, + 0xa8, 0x54, 0x87, 0x54, 0x88, 0x5c, 0x06, 0x4c, 0xa6, 0x43, 0x25, 0x3b, 0x44, 0x2a, 0x42, 0x19, + 0x22, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x08, + 0x23, 0x19, 0x84, 0x2a, 0x25, 0x3b, 0xa6, 0x43, 0x07, 0x4c, 0x87, 0x54, 0x88, 0x5c, 0x87, 0x54, + 0x66, 0x43, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x6b, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xde, 0xc3, 0x18, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x01, 0x08, 0x40, 0x00, 0x85, 0x68, 0x86, 0x80, 0xc8, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xa6, 0x80, 0x64, 0x58, 0x41, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x08, 0xf3, 0x9c, 0x9e, 0xf7, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xc5, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x42, 0x28, 0xa6, 0x80, + 0x0a, 0xd1, 0x0a, 0xd9, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xea, 0xc8, 0x0a, 0xd9, 0xea, 0xd0, + 0xa7, 0x88, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xaf, 0x7b, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xe8, 0x39, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x80, 0x0a, 0xe1, 0xe9, 0xc0, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xc8, 0xa7, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xa6, 0x31, 0x9e, 0xf7, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x9c, 0xa3, 0x18, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc8, 0xa8, 0x0a, 0xd9, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc0, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x63, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x3d, 0xef, 0x28, 0x42, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc8, 0xa8, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0xc8, 0xa8, + 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x21, 0xbb, 0xde, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0x14, 0xa5, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x64, 0x48, 0xa6, 0x88, 0xe9, 0xb8, 0xe9, 0xc0, + 0x0a, 0xd1, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc8, 0x0a, 0xd1, 0xea, 0xd0, 0xe9, 0xc0, 0xa7, 0x98, + 0x86, 0x78, 0x64, 0x48, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x85, 0x68, 0x0a, 0xd9, + 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd1, 0x86, 0x78, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x41, 0x00, 0x21, 0x00, 0x41, 0x00, 0x20, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x10, 0x84, 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, 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, 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, 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, 0x4d, 0x6b, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x86, 0x88, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xd0, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, + 0xe9, 0xc8, 0xea, 0xd0, 0xe9, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0xc8, 0xb0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x08, 0xa7, 0x90, 0xea, 0xd0, + 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, + 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc8, 0xa7, 0xa0, 0x65, 0x60, 0x20, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x69, 0x4a, + 0x7d, 0xef, 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, 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, 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, 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, 0x5d, 0xef, 0x29, 0x4a, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xa6, 0x88, 0xea, 0xc8, 0xea, 0xc8, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xc8, 0xa0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x22, 0x30, 0x0a, 0xc9, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0x64, 0x50, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x64, 0x50, 0x0a, 0xd9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0xea, 0xd0, 0x0a, 0xd1, 0xe9, 0xc8, + 0xc8, 0xa8, 0x42, 0x28, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x21, 0x00, + 0x00, 0x00, 0xdb, 0xde, 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, 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, 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, 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, 0xfb, 0xde, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xc8, 0xa8, 0xe9, 0xc8, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x0a, 0xd9, 0x22, 0x30, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x22, 0x28, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x85, 0x70, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x42, 0x30, 0xea, 0xd8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xc0, 0xc7, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xd7, 0xbd, 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, 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, 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, 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, 0xba, 0xd6, 0x00, 0x00, 0x21, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xc8, 0xa8, 0x0a, 0xc9, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xc7, 0x98, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x44, 0x58, 0x0a, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd1, 0x86, 0x80, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc8, 0xa0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd1, 0xc8, 0xa8, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xd7, 0xbd, 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, 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, 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, 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, 0xba, 0xd6, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x43, 0x48, + 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, + 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x64, 0x58, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x08, 0x0b, 0xe1, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xea, 0xd0, 0xc7, 0x98, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0xad, 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, 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, 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, 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, 0xfc, 0xe6, 0x25, 0x29, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc8, 0xa0, 0x0a, 0xd9, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x42, 0x30, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, + 0xe9, 0xc0, 0x21, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x59, 0xce, 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, 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, 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, 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, 0x65, 0x31, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0xe9, 0xb8, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xd0, 0x64, 0x60, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xa7, 0x88, + 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, + 0xc8, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x86, 0x80, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x0b, 0xe1, 0x85, 0x78, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0xde, 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, 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, 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, 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, + 0xe8, 0x41, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x21, 0x20, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0xa6, 0x80, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xc8, 0xb0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0xa7, 0x98, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0x04, 0x21, 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, 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, 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, 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, 0xd3, 0x9c, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x08, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x43, 0x40, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xc8, 0xa0, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0xa7, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08, 0x42, + 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, + 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, + 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, + 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, 0xbf, 0xff, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x86, 0x78, 0xea, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xc8, 0xa8, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xf8, 0xc5, 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, 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, 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, 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, 0xc1, 0x08, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xe9, 0xb0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xb8, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x43, 0x38, 0xea, 0xd0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xea, 0xc8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0xa6, 0x88, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x21, 0x08, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xde, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xa6, 0x88, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc8, 0xe9, 0xb8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x65, 0x68, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x8a, 0x52, 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, 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, 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, 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, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc8, 0xe9, 0xb8, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xb8, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0xdf, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, + 0xe9, 0xb0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x42, 0x28, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xc9, 0xa6, 0x88, 0x01, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xea, 0xd0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xb8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xab, 0x5a, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x64, 0x60, 0x0a, 0xd1, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0xc8, 0xa0, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc8, 0xa8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xd0, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xd0, 0x65, 0x68, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd8, 0xa6, 0x80, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, + 0xa7, 0x90, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x55, 0xad, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x52, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x65, 0x60, 0xea, 0xd0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xea, 0xd0, 0xa6, 0x78, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xc9, 0xb0, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc8, 0xa8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x0a, 0xd1, 0x64, 0x60, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xe1, 0x43, 0x38, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xa8, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0xe9, 0xb0, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xa8, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xbe, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x21, 0x18, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x68, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd8, 0x85, 0x70, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x78, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xd0, 0x42, 0x30, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x31, 0x84, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x31, 0x8c, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xa7, 0x88, 0xea, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc8, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x21, 0x18, 0xc8, 0x98, 0x0a, 0xd9, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0xc8, 0xb0, 0x42, 0x28, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x64, 0x60, 0x0b, 0xe1, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xc8, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, + 0xc7, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x22, 0x30, + 0xa6, 0x88, 0x0a, 0xd9, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, + 0xea, 0xd8, 0xc8, 0xb0, 0x23, 0x40, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x40, 0x0a, 0xd9, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdf, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xbe, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0xa6, 0x88, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x86, 0x70, 0xc8, 0xa8, 0x0b, 0xe1, 0xea, 0xd0, 0x0a, 0xc9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x0a, 0xd9, 0xea, 0xc8, 0x86, 0x78, + 0x42, 0x30, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x21, 0x18, + 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0x42, 0x20, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xef, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9e, 0xf7, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x65, 0x60, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0b, 0xe1, 0x44, 0x58, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x58, 0xa6, 0x88, 0xc8, 0xa8, + 0xea, 0xd8, 0x0a, 0xd9, 0xe9, 0xd0, 0xea, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd1, + 0xea, 0xd0, 0x0b, 0xe1, 0xc8, 0xb8, 0xc8, 0xa8, 0x85, 0x68, 0x22, 0x28, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xc8, 0xa0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x31, 0x8c, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xb6, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xa0, 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0x22, 0x30, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x21, 0x20, 0x64, 0x60, 0x85, 0x78, 0xa6, 0x80, 0xa7, 0x98, 0xc7, 0x98, 0xc8, 0xb0, + 0xe9, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc7, 0x90, 0xa7, 0x90, 0xa6, 0x78, 0x64, 0x60, + 0x43, 0x48, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xa7, 0x88, 0x0a, 0xd1, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xe4, 0x20, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xaa, 0x52, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x43, 0x38, 0x42, 0x30, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x44, 0x58, 0xea, 0xd8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf, 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, 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, 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, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xea, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0x0a, 0xd9, 0xa7, 0x88, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xa7, 0x90, 0xc8, 0xb0, + 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd9, 0xea, 0xd0, 0x0a, 0xd1, 0x0a, 0xd1, 0x0a, 0xd9, 0xea, 0xc8, + 0x0a, 0xc9, 0xc8, 0xb0, 0xa7, 0x88, 0x43, 0x40, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, 0x0a, 0xc9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x21, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xdf, 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, 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, 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, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x22, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x44, 0x58, 0xa7, 0x90, + 0xc7, 0xa0, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xc8, 0xb8, 0xc7, 0xa0, + 0x86, 0x80, 0x64, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x80, 0xe9, 0xc0, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc0, 0xc8, 0xa8, 0x43, 0x48, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0xa0, 0x0a, 0xd9, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0x42, 0x28, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0xf7, 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, 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, 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, 0xff, 0xff, + 0xdf, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x40, 0x00, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0xc8, 0xa8, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x43, 0x38, 0xa6, 0x90, 0xe9, 0xc0, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc0, + 0x0a, 0xc9, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xc8, 0x0a, 0xd1, 0xc8, 0xa8, 0x85, 0x70, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x86, 0x88, 0x0a, 0xd1, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0xe9, 0xc0, + 0x86, 0x78, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x44, 0x50, + 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x64, 0x58, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x9e, 0xf7, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x9e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xea, 0xc8, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x43, 0x48, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x64, 0x60, 0xe9, 0xb8, 0xe9, 0xd0, 0xe9, 0xc8, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0x65, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x44, 0x58, + 0xe9, 0xc8, 0xe9, 0xc8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc8, 0xea, 0xc8, 0x65, 0x70, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xe9, 0xb8, 0xe9, 0xc8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc7, 0x98, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xe7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7d, 0xef, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x41, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x65, 0x68, 0xe9, 0xb8, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xea, 0xc8, 0xe9, 0xc0, + 0x64, 0x50, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xa7, 0x90, 0xea, 0xd0, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xb8, 0x21, 0x20, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x86, 0x70, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0x0a, 0xc9, 0xa7, 0x90, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xf8, 0xc5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xbe, 0xf7, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, + 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, + 0xbe, 0xf7, 0xdf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x20, 0x00, 0xea, 0xc8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0x43, 0x48, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x30, 0xc9, 0xb0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xe9, 0xc8, 0xa6, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xc9, 0xb0, 0xc9, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd9, 0x86, 0x78, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb0, 0xea, 0xc8, 0xc8, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xc8, 0xb0, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf7, 0xbd, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, + 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, + 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, + 0xbf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, + 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, + 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x42, 0x08, 0xe9, 0xc8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0x86, 0x80, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x65, 0x68, 0x0a, 0xd1, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe9, 0xb0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0xc8, 0xa8, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x43, 0x48, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xc8, 0xb0, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xd3, 0x9c, 0xff, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, + 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, + 0xbf, 0xff, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, + 0x9e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, + 0x7d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, + 0x7d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, + 0x3c, 0xe7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0x86, 0x80, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb0, 0xea, 0xc8, 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xe9, 0xc8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xa7, 0x98, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x70, + 0xe9, 0xc8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xc8, 0xb0, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x9c, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, + 0x7d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, + 0x7d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, + 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, + 0x7e, 0xf7, 0x5d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, 0x3d, 0xef, 0x5d, 0xef, 0x3d, 0xef, + 0x5d, 0xef, 0x3d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, + 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, + 0x1c, 0xe7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x01, 0x08, 0x43, 0x38, 0x64, 0x48, 0x41, 0x10, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x20, 0xe9, 0xc8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xe9, 0xc8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x86, 0x70, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x85, 0x70, 0xe9, 0xb8, 0xe9, 0xc8, 0x0a, 0xd9, 0x42, 0x20, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x92, 0x94, 0xdf, 0xff, + 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, + 0x5d, 0xef, 0x3d, 0xef, 0x5d, 0xef, 0x3d, 0xef, 0x3d, 0xef, 0x3c, 0xe7, 0x5d, 0xef, 0x3d, 0xef, + 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, + 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, + 0x3c, 0xe7, 0x3d, 0xef, 0x1c, 0xe7, 0x1c, 0xe7, 0x1c, 0xe7, 0x1c, 0xe7, 0xfb, 0xde, 0x1c, 0xe7, + 0xfb, 0xde, 0x1c, 0xe7, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, + 0x3c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x42, 0x30, + 0xc9, 0xc0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x22, 0x28, 0xc9, 0xc0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x5d, 0xef, + 0x9e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, 0x3c, 0xe7, 0x3c, 0xe7, + 0x1c, 0xe7, 0x1c, 0xe7, 0xfb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0x1c, 0xe7, + 0x1c, 0xe7, 0x3c, 0xe7, 0x3c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, + 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, 0x1c, 0xe7, + 0x1c, 0xe7, 0xfb, 0xde, 0xfc, 0xe6, 0xdb, 0xde, 0xdb, 0xde, 0xbb, 0xde, 0xdb, 0xde, 0xbb, 0xde, + 0xdb, 0xde, 0xbb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, + 0x1c, 0xe7, 0x1c, 0xe7, 0x3c, 0xe7, 0x3c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x9a, 0xd6, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x42, 0x20, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, + 0xeb, 0xb9, 0x32, 0xc4, 0x97, 0xdd, 0x59, 0xe6, 0xfc, 0xf6, 0x5d, 0xf7, 0xbf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0x7d, 0xf7, 0xfc, 0xf6, 0xf8, 0xdd, 0xd4, 0xcc, 0x4b, 0xaa, + 0xc8, 0xa8, 0xa8, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0x64, 0x48, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x01, 0x08, 0xc8, 0xb8, 0x6f, 0xc3, 0xb7, 0xdd, 0xfc, 0xf6, 0x7e, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9e, 0xff, 0x1c, 0xf7, 0x18, 0xde, 0x52, 0xc4, 0xe8, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x31, 0x8c, + 0x9e, 0xf7, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0x7d, 0xef, 0x1c, 0xe7, 0xbb, 0xde, + 0xdb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x3d, 0xef, 0x3d, 0xef, 0x5d, 0xef, 0x7d, 0xef, + 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xbe, 0xf7, 0x9e, 0xf7, 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, 0xdf, 0xff, 0xbf, 0xff, 0x7d, 0xef, 0x3d, 0xef, 0xfb, 0xde, 0xbb, 0xde, + 0xba, 0xd6, 0xdb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0x3c, 0xe7, 0x3c, 0xe7, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xcb, 0x5a, + 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, 0xdf, 0xff, 0x9e, 0xf7, + 0x3c, 0xe7, 0xbb, 0xde, 0xf7, 0xbd, 0xd3, 0x9c, 0xaa, 0x52, 0x20, 0x00, 0xc8, 0xb8, 0xc8, 0xa8, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xea, 0xb9, 0xb3, 0xd4, 0x19, 0xe6, 0x5d, 0xf7, + 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, + 0x9a, 0xe6, 0x31, 0xbc, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc9, 0xc0, 0x21, 0x20, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0xae, 0x83, 0xfc, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xf7, 0x14, 0xcd, 0xa8, 0xa0, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0x00, 0x00, 0x4d, 0x6b, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x9a, 0xd6, 0x5d, 0xef, 0x5d, 0xef, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0x1c, 0xe7, 0x9a, 0xd6, 0xba, 0xd6, 0xdb, 0xde, 0xdb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x5d, 0xef, + 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, + 0xbf, 0xff, 0x7e, 0xf7, 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, + 0x7e, 0xf7, 0xbb, 0xde, 0x9a, 0xd6, 0xba, 0xd6, 0xdb, 0xde, 0x59, 0xce, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xcb, 0x5a, + 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, 0x5d, 0xf7, 0x97, 0xd5, 0x6b, 0xaa, + 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0x59, 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, 0xbb, 0xee, 0x8c, 0xa2, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0x98, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xd7, 0xbd, + 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, 0xfc, 0xee, + 0x6c, 0xaa, 0xa7, 0x98, 0xc8, 0xa0, 0xa8, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0x86, 0x80, 0xfb, 0xde, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xba, 0xd6, 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, 0x9e, 0xf7, 0x9a, 0xd6, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, + 0x5d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, + 0x7e, 0xf7, 0x7e, 0xf7, 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, 0x5d, 0xef, 0x7a, 0xd6, 0x30, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xcb, 0x5a, + 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, 0xdf, 0xff, + 0xb7, 0xd5, 0x08, 0xa1, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, + 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0x39, 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, 0xbf, 0xff, 0x52, 0xb4, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xb0, + 0x22, 0x28, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x82, 0x10, 0x79, 0xce, 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, + 0x7d, 0xf7, 0xed, 0xaa, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0x15, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x82, 0x10, + 0x7a, 0xd6, 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, 0xbe, 0xf7, 0x79, 0xce, 0x59, 0xce, 0x9a, 0xd6, 0xba, 0xd6, 0xfb, 0xde, + 0xfc, 0xe6, 0x3d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, + 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, + 0x9e, 0xf7, 0x5d, 0xef, 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, 0x7d, 0xef, 0x6a, 0x52, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xcb, 0x5a, + 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, 0x1c, 0xef, 0x4b, 0xa2, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0x59, 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, 0x52, 0xbc, 0xa7, 0x98, 0xa7, 0x98, + 0xa7, 0x90, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x38, 0xc6, 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, 0x5d, 0xf7, 0x0a, 0x9a, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0x8c, 0xb2, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x18, 0xc6, + 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, 0xbe, 0xf7, 0x39, 0xce, 0x39, 0xce, 0x7a, 0xd6, 0x9a, 0xd6, + 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 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, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, + 0x5d, 0xef, 0x3d, 0xef, 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, 0x3c, 0xe7, 0xe7, 0x39, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x5a, + 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, 0x3d, 0xef, 0xc9, 0x99, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0x38, 0xde, 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, 0xdf, 0xff, 0xed, 0xa2, 0xa7, 0x98, + 0xa7, 0xa8, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0xb2, 0x94, 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, 0x7a, 0xde, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0x9a, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x92, 0x94, 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, 0x3c, 0xe7, 0xf7, 0xbd, 0x18, 0xc6, 0x7a, 0xd6, + 0x9a, 0xd6, 0xdb, 0xde, 0xfc, 0xe6, 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, + 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x7e, 0xf7, + 0x5d, 0xef, 0x1c, 0xe7, 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, 0xd7, 0xbd, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5a, + 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, 0x59, 0xde, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, + 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0x39, 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, 0xdc, 0xee, 0x86, 0x88, + 0xa7, 0x98, 0x43, 0x48, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x86, 0x31, 0x9e, 0xf7, 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, 0x31, 0xac, 0xa7, 0x90, 0xa7, 0x90, 0xa8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0x73, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x64, 0x48, 0x86, 0x88, + 0xa7, 0x90, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x86, 0x31, 0xbf, 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, 0x59, 0xce, 0xf8, 0xc5, 0x18, 0xc6, + 0x7a, 0xd6, 0xba, 0xd6, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, + 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x7d, 0xef, + 0x3c, 0xe7, 0x1c, 0xe7, 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, 0xdf, 0xff, 0x8a, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0xa7, 0xa0, 0xcd, 0xb2, + 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, 0xaf, 0xa3, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0x38, 0xde, 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, 0xd0, 0xa3, + 0x86, 0x88, 0x86, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xb5, 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, 0x3d, 0xef, 0x86, 0x80, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xaa, 0xb1, 0x7d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0x88, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xe9, 0xb8, 0x64, 0x60, 0x00, 0x00, 0x00, 0x00, 0xb7, 0xbd, 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, 0x9e, 0xf7, 0x96, 0xb5, 0xf7, 0xbd, + 0x38, 0xc6, 0x7a, 0xd6, 0xba, 0xd6, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, + 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, + 0x3d, 0xef, 0xfb, 0xde, 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, 0x96, 0xb5, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x86, 0x78, 0xc8, 0xa8, 0xa7, 0xa0, 0xcc, 0xaa, + 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, 0x9b, 0xe6, 0x86, 0x80, 0x87, 0x88, 0x86, 0x90, + 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0x39, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1c, 0xef, 0x59, 0xde, 0x75, 0xc5, 0x93, 0xb4, 0x4e, 0x9b, 0xab, 0x8a, 0x88, 0x79, + 0xa8, 0x79, 0xec, 0x8a, 0xb3, 0xac, 0x79, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x38, 0xd6, + 0x86, 0x88, 0xa7, 0x98, 0x21, 0x10, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x04, 0x21, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xf0, 0x93, 0xe8, 0x69, + 0x4e, 0x8b, 0xb7, 0xc5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0xac, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, + 0xa8, 0xa0, 0xa8, 0xa0, 0xc8, 0xa8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xf8, 0xdd, 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, 0x59, 0xce, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x43, 0x48, 0xc8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc9, 0xb8, 0xc8, 0xa8, 0x04, 0x21, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xd6, + 0x35, 0xad, 0x10, 0x84, 0xb3, 0x9c, 0x38, 0xc6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x18, 0xc6, 0x96, 0xb5, + 0xf8, 0xc5, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x3d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, + 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x7d, 0xef, 0x5d, 0xef, + 0x1c, 0xe7, 0xfb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x2d, 0x6b, 0xeb, 0x5a, 0xec, 0x62, 0xec, 0x62, 0x4d, 0x6b, + 0xae, 0x73, 0xb2, 0x94, 0xb7, 0xbd, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xde, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x87, 0x98, 0xcd, 0xaa, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x08, 0xe7, 0x39, 0xaa, 0x52, 0x31, 0x8c, + 0x75, 0xb5, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x88, 0x81, 0x66, 0x80, 0x86, 0x88, + 0x86, 0x88, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0xf8, 0xd5, 0xfc, 0xee, 0x97, 0xd5, 0xd0, 0xb3, + 0x07, 0x91, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x65, 0x80, 0x86, 0x80, 0x65, 0x78, 0x65, 0x78, + 0x65, 0x70, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x4d, 0x8b, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xf7, + 0x65, 0x78, 0xa7, 0x90, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x92, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0xc5, 0x44, 0x58, 0x23, 0x50, 0x44, 0x58, + 0x23, 0x50, 0x43, 0x50, 0xcf, 0x8b, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xde, 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, + 0x87, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0x8f, 0xbb, 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, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa7, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xb3, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xb5, 0x00, 0x00, + 0x04, 0x21, 0x8e, 0x73, 0x8e, 0x73, 0x8e, 0x73, 0xd3, 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x55, 0xad, + 0xb6, 0xb5, 0x18, 0xc6, 0x59, 0xce, 0xba, 0xd6, 0xdb, 0xde, 0x3c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, + 0x9e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, + 0x1c, 0xe7, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcb, 0x5a, 0xcb, 0x5a, 0xab, 0x5a, 0xcb, 0x5a, 0xeb, 0x5a, + 0x0c, 0x63, 0x2c, 0x63, 0x4d, 0x6b, 0x4d, 0x6b, 0xf8, 0xc5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x22, 0x30, 0xa7, 0xa0, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x90, 0xa7, 0x98, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, + 0x44, 0x58, 0x23, 0x50, 0xb3, 0xa4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0xa4, 0x86, 0x80, 0x86, 0x80, + 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, + 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x86, 0x80, 0x86, 0x80, 0x65, 0x78, + 0x86, 0x78, 0x65, 0x70, 0x65, 0x78, 0x65, 0x70, 0x65, 0x68, 0xab, 0x7a, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xe6, 0x78, 0x86, 0x88, 0x43, 0x40, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x9a, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x44, 0x58, 0x23, 0x50, 0x44, 0x58, 0x23, 0x50, + 0x44, 0x58, 0x23, 0x50, 0x44, 0x58, 0x76, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x47, 0x81, 0x86, 0x88, 0x86, 0x88, + 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xe8, 0xa8, + 0x3d, 0xf7, 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, 0x59, 0xce, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x22, 0x30, 0xa8, 0xa0, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa0, 0xbb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xe7, 0x39, 0x8e, 0x73, 0x6e, 0x73, 0x8e, 0x73, 0xf7, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0xa5, + 0x96, 0xb5, 0xd7, 0xbd, 0x39, 0xce, 0x7a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, + 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x5d, 0xef, + 0xfc, 0xe6, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xab, 0x5a, 0x8a, 0x52, 0xab, 0x5a, 0xaa, 0x52, 0xec, 0x62, + 0x0c, 0x63, 0x2d, 0x6b, 0x4d, 0x6b, 0x4d, 0x6b, 0x4d, 0x6b, 0x9a, 0xd6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x28, 0x42, + 0x23, 0x48, 0x87, 0x90, 0x86, 0x80, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x90, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x28, + 0x23, 0x50, 0x44, 0x58, 0x23, 0x50, 0x35, 0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x97, 0xc5, 0x65, 0x70, 0x86, 0x80, + 0x86, 0x88, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, + 0x87, 0x98, 0xa7, 0x98, 0x86, 0x90, 0x87, 0x90, 0x86, 0x88, 0x86, 0x88, 0x86, 0x80, 0x86, 0x80, + 0x65, 0x80, 0x86, 0x80, 0x65, 0x78, 0x65, 0x78, 0x45, 0x70, 0x65, 0x68, 0x96, 0xbd, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x8b, 0x82, 0x86, 0x80, 0x44, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x82, 0x10, 0xbe, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x9c, 0x23, 0x50, 0x43, 0x50, 0x23, 0x50, 0x43, 0x50, + 0x23, 0x50, 0x44, 0x58, 0x23, 0x50, 0x87, 0x61, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x52, 0xac, 0x65, 0x78, 0x86, 0x88, + 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xa8, 0xa8, 0x56, 0xd5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xe6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x60, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xe8, 0xa0, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x8c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xeb, 0x5a, 0x8e, 0x73, 0x8e, 0x73, 0xcf, 0x7b, 0xbe, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xbd, + 0x34, 0xa5, 0xb6, 0xb5, 0xf7, 0xbd, 0x59, 0xce, 0x9a, 0xd6, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, + 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3d, 0xef, + 0x1c, 0xe7, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0xab, 0x5a, 0xaa, 0x52, 0xec, 0x62, 0x0c, 0x63, + 0x4d, 0x6b, 0x4d, 0x6b, 0x8e, 0x73, 0x6e, 0x73, 0x49, 0x4a, 0x71, 0x8c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2d, 0x7b, + 0x86, 0x80, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x58, + 0x44, 0x58, 0x44, 0x58, 0x44, 0x58, 0xc5, 0x58, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xd6, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, + 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x88, + 0x87, 0x88, 0x86, 0x80, 0x86, 0x80, 0x65, 0x78, 0x86, 0x78, 0x65, 0x70, 0x4d, 0x93, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xed, 0x8a, 0x65, 0x78, 0x65, 0x68, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0xae, 0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x9e, 0xff, 0x23, 0x50, 0x44, 0x58, 0x23, 0x50, 0x44, 0x58, 0x23, 0x50, + 0x44, 0x58, 0x43, 0x58, 0x44, 0x58, 0x43, 0x58, 0x39, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xcd, 0x86, 0x78, 0x86, 0x80, + 0xa7, 0x90, 0xa7, 0x90, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, 0xcd, 0xba, 0xdf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x0d, 0x8b, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x78, 0xa7, 0x90, 0xa7, 0x90, 0xa7, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xb0, 0xb3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc3, 0x18, 0xae, 0x73, 0xcf, 0x7b, 0xaf, 0x7b, 0x9a, 0xd6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xd6, + 0x14, 0xa5, 0x76, 0xb5, 0xf7, 0xbd, 0x38, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, + 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x8a, 0x52, 0x8a, 0x52, 0xcb, 0x5a, 0xeb, 0x5a, 0x2d, 0x6b, + 0x6d, 0x6b, 0x8e, 0x73, 0x8e, 0x73, 0x8e, 0x73, 0x00, 0x00, 0x8a, 0x52, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0xa4, + 0x44, 0x68, 0x65, 0x78, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x90, 0x86, 0x88, 0xcd, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x44, 0x68, + 0x43, 0x58, 0x44, 0x60, 0x44, 0x58, 0x44, 0x58, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xde, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x80, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, + 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x65, 0x78, 0x65, 0x78, 0xa5, 0x70, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xa7, 0x71, 0x65, 0x78, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x75, 0xad, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x43, 0x50, 0x23, 0x50, 0x43, 0x50, 0x23, 0x50, 0x44, 0x58, + 0x23, 0x58, 0x44, 0x60, 0x44, 0x58, 0x44, 0x60, 0x72, 0xa4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x65, 0x70, 0x86, 0x80, + 0x86, 0x80, 0xa7, 0x90, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xb0, 0xc9, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xba, 0xe6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, 0xc5, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x90, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0xa0, + 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0xa0, 0x76, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x49, 0x4a, 0xef, 0x7b, 0xf0, 0x83, 0x75, 0xad, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xef, + 0xd3, 0x9c, 0x55, 0xad, 0xb6, 0xb5, 0x18, 0xc6, 0x59, 0xce, 0xbb, 0xde, 0xfb, 0xde, 0x3d, 0xef, + 0x5d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3d, 0xef, + 0x1c, 0xe7, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0xab, 0x5a, 0xcb, 0x5a, 0x2d, 0x6b, 0x4d, 0x6b, + 0xae, 0x73, 0xaf, 0x7b, 0xf0, 0x83, 0x04, 0x21, 0x20, 0x00, 0x45, 0x29, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x93, + 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x40, 0x44, 0x60, + 0x44, 0x60, 0x44, 0x60, 0x45, 0x68, 0x44, 0x60, 0x7a, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe6, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0x98, + 0xa7, 0x98, 0x87, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x65, 0x80, 0x27, 0x81, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0x65, 0x68, 0x65, 0x70, 0x65, 0x70, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x59, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x55, 0xb5, 0x23, 0x50, 0x44, 0x50, 0x23, 0x50, 0x44, 0x58, 0x44, 0x58, + 0x44, 0x60, 0x44, 0x60, 0x65, 0x68, 0x44, 0x60, 0x4a, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0xff, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0x93, 0xc4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xf7, 0xc5, 0x68, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x86, 0x90, 0x87, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, + 0xc8, 0xa0, 0xa7, 0xa0, 0xa8, 0xa0, 0x59, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x10, 0x84, 0x10, 0x84, 0x72, 0x94, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0xb3, 0x9c, 0x14, 0xa5, 0x96, 0xb5, 0xf8, 0xc5, 0x59, 0xce, 0x9a, 0xd6, 0xfc, 0xe6, 0x3c, 0xe7, + 0x7d, 0xef, 0x7e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xaa, 0x52, 0xaa, 0x52, 0xec, 0x62, 0x2c, 0x63, 0x8e, 0x73, + 0xae, 0x73, 0xef, 0x7b, 0xae, 0x73, 0x00, 0x00, 0x00, 0x00, 0x6a, 0x52, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x83, + 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x60, 0x44, 0x60, + 0x44, 0x60, 0x45, 0x68, 0x44, 0x60, 0x44, 0x68, 0x79, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe6, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0xa0, 0xa7, 0xa0, + 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x0d, 0x93, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0xef, + 0x44, 0x68, 0x65, 0x70, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf0, 0x8b, 0x43, 0x50, 0x23, 0x50, 0x44, 0x58, 0x23, 0x58, 0x44, 0x60, + 0x44, 0x60, 0x44, 0x68, 0x44, 0x60, 0x44, 0x68, 0x44, 0x60, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x7a, 0x65, 0x78, + 0x65, 0x80, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xea, 0xa9, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaf, 0x93, 0x44, 0x60, 0x23, 0x50, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0x3c, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x31, 0x51, 0x8c, 0x30, 0x84, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd3, 0x9c, 0x14, 0xa5, 0x55, 0xad, 0xd7, 0xbd, 0x38, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, + 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0x1c, 0xe7, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0x52, 0xcb, 0x5a, 0x0c, 0x63, 0x4d, 0x6b, 0x8e, 0x73, + 0xcf, 0x7b, 0xf0, 0x83, 0xc3, 0x18, 0x00, 0x00, 0x01, 0x00, 0x72, 0x94, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x26, 0x61, + 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x87, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x65, 0x70, 0x44, 0x68, + 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x44, 0x68, 0xfc, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbb, 0xde, 0x65, 0x68, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, + 0xc8, 0xa0, 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x55, 0xc5, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xc5, + 0x65, 0x68, 0x65, 0x70, 0x65, 0x68, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x8b, 0x72, 0x23, 0x50, 0x44, 0x58, 0x44, 0x58, 0x44, 0x60, 0x44, 0x60, + 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x1c, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x9b, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x98, 0xc8, 0xa0, 0xa8, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0x39, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x18, 0xce, 0x65, 0x68, 0x44, 0x60, 0x44, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x01, 0x00, 0x00, 0x00, 0x22, 0x40, 0x86, 0x80, 0x87, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, + 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x8c, 0x72, 0x94, 0x5d, 0xef, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x76, 0xb5, 0xd3, 0x9c, 0x55, 0xad, 0xb6, 0xb5, 0x39, 0xce, 0x7a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, + 0x5d, 0xef, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x8a, 0x52, 0xaa, 0x52, 0x0c, 0x63, 0x4d, 0x6b, 0x8e, 0x73, + 0xcf, 0x7b, 0xcf, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x44, 0x60, + 0x44, 0x68, 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x28, 0x44, 0x68, 0x65, 0x68, + 0x44, 0x68, 0x65, 0x70, 0x44, 0x68, 0xe6, 0x68, 0xbe, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xd6, 0x44, 0x68, 0x65, 0x70, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0x86, 0x90, 0x3c, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x93, + 0x44, 0x68, 0x65, 0x70, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xa2, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x23, 0x48, 0x23, 0x50, 0x23, 0x50, 0x44, 0x58, 0x44, 0x60, 0x44, 0x68, + 0x44, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x44, 0x68, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0xac, 0x65, 0x70, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0xa8, 0xd0, 0xbb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7e, 0xf7, 0xa8, 0x79, 0x44, 0x60, 0x44, 0x60, 0x23, 0x50, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x88, 0x86, 0x80, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0x98, 0x07, 0x99, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x31, 0x71, 0x8c, 0x1c, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd7, 0xbd, 0xb3, 0x9c, 0x34, 0xa5, 0xb6, 0xb5, 0xf7, 0xbd, 0x79, 0xce, 0xba, 0xd6, 0x1c, 0xe7, + 0x3c, 0xe7, 0x7d, 0xef, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0xab, 0x5a, 0xeb, 0x5a, 0x4d, 0x6b, 0x6e, 0x73, + 0xcf, 0x7b, 0x45, 0x29, 0x00, 0x00, 0x00, 0x00, 0x96, 0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, 0xbd, 0x44, 0x60, + 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x87, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x65, 0x68, 0x44, 0x68, + 0x65, 0x70, 0x44, 0x68, 0x65, 0x70, 0x35, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x96, 0xbd, 0x65, 0x68, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xb0, 0xc8, 0xa8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x72, 0xb4, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xef, 0x44, 0x60, + 0x65, 0x70, 0x65, 0x78, 0x44, 0x50, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xaa, 0x52, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9e, 0xf7, 0x43, 0x50, 0x23, 0x50, 0x44, 0x58, 0x43, 0x58, 0x44, 0x60, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x68, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x59, 0xd6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, 0xbd, 0x45, 0x68, + 0x86, 0x78, 0x86, 0x80, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xa8, 0xa8, 0x29, 0xa9, 0x3d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x72, 0xac, 0x45, 0x68, 0x65, 0x68, 0x44, 0x58, 0x44, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x43, 0x40, 0x86, 0x80, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0x98, 0xad, 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x23, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x41, 0x08, 0x92, 0x94, 0xdb, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x39, 0xce, 0x92, 0x94, 0x35, 0xad, 0x96, 0xb5, 0x18, 0xc6, 0x59, 0xce, 0xbb, 0xde, 0xfb, 0xde, + 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x69, 0x4a, 0x6a, 0x52, 0xcb, 0x5a, 0x0c, 0x63, 0x6e, 0x73, + 0x10, 0x84, 0xcf, 0x7b, 0x55, 0xad, 0x3c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x29, 0x6a, 0x44, 0x60, + 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x50, 0x44, 0x60, 0x44, 0x68, + 0x44, 0x68, 0x65, 0x68, 0x92, 0xa4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x9c, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x80, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xa7, 0xa0, 0xe9, 0x99, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10, 0x94, 0x64, 0x68, + 0x45, 0x70, 0x66, 0x80, 0x22, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x4d, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7d, 0xf7, 0x22, 0x48, 0x23, 0x50, 0x23, 0x50, 0x92, 0xa4, 0x5d, 0xef, 0xff, 0xff, + 0x9e, 0xf7, 0xf8, 0xcd, 0xc5, 0x70, 0x65, 0x70, 0x44, 0x68, 0xf8, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xc5, 0x65, 0x68, + 0x65, 0x70, 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xa8, 0xa0, + 0xa7, 0xa0, 0xa8, 0xa8, 0x96, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9a, 0xde, 0x65, 0x70, 0x65, 0x68, 0x44, 0x60, 0x44, 0x60, 0x23, 0x50, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x80, 0x86, 0x80, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0x87, 0x98, 0xa7, 0x98, 0x6e, 0xab, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7d, 0xef, 0x23, 0x50, 0x01, 0x18, 0x00, 0x00, 0x92, 0x94, + 0x3d, 0xef, 0xff, 0xff, 0x9e, 0xf7, 0xf7, 0xbd, 0xa2, 0x10, 0x00, 0x00, 0xcb, 0x5a, 0x9a, 0xd6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x59, 0xce, 0x92, 0x94, 0xf3, 0x9c, 0x76, 0xb5, 0xd7, 0xbd, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, + 0x1c, 0xe7, 0x7d, 0xef, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 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, 0x14, 0xad, 0x44, 0x60, 0x44, 0x60, + 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x10, 0xc8, 0x61, 0xcc, 0x7a, 0x10, 0x9c, + 0x96, 0xc5, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x67, 0x69, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, + 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0x98, 0x9b, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xd6, 0x65, 0x68, 0x44, 0x68, + 0x65, 0x78, 0x86, 0x88, 0x21, 0x20, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x10, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x3c, 0xef, 0x43, 0x48, 0x23, 0x48, 0xb3, 0xa4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7a, 0xde, 0x65, 0x70, 0x65, 0x70, 0xb7, 0xc5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x44, 0x68, + 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa0, 0x0d, 0xb3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0x6b, 0x8a, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0x44, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x01, 0x00, 0x00, 0x00, 0x43, 0x48, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x90, + 0xa7, 0x98, 0xa7, 0x98, 0x11, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0xef, 0x43, 0x48, 0x22, 0x40, 0xb2, 0x94, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xd6, 0x00, 0x00, 0xc3, 0x18, 0x59, 0xce, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbb, 0xde, 0x71, 0x8c, 0xf4, 0xa4, 0x55, 0xad, 0xf8, 0xc5, 0x39, 0xce, 0xba, 0xd6, 0xdb, 0xde, + 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 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, 0x18, 0xc6, 0x43, 0x58, 0x44, 0x58, 0x65, 0x68, + 0x65, 0x70, 0x66, 0x78, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x90, 0x86, 0x88, 0xcc, 0x9a, + 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, 0x9a, 0xd6, 0x44, 0x60, 0x44, 0x68, 0x66, 0x78, + 0x66, 0x80, 0x87, 0x90, 0x87, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0x97, 0xd5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x29, 0x7a, 0x44, 0x68, 0x65, 0x70, + 0x65, 0x70, 0x86, 0x88, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1c, 0xe7, 0x22, 0x48, 0x23, 0x50, 0x5d, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8f, 0x93, 0x44, 0x68, 0x96, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x44, 0x68, + 0x44, 0x68, 0x65, 0x78, 0x66, 0x80, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, + 0xa7, 0x98, 0xdb, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x14, 0xb5, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0x44, 0x60, 0x23, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x80, 0x65, 0x80, 0x86, 0x88, 0x86, 0x90, 0xa7, 0x98, + 0x86, 0x90, 0xa7, 0x98, 0x51, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x22, 0x48, 0x43, 0x50, 0x5d, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x73, 0x00, 0x00, 0x59, 0xce, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xba, 0xd6, 0x51, 0x8c, 0xd3, 0x9c, 0x55, 0xad, 0xb6, 0xb5, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 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, 0x75, 0xb5, 0x43, 0x50, 0x43, 0x58, 0x45, 0x68, 0x45, 0x68, + 0x65, 0x78, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0xcc, 0x9a, + 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, 0xcf, 0x93, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x90, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, + 0xc8, 0xa8, 0xa7, 0xa0, 0xf4, 0xcc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0x9c, 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, + 0x86, 0x80, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x72, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0xe6, 0x23, 0x48, 0x49, 0x62, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xbd, 0x65, 0x68, 0x75, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xd6, 0x44, 0x60, + 0x65, 0x70, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0x98, + 0xf4, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xe6, + 0x65, 0x78, 0x65, 0x70, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x90, + 0xa7, 0x98, 0xa7, 0x90, 0x93, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xe6, 0x23, 0x48, 0x49, 0x6a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x00, 0x00, 0x96, 0xb5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdb, 0xde, 0x51, 0x8c, 0xd3, 0x9c, 0x55, 0xad, 0xd7, 0xbd, 0x18, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 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, + 0x7e, 0xf7, 0xf8, 0xc5, 0xab, 0x62, 0x23, 0x48, 0x23, 0x50, 0x44, 0x58, 0x44, 0x60, 0x65, 0x70, + 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x88, 0xcc, 0xa2, + 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, 0x59, 0xd6, 0x44, 0x60, 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, + 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa8, 0x73, 0xc4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x35, 0xb5, 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, + 0x65, 0x80, 0x64, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x92, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0xe6, 0x22, 0x40, 0x4a, 0x62, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xbd, 0x44, 0x68, 0x56, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x44, 0x60, + 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0x2a, 0xa2, + 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x2d, 0x93, + 0x65, 0x70, 0x65, 0x70, 0x44, 0x68, 0x44, 0x68, 0x44, 0x60, 0x44, 0x60, 0x43, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x30, 0x86, 0x80, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, + 0x86, 0x90, 0xa7, 0x90, 0x92, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xe6, 0x22, 0x40, 0x4a, 0x6a, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x00, 0x00, 0x75, 0xad, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xbb, 0xde, 0x31, 0x8c, 0xb2, 0x94, 0x35, 0xad, 0xb6, 0xb5, 0x38, 0xc6, 0x79, 0xce, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 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, 0xdf, 0xff, 0x34, 0xa5, + 0x21, 0x20, 0x22, 0x38, 0x22, 0x40, 0x23, 0x48, 0x44, 0x58, 0x44, 0x60, 0x65, 0x68, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x80, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x87, 0x90, 0xa7, 0x90, 0xcc, 0x9a, + 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, 0x5d, 0xef, 0xa8, 0x69, 0x65, 0x68, 0x65, 0x70, 0x86, 0x80, 0x86, 0x80, + 0xa7, 0x90, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, + 0x32, 0xc4, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xb7, 0xc5, 0x65, 0x68, 0x65, 0x70, 0x65, 0x70, 0x86, 0x78, 0x65, 0x80, + 0xa7, 0x98, 0x01, 0x20, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x72, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0xe6, 0x23, 0x48, 0x23, 0x48, 0x7e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x93, 0x65, 0x68, 0x75, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xd6, 0x44, 0x58, + 0x65, 0x68, 0x65, 0x70, 0x86, 0x80, 0x86, 0x80, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x59, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb7, 0xcd, 0x65, 0x70, + 0x65, 0x70, 0x45, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x28, 0x65, 0x80, 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, + 0xa7, 0x98, 0x87, 0x90, 0x93, 0xbc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xe6, 0x23, 0x48, 0x23, 0x48, 0x7e, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x73, 0x00, 0x00, 0x75, 0xad, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdb, 0xde, 0x30, 0x84, 0xb3, 0x9c, 0x34, 0xa5, 0xb7, 0xbd, 0x18, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xdb, 0xde, 0xba, 0xd6, 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, + 0x59, 0xce, 0x22, 0x30, 0x02, 0x38, 0x23, 0x48, 0x23, 0x50, 0x44, 0x60, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xcd, 0xa2, + 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, 0x1c, 0xef, 0x49, 0x72, 0x44, 0x68, 0x44, 0x68, 0x65, 0x78, 0x65, 0x80, 0x86, 0x88, + 0x86, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xa8, 0xa8, 0xf1, 0xc3, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x18, 0xce, 0x45, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, + 0x86, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x30, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x1c, 0xe7, 0x22, 0x40, 0x23, 0x48, 0xb2, 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x45, 0x68, 0x44, 0x60, 0x76, 0xbd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x44, 0x58, + 0x44, 0x60, 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x90, 0x10, 0xac, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xf7, 0x06, 0x71, 0x65, 0x70, + 0x44, 0x68, 0x64, 0x68, 0x44, 0x60, 0x44, 0x68, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x86, 0x80, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0x87, 0x90, + 0x86, 0x90, 0xa7, 0x90, 0x51, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x22, 0x40, 0x23, 0x48, 0xb2, 0xa4, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x00, 0x00, 0x00, 0x00, 0x76, 0xb5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x9a, 0xd6, 0x30, 0x84, 0xb2, 0x94, 0x35, 0xad, 0x96, 0xb5, 0x18, 0xc6, 0x79, 0xce, 0xdb, 0xde, + 0xfb, 0xde, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 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, 0x96, 0xb5, 0x23, 0x40, 0x23, 0x48, 0x44, 0x58, 0x44, 0x60, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0x90, 0xa7, 0x98, 0xcc, 0xa2, + 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, 0xdf, 0xff, + 0xd7, 0xc5, 0x05, 0x61, 0x65, 0x68, 0x65, 0x70, 0x65, 0x78, 0x65, 0x80, 0x86, 0x88, 0x86, 0x90, + 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xb0, 0xc3, 0xbf, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x59, 0xd6, 0x65, 0x70, 0x65, 0x78, 0x65, 0x70, 0x86, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, + 0x43, 0x48, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x10, 0x84, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x3c, 0xe7, 0x23, 0x48, 0x23, 0x48, 0x43, 0x50, 0x92, 0xa4, 0x5d, 0xf7, 0xff, 0xff, + 0xbf, 0xff, 0xd7, 0xc5, 0x26, 0x71, 0x44, 0x68, 0x65, 0x68, 0xb6, 0xc5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x44, 0x58, + 0x65, 0x68, 0x65, 0x70, 0x86, 0x78, 0x66, 0x80, 0x86, 0x88, 0x47, 0x89, 0x7e, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd0, 0x9b, 0x65, 0x70, 0x44, 0x68, + 0x65, 0x68, 0x44, 0x60, 0x65, 0x68, 0x44, 0x60, 0x64, 0x68, 0x44, 0x60, 0x44, 0x60, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x10, 0x65, 0x80, 0x86, 0x80, 0x86, 0x80, 0x87, 0x90, 0x86, 0x88, + 0xa7, 0x90, 0x86, 0x90, 0x31, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0xef, 0x23, 0x40, 0x22, 0x40, 0x44, 0x50, 0x92, 0x9c, + 0x5d, 0xef, 0xff, 0xff, 0xbf, 0xff, 0xd7, 0xbd, 0x04, 0x21, 0x00, 0x00, 0x01, 0x00, 0xb6, 0xb5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x9a, 0xd6, 0x30, 0x84, 0xb3, 0x9c, 0x34, 0xa5, 0xb7, 0xbd, 0x18, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xdb, 0xde, 0xba, 0xd6, 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, 0xcb, 0x6a, 0x23, 0x48, 0x23, 0x58, 0x44, 0x68, 0x44, 0x70, 0x66, 0x78, + 0x66, 0x80, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xcc, 0xa2, + 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, 0x5d, 0xef, 0x96, 0xbd, 0x4a, 0x72, + 0x44, 0x60, 0x65, 0x68, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, + 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xa8, 0xa8, 0x8f, 0xbb, 0xbe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xde, + 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, 0xa7, 0xa0, + 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x6d, 0x6b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7d, 0xf7, 0x22, 0x40, 0x23, 0x48, 0x23, 0x48, 0x44, 0x58, 0x23, 0x58, 0x44, 0x60, + 0x44, 0x60, 0x45, 0x68, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0xf8, 0xcd, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd7, 0xbd, 0x44, 0x58, + 0x44, 0x60, 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, 0x66, 0x80, 0xd7, 0xd5, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x18, 0xce, 0x65, 0x70, 0x44, 0x60, 0x44, 0x68, + 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x23, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, + 0x86, 0x88, 0x87, 0x90, 0x6e, 0xa3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xef, 0x22, 0x40, 0x23, 0x48, 0x23, 0x48, 0x23, 0x48, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xc5, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x38, 0xc6, 0x31, 0x8c, 0xb2, 0x94, 0x34, 0xa5, 0x96, 0xb5, 0x18, 0xc6, 0x79, 0xce, 0xdb, 0xde, + 0xfc, 0xe6, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x5a, 0x75, 0xad, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7a, 0xd6, 0x23, 0x48, 0x44, 0x60, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xcc, 0xa2, + 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, 0x9e, 0xf7, + 0x5d, 0xef, 0xbb, 0xde, 0x18, 0xce, 0xd3, 0xac, 0xcc, 0x7a, 0x44, 0x60, 0x64, 0x68, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x70, 0x86, 0x78, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, + 0xc8, 0xa0, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0x6f, 0xbb, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xde, 0xa5, 0x70, + 0x65, 0x78, 0x65, 0x70, 0x86, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x64, 0x60, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0xab, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9e, 0xf7, 0x23, 0x48, 0x23, 0x48, 0x44, 0x50, 0x23, 0x58, 0x44, 0x60, 0x44, 0x60, + 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x44, 0x68, 0x65, 0x68, 0x39, 0xd6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, 0xbd, 0x43, 0x58, + 0x65, 0x68, 0x45, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0xbe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0xe9, 0x79, 0x44, 0x68, 0x64, 0x68, 0x44, 0x60, + 0x44, 0x60, 0x44, 0x58, 0x44, 0x60, 0x44, 0x58, 0x44, 0x60, 0x44, 0x58, 0x44, 0x58, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x68, 0x66, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, + 0x87, 0x90, 0x86, 0x88, 0xcc, 0x9a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x23, 0x48, 0x23, 0x48, 0x43, 0x50, 0x23, 0x50, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x39, 0xce, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x18, 0xc6, 0x30, 0x84, 0xb3, 0x9c, 0x34, 0xa5, 0xb7, 0xbd, 0x18, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0c, 0x63, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2d, 0x7b, 0x23, 0x58, 0x44, 0x68, 0x65, 0x70, 0x86, 0x80, + 0x86, 0x80, 0x86, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0x87, 0x90, 0xcd, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x22, 0x40, 0x23, 0x48, + 0x23, 0x48, 0x44, 0x58, 0x23, 0x58, 0x44, 0x60, 0x44, 0x60, 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, + 0x65, 0x70, 0x86, 0x78, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x98, 0xa8, 0xa0, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xa8, 0xa8, 0x2e, 0xbb, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xa5, 0x70, 0x65, 0x78, + 0x65, 0x70, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x90, 0xa7, 0xa8, 0x21, 0x10, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe3, 0x18, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x23, 0x50, 0x23, 0x48, 0x23, 0x50, 0x44, 0x58, 0x44, 0x60, 0x44, 0x68, + 0x44, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x44, 0x68, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd3, 0xa4, 0x44, 0x58, + 0x44, 0x60, 0x65, 0x68, 0x65, 0x70, 0x66, 0x78, 0x65, 0x78, 0xbf, 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, 0x18, 0xce, 0x65, 0x78, 0x65, 0x80, 0x86, 0x88, + 0x86, 0x80, 0x86, 0x88, 0x07, 0x89, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x22, 0x40, 0x23, 0x48, 0x23, 0x50, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbb, 0xde, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x96, 0xb5, 0x51, 0x8c, 0xb2, 0x94, 0x35, 0xad, 0xb6, 0xb5, 0x38, 0xc6, 0x79, 0xce, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x8e, 0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x44, 0x60, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x50, 0x23, 0x50, + 0x44, 0x58, 0x44, 0x60, 0x65, 0x68, 0x45, 0x68, 0x65, 0x70, 0x65, 0x70, 0x86, 0x78, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x80, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa8, 0xa0, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xa8, 0x0e, 0xbb, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xa5, 0x70, 0x65, 0x78, 0x65, 0x70, + 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0xa7, 0x90, 0x86, 0x90, 0x85, 0x70, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0x23, 0x50, 0x44, 0x58, 0x44, 0x58, 0x45, 0x68, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x1c, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x93, 0x44, 0x58, + 0x64, 0x68, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0xbe, 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, 0x39, 0xd6, 0x65, 0x70, 0x86, 0x80, 0x86, 0x80, + 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x9e, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x6a, 0x23, 0x48, 0x44, 0x58, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x1c, 0xe7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x14, 0xa5, 0x51, 0x8c, 0xd3, 0x9c, 0x55, 0xad, 0xd7, 0xbd, 0x18, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x45, 0x29, 0x04, 0x21, 0x65, 0x29, 0x41, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xb6, 0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x83, 0x45, 0x68, 0x65, 0x70, 0x86, 0x80, + 0x66, 0x80, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xcd, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x50, 0x44, 0x60, + 0x44, 0x60, 0x65, 0x68, 0x44, 0x70, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x65, 0x80, 0x86, 0x88, + 0x86, 0x88, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xa8, 0xa8, 0xcd, 0xb2, 0x7d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xa5, 0x70, 0x65, 0x70, 0x44, 0x70, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x80, 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa8, 0xa8, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xef, 0x7b, 0x23, 0x48, 0x23, 0x50, 0x44, 0x60, 0x44, 0x60, 0x65, 0x68, + 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x45, 0x70, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x6a, 0x6a, 0x44, 0x58, + 0x44, 0x60, 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x65, 0x78, 0xbf, 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, 0x18, 0xce, 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, + 0x66, 0x80, 0x86, 0x88, 0x65, 0x80, 0x3c, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x8b, 0x23, 0x50, 0x23, 0x50, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0xf7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x51, 0x8c, 0x51, 0x8c, 0xd3, 0x9c, 0x55, 0xad, 0xb6, 0xb5, 0x39, 0xce, 0x79, 0xce, 0xdb, 0xde, + 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0x9a, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0x39, 0xe8, 0x41, 0x08, 0x42, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x86, 0x31, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xde, 0x44, 0x68, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x30, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, + 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, + 0xad, 0xba, 0x7d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xa5, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, + 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x98, 0x22, 0x20, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x59, 0xce, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x00, 0x00, 0x44, 0x60, 0x44, 0x60, 0x65, 0x68, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x65, 0x70, 0x4b, 0x82, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbe, 0xf7, 0x44, 0x58, 0x44, 0x58, + 0x65, 0x68, 0x65, 0x70, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0xbe, 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, 0x39, 0xd6, 0x65, 0x70, 0x86, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x80, 0x86, 0x88, 0x59, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xb5, 0x23, 0x50, 0x44, 0x58, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x49, 0x4a, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbf, 0xff, + 0x10, 0x84, 0x71, 0x8c, 0xf4, 0xa4, 0x55, 0xad, 0xd7, 0xbd, 0x39, 0xce, 0x9a, 0xd6, 0xdb, 0xde, + 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x49, 0x4a, 0x49, 0x4a, 0x8a, 0x52, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x8b, 0x45, 0x70, 0x65, 0x78, + 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xcd, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x86, 0x80, + 0x65, 0x78, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xa8, 0xa8, 0x8c, 0xb2, + 0x5d, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7a, 0xde, 0xa5, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x45, 0x70, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, 0x87, 0x90, 0x86, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x75, 0xad, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x00, 0x00, 0x00, 0x00, 0x44, 0x68, 0x44, 0x60, 0x65, 0x68, + 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x92, 0xac, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x23, 0x50, 0x44, 0x60, + 0x44, 0x60, 0x65, 0x70, 0x65, 0x70, 0x66, 0x80, 0x65, 0x78, 0xbf, 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, 0x18, 0xce, 0x65, 0x68, 0x65, 0x70, 0x66, 0x80, + 0x65, 0x78, 0x86, 0x80, 0x66, 0x80, 0x76, 0xc5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, 0x43, 0x50, 0x23, 0x50, 0x44, 0x60, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x94, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3d, 0xef, + 0x10, 0x84, 0x92, 0x94, 0xf3, 0x9c, 0x76, 0xb5, 0xd7, 0xbd, 0x59, 0xce, 0x9a, 0xd6, 0xfc, 0xe6, + 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0xfc, 0xe6, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xab, 0x5a, 0xcb, 0x5a, 0x0c, 0x63, 0x04, 0x21, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x86, 0x31, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0x87, 0x90, 0xa7, 0x98, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x60, + 0x86, 0x80, 0x86, 0x88, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, 0x6c, 0xb2, 0x5d, 0xf7, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x9a, 0xde, 0xa5, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x68, 0x44, 0x68, 0x65, 0x70, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x80, 0x87, 0x88, 0xa7, 0x98, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0xae, 0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x22, 0x30, 0x65, 0x70, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x70, 0x65, 0x78, 0x65, 0x70, 0x39, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf7, 0xc5, 0x44, 0x58, 0x44, 0x60, + 0x65, 0x68, 0x65, 0x70, 0x86, 0x78, 0x66, 0x80, 0x86, 0x80, 0xbe, 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, 0x39, 0xd6, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0xaf, 0xa3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x23, 0x50, 0x44, 0x58, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x39, 0xce, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xce, + 0x31, 0x8c, 0x92, 0x94, 0x14, 0xa5, 0x96, 0xb5, 0x18, 0xc6, 0x59, 0xce, 0xbb, 0xde, 0xfb, 0xde, + 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x0c, 0x63, 0x0c, 0x63, 0x6e, 0x73, 0xe3, 0x18, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xb5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x8b, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0x87, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x90, 0xcc, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x18, + 0x87, 0x98, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0x2b, 0xb2, 0x3c, 0xef, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, + 0x85, 0x60, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x44, 0x60, 0x65, 0x68, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x80, 0x86, 0x90, 0x21, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x82, 0x10, 0xbe, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x22, 0x48, 0x65, 0x70, + 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, 0x87, 0x79, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x72, 0x9c, 0x23, 0x58, 0x44, 0x68, + 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, 0x86, 0x80, 0x66, 0x80, 0xbf, 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, 0x38, 0xce, 0x65, 0x68, 0x65, 0x70, 0x65, 0x78, + 0x65, 0x80, 0x86, 0x80, 0x65, 0x80, 0xc6, 0x80, 0xbf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x9c, 0x23, 0x50, 0x44, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x29, 0x9e, 0xf7, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x75, 0xad, + 0x31, 0x8c, 0xb3, 0x9c, 0x14, 0xa5, 0xb6, 0xb5, 0xf7, 0xbd, 0x79, 0xce, 0xba, 0xd6, 0xfc, 0xe6, + 0x3c, 0xe7, 0x7e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3c, 0xe7, + 0x1c, 0xe7, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x4d, 0x6b, 0x8e, 0x73, 0xaf, 0x7b, 0x08, 0x42, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x08, 0x42, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7a, 0xde, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x65, 0x70, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0x0b, 0xba, 0x3c, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xa5, 0x60, + 0x44, 0x60, 0x44, 0x58, 0x44, 0x60, 0x44, 0x58, 0x45, 0x68, 0x44, 0x68, 0x65, 0x70, 0x65, 0x70, + 0x86, 0x80, 0x86, 0x88, 0x43, 0x38, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x50, + 0x65, 0x70, 0x65, 0x70, 0x65, 0x70, 0x76, 0xbd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x46, 0x61, 0x44, 0x60, 0x44, 0x68, + 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0xbf, 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, 0x39, 0xce, 0x45, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x80, 0xbb, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x44, 0x58, 0x23, 0x50, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x75, 0xad, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x84, + 0x72, 0x94, 0xd3, 0x9c, 0x55, 0xad, 0xb6, 0xb5, 0x39, 0xce, 0x7a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, + 0x5d, 0xef, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, + 0xfb, 0xde, 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x8e, 0x73, 0xae, 0x73, 0x10, 0x84, 0x6a, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc6, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0d, 0x8b, + 0x65, 0x70, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x90, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x08, 0xc8, 0xb0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb8, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xeb, 0xb1, 0x1c, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xde, 0xc5, 0x60, 0x44, 0x58, + 0x23, 0x50, 0x43, 0x58, 0x23, 0x50, 0x44, 0x58, 0x43, 0x58, 0x44, 0x60, 0x44, 0x68, 0x65, 0x70, + 0x65, 0x80, 0x43, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xb2, 0x94, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x23, 0x50, 0x65, 0x70, 0xcf, 0x9b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79, 0xd6, 0x44, 0x58, 0x44, 0x60, 0x65, 0x70, + 0x65, 0x70, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, + 0x86, 0x80, 0x86, 0x80, 0x65, 0x78, 0x65, 0x78, 0x44, 0x70, 0x65, 0x68, 0x44, 0x68, 0x44, 0x60, + 0x44, 0x58, 0x44, 0x58, 0x23, 0x58, 0x44, 0x58, 0x23, 0x48, 0x23, 0x48, 0x01, 0x28, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, + 0x65, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0xb3, 0xb4, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb6, 0xbd, 0x22, 0x38, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcf, 0x7b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdb, 0xde, 0x30, 0x84, + 0x71, 0x8c, 0xf4, 0xa4, 0x55, 0xad, 0xd7, 0xbd, 0x38, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, + 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xff, 0xff, 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3d, 0xef, + 0x1c, 0xe7, 0xba, 0xd6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x7b, 0x10, 0x84, 0x31, 0x8c, 0x31, 0x8c, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x8a, 0x52, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xd6, + 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0x87, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x21, 0x08, 0xc9, 0xb8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xd8, 0xdd, 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, + 0xcf, 0x7b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x25, 0x29, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xd6, 0xf0, 0x83, 0xc7, 0x39, + 0x4d, 0x6b, 0xb6, 0xbd, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0x9c, 0x44, 0x60, 0x65, 0x68, 0x65, 0x70, + 0x86, 0x78, 0x86, 0x80, 0x87, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x90, + 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x66, 0x80, 0x86, 0x78, 0x65, 0x70, 0x65, 0x78, 0x65, 0x70, + 0x65, 0x68, 0x44, 0x68, 0x65, 0x68, 0x44, 0x60, 0x44, 0x60, 0x23, 0x50, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x80, 0x86, 0x80, 0x86, 0x80, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x88, 0x48, 0x91, 0x9e, 0xf7, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9a, 0xd6, + 0xf0, 0x83, 0xc7, 0x39, 0x4d, 0x6b, 0xb6, 0xb5, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x51, 0x8c, + 0xb3, 0x9c, 0x14, 0xa5, 0x96, 0xb5, 0xf7, 0xbd, 0x59, 0xce, 0x9a, 0xd6, 0xfc, 0xe6, 0x3c, 0xe7, + 0x7d, 0xef, 0x7e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x5d, 0xef, + 0xfb, 0xde, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x10, 0x84, 0x30, 0x84, 0x92, 0x94, 0xb2, 0x94, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xc6, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xec, 0x8a, 0x65, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x64, 0x60, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0x18, 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, + 0xcf, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0xbd, 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, 0x3d, 0xef, 0x44, 0x58, 0x44, 0x68, 0x44, 0x68, 0x65, 0x78, + 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x98, + 0x86, 0x90, 0x87, 0x90, 0x86, 0x88, 0x86, 0x88, 0x66, 0x80, 0x86, 0x80, 0x65, 0x78, 0x65, 0x78, + 0x65, 0x70, 0x65, 0x70, 0x44, 0x68, 0x65, 0x70, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x80, 0x65, 0x78, 0x86, 0x88, + 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0xb7, 0xcd, 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, 0x5d, 0xef, 0x10, 0x84, 0x72, 0x94, + 0xd3, 0x9c, 0x55, 0xad, 0x96, 0xb5, 0x18, 0xc6, 0x59, 0xce, 0xbb, 0xde, 0xfb, 0xde, 0x3d, 0xef, + 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, 0x3d, 0xef, + 0x1c, 0xe7, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0x8c, 0x72, 0x94, 0xb3, 0x9c, 0xf4, 0xa4, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0c, 0x63, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7a, 0xde, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xa0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0x18, 0xde, 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, + 0xcf, 0x7b, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x86, 0x31, 0xbf, 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, 0x31, 0x9c, 0x45, 0x68, 0x44, 0x68, 0x65, 0x78, 0x65, 0x78, + 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x86, 0x80, + 0x86, 0x80, 0x66, 0x80, 0x86, 0x80, 0x65, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x50, 0x86, 0x88, 0x86, 0x88, + 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0xa9, 0x91, 0xbf, 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, 0x55, 0xad, 0x51, 0x8c, 0x92, 0x94, + 0x14, 0xa5, 0x75, 0xad, 0xd7, 0xbd, 0x38, 0xc6, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, + 0x7e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x5d, 0xef, + 0x1c, 0xe7, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x72, 0x94, 0xb2, 0x94, 0xf4, 0xa4, 0x34, 0xa5, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9a, 0xd6, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x0d, 0x93, 0x65, 0x78, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x88, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0x18, 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, + 0xcf, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x92, 0x94, 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, 0x7a, 0xd6, 0x44, 0x60, 0x44, 0x60, 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, + 0x86, 0x88, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xa8, 0xa0, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x90, 0x87, 0x90, + 0x86, 0x88, 0xa7, 0x90, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x88, 0xa7, 0x90, + 0x86, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0xb3, 0xbc, 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, 0xdb, 0xde, 0x10, 0x84, 0x71, 0x8c, 0xd3, 0x9c, + 0x34, 0xa5, 0x96, 0xb5, 0xf7, 0xbd, 0x59, 0xce, 0x9a, 0xd6, 0xfb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, + 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, + 0x3d, 0xef, 0xdb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xb2, 0x94, 0xf4, 0xa4, 0x34, 0xa5, 0x76, 0xb5, 0xef, 0x7b, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x6e, 0x73, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x59, 0xd6, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x87, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x85, 0x68, 0x0a, 0xd1, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0x18, 0xde, 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, + 0xcf, 0x7b, 0x00, 0x00, 0x21, 0x20, 0x42, 0x30, 0x64, 0x58, 0x85, 0x70, 0xa6, 0x80, 0x86, 0x80, + 0xa7, 0x90, 0x86, 0x78, 0x86, 0x80, 0x64, 0x58, 0x43, 0x38, 0x38, 0xc6, 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, 0x5d, 0xef, 0x09, 0x72, 0x44, 0x68, 0x65, 0x70, 0x65, 0x78, 0x86, 0x80, 0x86, 0x88, + 0xa7, 0x90, 0xa7, 0x90, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, + 0xa8, 0xa0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xa8, 0xa8, 0xa7, 0x90, + 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x90, 0xa7, 0x90, 0x39, 0xde, + 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, 0x9e, 0xf7, 0x51, 0x8c, 0x51, 0x8c, 0xb3, 0x9c, 0x14, 0xa5, + 0x76, 0xb5, 0xd7, 0xbd, 0x39, 0xce, 0x7a, 0xd6, 0xdb, 0xde, 0xfc, 0xe6, 0x5d, 0xef, 0x7d, 0xef, + 0x9e, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x7d, 0xef, 0x5d, 0xef, + 0x1c, 0xe7, 0xfc, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf4, 0xa4, 0x14, 0xa5, 0x75, 0xad, 0x96, 0xb5, 0xd7, 0xbd, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xbb, 0xde, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xec, 0x92, 0x86, 0x80, 0x66, 0x80, 0x86, 0x88, 0x86, 0x88, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, 0x18, 0xde, 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, + 0xcf, 0x9b, 0xa8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x98, 0xe7, 0x98, 0x7a, 0xde, 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, + 0x7d, 0xef, 0xcb, 0x6a, 0x44, 0x70, 0x65, 0x70, 0x65, 0x70, 0x86, 0x80, 0x66, 0x80, 0x86, 0x90, + 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0x64, 0x58, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x70, 0xa7, 0x98, + 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0xc7, 0x90, + 0x9a, 0xde, 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, 0x9e, 0xf7, 0xb2, 0x94, 0x31, 0x8c, 0x92, 0x94, 0xd3, 0x9c, 0x55, 0xad, + 0x96, 0xb5, 0xf8, 0xc5, 0x59, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, + 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0x9e, 0xf7, 0x5d, 0xef, + 0x5d, 0xef, 0xfc, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x34, 0xa5, 0x76, 0xb5, 0x96, 0xb5, 0xd7, 0xbd, 0xf8, 0xc5, + 0x82, 0x10, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0xf0, 0x83, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7a, 0xde, 0x86, 0x80, 0x87, 0x88, 0x86, 0x88, 0xa7, 0x90, 0xcc, 0x9a, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7e, 0xf7, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x86, 0x70, 0xea, 0xd8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0x18, 0xde, 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, + 0xf0, 0xb3, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, + 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0x90, 0xd7, 0xcd, + 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, 0xfb, 0xde, + 0x6a, 0x52, 0x00, 0x00, 0x00, 0x00, 0x21, 0x28, 0x65, 0x70, 0x87, 0x90, 0xa7, 0x98, 0x87, 0x90, + 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc9, 0xc0, 0xc8, 0xb0, 0x43, 0x38, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x43, 0x40, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa8, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x90, + 0xa7, 0x90, 0xd7, 0xcd, 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, 0x3c, 0xe7, 0x92, 0x94, 0x51, 0x8c, 0x92, 0x94, 0xd3, 0x9c, 0x35, 0xad, 0x96, 0xb5, + 0xf8, 0xc5, 0x38, 0xc6, 0x9a, 0xd6, 0xbb, 0xde, 0x1c, 0xe7, 0x3d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, + 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x9e, 0xf7, 0x7e, 0xf7, + 0x3c, 0xe7, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x76, 0xb5, 0x96, 0xb5, 0xd7, 0xbd, 0xf8, 0xc5, 0x39, 0xce, + 0x4d, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xed, 0x9a, 0x86, 0x88, 0x86, 0x90, 0x86, 0x88, 0xcd, 0xa2, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x85, 0x70, 0xea, 0xd0, 0xe9, 0xc8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0x19, 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, + 0xd0, 0xab, 0xa7, 0x90, 0x87, 0x90, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0x87, 0x90, + 0xaf, 0xa3, 0xfc, 0xe6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0xf7, 0x14, 0xa5, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x21, 0x18, 0x44, 0x50, + 0x86, 0x88, 0xc8, 0xa8, 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc8, 0xc9, 0xb8, 0xe9, 0xb8, + 0xc7, 0xa0, 0xa6, 0x80, 0x22, 0x28, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x59, 0xce, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb0, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, 0xa7, 0x98, + 0x86, 0x90, 0x86, 0x90, 0xaf, 0xa3, 0xfc, 0xee, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, + 0xf7, 0xbd, 0x31, 0x8c, 0x51, 0x8c, 0xb3, 0x9c, 0xd3, 0x9c, 0x34, 0xa5, 0x75, 0xad, 0xd7, 0xbd, + 0x18, 0xc6, 0x79, 0xce, 0x9a, 0xd6, 0xfc, 0xe6, 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, + 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0x7e, 0xf7, + 0x7d, 0xef, 0x3c, 0xe7, 0xfc, 0xe6, 0xbb, 0xde, 0x9a, 0xd6, 0x38, 0xc6, 0x18, 0xc6, 0xd7, 0xbd, + 0xb7, 0xbd, 0x96, 0xb5, 0xb7, 0xbd, 0xb7, 0xbd, 0xf8, 0xc5, 0x18, 0xc6, 0x59, 0xce, 0x79, 0xce, + 0x9a, 0xd6, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x64, 0x60, 0x87, 0x90, 0x87, 0x90, 0x86, 0x88, 0x86, 0x88, 0x86, 0x80, + 0x86, 0x88, 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0xa0, + 0x22, 0x28, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x43, 0x38, 0x86, 0x78, 0xe9, 0xb8, 0xea, 0xc8, + 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, + 0xa7, 0x98, 0x65, 0x70, 0x43, 0x48, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x21, 0x20, 0x65, 0x78, 0x65, 0x70, 0x65, 0x70, 0x86, 0x78, 0x65, 0x78, 0x86, 0x88, 0x86, 0x88, + 0xa7, 0x90, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xa8, 0xa0, 0xa7, 0x90, + 0xa7, 0x90, 0x86, 0x88, 0x6e, 0xa3, 0xb7, 0xcd, 0xfb, 0xe6, 0x7e, 0xf7, 0xdf, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x9e, 0xf7, 0x3d, 0xef, 0x18, 0xc6, 0x51, 0x8c, 0x61, 0x08, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x10, 0x00, 0x08, 0x21, 0x18, 0x00, 0x18, 0x21, 0x10, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x65, 0x68, + 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, + 0xa7, 0xa0, 0xa7, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x4e, 0x8b, 0x96, 0xb5, 0xdb, 0xde, 0x7e, 0xf7, + 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x3c, 0xe7, 0x18, 0xc6, 0xb3, 0x9c, 0x51, 0x8c, + 0x72, 0x94, 0x92, 0x94, 0xd3, 0x9c, 0xf4, 0xa4, 0x55, 0xad, 0x76, 0xb5, 0xd7, 0xbd, 0x18, 0xc6, + 0x59, 0xce, 0x9a, 0xd6, 0xdb, 0xde, 0x1c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, 0xbe, 0xf7, + 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, + 0x5d, 0xef, 0x5d, 0xef, 0x1c, 0xe7, 0xfb, 0xde, 0x9a, 0xd6, 0x7a, 0xd6, 0x38, 0xc6, 0x18, 0xc6, + 0xf7, 0xbd, 0xf8, 0xc5, 0xf7, 0xbd, 0x18, 0xc6, 0x18, 0xc6, 0x59, 0xce, 0x79, 0xce, 0xba, 0xd6, + 0xba, 0xd6, 0xe8, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0x98, 0x86, 0x90, 0x87, 0x90, 0x86, 0x88, 0x86, 0x88, + 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0xa0, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, + 0x01, 0x20, 0x43, 0x38, 0x43, 0x40, 0x43, 0x48, 0x43, 0x40, 0x43, 0x40, 0x21, 0x28, 0x01, 0x18, + 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x68, + 0x65, 0x78, 0x65, 0x78, 0x65, 0x78, 0x66, 0x78, 0x65, 0x78, 0x86, 0x80, 0x86, 0x80, 0x86, 0x90, + 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0x98, 0xa7, 0x98, + 0x87, 0x90, 0xa7, 0x90, 0x86, 0x88, 0x86, 0x88, 0x65, 0x78, 0x66, 0x78, 0x65, 0x70, 0x65, 0x70, + 0x65, 0x78, 0x22, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x28, + 0xc9, 0xc0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa0, 0xa7, 0x98, 0x86, 0x90, 0xa7, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb2, 0x94, 0xd3, 0x9c, + 0xd3, 0x9c, 0x14, 0xa5, 0x14, 0xa5, 0x75, 0xad, 0x96, 0xb5, 0xd7, 0xbd, 0x18, 0xc6, 0x59, 0xce, + 0x9a, 0xd6, 0xdb, 0xde, 0xfb, 0xde, 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, + 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, + 0x9e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, 0xfc, 0xe6, 0xdb, 0xde, 0x9a, 0xd6, 0x9a, 0xd6, 0x59, 0xce, + 0x59, 0xce, 0x39, 0xce, 0x59, 0xce, 0x59, 0xce, 0x7a, 0xd6, 0x7a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, + 0xfc, 0xe6, 0xfb, 0xde, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x43, 0x48, 0xc8, 0xa8, 0xa7, 0x98, 0xa7, 0x98, 0x87, 0x90, + 0xa7, 0x98, 0x87, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0x43, 0x40, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x08, 0x01, 0x18, 0x86, 0x80, 0x65, 0x78, + 0x86, 0x80, 0x66, 0x80, 0x86, 0x80, 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, + 0xa7, 0x98, 0xa7, 0x98, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, + 0xa8, 0xa0, 0xa7, 0x98, 0xa7, 0x90, 0x86, 0x88, 0x87, 0x88, 0x86, 0x80, 0x86, 0x80, 0x65, 0x78, + 0x86, 0x80, 0x65, 0x80, 0x65, 0x68, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xa7, 0x90, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xb0, 0x23, 0x48, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x86, 0x31, 0x34, 0xa5, 0x34, 0xa5, + 0x55, 0xad, 0x55, 0xad, 0x96, 0xb5, 0xb7, 0xbd, 0xf8, 0xc5, 0x18, 0xc6, 0x7a, 0xd6, 0x9a, 0xd6, + 0xdb, 0xde, 0xfc, 0xe6, 0x3d, 0xef, 0x5d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbf, 0xff, + 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, + 0x7d, 0xef, 0x7e, 0xf7, 0x3d, 0xef, 0x3d, 0xef, 0xfb, 0xde, 0xdb, 0xde, 0xba, 0xd6, 0x9a, 0xd6, + 0x79, 0xce, 0x9a, 0xd6, 0x79, 0xce, 0x9a, 0xd6, 0x9a, 0xd6, 0xdb, 0xde, 0xdb, 0xde, 0x1c, 0xe7, + 0x1c, 0xe7, 0x3d, 0xef, 0xc6, 0x31, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x88, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa8, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x48, 0x86, 0x90, 0x66, 0x80, 0x86, 0x88, + 0x86, 0x80, 0x86, 0x88, 0x86, 0x88, 0x87, 0x90, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa8, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0x86, 0x90, 0x86, 0x90, 0x86, 0x88, 0x86, 0x88, + 0x86, 0x80, 0x86, 0x88, 0x86, 0x80, 0x86, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x18, 0xea, 0xd0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xa8, 0xa8, 0xc8, 0xa8, 0x86, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0xad, 0x76, 0xb5, 0x96, 0xb5, + 0xb6, 0xb5, 0xd7, 0xbd, 0xf7, 0xbd, 0x18, 0xc6, 0x38, 0xc6, 0x7a, 0xd6, 0x9a, 0xd6, 0xdb, 0xde, + 0xfb, 0xde, 0x3c, 0xe7, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, + 0xdf, 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, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, + 0xbf, 0xff, 0x7e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0xfc, 0xe6, 0xdb, 0xde, + 0xdb, 0xde, 0xbb, 0xde, 0xdb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0x1c, 0xe7, 0x3c, 0xe7, + 0x5d, 0xef, 0x5d, 0xef, 0x1c, 0xe7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xc8, 0xb0, 0xc8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0x43, 0x40, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x50, 0xa7, 0x98, 0x86, 0x88, 0xa7, 0x90, 0x86, 0x90, + 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0xa7, 0x90, 0xa7, 0x98, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xa8, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0x87, 0x90, + 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x90, 0x86, 0x90, 0xa7, 0x98, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x86, 0x78, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xa8, 0xa0, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x8a, 0x52, 0xf7, 0xbd, 0xf8, 0xc5, 0xf8, 0xc5, + 0x18, 0xc6, 0x38, 0xc6, 0x59, 0xce, 0x79, 0xce, 0x9a, 0xd6, 0xba, 0xd6, 0xfc, 0xe6, 0x1c, 0xe7, + 0x3d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xbe, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x3d, 0xef, 0x1c, 0xe7, 0x1c, 0xe7, + 0xfb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3d, 0xef, 0x3c, 0xe7, 0x5d, 0xef, + 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x0c, 0x63, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x22, 0x28, 0xc8, 0xb8, 0xc8, 0xa8, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xa7, 0x98, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x44, 0x58, 0xa8, 0xa0, 0x87, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa7, 0x98, + 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0x98, 0xa7, 0xa0, 0xa7, 0x98, 0xa8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa8, + 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, 0xa7, 0xa0, 0xa7, 0x98, 0xa7, 0x98, + 0x87, 0x98, 0xa7, 0x98, 0x87, 0x90, 0xa7, 0x98, 0x87, 0x98, 0xa8, 0xa0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb8, 0x21, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xc6, 0x59, 0xce, 0x59, 0xce, 0x59, 0xce, + 0x59, 0xce, 0x9a, 0xd6, 0x9a, 0xd6, 0xbb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0x1c, 0xe7, 0x3d, 0xef, + 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 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, 0xdf, 0xff, + 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x5d, 0xef, 0x5d, 0xef, 0x3d, 0xef, + 0x3d, 0xef, 0x3c, 0xe7, 0x3d, 0xef, 0x3c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, + 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0x01, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x44, 0x50, 0xc9, 0xc0, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xe9, 0xc0, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x43, 0x48, 0xc8, 0xb0, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xc8, 0xa8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, + 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, + 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa0, 0xa7, 0xa0, 0xc8, 0xa0, 0xa8, 0xa0, 0xc8, 0xa0, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x42, 0x28, 0x85, 0x70, 0xc9, 0xb8, 0xc8, 0xb0, 0xe8, 0xb0, 0xc8, 0xb0, + 0xc9, 0xb0, 0xa8, 0xa0, 0x43, 0x48, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xb8, 0xea, 0xd0, 0xc9, 0xb8, 0xe9, 0xb8, 0xe9, 0xc0, + 0x22, 0x28, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x51, 0x8c, 0xbb, 0xde, 0x9a, 0xd6, 0xbb, 0xde, 0xba, 0xd6, + 0xdb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, 0xfb, 0xde, 0x1c, 0xe7, 0x3c, 0xe7, 0x5d, 0xef, 0x5d, 0xef, + 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 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, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0x7d, 0xef, 0x7e, 0xf7, + 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x7d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, + 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xbf, 0xff, 0xb6, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x43, 0x50, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xc8, 0xa0, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0xc8, 0xb0, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xc9, 0xb8, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc8, 0xa8, 0xa8, 0xa8, 0xc8, 0xa8, + 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0xa8, 0xc8, 0xa8, 0xa7, 0xa0, 0xc8, 0xa8, 0xc8, 0xb0, 0xa7, 0x90, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x43, 0x50, 0xc9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc9, 0xc0, 0xc9, 0xb8, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x70, 0xc7, 0xa0, 0xa6, 0x90, 0x21, 0x18, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x8a, 0x52, 0xfc, 0xe6, 0xdb, 0xde, 0xfb, 0xde, 0xdb, 0xde, 0xfc, 0xe6, + 0xfb, 0xde, 0x1c, 0xe7, 0x1c, 0xe7, 0x3d, 0xef, 0x3c, 0xe7, 0x5d, 0xef, 0x7d, 0xef, 0x9e, 0xf7, + 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xbf, 0xff, 0x9e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, + 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, + 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0x4d, 0x6b, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x43, 0x50, 0x43, 0x48, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xc8, 0xa8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, + 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc8, 0xa8, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc9, 0xc0, + 0x64, 0x58, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x64, 0x58, 0xe9, 0xc0, + 0x0a, 0xd1, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0x0a, 0xd1, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xdb, 0xde, 0x3c, 0xe7, 0x3d, 0xef, 0x3c, 0xe7, 0x3d, 0xef, 0x3c, 0xe7, + 0x5d, 0xef, 0x3d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x7e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, + 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbe, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xbe, 0xf7, + 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, + 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xa6, 0x31, 0x21, 0x08, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x85, 0x78, + 0xc8, 0xb8, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc8, 0xb0, 0xc9, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc8, 0xb0, 0xc9, 0xb8, 0xc8, 0xb0, 0xc8, 0xb0, + 0xc9, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb0, 0xe9, 0xd0, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xea, 0xd0, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xb6, 0xb5, 0x5d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x5d, 0xef, 0x7d, 0xef, + 0x5d, 0xef, 0x7e, 0xf7, 0x7d, 0xef, 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xbf, 0xff, + 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, + 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x5d, 0xef, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x23, 0x40, 0xc8, 0x98, 0xc8, 0xa8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xb0, 0xa7, 0x98, 0x85, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, + 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, + 0xe9, 0xc0, 0xa7, 0x90, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x64, 0x58, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc8, 0xa7, 0x88, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x31, 0x8c, 0x9e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x7e, 0xf7, 0x9e, 0xf7, 0x9e, 0xf7, + 0x9e, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0xbe, 0xf7, 0xbf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9a, 0xd6, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x23, 0x38, 0xc8, 0xb0, 0x0a, 0xd1, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc8, 0xea, 0xd0, 0xa7, 0x98, 0x43, 0x48, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x88, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc8, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, + 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xb8, 0xc8, 0xb8, 0xe9, 0xc0, + 0xc8, 0xb8, 0xea, 0xc8, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa7, 0x98, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc8, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x2c, 0x63, + 0xbe, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbe, 0xf7, 0x9e, 0xf7, 0xbf, 0xff, + 0x9e, 0xf7, 0xbf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xbe, 0xf7, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 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, 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, 0xdf, 0xff, + 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xcf, 0x7b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, + 0xe9, 0xc0, 0x44, 0x60, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xea, 0xc8, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xb8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xa7, 0x90, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x18, 0xe9, 0xb8, 0x0a, 0xc9, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x65, 0x60, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xdf, 0xff, + 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, 0xdf, 0xff, 0xbf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xdf, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x96, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xea, 0xd0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x0a, 0xd9, 0xc8, 0xa8, 0x22, 0x20, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x65, 0x60, 0xe9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, 0xc9, 0xb8, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x22, 0x30, + 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x8a, 0x52, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, + 0xdf, 0xff, 0xdf, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xff, 0xff, 0xff, + 0xfc, 0xe6, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x85, 0x78, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xe1, 0xa6, 0x80, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x21, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x44, 0x50, 0x0a, 0xd9, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x92, 0x94, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x0a, 0xd9, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x21, 0x28, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xc9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc8, 0xa0, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x64, 0x50, 0x0a, 0xe1, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, + 0x64, 0x60, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd7, 0xbd, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff, 0xff, 0xdf, 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, 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, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x8a, 0x52, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x42, 0x18, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x2b, 0xe9, 0x84, 0x60, + 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x64, 0x58, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x85, 0x70, 0x0a, 0xd9, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xe8, 0xa8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x1c, 0xe7, 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, 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, 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, 0x14, 0xa5, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0xa6, 0x88, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, + 0x86, 0x78, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa7, 0x98, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x65, 0x60, 0xea, 0xd8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xfc, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd1, 0xa7, 0x98, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe9, 0xb8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x42, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x43, 0x40, 0x0a, 0xd1, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0b, 0xd9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x55, 0xad, 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, 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, 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xd8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xb0, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x63, 0x48, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x43, 0x38, 0xea, 0xd8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x39, 0xce, 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, 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, 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, 0x55, 0xad, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xd9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xa6, 0x80, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x43, 0x38, 0x0a, 0xd1, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xc9, 0x42, 0x28, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x79, 0xce, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x41, 0x10, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xc8, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x86, 0x78, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x42, 0x20, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0xae, 0x73, 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, 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, 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, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x41, 0x10, 0x0a, 0xd1, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0xc9, 0xb8, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xa6, 0x80, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0x64, 0x58, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x7a, 0xd6, 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, 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, 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, 0x55, 0xad, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x41, 0x08, 0xe9, 0xc8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xb8, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x86, 0x78, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xa0, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x84, 0x58, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xfc, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xc8, 0xa0, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x64, 0x50, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x42, 0x20, 0x0a, 0xd9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xa6, 0x80, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x75, 0xad, 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, 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, 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, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, + 0x85, 0x78, 0x00, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x22, 0x18, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0x85, 0x58, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdb, 0xde, 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, 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, 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, 0x18, 0xc6, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xc9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc8, 0xa8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0x41, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xa6, 0x80, 0xea, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0x64, 0x58, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xd8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x64, 0x58, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0xe9, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x63, 0x38, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x59, 0xce, 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, 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, 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, 0xa6, 0x31, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe9, 0xb8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xd0, 0x64, 0x50, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x40, 0x00, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xc8, 0xa8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xc9, 0x42, 0x28, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x7e, 0xf7, 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, 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, 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, 0xd7, 0xbd, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x86, 0x80, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0x65, 0x60, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x1c, 0xe7, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x63, 0x38, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x63, 0x48, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xa7, 0x90, 0x0a, 0xc9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xc8, 0xa8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0xcf, 0x7b, 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, 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, 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, 0x7d, 0xef, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x0a, 0xd1, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xea, 0xd8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x59, 0xce, 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, 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, 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, 0xdf, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xea, 0xd0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x64, 0x48, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xe9, 0xb0, 0xe9, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xd0, 0x42, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x85, 0x68, 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, + 0xc7, 0x98, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0xe7, 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, 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, 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, 0xcb, 0x5a, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x85, 0x70, + 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x21, 0x10, 0x0a, 0xc9, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xb8, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, + 0x43, 0x38, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xbf, 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, 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, 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, 0x18, 0xc6, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x21, 0x00, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x08, 0xc8, 0xa8, + 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x63, 0x38, 0xea, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0xa3, 0x18, 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, 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, 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, 0x5d, 0xef, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xa7, 0x98, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, + 0xa6, 0x88, 0x00, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x85, 0x70, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xb8, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x38, 0xc6, 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, 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, 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, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x85, 0x70, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x64, 0x50, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x0b, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x43, 0x38, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x5d, 0xef, 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, 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, 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, 0x35, 0xad, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0x20, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0xa7, 0x90, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xd0, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x18, + 0xea, 0xd0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 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, + 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, + 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, 0x7d, 0xef, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x01, 0x08, 0xa7, 0x90, 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x85, 0x68, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xc8, 0xb0, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, 0x21, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x85, 0x68, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0x85, 0x70, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc6, + 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, + 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, + 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, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xc8, 0xa8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xea, 0xd0, 0x44, 0x50, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xe9, 0xb0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xea, 0xd0, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x9e, 0xf7, + 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, + 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, + 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, + 0x9e, 0xf7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0xc7, 0x98, 0xea, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc8, 0xa0, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x0a, 0xd9, 0x42, 0x18, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xe1, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x43, 0x38, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xcf, 0x7b, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xea, 0xd0, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0xa6, 0x80, 0xe9, 0xd0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x18, 0x0a, 0xd9, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9e, 0xf7, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0x7e, 0xf7, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x43, 0x48, 0x0a, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0x41, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x84, 0x50, 0xea, 0xd0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0xc8, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x62, 0x28, 0x0a, 0xd1, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xe8, 0x41, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0x90, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x85, 0x60, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, + 0xa7, 0xa0, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd9, + 0x63, 0x40, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x43, 0x40, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdf, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x64, 0x58, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x20, 0x00, 0x22, 0x38, 0xe9, 0xc0, 0x0a, 0xd9, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0x0a, 0xd9, 0x85, 0x70, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x86, 0x70, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xd0, 0x64, 0x50, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xd3, 0x9c, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2d, 0x6b, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xa7, 0x88, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x23, 0x40, 0xa7, 0x98, 0x0a, 0xd9, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd8, 0xea, 0xc8, 0x64, 0x60, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x85, 0x68, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc8, 0xc7, 0x98, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x18, 0xea, 0xc8, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xa6, 0x88, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x18, 0x85, 0x68, 0xc7, 0x98, + 0x0a, 0xd1, 0x0a, 0xd9, 0x0a, 0xc9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0x0a, 0xd1, + 0x0a, 0xc9, 0xa6, 0x88, 0x22, 0x38, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xc7, 0x90, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, + 0xc8, 0xa8, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xef, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5d, 0xef, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x42, 0x28, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x85, 0x60, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x18, 0x43, 0x50, 0x85, 0x70, 0xa7, 0x90, 0xa7, 0x98, 0xe9, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, + 0xe9, 0xc8, 0xea, 0xd0, 0xe9, 0xb8, 0xe9, 0xb0, 0xa7, 0x98, 0x86, 0x78, 0x63, 0x50, 0x22, 0x38, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x85, 0x70, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xb0, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x92, 0x94, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x71, 0x94, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x22, 0x28, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0x43, 0x40, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xa6, 0x70, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0xc8, 0xa8, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa6, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x10, 0xc8, 0xb8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0x42, 0x18, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x43, 0x40, 0xea, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0xc7, 0x98, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0xbf, 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, 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, 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, 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, 0x24, 0x21, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc7, 0xa0, 0x0b, 0xd9, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0b, 0xe1, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x20, 0x0a, 0xd1, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd9, 0xa7, 0x88, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x3d, 0xef, 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, 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, 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, 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, 0xbf, 0xff, + 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x68, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xc8, 0xa8, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x0a, 0xd1, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0x44, 0x50, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdb, 0xde, + 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, + 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, + 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, + 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, + 0xbf, 0xff, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x20, 0x00, 0xe9, 0xb8, 0xea, 0xd0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xc8, 0x43, 0x38, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x86, 0x78, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0xc8, 0xa8, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x9a, 0xd6, 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, 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, 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, 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, 0x3d, 0xef, 0x80, 0x08, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x43, 0x48, + 0xc8, 0xb8, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xc8, 0xb0, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xea, 0xd8, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xd0, 0x0a, 0xd1, + 0x43, 0x48, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x7a, 0xd6, 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, 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, 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, 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, 0x29, 0x4a, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x43, 0x38, 0xe9, 0xc0, 0x0a, 0xd1, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0x20, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x43, 0x38, 0x0a, 0xd9, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xc8, 0xa7, 0x88, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xbb, 0xde, 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, 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, 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, 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, 0x0c, 0x63, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa7, 0xa0, 0xe9, 0xc8, 0xe9, 0xc8, 0x0a, 0xd1, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc8, 0xea, 0xd0, 0xe9, 0xc8, 0xa7, 0x98, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x42, 0x28, 0xe9, 0xc8, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, 0x64, 0x60, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x21, 0x00, 0xa6, 0x31, 0xdb, 0xde, 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, 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, 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, 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, 0xb3, 0x9c, 0x00, 0x00, 0x20, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x65, 0x60, + 0xc8, 0xa8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xc9, 0xe9, 0xc0, 0x0a, 0xc9, 0xe9, 0xc8, + 0xc8, 0xa0, 0x64, 0x58, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x22, 0x28, 0x22, 0x40, + 0x85, 0x68, 0x86, 0x80, 0xa7, 0x90, 0xc8, 0xa0, 0x0a, 0xc9, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc0, + 0x0a, 0xc9, 0xea, 0xd0, 0x0a, 0xd1, 0xea, 0xc8, 0x0a, 0xc9, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xb8, + 0xc8, 0xa8, 0xa7, 0x90, 0xa6, 0x80, 0x64, 0x58, 0x22, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x86, 0x88, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd1, 0xea, 0xc8, + 0x0a, 0xc9, 0xe9, 0xc0, 0x0a, 0xc9, 0xe9, 0xc8, 0x0a, 0xc9, 0xe9, 0xc8, 0x0a, 0xd1, 0xe9, 0xc8, + 0x0a, 0xd1, 0xa6, 0x88, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0xcb, 0x5a, 0xbf, 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, 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, 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, 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, 0xfb, 0xde, 0x82, 0x10, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x38, 0x86, 0x78, 0xa6, 0x88, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xd9, + 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd9, 0xea, 0xd8, 0x0a, 0xd1, 0xe8, 0xb8, 0x86, 0x78, + 0x43, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x42, 0x30, 0xa7, 0x90, + 0xa7, 0x90, 0xc9, 0xb0, 0xc8, 0xa8, 0xc8, 0xb0, 0x86, 0x88, 0x85, 0x68, 0x42, 0x38, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf4, 0xa4, 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, 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, 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, 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, + 0x4d, 0x6b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x28, 0x64, 0x50, + 0xc7, 0x90, 0xea, 0xc8, 0x0b, 0xe1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd9, 0xea, 0xd0, 0xe9, 0xb0, 0x64, 0x60, 0x21, 0x20, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x29, 0x4a, 0x1c, 0xe7, + 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, + 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, + 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, + 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, + 0xff, 0xff, 0xfc, 0xe6, 0xa6, 0x31, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x40, 0xc8, 0xb0, 0xea, 0xd8, 0x0a, 0xd1, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0xc7, 0x98, 0x42, 0x38, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x10, 0xf4, 0xa4, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0xc5, 0x66, 0x31, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x00, 0x00, 0x08, 0xa6, 0x78, 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd9, 0xc8, 0xb0, + 0x21, 0x18, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xec, 0x62, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x39, 0xce, 0x49, 0x4a, 0xa3, 0x18, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x43, 0x48, 0x0a, 0xe1, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0x0a, 0xd9, 0x64, 0x50, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x25, 0x29, 0x10, 0x84, 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, 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, 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, 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, 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, 0xdf, 0xff, + 0xc1, 0x10, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xb8, + 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xc8, 0x86, 0x78, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x41, 0x08, 0x1c, 0xe7, + 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, + 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, + 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, + 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, + 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, 0x55, 0xad, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xd0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 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, 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, 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, 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, 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, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc8, 0xb8, 0x0a, 0xc9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xc9, 0xa7, 0x98, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x76, 0xb5, 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, 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, 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, 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, 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, 0xcb, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 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, 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, 0x59, 0xce, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x41, 0x00, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x64, 0x58, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x92, 0x94, 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, 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, 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, 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, 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, 0xbe, 0xf7, 0x29, 0x4a, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x0a, 0xd1, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xbe, 0xf7, 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, 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, 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, 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, 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, + 0x1c, 0xe7, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0xc8, 0xa8, 0x0a, 0xc9, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xea, 0xd0, 0x85, 0x68, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0xf4, 0xa4, 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, 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, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xf3, 0x9c, 0x00, 0x00, 0x20, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe9, 0xc8, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc0, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x42, 0x9e, 0xf7, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xf7, 0xaf, 0x7b, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x42, 0x20, 0xea, 0xd0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xc9, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x1c, 0xe7, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1c, 0xe7, 0x8a, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x63, 0x40, + 0xea, 0xd8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xea, 0xc8, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xd7, 0xbd, 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, 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, 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, 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, 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, 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, 0xdb, 0xde, + 0xcb, 0x5a, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x08, + 0x63, 0x48, 0xea, 0xd0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0xc6, + 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, + 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, + 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, + 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, + 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, + 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, 0xdb, 0xde, 0x0c, 0x63, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x22, 0x28, 0xe9, 0xd0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0x31, 0x59, 0xce, 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, 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, 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, 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, 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, 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, 0x9e, 0xf7, 0xf4, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x08, 0x20, 0x00, 0xc8, 0xb0, 0x0a, 0xd1, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0x0a, 0xd1, 0xa7, 0x90, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x8c, 0xbb, 0xde, 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, 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, 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, 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, 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, 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, 0x18, 0xc6, 0x4d, 0x6b, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x80, 0x0a, 0xd9, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x64, 0x58, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x49, 0x4a, + 0x75, 0xad, 0x5d, 0xef, 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, 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, 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, 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, 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, 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, + 0xdf, 0xff, 0x24, 0x21, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x08, 0x21, 0x10, 0xe9, 0xc0, 0xea, 0xd0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0x0a, 0xd1, 0xc7, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x39, 0xce, 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, 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, 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, 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, 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, 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, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x65, 0x29, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x85, 0x60, + 0xe9, 0xc0, 0xea, 0xd0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, + 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc8, 0xe9, 0xc0, + 0x21, 0x18, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xdb, 0xde, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8a, 0x52, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x86, 0x80, 0x0a, 0xc9, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0x0a, 0xd1, 0xe9, 0xc0, 0x42, 0x28, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x7e, 0xf7, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xae, 0x73, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x64, 0x50, 0xc8, 0xb8, 0x0a, 0xd1, 0xe9, 0xc8, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc0, 0xe9, 0xc8, + 0xe9, 0xc0, 0xea, 0xc8, 0xea, 0xd0, 0xe9, 0xb8, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x66, 0x31, 0x5d, 0xef, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x55, 0xad, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa6, 0x78, 0xe9, 0xb8, + 0x0b, 0xd9, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc8, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, + 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc0, 0xea, 0xc8, 0xe9, 0xc8, 0x0a, 0xc9, 0xea, 0xd0, + 0xe9, 0xc0, 0x63, 0x48, 0x40, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x4d, 0x6b, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xba, 0xd6, 0x25, 0x29, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x41, 0x00, 0xa7, 0x90, 0xe9, 0xb8, 0xc9, 0xb8, 0x0a, 0xd1, 0xea, 0xd0, 0x0a, 0xd1, + 0xea, 0xd0, 0x0a, 0xd9, 0xe9, 0xc8, 0xe9, 0xc0, 0xa7, 0xa0, 0x86, 0x78, 0x20, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x75, 0xad, 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, 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, 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, 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, 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, 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, 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, + 0xcc, 0x62, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x86, 0x31, 0xfb, 0xde, + 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, + 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, + 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, + 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, + 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, + 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, + 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, 0xfc, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0xf3, 0x9c, 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, 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, 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, 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, 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, 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, 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, 0xf3, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x25, 0x29, 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, 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, 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, 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, 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, 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, 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, 0x31, 0x8c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, + 0x00, 0x00, 0x66, 0x31, 0x7d, 0xef, 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, 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, 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, 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, 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, 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, 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, 0x75, 0xad, + 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x45, 0x29, + 0x9e, 0xf7, 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, 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, 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, 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, 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, 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, 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, + 0xdf, 0xff, 0x9e, 0xf7, 0x4d, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x39, 0xdb, 0xde, 0xdf, 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, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9e, 0xf7, 0xf3, 0x9c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, + 0x21, 0x08, 0x00, 0x00, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xf3, 0x9c, 0x9e, 0xf7, 0x9e, 0xf7, 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, 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, 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, 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, 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, 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, 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, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, + 0x7e, 0xf7, 0x7d, 0xef, 0xd7, 0xbd, 0x14, 0xa5, 0x51, 0x8c, 0x4d, 0x6b, 0x6a, 0x4a, 0xa6, 0x31, + 0x8a, 0x52, 0x4d, 0x6b, 0x51, 0x8c, 0xd3, 0x9c, 0xf8, 0xc5, 0x7d, 0xef, 0x7d, 0xef, 0xbf, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, + +}; diff --git a/pio/st7789_lcd/st7789_lcd.c b/pio/st7789_lcd/st7789_lcd.c new file mode 100644 index 0000000..f191557 --- /dev/null +++ b/pio/st7789_lcd/st7789_lcd.c @@ -0,0 +1,148 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/gpio.h" +#include "hardware/interp.h" + +#include "st7789_lcd.pio.h" +#include "raspberry_256x256_rgb565.h" + +#define SCREEN_WIDTH 240 +#define SCREEN_HEIGHT 240 +#define IMAGE_SIZE 256 +#define LOG_IMAGE_SIZE 8 + +#define PIN_DIN 0 +#define PIN_CLK 1 +#define PIN_CS 2 +#define PIN_DC 3 +#define PIN_RESET 4 +#define PIN_BL 5 + +#define SERIAL_CLK_DIV 1.f + +// Format: cmd length (including cmd byte), post delay in units of 5 ms, then cmd payload +// Note the delays have been shortened a little +static const uint8_t st7789_init_seq[] = { + 1, 20, 0x01, // Software reset + 1, 10, 0x11, // Exit sleep mode + 2, 2, 0x3a, 0x55, // Set colour mode to 16 bit + 2, 0, 0x36, 0x00, // Set MADCTL: row then column, refresh is bottom to top ???? + 5, 0, 0x2a, 0x00, 0x00, 0x00, 0xf0, // CASET: column addresses from 0 to 240 (f0) + 5, 0, 0x2b, 0x00, 0x00, 0x00, 0xf0, // RASET: row addresses from 0 to 240 (f0) + 1, 2, 0x21, // Inversion on, then 10 ms delay (supposedly a hack?) + 1, 2, 0x13, // Normal display on, then 10 ms delay + 1, 2, 0x29, // Main screen turn on, then wait 500 ms + 0 // Terminate list +}; + +static inline void lcd_set_dc_cs(bool dc, bool cs) { + sleep_us(1); + gpio_put_masked((1u << PIN_DC) | (1u << PIN_CS), !!dc << PIN_DC | !!cs << PIN_CS); + sleep_us(1); +} + +static inline void lcd_write_cmd(PIO pio, uint sm, const uint8_t *cmd, size_t count) { + st7789_lcd_wait_idle(pio, sm); + lcd_set_dc_cs(0, 0); + st7789_lcd_put(pio, sm, *cmd++); + if (count >= 2) { + st7789_lcd_wait_idle(pio, sm); + lcd_set_dc_cs(1, 0); + for (size_t i = 0; i < count - 1; ++i) + st7789_lcd_put(pio, sm, *cmd++); + } + st7789_lcd_wait_idle(pio, sm); + lcd_set_dc_cs(1, 1); +} + +static inline void lcd_init(PIO pio, uint sm, const uint8_t *init_seq) { + const uint8_t *cmd = init_seq; + while (*cmd) { + lcd_write_cmd(pio, sm, cmd + 2, *cmd); + sleep_ms(*(cmd + 1) * 5); + cmd += *cmd + 2; + } +} + +static inline void st7789_start_pixels(PIO pio, uint sm) { + uint8_t cmd = 0x2c; // RAMWR + lcd_write_cmd(pio, sm, &cmd, 1); + lcd_set_dc_cs(1, 0); +} + +int main() { + stdio_init_all(); + + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &st7789_lcd_program); + st7789_lcd_program_init(pio, sm, offset, PIN_DIN, PIN_CLK, SERIAL_CLK_DIV); + + gpio_init(PIN_CS); + gpio_init(PIN_DC); + gpio_init(PIN_RESET); + gpio_init(PIN_BL); + gpio_set_dir(PIN_CS, GPIO_OUT); + gpio_set_dir(PIN_DC, GPIO_OUT); + gpio_set_dir(PIN_RESET, GPIO_OUT); + gpio_set_dir(PIN_BL, GPIO_OUT); + + gpio_put(PIN_CS, 1); + gpio_put(PIN_RESET, 1); + lcd_init(pio, sm, st7789_init_seq); + gpio_put(PIN_BL, 1); + + // Other SDKs: static image on screen, lame, boring + // Pico SDK: spinning image on screen, bold, exciting + + // Lane 0 will be u coords (bits 8:1 of addr offset), lane 1 will be v + // coords (bits 16:9 of addr offset), and we'll represent coords with + // 16.16 fixed point. ACCUM0,1 will contain current coord, BASE0/1 will + // contain increment vector, and BASE2 will contain image base pointer +#define UNIT_LSB 16 + interp_config lane0_cfg = interp_default_config(); + interp_config_set_shift(&lane0_cfg, UNIT_LSB - 1); // -1 because 2 bytes per pixel + interp_config_set_mask(&lane0_cfg, 1, 1 + (LOG_IMAGE_SIZE - 1)); + interp_config_set_add_raw(&lane0_cfg, true); // Add full accumulator to base with each POP + interp_config lane1_cfg = interp_default_config(); + interp_config_set_shift(&lane1_cfg, UNIT_LSB - (1 + LOG_IMAGE_SIZE)); + interp_config_set_mask(&lane1_cfg, 1 + LOG_IMAGE_SIZE, 1 + (2 * LOG_IMAGE_SIZE - 1)); + interp_config_set_add_raw(&lane1_cfg, true); + + interp_set_config(interp0, 0, &lane0_cfg); + interp_set_config(interp0, 1, &lane1_cfg); + interp0->base[2] = (uint32_t) raspberry_256x256; + + float theta = 0.f; + float theta_max = 2.f * (float) M_PI; + while (1) { + theta += 0.02f; + if (theta > theta_max) + theta -= theta_max; + int32_t rotate[4] = { + cosf(theta) * (1 << UNIT_LSB), -sinf(theta) * (1 << UNIT_LSB), + sinf(theta) * (1 << UNIT_LSB), cosf(theta) * (1 << UNIT_LSB) + }; + interp0->base[0] = rotate[0]; + interp0->base[1] = rotate[2]; + st7789_start_pixels(pio, sm); + for (int y = 0; y < SCREEN_HEIGHT; ++y) { + interp0->accum[0] = rotate[1] * y; + interp0->accum[1] = rotate[3] * y; + for (int x = 0; x < SCREEN_WIDTH; ++x) { + uint16_t colour = *(uint16_t *) (interp0->pop[2]); + st7789_lcd_put(pio, sm, colour >> 8); + st7789_lcd_put(pio, sm, colour & 0xff); + } + } + } +} diff --git a/pio/st7789_lcd/st7789_lcd.pio b/pio/st7789_lcd/st7789_lcd.pio new file mode 100644 index 0000000..aa35c68 --- /dev/null +++ b/pio/st7789_lcd/st7789_lcd.pio @@ -0,0 +1,57 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program st7789_lcd +.side_set 1 + +; This is just a simple clocked serial TX. At 125 MHz system clock we can +; sustain up to 62.5 Mbps. +; Data on OUT pin 0 +; Clock on side-set pin 0 + +.wrap_target + out pins, 1 side 0 ; stall here if no data (clock low) + nop side 1 +.wrap + +% c-sdk { +// For optimal use of DMA bandwidth we would use an autopull threshold of 32, +// but we are using a threshold of 8 here (consume 1 byte from each FIFO entry +// and discard the remainder) to make things easier for software on the other side + +static inline void st7789_lcd_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clk_pin, float clk_div) { + pio_gpio_init(pio, data_pin); + pio_gpio_init(pio, clk_pin); + pio_sm_set_consecutive_pindirs(pio, sm, data_pin, 1, true); + pio_sm_set_consecutive_pindirs(pio, sm, clk_pin, 1, true); + pio_sm_config c = st7789_lcd_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, clk_pin); + sm_config_set_out_pins(&c, data_pin, 1); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + sm_config_set_clkdiv(&c, clk_div); + sm_config_set_out_shift(&c, false, true, 8); + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + +// Making use of the narrow store replication behaviour on RP2040 to get the +// data left-justified (as we are using shift-to-left to get MSB-first serial) + +static inline void st7789_lcd_put(PIO pio, uint sm, uint8_t x) { + while (pio_sm_is_tx_fifo_full(pio, sm)) + ; + *(volatile uint8_t*)&pio->txf[sm] = x; +} + +// SM is done when it stalls on an empty FIFO + +static inline void st7789_lcd_wait_idle(PIO pio, uint sm) { + uint32_t sm_stall_mask = 1u << (sm + PIO_FDEBUG_TXSTALL_LSB); + pio->fdebug = sm_stall_mask; + while (!(pio->fdebug & sm_stall_mask)) + ; +} +%} diff --git a/pio/uart_rx/CMakeLists.txt b/pio/uart_rx/CMakeLists.txt new file mode 100644 index 0000000..c2adc6e --- /dev/null +++ b/pio/uart_rx/CMakeLists.txt @@ -0,0 +1,16 @@ +add_executable(pio_uart_rx) + +pico_generate_pio_header(pio_uart_rx ${CMAKE_CURRENT_LIST_DIR}/uart_rx.pio) + +target_sources(pio_uart_rx PRIVATE uart_rx.c) + +target_link_libraries(pio_uart_rx PRIVATE + pico_stdlib + pico_multicore + hardware_pio + ) + +pico_add_extra_outputs(pio_uart_rx) + +# add url via pico_set_program_url +example_auto_set_url(pio_uart_rx) diff --git a/pio/uart_rx/uart_rx.c b/pio/uart_rx/uart_rx.c new file mode 100644 index 0000000..2b7722e --- /dev/null +++ b/pio/uart_rx/uart_rx.c @@ -0,0 +1,60 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "pico/multicore.h" +#include "hardware/pio.h" +#include "hardware/uart.h" +#include "uart_rx.pio.h" + +// This program +// - Uses UART1 (the spare UART, by default) to transmit some text +// - Uses a PIO state machine to receive that text +// - Prints out the received text to the default console (UART0) +// This might require some reconfiguration on boards where UART1 is the +// default UART. + +#define SERIAL_BAUD PICO_DEFAULT_UART_BAUD_RATE +#define HARD_UART_INST uart1 + +// You'll need a wire from GPIO4 -> GPIO3 +#define HARD_UART_TX_PIN 4 +#define PIO_RX_PIN 3 + +// Ask core 1 to print a string, to make things easier on core 0 +void core1_main() { + const char *s = (const char *) multicore_fifo_pop_blocking(); + uart_puts(HARD_UART_INST, s); +} + +int main() { + // Console output (also a UART, yes it's confusing) + setup_default_uart(); + printf("Starting PIO UART RX example\n"); + + // Set up the hard UART we're going to use to print characters + uart_init(HARD_UART_INST, SERIAL_BAUD); + gpio_set_function(HARD_UART_TX_PIN, GPIO_FUNC_UART); + + // Set up the state machine we're going to use to receive them. + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &uart_rx_program); + uart_rx_program_init(pio, sm, offset, PIO_RX_PIN, SERIAL_BAUD); + + // Tell core 1 to print some text to uart1 as fast as it can + multicore_launch_core1(core1_main); + const char *text = "Hello, world from PIO! (Plus 2 UARTs and 2 cores, for complex reasons)\n"; + multicore_fifo_push_blocking((uint32_t) text); + + // Echo characters received from PIO to the console + while (true) { + char c = uart_rx_program_getc(pio, sm); + putchar(c); + } +} diff --git a/pio/uart_rx/uart_rx.pio b/pio/uart_rx/uart_rx.pio new file mode 100644 index 0000000..2573bf7 --- /dev/null +++ b/pio/uart_rx/uart_rx.pio @@ -0,0 +1,94 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program uart_rx_mini + +; Minimum viable 8n1 UART receiver. Wait for the start bit, then sample 8 bits +; with the correct timing. +; IN pin 0 is mapped to the GPIO used as UART RX. +; Autopush must be enabled, with a threshold of 8. + + wait 0 pin 0 ; Wait for start bit + set x, 7 [10] ; Preload bit counter, delay until eye of first data bit +bitloop: ; Loop 8 times + in pins, 1 ; Sample data + jmp x-- bitloop [6] ; Each iteration is 8 cycles + +% c-sdk { +#include "hardware/clocks.h" +#include "hardware/gpio.h" + +static inline void uart_rx_mini_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) { + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); + pio_gpio_init(pio, pin); + gpio_pull_up(pin); + + pio_sm_config c = uart_rx_mini_program_get_default_config(offset); + sm_config_set_in_pins(&c, pin); // for WAIT, IN + // Shift to right, autopush enabled + sm_config_set_in_shift(&c, true, true, 8); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + // SM transmits 1 bit per 8 execution cycles. + float div = (float)clock_get_hz(clk_sys) / (8 * baud); + sm_config_set_clkdiv(&c, div); + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} + +.program uart_rx + +; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and +; break conditions more gracefully. +; IN pin 0 and JMP pin are both mapped to the GPIO used as UART RX. + +start: + wait 0 pin 0 ; Stall until start bit is asserted + set x, 7 [10] ; Preload bit counter, then delay until halfway through +bitloop: ; the first data bit (12 cycles incl wait, set). + in pins, 1 ; Shift data bit into ISR + jmp x-- bitloop [6] ; Loop 8 times, each loop iteration is 8 cycles + jmp pin good_stop ; Check stop bit (should be high) + + irq 4 rel ; Either a framing error or a break. Set a sticky flag, + wait 1 pin 0 ; and wait for line to return to idle state. + jmp start ; Don't push data if we didn't see good framing. + +good_stop: ; No delay before returning to start; a little slack is + push ; important in case the TX clock is slightly too fast. + + +% c-sdk { +static inline void uart_rx_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) { + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); + pio_gpio_init(pio, pin); + gpio_pull_up(pin); + + pio_sm_config c = uart_rx_program_get_default_config(offset); + sm_config_set_in_pins(&c, pin); // for WAIT, IN + sm_config_set_jmp_pin(&c, pin); // for JMP + // Shift to right, autopull disabled + sm_config_set_in_shift(&c, true, false, 32); + // Deeper FIFO as we're not doing any TX + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + // SM transmits 1 bit per 8 execution cycles. + float div = (float)clock_get_hz(clk_sys) / (8 * baud); + sm_config_set_clkdiv(&c, div); + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + +static inline char uart_rx_program_getc(PIO pio, uint sm) { + // 8-bit read from the uppermost byte of the FIFO, as data is left-justified + io_rw_8 *rxfifo_shift = (io_rw_8*)&pio->rxf[sm] + 3; + while (pio_sm_is_rx_fifo_empty(pio, sm)) + tight_loop_contents(); + return (char)*rxfifo_shift; +} + +%} diff --git a/pio/uart_tx/CMakeLists.txt b/pio/uart_tx/CMakeLists.txt new file mode 100644 index 0000000..5e3cf2a --- /dev/null +++ b/pio/uart_tx/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(pio_uart_tx) + +pico_generate_pio_header(pio_uart_tx ${CMAKE_CURRENT_LIST_DIR}/uart_tx.pio) + +target_sources(pio_uart_tx PRIVATE uart_tx.c) + +target_link_libraries(pio_uart_tx PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_uart_tx) + +# add url via pico_set_program_url +example_auto_set_url(pio_uart_tx) diff --git a/pio/uart_tx/uart_tx.c b/pio/uart_tx/uart_tx.c new file mode 100644 index 0000000..26266b9 --- /dev/null +++ b/pio/uart_tx/uart_tx.c @@ -0,0 +1,27 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "uart_tx.pio.h" + +int main() { + // We're going to use PIO to print "Hello, world!" on the same GPIO which we + // normally attach UART0 to. + const uint PIN_TX = 0; + // This is the same as the default UART baud rate on Pico + const uint SERIAL_BAUD = 115200; + + PIO pio = pio0; + uint sm = 0; + uint offset = pio_add_program(pio, &uart_tx_program); + uart_tx_program_init(pio, sm, offset, PIN_TX, SERIAL_BAUD); + + while (true) { + uart_tx_program_puts(pio, sm, "Hello, world! (from PIO!)\n"); + sleep_ms(1000); + } +} diff --git a/pio/uart_tx/uart_tx.pio b/pio/uart_tx/uart_tx.pio new file mode 100644 index 0000000..b1320f6 --- /dev/null +++ b/pio/uart_tx/uart_tx.pio @@ -0,0 +1,61 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program uart_tx +.side_set 1 opt + +; An 8n1 UART transmit program. +; OUT pin 0 and side-set pin 0 are both mapped to UART TX pin. + + pull side 1 [7] ; Assert stop bit, or stall with line in idle state + set x, 7 side 0 [7] ; Preload bit counter, assert start bit for 8 clocks +bitloop: ; This loop will run 8 times (8n1 UART) + out pins, 1 ; Shift 1 bit from OSR to the first OUT pin + jmp x-- bitloop [6] ; Each loop iteration is 8 cycles. + + +% c-sdk { +#include "hardware/clocks.h" + +static inline void uart_tx_program_init(PIO pio, uint sm, uint offset, uint pin_tx, uint baud) { + // Tell PIO to initially drive output-high on the selected pin, then map PIO + // onto that pin with the IO muxes. + pio_sm_set_pins_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx); + pio_sm_set_pindirs_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx); + pio_gpio_init(pio, pin_tx); + + pio_sm_config c = uart_tx_program_get_default_config(offset); + + // OUT shifts to right, no autopull + sm_config_set_out_shift(&c, true, false, 32); + + // We are mapping both OUT and side-set to the same pin, because sometimes + // we need to assert user data onto the pin (with OUT) and sometimes + // assert constant values (start/stop bit) + sm_config_set_out_pins(&c, pin_tx, 1); + sm_config_set_sideset_pins(&c, pin_tx); + + // We only need TX, so get an 8-deep FIFO! + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + + // SM transmits 1 bit per 8 execution cycles. + float div = (float)clock_get_hz(clk_sys) / (8 * baud); + sm_config_set_clkdiv(&c, div); + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + +static inline void uart_tx_program_putc(PIO pio, uint sm, char c) { + pio_sm_put_blocking(pio, sm, (uint32_t)c); +} + +static inline void uart_tx_program_puts(PIO pio, uint sm, const char *s) { + while (*s) + uart_tx_program_putc(pio, sm, *s++); +} + +%} diff --git a/pio/ws2812/CMakeLists.txt b/pio/ws2812/CMakeLists.txt new file mode 100644 index 0000000..f8cd57f --- /dev/null +++ b/pio/ws2812/CMakeLists.txt @@ -0,0 +1,35 @@ +add_executable(pio_ws2812) + +# generate the header file into the source tree as it is included in the RP2040 datasheet +pico_generate_pio_header(pio_ws2812 ${CMAKE_CURRENT_LIST_DIR}/ws2812.pio OUTPUT_DIR ${CMAKE_CURRENT_LIST_DIR}/generated) + +target_sources(pio_ws2812 PRIVATE ws2812.c) + +target_link_libraries(pio_ws2812 PRIVATE pico_stdlib hardware_pio) +pico_add_extra_outputs(pio_ws2812) + +# add url via pico_set_program_url +example_auto_set_url(pio_ws2812) + +add_executable(pio_ws2812_parallel) + +pico_generate_pio_header(pio_ws2812_parallel ${CMAKE_CURRENT_LIST_DIR}/ws2812.pio OUTPUT_DIR ${CMAKE_CURRENT_LIST_DIR}/generated) + +target_sources(pio_ws2812_parallel PRIVATE ws2812_parallel.c) + +target_compile_definitions(pio_ws2812_parallel PRIVATE + PIN_DBG1=3) + +target_link_libraries(pio_ws2812_parallel PRIVATE pico_stdlib hardware_pio hardware_dma) +pico_add_extra_outputs(pio_ws2812_parallel) + +# add url via pico_set_program_url +example_auto_set_url(pio_ws2812_parallel) + +# Additionally generate python and hex pioasm outputs for inclusion in the RP2040 datasheet +add_custom_target(pio_ws2812_datasheet DEPENDS Pioasm ${CMAKE_CURRENT_LIST_DIR}/generated/ws2812.py) +add_custom_command(OUTPUT ${CMAKE_CURRENT_LIST_DIR}/generated/ws2812.py + DEPENDS ${CMAKE_CURRENT_LIST_DIR}/ws2812.pio + COMMAND Pioasm -o python ${CMAKE_CURRENT_LIST_DIR}/ws2812.pio ${CMAKE_CURRENT_LIST_DIR}/generated/ws2812.py + ) +add_dependencies(pio_ws2812 pio_ws2812_datasheet) \ No newline at end of file diff --git a/pio/ws2812/generated/ws2812.pio.h b/pio/ws2812/generated/ws2812.pio.h new file mode 100644 index 0000000..ca40fc5 --- /dev/null +++ b/pio/ws2812/generated/ws2812.pio.h @@ -0,0 +1,112 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#if !PICO_NO_HARDWARE +#include "hardware/pio.h" +#endif + +// ------ // +// ws2812 // +// ------ // + +#define ws2812_wrap_target 0 +#define ws2812_wrap 3 + +#define ws2812_T1 2 +#define ws2812_T2 5 +#define ws2812_T3 3 + +static const uint16_t ws2812_program_instructions[] = { + // .wrap_target + 0x6221, // 0: out x, 1 side 0 [2] + 0x1123, // 1: jmp !x, 3 side 1 [1] + 0x1400, // 2: jmp 0 side 1 [4] + 0xa442, // 3: nop side 0 [4] + // .wrap +}; + +#if !PICO_NO_HARDWARE +static const struct pio_program ws2812_program = { + .instructions = ws2812_program_instructions, + .length = 4, + .origin = -1, +}; + +static inline pio_sm_config ws2812_program_get_default_config(uint offset) { + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_wrap(&c, offset + ws2812_wrap_target, offset + ws2812_wrap); + sm_config_set_sideset(&c, 1, false, false); + return c; +} + +#include "hardware/clocks.h" +static inline void ws2812_program_init(PIO pio, uint sm, uint offset, uint pin, float freq, bool rgbw) { + pio_gpio_init(pio, pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + pio_sm_config c = ws2812_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, pin); + sm_config_set_out_shift(&c, false, true, rgbw ? 32 : 24); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + int cycles_per_bit = ws2812_T1 + ws2812_T2 + ws2812_T3; + float div = clock_get_hz(clk_sys) / (freq * cycles_per_bit); + sm_config_set_clkdiv(&c, div); + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + +#endif + +// --------------- // +// ws2812_parallel // +// --------------- // + +#define ws2812_parallel_wrap_target 0 +#define ws2812_parallel_wrap 3 + +#define ws2812_parallel_T1 2 +#define ws2812_parallel_T2 5 +#define ws2812_parallel_T3 3 + +static const uint16_t ws2812_parallel_program_instructions[] = { + // .wrap_target + 0x6020, // 0: out x, 32 + 0xa10b, // 1: mov pins, !null [1] + 0xa401, // 2: mov pins, x [4] + 0xa103, // 3: mov pins, null [1] + // .wrap +}; + +#if !PICO_NO_HARDWARE +static const struct pio_program ws2812_parallel_program = { + .instructions = ws2812_parallel_program_instructions, + .length = 4, + .origin = -1, +}; + +static inline pio_sm_config ws2812_parallel_program_get_default_config(uint offset) { + pio_sm_config c = pio_get_default_sm_config(); + sm_config_set_wrap(&c, offset + ws2812_parallel_wrap_target, offset + ws2812_parallel_wrap); + return c; +} + +#include "hardware/clocks.h" +static inline void ws2812_parallel_program_init(PIO pio, uint sm, uint offset, uint pin_base, uint pin_count, float freq) { + for(uint i=pin_base; i +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/clocks.h" +#include "ws2812.pio.h" + +static inline void put_pixel(uint32_t pixel_grb) { + pio_sm_put_blocking(pio0, 0, pixel_grb << 8u); +} + +static inline uint32_t urgb_u32(uint8_t r, uint8_t g, uint8_t b) { + return + ((uint32_t) (r) << 8) | + ((uint32_t) (g) << 16) | + (uint32_t) (b); +} + +void pattern_snakes(uint len, uint t) { + for (uint i = 0; i < len; ++i) { + uint x = (i + (t >> 1)) % 64; + if (x < 10) + put_pixel(urgb_u32(0xff, 0, 0)); + else if (x >= 15 && x < 25) + put_pixel(urgb_u32(0, 0xff, 0)); + else if (x >= 30 && x < 40) + put_pixel(urgb_u32(0, 0, 0xff)); + else + put_pixel(0); + } +} + +void pattern_random(uint len, uint t) { + if (t % 8) + return; + for (int i = 0; i < len; ++i) + put_pixel(rand()); +} + +void pattern_sparkle(uint len, uint t) { + if (t % 8) + return; + for (int i = 0; i < len; ++i) + put_pixel(rand() % 16 ? 0 : 0xffffffff); +} + +void pattern_greys(uint len, uint t) { + int max = 100; // let's not draw too much current! + t %= max; + for (int i = 0; i < len; ++i) { + put_pixel(t * 0x10101); + if (++t >= max) t = 0; + } +} + +typedef void (*pattern)(uint len, uint t); +const struct { + pattern pat; + const char *name; +} pattern_table[] = { + {pattern_snakes, "Snakes!"}, + {pattern_random, "Random data"}, + {pattern_sparkle, "Sparkles"}, + {pattern_greys, "Greys"}, +}; + +const int PIN_TX = 0; + +int main() { + //set_sys_clock_48(); + stdio_init_all(); + puts("WS2812 Smoke Test"); + + // todo get free sm + PIO pio = pio0; + int sm = 0; + uint offset = pio_add_program(pio, &ws2812_program); + + ws2812_program_init(pio, sm, offset, PIN_TX, 800000, true); + + int t = 0; + while (1) { + int pat = rand() % count_of(pattern_table); + int dir = (rand() >> 30) & 1 ? 1 : -1; + puts(pattern_table[pat].name); + puts(dir == 1 ? "(forward)" : "(backward)"); + for (int i = 0; i < 1000; ++i) { + pattern_table[pat].pat(150, t); + sleep_ms(10); + t += dir; + } + } +} \ No newline at end of file diff --git a/pio/ws2812/ws2812.pio b/pio/ws2812/ws2812.pio new file mode 100644 index 0000000..3c31fd6 --- /dev/null +++ b/pio/ws2812/ws2812.pio @@ -0,0 +1,85 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program ws2812 +.side_set 1 + +.define public T1 2 +.define public T2 5 +.define public T3 3 + +.lang_opt python sideset_init = pico.PIO.OUT_HIGH +.lang_opt python out_init = pico.PIO.OUT_HIGH +.lang_opt python out_shiftdir = 1 + +.wrap_target +bitloop: + out x, 1 side 0 [T3 - 1] ; Side-set still takes place when instruction stalls + jmp !x do_zero side 1 [T1 - 1] ; Branch on the bit we shifted out. Positive pulse +do_one: + jmp bitloop side 1 [T2 - 1] ; Continue driving high, for a long pulse +do_zero: + nop side 0 [T2 - 1] ; Or drive low, for a short pulse +.wrap + +% c-sdk { +#include "hardware/clocks.h" + +static inline void ws2812_program_init(PIO pio, uint sm, uint offset, uint pin, float freq, bool rgbw) { + + pio_gpio_init(pio, pin); + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); + + pio_sm_config c = ws2812_program_get_default_config(offset); + sm_config_set_sideset_pins(&c, pin); + sm_config_set_out_shift(&c, false, true, rgbw ? 32 : 24); + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); + + int cycles_per_bit = ws2812_T1 + ws2812_T2 + ws2812_T3; + float div = clock_get_hz(clk_sys) / (freq * cycles_per_bit); + sm_config_set_clkdiv(&c, div); + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} + +.program ws2812_parallel + +.define public T1 2 +.define public T2 5 +.define public T3 3 + +.wrap_target + out x, 32 + mov pins, !null [T1-1] + mov pins, x [T2-1] + mov pins, null [T3-2] +.wrap + +% c-sdk { +#include "hardware/clocks.h" + +static inline void ws2812_parallel_program_init(PIO pio, uint sm, uint offset, uint pin_base, uint pin_count, float freq) { + for(uint i=pin_base; i +#include +#include + +#include "pico/stdlib.h" +#include "pico/sem.h" +#include "hardware/pio.h" +#include "hardware/dma.h" +#include "hardware/irq.h" +#include "ws2812.pio.h" + +#define FRAC_BITS 4 +#define PIN_TX 0 + +CU_REGISTER_DEBUG_PINS(timing) +CU_SELECT_DEBUG_PINS(timing) + +// horrible temporary hack to avoid changing pattern code +static uint8_t *current_string_out; +static bool current_string_4color; + +static inline void put_pixel(uint32_t pixel_grb) { + *current_string_out++ = pixel_grb & 0xffu; + *current_string_out++ = (pixel_grb >> 8u) & 0xffu; + *current_string_out++ = (pixel_grb >> 16u) & 0xffu; + if (current_string_4color) { + *current_string_out++ = 0; // todo adjust? + } +} + +static inline uint32_t urgb_u32(uint8_t r, uint8_t g, uint8_t b) { + return + ((uint32_t) (r) << 8) | + ((uint32_t) (g) << 16) | + (uint32_t) (b); +} + +void pattern_snakes(uint len, uint t) { + for (uint i = 0; i < len; ++i) { + uint x = (i + (t >> 1)) % 64; + if (x < 10) + put_pixel(urgb_u32(0xff, 0, 0)); + else if (x >= 15 && x < 25) + put_pixel(urgb_u32(0, 0xff, 0)); + else if (x >= 30 && x < 40) + put_pixel(urgb_u32(0, 0, 0xff)); + else + put_pixel(0); + } +} + +void pattern_random(uint len, uint t) { + if (t % 8) + return; + for (int i = 0; i < len; ++i) + put_pixel(rand()); +} + +void pattern_sparkle(uint len, uint t) { + if (t % 8) + return; + for (int i = 0; i < len; ++i) + put_pixel(rand() % 16 ? 0 : 0xffffffff); +} + +void pattern_greys(uint len, uint t) { + int max = 100; // let's not draw too much current! + t %= max; + for (int i = 0; i < len; ++i) { + put_pixel(t * 0x10101); + if (++t >= max) t = 0; + } +} + +void pattern_solid(uint len, uint t) { + t = 1; + for (int i = 0; i < len; ++i) { + put_pixel(t * 0x10101); + } +} + +int level = 8; + +void pattern_fade(uint len, uint t) { + uint shift = 4; + + uint max = 16; // let's not draw too much current! + max <<= shift; + + uint slow_t = t / 32; + slow_t = level; + slow_t %= max; + + static int error; + slow_t += error; + error = slow_t & ((1u << shift) - 1); + slow_t >>= shift; + slow_t *= 0x010101; + + for (int i = 0; i < len; ++i) { + put_pixel(slow_t); + } +} + +typedef void (*pattern)(uint len, uint t); +const struct { + pattern pat; + const char *name; +} pattern_table[] = { + {pattern_snakes, "Snakes!"}, + {pattern_random, "Random data"}, + {pattern_sparkle, "Sparkles"}, + {pattern_greys, "Greys"}, +// {pattern_solid, "Solid!"}, +// {pattern_fade, "Fade"}, +}; + +#define VALUE_PLANE_COUNT (8 + FRAC_BITS) +// we store value (8 bits + fractional bits of a single color (R/G/B/W) value) for multiple +// strings, in bit planes. bit plane N has the Nth bit of each string. +typedef struct { + // stored MSB first + uint32_t planes[VALUE_PLANE_COUNT]; +} value_bits_t; + +// Add FRAC_BITS planes of e to s and store in d +void add_error(value_bits_t *d, const value_bits_t *s, const value_bits_t *e) { + uint32_t carry_plane = 0; + // add the FRAC_BITS low planes + for (int p = VALUE_PLANE_COUNT - 1; p >= 8; p--) { + uint32_t e_plane = e->planes[p]; + uint32_t s_plane = s->planes[p]; + d->planes[p] = (e_plane ^ s_plane) ^ carry_plane; + carry_plane = (e_plane & s_plane) | (carry_plane & (s_plane ^ e_plane)); + } + // then just ripple carry through the non fractional bits + for (int p = 7; p >= 0; p--) { + uint32_t s_plane = s->planes[p]; + d->planes[p] = s_plane ^ carry_plane; + carry_plane &= s_plane; + } +} + +typedef struct { + uint8_t *data; + uint data_len; + uint frac_brightness; // 256 = *1.0; +} string_t; + +// takes 8 bit color values, multiply by brightness and store in bit planes +void transform_strings(string_t **strings, uint num_strings, value_bits_t *values, uint value_length, + uint frac_brightness) { + for (uint v = 0; v < value_length; v++) { + memset(&values[v], 0, sizeof(values[v])); + for (int i = 0; i < num_strings; i++) { + if (v < strings[i]->data_len) { + // todo clamp? + uint32_t value = (strings[i]->data[v] * strings[i]->frac_brightness) >> 8u; + value = (value * frac_brightness) >> 8u; + for (int j = 0; j < VALUE_PLANE_COUNT && value; j++, value >>= 1u) { + if (value & 1u) values[v].planes[VALUE_PLANE_COUNT - 1 - j] |= 1u << i; + } + } + } + } +} + +void dither_values(const value_bits_t *colors, value_bits_t *state, const value_bits_t *old_state, uint value_length) { + for (uint i = 0; i < value_length; i++) { + add_error(state + i, colors + i, old_state + i); + } +} + +#define MAX_LENGTH 100 + +// requested colors * 4 to allow for WRGB +static value_bits_t colors[MAX_LENGTH * 4]; +// double buffer the state of the string, since we update next version in parallel with DMAing out old version +static value_bits_t states[2][MAX_LENGTH * 4]; + +// example - string 0 is RGB only +static uint8_t string0_data[MAX_LENGTH * 3]; +// example - string 1 is WRGB +static uint8_t string1_data[MAX_LENGTH * 4]; + +string_t string0 = { + .data = string0_data, + .data_len = sizeof(string0_data), + .frac_brightness = 0x40, +}; + +string_t string1 = { + .data = string1_data, + .data_len = sizeof(string1_data), + .frac_brightness = 0x100, +}; + +string_t *strings[] = { + &string0, + &string1, +}; + +// bit plane content dma channel +#define DMA_CHANNEL 0 +// chain channel for configuring main dma channel to output from disjoint 8 word fragments of memory +#define DMA_CB_CHANNEL 1 + +#define DMA_CHANNEL_MASK (1u << DMA_CHANNEL) +#define DMA_CB_CHANNEL_MASK (1u << DMA_CB_CHANNEL) +#define DMA_CHANNELS_MASK (DMA_CHANNEL_MASK | DMA_CB_CHANNEL_MASK) + +// start of each value fragment (+1 for NULL terminator) +static uintptr_t fragment_start[MAX_LENGTH * 4 + 1]; + +// posted when it is safe to output a new set of values +static struct semaphore reset_delay_complete_sem; +// alarm handle for handling delay +alarm_id_t reset_delay_alarm_id; + +int64_t reset_delay_complete(alarm_id_t id, void *user_data) { + reset_delay_alarm_id = 0; + sem_release(&reset_delay_complete_sem); + // no repeat + return 0; +} + +void __isr dma_complete_handler() { + if (dma_hw->ints0 & DMA_CHANNEL_MASK) { + // clear IRQ + dma_hw->ints0 = DMA_CHANNEL_MASK; + // when the dma is complete we start the reset delay timer + DEBUG_PINS_SET(timing, 4); + if (reset_delay_alarm_id) cancel_alarm(reset_delay_alarm_id); + reset_delay_alarm_id = add_alarm_in_us(400, reset_delay_complete, NULL, true); + } +} + +void dma_init(PIO pio, uint sm) { + dma_claim_mask(DMA_CHANNELS_MASK); + + // main DMA channel outputs 8 word fragments, and then chains back to the chain channel + dma_channel_config channel_config = dma_channel_get_default_config(DMA_CHANNEL); + channel_config_set_dreq(&channel_config, pio_get_dreq(pio, sm, true)); + channel_config_set_chain_to(&channel_config, DMA_CB_CHANNEL); + channel_config_set_irq_quiet(&channel_config, true); + dma_channel_configure(DMA_CHANNEL, + &channel_config, + &pio->txf[sm], + NULL, // set by chain + 8, // 8 words for 8 bit planes + false); + + // chain channel sends single word pointer to start of fragment each time + dma_channel_config chain_config = dma_channel_get_default_config(DMA_CB_CHANNEL); + dma_channel_configure(DMA_CB_CHANNEL, + &chain_config, + &dma_channel_hw_addr( + DMA_CHANNEL)->al3_read_addr_trig, // ch DMA config (target "ring" buffer size 4) - this is (read_addr trigger) + NULL, // set later + 1, + false); + + irq_set_exclusive_handler(DMA_IRQ_0, dma_complete_handler); + dma_channel_set_irq0_enabled(DMA_CHANNEL, true); + irq_set_enabled(DMA_IRQ_0, true); +} + +void output_strings_dma(value_bits_t *bits, uint value_length) { + DEBUG_PINS_SET(timing, 3); + for (uint i = 0; i < value_length; i++) { + fragment_start[i] = (uintptr_t) bits[i].planes; // MSB first + } + fragment_start[value_length] = 0; + dma_channel_hw_addr(DMA_CB_CHANNEL)->al3_read_addr_trig = (uintptr_t) fragment_start; + DEBUG_PINS_CLR(timing, 3); +} + + +int main() { + //set_sys_clock_48(); + stdio_init_all(); + puts("WS2812 parallel"); +#if PIN_TX != 3 + gpio_debug_pins_init(); +#endif + // todo get free sm + PIO pio = pio0; + int sm = 0; + uint offset = pio_add_program(pio, &ws2812_parallel_program); + + ws2812_parallel_program_init(pio, sm, offset, PIN_TX, count_of(strings), 800000); + + sem_init(&reset_delay_complete_sem, 1, 1); // initially posted so we don't block first time + dma_init(pio, sm); + int t = 0; + while (1) { + int pat = rand() % count_of(pattern_table); + int dir = (rand() >> 30) & 1 ? 1 : -1; + if (rand() & 1) dir = 0; + puts(pattern_table[pat].name); + puts(dir == 1 ? "(forward)" : dir ? "(backward)" : "(still)"); + int brightness = 0; + uint current = 0; + for (int i = 0; i < 1000; ++i) { + int n = 64; + DEBUG_PINS_SET(timing, 1); + current_string_out = string0.data; + current_string_4color = false; + pattern_table[pat].pat(n, t); + current_string_out = string1.data; + current_string_4color = true; + pattern_table[pat].pat(n, t); + DEBUG_PINS_CLR(timing, 1); + + DEBUG_PINS_SET(timing, 2); + transform_strings(strings, count_of(strings), colors, n * 4, brightness); + DEBUG_PINS_CLR(timing, 2); + + DEBUG_PINS_SET(timing, 1); + dither_values(colors, states[current], states[current ^ 1], n * 4); + DEBUG_PINS_CLR(timing, 1); + + sem_acquire_blocking(&reset_delay_complete_sem); + DEBUG_PINS_CLR(timing, 4); + + output_strings_dma(states[current], n * 4); + + current ^= 1; + t += dir; + brightness++; + if (brightness == (0x20 << FRAC_BITS)) brightness = 0; + } + memset(&states, 0, sizeof(states)); // clear out errors + } +} diff --git a/pwm/CMakeLists.txt b/pwm/CMakeLists.txt new file mode 100644 index 0000000..b513533 --- /dev/null +++ b/pwm/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_pwm) + add_subdirectory(led_fade) + add_subdirectory(measure_duty_cycle) +endif () diff --git a/pwm/hello_pwm/CMakeLists.txt b/pwm/hello_pwm/CMakeLists.txt new file mode 100644 index 0000000..9c7b0e1 --- /dev/null +++ b/pwm/hello_pwm/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_pwm + hello_pwm.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_pwm pico_stdlib hardware_pwm) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_pwm) + +# add url via pico_set_program_url +example_auto_set_url(hello_pwm) diff --git a/pwm/hello_pwm/hello_pwm.c b/pwm/hello_pwm/hello_pwm.c new file mode 100644 index 0000000..bfce35e --- /dev/null +++ b/pwm/hello_pwm/hello_pwm.c @@ -0,0 +1,34 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Output PWM signals on pins 0 and 1 + +#include "pico/stdlib.h" +#include "hardware/pwm.h" + +int main() { + ///tag::setup_pwm[] + + // Tell GPIO 0 and 1 they are allocated to the PWM + gpio_set_function(0, GPIO_FUNC_PWM); + gpio_set_function(1, GPIO_FUNC_PWM); + + // Find out which PWM slice is connected to GPIO 0 (it's slice 0) + uint slice_num = pwm_gpio_to_slice_num(0); + + // Set period of 4 cycles (0 to 3 inclusive) + pwm_set_wrap(slice_num, 3); + // Set channel A output high for one cycle before dropping + pwm_set_chan_level(slice_num, PWM_CHAN_A, 1); + // Set initial B output high for three cycles before dropping + pwm_set_chan_level(slice_num, PWM_CHAN_B, 3); + // Set the PWM running + pwm_set_enabled(slice_num, true); + ///end::setup_pwm[] + + // Note we could also use pwm_set_gpio_level(gpio, x) which looks up the + // correct slice and channel for a given GPIO. +} diff --git a/pwm/led_fade/CMakeLists.txt b/pwm/led_fade/CMakeLists.txt new file mode 100644 index 0000000..4090f46 --- /dev/null +++ b/pwm/led_fade/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(pwm_led_fade + pwm_led_fade.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(pwm_led_fade pico_stdlib hardware_pwm) + +# create map/bin/hex file etc. +pico_add_extra_outputs(pwm_led_fade) + +# add url via pico_set_program_url +example_auto_set_url(pwm_led_fade) diff --git a/pwm/led_fade/pwm_led_fade.c b/pwm/led_fade/pwm_led_fade.c new file mode 100644 index 0000000..522ab92 --- /dev/null +++ b/pwm/led_fade/pwm_led_fade.c @@ -0,0 +1,65 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Fade an LED between low and high brightness. An interrupt handler updates +// the PWM slice's output level each time the counter wraps. + +#include "pico/stdlib.h" +#include +#include "pico/time.h" +#include "hardware/irq.h" +#include "hardware/pwm.h" + +void on_pwm_wrap() { + static int fade = 0; + static bool going_up = true; + // Clear the interrupt flag that brought us here + pwm_clear_irq(pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN)); + + if (going_up) { + ++fade; + if (fade > 255) { + fade = 255; + going_up = false; + } + } else { + --fade; + if (fade < 0) { + fade = 0; + going_up = true; + } + } + // Square the fade value to make the LED's brightness appear more linear + // Note this range matches with the wrap value + pwm_set_gpio_level(PICO_DEFAULT_LED_PIN, fade * fade); +} + +int main() { + // Tell the LED pin that the PWM is in charge of its value. + gpio_set_function(PICO_DEFAULT_LED_PIN, GPIO_FUNC_PWM); + // Figure out which slice we just connected to the LED pin + uint slice_num = pwm_gpio_to_slice_num(PICO_DEFAULT_LED_PIN); + + // Mask our slice's IRQ output into the PWM block's single interrupt line, + // and register our interrupt handler + pwm_clear_irq(slice_num); + pwm_set_irq_enabled(slice_num, true); + irq_set_exclusive_handler(PWM_IRQ_WRAP, on_pwm_wrap); + irq_set_enabled(PWM_IRQ_WRAP, true); + + // Get some sensible defaults for the slice configuration. By default, the + // counter is allowed to wrap over its maximum range (0 to 2**16-1) + pwm_config config = pwm_get_default_config(); + // Set divider, reduces counter clock to sysclock/this value + pwm_config_set_clkdiv(&config, 4.f); + // Load the configuration into our PWM slice, and set it running. + pwm_init(slice_num, &config, true); + + // Everything after this point happens in the PWM interrupt handler, so we + // can twiddle our thumbs + while (1) + tight_loop_contents(); +} diff --git a/pwm/measure_duty_cycle/CMakeLists.txt b/pwm/measure_duty_cycle/CMakeLists.txt new file mode 100644 index 0000000..174e4b9 --- /dev/null +++ b/pwm/measure_duty_cycle/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(pwm_measure_duty_cycle + measure_duty_cycle.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(pwm_measure_duty_cycle pico_stdlib hardware_pwm) + +# create map/bin/hex file etc. +pico_add_extra_outputs(pwm_measure_duty_cycle) + +# add url via pico_set_program_url +example_auto_set_url(pwm_measure_duty_cycle) diff --git a/pwm/measure_duty_cycle/measure_duty_cycle.c b/pwm/measure_duty_cycle/measure_duty_cycle.c new file mode 100644 index 0000000..9cd1137 --- /dev/null +++ b/pwm/measure_duty_cycle/measure_duty_cycle.c @@ -0,0 +1,72 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pwm.h" +#include "hardware/clocks.h" + +// This example drives a PWM output at a range of duty cycles, and uses +// another PWM slice in input mode to measure the duty cycle. You'll need to +// connect these two pins with a jumper wire: +const uint OUTPUT_PIN = 2; +const uint MEASURE_PIN = 5; + +float measure_duty_cycle(uint gpio) { + // Only the PWM B pins can be used as inputs. + assert(pwm_gpio_to_channel(gpio) == PWM_CHAN_B); + uint slice_num = pwm_gpio_to_slice_num(gpio); + + // Count once for every 100 cycles the PWM B input is high + pwm_config cfg = pwm_get_default_config(); + pwm_config_set_clkdiv_mode(&cfg, PWM_DIV_B_HIGH); + pwm_config_set_clkdiv(&cfg, 100); + pwm_init(slice_num, &cfg, false); + gpio_set_function(gpio, GPIO_FUNC_PWM); + + pwm_set_enabled(slice_num, true); + sleep_ms(10); + pwm_set_enabled(slice_num, false); + float counting_rate = clock_get_hz(clk_sys) / 100; + float max_possible_count = counting_rate * 0.01; + return pwm_get_counter(slice_num) / max_possible_count; +} + +const float test_duty_cycles[] = { + 0.f, + 0.1f, + 0.5f, + 0.9f, + 1.f +}; + +int main() { + stdio_init_all(); + printf("\nPWM duty cycle measurement example\n"); + + // Configure PWM slice and set it running + const uint count_top = 1000; + pwm_config cfg = pwm_get_default_config(); + pwm_config_set_wrap(&cfg, count_top); + pwm_init(pwm_gpio_to_slice_num(OUTPUT_PIN), &cfg, true); + + // Note we aren't touching the other pin yet -- PWM pins are outputs by + // default, but change to inputs once the divider mode is changed from + // free-running. It's not wise to connect two outputs directly together! + gpio_set_function(OUTPUT_PIN, GPIO_FUNC_PWM); + + // For each of our test duty cycles, drive the output pin at that level, + // and read back the actual output duty cycle using the other pin. The two + // values should be very close! + for (int i = 0; i < count_of(test_duty_cycles); ++i) { + float output_duty_cycle = test_duty_cycles[i]; + pwm_set_gpio_level(OUTPUT_PIN, output_duty_cycle * (count_top + 1)); + float measured_duty_cycle = measure_duty_cycle(MEASURE_PIN); + printf("Output duty cycle = %.1f%%, measured input duty cycle = %.1f%%\n", + output_duty_cycle * 100.f, measured_duty_cycle * 100.f); + } +} diff --git a/reset/CMakeLists.txt b/reset/CMakeLists.txt new file mode 100644 index 0000000..29519cd --- /dev/null +++ b/reset/CMakeLists.txt @@ -0,0 +1,14 @@ +if (TARGET hardware_reset) + add_executable(hello_reset + hello_reset.c + ) + + # Pull in our pico_stdlib which pulls in commonly used features + target_link_libraries(hello_reset pico_stdlib) + + # create map/bin/hex file etc. + pico_add_extra_outputs(hello_reset) + + # add url via pico_set_program_url + example_auto_set_url(hello_reset) +endif () \ No newline at end of file diff --git a/reset/hello_reset/CMakeLists.txt b/reset/hello_reset/CMakeLists.txt new file mode 100644 index 0000000..c5d4332 --- /dev/null +++ b/reset/hello_reset/CMakeLists.txt @@ -0,0 +1,14 @@ +if (TARGET hardware_resets) + add_executable(hello_reset + hello_reset.c + ) + + # Pull in our pico_stdlib which pulls in commonly used features + target_link_libraries(hello_reset pico_stdlib hardware_resets) + + # create map/bin/hex file etc. + pico_add_extra_outputs(hello_reset) + + # add url via pico_set_program_url + example_auto_set_url(hello_reset) +endif () \ No newline at end of file diff --git a/reset/hello_reset/hello_reset.c b/reset/hello_reset/hello_reset.c new file mode 100644 index 0000000..920fda5 --- /dev/null +++ b/reset/hello_reset/hello_reset.c @@ -0,0 +1,31 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/resets.h" + +/// \tag::hello_reset[] +int main() { + stdio_init_all(); + + printf("Hello, reset!\n"); + + // Put the PWM block into reset + reset_block(RESETS_RESET_PWM_BITS); + + // And bring it out + unreset_block_wait(RESETS_RESET_PWM_BITS); + + // Put the PWM and RTC block into reset + reset_block(RESETS_RESET_PWM_BITS | RESETS_RESET_RTC_BITS); + + // Wait for both to come out of reset + unreset_block_wait(RESETS_RESET_PWM_BITS | RESETS_RESET_RTC_BITS); + + return 0; +} +/// \end::hello_reset[] diff --git a/rtc/CMakeLists.txt b/rtc/CMakeLists.txt new file mode 100644 index 0000000..9de76b4 --- /dev/null +++ b/rtc/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_rtc) + add_subdirectory(rtc_alarm) + add_subdirectory(rtc_alarm_repeat) +endif () diff --git a/rtc/hello_rtc/CMakeLists.txt b/rtc/hello_rtc/CMakeLists.txt new file mode 100644 index 0000000..9a5e379 --- /dev/null +++ b/rtc/hello_rtc/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_rtc + hello_rtc.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(hello_rtc pico_stdlib hardware_rtc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_rtc) + +# add url via pico_set_program_url +example_auto_set_url(hello_rtc) diff --git a/rtc/hello_rtc/hello_rtc.c b/rtc/hello_rtc/hello_rtc.c new file mode 100644 index 0000000..59cd6fa --- /dev/null +++ b/rtc/hello_rtc/hello_rtc.c @@ -0,0 +1,45 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "hardware/rtc.h" +#include "pico/stdlib.h" +#include "pico/util/datetime.h" + +/// \tag::hello_rtc_main[] +int main() { + stdio_init_all(); + printf("Hello RTC!\n"); + + char datetime_buf[256]; + char *datetime_str = &datetime_buf[0]; + + // Start on Friday 5th of June 2020 15:45:00 + datetime_t t = { + .year = 2020, + .month = 06, + .day = 05, + .dotw = 5, // 0 is Sunday, so 5 is Friday + .hour = 15, + .min = 45, + .sec = 00 + }; + + // Start the RTC + rtc_init(); + rtc_set_datetime(&t); + + // Print the time + while (true) { + rtc_get_datetime(&t); + datetime_to_str(datetime_str, sizeof(datetime_buf), &t); + printf("\r%s ", datetime_str); + sleep_ms(100); + } + + return 0; +} +/// \end::hello_rtc_main[] diff --git a/rtc/rtc_alarm/CMakeLists.txt b/rtc/rtc_alarm/CMakeLists.txt new file mode 100644 index 0000000..e937905 --- /dev/null +++ b/rtc/rtc_alarm/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(rtc_alarm + rtc_alarm.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(rtc_alarm pico_stdlib hardware_rtc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(rtc_alarm) + +# add url via pico_set_program_url +example_auto_set_url(rtc_alarm) diff --git a/rtc/rtc_alarm/rtc_alarm.c b/rtc/rtc_alarm/rtc_alarm.c new file mode 100644 index 0000000..80953aa --- /dev/null +++ b/rtc/rtc_alarm/rtc_alarm.c @@ -0,0 +1,60 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "hardware/rtc.h" +#include "pico/stdlib.h" +#include "pico/util/datetime.h" + +static volatile bool fired = false; + +static void alarm_callback(void) { + datetime_t t = {0}; + rtc_get_datetime(&t); + char datetime_buf[256]; + char *datetime_str = &datetime_buf[0]; + datetime_to_str(datetime_str, sizeof(datetime_buf), &t); + printf("Alarm Fired At %s\n", datetime_str); + stdio_flush(); + fired = true; +} + +int main() { + stdio_init_all(); + printf("RTC Alarm!\n"); + + // Start on Wednesday 13th January 2021 11:20:00 + datetime_t t = { + .year = 2020, + .month = 01, + .day = 13, + .dotw = 3, // 0 is Sunday, so 3 is Wednesday + .hour = 11, + .min = 20, + .sec = 00 + }; + + // Start the RTC + rtc_init(); + rtc_set_datetime(&t); + + // Alarm 5 seconds later + datetime_t alarm = { + .year = 2020, + .month = 01, + .day = 13, + .dotw = 3, // 0 is Sunday, so 3 is Wednesday + .hour = 11, + .min = 20, + .sec = 05 + }; + + rtc_set_alarm(&alarm, &alarm_callback); + + while(!fired); + + return 0; +} \ No newline at end of file diff --git a/rtc/rtc_alarm_repeat/CMakeLists.txt b/rtc/rtc_alarm_repeat/CMakeLists.txt new file mode 100644 index 0000000..5c0155d --- /dev/null +++ b/rtc/rtc_alarm_repeat/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(rtc_alarm_repeat + rtc_alarm_repeat.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(rtc_alarm_repeat pico_stdlib hardware_rtc) + +# create map/bin/hex file etc. +pico_add_extra_outputs(rtc_alarm_repeat) + +# add url via pico_set_program_url +example_auto_set_url(rtc_alarm_repeat) diff --git a/rtc/rtc_alarm_repeat/rtc_alarm_repeat.c b/rtc/rtc_alarm_repeat/rtc_alarm_repeat.c new file mode 100644 index 0000000..fbb9592 --- /dev/null +++ b/rtc/rtc_alarm_repeat/rtc_alarm_repeat.c @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "hardware/rtc.h" +#include "pico/stdlib.h" +#include "pico/util/datetime.h" + +static volatile bool fired = false; + +static void alarm_callback(void) { + datetime_t t = {0}; + rtc_get_datetime(&t); + char datetime_buf[256]; + char *datetime_str = &datetime_buf[0]; + datetime_to_str(datetime_str, sizeof(datetime_buf), &t); + printf("Alarm Fired At %s\n", datetime_str); + stdio_flush(); + fired = true; +} + +int main() { + stdio_init_all(); + printf("RTC Alarm Repeat!\n"); + + // Start on Wednesday 13th January 2021 11:20:00 + datetime_t t = { + .year = 2020, + .month = 01, + .day = 13, + .dotw = 3, // 0 is Sunday, so 3 is Wednesday + .hour = 11, + .min = 20, + .sec = 00 + }; + + // Start the RTC + rtc_init(); + rtc_set_datetime(&t); + + // Alarm once a minute + datetime_t alarm = { + .year = -1, + .month = -1, + .day = -1, + .dotw = -1, + .hour = -1, + .min = -1, + .sec = 00 + }; + + rtc_set_alarm(&alarm, &alarm_callback); + + // Alarm will keep firing forever + while(1); + + return 0; +} \ No newline at end of file diff --git a/spi/CMakeLists.txt b/spi/CMakeLists.txt new file mode 100644 index 0000000..18dd9fe --- /dev/null +++ b/spi/CMakeLists.txt @@ -0,0 +1,6 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(spi_flash) + add_subdirectory(mpu9250_spi) + add_subdirectory(bme280_spi) + add_subdirectory(spi_dma) +endif () diff --git a/spi/bme280_spi/CMakeLists.txt b/spi/bme280_spi/CMakeLists.txt new file mode 100644 index 0000000..17ef7dd --- /dev/null +++ b/spi/bme280_spi/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(bme280_spi + bme280_spi.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(bme280_spi pico_stdlib hardware_spi) + +# create map/bin/hex file etc. +pico_add_extra_outputs(bme280_spi) + +# add url via pico_set_program_url +example_auto_set_url(bme280_spi) diff --git a/spi/bme280_spi/README.adoc b/spi/bme280_spi/README.adoc new file mode 100644 index 0000000..a96b2c1 --- /dev/null +++ b/spi/bme280_spi/README.adoc @@ -0,0 +1,50 @@ += Attaching a BME280 temperature/humidity/pressure sensor via SPI + +This example code shows how to interface the Raspberry Pi Pico to a BME280 temperature/humidity/pressure. The particular device used can be interfaced via I2C or SPI, we are using SPI, and interfacing at 3.3v. + +This examples reads the data from the sensor, and runs it through the appropriate compensation routines (see the chip datasheet for details https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf). At startup the compensation parameters required by the compensation routines are read from the chip. +) + +== Wiring information + +Wiring up the device requires 6 jumpers as follows: + + * GPIO 16 (pin 21) MISO/spi0_rx-> SDO/SDO on bme280 board + * GPIO 17 (pin 22) Chip select -> CSB/!CS on bme280 board + * GPIO 18 (pin 24) SCK/spi0_sclk -> SCL/SCK on bme280 board + * GPIO 19 (pin 25) MOSI/spi0_tx -> SDA/SDI on bme280 board + * 3.3v (pin 3;6) -> VCC on bme280 board + * GND (pin 38) -> GND on bme280 board + +The example here uses SPI port 0. Power is supplied from the 3.3V pin. + +[NOTE] +====== +There are many different manufacturers who sell boards with the BME280. Whilst they all appear slightly different, they all have, at least, the same 6 pins required to power and communicate. When wiring up a board that is different to the one in the diagram, ensure you connect up as described in the previous paragraph. +====== + + +[[BME280_spi_wiring]] +[pdfwidth=75%] +.Wiring Diagram for bme280. +image::bme280_spi_bb.png[] + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +bme280_spi.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[BME280-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| BME280 board| 1 | generic part +| M/M Jumper wires | 6 | generic part +|=== + + diff --git a/spi/bme280_spi/bme280_spi.c b/spi/bme280_spi/bme280_spi.c new file mode 100644 index 0000000..9eff1c2 --- /dev/null +++ b/spi/bme280_spi/bme280_spi.c @@ -0,0 +1,233 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#include "pico/stdlib.h" +#include "hardware/spi.h" + +/* Example code to talk to a bme280 humidity/temperature/pressure sensor. + + NOTE: Ensure the device is capable of being driven at 3.3v NOT 5v. The Pico + GPIO (and therefor SPI) cannot be used at 5v. + + You will need to use a level shifter on the SPI lines if you want to run the + board at 5v. + + Connections on Raspberry Pi Pico board and a generic bme280 board, other + boards may vary. + + GPIO 16 (pin 21) MISO/spi0_rx-> SDO/SDO on bme280 board + GPIO 17 (pin 22) Chip select -> CSB/!CS on bme280 board + GPIO 18 (pin 24) SCK/spi0_sclk -> SCL/SCK on bme280 board + GPIO 19 (pin 25) MOSI/spi0_tx -> SDA/SDI on bme280 board + 3.3v (pin 3;6) -> VCC on bme280 board + GND (pin 38) -> GND on bme280 board + + Note: SPI devices can have a number of different naming schemes for pins. See + the Wikipedia page at https://en.wikipedia.org/wiki/Serial_Peripheral_Interface + for variations. + + This code uses a bunch of register definitions, and some compensation code derived + from the Bosch datasheet which can be found here. + https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme280-ds002.pdf +*/ + +#define PIN_MISO 16 +#define PIN_CS 17 +#define PIN_SCK 18 +#define PIN_MOSI 19 + +#define SPI_PORT spi0 +#define READ_BIT 0x80 + +int32_t t_fine; + +uint16_t dig_T1; +int16_t dig_T2, dig_T3; +uint16_t dig_P1; +int16_t dig_P2, dig_P3, dig_P4, dig_P5, dig_P6, dig_P7, dig_P8, dig_P9; +uint8_t dig_H1, dig_H3; +int8_t dig_H6; +int16_t dig_H2, dig_H4, dig_H5; + +/* The following compensation functions are required to convert from the raw ADC +data from the chip to something usable. Each chip has a different set of +compensation parameters stored on the chip at point of manufacture, which are +read from the chip at startup and used inthese routines. +*/ +int32_t compensate_temp(int32_t adc_T) { + int32_t var1, var2, T; + var1 = ((((adc_T >> 3) - ((int32_t) dig_T1 << 1))) * ((int32_t) dig_T2)) >> 11; + var2 = (((((adc_T >> 4) - ((int32_t) dig_T1)) * ((adc_T >> 4) - ((int32_t) dig_T1))) >> 12) * ((int32_t) dig_T3)) + >> 14; + + t_fine = var1 + var2; + T = (t_fine * 5 + 128) >> 8; + return T; +} + +uint32_t compensate_pressure(int32_t adc_P) { + int32_t var1, var2; + uint32_t p; + var1 = (((int32_t) t_fine) >> 1) - (int32_t) 64000; + var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((int32_t) dig_P6); + var2 = var2 + ((var1 * ((int32_t) dig_P5)) << 1); + var2 = (var2 >> 2) + (((int32_t) dig_P4) << 16); + var1 = (((dig_P3 * (((var1 >> 2) * (var1 >> 2)) >> 13)) >> 3) + ((((int32_t) dig_P2) * var1) >> 1)) >> 18; + var1 = ((((32768 + var1)) * ((int32_t) dig_P1)) >> 15); + if (var1 == 0) + return 0; + + p = (((uint32_t) (((int32_t) 1048576) - adc_P) - (var2 >> 12))) * 3125; + if (p < 0x80000000) + p = (p << 1) / ((uint32_t) var1); + else + p = (p / (uint32_t) var1) * 2; + + var1 = (((int32_t) dig_P9) * ((int32_t) (((p >> 3) * (p >> 3)) >> 13))) >> 12; + var2 = (((int32_t) (p >> 2)) * ((int32_t) dig_P8)) >> 13; + p = (uint32_t) ((int32_t) p + ((var1 + var2 + dig_P7) >> 4)); + + return p; +} + +uint32_t compensate_humidity(int32_t adc_H) { + int32_t v_x1_u32r; + v_x1_u32r = (t_fine - ((int32_t) 76800)); + v_x1_u32r = (((((adc_H << 14) - (((int32_t) dig_H4) << 20) - (((int32_t) dig_H5) * v_x1_u32r)) + + ((int32_t) 16384)) >> 15) * (((((((v_x1_u32r * ((int32_t) dig_H6)) >> 10) * (((v_x1_u32r * + ((int32_t) dig_H3)) + >> 11) + ((int32_t) 32768))) >> 10) + ((int32_t) 2097152)) * + ((int32_t) dig_H2) + 8192) >> 14)); + v_x1_u32r = (v_x1_u32r - (((((v_x1_u32r >> 15) * (v_x1_u32r >> 15)) >> 7) * ((int32_t) dig_H1)) >> 4)); + v_x1_u32r = (v_x1_u32r < 0 ? 0 : v_x1_u32r); + v_x1_u32r = (v_x1_u32r > 419430400 ? 419430400 : v_x1_u32r); + + return (uint32_t) (v_x1_u32r >> 12); +} + +static inline void cs_select() { + asm volatile("nop \n nop \n nop"); + gpio_put(PIN_CS, 0); // Active low + asm volatile("nop \n nop \n nop"); +} + +static inline void cs_deselect() { + asm volatile("nop \n nop \n nop"); + gpio_put(PIN_CS, 1); + asm volatile("nop \n nop \n nop"); +} + +static void write_register(uint8_t reg, uint8_t data) { + uint8_t buf[2]; + buf[0] = reg & 0x7f; // remove read bit as this is a write + buf[1] = data; + cs_select(); + spi_write_blocking(SPI_PORT, buf, 2); + cs_deselect(); + sleep_ms(10); +} + +static void read_registers(uint8_t reg, uint8_t *buf, uint16_t len) { + // For this particular device, we send the device the register we want to read + // first, then subsequently read from the device. The register is auto incrementing + // so we don't need to keep sending the register we want, just the first. + reg |= READ_BIT; + cs_select(); + spi_write_blocking(SPI_PORT, ®, 1); + sleep_ms(10); + spi_read_blocking(SPI_PORT, 0, buf, len); + cs_deselect(); + sleep_ms(10); +} + +/* This function reads the manufacturing assigned compensation parameters from the device */ +void read_compensation_parameters() { + uint8_t buffer[26]; + + read_registers(0x88, buffer, 24); + + dig_T1 = buffer[0] | (buffer[1] << 8); + dig_T2 = buffer[2] | (buffer[3] << 8); + dig_T3 = buffer[4] | (buffer[5] << 8); + + dig_P1 = buffer[6] | (buffer[7] << 8); + dig_P2 = buffer[8] | (buffer[9] << 8); + dig_P3 = buffer[10] | (buffer[11] << 8); + dig_P4 = buffer[12] | (buffer[13] << 8); + dig_P5 = buffer[14] | (buffer[15] << 8); + dig_P6 = buffer[16] | (buffer[17] << 8); + dig_P7 = buffer[18] | (buffer[19] << 8); + dig_P8 = buffer[20] | (buffer[21] << 8); + dig_P9 = buffer[22] | (buffer[23] << 8); + + dig_H1 = buffer[25]; + + read_registers(0xE1, buffer, 8); + + dig_H2 = buffer[0] | (buffer[1] << 8); + dig_H3 = (int8_t) buffer[2]; + dig_H4 = buffer[3] << 4 | (buffer[4] & 0xf); + dig_H5 = (buffer[5] >> 4) | (buffer[6] << 4); + dig_H6 = (int8_t) buffer[7]; +} + +static void bme280_read_raw(int32_t *humidity, int32_t *pressure, int32_t *temperature) { + uint8_t buffer[8]; + + read_registers(0xF7, buffer, 8); + *pressure = ((uint32_t) buffer[0] << 12) | ((uint32_t) buffer[1] << 4) | (buffer[2] >> 4); + *temperature = ((uint32_t) buffer[3] << 12) | ((uint32_t) buffer[4] << 4) | (buffer[5] >> 4); + *humidity = (uint32_t) buffer[6] << 8 | buffer[7]; +} + +int main() { + stdio_init_all(); + + printf("Hello, bme280! Reading raw data from registers via SPI...\n"); + + // This example will use SPI0 at 0.5MHz. + spi_init(SPI_PORT, 500 * 1000); + gpio_set_function(PIN_MISO, GPIO_FUNC_SPI); + gpio_set_function(PIN_SCK, GPIO_FUNC_SPI); + gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI); + + // Chip select is active-low, so we'll initialise it to a driven-high state + gpio_init(PIN_CS); + gpio_set_dir(PIN_CS, GPIO_OUT); + gpio_put(PIN_CS, 1); + + // See if SPI is working - interrograte the device for its I2C ID number, should be 0x60 + uint8_t id; + read_registers(0xD0, &id, 1); + printf("Chip ID is 0x%x\n", id); + + read_compensation_parameters(); + + write_register(0xF2, 0x1); // Humidity oversampling register - going for x1 + write_register(0xF4, 0x27);// Set rest of oversampling modes and run mode to normal + + int32_t humidity, pressure, temperature; + + while (1) { + bme280_read_raw(&humidity, &pressure, &temperature); + + // These are the raw numbers from the chip, so we need to run through the + // compensations to get human understandable numbers + pressure = compensate_pressure(pressure); + temperature = compensate_temp(temperature); + humidity = compensate_humidity(humidity); + + printf("Humidity = %.2f%%\n", humidity / 1024.0); + printf("Pressure = %dPa\n", pressure); + printf("Temp. = %.2fC\n", temperature / 100.0); + + sleep_ms(1000); + } + + return 0; +} diff --git a/spi/bme280_spi/bme280_spi.fzz b/spi/bme280_spi/bme280_spi.fzz new file mode 100644 index 0000000..fd4d255 Binary files /dev/null and b/spi/bme280_spi/bme280_spi.fzz differ diff --git a/spi/bme280_spi/bme280_spi_bb.png b/spi/bme280_spi/bme280_spi_bb.png new file mode 100644 index 0000000..b3db3b8 Binary files /dev/null and b/spi/bme280_spi/bme280_spi_bb.png differ diff --git a/spi/mpu9250_spi/CMakeLists.txt b/spi/mpu9250_spi/CMakeLists.txt new file mode 100644 index 0000000..e0aef15 --- /dev/null +++ b/spi/mpu9250_spi/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(mpu9250_spi + mpu9250_spi.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(mpu9250_spi pico_stdlib hardware_spi) + +# create map/bin/hex file etc. +pico_add_extra_outputs(mpu9250_spi) + +# add url via pico_set_program_url +example_auto_set_url(mpu9250_spi) diff --git a/spi/mpu9250_spi/README.adoc b/spi/mpu9250_spi/README.adoc new file mode 100644 index 0000000..9e81912 --- /dev/null +++ b/spi/mpu9250_spi/README.adoc @@ -0,0 +1,52 @@ += Attaching a MPU9250 accelerometer/gyroscope via SPI + +This example code shows how to interface the Raspberry Pi Pico to the MPU9250 accelerometer/gyroscope board. The particular device used can be interfaced via I2C or SPI, we are using SPI, and interfacing at 3.3v. + +[NOTE] +====== +This is a very basic example, and only recovers raw data from the sensor. There are various calibration options available that should be used to ensure that the final results are accurate. It is also possible to wire up the interrupt pin to a GPIO and read data only when it is ready, rather than using the polling approach in the example. +====== + +== Wiring information + +Wiring up the device requires 6 jumpers as follows: + + * GPIO 4 (pin 6) MISO/spi0_rx-> ADO on MPU9250 board + * GPIO 5 (pin 7) Chip select -> NCS on MPU9250 board + * GPIO 6 (pin 9) SCK/spi0_sclk -> SCL on MPU9250 board + * GPIO 7 (pin 10) MOSI/spi0_tx -> SDA on MPU9250 board + * 3.3v (pin 36) -> VCC on MPU9250 board + * GND (pin 38) -> GND on MPU9250 board + +The example here uses SPI port 0. Power is supplied from the 3.3V pin. + +[NOTE] +====== +There are many different manufacturers who sell boards with the MPU9250. Whilst they all appear slightly different, they all have, at least, the same 6 pins required to power and communicate. When wiring up a board that is different to the one in the diagram, ensure you connect up as described in the previous paragraph. +====== + + +[[mpu9250_spi_wiring]] +[pdfwidth=75%] +.Wiring Diagram for MPU9250. +image::mpu9250_spi_bb.png[] + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +mpu9250_spi.c:: The example code. + +== Bill of Materials + +.A list of materials required for the example +[[MPU9250-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | http://raspberrypi.org/ +| MPU9250 board| 1 | generic part +| M/M Jumper wires | 6 | generic part +|=== + + diff --git a/spi/mpu9250_spi/mpu9250_spi.c b/spi/mpu9250_spi/mpu9250_spi.c new file mode 100644 index 0000000..97e221c --- /dev/null +++ b/spi/mpu9250_spi/mpu9250_spi.c @@ -0,0 +1,150 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#include "pico/stdlib.h" +#include "hardware/spi.h" + +/* Example code to talk to a MPU9250 MEMS accelerometer and gyroscope. + Ignores the magnetometer, that is left as a exercise for the reader. + + This is taking to simple approach of simply reading registers. It's perfectly + possible to link up an interrupt line and set things up to read from the + inbuilt FIFO to make it more useful. + + NOTE: Ensure the device is capable of being driven at 3.3v NOT 5v. The Pico + GPIO (and therefor SPI) cannot be used at 5v. + + You will need to use a level shifter on the I2C lines if you want to run the + board at 5v. + + Connections on Raspberry Pi Pico board and a generic MPU9250 board, other + boards may vary. + + GPIO 4 (pin 6) MISO/spi0_rx-> ADO on MPU9250 board + GPIO 5 (pin 7) Chip select -> NCS on MPU9250 board + GPIO 6 (pin 9) SCK/spi0_sclk -> SCL on MPU9250 board + GPIO 7 (pin 10) MOSI/spi0_tx -> SDA on MPU9250 board + 3.3v (pin 36) -> VCC on MPU9250 board + GND (pin 38) -> GND on MPU9250 board + + Note: SPI devices can have a number of different naming schemes for pins. See + the Wikipedia page at https://en.wikipedia.org/wiki/Serial_Peripheral_Interface + for variations. + The particular device used here uses the same pins for I2C and SPI, hence the + using of I2C names +*/ + +#define PIN_MISO 4 +#define PIN_CS 5 +#define PIN_SCK 6 +#define PIN_MOSI 7 + +#define SPI_PORT spi0 +#define READ_BIT 0x80 + +static inline void cs_select() { + asm volatile("nop \n nop \n nop"); + gpio_put(PIN_CS, 0); // Active low + asm volatile("nop \n nop \n nop"); +} + +static inline void cs_deselect() { + asm volatile("nop \n nop \n nop"); + gpio_put(PIN_CS, 1); + asm volatile("nop \n nop \n nop"); +} + +static void mpu9250_reset() { + // Two byte reset. First byte register, second byte data + // There are a load more options to set up the device in different ways that could be added here + uint8_t buf[] = {0x6B, 0x00}; + cs_select(); + spi_write_blocking(SPI_PORT, buf, 2); + cs_deselect(); +} + + +static void read_registers(uint8_t reg, uint8_t *buf, uint16_t len) { + // For this particular device, we send the device the register we want to read + // first, then subsequently read from the device. The register is auto incrementing + // so we don't need to keep sending the register we want, just the first. + + reg |= READ_BIT; + cs_select(); + spi_write_blocking(SPI_PORT, ®, 1); + sleep_ms(10); + spi_read_blocking(SPI_PORT, 0, buf, len); + cs_deselect(); + sleep_ms(10); +} + + +static void mpu9250_read_raw(int16_t accel[3], int16_t gyro[3], int16_t *temp) { + uint8_t buffer[6]; + + // Start reading acceleration registers from register 0x3B for 6 bytes + read_registers(0x3B, buffer, 6); + + for (int i = 0; i < 3; i++) { + accel[i] = (buffer[i * 2] << 8 | buffer[(i * 2) + 1]); + } + + // Now gyro data from reg 0x43 for 6 bytes + read_registers(0x43, buffer, 6); + + for (int i = 0; i < 3; i++) { + gyro[i] = (buffer[i * 2] << 8 | buffer[(i * 2) + 1]);; + } + + // Now temperature from reg 0x41 for 2 bytes + read_registers(0x41, buffer, 2); + + *temp = buffer[0] << 8 | buffer[1]; +} + +int main() { + stdio_init_all(); + + printf("Hello, MPU9250! Reading raw data from registers via SPI...\n"); + + // This example will use SPI0 at 0.5MHz. + spi_init(SPI_PORT, 500 * 1000); + gpio_set_function(PIN_MISO, GPIO_FUNC_SPI); + gpio_set_function(PIN_SCK, GPIO_FUNC_SPI); + gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI); + + // Chip select is active-low, so we'll initialise it to a driven-high state + gpio_init(PIN_CS); + gpio_set_dir(PIN_CS, GPIO_OUT); + gpio_put(PIN_CS, 1); + + mpu9250_reset(); + + // See if SPI is working - interrograte the device for its I2C ID number, should be 0x71 + uint8_t id; + read_registers(0x75, &id, 1); + printf("I2C address is 0x%x\n", id); + + int16_t acceleration[3], gyro[3], temp; + + while (1) { + mpu9250_read_raw(acceleration, gyro, &temp); + + // These are the raw numbers from the chip, so will need tweaking to be really useful. + // See the datasheet for more information + printf("Acc. X = %d, Y = %d, Z = %d\n", acceleration[0], acceleration[1], acceleration[2]); + printf("Gyro. X = %d, Y = %d, Z = %d\n", gyro[0], gyro[1], gyro[2]); + // Temperature is simple so use the datasheet calculation to get deg C. + // Note this is chip temperature. + printf("Temp. = %f\n", (temp / 340.0) + 36.53); + + sleep_ms(100); + } + + return 0; +} diff --git a/spi/mpu9250_spi/mpu9250_spi.fzz b/spi/mpu9250_spi/mpu9250_spi.fzz new file mode 100644 index 0000000..5481400 Binary files /dev/null and b/spi/mpu9250_spi/mpu9250_spi.fzz differ diff --git a/spi/mpu9250_spi/mpu9250_spi_bb.png b/spi/mpu9250_spi/mpu9250_spi_bb.png new file mode 100644 index 0000000..2056007 Binary files /dev/null and b/spi/mpu9250_spi/mpu9250_spi_bb.png differ diff --git a/spi/spi_dma/CMakeLists.txt b/spi/spi_dma/CMakeLists.txt new file mode 100644 index 0000000..3adfdda --- /dev/null +++ b/spi/spi_dma/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(spi_dma + spi_dma.c + ) + +target_link_libraries(spi_dma pico_stdlib hardware_spi hardware_dma) + +# create map/bin/hex file etc. +pico_add_extra_outputs(spi_dma) + +# add url via pico_set_program_url +example_auto_set_url(spi_dma) diff --git a/spi/spi_dma/spi_dma.c b/spi/spi_dma/spi_dma.c new file mode 100644 index 0000000..2ee2af3 --- /dev/null +++ b/spi/spi_dma/spi_dma.c @@ -0,0 +1,103 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Example of writing via DMA to the SPI interface and similarly reading it back via a loopback. + +#include +#include +#include "pico/stdlib.h" +#include "hardware/spi.h" +#include "hardware/dma.h" + +#define PIN_MISO 16 +#define PIN_CS 17 +#define PIN_SCK 18 +#define PIN_MOSI 19 + +#define SPI_INST spi0 + +#define TEST_SIZE 1024 + +int main() { + // Enable UART so we can print status output + stdio_init_all(); + + printf("SPI DMA example\n"); + + // Enable SPI at 1 MHz and connect to GPIOs + spi_init(SPI_INST, 1000 * 1000); + gpio_set_function(PIN_MISO, GPIO_FUNC_SPI); + gpio_init(PIN_CS); + gpio_set_function(PIN_SCK, GPIO_FUNC_SPI); + gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI); + + // Grab some unused dma channels + const uint dma_tx = dma_claim_unused_channel(true); + const uint dma_rx = dma_claim_unused_channel(true); + + // Force loopback for testing (I don't have an SPI device handy) + hw_set_bits(&spi_get_hw(SPI_INST)->cr1, SPI_SSPCR1_LBM_BITS); + + static uint8_t txbuf[TEST_SIZE]; + static uint8_t rxbuf[TEST_SIZE]; + for (uint i = 0; i < TEST_SIZE; ++i) { + txbuf[i] = rand(); + } + + // We set the outbound DMA to transfer from a memory buffer to the SPI transmit FIFO paced by the SPI TX FIFO DREQ + // The default is for the read address to increment every element (in this case 1 byte - DMA_SIZE_8) + // and for the write address to remain unchanged. + + printf("Configure TX DMA\n"); + dma_channel_config c = dma_channel_get_default_config(dma_tx); + channel_config_set_transfer_data_size(&c, DMA_SIZE_8); + channel_config_set_dreq(&c, spi_get_index(SPI_INST) ? DREQ_SPI1_TX : DREQ_SPI0_TX); + dma_channel_configure(dma_tx, &c, + &spi_get_hw(SPI_INST)->dr, // write address + txbuf, // read address + TEST_SIZE, // element count (each element is of size transfer_data_size) + false); // don't start yet + + printf("Configure RX DMA\n"); + + // We set the inbound DMA to transfer from the SPI receive FIFO to a memory buffer paced by the SPI RX FIFO DREQ + // We coinfigure the read address to remain unchanged for each element, but the write + // address to increment (so data is written throughout the buffer) + c = dma_channel_get_default_config(dma_rx); + channel_config_set_transfer_data_size(&c, DMA_SIZE_8); + channel_config_set_dreq(&c, spi_get_index(SPI_INST) ? DREQ_SPI1_RX : DREQ_SPI0_RX); + channel_config_set_read_increment(&c, false); + channel_config_set_write_increment(&c, true); + dma_channel_configure(dma_rx, &c, + rxbuf, // write address + &spi_get_hw(SPI_INST)->dr, // read address + TEST_SIZE, // element count (each element is of size transfer_data_size) + false); // don't start yet + + + printf("Starting DMAs...\n"); + // start them exactly simultaneously to avoid races (in extreme cases the FIFO could overflow) + dma_start_channel_mask((1u << dma_tx) | (1u << dma_rx)); + printf("Wait for RX complete...\n"); + dma_channel_wait_for_finish_blocking(dma_rx); + if (dma_channel_is_busy(dma_tx)) { + panic("RX completed before TX"); + } + + printf("Done. Checking..."); + for (uint i = 0; i < TEST_SIZE; ++i) { + if (rxbuf[i] != txbuf[i]) { + panic("Mismatch at %d/%d: expected %02x, got %02x", + i, TEST_SIZE, txbuf[i], rxbuf[i] + ); + } + } + + printf("All good\n"); + dma_channel_unclaim(dma_tx); + dma_channel_unclaim(dma_rx); + return 0; +} diff --git a/spi/spi_flash/CMakeLists.txt b/spi/spi_flash/CMakeLists.txt new file mode 100644 index 0000000..c0b54e9 --- /dev/null +++ b/spi/spi_flash/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(spi_flash + spi_flash.c + ) + +# Pull in basic dependencies +target_link_libraries(spi_flash pico_stdlib hardware_spi) + +# create map/bin/hex file etc. +pico_add_extra_outputs(spi_flash) + +# add url via pico_set_program_url +example_auto_set_url(spi_flash) diff --git a/spi/spi_flash/spi_flash.c b/spi/spi_flash/spi_flash.c new file mode 100644 index 0000000..e3df7e8 --- /dev/null +++ b/spi/spi_flash/spi_flash.c @@ -0,0 +1,154 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// Example of reading/writing an external serial flash using the PL022 SPI interface + +#include +#include "pico/stdlib.h" +#include "hardware/spi.h" + +#define FLASH_PAGE_SIZE 256 +#define FLASH_SECTOR_SIZE 4096 + +#define FLASH_CMD_PAGE_PROGRAM 0x02 +#define FLASH_CMD_READ 0x03 +#define FLASH_CMD_STATUS 0x05 +#define FLASH_CMD_WRITE_EN 0x06 +#define FLASH_CMD_SECTOR_ERASE 0x20 + +#define FLASH_STATUS_BUSY_MASK 0x01 + +#define PIN_MISO 4 +#define PIN_CS 5 +#define PIN_SCK 6 +#define PIN_MOSI 7 + +static inline void cs_select(uint cs_pin) { + asm volatile("nop \n nop \n nop"); // FIXME + gpio_put(cs_pin, 0); + asm volatile("nop \n nop \n nop"); // FIXME +} + +static inline void cs_deselect(uint cs_pin) { + asm volatile("nop \n nop \n nop"); // FIXME + gpio_put(cs_pin, 1); + asm volatile("nop \n nop \n nop"); // FIXME +} + +void __not_in_flash_func(flash_read)(spi_inst_t *spi, uint cs_pin, uint32_t addr, uint8_t *buf, size_t len) { + cs_select(cs_pin); + uint8_t cmdbuf[4] = { + FLASH_CMD_READ, + addr >> 16, + addr >> 8, + addr + }; + spi_write_blocking(spi, cmdbuf, 4); + spi_read_blocking(spi, 0, buf, len); + cs_deselect(cs_pin); +} + +void __not_in_flash_func(flash_write_enable)(spi_inst_t *spi, uint cs_pin) { + cs_select(cs_pin); + uint8_t cmd = FLASH_CMD_WRITE_EN; + spi_write_blocking(spi, &cmd, 1); + cs_deselect(cs_pin); +} + +void __not_in_flash_func(flash_wait_done)(spi_inst_t *spi, uint cs_pin) { + uint8_t status; + do { + cs_select(cs_pin); + uint8_t buf[2] = {FLASH_CMD_STATUS, 0}; + spi_write_read_blocking(spi, buf, buf, 2); + cs_deselect(cs_pin); + status = buf[1]; + } while (status & FLASH_STATUS_BUSY_MASK); +} + +void __not_in_flash_func(flash_sector_erase)(spi_inst_t *spi, uint cs_pin, uint32_t addr) { + uint8_t cmdbuf[4] = { + FLASH_CMD_SECTOR_ERASE, + addr >> 16, + addr >> 8, + addr + }; + flash_write_enable(spi, cs_pin); + cs_select(cs_pin); + spi_write_blocking(spi, cmdbuf, 4); + cs_deselect(cs_pin); + flash_wait_done(spi, cs_pin); +} + +void __not_in_flash_func(flash_page_program)(spi_inst_t *spi, uint cs_pin, uint32_t addr, uint8_t data[]) { + uint8_t cmdbuf[4] = { + FLASH_CMD_PAGE_PROGRAM, + addr >> 16, + addr >> 8, + addr + }; + flash_write_enable(spi, cs_pin); + cs_select(cs_pin); + spi_write_blocking(spi, cmdbuf, 4); + spi_write_blocking(spi, data, FLASH_PAGE_SIZE); + cs_deselect(cs_pin); + flash_wait_done(spi, cs_pin); +} + +void printbuf(uint8_t buf[FLASH_PAGE_SIZE]) { + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) { + if (i % 16 == 15) + printf("%02x\n", buf[i]); + else + printf("%02x ", buf[i]); + } +} + +int main() { + // Enable UART so we can print status output + stdio_init_all(); + + printf("SPI flash example\n"); + + // Enable SPI 0 at 1 MHz and connect to GPIOs + spi_init(spi0, 1000 * 1000); + gpio_set_function(PIN_MISO, GPIO_FUNC_SPI); + gpio_set_function(PIN_SCK, GPIO_FUNC_SPI); + gpio_set_function(PIN_MOSI, GPIO_FUNC_SPI); + + // Chip select is active-low, so we'll initialise it to a driven-high state + gpio_init(PIN_CS); + gpio_put(PIN_CS, 1); + gpio_set_dir(PIN_CS, GPIO_OUT); + + printf("SPI initialised, let's goooooo\n"); + + uint8_t page_buf[FLASH_PAGE_SIZE]; + + const uint32_t target_addr = 0; + + flash_sector_erase(spi0, PIN_CS, target_addr); + flash_read(spi0, PIN_CS, target_addr, page_buf, FLASH_PAGE_SIZE); + + printf("After erase:\n"); + printbuf(page_buf); + + for (int i = 0; i < FLASH_PAGE_SIZE; ++i) + page_buf[i] = i; + flash_page_program(spi0, PIN_CS, target_addr, page_buf); + flash_read(spi0, PIN_CS, target_addr, page_buf, FLASH_PAGE_SIZE); + + printf("After program:\n"); + printbuf(page_buf); + + flash_sector_erase(spi0, PIN_CS, target_addr); + flash_read(spi0, PIN_CS, target_addr, page_buf, FLASH_PAGE_SIZE); + + printf("Erase again:\n"); + printbuf(page_buf); + + return 0; +} diff --git a/system/CMakeLists.txt b/system/CMakeLists.txt new file mode 100644 index 0000000..b11455b --- /dev/null +++ b/system/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(double_tap_usb_boot) + add_subdirectory(narrow_io_write) + add_subdirectory(hello_double_tap) +endif () diff --git a/system/double_tap_usb_boot/CMakeLists.txt b/system/double_tap_usb_boot/CMakeLists.txt new file mode 100644 index 0000000..2d72a27 --- /dev/null +++ b/system/double_tap_usb_boot/CMakeLists.txt @@ -0,0 +1,13 @@ +add_library(double_tap_usb_boot INTERFACE) + +# inclusion of this library will allow you to double tap reset within 100ms to launch into bootrom USB bootloader +if (PICO_ON_DEVICE) + target_sources(double_tap_usb_boot INTERFACE + ${CMAKE_CURRENT_LIST_DIR}/double_tap_usb_boot.c + ) + + target_link_libraries(double_tap_usb_boot INTERFACE + pico_bootrom + pico_time + ) +endif () \ No newline at end of file diff --git a/system/double_tap_usb_boot/double_tap_usb_boot.c b/system/double_tap_usb_boot/double_tap_usb_boot.c new file mode 100644 index 0000000..72afe7b --- /dev/null +++ b/system/double_tap_usb_boot/double_tap_usb_boot.c @@ -0,0 +1,36 @@ +#include "pico.h" +#include "pico/time.h" +#include "pico/bootrom.h" + +// Allow user override of the LED mask +#ifndef USB_BOOT_LED_ACTIVITY_MASK +#define USB_BOOT_LED_ACTIVITY_MASK 0 +#endif + +// Doesn't make any sense for a RAM only binary +#if !PICO_NO_FLASH +static const uint32_t magic_token[] = { + 0xf01681de, 0xbd729b29, 0xd359be7a, +}; + +static uint32_t __uninitialized_ram(magic_location)[count_of(magic_token)]; + +// run at initialization time +static void __attribute__((constructor)) boot_double_tap_check() { + for (uint i = 0; i < count_of(magic_token); i++) { + if (magic_location[i] != magic_token[i]) { + // Arm for 100 ms then disarm and continue booting + for (i = 0; i < count_of(magic_token); i++) { + magic_location[i] = magic_token[i]; + } + busy_wait_us(100000); + magic_location[0] = 0; + return; + } + } + + magic_location[0] = 0; + reset_usb_boot(USB_BOOT_LED_ACTIVITY_MASK, 0); +} + +#endif \ No newline at end of file diff --git a/system/hello_double_tap/CMakeLists.txt b/system/hello_double_tap/CMakeLists.txt new file mode 100644 index 0000000..a4344ae --- /dev/null +++ b/system/hello_double_tap/CMakeLists.txt @@ -0,0 +1,14 @@ +add_executable(hello_double_tap + hello_double_tap.c + ) + +# Double tap reset into bootrom is injected by linking with the double_tap_usb_boot library +target_link_libraries(hello_double_tap + pico_stdlib + double_tap_usb_boot + ) + +pico_add_extra_outputs(hello_double_tap) + +# add url via pico_set_program_url +example_auto_set_url(hello_double_tap) diff --git a/system/hello_double_tap/hello_double_tap.c b/system/hello_double_tap/hello_double_tap.c new file mode 100644 index 0000000..6d0ba7f --- /dev/null +++ b/system/hello_double_tap/hello_double_tap.c @@ -0,0 +1,21 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" + +// This is a regular old LED blinking example, however it is linked with double_tap_usb_boot +// so pressing reset quickly twice, will reset into USB bootloader +int main() { + const uint LED_PIN = 21; + gpio_init(LED_PIN); + gpio_set_dir(LED_PIN, GPIO_OUT); + while (true) { + gpio_put(LED_PIN, 1); + sleep_ms(250); + gpio_put(LED_PIN, 0); + sleep_ms(250); + } +} diff --git a/system/narrow_io_write/CMakeLists.txt b/system/narrow_io_write/CMakeLists.txt new file mode 100644 index 0000000..8f3c317 --- /dev/null +++ b/system/narrow_io_write/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(narrow_io_write + narrow_io_write.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(narrow_io_write pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(narrow_io_write) + +# add url via pico_set_program_url +example_auto_set_url(narrow_io_write) diff --git a/system/narrow_io_write/narrow_io_write.c b/system/narrow_io_write/narrow_io_write.c new file mode 100644 index 0000000..e4aa2f4 --- /dev/null +++ b/system/narrow_io_write/narrow_io_write.c @@ -0,0 +1,60 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/structs/watchdog.h" + +// This app shows the effect of byte and halfword writes on IO registers. All +// IO registers on RP2040 will sample the entire 32 bit write data bus on any +// write; the transfer size and the 2 LSBs of the address are *ignored*. +// +// This can have unintuitive results, especially given the way RP2040 +// busmasters replicate narrow write data across the entire 32-bit write data +// bus. However, this behaviour can be quite useful if you are aware of it! + +int main() { + stdio_init_all(); + + // We'll use WATCHDOG_SCRATCH0 as a convenient 32 bit read/write register + // that we can assign arbitrary values to + io_rw_32 *scratch32 = &watchdog_hw->scratch[0]; + // Alias the scratch register as two halfwords at offsets +0x0 and +0x2 + volatile uint16_t *scratch16 = (volatile uint16_t *) scratch32; + // Alias the scratch register as four bytes at offsets +0x0, +0x1, +0x2, +0x3: + volatile uint8_t *scratch8 = (volatile uint8_t *) scratch32; + + // Show that we can read/write the scratch register as normal: + printf("Writing 32 bit value\n"); + *scratch32 = 0xdeadbeef; + printf("Should be 0xdeadbeef: 0x%08x\n", *scratch32); + + // We can do narrow reads just fine -- IO registers treat this as a 32 bit + // read, and the processor/DMA will pick out the correct byte lanes based + // on transfer size and address LSBs + printf("\nReading back 1 byte at a time\n"); + // Little-endian! + printf("Should be ef be ad de: %02x %02x %02x %02x\n", + scratch8[0], scratch8[1], scratch8[2], scratch8[3]); + + // The Cortex-M0+ and the RP2040 DMA replicate byte writes across the bus, + // and IO registers will sample the entire write bus always. + printf("\nWriting 8 bit value 0xa5 at offset 0\n"); + scratch8[0] = 0xa5; + // Read back the whole scratch register in one go + printf("Should be 0xa5a5a5a5: 0x%08x\n", *scratch32); + + // The IO register ignores the address LSBs [1:0] as well as the transfer + // size, so it doesn't matter what byte offset we use + printf("\nWriting 8 bit value at offset 1\n"); + scratch8[1] = 0x3c; + printf("Should be 0x3c3c3c3c: 0x%08x\n", *scratch32); + + // Halfword writes are also replicated across the write data bus + printf("\nWriting 16 bit value at offset 0\n"); + scratch16[0] = 0xf00d; + printf("Should be 0xf00df00d: 0x%08x\n", *scratch32); +} diff --git a/timer/CMakeLists.txt b/timer/CMakeLists.txt new file mode 100644 index 0000000..7d95179 --- /dev/null +++ b/timer/CMakeLists.txt @@ -0,0 +1,5 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_timer) +endif () +add_subdirectory(periodic_sampler) +add_subdirectory(timer_lowlevel) diff --git a/timer/hello_timer/CMakeLists.txt b/timer/hello_timer/CMakeLists.txt new file mode 100644 index 0000000..058bcad --- /dev/null +++ b/timer/hello_timer/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_timer + hello_timer.c + ) + +# Pull in our (to be renamed) simple get you started dependencies +target_link_libraries(hello_timer pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_timer) + +# add url via pico_set_program_url +example_auto_set_url(hello_timer) diff --git a/timer/hello_timer/hello_timer.c b/timer/hello_timer/hello_timer.c new file mode 100644 index 0000000..2753648 --- /dev/null +++ b/timer/hello_timer/hello_timer.c @@ -0,0 +1,58 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" + +/// \tag::timer_example[] +volatile bool timer_fired = false; + +int64_t alarm_callback(alarm_id_t id, void *user_data) { + printf("Timer %d fired!\n", (int) id); + timer_fired = true; + // Can return a value here in us to fire in the future + return 0; +} + +bool repeating_timer_callback(struct repeating_timer *t) { + printf("Repeat at %lld\n", time_us_64()); + return true; +} + +int main() { + stdio_init_all(); + printf("Hello Timer!\n"); + + // Call alarm_callback in 2 seconds + add_alarm_in_ms(2000, alarm_callback, NULL, false); + + // Wait for alarm callback to set timer_fired + while (!timer_fired) { + tight_loop_contents(); + } + + // Create a repeating timer that calls repeating_timer_callback. + // If the delay is > 0 then this is the delay between the previous callback ending and the next starting. + // If the delay is negative (see below) then the next call to the callback will be exactly 500ms after the + // start of the call to the last callback + struct repeating_timer timer; + add_repeating_timer_ms(500, repeating_timer_callback, NULL, &timer); + sleep_ms(3000); + bool cancelled = cancel_repeating_timer(&timer); + printf("cancelled... %d\n", cancelled); + sleep_ms(2000); + + // Negative delay so means we will call repeating_timer_callback, and call it again + // 500ms later regardless of how long the callback took to execute + add_repeating_timer_ms(-500, repeating_timer_callback, NULL, &timer); + sleep_ms(3000); + cancelled = cancel_repeating_timer(&timer); + printf("cancelled... %d\n", cancelled); + sleep_ms(2000); + printf("Done\n"); + return 0; +} +/// \end::timer_example[] diff --git a/timer/periodic_sampler/CMakeLists.txt b/timer/periodic_sampler/CMakeLists.txt new file mode 100644 index 0000000..a4094c4 --- /dev/null +++ b/timer/periodic_sampler/CMakeLists.txt @@ -0,0 +1,14 @@ +if (NOT PICO_TIME_NO_ALARM_SUPPORT) + add_executable(periodic_sampler + periodic_sampler.c + ) + + # Pull in our (to be renamed) simple get you started dependencies + target_link_libraries(periodic_sampler pico_stdlib) + + # create map/bin/hex file etc. + pico_add_extra_outputs(periodic_sampler) + + # add url via pico_set_program_url + example_auto_set_url(periodic_sampler) +endif() diff --git a/timer/periodic_sampler/periodic_sampler.c b/timer/periodic_sampler/periodic_sampler.c new file mode 100644 index 0000000..b347855 --- /dev/null +++ b/timer/periodic_sampler/periodic_sampler.c @@ -0,0 +1,82 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "pico/util/queue.h" + +bool timer_callback(repeating_timer_t *rt); + +queue_t sample_fifo; + +// using struct as an example, but primitive types can be used too +typedef struct element { + uint value; +} element_t; + +const int FIFO_LENGTH = 32; + +int main() { + stdio_init_all(); + + int hz = 25; + + queue_init(&sample_fifo, sizeof(element_t), FIFO_LENGTH); + + repeating_timer_t timer; + + // negative timeout means exact delay (rather than delay between callbacks) + if (!add_repeating_timer_us(-1000000 / hz, timer_callback, NULL, &timer)) { + printf("Failed to add timer\n"); + return 1; + } + + // read some blocking + + for (int i = 0; i < 10; i++) { + element_t element; + queue_remove_blocking(&sample_fifo, &element); + printf("Got %d: %d\n", i, element.value); + } + + // now retrieve all that are available periodically (simulate polling) + for (int i = 0; i < 10; i++) { + int count = queue_get_level(&sample_fifo); + if (count) { + printf("Getting %d, %d:\n", i, count); + for (; count > 0; count--) { + element_t element; + queue_remove_blocking(&sample_fifo, &element); + printf(" got %d\n", element.value); + } + } + sleep_us(5000000 / hz); // sleep for 5 times the sampling period + } + + cancel_repeating_timer(&timer); + + // drain any remaining + element_t element; + while (queue_try_remove(&sample_fifo, &element)) { + printf("Got remaining %d\n", element.value); + } + + queue_free(&sample_fifo); + printf("Done\n"); +} + +bool timer_callback(repeating_timer_t *rt) { + static int v = 100; + element_t element = { + .value = v + }; + v += 100; + + if (!queue_try_add(&sample_fifo, &element)) { + printf("FIFO was full\n"); + } + return true; // keep repeating +} diff --git a/timer/timer_lowlevel/CMakeLists.txt b/timer/timer_lowlevel/CMakeLists.txt new file mode 100644 index 0000000..55d4e82 --- /dev/null +++ b/timer/timer_lowlevel/CMakeLists.txt @@ -0,0 +1,15 @@ +if (PICO_ON_DEVICE) + add_executable(timer_lowlevel + timer_lowlevel.c) + + # Disable SDK alarm support for this lowlevel example + set(PICO_TIME_DEFAULT_ALARM_POOL_DISABLED 1) + + target_link_libraries(timer_lowlevel pico_stdlib) + + # create map/bin/hex file etc. + pico_add_extra_outputs(timer_lowlevel) + + # add url via pico_set_program_url + example_auto_set_url(timer_lowlevel) +endif () \ No newline at end of file diff --git a/timer/timer_lowlevel/timer_lowlevel.c b/timer/timer_lowlevel/timer_lowlevel.c new file mode 100644 index 0000000..68f1840 --- /dev/null +++ b/timer/timer_lowlevel/timer_lowlevel.c @@ -0,0 +1,73 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/timer.h" +#include "hardware/irq.h" + +/// \tag::get_time[] +// Simplest form of getting 64 bit time from the timer. +// It isn't safe when called from 2 cores because of the latching +// so isn't implemented this way in the sdk +static uint64_t get_time(void) { + // Reading low latches the high value + uint32_t lo = timer_hw->timelr; + uint32_t hi = timer_hw->timehr; + return ((uint64_t) hi << 32u) | lo; +} +/// \end::get_time[] + +/// \tag::alarm_standalone[] +// Use alarm 0 +#define ALARM_NUM 0 +#define ALARM_IRQ TIMER_IRQ_0 + +// Alarm interrupt handler +static volatile bool alarm_fired; + +static void alarm_irq(void) { + // Clear the alarm irq + hw_clear_bits(&timer_hw->intr, 1u << ALARM_NUM); + + // Assume alarm 0 has fired + printf("Alarm IRQ fired\n"); + alarm_fired = true; +} + +static void alarm_in_us(uint32_t delay_us) { + // Enable the interrupt for our alarm (the timer outputs 4 alarm irqs) + hw_set_bits(&timer_hw->inte, 1u << ALARM_NUM); + // Set irq handler for alarm irq + irq_set_exclusive_handler(ALARM_IRQ, alarm_irq); + // Enable the alarm irq + irq_set_enabled(ALARM_IRQ, true); + // Enable interrupt in block and at processor + + // Alarm is only 32 bits so if trying to delay more + // than that need to be careful and keep track of the upper + // bits + uint64_t target = timer_hw->timerawl + delay_us; + + // Write the lower 32 bits of the target time to the alarm which + // will arm it + timer_hw->alarm[ALARM_NUM] = (uint32_t) target; +} + +int main() { + stdio_init_all(); + printf("Timer lowlevel!\n"); + + // Set alarm every 2 seconds + while (1) { + alarm_fired = false; + alarm_in_us(1000000 * 2); + // Wait for alarm to fire + while (!alarm_fired); + } +} + +/// \end::alarm_standalone[] \ No newline at end of file diff --git a/uart/CMakeLists.txt b/uart/CMakeLists.txt new file mode 100644 index 0000000..2ca582b --- /dev/null +++ b/uart/CMakeLists.txt @@ -0,0 +1,4 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_uart) + add_subdirectory(uart_advanced) +endif () diff --git a/uart/hello_uart/CMakeLists.txt b/uart/hello_uart/CMakeLists.txt new file mode 100644 index 0000000..62bb95e --- /dev/null +++ b/uart/hello_uart/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(hello_uart + hello_uart.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(hello_uart pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_uart) + +# add url via pico_set_program_url +example_auto_set_url(hello_uart) diff --git a/uart/hello_uart/hello_uart.c b/uart/hello_uart/hello_uart.c new file mode 100644 index 0000000..6fbad0e --- /dev/null +++ b/uart/hello_uart/hello_uart.c @@ -0,0 +1,44 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#include +#include "pico/stdlib.h" +#include "hardware/uart.h" + +/// \tag::hello_uart[] + +#define UART_ID uart0 +#define BAUD_RATE 115200 + +// We are using pins 0 and 1, but see the GPIO function select table in the +// datasheet for information on which other pins can be used. +#define UART_TX_PIN 0 +#define UART_RX_PIN 1 + +int main() { + // Set up our UART with the required speed. + uart_init(UART_ID, BAUD_RATE); + + // Set the TX and RX pins by using the function select on the GPIO + // Set datasheet for more information on function select + gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART); + gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART); + + // Use some the various UART functions to send out data + // In a default system, printf will also output via the default UART + + // Send out a character without any conversions + uart_putc_raw(UART_ID, 'A'); + + // Send out a character but do CR/LF conversions + uart_putc(UART_ID, 'B'); + + // Send out a string, with CR/LF conversions + uart_puts(UART_ID, " Hello, UART!\n"); +} + +/// \end::hello_uart[] diff --git a/uart/uart_advanced/CMakeLists.txt b/uart/uart_advanced/CMakeLists.txt new file mode 100644 index 0000000..38cdfef --- /dev/null +++ b/uart/uart_advanced/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(uart_advanced + uart_advanced.c + ) + +# Pull in our pico_stdlib which pulls in commonly used features +target_link_libraries(uart_advanced pico_stdlib hardware_uart) + +# create map/bin/hex file etc. +pico_add_extra_outputs(uart_advanced) + +# add url via pico_set_program_url +example_auto_set_url(uart_advanced) diff --git a/uart/uart_advanced/uart_advanced.c b/uart/uart_advanced/uart_advanced.c new file mode 100644 index 0000000..c9b51d2 --- /dev/null +++ b/uart/uart_advanced/uart_advanced.c @@ -0,0 +1,86 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +#include "pico/stdlib.h" +#include "hardware/uart.h" +#include "hardware/irq.h" + + +/// \tag::uart_advanced[] + +#define UART_ID uart0 +#define BAUD_RATE 115200 +#define DATA_BITS 8 +#define STOP_BITS 1 +#define PARITY UART_PARITY_NONE + +// We are using pins 0 and 1, but see the GPIO function select table in the +// datasheet for information on which other pins can be used. +#define UART_TX_PIN 0 +#define UART_RX_PIN 1 + +static int chars_rxed = 0; + +// RX interrupt handler +void on_uart_rx() { + while (uart_is_readable(UART_ID)) { + uint8_t ch = uart_getc(UART_ID); + // Can we send it back? + if (uart_is_writable(UART_ID)) { + // Change it slightly first! + ch++; + uart_putc(UART_ID, ch); + } + chars_rxed++; + } +} + +int main() { + // Set up our UART with a basic baud rate. + uart_init(UART_ID, 2400); + + // Set the TX and RX pins by using the function select on the GPIO + // Set datasheet for more information on function select + gpio_set_function(UART_TX_PIN, GPIO_FUNC_UART); + gpio_set_function(UART_RX_PIN, GPIO_FUNC_UART); + + // Actually, we want a different speed + // The call will return the actual baud rate selected, which will be as close as + // possible to that requested + int actual = uart_set_baudrate(UART_ID, BAUD_RATE); + + // Set UART flow control CTS/RTS, we don't want these, so turn them off + uart_set_hw_flow(UART_ID, false, false); + + // Set our data format + uart_set_format(UART_ID, DATA_BITS, STOP_BITS, PARITY); + + // Turn off FIFO's - we want to do this character by character + uart_set_fifo_enabled(UART_ID, false); + + // Set up a RX interrupt + // We need to set up the handler first + // Select correct interrupt for the UART we are using + int UART_IRQ = UART_ID == uart0 ? UART0_IRQ : UART1_IRQ; + + // And set up and enable the interrupt handlers + irq_set_exclusive_handler(UART_IRQ, on_uart_rx); + irq_set_enabled(UART_IRQ, true); + + // Now enable the UART to send interrupts - RX only + uart_set_irq_enables(UART_ID, true, false); + + // OK, all set up. + // Lets send a basic string out, and then run a loop and wait for RX interrupts + // The handler will count them, but also reflect the incoming data back with a slight change! + uart_puts(UART_ID, "\nHello, uart interrupts\n"); + + while (1) + tight_loop_contents(); +} + +/// \end:uart_advanced[] diff --git a/usb/CMakeLists.txt b/usb/CMakeLists.txt new file mode 100644 index 0000000..2d79b6b --- /dev/null +++ b/usb/CMakeLists.txt @@ -0,0 +1,10 @@ +if (TARGET tinyusb_device) + add_subdirectory(device) +else () + message("Skipping TinyUSB device examples, as TinyUSB unavailable") +endif () +if (TARGET tinyusb_host) + add_subdirectory(host) +else () + message("Skipping TinyUSB host examples, as TinyUSB unavailable") +endif () \ No newline at end of file diff --git a/usb/README.md b/usb/README.md new file mode 100644 index 0000000..a0a6ed3 --- /dev/null +++ b/usb/README.md @@ -0,0 +1 @@ +Note: most of these examples are copies of the tinyusb examples in pico-sdk/lib/tinyusb/examples diff --git a/usb/device/CMakeLists.txt b/usb/device/CMakeLists.txt new file mode 100644 index 0000000..06895a0 --- /dev/null +++ b/usb/device/CMakeLists.txt @@ -0,0 +1,4 @@ +add_subdirectory(dev_audio_headset) +add_subdirectory(dev_hid_composite) +add_subdirectory(dev_hid_generic_inout) +add_subdirectory(dev_lowlevel) diff --git a/usb/device/dev_audio_headset/CMakeLists.txt b/usb/device/dev_audio_headset/CMakeLists.txt new file mode 100644 index 0000000..16d34b0 --- /dev/null +++ b/usb/device/dev_audio_headset/CMakeLists.txt @@ -0,0 +1,14 @@ +set(CMAKE_C_FLAGS_DEBUG "-O0 -g") + +add_executable(dev_audio_headset + dev_audio_headset.c + usb_descriptors.c + ) + +target_include_directories(dev_audio_headset PRIVATE ${CMAKE_CURRENT_LIST_DIR}) + +target_link_libraries(dev_audio_headset PRIVATE pico_stdlib tinyusb_device tinyusb_board) +pico_add_extra_outputs(dev_audio_headset) + +# add url via pico_set_program_url +example_auto_set_url(dev_audio_headset) diff --git a/usb/device/dev_audio_headset/dev_audio_headset.c b/usb/device/dev_audio_headset/dev_audio_headset.c new file mode 100644 index 0000000..49d6815 --- /dev/null +++ b/usb/device/dev_audio_headset/dev_audio_headset.c @@ -0,0 +1,358 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2020 Jerzy Kasenberg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include +#include + +#include "bsp/board.h" +#include "tusb.h" +#include "usb_descriptors.h" + +//--------------------------------------------------------------------+ +// MACRO CONSTANT TYPEDEF PROTOTYPES +//--------------------------------------------------------------------+ + +/* Blink pattern + * - 25 ms : streaming data + * - 250 ms : device not mounted + * - 1000 ms : device mounted + * - 2500 ms : device is suspended + */ +enum { + BLINK_STREAMING = 25, + BLINK_NOT_MOUNTED = 250, + BLINK_MOUNTED = 1000, + BLINK_SUSPENDED = 2500, +}; + +enum { + VOLUME_CTRL_0_DB = 0, + VOLUME_CTRL_10_DB = 2560, + VOLUME_CTRL_20_DB = 5120, + VOLUME_CTRL_30_DB = 7680, + VOLUME_CTRL_40_DB = 10240, + VOLUME_CTRL_50_DB = 12800, + VOLUME_CTRL_60_DB = 15360, + VOLUME_CTRL_70_DB = 17920, + VOLUME_CTRL_80_DB = 20480, + VOLUME_CTRL_90_DB = 23040, + VOLUME_CTRL_100_DB = 25600, + VOLUME_CTRL_SILENCE = 0x8000, +}; + +static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED; + +// Audio controls +// Current states +int8_t mute[CFG_TUD_AUDIO_N_CHANNELS_TX + 1]; // +1 for master channel 0 +int16_t volume[CFG_TUD_AUDIO_N_CHANNELS_TX + 1]; // +1 for master channel 0 + +// Buffer for microphone data +int16_t mic_buf[1000]; +// Buffer for speaker data +int16_t spk_buf[1000]; +// Speaker data size received in the last frame +int spk_data_size; + +void led_blinking_task(void); +void audio_task(void); + +/*------------- MAIN -------------*/ +int main(void) { + board_init(); + + tusb_init(); + + TU_LOG1("Headset running\r\n"); + + while (1) { + tud_task(); // TinyUSB device task + audio_task(); + led_blinking_task(); + } + + return 0; +} + +//--------------------------------------------------------------------+ +// Device callbacks +//--------------------------------------------------------------------+ + +// Invoked when device is mounted +void tud_mount_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +// Invoked when device is unmounted +void tud_umount_cb(void) { + blink_interval_ms = BLINK_NOT_MOUNTED; +} + +// Invoked when usb bus is suspended +// remote_wakeup_en : if host allow us to perform remote wakeup +// Within 7ms, device must draw an average of current less than 2.5 mA from bus +void tud_suspend_cb(bool remote_wakeup_en) { + (void) remote_wakeup_en; + blink_interval_ms = BLINK_SUSPENDED; +} + +// Invoked when usb bus is resumed +void tud_resume_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +typedef struct TU_ATTR_PACKED { + union { + struct TU_ATTR_PACKED { + uint8_t recipient: 5; ///< Recipient type tusb_request_recipient_t. + uint8_t type: 2; ///< Request type tusb_request_type_t. + uint8_t direction: 1; ///< Direction type. tusb_dir_t + } bmRequestType_bit; + + uint8_t bmRequestType; + }; + + audio_cs_req_t bRequest; + uint8_t bChannelNumber; + uint8_t bControlSelector; + union { + uint8_t bInterface; + uint8_t bEndpoint; + }; + uint8_t bEntityID; + uint16_t wLength; +} audio_control_request_t; + +// Helper for clock get requests +static bool tud_audio_clock_get_request(uint8_t rhport, audio_control_request_t const *request) { + TU_ASSERT(request->bEntityID == UAC2_ENTITY_CLOCK); + + // Example supports only single frequency, same value will be used for current value and range + if (request->bControlSelector == AUDIO_CS_CTRL_SAM_FREQ) { + if (request->bRequest == AUDIO_CS_REQ_CUR) { + TU_LOG2("Clock get current freq %u\r\n", AUDIO_SAMPLE_RATE); + + audio_control_cur_4_t curf = {tu_htole32(AUDIO_SAMPLE_RATE)}; + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &curf, + sizeof(curf)); + } else if (request->bRequest == AUDIO_CS_REQ_RANGE) { + audio_control_range_4_n_t(1) rangef = + { + .wNumSubRanges = tu_htole16(1), + .subrange[0] = {tu_htole32(AUDIO_SAMPLE_RATE), tu_htole32(AUDIO_SAMPLE_RATE), 0} + }; + TU_LOG2("Clock get freq range (%d, %d, %d)\r\n", (int) rangef.subrange[0].bMin, + (int) rangef.subrange[0].bMax, (int) rangef.subrange[0].bRes); + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &rangef, + sizeof(rangef)); + } + } else if (request->bControlSelector == AUDIO_CS_CTRL_CLK_VALID && + request->bRequest == AUDIO_CS_REQ_CUR) { + audio_control_cur_1_t cur_valid = {.bCur = 1}; + TU_LOG2("Clock get is valid %u\r\n", cur_valid.bCur); + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &cur_valid, + sizeof(cur_valid)); + } + TU_LOG1("Clock get request not supported, entity = %u, selector = %u, request = %u\r\n", + request->bEntityID, request->bControlSelector, request->bRequest); + return false; +} + +// Helper for feature unit get requests +static bool tud_audio_feature_unit_get_request(uint8_t rhport, audio_control_request_t const *request) { + TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT); + + if (request->bControlSelector == AUDIO_FU_CTRL_MUTE && request->bRequest == AUDIO_CS_REQ_CUR) { + audio_control_cur_1_t mute1 = {.bCur = mute[request->bChannelNumber]}; + TU_LOG2("Get channel %u mute %d\r\n", request->bChannelNumber, mute1.bCur); + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, &mute1, + sizeof(mute1)); + } else if (UAC2_ENTITY_SPK_FEATURE_UNIT && request->bControlSelector == AUDIO_FU_CTRL_VOLUME) { + if (request->bRequest == AUDIO_CS_REQ_RANGE) { + audio_control_range_2_n_t(1) range_vol = { + .wNumSubRanges = tu_htole16(1), + .subrange[0] = {.bMin = tu_htole16(-VOLUME_CTRL_50_DB), tu_htole16(VOLUME_CTRL_0_DB), + tu_htole16(256)} + }; + TU_LOG2("Get channel %u volume range (%d, %d, %u) dB\r\n", request->bChannelNumber, + range_vol.subrange[0].bMin / 256, range_vol.subrange[0].bMax / 256, + range_vol.subrange[0].bRes / 256); + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, + &range_vol, sizeof(range_vol)); + } else if (request->bRequest == AUDIO_CS_REQ_CUR) { + audio_control_cur_2_t cur_vol = {.bCur = tu_htole16(volume[request->bChannelNumber])}; + TU_LOG2("Get channel %u volume %u dB\r\n", request->bChannelNumber, cur_vol.bCur); + return tud_audio_buffer_and_schedule_control_xfer(rhport, (tusb_control_request_t const *) request, + &cur_vol, sizeof(cur_vol)); + } + } + TU_LOG1("Feature unit get request not supported, entity = %u, selector = %u, request = %u\r\n", + request->bEntityID, request->bControlSelector, request->bRequest); + + return false; +} + +// Helper for feature unit set requests +static bool tud_audio_feature_unit_set_request(uint8_t rhport, audio_control_request_t const *request, + uint8_t const *buf) { + (void) rhport; + + TU_ASSERT(request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT); + TU_VERIFY(request->bRequest == AUDIO_CS_REQ_CUR); + + if (request->bControlSelector == AUDIO_FU_CTRL_MUTE) { + TU_VERIFY(request->wLength == sizeof(audio_control_cur_1_t)); + + mute[request->bChannelNumber] = ((audio_control_cur_1_t *) buf)->bCur; + + TU_LOG2("Set channel %d Mute: %d\r\n", request->bChannelNumber, mute[request->bChannelNumber]); + + return true; + } else if (request->bControlSelector == AUDIO_FU_CTRL_VOLUME) { + TU_VERIFY(request->wLength == sizeof(audio_control_cur_2_t)); + + volume[request->bChannelNumber] = ((audio_control_cur_2_t const *) buf)->bCur; + + TU_LOG2("Set channel %d volume: %d dB\r\n", request->bChannelNumber, volume[request->bChannelNumber] / 256); + + return true; + } else { + TU_LOG1("Feature unit set request not supported, entity = %u, selector = %u, request = %u\r\n", + request->bEntityID, request->bControlSelector, request->bRequest); + return false; + } +} + +//--------------------------------------------------------------------+ +// Application Callback API Implementations +//--------------------------------------------------------------------+ + +// Invoked when audio class specific get request received for an entity +bool tud_audio_get_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request) { + audio_control_request_t *request = (audio_control_request_t *) p_request; + + if (request->bEntityID == UAC2_ENTITY_CLOCK) + return tud_audio_clock_get_request(rhport, request); + if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT) + return tud_audio_feature_unit_get_request(rhport, request); + else { + TU_LOG1("Get request not handled, entity = %d, selector = %d, request = %d\r\n", + request->bEntityID, request->bControlSelector, request->bRequest); + } + return false; +} + +// Invoked when audio class specific set request received for an entity +bool tud_audio_set_req_entity_cb(uint8_t rhport, tusb_control_request_t const *p_request, uint8_t *buf) { + audio_control_request_t const *request = (audio_control_request_t const *) p_request; + + if (request->bEntityID == UAC2_ENTITY_SPK_FEATURE_UNIT) + return tud_audio_feature_unit_set_request(rhport, request, buf); + + TU_LOG1("Set request not handled, entity = %d, selector = %d, request = %d\r\n", + request->bEntityID, request->bControlSelector, request->bRequest); + + return false; +} + +bool tud_audio_set_itf_close_EP_cb(uint8_t rhport, tusb_control_request_t const *p_request) { + (void) rhport; + + uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex)); + uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue)); + + if (ITF_NUM_AUDIO_STREAMING_SPK == itf && alt == 0) + blink_interval_ms = BLINK_MOUNTED; + + return true; +} + +bool tud_audio_set_itf_cb(uint8_t rhport, tusb_control_request_t const *p_request) { + (void) rhport; + uint8_t const itf = tu_u16_low(tu_le16toh(p_request->wIndex)); + uint8_t const alt = tu_u16_low(tu_le16toh(p_request->wValue)); + + TU_LOG2("Set interface %d alt %d\r\n", itf, alt); + if (ITF_NUM_AUDIO_STREAMING_SPK == itf && alt != 0) + blink_interval_ms = BLINK_STREAMING; + + return true; +} + +bool tud_audio_rx_done_cb(uint8_t rhport, uint8_t *buffer, uint16_t buf_size) { + (void) rhport; + + spk_data_size = buf_size; + memcpy(spk_buf, buffer, buf_size); + + return true; +} + +bool tud_audio_tx_done_pre_load_cb(uint8_t rhport, uint8_t itf, uint8_t ep_in, uint8_t cur_alt_setting) { + (void) rhport; + (void) itf; + (void) ep_in; + (void) cur_alt_setting; + + // This callback could be used to fill microphone data separately + return true; +} + +//--------------------------------------------------------------------+ +// AUDIO Task +//--------------------------------------------------------------------+ + +void audio_task(void) { + // When new data arrived, copy data from speaker buffer, to microphone buffer + // and send it over + if (spk_data_size) { + int16_t *src = spk_buf; + int16_t *limit = spk_buf + spk_data_size / 2; + int16_t *dst = mic_buf; + while (src < limit) { + // Combine two channels into one + int32_t left = *src++; + int32_t right = *src++; + *dst++ = (int16_t) ((left + right) / 2); + } + tud_audio_write((uint8_t *) mic_buf, spk_data_size / 2); + spk_data_size = 0; + } +} + +//--------------------------------------------------------------------+ +// BLINKING TASK +//--------------------------------------------------------------------+ +void led_blinking_task(void) { + static uint32_t start_ms = 0; + static bool led_state = false; + + // Blink every interval ms + if (board_millis() - start_ms < blink_interval_ms) return; + start_ms += blink_interval_ms; + + board_led_write(led_state); + led_state = 1 - led_state; +} diff --git a/usb/device/dev_audio_headset/tusb_config.h b/usb/device/dev_audio_headset/tusb_config.h new file mode 100644 index 0000000..504ecc0 --- /dev/null +++ b/usb/device/dev_audio_headset/tusb_config.h @@ -0,0 +1,132 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2020 Ha Thach (tinyusb.org) + * Copyright (c) 2020 Jerzy Kasenberg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _TUSB_CONFIG_H_ +#define _TUSB_CONFIG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +//-------------------------------------------------------------------- +// COMMON CONFIGURATION +//-------------------------------------------------------------------- + +// defined by compiler flags for flexibility +#ifndef CFG_TUSB_MCU +#error CFG_TUSB_MCU must be defined +#endif + +#if CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_LPC18XX || CFG_TUSB_MCU == OPT_MCU_MIMXRT10XX +#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED) +#else +#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE +#endif + +#ifndef CFG_TUSB_DEBUG +// Can be set during compilation i.e.: make LOG= BOARD= +// Keep in mind that enabling logs when data is streaming can disrupt data flow. +// It can be very helpful though when audio unit requests are tested/debugged. +#define CFG_TUSB_DEBUG 2 +#endif + +/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment. + * Tinyusb use follows macros to declare transferring memory so that they can be put + * into those specific section. + * e.g + * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") )) + * - CFG_TUSB_MEM_ALIGN : __attribute__ ((aligned(4))) + */ +#ifndef CFG_TUSB_MEM_SECTION +#define CFG_TUSB_MEM_SECTION +#endif + +#ifndef CFG_TUSB_MEM_ALIGN +#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) +#endif + +//-------------------------------------------------------------------- +// DEVICE CONFIGURATION +//-------------------------------------------------------------------- + +#ifndef CFG_TUD_ENDPOINT0_SIZE +#define CFG_TUD_ENDPOINT0_SIZE 64 +#endif + +//------------- CLASS -------------// +#define CFG_TUD_CDC 0 +#define CFG_TUD_MSC 0 +#define CFG_TUD_HID 0 +#define CFG_TUD_MIDI 0 +#define CFG_TUD_AUDIO 1 +#define CFG_TUD_VENDOR 0 + +//-------------------------------------------------------------------- +// AUDIO CLASS DRIVER CONFIGURATION +//-------------------------------------------------------------------- + +#ifndef AUDIO_SAMPLE_RATE +#define AUDIO_SAMPLE_RATE 48000 +#endif + +#define CFG_TUD_AUDIO_IN_PATH (CFG_TUD_AUDIO) +#define CFG_TUD_AUDIO_OUT_PATH (CFG_TUD_AUDIO) + +// Audio format type +#define CFG_TUD_AUDIO_FORMAT_TYPE_TX AUDIO_FORMAT_TYPE_I +#define CFG_TUD_AUDIO_FORMAT_TYPE_RX AUDIO_FORMAT_TYPE_I + +// Audio format type I specifications +#define CFG_TUD_AUDIO_FORMAT_TYPE_I_TX AUDIO_DATA_FORMAT_TYPE_I_PCM +#define CFG_TUD_AUDIO_FORMAT_TYPE_I_RX AUDIO_DATA_FORMAT_TYPE_I_PCM +#define CFG_TUD_AUDIO_N_CHANNELS_TX 1 +#define CFG_TUD_AUDIO_N_BYTES_PER_SAMPLE_TX 2 +#define CFG_TUD_AUDIO_N_CHANNELS_RX 2 +#define CFG_TUD_AUDIO_N_BYTES_PER_SAMPLE_RX 2 +#define CFG_TUD_AUDIO_RX_ITEMSIZE 2 +#define CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP 0 + +// EP and buffer size - for isochronous EP´s, the buffer and EP size are equal (different sizes would not make sense) +#define CFG_TUD_AUDIO_EPSIZE_IN (CFG_TUD_AUDIO_IN_PATH * (48 + 1) * (CFG_TUD_AUDIO_N_BYTES_PER_SAMPLE_TX) * (CFG_TUD_AUDIO_N_CHANNELS_TX)) // 48 Samples (48 kHz) x 2 Bytes/Sample x n Channels +#define CFG_TUD_AUDIO_TX_FIFO_COUNT (CFG_TUD_AUDIO_IN_PATH * 1) +#define CFG_TUD_AUDIO_TX_FIFO_SIZE (CFG_TUD_AUDIO_IN_PATH ? ((CFG_TUD_AUDIO_EPSIZE_IN)) : 0) + +// EP and buffer size - for isochronous EP´s, the buffer and EP size are equal (different sizes would not make sense) +#define CFG_TUD_AUDIO_EPSIZE_OUT (CFG_TUD_AUDIO_OUT_PATH * ((48 + CFG_TUD_AUDIO_ENABLE_FEEDBACK_EP) * (CFG_TUD_AUDIO_N_BYTES_PER_SAMPLE_RX) * (CFG_TUD_AUDIO_N_CHANNELS_RX))) // N Samples (N kHz) x 2 Bytes/Sample x n Channels +#define CFG_TUD_AUDIO_RX_FIFO_COUNT (CFG_TUD_AUDIO_OUT_PATH * 1) +#define CFG_TUD_AUDIO_RX_FIFO_SIZE (CFG_TUD_AUDIO_OUT_PATH ? (3 * (CFG_TUD_AUDIO_EPSIZE_OUT / CFG_TUD_AUDIO_RX_FIFO_COUNT)) : 0) + +// Number of Standard AS Interface Descriptors (4.9.1) defined per audio function - this is required to be able to remember the current alternate settings of these interfaces - We restrict us here to have a constant number for all audio functions (which means this has to be the maximum number of AS interfaces an audio function has and a second audio function with less AS interfaces just wastes a few bytes) +#define CFG_TUD_AUDIO_N_AS_INT 1 + +// Size of control request buffer +#define CFG_TUD_AUDIO_CTRL_BUF_SIZE 64 + +#ifdef __cplusplus +} +#endif + +#endif /* _TUSB_CONFIG_H_ */ diff --git a/usb/device/dev_audio_headset/usb_descriptors.c b/usb/device/dev_audio_headset/usb_descriptors.c new file mode 100644 index 0000000..63d69cd --- /dev/null +++ b/usb/device/dev_audio_headset/usb_descriptors.c @@ -0,0 +1,159 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2020 Ha Thach (tinyusb.org) + * Copyright (c) 2020 Jerzy Kasenberg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include "tusb.h" +#include "usb_descriptors.h" + +/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug. + * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC. + * + * Auto ProductID layout's Bitmap: + * [MSB] AUDIO | MIDI | HID | MSC | CDC [LSB] + */ +#define _PID_MAP(itf, n) ( (CFG_TUD_##itf) << (n) ) +#define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \ + _PID_MAP(MIDI, 3) | _PID_MAP(AUDIO, 4) | _PID_MAP(VENDOR, 5) ) + +//--------------------------------------------------------------------+ +// Device Descriptors +//--------------------------------------------------------------------+ +tusb_desc_device_t const desc_device = + { + .bLength = sizeof(tusb_desc_device_t), + .bDescriptorType = TUSB_DESC_DEVICE, + .bcdUSB = 0x0200, + + // Use Interface Association Descriptor (IAD) for CDC + // As required by USB Specs IAD's subclass must be common class (2) and protocol must be IAD (1) + .bDeviceClass = TUSB_CLASS_MISC, + .bDeviceSubClass = MISC_SUBCLASS_COMMON, + .bDeviceProtocol = MISC_PROTOCOL_IAD, + .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE, + + .idVendor = 0xCafe, + .idProduct = USB_PID, + .bcdDevice = 0x0100, + + .iManufacturer = 0x01, + .iProduct = 0x02, + .iSerialNumber = 0x03, + + .bNumConfigurations = 0x01 + }; + +// Invoked when received GET DEVICE DESCRIPTOR +// Application return pointer to descriptor +uint8_t const *tud_descriptor_device_cb(void) { + return (uint8_t const *) &desc_device; +} + +//--------------------------------------------------------------------+ +// Configuration Descriptor +//--------------------------------------------------------------------+ +#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + CFG_TUD_AUDIO * TUD_AUDIO_HEADSET_STEREO_DESC_LEN) + +#if CFG_TUSB_MCU == OPT_MCU_LPC175X_6X || CFG_TUSB_MCU == OPT_MCU_LPC177X_8X || CFG_TUSB_MCU == OPT_MCU_LPC40XX +// LPC 17xx and 40xx endpoint type (bulk/interrupt/iso) are fixed by its number +// 0 control, 1 In, 2 Bulk, 3 Iso, 4 In etc ... +#define EPNUM_AUDIO 0x03 +#elif CFG_TUSB_MCU == OPT_MCU_NRF5X +// ISO endpoints for NRF5x are fixed to 0x08 (0x88) +#define EPNUM_AUDIO 0x08 +#else +#define EPNUM_AUDIO 0x01 +#endif + +// These variables are required by the audio driver in audio_device.c + +// List of audio descriptor lengths which is required by audio driver - you need as many entries as CFG_TUD_AUDIO +const uint16_t tud_audio_desc_lengths[] = {TUD_AUDIO_HEADSET_STEREO_DESC_LEN}; + +uint8_t const desc_configuration[] = + { + // Interface count, string index, total length, attribute, power in mA + TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100), + + // Interface number, string index, EP Out & EP In address, EP size + TUD_AUDIO_HEADSET_STEREO_DESCRIPTOR(2, 2, 16, EPNUM_AUDIO, CFG_TUD_AUDIO_EPSIZE_OUT, EPNUM_AUDIO | 0x80, + CFG_TUD_AUDIO_EPSIZE_IN) + }; + +// Invoked when received GET CONFIGURATION DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const *tud_descriptor_configuration_cb(uint8_t index) { + (void) index; // for multiple configurations + return desc_configuration; +} + +//--------------------------------------------------------------------+ +// String Descriptors +//--------------------------------------------------------------------+ + +// array of pointer to string descriptors +char const *string_desc_arr[] = + { + (const char[]) {0x09, 0x04}, // 0: is supported language is English (0x0409) + "TinyUSB", // 1: Manufacturer + "TinyUSB headset", // 2: Product + "000001", // 3: Serials, should use chip ID + "TinyUSB Speakers", // 4: Audio Interface + "TinyUSB Microphone", // 5: Audio Interface + }; + +static uint16_t _desc_str[32]; + +// Invoked when received GET STRING DESCRIPTOR request +// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete +uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) { + (void) langid; + + uint8_t chr_count; + + if (index == 0) { + memcpy(&_desc_str[1], string_desc_arr[0], 2); + chr_count = 1; + } else { + // Convert ASCII string into UTF-16 + + if (!(index < sizeof(string_desc_arr) / sizeof(string_desc_arr[0]))) return NULL; + + const char *str = string_desc_arr[index]; + + // Cap at max char + chr_count = strlen(str); + if (chr_count > 31) chr_count = 31; + + for (uint8_t i = 0; i < chr_count; i++) { + _desc_str[1 + i] = str[i]; + } + } + + // first byte is length (including header), second byte is string type + _desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * chr_count + 2); + + return _desc_str; +} diff --git a/usb/device/dev_audio_headset/usb_descriptors.h b/usb/device/dev_audio_headset/usb_descriptors.h new file mode 100644 index 0000000..1979f3d --- /dev/null +++ b/usb/device/dev_audio_headset/usb_descriptors.h @@ -0,0 +1,119 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2020 Jerzy Kasenbreg + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _USB_DESCRIPTORS_H_ +#define _USB_DESCRIPTORS_H_ + +#include "tusb.h" + +// Unit numbers are arbitrary selected +#define UAC2_ENTITY_CLOCK 0x04 +// Speaker path +#define UAC2_ENTITY_SPK_INPUT_TERMINAL 0x01 +#define UAC2_ENTITY_SPK_FEATURE_UNIT 0x02 +#define UAC2_ENTITY_SPK_OUTPUT_TERMINAL 0x03 +// Microphone path +#define UAC2_ENTITY_MIC_INPUT_TERMINAL 0x11 +#define UAC2_ENTITY_MIC_OUTPUT_TERMINAL 0x13 + +enum { + ITF_NUM_AUDIO_CONTROL = 0, + ITF_NUM_AUDIO_STREAMING_SPK, + ITF_NUM_AUDIO_STREAMING_MIC, + ITF_NUM_TOTAL +}; + +#define TUD_AUDIO_HEADSET_STEREO_DESC_LEN (TUD_AUDIO_DESC_IAD_LEN\ + + TUD_AUDIO_DESC_STD_AC_LEN\ + + TUD_AUDIO_DESC_CS_AC_LEN\ + + TUD_AUDIO_DESC_CLK_SRC_LEN\ + + TUD_AUDIO_DESC_INPUT_TERM_LEN\ + + TUD_AUDIO_DESC_FEATURE_UNIT_TWO_CHANNEL_LEN\ + + TUD_AUDIO_DESC_OUTPUT_TERM_LEN\ + + TUD_AUDIO_DESC_INPUT_TERM_LEN\ + + TUD_AUDIO_DESC_OUTPUT_TERM_LEN\ + + TUD_AUDIO_DESC_STD_AS_INT_LEN\ + + TUD_AUDIO_DESC_STD_AS_INT_LEN\ + + TUD_AUDIO_DESC_CS_AS_INT_LEN\ + + TUD_AUDIO_DESC_TYPE_I_FORMAT_LEN\ + + TUD_AUDIO_DESC_STD_AS_ISO_EP_LEN\ + + TUD_AUDIO_DESC_CS_AS_ISO_EP_LEN\ + + TUD_AUDIO_DESC_STD_AS_INT_LEN\ + + TUD_AUDIO_DESC_STD_AS_INT_LEN\ + + TUD_AUDIO_DESC_CS_AS_INT_LEN\ + + TUD_AUDIO_DESC_TYPE_I_FORMAT_LEN\ + + TUD_AUDIO_DESC_STD_AS_ISO_EP_LEN\ + + TUD_AUDIO_DESC_CS_AS_ISO_EP_LEN) + + +#define TUD_AUDIO_HEADSET_STEREO_DESCRIPTOR(_stridx, _nBytesPerSample, _nBitsUsedPerSample, _epout, _epoutsize, _epin, _epinsize) \ + /* Standard Interface Association Descriptor (IAD) */\ + TUD_AUDIO_DESC_IAD(/*_firstitfs*/ ITF_NUM_AUDIO_CONTROL, /*_nitfs*/ ITF_NUM_TOTAL, /*_stridx*/ 0x00),\ + /* Standard AC Interface Descriptor(4.7.1) */\ + TUD_AUDIO_DESC_STD_AC(/*_itfnum*/ ITF_NUM_AUDIO_CONTROL, /*_nEPs*/ 0x00, /*_stridx*/ _stridx),\ + /* Class-Specific AC Interface Header Descriptor(4.7.2) */\ + TUD_AUDIO_DESC_CS_AC(/*_bcdADC*/ 0x0200, /*_category*/ AUDIO_FUNC_HEADSET, /*_totallen*/ TUD_AUDIO_DESC_CLK_SRC_LEN+TUD_AUDIO_DESC_FEATURE_UNIT_TWO_CHANNEL_LEN+TUD_AUDIO_DESC_INPUT_TERM_LEN+TUD_AUDIO_DESC_OUTPUT_TERM_LEN+TUD_AUDIO_DESC_INPUT_TERM_LEN+TUD_AUDIO_DESC_OUTPUT_TERM_LEN, /*_ctrl*/ AUDIO_CS_AS_INTERFACE_CTRL_LATENCY_POS),\ + /* Clock Source Descriptor(4.7.2.1) */\ + TUD_AUDIO_DESC_CLK_SRC(/*_clkid*/ UAC2_ENTITY_CLOCK, /*_attr*/ 3, /*_ctrl*/ 5, /*_assocTerm*/ 0x00, /*_stridx*/ 0x00), \ + /* Input Terminal Descriptor(4.7.2.4) */\ + TUD_AUDIO_DESC_INPUT_TERM(/*_termid*/ UAC2_ENTITY_SPK_INPUT_TERMINAL, /*_termtype*/ AUDIO_TERM_TYPE_USB_STREAMING, /*_assocTerm*/ 0x00, /*_clkid*/ UAC2_ENTITY_CLOCK, /*_nchannelslogical*/ 0x02, /*_channelcfg*/ AUDIO_CHANNEL_CONFIG_NON_PREDEFINED, /*_idxchannelnames*/ 0x00, /*_ctrl*/ 0 * (AUDIO_CTRL_R << AUDIO_IN_TERM_CTRL_CONNECTOR_POS), /*_stridx*/ 0x00),\ + /* Feature Unit Descriptor(4.7.2.8) */\ + TUD_AUDIO_DESC_FEATURE_UNIT_TWO_CHANNEL(/*_unitid*/ UAC2_ENTITY_SPK_FEATURE_UNIT, /*_srcid*/ UAC2_ENTITY_SPK_INPUT_TERMINAL, /*_ctrlch0master*/ (AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_MUTE_POS | AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_VOLUME_POS), /*_ctrlch1*/ (AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_MUTE_POS | AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_VOLUME_POS), /*_ctrlch2*/ (AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_MUTE_POS | AUDIO_CTRL_RW << AUDIO_FEATURE_UNIT_CTRL_VOLUME_POS), /*_stridx*/ 0x00),\ + /* Output Terminal Descriptor(4.7.2.5) */\ + TUD_AUDIO_DESC_OUTPUT_TERM(/*_termid*/ UAC2_ENTITY_SPK_OUTPUT_TERMINAL, /*_termtype*/ AUDIO_TERM_TYPE_OUT_GENERIC_SPEAKER, /*_assocTerm*/ 0x00, /*_srcid*/ UAC2_ENTITY_SPK_FEATURE_UNIT, /*_clkid*/ UAC2_ENTITY_CLOCK, /*_ctrl*/ 0x0000, /*_stridx*/ 0x00),\ + /* Input Terminal Descriptor(4.7.2.4) */\ + TUD_AUDIO_DESC_INPUT_TERM(/*_termid*/ UAC2_ENTITY_MIC_INPUT_TERMINAL, /*_termtype*/ AUDIO_TERM_TYPE_IN_GENERIC_MIC, /*_assocTerm*/ 0x00, /*_clkid*/ UAC2_ENTITY_CLOCK, /*_nchannelslogical*/ 0x01, /*_channelcfg*/ AUDIO_CHANNEL_CONFIG_NON_PREDEFINED, /*_idxchannelnames*/ 0x00, /*_ctrl*/ 0 * (AUDIO_CTRL_R << AUDIO_IN_TERM_CTRL_CONNECTOR_POS), /*_stridx*/ 0x00),\ + /* Output Terminal Descriptor(4.7.2.5) */\ + TUD_AUDIO_DESC_OUTPUT_TERM(/*_termid*/ UAC2_ENTITY_MIC_OUTPUT_TERMINAL, /*_termtype*/ AUDIO_TERM_TYPE_USB_STREAMING, /*_assocTerm*/ 0x00, /*_srcid*/ UAC2_ENTITY_MIC_INPUT_TERMINAL, /*_clkid*/ UAC2_ENTITY_CLOCK, /*_ctrl*/ 0x0000, /*_stridx*/ 0x00),\ + /* Standard AS Interface Descriptor(4.9.1) */\ + /* Interface 1, Alternate 0 - default alternate setting with 0 bandwidth */\ + TUD_AUDIO_DESC_STD_AS_INT(/*_itfnum*/ (uint8_t)(ITF_NUM_AUDIO_STREAMING_SPK), /*_altset*/ 0x00, /*_nEPs*/ 0x00, /*_stridx*/ 0x05),\ + /* Standard AS Interface Descriptor(4.9.1) */\ + /* Interface 1, Alternate 1 - alternate interface for data streaming */\ + TUD_AUDIO_DESC_STD_AS_INT(/*_itfnum*/ (uint8_t)(ITF_NUM_AUDIO_STREAMING_SPK), /*_altset*/ 0x01, /*_nEPs*/ 0x01, /*_stridx*/ 0x05),\ + /* Class-Specific AS Interface Descriptor(4.9.2) */\ + TUD_AUDIO_DESC_CS_AS_INT(/*_termid*/ UAC2_ENTITY_SPK_INPUT_TERMINAL, /*_ctrl*/ AUDIO_CTRL_NONE, /*_formattype*/ AUDIO_FORMAT_TYPE_I, /*_formats*/ AUDIO_DATA_FORMAT_TYPE_I_PCM, /*_nchannelsphysical*/ 0x02, /*_channelcfg*/ AUDIO_CHANNEL_CONFIG_NON_PREDEFINED, /*_stridx*/ 0x00),\ + /* Type I Format Type Descriptor(2.3.1.6 - Audio Formats) */\ + TUD_AUDIO_DESC_TYPE_I_FORMAT(_nBytesPerSample, _nBitsUsedPerSample),\ + /* Standard AS Isochronous Audio Data Endpoint Descriptor(4.10.1.1) */\ + TUD_AUDIO_DESC_STD_AS_ISO_EP(/*_ep*/ _epout, /*_attr*/ (TUSB_XFER_ISOCHRONOUS | TUSB_ISO_EP_ATT_ADAPTIVE | TUSB_ISO_EP_ATT_DATA), /*_maxEPsize*/ _epoutsize, /*_interval*/ (CFG_TUSB_RHPORT0_MODE & OPT_MODE_HIGH_SPEED) ? 0x04 : 0x01),\ + /* Class-Specific AS Isochronous Audio Data Endpoint Descriptor(4.10.1.2) */\ + TUD_AUDIO_DESC_CS_AS_ISO_EP(/*_attr*/ AUDIO_CS_AS_ISO_DATA_EP_ATT_NON_MAX_PACKETS_OK, /*_ctrl*/ AUDIO_CTRL_NONE, /*_lockdelayunit*/ AUDIO_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_MILLISEC, /*_lockdelay*/ 0x0001),\ + /* Standard AS Interface Descriptor(4.9.1) */\ + /* Interface 2, Alternate 0 - default alternate setting with 0 bandwidth */\ + TUD_AUDIO_DESC_STD_AS_INT(/*_itfnum*/ (uint8_t)(ITF_NUM_AUDIO_STREAMING_MIC), /*_altset*/ 0x00, /*_nEPs*/ 0x00, /*_stridx*/ 0x04),\ + /* Standard AS Interface Descriptor(4.9.1) */\ + /* Interface 1, Alternate 1 - alternate interface for data streaming */\ + TUD_AUDIO_DESC_STD_AS_INT(/*_itfnum*/ (uint8_t)(ITF_NUM_AUDIO_STREAMING_MIC), /*_altset*/ 0x01, /*_nEPs*/ 0x01, /*_stridx*/ 0x04),\ + /* Class-Specific AS Interface Descriptor(4.9.2) */\ + TUD_AUDIO_DESC_CS_AS_INT(/*_termid*/ UAC2_ENTITY_MIC_OUTPUT_TERMINAL, /*_ctrl*/ AUDIO_CTRL_NONE, /*_formattype*/ AUDIO_FORMAT_TYPE_I, /*_formats*/ AUDIO_DATA_FORMAT_TYPE_I_PCM, /*_nchannelsphysical*/ 0x01, /*_channelcfg*/ AUDIO_CHANNEL_CONFIG_NON_PREDEFINED, /*_stridx*/ 0x00),\ + /* Type I Format Type Descriptor(2.3.1.6 - Audio Formats) */\ + TUD_AUDIO_DESC_TYPE_I_FORMAT(_nBytesPerSample, _nBitsUsedPerSample),\ + /* Standard AS Isochronous Audio Data Endpoint Descriptor(4.10.1.1) */\ + TUD_AUDIO_DESC_STD_AS_ISO_EP(/*_ep*/ _epin, /*_attr*/ (TUSB_XFER_ISOCHRONOUS | TUSB_ISO_EP_ATT_ASYNCHRONOUS | TUSB_ISO_EP_ATT_DATA), /*_maxEPsize*/ _epinsize, /*_interval*/ (CFG_TUSB_RHPORT0_MODE & OPT_MODE_HIGH_SPEED) ? 0x04 : 0x01),\ + /* Class-Specific AS Isochronous Audio Data Endpoint Descriptor(4.10.1.2) */\ + TUD_AUDIO_DESC_CS_AS_ISO_EP(/*_attr*/ AUDIO_CS_AS_ISO_DATA_EP_ATT_NON_MAX_PACKETS_OK, /*_ctrl*/ AUDIO_CTRL_NONE, /*_lockdelayunit*/ AUDIO_CS_AS_ISO_DATA_EP_LOCK_DELAY_UNIT_UNDEFINED, /*_lockdelay*/ 0x0000)\ + +#endif diff --git a/usb/device/dev_hid_composite/CMakeLists.txt b/usb/device/dev_hid_composite/CMakeLists.txt new file mode 100644 index 0000000..c1e97b8 --- /dev/null +++ b/usb/device/dev_hid_composite/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(dev_hid_composite + dev_hid_composite.c + usb_descriptors.c + ) + +target_include_directories(dev_hid_composite PRIVATE ${CMAKE_CURRENT_LIST_DIR}) + +target_link_libraries(dev_hid_composite PRIVATE pico_stdlib tinyusb_device tinyusb_board) +pico_add_extra_outputs(dev_hid_composite) + +# add url via pico_set_program_url +example_auto_set_url(dev_hid_composite) diff --git a/usb/device/dev_hid_composite/dev_hid_composite.c b/usb/device/dev_hid_composite/dev_hid_composite.c new file mode 100644 index 0000000..5f0ad1e --- /dev/null +++ b/usb/device/dev_hid_composite/dev_hid_composite.c @@ -0,0 +1,189 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include +#include +#include + +#include "bsp/board.h" +#include "tusb.h" + +#include "usb_descriptors.h" + +//--------------------------------------------------------------------+ +// MACRO CONSTANT TYPEDEF PROTYPES +//--------------------------------------------------------------------+ + +/* Blink pattern + * - 250 ms : device not mounted + * - 1000 ms : device mounted + * - 2500 ms : device is suspended + */ +enum { + BLINK_NOT_MOUNTED = 250, + BLINK_MOUNTED = 1000, + BLINK_SUSPENDED = 2500, +}; + +static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED; + +void led_blinking_task(void); +void hid_task(void); + +/*------------- MAIN -------------*/ +int main(void) { + board_init(); + tusb_init(); + + while (1) { + tud_task(); // tinyusb device task + led_blinking_task(); + + hid_task(); + } + + return 0; +} + +//--------------------------------------------------------------------+ +// Device callbacks +//--------------------------------------------------------------------+ + +// Invoked when device is mounted +void tud_mount_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +// Invoked when device is unmounted +void tud_umount_cb(void) { + blink_interval_ms = BLINK_NOT_MOUNTED; +} + +// Invoked when usb bus is suspended +// remote_wakeup_en : if host allow us to perform remote wakeup +// Within 7ms, device must draw an average of current less than 2.5 mA from bus +void tud_suspend_cb(bool remote_wakeup_en) { + (void) remote_wakeup_en; + blink_interval_ms = BLINK_SUSPENDED; +} + +// Invoked when usb bus is resumed +void tud_resume_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +//--------------------------------------------------------------------+ +// USB HID +//--------------------------------------------------------------------+ + +void hid_task(void) { + // Poll every 10ms + const uint32_t interval_ms = 10; + static uint32_t start_ms = 0; + + if (board_millis() - start_ms < interval_ms) return; // not enough time + start_ms += interval_ms; + + uint32_t const btn = 1; + + // Remote wakeup + if (tud_suspended() && btn) { + // Wake up host if we are in suspend mode + // and REMOTE_WAKEUP feature is enabled by host + tud_remote_wakeup(); + } + + /*------------- Mouse -------------*/ + if (tud_hid_ready()) { + if (btn) { + int8_t const delta = 5; + + // no button, right + down, no scroll pan + tud_hid_mouse_report(REPORT_ID_MOUSE, 0x00, delta, delta, 0, 0); + + // delay a bit before attempt to send keyboard report + board_delay(10); + } + } + + /*------------- Keyboard -------------*/ + if (tud_hid_ready()) { + // use to avoid send multiple consecutive zero report for keyboard + static bool has_key = false; + + static bool toggle = false; + if (toggle = !toggle) { + uint8_t keycode[6] = {0}; + keycode[0] = HID_KEY_A; + + tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, keycode); + + has_key = true; + } else { + // send empty key report if previously has key pressed + if (has_key) tud_hid_keyboard_report(REPORT_ID_KEYBOARD, 0, NULL); + has_key = false; + } + } +} + + +// Invoked when received GET_REPORT control request +// Application must fill buffer report's content and return its length. +// Return zero will cause the stack to STALL request +uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) { + // TODO not Implemented + (void) report_id; + (void) report_type; + (void) buffer; + (void) reqlen; + + return 0; +} + +// Invoked when received SET_REPORT control request or +// received data on OUT endpoint ( Report ID = 0, Type = 0 ) +void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize) { + // TODO set LED based on CAPLOCK, NUMLOCK etc... + (void) report_id; + (void) report_type; + (void) buffer; + (void) bufsize; +} + +//--------------------------------------------------------------------+ +// BLINKING TASK +//--------------------------------------------------------------------+ +void led_blinking_task(void) { + static uint32_t start_ms = 0; + static bool led_state = false; + + // Blink every interval ms + if (board_millis() - start_ms < blink_interval_ms) return; // not enough time + start_ms += blink_interval_ms; + + board_led_write(led_state); + led_state = 1 - led_state; // toggle +} diff --git a/usb/device/dev_hid_composite/tusb_config.h b/usb/device/dev_hid_composite/tusb_config.h new file mode 100644 index 0000000..b64d497 --- /dev/null +++ b/usb/device/dev_hid_composite/tusb_config.h @@ -0,0 +1,93 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _TUSB_CONFIG_H_ +#define _TUSB_CONFIG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +//-------------------------------------------------------------------- +// COMMON CONFIGURATION +//-------------------------------------------------------------------- + +// defined by compiler flags for flexibility +#ifndef CFG_TUSB_MCU +#error CFG_TUSB_MCU must be defined +#endif + +#if CFG_TUSB_MCU == OPT_MCU_LPC18XX || CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_MIMXRT10XX || \ + CFG_TUSB_MCU == OPT_MCU_NUC505 || CFG_TUSB_MCU == OPT_MCU_CXD56 +#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED) +#else +#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE +#endif + +#ifndef CFG_TUSB_OS +#define CFG_TUSB_OS OPT_OS_PICO +#endif + +// CFG_TUSB_DEBUG is defined by compiler in DEBUG build +// #define CFG_TUSB_DEBUG 0 + +/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment. + * Tinyusb use follows macros to declare transferring memory so that they can be put + * into those specific section. + * e.g + * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") )) + * - CFG_TUSB_MEM_ALIGN : __attribute__ ((aligned(4))) + */ +#ifndef CFG_TUSB_MEM_SECTION +#define CFG_TUSB_MEM_SECTION +#endif + +#ifndef CFG_TUSB_MEM_ALIGN +#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) +#endif + +//-------------------------------------------------------------------- +// DEVICE CONFIGURATION +//-------------------------------------------------------------------- + +#ifndef CFG_TUD_ENDPOINT0_SIZE +#define CFG_TUD_ENDPOINT0_SIZE 64 +#endif + +//------------- CLASS -------------// +#define CFG_TUD_HID 1 +#define CFG_TUD_CDC 0 +#define CFG_TUD_MSC 0 +#define CFG_TUD_MIDI 0 +#define CFG_TUD_VENDOR 0 + +// HID buffer size Should be sufficient to hold ID (if any) + Data +#define CFG_TUD_HID_BUFSIZE 16 + +#ifdef __cplusplus +} +#endif + +#endif /* _TUSB_CONFIG_H_ */ diff --git a/usb/device/dev_hid_composite/usb_descriptors.c b/usb/device/dev_hid_composite/usb_descriptors.c new file mode 100644 index 0000000..f6750f6 --- /dev/null +++ b/usb/device/dev_hid_composite/usb_descriptors.c @@ -0,0 +1,162 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include "tusb.h" +#include "usb_descriptors.h" + +/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug. + * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC. + * + * Auto ProductID layout's Bitmap: + * [MSB] HID | MSC | CDC [LSB] + */ +#define _PID_MAP(itf, n) ( (CFG_TUD_##itf) << (n) ) +#define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \ + _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) ) + +//--------------------------------------------------------------------+ +// Device Descriptors +//--------------------------------------------------------------------+ +tusb_desc_device_t const desc_device = + { + .bLength = sizeof(tusb_desc_device_t), + .bDescriptorType = TUSB_DESC_DEVICE, + .bcdUSB = 0x0200, + .bDeviceClass = 0x00, + .bDeviceSubClass = 0x00, + .bDeviceProtocol = 0x00, + .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE, + + .idVendor = 0xCafe, + .idProduct = USB_PID, + .bcdDevice = 0x0100, + + .iManufacturer = 0x01, + .iProduct = 0x02, + .iSerialNumber = 0x03, + + .bNumConfigurations = 0x01 + }; + +// Invoked when received GET DEVICE DESCRIPTOR +// Application return pointer to descriptor +uint8_t const *tud_descriptor_device_cb(void) { + return (uint8_t const *) &desc_device; +} + +//--------------------------------------------------------------------+ +// HID Report Descriptor +//--------------------------------------------------------------------+ + +uint8_t const desc_hid_report[] = + { + TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(REPORT_ID_KEYBOARD)), + TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(REPORT_ID_MOUSE)) + }; + +// Invoked when received GET HID REPORT DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const *tud_hid_descriptor_report_cb(void) { + return desc_hid_report; +} + +//--------------------------------------------------------------------+ +// Configuration Descriptor +//--------------------------------------------------------------------+ + +enum { + ITF_NUM_HID, + ITF_NUM_TOTAL +}; + +#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_HID_DESC_LEN) + +#define EPNUM_HID 0x81 + +uint8_t const desc_configuration[] = + { + // Config number, interface count, string index, total length, attribute, power in mA + TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100), + + // Interface number, string index, protocol, report descriptor len, EP In & Out address, size & polling interval + TUD_HID_DESCRIPTOR(ITF_NUM_HID, 0, HID_PROTOCOL_NONE, sizeof(desc_hid_report), EPNUM_HID, + CFG_TUD_HID_BUFSIZE, 10) + }; + +// Invoked when received GET CONFIGURATION DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const *tud_descriptor_configuration_cb(uint8_t index) { + (void) index; // for multiple configurations + return desc_configuration; +} + +//--------------------------------------------------------------------+ +// String Descriptors +//--------------------------------------------------------------------+ + +// array of pointer to string descriptors +char const *string_desc_arr[] = + { + (const char[]) {0x09, 0x04}, // 0: is supported language is English (0x0409) + "TinyUSB", // 1: Manufacturer + "TinyUSB Device", // 2: Product + "123456", // 3: Serials, should use chip ID + }; + +static uint16_t _desc_str[32]; + +// Invoked when received GET STRING DESCRIPTOR request +// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete +uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) { + (void) langid; + + uint8_t chr_count; + + if (index == 0) { + memcpy(&_desc_str[1], string_desc_arr[0], 2); + chr_count = 1; + } else { + // Convert ASCII string into UTF-16 + + if (!(index < sizeof(string_desc_arr) / sizeof(string_desc_arr[0]))) return NULL; + + const char *str = string_desc_arr[index]; + + // Cap at max char + chr_count = strlen(str); + if (chr_count > 31) chr_count = 31; + + for (uint8_t i = 0; i < chr_count; i++) { + _desc_str[1 + i] = str[i]; + } + } + + // first byte is length (including header), second byte is string type + _desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * chr_count + 2); + + return _desc_str; +} diff --git a/usb/device/dev_hid_composite/usb_descriptors.h b/usb/device/dev_hid_composite/usb_descriptors.h new file mode 100644 index 0000000..9bd12b6 --- /dev/null +++ b/usb/device/dev_hid_composite/usb_descriptors.h @@ -0,0 +1,33 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef USB_DESCRIPTORS_H_ +#define USB_DESCRIPTORS_H_ + +enum { + REPORT_ID_KEYBOARD = 1, + REPORT_ID_MOUSE +}; + +#endif /* USB_DESCRIPTORS_H_ */ diff --git a/usb/device/dev_hid_generic_inout/CMakeLists.txt b/usb/device/dev_hid_generic_inout/CMakeLists.txt new file mode 100644 index 0000000..36c2653 --- /dev/null +++ b/usb/device/dev_hid_generic_inout/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(dev_hid_generic_inout + dev_hid_generic_inout.c + usb_descriptors.c + ) + +target_include_directories(dev_hid_generic_inout PRIVATE ${CMAKE_CURRENT_LIST_DIR}) + +target_link_libraries(dev_hid_generic_inout PRIVATE pico_stdlib tinyusb_device tinyusb_board) +pico_add_extra_outputs(dev_hid_generic_inout) + +# add url via pico_set_program_url +example_auto_set_url(dev_hid_generic_inout) diff --git a/usb/device/dev_hid_generic_inout/dev_hid_generic_inout.c b/usb/device/dev_hid_generic_inout/dev_hid_generic_inout.c new file mode 100644 index 0000000..780b50f --- /dev/null +++ b/usb/device/dev_hid_generic_inout/dev_hid_generic_inout.c @@ -0,0 +1,152 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include +#include +#include + +#include "bsp/board.h" +#include "tusb.h" + +/* This example demonstrate HID Generic raw Input & Output. + * It will receive data from Host (In endpoint) and echo back (Out endpoint). + * HID Report descriptor use vendor for usage page (using template TUD_HID_REPORT_DESC_GENERIC_INOUT) + * + * There are 2 ways to test the sketch + * 1. Using nodejs + * - Install nodejs and nmp to your PC + * - Install execellent node-hid (https://github.com/node-hid/node-hid) by + * $ npm install node-hid + * - Run provided hid test script + * $ node hid_test.js + * + * 2. Using python hidRun + * - Python and `hid` package is required, for installation please follow https://pypi.org/project/hid/ + * - Run provided hid test script to send and receive data to this device. + * $ python3 hid_test.py + */ + +//--------------------------------------------------------------------+ +// MACRO CONSTANT TYPEDEF PROTYPES +//--------------------------------------------------------------------+ + +/* Blink pattern + * - 250 ms : device not mounted + * - 1000 ms : device mounted + * - 2500 ms : device is suspended + */ +enum { + BLINK_NOT_MOUNTED = 250, + BLINK_MOUNTED = 1000, + BLINK_SUSPENDED = 2500, +}; + +static uint32_t blink_interval_ms = BLINK_NOT_MOUNTED; + +void led_blinking_task(void); + +/*------------- MAIN -------------*/ +int main(void) { + board_init(); + + tusb_init(); + + while (1) { + tud_task(); // tinyusb device task + led_blinking_task(); + } + + return 0; +} + +//--------------------------------------------------------------------+ +// Device callbacks +//--------------------------------------------------------------------+ + +// Invoked when device is mounted +void tud_mount_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +// Invoked when device is unmounted +void tud_umount_cb(void) { + blink_interval_ms = BLINK_NOT_MOUNTED; +} + +// Invoked when usb bus is suspended +// remote_wakeup_en : if host allow us to perform remote wakeup +// Within 7ms, device must draw an average of current less than 2.5 mA from bus +void tud_suspend_cb(bool remote_wakeup_en) { + (void) remote_wakeup_en; + blink_interval_ms = BLINK_SUSPENDED; +} + +// Invoked when usb bus is resumed +void tud_resume_cb(void) { + blink_interval_ms = BLINK_MOUNTED; +} + +//--------------------------------------------------------------------+ +// USB HID +//--------------------------------------------------------------------+ + +// Invoked when received GET_REPORT control request +// Application must fill buffer report's content and return its length. +// Return zero will cause the stack to STALL request +uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) { + // TODO not Implemented + (void) report_id; + (void) report_type; + (void) buffer; + (void) reqlen; + + return 0; +} + +// Invoked when received SET_REPORT control request or +// received data on OUT endpoint ( Report ID = 0, Type = 0 ) +void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const *buffer, uint16_t bufsize) { + // This example doesn't use multiple report and report ID + (void) report_id; + (void) report_type; + + // echo back anything we received from host + tud_hid_report(0, buffer, bufsize); +} + +//--------------------------------------------------------------------+ +// BLINKING TASK +//--------------------------------------------------------------------+ +void led_blinking_task(void) { + static uint32_t start_ms = 0; + static bool led_state = false; + + // Blink every interval ms + if (board_millis() - start_ms < blink_interval_ms) return; // not enough time + start_ms += blink_interval_ms; + + board_led_write(led_state); + led_state = 1 - led_state; // toggle +} diff --git a/usb/device/dev_hid_generic_inout/tusb_config.h b/usb/device/dev_hid_generic_inout/tusb_config.h new file mode 100644 index 0000000..49dcd8c --- /dev/null +++ b/usb/device/dev_hid_generic_inout/tusb_config.h @@ -0,0 +1,93 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _TUSB_CONFIG_H_ +#define _TUSB_CONFIG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +//-------------------------------------------------------------------- +// COMMON CONFIGURATION +//-------------------------------------------------------------------- + +// defined by compiler flags for flexibility +#ifndef CFG_TUSB_MCU +#error CFG_TUSB_MCU must be defined +#endif + +#if CFG_TUSB_MCU == OPT_MCU_LPC18XX || CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_MIMXRT10XX || \ + CFG_TUSB_MCU == OPT_MCU_NUC505 || CFG_TUSB_MCU == OPT_MCU_CXD56 +#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED) +#else +#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE +#endif + +#ifndef CFG_TUSB_OS +#define CFG_TUSB_OS OPT_OS_PICO +#endif + +// CFG_TUSB_DEBUG is defined by compiler in DEBUG build +// #define CFG_TUSB_DEBUG 0 + +/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment. + * Tinyusb use follows macros to declare transferring memory so that they can be put + * into those specific section. + * e.g + * - CFG_TUSB_MEM SECTION : __attribute__ (( section(".usb_ram") )) + * - CFG_TUSB_MEM_ALIGN : __attribute__ ((aligned(4))) + */ +#ifndef CFG_TUSB_MEM_SECTION +#define CFG_TUSB_MEM_SECTION +#endif + +#ifndef CFG_TUSB_MEM_ALIGN +#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) +#endif + +//-------------------------------------------------------------------- +// DEVICE CONFIGURATION +//-------------------------------------------------------------------- + +#ifndef CFG_TUD_ENDPOINT0_SIZE +#define CFG_TUD_ENDPOINT0_SIZE 64 +#endif + +//------------- CLASS -------------// +#define CFG_TUD_CDC 0 +#define CFG_TUD_MSC 0 +#define CFG_TUD_HID 1 +#define CFG_TUD_MIDI 0 +#define CFG_TUD_VENDOR 0 + +// HID buffer size Should be sufficient to hold ID (if any) + Data +#define CFG_TUD_HID_BUFSIZE 64 + +#ifdef __cplusplus +} +#endif + +#endif /* _TUSB_CONFIG_H_ */ diff --git a/usb/device/dev_hid_generic_inout/usb_descriptors.c b/usb/device/dev_hid_generic_inout/usb_descriptors.c new file mode 100644 index 0000000..5cdd3ce --- /dev/null +++ b/usb/device/dev_hid_generic_inout/usb_descriptors.c @@ -0,0 +1,160 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include "tusb.h" + +/* A combination of interfaces must have a unique product id, since PC will save device driver after the first plug. + * Same VID/PID with different interface e.g MSC (first), then CDC (later) will possibly cause system error on PC. + * + * Auto ProductID layout's Bitmap: + * [MSB] HID | MSC | CDC [LSB] + */ +#define _PID_MAP(itf, n) ( (CFG_TUD_##itf) << (n) ) +#define USB_PID (0x4000 | _PID_MAP(CDC, 0) | _PID_MAP(MSC, 1) | _PID_MAP(HID, 2) | \ + _PID_MAP(MIDI, 3) | _PID_MAP(VENDOR, 4) ) + +//--------------------------------------------------------------------+ +// Device Descriptors +//--------------------------------------------------------------------+ +tusb_desc_device_t const desc_device = + { + .bLength = sizeof(tusb_desc_device_t), + .bDescriptorType = TUSB_DESC_DEVICE, + .bcdUSB = 0x0200, + .bDeviceClass = 0x00, + .bDeviceSubClass = 0x00, + .bDeviceProtocol = 0x00, + .bMaxPacketSize0 = CFG_TUD_ENDPOINT0_SIZE, + + .idVendor = 0xCafe, + .idProduct = USB_PID, + .bcdDevice = 0x0100, + + .iManufacturer = 0x01, + .iProduct = 0x02, + .iSerialNumber = 0x03, + + .bNumConfigurations = 0x01 + }; + +// Invoked when received GET DEVICE DESCRIPTOR +// Application return pointer to descriptor +uint8_t const *tud_descriptor_device_cb(void) { + return (uint8_t const *) &desc_device; +} + +//--------------------------------------------------------------------+ +// HID Report Descriptor +//--------------------------------------------------------------------+ + +uint8_t const desc_hid_report[] = + { + TUD_HID_REPORT_DESC_GENERIC_INOUT(CFG_TUD_HID_BUFSIZE) + }; + +// Invoked when received GET HID REPORT DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const *tud_hid_descriptor_report_cb(void) { + return desc_hid_report; +} + +//--------------------------------------------------------------------+ +// Configuration Descriptor +//--------------------------------------------------------------------+ + +enum { + ITF_NUM_HID, + ITF_NUM_TOTAL +}; + +#define CONFIG_TOTAL_LEN (TUD_CONFIG_DESC_LEN + TUD_HID_INOUT_DESC_LEN) + +#define EPNUM_HID 0x01 + +uint8_t const desc_configuration[] = + { + // Config number, interface count, string index, total length, attribute, power in mA + TUD_CONFIG_DESCRIPTOR(1, ITF_NUM_TOTAL, 0, CONFIG_TOTAL_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100), + + // Interface number, string index, protocol, report descriptor len, EP In & Out address, size & polling interval + TUD_HID_INOUT_DESCRIPTOR(ITF_NUM_HID, 0, HID_PROTOCOL_NONE, sizeof(desc_hid_report), EPNUM_HID, + 0x80 | EPNUM_HID, CFG_TUD_HID_BUFSIZE, 10) + }; + +// Invoked when received GET CONFIGURATION DESCRIPTOR +// Application return pointer to descriptor +// Descriptor contents must exist long enough for transfer to complete +uint8_t const *tud_descriptor_configuration_cb(uint8_t index) { + (void) index; // for multiple configurations + return desc_configuration; +} + +//--------------------------------------------------------------------+ +// String Descriptors +//--------------------------------------------------------------------+ + +// array of pointer to string descriptors +char const *string_desc_arr[] = + { + (const char[]) {0x09, 0x04}, // 0: is supported language is English (0x0409) + "TinyUSB", // 1: Manufacturer + "TinyUSB Device", // 2: Product + "123456", // 3: Serials, should use chip ID + }; + +static uint16_t _desc_str[32]; + +// Invoked when received GET STRING DESCRIPTOR request +// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete +uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid) { + (void) langid; + + uint8_t chr_count; + + if (index == 0) { + memcpy(&_desc_str[1], string_desc_arr[0], 2); + chr_count = 1; + } else { + // Convert ASCII string into UTF-16 + + if (!(index < sizeof(string_desc_arr) / sizeof(string_desc_arr[0]))) return NULL; + + const char *str = string_desc_arr[index]; + + // Cap at max char + chr_count = strlen(str); + if (chr_count > 31) chr_count = 31; + + for (uint8_t i = 0; i < chr_count; i++) { + _desc_str[1 + i] = str[i]; + } + } + + // first byte is length (including header), second byte is string type + _desc_str[0] = (TUSB_DESC_STRING << 8) | (2 * chr_count + 2); + + return _desc_str; +} diff --git a/usb/device/dev_lowlevel/CMakeLists.txt b/usb/device/dev_lowlevel/CMakeLists.txt new file mode 100644 index 0000000..906c84e --- /dev/null +++ b/usb/device/dev_lowlevel/CMakeLists.txt @@ -0,0 +1,9 @@ +add_executable(dev_lowlevel + dev_lowlevel.c + ) + +target_link_libraries(dev_lowlevel PRIVATE pico_stdlib hardware_resets hardware_irq) +pico_add_extra_outputs(dev_lowlevel) + +# add url via pico_set_program_url +example_auto_set_url(dev_lowlevel) diff --git a/usb/device/dev_lowlevel/dev_lowlevel.c b/usb/device/dev_lowlevel/dev_lowlevel.c new file mode 100644 index 0000000..9115914 --- /dev/null +++ b/usb/device/dev_lowlevel/dev_lowlevel.c @@ -0,0 +1,572 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +// Pico +#include "pico/stdlib.h" + +// For memcpy +#include + +// Include descriptor struct definitions +#include "usb_common.h" +// USB register definitions from pico-sdk +#include "hardware/regs/usb.h" +// USB hardware struct definitions from pico-sdk +#include "hardware/structs/usb.h" +// For interrupt enable and numbers +#include "hardware/irq.h" +// For resetting the USB controller +#include "hardware/resets.h" + +// Device descriptors +#include "dev_lowlevel.h" + +#define usb_hw_set hw_set_alias(usb_hw) +#define usb_hw_clear hw_clear_alias(usb_hw) + +// Function prototypes for our device specific endpoint handlers defined +// later on +void ep0_in_handler(uint8_t *buf, uint16_t len); +void ep0_out_handler(uint8_t *buf, uint16_t len); +void ep1_out_handler(uint8_t *buf, uint16_t len); +void ep2_in_handler(uint8_t *buf, uint16_t len); + +// Global device address +static bool should_set_address = false; +static uint8_t dev_addr = 0; +static volatile bool configured = false; + +// Global data buffer for EP0 +static uint8_t ep0_buf[64]; + +// Struct defining the device configuration +static struct usb_device_configuration dev_config = { + .device_descriptor = &device_descriptor, + .interface_descriptor = &interface_descriptor, + .config_descriptor = &config_descriptor, + .lang_descriptor = lang_descriptor, + .descriptor_strings = descriptor_strings, + .endpoints = { + { + .descriptor = &ep0_out, + .handler = &ep0_out_handler, + .endpoint_control = NULL, // NA for EP0 + .buffer_control = &usb_dpram->ep_buf_ctrl[0].out, + // EP0 in and out share a data buffer + .data_buffer = &usb_dpram->ep0_buf_a[0], + }, + { + .descriptor = &ep0_in, + .handler = &ep0_in_handler, + .endpoint_control = NULL, // NA for EP0, + .buffer_control = &usb_dpram->ep_buf_ctrl[0].in, + // EP0 in and out share a data buffer + .data_buffer = &usb_dpram->ep0_buf_a[0], + }, + { + .descriptor = &ep1_out, + .handler = &ep1_out_handler, + // EP1 starts at offset 0 for endpoint control + .endpoint_control = &usb_dpram->ep_ctrl[0].out, + .buffer_control = &usb_dpram->ep_buf_ctrl[1].out, + // First free EPX buffer + .data_buffer = &usb_dpram->epx_data[0 * 64], + }, + { + .descriptor = &ep2_in, + .handler = &ep2_in_handler, + .endpoint_control = &usb_dpram->ep_ctrl[1].in, + .buffer_control = &usb_dpram->ep_buf_ctrl[2].in, + // Second free EPX buffer + .data_buffer = &usb_dpram->epx_data[1 * 64], + } + } +}; + +/** + * @brief Given an endpoint address, return the usb_endpoint_configuration of that endpoint. Returns NULL + * if an endpoint of that address is not found. + * + * @param addr + * @return struct usb_endpoint_configuration* + */ +struct usb_endpoint_configuration *usb_get_endpoint_configuration(uint8_t addr) { + struct usb_endpoint_configuration *endpoints = dev_config.endpoints; + for (int i = 0; i < USB_NUM_ENDPOINTS; i++) { + if (endpoints[i].descriptor && (endpoints[i].descriptor->bEndpointAddress == addr)) { + return &endpoints[i]; + } + } + return NULL; +} + +/** + * @brief Given a C string, fill the EP0 data buf with a USB string descriptor for that string. + * + * @param C string you would like to send to the USB host + * @return the length of the string descriptor in EP0 buf + */ +uint8_t usb_prepare_string_descriptor(const unsigned char *str) { + // 2 for bLength + bDescriptorType + strlen * 2 because string is unicode. i.e. other byte will be 0 + uint8_t bLength = 2 + (strlen(str) * 2); + static const uint8_t bDescriptorType = 0x03; + + volatile uint8_t *buf = &ep0_buf[0]; + *buf++ = bLength; + *buf++ = bDescriptorType; + + uint8_t c; + + do { + c = *str++; + *buf++ = c; + *buf++ = 0; + } while (c != '\0'); + + return bLength; +} + +/** + * @brief Take a buffer pointer located in the USB RAM and return as an offset of the RAM. + * + * @param buf + * @return uint32_t + */ +static inline uint32_t usb_buffer_offset(volatile uint8_t *buf) { + return (uint32_t) buf ^ (uint32_t) usb_dpram; +} + +/** + * @brief Set up the endpoint control register for an endpoint (if applicable. Not valid for EP0). + * + * @param ep + */ +void usb_setup_endpoint(const struct usb_endpoint_configuration *ep) { + printf("Set up endpoint 0x%x with buffer address 0x%p\n", ep->descriptor->bEndpointAddress, ep->data_buffer); + + // EP0 doesn't have one so return if that is the case + if (!ep->endpoint_control) { + return; + } + + // Get the data buffer as an offset of the USB controller's DPRAM + uint32_t dpram_offset = usb_buffer_offset(ep->data_buffer); + uint32_t reg = EP_CTRL_ENABLE_BITS + | EP_CTRL_INTERRUPT_PER_BUFFER + | (ep->descriptor->bmAttributes << EP_CTRL_BUFFER_TYPE_LSB) + | dpram_offset; + *ep->endpoint_control = reg; +} + +/** + * @brief Set up the endpoint control register for each endpoint. + * + */ +void usb_setup_endpoints() { + const struct usb_endpoint_configuration *endpoints = dev_config.endpoints; + for (int i = 0; i < USB_NUM_ENDPOINTS; i++) { + if (endpoints[i].descriptor && endpoints[i].handler) { + usb_setup_endpoint(&endpoints[i]); + } + } +} + +/** + * @brief Set up the USB controller in device mode, clearing any previous state. + * + */ +void usb_device_init() { + // Reset usb controller + reset_block(RESETS_RESET_USBCTRL_BITS); + unreset_block_wait(RESETS_RESET_USBCTRL_BITS); + + // Clear any previous state in dpram just in case + memset(usb_dpram, 0, sizeof(*usb_dpram)); // <1> + + // Enable USB interrupt at processor + irq_set_enabled(USBCTRL_IRQ, true); + + // Mux the controller to the onboard usb phy + usb_hw->muxing = USB_USB_MUXING_TO_PHY_BITS | USB_USB_MUXING_SOFTCON_BITS; + + // Force VBUS detect so the device thinks it is plugged into a host + usb_hw->pwr = USB_USB_PWR_VBUS_DETECT_BITS | USB_USB_PWR_VBUS_DETECT_OVERRIDE_EN_BITS; + + // Enable the USB controller in device mode. + usb_hw->main_ctrl = USB_MAIN_CTRL_CONTROLLER_EN_BITS; + + // Enable an interrupt per EP0 transaction + usb_hw->sie_ctrl = USB_SIE_CTRL_EP0_INT_1BUF_BITS; // <2> + + // Enable interrupts for when a buffer is done, when the bus is reset, + // and when a setup packet is received + usb_hw->inte = USB_INTS_BUFF_STATUS_BITS | + USB_INTS_BUS_RESET_BITS | + USB_INTS_SETUP_REQ_BITS; + + // Set up endpoints (endpoint control registers) + // described by device configuration + usb_setup_endpoints(); + + // Present full speed device by enabling pull up on DP + usb_hw_set->sie_ctrl = USB_SIE_CTRL_PULLUP_EN_BITS; +} + +/** + * @brief Given an endpoint configuration, returns true if the endpoint + * is transmitting data to the host (i.e. is an IN endpoint) + * + * @param ep, the endpoint configuration + * @return true + * @return false + */ +static inline bool ep_is_tx(struct usb_endpoint_configuration *ep) { + return ep->descriptor->bEndpointAddress & USB_DIR_IN; +} + +/** + * @brief Starts a transfer on a given endpoint. + * + * @param ep, the endpoint configuration. + * @param buf, the data buffer to send. Only applicable if the endpoint is TX + * @param len, the length of the data in buf (this example limits max len to one packet - 64 bytes) + */ +void usb_start_transfer(struct usb_endpoint_configuration *ep, uint8_t *buf, uint16_t len) { + // We are asserting that the length is <= 64 bytes for simplicity of the example. + // For multi packet transfers see the tinyusb port. + assert(len <= 64); + + printf("Start transfer of len %d on ep addr 0x%x\n", len, ep->descriptor->bEndpointAddress); + + // Prepare buffer control register value + uint32_t val = len | USB_BUF_CTRL_AVAIL; + + if (ep_is_tx(ep)) { + // Need to copy the data from the user buffer to the usb memory + memcpy((void *) ep->data_buffer, (void *) buf, len); + // Mark as full + val |= USB_BUF_CTRL_FULL; + } + + // Set pid and flip for next transfer + val |= ep->next_pid ? USB_BUF_CTRL_DATA1_PID : USB_BUF_CTRL_DATA0_PID; + ep->next_pid ^= 1u; + + *ep->buffer_control = val; +} + +/** + * @brief Send device descriptor to host + * + */ +void usb_handle_device_descriptor(void) { + const struct usb_device_descriptor *d = dev_config.device_descriptor; + // EP0 in + struct usb_endpoint_configuration *ep = usb_get_endpoint_configuration(EP0_IN_ADDR); + // Always respond with pid 1 + ep->next_pid = 1; + usb_start_transfer(ep, (uint8_t *) d, sizeof(struct usb_device_descriptor)); +} + +/** + * @brief Send the configuration descriptor (and potentially the configuration and endpoint descriptors) to the host. + * + * @param pkt, the setup packet received from the host. + */ +void usb_handle_config_descriptor(volatile struct usb_setup_packet *pkt) { + uint8_t *buf = &ep0_buf[0]; + + // First request will want just the config descriptor + const struct usb_configuration_descriptor *d = dev_config.config_descriptor; + memcpy((void *) buf, d, sizeof(struct usb_configuration_descriptor)); + buf += sizeof(struct usb_configuration_descriptor); + + // If we more than just the config descriptor copy it all + if (pkt->wLength >= d->wTotalLength) { + memcpy((void *) buf, dev_config.interface_descriptor, sizeof(struct usb_interface_descriptor)); + buf += sizeof(struct usb_interface_descriptor); + const struct usb_endpoint_configuration *ep = dev_config.endpoints; + + // Copy all the endpoint descriptors starting from EP1 + for (uint i = 2; i < USB_NUM_ENDPOINTS; i++) { + if (ep[i].descriptor) { + memcpy((void *) buf, ep[i].descriptor, sizeof(struct usb_endpoint_descriptor)); + buf += sizeof(struct usb_endpoint_descriptor); + } + } + + } + + // Send data + // Get len by working out end of buffer subtract start of buffer + uint32_t len = (uint32_t) buf - (uint32_t) &ep0_buf[0]; + usb_start_transfer(usb_get_endpoint_configuration(EP0_IN_ADDR), &ep0_buf[0], len); +} + +/** + * @brief Handle a BUS RESET from the host by setting the device address back to 0. + * + */ +void usb_bus_reset(void) { + // Set address back to 0 + dev_addr = 0; + should_set_address = false; + usb_hw->dev_addr_ctrl = 0; + configured = false; +} + +/** + * @brief Send the requested string descriptor to the host. + * + * @param pkt, the setup packet from the host. + */ +void usb_handle_string_descriptor(volatile struct usb_setup_packet *pkt) { + uint8_t i = pkt->wValue & 0xff; + uint8_t len = 0; + + if (i == 0) { + len = 4; + memcpy(&ep0_buf[0], dev_config.lang_descriptor, len); + } else { + // Prepare fills in ep0_buf + len = usb_prepare_string_descriptor(dev_config.descriptor_strings[i - 1]); + } + + usb_start_transfer(usb_get_endpoint_configuration(EP0_IN_ADDR), &ep0_buf[0], len); +} + +/** + * @brief Handles a SET_ADDR request from the host. The actual setting of the device address in + * hardware is done in ep0_in_handler. This is because we have to acknowledge the request first + * as a device with address zero. + * + * @param pkt, the setup packet from the host. + */ +void usb_set_device_address(volatile struct usb_setup_packet *pkt) { + // Set address is a bit of a strange case because we have to send a 0 length status packet first with + // address 0 + dev_addr = (pkt->wValue & 0xff); + printf("Set address %d\r\n", dev_addr); + // Will set address in the callback phase + should_set_address = true; + usb_start_transfer(usb_get_endpoint_configuration(EP0_IN_ADDR), NULL, 0); +} + +/** + * @brief Handles a SET_CONFIGRUATION request from the host. Assumes one configuration so simply + * sends a zero length status packet back to the host. + * + * @param pkt, the setup packet from the host. + */ +void usb_set_device_configuration(volatile struct usb_setup_packet *pkt) { + // Only one configuration so just acknowledge the request + printf("Device Enumerated\r\n"); + usb_start_transfer(usb_get_endpoint_configuration(EP0_IN_ADDR), NULL, 0); + configured = true; +} + +/** + * @brief Respond to a setup packet from the host. + * + */ +void usb_handle_setup_packet(void) { + volatile struct usb_setup_packet *pkt = (volatile struct usb_setup_packet *) &usb_dpram->setup_packet; + uint8_t req_direction = pkt->bmRequestType; + uint8_t req = pkt->bRequest; + + // Reset PID to 1 for EP0 IN + usb_get_endpoint_configuration(EP0_IN_ADDR)->next_pid = 1u; + + if (req_direction == USB_DIR_OUT) { + if (req == USB_REQUEST_SET_ADDRESS) { + usb_set_device_address(pkt); + } else if (req == USB_REQUEST_SET_CONFIGURATION) { + usb_set_device_configuration(pkt); + } else { + printf("Other OUT request (0x%x)\r\n", pkt->bRequest); + } + } else if (req_direction == USB_DIR_IN) { + if (req == USB_REQUEST_GET_DESCRIPTOR) { + uint16_t descriptor_type = pkt->wValue >> 8; + + switch (descriptor_type) { + case USB_DT_DEVICE: + usb_handle_device_descriptor(); + printf("GET DEVICE DESCRIPTOR\r\n"); + break; + + case USB_DT_CONFIG: + usb_handle_config_descriptor(pkt); + printf("GET CONFIG DESCRIPTOR\r\n"); + break; + + case USB_DT_STRING: + usb_handle_string_descriptor(pkt); + printf("GET STRING DESCRIPTOR\r\n"); + break; + + default: + printf("Unhandled GET_DESCRIPTOR type 0x%x\r\n", descriptor_type); + } + } else { + printf("Other IN request (0x%x)\r\n", pkt->bRequest); + } + } +} + +/** + * @brief Notify an endpoint that a transfer has completed. + * + * @param ep, the endpoint to notify. + */ +static void usb_handle_ep_buff_done(struct usb_endpoint_configuration *ep) { + uint32_t buffer_control = *ep->buffer_control; + // Get the transfer length for this endpoint + uint16_t len = buffer_control & USB_BUF_CTRL_LEN_MASK; + + // Call that endpoints buffer done handler + ep->handler((uint8_t *) ep->data_buffer, len); +} + +/** + * @brief Find the endpoint configuration for a specified endpoint number and + * direction and notify it that a transfer has completed. + * + * @param ep_num + * @param in + */ +static void usb_handle_buff_done(uint ep_num, bool in) { + uint8_t ep_addr = ep_num | (in ? USB_DIR_IN : 0); + printf("EP %d (in = %d) done\n", ep_num, in); + for (uint i = 0; i < USB_NUM_ENDPOINTS; i++) { + struct usb_endpoint_configuration *ep = &dev_config.endpoints[i]; + if (ep->descriptor && ep->handler) { + if (ep->descriptor->bEndpointAddress == ep_addr) { + usb_handle_ep_buff_done(ep); + return; + } + } + } +} + +/** + * @brief Handle a "buffer status" irq. This means that one or more + * buffers have been sent / received. Notify each endpoint where this + * is the case. + */ +static void usb_handle_buff_status() { + uint32_t buffers = usb_hw->buf_status; + uint32_t remaining_buffers = buffers; + + uint bit = 1u; + for (uint i = 0; remaining_buffers && i < USB_NUM_ENDPOINTS * 2; i++) { + if (remaining_buffers & bit) { + // clear this in advance + usb_hw_clear->buf_status = bit; + // IN transfer for even i, OUT transfer for odd i + usb_handle_buff_done(i >> 1u, !(i & 1u)); + remaining_buffers &= ~bit; + } + bit <<= 1u; + } +} + +/** + * @brief USB interrupt handler + * + */ +// tag::isr_setup_packet[] +void isr_usbctrl(void) { + // USB interrupt handler + uint32_t status = usb_hw->ints; + uint32_t handled = 0; + + // Setup packet received + if (status & USB_INTS_SETUP_REQ_BITS) { + handled |= USB_INTS_SETUP_REQ_BITS; + usb_hw_clear->sie_status = USB_SIE_STATUS_SETUP_REC_BITS; + usb_handle_setup_packet(); + } +// end::isr_setup_packet[] + + // Buffer status, one or more buffers have completed + if (status & USB_INTS_BUFF_STATUS_BITS) { + handled |= USB_INTS_BUFF_STATUS_BITS; + usb_handle_buff_status(); + } + + // Bus is reset + if (status & USB_INTS_BUS_RESET_BITS) { + printf("BUS RESET\n"); + handled |= USB_INTS_BUS_RESET_BITS; + usb_hw_clear->sie_status = USB_SIE_STATUS_BUS_RESET_BITS; + usb_bus_reset(); + } + + if (status ^ handled) { + panic("Unhandled IRQ 0x%x\n", (uint) (status ^ handled)); + } +} + +/** + * @brief EP0 in transfer complete. Either finish the SET_ADDRESS process, or receive a zero + * length status packet from the host. + * + * @param buf the data that was sent + * @param len the length that was sent + */ +void ep0_in_handler(uint8_t *buf, uint16_t len) { + if (should_set_address) { + // Set actual device address in hardware + usb_hw->dev_addr_ctrl = dev_addr; + should_set_address = false; + } else { + // Receive a zero length status packet from the host on EP0 OUT + struct usb_endpoint_configuration *ep = usb_get_endpoint_configuration(EP0_OUT_ADDR); + usb_start_transfer(ep, NULL, 0); + } +} + +void ep0_out_handler(uint8_t *buf, uint16_t len) { + ; +} + +// Device specific functions +void ep1_out_handler(uint8_t *buf, uint16_t len) { + printf("RX %d bytes from host\n", len); + // Send data back to host + struct usb_endpoint_configuration *ep = usb_get_endpoint_configuration(EP2_IN_ADDR); + usb_start_transfer(ep, buf, len); +} + +void ep2_in_handler(uint8_t *buf, uint16_t len) { + printf("Sent %d bytes to host\n", len); + // Get ready to rx again from host + usb_start_transfer(usb_get_endpoint_configuration(EP1_OUT_ADDR), NULL, 64); +} + +int main(void) { + stdio_init_all(); + printf("USB Device Low-Level hardware example\n"); + usb_device_init(); + + // Wait until configured + while (!configured) { + tight_loop_contents(); + } + + // Get ready to rx from host + usb_start_transfer(usb_get_endpoint_configuration(EP1_OUT_ADDR), NULL, 64); + + // Everything is interrupt driven so just loop here + while (1) { + tight_loop_contents(); + } + + return 0; +} \ No newline at end of file diff --git a/usb/device/dev_lowlevel/dev_lowlevel.h b/usb/device/dev_lowlevel/dev_lowlevel.h new file mode 100644 index 0000000..afe29cb --- /dev/null +++ b/usb/device/dev_lowlevel/dev_lowlevel.h @@ -0,0 +1,136 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef DEV_LOWLEVEL_H_ +#define DEV_LOWLEVEL_H_ + +#include "usb_common.h" + +// Struct in which we keep the endpoint configuration +typedef void (*usb_ep_handler)(uint8_t *buf, uint16_t len); +struct usb_endpoint_configuration { + const struct usb_endpoint_descriptor *descriptor; + usb_ep_handler handler; + + // Pointers to endpoint + buffer control registers + // in the USB controller DPSRAM + volatile uint32_t *endpoint_control; + volatile uint32_t *buffer_control; + volatile uint8_t *data_buffer; + + // Toggle after each packet (unless replying to a SETUP) + uint8_t next_pid; +}; + +// Struct in which we keep the device configuration +struct usb_device_configuration { + const struct usb_device_descriptor *device_descriptor; + const struct usb_interface_descriptor *interface_descriptor; + const struct usb_configuration_descriptor *config_descriptor; + const unsigned char *lang_descriptor; + const unsigned char **descriptor_strings; + // USB num endpoints is 16 + struct usb_endpoint_configuration endpoints[USB_NUM_ENDPOINTS]; +}; + +#define EP0_IN_ADDR (USB_DIR_IN | 0) +#define EP0_OUT_ADDR (USB_DIR_OUT | 0) +#define EP1_OUT_ADDR (USB_DIR_OUT | 1) +#define EP2_IN_ADDR (USB_DIR_IN | 2) + +// EP0 IN and OUT +static const struct usb_endpoint_descriptor ep0_out = { + .bLength = sizeof(struct usb_endpoint_descriptor), + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = EP0_OUT_ADDR, // EP number 0, OUT from host (rx to device) + .bmAttributes = USB_TRANSFER_TYPE_CONTROL, + .wMaxPacketSize = 64, + .bInterval = 0 +}; + +static const struct usb_endpoint_descriptor ep0_in = { + .bLength = sizeof(struct usb_endpoint_descriptor), + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = EP0_IN_ADDR, // EP number 0, OUT from host (rx to device) + .bmAttributes = USB_TRANSFER_TYPE_CONTROL, + .wMaxPacketSize = 64, + .bInterval = 0 +}; + +// Descriptors +static const struct usb_device_descriptor device_descriptor = { + .bLength = sizeof(struct usb_device_descriptor), + .bDescriptorType = USB_DT_DEVICE, + .bcdUSB = 0x0110, // USB 1.1 device + .bDeviceClass = 0, // Specified in interface descriptor + .bDeviceSubClass = 0, // No subclass + .bDeviceProtocol = 0, // No protocol + .bMaxPacketSize0 = 64, // Max packet size for ep0 + .idVendor = 0x0000, // Your vendor id + .idProduct = 0x0001, // Your product ID + .bcdDevice = 0, // No device revision number + .iManufacturer = 1, // Manufacturer string index + .iProduct = 2, // Product string index + .iSerialNumber = 0, // No serial number + .bNumConfigurations = 1 // One configuration +}; + +static const struct usb_interface_descriptor interface_descriptor = { + .bLength = sizeof(struct usb_interface_descriptor), + .bDescriptorType = USB_DT_INTERFACE, + .bInterfaceNumber = 0, + .bAlternateSetting = 0, + .bNumEndpoints = 2, // Interface has 2 endpoints + .bInterfaceClass = 0xff, // Vendor specific endpoint + .bInterfaceSubClass = 0, + .bInterfaceProtocol = 0, + .iInterface = 0 +}; + +static const struct usb_endpoint_descriptor ep1_out = { + .bLength = sizeof(struct usb_endpoint_descriptor), + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = EP1_OUT_ADDR, // EP number 1, OUT from host (rx to device) + .bmAttributes = USB_TRANSFER_TYPE_BULK, + .wMaxPacketSize = 64, + .bInterval = 0 +}; + +static const struct usb_endpoint_descriptor ep2_in = { + .bLength = sizeof(struct usb_endpoint_descriptor), + .bDescriptorType = USB_DT_ENDPOINT, + .bEndpointAddress = EP2_IN_ADDR, // EP number 2, IN from host (tx from device) + .bmAttributes = USB_TRANSFER_TYPE_BULK, + .wMaxPacketSize = 64, + .bInterval = 0 +}; + +static const struct usb_configuration_descriptor config_descriptor = { + .bLength = sizeof(struct usb_configuration_descriptor), + .bDescriptorType = USB_DT_CONFIG, + .wTotalLength = (sizeof(config_descriptor) + + sizeof(interface_descriptor) + + sizeof(ep1_out) + + sizeof(ep2_in)), + .bNumInterfaces = 1, + .bConfigurationValue = 1, // Configuration 1 + .iConfiguration = 0, // No string + .bmAttributes = 0xc0, // attributes: self powered, no remote wakeup + .bMaxPower = 0x32 // 100ma +}; + +static const unsigned char lang_descriptor[] = { + 4, // bLength + 0x03, // bDescriptorType == String Descriptor + 0x09, 0x04 // language id = us english +}; + +static const unsigned char *descriptor_strings[] = { + "Raspberry Pi", // Vendor + "Pico Test Device" // Product +}; + +#endif \ No newline at end of file diff --git a/usb/device/dev_lowlevel/dev_lowlevel_loopback.py b/usb/device/dev_lowlevel/dev_lowlevel_loopback.py new file mode 100755 index 0000000..82bf478 --- /dev/null +++ b/usb/device/dev_lowlevel/dev_lowlevel_loopback.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 + +# +# Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +# sudo pip3 install pyusb + +import usb.core +import usb.util + +# find our device +dev = usb.core.find(idVendor=0x0000, idProduct=0x0001) + +# was it found? +if dev is None: + raise ValueError('Device not found') + +# get an endpoint instance +cfg = dev.get_active_configuration() +intf = cfg[(0, 0)] + +outep = usb.util.find_descriptor( + intf, + # match the first OUT endpoint + custom_match= \ + lambda e: \ + usb.util.endpoint_direction(e.bEndpointAddress) == \ + usb.util.ENDPOINT_OUT) + +inep = usb.util.find_descriptor( + intf, + # match the first IN endpoint + custom_match= \ + lambda e: \ + usb.util.endpoint_direction(e.bEndpointAddress) == \ + usb.util.ENDPOINT_IN) + +assert inep is not None +assert outep is not None + +test_string = "Hello World!" +outep.write(test_string) +from_device = inep.read(len(test_string)) + +print("Device Says: {}".format(''.join([chr(x) for x in from_device]))) diff --git a/usb/device/dev_lowlevel/usb_common.h b/usb/device/dev_lowlevel/usb_common.h new file mode 100644 index 0000000..4f6c01e --- /dev/null +++ b/usb/device/dev_lowlevel/usb_common.h @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _USB_COMMON_H +#define _USB_COMMON_H + +#include "pico/types.h" +#include "hardware/structs/usb.h" + +// bmRequestType bit definitions +#define USB_REQ_TYPE_STANDARD 0x00u +#define USB_REQ_TYPE_TYPE_MASK 0x60u +#define USB_REQ_TYPE_TYPE_CLASS 0x20u +#define USB_REQ_TYPE_TYPE_VENDOR 0x40u + +#define USB_REQ_TYPE_RECIPIENT_MASK 0x1fu +#define USB_REQ_TYPE_RECIPIENT_DEVICE 0x00u +#define USB_REQ_TYPE_RECIPIENT_INTERFACE 0x01u +#define USB_REQ_TYPE_RECIPIENT_ENDPOINT 0x02u + +#define USB_DIR_OUT 0x00u +#define USB_DIR_IN 0x80u + +#define USB_TRANSFER_TYPE_CONTROL 0x0 +#define USB_TRANSFER_TYPE_ISOCHRONOUS 0x1 +#define USB_TRANSFER_TYPE_BULK 0x2 +#define USB_TRANSFER_TYPE_INTERRUPT 0x3 +#define USB_TRANSFER_TYPE_BITS 0x3 + +// Descriptor types +#define USB_DT_DEVICE 0x01 +#define USB_DT_CONFIG 0x02 +#define USB_DT_STRING 0x03 +#define USB_DT_INTERFACE 0x04 +#define USB_DT_ENDPOINT 0x05 + +#define USB_REQUEST_GET_STATUS 0x0 +#define USB_REQUEST_CLEAR_FEATURE 0x01 +#define USB_REQUEST_SET_FEATURE 0x03 +#define USB_REQUEST_SET_ADDRESS 0x05 +#define USB_REQUEST_GET_DESCRIPTOR 0x06 +#define USB_REQUEST_SET_DESCRIPTOR 0x07 +#define USB_REQUEST_GET_CONFIGURATION 0x08 +#define USB_REQUEST_SET_CONFIGURATION 0x09 +#define USB_REQUEST_GET_INTERFACE 0x0a +#define USB_REQUEST_SET_INTERFACE 0x0b +#define USB_REQUEST_SYNC_FRAME 0x0c + +#define USB_REQUEST_MSC_GET_MAX_LUN 0xfe +#define USB_REQUEST_MSC_RESET 0xff + +#define USB_FEAT_ENDPOINT_HALT 0x00 +#define USB_FEAT_DEVICE_REMOTE_WAKEUP 0x01 +#define USB_FEAT_TEST_MODE 0x02 + +#define USB_DESCRIPTOR_TYPE_ENDPOINT 0x05 + +struct usb_setup_packet { + uint8_t bmRequestType; + uint8_t bRequest; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} __packed; + +struct usb_descriptor { + uint8_t bLength; + uint8_t bDescriptorType; +}; + +struct usb_device_descriptor { + uint8_t bLength; + uint8_t bDescriptorType; + uint16_t bcdUSB; + uint8_t bDeviceClass; + uint8_t bDeviceSubClass; + uint8_t bDeviceProtocol; + uint8_t bMaxPacketSize0; + uint16_t idVendor; + uint16_t idProduct; + uint16_t bcdDevice; + uint8_t iManufacturer; + uint8_t iProduct; + uint8_t iSerialNumber; + uint8_t bNumConfigurations; +} __packed; + +struct usb_configuration_descriptor { + uint8_t bLength; + uint8_t bDescriptorType; + uint16_t wTotalLength; + uint8_t bNumInterfaces; + uint8_t bConfigurationValue; + uint8_t iConfiguration; + uint8_t bmAttributes; + uint8_t bMaxPower; +} __packed; + +struct usb_interface_descriptor { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bInterfaceNumber; + uint8_t bAlternateSetting; + uint8_t bNumEndpoints; + uint8_t bInterfaceClass; + uint8_t bInterfaceSubClass; + uint8_t bInterfaceProtocol; + uint8_t iInterface; +} __packed; + +struct usb_endpoint_descriptor { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bEndpointAddress; + uint8_t bmAttributes; + uint16_t wMaxPacketSize; + uint8_t bInterval; +} __packed; + +struct usb_endpoint_descriptor_long { + uint8_t bLength; + uint8_t bDescriptorType; + uint8_t bEndpointAddress; + uint8_t bmAttributes; + uint16_t wMaxPacketSize; + uint8_t bInterval; + uint8_t bRefresh; + uint8_t bSyncAddr; +} __attribute__((packed)); + +#endif \ No newline at end of file diff --git a/usb/host/CMakeLists.txt b/usb/host/CMakeLists.txt new file mode 100644 index 0000000..551d414 --- /dev/null +++ b/usb/host/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(host_hid) \ No newline at end of file diff --git a/usb/host/host_hid/CMakeLists.txt b/usb/host/host_hid/CMakeLists.txt new file mode 100644 index 0000000..f89ca15 --- /dev/null +++ b/usb/host/host_hid/CMakeLists.txt @@ -0,0 +1,10 @@ +add_executable(host_hid + host_hid.c + ) + +target_include_directories(host_hid PRIVATE ${CMAKE_CURRENT_LIST_DIR}) +target_link_libraries(host_hid PRIVATE pico_stdlib tinyusb_host tinyusb_board) +pico_add_extra_outputs(host_hid) + +# add url via pico_set_program_url +example_auto_set_url(host_hid) diff --git a/usb/host/host_hid/host_hid.c b/usb/host/host_hid/host_hid.c new file mode 100644 index 0000000..a3bbab0 --- /dev/null +++ b/usb/host/host_hid/host_hid.c @@ -0,0 +1,228 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#include +#include +#include + +#include "bsp/board.h" +#include "tusb.h" + +void print_greeting(void); +void led_blinking_task(void); +extern void hid_task(void); + +int main(void) { + board_init(); + print_greeting(); + + tusb_init(); + + while (1) { + // tinyusb host task + tuh_task(); + led_blinking_task(); + +#if CFG_TUH_HID_KEYBOARD || CFG_TUH_HID_MOUSE + hid_task(); +#endif + } + + return 0; +} + +//--------------------------------------------------------------------+ +// USB HID +//--------------------------------------------------------------------+ +#if CFG_TUH_HID_KEYBOARD + +CFG_TUSB_MEM_SECTION static hid_keyboard_report_t usb_keyboard_report; +uint8_t const keycode2ascii[128][2] = {HID_KEYCODE_TO_ASCII}; + +// look up new key in previous keys +static inline bool find_key_in_report(hid_keyboard_report_t const *p_report, uint8_t keycode) { + for (uint8_t i = 0; i < 6; i++) { + if (p_report->keycode[i] == keycode) return true; + } + + return false; +} + +static inline void process_kbd_report(hid_keyboard_report_t const *p_new_report) { + static hid_keyboard_report_t prev_report = {0, 0, {0}}; // previous report to check key released + + //------------- example code ignore control (non-printable) key affects -------------// + for (uint8_t i = 0; i < 6; i++) { + if (p_new_report->keycode[i]) { + if (find_key_in_report(&prev_report, p_new_report->keycode[i])) { + // exist in previous report means the current key is holding + } else { + // not existed in previous report means the current key is pressed + bool const is_shift = + p_new_report->modifier & (KEYBOARD_MODIFIER_LEFTSHIFT | KEYBOARD_MODIFIER_RIGHTSHIFT); + uint8_t ch = keycode2ascii[p_new_report->keycode[i]][is_shift ? 1 : 0]; + putchar(ch); + if (ch == '\r') putchar('\n'); // added new line for enter key + + fflush(stdout); // flush right away, else nanolib will wait for newline + } + } + // TODO example skips key released + } + + prev_report = *p_new_report; +} + +void tuh_hid_keyboard_mounted_cb(uint8_t dev_addr) { + // application set-up + printf("A Keyboard device (address %d) is mounted\r\n", dev_addr); + + tuh_hid_keyboard_get_report(dev_addr, &usb_keyboard_report); +} + +void tuh_hid_keyboard_unmounted_cb(uint8_t dev_addr) { + // application tear-down + printf("A Keyboard device (address %d) is unmounted\r\n", dev_addr); +} + +// invoked ISR context +void tuh_hid_keyboard_isr(uint8_t dev_addr, xfer_result_t event) { + (void) dev_addr; + (void) event; +} + +#endif + +#if CFG_TUH_HID_MOUSE + +CFG_TUSB_MEM_SECTION static hid_mouse_report_t usb_mouse_report; + +void cursor_movement(int8_t x, int8_t y, int8_t wheel) { + //------------- X -------------// + if (x < 0) { + printf(ANSI_CURSOR_BACKWARD(%d), (-x)); // move left + } else if (x > 0) { + printf(ANSI_CURSOR_FORWARD(%d), x); // move right + } else {} + + //------------- Y -------------// + if (y < 0) { + printf(ANSI_CURSOR_UP(%d), (-y)); // move up + } else if (y > 0) { + printf(ANSI_CURSOR_DOWN(%d), y); // move down + } else {} + + //------------- wheel -------------// + if (wheel < 0) { + printf(ANSI_SCROLL_UP(%d), (-wheel)); // scroll up + } else if (wheel > 0) { + printf(ANSI_SCROLL_DOWN(%d), wheel); // scroll down + } else {} +} + +static inline void process_mouse_report(hid_mouse_report_t const *p_report) { + static hid_mouse_report_t prev_report = {0}; + + //------------- button state -------------// + uint8_t button_changed_mask = p_report->buttons ^prev_report.buttons; + if (button_changed_mask & p_report->buttons) { + printf(" %c%c%c ", + p_report->buttons & MOUSE_BUTTON_LEFT ? 'L' : '-', + p_report->buttons & MOUSE_BUTTON_MIDDLE ? 'M' : '-', + p_report->buttons & MOUSE_BUTTON_RIGHT ? 'R' : '-'); + } + + //------------- cursor movement -------------// + cursor_movement(p_report->x, p_report->y, p_report->wheel); +} + + +void tuh_hid_mouse_mounted_cb(uint8_t dev_addr) { + // application set-up + printf("A Mouse device (address %d) is mounted\r\n", dev_addr); +} + +void tuh_hid_mouse_unmounted_cb(uint8_t dev_addr) { + // application tear-down + printf("A Mouse device (address %d) is unmounted\r\n", dev_addr); +} + +// invoked ISR context +void tuh_hid_mouse_isr(uint8_t dev_addr, xfer_result_t event) { + (void) dev_addr; + (void) event; +} + +#endif + + +void hid_task(void) { + uint8_t const addr = 1; + +#if CFG_TUH_HID_KEYBOARD + if (tuh_hid_keyboard_is_mounted(addr)) { + if (!tuh_hid_keyboard_is_busy(addr)) { + process_kbd_report(&usb_keyboard_report); + tuh_hid_keyboard_get_report(addr, &usb_keyboard_report); + } + } +#endif + +#if CFG_TUH_HID_MOUSE + if (tuh_hid_mouse_is_mounted(addr)) { + if (!tuh_hid_mouse_is_busy(addr)) { + process_mouse_report(&usb_mouse_report); + tuh_hid_mouse_get_report(addr, &usb_mouse_report); + } + } +#endif +} + + +//--------------------------------------------------------------------+ +// BLINKING TASK +//--------------------------------------------------------------------+ +void led_blinking_task(void) { + const uint32_t interval_ms = 250; + static uint32_t start_ms = 0; + + static bool led_state = false; + + // Blink every interval ms + if (board_millis() - start_ms < interval_ms) return; // not enough time + start_ms += interval_ms; + + board_led_write(led_state); + led_state = 1 - led_state; // toggle +} + +//--------------------------------------------------------------------+ +// HELPER FUNCTION +//--------------------------------------------------------------------+ +void print_greeting(void) { + printf("This Host demo is configured to support:\n"); + if (CFG_TUH_HID_KEYBOARD) puts(" - HID Keyboard"); + if (CFG_TUH_HID_MOUSE) puts(" - HID Mouse"); +} diff --git a/usb/host/host_hid/tusb_config.h b/usb/host/host_hid/tusb_config.h new file mode 100644 index 0000000..b1257b9 --- /dev/null +++ b/usb/host/host_hid/tusb_config.h @@ -0,0 +1,73 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2019 Ha Thach (tinyusb.org) + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + */ + +#ifndef _TUSB_CONFIG_H_ +#define _TUSB_CONFIG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +//-------------------------------------------------------------------- +// COMMON CONFIGURATION +//-------------------------------------------------------------------- + +// defined by compiler flags for flexibility +#ifndef CFG_TUSB_MCU +#error CFG_TUSB_MCU must be defined +#endif + +#if CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_LPC18XX || CFG_TUSB_MCU == OPT_MCU_MIMXRT10XX +#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_HOST | OPT_MODE_HIGH_SPEED) +#else +#define CFG_TUSB_RHPORT0_MODE OPT_MODE_HOST +#endif + +#ifndef CFG_TUSB_MEM_SECTION +#define CFG_TUSB_MEM_SECTION +#endif + +#ifndef CFG_TUSB_MEM_ALIGN +#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) +#endif + +//-------------------------------------------------------------------- +// CONFIGURATION +//-------------------------------------------------------------------- + +#define CFG_TUH_HUB 1 +#define CFG_TUH_HID_KEYBOARD 1 +#define CFG_TUH_HID_MOUSE 1 +#define CFG_TUSB_HOST_HID_GENERIC 0 // (not yet supported) +#define CFG_TUH_MSC 0 +#define CFG_TUH_CDC 0 + +#define CFG_TUSB_HOST_DEVICE_MAX (CFG_TUH_HUB ? 5 : 1) // normal hub has 4 ports + +#ifdef __cplusplus +} +#endif + +#endif /* _TUSB_CONFIG_H_ */ diff --git a/watchdog/CMakeLists.txt b/watchdog/CMakeLists.txt new file mode 100644 index 0000000..5c52174 --- /dev/null +++ b/watchdog/CMakeLists.txt @@ -0,0 +1,3 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(hello_watchdog) +endif () diff --git a/watchdog/hello_watchdog/CMakeLists.txt b/watchdog/hello_watchdog/CMakeLists.txt new file mode 100644 index 0000000..9e1e5d0 --- /dev/null +++ b/watchdog/hello_watchdog/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(hello_watchdog + hello_watchdog.c + ) + +target_link_libraries(hello_watchdog pico_stdlib) + +# create map/bin/hex file etc. +pico_add_extra_outputs(hello_watchdog) + +# add url via pico_set_program_url +example_auto_set_url(hello_watchdog) diff --git a/watchdog/hello_watchdog/hello_watchdog.c b/watchdog/hello_watchdog/hello_watchdog.c new file mode 100644 index 0000000..0534b73 --- /dev/null +++ b/watchdog/hello_watchdog/hello_watchdog.c @@ -0,0 +1,33 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/watchdog.h" + +int main() { + stdio_init_all(); + + if (watchdog_caused_reboot()) { + printf("Rebooted by Watchdog!\n"); + return 0; + } else { + printf("Clean boot\n"); + } + + // Enable the watchdog, requiring the watchdog to be updated every 100ms or the chip will reboot + // second arg is pause on debug which means the watchdog will pause when stepping through code + watchdog_enable(100, 1); + + for (uint i = 0; i < 5; i++) { + printf("Updating watchdog %d\n", i); + watchdog_update(); + } + + // Wait in an infinite loop and don't update the watchdog so it reboots us + printf("Waiting to be rebooted by watchdog\n"); + while(1); +} \ No newline at end of file