diff --git a/Cmake.png b/Cmake.png new file mode 100644 index 0000000..e4c8507 Binary files /dev/null and b/Cmake.png differ diff --git a/GNU Toolchain.png b/GNU Toolchain.png new file mode 100644 index 0000000..d2e2b2b Binary files /dev/null and b/GNU Toolchain.png differ diff --git a/Lab 2 Prob3/3.5.pdf b/Lab 2 Prob3/3.5.pdf new file mode 100644 index 0000000..59fc919 Binary files /dev/null and b/Lab 2 Prob3/3.5.pdf differ diff --git a/Lab 2 Prob3/3.6.xlsx b/Lab 2 Prob3/3.6.xlsx new file mode 100644 index 0000000..750c087 Binary files /dev/null and b/Lab 2 Prob3/3.6.xlsx differ diff --git a/Lab 2 Prob3/3.7.jpg b/Lab 2 Prob3/3.7.jpg new file mode 100644 index 0000000..b104ada Binary files /dev/null and b/Lab 2 Prob3/3.7.jpg differ diff --git a/Lab 2 Prob3/part3.4 - Sheet1.pdf b/Lab 2 Prob3/part3.4 - Sheet1.pdf new file mode 100644 index 0000000..40d6fb2 Binary files /dev/null and b/Lab 2 Prob3/part3.4 - Sheet1.pdf differ diff --git a/Lab 2 Prob3/ws2812.c1.jpg b/Lab 2 Prob3/ws2812.c1.jpg new file mode 100644 index 0000000..d7bb6d8 Binary files /dev/null and b/Lab 2 Prob3/ws2812.c1.jpg differ diff --git a/Lab 2 Prob3/ws2812.c2.jpg b/Lab 2 Prob3/ws2812.c2.jpg new file mode 100644 index 0000000..2618f61 Binary files /dev/null and b/Lab 2 Prob3/ws2812.c2.jpg differ diff --git a/Lab 2 Prob3/ws2812.pio.h1.jpg b/Lab 2 Prob3/ws2812.pio.h1.jpg new file mode 100644 index 0000000..518d222 Binary files /dev/null and b/Lab 2 Prob3/ws2812.pio.h1.jpg differ diff --git a/Lab 2 Prob3/ws2812.pio.h2.jpg b/Lab 2 Prob3/ws2812.pio.h2.jpg new file mode 100644 index 0000000..9da1162 Binary files /dev/null and b/Lab 2 Prob3/ws2812.pio.h2.jpg differ diff --git a/Putty.png b/Putty.png new file mode 100644 index 0000000..4b05dd8 Binary files /dev/null and b/Putty.png differ diff --git a/README.md b/README.md index a8be84b..017db82 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,76 @@ University of Pennsylvania, ESE 5190: Intro to Embedded Systems, Lab 2A - (TODO) YOUR NAME HERE - (TODO) LinkedIn, personal website, twitter, etc. - Tested on: (TODO) MacBook Pro (14-inch, 2021), macOS Monterey 12.5.1 -(TODO: Your README) + Name: Sen Luo + email: luosen@seas.upenn.edu + Tested on: Razer Blade 15 (15-inch, 2020), Windows 10 21H2 + +# Part3 TALKING LEDS + +## Brief responses to the reading questions in 3.2 + +- Why is bit-banging impractical on your laptop, despite it having a much faster processor than the RP2040? + +Due to the timing uncertainty of actually entering an interrupt handler, the bit-banging become impractical. Another choice is to set the processor in a carefully times loop trying to make sure the GPIO reading and writing happens on the exact cycle required, which is really hard work. + +- What are some cases where directly using the GPIO might be a better choice than using the PIO hardware? + +LEDs and push buttons. + +- How do you get data into a PIO state machine? + +The pull instruction takes one data item from the transmit FIFO buffer, and places it in the output shift register (OSR). Data moves from the FIFO to the OSR one word (32 bits) at a time. + +- How do you get data out of a PIO state machine? + +The out instruction here takes one bit from the data we just pull-ed from the FIFO, and writes that data to some pins. + +- How do you program a PIO state machine? + +There are three things to consider here: +1. The state machine needs to be told which GPIO or GPIOs to output to. +2. The GPIO also needs to be told that PIO is in control of it(GPIO function select) +3. If we are using the pin for output only, we need to make sure that PIO is driving the output enable line high. + +- In the example, which low-level C SDK function is directly responsible for telling the PIO to set the LED to a new color? How is this function accessed from the main “application” code? + +``` +pio_sm_put_blocking(pio, sm, 1): +``` +After you set up everything correctly, the state machine will run autonomously,then the processor will push data directly into the state machine' TX FIFO. Writing 1 will turn the LED on, and writing a 0 will turn the LED off. + +- What role does the pioasm “assembler” play in the example, and how does this interact with CMake? + +The role of the pioasm assembler is to translating assembly code into binary. If Cmake functions want to interact with pioasm, you need take care of invoking pioasm and adding the generated header to the include path of the target TARGET for you. + +## 3.3 FOLLOW THE FLOW +For this part, I tried to describe the definition of the functions and their runing sequence. +### ws2812.c +![](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/ws2812.c1.jpg) + +![](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/ws2812.c2.jpg) + +### ws2812.pio.h +![](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/ws2812.pio.h1.jpg) + +![](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/ws2812.pio.h2.jpg) + +## 3.4 COLOR BY NUMBER +For this part, I choose color 0X0000FF(BLUE). + +[3.4 link](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/part3.4%20-%20Sheet1.pdf) +## 3.5 MODELING TIME +[3.5 link](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/3.5.pdf) +## 3.6 ZOOMING IN +[3.6 link](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/3.6.xlsx) +## 3.7 TIMING DIAGRAM +![](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/blob/main/Lab%202%20Prob3/3.7.jpg) + +## Reflection +For this lab, I chose to use "Notability" in iPad to finish handwritting part. Although I think writing is not as fast as typing, drawing forms by hand sometimes is easier than creating proper forms on computer. What's more, I am not familiar with working with spreadsheets. Sometimes, I feel it takes me a lot of time on adjust the format of the spreadsheets. + +# Part4 HELLO, BLINKENLIGHT +[part4 folder](https://github.com/SEN316/ese5190-2022-lab2-into-the-void-star/tree/main/lab2%20prob4) + +In this part, I modify hello_usb.c to make my LED to switch between blue and green constantly. By using PuTTY, you can find the program print "Hello, world! BLUE" when LED blue light blink and print "Hello, world! GREEN" when LED green light blink. -Include lab questions, screenshots, analysis, etc. (Remember, this is public, so don't put anything here you don't want to share with the world.) diff --git a/VScode.png b/VScode.png new file mode 100644 index 0000000..7699390 Binary files /dev/null and b/VScode.png differ diff --git a/git1.png b/git1.png new file mode 100644 index 0000000..6c05011 Binary files /dev/null and b/git1.png differ diff --git a/git2.png b/git2.png new file mode 100644 index 0000000..6b30474 Binary files /dev/null and b/git2.png differ diff --git a/git3.png b/git3.png new file mode 100644 index 0000000..73ef63b Binary files /dev/null and b/git3.png differ diff --git a/git4.png b/git4.png new file mode 100644 index 0000000..f7c7427 Binary files /dev/null and b/git4.png differ diff --git a/git5.png b/git5.png new file mode 100644 index 0000000..ba5985b Binary files /dev/null and b/git5.png differ diff --git a/guide/Cmake.png b/guide/Cmake.png new file mode 100644 index 0000000..e4c8507 Binary files /dev/null and b/guide/Cmake.png differ diff --git a/guide/GNU Toolchain.png b/guide/GNU Toolchain.png new file mode 100644 index 0000000..d2e2b2b Binary files /dev/null and b/guide/GNU Toolchain.png differ diff --git a/guide/Putty.png b/guide/Putty.png new file mode 100644 index 0000000..4b05dd8 Binary files /dev/null and b/guide/Putty.png differ diff --git a/guide/VScode.png b/guide/VScode.png new file mode 100644 index 0000000..7699390 Binary files /dev/null and b/guide/VScode.png differ diff --git a/guide/git1.png b/guide/git1.png new file mode 100644 index 0000000..6c05011 Binary files /dev/null and b/guide/git1.png differ diff --git a/guide/git2.png b/guide/git2.png new file mode 100644 index 0000000..6b30474 Binary files /dev/null and b/guide/git2.png differ diff --git a/guide/git3.png b/guide/git3.png new file mode 100644 index 0000000..73ef63b Binary files /dev/null and b/guide/git3.png differ diff --git a/guide/git4.png b/guide/git4.png new file mode 100644 index 0000000..f7c7427 Binary files /dev/null and b/guide/git4.png differ diff --git a/guide/git5.png b/guide/git5.png new file mode 100644 index 0000000..ba5985b Binary files /dev/null and b/guide/git5.png differ diff --git a/guide/hello.png b/guide/hello.png new file mode 100644 index 0000000..a501391 Binary files /dev/null and b/guide/hello.png differ diff --git a/guide/nmake.png b/guide/nmake.png new file mode 100644 index 0000000..3e8edcf Binary files /dev/null and b/guide/nmake.png differ diff --git a/guide/python3.10.png b/guide/python3.10.png new file mode 100644 index 0000000..c90d1a5 Binary files /dev/null and b/guide/python3.10.png differ diff --git a/hello.png b/hello.png new file mode 100644 index 0000000..a501391 Binary files /dev/null and b/hello.png differ diff --git a/lab2 prob4/CMakeLists.txt b/lab2 prob4/CMakeLists.txt new file mode 100644 index 0000000..b305a7e --- /dev/null +++ b/lab2 prob4/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 3.12) + +# Pull in 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) + +if (PICO_SDK_VERSION_STRING VERSION_LESS "1.3.0") + message(FATAL_ERROR "Raspberry Pi Pico SDK version 1.3.0 (or later) required. Your version is ${PICO_SDK_VERSION_STRING}") +endif() + +set(PICO_EXAMPLES_PATH ${PROJECT_SOURCE_DIR}) + +# Initialize the SDK +pico_sdk_init() + +include(example_auto_set_url.cmake) +# Add blink example + + +# Add hello world example + + +add_compile_options(-Wall + -Wno-format # int != int32_t as far as the compiler is concerned because gcc has int32_t as long int + -Wno-unused-function # we have some for the docs that aren't called + -Wno-maybe-uninitialized + ) + +# Hardware-specific examples in subdirectories: + +add_subdirectory(pio) + diff --git a/lab2 prob4/CONTRIBUTING.md b/lab2 prob4/CONTRIBUTING.md new file mode 100644 index 0000000..98da77e --- /dev/null +++ b/lab2 prob4/CONTRIBUTING.md @@ -0,0 +1,23 @@ +# Contributing to Raspberry Pi Pico C/C++ Examples + +## How to Report a Bug + +We use GitHub to host code, track [issues](https://github.com/raspberrypi/pico-examples/issues) and feature requests, and to accept [pull requests](https://github.com/raspberrypi/pico-examples/pulls). If you find think you have found a bug, please report it by [opening a new issue](https://github.com/raspberrypi/pico-examples/issues/new). Please include as much detail as possible, and ideally some code to reproduce the problem. + +## How to Contribute Code + +In order to contribute new or updated code, you must first create a GitHub account and fork the original repository to your own account. You can make changes, save them in your repository, then [make a pull request](https://docs.github.com/en/github/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) against this repository. The pull request will appear [in the repository](https://github.com/raspberrypi/pico-examples/pulls) where it can be assessed by the maintainers, and if appropriate, merged with the official repository. + +**NOTE:** Development takes place on the `develop` branch in this repository. Please open your https://github.com/raspberrypi/pico-examples/pulls[pull request] (PR) against the [`develop`](https://github.com/raspberrypi/pico-examples/tree/develop) branch, pull requests against the `master` branch will automatically CI fail checks and will not be accepted. You will be asked to rebase your PR against `develop` and if you do not do so, your PR will be closed. + +### Code Style + +If you are contributing new or updated code please match the existing code style, particularly: + +* Use 4 spaces for indentation rather than tabs. +* Braces are required for everything except single line `if` statements. +* Opening braces should not be placed on a new line. + +### Licensing + +Code in this repository is lisensed under the [BSD-3 License](LICENSE.TXT). By contributing content to this repository you are agreeing to place your contributions under this licence. diff --git a/lab2 prob4/LICENSE.TXT b/lab2 prob4/LICENSE.TXT new file mode 100644 index 0000000..e8a64f1 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/README.md b/lab2 prob4/README.md new file mode 100644 index 0000000..a4c92ad --- /dev/null +++ b/lab2 prob4/README.md @@ -0,0 +1,279 @@ +# Raspberry Pi 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) | +[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. +[onboard_temperature](adc/onboard_temperature)|Display the value of the onboard temperature sensor. +[microphone_adc](adc/microphone_adc)|Read analog values from a microphone and plot the measured sound amplitude. + +### 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. +[bmp280_i2c](i2c/bmp280_i2c) | Read and convert temperature and pressure data from a BMP280 sensor, attached to an I2C bus. +[lcd_1602_i2c](i2c/lcd_1602_i2c) | Display some text on a generic 16x2 character LCD display, via I2C. +[lis3dh_i2c](i2c/lis3dh_i2c) | Read acceleration and temperature value from a LIS3DH sensor via I2C +[mcp9808_i2c](i2c/mcp9808_i2c) | Read temperature, set limits and raise alerts when limits are surpassed. +[mma8451_i2c](i2c/mma8451_i2c) | Read acceleration from a MMA8451 accelerometer and set range and precision for the data. +[mpl3115a2_i2c](i2c/mpl3115a2_i2c) | Interface with an MPL3115A2 altimeter, exploring interrupts and advanced board features, via I2C. +[mpu6050_i2c](i2c/mpu6050_i2c) | Read acceleration and angular rate values from a MPU6050 accelerometer/gyro, attached to an I2C bus. +[oled_i2c](i2c/oled_i2c) | Convert and display a bitmap on a 128x32 SSD1306-driven OLED display +[pa1010d_i2c](i2c/pa1010d_i2c) | Read GPS location data, parse and display data via I2C. +[pcf8523_i2c](i2c/pcf8523_i2c) | Read time and date values from a real time clock. Set current time and alarms on it. + +### 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. + +### Pico W Networking + +These eaxmples are for the Pico W, and are only available for `PICO_BOARD=pico_w` + +App|Description +---|--- +[picow_access_point](pico_w/access_point)| Starts a WiFi access point, and fields DHCP requests. +[picow_blink](pico_w/blink)| Blinks the on-board LED (which is connected via the WiFi chip). +[picow_iperf_server](pico_w/iperf)| Runs an "iperf" server for WiFi speed testing. +[picow_ntp_client](pico_w/ntp_client)| Connects to an NTP server to fetch and display the current time. +[picow_tcp_client](pico_w/tcp_client)| A simple TCP client. You can run [python_test_tcp_server.py](pico_w/python_test_tcp/python_test_tcp_server.py) for it to connect to. +[picow_tcp_server](pico_w/tcp_server)| A simple TCP server. You can use [python_test_tcp_client.py](pico_w/python_test_tcp/python_test_tcp_client.py) to connect to it. +[picow_wifi_scan](pico_w/wifi_scan)| Scans for WiFi networks and prints the results. + +#### FreeRTOS examples + +These are examples of integrating Pico W networking under FreeRTOS, and require you to set the `FREERTOS_KERNEL_PATH` +to point to the FreeRTOS Kernel. + +App|Description +---|--- +[picow_freertos_iperf_server_nosys](pico_w/freertos/iperf)| Runs an "iperf" server for WiFi speed testing under FreeRTOS in NO_SYS=1 mode. The LED is blinked in another task +[picow_freertos_iperf_server_sys](pico_w/freertos/iperf)| Runs an "iperf" server for WiFi speed testing under FreeRTOS in NO_SYS=0 (i.e. full FreeRTOS integration) mode. The LED is blinked in another task +[picow_freertos_ping_nosys](pico_w/freertos/ping)| Runs the lwip-contrib/apps/ping test app under FreeRTOS in NO_SYS=1 mode. +[picow_freertos_iperf_server_sys](pico_w/freertos/iperf)| Runs the lwip-contrib/apps/ping test app under FreeRTOS in NO_SYS=0 (i.e. full FreeRTOS integration) mode. The test app uses the lwIP \em socket API in this case. + +### 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. +[ir_nec](pio/ir_nec)| Sending and receiving IR (infra-red) codes using the PIO. +[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. +[quadrature_encoder](pio/quadrature_encoder)| A quadrature encoder using PIO to maintain counts independent of the CPU. +[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. +[spi_master_slave](spi/spi_master_slave) | Demonstrate SPI communication as master and slave. +[max7219_8x7seg_spi](spi/max7219_8x7seg_spi) | Attaching a Max7219 driving an 8 digit 7 segment display via SPI +[max7219_32x8_spi](spi/max7219_32x8_spi) | Attaching a Max7219 driving an 32x8 LED display via SPI + +### System + +App|Description +---|--- +[hello_double_tap](system/hello_double_tap) | An LED blink with the `pico_bootsel_via_double_reset` library linked. This enters the USB bootloader when it detects the system being reset twice in quick succession, which is useful for boards with a reset button but no BOOTSEL button. +[narrow_io_write](system/narrow_io_write) | Demonstrate the effects of 8-bit and 16-bit writes on a 32-bit IO register. +[unique_board_id](system/unique_board_id) | Read the 64 bit unique ID from external flash, which serves as a unique identifier for the board. + +### 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`. +[lcd_uart](uart/lcd_uart) | Display text and symbols on a 16x02 RGB LCD display via UART +[uart_advanced](uart/uart_advanced) | Use some other UART features like RX interrupts, hardware control flow, and data formats other than 8n1. + +### USB Device + +#### TinyUSB Examples + +Most of the USB device examples come directly from the TinyUSB device examples directory [here](https://github.com/hathach/tinyusb/tree/master/examples/device). +Those that are supported on RP2040 devices are automatically included as part of the pico-examples +build as targets named `tinyusb_dev_`, e.g. https://github.com/hathach/tinyusb/tree/master/examples/device/hid_composite +is built as `tinyusb_dev_hid_composite`. + +At the time of writing, these examples are available: + +- tinyusb_dev_audio_4_channel_mic +- tinyusb_dev_audio_test +- tinyusb_dev_board_test +- tinyusb_dev_cdc_dual_ports +- tinyusb_dev_cdc_msc +- tinyusb_dev_dfu +- tinyusb_dev_dfu_runtime +- tinyusb_dev_dynamic_configuration +- tinyusb_dev_hid_composite +- tinyusb_dev_hid_generic_inout +- tinyusb_dev_hid_multiple_interface +- tinyusb_dev_midi_test +- tinyusb_dev_msc_dual_lun +- tinyusb_dev_net_lwip_webserver +- tinyusb_dev_uac2_headset +- tinyusb_dev_usbtmc +- tinyusb_dev_video_capture +- tinyusb_dev_webusb_serial + +Whilst these examples ably demonstrate how to use TinyUSB in device mode, their `CMakeLists.txt` is set up in a way +tailored to how TinyUSB builds their examples within their source tree. + +For a better example of how to configure `CMakeLists.txt` for using TinyUSB in device mode with the Raspberry Pi SDK +see below: + +#### SDK build example +App|Description +---|--- +[dev_hid_composite](usb/device/dev_hid_composite) | A copy of the TinyUSB device example with the same name, but with a CMakeLists.txt which demonstrates how to add a dependency on the TinyUSB device libraries with the Raspberry Pi Pico SDK + +#### Low Level example +App|Description +---|--- +[dev_lowlevel](usb/device/dev_lowlevel) | A USB Bulk loopback implemented with direct access to the USB hardware (no TinyUSB) + +### USB Host + +All the USB host examples come directly from the TinyUSB host examples directory [here](https://github.com/hathach/tinyusb/tree/master/examples/host). +Those that are supported on RP2040 devices are automatically included as part of the pico-examples +build as targets named `tinyusb_host_`, e.g. https://github.com/hathach/tinyusb/tree/master/examples/host/cdc_msc_hid +is built as `tinyusb_host_cdc_msc_hid`. + +At the time of writing, there is only one host example available: + +- tinyusb_host_cdc_msc_hid + +### Watchdog + +App|Description +---|--- +[hello_watchdog](watchdog/hello_watchdog) | Set the watchdog timer, and let it expire. Detect the reboot, and halt. diff --git a/lab2 prob4/example_auto_set_url.cmake b/lab2 prob4/example_auto_set_url.cmake new file mode 100644 index 0000000..59e6c71 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pico_sdk_import.cmake b/lab2 prob4/pico_sdk_import.cmake new file mode 100644 index 0000000..65f8a6f --- /dev/null +++ b/lab2 prob4/pico_sdk_import.cmake @@ -0,0 +1,73 @@ +# 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() + +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 Raspberry Pi Pico SDK") +set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of 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 () + # GIT_SUBMODULES_RECURSE was added in 3.17 + if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.17.0") + FetchContent_Declare( + pico_sdk + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG master + GIT_SUBMODULES_RECURSE FALSE + ) + else () + FetchContent_Declare( + pico_sdk + GIT_REPOSITORY https://github.com/raspberrypi/pico-sdk + GIT_TAG master + ) + endif () + + if (NOT pico_sdk) + message("Downloading Raspberry Pi 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 + "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 Raspberry Pi Pico SDK") +endif () + +set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE) + +include(${PICO_SDK_INIT_CMAKE_FILE}) diff --git a/lab2 prob4/pio/CMakeLists.txt b/lab2 prob4/pio/CMakeLists.txt new file mode 100644 index 0000000..0b9d0b3 --- /dev/null +++ b/lab2 prob4/pio/CMakeLists.txt @@ -0,0 +1,21 @@ +if (NOT PICO_NO_HARDWARE) + add_subdirectory(addition) + add_subdirectory(apa102) + add_subdirectory(clocked_input) + add_subdirectory(differential_manchester) + add_subdirectory(hello_pio) + add_subdirectory(hub75) + add_subdirectory(i2c) + add_subdirectory(ir_nec) + add_subdirectory(logic_analyser) + add_subdirectory(manchester_encoding) + add_subdirectory(pio_blink) + add_subdirectory(pwm) + add_subdirectory(quadrature_encoder) + 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/lab2 prob4/pio/addition/CMakeLists.txt b/lab2 prob4/pio/addition/CMakeLists.txt new file mode 100644 index 0000000..9ff9077 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/addition/addition.c b/lab2 prob4/pio/addition/addition.c new file mode 100644 index 0000000..a63579f --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/addition/addition.pio b/lab2 prob4/pio/addition/addition.pio new file mode 100644 index 0000000..8eddd0e --- /dev/null +++ b/lab2 prob4/pio/addition/addition.pio @@ -0,0 +1,33 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.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/lab2 prob4/pio/apa102/CMakeLists.txt b/lab2 prob4/pio/apa102/CMakeLists.txt new file mode 100644 index 0000000..1522f55 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/apa102/apa102.c b/lab2 prob4/pio/apa102/apa102.c new file mode 100644 index 0000000..152945a --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/apa102/apa102.pio b/lab2 prob4/pio/apa102/apa102.pio new file mode 100644 index 0000000..5d76f08 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/clocked_input/CMakeLists.txt b/lab2 prob4/pio/clocked_input/CMakeLists.txt new file mode 100644 index 0000000..cd71408 --- /dev/null +++ b/lab2 prob4/pio/clocked_input/CMakeLists.txt @@ -0,0 +1,16 @@ +add_executable(pio_clocked_input) + +pico_generate_pio_header(pio_clocked_input ${CMAKE_CURRENT_LIST_DIR}/clocked_input.pio) + +target_sources(pio_clocked_input PRIVATE clocked_input.c) + +target_link_libraries(pio_clocked_input PRIVATE + pico_stdlib + hardware_pio + hardware_spi + ) + +pico_add_extra_outputs(pio_clocked_input) + +# add url via pico_set_program_url +example_auto_set_url(pio_clocked_input) diff --git a/lab2 prob4/pio/clocked_input/clocked_input.c b/lab2 prob4/pio/clocked_input/clocked_input.c new file mode 100644 index 0000000..acb7497 --- /dev/null +++ b/lab2 prob4/pio/clocked_input/clocked_input.c @@ -0,0 +1,75 @@ +/** + * Copyright (c) 2021 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include "pico/stdlib.h" +#include "hardware/clocks.h" +#include "hardware/pio.h" +#include "hardware/spi.h" +#include "clocked_input.pio.h" + +// Set up a PIO state machine to shift in serial data, sampling with an +// external clock, and push the data to the RX FIFO, 8 bits at a time. +// +// Use one of the hard SPI peripherals to drive data into the SM through a +// pair of external jumper wires, then read back and print out the data from +// the SM to confirm everything worked ok. +// +// On your Pico you need to connect jumper wires to these pins: +// - GPIO 2 -> GPIO 5 (clock output to clock input) +// - GPIO 3 -> GPIO 4 (data output to data input) + +#define SPI_SCK_PIN 2 +#define SPI_TX_PIN 3 +// GPIO 4 for PIO data input, GPIO 5 for clock input: +#define PIO_INPUT_PIN_BASE 4 + +#define BUF_SIZE 8 + +int main() { + stdio_init_all(); + + // Configure the SPI before PIO to avoid driving any glitches into the + // state machine. + spi_init(spi0, 1000 * 1000); + uint actual_freq_hz = spi_set_baudrate(spi0, clock_get_hz(clk_sys) / 6); + printf("SPI running at %u Hz\n", actual_freq_hz); + gpio_set_function(SPI_TX_PIN, GPIO_FUNC_SPI); + gpio_set_function(SPI_SCK_PIN, GPIO_FUNC_SPI); + + // Load the clocked_input program, and configure a free state machine + // to run the program. + PIO pio = pio0; + uint offset = pio_add_program(pio, &clocked_input_program); + uint sm = pio_claim_unused_sm(pio, true); + clocked_input_program_init(pio, sm, offset, PIO_INPUT_PIN_BASE); + + // Make up some random data to send. + static uint8_t txbuf[BUF_SIZE]; + puts("Data to transmit:"); + for (int i = 0; i < BUF_SIZE; ++i) { + txbuf[i] = rand() >> 16; + printf("%02x\n", txbuf[i]); + } + + // The "blocking" write function will send all the data in one go, and not + // return until the full transmission is finished. + spi_write_blocking(spi0, (const uint8_t*)txbuf, BUF_SIZE); + + // The data we just sent should now be present in the state machine's + // FIFO. We only sent 8 bytes, so all the data received by the state + // machine will fit into the FIFO. Generally you want to be continuously + // reading data out as it appears in the FIFO -- either with polling, FIFO + // interrupts, or DMA. + puts("Reading back from RX FIFO:"); + for (int i = 0; i < BUF_SIZE; ++i) { + uint8_t rxdata = pio_sm_get_blocking(pio, sm); + printf("%02x %s\n", rxdata, rxdata == txbuf[i] ? "OK" : "FAIL"); + } + puts("Done."); +} diff --git a/lab2 prob4/pio/clocked_input/clocked_input.pio b/lab2 prob4/pio/clocked_input/clocked_input.pio new file mode 100644 index 0000000..51fa54c --- /dev/null +++ b/lab2 prob4/pio/clocked_input/clocked_input.pio @@ -0,0 +1,51 @@ +; +; Copyright (c) 2021 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program clocked_input + +; Sample bits using an external clock, and push groups of bits into the RX FIFO. +; - IN pin 0 is the data pin +; - IN pin 1 is the clock pin +; - Autopush is enabled, threshold 8 +; +; This program samples data with each rising clock edge (like mode 0 or mode 3 +; SPI). The data is actually sampled one system clock cycle after the rising +; edge is observed, so a clock ratio of at least input_clk < clk_sys / 6 is +; recommended for good sampling alignment. + + wait 0 pin 1 + wait 1 pin 1 + in pins, 1 + +% c-sdk { +static inline void clocked_input_program_init(PIO pio, uint sm, uint offset, uint pin) { + pio_sm_config c = clocked_input_program_get_default_config(offset); + + // Set the IN base pin to the provided `pin` parameter. This is the data + // pin, and the next-numbered GPIO is used as the clock pin. + sm_config_set_in_pins(&c, pin); + // Set the pin directions to input at the PIO + pio_sm_set_consecutive_pindirs(pio, sm, pin, 2, false); + // Connect these GPIOs to this PIO block + pio_gpio_init(pio, pin); + pio_gpio_init(pio, pin + 1); + + // Shifting to left matches the customary MSB-first ordering of SPI. + sm_config_set_in_shift( + &c, + false, // Shift-to-right = false (i.e. shift to left) + true, // Autopush enabled + 8 // Autopush threshold = 8 + ); + + // We only receive, so disable the TX FIFO to make the RX FIFO deeper. + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); + + // Load our configuration, and start the program from the beginning + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/lab2 prob4/pio/differential_manchester/CMakeLists.txt b/lab2 prob4/pio/differential_manchester/CMakeLists.txt new file mode 100644 index 0000000..6276f09 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/differential_manchester/differential_manchester.c b/lab2 prob4/pio/differential_manchester/differential_manchester.c new file mode 100644 index 0000000..c8b5612 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/differential_manchester/differential_manchester.pio b/lab2 prob4/pio/differential_manchester/differential_manchester.pio new file mode 100644 index 0000000..a9e825d --- /dev/null +++ b/lab2 prob4/pio/differential_manchester/differential_manchester.pio @@ -0,0 +1,104 @@ +; +; 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 16 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 ; Start of bit period: always assert transition + jmp !x high_0 side 1 [6] ; Test the data bit we just shifted out of OSR +high_1: + nop + jmp initial_high side 0 [6] ; 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 ; Always shift 1 bit from OSR to X so we can + jmp !x low_0 side 0 [6] ; branch on it. Autopull refills OSR for us. +low_1: + nop + jmp initial_low side 1 [6] ; If there are two transitions, return to +low_0: + 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/lab2 prob4/pio/hello_pio/CMakeLists.txt b/lab2 prob4/pio/hello_pio/CMakeLists.txt new file mode 100644 index 0000000..35b80cf --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/hello_pio/hello.c b/lab2 prob4/pio/hello_pio/hello.c new file mode 100644 index 0000000..2af0d05 --- /dev/null +++ b/lab2 prob4/pio/hello_pio/hello.c @@ -0,0 +1,42 @@ +/** + * 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() { +#ifndef PICO_DEFAULT_LED_PIN +#warning pio/hello_pio example requires a board with a regular LED +#else + // 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); + } +#endif +} diff --git a/lab2 prob4/pio/hello_pio/hello.pio b/lab2 prob4/pio/hello_pio/hello.pio new file mode 100644 index 0000000..9eac4de --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/hub75/CMakeLists.txt b/lab2 prob4/pio/hub75/CMakeLists.txt new file mode 100644 index 0000000..a976f4e --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/hub75/Readme.md b/lab2 prob4/pio/hub75/Readme.md new file mode 100644 index 0000000..660d795 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/hub75/hub75.c b/lab2 prob4/pio/hub75/hub75.c new file mode 100644 index 0000000..498ffa7 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/hub75/hub75.pio b/lab2 prob4/pio/hub75/hub75.pio new file mode 100644 index 0000000..a6fb619 --- /dev/null +++ b/lab2 prob4/pio/hub75/hub75.pio @@ -0,0 +1,128 @@ +; +; Copyright (c) 2020 Raspberry Pi (Trading) Ltd. +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.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/lab2 prob4/pio/hub75/mountains_128x64.png b/lab2 prob4/pio/hub75/mountains_128x64.png new file mode 100644 index 0000000..be19ae2 Binary files /dev/null and b/lab2 prob4/pio/hub75/mountains_128x64.png differ diff --git a/lab2 prob4/pio/hub75/mountains_128x64_rgb565.h b/lab2 prob4/pio/hub75/mountains_128x64_rgb565.h new file mode 100644 index 0000000..337afb3 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/i2c/CMakeLists.txt b/lab2 prob4/pio/i2c/CMakeLists.txt new file mode 100644 index 0000000..d49b224 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/i2c/i2c.pio b/lab2 prob4/pio/i2c/i2c.pio new file mode 100644 index 0000000..65f3e78 --- /dev/null +++ b/lab2 prob4/pio/i2c/i2c.pio @@ -0,0 +1,145 @@ +; +; 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, and make sure flag doesn't actually + // assert a system-level interrupt (we're using it as a status flag) + pio_set_irq0_source_enabled(pio, pis_interrupt0 + sm, false); + pio_set_irq1_source_enabled(pio, pis_interrupt0 + sm, false); + pio_interrupt_clear(pio, 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/lab2 prob4/pio/i2c/i2c_bus_scan.c b/lab2 prob4/pio/i2c/i2c_bus_scan.c new file mode 100644 index 0000000..5e6db23 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/i2c/pio_i2c.c b/lab2 prob4/pio/i2c/pio_i2c.c new file mode 100644 index 0000000..ef47e4b --- /dev/null +++ b/lab2 prob4/pio/i2c/pio_i2c.c @@ -0,0 +1,147 @@ +/** + * 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_interrupt_get(pio, 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_interrupt_clear(pio, 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)) + ; + // some versions of GCC dislike this +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" + *(io_rw_16 *)&pio->txf[sm] = data; +#pragma GCC diagnostic pop +} + + +// 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; + // some versions of GCC dislike this +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" + *(io_rw_16 *)&pio->txf[sm] = data; +#pragma GCC diagnostic pop +} + +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/lab2 prob4/pio/i2c/pio_i2c.h b/lab2 prob4/pio/i2c/pio_i2c.h new file mode 100644 index 0000000..554c333 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/ir_nec/CMakeLists.txt b/lab2 prob4/pio/ir_nec/CMakeLists.txt new file mode 100644 index 0000000..cf6dfa1 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/CMakeLists.txt @@ -0,0 +1,8 @@ +# build the transmit and receive libraries +# +add_subdirectory(nec_transmit_library) +add_subdirectory(nec_receive_library) + +# build the example program +# +add_subdirectory(ir_loopback) diff --git a/lab2 prob4/pio/ir_nec/README.adoc b/lab2 prob4/pio/ir_nec/README.adoc new file mode 100644 index 0000000..957708b --- /dev/null +++ b/lab2 prob4/pio/ir_nec/README.adoc @@ -0,0 +1,54 @@ += Sending and receiving IR (infra-red) codes using the PIO + +This example shows how to use the Raspberry Pi Pico (RP2040) to send and receive infra-red frames in the 'NEC' format that is used by many consumer remote control applications. + +It performs a loopback test by transmitting IR codes via an IR LED and receiving them on an IR detector. The results are sent to the default serial terminal connnected via UART or USB as configured in the SDK. + +The tasks of encoding and decoding the data are offloaded to the RP2040 PIO state machines. This releases the main processor cores to concentrate on other tasks. + +== Wiring information + +Connect GPIO 14 to the positive side ('anode') of an IR LED via a suitable series resistor e.g. 1.5k Ohms, and the negative side ('cathode') to ground. The wavelength of the LED is unlikely to be critical so long as it is compatible with your detector. + +Connect GPIO 15 to the output of a 3.3v IR detector such as the VS1838b, and wire the power connections of the detector to 3v3 and ground. The program expects the decoder output to be low (logic '0') when a carrier is detected. + +[[pio_ir_loopback_wiring]] +[pdfwidth=75%] +.Wiring Diagram for IR loopback. +image::pio_ir_loopback.png[] + +== Build information + +The code is organised into three sub-directories. These contain the loopback example and two libraries for the IR transmit and receive functions. + +After a successful build the executable program can be found in the **build/ir_loopback** directory. + +== List of Files + +CMakeLists.txt:: CMake file to incorporate the example in to the examples build tree. +ir_loopback/CMakeLists.txt:: CMake file to incorporate the loopback example in to the examples build tree. +ir_loopback/ir_loopback.c:: The code for the loopback example. +nec_receive_library/CMakeLists.txt:: CMake file to incorporate the IR receive library in to the examples build tree. +nec_receive_library/nec_receive.c:: The source code for the IR receive functions. +nec_receive_library/nec_receive.h:: The headers for the IR receive functions. +nec_receive_library/nec_receive.pio:: The PIO assembler code to receive a frame. +nec_transmit_library/CMakeLists.txt:: CMake file to incorporate the IR transmit library in to the examples build tree. +nec_transmit_library/nec_transmit.c:: The source code for the IR transmit functions. +nec_transmit_library/nec_transmit.h:: The headers for the IR transmit functions. +nec_transmit_library/nec_carrier_burst.pio:: The PIO assembler code to generate a carrier burst. +nec_transmit_library/nec_carrier_control.pio:: The PIO assembler code to transmit a complete frame. + +== Bill of Materials + +.A list of materials required for the example +[[pio_ir_loopback-bom-table]] +[cols=3] +|=== +| *Item* | *Quantity* | Details +| Breadboard | 1 | generic part +| Raspberry Pi Pico | 1 | https://www.raspberrypi.com/products/raspberry-pi-pico/ +| Infra-Red LED | 1 | generic part +| 1500 ohm resistor | 1 | generic part +| Infra-Red Detector | 1 | generic part e.g. VS1838b +| M/M Jumper wires | 5 | generic part +|=== diff --git a/lab2 prob4/pio/ir_nec/ir_loopback/CMakeLists.txt b/lab2 prob4/pio/ir_nec/ir_loopback/CMakeLists.txt new file mode 100644 index 0000000..8c7d8f4 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/ir_loopback/CMakeLists.txt @@ -0,0 +1,15 @@ +add_executable (pio_ir_loopback ir_loopback.c) + +# link the executable using the IR transmit and receive libraries +# +target_link_libraries(pio_ir_loopback LINK_PUBLIC + pico_stdlib + hardware_pio + nec_transmit_library + nec_receive_library + ) + +pico_add_extra_outputs(pio_ir_loopback) + +# add url via pico_set_program_url +example_auto_set_url(pio_ir_loopback) diff --git a/lab2 prob4/pio/ir_nec/ir_loopback/ir_loopback.c b/lab2 prob4/pio/ir_nec/ir_loopback/ir_loopback.c new file mode 100644 index 0000000..02910d8 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/ir_loopback/ir_loopback.c @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2021 mjcross + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" + +#include "nec_transmit.h" // include the library headers +#include "nec_receive.h" + +// Infrared loopback example ('NEC' format) +// +// Need to connect an IR LED to GPIO 14 via a suitable series resistor (e.g. 1.5k) +// and an active-low IR detector to GPIO 15 (e.g. VS1838b) +// +// Output is sent to stdout + +int main() { + stdio_init_all(); + + PIO pio = pio0; // choose which PIO block to use (RP2040 has two: pio0 and pio1) + uint tx_gpio = 14; // choose which GPIO pin is connected to the IR LED + uint rx_gpio = 15; // choose which GPIO pin is connected to the IR detector + + // configure and enable the state machines + int tx_sm = nec_tx_init(pio, tx_gpio); // uses two state machines, 16 instructions and one IRQ + int rx_sm = nec_rx_init(pio, rx_gpio); // uses one state machine and 9 instructions + + if (tx_sm == -1 || rx_sm == -1) { + printf("could not configure PIO\n"); + return -1; + } + + // transmit and receive frames + uint8_t tx_address = 0x00, tx_data = 0x00, rx_address, rx_data; + while (true) { + // create a 32-bit frame and add it to the transmit FIFO + uint32_t tx_frame = nec_encode_frame(tx_address, tx_data); + pio_sm_put(pio, tx_sm, tx_frame); + printf("\nsent: %02x, %02x", tx_address, tx_data); + + // allow time for the frame to be transmitted (optional) + sleep_ms(100); + + // display any frames in the receive FIFO + while (!pio_sm_is_rx_fifo_empty(pio, rx_sm)) { + uint32_t rx_frame = pio_sm_get(pio, rx_sm); + + if (nec_decode_frame(rx_frame, &rx_address, &rx_data)) { + printf("\treceived: %02x, %02x", rx_address, rx_data); + } else { + printf("\treceived: %08x", rx_frame); + } + } + + sleep_ms(900); + tx_data += 1; + } +} diff --git a/lab2 prob4/pio/ir_nec/nec_receive_library/CMakeLists.txt b/lab2 prob4/pio/ir_nec/nec_receive_library/CMakeLists.txt new file mode 100644 index 0000000..72d296d --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_receive_library/CMakeLists.txt @@ -0,0 +1,19 @@ +# build a normal library +# +add_library(nec_receive_library nec_receive.c) + +# invoke pio_asm to assemble the state machine program +# +pico_generate_pio_header(nec_receive_library ${CMAKE_CURRENT_LIST_DIR}/nec_receive.pio) + +target_link_libraries(nec_receive_library PRIVATE + pico_stdlib + hardware_pio + ) + +# add the `binary` directory so that the generated headers are included in the project +# +target_include_directories (nec_receive_library PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_BINARY_DIR} + ) diff --git a/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.c b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.c new file mode 100644 index 0000000..b034284 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.c @@ -0,0 +1,79 @@ +/** + * Copyright (c) 2021 mjcross + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// SDK types and declarations +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/clocks.h" // for clock_get_hz() + +#include "nec_receive.h" + +// import the assembled PIO state machine program +#include "nec_receive.pio.h" + +// Claim an unused state machine on the specified PIO and configure it +// to receive NEC IR frames on the given GPIO pin. +// +// Returns: the state machine number on success, otherwise -1 +int nec_rx_init(PIO pio, uint pin_num) { + + // disable pull-up and pull-down on gpio pin + gpio_disable_pulls(pin_num); + + // install the program in the PIO shared instruction space + uint offset; + if (pio_can_add_program(pio, &nec_receive_program)) { + offset = pio_add_program(pio, &nec_receive_program); + } else { + return -1; // the program could not be added + } + + // claim an unused state machine on this PIO + int sm = pio_claim_unused_sm(pio, true); + if (sm == -1) { + return -1; // we were unable to claim a state machine + } + + // configure and enable the state machine + nec_receive_program_init(pio, sm, offset, pin_num); + + return sm; +} + + +// Validate a 32-bit frame and store the address and data at the locations +// provided. +// +// Returns: `true` if the frame was valid, otherwise `false` +bool nec_decode_frame(uint32_t frame, uint8_t *p_address, uint8_t *p_data) { + + // access the frame data as four 8-bit fields + // + union { + uint32_t raw; + struct { + uint8_t address; + uint8_t inverted_address; + uint8_t data; + uint8_t inverted_data; + }; + } f; + + f.raw = frame; + + // a valid (non-extended) 'NEC' frame should contain 8 bit + // address, inverted address, data and inverted data + if (f.address != (f.inverted_address ^ 0xff) || + f.data != (f.inverted_data ^ 0xff)) { + return false; + } + + // store the validated address and data + *p_address = f.address; + *p_data = f.data; + + return true; +} diff --git a/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.h b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.h new file mode 100644 index 0000000..fdd6e23 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.h @@ -0,0 +1,13 @@ +/** + * Copyright (c) 2021 mjcross + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" +#include "hardware/pio.h" + +// public API + +int nec_rx_init(PIO pio, uint pin); +bool nec_decode_frame(uint32_t sm, uint8_t *p_address, uint8_t *p_data); diff --git a/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.pio b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.pio new file mode 100644 index 0000000..a2c5f5e --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_receive_library/nec_receive.pio @@ -0,0 +1,96 @@ +; +; Copyright (c) 2021 mjcross +; +; SPDX-License-Identifier: BSD-3-Clause +; + + +.program nec_receive + +; Decode IR frames in NEC format and push 32-bit words to the input FIFO. +; +; The input pin should be connected to an IR detector with an 'active low' output. +; +; This program expects there to be 10 state machine clock ticks per 'normal' 562.5us burst period +; in order to permit timely detection of start of a burst. The initailisation function below sets +; the correct divisor to achive this relative to the system clock. +; +; Within the 'NEC' protocol frames consists of 32 bits sent least-siginificant bit first; so the +; Input Shift Register should be configured to shift right and autopush after 32 bits, as in the +; initialisation function below. +; +.define BURST_LOOP_COUNTER 30 ; the detection threshold for a 'frame sync' burst +.define BIT_SAMPLE_DELAY 15 ; how long to wait after the end of the burst before sampling + +.wrap_target + +next_burst: + set X, BURST_LOOP_COUNTER + wait 0 pin 0 ; wait for the next burst to start + +burst_loop: + jmp pin data_bit ; the burst ended before the counter expired + jmp X-- burst_loop ; wait for the burst to end + + ; the counter expired - this is a sync burst + mov ISR, NULL ; reset the Input Shift Register + wait 1 pin 0 ; wait for the sync burst to finish + jmp next_burst ; wait for the first data bit + +data_bit: + nop [ BIT_SAMPLE_DELAY - 1 ] ; wait for 1.5 burst periods before sampling the bit value + in PINS, 1 ; if the next burst has started then detect a '0' (short gap) + ; otherwise detect a '1' (long gap) + ; after 32 bits the ISR will autopush to the receive FIFO +.wrap + + +% c-sdk { +static inline void nec_receive_program_init (PIO pio, uint sm, uint offset, uint pin) { + + // Set the GPIO function of the pin (connect the PIO to the pad) + // + pio_gpio_init(pio, pin); + + // Set the pin direction to `input` at the PIO + // + pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); + + // Create a new state machine configuration + // + pio_sm_config c = nec_receive_program_get_default_config (offset); + + // configure the Input Shift Register + // + sm_config_set_in_shift (&c, + true, // shift right + true, // enable autopush + 32); // autopush after 32 bits + + // join the FIFOs to make a single large receive FIFO + // + sm_config_set_fifo_join (&c, PIO_FIFO_JOIN_RX); + + // Map the IN pin group to one pin, namely the `pin` + // parameter to this function. + // + sm_config_set_in_pins (&c, pin); + + // Map the JMP pin to the `pin` parameter of this function. + // + sm_config_set_jmp_pin (&c, pin); + + // Set the clock divider to 10 ticks per 562.5us burst period + // + float div = clock_get_hz (clk_sys) / (10.0 / 562.5e-6); + sm_config_set_clkdiv (&c, div); + + // Apply the configuration to the state machine + // + pio_sm_init (pio, sm, offset, &c); + + // Set the state machine running + // + pio_sm_set_enabled (pio, sm, true); +} +%} diff --git a/lab2 prob4/pio/ir_nec/nec_transmit_library/CMakeLists.txt b/lab2 prob4/pio/ir_nec/nec_transmit_library/CMakeLists.txt new file mode 100644 index 0000000..dfb96bf --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_transmit_library/CMakeLists.txt @@ -0,0 +1,20 @@ +# build a normal library +# +add_library(nec_transmit_library nec_transmit.c) + +# invoke pio_asm to assemble the PIO state machine programs +# +pico_generate_pio_header(nec_transmit_library ${CMAKE_CURRENT_LIST_DIR}/nec_carrier_burst.pio) +pico_generate_pio_header(nec_transmit_library ${CMAKE_CURRENT_LIST_DIR}/nec_carrier_control.pio) + +target_link_libraries(nec_transmit_library PRIVATE + pico_stdlib + hardware_pio + ) + +# add the `binary` directory so that the generated headers are included in the project +# +target_include_directories (nec_transmit_library PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_BINARY_DIR} + ) diff --git a/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_burst.pio b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_burst.pio new file mode 100644 index 0000000..499e892 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_burst.pio @@ -0,0 +1,61 @@ +; +; Copyright (c) 2021 mjcross +; +; SPDX-License-Identifier: BSD-3-Clause +; + + +.program nec_carrier_burst + +; Generate bursts of carrier. +; +; Repeatedly wait for an IRQ to be set then clear it and generate 21 cycles of +; carrier with 25% duty cycle +; +.define NUM_CYCLES 21 ; how many carrier cycles to generate +.define BURST_IRQ 7 ; which IRQ should trigger a carrier burst +.define public TICKS_PER_LOOP 4 ; the number of instructions in the loop (for timing) + +.wrap_target + set X, (NUM_CYCLES - 1) ; initialise the loop counter + wait 1 irq BURST_IRQ ; wait for the IRQ then clear it +cycle_loop: + set pins, 1 ; set the pin high (1 cycle) + set pins, 0 [1] ; set the pin low (2 cycles) + jmp X--, cycle_loop ; (1 more cycle) +.wrap + + +% c-sdk { +static inline void nec_carrier_burst_program_init(PIO pio, uint sm, uint offset, uint pin, float freq) { + // Create a new state machine configuration + // + pio_sm_config c = nec_carrier_burst_program_get_default_config (offset); + + // Map the SET pin group to one pin, namely the `pin` + // parameter to this function. + // + sm_config_set_set_pins (&c, pin, 1); + + // Set the GPIO function of the pin (connect the 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); + + // Set the clock divider to generate the required frequency + // + float div = clock_get_hz (clk_sys) / (freq * nec_carrier_burst_TICKS_PER_LOOP); + sm_config_set_clkdiv (&c, div); + + // Apply the configuration to the state machine + // + pio_sm_init (pio, sm, offset, &c); + + // Set the state machine running + // + pio_sm_set_enabled (pio, sm, true); +} +%} diff --git a/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_control.pio b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_control.pio new file mode 100644 index 0000000..0733afe --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_carrier_control.pio @@ -0,0 +1,79 @@ +; +; Copyright (c) 2021 mjcross +; +; SPDX-License-Identifier: BSD-3-Clause +; + + +.program nec_carrier_control + +; Transmit an encoded 32-bit frame in NEC IR format. +; +; Accepts 32-bit words from the transmit FIFO and sends them least-significant bit first +; using pulse position modulation. +; +; Carrier bursts are generated using the nec_carrier_burst program, which is expected to be +; running on a separate state machine. +; +; This program expects there to be 2 state machine ticks per 'normal' 562.5us +; burst period. +; +.define BURST_IRQ 7 ; the IRQ used to trigger a carrier burst +.define NUM_INITIAL_BURSTS 16 ; how many bursts to transmit for a 'sync burst' + +.wrap_target + pull ; fetch a data word from the transmit FIFO into the + ; output shift register, blocking if the FIFO is empty + + set X, (NUM_INITIAL_BURSTS - 1) ; send a sync burst (9ms) +long_burst: + irq BURST_IRQ + jmp X-- long_burst + + nop [15] ; send a 4.5ms space + irq BURST_IRQ [1] ; send a 562.5us burst to begin the first data bit + +data_bit: + out X, 1 ; shift the least-significant bit from the OSR + jmp !X burst ; send a short delay for a '0' bit + nop [3] ; send an additional delay for a '1' bit +burst: + irq BURST_IRQ ; send a 562.5us burst to end the data bit + +jmp !OSRE data_bit ; continue sending bits until the OSR is empty + +.wrap ; fetch another data word from the FIFO + + +% c-sdk { +static inline void nec_carrier_control_program_init (PIO pio, uint sm, uint offset, float tick_rate, int bits_per_frame) { + + // create a new state machine configuration + // + pio_sm_config c = nec_carrier_control_program_get_default_config(offset); + + // configure the output shift register + // + sm_config_set_out_shift (&c, + true, // shift right + false, // disable autopull + bits_per_frame); + + // join the FIFOs to make a single large transmit FIFO + // + sm_config_set_fifo_join (&c, PIO_FIFO_JOIN_TX); + + // configure the clock divider + // + float div = clock_get_hz (clk_sys) / tick_rate; + sm_config_set_clkdiv (&c, div); + + // apply the configuration to the state machine + // + pio_sm_init(pio, sm, offset, &c); + + // set the state machine running + // + pio_sm_set_enabled(pio, sm, true); +} +%} diff --git a/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.c b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.c new file mode 100644 index 0000000..03ea932 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.c @@ -0,0 +1,78 @@ +/** + * Copyright (c) 2021 mjcross + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +// SDK types and declarations +// +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/clocks.h" // for clock_get_hz() +#include "nec_transmit.h" + +// import the assembled PIO state machine programs +#include "nec_carrier_burst.pio.h" +#include "nec_carrier_control.pio.h" + +// Claim an unused state machine on the specified PIO and configure it +// to transmit NEC IR frames on the specificied GPIO pin. +// +// Returns: on success, the number of the carrier_control state machine +// otherwise -1 +int nec_tx_init(PIO pio, uint pin_num) { + + // install the carrier_burst program in the PIO shared instruction space + uint carrier_burst_offset; + if (pio_can_add_program(pio, &nec_carrier_burst_program)) { + carrier_burst_offset = pio_add_program(pio, &nec_carrier_burst_program); + } else { + return -1; + } + + // claim an unused state machine on this PIO + int carrier_burst_sm = pio_claim_unused_sm(pio, true); + if (carrier_burst_sm == -1) { + return -1; + } + + // configure and enable the state machine + nec_carrier_burst_program_init(pio, + carrier_burst_sm, + carrier_burst_offset, + pin_num, + 38.222e3); // 38.222 kHz carrier + + // install the carrier_control program in the PIO shared instruction space + uint carrier_control_offset; + if (pio_can_add_program(pio, &nec_carrier_control_program)) { + carrier_control_offset = pio_add_program(pio, &nec_carrier_control_program); + } else { + return -1; + } + + // claim an unused state machine on this PIO + int carrier_control_sm = pio_claim_unused_sm(pio, true); + if (carrier_control_sm == -1) { + return -1; + } + + // configure and enable the state machine + nec_carrier_control_program_init(pio, + carrier_control_sm, + carrier_control_offset, + 2 * (1 / 562.5e-6f), // 2 ticks per 562.5us carrier burst + 32); // 32 bits per frame + + return carrier_control_sm; +} + + +// Create a frame in `NEC` format from the provided 8-bit address and data +// +// Returns: a 32-bit encoded frame +uint32_t nec_encode_frame(uint8_t address, uint8_t data) { + // a normal 32-bit frame is encoded as address, inverted address, data, inverse data, + return address | (address ^ 0xff) << 8 | data << 16 | (data ^ 0xff) << 24; +} diff --git a/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.h b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.h new file mode 100644 index 0000000..39c4937 --- /dev/null +++ b/lab2 prob4/pio/ir_nec/nec_transmit_library/nec_transmit.h @@ -0,0 +1,13 @@ +/** + * Copyright (c) 2021 mjcross + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "pico/stdlib.h" +#include "hardware/pio.h" + +// public API + +int nec_tx_init(PIO pio, uint pin); +uint32_t nec_encode_frame(uint8_t address, uint8_t data); diff --git a/lab2 prob4/pio/ir_nec/pio_ir_loopback.fzz b/lab2 prob4/pio/ir_nec/pio_ir_loopback.fzz new file mode 100644 index 0000000..9754f18 Binary files /dev/null and b/lab2 prob4/pio/ir_nec/pio_ir_loopback.fzz differ diff --git a/lab2 prob4/pio/ir_nec/pio_ir_loopback.png b/lab2 prob4/pio/ir_nec/pio_ir_loopback.png new file mode 100644 index 0000000..e5a9e4a Binary files /dev/null and b/lab2 prob4/pio/ir_nec/pio_ir_loopback.png differ diff --git a/lab2 prob4/pio/logic_analyser/CMakeLists.txt b/lab2 prob4/pio/logic_analyser/CMakeLists.txt new file mode 100644 index 0000000..8a65198 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/logic_analyser/logic_analyser.c b/lab2 prob4/pio/logic_analyser/logic_analyser.c new file mode 100644 index 0000000..c3bd573 --- /dev/null +++ b/lab2 prob4/pio/logic_analyser/logic_analyser.c @@ -0,0 +1,159 @@ +/** + * 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 + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/dma.h" +#include "hardware/structs/bus_ctrl.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; + +static inline uint bits_packed_per_word(uint pin_count) { + // If the number of pins to be sampled divides the shift register size, we + // can use the full SR and FIFO width, and push when the input shift count + // exactly reaches 32. If not, we have to push earlier, so we use the FIFO + // a little less efficiently. + const uint SHIFT_REG_WIDTH = 32; + return SHIFT_REG_WIDTH - (SHIFT_REG_WIDTH % pin_count); +} + +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); + // Note that we may push at a < 32 bit threshold if pin_count does not + // divide 32. We are using shift-to-right, so the sample data ends up + // left-justified in the FIFO in this case, with some zeroes at the LSBs. + sm_config_set_in_shift(&c, true, true, bits_packed_per_word(pin_count)); + 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); + // Need to clear _input shift counter_, as well as FIFO, because there may be + // partial ISR contents left over from a previous run. sm_restart does this. + pio_sm_clear_fifos(pio, sm); + pio_sm_restart(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, // Destination 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"); + // Each FIFO record may be only partially filled with bits, depending on + // whether pin_count is a factor of 32. + uint record_size_bits = bits_packed_per_word(pin_count); + 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; + uint word_index = bit_index / record_size_bits; + // Data is left-justified in each FIFO entry, hence the (32 - record_size_bits) offset + uint word_mask = 1u << (bit_index % record_size_bits + 32 - record_size_bits); + printf(buf[word_index] & word_mask ? "-" : "_"); + } + printf("\n"); + } +} + +int main() { + stdio_init_all(); + printf("PIO logic analyser example\n"); + + // We're going to capture into a u32 buffer, for best DMA efficiency. Need + // to be careful of rounding in case the number of pins being sampled + // isn't a power of 2. + uint total_sample_bits = CAPTURE_N_SAMPLES * CAPTURE_PIN_COUNT; + total_sample_bits += bits_packed_per_word(CAPTURE_PIN_COUNT) - 1; + uint buf_size_words = total_sample_bits / bits_packed_per_word(CAPTURE_PIN_COUNT); + uint32_t *capture_buf = malloc(buf_size_words * sizeof(uint32_t)); + hard_assert(capture_buf); + + // Grant high bus priority to the DMA, so it can shove the processors out + // of the way. This should only be needed if you are pushing things up to + // >16bits/clk here, i.e. if you need to saturate the bus completely. + bus_ctrl_hw->priority = BUSCTRL_BUS_PRIORITY_DMA_W_BITS | BUSCTRL_BUS_PRIORITY_DMA_R_BITS; + + 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, buf_size_words, 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; + // ------------------------------------------------------------------------ + + // The logic analyser should have started capturing as soon as it saw the + // first transition. Wait until the last sample comes in from the DMA. + 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/lab2 prob4/pio/manchester_encoding/CMakeLists.txt b/lab2 prob4/pio/manchester_encoding/CMakeLists.txt new file mode 100644 index 0000000..70b8828 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/manchester_encoding/manchester_encoding.c b/lab2 prob4/pio/manchester_encoding/manchester_encoding.c new file mode 100644 index 0000000..4eb0638 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/manchester_encoding/manchester_encoding.pio b/lab2 prob4/pio/manchester_encoding/manchester_encoding.pio new file mode 100644 index 0000000..0117d2a --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/pio_blink/CMakeLists.txt b/lab2 prob4/pio/pio_blink/CMakeLists.txt new file mode 100644 index 0000000..88b5584 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/pio_blink/blink.c b/lab2 prob4/pio/pio_blink/blink.c new file mode 100644 index 0000000..9d253bb --- /dev/null +++ b/lab2 prob4/pio/pio_blink/blink.c @@ -0,0 +1,38 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/clocks.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 %d Hz\n", pin, freq); + + // PIO counter program takes 3 more cycles in total than we pass as + // input (wait for n + 1; mov; jmp) + pio->txf[sm] = (clock_get_hz(clk_sys) / (2 * freq)) - 3; +} diff --git a/lab2 prob4/pio/pio_blink/blink.pio b/lab2 prob4/pio/pio_blink/blink.pio new file mode 100644 index 0000000..ef30900 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/pwm/CMakeLists.txt b/lab2 prob4/pio/pwm/CMakeLists.txt new file mode 100644 index 0000000..7c6f2fc --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/pwm/pwm.c b/lab2 prob4/pio/pwm/pwm.c new file mode 100644 index 0000000..c3148a6 --- /dev/null +++ b/lab2 prob4/pio/pwm/pwm.c @@ -0,0 +1,51 @@ +/** + * 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(); +#ifndef PICO_DEFAULT_LED_PIN +#warning pio/pwm example requires a board with a regular LED + puts("Default LED pin was not defined"); +#else + + // 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, PICO_DEFAULT_LED_PIN); + 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); + } +#endif +} diff --git a/lab2 prob4/pio/pwm/pwm.pio b/lab2 prob4/pio/pwm/pwm.pio new file mode 100644 index 0000000..d0f2bcb --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/quadrature_encoder/CMakeLists.txt b/lab2 prob4/pio/quadrature_encoder/CMakeLists.txt new file mode 100644 index 0000000..b118f3c --- /dev/null +++ b/lab2 prob4/pio/quadrature_encoder/CMakeLists.txt @@ -0,0 +1,18 @@ +add_executable(pio_quadrature_encoder) + +pico_generate_pio_header(pio_quadrature_encoder ${CMAKE_CURRENT_LIST_DIR}/quadrature_encoder.pio) + +target_sources(pio_quadrature_encoder PRIVATE quadrature_encoder.c) + +target_link_libraries(pio_quadrature_encoder PRIVATE + pico_stdlib + pico_multicore + hardware_pio + ) + +pico_enable_stdio_usb(pio_quadrature_encoder 1) + +pico_add_extra_outputs(pio_quadrature_encoder) + +# add url via pico_set_program_url +example_auto_set_url(pio_quadrature_encoder) diff --git a/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.c b/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.c new file mode 100644 index 0000000..a11ab89 --- /dev/null +++ b/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.c @@ -0,0 +1,61 @@ +/** + * Copyright (c) 2021 pmarques-dev @ github + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include "pico/stdlib.h" +#include "hardware/pio.h" +#include "hardware/timer.h" + +#include "quadrature_encoder.pio.h" + +// +// ---- quadrature encoder interface example +// +// the PIO program reads phase A/B of a quadrature encoder and increments or +// decrements an internal counter to keep the current absolute step count +// updated. At any point, the main code can query the current count by using +// the quadrature_encoder_*_count functions. The counter is kept in a full +// 32 bit register that just wraps around. Two's complement arithmetic means +// that it can be interpreted as a 32-bit signed or unsigned value, and it will +// work anyway. +// +// As an example, a two wheel robot being controlled at 100Hz, can use two +// state machines to read the two encoders and in the main control loop it can +// simply ask for the current encoder counts to get the absolute step count. It +// can also subtract the values from the last sample to check how many steps +// each wheel as done since the last sample period. +// +// One advantage of this approach is that it requires zero CPU time to keep the +// encoder count updated and because of that it supports very high step rates. +// + +int main() { + int new_value, delta, old_value = 0; + + // Base pin to connect the A phase of the encoder. + // The B phase must be connected to the next pin + const uint PIN_AB = 10; + + stdio_init_all(); + + PIO pio = pio0; + const uint sm = 0; + + uint offset = pio_add_program(pio, &quadrature_encoder_program); + quadrature_encoder_program_init(pio, sm, offset, PIN_AB, 0); + + while (1) { + // note: thanks to two's complement arithmetic delta will always + // be correct even when new_value wraps around MAXINT / MININT + new_value = quadrature_encoder_get_count(pio, sm); + delta = new_value - old_value; + old_value = new_value; + + printf("position %8d, delta %6d\n", new_value, delta); + sleep_ms(100); + } +} + diff --git a/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.pio b/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.pio new file mode 100644 index 0000000..d245d4b --- /dev/null +++ b/lab2 prob4/pio/quadrature_encoder/quadrature_encoder.pio @@ -0,0 +1,165 @@ +; +; Copyright (c) 2021 pmarques-dev @ github +; +; SPDX-License-Identifier: BSD-3-Clause +; + +.program quadrature_encoder + +; this code must be loaded into address 0, but at 29 instructions, it probably +; wouldn't be able to share space with other programs anyway +.origin 0 + + +; the code works by running a loop that continuously shifts the 2 phase pins into +; ISR and looks at the lower 4 bits to do a computed jump to an instruction that +; does the proper "do nothing" | "increment" | "decrement" action for that pin +; state change (or no change) + +; ISR holds the last state of the 2 pins during most of the code. The Y register +; keeps the current encoder count and is incremented / decremented according to +; the steps sampled + +; writing any non zero value to the TX FIFO makes the state machine push the +; current count to RX FIFO between 6 to 18 clocks afterwards. The worst case +; sampling loop takes 14 cycles, so this program is able to read step rates up +; to sysclk / 14 (e.g., sysclk 125MHz, max step rate = 8.9 Msteps/sec) + + +; 00 state + JMP update ; read 00 + JMP decrement ; read 01 + JMP increment ; read 10 + JMP update ; read 11 + +; 01 state + JMP increment ; read 00 + JMP update ; read 01 + JMP update ; read 10 + JMP decrement ; read 11 + +; 10 state + JMP decrement ; read 00 + JMP update ; read 01 + JMP update ; read 10 + JMP increment ; read 11 + +; to reduce code size, the last 2 states are implemented in place and become the +; target for the other jumps + +; 11 state + JMP update ; read 00 + JMP increment ; read 01 +decrement: + ; note: the target of this instruction must be the next address, so that + ; the effect of the instruction does not depend on the value of Y. The + ; same is true for the "JMP X--" below. Basically "JMP Y--, " + ; is just a pure "decrement Y" instruction, with no other side effects + JMP Y--, update ; read 10 + + ; this is where the main loop starts +.wrap_target +update: + ; we start by checking the TX FIFO to see if the main code is asking for + ; the current count after the PULL noblock, OSR will have either 0 if + ; there was nothing or the value that was there + SET X, 0 + PULL noblock + + ; since there are not many free registers, and PULL is done into OSR, we + ; have to do some juggling to avoid losing the state information and + ; still place the values where we need them + MOV X, OSR + MOV OSR, ISR + + ; the main code did not ask for the count, so just go to "sample_pins" + JMP !X, sample_pins + + ; if it did ask for the count, then we push it + MOV ISR, Y ; we trash ISR, but we already have a copy in OSR + PUSH + +sample_pins: + ; we shift into ISR the last state of the 2 input pins (now in OSR) and + ; the new state of the 2 pins, thus producing the 4 bit target for the + ; computed jump into the correct action for this state + MOV ISR, NULL + IN OSR, 2 + IN PINS, 2 + MOV PC, ISR + + ; the PIO does not have a increment instruction, so to do that we do a + ; negate, decrement, negate sequence +increment: + MOV X, !Y + JMP X--, increment_cont +increment_cont: + MOV Y, !X +.wrap ; the .wrap here avoids one jump instruction and saves a cycle too + + + +% c-sdk { + +#include "hardware/clocks.h" +#include "hardware/gpio.h" + +// max_step_rate is used to lower the clock of the state machine to save power +// if the application doesn't require a very high sampling rate. Passing zero +// will set the clock to the maximum, which gives a max step rate of around +// 8.9 Msteps/sec at 125MHz + +static inline void quadrature_encoder_program_init(PIO pio, uint sm, uint offset, uint pin, int max_step_rate) +{ + pio_sm_set_consecutive_pindirs(pio, sm, pin, 2, false); + gpio_pull_up(pin); + gpio_pull_up(pin + 1); + + pio_sm_config c = quadrature_encoder_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 left, autopull disabled + sm_config_set_in_shift(&c, false, false, 32); + // don't join FIFO's + sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_NONE); + + // passing "0" as the sample frequency, + if (max_step_rate == 0) { + sm_config_set_clkdiv(&c, 1.0); + } else { + // one state machine loop takes at most 14 cycles + float div = (float)clock_get_hz(clk_sys) / (14 * max_step_rate); + sm_config_set_clkdiv(&c, div); + } + + pio_sm_init(pio, sm, offset, &c); + pio_sm_set_enabled(pio, sm, true); +} + + +// When requesting the current count we may have to wait a few cycles (average +// ~11 sysclk cycles) for the state machine to reply. If we are reading multiple +// encoders, we may request them all in one go and then fetch them all, thus +// avoiding doing the wait multiple times. If we are reading just one encoder, +// we can use the "get_count" function to request and wait + +static inline void quadrature_encoder_request_count(PIO pio, uint sm) +{ + pio->txf[sm] = 1; +} + +static inline int32_t quadrature_encoder_fetch_count(PIO pio, uint sm) +{ + while (pio_sm_is_rx_fifo_empty(pio, sm)) + tight_loop_contents(); + return pio->rxf[sm]; +} + +static inline int32_t quadrature_encoder_get_count(PIO pio, uint sm) +{ + quadrature_encoder_request_count(pio, sm); + return quadrature_encoder_fetch_count(pio, sm); +} + +%} + diff --git a/lab2 prob4/pio/spi/CMakeLists.txt b/lab2 prob4/pio/spi/CMakeLists.txt new file mode 100644 index 0000000..44c561a --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/spi/pio_spi.c b/lab2 prob4/pio/spi/pio_spi.c new file mode 100644 index 0000000..6306b7d --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/spi/pio_spi.h b/lab2 prob4/pio/spi/pio_spi.h new file mode 100644 index 0000000..dfa929d --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/spi/spi.pio b/lab2 prob4/pio/spi/spi.pio new file mode 100644 index 0000000..eba785e --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/spi/spi_flash.c b/lab2 prob4/pio/spi/spi_flash.c new file mode 100644 index 0000000..fd97f17 --- /dev/null +++ b/lab2 prob4/pio/spi/spi_flash.c @@ -0,0 +1,159 @@ +/** + * Copyright (c) 2020 Raspberry Pi (Trading) Ltd. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include "pico/stdlib.h" +#include "pico/binary_info.h" +#include "pio_spi.h" + +// This example uses PIO to erase, program and read back a SPI serial flash +// memory. + +// ---------------------------------------------------------------------------- +// 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(); +#if !defined(PICO_DEFAULT_SPI_SCK_PIN) || !defined(PICO_DEFAULT_SPI_TX_PIN) || !defined(PICO_DEFAULT_SPI_RX_PIN) || !defined(PICO_DEFAULT_SPI_CSN_PIN) +#warning pio/spi/spi_flash example requires a board with SPI pins + puts("Default SPI pins were not defined"); +#else + + puts("PIO SPI Example"); + + pio_spi_inst_t spi = { + .pio = pio0, + .sm = 0, + .cs_pin = PICO_DEFAULT_SPI_CSN_PIN + }; + + gpio_init(PICO_DEFAULT_SPI_CSN_PIN); + gpio_put(PICO_DEFAULT_SPI_CSN_PIN, 1); + gpio_set_dir(PICO_DEFAULT_SPI_CSN_PIN, 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 + PICO_DEFAULT_SPI_SCK_PIN, + PICO_DEFAULT_SPI_TX_PIN, + PICO_DEFAULT_SPI_RX_PIN + ); + // Make the 'SPI' pins available to picotool + bi_decl(bi_4pins_with_names(PICO_DEFAULT_SPI_RX_PIN, "SPI RX", PICO_DEFAULT_SPI_TX_PIN, "SPI TX", PICO_DEFAULT_SPI_SCK_PIN, "SPI SCK", PICO_DEFAULT_SPI_CSN_PIN, "SPI CS")); + + 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; +#endif +} diff --git a/lab2 prob4/pio/spi/spi_loopback.c b/lab2 prob4/pio/spi/spi_loopback.c new file mode 100644 index 0000000..ac5897f --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/squarewave/CMakeLists.txt b/lab2 prob4/pio/squarewave/CMakeLists.txt new file mode 100644 index 0000000..fd095e2 --- /dev/null +++ b/lab2 prob4/pio/squarewave/CMakeLists.txt @@ -0,0 +1,34 @@ +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 + ${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/lab2 prob4/pio/squarewave/generated/squarewave.hex b/lab2 prob4/pio/squarewave/generated/squarewave.hex new file mode 100644 index 0000000..4486018 --- /dev/null +++ b/lab2 prob4/pio/squarewave/generated/squarewave.hex @@ -0,0 +1,4 @@ +e081 +e101 +e000 +0001 diff --git a/lab2 prob4/pio/squarewave/generated/squarewave.pio.h b/lab2 prob4/pio/squarewave/generated/squarewave.pio.h new file mode 100644 index 0000000..9ff8f86 --- /dev/null +++ b/lab2 prob4/pio/squarewave/generated/squarewave.pio.h @@ -0,0 +1,40 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#pragma once + +#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/lab2 prob4/pio/squarewave/generated/squarewave_wrap.pio.h b/lab2 prob4/pio/squarewave/generated/squarewave_wrap.pio.h new file mode 100644 index 0000000..3084543 --- /dev/null +++ b/lab2 prob4/pio/squarewave/generated/squarewave_wrap.pio.h @@ -0,0 +1,39 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#pragma once + +#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/lab2 prob4/pio/squarewave/squarewave.c b/lab2 prob4/pio/squarewave/squarewave.c new file mode 100644 index 0000000..40a7809 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/squarewave/squarewave.pio b/lab2 prob4/pio/squarewave/squarewave.pio new file mode 100644 index 0000000..405c899 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/squarewave/squarewave_fast.pio b/lab2 prob4/pio/squarewave/squarewave_fast.pio new file mode 100644 index 0000000..26162fa --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/squarewave/squarewave_wrap.pio b/lab2 prob4/pio/squarewave/squarewave_wrap.pio new file mode 100644 index 0000000..100f09c --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/st7789_lcd/CMakeLists.txt b/lab2 prob4/pio/st7789_lcd/CMakeLists.txt new file mode 100644 index 0000000..a6243e6 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/st7789_lcd/raspberry_256x256.png b/lab2 prob4/pio/st7789_lcd/raspberry_256x256.png new file mode 100644 index 0000000..1f12d14 Binary files /dev/null and b/lab2 prob4/pio/st7789_lcd/raspberry_256x256.png differ diff --git a/lab2 prob4/pio/st7789_lcd/raspberry_256x256_rgb565.h b/lab2 prob4/pio/st7789_lcd/raspberry_256x256_rgb565.h new file mode 100644 index 0000000..15493b5 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/st7789_lcd/st7789_lcd.c b/lab2 prob4/pio/st7789_lcd/st7789_lcd.c new file mode 100644 index 0000000..dde9efe --- /dev/null +++ b/lab2 prob4/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 + // Raspberry Pi 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/lab2 prob4/pio/st7789_lcd/st7789_lcd.pio b/lab2 prob4/pio/st7789_lcd/st7789_lcd.pio new file mode 100644 index 0000000..aa35c68 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/uart_rx/CMakeLists.txt b/lab2 prob4/pio/uart_rx/CMakeLists.txt new file mode 100644 index 0000000..c2adc6e --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/uart_rx/uart_rx.c b/lab2 prob4/pio/uart_rx/uart_rx.c new file mode 100644 index 0000000..2b7722e --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/uart_rx/uart_rx.pio b/lab2 prob4/pio/uart_rx/uart_rx.pio new file mode 100644 index 0000000..54a6577 --- /dev/null +++ b/lab2 prob4/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, autopush 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/lab2 prob4/pio/uart_tx/CMakeLists.txt b/lab2 prob4/pio/uart_tx/CMakeLists.txt new file mode 100644 index 0000000..5e3cf2a --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/uart_tx/uart_tx.c b/lab2 prob4/pio/uart_tx/uart_tx.c new file mode 100644 index 0000000..26266b9 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/uart_tx/uart_tx.pio b/lab2 prob4/pio/uart_tx/uart_tx.pio new file mode 100644 index 0000000..b1320f6 --- /dev/null +++ b/lab2 prob4/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/lab2 prob4/pio/ws2812/CMakeLists.txt b/lab2 prob4/pio/ws2812/CMakeLists.txt new file mode 100644 index 0000000..c9032c6 --- /dev/null +++ b/lab2 prob4/pio/ws2812/CMakeLists.txt @@ -0,0 +1,38 @@ +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 hello_usb.c ws2812.c ws2812.h) + +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 ${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) + +pico_enable_stdio_usb(pio_ws2812 1) #enable usb output +pico_enable_stdio_uart(pio_ws2812 0) #disable uart output \ No newline at end of file diff --git a/lab2 prob4/pio/ws2812/generated/ws2812.pio.h b/lab2 prob4/pio/ws2812/generated/ws2812.pio.h new file mode 100644 index 0000000..f219957 --- /dev/null +++ b/lab2 prob4/pio/ws2812/generated/ws2812.pio.h @@ -0,0 +1,114 @@ +// -------------------------------------------------- // +// This file is autogenerated by pioasm; do not edit! // +// -------------------------------------------------- // + +#pragma once + +#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" +#include "ws2812.h" + +#define IS_RGBW true +#define NUM_PIXELS 150 + +#ifdef PICO_DEFAULT_WS2812_PIN +#define WS2812_PIN PICO_DEFAULT_WS2812_PIN +#else +// default to pin 2 if the board doesn't have a default WS2812 pin defined +#define WS2812_PIN 12 +#define WS2812_POWER_PIN 11 +#endif + +void turn_on_NeoPixel_power(){ + const uint led_pin = WS2812_POWER_PIN; + gpio_init(led_pin); + gpio_set_dir(led_pin, GPIO_OUT); + gpio_put(led_pin, 1); +} + +int main() { + + //set_sys_clock_48(); + stdio_init_all(); + printf("WS2812 Smoke Test, using pin %d", WS2812_PIN); + + turn_on_NeoPixel_power(); + + // todo get free sm + PIO pio = pio0; + int sm = 0; + uint offset = pio_add_program(pio, &ws2812_program); + + ws2812_program_init(pio, sm, offset, WS2812_PIN, 800000, IS_RGBW); + + //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(NUM_PIXELS, t); + sleep_ms(10); + t += dir; + } + }*/ + + int my_toggle = 0; + + while (1) { + if(my_toggle == 1){ + printf("Hello, world! GREEN\n"); + sleep_ms(500); + my_toggle = 0; + set_neopixel_color(0xff0000); + } + else { + printf("Hello, world! BLUE\n"); + sleep_ms(500); + my_toggle = 1; + set_neopixel_color(0x0000ff); + } + + } + + return 0; +} diff --git a/lab2 prob4/pio/ws2812/ws2812.c b/lab2 prob4/pio/ws2812/ws2812.c new file mode 100644 index 0000000..a9f61c1 --- /dev/null +++ b/lab2 prob4/pio/ws2812/ws2812.c @@ -0,0 +1,79 @@ +/** + * 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/clocks.h" +#include "ws2812.pio.h" +#include "ws2812.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"}, +}; + +// set neopixel color function +void set_neopixel_color(uint32_t color){ + + put_pixel(color); +} \ No newline at end of file diff --git a/lab2 prob4/pio/ws2812/ws2812.h b/lab2 prob4/pio/ws2812/ws2812.h new file mode 100644 index 0000000..62d0b80 --- /dev/null +++ b/lab2 prob4/pio/ws2812/ws2812.h @@ -0,0 +1,16 @@ +#ifndef _WS2812_H +#define _WS2812_H + +#ifdef PICO_DEFAULT_WS2812_PIN +#define WS2812_PIN PICO_DEFAULT_WS2812_PIN +#else +// default to pin 2 if the board doesn't have a default WS2812 pin defined +#define WS2812_PIN 12 +#define WS2812_POWER_PIN 11 +#endif + +void set_neopixel_color(uint32_t color); + + + +#endif \ No newline at end of file diff --git a/lab2 prob4/pio/ws2812/ws2812.pio b/lab2 prob4/pio/ws2812/ws2812.pio new file mode 100644 index 0000000..3c31fd6 --- /dev/null +++ b/lab2 prob4/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 NUM_PIXELS 64 +#define WS2812_PIN_BASE 2 + +// 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); + } +} + +// requested colors * 4 to allow for RGBW +static value_bits_t colors[NUM_PIXELS * 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][NUM_PIXELS * 4]; + +// example - string 0 is RGB only +static uint8_t string0_data[NUM_PIXELS * 3]; +// example - string 1 is RGBW +static uint8_t string1_data[NUM_PIXELS * 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[NUM_PIXELS * 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 + 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) { + 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; +} + + +int main() { + //set_sys_clock_48(); + stdio_init_all(); + puts("WS2812 parallel"); + + // 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, WS2812_PIN_BASE, 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) { + current_string_out = string0.data; + current_string_4color = false; + pattern_table[pat].pat(NUM_PIXELS, t); + current_string_out = string1.data; + current_string_4color = true; + pattern_table[pat].pat(NUM_PIXELS, t); + + transform_strings(strings, count_of(strings), colors, NUM_PIXELS * 4, brightness); + dither_values(colors, states[current], states[current ^ 1], NUM_PIXELS * 4); + sem_acquire_blocking(&reset_delay_complete_sem); + output_strings_dma(states[current], NUM_PIXELS * 4); + + current ^= 1; + t += dir; + brightness++; + if (brightness == (0x20 << FRAC_BITS)) brightness = 0; + } + memset(&states, 0, sizeof(states)); // clear out errors + } +} diff --git a/nmake.png b/nmake.png new file mode 100644 index 0000000..3e8edcf Binary files /dev/null and b/nmake.png differ diff --git a/python3.10.png b/python3.10.png new file mode 100644 index 0000000..c90d1a5 Binary files /dev/null and b/python3.10.png differ