From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: FantasyGmm <16450052+FantasyGmm@users.noreply.github.com> Date: Sun, 28 Jan 2024 23:02:42 +0800 Subject: Patching kernel arm64 files drivers/gpio/gpiolib-of.c drivers/input/touchscreen/Kconfig drivers/input/touchscreen/Makefile drivers/input/touchscreen/fts_521/Kconfig drivers/input/touchscreen/fts_521/Makefile drivers/input/touchscreen/fts_521/fts.c drivers/input/touchscreen/fts_521/fts.h drivers/input/touchscreen/fts_521/fts_fw.h drivers/input/touchscreen/fts_521/fts_lib/Makefile drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.c drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.h drivers/input/touchscreen/fts_521/fts_lib/ftsCore.c drivers/input/touchscreen/fts_521/fts_lib/ftsCore.h drivers/input/touchscreen/fts_521/fts_lib/ftsError.c drivers/input/touchscreen/fts_521/fts_lib/ftsError.h drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.c drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.h drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.c drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.h drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.c drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.h drivers/input/touchscreen/fts_521/fts_lib/ftsHardware.h drivers/input/touchscreen/fts_521/fts_lib/ftsIO.c drivers/input/touchscreen/fts_521/fts_lib/ftsIO.h drivers/input/touchscreen/fts_521/fts_lib/ftsSoftware.h drivers/input/touchscreen/fts_521/fts_lib/ftsTest.c drivers/input/touchscreen/fts_521/fts_lib/ftsTest.h drivers/input/touchscreen/fts_521/fts_lib/ftsTime.c drivers/input/touchscreen/fts_521/fts_lib/ftsTime.h drivers/input/touchscreen/fts_521/fts_lib/ftsTool.c drivers/input/touchscreen/fts_521/fts_lib/ftsTool.h drivers/input/touchscreen/fts_521/fts_limits.h drivers/input/touchscreen/fts_521/fts_proc.c include/linux/of_gpio.h --- drivers/gpio/gpiolib-of.c | 19 +- drivers/input/touchscreen/Kconfig | 1 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/fts_521/Kconfig | 25 + drivers/input/touchscreen/fts_521/Makefile | 6 + drivers/input/touchscreen/fts_521/fts.c | 6519 +++++ drivers/input/touchscreen/fts_521/fts.h | 393 + drivers/input/touchscreen/fts_521/fts_fw.h | 12573 ++++++++++ drivers/input/touchscreen/fts_521/fts_lib/Makefile | 7 + drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.c | 790 + drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.h | 110 + drivers/input/touchscreen/fts_521/fts_lib/ftsCore.c | 1365 + drivers/input/touchscreen/fts_521/fts_lib/ftsCore.h | 180 + drivers/input/touchscreen/fts_521/fts_lib/ftsError.c | 357 + drivers/input/touchscreen/fts_521/fts_lib/ftsError.h | 145 + drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.c | 1032 + drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.h | 100 + drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.c | 398 + drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.h | 91 + drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.c | 349 + drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.h | 38 + drivers/input/touchscreen/fts_521/fts_lib/ftsHardware.h | 191 + drivers/input/touchscreen/fts_521/fts_lib/ftsIO.c | 911 + drivers/input/touchscreen/fts_521/fts_lib/ftsIO.h | 59 + drivers/input/touchscreen/fts_521/fts_lib/ftsSoftware.h | 379 + drivers/input/touchscreen/fts_521/fts_lib/ftsTest.c | 5936 +++++ drivers/input/touchscreen/fts_521/fts_lib/ftsTest.h | 293 + drivers/input/touchscreen/fts_521/fts_lib/ftsTime.c | 80 + drivers/input/touchscreen/fts_521/fts_lib/ftsTime.h | 57 + drivers/input/touchscreen/fts_521/fts_lib/ftsTool.c | 648 + drivers/input/touchscreen/fts_521/fts_lib/ftsTool.h | 56 + drivers/input/touchscreen/fts_521/fts_limits.h | 2109 ++ drivers/input/touchscreen/fts_521/fts_proc.c | 2451 ++ include/linux/of_gpio.h | 27 + 34 files changed, 37694 insertions(+), 2 deletions(-) diff --git a/drivers/gpio/gpiolib-of.c b/drivers/gpio/gpiolib-of.c index 402f7d99b0c1..eec54727163d 100644 --- a/drivers/gpio/gpiolib-of.c +++ b/drivers/gpio/gpiolib-of.c @@ -29,7 +29,7 @@ * This is Linux-specific flags. By default controllers' and Linux' mapping * match, but GPIO controllers are free to translate their own flags to * Linux-specific in their .xlate callback. Though, 1:1 mapping is recommended. - */ + enum of_gpio_flags { OF_GPIO_ACTIVE_LOW = 0x1, OF_GPIO_SINGLE_ENDED = 0x2, @@ -39,7 +39,8 @@ enum of_gpio_flags { OF_GPIO_PULL_DOWN = 0x20, OF_GPIO_PULL_DISABLE = 0x40, }; - + */ + /** * of_gpio_named_count() - Count GPIOs for a device * @np: device node to count GPIOs for @@ -408,6 +409,20 @@ static struct gpio_desc *of_get_named_gpiod_flags(const struct device_node *np, return desc; } +int of_get_named_gpio_flags(struct device_node *np, const char *list_name, + int index, enum of_gpio_flags *flags) +{ + struct gpio_desc *desc; + + desc = of_get_named_gpiod_flags(np, list_name, index, flags); + + if (IS_ERR(desc)) + return PTR_ERR(desc); + else + return desc_to_gpio(desc); +} +EXPORT_SYMBOL_GPL(of_get_named_gpio_flags); + /** * of_get_named_gpio() - Get a GPIO number to use with GPIO API * @np: device node to get GPIO from diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 1f8b33c2b03d..8ef609788abd 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -12,6 +12,7 @@ menuconfig INPUT_TOUCHSCREEN if INPUT_TOUCHSCREEN +source "drivers/input/touchscreen/fts_521/Kconfig" source "drivers/input/touchscreen/nt36523/Kconfig" config TOUCHSCREEN_88PM860X diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 7d52592f4290..4b9fe7c9c305 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -119,3 +119,4 @@ obj-$(CONFIG_TOUCHSCREEN_IQS7211) += iqs7211.o obj-$(CONFIG_TOUCHSCREEN_ZINITIX) += zinitix.o obj-$(CONFIG_TOUCHSCREEN_HIMAX_HX83112B) += himax_hx83112b.o obj-$(CONFIG_TOUCHSCREEN_NT36523_SPI) += nt36523/ +obj-$(CONFIG_TOUCHSCREEN_ST_FTS_V521) += fts_521/ diff --git a/drivers/input/touchscreen/fts_521/Kconfig b/drivers/input/touchscreen/fts_521/Kconfig new file mode 100644 index 000000000000..3f2e20abb7f8 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/Kconfig @@ -0,0 +1,25 @@ +config TOUCHSCREEN_ST_FTS_V521 + tristate "ST FTS V521 I2C Touchscreen" + depends on I2C + help + Say Y here if you have ST FTS series I2C touchscreen. + + If unsure, say N. + + To compile this driver as a module, choose M here: the + +config FTS_FOD_AREA_REPORT + tristate "FTS FOD area report" + depends on TOUCHSCREEN_ST_FTS_V521 + help + Say Y here to enable fod area report functionality. + + If unsure, say N. + +config TOUCHSCREEN_ST_DEBUG_FS + tristate "St core driver module" + depends on TOUCHSCREEN_ST_FTS_V521 + help + Say Y here to enable touch debugfs functionality. + + If unsure, say N. \ No newline at end of file diff --git a/drivers/input/touchscreen/fts_521/Makefile b/drivers/input/touchscreen/fts_521/Makefile new file mode 100644 index 000000000000..cf21f2190fcc --- /dev/null +++ b/drivers/input/touchscreen/fts_521/Makefile @@ -0,0 +1,6 @@ +# +# Makefile for the touchscreen drivers. +# + +obj-$(CONFIG_TOUCHSCREEN_ST_FTS_V521) += fts.o fts_proc.o fts_lib/ + diff --git a/drivers/input/touchscreen/fts_521/fts.c b/drivers/input/touchscreen/fts_521/fts.c new file mode 100644 index 000000000000..d2c3342fa830 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts.c @@ -0,0 +1,6519 @@ +/* + * fts.c + * + * FTS Capacitive touch screen controller (FingerTipS) + * + * Copyright (C) 2016, STMicroelectronics Limited. + * Authors: AMG(Analog Mems Group) + * + * marco.cali@st.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES + * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE + * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT. + * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, + * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE + * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING + * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. + * + * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS. + */ + +/*! +* \file fts.c +* \brief It is the main file which contains all the most important functions generally used by a device driver the driver +*/ +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef CONFIG_SECURE_TOUCH +#include +#include +#include +#endif + +#include +#include +#include + +#include +/* +#ifdef CONFIG_DRM +#include +#endif +*/ +#include +#include +#include +#include + +#ifdef KERNEL_ABOVE_2_6_38 +#include +#endif +#include + +#include "fts.h" +#include "fts_lib/ftsCompensation.h" +#include "fts_lib/ftsCore.h" +#include "fts_lib/ftsIO.h" +#include "fts_lib/ftsError.h" +#include "fts_lib/ftsFlash.h" +#include "fts_lib/ftsFrame.h" +#include "fts_lib/ftsGesture.h" +#include "fts_lib/ftsTest.h" +#include "fts_lib/ftsTime.h" +#include "fts_lib/ftsTool.h" + +#define PROC_SYMLINK_PATH "touchpanel" + +/** + * Event handler installer helpers + */ +#define event_id(_e) (EVT_ID_##_e>>4) +#define handler_name(_h) fts_##_h##_event_handler + +#define install_handler(_i, _evt, _hnd) \ +do { \ + _i->event_dispatch_table[event_id(_evt)] = handler_name(_hnd); \ +} while (0) + +#ifdef KERNEL_ABOVE_2_6_38 +#define TYPE_B_PROTOCOL +#endif + +#define INPUT_EVENT_START 0 +#define INPUT_EVENT_SENSITIVE_MODE_OFF 0 +#define INPUT_EVENT_SENSITIVE_MODE_ON 1 +#define INPUT_EVENT_STYLUS_MODE_OFF 2 +#define INPUT_EVENT_STYLUS_MODE_ON 3 +#define INPUT_EVENT_WAKUP_MODE_OFF 4 +#define INPUT_EVENT_WAKUP_MODE_ON 5 +#define INPUT_EVENT_COVER_MODE_OFF 6 +#define INPUT_EVENT_COVER_MODE_ON 7 +#define INPUT_EVENT_SLIDE_FOR_VOLUME 8 +#define INPUT_EVENT_DOUBLE_TAP_FOR_VOLUME 9 +#define INPUT_EVENT_SINGLE_TAP_FOR_VOLUME 10 +#define INPUT_EVENT_LONG_SINGLE_TAP_FOR_VOLUME 11 +#define INPUT_EVENT_PALM_OFF 12 +#define INPUT_EVENT_PALM_ON 13 +#define INPUT_EVENT_END 13 + +extern SysInfo systemInfo; +extern TestToDo tests; +#ifdef GESTURE_MODE +extern struct mutex gestureMask_mutex; +#endif + +char tag[8] = "[ FTS ]\0"; +/* buffer which store the input device name assigned by the kernel */ +char fts_ts_phys[64]; +/* buffer used to store the command sent from the MP device file node */ +static u32 typeOfComand[CMD_STR_LEN] = { 0 }; + +/* number of parameter passed through the MP device file node */ +static int numberParameters; +#ifdef USE_ONE_FILE_NODE +static int feature_feasibility = ERROR_OP_NOT_ALLOW; +#endif +#ifdef GESTURE_MODE +static u8 mask[GESTURE_MASK_SIZE + 2]; +extern u16 gesture_coordinates_x[GESTURE_MAX_COORDS_PAIRS_REPORT]; +extern u16 gesture_coordinates_y[GESTURE_MAX_COORDS_PAIRS_REPORT]; +extern int gesture_coords_reported; +extern struct mutex gestureMask_mutex; +#endif +/* store the last update of the key mask published by the IC */ +#ifdef PHONE_KEY +static u8 key_mask; +#endif + +extern spinlock_t fts_int; +struct fts_ts_info *fts_info; + +static int fts_init_sensing(struct fts_ts_info *info); +static int fts_mode_handler(struct fts_ts_info *info, int force); +static int fts_chip_initialization(struct fts_ts_info *info, int init_type); +static const char *fts_get_limit(struct fts_ts_info *info); +static irqreturn_t fts_event_handler(int irq, void *ts_info); + +/** +* Release all the touches in the linux input subsystem +* @param info pointer to fts_ts_info which contains info about the device and its hw setup +*/ +void release_all_touches(struct fts_ts_info *info) +{ + unsigned int type = MT_TOOL_FINGER; + int i; + + for (i = 0; i < TOUCH_ID_MAX; i++) { +#ifdef STYLUS_MODE + if (test_bit(i, &info->stylus_id)) + type = MT_TOOL_PEN; + else + type = MT_TOOL_FINGER; +#endif + info->coor[i][0] = -1; + info->coor[i][1] = -1; + input_mt_slot(info->input_dev, i); + input_mt_report_slot_state(info->input_dev, type, 0); + input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, -1); + } + input_sync(info->input_dev); + info->touch_id = 0; + info->touch_skip = 0; + info->fod_id = 0; +#ifdef STYLUS_MODE + info->stylus_id = 0; +#endif +} + +/** + * @defgroup file_nodes Driver File Nodes + * Driver publish a series of file nodes used to provide several utilities to the host and give him access to different API. + * @{ + */ + +/** + * @defgroup device_file_nodes Device File Nodes + * @ingroup file_nodes + * Device File Nodes \n + * There are several file nodes that are associated to the device and which are designed to be used by the host to enable/disable features or trigger some system specific actions \n + * Usually their final path depend on the definition of device tree node of the IC (e.g /sys/devices/soc.0/f9928000.i2c/i2c-6/6-0049) + * @{ + */ +/***************************************** FW UPGGRADE ***************************************************/ + +/** + * File node function to Update firmware from shell \n + * echo path_to_fw X Y > fwupdate perform a fw update \n + * where: \n + * path_to_fw = file name or path of the the FW to burn, if "NULL" the default approach selected in the driver will be used\n + * X = 0/1 to force the FW update whichever fw_version and config_id; 0=perform a fw update only if the fw in the file is newer than the fw in the chip \n + * Y = 0/1 keep the initialization data; 0 = will erase the initialization data from flash, 1 = will keep the initialization data + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent an error code (00000000 no error) \n + * } = end byte + */ +static ssize_t fts_fwupdate_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int ret, mode[2]; + char path[100]; + struct fts_ts_info *info = dev_get_drvdata(dev); + + /* by default(if not specified by the user) set the force = 0 and keep_cx to 1 */ + mode[0] = 0; + mode[1] = 1; + + /* reading out firmware upgrade parameters */ + sscanf(buf, "%100s %d %d", path, &mode[0], &mode[1]); + logError(1, "%s fts_fwupdate_store: mode = %s \n", tag, path); + + ret = flashProcedure(path, mode[0], mode[1]); + + info->fwupdate_stat = ret; + + if (ret < OK) + logError(1, "%s %s Unable to upgrade firmware! ERROR %08X\n", + tag, __func__, ret); + return count; +} + +static ssize_t fts_fwupdate_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + /*fwupdate_stat: ERROR code Returned by flashProcedure. */ + return snprintf(buf, PAGE_SIZE, "{ %08X }\n", info->fwupdate_stat); +} + +/***************************************** UTILITIES (current fw_ver/conf_id, active mode, file fw_ver/conf_id) ***************************************************/ +/** +* File node to show on terminal external release version in Little Endian (first the less significant byte) \n +* cat appid show on the terminal external release version of the FW running in the IC +*/ +static ssize_t fts_appid_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int error; + char temp[100] = { 0x00, }; + + error = snprintf(buf, PAGE_SIZE, "%s\n", + printHex("EXT Release = ", systemInfo.u8_releaseInfo, + EXTERNAL_RELEASE_INFO_SIZE, temp)); + + return error; +} + +/** + * File node to show on terminal the mode that is active on the IC \n + * cat mode_active to show the bitmask which indicate the modes/features which are running on the IC in a specific instant of time + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1 = 1 byte in HEX format which represent the actual running scan mode (@link scan_opt Scan Mode Options @endlink) \n + * X2 = 1 byte in HEX format which represent the bitmask on which is running the actual scan mode \n + * X3X4 = 2 bytes in HEX format which represent a bitmask of the features that are enabled at this moment (@link feat_opt Feature Selection Options @endlink) \n + * } = end byte + * @see fts_mode_handler() + */ +static ssize_t fts_mode_active_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(1, "%s Current mode active = %08X\n", tag, info->mode); + return snprintf(buf, PAGE_SIZE, "{ %08X }\n", info->mode); +} + +/** + * File node to show the fw_ver and config_id of the FW file + * cat fw_file_test show on the kernel log fw_version and config_id of the FW stored in the fw file/header file + */ +static ssize_t fts_fw_test_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + Firmware fw; + int ret; + char temp[100] = { 0x00, }; + struct fts_ts_info *info = dev_get_drvdata(dev); + + fw.data = NULL; + ret = readFwFile(info->board->default_fw_name, &fw, 0); + + if (ret < OK) { + logError(1, "%s Error during reading FW file! ERROR %08X\n", + tag, ret); + } else { + logError(1, "%s %s, size = %d bytes\n", tag, + printHex("EXT Release = ", systemInfo.u8_releaseInfo, + EXTERNAL_RELEASE_INFO_SIZE, temp), + fw.data_size); + } + + kfree(fw.data); + return 0; +} + +/***************************************** FEATURES ***************************************************/ + +/*TODO: edit this function according to the features policy to allow during the screen on/off, following is shown an example but check always with ST for more details*/ +/** + * Check if there is any conflict in enable/disable a particular feature considering the features already enabled and running + * @param info pointer to fts_ts_info which contains info about the device and its hw setup + * @param feature code of the feature that want to be tested + * @return OK if is possible to enable/disable feature, ERROR_OP_NOT_ALLOW in case of any other conflict + */ +int check_feature_feasibility(struct fts_ts_info *info, unsigned int feature) +{ + int res = OK; + + switch (feature) { + case FEAT_SEL_GESTURE: + if (info->cover_enabled == 1) { + res = ERROR_OP_NOT_ALLOW; + logError(1, + "%s %s: Feature not allowed when in Cover mode! ERROR %08X \n", + tag, __func__, res); + /*for example here can be placed a code for disabling the cover mode when gesture is activated */ + } + break; + + case FEAT_SEL_GLOVE: + if (info->gesture_enabled == 1) { + res = ERROR_OP_NOT_ALLOW; + logError(1, + "%s %s: Feature not allowed when Gestures enabled! ERROR %08X \n", + tag, __func__, res); + /*for example here can be placed a code for disabling the gesture mode when cover is activated (that means that cover mode has an higher priority on gesture mode) */ + } + break; + + default: + logError(1, "%s %s: Feature Allowed! \n", tag, __func__); + + } + + return res; + +} + +#ifdef USE_ONE_FILE_NODE +/** + * File node to enable some feature + * echo XX 00/01 > feature_enable to enable/disable XX (possible values @link feat_opt Feature Selection Options @endlink) feature \n + * cat feature_enable to show the result of enabling/disabling process \n + * echo 01/00 > feature_enable; cat feature_enable to perform both actions stated before in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent an error code (00000000 = no error) \n + * } = end byte + */ +static ssize_t fts_feature_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + char *p = (char *)buf; + unsigned int temp; + int res = OK; + + if ((count - 2 + 1) / 3 != 1) { + logError(1, + "%s fts_feature_enable: Number of parameter wrong! %d > %d \n", + tag, (count - 2 + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 9; + res = check_feature_feasibility(info, temp); + if (res >= OK) { + switch (temp) { + +#ifdef GESTURE_MODE + case FEAT_SEL_GESTURE: + sscanf(p, "%02X ", &info->gesture_enabled); + logError(1, + "%s fts_feature_enable: Gesture Enabled = %d \n", + tag, info->gesture_enabled); + break; +#endif + +#ifdef GLOVE_MODE + case FEAT_SEL_GLOVE: + sscanf(p, "%02X ", &info->glove_enabled); + logError(1, + "%s fts_feature_enable: Glove Enabled = %d \n", + tag, info->glove_enabled); + + break; +#endif + +#ifdef STYLUS_MODE + case FEAT_SEL_STYLUS: + sscanf(p, "%02X ", &info->stylus_enabled); + logError(1, + "%s fts_feature_enable: Stylus Enabled = %d \n", + tag, info->stylus_enabled); + + break; +#endif + +#ifdef COVER_MODE + case FEAT_SEL_COVER: + sscanf(p, "%02X ", &info->cover_enabled); + logError(1, + "%s fts_feature_enable: Cover Enabled = %d \n", + tag, info->cover_enabled); + + break; +#endif + +#ifdef CHARGER_MODE + case FEAT_SEL_CHARGER: + sscanf(p, "%02X ", &info->charger_enabled); + logError(1, + "%s fts_feature_enable: Charger Enabled = %d \n", + tag, info->charger_enabled); + + break; +#endif + +#ifdef GRIP_MODE + case FEAT_SEL_GRIP: + sscanf(p, "%02X ", &info->grip_enabled); + logError(1, + "%s fts_feature_enable: Grip Enabled = %d \n", + tag, info->grip_enabled); + + break; +#endif + default: + logError(1, + "%s fts_feature_enable: Feature %08X not valid! ERROR %08X\n", + tag, temp, ERROR_OP_NOT_ALLOW); + res = ERROR_OP_NOT_ALLOW; + } + feature_feasibility = res; + } + if (feature_feasibility >= OK) + feature_feasibility = fts_mode_handler(info, 1); + else { + logError(1, + "%s %s: Call echo XX 00/01 > feature_enable with a correct feature value (XX)! ERROR %08X \n", + tag, __func__, res); + } + + } + return count; +} + +static ssize_t fts_feature_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + + if (feature_feasibility < OK) { + logError(1, + "%s %s: Call before echo XX 00/01 > feature_enable with a correct feature value (XX)! ERROR %08X \n", + tag, __func__, feature_feasibility); + } + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + feature_feasibility); + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s fts_feature_enable_show: Unable to allocate all_strbuff! ERROR %08X\n", + tag, ERROR_ALLOC); + } + + feature_feasibility = ERROR_OP_NOT_ALLOW; + return count; +} +#else + +#ifdef GRIP_MODE +/** + * File node to set the grip mode + * echo 01/00 > grip_mode to enable/disable glove mode \n + * cat grip_mode to show the status of the grip_enabled switch \n + * echo 01/00 > grip_mode; cat grip_mode to enable/disable grip mode and see the switch status in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent the value info->grip_enabled (1 = enabled; 0= disabled) \n + * } = end byte + */ +static ssize_t fts_grip_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s %s: grip_enabled = %d \n", tag, __func__, + info->grip_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->grip_enabled); + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_grip_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + unsigned int temp; + int res; + struct fts_ts_info *info = dev_get_drvdata(dev); + +/*in case of a different elaboration of the input, just modify this initial part of the code according to customer needs*/ + if ((count + 1) / 3 != 1) { + logError(1, + "%s %s: Number of bytes of parameter wrong! %d != %d byte\n", + tag, __func__, (count + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 3; +/* +*this is a standard code that should be always used when a feature is enabled! +*first step : check if the wanted feature can be enabled +*second step: call fts_mode_handler to actually enable it +*NOTE: Disabling a feature is always allowed by default +*/ + res = check_feature_feasibility(info, FEAT_SEL_GRIP); + if (res >= OK || temp == FEAT_DISABLE) { + info->grip_enabled = temp; + res = fts_mode_handler(info, 1); + if (res < OK) { + logError(1, + "%s %s: Error during fts_mode_handler! ERROR %08X\n", + tag, __func__, res); + } + } + } + return count; +} +#endif + +#ifdef CHARGER_MODE +/** + * File node to set the glove mode + * echo XX/00 > charger_mode to value >0 to enable (possible values: @link charger_opt Charger Options @endlink),00 to disable charger mode \n + * cat charger_mode to show the status of the charger_enabled switch \n + * echo 01/00 > charger_mode; cat charger_mode to enable/disable charger mode and see the switch status in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent the value info->charger_enabled (>0 = enabled; 0= disabled) \n + * } = end byte + */ +static ssize_t fts_charger_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s %s: charger_enabled = %d \n", tag, __func__, + info->charger_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->charger_enabled); + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_charger_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + unsigned int temp; + int res; + struct fts_ts_info *info = dev_get_drvdata(dev); + +/*in case of a different elaboration of the input, just modify this initial part of the code according to customer needs*/ + if ((count + 1) / 3 != 1) { + logError(1, + "%s %s: Number of bytes of parameter wrong! %d != %d byte\n", + tag, __func__, (count + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 3; +/* +*this is a standard code that should be always used when a feature is enabled! +*first step : check if the wanted feature can be enabled +*second step: call fts_mode_handler to actually enable it +*NOTE: Disabling a feature is always allowed by default +*/ + res = check_feature_feasibility(info, FEAT_SEL_CHARGER); + if (res >= OK || temp == FEAT_DISABLE) { + info->charger_enabled = temp; + res = fts_mode_handler(info, 1); + if (res < OK) { + logError(1, + "%s %s: Error during fts_mode_handler! ERROR %08X\n", + tag, __func__, res); + } + } + } + return count; +} +#endif + +#ifdef GLOVE_MODE +/** + * File node to set the glove mode + * echo 01/00 > glove_mode to enable/disable glove mode \n + * cat glove_mode to show the status of the glove_enabled switch \n + * echo 01/00 > glove_mode; cat glove_mode to enable/disable glove mode and see the switch status in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent the of value info->glove_enabled (1 = enabled; 0= disabled) \n + * } = end byte + */ +static ssize_t fts_glove_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s %s: glove_enabled = %d \n", tag, __func__, + info->glove_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->glove_enabled); + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_glove_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + unsigned int temp; + int res; + struct fts_ts_info *info = dev_get_drvdata(dev); + +/*in case of a different elaboration of the input, just modify this initial part of the code according to customer needs*/ + if ((count + 1) / 3 != 1) { + logError(1, + "%s %s: Number of bytes of parameter wrong! %d != %d byte\n", + tag, __func__, (count + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 3; +/* +*this is a standard code that should be always used when a feature is enabled! +*first step : check if the wanted feature can be enabled +*second step: call fts_mode_handler to actually enable it +*NOTE: Disabling a feature is always allowed by default +*/ + res = check_feature_feasibility(info, FEAT_SEL_GLOVE); + if (res >= OK || temp == FEAT_DISABLE) { + info->glove_enabled = temp; + res = fts_mode_handler(info, 1); + if (res < OK) { + logError(1, + "%s %s: Error during fts_mode_handler! ERROR %08X\n", + tag, __func__, res); + } + } + } + + return count; +} +#endif + +#ifdef COVER_MODE +/** + * File node to set the cover mode + * echo 01/00 > cover_mode to enable/disable cover mode \n + * cat cover_mode to show the status of the cover_enabled switch \n + * echo 01/00 > cover_mode; cat cover_mode to enable/disable cover mode and see the switch status in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which is the value of info->cover_enabled (1 = enabled; 0= disabled)\n + * } = end byte\n + * NOTE: \n + * the cover can be handled also using a notifier, in this case the body of these functions should be copied in the notifier callback + */ +static ssize_t fts_cover_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s %s: cover_enabled = %d \n", tag, __func__, + info->cover_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->cover_enabled); + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_cover_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + unsigned int temp; + int res; + struct fts_ts_info *info = dev_get_drvdata(dev); + +/*in case of a different elaboration of the input, just modify this initial part of the code according to customer needs*/ + if ((count + 1) / 3 != 1) { + logError(1, + "%s %s: Number of bytes of parameter wrong! %d != %d byte\n", + tag, __func__, (count + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 3; +/* +*this is a standard code that should be always used when a feature is enabled! +*first step : check if the wanted feature can be enabled +*second step: call fts_mode_handler to actually enable it +*NOTE: Disabling a feature is always allowed by default +*/ + res = check_feature_feasibility(info, FEAT_SEL_COVER); + if (res >= OK || temp == FEAT_DISABLE) { + info->cover_enabled = temp; + res = fts_mode_handler(info, 1); + if (res < OK) { + logError(1, + "%s %s: Error during fts_mode_handler! ERROR %08X\n", + tag, __func__, res); + } + } + } + + return count; +} +#endif + +#ifdef STYLUS_MODE +/** + * File node to enable the stylus report + * echo 01/00 > stylus_mode to enable/disable stylus mode\n + * cat stylus_mode to show the status of the stylus_enabled switch\n + * echo 01/00 > stylus_mode; cat stylus_mode to enable/disable stylus mode and see the switch status in just one call\n + * the string returned in the shell is made up as follow:\n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which is the value of info->stylus_enabled (1 = enabled; 0= disabled)\n + * } = end byte + */ +static ssize_t fts_stylus_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s %s: stylus_enabled = %d \n", tag, __func__, + info->stylus_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->stylus_enabled); + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_stylus_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + unsigned int temp; + struct fts_ts_info *info = dev_get_drvdata(dev); + +/*in case of a different elaboration of the input, just modify this initial part of the code according to customer needs*/ + if ((count + 1) / 3 != 1) { + logError(1, + "%s %s: Number of bytes of parameter wrong! %d != %d byte\n", + tag, __func__, (count + 1) / 3, 1); + } else { + sscanf(p, "%02X ", &temp); + p += 3; + info->stylus_enabled = temp; + + } + return count; +} +#endif + +#endif + +/***************************************** GESTURES ***************************************************/ +#ifdef GESTURE_MODE +#ifdef USE_GESTURE_MASK +/** + * File node used by the host to set the gesture mask to enable or disable + * echo EE X1 X2 ~~ > gesture_mask set the gesture to disable/enable; EE = 00(disable) or 01(enable)\n + * X1 ~~ = gesture mask (example 06 00 ~~ 00 this gesture mask represents the gestures with ID = 1 and 2) can be specified from 1 to GESTURE_MASK_SIZE bytes,\n + * if less than GESTURE_MASK_SIZE bytes are passed as arguments, the omit bytes of the mask maintain the previous settings\n + * if one or more gestures is enabled the driver will automatically enable the gesture mode, If all the gestures are disabled the driver automatically will disable the gesture mode\n + * cat gesture_mask set inside the specified mask and return an error code for the operation \n + * the string returned in the shell is made up as follow:\n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent an error code for enabling the mask (00000000 = no error)\n + * } = end byte \n\n + * if USE_GESTURE_MASK is not define the usage of the function become: \n\n + * echo EE X1 X2 ~~ > gesture_mask set the gesture to disable/enable; EE = 00(disable) or 01(enable)\n + * X1 ~~ = gesture IDs (example 01 02 05 represent the gestures with ID = 1, 2 and 5) there is no limit of the IDs passed as arguments, (@link gesture_opt Gesture IDs @endlink)\n + * if one or more gestures is enabled the driver will automatically enable the gesture mode. If all the gestures are disabled the driver automatically will disable the gesture mode.\n + * cat gesture_mask to show the status of the gesture enabled switch \n + * the string returned in the shell is made up as follow:\n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which is the value of info->gesture_enabled (1 = enabled; 0= disabled)\n + * } = end byte + */ +static ssize_t fts_gesture_mask_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0, res, temp; + struct fts_ts_info *info = dev_get_drvdata(dev); + + if (mask[0] == 0) { + res = ERROR_OP_NOT_ALLOW; + logError(1, + "%s %s: Call before echo enable/disable xx xx .... > gesture_mask with a correct number of parameters! ERROR %08X \n", + tag, __func__, res); + } else { + + if (mask[1] == FEAT_ENABLE || mask[1] == FEAT_DISABLE) + res = updateGestureMask(&mask[2], mask[0], mask[1]); + else + res = ERROR_OP_NOT_ALLOW; + + if (res < OK) { + logError(1, "%s fts_gesture_mask_store: ERROR %08X \n", + tag, res); + } + } + res |= check_feature_feasibility(info, FEAT_SEL_GESTURE); + temp = isAnyGestureActive(); + if (res >= OK || temp == FEAT_DISABLE) { + info->gesture_enabled = temp; + } + + logError(1, "%s fts_gesture_mask_store: Gesture Enabled = %d \n", tag, + info->gesture_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += snprintf(&all_strbuff[index], 13, "{ %08X }", res); + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s fts_gesture_mask_show: Unable to allocate all_strbuff! ERROR %08X\n", + tag, ERROR_ALLOC); + } + + mask[0] = 0; + return count; +} + +static ssize_t fts_gesture_mask_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + int n; + unsigned int temp; + + if ((count + 1) / 3 > GESTURE_MASK_SIZE + 1) { + logError(1, + "%s fts_gesture_mask_store: Number of bytes of parameter wrong! %d > (enable/disable + %d )\n", + tag, (count + 1) / 3, GESTURE_MASK_SIZE); + mask[0] = 0; + } else { + mask[0] = ((count + 1) / 3) - 1; + for (n = 1; n <= (count + 1) / 3; n++) { + sscanf(p, "%02X ", &temp); + p += 3; + mask[n] = (u8) temp; + logError(0, "%s mask[%d] = %02X \n", tag, n, mask[n]); + + } + } + + return count; +} + +#else +/** + * File node used by the host to set the gesture mask to enable or disable + * echo EE X1 X2 ~~ > gesture_mask set the gesture to disable/enable; EE = 00(disable) or 01(enable)\n + * X1 ~ = gesture IDs (example 01 02 05 represent the gestures with ID = 1, 2 and 5) there is no limit of the IDs passed as arguments, (@link gesture_opt Gesture IDs @endlink) \n + * if one or more gestures is enabled the driver will automatically enable the gesture mode, If all the gestures are disabled the driver automatically will disable the gesture mode \n + * cat gesture_mask to show the status of the gesture enabled switch \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which is the value of info->gesture_enabled (1 = enabled; 0= disabled)\n + * } = end byte + */ +static ssize_t fts_gesture_mask_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(0, "%s fts_gesture_mask_show: gesture_enabled = %d \n", tag, + info->gesture_enabled); + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + index += + snprintf(&all_strbuff[index], 13, "{ %08X }", + info->gesture_enabled); + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s fts_gesture_mask_show: Unable to allocate all_strbuff! ERROR %08X\n", + tag, ERROR_ALLOC); + } + + return count; +} + +static ssize_t fts_gesture_mask_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + char *p = (char *)buf; + int n; + unsigned int temp; + int res; + struct fts_ts_info *info = dev_get_drvdata(dev); + + if ((count + 1) / 3 < 2 || (count + 1) / 3 > GESTURE_MASK_SIZE + 1) { + logError(1, + "%s fts_gesture_mask_store: Number of bytes of parameter wrong! %d < or > (enable/disable + at least one gestureID or max %d bytes)\n", + tag, (count + 1) / 3, GESTURE_MASK_SIZE); + mask[0] = 0; + } else { + memset(mask, 0, GESTURE_MASK_SIZE + 2); + mask[0] = ((count + 1) / 3) - 1; + sscanf(p, "%02X ", &temp); + p += 3; + mask[1] = (u8) temp; + for (n = 1; n < (count + 1) / 3; n++) { + sscanf(p, "%02X ", &temp); + p += 3; + fromIDtoMask((u8) temp, &mask[2], GESTURE_MASK_SIZE); + + } + + for (n = 0; n < GESTURE_MASK_SIZE + 2; n++) { + logError(1, "%s mask[%d] = %02X \n", tag, n, mask[n]); + + } + + } + + if (mask[0] == 0) { + res = ERROR_OP_NOT_ALLOW; + logError(1, + "%s %s: Call before echo enable/disable xx xx .... > gesture_mask with a correct number of parameters! ERROR %08X \n", + tag, __func__, res); + } else { + + if (mask[1] == FEAT_ENABLE || mask[1] == FEAT_DISABLE) + res = updateGestureMask(&mask[2], mask[0], mask[1]); + else + res = ERROR_OP_NOT_ALLOW; + + if (res < OK) { + logError(1, "%s fts_gesture_mask_store: ERROR %08X \n", + tag, res); + } + + } + + res = check_feature_feasibility(info, FEAT_SEL_GESTURE); + temp = isAnyGestureActive(); + if (res >= OK || temp == FEAT_DISABLE) { + info->gesture_enabled = temp; + } + res = fts_mode_handler(info, 0); + + return count; +} + +#endif + +/** + * File node to read the coordinates of the last gesture drawn by the user \n + * cat gesture_coordinates to obtain the gesture coordinates \n + * the string returned in the shell follow this up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent an error code (00000000 no error) \n + * \n if error code = 00000000 \n + * CC = 1 byte in HEX format number of coords (pair of x,y) returned \n + * XXiYYi ... = XXi 2 bytes in HEX format for x[i] and YYi 2 bytes in HEX format for y[i] (big endian) \n + * \n + * } = end byte + */ +static ssize_t fts_gesture_coordinates_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + int size = (6 * 2) + 1, index = 0; + u8 *all_strbuff = NULL; + int count = 0, res, i = 0; + + logError(0, "%s %s: Getting gestures coordinates... \n", tag, __func__); + + if (gesture_coords_reported < OK) { + logError(1, "%s %s: invalid coordinates! ERROR %08X \n", tag, + __func__, gesture_coords_reported); + res = gesture_coords_reported; + } else { + size += gesture_coords_reported * 2 * 4 + 2; + res = OK; + } + + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + if (all_strbuff != NULL) { + + snprintf(&all_strbuff[index], 11, "{ %08X", res); + index += 10; + + if (res >= OK) { + snprintf(&all_strbuff[index], 3, "%02X", + gesture_coords_reported); + index += 2; + + for (i = 0; i < gesture_coords_reported; i++) { + snprintf(&all_strbuff[index], 5, "%04X", + gesture_coordinates_x[i]); + index += 4; + snprintf(&all_strbuff[index], 5, "%04X", + gesture_coordinates_y[i]); + index += 4; + } + } + + index += snprintf(&all_strbuff[index], 3, " }"); + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + logError(0, "%s %s: Getting gestures coordinates FINISHED! \n", + tag, __func__); + + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, ERROR_ALLOC); + } + + return count; +} +#endif + +/***************************************** PRODUCTION TEST ***************************************************/ + +/** + * File node to execute the Mass Production Test or to get data from the IC (raw or ms/ss init data) + * echo cmd > stm_fts_cmd to execute a command \n + * cat stm_fts_cmd to show the result of the command \n + * echo cmd > stm_fts_cmd; cat stm_fts_cmd to execute and show the result in just one call \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * X1X2X3X4 = 4 bytes in HEX format which represent an error_code (00000000 = OK)\n + * (optional) data = data coming from the command executed represented as HEX string \n + * Not all the command return additional data \n + * } = end byte + * \n + * Possible commands (cmd): \n + * - 00 = MP Test -> return erro_code \n + * - 01 = ITO Test -> return error_code \n + * - 03 = MS Raw Test -> return error_code \n + * - 04 = MS Init Data Test -> return error_code \n + * - 05 = SS Raw Test -> return error_code \n + * - 06 = SS Init Data Test -> return error_code \n + * - 13 = Read 1 MS Raw Frame -> return additional data: MS frame row after row \n + * - 14 = Read MS Init Data -> return additional data: MS init data row after row \n + * - 15 = Read 1 SS Raw Frame -> return additional data: SS frame, force channels followed by sense channels \n + * - 16 = Read SS Init Data -> return additional data: SS Init data, first IX for force and sense channels and then CX for force and sense channels \n + * - F0 = Perform a system reset -> return error_code \n + * - F1 = Perform a system reset and reenable the sensing and the interrupt + */ +static ssize_t stm_fts_cmd_store(struct device *dev, + struct device_attribute *attr, const char *buf, + size_t count) +{ + int n; + char *p = (char *)buf; + + memset(typeOfComand, 0, CMD_STR_LEN * sizeof(u32)); + + logError(1, "%s \n", tag); + for (n = 0; n < (count + 1) / 3; n++) { + sscanf(p, "%02X ", &typeOfComand[n]); + p += 3; + logError(1, "%s typeOfComand[%d] = %02X \n", tag, n, + typeOfComand[n]); + + } + + numberParameters = n; + logError(1, "%s Number of Parameters = %d \n", tag, numberParameters); + return count; +} + +static ssize_t stm_fts_cmd_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res, j, doClean = 0, count = 0, index = 0; + char buff[CMD_STR_LEN] = { 0 }; + + int size = (6 * 2) + 1; + int init_type = SPECIAL_PANEL_INIT; + u8 *all_strbuff = NULL; + const char *limit_file_name = NULL; + struct fts_ts_info *info = dev_get_drvdata(dev); + + MutualSenseData compData; + SelfSenseData comData; + MutualSenseFrame frameMS; + SelfSenseFrame frameSS; + + if (numberParameters >= 1) { + res = fts_disableInterrupt(); + if (res < 0) { + logError(0, "%s fts_disableInterrupt: ERROR %08X \n", + tag, res); + res = (res | ERROR_DISABLE_INTER); + goto END; + } +/* +#ifdef CONFIG_DRM + res = msm_drm_unregister_client(&info->notifier); + if (res < 0) { + logError(1, "%s ERROR: unregister notifier failed!\n", + tag); + goto END; + } +#endif +*/ + switch (typeOfComand[0]) { + /*ITO TEST */ + case 0x01: + res = production_test_ito(LIMITS_FILE, &tests); + break; + /*PRODUCTION TEST */ + case 0x00: + + if (systemInfo.u8_cfgAfeVer != systemInfo.u8_cxAfeVer) { + res = ERROR_OP_NOT_ALLOW; + logError(0, + "%s Miss match in CX version! MP test not allowed with wrong CX memory! ERROR %08X \n", + tag, res); + break; + } + + limit_file_name = fts_get_limit(info); + res = + production_test_main(LIMITS_FILE, 1, init_type, + &tests); + break; + /*read mutual raw */ + case 0x13: + logError(0, "%s Get 1 MS Frame \n", tag); + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = getMSFrame3(MS_RAW, &frameMS); + if (res < 0) { + logError(0, + "%s Error while taking the MS frame... ERROR %08X \n", + tag, res); + + } else { + logError(0, "%s The frame size is %d words\n", + tag, res); + size = (res * (sizeof(short) * 2 + 1)) + 10; + res = OK; + print_frame_short("MS frame =", + array1dTo2d_short + (frameMS.node_data, + frameMS.node_data_size, + frameMS.header.sense_node), + frameMS.header.force_node, + frameMS.header.sense_node); + } + break; + /*read self raw */ + case 0x15: + logError(0, "%s Get 1 SS Frame \n", tag); + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = getSSFrame3(SS_RAW, &frameSS); + + if (res < OK) { + logError(0, + "%s Error while taking the SS frame... ERROR %08X \n", + tag, res); + + } else { + logError(0, "%s The frame size is %d words\n", + tag, res); + size = (res * (sizeof(short) * 2 + 1)) + 10; + res = OK; + print_frame_short("SS force frame =", + array1dTo2d_short + (frameSS.force_data, + frameSS.header.force_node, + 1), + frameSS.header.force_node, 1); + print_frame_short("SS sense frame =", + array1dTo2d_short + (frameSS.sense_data, + frameSS.header.sense_node, + frameSS.header.sense_node), + 1, frameSS.header.sense_node); + } + + break; + + case 0x14: + logError(0, "%s Get MS Compensation Data \n", tag); + res = + readMutualSenseCompensationData(LOAD_CX_MS_TOUCH, + &compData); + + if (res < 0) { + logError(0, + "%s Error reading MS compensation data ERROR %08X \n", + tag, res); + } else { + logError(0, + "%s MS Compensation Data Reading Finished! \n", + tag); + size = + (compData.node_data_size * sizeof(u8)) * 3 + + 1; + print_frame_i8("MS Data (Cx2) =", + array1dTo2d_i8 + (compData.node_data, + compData.node_data_size, + compData.header.sense_node), + compData.header.force_node, + compData.header.sense_node); + } + break; + + case 0x16: + logError(0, "%s Get SS Compensation Data... \n", tag); + res = + readSelfSenseCompensationData(LOAD_CX_SS_TOUCH, + &comData); + if (res < 0) { + logError(0, + "%s Error reading SS compensation data ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s SS Compensation Data Reading Finished! \n", + tag); + size = + ((comData.header.force_node + + comData.header.sense_node) * 2 + + 12) * sizeof(u8) * 2 + 1; + print_frame_u8("SS Data Ix2_fm = ", + array1dTo2d_u8(comData.ix2_fm, + comData. + header.force_node, + 1), + comData.header.force_node, 1); + print_frame_i8("SS Data Cx2_fm = ", + array1dTo2d_i8(comData.cx2_fm, + comData. + header.force_node, + 1), + comData.header.force_node, 1); + print_frame_u8("SS Data Ix2_sn = ", + array1dTo2d_u8(comData.ix2_sn, + comData. + header.sense_node, + comData. + header.sense_node), + 1, comData.header.sense_node); + print_frame_i8("SS Data Cx2_sn = ", + array1dTo2d_i8(comData.cx2_sn, + comData. + header.sense_node, + comData. + header.sense_node), + 1, comData.header.sense_node); + } + break; + + case 0x03: + res = fts_system_reset(); + if (res >= OK) + res = + production_test_ms_raw(LIMITS_FILE, 1, + &tests); + break; + + case 0x04: + res = fts_system_reset(); + if (res >= OK) + res = + production_test_ms_cx(LIMITS_FILE, 1, + &tests); + break; + + case 0x05: + res = fts_system_reset(); + if (res >= OK) + res = + production_test_ss_raw(LIMITS_FILE, 1, + &tests); + break; + + case 0x06: + res = fts_system_reset(); + if (res >= OK) + res = + production_test_ss_ix_cx(LIMITS_FILE, 1, + &tests); + break; + + case 0xF0: + case 0xF1: + doClean = (int)(typeOfComand[0] & 0x01); + res = cleanUp(doClean); + break; + + default: + logError(1, + "%s COMMAND NOT VALID!! Insert a proper value ...\n", + tag); + res = ERROR_OP_NOT_ALLOW; + break; + } + + doClean = fts_mode_handler(info, 1); + if (typeOfComand[0] != 0xF0) + doClean |= fts_enableInterrupt(); + if (doClean < 0) { + logError(0, "%s %s: ERROR %08X \n", tag, __func__, + (doClean | ERROR_ENABLE_INTER)); + } + } else { + logError(1, + "%s NO COMMAND SPECIFIED!!! do: 'echo [cmd_code] [args] > stm_fts_cmd' before looking for result!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + + } +/* +#ifdef CONFIG_DRM + if (msm_drm_register_client(&info->notifier) < 0) { + logError(1, "%s ERROR: register notifier failed!\n", tag); + } +#endif +*/ +END: + all_strbuff = (u8 *) kzalloc(size, GFP_KERNEL); + + if (res >= OK) { + /*all the other cases are already fine printing only the res. */ + switch (typeOfComand[0]) { + case 0x13: + snprintf(all_strbuff, size, "ms_frame\n"); + for (j = 0; j < frameMS.node_data_size; j++) { + if ((j + 1) % frameMS.header.sense_node) + snprintf(buff, sizeof(buff), "%04d ", + frameMS.node_data[j]); + else + snprintf(buff, sizeof(buff), "%04d\n", + frameMS.node_data[j]); + + strlcat(all_strbuff, buff, size); + } + + kfree(frameMS.node_data); + frameMS.node_data = NULL; + break; + + case 0x15: + snprintf(all_strbuff, size, "ss_frame\n"); + for (j = 0; j < frameSS.header.force_node - 1; j++) { + snprintf(buff, sizeof(buff), "%04d ", + frameSS.force_data[j]); + strlcat(all_strbuff, buff, size); + } + + if (j == frameSS.header.force_node - 1) { + snprintf(buff, sizeof(buff), "%04d\n", + frameSS.force_data[j]); + strlcat(all_strbuff, buff, size); + } + + for (j = 0; j < frameSS.header.sense_node - 1; j++) { + snprintf(buff, sizeof(buff), "%04d ", + frameSS.sense_data[j]); + strlcat(all_strbuff, buff, size); + } + + if (j == frameSS.header.sense_node - 1) { + snprintf(buff, sizeof(buff), "%04d\n", + frameSS.sense_data[j]); + strlcat(all_strbuff, buff, size); + } + + kfree(frameSS.force_data); + kfree(frameSS.sense_data); + + break; + + case 0x14: + snprintf(buff, sizeof(buff), "%02X", + (u8) compData.header.force_node); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", + (u8) compData.header.sense_node); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", compData.cx1); + strlcat(all_strbuff, buff, size); + + for (j = 0; j < compData.node_data_size; j++) { + snprintf(buff, sizeof(buff), "%02X", + *(compData.node_data + j)); + strlcat(all_strbuff, buff, size); + } + + kfree(compData.node_data); + compData.node_data = NULL; + + break; + + case 0x16: + snprintf(buff, sizeof(buff), "%02X", + comData.header.force_node); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", + comData.header.sense_node); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", comData.f_ix1); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", comData.s_ix1); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", comData.f_cx1); + strlcat(all_strbuff, buff, size); + snprintf(buff, sizeof(buff), "%02X", comData.s_cx1); + strlcat(all_strbuff, buff, size); + + for (j = 0; j < comData.header.force_node; j++) { + snprintf(buff, sizeof(buff), "%02X", + comData.ix2_fm[j]); + strlcat(all_strbuff, buff, size); + } + + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(buff, sizeof(buff), "%02X", + comData.ix2_sn[j]); + strlcat(all_strbuff, buff, size); + } + + for (j = 0; j < comData.header.force_node; j++) { + snprintf(buff, sizeof(buff), "%02X", + comData.cx2_fm[j]); + strlcat(all_strbuff, buff, size); + } + + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(buff, sizeof(buff), "%02X", + comData.cx2_sn[j]); + strlcat(all_strbuff, buff, size); + } + + kfree(comData.ix2_fm); + kfree(comData.ix2_sn); + kfree(comData.cx2_fm); + kfree(comData.cx2_sn); + + break; + + default: + snprintf(&all_strbuff[index], 11, "{ %08X", res); + index += 10; + snprintf(&all_strbuff[index], 3, " }"); + index += 2; + + break; + + } + } else { + snprintf(&all_strbuff[index], 11, "{ %08X", res); + index += 10; + snprintf(&all_strbuff[index], 3, " }"); + index += 2; + } + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + numberParameters = 0; + kfree(all_strbuff); + + return count; +} + +static ssize_t fts_panel_color_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + return snprintf(buf, PAGE_SIZE, "%c\n", info->lockdown_info[2]); +} + +static ssize_t fts_panel_vendor_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + return snprintf(buf, PAGE_SIZE, "%c\n", info->lockdown_info[6]); +} + +static ssize_t fts_panel_display_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + return snprintf(buf, PAGE_SIZE, "%c\n", info->lockdown_info[1]); +} + +static ssize_t fts_lockdown_info_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + int ret; + ret = fts_get_lockdown_info(info->lockdown_info, info); + + if (ret != OK) { + logError(1, "%s get lockdown info error\n", tag); + return 0; + } + + return snprintf(buf, PAGE_SIZE, + "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x\n", + info->lockdown_info[0], info->lockdown_info[1], + info->lockdown_info[2], info->lockdown_info[3], + info->lockdown_info[4], info->lockdown_info[5], + info->lockdown_info[6], info->lockdown_info[7]); +} + +static ssize_t fts_lockdown_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int n, i, ret; + char *p = (char *)buf; + u8 *typecomand = NULL; + + memset(typeOfComand, 0, CMD_STR_LEN * sizeof(u32)); + logError(1, "%s \n", tag); + for (n = 0; n < (count + 1) / 3; n++) { + sscanf(p, "%02X ", &typeOfComand[n]); + p += 3; + logError(1, "%s command_sequence[%d] = %02X\n", tag, n, + typeOfComand[n]); + } + numberParameters = n; + if (numberParameters < 3) + goto END; + logError(1, "%s %d = %d \n", tag, n, numberParameters); + + typecomand = + (u8 *) kmalloc((numberParameters - 2) * sizeof(u8), GFP_KERNEL); + if (typecomand != NULL) { + for (i = 0; i < numberParameters - 2; i++) { + typecomand[i] = (u8) typeOfComand[i + 2]; + logError(1, "%s typecomand[%d] = %X \n", tag, i, + typecomand[i]); + } + } else { + goto END; + } + + ret = + writeLockDownInfo(typecomand, numberParameters - 2, + typeOfComand[0]); + if (ret < 0) { + logError(1, "%s fts_lockdown_store failed\n", tag); + } + kfree(typecomand); +END: + logError(1, "%s Number of Parameters = %d \n", tag, numberParameters); + + return count; +} + +static ssize_t fts_lockdown_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int i, ret; + int size = 0, count = 0; + u8 type; + u8 *temp_buffer = NULL; + + temp_buffer = (u8 *) kmalloc(LOCKDOWN_LENGTH * sizeof(u8), GFP_KERNEL); + if (temp_buffer == NULL || numberParameters < 2) { + count += + snprintf(&buf[count], PAGE_SIZE, "prepare read lockdown failded\n"); + return count; + } + type = typeOfComand[0]; + size = (int)(typeOfComand[1]); + count += snprintf(&buf[count], PAGE_SIZE, "read lock down code:\n"); + ret = readLockDownInfo(temp_buffer, type, size); + if (ret < OK) { + count += snprintf(&buf[count], PAGE_SIZE, "read lockdown failded\n"); + goto END; + } + for (i = 0; i < size; i++) { + count += snprintf(&buf[count], PAGE_SIZE, "%02X ", temp_buffer[i]); + } + count += snprintf(&buf[count], PAGE_SIZE, "\n"); + +END: + numberParameters = 0; + kfree(temp_buffer); + return count; +} + +static ssize_t fts_selftest_info_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res = 0, i = 0, count = 0, force_node = 0, sense_node = 0, pos = + 0, last_pos = 0; + MutualSenseFrame frameMS; + char buff[80]; + struct i2c_client *client = to_i2c_client(dev); + struct fts_ts_info *info = i2c_get_clientdata(client); + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = getMSFrame3(MS_RAW, &frameMS); + if (res < 0) { + logError(0, + "%s Error while taking the MS frame... ERROR %08X \n", + tag, res); + goto END; + } + fts_mode_handler(info, 1); + + sense_node = frameMS.header.sense_node; + force_node = frameMS.header.force_node; + + for (i = 0; i < RELEASE_INFO_SIZE; i++) { + if (i == 0) { + pos += + snprintf(buff + last_pos, PAGE_SIZE, "0x%02x", + systemInfo.u8_releaseInfo[i]); + last_pos = pos; + } else { + pos += + snprintf(buff + last_pos, PAGE_SIZE, "%02x", + systemInfo.u8_releaseInfo[i]); + last_pos = pos; + } + } + count = + snprintf(buf, PAGE_SIZE, + "Device address:,0x49\nChip Id:,0x%04x\nFw version:,0x%04x\nConfig version:,0x%04x\nChip serial number:,%s\nForce lines count:,%02d\nSense lines count:,%02d\n\n", + systemInfo.u16_chip0Id, systemInfo.u16_fwVer, + systemInfo.u16_cfgVer, buff, force_node, sense_node); +END: + fts_enableInterrupt(); + return count; + +} + +static ssize_t fts_ms_raw_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res = 0, count = 0, j = 0, sense_node = 0, force_node = 0, pos = + 0, last_pos = 0; + char *all_strbuff = NULL; + struct i2c_client *client = to_i2c_client(dev); + struct fts_ts_info *info = i2c_get_clientdata(client); + MutualSenseFrame frameMS; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + all_strbuff = vmalloc(PAGE_SIZE); + if (!all_strbuff) { + logError(1, "%s %s alloc all_strbuff fail\n", tag, __func__); + goto END; + } else + memset(all_strbuff, 0, PAGE_SIZE); + + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = getMSFrame3(MS_RAW, &frameMS); + + fts_mode_handler(info, 1); + sense_node = frameMS.header.sense_node; + force_node = frameMS.header.force_node; + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "MsTouchRaw,%2d,%2d\n ,", force_node, sense_node); + last_pos = pos; + if (res >= OK) { + for (j = 0; j < sense_node; j++) + if ((j + 1) % sense_node) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "C%02d,", j); + last_pos = pos; + } else { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "C%02d\nR00,", j); + last_pos = pos; + } + for (j = 0; j < sense_node * force_node; j++) { + if ((j + 1) % sense_node) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%4d,", frameMS.node_data[j]); + last_pos = pos; + } else { + if ((j + 1) / sense_node != force_node) + pos += + snprintf(all_strbuff + last_pos, + PAGE_SIZE, "%4d\nR%02d,", + frameMS.node_data[j], + (j + 1) / sense_node); + else + pos += + snprintf(all_strbuff + last_pos, + PAGE_SIZE, "%4d\n", + frameMS.node_data[j]); + last_pos = pos; + } + } + if (frameMS.node_data) { + kfree(frameMS.node_data); + frameMS.node_data = NULL; + } + } + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + vfree(all_strbuff); +END: + fts_enableInterrupt(); + return count; +} + +static ssize_t fts_ms_cx_total_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res = 0, pos = 0, last_pos = 0, count = 0, j = 0, sense_node = + 0, force_node = 0; + char *all_strbuff = NULL; + TotMutualSenseData totCompData; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + all_strbuff = vmalloc(PAGE_SIZE); + if (!all_strbuff) { + logError(1, "%s %s alloc all_strbuff fail\n", tag, __func__); + goto END; + } else + memset(all_strbuff, 0, PAGE_SIZE); + + res = + readTotMutualSenseCompensationData(LOAD_PANEL_CX_TOT_MS_TOUCH, + &totCompData); + if (res >= OK) { + sense_node = totCompData.header.sense_node; + force_node = totCompData.header.force_node; + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "MsTouchTotalCx,%2d,%2d\n ,", force_node, + sense_node); + last_pos = pos; + for (j = 0; j < sense_node; j++) + if ((j + 1) % sense_node) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "C%02d,", j); + last_pos = pos; + } else { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "C%02d\nR00,", j); + last_pos = pos; + } + for (j = 0; j < sense_node * force_node; j++) { + if ((j + 1) % sense_node) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%4d,", totCompData.node_data[j]); + last_pos = pos; + } else { + if ((j + 1) / sense_node != force_node) + pos += + snprintf(all_strbuff + last_pos, + PAGE_SIZE, "%4d\nR%02d,", + totCompData.node_data[j], + (j + 1) / sense_node); + else + pos += + snprintf(all_strbuff + last_pos, + PAGE_SIZE, "%4d\n", + totCompData.node_data[j]); + last_pos = pos; + } + } + if (totCompData.node_data) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + } + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + vfree(all_strbuff); +END: + fts_enableInterrupt(); + return count; + +} + +static ssize_t fts_ss_ix_total_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int ret = 0, pos = 0, last_pos = 0, count = 0, j = 0, sense_node = + 0, force_node = 0; + char *all_strbuff = NULL; + TotSelfSenseData totCompData; + + ret = fts_disableInterrupt(); + if (ret < OK) + goto END; + all_strbuff = vmalloc(PAGE_SIZE); + if (!all_strbuff) { + logError(1, "%s %s alloc all_strbuff fail\n", tag, __func__); + goto END; + } else { + memset(all_strbuff, 0, PAGE_SIZE); + } + ret = + readTotSelfSenseCompensationData(LOAD_PANEL_CX_TOT_SS_TOUCH, + &totCompData); + if (ret < 0) { + logError(1, + "%s production_test_data: readTotSelfSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + goto END; + } + + sense_node = 1; + force_node = totCompData.header.force_node; + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SsTouchForceTotalIx,%2d,1\n ,C00\n", force_node); + last_pos = pos; + for (j = 0; j < force_node; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "R%02d,%4d\n", + j, totCompData.ix_fm[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SsTouchForceTotalCx,%2d,1\n ,C00\n", force_node); + last_pos = pos; + for (j = 0; j < force_node; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "R%02d,%4d\n", + j, totCompData.cx_fm[j]); + last_pos = pos; + } + + sense_node = totCompData.header.sense_node; + force_node = 1; + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SsTouchsenseTotalIx,%2d,1\n ,C00\n", sense_node); + last_pos = pos; + for (j = 0; j < sense_node; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "R%02d,%4d\n", + j, totCompData.ix_sn[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SsTouchsenseTotalCx,%2d,1\n ,C00\n", sense_node); + last_pos = pos; + for (j = 0; j < sense_node; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "R%02d,%4d\n", + j, totCompData.cx_sn[j]); + last_pos = pos; + } + + if (totCompData.ix_fm != NULL) { + kfree(totCompData.ix_fm); + totCompData.ix_fm = NULL; + } + + if (totCompData.cx_fm != NULL) { + kfree(totCompData.cx_fm); + totCompData.cx_fm = NULL; + } + + if (totCompData.ix_sn != NULL) { + kfree(totCompData.ix_sn); + totCompData.ix_sn = NULL; + } + + if (totCompData.cx_sn != NULL) { + kfree(totCompData.cx_sn); + totCompData.cx_sn = NULL; + } + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + vfree(all_strbuff); +END: + fts_enableInterrupt(); + return count; +} + +static ssize_t fts_ss_raw_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res = 0, count = 0, j = 0, sense_node = 0, force_node = 0, pos = + 0, last_pos = 0; + char *all_strbuff = NULL; + struct i2c_client *client = to_i2c_client(dev); + struct fts_ts_info *info = i2c_get_clientdata(client); + SelfSenseFrame frameSS; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + all_strbuff = vmalloc(PAGE_SIZE * 4); + if (!all_strbuff) { + logError(1, "%s %s alloc all_strbuff fail\n", tag, __func__); + goto END; + } else + memset(all_strbuff, 0, PAGE_SIZE); + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = getSSFrame3(SS_RAW, &frameSS); + + fts_mode_handler(info, 1); + sense_node = frameSS.header.sense_node; + force_node = frameSS.header.force_node; + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "SsTouchRaw,%2d,%2d\n", + force_node, sense_node); + last_pos = pos; + if (res >= OK) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS force frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.force_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.force_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.force_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.force_data[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS sense frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.sense_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.sense_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.sense_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.sense_data[j]); + last_pos = pos; + } + + if (frameSS.force_data) { + kfree(frameSS.force_data); + frameSS.force_data = NULL; + } + if (frameSS.sense_data) { + kfree(frameSS.sense_data); + frameSS.sense_data = NULL; + } + + } + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + vfree(all_strbuff); +END: + fts_enableInterrupt(); + return count; +} + +static ssize_t fts_strength_frame_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + MutualSenseFrame frame; + int res = 0, count = 0, j = 0, size = 0; + char *all_strbuff = NULL; + char buff[CMD_STR_LEN] = { 0 }; + struct i2c_client *client = to_i2c_client(dev); + struct fts_ts_info *info = i2c_get_clientdata(client); + frame.node_data = NULL; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + + res = getMSFrame3(MS_STRENGTH, &frame); + + if (res < OK) { + logError(1, "%s %s: could not get the frame! ERROR %08X \n", + tag, __func__, res); + goto END; + } + size = (res * 5) + 11; + + /* + flushFIFO(); + */ + fts_mode_handler(info, 1); + all_strbuff = (char *)kmalloc(PAGE_SIZE * sizeof(char), GFP_KERNEL); + + if (all_strbuff != NULL) { + memset(all_strbuff, 0, size); + snprintf(all_strbuff, size, "ms_differ\n"); + if (res >= OK) { + for (j = 0; j < frame.node_data_size; j++) { + if ((j + 1) % frame.header.sense_node) + snprintf(buff, sizeof(buff), "%4d,", + frame.node_data[j]); + else + snprintf(buff, sizeof(buff), "%4d\n", + frame.node_data[j]); + + strlcat(all_strbuff, buff, size); + } + + kfree(frame.node_data); + frame.node_data = NULL; + } + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + kfree(all_strbuff); + } else { + logError(1, + "%s %s: Unable to allocate all_strbuff! ERROR %08X\n", + tag, __func__, ERROR_ALLOC); + } + +END: + fts_enableInterrupt(); + + return count; +} + +int fts_hover_auto_tune(struct fts_ts_info *info) { + int res=OK; + u8 sett[2]; + logError(0, "%s start...\n", tag, __func__); + + fts_disableInterrupt(); + + sett[0] = 0x02; + sett[1] = 0x00; + res = writeSysCmd(SYS_CMD_SPECIAL_TUNING, sett, 2); + if (res < OK) { + logError(1, "%s fts_hover_autotune Ioffset tuning 02 00 failed ERROR %08X\n", + tag, (res | ERROR_PROD_TEST_INITIALIZATION)); + return res | ERROR_PROD_TEST_INITIALIZATION; + } + sett[0] = 0x00; + sett[1] = 0x01; + res = writeSysCmd(SYS_CMD_CX_TUNING, sett, 2); + if (res < OK) { + logError(1, "%s fts_hover_autotune autotune hover 00 01 failed ERROR %08X\n", + tag, (res | ERROR_PROD_TEST_INITIALIZATION)); + return res | ERROR_PROD_TEST_INITIALIZATION; + } + sett[0] = 0x06; + res = writeSysCmd(SYS_CMD_SAVE_FLASH, sett, 1); + if (res < OK) { + logError(1, "%s fts_hover_autotune save flash 06 failed ERROR %08X\n", + tag, (res | ERROR_PROD_TEST_INITIALIZATION)); + return res | ERROR_PROD_TEST_INITIALIZATION; + } + logError(0, "%s end...\n", tag, __func__); + + fts_enableInterrupt(); + + return res; +} + +static ssize_t fts_hover_autotune_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + int on; + int ret = 0; + + sscanf(buf, "%u", &on); + logError(1, " %s %s\n", tag, __func__); + if (on) + ret = fts_hover_auto_tune(info); + if (ret < OK) + return -1; + + return count; +} + +static ssize_t fts_hover_raw_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int res = 0, count = 0, j = 0, sense_node = 0, force_node = 0, pos = + 0, last_pos = 0; + char *all_strbuff = NULL; + struct i2c_client *client = to_i2c_client(dev); + struct fts_ts_info *info = i2c_get_clientdata(client); + SelfSenseFrame frameSS; + TotSelfSenseData ssHoverCompData; + u8 hover_cnt[4] = {0xa8, 0x0b, 0x01, 0x00}; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + all_strbuff = vmalloc(PAGE_SIZE * 4); + if (!all_strbuff) { + logError(1, "%s %s alloc all_strbuff fail\n", tag, __func__); + goto END; + } else { + memset(all_strbuff, 0, PAGE_SIZE); + } + res = fts_write_dma_safe(hover_cnt, sizeof(hover_cnt)); + if (res != OK) { + logError(1, + "%s hover clear count ERROR = %d\n",tag, res); + goto END; + } + + setScanMode(SCAN_MODE_ACTIVE, 0xFF); + + res = getSSFrame3(SS_HVR_RAW, &frameSS); + + sense_node = frameSS.header.sense_node; + force_node = frameSS.header.force_node; + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "SsHoverTouchRaw,%2d,%2d\n", + force_node, sense_node); + last_pos = pos; + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "TxRaw\n"); + last_pos = pos; + + + if (res >= OK) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover force frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.force_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.force_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.force_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.force_data[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover sense frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.sense_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.sense_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.sense_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.sense_data[j]); + last_pos = pos; + } + + if (frameSS.force_data) { + kfree(frameSS.force_data); + frameSS.force_data = NULL; + } + if (frameSS.sense_data) { + kfree(frameSS.sense_data); + frameSS.sense_data = NULL; + } + + } + + res = getSSFrame3(SS_HVR_FILTER, &frameSS); + + sense_node = frameSS.header.sense_node; + force_node = frameSS.header.force_node; + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "TxFilter\n"); + last_pos = pos; + + + if (res >= OK) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover force frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.force_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.force_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.force_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.force_data[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover sense frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.sense_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.sense_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.sense_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.sense_data[j]); + last_pos = pos; + } + + if (frameSS.force_data) { + kfree(frameSS.force_data); + frameSS.force_data = NULL; + } + if (frameSS.sense_data) { + kfree(frameSS.sense_data); + frameSS.sense_data = NULL; + } + + } + + res = getSSFrame3(SS_HVR_BASELINE, &frameSS); + + sense_node = frameSS.header.sense_node; + force_node = frameSS.header.force_node; + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "TxBaseline\n"); + last_pos = pos; + + + if (res >= OK) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover force frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.force_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.force_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.force_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.force_data[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover sense frame\n ,"); + last_pos = pos; + + for (j = 0; j < frameSS.header.sense_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + frameSS.sense_data[j]); + last_pos = pos; + } + + if (j == frameSS.header.sense_node - 1) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "%04d\n", frameSS.sense_data[j]); + last_pos = pos; + } + + if (frameSS.force_data) { + kfree(frameSS.force_data); + frameSS.force_data = NULL; + } + + if (frameSS.sense_data) { + kfree(frameSS.sense_data); + frameSS.sense_data = NULL; + } + + } + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover IX Data\n ,"); + last_pos = pos; + + res = readTotSelfSenseCompensationData(STAPI_HOST_DATA_ID_PANEL_CX_SS_HVR, &ssHoverCompData); + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "SS Hover IX force frame\n ,"); + last_pos = pos; + for (j = 0; j < ssHoverCompData.header.force_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + ssHoverCompData.ix_fm[j]); + last_pos = pos; + } + + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, + "\nSS Hover IX sense frame\n ,"); + last_pos = pos; + + for (j = 0; j < ssHoverCompData.header.sense_node - 1; j++) { + pos += + snprintf(all_strbuff + last_pos, PAGE_SIZE, "%04d,", + ssHoverCompData.ix_sn[j]); + last_pos = pos; + } + + if (ssHoverCompData.ix_fm != NULL) + kfree(ssHoverCompData.ix_fm); + if (ssHoverCompData.ix_sn != NULL) + kfree(ssHoverCompData.ix_sn); + if (ssHoverCompData.cx_fm != NULL) + kfree(ssHoverCompData.cx_fm); + if (ssHoverCompData.cx_sn != NULL) + kfree(ssHoverCompData.cx_sn); + + count = snprintf(buf, PAGE_SIZE, "%s\n", all_strbuff); + vfree(all_strbuff); +END: + fts_mode_handler(info, 1); + fts_enableInterrupt(); + return count; +} + +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP +static ssize_t fts_touch_suspend_notify_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + return snprintf(buf, PAGE_SIZE, "%d\n", fts_info->sensor_sleep); +} +#endif + +static ssize_t fts_doze_time_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + return snprintf(buf, TSP_BUF_SIZE, "%u\n", info->doze_time); +} + +static ssize_t fts_doze_time_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + u8 cmd[4] = {FTS_CMD_CUSTOM, 0x00, 0x00, 0x00}; + int ret = 0; + u16 reg_val = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + pr_info("%s,buf:%s,count:%zu\n", __func__, buf, count); + sscanf(buf, "%u", &info->doze_time); + /*reg value * 10 represents of the num of frames ,one frame is about 8ms, the input value is ms*/ + reg_val = (info->doze_time / 8 - 1) / 10; + cmd[3] = reg_val; + ret = fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)); + if (ret < OK) { + logError(1, "%s %s: write failed...ERROR %08X !\n", tag, + __func__, ret); + return -EPERM; + } + return count; +} + +static ssize_t fts_grip_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + return snprintf(buf, TSP_BUF_SIZE, "%d\n", info->grip_enabled); +} + +static ssize_t fts_grip_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + u8 cmd[3] = {FTS_CMD_FEATURE, 0x04, 0x01}; + int ret = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + pr_info("%s,buf:%s,count:%zu\n", __func__, buf, count); + sscanf(buf, "%u", &info->grip_enabled); + cmd[2] = info->grip_enabled; + ret = fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)); + if (ret < OK) { + logError(1, "%s %s: write failed...ERROR %08X !\n", tag, + __func__, ret); + return -EPERM; + } + return count; +} + +static ssize_t fts_grip_area_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + return snprintf(buf, TSP_BUF_SIZE, "%d\n", info->grip_pixel); +} + +static ssize_t fts_grip_area_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + u8 cmd[4] = {FTS_CMD_CUSTOM, 0x01, 0x01, 0x00}; + int ret = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(1, " %s %s,buf:%s,count:%zu\n", tag, __func__, buf, count); + sscanf(buf, "%u", &info->grip_pixel); + cmd[3] = info->grip_pixel; + if (atomic_read(&info->system_is_resetting)) { + logError(1, "%s %s system is resetting ,wait reset done\n", tag, __func__); + ret = wait_for_completion_timeout(&info->tp_reset_completion, msecs_to_jiffies(40)); + if (!ret) { + logError(1, "%s %s wait tp reset timeout, wrtie grip area error\n", tag, __func__); + return count; + } + } + ret = fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)); + if (ret < OK) { + logError(1, "%s %s: write failed...ERROR %08X !\n", tag, + __func__, ret); + return -EPERM; + } + return count; +} +#ifdef CONFIG_FTS_FOD_AREA_REPORT +static ssize_t fts_fod_status_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + return snprintf(buf, TSP_BUF_SIZE, "%d\n", info->fod_status); +} + +static ssize_t fts_fod_status_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(1, " %s %s buf:%c,count:%zu\n", tag, __func__, buf[0], count); + sscanf(buf, "%u", &info->fod_status); + queue_work(info->event_wq, &info->mode_handler_work); + logError(1, " %s %s end\n", tag, __func__); + + return count; +} + +static ssize_t fts_fod_test_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + int value = 0; + struct fts_ts_info *info = dev_get_drvdata(dev); + + logError(1, " %s %s,buf:%s,count:%zu\n", tag, __func__, buf, count); + sscanf(buf, "%u", &value); + if (value) { + input_report_key(info->input_dev, BTN_INFO, 1); + input_report_key(info->input_dev, KEY_INFO, 1); + info->fod_pressed = true; + input_sync(info->input_dev); + input_mt_slot(info->input_dev, 0); + input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER, 1); + input_report_key(info->input_dev, BTN_TOUCH, 1); + input_report_key(info->input_dev, BTN_TOOL_FINGER, 1); + input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, 0); + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, 1); + input_report_abs(info->input_dev, ABS_MT_POSITION_X, CENTER_X); + input_report_abs(info->input_dev, ABS_MT_POSITION_Y, CENTER_Y); + input_sync(info->input_dev); + } else { + input_mt_slot(info->input_dev, 0); + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, 0); + input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER, 0); + input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, -1); + input_report_key(info->input_dev, BTN_INFO, 0); + input_report_key(info->input_dev, KEY_INFO, 0); + input_sync(info->input_dev); + } + return count; +} +#endif + +#ifdef CONFIG_SECURE_TOUCH +static void fts_secure_touch_notify (struct fts_ts_info *info) +{ + /*might sleep*/ + sysfs_notify(&info->dev->kobj, NULL, "secure_touch"); + logError(1, "%s %s SECURE_NOTIFY:notify secure_touch\n", tag, __func__); +} + +static int fts_secure_stop(struct fts_ts_info *info, bool block) +{ + struct fts_secure_info *scr_info = info->secure_info; + + logError(1, "%s %s SECURE_STOP: block = %d\n", tag, __func__, (int)block); + if (atomic_read(&scr_info->st_enabled) == 0) { + logError(1, "%s %s secure touch is already disabled\n", tag, __func__); + return OK; + } + + atomic_set(&scr_info->st_pending_irqs, -1); + fts_secure_touch_notify(info); + if (block) { + if (wait_for_completion_interruptible(&scr_info->st_powerdown) == -ERESTARTSYS) { + logError(1, "%s %s SECURE_STOP:st_powerdown be interrupted\n", + tag, __func__); + } else { + logError(1, "%s %s SECURE_STOP:st_powerdown be completed\n", tag, __func__); + } + } + return OK; +} + +static void fts_secure_work(struct fts_secure_info *scr_info) +{ + struct fts_ts_info *info = (struct fts_ts_info *)scr_info->fts_info; + + + fts_secure_touch_notify(info); + atomic_set(&scr_info->st_1st_complete, 1); + if (wait_for_completion_interruptible(&scr_info->st_irq_processed) == -ERESTARTSYS) { + logError(1, "%s %s SECURE_FILTER:st_irq_processed be interrupted\n", tag, __func__); + } else { + logError(1, "%s %s SECURE_FILTER:st_irq_processed be completed\n", tag, __func__); + } + + fts_enableInterrupt(); + logError(1, "%s %s SECURE_FILTER:enable irq\n", tag, __func__); +} + +static void fts_flush_delay_task(struct fts_secure_info *scr_info) +{ + if (scr_info->scr_delay.palm_pending) { + scr_info->scr_delay.palm_pending = false; + } +} + +static int fts_secure_filter_interrupt(struct fts_ts_info *info) +{ + struct fts_secure_info *scr_info = info->secure_info; + + /*inited and enable first*/ + if (!scr_info->secure_inited || atomic_read(&scr_info->st_enabled) == 0) { + return -EPERM; + } + + fts_disableInterruptNoSync(); + logError(1, "%s %s SECURE_FILTER:disable irq\n", tag, __func__); + /*check and change irq pending state + *change irq pending here, secure_touch_show, secure_touch_enable_store + *completion st_irq_processed at secure_touch_show, secure_touch_enable_stroe + */ + logError(1, "%s %s SECURE_FILTER:st_pending_irqs = %d\n", + tag, __func__, atomic_read(&scr_info->st_pending_irqs)); + if (atomic_cmpxchg(&scr_info->st_pending_irqs, 0, 1) == 0) { + fts_secure_work(scr_info); + logError(1, "%s %s SECURE_FILTER:secure_work return\n", tag, __func__); + } + + return 0; +} + +static ssize_t fts_secure_touch_enable_show (struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + struct fts_secure_info *scr_info = info->secure_info; + + logError(1, "%s %s SECURE_TOUCH_ENABLE[R]:st_enabled = %d\n", tag, __func__, atomic_read(&scr_info->st_enabled)); + return scnprintf(buf, PAGE_SIZE, "%d", atomic_read(&scr_info->st_enabled)); +} + +/* echo 0 > secure_touch_enable to disable secure touch + * echo 1 > secure_touch_enable to enable secure touch + */ +static ssize_t fts_secure_touch_enable_store (struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + int ret; + unsigned long value; + struct fts_ts_info *info = dev_get_drvdata(dev); + struct fts_secure_info *scr_info = info->secure_info; + + atomic_set(&scr_info->st_1st_complete, 0); + logError(1, "%s %s SECURE_TOUCH_ENABLE[W]:st_1st_complete=0\n", tag, __func__); + logError(1, "%s %s SECURE_TOUCH_ENABLE[W]:parse parameter\n", tag, __func__); + /*check and get cmd*/ + if (count > 2) + return -EINVAL; + ret = kstrtoul(buf, 10, &value); + if (ret != 0) + return ret; + + if (!scr_info->secure_inited) + return -EIO; + + ret = count; + + logError(1, "%s %s SECURE_TOUCH_ENABLE[W]:st_enabled = %d\n", tag, __func__, value); + switch (value) { + case 0: + if (atomic_read(&scr_info->st_enabled) == 0) { + logError(1, "%s %s secure touch is already disabled\n", + tag, __func__); + return ret; + } + mutex_lock(&scr_info->palm_lock); + atomic_set(&scr_info->st_enabled, 0); + fts_secure_touch_notify(info); + complete(&scr_info->st_irq_processed); + fts_event_handler(info->client->irq, info); + complete(&scr_info->st_powerdown); + fts_flush_delay_task(scr_info); + mutex_unlock(&scr_info->palm_lock); + logError(1, "%s %s SECURE_TOUCH_ENABLE[W]:disable secure touch successful\n", + tag, __func__); + break; + case 1: + if (atomic_read(&scr_info->st_enabled) == 1) { + logError(1, "%s %s secure touch is already enabled\n", + tag, __func__); + return ret; + } + mutex_lock(&scr_info->palm_lock); + /*wait until finish process all normal irq*/ + synchronize_irq(info->client->irq); + + /*enable secure touch*/ + reinit_completion(&scr_info->st_powerdown); + reinit_completion(&scr_info->st_irq_processed); + atomic_set(&scr_info->st_pending_irqs, 0); + atomic_set(&scr_info->st_enabled, 1); + mutex_unlock(&scr_info->palm_lock); + logError(1, "%s %s SECURE_TOUCH_ENABLE[W]:enable secure touch successful\n", + tag, __func__); + break; + default: + logError(1, "%s %s %d in secure_touch_enable is not support\n", + tag, __func__, value); + break; + } + return ret; +} + +static ssize_t fts_secure_touch_show (struct device *dev, struct device_attribute *attr, char *buf) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + struct fts_secure_info *scr_info = info->secure_info; + int value = 0; + + logError(1, "%s %s SECURE_TOUCH[R]:st_1st_complete = %d\n", + tag, __func__, atomic_read(&scr_info->st_1st_complete)); + logError(1, "%s %s SECURE_TOUCH[R]:st_pending_irqs = %d\n", + tag, __func__, atomic_read(&scr_info->st_pending_irqs)); + + if (atomic_read(&scr_info->st_enabled) == 0) { + return -EBADF; + } + + if (atomic_cmpxchg(&scr_info->st_pending_irqs, -1, 0) == -1) + return -EINVAL; + + if (atomic_cmpxchg(&scr_info->st_pending_irqs, 1, 0) == 1) { + value = 1; + } else if (atomic_cmpxchg(&scr_info->st_1st_complete, 1, 0) == 1) { + complete(&scr_info->st_irq_processed); + logError(1, "%s %s SECURE_TOUCH[R]:comlpetion st_irq_processed\n", tag, __func__); + } + return scnprintf(buf, PAGE_SIZE, "%d", value); +} +#endif + +static ssize_t fts_wake_gesture_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + unsigned int input = 0; + static const char *fts_gesture_on = "01 20"; + static const char *fts_gesture_off = "00 20"; + struct fts_ts_info *info = dev_get_drvdata(dev); + char *gesture_result; + int size = 6 * 2 + 1; + if (sscanf(buf, "%u", &input) != 1) + return -EINVAL; + + if (input == 1) { + gesture_result = (u8 *) kzalloc(size, GFP_KERNEL); + fts_gesture_mask_store(info->dev, NULL, + fts_gesture_on, strlen(fts_gesture_on)); + fts_gesture_mask_show(info->dev, NULL, + gesture_result); + } else { + gesture_result = (u8 *) kzalloc(size, GFP_KERNEL); + fts_gesture_mask_store(info->dev, NULL, + fts_gesture_off, strlen(fts_gesture_off)); + fts_gesture_mask_show(info->dev, NULL, + gesture_result); + } + + if (strncmp("{ 00000000 }", gesture_result, size - 1)) + logError(1, "%s %s: store gesture mask error\n", tag, __func__); + + kfree(gesture_result); + gesture_result = NULL; + + return count; +} + +static DEVICE_ATTR(fts_lockdown, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_lockdown_show, fts_lockdown_store); +static DEVICE_ATTR(fwupdate, (S_IRUGO | S_IWUSR | S_IWGRP), fts_fwupdate_show, + fts_fwupdate_store); +static DEVICE_ATTR(panel_vendor, (S_IRUGO), fts_panel_vendor_show, NULL); +static DEVICE_ATTR(panel_color, (S_IRUGO), fts_panel_color_show, NULL); +static DEVICE_ATTR(panel_display, (S_IRUGO), fts_panel_display_show, NULL); +static DEVICE_ATTR(ms_strength, (S_IRUGO), fts_strength_frame_show, NULL); +static DEVICE_ATTR(lockdown_info, (S_IRUGO), fts_lockdown_info_show, NULL); +static DEVICE_ATTR(appid, (S_IRUGO), fts_appid_show, NULL); +static DEVICE_ATTR(mode_active, (S_IRUGO), fts_mode_active_show, NULL); +static DEVICE_ATTR(fw_file_test, (S_IRUGO), fts_fw_test_show, NULL); +static DEVICE_ATTR(selftest_info, (S_IRUGO), fts_selftest_info_show, NULL); +static DEVICE_ATTR(ms_raw, (S_IRUGO), fts_ms_raw_show, NULL); +static DEVICE_ATTR(ss_raw, (S_IRUGO), fts_ss_raw_show, NULL); +static DEVICE_ATTR(ms_cx_total, (S_IRUGO), fts_ms_cx_total_show, NULL); +static DEVICE_ATTR(ss_ix_total, (S_IRUGO), fts_ss_ix_total_show, NULL); +static DEVICE_ATTR(ss_hover, (S_IRUGO), fts_hover_raw_show, NULL); +static DEVICE_ATTR(stm_fts_cmd, (S_IRUGO | S_IWUSR | S_IWGRP), stm_fts_cmd_show, + stm_fts_cmd_store); +#ifdef USE_ONE_FILE_NODE +static DEVICE_ATTR(feature_enable, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_feature_enable_show, fts_feature_enable_store); +#else + +#ifdef GRIP_MODE +static DEVICE_ATTR(grip_mode, (S_IRUGO | S_IWUSR | S_IWGRP), fts_grip_mode_show, + fts_grip_mode_store); +#endif + +#ifdef CHARGER_MODE +static DEVICE_ATTR(charger_mode, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_charger_mode_show, fts_charger_mode_store); +#endif + +#ifdef GLOVE_MODE +static DEVICE_ATTR(glove_mode, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_glove_mode_show, fts_glove_mode_store); +#endif + +#ifdef COVER_MODE +static DEVICE_ATTR(cover_mode, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_cover_mode_show, fts_cover_mode_store); +#endif + +#ifdef STYLUS_MODE +static DEVICE_ATTR(stylus_mode, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_stylus_mode_show, fts_stylus_mode_store); +#endif + +#endif + +#ifdef GESTURE_MODE +static DEVICE_ATTR(gesture_mask, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_gesture_mask_show, fts_gesture_mask_store); +static DEVICE_ATTR(gesture_coordinates, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_gesture_coordinates_show, NULL); +#endif +static DEVICE_ATTR(doze_time, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_doze_time_show, fts_doze_time_store); +static DEVICE_ATTR(grip_enable, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_grip_enable_show, fts_grip_enable_store); +static DEVICE_ATTR(grip_area, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_grip_area_show, fts_grip_area_store); + +static DEVICE_ATTR(hover_tune, (S_IRUGO | S_IWUSR | S_IWGRP), NULL, fts_hover_autotune_store); + +static DEVICE_ATTR(wake_gesture, (S_IRUGO | S_IWUSR), + fts_gesture_mask_show, fts_wake_gesture_store); + +static struct attribute *fts_attr_group[] = { + &dev_attr_fwupdate.attr, + &dev_attr_appid.attr, + &dev_attr_mode_active.attr, + &dev_attr_fw_file_test.attr, + &dev_attr_stm_fts_cmd.attr, +#ifdef USE_ONE_FILE_NODE + &dev_attr_feature_enable.attr, +#else + +#ifdef GRIP_MODE + &dev_attr_grip_mode.attr, +#endif +#ifdef CHARGER_MODE + &dev_attr_charger_mode.attr, +#endif +#ifdef GLOVE_MODE + &dev_attr_glove_mode.attr, +#endif +#ifdef COVER_MODE + &dev_attr_cover_mode.attr, +#endif +#ifdef STYLUS_MODE + &dev_attr_stylus_mode.attr, +#endif +#endif + &dev_attr_fts_lockdown.attr, + &dev_attr_panel_vendor.attr, + &dev_attr_panel_color.attr, + &dev_attr_panel_display.attr, + &dev_attr_lockdown_info.attr, +#ifdef GESTURE_MODE + &dev_attr_gesture_mask.attr, + &dev_attr_gesture_coordinates.attr, +#endif + &dev_attr_selftest_info.attr, + &dev_attr_ms_raw.attr, + &dev_attr_ss_raw.attr, + &dev_attr_ms_cx_total.attr, + &dev_attr_ss_ix_total.attr, + &dev_attr_ms_strength.attr, + &dev_attr_ss_hover.attr, + &dev_attr_hover_tune.attr, + &dev_attr_doze_time.attr, + &dev_attr_grip_enable.attr, + &dev_attr_grip_area.attr, + &dev_attr_wake_gesture.attr, + NULL, +}; + +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP +static DEVICE_ATTR(touch_suspend_notify, (S_IRUGO | S_IRGRP), + fts_touch_suspend_notify_show, NULL); +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT +static DEVICE_ATTR(fod_status, (S_IRUGO | S_IWUSR | S_IWGRP), + fts_fod_status_show, fts_fod_status_store); + +static DEVICE_ATTR(fod_test, (S_IRUGO | S_IWUSR | S_IWGRP), NULL, fts_fod_test_store); +#endif + +#ifdef CONFIG_SECURE_TOUCH +DEVICE_ATTR(secure_touch_enable, (S_IRUGO | S_IWUSR | S_IWGRP), fts_secure_touch_enable_show, fts_secure_touch_enable_store); +DEVICE_ATTR(secure_touch, (S_IRUGO | S_IWUSR | S_IWGRP), fts_secure_touch_show, NULL); +#endif +/**@}*/ +/**@}*/ + +/** + * @defgroup isr Interrupt Service Routine (Event Handler) + * The most important part of the driver is the ISR (Interrupt Service Routine) called also as Event Handler \n + * As soon as the interrupt pin goes low, fts_interrupt_handler() is called and the chain to read and parse the event read from the FIFO start.\n + * For any different kind of EVT_ID there is a specific event handler which will take the correct action to report the proper info to the host. \n + * The most important events are the one related to touch informations, status update or user report. + * @{ + */ + +/** + * Report to the linux input system the pressure and release of a button handling concurrency + * @param info pointer to fts_ts_info which contains info about the device and its hw setup + * @param key_code button value + */ +void fts_input_report_key(struct fts_ts_info *info, int key_code) +{ + mutex_lock(&info->input_report_mutex); + input_report_key(info->input_dev, key_code, 1); + input_sync(info->input_dev); + input_report_key(info->input_dev, key_code, 0); + input_sync(info->input_dev); + mutex_unlock(&info->input_report_mutex); +} + +/** +* Event Handler for no events (EVT_ID_NOEVENT) +*/ +static void fts_nop_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + logError(1, + "%s %s Doing nothing for event = %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); +} + +#ifdef CONFIG_FTS_FOD_AREA_REPORT +static bool fts_is_in_fodarea(int x, int y) +{ + if ((x > FOD_LX && x < FOD_LX + FOD_SIDE) && (y > FOD_LY && y < FOD_LY + + FOD_SIDE)) + return true; + else + return false; +} + +static bool finger_report_flag; + +#endif +/** +* Event handler for enter and motion events (EVT_ID_ENTER_POINT, EVT_ID_MOTION_POINT ) +* report to the linux input system touches with their coordinated and additional informations +*/ +static void fts_enter_pointer_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + unsigned char touchId; + unsigned int touch_condition = 1, tool = MT_TOOL_FINGER; + int x, y, z, distance; + u8 touchType; + int area_size; +#ifndef CONFIG_FTS_FOD_AREA_REPORT + if (!info->resume_bit) + goto no_report; +#endif + if (info->sensor_sleep) { + logError(1, "%s %s sensor sleep, skip touch down event\n", tag, __func__); + return; + } + touchType = event[1] & 0x0F; + touchId = (event[1] & 0xF0) >> 4; + + x = (((int)event[3] & 0x0F) << 8) | (event[2]); + y = ((int)event[4] << 4) | ((event[3] & 0xF0) >> 4); + + z = 1; + distance = 0; + + if (event[0] == EVT_ID_MOTION_POINT) { + area_size = (event[5] << 8) | event[6]; + } else { + area_size = 1; + } + + if (x >= info->board->x_max) + x = info->board->x_max; + + if (y >= info->board->y_max) + y = info->board->y_max; + + input_mt_slot(info->input_dev, touchId); + switch (touchType) { + +#ifdef STYLUS_MODE + case TOUCH_TYPE_STYLUS: + logError(0, "%s %s : It is a stylus!\n", tag, __func__); + if (info->stylus_enabled == 1) { + tool = MT_TOOL_PEN; + touch_condition = 1; + __set_bit(touchId, &info->stylus_id); + break; + } +#endif + case TOUCH_TYPE_FINGER: + /*logError(0, "%s %s : It is a finger!\n",tag,__func__); */ + case TOUCH_TYPE_GLOVE: + /*logError(0, "%s %s : It is a glove!\n",tag,__func__); */ + case TOUCH_TYPE_PALM: + /*logError(0, "%s %s : It is a palm!\n",tag,__func__); */ + tool = MT_TOOL_FINGER; + touch_condition = 1; + __set_bit(touchId, &info->touch_id); + break; + + case TOUCH_TYPE_HOVER: + tool = MT_TOOL_FINGER; + touch_condition = 0; + z = 0; + __set_bit(touchId, &info->touch_id); + distance = DISTANCE_MAX; + break; + + case TOUCH_TYPE_INVALID: + default: + logError(1, "%s %s : Invalid touch type = %d ! No Report...\n", + tag, __func__, touchType); +#ifndef CONFIG_FTS_FOD_AREA_REPORT + goto no_report; +#endif + + } + + input_mt_report_slot_state(info->input_dev, tool, 1); + input_report_key(info->input_dev, BTN_TOUCH, touch_condition); + if (touch_condition) + input_report_key(info->input_dev, BTN_TOOL_FINGER, 1); + + /*input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, touchId); */ + input_report_abs(info->input_dev, ABS_MT_POSITION_X, x); + input_report_abs(info->input_dev, ABS_MT_POSITION_Y, y); + input_report_abs(info->input_dev, ABS_MT_TOUCH_MINOR, z); + input_report_abs(info->input_dev, ABS_MT_DISTANCE, distance); + input_report_abs(info->input_dev, ABS_MT_TOUCH_MAJOR, area_size); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (fts_is_in_fodarea(x, y) && !(info->fod_id & ~(1 << touchId))) { + __set_bit(touchId, &info->sleep_finger); + if (info->fod_status) { + info->fod_x = x; + info->fod_y = y; + info->fod_coordinate_update = true; + __set_bit(touchId, &info->fod_id); + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, info->fod_overlap); + input_report_key(info->input_dev, BTN_INFO, 1); + input_report_key(info->input_dev, KEY_INFO, 1); + logError(1, "%s %s : FOD Press :%d, fod_id:%08x\n", tag, __func__, + touchId, info->fod_id); + } + } else if (__test_and_clear_bit(touchId, &info->fod_id)) { + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, 0); + input_report_key(info->input_dev, BTN_INFO, 0); + input_report_key(info->input_dev, KEY_INFO, 0); + info->fod_coordinate_update = false; + info->fod_overlap = 0; + logError(1, "%s %s : FOD Release :%d\n", tag, __func__, + touchId); + __clear_bit(touchId, &info->sleep_finger); + } +#endif + input_sync(info->input_dev); + dev_dbg(info->dev, + "%s %s : Event 0x%02x - ID[%d], (x, y, z) = (%3d, %3d, %3d) type = %d, size = %d, overlap:%d\n", + tag, __func__, *event, touchId, x, y, z, touchType, area_size, + info->fod_overlap); + +#ifndef CONFIG_FTS_FOD_AREA_REPORT +no_report: + return; +#endif +} + +/** +* Event handler for leave event (EVT_ID_LEAVE_POINT ) +* Report to the linux input system that one touch left the display +*/ +static void fts_leave_pointer_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + unsigned char touchId = 0; + unsigned int tool = MT_TOOL_FINGER; + unsigned int touch_condition = 0; + u8 touchType; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + int x, y; + bool fod_up = false; +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (event[1] == 0xb5) { + touchType = TOUCH_TYPE_FINGER; + info->sleep_finger = 0; + if (!info->fod_id) { + logError(1, "%s %s : FOD Release without FOD press\n", tag, __func__); + goto exit; + } + if (info->touch_id) { + logError(1, "%s %s : FOD Release in active mode\n", tag, __func__); + goto exit; + } + touchId = ffs(info->fod_id) - 1; + info->fod_overlap = 0; + + logError(1, "%s %s : FOD Release :%d, fod_id:%08x\n", tag, __func__, + touchId, info->fod_id); + + + __clear_bit(touchId, &info->fod_id); + fod_up = true; + + } else { +#endif + touchType = event[1] & 0x0F; + touchId = (event[1] & 0xF0) >> 4; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + } + x = (event[2] << 4) | (event[4] & 0xF0) >> 4; + y = (event[3] << 4) | (event[4] & 0x0F); +#endif + input_mt_slot(info->input_dev, touchId); + switch (touchType) { + +#ifdef STYLUS_MODE + case TOUCH_TYPE_STYLUS: + logError(0, "%s %s : It is a stylus!\n", tag, __func__); + if (info->stylus_enabled == 1) { + tool = MT_TOOL_PEN; + __clear_bit(touchId, &info->stylus_id); + break; + } +#endif + + case TOUCH_TYPE_FINGER: + /*logError(0, "%s %s : It is a finger!\n",tag,__func__); */ + case TOUCH_TYPE_GLOVE: + /*logError(0, "%s %s : It is a glove!\n",tag,__func__); */ + case TOUCH_TYPE_PALM: + /*logError(0, "%s %s : It is a palm!\n",tag,__func__); */ + tool = MT_TOOL_FINGER; + touch_condition = 0; + __clear_bit(touchId, &info->touch_id); + break; + case TOUCH_TYPE_HOVER: + tool = MT_TOOL_FINGER; + touch_condition = 1; + __clear_bit(touchId, &info->touch_id); + break; + + case TOUCH_TYPE_INVALID: + default: + logError(1, "%s %s : Invalid touch type = %d ! No Report...\n", + tag, __func__, touchType); + return; + + } +#ifdef CONFIG_FTS_FOD_AREA_REPORT + __clear_bit(touchId, &info->sleep_finger); + if (__test_and_clear_bit(touchId, &info->fod_id)) { + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, 0); + input_report_key(info->input_dev, BTN_INFO, 0); + input_report_key(info->input_dev, KEY_INFO, 0); + info->fod_coordinate_update = false; + } +#endif + input_mt_report_slot_state(info->input_dev, tool, 0); + if (info->touch_id == 0) { + input_report_key(info->input_dev, BTN_TOUCH, touch_condition); + if (!touch_condition) + input_report_key(info->input_dev, BTN_TOOL_FINGER, 0); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + info->fod_pressed = false; + info->fod_overlap = 0; + input_report_key(info->input_dev, BTN_INFO, 0); + input_report_key(info->input_dev, KEY_INFO, 0); + finger_report_flag = false; +#endif + + info->touch_skip = 0; + info->sleep_finger = 0; + info->fod_id = 0; + } + input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, -1); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (fod_up) + logError(1, + "%s %s : Event FOD - release ID[%d] type = %d\n", tag, + __func__, touchId, touchType); + else +#endif + + input_sync(info->input_dev); +#ifdef CONFIG_FTS_FOD_AREA_REPORT +exit: +#endif + return; +} + +/* EventId : EVT_ID_MOTION_POINT */ +#define fts_motion_pointer_event_handler fts_enter_pointer_event_handler + +/** +* Event handler for error events (EVT_ID_ERROR) +* Handle unexpected error events implementing recovery strategy and restoring the sensing status that the IC had before the error occured +*/ +static void fts_error_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + int error = 0; + logError(1, + "%s %s Received event %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); + + switch (event[1]) { + case EVT_TYPE_ERROR_ESD: + { + release_all_touches(info); + + fts_chip_powercycle(info); + + error = fts_system_reset(); + error |= fts_mode_handler(info, 0); + error |= fts_enableInterrupt(); + if (error < OK) { + logError(1, + "%s %s Cannot restore the device ERROR %08X\n", + tag, __func__, error); + } + } + break; + case EVT_TYPE_ERROR_WATCHDOG: + { + dumpErrorInfo(NULL, 0); + release_all_touches(info); + error = fts_system_reset(); + error |= fts_mode_handler(info, 0); + error |= fts_enableInterrupt(); + if (error < OK) { + logError(1, + "%s %s Cannot reset the device ERROR %08X\n", + tag, __func__, error); + } + } + break; + + } +} + +/** +* Event handler for controller ready event (EVT_ID_CONTROLLER_READY) +* Handle controller events received after unexpected reset of the IC updating the resets flag and restoring the proper sensing status +*/ +static void fts_controller_ready_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + int error; + logError(1, + "%s %s Received event %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); + release_all_touches(info); + setSystemResetedUp(1); + setSystemResetedDown(1); + error = fts_mode_handler(info, 0); + if (error < OK) { + logError(1, + "%s %s Cannot restore the device status ERROR %08X\n", + tag, __func__, error); + } +} + +/** +* Event handler for status events (EVT_ID_STATUS_UPDATE) +* Handle status update events +*/ +static void fts_status_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + switch (event[1]) { + + case EVT_TYPE_STATUS_ECHO: + logError(0, + "%s %s Echo event of command = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], event[5], + event[6], event[7]); + break; + + case EVT_TYPE_STATUS_FORCE_CAL: + switch (event[2]) { + case 0x00: + logError(1, + "%s %s Continuous frame drop Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x01: + logError(1, + "%s %s Mutual negative detect Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x02: + logError(1, + "%s %s Mutual calib deviation Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x11: + logError(1, + "%s %s SS negative detect Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x12: + logError(1, + "%s %s SS negative detect Force cal in Low Power mode = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x13: + logError(1, + "%s %s SS negative detect Force cal in Idle mode = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x20: + logError(1, + "%s %s SS invalid Mutual Strength soft Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x21: + logError(1, + "%s %s SS invalid Self Strength soft Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x22: + logError(1, + "%s %s SS invalid Self Island soft Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x30: + logError(1, + "%s %s MS invalid Mutual Strength soft Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x31: + logError(1, + "%s %s MS invalid Self Strength soft Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + default: + logError(1, + "%s %s Force cal = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + + } + break; + + case EVT_TYPE_STATUS_FRAME_DROP: + switch (event[2]) { + case 0x01: + logError(1, + "%s %s Frame drop noisy frame = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x02: + logError(1, + "%s %s Frame drop bad R = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case 0x03: + logError(1, + "%s %s Frame drop invalid processing state = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + default: + logError(1, + "%s %s Frame drop = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + + } + break; + + case EVT_TYPE_STATUS_SS_RAW_SAT: + if (event[2] == 1) + logError(1, + "%s %s SS Raw Saturated = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + else + logError(1, + "%s %s SS Raw No more Saturated = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + + case EVT_TYPE_STATUS_WATER: + if (event[2] == 1) + logError(1, + "%s %s Enter Water mode = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + else + logError(1, + "%s %s Exit Water mode = %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[2], event[3], event[4], + event[5], event[6], event[7]); + break; + default: + logError(1, + "%s %s Received unhandled status event = %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); + break; + } + +} + +#ifdef PHONE_KEY +/** + * Event handler for status events (EVT_TYPE_USER_KEY) + * Handle keys update events, the third byte of the event is a bitmask where if the bit set means that the corresponding key is pressed. + */ +static void fts_key_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + + logError(0, + "%s %s Received event %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); + + if (event[0] == EVT_ID_USER_REPORT && event[1] == EVT_TYPE_USER_KEY) { + + if ((event[2] & FTS_KEY_0) == 0 && (key_mask & FTS_KEY_0) > 0) { + logError(0, + "%s %s: Button HOME pressed and released! \n", + tag, __func__); + fts_input_report_key(info, KEY_HOMEPAGE); + } + + if ((event[2] & FTS_KEY_1) == 0 && (key_mask & FTS_KEY_1) > 0) { + logError(0, + "%s %s: Button Back pressed and released! \n", + tag, __func__); + fts_input_report_key(info, KEY_BACK); + } + + if ((event[2] & FTS_KEY_2) == 0 && (key_mask & FTS_KEY_2) > 0) { + logError(0, "%s %s: Button Menu pressed! \n", tag, + __func__); + fts_input_report_key(info, KEY_MENU); + } + + key_mask = event[2]; + } else { + logError(1, "%s %s: Invalid event passed as argument! \n", tag, + __func__); + } + +} +#endif + +#ifdef GESTURE_MODE +/** + * Event handler for gesture events (EVT_TYPE_USER_GESTURE) + * Handle gesture events and simulate the click on a different button for any gesture detected (@link gesture_opt Gesture IDs @endlink) + */ +static void fts_gesture_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + int value; + int needCoords = 0; + char ch[64] = { 0x0, }; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + int touch_area; + int fod_overlap; + int fod_id = 0; + int x = (event[4] << 8) | (event[3]); + int y = (event[6] << 8) | (event[5]); +#endif + + logError(1, + "%s gesture event data: %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, event[0], event[1], event[2], event[3], event[4], + event[5], event[6], event[7]); + if (event[0] == EVT_ID_USER_REPORT && event[1] == EVT_TYPE_USER_GESTURE) { + needCoords = 1; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (event[2] == GEST_ID_LONG_PRESS && info->fod_status) { + touch_area = (event[9] << 8) | (event[8]); + fod_overlap = (event[11] << 8) | (event[10]); + if ((!info->sensor_sleep && info->fod_coordinate_update && + info->fod_id && fts_is_in_fodarea(info->fod_x, info->fod_y)) || + (info->sensor_sleep && fts_is_in_fodarea(x, y))) { + if (!finger_report_flag) { + logError(1, "%s %s finger down in the fod area\n", tag, __func__); + finger_report_flag = true; + } + info->fod_overlap = fod_overlap; + + if ((info->sensor_sleep && !info->sleep_finger) || !info->sensor_sleep) { + info->fod_pressed = true; + input_report_key(info->input_dev, BTN_INFO, 1); + input_report_key(info->input_dev, KEY_INFO, 1); + input_sync(info->input_dev); + if (info->fod_id) { + fod_id = ffs(info->fod_id) - 1; + if (info->fod_id & ~(1 << fod_id)) + logError(1, "%s %s multi fingers on fod area:%08x\n", tag, + __func__, info->fod_id); + } else if (info->sensor_sleep) { + __set_bit(0, &info->fod_id); + } + + if (info->fod_coordinate_update || info->sensor_sleep) { + input_mt_slot(info->input_dev, fod_id); + input_mt_report_slot_state(info->input_dev, MT_TOOL_FINGER, 1); + input_report_key(info->input_dev, BTN_TOUCH, 1); + input_report_key(info->input_dev, BTN_TOOL_FINGER, 1); + if (info->sensor_sleep) { + input_report_abs(info->input_dev, ABS_MT_POSITION_X, x); + input_report_abs(info->input_dev, ABS_MT_POSITION_Y, y); + } else { + input_report_abs(info->input_dev, ABS_MT_POSITION_X, info->fod_x); + input_report_abs(info->input_dev, ABS_MT_POSITION_Y, info->fod_y); + info->fod_coordinate_update = false; + } + input_report_abs(info->input_dev, ABS_MT_WIDTH_MAJOR, touch_area); + input_report_abs(info->input_dev, ABS_MT_WIDTH_MINOR, fod_overlap); + logError(1, "%s %s id:%d, fod_id:%08x, touch_area:%d, overlap:%d,fod report\n", + tag, __func__, fod_id, info->fod_id, touch_area, fod_overlap); + } + input_sync(info->input_dev); + } + } + goto gesture_done; + } else if (event[2] == GEST_ID_SINGTAP && info->fod_status) { + input_report_key(info->input_dev, KEY_GOTO, 1); + input_sync(info->input_dev); + input_report_key(info->input_dev, KEY_GOTO, 0); + input_sync(info->input_dev); + info->sleep_finger = 0; + info->fod_overlap = 0; + info->fod_pressed = false; + goto gesture_done; + } +#endif + switch (event[2]) { + case GEST_ID_DBLTAP: + if (!info->gesture_enabled) + goto gesture_done; + value = KEY_WAKEUP; + logError(0, "%s %s: double tap ! \n", tag, __func__); + info->dbclick_count++; + snprintf(ch, sizeof(ch), "%d", info->dbclick_count); + needCoords = 0; + break; + + case GEST_ID_AT: + value = KEY_WWW; + logError(0, "%s %s: @ ! \n", tag, __func__); + break; + + case GEST_ID_C: + value = KEY_C; + logError(0, "%s %s: C ! \n", tag, __func__); + break; + + case GEST_ID_E: + value = KEY_E; + logError(0, "%s %s: e ! \n", tag, __func__); + break; + + case GEST_ID_F: + value = KEY_F; + logError(0, "%s %s: F ! \n", tag, __func__); + break; + + case GEST_ID_L: + value = KEY_L; + logError(0, "%s %s: L ! \n", tag, __func__); + break; + + case GEST_ID_M: + value = KEY_M; + logError(0, "%s %s: M ! \n", tag, __func__); + break; + + case GEST_ID_O: + value = KEY_O; + logError(0, "%s %s: O ! \n", tag, __func__); + break; + + case GEST_ID_S: + value = KEY_S; + logError(0, "%s %s: S ! \n", tag, __func__); + break; + + case GEST_ID_V: + value = KEY_V; + logError(0, "%s %s: V ! \n", tag, __func__); + break; + + case GEST_ID_W: + value = KEY_W; + logError(0, "%s %s: W ! \n", tag, __func__); + break; + + case GEST_ID_Z: + value = KEY_Z; + logError(0, "%s %s: Z ! \n", tag, __func__); + break; + + case GEST_ID_RIGHT_1F: + value = KEY_RIGHT; + logError(0, "%s %s: -> ! \n", tag, __func__); + break; + + case GEST_ID_LEFT_1F: + value = KEY_LEFT; + logError(0, "%s %s: <- ! \n", tag, __func__); + break; + + case GEST_ID_UP_1F: + value = KEY_UP; + logError(0, "%s %s: UP ! \n", tag, __func__); + break; + + case GEST_ID_DOWN_1F: + value = KEY_DOWN; + logError(0, "%s %s: DOWN ! \n", tag, __func__); + break; + + case GEST_ID_CARET: + value = KEY_APOSTROPHE; + logError(0, "%s %s: ^ ! \n", tag, __func__); + break; + + case GEST_ID_LEFTBRACE: + value = KEY_LEFTBRACE; + logError(0, "%s %s: < ! \n", tag, __func__); + break; + + case GEST_ID_RIGHTBRACE: + value = KEY_RIGHTBRACE; + logError(0, "%s %s: > ! \n", tag, __func__); + break; + + default: + logError(0, "%s %s: No valid GestureID! \n", tag, + __func__); + goto gesture_done; + + } + + if (needCoords == 1) + readGestureCoords(event); + + fts_input_report_key(info, value); + +gesture_done: + return; + } else { + logError(1, "%s %s: Invalid event passed as argument! \n", tag, + __func__); + } + +} +#endif + +/** + * Event handler for user report events (EVT_ID_USER_REPORT) + * Handle user events reported by the FW due to some interaction triggered by an external user (press keys, perform gestures, etc.) + */ +static void fts_user_report_event_handler(struct fts_ts_info *info, + unsigned char *event) +{ + + switch (event[1]) { + +#ifdef PHONE_KEY + case EVT_TYPE_USER_KEY: + fts_key_event_handler(info, event); + break; +#endif + + case EVT_TYPE_USER_PROXIMITY: + if (event[2] == 0) { + logError(1, "%s %s No proximity!\n", tag, __func__); + } else { + logError(1, "%s %s Proximity Detected!\n", tag, + __func__); + } + break; + +#ifdef GESTURE_MODE + case EVT_TYPE_USER_GESTURE: + fts_gesture_event_handler(info, event); + break; +#endif + default: + logError(1, + "%s %s Received unhandled user report event = %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, event[0], event[1], event[2], event[3], + event[4], event[5], event[6], event[7]); + break; + } + +} + +/* +static void buffDump(unsigned char *buf, unsigned int buflength, char *tag) +{ + unsigned char *tmp, *back; + unsigned int i; + unsigned int to_read; + unsigned int remain = buflength; + unsigned int chunk = 10; + + logError(1, "%s BUFFDUMP IN:", tag); + + tmp = kmalloc(300, GFP_ATOMIC); + if (!tmp) { + logError(1, "alloc tmp=%04d byte failed", 300); + return; + } + back = tmp; + + memcpy(tmp, buf, buflength); + + while (remain > 0) { + if (remain > chunk) { + remain -= chunk; + to_read = chunk; + } else { + to_read = remain; + for (i = to_read; i < chunk; i++) { + tmp[i] = 0xED; + } + remain = 0; + } + + logError(1, "%s %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", + tag, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9]); + + tmp += to_read; + } + kfree(back); +} +*/ + +static void fts_ts_sleep_work(struct work_struct *work) +{ + struct fts_ts_info *info = container_of(work, struct fts_ts_info, sleep_work); + int error = 0, count = 0; + unsigned char regAdd = FIFO_CMD_READALL; + unsigned char data[FIFO_EVENT_SIZE * FIFO_DEPTH] = {0}; + unsigned char eventId; + const unsigned char EVENTS_REMAINING_POS = 7; + const unsigned char EVENTS_REMAINING_MASK = 0x1F; + unsigned char events_remaining = 0; + unsigned char *evt_data; + static char pre_id[3]; + event_dispatch_handler_t event_handler; + int r; + fts_disableInterrupt(); + if (info->tp_pm_suspend) { + r = wait_for_completion_timeout(&info->pm_resume_completion, msecs_to_jiffies(500)); + if (!r) { + logError(1, "%s pm_resume_completion timeout, i2c is closed", tag); + pm_relax(info->dev); + fts_enableInterrupt(); + return; + } else { + logError(1, "%s pm_resume_completion be completed, handling irq", tag); + } + } + + info->irq_status = true; + error = fts_writeReadU8UX(regAdd, 0, 0, data, FIFO_EVENT_SIZE, + DUMMY_FIFO); + events_remaining = data[EVENTS_REMAINING_POS] & EVENTS_REMAINING_MASK; + events_remaining = (events_remaining > FIFO_DEPTH - 1) ? + FIFO_DEPTH - 1 : events_remaining; + + /*Drain the rest of the FIFO, up to 31 events*/ + if (error == OK && events_remaining > 0) { + error = fts_writeReadU8UX(regAdd, 0, 0, &data[FIFO_EVENT_SIZE], + FIFO_EVENT_SIZE * events_remaining, + DUMMY_FIFO); + } + if (error != OK) { + logError(1, + "Error (%d) while reading from FIFO in fts_event_handler", + error); + } else { + for (count = 0; count < events_remaining + 1; count++) { + evt_data = &data[count * FIFO_EVENT_SIZE]; + if (pre_id[0] == EVT_ID_USER_REPORT && + pre_id[1] == 0x02 && + pre_id[2] == 0x18) { + pre_id[0] = 0; + pre_id[1] = 0; + pre_id[2] = 0; + continue; + } + if (evt_data[0] == EVT_ID_NOEVENT) + break; + eventId = evt_data[0] >> 4; + /*Ensure event ID is within bounds*/ + if (eventId < NUM_EVT_ID) { + event_handler = info->event_dispatch_table[eventId]; + event_handler(info, (evt_data)); + pre_id[0] = evt_data[0]; + pre_id[1] = evt_data[1]; + pre_id[2] = evt_data[2]; + } + } + } + input_sync(info->input_dev); + info->irq_status = false; + pm_relax(info->dev); + fts_enableInterrupt(); + return; +} + +/** + * Bottom Half Interrupt Handler function + * This handler is called each time there is at least one new event in the FIFO and the interrupt pin of the IC goes low. + * It will read all the events from the FIFO and dispatch them to the proper event handler according the event ID + */ +static irqreturn_t fts_event_handler(int irq, void *ts_info) +{ + struct fts_ts_info *info = ts_info; + int error = 0, count = 0; + unsigned char regAdd = FIFO_CMD_READALL; + unsigned char data[FIFO_EVENT_SIZE * FIFO_DEPTH] = {0}; + unsigned char eventId; + const unsigned char EVENTS_REMAINING_POS = 7; + const unsigned char EVENTS_REMAINING_MASK = 0x1F; + unsigned char events_remaining = 0; + unsigned char *evt_data; + static char pre_id[3]; + event_dispatch_handler_t event_handler; + + if (info->tp_pm_suspend) { + logError(1, "%s device in suspend, schedue to work", tag); + pm_wakeup_event(info->dev, 0); + if (!work_pending(&info->sleep_work)) { + pm_stay_awake(info->dev); + queue_work(info->irq_wq, &info->sleep_work); + } + return IRQ_HANDLED; + } + +#ifdef CONFIG_SECURE_TOUCH + if (!fts_secure_filter_interrupt(info)) { + return IRQ_HANDLED; + } +#endif + + info->irq_status = true; + error = fts_writeReadU8UX(regAdd, 0, 0, data, FIFO_EVENT_SIZE, + DUMMY_FIFO); + events_remaining = data[EVENTS_REMAINING_POS] & EVENTS_REMAINING_MASK; + events_remaining = (events_remaining > FIFO_DEPTH - 1) ? + FIFO_DEPTH - 1 : events_remaining; + + /*Drain the rest of the FIFO, up to 31 events*/ + if (error == OK && events_remaining > 0) { + error = fts_writeReadU8UX(regAdd, 0, 0, &data[FIFO_EVENT_SIZE], + FIFO_EVENT_SIZE * events_remaining, + DUMMY_FIFO); + } + if (error != OK) { + logError(1, + "Error (%d) while reading from FIFO in fts_event_handler", + error); + } else { + for (count = 0; count < events_remaining + 1; count++) { + evt_data = &data[count * FIFO_EVENT_SIZE]; + if (pre_id[0] == EVT_ID_USER_REPORT && + pre_id[1] == 0x02 && + pre_id[2] == 0x18) { + pre_id[0] = 0; + pre_id[1] = 0; + pre_id[2] = 0; + continue; + } + if (evt_data[0] == EVT_ID_NOEVENT) + break; + eventId = evt_data[0] >> 4; + /*Ensure event ID is within bounds*/ + if (eventId < NUM_EVT_ID) { + event_handler = info->event_dispatch_table[eventId]; + event_handler(info, (evt_data)); + pre_id[0] = evt_data[0]; + pre_id[1] = evt_data[1]; + pre_id[2] = evt_data[2]; + } + } + } + input_sync(info->input_dev); + info->irq_status = false; + return IRQ_HANDLED; +} + +/**@}*/ + +static const char *fts_get_config(struct fts_ts_info *info) +{ + struct fts_hw_platform_data *pdata = info->board; + int i = 0, ret = 0; + + ret = fts_get_lockdown_info(info->lockdown_info, info); + + if (ret < OK) { + logError(1, "%s can't read lockdown info", tag); + return pdata->default_fw_name; + } + + ret |= fts_enableInterrupt(); + + for (i = 0; i < pdata->config_array_size; i++) { + if (info->lockdown_info[0] == pdata->config_array[i].tp_vendor) + break; + } + + if (i >= pdata->config_array_size) { + logError(1, "%s can't find right config", tag); + return pdata->default_fw_name; + } + + logError(1, "%s Choose config %d: %s", tag, i, + pdata->config_array[i].fts_cfg_name); + pdata->current_index = i; +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + if (pdata->dump_click_count) { + info->current_clicknum_file = + kzalloc(TOUCH_COUNT_FILE_MAXSIZE, GFP_KERNEL); + strlcpy(info->current_clicknum_file, + pdata->config_array[i].clicknum_file_name, + TOUCH_COUNT_FILE_MAXSIZE); + } +#endif + return pdata->config_array[i].fts_cfg_name; +} + +static const char *fts_get_limit(struct fts_ts_info *info) +{ + struct fts_hw_platform_data *pdata = info->board; + int i = 0, ret = 0; + + ret = fts_get_lockdown_info(info->lockdown_info, info); + + if (ret < OK) { + logError(1, "%s can't read lockdown info", tag); + return LIMITS_FILE; + } + + ret |= fts_enableInterrupt(); + + for (i = 0; i < pdata->config_array_size; i++) { + if (info->lockdown_info[0] == pdata->config_array[i].tp_vendor) + break; + } + + if (i >= pdata->config_array_size) { + logError(1, "%s can't find right limit", tag); + return LIMITS_FILE; + } + + logError(1, "%s Choose limit file %d: %s", tag, i, + pdata->config_array[i].fts_limit_name); + pdata->current_index = i; + return pdata->config_array[i].fts_limit_name; +} + +/** +* Implement the fw update and initialization flow of the IC that should be executed at every boot up. +* The function perform a fw update of the IC in case of crc error or a new fw version and then understand if the IC need to be re-initialized again. +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_fw_update(struct fts_ts_info *info, const char *fw_name, int force) +{ + + u8 error_to_search[4] = {EVT_TYPE_ERROR_CRC_CX_HEAD, EVT_TYPE_ERROR_CRC_CX, + EVT_TYPE_ERROR_CRC_CX_SUB_HEAD, EVT_TYPE_ERROR_CRC_CX_SUB + }; + int retval = 0; + int retval1 = 0; + int ret; + int crc_status = 0; + int error = 0; + int init_type = NO_INIT; +#ifdef PRE_SAVED_METHOD + int keep_cx = 1; +#else + int keep_cx = 0; +#endif + + logError(1, "%s Fw Auto Update is starting... \n", tag); + + ret = fts_crc_check(); + if (ret > OK) { + logError(1, "%s %s: CRC Error or NO FW!\n", tag, __func__); + crc_status = ret; + } else { + crc_status = 0; + logError(1, + "%s %s: NO CRC Error or Impossible to read CRC register! \n", + tag, __func__); + } + + if (fw_name == NULL) { + fw_name = fts_get_config(info); + if (fw_name == NULL) + logError(1, "%s not found mached config!", tag); + } + + if (fw_name) { + if (force) + retval = flashProcedure(fw_name, 1, keep_cx); + else + retval = flashProcedure(fw_name, crc_status, keep_cx); + + if ((retval & 0xFF000000) == ERROR_FLASH_PROCEDURE) { + logError(1, + "%s %s: firmware update failed and retry! ERROR %08X\n", + tag, __func__, retval); + fts_chip_powercycle(info); + retval1 = flashProcedure(info->board->default_fw_name, crc_status, keep_cx); + if ((retval1 & 0xFF000000) == ERROR_FLASH_PROCEDURE) { + logError(1, + "%s %s: firmware update failed again! ERROR %08X\n", + tag, __func__, retval1); + logError(1, "%s Fw Auto Update Failed!\n", tag); + } + } + } + + logError(1, "%s %s: Verifying if CX CRC Error...\n", tag, __func__, + ret); + ret = fts_system_reset(); + if (ret >= OK) { + ret = pollForErrorType(error_to_search, 4); + if (ret < OK) { + logError(1, "%s %s: No Cx CRC Error Found! \n", tag, + __func__); + logError(1, "%s %s: Verifying if Panel CRC Error... \n", + tag, __func__); + error_to_search[0] = EVT_TYPE_ERROR_CRC_PANEL_HEAD; + error_to_search[1] = EVT_TYPE_ERROR_CRC_PANEL; + ret = pollForErrorType(error_to_search, 2); + if (ret < OK) { + logError(1, + "%s %s: No Panel CRC Error Found! \n", + tag, __func__); + init_type = NO_INIT; + } else { + logError(1, + "%s %s: Panel CRC Error FOUND! CRC ERROR = %02X\n", + tag, __func__, ret); + init_type = SPECIAL_PANEL_INIT; + } + } else { + logError(1, + "%s %s: Cx CRC Error FOUND! CRC ERROR = %02X\n", + tag, __func__, ret); + + logError(1, + "%s %s: Try to recovery with CX in fw file...\n", + tag, __func__, ret); + flashProcedure(info->board->default_fw_name, CRC_CX, 0); + logError(1, "%s %s: Refresh panel init data... \n", tag, + __func__, ret); + } + } else { + logError(1, + "%s %s: Error while executing system reset! ERROR %08X\n", + tag, __func__, ret); + } + + if (init_type == NO_INIT) { +#ifdef PRE_SAVED_METHOD + if (systemInfo.u8_cfgAfeVer != systemInfo.u8_cxAfeVer) { + init_type = SPECIAL_FULL_PANEL_INIT; + logError(0, + "%s %s: Different CX AFE Ver: %02X != %02X... Execute FULL Panel Init! \n", + tag, __func__, systemInfo.u8_cfgAfeVer, + systemInfo.u8_cxAfeVer); + } else +#endif + + if (systemInfo.u8_cfgAfeVer != systemInfo.u8_panelCfgAfeVer) { + init_type = SPECIAL_PANEL_INIT; + logError(0, + "%s %s: Different Panel AFE Ver: %02X != %02X... Execute Panel Init! \n", + tag, __func__, systemInfo.u8_cfgAfeVer, + systemInfo.u8_panelCfgAfeVer); + } else { + init_type = NO_INIT; + } + } + + if (init_type != NO_INIT) { + error = fts_chip_initialization(info, init_type); + if (error < OK) { + logError(1, + "%s %s Cannot initialize the chip ERROR %08X\n", + tag, __func__, error); + } + } + + error = fts_init_sensing(info); + if (error < OK) { + logError(1, + "%s Cannot initialize the hardware device ERROR %08X\n", + tag, error); + } + + logError(1, "%s Fw Update Finished! error = %08X\n", tag, error); + return error; +} + +#ifndef FW_UPDATE_ON_PROBE + +/** +* Function called by the delayed workthread executed after the probe in order to perform the fw update flow +* @see fts_fw_update() +*/ +static void fts_fw_update_auto(struct work_struct *work) +{ + struct delayed_work *fwu_work = + container_of(work, struct delayed_work, work); + struct fts_ts_info *info = + container_of(fwu_work, struct fts_ts_info, fwu_work); + fts_fw_update(info, NULL, 0); +} +#endif + +/** +* Execute the initialization of the IC (supporting a retry mechanism), checking also the resulting data +* @see production_test_main() +*/ +static int fts_chip_initialization(struct fts_ts_info *info, int init_type) +{ + int ret2 = 0; + int retry; + int initretrycnt = 0; + + for (retry = 0; retry <= RETRY_INIT_BOOT; retry++) { + ret2 = production_test_initialization(init_type); + if (ret2 == OK) + break; + initretrycnt++; + logError(1, + "%s initialization cycle count = %04d - ERROR %08X \n", + tag, initretrycnt, ret2); + fts_chip_powercycle(info); + } + + if (ret2 < OK) { + logError(1, "%s fts initialization failed 3 times \n", tag); + } + + return ret2; +} + +/** + * @addtogroup isr + * @{ + */ +/** +* Top half Interrupt handler function +* Respond to the interrupt and schedule the bottom half interrupt handler in its work queue +* @see fts_event_handler() +*/ +/* +static irqreturn_t fts_interrupt_handler(int irq, void *handle) +{ + struct fts_ts_info *info = handle; +#ifdef CONFIG_SECURE_TOUCH + if (!fts_secure_filter_interrupt(info)) { + return IRQ_HANDLED; + } +#endif + disable_irq_nosync(info->client->irq); + queue_work(info->event_wq, &info->work); + + return IRQ_HANDLED; +} +*/ +/** +* Initialize the dispatch table with the event handlers for any possible event ID and the interrupt routine behavior (triggered when the IRQ pin is low and associating the top half interrupt handler function). +* @see fts_interrupt_handler() +*/ +static int fts_interrupt_install(struct fts_ts_info *info) +{ + int i, error = 0; + + info->event_dispatch_table = + kzalloc(sizeof(event_dispatch_handler_t) * NUM_EVT_ID, GFP_KERNEL); + + if (!info->event_dispatch_table) { + logError(1, "%s OOM allocating event dispatch table\n", tag); + return -ENOMEM; + } + + for (i = 0; i < NUM_EVT_ID; i++) + info->event_dispatch_table[i] = fts_nop_event_handler; + + install_handler(info, ENTER_POINT, enter_pointer); + install_handler(info, LEAVE_POINT, leave_pointer); + install_handler(info, MOTION_POINT, motion_pointer); + install_handler(info, ERROR, error); + install_handler(info, CONTROLLER_READY, controller_ready); + install_handler(info, STATUS_UPDATE, status); + install_handler(info, USER_REPORT, user_report); + + /* disable interrupts in any case */ + error = fts_disableInterrupt(); + logError(1, "%s Interrupt Mode\n", tag); + if (request_threaded_irq(info->client->irq, NULL, fts_event_handler, info->board->irq_flags, + FTS_TS_DRV_NAME, info)) { + logError(1, "%s Request irq failed\n", tag); + kfree(info->event_dispatch_table); + error = -EBUSY; + } else { + disable_irq(info->client->irq); + } + + return error; +} + +/** +* Clean the dispatch table and the free the IRQ. +* This function is called when the driver need to be removed +*/ +static void fts_interrupt_uninstall(struct fts_ts_info *info) +{ + + fts_disableInterrupt(); + + kfree(info->event_dispatch_table); + + free_irq(info->client->irq, info); + +} + +/**@}*/ + +/** +* This function try to attempt to communicate with the IC for the first time during the boot up process in order to acquire the necessary info for the following stages. +* The function execute a system reset, read fundamental info (system info) from the IC and install the interrupt +* @return OK if success or an error code which specify the type of error encountered +*/ +static int fts_init(struct fts_ts_info *info) +{ + int error; + + error = fts_system_reset(); + if (error < OK && isI2cError(error)) { + logError(1, "%s Cannot reset the device! ERROR %08X\n", tag, + error); + return error; + } else { + if (error == (ERROR_TIMEOUT | ERROR_SYSTEM_RESET_FAIL)) { + logError(1, "%s Setting default Sys INFO! \n", tag); + error = defaultSysInfo(0); + } else { + error = readSysInfo(0); + if (error < OK) { + if (!isI2cError(error)) + error = OK; + logError(1, + "%s Cannot read Sys Info! ERROR %08X\n", + tag, error); + } + } + } + + return error; +} + +/** +* Execute a power cycle in the IC, toggling the power lines (AVDD and DVDD) +* @param info pointer to fts_ts_info struct which contain information of the regulators +* @return 0 if success or another value if fail +*/ +int fts_chip_powercycle(struct fts_ts_info *info) +{ + int error = 0; + + logError(1, "%s %s: Power Cycle Starting... \n", tag, __func__); + logError(1, "%s %s: Disabling IRQ... \n", tag, __func__); + + fts_disableInterruptNoSync(); + + if (info->vdd_reg) { + error = regulator_disable(info->vdd_reg); + if (error < 0) { + logError(1, "%s %s: Failed to disable DVDD regulator\n", + tag, __func__); + } + } + + if (info->avdd_reg) { + error = regulator_disable(info->avdd_reg); + if (error < 0) { + logError(1, "%s %s: Failed to disable AVDD regulator\n", + tag, __func__); + } + } + + if (info->board->reset_gpio != GPIO_NOT_DEFINED) + gpio_set_value(info->board->reset_gpio, 0); + else + mdelay(300); + + if (info->vdd_reg) { + error = regulator_enable(info->vdd_reg); + if (error < 0) { + logError(1, "%s %s: Failed to enable DVDD regulator\n", + tag, __func__); + } + } + + mdelay(1); + + if (info->avdd_reg) { + error = regulator_enable(info->avdd_reg); + if (error < 0) { + logError(1, "%s %s: Failed to enable AVDD regulator\n", + tag, __func__); + } + } + + mdelay(5); + + if (info->board->reset_gpio != GPIO_NOT_DEFINED) { + mdelay(10); + gpio_set_value(info->board->reset_gpio, 1); + } + + release_all_touches(info); + + logError(1, "%s %s: Power Cycle Finished! ERROR CODE = %08x\n", tag, + __func__, error); + setSystemResetedUp(1); + setSystemResetedDown(1); + return error; +} + +/** + * Complete the boot up process, initializing the sensing of the IC according to the current setting chosen by the host and register the notifier for the suspend/resume actions and the event handler + * @return OK if success or an error code which specify the type of error encountered + */ +static int fts_init_sensing(struct fts_ts_info *info) +{ + int error = 0; +/* +#ifdef CONFIG_DRM + error |= msm_drm_register_client(&info->notifier); +#endif +*/ + error |= fts_interrupt_install(info); + error |= fts_mode_handler(info, 0); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + error |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + error |= setScanMode(SCAN_MODE_ACTIVE, 0x01); +#endif + error |= fts_enableInterrupt(); + + if (error < OK) + logError(1, "%s %s Init after Probe error (ERROR = %08X)\n", + tag, __func__, error); + + return error; +} + +/** + * @ingroup mode_section + * @{ + */ +/** + * The function handle the switching of the mode in the IC enabling/disabling the sensing and the features set from the host + * @param info pointer to fts_ts_info which contains info about the device and its hw setup + * @param force if 1, the enabling/disabling command will be send even if the feature was alredy enabled/disabled otherwise it will judge if the feature changed status or the IC had s system reset and therefore the features need to be restored + * @return OK if success or an error code which specify the type of error encountered + */ +static int fts_mode_handler(struct fts_ts_info *info, int force) +{ + int res = OK; + int ret = OK; + u8 settings[4] = { 0 }; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + u8 gesture_cmd[6] = {0xA2, 0x03, 0x20, 0x00, 0x00, 0x01}; + u8 single_only_cmd[4] = {0xC0, 0x02, 0x00, 0x00}; + u8 single_double_cmd[4] = {0xC0, 0x02, 0x01, 0x1E}; +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT + mutex_lock(&info->fod_mutex); +#endif + info->mode = MODE_NOTHING; + logError(0, "%s %s: Mode Handler starting... \n", tag, __func__); + switch (info->resume_bit) { + case 0: + logError(0, "%s %s: Screen OFF... \n", tag, __func__); + +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (info->fod_status) { + logError(1, "%s %s: Sense OFF by FOD \n", tag, __func__); + logError(1, "%s %s,send long press and gesture cmd\n", tag, __func__); + res = fts_write_dma_safe(gesture_cmd, ARRAY_SIZE(gesture_cmd)); + if (res < OK) + logError(1, "%s %s: enter gesture and longpress failed! ERROR %08X recovery in senseOff...\n", + tag, __func__, res); + res = setScanMode(SCAN_MODE_LOW_POWER, 0); + res |= ret; + if (info->gesture_enabled == 1) { + res = fts_write_dma_safe(single_double_cmd, ARRAY_SIZE(single_double_cmd)); + if (res < OK) + logError(1, "%s %s: set single and double tap delay time failed! ERROR %08X\n", tag, __func__, res); + } else { + res = fts_write_dma_safe(single_only_cmd, ARRAY_SIZE(single_only_cmd)); + if (res < OK) + logError(1, "%s %s: set single only delay time failed! ERROR %08X\n", tag, __func__, res); + } + info->fod_status_set = true; + } else { +#endif + logError(1, "%s %s: Sense OFF! \n", tag, __func__); + ret = setScanMode(SCAN_MODE_ACTIVE, 0x00); + res |= ret; + + if (info->gesture_enabled == 1) { + logError(1, "%s %s: enter in gesture mode ! \n", tag, + __func__); + res = enterGestureMode(isSystemResettedDown()); + if (res >= OK) { + fromIDtoMask(FEAT_SEL_GESTURE, + (u8 *)&info->mode, + sizeof(info->mode)); + MODE_LOW_POWER(info->mode, 0); + } else { + logError(1, + "%s %s: enterGestureMode failed! ERROR %08X recovery in senseOff...\n", + tag, __func__, res); + } + } + info->fod_status_set = false; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + } +#endif + setSystemResetedDown(0); + break; + + case 1: + logError(1, "%s %s: Screen ON... \n", tag, __func__); + +#ifdef GLOVE_MODE + if ((info->glove_enabled == FEAT_ENABLE && isSystemResettedUp()) + || force == 1) { + logError(0, "%s %s: Glove Mode setting... \n", tag, + __func__); + settings[0] = info->glove_enabled; + ret = setFeatures(FEAT_SEL_GLOVE, settings, 1); + if (ret < OK) { + logError(1, + "%s %s: error during setting GLOVE_MODE! ERROR %08X\n", + tag, __func__, ret); + } + res |= ret; + + if (ret >= OK && info->glove_enabled == FEAT_ENABLE) { + fromIDtoMask(FEAT_SEL_GLOVE, + (u8 *)&info->mode, + sizeof(info->mode)); + logError(1, "%s %s: GLOVE_MODE Enabled! \n", + tag, __func__); + } else { + logError(1, "%s %s: GLOVE_MODE Disabled! \n", + tag, __func__); + } + + } +#endif + +#ifdef COVER_MODE + if ((info->cover_enabled == FEAT_ENABLE && isSystemResettedUp()) + || force == 1) { + logError(0, "%s %s: Cover Mode setting... \n", tag, + __func__); + settings[0] = info->cover_enabled; + ret = setFeatures(FEAT_SEL_COVER, settings, 1); + if (ret < OK) { + logError(1, + "%s %s: error during setting COVER_MODE! ERROR %08X\n", + tag, __func__, ret); + } + res |= ret; + + if (ret >= OK && info->cover_enabled == FEAT_ENABLE) { + fromIDtoMask(FEAT_SEL_COVER, + (u8 *)&info->mode, + sizeof(info->mode)); + logError(1, "%s %s: COVER_MODE Enabled! \n", + tag, __func__); + } else { + logError(1, "%s %s: COVER_MODE Disabled! \n", + tag, __func__); + } + + } +#endif +#ifdef CHARGER_MODE + if ((info->charger_enabled > 0 && isSystemResettedUp()) + || force == 1) { + logError(0, "%s %s: Charger Mode setting... \n", tag, + __func__); + + settings[0] = info->charger_enabled; + ret = setFeatures(FEAT_SEL_CHARGER, settings, 1); + if (ret < OK) { + logError(1, + "%s %s: error during setting CHARGER_MODE! ERROR %08X\n", + tag, __func__, ret); + } + res |= ret; + + if (ret >= OK && info->charger_enabled == FEAT_ENABLE) { + fromIDtoMask(FEAT_SEL_CHARGER, + (u8 *)&info->mode, + sizeof(info->mode)); + logError(1, "%s %s: CHARGER_MODE Enabled! \n", + tag, __func__); + } else { + logError(1, "%s %s: CHARGER_MODE Disabled! \n", + tag, __func__); + } + + } +#endif + +#ifdef GRIP_MODE + if ((info->grip_enabled == FEAT_ENABLE && isSystemResettedUp()) + || force == 1) { + logError(0, "%s %s: Grip Mode setting... \n", tag, + __func__); + settings[0] = info->grip_enabled; + ret = setFeatures(FEAT_SEL_GRIP, settings, 1); + if (ret < OK) { + logError(1, + "%s %s: error during setting GRIP_MODE! ERROR %08X\n", + tag, __func__, ret); + } + res |= ret; + + if (ret >= OK && info->grip_enabled == FEAT_ENABLE) { + fromIDtoMask(FEAT_SEL_GRIP, (u8 *)&info->mode, + sizeof(info->mode)); + logError(1, "%s %s: GRIP_MODE Enabled! \n", tag, + __func__); + } else { + logError(1, "%s %s: GRIP_MODE Disabled! \n", + tag, __func__); + } + + } +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (info->fod_pressed) { + logError(1, "%s %s: Sense OFF \n", tag, __func__); + res |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + logError(1, "%s %s: Sense ON without cal \n", tag, __func__); + res |= setScanMode(SCAN_MODE_ACTIVE, 0x20); + } else { + logError(1, "%s %s: Sense ON\n", tag, __func__); + res |= setScanMode(SCAN_MODE_ACTIVE, 0x01); + } + info->sensor_scan = true; + if (info->fod_status) { + res = fts_write_dma_safe(gesture_cmd, ARRAY_SIZE(gesture_cmd)); + if (res < OK) + logError(1, "%s %s: enter gesture and longpress failed! ERROR %08X recovery in senseOff...\n", + tag, __func__, res); + info->fod_status_set = true; + } +#else + settings[0] = 0x01; + logError(1, "%s %s: Sense ON! \n", tag, __func__); + res |= setScanMode(SCAN_MODE_ACTIVE, settings[0]); + info->mode |= (SCAN_MODE_ACTIVE << 24); + MODE_ACTIVE(info->mode, settings[0]); +#endif + setSystemResetedUp(0); + break; + + default: + logError(1, + "%s %s: invalid resume_bit value = %d! ERROR %08X \n", + tag, __func__, info->resume_bit, ERROR_OP_NOT_ALLOW); + res = ERROR_OP_NOT_ALLOW; + } + + logError(0, "%s %s: Mode Handler finished! res = %08X mode = %08X \n", + tag, __func__, res, info->mode); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + mutex_unlock(&info->fod_mutex); +#endif + return res; + +} + +static void fts_mode_handler_work(struct work_struct *work) +{ + struct fts_ts_info *info; + + info = container_of(work, struct fts_ts_info, mode_handler_work); + + fts_mode_handler(info, 0); +} + +/** + * Resume work function which perform a system reset, clean all the touches from the linux input system and prepare the ground for enabling the sensing + */ +static void fts_resume_work(struct work_struct *work) +{ + struct fts_ts_info *info; + + info = container_of(work, struct fts_ts_info, resume_work); + fts_disableInterrupt(); +#ifdef CONFIG_SECURE_TOUCH + fts_secure_stop(info, true); +#endif + info->resume_bit = 1; +#ifdef CONFIG_FTS_FOD_AREA_REPORT + if (!info->fod_pressed) { +#endif + fts_system_reset(); + release_all_touches(info); +#ifdef CONFIG_FTS_FOD_AREA_REPORT + } +#endif + info->fod_status_set = false; + fts_mode_handler(info, 0); + info->sensor_sleep = false; + info->sleep_finger = 0; + + fts_enableInterrupt(); +} + +/** + * Suspend work function which clean all the touches from Linux input system and prepare the ground to disabling the sensing or enter in gesture mode + */ +static void fts_suspend_work(struct work_struct *work) +{ + struct fts_ts_info *info; + + info = container_of(work, struct fts_ts_info, suspend_work); +#ifdef CONFIG_SECURE_TOUCH + fts_secure_stop(info, true); +#endif + fts_disableInterrupt(); + info->resume_bit = 0; + fts_mode_handler(info, 0); + release_all_touches(info); + + info->sensor_sleep = true; + + if (info->gesture_enabled || info->fod_status) + fts_enableInterrupt(); +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + sysfs_notify(&fts_info->fts_touch_dev->kobj, NULL, + "touch_suspend_notify"); +#endif +} +/* +#ifdef CONFIG_DRM + + * Callback function used to detect the suspend/resume events generated by clicking the power button. + * This function schedule a suspend or resume work according to the event received. + +static int fts_drm_state_chg_callback(struct notifier_block *nb, + unsigned long val, void *data) +{ + struct fts_ts_info *info = + container_of(nb, struct fts_ts_info, notifier); + struct msm_drm_notifier *evdata = data; + unsigned int blank; + + logError(0, "%s %s: fts notifier begin!\n", tag, __func__); + + if (evdata && evdata->data && info) { + + blank = *(int *)(evdata->data); + logError(1, "%s %s: val:%lu,blank:%u\n", tag, __func__, val, blank); + + if (val == MSM_DRM_EARLY_EVENT_BLANK && (blank == MSM_DRM_BLANK_POWERDOWN || + blank == MSM_DRM_BLANK_LP)) { + if (info->sensor_sleep) + return NOTIFY_OK; + + logError(1, "%s %s: FB_BLANK %s\n", tag, + __func__, blank == MSM_DRM_BLANK_POWERDOWN ? "POWER DOWN" : "LP"); + + flush_workqueue(info->event_wq); + queue_work(info->event_wq, &info->suspend_work); + } else if (val == MSM_DRM_EVENT_BLANK && blank == MSM_DRM_BLANK_UNBLANK) { + if (!info->sensor_sleep) + return NOTIFY_OK; + + logError(1, "%s %s: FB_BLANK_UNBLANK\n", tag, + __func__); + + flush_workqueue(info->event_wq); + queue_work(info->event_wq, &info->resume_work); + } + } + return NOTIFY_OK; +} + +static struct notifier_block fts_noti_block = { + .notifier_call = fts_drm_state_chg_callback, +}; +#endif +*/ +/** + * From the name of the power regulator get/put the actual regulator structs (copying their references into fts_ts_info variable) + * @param info pointer to fts_ts_info which contains info about the device and its hw setup + * @param get if 1, the regulators are get otherwise they are put (released) back to the system + * @return OK if success or an error code which specify the type of error encountered + */ +static int fts_get_reg(struct fts_ts_info *info, bool get) +{ + int retval; + const struct fts_hw_platform_data *bdata = info->board; + + if (!get) { + retval = 0; + goto regulator_put; + } + + if ((bdata->vdd_reg_name != NULL) && (*bdata->vdd_reg_name != 0)) { + info->vdd_reg = regulator_get(info->dev, bdata->vdd_reg_name); + if (IS_ERR(info->vdd_reg)) { + logError(1, "%s %s: Failed to get power regulator\n", + tag, __func__); + retval = PTR_ERR(info->vdd_reg); + goto regulator_put; + } + } + + if ((bdata->avdd_reg_name != NULL) && (*bdata->avdd_reg_name != 0)) { + info->avdd_reg = regulator_get(info->dev, bdata->avdd_reg_name); + if (IS_ERR(info->avdd_reg)) { + logError(1, + "%s %s: Failed to get bus pullup regulator\n", + tag, __func__); + retval = PTR_ERR(info->avdd_reg); + goto regulator_put; + } + } + + return OK; + +regulator_put: + if (info->vdd_reg) { + regulator_put(info->vdd_reg); + info->vdd_reg = NULL; + } + + if (info->avdd_reg) { + regulator_put(info->avdd_reg); + info->avdd_reg = NULL; + } + + return retval; +} + +/** + * Enable or disable the power regulators + * @param info pointer to fts_ts_info which contains info about the device and its hw setup + * @param enable if 1, the power regulators are turned on otherwise they are turned off + * @return OK if success or an error code which specify the type of error encountered + */ +static int fts_enable_reg(struct fts_ts_info *info, bool enable) +{ + int retval; + + if (!enable) { + retval = 0; + goto disable_pwr_reg; + } + + if (info->vdd_reg) { + retval = regulator_enable(info->vdd_reg); + if (retval < 0) { + logError(1, "%s %s: Failed to enable bus regulator\n", + tag, __func__); + goto exit; + } + } + + if (info->avdd_reg) { + retval = regulator_enable(info->avdd_reg); + if (retval < 0) { + logError(1, "%s %s: Failed to enable power regulator\n", + tag, __func__); + goto disable_bus_reg; + } + } + + return OK; + +disable_pwr_reg: + if (info->avdd_reg) + regulator_disable(info->vdd_reg); + +disable_bus_reg: + if (info->vdd_reg) + regulator_disable(info->avdd_reg); + +exit: + return retval; +} + +/** + * Configure a GPIO according to the parameters + * @param gpio gpio number + * @param config if true, the gpio is set up otherwise it is free + * @param dir direction of the gpio, 0 = in, 1 = out + * @param state initial value (if the direction is in, this parameter is ignored) + * return error code + */ +static int fts_gpio_setup(int gpio, bool config, int dir, int state) +{ + int retval = 0; + unsigned char buf[16]; + + if (config) { + snprintf(buf, 16, "fts_gpio_%u\n", gpio); + + retval = gpio_request(gpio, buf); + if (retval) { + logError(1, "%s %s: Failed to get gpio %d (code: %d)", + tag, __func__, gpio, retval); + return retval; + } + + if (dir == 0) + retval = gpio_direction_input(gpio); + else + retval = gpio_direction_output(gpio, state); + if (retval) { + logError(1, "%s %s: Failed to set gpio %d direction", + tag, __func__, gpio); + return retval; + } + } else { + gpio_free(gpio); + } + + return retval; +} + +/** + * Setup the IRQ and RESET (if present) gpios. + * If the Reset Gpio is present it will perform a cycle HIGH-LOW-HIGH in order to assure that the IC has been reset properly + */ +static int fts_set_gpio(struct fts_ts_info *info) +{ + int retval; + struct fts_hw_platform_data *bdata = info->board; + + retval = fts_gpio_setup(bdata->irq_gpio, true, 0, 0); + if (retval < 0) { + logError(1, "%s %s: Failed to configure irq GPIO\n", tag, + __func__); + goto err_gpio_irq; + } + + if (bdata->reset_gpio >= 0) { + retval = fts_gpio_setup(bdata->reset_gpio, true, 1, 0); + if (retval < 0) { + logError(1, "%s %s: Failed to configure reset GPIO\n", + tag, __func__); + goto err_gpio_reset; + } + } + if (bdata->reset_gpio >= 0) { + gpio_set_value(bdata->reset_gpio, 0); + mdelay(10); + gpio_set_value(bdata->reset_gpio, 1); + } + + return OK; + +err_gpio_reset: + fts_gpio_setup(bdata->irq_gpio, false, 0, 0); + bdata->reset_gpio = GPIO_NOT_DEFINED; +err_gpio_irq: + return retval; +} + +static int fts_pinctrl_init(struct fts_ts_info *info) +{ + int retval = 0; + /* Get pinctrl if target uses pinctrl */ + info->ts_pinctrl = devm_pinctrl_get(info->dev); + + if (IS_ERR_OR_NULL(info->ts_pinctrl)) { + retval = PTR_ERR(info->ts_pinctrl); + dev_err(info->dev, "Target does not use pinctrl %d\n", retval); + goto err_pinctrl_get; + } + + info->pinctrl_state_active + = pinctrl_lookup_state(info->ts_pinctrl, PINCTRL_STATE_ACTIVE); + + if (IS_ERR_OR_NULL(info->pinctrl_state_active)) { + retval = PTR_ERR(info->pinctrl_state_active); + dev_err(info->dev, "Can not lookup %s pinstate %d\n", + PINCTRL_STATE_ACTIVE, retval); + goto err_pinctrl_lookup; + } + + info->pinctrl_state_suspend + = pinctrl_lookup_state(info->ts_pinctrl, PINCTRL_STATE_SUSPEND); + + if (IS_ERR_OR_NULL(info->pinctrl_state_suspend)) { + retval = PTR_ERR(info->pinctrl_state_suspend); + dev_dbg(info->dev, "Can not lookup %s pinstate %d\n", + PINCTRL_STATE_SUSPEND, retval); + goto err_pinctrl_lookup; + } + + return 0; +err_pinctrl_lookup: + devm_pinctrl_put(info->ts_pinctrl); +err_pinctrl_get: + info->ts_pinctrl = NULL; + return retval; +} + +/** + * Retrieve and parse the hw information from the device tree node defined in the system. + * the most important information to obtain are: IRQ and RESET gpio numbers, power regulator names + * In the device file node is possible to define additional optional information that can be parsed here. + */ +static int parse_dt(struct device *dev, struct fts_hw_platform_data *bdata) +{ + int retval; + const char *name; + struct device_node *temp, *np = dev->of_node; + struct fts_config_info *config_info; + u32 temp_val; + + bdata->irq_gpio = of_get_named_gpio_flags(np, "fts,irq-gpio", 0, NULL); + + logError(0, "%s irq_gpio = %d\n", tag, bdata->irq_gpio); + + retval = of_property_read_string(np, "fts,pwr-reg-name", &name); + if (retval == -EINVAL) + bdata->vdd_reg_name = NULL; + else if (retval < 0) + return retval; + else { + bdata->vdd_reg_name = name; + logError(0, "%s pwr_reg_name = %s\n", tag, name); + } + + retval = of_property_read_string(np, "fts,bus-reg-name", &name); + if (retval == -EINVAL) + bdata->avdd_reg_name = NULL; + else if (retval < 0) + return retval; + else { + bdata->avdd_reg_name = name; + logError(0, "%s bus_reg_name = %s\n", tag, name); + } + + if (of_property_read_bool(np, "fts,reset-gpio-enable")) { + bdata->reset_gpio = of_get_named_gpio_flags(np, + "fts,reset-gpio", 0, + NULL); + logError(0, "%s reset_gpio =%d\n", tag, bdata->reset_gpio); + } else { + bdata->reset_gpio = GPIO_NOT_DEFINED; + } + + retval = of_property_read_u32(np, "fts,irq-flags", &temp_val); + if (retval < 0) + return retval; + else + bdata->irq_flags = temp_val; + retval = of_property_read_u32(np, "fts,x-max", &temp_val); + if (retval < 0) + bdata->x_max = X_AXIS_MAX; + else + bdata->x_max = temp_val; + + retval = of_property_read_u32(np, "fts,y-max", &temp_val); + if (retval < 0) + bdata->y_max = Y_AXIS_MAX; + else + bdata->y_max = temp_val; + retval = of_property_read_string(np, "fts,default-fw-name", + &bdata->default_fw_name); + +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + bdata->dump_click_count = + of_property_read_bool(np, "fts,dump-click-count"); +#endif + retval = + of_property_read_u32(np, "fts,config-array-size", + (u32 *)&bdata->config_array_size); + + if (retval) { + logError(1, "%s Unable to get array size\n", tag); + return retval; + } + + bdata->config_array = devm_kzalloc(dev, bdata->config_array_size * + sizeof(struct fts_config_info), + GFP_KERNEL); + + if (!bdata->config_array) { + logError(1, "%s Unable to allocate memory\n", tag); + return -ENOMEM; + } + + config_info = bdata->config_array; + for_each_child_of_node(np, temp) { + retval = of_property_read_u32(temp, "fts,tp-vendor", &temp_val); + + if (retval) { + logError(1, "%s Unable to read tp vendor\n", tag); + } else { + config_info->tp_vendor = (u8) temp_val; + logError(1, "%s %s:tp vendor: %u", tag, __func__, + config_info->tp_vendor); + } + retval = of_property_read_u32(temp, "fts,tp-color", &temp_val); + if (retval) { + logError(1, "%s Unable to read tp color\n", tag); + } else { + config_info->tp_color = (u8) temp_val; + logError(1, "%s %s:tp color: %u", tag, __func__, + config_info->tp_color); + } + + retval = + of_property_read_u32(temp, "fts,tp-hw-version", &temp_val); + + if (retval) { + logError(1, "%s Unable to read tp hw version\n", tag); + } else { + config_info->tp_hw_version = (u8) temp_val; + logError(1, "%s %s:tp color: %u", tag, __func__, + config_info->tp_hw_version); + } + + retval = of_property_read_string(temp, "fts,fw-name", + &config_info->fts_cfg_name); + + if (retval && (retval != -EINVAL)) { + logError(1, "%s Unable to read cfg name\n", tag); + } else { + logError(1, "%s %s:fw_name: %s", tag, __func__, + config_info->fts_cfg_name); + } + retval = of_property_read_string(temp, "fts,limit-name", + &config_info->fts_limit_name); + + if (retval && (retval != -EINVAL)) { + logError(1, "%s Unable to read limit name\n", tag); + } else { + logError(1, "%s %s:limit_name: %s", tag, __func__, + config_info->fts_limit_name); + } +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + if (bdata->dump_click_count) { + retval = + of_property_read_string(temp, + "fts,clicknum-file-name", + &config_info->clicknum_file_name); + if (retval && (retval != -EINVAL)) { + dev_err(dev, + "Unable to read click count file name\n"); + } else + dev_err(dev, "%s\n", + config_info->clicknum_file_name); + } +#endif + + config_info++; + } + return OK; +} + +static void fts_switch_mode_work(struct work_struct *work) +{ + struct fts_mode_switch *ms = + container_of(work, struct fts_mode_switch, switch_mode_work); + + struct fts_ts_info *info = ms->info; + unsigned char value = ms->mode; + static const char *fts_gesture_on = "01 20"; + char *gesture_result; + int size = 6 * 2 + 1; + char ch[16] = { 0x0, }; + + logError(1, "%s %s mode:%d\n", tag, __func__, value); + + if (value >= INPUT_EVENT_WAKUP_MODE_OFF + && value <= INPUT_EVENT_WAKUP_MODE_ON) { + info->gesture_enabled = value - INPUT_EVENT_WAKUP_MODE_OFF; + if (info->gesture_enabled) { + gesture_result = (u8 *) kzalloc(size, GFP_KERNEL); + if (gesture_result != NULL) { + fts_gesture_mask_store(info->dev, NULL, + fts_gesture_on, + strlen(fts_gesture_on)); + fts_gesture_mask_show(info->dev, NULL, + gesture_result); + if (strncmp + ("{ 00000000 }", gesture_result, size - 1)) + logError(1, + "%s %s:store gesture mask error\n", + tag, __func__); + kfree(gesture_result); + gesture_result = NULL; + } + } + snprintf(ch, sizeof(ch), "%s", + (value - + INPUT_EVENT_WAKUP_MODE_OFF) ? "enabled" : "disabled"); + } else if (value >= INPUT_EVENT_COVER_MODE_OFF + && value <= INPUT_EVENT_COVER_MODE_ON) { + info->glove_enabled = value - INPUT_EVENT_COVER_MODE_OFF; + fts_mode_handler(info, 1); + } +#ifdef EDGEHOVER_FOR_VOLUME + if (value >= INPUT_EVENT_SLIDE_FOR_VOLUME + && value <= INPUT_EVENT_LONG_SINGLE_TAP_FOR_VOLUME) { + info->volume_type = value; + if (fts_info->volume_type == INPUT_EVENT_SINGLE_TAP_FOR_VOLUME) { + fts_info->single_press_time_low = 30; + fts_info->single_press_time_hi = 800; + } else if (fts_info->volume_type == + INPUT_EVENT_LONG_SINGLE_TAP_FOR_VOLUME) { + fts_info->single_press_time_low = 300; + fts_info->single_press_time_hi = 800; + } + } +#endif +#ifdef PHONE_PALM + if (value >= INPUT_EVENT_PALM_OFF && value <= INPUT_EVENT_PALM_ON) + info->palm_enabled = value - INPUT_EVENT_PALM_OFF; +#endif + if (ms != NULL) { + kfree(ms); + ms = NULL; + } +} + +static ssize_t fts_input_symlink(struct fts_ts_info *info) { + char *driver_path; + int ret = 0; + + if (info->input_proc) { + proc_remove(info->input_proc); + info->input_proc = NULL; + } + + driver_path = kzalloc(PATH_MAX, GFP_KERNEL); + if (!driver_path) { + return -ENOMEM; + } + + sprintf(driver_path, "/sys%s", + kobject_get_path(&info->input_dev->dev.kobj, GFP_KERNEL)); + + pr_info("%s: driver_path=%s\n", __func__, driver_path); + info->input_proc = proc_symlink(PROC_SYMLINK_PATH, NULL, driver_path); + if (!info->input_proc) { + ret = -ENOMEM; + } + + kfree(driver_path); + + return ret; +} + +static int fts_input_event(struct input_dev *dev, unsigned int type, + unsigned int code, int value) +{ + struct fts_ts_info *info = input_get_drvdata(dev); + struct fts_mode_switch *ms; + + logError(1, "%s %s:set input event value = %d\n", tag, __func__, value); + + if (!info) { + printk("%s fts_ts_info is NULL\n", __func__); + return 0; + } + + if (type == EV_SYN && code == SYN_CONFIG) { + if (value >= INPUT_EVENT_START && value <= INPUT_EVENT_END) { + ms = (struct fts_mode_switch *) + kmalloc(sizeof(struct fts_mode_switch), GFP_ATOMIC); + + if (ms != NULL) { + ms->info = info; + ms->mode = (unsigned char)value; + INIT_WORK(&ms->switch_mode_work, + fts_switch_mode_work); + schedule_work(&ms->switch_mode_work); + } else { + logError(1, + "%s %s:failed in allocating memory for switching mode\n", + tag, __func__); + return -ENOMEM; + } + } else { + logError(1, "%s %s:Invalid event value\n", tag, + __func__); + return -EINVAL; + } + } + + return 0; +} + +static int fts_short_open_test(void) +{ + TestToDo selftests; + int res = -1; + int init_type = SPECIAL_PANEL_INIT; + + memset(&selftests, 0x00, sizeof(TestToDo)); + +/* Hover Test */ + selftests.SelfHoverForceRaw = 0; /* SS Hover Force Raw min/Max test */ + selftests.SelfHoverSenceRaw = 0; /* SS Hover Sence Raw min/Max test */ + selftests.SelfHoverForceIxTotal = 0; /* SS Hover Total Force Ix min/Max (for each node)* test */ + selftests.SelfHoverSenceIxTotal = 0; + + selftests.MutualRawAdjITO = 0; + selftests.MutualRaw = 0; + selftests.MutualRawEachNode = 1; + selftests.MutualRawGap = 0; + selftests.MutualRawAdj = 0; + selftests.MutualRawLP = 0; + selftests.MutualRawGapLP = 0; + selftests.MutualRawAdjLP = 0; + selftests.MutualCx1 = 0; + selftests.MutualCx2 = 0; + selftests.MutualCx2Adj = 0; + selftests.MutualCxTotal = 0; + selftests.MutualCxTotalAdj = 0; + selftests.MutualCx1LP = 0; + selftests.MutualCx2LP = 0; + selftests.MutualCx2AdjLP = 0; + selftests.MutualCxTotalLP = 0; + selftests.MutualCxTotalAdjLP = 0; +#ifdef PHONE_KEY + selftests.MutualKeyRaw = 0; +#else + selftests.MutualKeyRaw = 0; +#endif + selftests.MutualKeyCx1 = 0; + selftests.MutualKeyCx2 = 0; +#ifdef PHONE_KEY + selftests.MutualKeyCxTotal = 0; +#else + selftests.MutualKeyCxTotal = 0; +#endif + selftests.SelfForceRaw= 1; + selftests.SelfForceRawGap = 0; + selftests.SelfForceRawLP = 0; + selftests.SelfForceRawGapLP = 0; + selftests.SelfForceIx1 = 0; + selftests.SelfForceIx2 = 0; + selftests.SelfForceIx2Adj = 0; + selftests.SelfForceIxTotal = 0; + selftests.SelfForceIxTotalAdj = 0; + selftests.SelfForceCx1 = 0; + selftests.SelfForceCx2 = 0; + selftests.SelfForceCx2Adj = 0; + selftests.SelfForceCxTotal = 0; + selftests.SelfForceCxTotalAdj = 0; + selftests.SelfSenseRaw = 1; + selftests.SelfSenseRawGap = 0; + selftests.SelfSenseRawLP = 0; + selftests.SelfSenseRawGapLP = 0; + selftests.SelfSenseIx1 = 0; + selftests.SelfSenseIx2 = 0; + selftests.SelfSenseIx2Adj = 0; + selftests.SelfSenseIxTotal = 0; + selftests.SelfSenseIxTotalAdj = 0; + selftests.SelfSenseCx1 = 0; + selftests.SelfSenseCx2 = 0; + selftests.SelfSenseCx2Adj = 0; + selftests.SelfSenseCxTotal = 0; + selftests.SelfSenseCxTotalAdj = 0; + + res = fts_disableInterrupt(); + if (res < 0) { + logError(0, "%s fts_disableInterrupt: ERROR %08X \n", + tag, res); + res = (res | ERROR_DISABLE_INTER); + goto END; + } + res = production_test_main(LIMITS_FILE, 1, init_type, &selftests); +END: + fts_mode_handler(fts_info, 1); + fts_enableInterrupt(); + if (res == OK) + return FTS_RESULT_PASS; + else + return FTS_RESULT_FAIL; +} + +static int fts_i2c_test(void) +{ + int ret = 0; + u8 data[SYS_INFO_SIZE] = { 0 }; + + logError(0, "%s %s: Reading System Info...\n", tag, __func__); + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, ADDR_FRAMEBUFFER, + data, SYS_INFO_SIZE, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading the system data ERROR %08X\n", + tag, __func__, ret); + return FTS_RESULT_FAIL; + } + + return FTS_RESULT_PASS; +} + +static ssize_t fts_selftest_read(struct file *file, char __user *buf, + size_t count, loff_t *pos) +{ + char tmp[5] = { 0 }; + int cnt; + + if (*pos != 0) + return 0; + cnt = + snprintf(tmp, sizeof(fts_info->result_type), "%d\n", + fts_info->result_type); + if (copy_to_user(buf, tmp, strlen(tmp))) { + return -EFAULT; + } + *pos += cnt; + return cnt; +} + +static ssize_t fts_selftest_write(struct file *file, const char __user *buf, + size_t count, loff_t *pos) +{ + int retval = 0; + char tmp[6]; + + if (copy_from_user(tmp, buf, count)) { + retval = -EFAULT; + goto out; + } + + if (!strncmp("short", tmp, 5) || !strncmp("open", tmp, 4)) { + retval = fts_short_open_test(); + } else if (!strncmp("i2c", tmp, 3)) + retval = fts_i2c_test(); + + fts_info->result_type = retval; +out: + if (retval >= 0) + retval = count; + + return retval; +} + +static const struct proc_ops fts_selftest_ops = { + .proc_read = fts_selftest_read, + .proc_write = fts_selftest_write, +}; + +static ssize_t fts_datadump_read(struct file *file, char __user *buf, + size_t count, loff_t *pos) +{ + int ret = 0, cnt1 = 0, cnt2 = 0, cnt3 = 0; + char *tmp; + + if (*pos != 0) + return 0; + + tmp = vmalloc(PAGE_SIZE * 2); + if (tmp == NULL) + return 0; + else + memset(tmp, 0, PAGE_SIZE * 2); + + cnt1 = fts_strength_frame_show(fts_info->dev, NULL, tmp); + if (cnt1 == 0) { + ret = 0; + goto out; + } + + ret = stm_fts_cmd_store(fts_info->dev, NULL, "13", 2); + if (ret == 0) + goto out; + cnt2 = stm_fts_cmd_show(fts_info->dev, NULL, tmp + cnt1); + if (cnt2 == 0) { + ret = 0; + goto out; + } + + ret = stm_fts_cmd_store(fts_info->dev, NULL, "15", 2); + if (ret == 0) + goto out; + cnt3 = stm_fts_cmd_show(fts_info->dev, NULL, tmp + cnt1 + cnt2); + if (cnt3 == 0) { + ret = 0; + goto out; + } + + if (copy_to_user(buf, tmp, cnt1 + cnt2 + cnt3)) + ret = -EFAULT; + +out: + if (tmp) { + vfree(tmp); + tmp = NULL; + } + *pos += (cnt1 + cnt2 + cnt3); + if (ret <= 0) + return ret; + return cnt1 + cnt2 + cnt3; +} + +static const struct proc_ops fts_datadump_ops = { + .proc_read = fts_datadump_read, +}; + +#define TP_INFO_MAX_LENGTH 50 + +static ssize_t fts_fw_version_read(struct file *file, char __user *buf, + size_t count, loff_t *pos) +{ + int cnt = 0, ret = 0; + char tmp[TP_INFO_MAX_LENGTH]; + + if (*pos != 0) + return 0; + + cnt = + snprintf(tmp, TP_INFO_MAX_LENGTH, "%x.%x\n", systemInfo.u16_fwVer, + systemInfo.u16_cfgVer); + ret = copy_to_user(buf, tmp, cnt); + *pos += cnt; + if (ret != 0) + return 0; + else + return cnt; +} + +static const struct proc_ops fts_fw_version_ops = { + .proc_read = fts_fw_version_read, +}; + +static ssize_t fts_lockdown_info_read(struct file *file, char __user *buf, + size_t count, loff_t *pos) +{ + int cnt = 0, ret = 0; + char tmp[TP_INFO_MAX_LENGTH]; + + if (*pos != 0) + return 0; + + ret = fts_get_lockdown_info(fts_info->lockdown_info, fts_info); + if (ret != OK) { + logError(1, "%s %s get lockdown info error\n", tag, __func__); + goto out; + } + + cnt = + snprintf(tmp, TP_INFO_MAX_LENGTH, + "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x\n", + fts_info->lockdown_info[0], fts_info->lockdown_info[1], + fts_info->lockdown_info[2], fts_info->lockdown_info[3], + fts_info->lockdown_info[4], fts_info->lockdown_info[5], + fts_info->lockdown_info[6], fts_info->lockdown_info[7]); + ret = copy_to_user(buf, tmp, cnt); +out: + *pos += cnt; + if (ret != 0) + return 0; + else + return cnt; +} + +static const struct proc_ops fts_lockdown_info_ops = { + .proc_read = fts_lockdown_info_read, +}; + +#ifdef CONFIG_PM +static int fts_pm_suspend(struct device *dev) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + +#ifndef CONFIG_FTS_FOD_AREA_REPORT + if (device_may_wakeup(dev) && info->gesture_enabled) { + logError(1, "%s enable touch irq wake\n", tag); + enable_irq_wake(info->client->irq); + } +#else + enable_irq_wake(info->client->irq); +#endif + info->tp_pm_suspend = true; + reinit_completion(&info->pm_resume_completion); + + return 0; + +} + +static int fts_pm_resume(struct device *dev) +{ + struct fts_ts_info *info = dev_get_drvdata(dev); + +#ifndef CONFIG_FTS_FOD_AREA_REPORT + if (device_may_wakeup(dev) && info->gesture_enabled) { + logError(1, "%s disable touch irq wake\n", tag); + disable_irq_wake(info->client->irq); + } +#else + disable_irq_wake(info->client->irq); +#endif + info->tp_pm_suspend = false; + complete(&info->pm_resume_completion); + + return 0; +} + +static const struct dev_pm_ops fts_dev_pm_ops = { + .suspend = fts_pm_suspend, + .resume = fts_pm_resume, +}; +#endif + +#ifdef CONFIG_TOUCHSCREEN_ST_DEBUG_FS +static void tpdbg_shutdown(struct fts_ts_info *info, bool sleep) +{ + u8 settings[4] = { 0 }; + info->mode = MODE_NOTHING; + + if (sleep) { + logError(0, "%s %s: Sense OFF! \n", tag, __func__); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + } else { + settings[0] = 0x01; + logError(0, "%s %s: Sense ON! \n", tag, __func__); + setScanMode(SCAN_MODE_ACTIVE, settings[0]); + info->mode |= (SCAN_MODE_ACTIVE << 24); + MODE_ACTIVE(info->mode, settings[0]); + } +} + +static void tpdbg_suspend(struct fts_ts_info *info, bool enable) +{ + if (enable) + queue_work(info->event_wq, &info->suspend_work); + else + queue_work(info->event_wq, &info->resume_work); +} + +static int tpdbg_open(struct inode *inode, struct file *file) +{ + file->private_data = inode->i_private; + + return 0; +} + +static ssize_t tpdbg_read(struct file *file, char __user *buf, size_t size, + loff_t *ppos) +{ + const char *str = "cmd support as below:\n \ + \necho \"irq-disable\" or \"irq-enable\" to ctrl irq\n \ + \necho \"tp-sd-en\" of \"tp-sd-off\" to ctrl panel in or off sleep mode\n \ + \necho \"tp-suspend-en\" or \"tp-suspend-off\" to ctrl panel in or off suspend status\n"; + + loff_t pos = *ppos; + int len = strlen(str); + + if (pos < 0) + return -EINVAL; + if (pos >= len) + return 0; + + if (copy_to_user(buf, str, len)) + return -EFAULT; + + *ppos = pos + len; + + return len; +} + +static ssize_t tpdbg_write(struct file *file, const char __user *buf, + size_t size, loff_t *ppos) +{ + struct fts_ts_info *info = file->private_data; + char *cmd = kzalloc(size + 1, GFP_KERNEL); + int ret = size; + + if (!cmd) + return -ENOMEM; + + if (copy_from_user(cmd, buf, size)) { + ret = -EFAULT; + goto out; + } + + cmd[size] = '\0'; + + if (!strncmp(cmd, "irq-disable", 11)) + disable_irq(info->client->irq); + else if (!strncmp(cmd, "irq-enable", 10)) + enable_irq(info->client->irq); + else if (!strncmp(cmd, "tp-sd-en", 8)) + tpdbg_shutdown(info, true); + else if (!strncmp(cmd, "tp-sd-off", 9)) + tpdbg_shutdown(info, false); + else if (!strncmp(cmd, "tp-suspend-en", 13)) + tpdbg_suspend(info, true); + else if (!strncmp(cmd, "tp-suspend-off", 14)) + tpdbg_suspend(info, false); +out: + kfree(cmd); + + return ret; +} + +static int tpdbg_release(struct inode *inode, struct file *file) +{ + file->private_data = NULL; + + return 0; +} + +static const struct file_operations tpdbg_operations = { + .owner = THIS_MODULE, + .open = tpdbg_open, + .read = tpdbg_read, + .write = tpdbg_write, + .release = tpdbg_release, +}; +#endif + +#ifdef CONFIG_SECURE_TOUCH +int fts_secure_init(struct fts_ts_info *info) +{ + int ret; + struct fts_secure_info *scr_info = kmalloc(sizeof(*scr_info), GFP_KERNEL); + if (!scr_info) { + logError(1, "%s %s alloc fts_secure_info failed\n", tag, __func__); + return -ENOMEM; + } + + logError(1, "%s fts_secure_init\n", tag); + + mutex_init(&scr_info->palm_lock); + + init_completion(&scr_info->st_powerdown); + init_completion(&scr_info->st_irq_processed); + + atomic_set(&scr_info->st_enabled, 0); + atomic_set(&scr_info->st_pending_irqs, 0); + + info->secure_info = scr_info; + + ret = sysfs_create_file(&info->dev->kobj, &dev_attr_secure_touch_enable.attr); + if (ret < 0) { + logError(1, "%s %s create sysfs attribute secure_touch_enable failed\n", tag, __func__); + goto err; + } + + ret = sysfs_create_file(&info->dev->kobj, &dev_attr_secure_touch.attr); + if (ret < 0) { + logError(1, "%s %s create sysfs attribute secure_touch failed\n", tag, __func__); + goto err; + } + + scr_info->fts_info = info; + scr_info->secure_inited = true; + + return 0; + +err: + kfree(scr_info); + info->secure_info = NULL; + return ret; +} + +void fts_secure_remove(struct fts_ts_info *info) +{ + struct fts_secure_info *scr_info = info->secure_info; + + sysfs_remove_file(&info->dev->kobj, &dev_attr_secure_touch_enable.attr); + sysfs_remove_file(&info->dev->kobj, &dev_attr_secure_touch.attr); + kfree(scr_info); +} + +#endif + + +/** + * Probe function, called when the driver it is matched with a device with the same name compatible name + * This function allocate, initialize and define all the most important function and flow that are used by the driver to operate with the IC. + * It allocates device variables, initialize queues and schedule works, registers the IRQ handler, suspend/resume callbacks, registers the device to the linux input subsystem etc. + */ +#ifdef I2C_INTERFACE +static int fts_probe(struct i2c_client *client) +{ +#else +static int fts_probe(struct spi_device *client) +{ +#endif + + struct fts_ts_info *info = NULL; + int error = 0; + struct device_node *dp = client->dev.of_node; + int retval; + int skip_5_1 = 0; + u16 bus_type; + u8 *tp_maker; + + logError(1, "%s %s: driver ver: %s\n", tag, __func__, + FTS_TS_DRV_VERSION); + +#ifdef I2C_INTERFACE + logError(0, "%s I2C interface... \n", tag); + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { + logError(1, "%s Unsupported I2C functionality\n", tag); + error = -EIO; + goto ProbeErrorExit_0; + } + + logError(0, "%s i2c address: %x \n", tag, client->addr); + bus_type = BUS_I2C; +#else + logError(0, "%s SPI interface... \n", tag); + client->mode = SPI_MODE_0; +#ifndef SPI4_WIRE + client->mode |= SPI_3WIRE; +#endif + client->max_speed_hz = SPI_CLOCK_FREQ; + client->bits_per_word = 8; + if (spi_setup(client) < 0) { + logError(1, "%s Unsupported SPI functionality\n", tag); + error = -EIO; + goto ProbeErrorExit_0; + } + bus_type = BUS_SPI; +#endif + + logError(0, "%s SET Device driver INFO: \n", tag); + + info = kzalloc(sizeof(struct fts_ts_info), GFP_KERNEL); + if (!info) { + logError(1, + "%s Out of memory... Impossible to allocate struct info!\n", + tag); + error = -ENOMEM; + goto ProbeErrorExit_0; + } + + fts_info = info; + info->client = client; + info->dev = &info->client->dev; + dev_set_drvdata(info->dev, info); + + if (dp) { + info->board = + devm_kzalloc(&client->dev, + sizeof(struct fts_hw_platform_data), + GFP_KERNEL); + if (!info->board) { + logError(1, "%s ERROR:info.board kzalloc failed \n", + tag); + error = -ENOMEM; + goto ProbeErrorExit_1; + } + parse_dt(&client->dev, info->board); + } + + logError(0, "%s SET Regulators: \n", tag); + retval = fts_get_reg(info, true); + if (retval < 0) { + logError(1, "%s ERROR: %s: Failed to get regulators\n", tag, + __func__); + error = retval; + goto ProbeErrorExit_1; + } + + retval = fts_enable_reg(info, true); + if (retval < 0) { + logError(1, "%s %s: ERROR Failed to enable regulators\n", tag, + __func__); + error = retval; + goto ProbeErrorExit_2; + } + + logError(0, "%s SET GPIOS: \n", tag); + retval = fts_set_gpio(info); + if (retval < 0) { + logError(1, "%s %s: ERROR Failed to set up GPIO's\n", tag, + __func__); + error = retval; + goto ProbeErrorExit_2; + } + + error = fts_pinctrl_init(info); + + if (!error && info->ts_pinctrl) { + error = + pinctrl_select_state(info->ts_pinctrl, + info->pinctrl_state_active); + + if (error < 0) { + dev_err(&client->dev, + "%s: Failed to select %s pinstate %d\n", + __func__, PINCTRL_STATE_ACTIVE, error); + } + } else { + dev_err(&client->dev, "%s: Failed to init pinctrl\n", __func__); + } + + info->client->irq = gpio_to_irq(info->board->irq_gpio); + + logError(0, "%s SET Event Handler: \n", tag); + + info->event_wq = + alloc_workqueue("fts-event-queue", + WQ_UNBOUND | WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1); + if (!info->event_wq) { + logError(1, "%s ERROR: Cannot create work thread\n", tag); + error = -ENOMEM; + goto ProbeErrorExit_4; + } + + info->irq_wq = + alloc_workqueue("fts-irq-queue", + WQ_UNBOUND | WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1); + if (!info->irq_wq) { + logError(1, "%s ERROR: Cannot create irq work thread\n", tag); + error = -ENOMEM; + goto ProbeErrorExit_4; + } + + INIT_WORK(&info->resume_work, fts_resume_work); + INIT_WORK(&info->suspend_work, fts_suspend_work); + INIT_WORK(&info->sleep_work, fts_ts_sleep_work); + INIT_WORK(&info->mode_handler_work, fts_mode_handler_work); + init_completion(&info->tp_reset_completion); + logError(0, "%s SET Input Device Property: \n", tag); + info->dev = &info->client->dev; + info->input_dev = input_allocate_device(); + if (!info->input_dev) { + logError(1, "%s ERROR: No such input device defined! \n", tag); + error = -ENODEV; + goto ProbeErrorExit_5; + } + info->input_dev->dev.parent = &client->dev; + info->input_dev->name = FTS_TS_DRV_NAME; + snprintf(fts_ts_phys, sizeof(fts_ts_phys), "%s/input0", + info->input_dev->name); + info->input_dev->phys = fts_ts_phys; + info->input_dev->id.bustype = bus_type; + info->input_dev->id.vendor = 0x0001; + info->input_dev->id.product = 0x0002; + info->input_dev->id.version = 0x0100; + info->input_dev->event = fts_input_event; + input_set_drvdata(info->input_dev, info); + + info->input_proc = NULL; + + __set_bit(EV_SYN, info->input_dev->evbit); + __set_bit(EV_KEY, info->input_dev->evbit); + __set_bit(EV_ABS, info->input_dev->evbit); + __set_bit(BTN_TOUCH, info->input_dev->keybit); + __set_bit(BTN_TOOL_FINGER, info->input_dev->keybit); + /*__set_bit(BTN_TOOL_PEN, info->input_dev->keybit);*/ + + input_mt_init_slots(info->input_dev, TOUCH_ID_MAX, INPUT_MT_DIRECT); + + /*input_mt_init_slots(info->input_dev, TOUCH_ID_MAX); */ + + input_set_abs_params(info->input_dev, ABS_MT_POSITION_X, X_AXIS_MIN, + info->board->x_max - 1, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_POSITION_Y, Y_AXIS_MIN, + info->board->y_max - 1, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_TOUCH_MAJOR, AREA_MIN, + AREA_MAX, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_TOUCH_MINOR, AREA_MIN, + AREA_MAX, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_WIDTH_MINOR, AREA_MIN, + AREA_MAX, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_WIDTH_MAJOR, AREA_MIN, + AREA_MAX, 0, 0); + +#ifdef CONFIG_FTS_FOD_AREA_REPORT + /*input_set_abs_params(info->input_dev, ABS_MT_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0);*/ +#endif + input_set_abs_params(info->input_dev, ABS_MT_DISTANCE, DISTANCE_MIN, + DISTANCE_MAX, 0, 0); + +#ifdef GESTURE_MODE + input_set_capability(info->input_dev, EV_KEY, KEY_WAKEUP); + + input_set_capability(info->input_dev, EV_KEY, KEY_M); + input_set_capability(info->input_dev, EV_KEY, KEY_O); + input_set_capability(info->input_dev, EV_KEY, KEY_E); + input_set_capability(info->input_dev, EV_KEY, KEY_W); + input_set_capability(info->input_dev, EV_KEY, KEY_C); + input_set_capability(info->input_dev, EV_KEY, KEY_L); + input_set_capability(info->input_dev, EV_KEY, KEY_F); + input_set_capability(info->input_dev, EV_KEY, KEY_V); + input_set_capability(info->input_dev, EV_KEY, KEY_S); + input_set_capability(info->input_dev, EV_KEY, KEY_Z); + input_set_capability(info->input_dev, EV_KEY, KEY_WWW); + + input_set_capability(info->input_dev, EV_KEY, KEY_LEFT); + input_set_capability(info->input_dev, EV_KEY, KEY_RIGHT); + input_set_capability(info->input_dev, EV_KEY, KEY_UP); + input_set_capability(info->input_dev, EV_KEY, KEY_DOWN); + + input_set_capability(info->input_dev, EV_KEY, KEY_F1); + input_set_capability(info->input_dev, EV_KEY, KEY_F2); + input_set_capability(info->input_dev, EV_KEY, KEY_F3); + input_set_capability(info->input_dev, EV_KEY, KEY_F4); + input_set_capability(info->input_dev, EV_KEY, KEY_F5); + + input_set_capability(info->input_dev, EV_KEY, KEY_LEFTBRACE); + input_set_capability(info->input_dev, EV_KEY, KEY_RIGHTBRACE); +#endif + +#ifdef PHONE_KEY + /*KEY associated to the touch screen buttons */ + input_set_capability(info->input_dev, EV_KEY, KEY_HOMEPAGE); + input_set_capability(info->input_dev, EV_KEY, KEY_BACK); + input_set_capability(info->input_dev, EV_KEY, KEY_MENU); +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT + input_set_capability(info->input_dev, EV_KEY, BTN_INFO); + input_set_capability(info->input_dev, EV_KEY, KEY_INFO); + input_set_capability(info->input_dev, EV_KEY, KEY_GOTO); +#endif + mutex_init(&(info->input_report_mutex)); +#ifdef GESTURE_MODE + mutex_init(&gestureMask_mutex); +#endif + + spin_lock_init(&fts_int); + + /* register the multi-touch input device */ + error = input_register_device(info->input_dev); + if (error) { + logError(1, "%s ERROR: No such input device\n", tag); + error = -ENODEV; + goto ProbeErrorExit_5_1; + } + + retval = fts_input_symlink(info); + if (retval < 0) { + logError(1, "%s ERROR: fts_ts_info is NULL\n", tag); + } + + skip_5_1 = 1; + /* track slots */ + info->touch_id = 0; +#ifdef STYLUS_MODE + info->stylus_id = 0; +#endif + + /* init feature switches (by default all the features are disable, if one feature want to be enabled from the start, set the corresponding value to 1) */ + info->gesture_enabled = 0; + info->glove_enabled = 0; + info->charger_enabled = 0; + info->cover_enabled = 0; + info->grip_enabled = 0; + info->grip_pixel_def = 30; + info->grip_pixel = info->grip_pixel_def; + + info->resume_bit = 1; + info->lockdown_is_ok = false; +/* +#ifdef CONFIG_DRM + info->notifier = fts_noti_block; +#endif +*/ + logError(0, "%s Init Core Lib: \n", tag); + initCore(info); + /* init hardware device */ + logError(0, "%s Device Initialization: \n", tag); + error = fts_init(info); + if (error < OK) { + logError(1, "%s Cannot initialize the device ERROR %08X\n", tag, + error); + error = -ENODEV; + goto ProbeErrorExit_6; + } + /*update_hardware_info(TYPE_TOUCH, 4);*/ + +#ifdef CONFIG_SECURE_TOUCH + logError(1, "%s %s create secure touch file...\n", tag, __func__); + error = fts_secure_init(info); + if (error < 0) { + logError(1, "%s %s init secure touch failed\n", tag, __func__); + goto ProbeErrorExit_7; + } + logError(1, "%s %s create secure touch file successful\n", tag, __func__); + fts_secure_stop(info, 1); +#endif + +#ifdef CONFIG_I2C_BY_DMA + /*dma buf init*/ + info->dma_buf = (struct fts_dma_buf *)kzalloc(sizeof(*info->dma_buf), GFP_KERNEL); + if (!info->dma_buf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + goto ProbeErrorExit_7; + } + mutex_init(&info->dma_buf->dmaBufLock); + info->dma_buf->rdBuf = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!info->dma_buf->rdBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + goto ProbeErrorExit_7; + } + info->dma_buf->wrBuf = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!info->dma_buf->wrBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + goto ProbeErrorExit_7; + } +#endif + + error = fts_get_lockdown_info(info->lockdown_info, info); + + if (error < OK) + logError(1, "%s can't get lockdown info", tag); + else { + logError(1, + "%s Lockdown:0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x\n", + tag, info->lockdown_info[0], info->lockdown_info[1], + info->lockdown_info[2], info->lockdown_info[3], + info->lockdown_info[4], info->lockdown_info[5], + info->lockdown_info[6], info->lockdown_info[7]); + info->lockdown_is_ok = true; + /*update_hardware_info(TYPE_TP_MAKER, info->lockdown_info[0] - 0x30); */ + } + +#ifdef FW_UPDATE_ON_PROBE + logError(1, "%s FW Update and Sensing Initialization: \n", tag); + error = fts_fw_update(info, NULL, 0); + if (error < OK) { + logError(1, + "%s Cannot execute fw upgrade the device ERROR %08X\n", + tag, error); + error = -ENODEV; + goto ProbeErrorExit_7; + } +#else + logError(0, "%s SET Auto Fw Update: \n", tag); + info->fwu_workqueue = + alloc_workqueue("fts-fwu-queue", + WQ_UNBOUND | WQ_HIGHPRI | WQ_CPU_INTENSIVE, 1); + if (!info->fwu_workqueue) { + logError(1, "%s ERROR: Cannot create fwu work thread\n", tag); + goto ProbeErrorExit_7; + } + INIT_DELAYED_WORK(&info->fwu_work, fts_fw_update_auto); +#endif + info->sensor_scan = true; + + logError(0, "%s SET Device File Nodes: \n", tag); + /* sysfs stuff */ + info->attrs.attrs = fts_attr_group; + error = sysfs_create_group(&info->input_dev->dev.kobj, &info->attrs); + if (error) { + logError(1, "%s ERROR: Cannot create sysfs structure!\n", tag); + error = -ENODEV; + goto ProbeErrorExit_7; + } + + error = fts_proc_init(); + if (error < OK) + logError(1, "%s Error: can not create /proc file! \n", tag); + info->dbclick_count = 0; + + tp_maker = kzalloc(20, GFP_KERNEL); + if (tp_maker == NULL) + logError(1, "%s fail to alloc vendor name memory\n", tag); + else { + kfree(tp_maker); + tp_maker = NULL; + } + device_init_wakeup(&client->dev, 1); + + init_completion(&info->pm_resume_completion); +#ifdef CONFIG_TOUCHSCREEN_ST_DEBUG_FS + info->debugfs = debugfs_create_dir("tp_debug", NULL); + if (info->debugfs) { + debugfs_create_file("switch_state", 0660, info->debugfs, info, + &tpdbg_operations); + } +#endif + + if (info->fts_tp_class == NULL) + info->fts_tp_class = class_create("touch"); + info->fts_touch_dev = + device_create(info->fts_tp_class, NULL, 0x49, info, "tp_dev"); + + if (IS_ERR(info->fts_touch_dev)) { + logError(1, + "%s ERROR: Failed to create device for the sysfs!\n", + tag); + goto ProbeErrorExit_8; + } + + dev_set_drvdata(info->fts_touch_dev, info); +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + error = + sysfs_create_file(&info->fts_touch_dev->kobj, + &dev_attr_touch_suspend_notify.attr); + + if (error) { + logError(1, "%s ERROR: Failed to create sysfs group!\n", tag); + goto ProbeErrorExit_8; + } +#endif +#ifdef CONFIG_FTS_FOD_AREA_REPORT + mutex_init(&(info->fod_mutex)); + + error = + sysfs_create_file(&info->fts_touch_dev->kobj, + &dev_attr_fod_status.attr); + if (error) { + logError(1, "%s ERROR: Failed to create fod_status sysfs group!\n", tag); + } + error = + sysfs_create_file(&info->fts_touch_dev->kobj, + &dev_attr_fod_test.attr); + if (error) { + logError(1, "%s ERROR: Failed to create fod_test sysfs group!\n", tag); + } +#endif + info->tp_lockdown_info_proc = + proc_create("tp_lockdown_info", 0444, NULL, &fts_lockdown_info_ops); + info->tp_selftest_proc = + proc_create("tp_selftest", 0644, NULL, &fts_selftest_ops); + info->tp_data_dump_proc = + proc_create("tp_data_dump", 0444, NULL, &fts_datadump_ops); + info->tp_fw_version_proc = + proc_create("tp_fw_version", 0444, NULL, &fts_fw_version_ops); + +#ifndef FW_UPDATE_ON_PROBE + queue_delayed_work(info->fwu_workqueue, &info->fwu_work, + msecs_to_jiffies(EXP_FN_WORK_DELAY_MS)); +#endif + + logError(1, "%s Probe Finished! \n", tag); + return OK; +ProbeErrorExit_8: + device_destroy(info->fts_tp_class, 0x49); + class_destroy(info->fts_tp_class); + info->fts_tp_class = NULL; +ProbeErrorExit_7: +#ifdef CONFIG_SECURE_TOUCH + fts_secure_remove(info); +#endif +#ifdef CONFIG_I2C_BY_DMA + if (info->dma_buf) + kfree(info->dma_buf); + if (info->dma_buf->rdBuf) + kfree(info->dma_buf->rdBuf); + if (info->dma_buf->wrBuf) + kfree(info->dma_buf->wrBuf); +#endif +/* +#ifdef CONFIG_DRM + msm_drm_unregister_client(&info->notifier); +#endif +*/ +ProbeErrorExit_6: + input_unregister_device(info->input_dev); + +ProbeErrorExit_5_1: + if (skip_5_1 != 1) + input_free_device(info->input_dev); + +ProbeErrorExit_5: + destroy_workqueue(info->event_wq); + +ProbeErrorExit_4: + fts_enable_reg(info, false); + +ProbeErrorExit_2: + fts_get_reg(info, false); + +ProbeErrorExit_1: + kfree(info); + +ProbeErrorExit_0: + logError(1, "%s Probe Failed!\n", tag); + + return error; +} + +/** + * Clear and free all the resources associated to the driver. + * This function is called when the driver need to be removed. + */ +#ifdef I2C_INTERFACE +static void fts_remove(struct i2c_client *client) +{ +#else +static int fts_remove(struct spi_device *client) +{ +#endif + + struct fts_ts_info *info = dev_get_drvdata(&(client->dev)); + + fts_proc_remove(); + /* sysfs stuff */ + sysfs_remove_group(&client->dev.kobj, &info->attrs); + /* remove interrupt and event handlers */ + fts_interrupt_uninstall(info); +/* +#ifdef CONFIG_DRM + msm_drm_unregister_client(&info->notifier); +#endif +*/ + /* unregister the device */ + input_unregister_device(info->input_dev); + + /* Remove the work thread */ + destroy_workqueue(info->event_wq); +#ifndef FW_UPDATE_ON_PROBE + destroy_workqueue(info->fwu_workqueue); +#endif +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + if (info->board->dump_click_count && !info->current_clicknum_file) { + kfree(info->current_clicknum_file); + info->current_clicknum_file = NULL; + } + sysfs_remove_file(&info->fts_touch_dev->kobj, + &dev_attr_touch_suspend_notify.attr); +#endif + + device_destroy(info->fts_tp_class, DCHIP_ID_0); + class_destroy(info->fts_tp_class); + info->fts_tp_class = NULL; + + fts_enable_reg(info, false); + fts_get_reg(info, false); + fts_info = NULL; +#ifdef CONFIG_SECURE_TOUCH + fts_secure_remove(info); +#endif + /* free all */ + kfree(info); + + return ((void)0x00000000); +} + +/** +* Struct which contains the compatible names that need to match with the definition of the device in the device tree node +*/ +static struct of_device_id fts_of_match_table[] = { + { + .compatible = "st,fts", + }, + {}, +}; + +#ifdef I2C_INTERFACE +static const struct i2c_device_id fts_device_id[] = { + {FTS_TS_DRV_NAME, 0}, + {} +}; + +static struct i2c_driver fts_i2c_driver = { + .driver = { + .name = FTS_TS_DRV_NAME, + .of_match_table = fts_of_match_table, +#ifdef CONFIG_PM + .pm = &fts_dev_pm_ops, +#endif + }, + .probe = fts_probe, + .remove = fts_remove, + .id_table = fts_device_id, +}; +#else +static struct spi_driver fts_spi_driver = { + .driver = { + .name = FTS_TS_DRV_NAME, + .of_match_table = fts_of_match_table, + .owner = THIS_MODULE, + }, + .probe = fts_probe, + .remove = fts_remove, +}; +#endif + +static int __init fts_driver_init(void) +{ +#ifdef I2C_INTERFACE + return i2c_add_driver(&fts_i2c_driver); +#else + return spi_register_driver(&fts_spi_driver); +#endif +} + +static void __exit fts_driver_exit(void) +{ +#ifdef I2C_INTERFACE + i2c_del_driver(&fts_i2c_driver); +#else + spi_unregister_driver(&fts_spi_driver); +#endif + +} + +MODULE_DESCRIPTION("STMicroelectronics MultiTouch IC Driver"); +MODULE_AUTHOR("STMicroelectronics"); +MODULE_LICENSE("GPL"); + +late_initcall(fts_driver_init); +module_exit(fts_driver_exit); diff --git a/drivers/input/touchscreen/fts_521/fts.h b/drivers/input/touchscreen/fts_521/fts.h new file mode 100644 index 000000000000..6a17085da88b --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts.h @@ -0,0 +1,393 @@ +/* + * fts.c + * + * FTS Capacitive touch screen controller (FingerTipS) + * + * Copyright (C) 2017, STMicroelectronics + * Authors: AMG(Analog Mems Group) + * + * marco.cali@st.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * THE PRESENT SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES + * OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, FOR THE SOLE + * PURPOSE TO SUPPORT YOUR APPLICATION DEVELOPMENT. + * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, + * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE + * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING + * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. + * + * THIS SOFTWARE IS SPECIFICALLY DESIGNED FOR EXCLUSIVE USE WITH ST PARTS. + */ + +/*! +* \file fts.h +* \brief Contains all the definitions and structs used generally by the driver +*/ + +#ifndef _LINUX_FTS_I2C_H_ +#define _LINUX_FTS_I2C_H_ + +#include +#include +#include +#include +#include "fts_lib/ftsSoftware.h" +#include "fts_lib/ftsHardware.h" +#include +/****************** CONFIGURATION SECTION ******************/ +/** @defgroup conf_section Driver Configuration Section +* Settings of the driver code in order to suit the HW set up and the application behavior +* @{ +*/ + +/**** CODE CONFIGURATION ****/ +#define FTS_TS_DRV_NAME "fts" /*driver name*/ +#define FTS_TS_DRV_VERSION "5.2.4" /*driver version string format*/ +#define FTS_TS_DRV_VER 0x05020400 /*driver version u32 format*/ + +#define PINCTRL_STATE_ACTIVE "pmx_ts_active" +#define PINCTRL_STATE_SUSPEND "pmx_ts_suspend" +#define PINCTRL_STATE_RELEASE "pmx_ts_release" + + +#define DRIVER_TEST + +#define PRE_SAVED_METHOD + +/*#define FW_H_FILE*/ +#define FW_UPDATE_ON_PROBE +#ifdef FW_H_FILE +#define FW_SIZE_NAME myArray_size +#define FW_ARRAY_NAME myArray +#endif + +/*#define LIMITS_H_FILE*/ +#ifdef LIMITS_H_FILE +#define LIMITS_SIZE_NAME myArray2_size +#define LIMITS_ARRAY_NAME myArray2 +#endif + + +/*#define USE_ONE_FILE_NODE*/ + +#ifndef FW_UPDATE_ON_PROBE +#define EXP_FN_WORK_DELAY_MS 1000 +#endif + +/**** END ****/ + +/**** FEATURES USED IN THE IC ****/ + +/*#define PHONE_KEY*/ + +#define GESTURE_MODE +#ifdef GESTURE_MODE +#define USE_GESTURE_MASK +#endif + +#define CHARGER_MODE + +#define GLOVE_MODE + +#define COVER_MODE + +#define STYLUS_MODE + + +/**** END ****/ + +/**** PANEL SPECIFICATION ****/ +#define X_AXIS_MAX 1080 +#define X_AXIS_MIN 0 +#define Y_AXIS_MAX 2340 +#define Y_AXIS_MIN 0 + +#define PRESSURE_MIN 0 +#ifdef CONFIG_INPUT_PRESS_NDT +#define PRESSURE_MAX 2048 +#else +#define PRESSURE_MAX 127 +#endif + +#define DISTANCE_MIN 0 +#define DISTANCE_MAX 127 + +#define TOUCH_ID_MAX 10 + +#define AREA_MIN PRESSURE_MIN +#define AREA_MAX PRESSURE_MAX +/**** END ****/ +/**@}*/ +/*********************************************************/ + +/* + * Configuration mode + * + * bitmask which can assume the value defined as features in ftsSoftware.h or the following values + */ + +/** @defgroup mode_section IC Status Mode +* Bitmask which keeps track of the features and working mode enabled in the IC. +* The meaning of the the LSB of the bitmask must be interpreted considering that the value defined in @link feat_opt Feature Selection Option @endlink correspond to the position of the corresponding bit in the mask +* @{ +*/ +#define MODE_NOTHING 0x00000000 +#define MODE_ACTIVE(_mask, _sett)\ +do {\ + _mask |= (SCAN_MODE_ACTIVE << 24)|(_sett << 16);\ +} while (0) +#define MODE_LOW_POWER(_mask, _sett)\ +do {\ + _mask |= (SCAN_MODE_LOW_POWER << 24)|(_sett << 16);\ +} while (0) +/** @}*/ + +#define CMD_STR_LEN 32 + +#define TSP_BUF_SIZE PAGE_SIZE + +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP +#define TOUCH_COUNT_FILE_MAXSIZE 50 +#endif + +/** + * Struct which contains information about the HW platform and set up + */ +#define FTS_LOCKDOWN_SIZE 8 +#define FTS_RESULT_INVALID 0 +#define FTS_RESULT_PASS 2 +#define FTS_RESULT_FAIL 1 + +struct fts_config_info { + u8 tp_vendor; + u8 tp_color; + u8 tp_hw_version; + const char *fts_cfg_name; + const char *fts_limit_name; +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + const char *clicknum_file_name; +#endif +}; + +struct fts_hw_platform_data { + int (*power) (bool on); + int irq_gpio; + int reset_gpio; + unsigned long irq_flags; + unsigned int x_max; + unsigned int y_max; + const char *vdd_reg_name; + const char *avdd_reg_name; + const char *default_fw_name; + size_t config_array_size; + struct fts_config_info *config_array; + int current_index; +#ifdef PHONE_KEY + size_t nbuttons; + int *key_code; +#endif +#ifdef CONFIG_FTS_TOUCH_COUNT_DUMP + bool dump_click_count; +#endif + unsigned long keystates; +}; + +/* + * Forward declaration + */ +struct fts_ts_info; +extern char tag[8]; + +/* + * Dispatch event handler + */ +typedef void (*event_dispatch_handler_t) + (struct fts_ts_info *info, unsigned char *data); + +#ifdef CONFIG_SECURE_TOUCH +struct fts_secure_delay { + bool palm_pending; + int palm_value; +}; + +struct fts_secure_info { + bool secure_inited; + atomic_t st_1st_complete; + atomic_t st_enabled; + atomic_t st_pending_irqs; + struct completion st_irq_processed; + struct completion st_powerdown; + struct fts_secure_delay scr_delay; + struct mutex palm_lock; + void *fts_info; +}; +#endif + +#ifdef CONFIG_I2C_BY_DMA +struct fts_dma_buf { + struct mutex dmaBufLock; + u8 *rdBuf; + u8 *wrBuf; +}; +#endif + + +/** + * FTS capacitive touch screen device information + * - dev Pointer to the structure device \n + * - client client structure \n + * - input_dev Input device structure \n + * - work Work thread \n + * - event_wq Event queue for work thread \n + * - event_dispatch_table Event dispatch table handlers \n + * - attrs SysFS attributes \n + * - mode Device operating mode (bitmask) \n + * - touch_id Bitmask for touch id (mapped to input slots) \n + * - stylus_id Bitmask for tracking the stylus touches (mapped using the touchId) \n + * - timer Timer when operating in polling mode \n + * - power Power on/off routine \n + * - board HW info retrieved from device tree \n + * - vdd_reg DVDD power regulator \n + * - avdd_reg AVDD power regulator \n + * - resume_bit Indicate if screen off/on \n + * - fwupdate_stat Store the result of a fw update triggered by the host \n + * - notifier Used for be notified from a suspend/resume event \n + * - sensor_sleep true suspend was called, false resume was called \n + * - wakelock Wake Lock struct \n + * - input_report_mutex mutex for handling the pressure of keys \n + * - series_of_switches to store the enabling status of a particular feature from the host \n + */ +struct fts_ts_info { + struct device *dev; +#ifdef I2C_INTERFACE + struct i2c_client *client; +#else + struct spi_device *client; +#endif + struct input_dev *input_dev; + + struct work_struct work; + struct work_struct suspend_work; + struct work_struct resume_work; + struct work_struct mode_handler_work; + struct work_struct cmd_update_work; + struct work_struct sleep_work; + struct workqueue_struct *event_wq; + struct workqueue_struct *irq_wq; + struct workqueue_struct *touch_feature_wq; + +#ifndef FW_UPDATE_ON_PROBE + struct delayed_work fwu_work; + struct workqueue_struct *fwu_workqueue; +#endif + event_dispatch_handler_t *event_dispatch_table; + + struct attribute_group attrs; + + unsigned int mode; + unsigned long touch_id; + unsigned long sleep_finger; + unsigned long touch_skip; + int coor[TOUCH_ID_MAX][2]; +#ifdef STYLUS_MODE + unsigned long stylus_id; +#endif + struct fts_hw_platform_data *board; + struct regulator *vdd_reg; + struct regulator *avdd_reg; + + int resume_bit; + int fwupdate_stat; + + struct notifier_block notifier; + struct notifier_block bl_notifier; + bool sensor_sleep; + bool sensor_scan; + struct pinctrl *ts_pinctrl; + struct pinctrl_state *pinctrl_state_active; + struct pinctrl_state *pinctrl_state_suspend; + u8 lockdown_info[FTS_LOCKDOWN_SIZE]; + int result_type; + struct proc_dir_entry *tp_selftest_proc; + struct proc_dir_entry *tp_data_dump_proc; + struct proc_dir_entry *tp_fw_version_proc; + struct proc_dir_entry *tp_lockdown_info_proc; + + /* input lock */ + struct mutex input_report_mutex; + int gesture_enabled; + int glove_enabled; + int charger_enabled; + int stylus_enabled; + int cover_enabled; + unsigned int grip_enabled; + unsigned int grip_pixel; + unsigned int doze_time; + unsigned int grip_pixel_def; + unsigned int doze_time_def; +#ifdef CONFIG_TOUCHSCREEN_ST_DEBUG_FS + struct dentry *debugfs; +#endif + int dbclick_count; + struct class *fts_tp_class; + struct device *fts_touch_dev; + char *current_clicknum_file; +#ifdef CONFIG_SECURE_TOUCH + struct fts_secure_info *secure_info; +#endif +#ifdef CONFIG_I2C_BY_DMA + struct fts_dma_buf *dma_buf; +#endif + bool lockdown_is_ok; + bool irq_status; + wait_queue_head_t wait_queue; + struct completion tp_reset_completion; + atomic_t system_is_resetting; + unsigned int fod_status; + unsigned int fod_overlap; + unsigned long fod_id; + unsigned long fod_x; + unsigned long fod_y; + struct mutex fod_mutex; + struct mutex cmd_update_mutex; + bool fod_coordinate_update; + bool fod_status_set; + bool fod_pressed; + bool p_sensor_changed; + bool p_sensor_switch; + bool palm_sensor_changed; + bool palm_sensor_switch; + bool tp_pm_suspend; + struct completion pm_resume_completion; + struct proc_dir_entry *input_proc; +}; + +struct fts_mode_switch { + struct fts_ts_info *info; + unsigned char mode; + struct work_struct switch_mode_work; +}; + +int fts_chip_powercycle(struct fts_ts_info *info); +extern int input_register_notifier_client(struct notifier_block *nb); +extern int input_unregister_notifier_client(struct notifier_block *nb); + +extern int fts_proc_init(void); +extern int fts_proc_remove(void); +#ifdef CONFIG_FTS_FOD_AREA_REPORT +#define CENTER_X 540 +#define CENTER_Y 2005 +#define CIRCLE_R 87 +#define FOD_LX 420 +#define FOD_LY 1885 +#define FOD_SIDE 242 +bool fts_is_infod(void); +void fts_get_pointer(int *touch_flag, int *x, int *y); +#endif +void fts_restore_regvalues(void); + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_fw.h b/drivers/input/touchscreen/fts_521/fts_fw.h new file mode 100644 index 000000000000..6821f3945a7b --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_fw.h @@ -0,0 +1,12573 @@ +/*! +* \file fts_fw.h +* \brief Contains the size and the byte array of the fw file to burn into the IC +*/ +#ifndef FTS_FW_H +#define FTS_FW_H +/*This is an auto generated header file*/ +/*--->Remember to change the name of the two variables!<---*/ +const uint32_t myArray_size = 100476; + +const uint8_t myArray[] = { + 0x55, 0xAA, 0x55, 0xAA, 0x01, 0x00, 0x00, 0x00, 0x36, 0x39, 0x00, 0x00, + 0x33, 0xA2, 0x00, 0x00, + 0x33, 0xA2, 0x00, 0x00, 0xA1, 0x00, 0xA1, 0x00, 0xA1, 0x00, 0xA1, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xE8, 0x7D, 0x01, 0x00, + 0x50, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xF3, 0xB0, 0x4F, 0xDA, + 0x69, 0xDA, 0x63, 0x91, 0x79, 0x5F, 0x00, 0x00, 0x96, 0x25, 0x9C, 0x6E, + 0x86, 0xA0, 0xFF, 0xFF, + 0x00, 0x04, 0x10, 0x00, 0xB5, 0x02, 0x00, 0x00, 0x0D, 0x03, 0x00, 0x00, + 0x27, 0x03, 0x00, 0x00, + 0x41, 0x03, 0x00, 0x00, 0x5B, 0x03, 0x00, 0x00, 0x75, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x85, 0x6E, 0x01, 0x00, + 0x8D, 0x6E, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x03, 0x00, 0x00, + 0x95, 0x6E, 0x01, 0x00, + 0x9D, 0x6E, 0x01, 0x00, 0xAB, 0x6E, 0x01, 0x00, 0xB9, 0x6E, 0x01, 0x00, + 0xC7, 0x6E, 0x01, 0x00, + 0xD5, 0x6E, 0x01, 0x00, 0xE3, 0x6E, 0x01, 0x00, 0xF1, 0x6E, 0x01, 0x00, + 0xFF, 0x6E, 0x01, 0x00, + 0x0D, 0x6F, 0x01, 0x00, 0x9D, 0x03, 0x00, 0x00, 0x1B, 0x6F, 0x01, 0x00, + 0x29, 0x6F, 0x01, 0x00, + 0x37, 0x6F, 0x01, 0x00, 0x3F, 0x6F, 0x01, 0x00, 0x47, 0x6F, 0x01, 0x00, + 0x4F, 0x6F, 0x01, 0x00, + 0x5D, 0x6F, 0x01, 0x00, 0x65, 0x6F, 0x01, 0x00, 0x6D, 0x6F, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x75, 0x6F, 0x01, 0x00, + 0x7D, 0x6F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x6F, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x33, 0xA2, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0xF0, 0x02, 0xF8, 0x00, 0xF0, 0x68, 0xF8, 0x0A, 0xA0, 0x90, 0xE8, + 0x00, 0x0C, 0x82, 0x44, + 0x83, 0x44, 0xAA, 0xF1, 0x01, 0x07, 0xDA, 0x45, 0x01, 0xD1, 0x00, 0xF0, + 0x5D, 0xF8, 0xAF, 0xF2, + 0x09, 0x0E, 0xBA, 0xE8, 0x0F, 0x00, 0x13, 0xF0, 0x01, 0x0F, 0x18, 0xBF, + 0xFB, 0x1A, 0x43, 0xF0, + 0x01, 0x03, 0x18, 0x47, 0x1C, 0x7C, 0x01, 0x00, 0x4C, 0x7C, 0x01, 0x00, + 0x0A, 0x44, 0x4F, 0xF0, + 0x00, 0x0C, 0x10, 0xF8, 0x01, 0x3B, 0x13, 0xF0, 0x07, 0x04, 0x08, 0xBF, + 0x10, 0xF8, 0x01, 0x4B, + 0x1D, 0x11, 0x08, 0xBF, 0x10, 0xF8, 0x01, 0x5B, 0x64, 0x1E, 0x05, 0xD0, + 0x10, 0xF8, 0x01, 0x6B, + 0x64, 0x1E, 0x01, 0xF8, 0x01, 0x6B, 0xF9, 0xD1, 0x13, 0xF0, 0x08, 0x0F, + 0x1E, 0xBF, 0x10, 0xF8, + 0x01, 0x4B, 0xAD, 0x1C, 0x0C, 0x1B, 0x09, 0xD1, 0x6D, 0x1E, 0x58, 0xBF, + 0x01, 0xF8, 0x01, 0xCB, + 0xFA, 0xD5, 0x05, 0xE0, 0x14, 0xF8, 0x01, 0x6B, 0x01, 0xF8, 0x01, 0x6B, + 0x6D, 0x1E, 0xF9, 0xD5, + 0x91, 0x42, 0xD6, 0xD3, 0x70, 0x47, 0x00, 0x00, 0x10, 0x3A, 0x24, 0xBF, + 0x78, 0xC8, 0x78, 0xC1, + 0xFA, 0xD8, 0x52, 0x07, 0x24, 0xBF, 0x30, 0xC8, 0x30, 0xC1, 0x44, 0xBF, + 0x04, 0x68, 0x0C, 0x60, + 0x70, 0x47, 0x00, 0x00, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, + 0x10, 0x3A, 0x28, 0xBF, + 0x78, 0xC1, 0xFB, 0xD8, 0x52, 0x07, 0x28, 0xBF, 0x30, 0xC1, 0x48, 0xBF, + 0x0B, 0x60, 0x70, 0x47, + 0x1F, 0xB5, 0x1F, 0xBD, 0x10, 0xB5, 0x10, 0xBD, 0xDF, 0xF8, 0x0C, 0xD0, + 0xFF, 0xF7, 0xF8, 0xFF, + 0x16, 0xF0, 0xE4, 0xFE, 0x17, 0xF0, 0x69, 0xF8, 0x00, 0x04, 0x10, 0x00, + 0x03, 0xB4, 0xFF, 0xF7, + 0xF1, 0xFF, 0x03, 0xBC, 0x17, 0xF0, 0x68, 0xF8, 0x0A, 0x48, 0x4F, 0xF0, + 0xFF, 0x01, 0x01, 0x70, + 0x4F, 0xF0, 0x00, 0x00, 0x80, 0xF3, 0x11, 0x88, 0x4F, 0xF0, 0x00, 0x00, + 0x80, 0xF3, 0x09, 0x88, + 0x05, 0x48, 0x4F, 0xF0, 0x02, 0x01, 0x01, 0x70, 0x62, 0xB6, 0x04, 0x48, + 0x4F, 0xF0, 0x80, 0x51, + 0x01, 0x60, 0x70, 0x47, 0x22, 0xED, 0x00, 0xE0, 0x00, 0x04, 0x10, 0x00, + 0x04, 0xED, 0x00, 0xE0, + 0x02, 0x48, 0x4F, 0xF0, 0x80, 0x51, 0x01, 0x60, 0x70, 0x47, 0x00, 0x00, + 0x04, 0xED, 0x00, 0xE0, + 0x4F, 0xF0, 0x20, 0x00, 0x80, 0xF3, 0x11, 0x88, 0xEF, 0xF3, 0x09, 0x80, + 0x98, 0xB1, 0x12, 0x48, + 0x00, 0x68, 0x12, 0x49, 0x09, 0x68, 0x88, 0x42, 0x17, 0xD0, 0xEF, 0xF3, + 0x09, 0x80, 0x0E, 0x49, + 0x09, 0x68, 0x20, 0xE9, 0xF0, 0x0F, 0x88, 0x60, 0x00, 0xB5, 0x0B, 0x48, + 0x00, 0x68, 0x00, 0xF0, + 0x2F, 0xF9, 0x5D, 0xF8, 0x04, 0xEB, 0x08, 0x48, 0x08, 0x49, 0x0A, 0x68, + 0x02, 0x60, 0x00, 0x68, + 0x81, 0x68, 0xB1, 0xE8, 0xF0, 0x0F, 0x81, 0xF3, 0x09, 0x88, 0x4E, 0xF0, + 0x04, 0x0E, 0x4F, 0xF0, + 0x00, 0x00, 0x80, 0xF3, 0x11, 0x88, 0x70, 0x47, 0x04, 0x04, 0x10, 0x00, + 0x08, 0x04, 0x10, 0x00, + 0xEF, 0xF3, 0x11, 0x80, 0x4F, 0xF0, 0x20, 0x01, 0x81, 0xF3, 0x11, 0x88, + 0x70, 0x47, 0x00, 0x00, + 0x4F, 0xF0, 0x00, 0x00, 0x80, 0xF3, 0x11, 0x88, 0x70, 0x47, 0x00, 0x00, + 0x62, 0xB6, 0x70, 0x47, + 0x72, 0xB6, 0x70, 0x47, 0x40, 0x1E, 0xFD, 0xD1, 0x70, 0x47, 0x00, 0x00, + 0x40, 0xBA, 0x70, 0x47, + 0xC0, 0xBA, 0x70, 0x47, 0x12, 0x48, 0x13, 0x49, 0xA1, 0xEB, 0x00, 0x01, + 0x4F, 0xF0, 0x20, 0x03, + 0x91, 0xFB, 0xF3, 0xF2, 0x02, 0xFB, 0x13, 0x11, 0x4F, 0xF0, 0xCC, 0x33, + 0x4F, 0xF0, 0xCC, 0x34, + 0x4F, 0xF0, 0xCC, 0x35, 0x4F, 0xF0, 0xCC, 0x36, 0x4F, 0xF0, 0xCC, 0x37, + 0x4F, 0xF0, 0xCC, 0x38, + 0x4F, 0xF0, 0xCC, 0x39, 0x4F, 0xF0, 0xCC, 0x3A, 0xA0, 0xE8, 0xF8, 0x07, + 0x01, 0x3A, 0xFB, 0xD1, + 0x19, 0xB1, 0x40, 0xF8, 0x04, 0xAB, 0x04, 0x39, 0xFB, 0xD1, 0x03, 0x48, + 0x00, 0x47, 0x00, 0x00, + 0x00, 0x00, 0x10, 0x00, 0x00, 0x04, 0x10, 0x00, 0xE1, 0x00, 0x00, 0x00, + 0x1E, 0xF0, 0x04, 0x0F, + 0x0C, 0xBF, 0xEF, 0xF3, 0x08, 0x80, 0xEF, 0xF3, 0x09, 0x80, 0x4F, 0xF0, + 0x01, 0x01, 0x4F, 0xF0, + 0x00, 0x02, 0x12, 0xF0, 0xBB, 0xB8, 0x1E, 0xF0, 0x04, 0x0F, 0x0C, 0xBF, + 0xEF, 0xF3, 0x08, 0x80, + 0xEF, 0xF3, 0x09, 0x80, 0x4F, 0xF0, 0x02, 0x01, 0x4F, 0xF0, 0x00, 0x02, + 0x12, 0xF0, 0xAE, 0xB8, + 0x1E, 0xF0, 0x04, 0x0F, 0x0C, 0xBF, 0xEF, 0xF3, 0x08, 0x80, 0xEF, 0xF3, + 0x09, 0x80, 0x4F, 0xF0, + 0x03, 0x01, 0x4F, 0xF0, 0x00, 0x02, 0x12, 0xF0, 0xA1, 0xB8, 0x1E, 0xF0, + 0x04, 0x0F, 0x0C, 0xBF, + 0xEF, 0xF3, 0x08, 0x80, 0xEF, 0xF3, 0x09, 0x80, 0x4F, 0xF0, 0x04, 0x01, + 0x4F, 0xF0, 0x00, 0x02, + 0x12, 0xF0, 0x94, 0xB8, 0x1E, 0xF0, 0x04, 0x0F, 0x0C, 0xBF, 0xEF, 0xF3, + 0x08, 0x80, 0xEF, 0xF3, + 0x09, 0x80, 0x4F, 0xF0, 0x05, 0x01, 0x4F, 0xF0, 0x00, 0x02, 0x12, 0xF0, + 0x87, 0xB8, 0x00, 0xB5, + 0x16, 0xF0, 0x72, 0xFD, 0x5D, 0xF8, 0x04, 0xEB, 0xFF, 0xF7, 0x42, 0xBF, + 0x1E, 0xF0, 0x04, 0x0F, + 0x0C, 0xBF, 0xEF, 0xF3, 0x08, 0x80, 0xEF, 0xF3, 0x09, 0x80, 0x4F, 0xF0, + 0x06, 0x01, 0x4F, 0xF0, + 0x00, 0x02, 0x12, 0xF0, 0x73, 0xB8, 0x00, 0x00, 0x19, 0x49, 0x10, 0xB5, + 0x01, 0x20, 0x08, 0x70, + 0x18, 0x49, 0x00, 0x20, 0x08, 0x60, 0x18, 0x49, 0x08, 0x60, 0x18, 0x49, + 0x08, 0x60, 0x18, 0x49, + 0x08, 0x60, 0x00, 0xF0, 0xBF, 0xF9, 0x00, 0xF0, 0x59, 0xF9, 0x00, 0xF0, + 0x7D, 0xF8, 0x00, 0x20, + 0x10, 0xBD, 0x10, 0xB5, 0x11, 0x48, 0x00, 0xF0, 0x38, 0xF9, 0x0F, 0x49, + 0x08, 0x60, 0x0D, 0x49, + 0x09, 0x68, 0x88, 0x42, 0x07, 0xD0, 0x0A, 0x48, 0x00, 0x78, 0x02, 0x28, + 0x03, 0xD1, 0xBD, 0xE8, + 0x10, 0x40, 0xFF, 0xF7, 0x05, 0xBF, 0x10, 0xBD, 0x10, 0xB5, 0xFF, 0xF7, + 0xEA, 0xFF, 0x04, 0x49, + 0x02, 0x20, 0x08, 0x70, 0xFF, 0xF7, 0xE0, 0xFE, 0x4F, 0xF0, 0xFF, 0x30, + 0x10, 0xBD, 0x00, 0x00, + 0x00, 0x04, 0x10, 0x00, 0x04, 0x04, 0x10, 0x00, 0x08, 0x04, 0x10, 0x00, + 0x0C, 0x04, 0x10, 0x00, + 0x10, 0x04, 0x10, 0x00, 0x70, 0xB5, 0x0D, 0x46, 0x04, 0x46, 0xC1, 0x69, + 0x80, 0x68, 0xCC, 0x22, + 0x16, 0xF0, 0xDA, 0xFE, 0xE1, 0x69, 0xA0, 0x68, 0x08, 0x44, 0x4F, 0xF0, + 0x80, 0x71, 0x40, 0xF8, + 0x04, 0x1C, 0x21, 0x6A, 0x40, 0xF8, 0x08, 0x1C, 0x00, 0x21, 0x40, 0xF8, + 0x0C, 0x1C, 0x40, 0xF8, + 0x10, 0x1C, 0x40, 0xF8, 0x14, 0x1C, 0x40, 0xF8, 0x18, 0x1C, 0x40, 0xE9, + 0x08, 0x51, 0x4F, 0xF0, + 0x0B, 0x31, 0x40, 0xF8, 0x24, 0x1C, 0x4F, 0xF0, 0x0A, 0x31, 0x40, 0xF8, + 0x28, 0x1C, 0x4F, 0xF0, + 0x09, 0x31, 0x40, 0xF8, 0x2C, 0x1C, 0x4F, 0xF0, 0x08, 0x31, 0x40, 0xF8, + 0x30, 0x1C, 0x4F, 0xF0, + 0x07, 0x31, 0x40, 0xF8, 0x34, 0x1C, 0x4F, 0xF0, 0x06, 0x31, 0x40, 0xF8, + 0x38, 0x1C, 0x4F, 0xF0, + 0x05, 0x31, 0x40, 0xF8, 0x3C, 0x1C, 0x4F, 0xF0, 0x04, 0x31, 0x40, 0xF8, + 0x40, 0x1D, 0x70, 0xBD, + 0x81, 0x69, 0x4F, 0xF0, 0xCC, 0x32, 0x0B, 0x68, 0x93, 0x42, 0x08, 0xD1, + 0x4B, 0x68, 0x93, 0x42, + 0x05, 0xD1, 0x8B, 0x68, 0x93, 0x42, 0x02, 0xD1, 0xC9, 0x68, 0x91, 0x42, + 0x02, 0xD0, 0x40, 0x68, + 0x12, 0xF0, 0xD9, 0xBB, 0x70, 0x47, 0x00, 0x00, 0x10, 0xB5, 0xA0, 0x21, + 0x49, 0x48, 0x16, 0xF0, + 0xB5, 0xFE, 0x00, 0x20, 0x10, 0xBD, 0x70, 0xB5, 0x05, 0x46, 0x46, 0x48, + 0x00, 0xEB, 0x05, 0x14, + 0xFF, 0xF7, 0xC6, 0xFE, 0x06, 0x46, 0x20, 0x78, 0x28, 0xB1, 0x30, 0x46, + 0xFF, 0xF7, 0xC8, 0xFE, + 0x6F, 0xF0, 0x01, 0x00, 0x70, 0xBD, 0x03, 0x20, 0x20, 0x70, 0x00, 0x20, + 0x65, 0x60, 0xE0, 0x60, + 0x04, 0xF1, 0x08, 0x00, 0x00, 0xF0, 0x7A, 0xF8, 0x30, 0x46, 0xFF, 0xF7, + 0xB9, 0xFE, 0x00, 0x20, + 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x0F, 0x46, 0x36, 0x49, 0x00, 0x25, + 0x01, 0xEB, 0x00, 0x14, + 0x2E, 0x46, 0xFF, 0xF7, 0xA5, 0xFE, 0x80, 0x46, 0xE0, 0x68, 0x38, 0x43, + 0xE0, 0x60, 0x04, 0xF1, + 0x08, 0x00, 0x07, 0x46, 0x00, 0xF0, 0x89, 0xF8, 0x0C, 0xE0, 0xE1, 0x68, + 0xC2, 0x6A, 0x11, 0x42, + 0x03, 0xD0, 0x00, 0xF0, 0x4F, 0xF9, 0x01, 0x26, 0x00, 0xE0, 0x6D, 0x1C, + 0x29, 0x46, 0x38, 0x46, + 0x00, 0xF0, 0x71, 0xF8, 0x00, 0x28, 0xF0, 0xD1, 0x0E, 0xB1, 0xFF, 0xF7, + 0x3A, 0xFF, 0x40, 0x46, + 0xFF, 0xF7, 0x8E, 0xFE, 0x00, 0x20, 0xBD, 0xE8, 0xF0, 0x81, 0x70, 0xB5, + 0x0D, 0x46, 0x21, 0x49, + 0x01, 0xEB, 0x00, 0x14, 0xFF, 0xF7, 0x7C, 0xFE, 0xE1, 0x68, 0xA9, 0x43, + 0xE1, 0x60, 0xFF, 0xF7, + 0x7F, 0xFE, 0x00, 0x20, 0x70, 0xBD, 0x70, 0xB5, 0x0C, 0x46, 0x1A, 0x49, + 0x01, 0xEB, 0x00, 0x15, + 0x00, 0x20, 0x20, 0x60, 0xFF, 0xF7, 0x6C, 0xFE, 0xE9, 0x68, 0x21, 0x60, + 0xFF, 0xF7, 0x70, 0xFE, + 0x00, 0x20, 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x0D, 0x46, 0x12, 0x49, + 0x1E, 0x46, 0x90, 0x46, + 0x01, 0xEB, 0x00, 0x14, 0xFF, 0xF7, 0x5C, 0xFE, 0x07, 0x46, 0x0F, 0x48, + 0x00, 0x68, 0xC5, 0x62, + 0xE1, 0x68, 0x29, 0x42, 0x03, 0xD1, 0x04, 0xF1, 0x08, 0x01, 0x00, 0xF0, + 0x1D, 0xF9, 0x38, 0x46, + 0xFF, 0xF7, 0x56, 0xFE, 0xFF, 0xF7, 0x4C, 0xFE, 0xE1, 0x68, 0x29, 0x40, + 0x31, 0x60, 0xB8, 0xF1, + 0x01, 0x0F, 0x02, 0xD1, 0xE1, 0x68, 0xA9, 0x43, 0xE1, 0x60, 0xFF, 0xF7, + 0x49, 0xFE, 0x00, 0x20, + 0xB9, 0xE7, 0x00, 0x00, 0x0C, 0x08, 0x10, 0x00, 0x04, 0x04, 0x10, 0x00, + 0x00, 0x21, 0x01, 0x60, + 0x08, 0x46, 0x70, 0x47, 0x30, 0xB5, 0x0A, 0x68, 0x12, 0xB1, 0x0B, 0x46, + 0x84, 0x6A, 0x09, 0xE0, + 0x00, 0x22, 0x08, 0x60, 0xC0, 0xE9, 0x03, 0x21, 0x0B, 0xE0, 0x00, 0xBF, + 0x02, 0xF1, 0x0C, 0x03, + 0xD2, 0x68, 0x12, 0xB1, 0x95, 0x6A, 0xA5, 0x42, 0xF8, 0xDC, 0x1A, 0x68, + 0xC0, 0xE9, 0x03, 0x21, + 0x18, 0x60, 0x00, 0x20, 0x30, 0xBD, 0x00, 0x68, 0x00, 0x22, 0x01, 0xE0, + 0xC0, 0x68, 0x52, 0x1C, + 0x8A, 0x42, 0x01, 0xD0, 0x00, 0x28, 0xF9, 0xD1, 0x70, 0x47, 0x00, 0x68, + 0x70, 0x47, 0x02, 0x69, + 0x0A, 0xB1, 0x11, 0x68, 0x31, 0xB9, 0x6F, 0xF0, 0x04, 0x00, 0x70, 0x47, + 0x01, 0xF1, 0x0C, 0x02, + 0xC9, 0x68, 0x39, 0xB1, 0x81, 0x42, 0xF9, 0xD1, 0xC9, 0x68, 0x11, 0x60, + 0x00, 0x21, 0x01, 0x61, + 0x08, 0x46, 0x70, 0x47, 0x6F, 0xF0, 0x03, 0x00, 0x70, 0x47, 0x00, 0x00, + 0x10, 0xB5, 0xC8, 0x21, + 0x2E, 0x48, 0x16, 0xF0, 0xDB, 0xFD, 0x00, 0x20, 0x10, 0xBD, 0x2D, 0xE9, + 0xF0, 0x41, 0x05, 0x46, + 0x2A, 0x49, 0x00, 0xEB, 0x85, 0x00, 0x17, 0x46, 0x01, 0xEB, 0x80, 0x04, + 0xFF, 0xF7, 0xE8, 0xFD, + 0x06, 0x46, 0x20, 0x78, 0x30, 0xB1, 0x30, 0x46, 0xFF, 0xF7, 0xEA, 0xFD, + 0x6F, 0xF0, 0x01, 0x00, + 0xBD, 0xE8, 0xF0, 0x81, 0x02, 0x20, 0x20, 0x70, 0x00, 0x20, 0x65, 0x60, + 0xC4, 0xE9, 0x02, 0x70, + 0x04, 0xF1, 0x10, 0x00, 0xFF, 0xF7, 0x9A, 0xFF, 0x30, 0x46, 0xFF, 0xF7, + 0xD9, 0xFD, 0x00, 0x20, + 0xEE, 0xE7, 0x70, 0xB5, 0x19, 0x49, 0x00, 0xEB, 0x80, 0x00, 0x01, 0xEB, + 0x80, 0x04, 0xFF, 0xF7, + 0xC7, 0xFD, 0x05, 0x46, 0xD4, 0xE9, 0x02, 0x01, 0x81, 0x42, 0x05, 0xDB, + 0x14, 0x48, 0x04, 0xF1, + 0x10, 0x01, 0x00, 0x68, 0x00, 0xF0, 0x88, 0xF8, 0xE0, 0x68, 0x40, 0x1C, + 0xE0, 0x60, 0x28, 0x46, + 0xFF, 0xF7, 0xBE, 0xFD, 0x00, 0x20, 0x70, 0xBD, 0x70, 0xB5, 0x0C, 0x49, + 0x00, 0xEB, 0x80, 0x00, + 0x01, 0xEB, 0x80, 0x04, 0xFF, 0xF7, 0xAC, 0xFD, 0x05, 0x46, 0xE0, 0x68, + 0x08, 0xB1, 0x40, 0x1E, + 0xE0, 0x60, 0x04, 0xF1, 0x10, 0x00, 0xFF, 0xF7, 0x90, 0xFF, 0x10, 0xB1, + 0x20, 0x69, 0x00, 0xF0, + 0x11, 0xF8, 0x28, 0x46, 0xFF, 0xF7, 0xA4, 0xFD, 0x00, 0x20, 0x70, 0xBD, + 0xAC, 0x08, 0x10, 0x00, + 0x04, 0x04, 0x10, 0x00, 0x10, 0xB5, 0x4F, 0xF4, 0xF0, 0x71, 0x3C, 0x48, + 0x16, 0xF0, 0x76, 0xFD, + 0x00, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x04, 0x46, 0x90, 0xF8, 0x24, 0x00, + 0x02, 0x28, 0x0B, 0xD0, + 0x20, 0x46, 0xFF, 0xF7, 0x74, 0xFF, 0x02, 0x20, 0x84, 0xF8, 0x24, 0x00, + 0x34, 0x49, 0x20, 0x46, + 0xFF, 0xF7, 0x48, 0xFF, 0xFF, 0xF7, 0x2D, 0xFE, 0x00, 0x20, 0x10, 0xBD, + 0x2D, 0xE9, 0xF0, 0x5F, + 0x06, 0x46, 0x0A, 0xA8, 0x06, 0xEB, 0x46, 0x01, 0x90, 0xE8, 0x00, 0x0E, + 0x2B, 0x48, 0x1D, 0x46, + 0x00, 0xEB, 0x01, 0x14, 0x90, 0x46, 0x20, 0x78, 0x18, 0xB1, 0x6F, 0xF0, + 0x01, 0x00, 0xBD, 0xE8, + 0xF0, 0x9F, 0xFF, 0xF7, 0x65, 0xFD, 0x07, 0x46, 0x01, 0x20, 0x20, 0x70, + 0xC4, 0xF8, 0x14, 0x80, + 0xC4, 0xE9, 0x01, 0x65, 0x04, 0xF1, 0x18, 0x01, 0x00, 0x20, 0x81, 0xE8, + 0x20, 0x06, 0x84, 0xF8, + 0x24, 0x00, 0xE0, 0x60, 0x20, 0x61, 0xC4, 0xE9, 0x0A, 0x80, 0x59, 0x46, + 0x20, 0x46, 0xFF, 0xF7, + 0x29, 0xFE, 0xA0, 0x60, 0x20, 0x46, 0xFF, 0xF7, 0xBD, 0xFF, 0x38, 0x46, + 0xFF, 0xF7, 0x50, 0xFD, + 0x00, 0x20, 0xDC, 0xE7, 0x10, 0xB5, 0x04, 0x46, 0x90, 0xF8, 0x24, 0x00, + 0x02, 0x28, 0x09, 0xD0, + 0x20, 0x46, 0xFF, 0xF7, 0x2C, 0xFF, 0x02, 0x20, 0x84, 0xF8, 0x24, 0x00, + 0x10, 0x49, 0x20, 0x46, + 0xFF, 0xF7, 0x00, 0xFF, 0x00, 0x20, 0x10, 0xBD, 0x70, 0xB5, 0x04, 0x46, + 0x90, 0xF8, 0x24, 0x00, + 0x0D, 0x46, 0x02, 0x28, 0x0B, 0xD1, 0x20, 0x46, 0xFF, 0xF7, 0x19, 0xFF, + 0x03, 0x20, 0x84, 0xF8, + 0x24, 0x00, 0x29, 0x46, 0x20, 0x46, 0xFF, 0xF7, 0xED, 0xFE, 0xFF, 0xF7, + 0xD2, 0xFD, 0x00, 0x20, + 0x70, 0xBD, 0x04, 0x48, 0x00, 0x68, 0x40, 0x68, 0x70, 0x47, 0x00, 0x00, + 0x74, 0x09, 0x10, 0x00, + 0x0C, 0x04, 0x10, 0x00, 0x04, 0x04, 0x10, 0x00, 0xA4, 0x22, 0x4F, 0x49, + 0x16, 0xF0, 0x55, 0xBC, + 0x70, 0x47, 0x10, 0xB5, 0x04, 0x46, 0x80, 0x07, 0x02, 0xD0, 0x02, 0x20, + 0x16, 0xF0, 0xA3, 0xF8, + 0x4F, 0xF4, 0x80, 0x30, 0x20, 0x44, 0xC0, 0xF3, 0x4F, 0x00, 0x10, 0xBD, + 0x01, 0x46, 0xAC, 0x22, + 0x46, 0x48, 0x16, 0xF0, 0x87, 0xBC, 0x45, 0x4A, 0x5F, 0xF0, 0x00, 0x01, + 0x42, 0xF8, 0x21, 0x00, + 0x49, 0x1C, 0x26, 0x29, 0xFA, 0xDB, 0x70, 0x47, 0x00, 0xF0, 0xF6, 0xBE, + 0x00, 0xF0, 0x1B, 0xBF, + 0x1D, 0x20, 0x70, 0x47, 0x26, 0x20, 0x70, 0x47, 0x3D, 0x48, 0x10, 0xB5, + 0x00, 0x68, 0x10, 0xB1, + 0xBD, 0xE8, 0x10, 0x40, 0x00, 0x47, 0x00, 0x20, 0x16, 0xF0, 0x7D, 0xF8, + 0x10, 0xBD, 0x01, 0x29, + 0x12, 0xD0, 0x02, 0x29, 0x24, 0xD0, 0x03, 0x29, 0x0E, 0xD0, 0x04, 0x29, + 0x1D, 0xD1, 0x01, 0x78, + 0x21, 0xF0, 0x12, 0x01, 0x00, 0xF8, 0x35, 0x1B, 0x01, 0x7E, 0x21, 0xF0, + 0x03, 0x01, 0x01, 0x76, + 0xC1, 0x7F, 0x21, 0xF0, 0x80, 0x01, 0x22, 0xE0, 0x02, 0x78, 0x01, 0x29, + 0x42, 0xF0, 0x12, 0x02, + 0x02, 0x70, 0x0B, 0xD0, 0x5F, 0xF0, 0x03, 0x02, 0x10, 0xF8, 0x4D, 0x1F, + 0x62, 0xF3, 0x01, 0x01, + 0x01, 0x70, 0xC1, 0x79, 0x41, 0xF0, 0x80, 0x01, 0xC1, 0x71, 0x70, 0x47, + 0x01, 0x22, 0xF3, 0xE7, + 0x01, 0x78, 0x21, 0xF0, 0x02, 0x01, 0x41, 0xF0, 0x10, 0x01, 0x00, 0xF8, + 0x35, 0x1B, 0x01, 0x7E, + 0x21, 0xF0, 0x03, 0x01, 0x89, 0x1C, 0x01, 0x76, 0xC1, 0x7F, 0x41, 0xF0, + 0x80, 0x01, 0xC1, 0x77, + 0x70, 0x47, 0x90, 0xF8, 0x29, 0x20, 0x02, 0x29, 0x04, 0xD0, 0x03, 0x29, + 0x22, 0xF0, 0x40, 0x01, + 0x02, 0xD1, 0x04, 0xE0, 0x42, 0xF0, 0x40, 0x01, 0x21, 0xF0, 0x80, 0x01, + 0x01, 0xE0, 0x41, 0xF0, + 0x80, 0x01, 0x80, 0xF8, 0x29, 0x10, 0x70, 0x47, 0x90, 0xF8, 0x29, 0x20, + 0x01, 0x29, 0x04, 0xD0, + 0x02, 0x29, 0x07, 0xD0, 0x22, 0xF0, 0x10, 0x01, 0x01, 0xE0, 0x42, 0xF0, + 0x10, 0x01, 0x21, 0xF0, + 0x20, 0x01, 0x01, 0xE0, 0x42, 0xF0, 0x30, 0x01, 0x80, 0xF8, 0x29, 0x10, + 0x70, 0x47, 0xC2, 0x78, + 0x00, 0x29, 0x61, 0xF3, 0x03, 0x02, 0xC2, 0x70, 0x04, 0xD0, 0x10, 0xF8, + 0x5E, 0x1F, 0x41, 0xF0, + 0x04, 0x01, 0x01, 0x70, 0x70, 0x47, 0x00, 0x00, 0x48, 0x74, 0x01, 0x00, + 0xA4, 0x00, 0x03, 0x20, + 0x18, 0x04, 0x10, 0x00, 0x01, 0xEB, 0x81, 0x01, 0x02, 0xEB, 0xC1, 0x01, + 0x40, 0x5C, 0x01, 0x06, + 0x02, 0xD5, 0x00, 0xF0, 0x7F, 0x00, 0x40, 0x42, 0x70, 0x47, 0x00, 0x2B, + 0x04, 0xDA, 0x5B, 0x42, + 0xDB, 0xB2, 0x43, 0xF0, 0x80, 0x03, 0x01, 0xE0, 0x03, 0xF0, 0x7F, 0x03, + 0x01, 0xEB, 0x81, 0x01, + 0x02, 0xEB, 0xC1, 0x01, 0x43, 0x54, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x5F, + 0x00, 0x25, 0x17, 0x46, + 0x98, 0x46, 0x89, 0x46, 0x83, 0x46, 0x2E, 0x46, 0x4F, 0xF0, 0x01, 0x0A, + 0x0A, 0xFA, 0x05, 0xF0, + 0x10, 0xEA, 0x09, 0x0F, 0x14, 0xD0, 0x00, 0x24, 0x22, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x16, 0xF0, + 0x4D, 0xFB, 0x38, 0x40, 0x01, 0xEA, 0x08, 0x01, 0x08, 0x43, 0x05, 0xD0, + 0x00, 0x23, 0x22, 0x46, + 0x31, 0x46, 0x58, 0x46, 0xFF, 0xF7, 0xD1, 0xFF, 0x64, 0x1C, 0x26, 0x2C, + 0xEC, 0xDB, 0x76, 0x1C, + 0x6D, 0x1C, 0x1D, 0x2D, 0xE2, 0xDB, 0xBD, 0xE8, 0xF0, 0x9F, 0x40, 0x5C, + 0x01, 0x06, 0x02, 0xD5, + 0x00, 0xF0, 0x7F, 0x00, 0x40, 0x42, 0x70, 0x47, 0x00, 0x2A, 0x04, 0xDA, + 0x52, 0x42, 0xD2, 0xB2, + 0x42, 0xF0, 0x80, 0x02, 0x01, 0xE0, 0x02, 0xF0, 0x7F, 0x02, 0x42, 0x54, + 0x70, 0x47, 0xF0, 0xB5, + 0x00, 0x24, 0x16, 0x46, 0x0F, 0x46, 0x84, 0x46, 0x23, 0x46, 0x01, 0x25, + 0x10, 0xE0, 0x00, 0xBF, + 0x07, 0xEB, 0xE3, 0x00, 0x03, 0xF0, 0x07, 0x02, 0x01, 0x78, 0x05, 0xFA, + 0x02, 0xF0, 0x08, 0x42, + 0x05, 0xD0, 0x00, 0x22, 0x19, 0x46, 0x60, 0x46, 0xFF, 0xF7, 0xDE, 0xFF, + 0x64, 0x1C, 0x5B, 0x1C, + 0xB4, 0x42, 0xED, 0xDB, 0xF0, 0xBD, 0x40, 0x5C, 0x70, 0x47, 0x42, 0x54, + 0x70, 0x47, 0x00, 0x00, + 0x2D, 0xE9, 0xF0, 0x47, 0x34, 0x4C, 0x54, 0xF8, 0x3C, 0x8F, 0x67, 0x68, + 0xE6, 0x68, 0x25, 0x7C, + 0xDF, 0xF8, 0xC8, 0x90, 0x01, 0x21, 0xC9, 0xF8, 0x00, 0x10, 0x4F, 0xF4, + 0x20, 0x70, 0xFF, 0xF7, + 0xF9, 0xFB, 0x00, 0x21, 0xC9, 0xF8, 0x00, 0x10, 0xC4, 0xF8, 0x00, 0x80, + 0x67, 0x60, 0xE6, 0x60, + 0x25, 0x74, 0xBD, 0xE8, 0xF0, 0x87, 0x28, 0x48, 0x00, 0x21, 0xC1, 0x63, + 0x01, 0x64, 0x81, 0x64, + 0x80, 0xF8, 0x4C, 0x10, 0x70, 0x47, 0x10, 0xB5, 0x02, 0x46, 0x00, 0x24, + 0x4F, 0xF0, 0x01, 0x00, + 0x49, 0xB3, 0x00, 0x21, 0x16, 0xF0, 0xDA, 0xFA, 0x1F, 0x4A, 0x48, 0x32, + 0x10, 0x60, 0x11, 0x71, + 0xFF, 0xF7, 0xCE, 0xFF, 0x00, 0x20, 0x00, 0xF0, 0x25, 0xF8, 0x00, 0xB1, + 0x01, 0x24, 0xFF, 0xF7, + 0xC7, 0xFF, 0x01, 0x20, 0x00, 0xF0, 0x1E, 0xF8, 0x08, 0xB1, 0x44, 0xF0, + 0x02, 0x04, 0xFF, 0xF7, + 0xBF, 0xFF, 0x02, 0x20, 0x00, 0xF0, 0x16, 0xF8, 0x08, 0xB1, 0x44, 0xF0, + 0x04, 0x04, 0xFF, 0xF7, + 0xB7, 0xFF, 0x03, 0x20, 0x00, 0xF0, 0x0E, 0xF8, 0x08, 0xB1, 0x44, 0xF0, + 0x08, 0x04, 0xFF, 0xF7, + 0xAF, 0xFF, 0x20, 0x46, 0x10, 0xBD, 0x90, 0x40, 0x0B, 0x4A, 0x00, 0x21, + 0x3C, 0x32, 0xC2, 0xE9, + 0x00, 0x01, 0xD5, 0xE7, 0x40, 0xF0, 0x20, 0x01, 0x07, 0x48, 0x10, 0xB5, + 0x80, 0xF8, 0xA3, 0x10, + 0xE5, 0x21, 0x81, 0x71, 0x4F, 0xF4, 0x20, 0x70, 0xFF, 0xF7, 0xA4, 0xFB, + 0x04, 0x48, 0xD0, 0xF8, + 0xC0, 0x02, 0xC0, 0xB2, 0x10, 0xBD, 0x00, 0x00, 0x00, 0x00, 0x03, 0x20, + 0x68, 0x14, 0x60, 0x22, + 0x00, 0x10, 0x60, 0x22, 0x01, 0x49, 0x01, 0x20, 0x09, 0x68, 0x08, 0x47, + 0x1C, 0x04, 0x10, 0x00, + 0x10, 0xB5, 0xFF, 0xF7, 0x8B, 0xFE, 0x05, 0x49, 0x02, 0x20, 0x08, 0x70, + 0x04, 0x49, 0x00, 0x20, + 0x08, 0x60, 0x04, 0x49, 0x09, 0x68, 0xBD, 0xE8, 0x10, 0x40, 0x08, 0x47, + 0x14, 0x04, 0x10, 0x00, + 0x18, 0x04, 0x10, 0x00, 0x1C, 0x04, 0x10, 0x00, 0x37, 0xB5, 0x04, 0x46, + 0x37, 0x49, 0x01, 0x98, + 0x15, 0x46, 0x08, 0x40, 0x01, 0x90, 0x04, 0x21, 0x01, 0xA8, 0x00, 0xF0, + 0xFC, 0xFA, 0x01, 0x2D, + 0x02, 0xD0, 0x02, 0x2D, 0x04, 0xD0, 0x06, 0xE0, 0xC0, 0x1C, 0x20, 0xF0, + 0x01, 0x00, 0x02, 0xE0, + 0xC0, 0x1D, 0x20, 0xF0, 0x03, 0x00, 0x01, 0x99, 0x44, 0xF8, 0x3C, 0x1F, + 0x00, 0x21, 0x61, 0x60, + 0x21, 0x7A, 0x60, 0xF3, 0x06, 0x01, 0x21, 0x72, 0x3E, 0xBD, 0x01, 0x23, + 0x40, 0xF8, 0x3C, 0x3F, + 0x00, 0x23, 0x43, 0x60, 0x51, 0x43, 0x02, 0x7A, 0x61, 0xF3, 0x06, 0x02, + 0x02, 0x72, 0x70, 0x47, + 0x1F, 0xB5, 0x04, 0x46, 0x03, 0x99, 0x02, 0xA8, 0x01, 0xF0, 0x3F, 0x01, + 0x03, 0x91, 0x08, 0x21, + 0x00, 0xF0, 0xD1, 0xFA, 0xDD, 0xE9, 0x02, 0x12, 0xA1, 0x64, 0x84, 0xF8, + 0x4C, 0x20, 0x14, 0xF8, + 0x70, 0x1F, 0x60, 0xF3, 0x05, 0x01, 0x04, 0xF8, 0x1E, 0x19, 0xE1, 0x7F, + 0x60, 0xF3, 0x05, 0x01, + 0xE1, 0x77, 0x1F, 0xBD, 0x08, 0xB5, 0x16, 0xA2, 0x12, 0x68, 0x00, 0x92, + 0x1D, 0xF8, 0x01, 0x20, + 0x10, 0xF8, 0x5D, 0x1F, 0x62, 0xF3, 0x01, 0x01, 0x01, 0x70, 0x08, 0xBD, + 0x10, 0xB5, 0x82, 0x79, + 0x22, 0xF0, 0x0D, 0x02, 0x42, 0xF0, 0xE0, 0x02, 0x82, 0x71, 0x0E, 0x4A, + 0x11, 0x60, 0x0E, 0x4A, + 0x03, 0x21, 0x11, 0x70, 0x0E, 0x4A, 0x0D, 0x49, 0x11, 0x60, 0x01, 0x46, + 0xA4, 0x22, 0x0D, 0x48, + 0x16, 0xF0, 0x4B, 0xFA, 0x0C, 0x49, 0x01, 0x20, 0xC1, 0xF8, 0xC0, 0x00, + 0xBD, 0xE8, 0x10, 0x40, + 0x0A, 0x49, 0x4F, 0xF4, 0xFA, 0x70, 0xFF, 0xF7, 0x07, 0xBE, 0x00, 0x00, + 0xFF, 0xFF, 0x03, 0x1C, + 0x00, 0x01, 0x02, 0x00, 0x1C, 0x04, 0x10, 0x00, 0x14, 0x04, 0x10, 0x00, + 0x81, 0x0B, 0x00, 0x00, + 0x18, 0x04, 0x10, 0x00, 0x00, 0x00, 0x03, 0x20, 0x00, 0x00, 0x60, 0x22, + 0x75, 0x0B, 0x00, 0x00, + 0x16, 0x48, 0x01, 0x78, 0x01, 0x29, 0x08, 0xD1, 0x02, 0x21, 0x01, 0x70, + 0x14, 0x48, 0x01, 0x68, + 0x19, 0xB1, 0x00, 0x22, 0x02, 0x60, 0x10, 0x46, 0x08, 0x47, 0x01, 0x20, + 0x15, 0xF0, 0x73, 0xBE, + 0x0E, 0x4A, 0x01, 0x21, 0x11, 0x70, 0x0E, 0x49, 0x08, 0x60, 0x0E, 0x49, + 0xE8, 0x20, 0x88, 0x71, + 0x0D, 0x49, 0x02, 0x20, 0xFF, 0xF7, 0xD8, 0xBD, 0x0A, 0x49, 0x08, 0x20, + 0x88, 0x71, 0x0B, 0x49, + 0x00, 0x20, 0x08, 0x62, 0x05, 0x49, 0x08, 0x70, 0x05, 0x49, 0x08, 0x60, + 0x70, 0x47, 0x03, 0x48, + 0x00, 0x78, 0x00, 0x28, 0x00, 0xD0, 0x01, 0x20, 0x70, 0x47, 0x00, 0x00, + 0x14, 0x04, 0x10, 0x00, + 0x20, 0x04, 0x10, 0x00, 0x00, 0x00, 0x03, 0x20, 0xB1, 0x0C, 0x00, 0x00, + 0x00, 0x00, 0x60, 0x22, + 0x53, 0x49, 0x01, 0x20, 0x09, 0x68, 0x08, 0x47, 0x10, 0xB5, 0xFF, 0xF7, + 0xB7, 0xFD, 0x51, 0x49, + 0x02, 0x20, 0x08, 0x70, 0x50, 0x49, 0x00, 0x20, 0x08, 0x60, 0x4D, 0x49, + 0x09, 0x68, 0xBD, 0xE8, + 0x10, 0x40, 0x08, 0x47, 0x13, 0xB5, 0x04, 0x46, 0x4C, 0x49, 0x01, 0x98, + 0x08, 0x40, 0x01, 0x90, + 0x04, 0x21, 0x01, 0xA8, 0x00, 0xF0, 0x2F, 0xFA, 0x01, 0x99, 0x44, 0xF8, + 0x3C, 0x1F, 0x00, 0x21, + 0x61, 0x60, 0x14, 0xF8, 0x08, 0x1F, 0x60, 0xF3, 0x06, 0x01, 0x04, 0xF8, + 0x11, 0x1B, 0x61, 0x7F, + 0x60, 0xF3, 0x05, 0x01, 0x61, 0x77, 0xA1, 0x7F, 0x60, 0xF3, 0x05, 0x01, + 0xA1, 0x77, 0xE0, 0x7F, + 0x20, 0xF0, 0x08, 0x00, 0xE0, 0x77, 0x1C, 0xBD, 0x1F, 0xB5, 0x04, 0x46, + 0x03, 0x99, 0x02, 0xA8, + 0x01, 0xF0, 0x3F, 0x01, 0x03, 0x91, 0x08, 0x21, 0x00, 0xF0, 0x0D, 0xFA, + 0xDD, 0xE9, 0x02, 0x12, + 0xA1, 0x64, 0x84, 0xF8, 0x4C, 0x20, 0x14, 0xF8, 0x70, 0x1F, 0x60, 0xF3, + 0x05, 0x01, 0x04, 0xF8, + 0x1E, 0x19, 0xE1, 0x7F, 0x60, 0xF3, 0x05, 0x01, 0xE1, 0x77, 0x1F, 0xBD, + 0x10, 0xB5, 0x30, 0xA3, + 0x89, 0xB0, 0x1C, 0xCB, 0x8D, 0xE8, 0x1C, 0x00, 0x30, 0xA4, 0x0D, 0xF1, + 0x0C, 0x0C, 0x1C, 0xCC, + 0x8C, 0xE8, 0x1C, 0x00, 0x30, 0xA4, 0x0D, 0xF1, 0x18, 0x0C, 0x1C, 0xCC, + 0x8C, 0xE8, 0x1C, 0x00, + 0x03, 0xAA, 0x53, 0x5C, 0x42, 0x7E, 0x63, 0xF3, 0x05, 0x02, 0x42, 0x76, + 0x1D, 0xF8, 0x01, 0x30, + 0x02, 0x7E, 0x63, 0xF3, 0x42, 0x02, 0x02, 0x76, 0x06, 0xAA, 0x52, 0x5C, + 0x81, 0x79, 0x62, 0xF3, + 0x83, 0x01, 0x81, 0x71, 0x09, 0xB0, 0x10, 0xBD, 0x1A, 0x49, 0x04, 0x20, + 0x08, 0x70, 0x1A, 0x49, + 0x24, 0x48, 0x08, 0x60, 0x24, 0x49, 0x01, 0x20, 0xC1, 0xF8, 0xC0, 0x00, + 0x23, 0x49, 0x4F, 0xF4, + 0xFA, 0x70, 0xFF, 0xF7, 0x39, 0xBD, 0x10, 0xB5, 0xB0, 0xF8, 0x56, 0x20, + 0x42, 0xF0, 0x01, 0x02, + 0xA0, 0xF8, 0x56, 0x20, 0x82, 0x79, 0x22, 0xF0, 0x01, 0x02, 0x42, 0xF0, + 0xE0, 0x02, 0x82, 0x71, + 0x0B, 0x4A, 0x11, 0x60, 0x0B, 0x4A, 0x04, 0x21, 0x11, 0x70, 0x0B, 0x4A, + 0x15, 0x49, 0x11, 0x60, + 0x01, 0x46, 0xA4, 0x22, 0x16, 0x48, 0x16, 0xF0, 0x58, 0xF9, 0x13, 0x49, + 0x01, 0x20, 0xC1, 0xF8, + 0xC0, 0x00, 0xBD, 0xE8, 0x10, 0x40, 0x11, 0x49, 0x4F, 0xF4, 0xFA, 0x70, + 0xFF, 0xF7, 0x14, 0xBD, + 0x24, 0x04, 0x10, 0x00, 0x14, 0x04, 0x10, 0x00, 0x18, 0x04, 0x10, 0x00, + 0xFF, 0xFF, 0x03, 0x1C, + 0x00, 0x00, 0x02, 0x02, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x00, 0x00, + 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x02, 0x03, 0x02, 0x03, + 0x02, 0x03, 0x02, 0x03, + 0x02, 0x03, 0x00, 0x00, 0x29, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x60, 0x22, + 0x21, 0x0D, 0x00, 0x00, + 0x00, 0x00, 0x03, 0x20, 0x35, 0x49, 0x01, 0x20, 0x08, 0x60, 0x17, 0x22, + 0x41, 0x07, 0x01, 0xF8, + 0x27, 0x2F, 0x0B, 0x22, 0x81, 0xF8, 0x41, 0x20, 0x30, 0x49, 0x18, 0x39, + 0x08, 0x60, 0x4F, 0xF0, + 0x08, 0x51, 0xC1, 0xF8, 0xC4, 0x03, 0x2D, 0x4A, 0x00, 0x21, 0xB0, 0x32, + 0x11, 0x60, 0x2C, 0x49, + 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x29, 0x49, 0x94, 0x39, 0x08, 0x60, + 0x70, 0x47, 0x4F, 0xF0, + 0x00, 0x50, 0x00, 0x88, 0x70, 0x47, 0x4F, 0xF0, 0x00, 0x50, 0x80, 0x78, + 0x70, 0x47, 0x4F, 0xF0, + 0x00, 0x51, 0x88, 0x80, 0x70, 0x47, 0x21, 0x49, 0x01, 0x20, 0x30, 0x39, + 0x08, 0x60, 0x70, 0x47, + 0x4F, 0xF0, 0x00, 0x50, 0x10, 0xF8, 0x22, 0x1F, 0x21, 0xF0, 0x03, 0x01, + 0x01, 0x70, 0x70, 0x47, + 0x4F, 0xF0, 0x00, 0x53, 0x03, 0xF8, 0x1F, 0x0F, 0x59, 0x70, 0x98, 0x78, + 0x62, 0xF3, 0x03, 0x00, + 0x98, 0x70, 0x70, 0x47, 0x17, 0x48, 0x00, 0x68, 0x70, 0x47, 0x16, 0x49, + 0x08, 0x60, 0x70, 0x47, + 0x10, 0xB5, 0x4F, 0xF0, 0x00, 0x54, 0xE2, 0x7E, 0x22, 0xF0, 0xAF, 0x03, + 0x20, 0x22, 0x02, 0xEA, + 0x40, 0x12, 0x1A, 0x43, 0x04, 0x23, 0x03, 0xEA, 0x80, 0x00, 0x02, 0x43, + 0x01, 0xF0, 0x03, 0x00, + 0x02, 0x43, 0xE2, 0x76, 0x10, 0xBD, 0x4F, 0xF0, 0x00, 0x50, 0x90, 0xF8, + 0x22, 0x00, 0x10, 0xF0, + 0x03, 0x00, 0x05, 0xD0, 0x01, 0x28, 0x05, 0xD0, 0x02, 0x28, 0x05, 0xD0, + 0x06, 0x48, 0x70, 0x47, + 0x06, 0x48, 0x70, 0x47, 0x06, 0x48, 0x70, 0x47, 0x06, 0x48, 0x70, 0x47, + 0xCC, 0x04, 0x00, 0x22, + 0x80, 0x1E, 0x00, 0x22, 0x28, 0x04, 0x10, 0x00, 0x00, 0x12, 0x7A, 0x00, + 0x00, 0x90, 0xD0, 0x03, + 0x00, 0x48, 0xE8, 0x01, 0x00, 0x24, 0xF4, 0x00, 0x30, 0xB5, 0x6C, 0x4C, + 0x01, 0x25, 0x25, 0x60, + 0xE5, 0x06, 0x03, 0xF0, 0x1F, 0x03, 0x85, 0xF8, 0x6B, 0x30, 0x00, 0x23, + 0x05, 0xE0, 0x00, 0xBF, + 0x51, 0xF8, 0x23, 0x50, 0x40, 0xF8, 0x23, 0x50, 0x5B, 0x1C, 0x93, 0x42, + 0xF8, 0xDB, 0x00, 0x20, + 0x20, 0x60, 0x30, 0xBD, 0xF0, 0xB5, 0x06, 0x46, 0x00, 0x20, 0x04, 0x46, + 0xDF, 0xF8, 0x80, 0xC1, + 0x14, 0xE0, 0x56, 0xF8, 0x24, 0x70, 0x03, 0x23, 0xDD, 0x00, 0x47, 0xFA, + 0x05, 0xF2, 0x80, 0xEA, + 0x02, 0x60, 0x08, 0x25, 0x00, 0x28, 0x02, 0xDA, 0x8C, 0xEA, 0x40, 0x00, + 0x00, 0xE0, 0x40, 0x00, + 0x6D, 0x1E, 0x00, 0x2D, 0xF6, 0xDC, 0x5B, 0x1E, 0xEE, 0xD5, 0x64, 0x1C, + 0x8C, 0x42, 0xE8, 0xDB, + 0xF0, 0xBD, 0xF0, 0xB5, 0xB1, 0xB0, 0x07, 0x46, 0x6D, 0x46, 0x52, 0x4E, + 0x01, 0x24, 0xC0, 0x21, + 0x28, 0x46, 0x16, 0xF0, 0x13, 0xF9, 0x00, 0x20, 0x56, 0xF8, 0x20, 0x10, + 0x45, 0xF8, 0x20, 0x10, + 0x40, 0x1C, 0x30, 0x28, 0xF8, 0xD3, 0x4C, 0x49, 0x00, 0x98, 0x88, 0x42, + 0x10, 0xD1, 0x02, 0x98, + 0x81, 0xB2, 0x05, 0xA8, 0x04, 0x46, 0xFF, 0xF7, 0xC5, 0xFF, 0x01, 0x99, + 0x81, 0x42, 0x06, 0xD1, + 0xAC, 0x22, 0x21, 0x46, 0x38, 0x46, 0x16, 0xF0, 0x9D, 0xF8, 0x00, 0x24, + 0x00, 0xE0, 0x03, 0x24, + 0x31, 0xB0, 0x20, 0x46, 0xF0, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x41, 0x4D, + 0x07, 0x46, 0x3F, 0x4E, + 0x01, 0x24, 0x4F, 0xF4, 0x58, 0x71, 0x28, 0x46, 0x16, 0xF0, 0xE8, 0xF8, + 0x5F, 0xF0, 0x00, 0x00, + 0x56, 0xF8, 0x20, 0x10, 0x45, 0xF8, 0x20, 0x10, 0x40, 0x1C, 0xD8, 0x28, + 0xF8, 0xD3, 0x38, 0x4D, + 0x38, 0x49, 0x28, 0x68, 0x88, 0x42, 0x12, 0xD1, 0x28, 0x89, 0x81, 0xB2, + 0x05, 0xF1, 0x14, 0x00, + 0xFF, 0xF7, 0x98, 0xFF, 0x69, 0x68, 0x81, 0x42, 0x08, 0xD1, 0x4F, 0xF4, + 0x52, 0x72, 0x05, 0xF1, + 0x18, 0x01, 0x38, 0x46, 0x16, 0xF0, 0x29, 0xF8, 0x00, 0x24, 0x00, 0xE0, + 0x03, 0x24, 0x20, 0x46, + 0xBD, 0xE8, 0xF0, 0x81, 0x70, 0xB5, 0x94, 0xB0, 0x04, 0x46, 0x6D, 0x46, + 0x2A, 0x4E, 0x50, 0x21, + 0x28, 0x46, 0x16, 0xF0, 0xBB, 0xF8, 0x00, 0x20, 0x56, 0xF8, 0x20, 0x10, + 0x45, 0xF8, 0x20, 0x10, + 0x40, 0x1C, 0x14, 0x28, 0xF8, 0xD3, 0x25, 0x49, 0x00, 0x98, 0x6F, 0xF0, + 0x02, 0x05, 0x88, 0x42, + 0x2E, 0xD1, 0xA8, 0x10, 0x20, 0x60, 0x60, 0x60, 0xA0, 0x60, 0xE0, 0x60, + 0x20, 0x61, 0x02, 0x98, + 0x81, 0xB2, 0x05, 0xA8, 0xFF, 0xF7, 0x66, 0xFF, 0x01, 0x99, 0x81, 0x42, + 0x20, 0xD1, 0xBD, 0xF8, + 0x38, 0x10, 0x45, 0xF2, 0xAA, 0x50, 0x81, 0x42, 0x0C, 0xD1, 0x9D, 0xF8, + 0x1D, 0x10, 0x21, 0x60, + 0x9D, 0xF8, 0x1C, 0x10, 0x01, 0xF0, 0x0F, 0x01, 0x61, 0x60, 0x9D, 0xF8, + 0x1E, 0x10, 0x01, 0xF0, + 0x0F, 0x01, 0xA1, 0x60, 0xBD, 0xF8, 0x3C, 0x10, 0x81, 0x42, 0x01, 0xD1, + 0x08, 0x99, 0xE1, 0x60, + 0xBD, 0xF8, 0x40, 0x10, 0x81, 0x42, 0x01, 0xD1, 0x09, 0x98, 0x20, 0x61, + 0x14, 0xB0, 0x70, 0xBD, + 0x25, 0x60, 0x65, 0x60, 0xA5, 0x60, 0xE5, 0x60, 0x25, 0x61, 0xF7, 0xE7, + 0xC4, 0x1B, 0x00, 0x22, + 0x1B, 0x00, 0x00, 0x80, 0x48, 0x1D, 0x04, 0x00, 0xB2, 0x57, 0x0E, 0x70, + 0xE8, 0x19, 0x04, 0x00, + 0x54, 0x0B, 0x10, 0x00, 0xA1, 0x46, 0x0D, 0x60, 0xAC, 0x1E, 0x04, 0x00, + 0x5C, 0x00, 0x0D, 0x60, + 0xF0, 0xB5, 0x07, 0x46, 0x00, 0x20, 0x03, 0x46, 0x2F, 0x4E, 0x11, 0xE0, + 0x57, 0xF8, 0x23, 0x50, + 0x03, 0x22, 0x00, 0xBF, 0x4F, 0xEA, 0xC2, 0x0C, 0x45, 0xFA, 0x0C, 0xF4, + 0x84, 0xEA, 0x20, 0x64, + 0xE4, 0xB2, 0x52, 0x1E, 0x56, 0xF8, 0x24, 0x40, 0x84, 0xEA, 0x00, 0x20, + 0xF2, 0xD5, 0x5B, 0x1C, + 0x8B, 0x42, 0xEB, 0xDB, 0xF0, 0xBD, 0x30, 0xB5, 0x02, 0x46, 0x23, 0x4B, + 0x00, 0x20, 0x10, 0x3B, + 0x08, 0xE0, 0x54, 0x5C, 0x04, 0xF0, 0x0F, 0x05, 0x03, 0xEB, 0x14, 0x14, + 0x5D, 0x5D, 0x24, 0x78, + 0x28, 0x44, 0x20, 0x44, 0x49, 0x1E, 0xF4, 0xD2, 0x30, 0xBD, 0x10, 0xB5, + 0x84, 0x68, 0x03, 0x68, + 0xE4, 0x43, 0xA3, 0x42, 0x0A, 0xD1, 0xC4, 0x68, 0x43, 0x68, 0xE4, 0x43, + 0xA3, 0x42, 0x05, 0xD1, + 0x5B, 0x1C, 0x0B, 0x60, 0x00, 0x68, 0x10, 0x60, 0x01, 0x20, 0x10, 0xBD, + 0x00, 0x20, 0x10, 0xBD, + 0x3C, 0xB5, 0x04, 0x46, 0x00, 0x25, 0x01, 0xAA, 0x69, 0x46, 0xFF, 0xF7, + 0xE6, 0xFF, 0x01, 0x28, + 0x09, 0xD1, 0x00, 0x99, 0x04, 0xF1, 0x10, 0x00, 0x09, 0x1F, 0xFF, 0xF7, + 0xB1, 0xFF, 0x01, 0x99, + 0x88, 0x42, 0x00, 0xD1, 0x01, 0x25, 0x28, 0x46, 0x3C, 0xBD, 0x30, 0xB5, + 0x0D, 0x46, 0x04, 0x46, + 0x09, 0x1F, 0x10, 0x30, 0xFF, 0xF7, 0xA4, 0xFF, 0x6D, 0x1E, 0x65, 0x60, + 0xE9, 0x43, 0xE1, 0x60, + 0x20, 0x60, 0xC0, 0x43, 0xA0, 0x60, 0x30, 0xBD, 0xFC, 0x74, 0x01, 0x00, + 0x4F, 0xF0, 0x00, 0x50, + 0x00, 0x21, 0x80, 0xF8, 0x3D, 0x10, 0x80, 0xF8, 0x3E, 0x10, 0x80, 0xF8, + 0x3F, 0x10, 0x3F, 0x22, + 0x80, 0xF8, 0x32, 0x20, 0x00, 0xF8, 0x30, 0x1F, 0x02, 0x71, 0x41, 0x71, + 0x42, 0x70, 0x01, 0x72, + 0x41, 0x72, 0x81, 0x72, 0xC1, 0x72, 0xC1, 0x71, 0x70, 0x47, 0x28, 0x4A, + 0x10, 0x60, 0x27, 0x48, + 0x0C, 0x30, 0x01, 0x60, 0x70, 0x47, 0x30, 0xB5, 0x01, 0x24, 0x84, 0x40, + 0x4F, 0xF0, 0x00, 0x50, + 0x00, 0x29, 0x03, 0x9D, 0x90, 0xF8, 0x32, 0x10, 0xE4, 0xB2, 0x01, 0xD0, + 0x21, 0x43, 0x00, 0xE0, + 0xA1, 0x43, 0x80, 0xF8, 0x32, 0x10, 0x90, 0xF8, 0x30, 0x10, 0x0A, 0xB1, + 0x21, 0x43, 0x00, 0xE0, + 0xA1, 0x43, 0x80, 0xF8, 0x30, 0x10, 0x90, 0xF8, 0x34, 0x10, 0x0B, 0xB1, + 0x21, 0x43, 0x00, 0xE0, + 0xA1, 0x43, 0x80, 0xF8, 0x34, 0x10, 0x10, 0xF8, 0x35, 0x1F, 0x0D, 0xB1, + 0x21, 0x43, 0x00, 0xE0, + 0xA1, 0x43, 0x01, 0x70, 0x30, 0xBD, 0x4F, 0xF0, 0x00, 0x52, 0x06, 0x28, + 0x17, 0xD2, 0xDF, 0xE8, + 0x00, 0xF0, 0x03, 0x06, 0x09, 0x0F, 0x17, 0x1A, 0x12, 0xF8, 0x3D, 0x0F, + 0x04, 0xE0, 0x12, 0xF8, + 0x3D, 0x0F, 0x07, 0xE0, 0x12, 0xF8, 0x3E, 0x0F, 0x20, 0xF0, 0x0F, 0x00, + 0x08, 0x43, 0x05, 0xE0, + 0x12, 0xF8, 0x3E, 0x0F, 0x20, 0xF0, 0xF0, 0x00, 0x40, 0xEA, 0x01, 0x10, + 0x10, 0x70, 0x70, 0x47, + 0x12, 0xF8, 0x3F, 0x0F, 0xF0, 0xE7, 0x12, 0xF8, 0x3F, 0x0F, 0xF3, 0xE7, + 0x38, 0x05, 0x00, 0x22, + 0xF0, 0xB5, 0x63, 0x4C, 0xD0, 0xE9, 0x00, 0x25, 0x01, 0x21, 0xE3, 0x1D, + 0x06, 0x7A, 0xFF, 0x27, + 0x48, 0x07, 0x80, 0xF8, 0xE5, 0x70, 0x80, 0xF8, 0xE4, 0x70, 0x00, 0x27, + 0xC0, 0xF8, 0xC0, 0x70, + 0xC0, 0xF8, 0xE8, 0x70, 0x80, 0xF8, 0xE1, 0x70, 0x80, 0xF8, 0xE3, 0x70, + 0x8E, 0x46, 0x58, 0xE0, + 0x17, 0x78, 0x04, 0xF8, 0x01, 0x7B, 0x2F, 0x88, 0x23, 0xF8, 0x02, 0x7B, + 0xD7, 0x78, 0x01, 0x2F, + 0x02, 0xD0, 0x02, 0x2F, 0x09, 0xD0, 0x10, 0xE0, 0x90, 0xF8, 0xE4, 0x70, + 0x0E, 0xFA, 0x01, 0xFC, + 0x27, 0xEA, 0x0C, 0x07, 0x80, 0xF8, 0xE4, 0x70, 0x07, 0xE0, 0x90, 0xF8, + 0xE5, 0x70, 0x0E, 0xFA, + 0x01, 0xFC, 0x27, 0xEA, 0x0C, 0x07, 0x80, 0xF8, 0xE5, 0x70, 0x4F, 0x1E, + 0x07, 0xEB, 0x47, 0x0C, + 0x27, 0xF0, 0x01, 0x07, 0xBC, 0x44, 0x57, 0x78, 0x07, 0xF0, 0x07, 0x07, + 0x07, 0xFA, 0x0C, 0xF7, + 0xD0, 0xF8, 0xC0, 0xC0, 0x47, 0xEA, 0x0C, 0x07, 0xC0, 0xF8, 0xC0, 0x70, + 0x97, 0x78, 0x4F, 0xEA, + 0x81, 0x0C, 0x07, 0xF0, 0x0F, 0x07, 0xAC, 0xF1, 0x04, 0x0C, 0x07, 0xFA, + 0x0C, 0xF7, 0xD0, 0xF8, + 0xE8, 0xC0, 0x47, 0xEA, 0x0C, 0x07, 0xC0, 0xF8, 0xE8, 0x70, 0x17, 0x79, + 0xFF, 0x07, 0x07, 0xD0, + 0x90, 0xF8, 0xE1, 0xC0, 0x0E, 0xFA, 0x01, 0xF7, 0x4C, 0xEA, 0x07, 0x0C, + 0x80, 0xF8, 0xE1, 0xC0, + 0x17, 0x79, 0xFF, 0x06, 0x07, 0xD5, 0x90, 0xF8, 0xE3, 0x70, 0x0E, 0xFA, + 0x01, 0xFC, 0x47, 0xEA, + 0x0C, 0x07, 0x80, 0xF8, 0xE3, 0x70, 0x49, 0x1C, 0x08, 0x29, 0x04, 0xD2, + 0x52, 0x1D, 0xAD, 0x1C, + 0x76, 0x1E, 0x00, 0x2E, 0xA4, 0xD1, 0xD0, 0xF8, 0xE8, 0x10, 0x41, 0x64, + 0xF0, 0xBD, 0xF0, 0xB5, + 0x27, 0x4D, 0x28, 0x49, 0x01, 0x26, 0xEC, 0x1D, 0xC3, 0x79, 0x00, 0x22, + 0x07, 0x68, 0x4A, 0x60, + 0x09, 0x04, 0x4F, 0xF0, 0xFF, 0x0E, 0x81, 0xF8, 0xE5, 0xE0, 0x81, 0xF8, + 0xE4, 0x60, 0xC1, 0xF8, + 0xC0, 0x20, 0x81, 0xF8, 0xE1, 0x20, 0x81, 0xF8, 0xE3, 0x20, 0x18, 0xE0, + 0x97, 0xF8, 0x00, 0xC0, + 0x05, 0xF8, 0x01, 0xCB, 0xB0, 0xF8, 0x04, 0xC0, 0x24, 0xF8, 0x02, 0xCB, + 0x90, 0xF8, 0x06, 0xC0, + 0x4F, 0xEA, 0x86, 0x0E, 0x0C, 0xF0, 0x0F, 0x0C, 0xAE, 0xF1, 0x04, 0x0E, + 0x0C, 0xFA, 0x0E, 0xFC, + 0x76, 0x1C, 0x4C, 0xEA, 0x02, 0x02, 0x08, 0x2E, 0x03, 0xD2, 0x5B, 0x1E, + 0x7F, 0x1C, 0x00, 0x2B, + 0xE4, 0xD1, 0xC1, 0xF8, 0xE8, 0x20, 0x4A, 0x64, 0xF0, 0xBD, 0x0D, 0x4A, + 0xD2, 0x1D, 0x22, 0xF8, + 0x10, 0x10, 0x70, 0x47, 0x10, 0xB5, 0x04, 0x46, 0x0B, 0x48, 0x00, 0x68, + 0x38, 0xB1, 0xA0, 0x68, + 0xFF, 0xF7, 0x46, 0xFF, 0x20, 0x68, 0xBD, 0xE8, 0x10, 0x40, 0x00, 0xF0, + 0x0F, 0xB8, 0xE0, 0x68, + 0xFF, 0xF7, 0x3E, 0xFF, 0x60, 0x68, 0xBD, 0xE8, 0x10, 0x40, 0x00, 0xF0, + 0xAB, 0xB8, 0x00, 0x00, + 0xAB, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x22, 0xBC, 0x05, 0x00, 0x22, + 0x10, 0xB5, 0x4F, 0x49, + 0x02, 0x68, 0x00, 0x24, 0x8A, 0x60, 0x82, 0x88, 0x4A, 0x80, 0x03, 0x89, + 0x8B, 0x80, 0x0C, 0x70, + 0x4F, 0xF0, 0x00, 0x51, 0xA1, 0xF8, 0x1A, 0x31, 0xA1, 0xF8, 0x1E, 0x21, + 0xC0, 0x88, 0xA1, 0xF8, + 0x20, 0x01, 0x47, 0x48, 0x01, 0x21, 0xC0, 0xF8, 0xD8, 0x11, 0xC0, 0xF8, + 0xDC, 0x11, 0xC0, 0xF8, + 0xC4, 0x11, 0xC0, 0xF8, 0xCC, 0x11, 0xC0, 0xF8, 0xD4, 0x11, 0xC0, 0xF8, + 0x80, 0x11, 0x72, 0xB6, + 0xD0, 0xF8, 0x08, 0x22, 0x00, 0x2A, 0xFB, 0xD1, 0x41, 0x60, 0x62, 0xB6, + 0x10, 0xBD, 0x2D, 0xE9, + 0xF0, 0x41, 0x3B, 0x4C, 0xD4, 0xF8, 0x5C, 0x01, 0x38, 0x4E, 0x25, 0x04, + 0x01, 0x27, 0xB2, 0x68, + 0x50, 0xB3, 0xB5, 0xF8, 0x1C, 0x81, 0x5F, 0xEA, 0x08, 0x00, 0x0F, 0xD0, + 0xD4, 0xF8, 0x54, 0x01, + 0x10, 0xB9, 0xD4, 0xF8, 0x00, 0x01, 0x48, 0xB1, 0x41, 0x46, 0x01, 0x20, + 0x90, 0x47, 0xC4, 0xF8, + 0xD8, 0x72, 0xD4, 0xF8, 0x54, 0x01, 0x08, 0xB1, 0xC4, 0xF8, 0xD4, 0x72, + 0xB2, 0x68, 0x41, 0x46, + 0x02, 0x20, 0x90, 0x47, 0x01, 0x78, 0x02, 0x29, 0x02, 0xD0, 0x03, 0x29, + 0x02, 0xD0, 0x08, 0xE0, + 0x41, 0x88, 0x00, 0xE0, 0x71, 0x88, 0xA5, 0xF8, 0x1E, 0x11, 0x80, 0x88, + 0xA5, 0xF8, 0x1A, 0x01, + 0x37, 0x70, 0xC4, 0xF8, 0xDC, 0x72, 0x38, 0xE0, 0xD4, 0xF8, 0x44, 0x01, + 0x80, 0xB1, 0xB5, 0xF8, + 0x1C, 0x11, 0x03, 0x20, 0x90, 0x47, 0x30, 0x78, 0x38, 0xB1, 0x70, 0x88, + 0xA5, 0xF8, 0x1E, 0x01, + 0xB0, 0x88, 0xA5, 0xF8, 0x1A, 0x01, 0x00, 0x20, 0x30, 0x70, 0xC4, 0xF8, + 0xC4, 0x72, 0x24, 0xE0, + 0xD4, 0xF8, 0x58, 0x01, 0x30, 0xB1, 0xB5, 0xF8, 0x1C, 0x11, 0x01, 0x20, + 0x90, 0x47, 0xC4, 0xF8, + 0xD8, 0x72, 0x1A, 0xE0, 0xD4, 0xF8, 0x4C, 0x01, 0x28, 0xB9, 0xD4, 0xF8, + 0x54, 0x01, 0x10, 0xB9, + 0xD4, 0xF8, 0x00, 0x01, 0x88, 0xB1, 0xB5, 0xF8, 0x1C, 0x11, 0x19, 0xB1, + 0x01, 0x20, 0x90, 0x47, + 0xC4, 0xF8, 0xD8, 0x72, 0xD4, 0xF8, 0x4C, 0x01, 0x10, 0xB1, 0xC4, 0xF8, + 0xCC, 0x72, 0x04, 0xE0, + 0xD4, 0xF8, 0x54, 0x01, 0x08, 0xB1, 0xC4, 0xF8, 0xD4, 0x72, 0xD4, 0xF8, + 0x00, 0x01, 0x00, 0x28, + 0x01, 0xD0, 0xC4, 0xF8, 0x80, 0x72, 0xBD, 0xE8, 0xF0, 0x81, 0x00, 0x00, + 0x2C, 0x04, 0x10, 0x00, + 0x00, 0x20, 0x00, 0x22, 0xC1, 0x7D, 0x01, 0x29, 0x05, 0xD1, 0x49, 0x07, + 0x11, 0xF8, 0x2D, 0x2F, + 0x42, 0xF0, 0x02, 0x02, 0x0A, 0x70, 0x04, 0x49, 0x02, 0x68, 0x4A, 0x60, + 0x42, 0x68, 0x8A, 0x60, + 0x80, 0x7D, 0x08, 0x70, 0x70, 0x47, 0x00, 0x00, 0x38, 0x04, 0x10, 0x00, + 0xE9, 0x49, 0x00, 0x20, + 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x09, 0x1D, + 0x08, 0x60, 0x09, 0x1D, + 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x09, 0x1D, + 0x08, 0x60, 0xE2, 0x49, + 0x01, 0x22, 0x0A, 0x60, 0xE0, 0x49, 0x14, 0x31, 0x08, 0x60, 0x51, 0x07, + 0x01, 0xF8, 0x50, 0x0F, + 0xF0, 0x23, 0x4B, 0x70, 0x0F, 0x23, 0x01, 0xF8, 0x05, 0x3C, 0x10, 0x23, + 0x4B, 0x80, 0x8A, 0x80, + 0xDA, 0x49, 0x08, 0x60, 0x48, 0x60, 0x88, 0x60, 0xC8, 0x60, 0x08, 0x61, + 0x48, 0x61, 0x88, 0x61, + 0xC8, 0x61, 0x08, 0x62, 0x70, 0x47, 0x70, 0x47, 0xD4, 0x4A, 0x11, 0x60, + 0xD1, 0x49, 0x00, 0x22, + 0x0A, 0x60, 0x00, 0xEB, 0xC0, 0x02, 0x02, 0xEB, 0x00, 0x10, 0x4F, 0xF6, + 0xFF, 0x72, 0x02, 0xEA, + 0x80, 0x00, 0x4F, 0xF0, 0x00, 0x52, 0xA2, 0xF8, 0x58, 0x00, 0x01, 0x20, + 0x08, 0x60, 0x70, 0x47, + 0x4F, 0xF0, 0x00, 0x50, 0x90, 0xF8, 0x22, 0x00, 0xC0, 0xF3, 0x81, 0x00, + 0x28, 0xB1, 0x01, 0x28, + 0x05, 0xD0, 0x02, 0x28, 0x05, 0xD0, 0xC6, 0x48, 0x70, 0x47, 0xC6, 0x48, + 0x70, 0x47, 0xC6, 0x48, + 0x70, 0x47, 0xC6, 0x48, 0x70, 0x47, 0x70, 0xB5, 0x4F, 0xF0, 0x00, 0x54, + 0x72, 0xB6, 0x65, 0x69, + 0x60, 0x69, 0x40, 0xF0, 0x04, 0x00, 0x60, 0x61, 0xBA, 0x49, 0x00, 0x20, + 0x08, 0x60, 0xB4, 0xF8, + 0x58, 0x10, 0x09, 0xB1, 0xA4, 0xF8, 0x58, 0x00, 0xFF, 0xF7, 0x35, 0xFC, + 0x01, 0x46, 0xFF, 0xF7, + 0xD7, 0xFF, 0xB1, 0xFB, 0xF0, 0xF0, 0xFE, 0xF7, 0xCD, 0xFD, 0x65, 0x61, + 0x02, 0x20, 0x00, 0xF0, + 0x56, 0xF9, 0x62, 0xB6, 0x70, 0xBD, 0xB1, 0x48, 0x10, 0xB5, 0x00, 0x21, + 0x04, 0x68, 0x01, 0x60, + 0xFF, 0xF7, 0xD9, 0xFF, 0x1C, 0xB1, 0xA4, 0x46, 0xBD, 0xE8, 0x10, 0x40, + 0x60, 0x47, 0x00, 0x20, + 0xFF, 0xF7, 0xA9, 0xFF, 0x10, 0xBD, 0xA9, 0x4A, 0x51, 0x60, 0xA6, 0x49, + 0x00, 0x22, 0x09, 0x1D, + 0x0A, 0x60, 0x00, 0xEB, 0xC0, 0x02, 0x02, 0xEB, 0x00, 0x10, 0x4F, 0xF6, + 0xFF, 0x72, 0x02, 0xEA, + 0x80, 0x00, 0xCA, 0x06, 0xA2, 0xF8, 0x5A, 0x00, 0x01, 0x20, 0x08, 0x60, + 0x70, 0x47, 0x70, 0xB5, + 0x4F, 0xF0, 0x00, 0x54, 0x72, 0xB6, 0x65, 0x69, 0x60, 0x69, 0x40, 0xF0, + 0x08, 0x00, 0x60, 0x61, + 0x98, 0x49, 0x00, 0x20, 0x09, 0x1D, 0x08, 0x60, 0xB4, 0xF8, 0x5A, 0x10, + 0x09, 0xB1, 0xA4, 0xF8, + 0x5A, 0x00, 0xFF, 0xF7, 0xF0, 0xFB, 0x01, 0x46, 0xFF, 0xF7, 0x92, 0xFF, + 0xB1, 0xFB, 0xF0, 0xF0, + 0xFE, 0xF7, 0x88, 0xFD, 0x65, 0x61, 0x03, 0x20, 0x00, 0xF0, 0x11, 0xF9, + 0x62, 0xB6, 0x70, 0xBD, + 0x8E, 0x48, 0x10, 0xB5, 0x00, 0x21, 0x44, 0x68, 0x41, 0x60, 0xFF, 0xF7, + 0xD8, 0xFF, 0x1C, 0xB1, + 0xA4, 0x46, 0xBD, 0xE8, 0x10, 0x40, 0x60, 0x47, 0x01, 0x20, 0xFF, 0xF7, + 0x64, 0xFF, 0x10, 0xBD, + 0x70, 0xB5, 0x4F, 0xF0, 0x00, 0x54, 0x72, 0xB6, 0x65, 0x69, 0x60, 0x69, + 0x40, 0xF0, 0x10, 0x00, + 0x60, 0x61, 0x80, 0x49, 0x00, 0x20, 0x08, 0x31, 0x08, 0x60, 0xB4, 0xF8, + 0x5C, 0x10, 0x09, 0xB1, + 0xA4, 0xF8, 0x5C, 0x00, 0xFF, 0xF7, 0xBF, 0xFB, 0x01, 0x46, 0xFF, 0xF7, + 0x61, 0xFF, 0xB1, 0xFB, + 0xF0, 0xF0, 0xFE, 0xF7, 0x57, 0xFD, 0x65, 0x61, 0x04, 0x20, 0x00, 0xF0, + 0xE0, 0xF8, 0x62, 0xB6, + 0x70, 0xBD, 0x76, 0x48, 0x10, 0xB5, 0x00, 0x21, 0x84, 0x68, 0x81, 0x60, + 0xFF, 0xF7, 0xD8, 0xFF, + 0x1C, 0xB1, 0xA4, 0x46, 0xBD, 0xE8, 0x10, 0x40, 0x60, 0x47, 0x02, 0x20, + 0xFF, 0xF7, 0x33, 0xFF, + 0x10, 0xBD, 0x70, 0xB5, 0x4F, 0xF0, 0x00, 0x54, 0x72, 0xB6, 0x65, 0x69, + 0x60, 0x69, 0x40, 0xF0, + 0x20, 0x00, 0x60, 0x61, 0x67, 0x49, 0x00, 0x20, 0x0C, 0x31, 0x08, 0x60, + 0xB4, 0xF8, 0x5E, 0x10, + 0x09, 0xB1, 0xA4, 0xF8, 0x5E, 0x00, 0xFF, 0xF7, 0x8E, 0xFB, 0x01, 0x46, + 0xFF, 0xF7, 0x30, 0xFF, + 0xB1, 0xFB, 0xF0, 0xF0, 0xFE, 0xF7, 0x26, 0xFD, 0x65, 0x61, 0x05, 0x20, + 0x00, 0xF0, 0xAF, 0xF8, + 0x62, 0xB6, 0x70, 0xBD, 0x5D, 0x48, 0x10, 0xB5, 0x00, 0x21, 0xC4, 0x68, + 0xC1, 0x60, 0xFF, 0xF7, + 0xD8, 0xFF, 0x1C, 0xB1, 0xA4, 0x46, 0xBD, 0xE8, 0x10, 0x40, 0x60, 0x47, + 0x03, 0x20, 0xFF, 0xF7, + 0x02, 0xFF, 0x10, 0xBD, 0x4F, 0xF0, 0x00, 0x50, 0xB0, 0xF8, 0x60, 0x00, + 0x70, 0x47, 0x53, 0x49, + 0x10, 0xB5, 0x00, 0x22, 0x08, 0x69, 0x0A, 0x61, 0x4E, 0x49, 0x10, 0x31, + 0x0A, 0x60, 0x10, 0xB1, + 0xBD, 0xE8, 0x10, 0x40, 0x00, 0x47, 0x04, 0x20, 0xFF, 0xF7, 0xED, 0xFE, + 0x10, 0xBD, 0x4B, 0x4A, + 0x00, 0x23, 0x51, 0x61, 0x47, 0x49, 0x14, 0x31, 0x0B, 0x60, 0x12, 0x6A, + 0x50, 0x43, 0x4F, 0xF0, + 0x00, 0x52, 0x80, 0x09, 0xA2, 0xF8, 0x62, 0x00, 0x01, 0x20, 0x08, 0x60, + 0x70, 0x47, 0x41, 0x49, + 0x00, 0x20, 0x14, 0x31, 0x08, 0x60, 0x70, 0x47, 0x40, 0x49, 0x10, 0xB5, + 0x00, 0x22, 0x48, 0x69, + 0x4A, 0x61, 0x3C, 0x49, 0x14, 0x31, 0x0A, 0x60, 0x10, 0xB1, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x47, + 0x05, 0x20, 0xFF, 0xF7, 0xC8, 0xFE, 0x10, 0xBD, 0x38, 0x49, 0x10, 0xB5, + 0x00, 0x22, 0x88, 0x69, + 0x8A, 0x61, 0x34, 0x49, 0x18, 0x31, 0x0A, 0x60, 0x10, 0xB1, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x47, + 0x06, 0x20, 0xFF, 0xF7, 0xB8, 0xFE, 0x10, 0xBD, 0x10, 0xB5, 0xFF, 0xF7, + 0x0B, 0xFB, 0x4F, 0xF0, + 0x00, 0x51, 0x91, 0xF8, 0x22, 0x20, 0x42, 0xF2, 0x10, 0x73, 0xB0, 0xFB, + 0xF3, 0xF0, 0xC2, 0xF3, + 0x81, 0x02, 0x52, 0x1C, 0xD0, 0x40, 0xB1, 0xF8, 0x54, 0x20, 0xC9, 0x6C, + 0x51, 0x43, 0x89, 0x09, + 0xB0, 0xFB, 0xF1, 0xF0, 0x10, 0xBD, 0x25, 0x49, 0xC8, 0x61, 0x22, 0x49, + 0x01, 0x20, 0xB8, 0x31, + 0x08, 0x60, 0x09, 0x1D, 0x08, 0x60, 0x70, 0x47, 0x20, 0x48, 0x10, 0xB5, + 0x00, 0x22, 0xC1, 0x69, + 0xC2, 0x61, 0x51, 0xB1, 0x1B, 0x48, 0xB8, 0x30, 0x02, 0x60, 0x4F, 0xF0, + 0x00, 0x50, 0xC0, 0x6C, + 0xBD, 0xE8, 0x10, 0x40, 0x20, 0xF0, 0x7F, 0x40, 0x08, 0x47, 0xFF, 0x20, + 0xFF, 0xF7, 0x83, 0xFE, + 0x10, 0xBD, 0x10, 0xB5, 0x04, 0x46, 0xFF, 0xF7, 0xD5, 0xFA, 0x4F, 0xF0, + 0x00, 0x51, 0x91, 0xF8, + 0x22, 0x10, 0x42, 0xF2, 0x10, 0x72, 0xB0, 0xFB, 0xF2, 0xF0, 0xC1, 0xF3, + 0x81, 0x01, 0x49, 0x1C, + 0xC8, 0x40, 0x00, 0x03, 0xB0, 0xFB, 0xF4, 0xF0, 0x0C, 0x49, 0x08, 0x62, + 0x10, 0xBD, 0x4F, 0xF0, + 0x00, 0x50, 0x90, 0xF8, 0x4A, 0x00, 0x00, 0x07, 0x00, 0xD0, 0x01, 0x20, + 0x70, 0x47, 0x00, 0xF0, + 0x1F, 0x02, 0x01, 0x21, 0x91, 0x40, 0x40, 0x09, 0x80, 0x00, 0x00, 0xF1, + 0xE0, 0x20, 0xC0, 0xF8, + 0x80, 0x12, 0x70, 0x47, 0x40, 0x09, 0x00, 0x22, 0xC0, 0x04, 0x00, 0x22, + 0x44, 0x04, 0x10, 0x00, + 0x00, 0x09, 0x3D, 0x00, 0x00, 0x48, 0xE8, 0x01, 0x00, 0x24, 0xF4, 0x00, + 0x00, 0x12, 0x7A, 0x00, + 0x10, 0xB5, 0x01, 0x46, 0x34, 0x22, 0xF6, 0x48, 0x15, 0xF0, 0xCC, 0xFB, + 0x01, 0x21, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x20, 0xFE, 0xF7, 0x8D, 0xBD, 0x38, 0xB5, 0x04, 0x46, + 0xF1, 0x48, 0xF0, 0x4D, + 0x20, 0x60, 0x20, 0x46, 0x15, 0xF0, 0x03, 0xF8, 0x00, 0x22, 0x6B, 0x46, + 0x01, 0x21, 0x10, 0x46, + 0xFE, 0xF7, 0xC8, 0xFD, 0x01, 0x21, 0x00, 0x20, 0xFE, 0xF7, 0xA7, 0xFD, + 0x28, 0x78, 0x00, 0x28, + 0x02, 0xD0, 0x10, 0xF0, 0x8A, 0xFD, 0xEC, 0xE7, 0x38, 0xBD, 0xE7, 0x48, + 0x02, 0x68, 0x92, 0xF8, + 0xB0, 0x00, 0xC1, 0x07, 0x0E, 0xD0, 0xE2, 0x49, 0x01, 0x23, 0x34, 0x31, + 0x4B, 0x73, 0xC0, 0xF3, + 0xC1, 0x03, 0x02, 0x2B, 0x01, 0xD1, 0x00, 0x23, 0x4B, 0x73, 0x80, 0x07, + 0x02, 0xD5, 0x92, 0xF8, + 0xBB, 0x00, 0x08, 0x73, 0x70, 0x47, 0xDC, 0x48, 0x10, 0xB5, 0x03, 0x68, + 0x93, 0xF8, 0xB0, 0x20, + 0xD0, 0x07, 0x16, 0xD0, 0x90, 0x07, 0x14, 0xD5, 0xD8, 0x48, 0x40, 0x78, + 0x00, 0x28, 0x10, 0xD1, + 0xD3, 0x48, 0x34, 0x30, 0x00, 0x21, 0x04, 0x7B, 0x0C, 0xB1, 0x41, 0x73, + 0x08, 0xE0, 0x01, 0x24, + 0xC2, 0xF3, 0xC1, 0x02, 0x44, 0x73, 0x02, 0x2A, 0x00, 0xD1, 0x41, 0x73, + 0x93, 0xF8, 0xBB, 0x10, + 0x01, 0x73, 0x10, 0xBD, 0x2D, 0xE9, 0xF0, 0x47, 0xDF, 0xF8, 0x2C, 0x83, + 0x82, 0x46, 0x01, 0x27, + 0xD8, 0xF8, 0x00, 0x00, 0xCA, 0x4D, 0x90, 0xF8, 0x31, 0x40, 0x10, 0xF8, + 0x30, 0x1F, 0x90, 0xF8, + 0x31, 0x00, 0x4C, 0x43, 0x00, 0xF0, 0x03, 0x00, 0x87, 0x40, 0xA1, 0x00, + 0x28, 0x46, 0x15, 0xF0, + 0xBD, 0xFB, 0xFF, 0xF7, 0xB2, 0xFF, 0x00, 0x26, 0xDF, 0xF8, 0xF4, 0x92, + 0x15, 0xE0, 0xBC, 0x48, + 0x34, 0x30, 0xFF, 0xF7, 0x91, 0xFF, 0x00, 0x20, 0xD9, 0xF8, 0x08, 0x10, + 0x08, 0xE0, 0x00, 0xBF, + 0x55, 0xF8, 0x20, 0x20, 0x31, 0xF9, 0x10, 0x30, 0x1A, 0x44, 0x45, 0xF8, + 0x20, 0x20, 0x40, 0x1C, + 0xA0, 0x42, 0xF5, 0xDB, 0xFF, 0xF7, 0xAF, 0xFF, 0x76, 0x1C, 0xBE, 0x42, + 0xE7, 0xDB, 0x40, 0x46, + 0x0A, 0xE0, 0x00, 0xBF, 0x02, 0x68, 0x55, 0xF8, 0x24, 0x10, 0x92, 0xF8, + 0x61, 0x20, 0x02, 0xF0, + 0x03, 0x02, 0x11, 0x41, 0x2A, 0xF8, 0x14, 0x10, 0x64, 0x1E, 0xF3, 0xD2, + 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xF0, 0x4F, 0xDF, 0xF8, 0xA0, 0xB2, 0x4F, 0xF0, 0x01, 0x09, + 0xA8, 0x4E, 0xDB, 0xF8, + 0x00, 0x00, 0x9F, 0xB0, 0x90, 0xF8, 0x61, 0x10, 0x90, 0xF8, 0x31, 0x40, + 0xC1, 0xF3, 0x81, 0x08, + 0x90, 0xF8, 0x30, 0x50, 0x09, 0xFA, 0x08, 0xFA, 0x60, 0x19, 0x81, 0x00, + 0x06, 0xEB, 0x84, 0x07, + 0x30, 0x46, 0x15, 0xF0, 0x73, 0xFB, 0x9A, 0x48, 0x34, 0x30, 0x14, 0xF0, + 0x33, 0xFF, 0x98, 0x48, + 0x34, 0x30, 0x80, 0xF8, 0x06, 0x90, 0xDB, 0xF8, 0x00, 0x10, 0x91, 0xF8, + 0x60, 0x20, 0x92, 0x07, + 0x01, 0xD5, 0x80, 0xF8, 0x04, 0x90, 0x91, 0xF8, 0x62, 0x10, 0x01, 0x73, + 0xFF, 0xF7, 0x55, 0xFF, + 0xDB, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x60, 0x00, 0xC0, 0x07, 0x05, 0xD0, + 0x8C, 0x48, 0x34, 0x30, + 0xFF, 0xF7, 0x32, 0xFF, 0xFF, 0xF7, 0x5F, 0xFF, 0x00, 0x20, 0x2E, 0xE0, + 0x88, 0x48, 0x34, 0x30, + 0xFF, 0xF7, 0x2A, 0xFF, 0xDF, 0xF8, 0x18, 0xB2, 0x62, 0x00, 0x13, 0xA8, + 0xDB, 0xF8, 0x18, 0x10, + 0x15, 0xF0, 0xA3, 0xFA, 0x6A, 0x00, 0x68, 0x46, 0xDB, 0xF8, 0x1C, 0x10, + 0x15, 0xF0, 0x9D, 0xFA, + 0x20, 0x46, 0x13, 0xA9, 0x07, 0xE0, 0x00, 0xBF, 0x56, 0xF8, 0x20, 0x20, + 0x31, 0xF9, 0x10, 0x30, + 0x1A, 0x44, 0x46, 0xF8, 0x20, 0x20, 0x40, 0x1E, 0xF6, 0xD2, 0x28, 0x46, + 0x69, 0x46, 0x06, 0xE0, + 0x57, 0xF8, 0x20, 0x20, 0x31, 0xF9, 0x10, 0x30, 0x1A, 0x44, 0x47, 0xF8, + 0x20, 0x20, 0x40, 0x1E, + 0xF6, 0xD2, 0xFF, 0xF7, 0x30, 0xFF, 0x09, 0xF1, 0x01, 0x00, 0x81, 0x46, + 0x50, 0x45, 0xCD, 0xDB, + 0x74, 0x49, 0x05, 0xE0, 0x56, 0xF8, 0x24, 0x00, 0x40, 0xFA, 0x08, 0xF0, + 0x21, 0xF8, 0x14, 0x00, + 0x64, 0x1E, 0xF7, 0xD2, 0x70, 0x49, 0x05, 0xE0, 0x57, 0xF8, 0x25, 0x00, + 0x40, 0xFA, 0x08, 0xF0, + 0x21, 0xF8, 0x15, 0x00, 0x6D, 0x1E, 0xF7, 0xD2, 0x1F, 0xB0, 0xBD, 0xE8, + 0xF0, 0x8F, 0x2D, 0xE9, + 0xFF, 0x5F, 0xDF, 0xF8, 0x94, 0x81, 0x66, 0x4F, 0xD8, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x31, 0x40, + 0x90, 0xF8, 0x30, 0x50, 0x07, 0xEB, 0x84, 0x0A, 0x60, 0x19, 0x81, 0x00, + 0x04, 0xFB, 0x05, 0xFB, + 0x0A, 0xEB, 0x85, 0x06, 0x38, 0x46, 0x15, 0xF0, 0xF1, 0xFA, 0x4F, 0xEA, + 0x8B, 0x01, 0x30, 0x46, + 0x15, 0xF0, 0xEC, 0xFA, 0x56, 0x48, 0x34, 0x30, 0x14, 0xF0, 0xAC, 0xFE, + 0x54, 0x48, 0x4F, 0xF0, + 0x01, 0x09, 0x34, 0x30, 0x80, 0xF8, 0x06, 0x90, 0x80, 0xF8, 0x04, 0x90, + 0xD8, 0xF8, 0x00, 0x10, + 0x91, 0xF8, 0x62, 0x10, 0x01, 0x73, 0xFF, 0xF7, 0xD0, 0xFE, 0xD8, 0xF8, + 0x00, 0x00, 0x90, 0xF8, + 0x60, 0x00, 0xC0, 0x07, 0x05, 0xD0, 0x4A, 0x48, 0x34, 0x30, 0xFF, 0xF7, + 0xAD, 0xFE, 0xFF, 0xF7, + 0xDA, 0xFE, 0xD8, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x61, 0x00, 0xC0, 0xF3, + 0x81, 0x01, 0x02, 0x91, + 0x00, 0xF0, 0x03, 0x01, 0x03, 0x91, 0x02, 0x99, 0x48, 0x46, 0x09, 0xFA, + 0x01, 0xF9, 0x03, 0x99, + 0x88, 0x40, 0x01, 0x90, 0x00, 0x20, 0x32, 0xE0, 0x3D, 0x48, 0x34, 0x30, + 0xFF, 0xF7, 0x94, 0xFE, + 0x3B, 0x48, 0xD0, 0xE9, 0x06, 0x32, 0x81, 0x68, 0x20, 0x46, 0x06, 0xE0, + 0x57, 0xF8, 0x20, 0xC0, + 0x33, 0xF9, 0x10, 0x80, 0xC4, 0x44, 0x47, 0xF8, 0x20, 0xC0, 0x40, 0x1E, + 0xF6, 0xD2, 0x28, 0x46, + 0x07, 0xE0, 0x00, 0xBF, 0x5A, 0xF8, 0x20, 0x30, 0x32, 0xF9, 0x10, 0xC0, + 0x9C, 0x44, 0x4A, 0xF8, + 0x20, 0xC0, 0x40, 0x1E, 0xF6, 0xD2, 0xDD, 0xE9, 0x00, 0x02, 0x90, 0x42, + 0x0B, 0xDA, 0x58, 0x46, + 0x07, 0xE0, 0x00, 0xBF, 0x56, 0xF8, 0x20, 0x20, 0x31, 0xF9, 0x10, 0x30, + 0x1A, 0x44, 0x46, 0xF8, + 0x20, 0x20, 0x40, 0x1E, 0xF6, 0xD2, 0xFF, 0xF7, 0x96, 0xFE, 0x00, 0x98, + 0x40, 0x1C, 0x00, 0x90, + 0x48, 0x45, 0xC9, 0xDB, 0x01, 0x98, 0x48, 0x45, 0x1F, 0xDD, 0x21, 0x48, + 0x00, 0x21, 0x34, 0x30, + 0x88, 0x46, 0x81, 0x71, 0x01, 0x99, 0xA1, 0xEB, 0x09, 0x09, 0x14, 0xE0, + 0x1C, 0x48, 0x34, 0x30, + 0xFF, 0xF7, 0x52, 0xFE, 0x1A, 0x48, 0x81, 0x68, 0x58, 0x46, 0x06, 0xE0, + 0x56, 0xF8, 0x20, 0x20, + 0x31, 0xF9, 0x10, 0x30, 0x1A, 0x44, 0x46, 0xF8, 0x20, 0x20, 0x40, 0x1E, + 0xF6, 0xD2, 0xFF, 0xF7, + 0x72, 0xFE, 0x08, 0xF1, 0x01, 0x08, 0xC1, 0x45, 0xE8, 0xDC, 0x16, 0x49, + 0x06, 0xE0, 0x00, 0xBF, + 0x57, 0xF8, 0x24, 0x00, 0x02, 0x9A, 0x10, 0x41, 0x21, 0xF8, 0x14, 0x00, + 0x64, 0x1E, 0xF7, 0xD2, + 0x11, 0x49, 0x05, 0xE0, 0x5A, 0xF8, 0x25, 0x00, 0x02, 0x9A, 0x10, 0x41, + 0x21, 0xF8, 0x15, 0x00, + 0x6D, 0x1E, 0xF7, 0xD2, 0x58, 0x46, 0x0D, 0x4A, 0x06, 0xE0, 0x00, 0xBF, + 0x56, 0xF8, 0x20, 0x10, + 0x03, 0x9B, 0x19, 0x41, 0x22, 0xF8, 0x10, 0x10, 0x40, 0x1E, 0xF7, 0xD2, + 0xBD, 0xE8, 0xFF, 0x9F, + 0xF4, 0x0E, 0x10, 0x00, 0xF1, 0x19, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0xD4, 0x56, 0x10, 0x00, 0x7E, 0x4A, 0x01, 0x20, 0xA8, 0x4A, 0x01, 0x20, + 0x42, 0x44, 0x01, 0x20, + 0x2D, 0xE9, 0xF8, 0x43, 0x14, 0xF0, 0x53, 0xFE, 0x00, 0x90, 0x04, 0x21, + 0x68, 0x46, 0xFF, 0xF7, + 0xDA, 0xF9, 0xDF, 0xF8, 0xA0, 0x82, 0xC6, 0xB2, 0x01, 0x27, 0xD8, 0xF8, + 0x00, 0x00, 0xA6, 0x4C, + 0x90, 0xF8, 0x61, 0x00, 0x80, 0x09, 0x07, 0xFA, 0x00, 0xF5, 0xB1, 0x00, + 0x20, 0x46, 0x15, 0xF0, + 0x15, 0xFA, 0xA2, 0x48, 0x14, 0xF0, 0xD6, 0xFD, 0xA0, 0x48, 0xA0, 0xF1, + 0x34, 0x09, 0x87, 0x72, + 0x00, 0x27, 0x12, 0xE0, 0x9D, 0x48, 0xFF, 0xF7, 0xE7, 0xFD, 0x00, 0x20, + 0xD9, 0xF8, 0x2C, 0x10, + 0x08, 0xE0, 0x00, 0xBF, 0x54, 0xF8, 0x20, 0x20, 0x31, 0xF9, 0x10, 0x30, + 0x1A, 0x44, 0x44, 0xF8, + 0x20, 0x20, 0x40, 0x1C, 0xB0, 0x42, 0xF5, 0xDB, 0x7F, 0x1C, 0xAF, 0x42, + 0xEA, 0xDB, 0x00, 0x20, + 0x93, 0x4B, 0xD8, 0xF8, 0x00, 0x10, 0x08, 0xE0, 0x91, 0xF8, 0x61, 0x50, + 0x54, 0xF8, 0x20, 0x20, + 0xAD, 0x09, 0x2A, 0x41, 0x23, 0xF8, 0x10, 0x20, 0x40, 0x1C, 0xB0, 0x42, + 0xF4, 0xDB, 0xBD, 0xE8, + 0xF8, 0x83, 0x2D, 0xE9, 0xF0, 0x47, 0x05, 0x46, 0x00, 0x20, 0xFE, 0xF7, + 0x2A, 0xFC, 0x02, 0x20, + 0xFE, 0xF7, 0x27, 0xFC, 0x03, 0x20, 0xFE, 0xF7, 0x24, 0xFC, 0x86, 0x4E, + 0x00, 0x20, 0x30, 0x70, + 0x82, 0x48, 0x14, 0xF0, 0x97, 0xFD, 0x84, 0x48, 0x01, 0x24, 0x04, 0x70, + 0x7D, 0x4F, 0xDF, 0xF8, + 0x0C, 0x82, 0xDF, 0xF8, 0x0C, 0x92, 0x38, 0x68, 0x90, 0xF8, 0x60, 0x00, + 0x80, 0x07, 0x4F, 0xEA, + 0x05, 0x70, 0x0B, 0xD5, 0x00, 0x28, 0x11, 0xDA, 0xA8, 0x07, 0x09, 0xD5, + 0x34, 0x70, 0xFF, 0xF7, + 0xB6, 0xFE, 0x88, 0xF8, 0x00, 0x40, 0x89, 0xF8, 0x00, 0x40, 0x01, 0xE0, + 0x00, 0x28, 0x05, 0xDA, + 0x30, 0x78, 0x18, 0xB9, 0xFF, 0xF7, 0x24, 0xFE, 0x88, 0xF8, 0x00, 0x40, + 0x28, 0x06, 0x08, 0xD5, + 0x38, 0x68, 0x90, 0xF8, 0x2F, 0x0A, 0xC0, 0x07, 0x03, 0xD0, 0x72, 0x48, + 0x04, 0x70, 0xFF, 0xF7, + 0x77, 0xFF, 0xDF, 0xF8, 0xA8, 0x81, 0xA8, 0x07, 0x11, 0xD5, 0x30, 0x78, + 0xD0, 0xB9, 0x40, 0x46, + 0x14, 0xF0, 0x60, 0xFD, 0x88, 0xF8, 0x04, 0x40, 0x6B, 0x48, 0xFF, 0xF7, + 0xC3, 0xFD, 0x6A, 0x48, + 0x00, 0xF0, 0x23, 0xF8, 0x69, 0x49, 0x08, 0x70, 0x89, 0xF8, 0x00, 0x40, + 0x0A, 0xE0, 0x68, 0x07, + 0x08, 0xD5, 0x5E, 0x48, 0x14, 0xF0, 0x4E, 0xFD, 0x04, 0x21, 0x88, 0xF8, + 0x04, 0x10, 0x62, 0x48, + 0xFF, 0xF7, 0xB0, 0xFD, 0x38, 0x68, 0x90, 0xF8, 0x61, 0x04, 0x18, 0xB1, + 0xE8, 0x06, 0x01, 0xD5, + 0x00, 0xF0, 0x5E, 0xF8, 0x03, 0x20, 0xFE, 0xF7, 0xDF, 0xFB, 0x02, 0x20, + 0xFE, 0xF7, 0xDC, 0xFB, + 0xBD, 0xE8, 0xF0, 0x47, 0x00, 0x20, 0xFE, 0xF7, 0xD7, 0xBB, 0x2D, 0xE9, + 0xF0, 0x43, 0x4D, 0x49, + 0x4F, 0xF0, 0x00, 0x09, 0xCC, 0x46, 0x0F, 0x68, 0x4B, 0x46, 0x97, 0xF8, + 0x31, 0x20, 0x97, 0xF8, + 0x30, 0x60, 0x97, 0xF8, 0x60, 0x40, 0x02, 0xFB, 0x06, 0xF1, 0x09, 0xB2, + 0x64, 0x07, 0x37, 0xD5, + 0x4F, 0x4C, 0x24, 0x68, 0x25, 0x8E, 0x8D, 0x42, 0x32, 0xD1, 0x32, 0x34, + 0x28, 0xE0, 0x35, 0x46, + 0x20, 0xE0, 0x00, 0xBF, 0x34, 0xF8, 0x15, 0x10, 0x30, 0xF8, 0x15, 0x80, + 0xA1, 0xEB, 0x08, 0x01, + 0x09, 0xB2, 0x00, 0x29, 0x01, 0xDB, 0x88, 0x46, 0x01, 0xE0, 0xC1, 0xF1, + 0x00, 0x08, 0xE0, 0x45, + 0x07, 0xDD, 0x00, 0x29, 0x01, 0xDB, 0x8C, 0x46, 0x01, 0xE0, 0xC1, 0xF1, + 0x00, 0x0C, 0x0F, 0xFA, + 0x8C, 0xFC, 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0xB7, 0xF8, 0x63, 0x80, + 0x41, 0x45, 0x01, 0xDD, + 0x5B, 0x1C, 0x9B, 0xB2, 0x6D, 0x1E, 0xDD, 0xD1, 0x04, 0xEB, 0x46, 0x04, + 0x00, 0xEB, 0x46, 0x00, + 0x52, 0x1E, 0xD4, 0xD2, 0x97, 0xF8, 0x65, 0x00, 0x98, 0x42, 0x01, 0xD2, + 0x4F, 0xF0, 0x01, 0x09, + 0x34, 0x48, 0xA0, 0xF8, 0x00, 0xC0, 0x34, 0x48, 0x03, 0x80, 0x48, 0x46, + 0xBD, 0xE8, 0xF0, 0x83, + 0x2D, 0xE9, 0xF0, 0x47, 0xDF, 0xF8, 0x8C, 0x80, 0x01, 0x21, 0x45, 0x46, + 0xD8, 0xF8, 0x00, 0x00, + 0x00, 0xF2, 0x61, 0x40, 0xFF, 0xF7, 0xC7, 0xF8, 0x04, 0x46, 0x28, 0x68, + 0x01, 0x27, 0x1E, 0x4D, + 0x90, 0xF8, 0x61, 0x00, 0xC0, 0xF3, 0x01, 0x10, 0x07, 0xFA, 0x00, 0xF6, + 0xA1, 0x00, 0x28, 0x46, + 0x15, 0xF0, 0x04, 0xF9, 0x19, 0x48, 0x14, 0xF0, 0xC5, 0xFC, 0x18, 0x48, + 0xA0, 0xF1, 0x34, 0x09, + 0x47, 0x72, 0x00, 0x27, 0x11, 0xE0, 0x15, 0x48, 0xFF, 0xF7, 0xD6, 0xFC, + 0x00, 0x20, 0xD9, 0xF8, + 0x14, 0x10, 0x07, 0xE0, 0x55, 0xF8, 0x20, 0x20, 0x31, 0xF9, 0x10, 0x30, + 0x1A, 0x44, 0x45, 0xF8, + 0x20, 0x20, 0x40, 0x1C, 0xA0, 0x42, 0xF5, 0xDB, 0x7F, 0x1C, 0xB7, 0x42, + 0xEB, 0xDB, 0x00, 0x20, + 0x16, 0x4B, 0xD8, 0xF8, 0x00, 0x10, 0x09, 0xE0, 0x91, 0xF8, 0x61, 0x60, + 0x55, 0xF8, 0x20, 0x20, + 0xC6, 0xF3, 0x01, 0x16, 0x32, 0x41, 0x23, 0xF8, 0x10, 0x20, 0x40, 0x1C, + 0xA0, 0x42, 0xF3, 0xDB, + 0x44, 0xE5, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xD4, 0x56, 0x10, 0x00, + 0x28, 0x0F, 0x10, 0x00, + 0xFC, 0x4A, 0x01, 0x20, 0x68, 0x04, 0x10, 0x00, 0x78, 0x07, 0x10, 0x00, + 0x7A, 0x07, 0x10, 0x00, + 0x79, 0x07, 0x10, 0x00, 0x7C, 0x07, 0x10, 0x00, 0x42, 0x44, 0x01, 0x20, + 0x7D, 0x07, 0x10, 0x00, + 0x50, 0x07, 0x10, 0x00, 0x7E, 0x07, 0x10, 0x00, 0x80, 0x07, 0x10, 0x00, + 0xF4, 0x4A, 0x01, 0x20, + 0x10, 0xB5, 0x01, 0x46, 0x34, 0x22, 0xFE, 0x48, 0x15, 0xF0, 0x54, 0xF8, + 0x01, 0x21, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x20, 0xFE, 0xF7, 0x15, 0xBA, 0x38, 0xB5, 0x04, 0x46, + 0xF9, 0x48, 0xF8, 0x4D, + 0x20, 0x60, 0x20, 0x46, 0x14, 0xF0, 0x8B, 0xFC, 0x00, 0x22, 0x6B, 0x46, + 0x01, 0x21, 0x10, 0x46, + 0xFE, 0xF7, 0x50, 0xFA, 0x01, 0x21, 0x00, 0x20, 0xFE, 0xF7, 0x2F, 0xFA, + 0x28, 0x78, 0x00, 0x28, + 0x02, 0xD0, 0x10, 0xF0, 0x12, 0xFA, 0xEC, 0xE7, 0x38, 0xBD, 0x2D, 0xE9, + 0xFF, 0x41, 0x00, 0x24, + 0xDD, 0xE9, 0x0A, 0x76, 0x04, 0x21, 0x68, 0x46, 0xFF, 0xF7, 0x3D, 0xF8, + 0x05, 0x46, 0x08, 0x21, + 0x02, 0xA8, 0xFF, 0xF7, 0x38, 0xF8, 0x02, 0x46, 0x00, 0x20, 0x6F, 0xF0, + 0x7E, 0x0E, 0x14, 0xE0, + 0x00, 0x21, 0x00, 0xFB, 0x02, 0xF3, 0x0D, 0xE0, 0x07, 0xEB, 0x01, 0x0C, + 0x13, 0xF9, 0x0C, 0xC0, + 0xB4, 0x44, 0xF4, 0x45, 0x01, 0xDA, 0x01, 0x24, 0x03, 0xE0, 0xBC, 0xF1, + 0x7F, 0x0F, 0x00, 0xDD, + 0x02, 0x24, 0x49, 0x1C, 0x91, 0x42, 0xEF, 0xDB, 0x40, 0x1C, 0xA8, 0x42, + 0xE8, 0xDB, 0x20, 0x46, + 0x04, 0xB0, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xFF, 0x41, 0x0A, 0xA9, + 0x00, 0x24, 0x91, 0xE8, + 0xC0, 0x01, 0x04, 0x21, 0x68, 0x46, 0xFF, 0xF7, 0x0E, 0xF8, 0x05, 0x46, + 0x08, 0x21, 0x02, 0xA8, + 0xFF, 0xF7, 0x09, 0xF8, 0x01, 0x46, 0x00, 0x20, 0x08, 0xE0, 0x32, 0x56, + 0xD2, 0x19, 0x01, 0xD5, + 0x01, 0x24, 0x02, 0xE0, 0xFF, 0x2A, 0x00, 0xDD, 0x02, 0x24, 0x40, 0x1C, + 0xA8, 0x42, 0xF4, 0xDB, + 0x00, 0x20, 0x0A, 0xE0, 0x2A, 0x18, 0xB2, 0x56, 0x12, 0xEB, 0x08, 0x02, + 0x01, 0xD5, 0x01, 0x24, + 0x02, 0xE0, 0xFF, 0x2A, 0x00, 0xDD, 0x02, 0x24, 0x40, 0x1C, 0x88, 0x42, + 0xF2, 0xDB, 0x20, 0x46, + 0xCE, 0xE7, 0x2D, 0xE9, 0xF0, 0x4F, 0x8D, 0xB0, 0x14, 0xF0, 0x51, 0xFC, + 0x0C, 0x90, 0x14, 0xF0, + 0x50, 0xFC, 0xBD, 0x4E, 0x04, 0x46, 0x0D, 0x46, 0x30, 0x68, 0x90, 0xF8, + 0xE7, 0x00, 0x10, 0xF0, + 0x60, 0x0F, 0x03, 0xD0, 0x0C, 0x98, 0x11, 0xF0, 0x67, 0xF9, 0x0C, 0x90, + 0xDF, 0xF8, 0xD8, 0xA2, + 0x01, 0x21, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x31, 0x60, 0x90, 0xF8, + 0x30, 0x80, 0x06, 0xFB, + 0x08, 0xF0, 0x0B, 0x90, 0x06, 0xA8, 0x0E, 0xF0, 0x42, 0xFC, 0xB0, 0x4F, + 0x4F, 0xF0, 0x00, 0x0B, + 0xDF, 0xF8, 0xBC, 0x92, 0x39, 0x68, 0x06, 0x9B, 0x22, 0x46, 0x91, 0xF9, + 0x1B, 0x10, 0xCD, 0xF8, + 0x0C, 0xB0, 0xCD, 0xF8, 0x00, 0x90, 0xCD, 0xE9, 0x01, 0x31, 0x2B, 0x46, + 0x0C, 0x98, 0x11, 0xF0, + 0xC5, 0xF9, 0x06, 0x9B, 0x01, 0x20, 0xCD, 0xE9, 0x00, 0x93, 0xCD, 0xE9, + 0x02, 0xB0, 0x22, 0x46, + 0x2B, 0x46, 0x0C, 0x98, 0x11, 0xF0, 0xBA, 0xF9, 0x9D, 0x48, 0x34, 0x30, + 0x14, 0xF0, 0xB2, 0xFB, + 0x9B, 0x49, 0x05, 0x20, 0x34, 0x31, 0x08, 0x71, 0x08, 0x46, 0xFF, 0xF7, + 0x3D, 0xFF, 0x98, 0x48, + 0x02, 0x21, 0x80, 0x68, 0x00, 0x90, 0x0A, 0xA8, 0x0E, 0xF0, 0x11, 0xFC, + 0xDA, 0xF8, 0x00, 0x00, + 0xB0, 0xF9, 0xC2, 0xA1, 0xB0, 0xF9, 0xC4, 0x91, 0x0A, 0xEB, 0x09, 0x01, + 0x49, 0x10, 0x02, 0x91, + 0x90, 0xF8, 0xE8, 0x00, 0x80, 0x07, 0x09, 0xD4, 0xA8, 0xF1, 0x01, 0x00, + 0x70, 0x43, 0x00, 0x99, + 0x0B, 0x90, 0x43, 0x46, 0x32, 0x46, 0x08, 0x46, 0x00, 0xF0, 0x76, 0xFB, + 0xDD, 0xE9, 0x0A, 0x12, + 0x00, 0x98, 0x11, 0xF0, 0x8C, 0xFF, 0x80, 0x46, 0x02, 0x21, 0x0A, 0xA8, + 0x0E, 0xF0, 0x82, 0xFC, + 0x00, 0x26, 0xD0, 0x45, 0x01, 0xDC, 0xC8, 0x45, 0x09, 0xDA, 0x83, 0x48, + 0x02, 0x99, 0x00, 0x68, + 0xA8, 0xEB, 0x01, 0x01, 0xB0, 0xF8, 0xC6, 0x01, 0x91, 0xFB, 0xF0, 0xF0, + 0x46, 0xB2, 0x06, 0x98, + 0xCD, 0xE9, 0x00, 0x06, 0x22, 0x46, 0x2B, 0x46, 0x0C, 0x98, 0xFF, 0xF7, + 0x16, 0xFF, 0x01, 0x28, + 0x18, 0xD0, 0x02, 0x28, 0x1C, 0xD0, 0x38, 0x68, 0x79, 0x49, 0x2B, 0x46, + 0xC6, 0x76, 0x01, 0x20, + 0x06, 0x9A, 0x03, 0x90, 0x8D, 0xE8, 0x46, 0x00, 0x22, 0x46, 0x0C, 0x98, + 0x11, 0xF0, 0x5E, 0xF9, + 0x39, 0x68, 0xA5, 0x20, 0x88, 0x76, 0x01, 0x21, 0x06, 0xA8, 0x0E, 0xF0, + 0x53, 0xFC, 0x0D, 0xB0, + 0xBD, 0xE8, 0xF0, 0x8F, 0x39, 0x68, 0x81, 0xF8, 0x1B, 0xB0, 0x01, 0x21, + 0xB0, 0x20, 0x04, 0xE0, + 0x39, 0x68, 0xB1, 0x20, 0x81, 0xF8, 0x1B, 0xB0, 0x01, 0x21, 0x10, 0xF0, + 0xEF, 0xF8, 0xE7, 0xE7, + 0x2D, 0xE9, 0xF0, 0x4F, 0x64, 0x4F, 0x8D, 0xB0, 0x38, 0x68, 0x90, 0xF8, + 0x31, 0x60, 0x90, 0xF8, + 0x30, 0x80, 0x14, 0xF0, 0x94, 0xFB, 0x0B, 0x90, 0x14, 0xF0, 0x93, 0xFB, + 0x04, 0x46, 0x38, 0x68, + 0x0D, 0x46, 0x90, 0xF8, 0xE7, 0x00, 0x10, 0xF0, 0x60, 0x0F, 0x03, 0xD0, + 0x0B, 0x98, 0x11, 0xF0, + 0xAB, 0xF8, 0x0B, 0x90, 0x01, 0x21, 0x04, 0xA8, 0x0E, 0xF0, 0x91, 0xFB, + 0x57, 0x4F, 0x4F, 0xF0, + 0x00, 0x0A, 0xDF, 0xF8, 0x60, 0x91, 0x38, 0x68, 0x04, 0x9B, 0x90, 0xF9, + 0x1D, 0x20, 0xCD, 0xF8, + 0x0C, 0xA0, 0xCD, 0xF8, 0x00, 0x90, 0xCD, 0xE9, 0x01, 0x32, 0x22, 0x46, + 0x2B, 0x46, 0x0B, 0x98, + 0x11, 0xF0, 0x14, 0xF9, 0x04, 0x9B, 0x01, 0x21, 0xCD, 0xE9, 0x00, 0x93, + 0xCD, 0xE9, 0x02, 0xA1, + 0x22, 0x46, 0x2B, 0x46, 0x0B, 0x98, 0x11, 0xF0, 0x09, 0xF9, 0x45, 0x48, + 0x34, 0x30, 0x14, 0xF0, + 0x01, 0xFB, 0x43, 0x49, 0x06, 0x20, 0x34, 0x31, 0x08, 0x71, 0x08, 0x46, + 0xFF, 0xF7, 0x8C, 0xFE, + 0x3F, 0x48, 0x02, 0x21, 0x80, 0x68, 0x00, 0x90, 0x0A, 0xA8, 0x0E, 0xF0, + 0x60, 0xFB, 0x3E, 0x48, + 0x06, 0xFB, 0x08, 0xFB, 0x00, 0x68, 0xB0, 0xF9, 0xC8, 0x11, 0xB0, 0xF9, + 0xCA, 0x21, 0x11, 0x44, + 0x49, 0x10, 0x01, 0x91, 0x90, 0xF8, 0xE8, 0x00, 0x80, 0x07, 0x09, 0xD4, + 0xA8, 0xF1, 0x01, 0x00, + 0x00, 0x99, 0x06, 0xFB, 0x00, 0xFB, 0x43, 0x46, 0x32, 0x46, 0x08, 0x46, + 0x00, 0xF0, 0xC4, 0xFA, + 0x5A, 0x46, 0x0A, 0x99, 0x00, 0x98, 0x11, 0xF0, 0xDA, 0xFE, 0x80, 0x46, + 0x02, 0x21, 0x0A, 0xA8, + 0x0E, 0xF0, 0xD0, 0xFB, 0x2C, 0x48, 0x00, 0x26, 0x00, 0x68, 0xB0, 0xF9, + 0xC8, 0x21, 0x42, 0x45, + 0x03, 0xDB, 0xB0, 0xF9, 0xCA, 0x21, 0x42, 0x45, 0x07, 0xDD, 0x01, 0x9A, + 0xB0, 0xF8, 0xCC, 0x01, + 0xA8, 0xEB, 0x02, 0x01, 0x91, 0xFB, 0xF0, 0xF0, 0x46, 0xB2, 0x04, 0x98, + 0xCD, 0xE9, 0x00, 0x06, + 0x22, 0x46, 0x2B, 0x46, 0x0B, 0x98, 0xFF, 0xF7, 0x60, 0xFE, 0x4F, 0xF4, + 0x80, 0x71, 0x01, 0x28, + 0x17, 0xD0, 0x02, 0x28, 0x1A, 0xD0, 0x38, 0x68, 0x2B, 0x46, 0x46, 0x77, + 0x01, 0x20, 0x04, 0x9A, + 0xCD, 0xF8, 0x00, 0x90, 0x03, 0x90, 0xCD, 0xE9, 0x01, 0x26, 0x22, 0x46, + 0x0B, 0x98, 0x11, 0xF0, + 0xA5, 0xF8, 0x39, 0x68, 0xA5, 0x20, 0x08, 0x77, 0x01, 0x21, 0x04, 0xA8, + 0x0E, 0xF0, 0x9A, 0xFB, + 0x45, 0xE7, 0x3A, 0x68, 0xB0, 0x20, 0x82, 0xF8, 0x1D, 0xA0, 0x03, 0xE0, + 0x3A, 0x68, 0xB1, 0x20, + 0x82, 0xF8, 0x1D, 0xA0, 0x10, 0xF0, 0x3A, 0xF8, 0xEB, 0xE7, 0x2D, 0xE9, + 0xF0, 0x4F, 0x87, 0xB0, + 0x14, 0xF0, 0xE9, 0xFA, 0x05, 0x90, 0x14, 0xF0, 0xE8, 0xFA, 0x04, 0x46, + 0x0D, 0x46, 0x01, 0x21, + 0x04, 0xA8, 0x0E, 0xF0, 0xEC, 0xFA, 0x4F, 0xF0, 0x00, 0x0A, 0x56, 0x46, + 0x03, 0x4F, 0x0B, 0xE0, + 0x38, 0x0F, 0x10, 0x00, 0xE1, 0x20, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x50, 0x07, 0x10, 0x00, + 0x78, 0x8B, 0x01, 0x20, 0x08, 0x92, 0x01, 0x20, 0x38, 0x68, 0xDF, 0xF8, + 0x2C, 0x94, 0x04, 0x9A, + 0x90, 0xF9, 0x25, 0x10, 0xCD, 0xF8, 0x0C, 0xA0, 0xCD, 0xF8, 0x00, 0x90, + 0xCD, 0xE9, 0x01, 0x21, + 0x22, 0x46, 0x2B, 0x46, 0x05, 0x98, 0x11, 0xF0, 0x61, 0xF8, 0x01, 0x21, + 0x04, 0x9A, 0xCD, 0xF8, + 0x00, 0x90, 0x03, 0x91, 0xCD, 0xE9, 0x01, 0x26, 0x22, 0x46, 0x2B, 0x46, + 0x05, 0x98, 0x11, 0xF0, + 0x55, 0xF8, 0xFE, 0x48, 0x14, 0xF0, 0x4E, 0xFA, 0xFC, 0x48, 0x02, 0x21, + 0x41, 0x72, 0xFF, 0xF7, + 0xDB, 0xFD, 0xFA, 0x48, 0x02, 0x21, 0x34, 0x38, 0x46, 0x69, 0x06, 0xA8, + 0x0E, 0xF0, 0xAF, 0xFA, + 0xDF, 0xF8, 0xDC, 0xB3, 0x01, 0x21, 0xDB, 0xF8, 0x00, 0x00, 0x00, 0xF2, + 0x61, 0x40, 0xFE, 0xF7, + 0x2A, 0xFE, 0x02, 0x46, 0x30, 0x46, 0x06, 0x99, 0x11, 0xF0, 0x39, 0xFE, + 0x80, 0x46, 0x02, 0x21, + 0x06, 0xA8, 0x0E, 0xF0, 0x2F, 0xFB, 0xDB, 0xF8, 0x00, 0x10, 0x00, 0x26, + 0xB1, 0xF9, 0xDC, 0x21, + 0xB1, 0xF9, 0xDE, 0x31, 0xD0, 0x18, 0x4F, 0xEA, 0x60, 0x0C, 0x90, 0x45, + 0x01, 0xDC, 0x98, 0x45, + 0x06, 0xDA, 0xB1, 0xF8, 0xE0, 0x11, 0xA8, 0xEB, 0x0C, 0x00, 0x90, 0xFB, + 0xF1, 0xF0, 0x46, 0xB2, + 0x04, 0x98, 0xCD, 0xE9, 0x00, 0x06, 0x22, 0x46, 0x2B, 0x46, 0x05, 0x98, + 0xFF, 0xF7, 0xBD, 0xFD, + 0x01, 0x28, 0x1A, 0xD0, 0x02, 0x28, 0x1E, 0xD0, 0x38, 0x68, 0x2B, 0x46, + 0x80, 0xF8, 0x25, 0x60, + 0x01, 0x20, 0x04, 0x9A, 0xCD, 0xF8, 0x00, 0x90, 0x03, 0x90, 0xCD, 0xE9, + 0x01, 0x26, 0x22, 0x46, + 0x05, 0x98, 0x11, 0xF0, 0x03, 0xF8, 0x39, 0x68, 0xA5, 0x20, 0x81, 0xF8, + 0x24, 0x00, 0x01, 0x21, + 0x04, 0xA8, 0x0E, 0xF0, 0xF7, 0xFA, 0x07, 0xB0, 0xA2, 0xE6, 0x39, 0x68, + 0x81, 0xF8, 0x25, 0xA0, + 0x02, 0x21, 0xB0, 0x20, 0x04, 0xE0, 0x39, 0x68, 0xB1, 0x20, 0x81, 0xF8, + 0x25, 0xA0, 0x02, 0x21, + 0x0F, 0xF0, 0x94, 0xFF, 0xE7, 0xE7, 0x2D, 0xE9, 0xF0, 0x4F, 0xC9, 0x48, + 0x89, 0xB0, 0x00, 0x68, + 0x90, 0xF8, 0x31, 0x60, 0x90, 0xF8, 0x30, 0xB0, 0x14, 0xF0, 0x39, 0xFA, + 0x07, 0x90, 0x14, 0xF0, + 0x38, 0xFA, 0x04, 0x46, 0x0D, 0x46, 0x01, 0x21, 0x06, 0xA8, 0x0E, 0xF0, + 0x40, 0xFA, 0xDF, 0xF8, + 0x04, 0xA3, 0x02, 0xAB, 0x00, 0x27, 0xDA, 0xF8, 0x00, 0x00, 0x06, 0x9A, + 0x90, 0xF9, 0x20, 0x10, + 0x90, 0xF9, 0x1F, 0x00, 0x83, 0xE8, 0x83, 0x00, 0xB7, 0x48, 0x2B, 0x46, + 0xA0, 0x30, 0xCD, 0xE9, + 0x00, 0x02, 0x08, 0x90, 0x22, 0x46, 0x07, 0x98, 0x11, 0xF0, 0x0C, 0xF8, + 0x06, 0x99, 0xCD, 0xE9, + 0x01, 0x17, 0x01, 0x20, 0xCD, 0xE9, 0x03, 0x70, 0x08, 0x98, 0x00, 0x90, + 0x22, 0x46, 0x2B, 0x46, + 0x07, 0x98, 0x10, 0xF0, 0xFF, 0xFF, 0xAD, 0x48, 0x14, 0xF0, 0xAC, 0xF9, + 0xAB, 0x48, 0x03, 0x21, + 0x81, 0x71, 0xFF, 0xF7, 0x39, 0xFD, 0xA9, 0x48, 0x02, 0x21, 0x34, 0x38, + 0xD0, 0xE9, 0x06, 0x70, + 0x00, 0x90, 0xA7, 0x48, 0x00, 0x68, 0xB0, 0xF9, 0xCE, 0x91, 0xB0, 0xF9, + 0xD0, 0x81, 0x05, 0xA8, + 0x0E, 0xF0, 0x05, 0xFA, 0x09, 0xEB, 0x08, 0x00, 0x40, 0x10, 0x01, 0x90, + 0xA0, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x34, 0x01, 0x80, 0x07, 0x05, 0xD4, 0x39, 0x46, 0x32, 0x46, + 0x08, 0x46, 0x00, 0xF0, + 0x87, 0xF9, 0x76, 0x1E, 0x32, 0x46, 0x38, 0x46, 0x05, 0x99, 0x11, 0xF0, + 0x88, 0xFD, 0x00, 0x27, + 0x48, 0x45, 0x01, 0xDC, 0x40, 0x45, 0x08, 0xDA, 0x01, 0x99, 0x09, 0x1A, + 0x94, 0x48, 0x00, 0x68, + 0xB0, 0xF8, 0xD2, 0x01, 0x91, 0xFB, 0xF0, 0xF0, 0x47, 0xB2, 0x91, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x34, 0x01, 0x80, 0x07, 0x06, 0xD4, 0x00, 0x99, 0x5A, 0x46, 0x08, 0x46, + 0x00, 0xF0, 0x68, 0xF9, + 0xAB, 0xF1, 0x01, 0x0B, 0x5A, 0x46, 0x05, 0x99, 0x00, 0x98, 0x11, 0xF0, + 0x68, 0xFD, 0x00, 0x26, + 0x48, 0x45, 0x01, 0xDC, 0x40, 0x45, 0x08, 0xDA, 0x01, 0x99, 0x09, 0x1A, + 0x84, 0x48, 0x00, 0x68, + 0xB0, 0xF8, 0xD4, 0x01, 0x91, 0xFB, 0xF0, 0xF0, 0x46, 0xB2, 0x02, 0x21, + 0x05, 0xA8, 0x0E, 0xF0, + 0x51, 0xFA, 0x06, 0x98, 0xCD, 0xE9, 0x00, 0x07, 0x02, 0x96, 0x22, 0x46, + 0x2B, 0x46, 0x07, 0x98, + 0xFF, 0xF7, 0x21, 0xFD, 0x01, 0x28, 0x1D, 0xD0, 0x02, 0x28, 0x24, 0xD0, + 0xDA, 0xF8, 0x00, 0x00, + 0x22, 0x46, 0x2B, 0x46, 0xC7, 0x77, 0x80, 0xF8, 0x20, 0x60, 0x01, 0x20, + 0x06, 0x99, 0xCD, 0xE9, + 0x03, 0x60, 0xCD, 0xE9, 0x01, 0x17, 0x08, 0x98, 0x00, 0x90, 0x07, 0x98, + 0x10, 0xF0, 0x82, 0xFF, + 0xDA, 0xF8, 0x00, 0x00, 0xA5, 0x21, 0x81, 0x77, 0x01, 0x21, 0x06, 0xA8, + 0x0E, 0xF0, 0x2A, 0xFA, + 0x09, 0xB0, 0xD5, 0xE5, 0xDA, 0xF8, 0x00, 0x10, 0x00, 0x20, 0xC8, 0x77, + 0x81, 0xF8, 0x20, 0x00, + 0x10, 0x21, 0xB2, 0x20, 0x07, 0xE0, 0xDA, 0xF8, 0x00, 0x10, 0x00, 0x20, + 0xC8, 0x77, 0x81, 0xF8, + 0x20, 0x00, 0x10, 0x21, 0xB3, 0x20, 0x0F, 0xF0, 0xC1, 0xFE, 0xE1, 0xE7, + 0x2D, 0xE9, 0xF0, 0x4F, + 0x87, 0xB0, 0x14, 0xF0, 0x6C, 0xF9, 0x83, 0x46, 0x14, 0xF0, 0x6B, 0xF9, + 0xDF, 0xF8, 0x70, 0x91, + 0x01, 0x21, 0xC8, 0x46, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x31, 0x60, + 0x05, 0xA8, 0x0E, 0xF0, + 0x6E, 0xF9, 0x58, 0x4D, 0x58, 0x4F, 0x05, 0x9A, 0x28, 0x68, 0x00, 0x24, + 0x23, 0x46, 0x90, 0xF9, + 0x23, 0x10, 0x90, 0xF9, 0x22, 0x00, 0x00, 0x97, 0xCD, 0xE9, 0x01, 0x20, + 0xCD, 0xE9, 0x03, 0x14, + 0x22, 0x46, 0x58, 0x46, 0x10, 0xF0, 0x3E, 0xFF, 0x05, 0x99, 0xCD, 0xE9, + 0x01, 0x14, 0x4F, 0xF0, + 0x01, 0x0A, 0x00, 0x97, 0xCD, 0xE9, 0x03, 0x4A, 0x00, 0x22, 0x13, 0x46, + 0x58, 0x46, 0x10, 0xF0, + 0x31, 0xFF, 0x46, 0x48, 0x14, 0xF0, 0xDE, 0xF8, 0x44, 0x49, 0x03, 0x20, + 0x08, 0x72, 0x08, 0x46, + 0xFF, 0xF7, 0x6A, 0xFC, 0x41, 0x48, 0x02, 0x21, 0x34, 0x38, 0x87, 0x6A, + 0x06, 0xA8, 0x0E, 0xF0, + 0x3E, 0xF9, 0xD8, 0xF8, 0x00, 0x00, 0xB0, 0xF9, 0xD6, 0x11, 0xB0, 0xF9, + 0xD8, 0x21, 0x90, 0xF8, + 0x84, 0x09, 0x11, 0x44, 0x01, 0xEB, 0xD1, 0x71, 0x4F, 0xEA, 0x61, 0x08, + 0x80, 0x07, 0x05, 0xD4, + 0x76, 0x1E, 0x39, 0x46, 0x32, 0x46, 0x08, 0x46, 0x00, 0xF0, 0xBA, 0xF8, + 0x32, 0x46, 0x38, 0x46, + 0x06, 0x99, 0x11, 0xF0, 0xBC, 0xFC, 0xD9, 0xF8, 0x00, 0x10, 0x00, 0x26, + 0x37, 0x46, 0xB1, 0xF9, + 0xD6, 0x21, 0x82, 0x42, 0x03, 0xDB, 0xB1, 0xF9, 0xD8, 0x21, 0x82, 0x42, + 0x06, 0xDD, 0xB1, 0xF8, + 0xDA, 0x11, 0xA8, 0xEB, 0x00, 0x00, 0x90, 0xFB, 0xF1, 0xF0, 0x46, 0xB2, + 0x02, 0x21, 0x06, 0xA8, + 0x0E, 0xF0, 0xA0, 0xF9, 0x05, 0x98, 0x00, 0x22, 0x8D, 0xE8, 0xC1, 0x00, + 0x13, 0x46, 0x58, 0x46, + 0xFF, 0xF7, 0x71, 0xFC, 0x01, 0x28, 0x1A, 0xD0, 0x02, 0x28, 0x28, 0x68, + 0x1E, 0xD0, 0x00, 0xF8, + 0x22, 0x6F, 0x00, 0x22, 0x44, 0x70, 0x20, 0x48, 0x05, 0x99, 0x98, 0x38, + 0x8D, 0xE8, 0x43, 0x00, + 0xCD, 0xE9, 0x03, 0x4A, 0x13, 0x46, 0x58, 0x46, 0x10, 0xF0, 0xD4, 0xFE, + 0x29, 0x68, 0xA5, 0x20, + 0x81, 0xF8, 0x21, 0x00, 0x01, 0x21, 0x05, 0xA8, 0x0E, 0xF0, 0x7C, 0xF9, + 0x83, 0xE6, 0x28, 0x68, + 0x40, 0x21, 0x00, 0xF8, 0x22, 0x4F, 0x44, 0x70, 0xB2, 0x20, 0x04, 0xE0, + 0x00, 0xF8, 0x22, 0x4F, + 0x40, 0x21, 0x44, 0x70, 0xB3, 0x20, 0x0F, 0xF0, 0x19, 0xFE, 0xE7, 0xE7, + 0x70, 0xB5, 0x04, 0x46, + 0x00, 0x20, 0xFD, 0xF7, 0xEE, 0xFE, 0x02, 0x20, 0xFD, 0xF7, 0xEB, 0xFE, + 0x0B, 0x49, 0x01, 0x20, + 0x08, 0x70, 0x07, 0x4D, 0x28, 0x68, 0x90, 0xF8, 0xC0, 0x01, 0x20, 0x40, + 0xC0, 0x07, 0x01, 0xD0, + 0xFF, 0xF7, 0x5F, 0xFC, 0x28, 0x68, 0x0B, 0xE0, 0x98, 0x98, 0x01, 0x20, + 0x6C, 0x0F, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x50, 0x07, 0x10, 0x00, 0xD0, 0x99, 0x01, 0x20, + 0x78, 0x07, 0x10, 0x00, + 0x90, 0xF8, 0xC0, 0x01, 0x80, 0x07, 0x03, 0xD5, 0xA0, 0x07, 0x01, 0xD5, + 0xFF, 0xF7, 0x00, 0xFD, + 0x28, 0x68, 0x90, 0xF8, 0xC0, 0x11, 0xC9, 0x06, 0x06, 0xD5, 0x90, 0xF8, + 0x61, 0x04, 0x18, 0xB1, + 0xE0, 0x06, 0x01, 0xD5, 0xFF, 0xF7, 0xA9, 0xFD, 0x28, 0x68, 0x90, 0xF8, + 0xC0, 0x01, 0x40, 0x07, + 0x03, 0xD5, 0x60, 0x07, 0x01, 0xD5, 0xFF, 0xF7, 0x46, 0xFE, 0x28, 0x68, + 0x90, 0xF8, 0xC0, 0x01, + 0x00, 0x07, 0x03, 0xD5, 0x20, 0x07, 0x01, 0xD5, 0xFF, 0xF7, 0x10, 0xFF, + 0x00, 0x20, 0xFD, 0xF7, + 0xC3, 0xFE, 0x02, 0x20, 0xFD, 0xF7, 0xC0, 0xFE, 0xE0, 0x07, 0x04, 0xD0, + 0xBD, 0xE8, 0x70, 0x40, + 0x01, 0x20, 0x01, 0xF0, 0x75, 0xBA, 0x70, 0xBD, 0xF0, 0xB5, 0x00, 0x26, + 0x35, 0x46, 0x0C, 0xE0, + 0x01, 0x24, 0x07, 0xE0, 0x05, 0xFB, 0x03, 0x47, 0x64, 0x1C, 0x31, 0xF8, + 0x17, 0x70, 0x20, 0xF8, + 0x16, 0x70, 0x76, 0x1C, 0x9C, 0x42, 0xF5, 0xDB, 0x6D, 0x1C, 0x95, 0x42, + 0xF0, 0xDB, 0xF0, 0xBD, + 0x30, 0xB5, 0x00, 0x24, 0x01, 0x23, 0x05, 0xE0, 0x31, 0xF8, 0x13, 0x50, + 0x20, 0xF8, 0x14, 0x50, + 0x5B, 0x1C, 0x64, 0x1C, 0x93, 0x42, 0xF7, 0xDB, 0x30, 0xBD, 0x00, 0x00, + 0x70, 0xB5, 0x7E, 0x4D, + 0x4F, 0xF4, 0x25, 0x74, 0x21, 0x46, 0x28, 0x68, 0xFE, 0xF7, 0x17, 0xFC, + 0x00, 0x21, 0x1F, 0x20, + 0x0D, 0xF1, 0xFE, 0xF8, 0x22, 0x46, 0x29, 0x68, 0xBD, 0xE8, 0x70, 0x40, + 0x1F, 0x23, 0x77, 0x48, + 0xFE, 0xF7, 0xCA, 0xBA, 0x70, 0xB5, 0x76, 0x4D, 0x40, 0xF2, 0xAF, 0x14, + 0x21, 0x46, 0x28, 0x68, + 0xFE, 0xF7, 0x03, 0xFC, 0x00, 0x21, 0x1A, 0x20, 0x0D, 0xF1, 0xEA, 0xF8, + 0x22, 0x46, 0x29, 0x68, + 0xBD, 0xE8, 0x70, 0x40, 0x1A, 0x23, 0x6F, 0x48, 0xFE, 0xF7, 0xB6, 0xBA, + 0x2D, 0xE9, 0xF0, 0x41, + 0xDF, 0xF8, 0xB4, 0x81, 0x05, 0x1D, 0x0E, 0x46, 0x29, 0x46, 0x40, 0x46, + 0xFE, 0xF7, 0xED, 0xFB, + 0x30, 0x68, 0x6A, 0x4A, 0x00, 0xEB, 0x85, 0x03, 0x93, 0x42, 0x01, 0xD2, + 0x1B, 0x23, 0x13, 0xE0, + 0x67, 0x49, 0x8B, 0x42, 0x13, 0xD2, 0x90, 0x42, 0x0D, 0xD2, 0x44, 0x46, + 0x11, 0x1A, 0x8F, 0x08, + 0x90, 0x46, 0x1B, 0x23, 0x3A, 0x46, 0x21, 0x46, 0xFE, 0xF7, 0x96, 0xFA, + 0xEA, 0x1B, 0x04, 0xEB, + 0x87, 0x01, 0x1C, 0x23, 0x15, 0xE0, 0x1C, 0x23, 0x2A, 0x46, 0x41, 0x46, + 0x12, 0xE0, 0x5D, 0x4A, + 0x93, 0x42, 0x19, 0xD2, 0x88, 0x42, 0x15, 0xD2, 0x44, 0x46, 0x88, 0x46, + 0x09, 0x1A, 0x8F, 0x08, + 0x1C, 0x23, 0x3A, 0x46, 0x21, 0x46, 0xFE, 0xF7, 0x7F, 0xFA, 0xEA, 0x1B, + 0x04, 0xEB, 0x87, 0x01, + 0x1D, 0x23, 0x40, 0x46, 0xFE, 0xF7, 0x78, 0xFA, 0x30, 0x68, 0x00, 0xEB, + 0x85, 0x00, 0x30, 0x60, + 0xBD, 0xE8, 0xF0, 0x81, 0x1D, 0x23, 0xDF, 0xE7, 0x90, 0x42, 0x0D, 0xD2, + 0x47, 0x46, 0x11, 0x1A, + 0x8C, 0x08, 0x90, 0x46, 0x1D, 0x23, 0x22, 0x46, 0x39, 0x46, 0xFE, 0xF7, + 0x65, 0xFA, 0x2A, 0x1B, + 0x07, 0xEB, 0x84, 0x01, 0x1E, 0x23, 0xE4, 0xE7, 0x1E, 0x23, 0xCD, 0xE7, + 0xF8, 0xB5, 0x42, 0x4C, + 0x45, 0x48, 0x00, 0x90, 0x10, 0x34, 0x02, 0x20, 0xFD, 0xF7, 0xF3, 0xFD, + 0x00, 0x21, 0x1B, 0x20, + 0x0D, 0xF1, 0x7E, 0xF8, 0x00, 0x21, 0x1C, 0x20, 0x0D, 0xF1, 0x7A, 0xF8, + 0x00, 0x21, 0x1D, 0x20, + 0x0D, 0xF1, 0x76, 0xF8, 0x00, 0x21, 0x1E, 0x20, 0x0D, 0xF1, 0x72, 0xF8, + 0x10, 0x21, 0x20, 0x46, + 0x14, 0xF0, 0x72, 0xFB, 0x00, 0x20, 0x20, 0x80, 0xA0, 0x70, 0x2F, 0x4D, + 0x01, 0x20, 0xE0, 0x70, + 0x28, 0x68, 0xC1, 0x8A, 0xA1, 0x80, 0x80, 0x8A, 0xE0, 0x80, 0x04, 0x20, + 0x69, 0x46, 0xFF, 0xF7, + 0x7D, 0xFF, 0x01, 0x23, 0x00, 0x22, 0x21, 0x46, 0x10, 0x20, 0x11, 0xF0, + 0x37, 0xF8, 0x06, 0x46, + 0x69, 0x46, 0xFF, 0xF7, 0x73, 0xFF, 0x01, 0x23, 0x00, 0x22, 0x21, 0x46, + 0x11, 0x20, 0x11, 0xF0, + 0x2D, 0xF8, 0x69, 0x46, 0x30, 0x46, 0xFF, 0xF7, 0x69, 0xFF, 0x28, 0x68, + 0x90, 0xF8, 0x61, 0x04, + 0x48, 0xB1, 0x01, 0x23, 0x00, 0x22, 0x21, 0x46, 0x14, 0x20, 0x11, 0xF0, + 0x1F, 0xF8, 0x69, 0x46, + 0x30, 0x46, 0xFF, 0xF7, 0x5B, 0xFF, 0x28, 0x68, 0x90, 0xF8, 0x50, 0x12, + 0xC9, 0x07, 0x03, 0xD1, + 0x90, 0xF8, 0x80, 0x02, 0xC0, 0x07, 0x09, 0xD0, 0x01, 0x23, 0x00, 0x22, + 0x21, 0x46, 0x12, 0x20, + 0x11, 0xF0, 0x0C, 0xF8, 0x69, 0x46, 0x30, 0x46, 0xFF, 0xF7, 0x48, 0xFF, + 0x01, 0x23, 0x00, 0x22, + 0x21, 0x46, 0x13, 0x20, 0x11, 0xF0, 0x02, 0xF8, 0x69, 0x46, 0x30, 0x46, + 0xFF, 0xF7, 0x3E, 0xFF, + 0x28, 0x68, 0x90, 0xF8, 0x2F, 0x0A, 0xC0, 0x07, 0x09, 0xD0, 0x01, 0x23, + 0x00, 0x22, 0x21, 0x46, + 0x17, 0x20, 0x10, 0xF0, 0xF3, 0xFF, 0x69, 0x46, 0x30, 0x46, 0xFF, 0xF7, + 0x2F, 0xFF, 0x02, 0x20, + 0xFD, 0xF7, 0x9A, 0xFD, 0xF8, 0xBD, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0xF0, 0xEF, 0x01, 0x00, + 0x50, 0x07, 0x10, 0x00, 0xF0, 0x9F, 0x01, 0x00, 0xD4, 0x56, 0x10, 0x00, + 0xF0, 0xBF, 0x01, 0x00, + 0xF0, 0xCF, 0x01, 0x00, 0xF0, 0xDF, 0x01, 0x00, 0xF0, 0xAF, 0x01, 0x00, + 0x10, 0xB5, 0x01, 0x46, + 0x34, 0x22, 0xFE, 0x48, 0x14, 0xF0, 0xBE, 0xFA, 0x01, 0x21, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x20, + 0xFD, 0xF7, 0x7F, 0xBC, 0x70, 0xB5, 0x86, 0xB0, 0x06, 0x46, 0x68, 0x46, + 0x13, 0xF0, 0xD2, 0xFE, + 0xF7, 0x48, 0x00, 0x90, 0x02, 0x2E, 0x15, 0xD0, 0x07, 0x20, 0x8D, 0xF8, + 0x04, 0x00, 0xF3, 0x4C, + 0x68, 0x46, 0x13, 0xF0, 0xEC, 0xFE, 0x00, 0x22, 0x04, 0xAB, 0x01, 0x21, + 0x10, 0x46, 0xFD, 0xF7, + 0xB1, 0xFC, 0x01, 0x21, 0x00, 0x20, 0xFD, 0xF7, 0x90, 0xFC, 0x20, 0x78, + 0x30, 0xB1, 0x0F, 0xF0, + 0x74, 0xFC, 0xED, 0xE7, 0x03, 0x20, 0x8D, 0xF8, 0x09, 0x00, 0xE8, 0xE7, + 0xE9, 0x4D, 0x02, 0x2E, + 0x09, 0xD0, 0x13, 0xF0, 0x0C, 0xFF, 0xA8, 0x61, 0x13, 0xF0, 0x0B, 0xFF, + 0xC5, 0xE9, 0x10, 0x01, + 0xA0, 0x68, 0x06, 0xB0, 0x70, 0xBD, 0x13, 0xF0, 0x06, 0xFF, 0xA8, 0x61, + 0x13, 0xF0, 0x05, 0xFF, + 0xC5, 0xE9, 0x10, 0x01, 0x60, 0x69, 0xF4, 0xE7, 0x2D, 0xE9, 0xF0, 0x41, + 0xDD, 0x4C, 0x01, 0x25, + 0x60, 0x38, 0xD4, 0xE9, 0x10, 0x23, 0xA6, 0x69, 0x09, 0x28, 0x6F, 0xD2, + 0xDF, 0xE8, 0x00, 0xF0, + 0x05, 0x0F, 0x1E, 0x28, 0x37, 0x41, 0x50, 0x5A, 0x6A, 0x00, 0x32, 0x46, + 0x00, 0x23, 0x08, 0x46, + 0x00, 0xF0, 0x51, 0xFA, 0x85, 0x40, 0x60, 0x68, 0x05, 0x43, 0x65, 0x60, + 0x5E, 0xE0, 0x08, 0x46, + 0x00, 0xF0, 0x49, 0xFA, 0x02, 0x46, 0x01, 0x20, 0x00, 0x21, 0x14, 0xF0, + 0xDF, 0xF9, 0xD4, 0xE9, + 0x08, 0x23, 0x10, 0x43, 0x19, 0x43, 0xC4, 0xE9, 0x08, 0x01, 0x4F, 0xE0, + 0x32, 0x46, 0x00, 0x23, + 0x08, 0x46, 0x00, 0xF0, 0x38, 0xFA, 0x85, 0x40, 0xE0, 0x68, 0x05, 0x43, + 0xE5, 0x60, 0x45, 0xE0, + 0x08, 0x46, 0x00, 0xF0, 0x30, 0xFA, 0x02, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x14, 0xF0, 0xC6, 0xF9, + 0xD4, 0xE9, 0x0C, 0x23, 0x10, 0x43, 0x19, 0x43, 0xC4, 0xE9, 0x0C, 0x01, + 0x36, 0xE0, 0x32, 0x46, + 0x00, 0x23, 0x08, 0x46, 0x00, 0xF0, 0x1F, 0xFA, 0x85, 0x40, 0xA0, 0x68, + 0x05, 0x43, 0xA5, 0x60, + 0x2C, 0xE0, 0x08, 0x46, 0x00, 0xF0, 0x17, 0xFA, 0x02, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x14, 0xF0, + 0xAD, 0xF9, 0xD4, 0xE9, 0x0A, 0x23, 0x10, 0x43, 0x19, 0x43, 0xC4, 0xE9, + 0x0A, 0x01, 0x1D, 0xE0, + 0x32, 0x46, 0x00, 0x23, 0x08, 0x46, 0x00, 0xF0, 0x06, 0xFA, 0x85, 0x40, + 0x20, 0x69, 0x05, 0x43, + 0x25, 0x61, 0x13, 0xE0, 0x08, 0x46, 0x00, 0xF0, 0xFE, 0xF9, 0x01, 0x23, + 0x02, 0x46, 0x00, 0x21, + 0x18, 0x46, 0x14, 0xF0, 0x93, 0xF9, 0xD4, 0xE9, 0x0E, 0x23, 0x10, 0x43, + 0x19, 0x43, 0xC4, 0xE9, + 0x0E, 0x01, 0x03, 0xE0, 0x60, 0x69, 0x8D, 0x40, 0x05, 0x43, 0x65, 0x61, + 0x20, 0x68, 0x40, 0x1C, + 0x20, 0x60, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xF0, 0x41, 0x17, 0x46, + 0x04, 0x46, 0x0D, 0x46, + 0x00, 0x26, 0x09, 0xE0, 0xE0, 0x07, 0x03, 0xD0, 0x31, 0x46, 0x38, 0x46, + 0x0F, 0xF0, 0xBE, 0xFB, + 0x76, 0x1C, 0x6D, 0x08, 0x4F, 0xEA, 0x34, 0x04, 0x54, 0xEA, 0x05, 0x00, + 0xF2, 0xD1, 0xE8, 0xE7, + 0x70, 0xB5, 0x94, 0x4C, 0xE1, 0x68, 0x60, 0x68, 0xD4, 0xE9, 0x0C, 0x65, + 0x40, 0xEA, 0x01, 0x03, + 0xD4, 0xE9, 0x08, 0x21, 0x29, 0x43, 0x25, 0x69, 0x32, 0x43, 0x9D, 0x43, + 0x25, 0x61, 0xD4, 0xE9, + 0x0E, 0x35, 0x93, 0x43, 0x8D, 0x43, 0xC4, 0xE9, 0x0E, 0x35, 0x21, 0x68, + 0x00, 0x29, 0x2C, 0xD0, + 0x60, 0x22, 0x00, 0x21, 0xFF, 0xF7, 0xCF, 0xFF, 0xD4, 0xE9, 0x08, 0x01, + 0x61, 0x22, 0xFF, 0xF7, + 0xCA, 0xFF, 0x62, 0x22, 0x00, 0x21, 0xE0, 0x68, 0xFF, 0xF7, 0xC5, 0xFF, + 0xD4, 0xE9, 0x0C, 0x01, + 0x63, 0x22, 0xFF, 0xF7, 0xC0, 0xFF, 0x64, 0x22, 0x00, 0x21, 0xA0, 0x68, + 0xFF, 0xF7, 0xBB, 0xFF, + 0xD4, 0xE9, 0x0A, 0x01, 0x65, 0x22, 0xFF, 0xF7, 0xB6, 0xFF, 0x66, 0x22, + 0x00, 0x21, 0x20, 0x69, + 0xFF, 0xF7, 0xB1, 0xFF, 0xD4, 0xE9, 0x0E, 0x01, 0x67, 0x22, 0xFF, 0xF7, + 0xAC, 0xFF, 0x60, 0x69, + 0xBD, 0xE8, 0x70, 0x40, 0x68, 0x22, 0x00, 0x21, 0xA5, 0xE7, 0x70, 0xBD, + 0x2D, 0xE9, 0xF0, 0x5F, + 0x83, 0x46, 0x4F, 0xF0, 0x00, 0x0A, 0x13, 0xF0, 0x1A, 0xFE, 0x04, 0x46, + 0x13, 0xF0, 0x1B, 0xFE, + 0x40, 0xEA, 0x04, 0x06, 0x13, 0xF0, 0x15, 0xFE, 0x07, 0x46, 0x88, 0x46, + 0x13, 0xF0, 0x15, 0xFE, + 0x41, 0xEA, 0x08, 0x05, 0x67, 0x49, 0x40, 0xEA, 0x07, 0x04, 0x8E, 0x61, + 0xC1, 0xE9, 0x10, 0x45, + 0xFD, 0xF7, 0x0E, 0xFD, 0x00, 0xF0, 0xFF, 0x08, 0xFD, 0xF7, 0x0C, 0xFD, + 0x00, 0xF0, 0xFF, 0x09, + 0xFD, 0xF7, 0x19, 0xFE, 0x00, 0x27, 0x26, 0xE0, 0x01, 0x20, 0xB8, 0x40, + 0x30, 0x42, 0x21, 0xD0, + 0xF8, 0xB2, 0x00, 0x21, 0xFD, 0xF7, 0x17, 0xFE, 0x41, 0x07, 0x05, 0xD5, + 0x5F, 0xEA, 0xCB, 0x61, + 0x02, 0xD5, 0x51, 0x46, 0x62, 0x20, 0x0F, 0xE0, 0xC1, 0x07, 0x05, 0xD0, + 0x5F, 0xEA, 0x4B, 0x71, + 0x02, 0xD5, 0x51, 0x46, 0x60, 0x20, 0x07, 0xE0, 0x1B, 0xF0, 0xC0, 0x0F, + 0x06, 0xD0, 0x10, 0xF0, + 0x0A, 0x0F, 0x03, 0xD0, 0x51, 0x46, 0x64, 0x20, 0xFF, 0xF7, 0xDE, 0xFE, + 0x0A, 0xF1, 0x01, 0x00, + 0x00, 0xF0, 0xFF, 0x0A, 0x7F, 0x1C, 0x47, 0x45, 0xD6, 0xDB, 0xFD, 0xF7, + 0xEC, 0xFD, 0x00, 0x27, + 0x3E, 0x46, 0x29, 0xE0, 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x14, 0xF0, + 0xCF, 0xF8, 0x20, 0x40, + 0x29, 0x40, 0x08, 0x43, 0x1F, 0xD0, 0xF0, 0xB2, 0x01, 0x21, 0xFD, 0xF7, + 0xE4, 0xFD, 0x41, 0x07, + 0x05, 0xD5, 0x5F, 0xEA, 0x8B, 0x61, 0x02, 0xD5, 0x39, 0x46, 0x63, 0x20, + 0x0F, 0xE0, 0xC1, 0x07, + 0x05, 0xD0, 0x5F, 0xEA, 0x0B, 0x71, 0x02, 0xD5, 0x39, 0x46, 0x61, 0x20, + 0x07, 0xE0, 0x1B, 0xF4, + 0xC0, 0x7F, 0x06, 0xD0, 0x10, 0xF0, 0x0A, 0x0F, 0x03, 0xD0, 0x39, 0x46, + 0x65, 0x20, 0xFF, 0xF7, + 0xAB, 0xFE, 0x7F, 0x1C, 0xFF, 0xB2, 0x76, 0x1C, 0x4E, 0x45, 0xD3, 0xDD, + 0xBD, 0xE8, 0xF0, 0x5F, + 0xFD, 0xF7, 0xB9, 0xBD, 0x30, 0x48, 0x02, 0x68, 0x12, 0xF8, 0xD3, 0x1F, + 0xD0, 0x78, 0x00, 0xF0, + 0x1F, 0x00, 0x40, 0x1C, 0x41, 0x43, 0x48, 0x00, 0xC0, 0xEB, 0x40, 0x20, + 0x40, 0x10, 0x70, 0x47, + 0x2D, 0xE9, 0xFC, 0x5F, 0x07, 0x46, 0x00, 0x20, 0xCD, 0xE9, 0x00, 0x00, + 0x1C, 0x46, 0x92, 0x46, + 0x0E, 0x46, 0xFF, 0xF7, 0xE7, 0xFF, 0x00, 0xEB, 0x04, 0x08, 0x0C, 0x98, + 0x80, 0x07, 0x50, 0xD5, + 0x00, 0x24, 0x4C, 0xE0, 0x4F, 0xF0, 0x00, 0x09, 0x4F, 0xF0, 0xFF, 0x3B, + 0x4D, 0x46, 0x27, 0xE0, + 0x05, 0xFB, 0x06, 0x40, 0x3A, 0xF9, 0x10, 0x20, 0x42, 0x45, 0x20, 0xD2, + 0x09, 0xF1, 0x01, 0x09, + 0xBB, 0xF1, 0xFF, 0x3F, 0x00, 0xD1, 0xAB, 0x46, 0x79, 0x1E, 0x8D, 0x42, + 0x17, 0xD1, 0xB9, 0xF1, + 0x01, 0x0F, 0x14, 0xD1, 0x71, 0x1E, 0x8C, 0x42, 0x04, 0xD1, 0x29, 0x46, + 0x66, 0x20, 0xFF, 0xF7, + 0x63, 0xFE, 0x0C, 0xE0, 0x0A, 0xEB, 0x40, 0x00, 0xB0, 0xF9, 0x02, 0x20, + 0x42, 0x45, 0x04, 0xD3, + 0x2C, 0xB1, 0x30, 0xF9, 0x02, 0x1C, 0x41, 0x45, 0x01, 0xD2, 0x4F, 0xF0, + 0x00, 0x09, 0x6D, 0x1C, + 0xBD, 0x42, 0xD5, 0xD3, 0xA7, 0xEB, 0x0B, 0x01, 0x49, 0x45, 0x17, 0xD8, + 0x21, 0x46, 0x67, 0x20, + 0xFF, 0xF7, 0x4A, 0xFE, 0x01, 0x20, 0x22, 0x46, 0x00, 0x21, 0x07, 0xE0, + 0x7C, 0x0F, 0x10, 0x00, + 0x0D, 0x2C, 0x00, 0x00, 0x70, 0x04, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x14, 0xF0, 0x3E, 0xF8, + 0xDD, 0xE9, 0x00, 0x23, 0x10, 0x43, 0x19, 0x43, 0xCD, 0xE9, 0x00, 0x01, + 0x64, 0x1C, 0xB4, 0x42, + 0xB0, 0xD3, 0x0C, 0x98, 0xC0, 0x07, 0x25, 0xD0, 0x00, 0x25, 0x21, 0xE0, + 0x4F, 0xF0, 0x00, 0x09, + 0x4C, 0x46, 0x13, 0xE0, 0x05, 0xFB, 0x06, 0x41, 0x3A, 0xF9, 0x11, 0x10, + 0x41, 0x45, 0x0C, 0xD2, + 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x14, 0xF0, 0x21, 0xF8, 0xDD, 0xE9, + 0x00, 0x23, 0x10, 0x40, + 0x19, 0x40, 0x08, 0x43, 0x01, 0xD1, 0x09, 0xF1, 0x01, 0x09, 0x64, 0x1C, + 0xB4, 0x42, 0xE9, 0xD3, + 0xB9, 0xF1, 0x00, 0x0F, 0x03, 0xD0, 0x29, 0x46, 0x66, 0x20, 0xFF, 0xF7, + 0x0D, 0xFE, 0x6D, 0x1C, + 0xBD, 0x42, 0xDB, 0xD3, 0xBD, 0xE8, 0xFC, 0x9F, 0x2D, 0xE9, 0xFF, 0x47, + 0x04, 0x46, 0x00, 0x20, + 0xFD, 0xF7, 0x27, 0xFB, 0x4C, 0x49, 0x4F, 0xF0, 0x01, 0x09, 0x81, 0xF8, + 0x00, 0x90, 0x00, 0xF0, + 0x7D, 0xF8, 0x14, 0xF0, 0x0C, 0x0F, 0x09, 0xD1, 0xE0, 0x06, 0x07, 0xD4, + 0xA0, 0x06, 0x05, 0xD4, + 0x60, 0x06, 0x03, 0xD4, 0xE0, 0x05, 0x01, 0xD4, 0x20, 0x06, 0x02, 0xD5, + 0x20, 0x46, 0xFF, 0xF7, + 0xC5, 0xFE, 0x42, 0x4E, 0xA0, 0x07, 0x1C, 0xD0, 0x01, 0x20, 0xFF, 0xF7, + 0xAB, 0xFD, 0x05, 0x46, + 0x13, 0xF0, 0xDD, 0xFC, 0x01, 0x90, 0x13, 0xF0, 0xDC, 0xFC, 0xCD, 0xE9, + 0x02, 0x01, 0x04, 0x21, + 0x01, 0xA8, 0xFE, 0xF7, 0x68, 0xF8, 0x07, 0x46, 0x08, 0x21, 0x02, 0xA8, + 0xFE, 0xF7, 0x63, 0xF8, + 0x01, 0x46, 0x00, 0x94, 0x30, 0x68, 0x2A, 0x46, 0x90, 0xF8, 0xDA, 0x30, + 0x38, 0x46, 0xFF, 0xF7, + 0x37, 0xFF, 0x14, 0xF4, 0xC0, 0x6F, 0x26, 0xD0, 0x30, 0x68, 0x90, 0xF8, + 0x61, 0x04, 0x10, 0xB3, + 0x00, 0x25, 0xFF, 0xF7, 0x1F, 0xFF, 0x31, 0x68, 0xB0, 0x46, 0x91, 0xF8, + 0xDB, 0x10, 0x0F, 0x18, + 0x02, 0x20, 0xFF, 0xF7, 0x7F, 0xFD, 0x06, 0x46, 0x5F, 0xF0, 0x00, 0x04, + 0xD8, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x61, 0x14, 0x09, 0xFA, 0x04, 0xF0, 0x01, 0x42, 0x09, 0xD0, + 0x6D, 0x1C, 0x36, 0xF9, + 0x14, 0x00, 0xED, 0xB2, 0xB8, 0x42, 0x03, 0xD2, 0x29, 0x46, 0x68, 0x20, + 0xFF, 0xF7, 0xA4, 0xFD, + 0x64, 0x1C, 0x04, 0x2C, 0xEA, 0xDB, 0xFF, 0xF7, 0x33, 0xFE, 0x04, 0xB0, + 0x00, 0x20, 0xBD, 0xE8, + 0xF0, 0x47, 0xFD, 0xF7, 0xD9, 0xBA, 0x2D, 0xE9, 0xF0, 0x41, 0x16, 0x46, + 0x1F, 0x46, 0x80, 0x46, + 0x4F, 0xF0, 0xFF, 0x35, 0x00, 0x24, 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x13, 0xF0, 0x8E, 0xFF, + 0x30, 0x40, 0x39, 0x40, 0x08, 0x43, 0x04, 0xD0, 0x6D, 0x1C, 0x45, 0x45, + 0x01, 0xD1, 0x20, 0x46, + 0xFF, 0xE5, 0x64, 0x1C, 0x40, 0x2C, 0xEE, 0xD3, 0x00, 0x20, 0xFA, 0xE5, + 0x0C, 0x48, 0x00, 0x21, + 0x01, 0x61, 0x41, 0x60, 0x81, 0x60, 0xC1, 0x60, 0xC0, 0xE9, 0x0E, 0x11, + 0xC0, 0xE9, 0x08, 0x11, + 0xC0, 0xE9, 0x0A, 0x11, 0x41, 0x61, 0x01, 0x60, 0xC0, 0xE9, 0x0C, 0x11, + 0x41, 0xF2, 0xC8, 0x11, + 0x04, 0x48, 0x14, 0xF0, 0x43, 0xB8, 0x00, 0x00, 0x78, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x70, 0x04, 0x10, 0x00, 0x78, 0x8B, 0x01, 0x20, 0x11, 0x49, 0x08, 0x60, + 0x4F, 0xF4, 0x00, 0x51, + 0x00, 0x20, 0xFD, 0xF7, 0x9E, 0xB9, 0x38, 0xB5, 0xAF, 0xF2, 0x13, 0x00, + 0xFE, 0xF7, 0xAB, 0xFB, + 0x00, 0x22, 0x4F, 0xF4, 0x00, 0x54, 0x6B, 0x46, 0x21, 0x46, 0x10, 0x46, + 0xFD, 0xF7, 0xDA, 0xF9, + 0x21, 0x46, 0x00, 0x20, 0xFD, 0xF7, 0xB9, 0xF9, 0x06, 0x48, 0xA5, 0x22, + 0x01, 0x68, 0x04, 0x48, + 0x0A, 0x74, 0x00, 0x68, 0x20, 0xF0, 0x7F, 0x42, 0x4A, 0x61, 0xFE, 0xF7, + 0xB2, 0xFB, 0x38, 0xBD, + 0xB8, 0x04, 0x10, 0x00, 0x50, 0x07, 0x10, 0x00, 0x02, 0x00, 0x04, 0xD0, + 0x01, 0x2A, 0x04, 0xD0, + 0x02, 0x28, 0x03, 0xD1, 0x04, 0xE0, 0x01, 0x20, 0x00, 0xE0, 0x04, 0x20, + 0x13, 0xF0, 0x32, 0xBB, + 0x01, 0x20, 0x12, 0xF0, 0xD1, 0xBC, 0x10, 0xB5, 0x01, 0x46, 0x34, 0x22, + 0xFA, 0x48, 0x13, 0xF0, + 0xA1, 0xFF, 0x01, 0x21, 0xBD, 0xE8, 0x10, 0x40, 0x00, 0x20, 0xFD, 0xF7, + 0x62, 0xB9, 0x30, 0xB5, + 0x85, 0xB0, 0x04, 0x46, 0x68, 0x46, 0x13, 0xF0, 0xB5, 0xFB, 0xF4, 0x48, + 0x00, 0x90, 0xAC, 0xB1, + 0x01, 0x2C, 0x15, 0xD0, 0x02, 0x2C, 0x15, 0xD0, 0x03, 0x2C, 0x31, 0xD1, + 0x5F, 0xF0, 0x08, 0x00, + 0x8D, 0xF8, 0x04, 0x00, 0x01, 0x20, 0x8D, 0xF8, 0x0D, 0x00, 0xED, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0xB0, 0x00, 0xC0, 0xF3, 0xC1, 0x00, 0x02, 0x28, 0x08, 0xD0, 0x0A, 0xE0, + 0x05, 0x20, 0xEF, 0xE7, + 0x06, 0x20, 0xED, 0xE7, 0x02, 0x20, 0x8D, 0xF8, 0x09, 0x00, 0xEB, 0xE7, + 0x00, 0x20, 0x8D, 0xF8, + 0x0D, 0x00, 0xE1, 0x4D, 0x03, 0x24, 0x68, 0x46, 0x13, 0xF0, 0xB1, 0xFB, + 0x00, 0x22, 0x04, 0xAB, + 0x01, 0x21, 0x10, 0x46, 0xFD, 0xF7, 0x76, 0xF9, 0x01, 0x21, 0x00, 0x20, + 0xFD, 0xF7, 0x55, 0xF9, + 0x28, 0x78, 0x00, 0x28, 0x04, 0xD0, 0x0F, 0xF0, 0x38, 0xF9, 0x64, 0x1E, + 0x00, 0x2C, 0xEA, 0xDC, + 0x05, 0xB0, 0x30, 0xBD, 0x2D, 0xE9, 0xF1, 0x4F, 0x88, 0xB0, 0x13, 0xF0, + 0xD0, 0xFB, 0x01, 0x90, + 0x13, 0xF0, 0xCF, 0xFB, 0x06, 0x46, 0xD2, 0x4C, 0x08, 0x98, 0x88, 0x46, + 0x00, 0x28, 0x20, 0x68, + 0x07, 0xD0, 0xB0, 0xF8, 0x7A, 0x11, 0x08, 0x98, 0xFF, 0xF7, 0x8E, 0xFF, + 0x03, 0x90, 0xCD, 0x48, + 0x10, 0xE0, 0x90, 0xF8, 0xE7, 0x00, 0x10, 0xF0, 0x60, 0x0F, 0x03, 0xD0, + 0x01, 0x98, 0x10, 0xF0, + 0xDB, 0xF8, 0x01, 0x90, 0x20, 0x68, 0xB0, 0xF8, 0x72, 0x11, 0x08, 0x98, + 0xFF, 0xF7, 0x7C, 0xFF, + 0x03, 0x90, 0xC5, 0x48, 0x02, 0x90, 0x20, 0x20, 0x06, 0x90, 0xBF, 0x48, + 0x4F, 0xF0, 0x40, 0x0A, + 0xB8, 0x21, 0xD0, 0x38, 0x13, 0xF0, 0x82, 0xFF, 0x00, 0x20, 0x00, 0x90, + 0x08, 0x98, 0xFF, 0xF7, + 0x86, 0xFF, 0xB9, 0x48, 0x00, 0x27, 0xB9, 0x46, 0x80, 0x68, 0x4F, 0xF0, + 0x01, 0x0B, 0x3C, 0x46, + 0x05, 0x90, 0x01, 0x20, 0x01, 0x99, 0xA0, 0x40, 0x08, 0x42, 0x40, 0xD0, + 0x00, 0x25, 0x2A, 0x46, + 0x01, 0x20, 0x00, 0x21, 0x13, 0xF0, 0x92, 0xFE, 0x02, 0x46, 0x0B, 0x46, + 0x30, 0x40, 0x01, 0xEA, + 0x08, 0x01, 0x08, 0x43, 0x21, 0xD0, 0xAC, 0x48, 0xD0, 0x38, 0x00, 0xEB, + 0xC4, 0x01, 0x04, 0x91, + 0xD1, 0xE9, 0x00, 0x01, 0x8E, 0x46, 0x00, 0xEA, 0x02, 0x0C, 0x19, 0x40, + 0x5C, 0xEA, 0x01, 0x0C, + 0x12, 0xD1, 0x05, 0x99, 0x31, 0xF9, 0x17, 0xC0, 0x03, 0x99, 0x8C, 0x45, + 0x06, 0xDC, 0x10, 0x43, + 0x04, 0x9A, 0x4E, 0xEA, 0x03, 0x01, 0xC2, 0xE9, 0x00, 0x01, 0x05, 0xE0, + 0x2A, 0x46, 0x49, 0x46, + 0x00, 0x9B, 0x02, 0x98, 0xFD, 0xF7, 0xF9, 0xFA, 0x7F, 0x1C, 0x6D, 0x1C, + 0x55, 0x45, 0xCE, 0xDB, + 0x99, 0x48, 0xD0, 0x38, 0x00, 0xEB, 0xC4, 0x01, 0xD1, 0xE9, 0x00, 0x01, + 0x70, 0x40, 0x81, 0xEA, + 0x08, 0x01, 0x08, 0x43, 0x01, 0xD0, 0x4F, 0xF0, 0x00, 0x0B, 0x09, 0xF1, + 0x01, 0x09, 0x06, 0x98, + 0x64, 0x1C, 0x84, 0x42, 0xB5, 0xDB, 0xBB, 0xF1, 0x01, 0x0F, 0x04, 0xD0, + 0x00, 0x98, 0x40, 0x1C, + 0x00, 0x90, 0x7F, 0x28, 0xA2, 0xDD, 0x09, 0xB0, 0x58, 0x46, 0xBD, 0xE8, + 0xF0, 0x8F, 0x2D, 0xE9, + 0xF1, 0x4F, 0x8A, 0xB0, 0x13, 0xF0, 0x3B, 0xFB, 0x06, 0x90, 0x13, 0xF0, + 0x38, 0xFB, 0x00, 0x21, + 0xCD, 0xE9, 0x02, 0x01, 0x0A, 0x98, 0x86, 0x4C, 0x00, 0x28, 0x56, 0xD0, + 0x20, 0x68, 0xB0, 0xF8, + 0x7A, 0x11, 0x0A, 0x98, 0xFF, 0xF7, 0xF8, 0xFE, 0x01, 0x90, 0x82, 0x48, + 0x05, 0x90, 0x20, 0x20, + 0x09, 0x90, 0x4F, 0xF0, 0x40, 0x0A, 0x04, 0x21, 0x06, 0xA8, 0xFD, 0xF7, + 0xB4, 0xFE, 0x04, 0x46, + 0x08, 0x21, 0x02, 0xA8, 0xFD, 0xF7, 0xAF, 0xFE, 0x44, 0x43, 0x7C, 0x48, + 0x00, 0x90, 0x00, 0xF5, + 0xE6, 0x60, 0x21, 0x46, 0x04, 0x90, 0x13, 0xF0, 0xCF, 0xFE, 0x61, 0x00, + 0x00, 0x98, 0x13, 0xF0, + 0xCB, 0xFE, 0x71, 0x48, 0xB8, 0x21, 0xD0, 0x38, 0x13, 0xF0, 0xE8, 0xFE, + 0x00, 0x25, 0x0A, 0x98, + 0xFF, 0xF7, 0xED, 0xFE, 0x6C, 0x48, 0x4F, 0xF0, 0x00, 0x09, 0x4C, 0x46, + 0x80, 0x68, 0x07, 0x90, + 0x68, 0x42, 0x4F, 0xF0, 0x01, 0x0B, 0x4E, 0x46, 0x08, 0x90, 0x01, 0x20, + 0x06, 0x99, 0xB0, 0x40, + 0x08, 0x42, 0x79, 0xD0, 0x00, 0x27, 0x3A, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x13, 0xF0, 0xF6, 0xFD, + 0xDD, 0xE9, 0x02, 0x8C, 0x02, 0x46, 0x0B, 0x46, 0x00, 0xEA, 0x08, 0x00, + 0x01, 0xEA, 0x0C, 0x01, + 0x08, 0x43, 0x6A, 0xD0, 0x5C, 0x48, 0xD0, 0x38, 0x00, 0xEB, 0xC6, 0x0C, + 0xDC, 0xE9, 0x00, 0x01, + 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x0D, 0xD0, 0x89, 0xE0, 0x06, 0x98, + 0x0F, 0xF0, 0xFC, 0xFF, + 0x06, 0x90, 0x20, 0x68, 0xB0, 0xF8, 0x72, 0x11, 0x0A, 0x98, 0xFF, 0xF7, + 0x9D, 0xFE, 0x01, 0x90, + 0x55, 0x48, 0xA3, 0xE7, 0x00, 0x2D, 0x0A, 0xDA, 0x07, 0x98, 0x30, 0xF9, + 0x14, 0x10, 0x01, 0x98, + 0x81, 0x42, 0x01, 0xDB, 0x00, 0x21, 0x00, 0xE0, 0x01, 0x21, 0x04, 0x98, + 0x01, 0x55, 0x07, 0x98, + 0x01, 0x99, 0x30, 0xF9, 0x14, 0x00, 0x88, 0x42, 0x2A, 0xDD, 0x04, 0x99, + 0x09, 0x5D, 0x11, 0xB1, + 0x01, 0x29, 0x07, 0xD0, 0x63, 0xE0, 0x7F, 0x2D, 0x61, 0xDA, 0x00, 0x99, + 0x6B, 0x1C, 0x21, 0xF8, + 0x14, 0x00, 0x4C, 0xE0, 0xDC, 0xE9, 0x00, 0x10, 0x11, 0x43, 0x18, 0x43, + 0xCC, 0xE9, 0x00, 0x10, + 0x00, 0x98, 0x30, 0xF9, 0x14, 0x10, 0x01, 0x98, 0x08, 0x1A, 0x07, 0x99, + 0x31, 0xF9, 0x14, 0x20, + 0x01, 0x99, 0xA2, 0xEB, 0x01, 0x01, 0x00, 0xD5, 0x40, 0x42, 0x00, 0x29, + 0x00, 0xDA, 0x49, 0x42, + 0x88, 0x42, 0x3A, 0xDC, 0x08, 0x9B, 0x3A, 0x46, 0x49, 0x46, 0x5B, 0x1C, + 0x05, 0x98, 0x31, 0xE0, + 0x37, 0xDA, 0x04, 0x99, 0x09, 0x5D, 0x01, 0x29, 0x01, 0xD0, 0x79, 0xB1, + 0x37, 0xE0, 0x08, 0x99, + 0x11, 0xF1, 0x7F, 0x0F, 0x33, 0xDD, 0x00, 0x99, 0x3A, 0x46, 0x21, 0xF8, + 0x14, 0x00, 0x08, 0x9B, + 0x49, 0x46, 0x5B, 0x1E, 0x05, 0x98, 0x1D, 0xE0, 0x3E, 0xE0, 0x29, 0xE0, + 0xDC, 0xE9, 0x00, 0x10, + 0x11, 0x43, 0x18, 0x43, 0xCC, 0xE9, 0x00, 0x10, 0x00, 0x98, 0x30, 0xF9, + 0x14, 0x10, 0x01, 0x98, + 0x08, 0x1A, 0x07, 0x99, 0x31, 0xF9, 0x14, 0x20, 0x01, 0x99, 0xA2, 0xEB, + 0x01, 0x01, 0x00, 0xD5, + 0x40, 0x42, 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0x88, 0x42, 0x06, 0xDC, + 0x6B, 0x1E, 0x3A, 0x46, + 0x49, 0x46, 0x05, 0x98, 0xFD, 0xF7, 0xF1, 0xF9, 0x09, 0xE0, 0x00, 0x98, + 0x20, 0xF8, 0x14, 0x20, + 0x05, 0xE0, 0xDC, 0xE9, 0x00, 0x10, 0x11, 0x43, 0x18, 0x43, 0xCC, 0xE9, + 0x00, 0x10, 0x64, 0x1C, + 0x7F, 0x1C, 0x57, 0x45, 0xFF, 0xF6, 0x57, 0xAF, 0x0F, 0x48, 0xD0, 0x38, + 0x00, 0xEB, 0xC6, 0x01, + 0xD1, 0xE9, 0x00, 0x01, 0xDD, 0xE9, 0x02, 0x23, 0x50, 0x40, 0x59, 0x40, + 0x08, 0x43, 0x01, 0xD0, + 0x4F, 0xF0, 0x00, 0x0B, 0x09, 0xF1, 0x01, 0x09, 0x09, 0x98, 0x76, 0x1C, + 0x86, 0x42, 0xFF, 0xF6, + 0x3C, 0xAF, 0x58, 0x46, 0xBB, 0xF1, 0x01, 0x0F, 0x03, 0xD0, 0x6D, 0x1C, + 0x7F, 0x2D, 0x7F, 0xF7, + 0x26, 0xAF, 0x0B, 0xB0, 0xE9, 0xE6, 0x00, 0x00, 0x80, 0x10, 0x10, 0x00, + 0x47, 0x32, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x08, 0x92, 0x01, 0x20, 0x78, 0x8B, 0x01, 0x20, + 0xD4, 0x56, 0x10, 0x00, + 0x2D, 0xE9, 0xF1, 0x4F, 0x96, 0xB0, 0x4F, 0xF0, 0x00, 0x0A, 0x13, 0xF0, + 0x18, 0xFA, 0x0D, 0x90, + 0x13, 0xF0, 0x17, 0xFA, 0xCD, 0xE9, 0x0E, 0x01, 0x16, 0x98, 0x48, 0xB1, + 0xFE, 0x48, 0x00, 0x68, + 0xB0, 0xF8, 0x7A, 0x11, 0x16, 0x98, 0xFF, 0xF7, 0xD7, 0xFD, 0x11, 0x90, + 0xFB, 0x48, 0x12, 0xE0, + 0xF9, 0x4C, 0x20, 0x68, 0x90, 0xF8, 0xE7, 0x00, 0x10, 0xF0, 0x60, 0x0F, + 0x03, 0xD0, 0x0D, 0x98, + 0x0F, 0xF0, 0x22, 0xFF, 0x0D, 0x90, 0x20, 0x68, 0xB0, 0xF8, 0x72, 0x11, + 0x16, 0x98, 0xFF, 0xF7, + 0xC3, 0xFD, 0x11, 0x90, 0xF2, 0x48, 0x01, 0x90, 0x40, 0x20, 0x0A, 0x90, + 0x20, 0x26, 0x04, 0x21, + 0x0D, 0xA8, 0xFD, 0xF7, 0x80, 0xFD, 0x0C, 0x90, 0x08, 0x21, 0x0E, 0xA8, + 0xFD, 0xF7, 0x7B, 0xFD, + 0x07, 0x90, 0xB8, 0x21, 0xEB, 0x48, 0x13, 0xF0, 0xC1, 0xFD, 0x01, 0x20, + 0x10, 0x90, 0x00, 0x20, + 0x04, 0x46, 0x05, 0x90, 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x13, 0xF0, + 0xDF, 0xFC, 0xDD, 0xE9, + 0x0E, 0x23, 0x81, 0x46, 0x8B, 0x46, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, + 0x78, 0xD0, 0xDE, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0x70, 0x01, 0x40, 0x07, 0x13, 0xD5, 0x05, 0x98, + 0x80, 0xB1, 0x00, 0x25, + 0x0B, 0xE0, 0xDD, 0xE9, 0x01, 0x02, 0x29, 0x46, 0xFD, 0xF7, 0x4C, 0xF9, + 0x03, 0x46, 0x22, 0x46, + 0x29, 0x46, 0x01, 0x98, 0xFD, 0xF7, 0x51, 0xF9, 0x6D, 0x1C, 0x0C, 0x98, + 0x85, 0x42, 0xF0, 0xDB, + 0x02, 0x94, 0x16, 0x98, 0xFF, 0xF7, 0x9B, 0xFD, 0xD2, 0x48, 0x4F, 0xF0, + 0x01, 0x08, 0xD0, 0x30, + 0x00, 0x25, 0x80, 0x68, 0x2F, 0x46, 0x14, 0x90, 0x01, 0x20, 0x0D, 0x99, + 0xB8, 0x40, 0x08, 0x42, + 0x45, 0xD0, 0xCC, 0x48, 0x00, 0xEB, 0xC7, 0x01, 0x15, 0x91, 0xD1, 0xE9, + 0x00, 0x01, 0x00, 0xEA, + 0x09, 0x00, 0x01, 0xEA, 0x0B, 0x01, 0x08, 0x43, 0x2E, 0xD1, 0x22, 0x46, + 0x29, 0x46, 0x01, 0x98, + 0xFD, 0xF7, 0x20, 0xF9, 0x07, 0x9A, 0x05, 0x99, 0x05, 0xFB, 0x02, 0x12, + 0x14, 0x99, 0x31, 0xF9, + 0x12, 0x20, 0x11, 0x99, 0x8A, 0x42, 0x0A, 0xDA, 0x15, 0x98, 0x15, 0x99, + 0xD0, 0xE9, 0x00, 0x20, + 0x42, 0xEA, 0x09, 0x02, 0x40, 0xEA, 0x0B, 0x00, 0xC1, 0xE9, 0x00, 0x20, + 0x14, 0xE0, 0x7F, 0x28, + 0x06, 0xDA, 0x43, 0x1C, 0x22, 0x46, 0x29, 0x46, 0x01, 0x98, 0xFD, 0xF7, + 0x0E, 0xF9, 0x0B, 0xE0, + 0x15, 0x98, 0x15, 0x9A, 0xD0, 0xE9, 0x00, 0x10, 0x41, 0xEA, 0x09, 0x01, + 0x40, 0xEA, 0x0B, 0x00, + 0xC2, 0xE9, 0x00, 0x10, 0x00, 0x20, 0x10, 0x90, 0x15, 0x99, 0x6D, 0x1C, + 0xD1, 0xE9, 0x00, 0x01, + 0x00, 0xEA, 0x09, 0x00, 0x01, 0xEA, 0x0B, 0x01, 0x08, 0x43, 0x00, 0xD1, + 0x80, 0x46, 0x7F, 0x1C, + 0xB7, 0x42, 0xB1, 0xDB, 0xB8, 0xF1, 0x00, 0x0F, 0xA3, 0xD0, 0x05, 0x98, + 0x40, 0x1C, 0x05, 0x90, + 0x0A, 0x98, 0x64, 0x1C, 0x84, 0x42, 0xFF, 0xF6, 0x75, 0xAF, 0x00, 0x20, + 0xB4, 0xE0, 0x00, 0xBF, + 0x4F, 0xF0, 0x00, 0x08, 0x45, 0x46, 0x2A, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x13, 0xF0, 0x4E, 0xFC, + 0xDD, 0xE9, 0x0E, 0x23, 0x83, 0x46, 0x06, 0x91, 0x10, 0x40, 0x19, 0x40, + 0x08, 0x43, 0x6E, 0xD0, + 0xB8, 0xF1, 0x00, 0x0F, 0x01, 0xD1, 0x4F, 0xF0, 0x01, 0x0A, 0x16, 0x98, + 0xFF, 0xF7, 0x1F, 0xFD, + 0x94, 0x48, 0x4F, 0xF0, 0x01, 0x09, 0xD0, 0x30, 0x00, 0x27, 0x80, 0x68, + 0x3C, 0x46, 0x14, 0x90, + 0x01, 0x20, 0x0D, 0x99, 0xA0, 0x40, 0x08, 0x42, 0x78, 0xD0, 0xB8, 0xF1, + 0x00, 0x0F, 0x0E, 0xDD, + 0x2A, 0x46, 0x39, 0x46, 0x01, 0x98, 0xFD, 0xF7, 0xAD, 0xF8, 0x8A, 0x49, + 0x2A, 0x46, 0xB8, 0x31, + 0x09, 0x57, 0x0B, 0x18, 0x39, 0x46, 0x01, 0x98, 0xFD, 0xF7, 0xAF, 0xF8, + 0x65, 0xE0, 0xBA, 0xF1, + 0x01, 0x0F, 0x12, 0xD1, 0x2A, 0x46, 0x39, 0x46, 0x01, 0x98, 0xFD, 0xF7, + 0x9B, 0xF8, 0x81, 0x49, + 0xB8, 0x31, 0x08, 0x55, 0x7F, 0x48, 0x00, 0xEB, 0xC4, 0x03, 0xD3, 0xE9, + 0x00, 0x01, 0x06, 0x9A, + 0x20, 0xEA, 0x0B, 0x00, 0x91, 0x43, 0xC3, 0xE9, 0x00, 0x01, 0x7A, 0x48, + 0x06, 0x9B, 0x00, 0xEB, + 0xC4, 0x00, 0x0C, 0x90, 0xD0, 0xE9, 0x00, 0x10, 0x01, 0xEA, 0x0B, 0x01, + 0x18, 0x40, 0x01, 0x43, + 0x39, 0xD1, 0x2A, 0x46, 0x39, 0x46, 0x01, 0x98, 0xFD, 0xF7, 0x7C, 0xF8, + 0x07, 0x9A, 0x14, 0x99, + 0x07, 0xFB, 0x02, 0x82, 0x31, 0xF9, 0x12, 0x20, 0x11, 0x99, 0x8A, 0x42, + 0x0E, 0xDA, 0x0C, 0x99, + 0x06, 0x9B, 0xD1, 0xE9, 0x00, 0xC2, 0x4C, 0xEA, 0x0B, 0x0C, 0x1A, 0x43, + 0xC1, 0xE9, 0x00, 0xC2, + 0x68, 0x49, 0xB8, 0x31, 0x0A, 0x5D, 0x80, 0x1A, 0x08, 0x55, 0x1C, 0xE0, + 0x7F, 0x28, 0x07, 0xDA, + 0x43, 0x1C, 0x2A, 0x46, 0x39, 0x46, 0x01, 0x98, 0xFD, 0xF7, 0x67, 0xF8, + 0x13, 0xE0, 0x29, 0xE0, + 0x0C, 0x99, 0xDD, 0xF8, 0x18, 0xC0, 0x0C, 0x9B, 0xD1, 0xE9, 0x00, 0x21, + 0x42, 0xEA, 0x0B, 0x02, + 0x41, 0xEA, 0x0C, 0x01, 0xC3, 0xE9, 0x00, 0x21, 0x5A, 0x49, 0xB8, 0x31, + 0x0A, 0x5D, 0x80, 0x1A, + 0x08, 0x55, 0x00, 0x20, 0x10, 0x90, 0x0C, 0x98, 0x06, 0x9A, 0xD0, 0xE9, + 0x00, 0x10, 0x01, 0xEA, + 0x0B, 0x01, 0x10, 0x40, 0x01, 0x43, 0x00, 0xD1, 0x89, 0x46, 0x7F, 0x1C, + 0x64, 0x1C, 0xB4, 0x42, + 0xFF, 0xF6, 0x7E, 0xAF, 0x4F, 0xF0, 0x00, 0x0A, 0xB9, 0xF1, 0x00, 0x0F, + 0x3F, 0xF4, 0x6D, 0xAF, + 0x08, 0xF1, 0x01, 0x08, 0x0A, 0x98, 0x6D, 0x1C, 0x85, 0x42, 0xFF, 0xF6, + 0x54, 0xAF, 0x16, 0x98, + 0xFF, 0xF7, 0x85, 0xFC, 0x0B, 0x98, 0x40, 0x1C, 0x0B, 0x90, 0x43, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x70, 0x11, 0x0B, 0x98, 0xB0, 0xEB, 0x11, 0x1F, 0xFF, 0xF6, 0x42, 0xAF, + 0x10, 0x98, 0x17, 0xB0, + 0x4B, 0xE5, 0x2D, 0xE9, 0xF0, 0x4F, 0x8B, 0xB0, 0x13, 0xF0, 0x8D, 0xF8, + 0x09, 0x90, 0x13, 0xF0, + 0x8C, 0xF8, 0x8A, 0x46, 0x38, 0x49, 0x81, 0x46, 0x00, 0x20, 0x0A, 0x68, + 0x01, 0x46, 0x16, 0x46, + 0x92, 0xF8, 0x61, 0x54, 0x01, 0x24, 0x02, 0xF2, 0x72, 0x42, 0x00, 0xBF, + 0x04, 0xFA, 0x01, 0xF3, + 0x1D, 0x42, 0x03, 0xD0, 0x57, 0x5C, 0x04, 0xFA, 0x07, 0xF3, 0x18, 0x43, + 0x49, 0x1C, 0x04, 0x29, + 0xF4, 0xDB, 0x01, 0x90, 0x00, 0x20, 0x00, 0x90, 0x20, 0x20, 0x08, 0x90, + 0x40, 0x20, 0x07, 0x90, + 0xB6, 0xF8, 0x82, 0x11, 0x02, 0x20, 0xFF, 0xF7, 0x2F, 0xFC, 0x03, 0x90, + 0x2A, 0x48, 0x05, 0x90, + 0x2A, 0x48, 0x00, 0x21, 0x02, 0x90, 0x01, 0x60, 0x0D, 0x46, 0x41, 0x60, + 0x02, 0x20, 0xFF, 0xF7, + 0x3E, 0xFC, 0x24, 0x48, 0x00, 0x24, 0xD0, 0x30, 0xA3, 0x46, 0x40, 0x69, + 0x06, 0x90, 0x01, 0x20, + 0x27, 0x46, 0x04, 0x90, 0x01, 0x20, 0x09, 0x99, 0xB8, 0x40, 0x08, 0x42, + 0x63, 0xD0, 0x00, 0x26, + 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x13, 0xF0, 0x49, 0xFB, 0x80, 0x46, + 0x0A, 0x46, 0x00, 0xEA, + 0x09, 0x00, 0x01, 0xEA, 0x0A, 0x01, 0x08, 0x43, 0x4F, 0xD0, 0x16, 0x48, + 0x00, 0xEB, 0xC7, 0x01, + 0xD1, 0xE9, 0x00, 0x01, 0x00, 0xEA, 0x08, 0x00, 0x11, 0x40, 0x08, 0x43, + 0x44, 0xD1, 0x01, 0x20, + 0x01, 0x99, 0x00, 0xFA, 0x04, 0xF8, 0x18, 0xEA, 0x01, 0x0F, 0x3D, 0xD0, + 0x06, 0x98, 0x30, 0xF9, + 0x14, 0x20, 0x03, 0x98, 0x82, 0x42, 0x2C, 0xDC, 0x00, 0x2D, 0x2A, 0xDD, + 0x02, 0x98, 0x30, 0xF9, + 0x14, 0x10, 0x03, 0x98, 0x08, 0x1A, 0x03, 0x99, 0xA2, 0xEB, 0x01, 0x01, + 0x00, 0xD5, 0x40, 0x42, + 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0x0B, 0xE0, 0x4C, 0x07, 0x10, 0x00, + 0x08, 0x92, 0x01, 0x20, + 0x78, 0x8B, 0x01, 0x20, 0xB0, 0x0F, 0x10, 0x00, 0x98, 0x98, 0x01, 0x20, + 0xD4, 0x56, 0x10, 0x00, + 0x88, 0x42, 0x06, 0xDC, 0x6B, 0x1E, 0x32, 0x46, 0x59, 0x46, 0x05, 0x98, + 0xFC, 0xF7, 0x95, 0xFF, + 0x02, 0xE0, 0x02, 0x98, 0x20, 0xF8, 0x14, 0x20, 0x00, 0x99, 0x48, 0xEA, + 0x01, 0x00, 0x00, 0x90, + 0x0A, 0xE0, 0x7F, 0x2D, 0x08, 0xDA, 0x02, 0x98, 0x6B, 0x1C, 0x59, 0x46, + 0x20, 0xF8, 0x14, 0x20, + 0x32, 0x46, 0x05, 0x98, 0xFC, 0xF7, 0x81, 0xFF, 0x64, 0x1C, 0x07, 0x98, + 0x76, 0x1C, 0x86, 0x42, + 0x9E, 0xDB, 0x0B, 0xF1, 0x01, 0x0B, 0x08, 0x98, 0x7F, 0x1C, 0x87, 0x42, + 0x92, 0xDB, 0xDD, 0xE9, + 0x00, 0x01, 0x88, 0x42, 0x05, 0xD0, 0x00, 0x20, 0x6D, 0x1C, 0x04, 0x90, + 0x7F, 0x2D, 0x7F, 0xF7, + 0x7D, 0xAF, 0x04, 0x98, 0xA5, 0xE5, 0x2D, 0xE9, 0xFF, 0x5F, 0x04, 0x46, + 0x01, 0x25, 0x12, 0xF0, + 0xD0, 0xFF, 0xCD, 0xE9, 0x02, 0x01, 0xC5, 0x48, 0x40, 0x27, 0x08, 0x21, + 0x00, 0x68, 0x00, 0xF2, + 0x02, 0x60, 0x01, 0x90, 0xC2, 0x48, 0x00, 0x90, 0x02, 0xA8, 0xFD, 0xF7, + 0x54, 0xFB, 0x06, 0x46, + 0x01, 0x2C, 0x6E, 0xD1, 0xDD, 0xE9, 0x02, 0x23, 0x29, 0x46, 0x00, 0x98, + 0xFC, 0xF7, 0x5C, 0xFF, + 0xDF, 0xF8, 0xF0, 0x92, 0x00, 0x20, 0x09, 0xEB, 0x46, 0x0B, 0x47, 0xF6, + 0xFF, 0x72, 0x6F, 0xF0, + 0x7E, 0x01, 0x04, 0xE0, 0x29, 0xF8, 0x10, 0x20, 0x0B, 0xF8, 0x00, 0x10, + 0x40, 0x1C, 0xB0, 0x42, + 0xF8, 0xDB, 0x6F, 0xF0, 0x7F, 0x08, 0x03, 0x20, 0xFF, 0xF7, 0x89, 0xFB, + 0xB2, 0x48, 0x00, 0x24, + 0x25, 0x46, 0xD0, 0xF8, 0x08, 0xA0, 0x2A, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x13, 0xF0, 0x9E, 0xFA, + 0xDD, 0xE9, 0x02, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x1D, 0xD0, + 0x3A, 0xF9, 0x14, 0x10, + 0x39, 0xF9, 0x14, 0x00, 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0x00, 0x28, + 0x00, 0xDA, 0x40, 0x42, + 0x81, 0x42, 0x0A, 0xDA, 0x2A, 0x46, 0x00, 0x21, 0x00, 0x98, 0xFC, 0xF7, + 0x0B, 0xFF, 0x0B, 0xF8, + 0x04, 0x00, 0x3A, 0xF8, 0x14, 0x10, 0x29, 0xF8, 0x14, 0x10, 0x43, 0x46, + 0x2A, 0x46, 0x00, 0x21, + 0x00, 0x98, 0xFC, 0xF7, 0x0A, 0xFF, 0x64, 0x1C, 0x6D, 0x1C, 0xBD, 0x42, + 0xD3, 0xDB, 0x08, 0xF1, + 0x01, 0x08, 0xB8, 0xF1, 0x7F, 0x0F, 0xC6, 0xDD, 0x00, 0x25, 0x2C, 0x46, + 0x22, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x13, 0xF0, 0x6B, 0xFA, 0xDD, 0xE9, 0x02, 0x23, 0x10, 0x40, + 0x19, 0x40, 0x08, 0x43, + 0x07, 0xD0, 0x1B, 0xF9, 0x05, 0x30, 0x22, 0x46, 0x00, 0x21, 0x00, 0x98, + 0xFC, 0xF7, 0xED, 0xFE, + 0x6D, 0x1C, 0x64, 0x1C, 0xBC, 0x42, 0xE9, 0xDB, 0xDD, 0xE9, 0x00, 0x10, + 0x26, 0x22, 0x13, 0xF0, + 0x8C, 0xFA, 0x00, 0x25, 0xDF, 0xF8, 0x24, 0x82, 0x2C, 0x46, 0x22, 0x46, + 0x01, 0x20, 0x00, 0x21, + 0x13, 0xF0, 0x4C, 0xFA, 0xDD, 0xE9, 0x02, 0x23, 0x10, 0x40, 0x19, 0x40, + 0x08, 0x43, 0x07, 0xD0, + 0x22, 0x46, 0x00, 0x21, 0x00, 0x98, 0xFC, 0xF7, 0xC5, 0xFE, 0x28, 0xF8, + 0x15, 0x00, 0x6D, 0x1C, + 0x64, 0x1C, 0xBC, 0x42, 0xE9, 0xDB, 0x03, 0x20, 0xFF, 0xF7, 0x19, 0xFB, + 0x7A, 0x48, 0x42, 0x46, + 0x81, 0x68, 0x00, 0x20, 0x06, 0xE0, 0x00, 0xBF, 0x31, 0xF8, 0x10, 0x30, + 0x34, 0x18, 0x40, 0x1C, + 0x22, 0xF8, 0x14, 0x30, 0xB0, 0x42, 0xF7, 0xDB, 0xBD, 0xE8, 0xFF, 0x9F, + 0x2D, 0xE9, 0xF0, 0x5F, + 0x07, 0x46, 0x01, 0x24, 0x00, 0x20, 0xFC, 0xF7, 0x44, 0xFD, 0x02, 0x20, + 0xFC, 0xF7, 0x41, 0xFD, + 0x6F, 0x49, 0x01, 0x20, 0x08, 0x70, 0x69, 0x4E, 0xF8, 0x07, 0x4F, 0xF0, + 0x00, 0x08, 0x4F, 0xF0, + 0xA5, 0x09, 0x09, 0xD0, 0x00, 0xF0, 0x55, 0xF8, 0x10, 0xF0, 0x01, 0x04, + 0x04, 0xD0, 0x30, 0x68, + 0x80, 0xF8, 0x1B, 0x80, 0x80, 0xF8, 0x1A, 0x90, 0xB8, 0x07, 0x09, 0xD5, + 0x00, 0xF0, 0x8F, 0xF8, + 0x20, 0x40, 0x04, 0x00, 0x04, 0xD0, 0x30, 0x68, 0x80, 0xF8, 0x1D, 0x80, + 0x80, 0xF8, 0x1C, 0x90, + 0xDF, 0xF8, 0x80, 0xA1, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x61, 0x04, + 0x58, 0xB3, 0xF8, 0x06, + 0x29, 0xD5, 0x01, 0x25, 0x12, 0xF0, 0xEF, 0xFE, 0x83, 0x46, 0x12, 0xF0, + 0xEE, 0xFE, 0xDA, 0xF8, + 0x00, 0x20, 0x92, 0xF8, 0x80, 0x21, 0xD2, 0x07, 0x13, 0xD0, 0x02, 0x46, + 0x0B, 0x46, 0x59, 0x46, + 0x55, 0x48, 0xFC, 0xF7, 0x81, 0xFE, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0x80, 0x01, 0xC0, 0x07, + 0x07, 0xD0, 0xFF, 0xF7, 0x46, 0xFE, 0x05, 0x00, 0x03, 0xD1, 0x02, 0x21, + 0x74, 0x20, 0x0E, 0xF0, + 0x1D, 0xFC, 0x02, 0x20, 0xFF, 0xF7, 0xB3, 0xFA, 0x2C, 0x40, 0x04, 0xD0, + 0x30, 0x68, 0x80, 0xF8, + 0x25, 0x80, 0x80, 0xF8, 0x24, 0x90, 0x00, 0x20, 0xFC, 0xF7, 0x06, 0xFD, + 0x02, 0x20, 0xFC, 0xF7, + 0x03, 0xFD, 0xF8, 0x07, 0x02, 0xD0, 0x01, 0x20, 0x00, 0xF0, 0xBA, 0xF8, + 0x20, 0x46, 0xBD, 0xE8, + 0xF0, 0x9F, 0x2D, 0xE9, 0xF0, 0x41, 0x01, 0x24, 0x12, 0xF0, 0xB1, 0xFE, + 0x80, 0x46, 0x12, 0xF0, + 0xB0, 0xFE, 0x3C, 0x4D, 0x06, 0x46, 0x0F, 0x46, 0x28, 0x68, 0x90, 0xF8, + 0xE7, 0x00, 0x10, 0xF0, + 0x60, 0x0F, 0x03, 0xD0, 0x40, 0x46, 0x0F, 0xF0, 0xC7, 0xFB, 0x80, 0x46, + 0x28, 0x68, 0x90, 0xF8, + 0x70, 0x01, 0xC0, 0x07, 0x25, 0xD0, 0x32, 0x46, 0x3B, 0x46, 0x41, 0x46, + 0x33, 0x48, 0xFC, 0xF7, + 0x3B, 0xFE, 0x28, 0x68, 0x90, 0xF8, 0x70, 0x11, 0xC9, 0x07, 0x1A, 0xD0, + 0x90, 0xF8, 0xE8, 0x10, + 0x89, 0x07, 0x03, 0xD4, 0x00, 0x20, 0xFF, 0xF7, 0x6B, 0xFC, 0x0C, 0xE0, + 0x90, 0xF8, 0xE7, 0x00, + 0xC0, 0xF3, 0x41, 0x10, 0x02, 0x28, 0x4F, 0xF0, 0x00, 0x00, 0x02, 0xD3, + 0xFF, 0xF7, 0x3F, 0xFB, + 0x01, 0xE0, 0xFF, 0xF7, 0xA7, 0xFA, 0x04, 0x00, 0x03, 0xD1, 0x01, 0x21, + 0x74, 0x20, 0x0E, 0xF0, + 0xC5, 0xFB, 0x00, 0x20, 0xFF, 0xF7, 0x5B, 0xFA, 0x20, 0x46, 0xBD, 0xE8, + 0xF0, 0x81, 0x70, 0xB5, + 0x01, 0x24, 0x12, 0xF0, 0x6C, 0xFE, 0x06, 0x46, 0x12, 0xF0, 0x6B, 0xFE, + 0x19, 0x4D, 0x2A, 0x68, + 0x92, 0xF8, 0x78, 0x21, 0xD2, 0x07, 0x1B, 0xD0, 0x02, 0x46, 0x0B, 0x46, + 0x31, 0x46, 0x18, 0x48, + 0xFC, 0xF7, 0x02, 0xFE, 0x28, 0x68, 0x90, 0xF8, 0x78, 0x11, 0xC9, 0x07, + 0x10, 0xD0, 0x90, 0xF8, + 0xE8, 0x00, 0x80, 0x07, 0x20, 0x46, 0x02, 0xD4, 0xFF, 0xF7, 0x32, 0xFC, + 0x01, 0xE0, 0xFF, 0xF7, + 0x79, 0xFA, 0x04, 0x00, 0x04, 0xD1, 0x4F, 0xF4, 0x80, 0x71, 0x74, 0x20, + 0x0E, 0xF0, 0x96, 0xFB, + 0x01, 0x20, 0xFF, 0xF7, 0x2C, 0xFA, 0x20, 0x46, 0x70, 0xBD, 0x00, 0x00, + 0x50, 0x07, 0x10, 0x00, + 0xE4, 0x9F, 0x01, 0x20, 0xD4, 0x56, 0x10, 0x00, 0x80, 0x10, 0x10, 0x00, + 0x04, 0x4B, 0x01, 0x20, + 0x78, 0x07, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x98, 0x98, 0x01, 0x20, + 0x78, 0x8B, 0x01, 0x20, + 0x08, 0x92, 0x01, 0x20, 0x10, 0xB5, 0xFF, 0xF7, 0xD6, 0xF9, 0x53, 0x20, + 0xFF, 0xF7, 0x06, 0xFF, + 0x00, 0x28, 0x12, 0xD0, 0x4F, 0xF4, 0xD6, 0x70, 0x00, 0xF0, 0x7B, 0xFF, + 0x00, 0x28, 0x0C, 0xD0, + 0x24, 0x48, 0x25, 0x49, 0x00, 0x68, 0x09, 0x68, 0x90, 0xF8, 0xDE, 0x00, + 0x08, 0x76, 0xFE, 0xF7, + 0x45, 0xFE, 0xBD, 0xE8, 0x10, 0x40, 0xFE, 0xF7, 0xD5, 0xBD, 0x10, 0xBD, + 0x10, 0xB5, 0xFF, 0xF7, + 0xBA, 0xF9, 0x40, 0xF2, 0xFF, 0x10, 0xFE, 0xF7, 0x41, 0xFD, 0x1A, 0x48, + 0x1A, 0x49, 0x00, 0x68, + 0x09, 0x68, 0x90, 0xF8, 0xDE, 0x00, 0x08, 0x76, 0xBD, 0xE8, 0x10, 0x40, + 0xFE, 0xF7, 0xC2, 0xBD, + 0x2D, 0xE9, 0xF0, 0x41, 0x13, 0x49, 0x09, 0x68, 0x91, 0xF8, 0xC1, 0x21, + 0xD2, 0x07, 0x1F, 0xD0, + 0x01, 0x28, 0x1D, 0xD1, 0x10, 0x4F, 0x91, 0xF8, 0x31, 0x20, 0x91, 0xF8, + 0x30, 0x10, 0x3D, 0x68, + 0x4A, 0x43, 0x02, 0x20, 0x0D, 0x4E, 0x14, 0xB2, 0x32, 0x35, 0xFD, 0xF7, + 0xE2, 0xFF, 0x03, 0x20, + 0xFC, 0xF7, 0x0F, 0xFC, 0x38, 0x68, 0x62, 0x00, 0x31, 0x46, 0x04, 0x86, + 0x28, 0x46, 0x13, 0xF0, + 0x1C, 0xF9, 0x03, 0x20, 0xFC, 0xF7, 0x20, 0xFC, 0xBD, 0xE8, 0xF0, 0x41, + 0xFE, 0xF7, 0x9A, 0xBD, + 0xBD, 0xE8, 0xF0, 0x81, 0x4C, 0x07, 0x10, 0x00, 0x50, 0x07, 0x10, 0x00, + 0x42, 0x44, 0x01, 0x20, + 0x10, 0xB5, 0x01, 0x46, 0x34, 0x22, 0xFB, 0x48, 0x13, 0xF0, 0x4C, 0xF9, + 0x01, 0x21, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x20, 0xFC, 0xF7, 0x0D, 0xBB, 0x30, 0xB5, 0x85, 0xB0, + 0x68, 0x46, 0x12, 0xF0, + 0x61, 0xFD, 0xF5, 0x48, 0x02, 0x22, 0x00, 0x78, 0xE0, 0xB1, 0x03, 0x21, + 0x01, 0x28, 0x0D, 0xD0, + 0x03, 0x28, 0x0E, 0xD0, 0x02, 0x28, 0x18, 0xD0, 0x04, 0x22, 0x05, 0x28, + 0x0C, 0xD0, 0x04, 0x28, + 0x0D, 0xD0, 0x06, 0x28, 0x0E, 0xD0, 0x07, 0x28, 0x0F, 0xD0, 0x10, 0xE0, + 0x8D, 0xF8, 0x06, 0x10, + 0x0D, 0xE0, 0x8D, 0xF8, 0x08, 0x10, 0x0A, 0xE0, 0x8D, 0xF8, 0x0A, 0x20, + 0x07, 0xE0, 0x8D, 0xF8, + 0x0A, 0x10, 0x04, 0xE0, 0x8D, 0xF8, 0x06, 0x20, 0x01, 0xE0, 0x8D, 0xF8, + 0x08, 0x20, 0xE3, 0x48, + 0x00, 0x90, 0xE3, 0x48, 0x00, 0x68, 0x90, 0xF8, 0xB0, 0x10, 0xC9, 0x07, + 0x0B, 0xD0, 0x01, 0x21, + 0x8D, 0xF8, 0x0D, 0x10, 0x90, 0xF8, 0xB0, 0x00, 0xC0, 0xF3, 0xC1, 0x00, + 0x02, 0x28, 0x02, 0xD1, + 0x00, 0x20, 0x8D, 0xF8, 0x0D, 0x00, 0xD7, 0x4D, 0x03, 0x24, 0x68, 0x46, + 0x12, 0xF0, 0x47, 0xFD, + 0x00, 0x22, 0x04, 0xAB, 0x01, 0x21, 0x10, 0x46, 0xFC, 0xF7, 0x0C, 0xFB, + 0x01, 0x21, 0x00, 0x20, + 0xFC, 0xF7, 0xEB, 0xFA, 0x28, 0x78, 0x00, 0x28, 0x04, 0xD0, 0x0E, 0xF0, + 0xCE, 0xFA, 0x64, 0x1E, + 0x00, 0x2C, 0xEA, 0xDC, 0x05, 0xB0, 0x30, 0xBD, 0x2D, 0xE9, 0xF0, 0x4F, + 0xCA, 0x4E, 0x04, 0x46, + 0x87, 0xB0, 0x06, 0x20, 0x89, 0x46, 0x30, 0x70, 0x12, 0xF0, 0x61, 0xFD, + 0x00, 0x21, 0x20, 0x27, + 0xCD, 0xE9, 0x04, 0x01, 0x1D, 0x20, 0xC7, 0x4D, 0x02, 0x90, 0x24, 0xB1, + 0x01, 0x2C, 0x0E, 0xD0, + 0x02, 0x2C, 0x21, 0xD0, 0x2F, 0xE0, 0xC4, 0x48, 0x00, 0x90, 0xDF, 0xF8, + 0xF8, 0x82, 0x28, 0x68, + 0x08, 0xF1, 0x18, 0x08, 0xDF, 0xF8, 0x04, 0xA3, 0x00, 0xF5, 0xC5, 0x60, + 0x22, 0xE0, 0x12, 0xF0, + 0x48, 0xFD, 0xCD, 0xE9, 0x04, 0x01, 0xBC, 0x48, 0x40, 0x27, 0x20, 0x30, + 0x00, 0x90, 0x28, 0x68, + 0xDF, 0xF8, 0xD0, 0x82, 0x00, 0xF2, 0x5E, 0x60, 0x01, 0x90, 0x26, 0x20, + 0x08, 0xF1, 0x1C, 0x08, + 0xDF, 0xF8, 0xDC, 0xA2, 0x02, 0x90, 0x0E, 0xE0, 0x07, 0x20, 0x30, 0x70, + 0xB2, 0x48, 0xDF, 0xF8, + 0xB4, 0x82, 0x48, 0x30, 0x00, 0x90, 0x28, 0x68, 0xDF, 0xF8, 0xC8, 0xA2, + 0x08, 0xF1, 0x28, 0x08, + 0x00, 0xF2, 0x84, 0x60, 0x01, 0x90, 0x08, 0x21, 0x04, 0xA8, 0xFD, 0xF7, + 0xB4, 0xF8, 0x04, 0x46, + 0xB9, 0xF1, 0x01, 0x0F, 0x74, 0xD1, 0x22, 0x46, 0x04, 0xA9, 0x00, 0x98, + 0xFC, 0xF7, 0xF7, 0xFC, + 0xDF, 0xF8, 0xA4, 0xB2, 0x47, 0xF6, 0xFF, 0x71, 0x0B, 0xEB, 0x44, 0x00, + 0x03, 0x90, 0x00, 0x20, + 0x6F, 0xF0, 0x7E, 0x02, 0x05, 0xE0, 0x00, 0xBF, 0x2B, 0xF8, 0x10, 0x10, + 0x03, 0x9B, 0x1A, 0x54, + 0x40, 0x1C, 0xA0, 0x42, 0xF8, 0xDB, 0x6F, 0xF0, 0x7F, 0x09, 0x00, 0xBF, + 0xFF, 0xF7, 0x3C, 0xFF, + 0xD8, 0xF8, 0x00, 0x00, 0x00, 0x25, 0x2E, 0x46, 0x06, 0x90, 0x2B, 0xE0, + 0x32, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x12, 0xF0, 0xFB, 0xFF, 0xDD, 0xE9, 0x04, 0x23, 0x10, 0x40, + 0x19, 0x40, 0x08, 0x43, + 0x1D, 0xD0, 0x06, 0x98, 0x30, 0xF9, 0x15, 0x10, 0x3B, 0xF9, 0x15, 0x00, + 0x00, 0x29, 0x00, 0xDA, + 0x49, 0x42, 0x00, 0x28, 0x00, 0xDA, 0x40, 0x42, 0x81, 0x42, 0x0A, 0xDA, + 0x31, 0x46, 0x00, 0x98, + 0xFC, 0xF7, 0xAB, 0xFC, 0x03, 0x99, 0x48, 0x55, 0x06, 0x98, 0x30, 0xF8, + 0x15, 0x10, 0x2B, 0xF8, + 0x15, 0x10, 0x4A, 0x46, 0x31, 0x46, 0x00, 0x98, 0xFC, 0xF7, 0xA6, 0xFC, + 0x6D, 0x1C, 0xA5, 0x42, + 0x02, 0xD0, 0x76, 0x1C, 0xBE, 0x42, 0xD1, 0xDB, 0x09, 0xF1, 0x01, 0x09, + 0xB9, 0xF1, 0x7F, 0x0F, + 0xC4, 0xDD, 0x00, 0x26, 0x35, 0x46, 0x14, 0xE0, 0x2A, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x12, 0xF0, + 0xC5, 0xFF, 0xDD, 0xE9, 0x04, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, + 0x06, 0xD0, 0x03, 0x98, + 0x29, 0x46, 0x82, 0x57, 0x00, 0x98, 0xFC, 0xF7, 0x87, 0xFC, 0x76, 0x1C, + 0xA6, 0x42, 0x02, 0xD0, + 0x6D, 0x1C, 0xBD, 0x42, 0xE8, 0xDB, 0xDD, 0xE9, 0x00, 0x10, 0x02, 0x9A, + 0x12, 0xF0, 0xE5, 0xFF, + 0x00, 0x26, 0x35, 0x46, 0x14, 0xE0, 0x2A, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x12, 0xF0, 0xA6, 0xFF, + 0xDD, 0xE9, 0x04, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x06, 0xD0, + 0x29, 0x46, 0x00, 0x98, + 0xFC, 0xF7, 0x63, 0xFC, 0x2A, 0xF8, 0x16, 0x00, 0x76, 0x1C, 0xA6, 0x42, + 0x02, 0xD0, 0x6D, 0x1C, + 0xBD, 0x42, 0xE8, 0xDB, 0xFF, 0xF7, 0xC8, 0xFE, 0x00, 0x20, 0xD8, 0xF8, + 0x00, 0x10, 0x05, 0xE0, + 0x31, 0xF8, 0x10, 0x30, 0x25, 0x18, 0x40, 0x1C, 0x2A, 0xF8, 0x15, 0x30, + 0xA0, 0x42, 0xF7, 0xDB, + 0x07, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0x70, 0xB5, 0x55, 0x4C, 0x05, 0x46, + 0x20, 0x68, 0x90, 0xF8, + 0x88, 0x01, 0xC0, 0x06, 0x07, 0xD5, 0x29, 0x46, 0x00, 0x20, 0xFF, 0xF7, + 0x05, 0xFF, 0x29, 0x46, + 0x01, 0x20, 0xFF, 0xF7, 0x01, 0xFF, 0x20, 0x68, 0x90, 0xF8, 0xA0, 0x01, + 0xC0, 0x06, 0x04, 0xD5, + 0x29, 0x46, 0xBD, 0xE8, 0x70, 0x40, 0x02, 0x20, 0xF6, 0xE6, 0x70, 0xBD, + 0x2D, 0xE9, 0xF0, 0x47, + 0x45, 0x49, 0x00, 0x25, 0x2C, 0x46, 0x0E, 0x69, 0xD1, 0xF8, 0x38, 0x30, + 0x28, 0x46, 0x01, 0x27, + 0x07, 0xFA, 0x00, 0xF2, 0x32, 0x42, 0x03, 0xD0, 0x1A, 0x5C, 0xAA, 0x42, + 0x00, 0xD9, 0x15, 0x46, + 0x40, 0x1C, 0x20, 0x28, 0xF4, 0xD3, 0xD1, 0xE9, 0x14, 0x78, 0xD1, 0xF8, + 0x3C, 0x90, 0x00, 0x26, + 0x8A, 0x46, 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x12, 0xF0, 0x48, 0xFF, + 0x38, 0x40, 0x01, 0xEA, + 0x08, 0x01, 0x08, 0x43, 0x04, 0xD0, 0x19, 0xF8, 0x06, 0x00, 0xA0, 0x42, + 0x00, 0xD9, 0x04, 0x46, + 0x76, 0x1C, 0x40, 0x2E, 0xED, 0xD3, 0xDA, 0xF8, 0x48, 0x20, 0x50, 0x46, + 0x15, 0x70, 0xDA, 0xF8, + 0x4C, 0x10, 0x0C, 0x70, 0xDA, 0xF8, 0x30, 0x30, 0xDA, 0xF8, 0x28, 0x70, + 0xDA, 0xF8, 0x34, 0x60, + 0x1B, 0x78, 0x3F, 0x78, 0x2B, 0x44, 0x3B, 0x44, 0xDA, 0xF8, 0x2C, 0x70, + 0x36, 0x78, 0x3F, 0x78, + 0x26, 0x44, 0x3E, 0x44, 0x07, 0x69, 0x6F, 0xB1, 0xD0, 0xE9, 0x14, 0x7C, + 0x57, 0xEA, 0x0C, 0x07, + 0x0A, 0xD0, 0xFF, 0x27, 0xB3, 0x42, 0x13, 0xD2, 0xF3, 0x1A, 0x2B, 0x44, + 0xFF, 0x2B, 0x07, 0xD8, + 0x13, 0x70, 0x0B, 0xE0, 0x14, 0x70, 0x09, 0xE0, 0x15, 0x70, 0x0D, 0x70, + 0xBD, 0xE8, 0xF0, 0x87, + 0x17, 0x70, 0xC2, 0x69, 0x42, 0xF4, 0x00, 0x72, 0xCA, 0xF8, 0x1C, 0x20, + 0x0C, 0x70, 0xF5, 0xE7, + 0x9E, 0x42, 0x0D, 0xD2, 0x9B, 0x1B, 0x23, 0x44, 0xFF, 0x2B, 0x01, 0xD8, + 0x0B, 0x70, 0x05, 0xE0, + 0x0F, 0x70, 0xC1, 0x69, 0x41, 0xF4, 0x00, 0x71, 0xCA, 0xF8, 0x1C, 0x10, + 0x15, 0x70, 0xE5, 0xE7, + 0x15, 0x70, 0xEB, 0xE7, 0x2D, 0xE9, 0xF0, 0x41, 0x1F, 0x46, 0x0D, 0x46, + 0x00, 0x2A, 0x34, 0xDD, + 0x09, 0x4C, 0x77, 0xB1, 0xB4, 0xF9, 0x0A, 0x60, 0x11, 0x46, 0x0F, 0xF0, + 0xD6, 0xFF, 0xB0, 0x42, + 0x28, 0x78, 0x27, 0xDA, 0xFF, 0x28, 0x1C, 0xD2, 0x40, 0x1C, 0x28, 0x70, + 0x00, 0x20, 0xBD, 0xE8, + 0xF0, 0x81, 0x13, 0xE0, 0xB4, 0x10, 0x10, 0x00, 0xC0, 0x04, 0x10, 0x00, + 0xF1, 0x3E, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x50, 0x07, 0x10, 0x00, 0x0C, 0xA0, 0x01, 0x20, + 0x9C, 0x4B, 0x01, 0x20, + 0xF0, 0x4B, 0x01, 0x20, 0x88, 0x4C, 0x01, 0x20, 0xD4, 0x56, 0x10, 0x00, + 0xB4, 0xF9, 0x08, 0x60, + 0xDA, 0xE7, 0xE0, 0x69, 0x1F, 0xB1, 0x40, 0xF0, 0x02, 0x00, 0xE0, 0x61, + 0x05, 0xE0, 0x40, 0xF4, + 0x00, 0x60, 0xFA, 0xE7, 0x08, 0xB1, 0x40, 0x1E, 0x28, 0x70, 0x01, 0x20, + 0xD7, 0xE7, 0x2D, 0xE9, + 0xF0, 0x41, 0x1E, 0x46, 0x0D, 0x46, 0x00, 0x2A, 0x1A, 0xDD, 0xFE, 0x4C, + 0x66, 0xB1, 0xB4, 0xF9, + 0x0A, 0x70, 0x11, 0x46, 0x0F, 0xF0, 0x99, 0xFF, 0xB8, 0x42, 0x11, 0xDD, + 0x28, 0x78, 0x50, 0xB1, + 0x10, 0x28, 0x04, 0xD3, 0x10, 0x38, 0x03, 0xE0, 0xB4, 0xF9, 0x08, 0x70, + 0xF1, 0xE7, 0x00, 0x20, + 0x28, 0x70, 0x00, 0x20, 0xBB, 0xE7, 0xE0, 0x69, 0x26, 0xB1, 0x40, 0xF0, + 0x01, 0x00, 0xE0, 0x61, + 0x01, 0x20, 0xB4, 0xE7, 0x40, 0xF4, 0x80, 0x60, 0xF9, 0xE7, 0x2D, 0xE9, + 0xF1, 0x4F, 0x82, 0xB0, + 0x00, 0x25, 0xEC, 0x48, 0x02, 0x9A, 0x2C, 0x46, 0xFF, 0x21, 0x02, 0xB3, + 0xD0, 0xF8, 0x30, 0x90, + 0x02, 0x26, 0x4F, 0xF0, 0x18, 0x0B, 0x89, 0xF8, 0x00, 0x10, 0xD0, 0xF8, + 0x34, 0x80, 0x88, 0xF8, + 0x00, 0x10, 0xB0, 0xF9, 0x0A, 0x70, 0x31, 0x46, 0x00, 0x91, 0x41, 0x69, + 0x00, 0x29, 0x00, 0xDC, + 0x01, 0x25, 0xE0, 0x48, 0x80, 0x69, 0x00, 0x28, 0x00, 0xDC, 0x01, 0x24, + 0xFF, 0xF7, 0x06, 0xFF, + 0xFF, 0xF7, 0xA2, 0xFD, 0x00, 0x98, 0x00, 0xF0, 0xFD, 0xFC, 0x85, 0xB1, + 0x21, 0xE0, 0xD0, 0xF8, + 0x28, 0x90, 0x4F, 0xF4, 0x00, 0x66, 0x4F, 0xF0, 0x18, 0x0B, 0x89, 0xF8, + 0x00, 0x10, 0xD0, 0xF8, + 0x2C, 0x80, 0x88, 0xF8, 0x00, 0x10, 0xB0, 0xF9, 0x08, 0x70, 0x01, 0x21, + 0xDC, 0xE7, 0xDF, 0xF8, + 0x44, 0xA3, 0x3A, 0x46, 0xDA, 0xF8, 0x20, 0x00, 0xDA, 0xF8, 0x14, 0x10, + 0x00, 0x68, 0x00, 0xF0, + 0xF6, 0xFC, 0x01, 0x28, 0x05, 0xD1, 0xDA, 0xF8, 0x1C, 0x10, 0x31, 0x43, + 0x01, 0x25, 0xCA, 0xF8, + 0x1C, 0x10, 0x8C, 0xB9, 0xDF, 0xF8, 0x1C, 0xA3, 0x3A, 0x46, 0xDA, 0xF8, + 0x24, 0x00, 0xDA, 0xF8, + 0x18, 0x10, 0x00, 0x68, 0x00, 0xF0, 0xE3, 0xFC, 0x01, 0x28, 0x05, 0xD1, + 0xDA, 0xF8, 0x1C, 0x10, + 0x31, 0x43, 0x01, 0x24, 0xCA, 0xF8, 0x1C, 0x10, 0x0D, 0xB1, 0x00, 0x2C, + 0x4E, 0xD1, 0x2F, 0x46, + 0x26, 0x46, 0x4F, 0xF0, 0x17, 0x0A, 0x4F, 0xB9, 0xBA, 0x48, 0x02, 0x9B, + 0x01, 0x6A, 0x42, 0x69, + 0x0F, 0x68, 0x49, 0x46, 0x38, 0x46, 0xFF, 0xF7, 0x6A, 0xFF, 0x07, 0x46, + 0x4E, 0xB9, 0xB5, 0x48, + 0x02, 0x9B, 0x41, 0x6A, 0x82, 0x69, 0x0E, 0x68, 0x41, 0x46, 0x30, 0x46, + 0xFF, 0xF7, 0x5F, 0xFF, + 0x06, 0x46, 0xFF, 0xF7, 0xAB, 0xFE, 0xFF, 0xF7, 0x47, 0xFD, 0x00, 0x98, + 0x00, 0xF0, 0xA2, 0xFC, + 0x07, 0xB1, 0x16, 0xB9, 0xBA, 0xF1, 0x01, 0x0A, 0xDD, 0xD2, 0x2F, 0x46, + 0xA9, 0x4D, 0xAB, 0xF1, + 0x01, 0x06, 0x3F, 0xB9, 0x28, 0x6A, 0x02, 0x9B, 0x49, 0x46, 0x00, 0x68, + 0x6A, 0x69, 0xFF, 0xF7, + 0x09, 0xFF, 0x07, 0x46, 0x3C, 0xB9, 0x68, 0x6A, 0x02, 0x9B, 0x41, 0x46, + 0x00, 0x68, 0xAA, 0x69, + 0xFF, 0xF7, 0x00, 0xFF, 0x04, 0x46, 0xFF, 0xF7, 0x89, 0xFE, 0xFF, 0xF7, + 0x25, 0xFD, 0x00, 0x98, + 0x00, 0xF0, 0x80, 0xFC, 0x07, 0xB1, 0x0C, 0xB9, 0x76, 0x1E, 0xE2, 0xD2, + 0x01, 0x2F, 0x05, 0xD1, + 0x01, 0x2C, 0x03, 0xD1, 0xE8, 0x69, 0x20, 0xF4, 0x00, 0x70, 0xE8, 0x61, + 0xBD, 0xE8, 0xFE, 0x8F, + 0x2D, 0xE9, 0xF0, 0x4F, 0x9A, 0x46, 0x91, 0x46, 0x00, 0x22, 0x92, 0x4B, + 0x83, 0x46, 0x14, 0x46, + 0xB3, 0xF9, 0x0C, 0x70, 0x10, 0x46, 0x01, 0x23, 0x90, 0x46, 0x14, 0xE0, + 0x09, 0xEB, 0xE4, 0x05, + 0x04, 0xF0, 0x07, 0x0C, 0x2E, 0x78, 0x03, 0xFA, 0x0C, 0xF5, 0x35, 0x42, + 0x0A, 0xD0, 0x3B, 0xF9, + 0x12, 0x50, 0xBD, 0x42, 0x03, 0xDC, 0x0A, 0xF8, 0x02, 0x30, 0x01, 0x20, + 0x01, 0xE0, 0x0A, 0xF8, + 0x02, 0x80, 0x52, 0x1C, 0x64, 0x1C, 0x8A, 0x42, 0xE8, 0xDB, 0x32, 0xE6, + 0x2D, 0xE9, 0xFF, 0x5F, + 0x00, 0x24, 0x4F, 0xF0, 0x01, 0x08, 0x9A, 0x46, 0x17, 0x46, 0x25, 0x46, + 0xDF, 0xF8, 0xF4, 0x91, + 0x46, 0x46, 0xDD, 0xF8, 0x3C, 0xB0, 0x4E, 0xE0, 0x0A, 0xEB, 0xE5, 0x00, + 0x05, 0xF0, 0x07, 0x01, + 0x00, 0x78, 0x06, 0xFA, 0x01, 0xF2, 0x02, 0x42, 0x44, 0xD0, 0x1B, 0xF8, + 0x04, 0x00, 0x01, 0x28, + 0x3F, 0xD0, 0x00, 0x98, 0xB9, 0xF9, 0x0C, 0x10, 0x30, 0xF9, 0x14, 0x20, + 0x8A, 0x42, 0x1D, 0xDA, + 0x29, 0x46, 0x01, 0x98, 0xFC, 0xF7, 0x87, 0xFA, 0xFF, 0x28, 0x0E, 0xDA, + 0x40, 0x1C, 0xC2, 0xB2, + 0x4F, 0xF0, 0x00, 0x08, 0x29, 0x46, 0x01, 0x98, 0xFC, 0xF7, 0x7F, 0xFA, + 0x00, 0x98, 0x30, 0xF8, + 0x14, 0x10, 0x0E, 0x98, 0x20, 0xF8, 0x14, 0x10, 0x23, 0xE0, 0x0B, 0xF8, + 0x04, 0x60, 0xD9, 0xF8, + 0x1C, 0x10, 0x41, 0xF0, 0x08, 0x01, 0xC9, 0xF8, 0x1C, 0x10, 0x1A, 0xE0, + 0x0E, 0x98, 0x30, 0xF9, + 0x14, 0x00, 0x00, 0x28, 0x13, 0xDD, 0x40, 0x1A, 0xA2, 0xEB, 0x01, 0x01, + 0x00, 0xD5, 0x40, 0x42, + 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0x88, 0x42, 0x09, 0xDC, 0x29, 0x46, + 0x01, 0x98, 0xFC, 0xF7, + 0x5A, 0xFA, 0x40, 0x1E, 0xC2, 0xB2, 0x29, 0x46, 0x01, 0x98, 0xFC, 0xF7, + 0x56, 0xFA, 0x0B, 0xF8, + 0x04, 0x60, 0x64, 0x1C, 0x6D, 0x1C, 0xBC, 0x42, 0xAE, 0xDB, 0x40, 0x46, + 0x04, 0xB0, 0xBD, 0xE8, + 0xF0, 0x9F, 0x2D, 0xE9, 0xFF, 0x5F, 0x00, 0x24, 0x4F, 0xF0, 0x01, 0x08, + 0x9A, 0x46, 0x17, 0x46, + 0x25, 0x46, 0x46, 0x46, 0xDF, 0xF8, 0x2C, 0x91, 0xDD, 0xF8, 0x38, 0xB0, + 0x31, 0xE0, 0x00, 0xBF, + 0x0A, 0xEB, 0xE5, 0x00, 0x05, 0xF0, 0x07, 0x02, 0x01, 0x78, 0x06, 0xFA, + 0x02, 0xF0, 0x08, 0x42, + 0x26, 0xD0, 0x1B, 0xF8, 0x04, 0x00, 0x01, 0x28, 0x21, 0xD0, 0x00, 0x98, + 0x30, 0xF9, 0x14, 0x10, + 0xB9, 0xF9, 0x0C, 0x00, 0x81, 0x42, 0x1A, 0xDD, 0x29, 0x46, 0x01, 0x98, + 0xFC, 0xF7, 0x23, 0xFA, + 0x00, 0x28, 0x0C, 0xDD, 0x4F, 0xF0, 0x00, 0x08, 0x04, 0x28, 0x01, 0xDB, + 0x00, 0x1F, 0x00, 0xE0, + 0x00, 0x20, 0xC2, 0xB2, 0x29, 0x46, 0x01, 0x98, 0xFC, 0xF7, 0x17, 0xFA, + 0x07, 0xE0, 0x0B, 0xF8, + 0x04, 0x60, 0xD9, 0xF8, 0x1C, 0x10, 0x41, 0xF0, 0x04, 0x01, 0xC9, 0xF8, + 0x1C, 0x10, 0x64, 0x1C, + 0x6D, 0x1C, 0xBC, 0x42, 0xCC, 0xDB, 0x40, 0x46, 0xB8, 0xE7, 0x2D, 0xE9, + 0xF0, 0x4F, 0x93, 0xB0, + 0x00, 0x24, 0x25, 0x46, 0x18, 0x21, 0x0C, 0xA8, 0x12, 0xF0, 0xE0, 0xFD, + 0x28, 0x21, 0x02, 0xA8, + 0x12, 0xF0, 0xDC, 0xFD, 0x27, 0x48, 0x41, 0x69, 0x00, 0x29, 0x00, 0xDC, + 0x01, 0x24, 0x82, 0x69, + 0x00, 0x2A, 0x00, 0xDC, 0x01, 0x25, 0x23, 0x4A, 0x81, 0x46, 0x06, 0x46, + 0xFF, 0x23, 0x10, 0x32, + 0x80, 0x6B, 0x00, 0xF0, 0xA6, 0xFB, 0x1F, 0x4A, 0xFF, 0x23, 0x50, 0x32, + 0xB1, 0x69, 0xF0, 0x6B, + 0x00, 0xF0, 0x9F, 0xFB, 0xFF, 0xF7, 0x82, 0xFD, 0xFF, 0xF7, 0x1E, 0xFC, + 0x04, 0x20, 0x00, 0xF0, + 0x79, 0xFB, 0x8C, 0xB1, 0xD9, 0xF8, 0x20, 0x00, 0x16, 0x4A, 0x4E, 0x46, + 0x00, 0x68, 0x0C, 0xAB, + 0x10, 0x32, 0xD9, 0xF8, 0x14, 0x10, 0xFF, 0xF7, 0xFB, 0xFE, 0x01, 0x28, + 0x04, 0xD1, 0xF0, 0x69, + 0x01, 0x24, 0x40, 0xF0, 0x08, 0x00, 0xF0, 0x61, 0x8D, 0xB1, 0xD9, 0xF8, + 0x24, 0x00, 0x0D, 0x4A, + 0x4E, 0x46, 0x00, 0x68, 0x02, 0xAB, 0x50, 0x32, 0xD9, 0xF8, 0x18, 0x10, + 0xFF, 0xF7, 0xE8, 0xFE, + 0x01, 0x28, 0x04, 0xD1, 0xF0, 0x69, 0x01, 0x25, 0x40, 0xF0, 0x08, 0x00, + 0xF0, 0x61, 0x0C, 0xB1, + 0x00, 0x2D, 0x7A, 0xD1, 0x26, 0x46, 0xA8, 0x46, 0x00, 0x27, 0x0D, 0xF1, + 0x30, 0x0B, 0x86, 0xB9, + 0x02, 0xE0, 0x00, 0x00, 0xC0, 0x04, 0x10, 0x00, 0xCD, 0xF8, 0x00, 0xB0, + 0xD9, 0xF8, 0x20, 0x00, + 0xFE, 0x4B, 0xD9, 0xF8, 0x14, 0x20, 0x00, 0x68, 0xD9, 0xF8, 0x38, 0x10, + 0xFF, 0xF7, 0x51, 0xFF, + 0x06, 0x46, 0xB8, 0xF1, 0x00, 0x0F, 0x0D, 0xD1, 0x02, 0xA8, 0x00, 0x90, + 0xD9, 0xF8, 0x24, 0x10, + 0xF6, 0x4B, 0xD9, 0xF8, 0x18, 0x20, 0x08, 0x68, 0x40, 0x33, 0xD9, 0xF8, + 0x3C, 0x10, 0xFF, 0xF7, + 0x40, 0xFF, 0x80, 0x46, 0xFF, 0xF7, 0x2A, 0xFD, 0xFF, 0xF7, 0xC6, 0xFB, + 0x04, 0x20, 0x00, 0xF0, + 0x21, 0xFB, 0x16, 0xB1, 0xB8, 0xF1, 0x00, 0x0F, 0x02, 0xD1, 0x7F, 0x1C, + 0x60, 0x2F, 0xCE, 0xDB, + 0xDF, 0xF8, 0xAC, 0xA3, 0xD9, 0xF8, 0x14, 0x00, 0x26, 0x46, 0x41, 0x00, + 0x0A, 0xF5, 0xE6, 0x68, + 0x4C, 0x46, 0x50, 0x46, 0x12, 0xF0, 0x30, 0xFD, 0xA0, 0x69, 0x41, 0x00, + 0x40, 0x46, 0x12, 0xF0, + 0x2B, 0xFD, 0x00, 0x27, 0xFF, 0xF7, 0xA8, 0xFB, 0x04, 0x20, 0x00, 0xF0, + 0x03, 0xFB, 0x4E, 0xB9, + 0xCD, 0xE9, 0x00, 0xAB, 0x20, 0x6A, 0xDD, 0x4B, 0x62, 0x69, 0x00, 0x68, + 0xA1, 0x6B, 0xFF, 0xF7, + 0xAD, 0xFE, 0x06, 0x46, 0x5D, 0xB9, 0x02, 0xA8, 0xCD, 0xE9, 0x00, 0x80, + 0x60, 0x6A, 0xD7, 0x4B, + 0xA2, 0x69, 0x00, 0x68, 0x40, 0x33, 0xE1, 0x6B, 0xFF, 0xF7, 0xA0, 0xFE, + 0x05, 0x46, 0xFF, 0xF7, + 0xED, 0xFC, 0xFF, 0xF7, 0x89, 0xFB, 0x04, 0x20, 0x00, 0xF0, 0xE4, 0xFA, + 0x06, 0xB1, 0x15, 0xB9, + 0x7F, 0x1C, 0x60, 0x2F, 0xD6, 0xDB, 0x01, 0x2E, 0x07, 0xD1, 0x01, 0x2D, + 0x05, 0xD1, 0xE0, 0x69, + 0x81, 0x05, 0x02, 0xD5, 0x20, 0xF4, 0x00, 0x70, 0xE0, 0x61, 0x13, 0xB0, + 0xB9, 0xE4, 0x2D, 0xE9, + 0xF0, 0x41, 0x0F, 0x46, 0xC5, 0x49, 0x16, 0x46, 0x02, 0x46, 0x10, 0x39, + 0xDD, 0xE9, 0x06, 0x05, + 0xB1, 0xF9, 0x0E, 0xC0, 0x01, 0x24, 0x62, 0x45, 0x11, 0xDD, 0x1D, 0x68, + 0xA0, 0xF1, 0x7F, 0x02, + 0x95, 0x42, 0x07, 0xDD, 0x2A, 0x1A, 0x31, 0x46, 0x38, 0x46, 0x1A, 0x60, + 0xFC, 0xF7, 0xF4, 0xF8, + 0x00, 0x24, 0x11, 0xE0, 0xC8, 0x69, 0x40, 0xF0, 0x40, 0x00, 0xC8, 0x61, + 0x0C, 0xE0, 0x01, 0x21, + 0x29, 0x70, 0x19, 0x68, 0xC0, 0xF1, 0x7F, 0x02, 0x91, 0x42, 0x05, 0xDA, + 0x0A, 0x18, 0x31, 0x46, + 0x38, 0x46, 0x1A, 0x60, 0xFC, 0xF7, 0xE0, 0xF8, 0x20, 0x46, 0x30, 0xE5, + 0x2D, 0xE9, 0xFF, 0x4F, + 0x00, 0x24, 0x85, 0xB0, 0x91, 0x46, 0x06, 0x46, 0x25, 0x46, 0xA2, 0x46, + 0x78, 0xE0, 0x08, 0x98, + 0x05, 0xF0, 0x07, 0x03, 0x00, 0xEB, 0xE5, 0x00, 0x7F, 0x22, 0x01, 0x78, + 0x01, 0x20, 0x98, 0x40, + 0x08, 0x42, 0x03, 0x92, 0x6B, 0xD0, 0x29, 0x46, 0x06, 0x98, 0xFC, 0xF7, + 0xC5, 0xF8, 0x00, 0x20, + 0x8D, 0xF8, 0x08, 0x00, 0x80, 0x46, 0x4F, 0xF0, 0x10, 0x0B, 0x00, 0xBF, + 0xFF, 0xF7, 0x24, 0xFB, + 0x08, 0x20, 0x00, 0xF0, 0x7F, 0xFA, 0x02, 0xAF, 0xCD, 0xE9, 0x00, 0xB7, + 0x36, 0xF9, 0x14, 0x00, + 0x03, 0xAB, 0x2A, 0x46, 0x06, 0x99, 0xFF, 0xF7, 0xA2, 0xFF, 0x20, 0xB9, + 0x08, 0xF1, 0x01, 0x08, + 0xB8, 0xF1, 0x18, 0x0F, 0xEA, 0xDB, 0x9D, 0xF8, 0x08, 0x00, 0xE0, 0xB3, + 0x00, 0x20, 0x8D, 0xF8, + 0x08, 0x00, 0x80, 0x46, 0x4F, 0xF0, 0x04, 0x0B, 0xFF, 0xF7, 0x06, 0xFB, + 0x08, 0x20, 0x00, 0xF0, + 0x61, 0xFA, 0xCD, 0xE9, 0x00, 0xB7, 0x36, 0xF9, 0x14, 0x00, 0x03, 0xAB, + 0x2A, 0x46, 0x06, 0x99, + 0xFF, 0xF7, 0x85, 0xFF, 0x20, 0xB9, 0x08, 0xF1, 0x01, 0x08, 0xB8, 0xF1, + 0x18, 0x0F, 0xEB, 0xDB, + 0x9D, 0xF8, 0x08, 0x00, 0xF8, 0xB1, 0x00, 0x20, 0x8D, 0xF8, 0x08, 0x00, + 0x80, 0x46, 0x4F, 0xF0, + 0x01, 0x0B, 0x00, 0xBF, 0xFF, 0xF7, 0xE8, 0xFA, 0x08, 0x20, 0x00, 0xF0, + 0x43, 0xFA, 0xCD, 0xE9, + 0x00, 0xB7, 0x36, 0xF9, 0x14, 0x00, 0x03, 0xAB, 0x2A, 0x46, 0x06, 0x99, + 0xFF, 0xF7, 0x67, 0xFF, + 0x78, 0xB1, 0x9D, 0xF8, 0x08, 0x00, 0x01, 0x28, 0x10, 0xD0, 0x03, 0x9A, + 0x29, 0x46, 0x52, 0x1E, + 0x03, 0x92, 0x06, 0x98, 0x00, 0xE0, 0x09, 0xE0, 0xFC, 0xF7, 0x66, 0xF8, + 0x0A, 0xF1, 0x01, 0x0A, + 0x04, 0xE0, 0x08, 0xF1, 0x01, 0x08, 0xB8, 0xF1, 0x18, 0x0F, 0xDB, 0xDB, + 0x64, 0x1C, 0x6D, 0x1C, + 0x4C, 0x45, 0x84, 0xDB, 0xCA, 0x45, 0x02, 0xD0, 0x00, 0x20, 0x09, 0xB0, + 0xCD, 0xE5, 0x01, 0x20, + 0xFB, 0xE7, 0x70, 0xB5, 0x69, 0x4C, 0x01, 0x25, 0x10, 0x3C, 0xA2, 0x69, + 0x00, 0x2A, 0x08, 0xDD, + 0x60, 0x6A, 0x04, 0xF1, 0x50, 0x03, 0x61, 0x6C, 0x00, 0x68, 0xFF, 0xF7, + 0x67, 0xFF, 0x00, 0xF0, + 0x01, 0x05, 0x62, 0x69, 0x00, 0x2A, 0x06, 0xDD, 0x20, 0x6A, 0x60, 0x4B, + 0x21, 0x6C, 0x00, 0x68, + 0xFF, 0xF7, 0x5C, 0xFF, 0x05, 0x40, 0x28, 0x46, 0x70, 0xBD, 0x70, 0xB5, + 0x5B, 0x4C, 0x00, 0x26, + 0x10, 0x3C, 0x05, 0x46, 0xE6, 0x61, 0x01, 0x28, 0x5B, 0xD0, 0x02, 0x2D, + 0x5B, 0xD0, 0x01, 0x20, + 0x20, 0x70, 0x60, 0x79, 0x60, 0xB1, 0x00, 0x23, 0x54, 0x4A, 0x61, 0x69, + 0xA0, 0x6B, 0x00, 0xF0, + 0x08, 0xFA, 0x52, 0x4A, 0x00, 0x23, 0x40, 0x32, 0xA1, 0x69, 0xE0, 0x6B, + 0x00, 0xF0, 0x01, 0xFA, + 0xA0, 0x79, 0x50, 0xB1, 0x4D, 0x49, 0x62, 0x69, 0x20, 0x6C, 0xFC, 0xF7, + 0x20, 0xF8, 0x4B, 0x49, + 0xA2, 0x69, 0x40, 0x31, 0x60, 0x6C, 0xFC, 0xF7, 0x1A, 0xF8, 0xE0, 0x78, + 0x10, 0xB1, 0x00, 0x20, + 0xFF, 0xF7, 0xAB, 0xFC, 0x20, 0x79, 0x60, 0xB1, 0xE0, 0x78, 0x38, 0xB1, + 0x61, 0x78, 0xA0, 0x6A, + 0x00, 0xF0, 0xD5, 0xF9, 0x61, 0x78, 0xE0, 0x6A, 0x00, 0xF0, 0xD1, 0xF9, + 0x01, 0x20, 0xFF, 0xF7, + 0x9C, 0xFC, 0x60, 0x79, 0x08, 0xB1, 0xFF, 0xF7, 0x18, 0xFE, 0x01, 0x2D, + 0x25, 0xD0, 0x02, 0x2D, + 0x25, 0xD0, 0x26, 0x70, 0xFF, 0xF7, 0x58, 0xFA, 0xA0, 0x79, 0x60, 0xB1, + 0x20, 0x79, 0x38, 0xB1, + 0xA1, 0x78, 0x20, 0x6B, 0x00, 0xF0, 0xBB, 0xF9, 0xA1, 0x78, 0x60, 0x6B, + 0x00, 0xF0, 0xB7, 0xF9, + 0xE0, 0x79, 0xFF, 0xF7, 0x8E, 0xFF, 0xFF, 0xF7, 0x47, 0xFA, 0x01, 0x2D, + 0x12, 0xD0, 0x02, 0x2D, + 0x12, 0xD0, 0x10, 0x21, 0xE0, 0x69, 0x00, 0xF0, 0xD1, 0xF9, 0xE0, 0x69, + 0x78, 0xB1, 0x00, 0x20, + 0x70, 0xBD, 0x03, 0x20, 0xA4, 0xE7, 0x05, 0x20, 0xA2, 0xE7, 0x02, 0x20, + 0x00, 0xE0, 0x04, 0x20, + 0x20, 0x70, 0xD7, 0xE7, 0x40, 0x21, 0xED, 0xE7, 0x4F, 0xF4, 0x00, 0x71, + 0xEA, 0xE7, 0x01, 0x20, + 0x70, 0xBD, 0x70, 0xB5, 0x21, 0x4D, 0x0C, 0x46, 0x10, 0x3D, 0x02, 0x28, + 0x26, 0xD0, 0x11, 0xF0, + 0xE6, 0xFF, 0x28, 0x61, 0x11, 0xF0, 0xE5, 0xFF, 0xC5, 0xE9, 0x14, 0x01, + 0x04, 0x21, 0x1B, 0x48, + 0xFC, 0xF7, 0x71, 0xFB, 0x68, 0x61, 0x19, 0x48, 0x08, 0x21, 0x40, 0x30, + 0xFC, 0xF7, 0x6B, 0xFB, + 0xA8, 0x61, 0x04, 0xF1, 0x90, 0x00, 0xA8, 0x62, 0x40, 0x1C, 0xE8, 0x62, + 0x40, 0x1C, 0x28, 0x63, + 0x40, 0x1C, 0x68, 0x63, 0x4B, 0x38, 0xA8, 0x63, 0x20, 0x30, 0xC5, 0xE9, + 0x0F, 0x04, 0x48, 0x38, + 0x68, 0x64, 0x74, 0x30, 0x95, 0x34, 0xC5, 0xE9, 0x12, 0x04, 0x70, 0xBD, + 0x11, 0xF0, 0xC7, 0xFF, + 0x28, 0x61, 0x11, 0xF0, 0xC6, 0xFF, 0xD7, 0xE7, 0x10, 0xB5, 0x0A, 0x49, + 0x00, 0x20, 0xFF, 0xF7, + 0xC8, 0xFF, 0x06, 0x48, 0x08, 0x49, 0x10, 0x38, 0x08, 0x4A, 0x01, 0x62, + 0x09, 0x1D, 0x41, 0x62, + 0x13, 0x68, 0x93, 0xF8, 0x88, 0x11, 0x11, 0xF0, 0x01, 0x04, 0x09, 0xE0, + 0xD0, 0x04, 0x10, 0x00, + 0xD4, 0x56, 0x10, 0x00, 0x38, 0x99, 0x01, 0x20, 0xCC, 0x10, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xC4, 0x70, 0x4F, 0xF0, 0x00, 0x01, 0x04, 0xD0, 0x83, 0x6A, 0x19, 0x70, + 0xC3, 0x6A, 0x19, 0x70, + 0x08, 0xE0, 0x84, 0x6A, 0x93, 0xF8, 0x92, 0x31, 0x23, 0x70, 0x13, 0x68, + 0xC4, 0x6A, 0x93, 0xF8, + 0x93, 0x31, 0x23, 0x70, 0x13, 0x68, 0x93, 0xF8, 0x88, 0x41, 0xC4, 0xF3, + 0x40, 0x04, 0x04, 0x71, + 0x14, 0xB1, 0x03, 0x6B, 0x19, 0x70, 0x06, 0xE0, 0x93, 0xF8, 0x94, 0x11, + 0x03, 0x6B, 0x19, 0x70, + 0x11, 0x68, 0x91, 0xF8, 0x95, 0x11, 0x43, 0x6B, 0x19, 0x70, 0x11, 0x68, + 0x91, 0xF8, 0x88, 0x21, + 0xC2, 0xF3, 0x80, 0x03, 0x43, 0x71, 0xC2, 0xF3, 0xC0, 0x02, 0x82, 0x71, + 0xB1, 0xF8, 0x8A, 0x21, + 0x02, 0x81, 0xB1, 0xF8, 0x8C, 0x21, 0x42, 0x81, 0xB1, 0xF8, 0x8E, 0x21, + 0x82, 0x81, 0xB1, 0xF8, + 0x90, 0x21, 0xC2, 0x81, 0x91, 0xF8, 0x96, 0x21, 0x42, 0x70, 0x91, 0xF8, + 0x97, 0x21, 0x82, 0x70, + 0x91, 0xF8, 0x34, 0x11, 0xC1, 0xF3, 0x40, 0x01, 0xC1, 0x71, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0x20, + 0xF3, 0xE6, 0x10, 0xB5, 0xAC, 0x49, 0x01, 0x20, 0xFF, 0xF7, 0x63, 0xFF, + 0xAC, 0x48, 0xAB, 0x49, + 0x01, 0x62, 0x00, 0x21, 0xC0, 0xE9, 0x14, 0x11, 0x0A, 0x46, 0x81, 0x61, + 0xA9, 0x49, 0x0B, 0x68, + 0x93, 0xF8, 0xA0, 0x41, 0x14, 0xF0, 0x01, 0x04, 0xC4, 0x70, 0x04, 0xD0, + 0x83, 0x6A, 0x1A, 0x70, + 0xC3, 0x6A, 0x1A, 0x70, 0x08, 0xE0, 0x84, 0x6A, 0x93, 0xF8, 0xAA, 0x31, + 0x23, 0x70, 0x0B, 0x68, + 0xC4, 0x6A, 0x93, 0xF8, 0xAB, 0x31, 0x23, 0x70, 0x0B, 0x68, 0x93, 0xF8, + 0xA0, 0x41, 0xC4, 0xF3, + 0x40, 0x04, 0x04, 0x71, 0x14, 0xB1, 0x03, 0x6B, 0x1A, 0x70, 0x06, 0xE0, + 0x93, 0xF8, 0xAC, 0x21, + 0x03, 0x6B, 0x1A, 0x70, 0x0A, 0x68, 0x92, 0xF8, 0xAD, 0x21, 0x43, 0x6B, + 0x1A, 0x70, 0x09, 0x68, + 0x91, 0xF8, 0xA0, 0x21, 0xC2, 0xF3, 0x80, 0x03, 0x43, 0x71, 0xC2, 0xF3, + 0xC0, 0x02, 0x82, 0x71, + 0xB1, 0xF8, 0xA2, 0x21, 0x02, 0x81, 0xB1, 0xF8, 0xA4, 0x21, 0x42, 0x81, + 0xB1, 0xF8, 0xA6, 0x21, + 0x82, 0x81, 0xB1, 0xF8, 0xA8, 0x21, 0xC2, 0x81, 0x91, 0xF8, 0xAE, 0x21, + 0x42, 0x70, 0x91, 0xF8, + 0xAF, 0x21, 0x82, 0x70, 0x91, 0xF8, 0x84, 0x19, 0xC1, 0xF3, 0x40, 0x01, + 0xC1, 0x71, 0xBD, 0xE8, + 0x10, 0x40, 0x01, 0x20, 0x99, 0xE6, 0x80, 0x49, 0x10, 0xB5, 0x98, 0x31, + 0x02, 0x20, 0xFF, 0xF7, + 0x08, 0xFF, 0x7E, 0x49, 0x7E, 0x48, 0x09, 0x1D, 0x01, 0x62, 0x7E, 0x49, + 0x0B, 0x68, 0x93, 0xF8, + 0xB0, 0x21, 0x12, 0xF0, 0x01, 0x04, 0xC4, 0x70, 0x4F, 0xF0, 0x00, 0x02, + 0x04, 0xD0, 0x83, 0x6A, + 0x1A, 0x70, 0xC3, 0x6A, 0x1A, 0x70, 0x08, 0xE0, 0x84, 0x6A, 0x93, 0xF8, + 0xBA, 0x31, 0x23, 0x70, + 0x0B, 0x68, 0xC4, 0x6A, 0x93, 0xF8, 0xBB, 0x31, 0x23, 0x70, 0x0C, 0x68, + 0x94, 0xF8, 0xB0, 0x31, + 0xC3, 0xF3, 0x40, 0x03, 0x03, 0x71, 0x13, 0xB1, 0x03, 0x6B, 0x1A, 0x70, + 0x06, 0xE0, 0x03, 0x6B, + 0x94, 0xF8, 0xBC, 0x21, 0x1A, 0x70, 0x0A, 0x68, 0x92, 0xF8, 0xBD, 0x21, + 0x43, 0x6B, 0x1A, 0x70, + 0x09, 0x68, 0x91, 0xF8, 0xB0, 0x21, 0xC2, 0xF3, 0x80, 0x03, 0x43, 0x71, + 0xC2, 0xF3, 0xC0, 0x02, + 0x82, 0x71, 0xB1, 0xF8, 0xB2, 0x21, 0x02, 0x81, 0xB1, 0xF8, 0xB4, 0x21, + 0x42, 0x81, 0xB1, 0xF8, + 0xB6, 0x21, 0x82, 0x81, 0xB1, 0xF8, 0xB8, 0x21, 0xC2, 0x81, 0x91, 0xF8, + 0xBE, 0x21, 0x42, 0x70, + 0x91, 0xF8, 0xBF, 0x11, 0x81, 0x70, 0x01, 0x21, 0xC1, 0x71, 0xBD, 0xE8, + 0x10, 0x40, 0x02, 0x20, + 0x43, 0xE6, 0x2D, 0xE9, 0xF0, 0x41, 0x07, 0x46, 0x01, 0x24, 0x00, 0x20, + 0xFB, 0xF7, 0xC9, 0xFC, + 0x02, 0x20, 0xFB, 0xF7, 0xC6, 0xFC, 0x54, 0x49, 0x01, 0x20, 0x08, 0x70, + 0x53, 0x4E, 0x78, 0x07, + 0x4F, 0xF0, 0x00, 0x05, 0x4F, 0xF0, 0xA5, 0x08, 0x0A, 0xD5, 0xFF, 0xF7, + 0xD5, 0xFE, 0x10, 0xF0, + 0x01, 0x04, 0x05, 0xD0, 0x30, 0x68, 0xC5, 0x77, 0x80, 0xF8, 0x20, 0x50, + 0x80, 0xF8, 0x1E, 0x80, + 0x38, 0x07, 0x0A, 0xD5, 0xFF, 0xF7, 0x2D, 0xFF, 0x20, 0x40, 0x04, 0x00, + 0x05, 0xD0, 0x30, 0x68, + 0x00, 0xF8, 0x22, 0x5F, 0x45, 0x70, 0x00, 0xF8, 0x01, 0x8C, 0x38, 0x06, + 0x0A, 0xD5, 0xFF, 0xF7, + 0x7A, 0xFF, 0x20, 0x40, 0x04, 0x00, 0x05, 0xD0, 0x30, 0x68, 0x00, 0xF8, + 0x27, 0x5F, 0x45, 0x70, + 0x00, 0xF8, 0x01, 0x8C, 0x02, 0x20, 0xFB, 0xF7, 0xAF, 0xFC, 0x00, 0x20, + 0xFB, 0xF7, 0xAC, 0xFC, + 0x20, 0x46, 0x5A, 0xE5, 0x3A, 0x49, 0x4A, 0x78, 0x02, 0x42, 0x07, 0xD0, + 0x08, 0x78, 0xAA, 0x28, + 0x04, 0xD1, 0x08, 0x78, 0xAA, 0x28, 0xFC, 0xD0, 0xAA, 0x20, 0x08, 0x70, + 0x70, 0x47, 0x02, 0x78, + 0x8A, 0x42, 0x01, 0xD9, 0x51, 0x1A, 0x00, 0xE0, 0x00, 0x21, 0x01, 0x70, + 0x70, 0x47, 0x10, 0xB5, + 0x14, 0x46, 0x0F, 0xF0, 0x42, 0xFA, 0xA0, 0x42, 0x01, 0xDC, 0x01, 0x20, + 0x10, 0xBD, 0x00, 0x20, + 0x10, 0xBD, 0xF0, 0xB5, 0x00, 0x25, 0x2C, 0x46, 0x01, 0x26, 0x0C, 0xE0, + 0x02, 0xEB, 0xE4, 0x07, + 0x04, 0xF0, 0x07, 0x0C, 0x3F, 0x78, 0x06, 0xFA, 0x0C, 0xFE, 0x1E, 0xEA, + 0x07, 0x0F, 0x01, 0xD0, + 0x03, 0x55, 0x6D, 0x1C, 0x64, 0x1C, 0x8D, 0x42, 0xF0, 0xDB, 0xF0, 0xBD, + 0x70, 0xB5, 0x04, 0x46, + 0x0D, 0x46, 0xC0, 0x07, 0x02, 0xD0, 0x83, 0x20, 0x0D, 0xF0, 0x78, 0xFB, + 0xA0, 0x07, 0x03, 0xD5, + 0x29, 0x46, 0x84, 0x20, 0x0D, 0xF0, 0x72, 0xFB, 0x60, 0x07, 0x03, 0xD5, + 0x29, 0x46, 0x85, 0x20, + 0x0D, 0xF0, 0x6C, 0xFB, 0x20, 0x07, 0x03, 0xD5, 0x29, 0x46, 0x86, 0x20, + 0x0D, 0xF0, 0x66, 0xFB, + 0x60, 0x06, 0x03, 0xD5, 0x29, 0x46, 0x8B, 0x20, 0x0D, 0xF0, 0x60, 0xFB, + 0x20, 0x06, 0x03, 0xD5, + 0x29, 0x46, 0x8C, 0x20, 0x0D, 0xF0, 0x5A, 0xFB, 0xE0, 0x05, 0x03, 0xD5, + 0x29, 0x46, 0x87, 0x20, + 0x0D, 0xF0, 0x54, 0xFB, 0xA0, 0x05, 0x05, 0xD5, 0x29, 0x46, 0xBD, 0xE8, + 0x70, 0x40, 0x88, 0x20, + 0x0D, 0xF0, 0x4C, 0xBB, 0x70, 0xBD, 0x00, 0x00, 0xD0, 0x99, 0x01, 0x20, + 0xDC, 0x10, 0x10, 0x00, + 0xC0, 0x04, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x78, 0x07, 0x10, 0x00, + 0x50, 0x07, 0x10, 0x00, + 0x08, 0x00, 0x00, 0x20, 0x08, 0xB5, 0x4E, 0x4E, 0x4E, 0x4D, 0x00, 0x24, + 0x00, 0x22, 0x6B, 0x46, + 0x31, 0x46, 0x10, 0x46, 0xFB, 0xF7, 0x76, 0xFB, 0x00, 0x98, 0x81, 0x07, + 0x32, 0xD5, 0xFB, 0xF7, + 0xE7, 0xF9, 0x49, 0x48, 0x07, 0x68, 0x04, 0x60, 0xFB, 0xF7, 0xE0, 0xF9, + 0x17, 0xF0, 0x53, 0x0F, + 0x02, 0xD0, 0x38, 0x46, 0xFE, 0xF7, 0xB2, 0xFE, 0x17, 0xF4, 0xD6, 0x7F, + 0x02, 0xD0, 0x38, 0x46, + 0xFF, 0xF7, 0x27, 0xFF, 0xB8, 0x05, 0x13, 0xD5, 0x28, 0x68, 0x90, 0xF8, + 0x70, 0x01, 0x80, 0x07, + 0x02, 0xD5, 0x01, 0x20, 0xFE, 0xF7, 0xEF, 0xFD, 0x28, 0x68, 0x90, 0xF8, + 0x88, 0x11, 0xC9, 0x06, + 0x03, 0xD4, 0x90, 0xF8, 0xA0, 0x01, 0xC0, 0x06, 0x02, 0xD5, 0x01, 0x20, + 0xFF, 0xF7, 0x3B, 0xF9, + 0x78, 0x05, 0x05, 0xD5, 0x00, 0x20, 0xFE, 0xF7, 0xDE, 0xFD, 0x00, 0x20, + 0xFF, 0xF7, 0x33, 0xF9, + 0x02, 0x21, 0x58, 0xE0, 0xC1, 0x05, 0x0C, 0xD5, 0xFB, 0xF7, 0xB2, 0xF9, + 0x2F, 0x48, 0x07, 0x68, + 0x04, 0x60, 0xFB, 0xF7, 0xAB, 0xF9, 0x38, 0x46, 0xFC, 0xF7, 0x9B, 0xFF, + 0x4F, 0xF4, 0x80, 0x71, + 0x49, 0xE0, 0x81, 0x05, 0x04, 0xD5, 0xFE, 0xF7, 0x46, 0xF9, 0x4F, 0xF4, + 0x00, 0x71, 0x42, 0xE0, + 0x41, 0x05, 0x15, 0xD5, 0xFB, 0xF7, 0x9C, 0xF9, 0x25, 0x48, 0x07, 0x68, + 0x04, 0x60, 0xFB, 0xF7, + 0x95, 0xF9, 0xF8, 0x07, 0x01, 0xD0, 0xFD, 0xF7, 0x39, 0xFD, 0xB8, 0x07, + 0x01, 0xD5, 0xFD, 0xF7, + 0xB5, 0xFD, 0x78, 0x07, 0x01, 0xD5, 0xFD, 0xF7, 0x45, 0xFD, 0x4F, 0xF4, + 0x80, 0x61, 0x2A, 0xE0, + 0x01, 0x06, 0x0B, 0xD5, 0xFB, 0xF7, 0x84, 0xF9, 0x1A, 0x48, 0x07, 0x68, + 0x04, 0x60, 0xFB, 0xF7, + 0x7D, 0xF9, 0x38, 0x46, 0xFE, 0xF7, 0x70, 0xF8, 0x80, 0x21, 0x1C, 0xE0, + 0x81, 0x02, 0x0C, 0xD5, + 0xFB, 0xF7, 0x76, 0xF9, 0x14, 0x48, 0x07, 0x68, 0x04, 0x60, 0xFB, 0xF7, + 0x6F, 0xF9, 0x38, 0x46, + 0xFD, 0xF7, 0x9C, 0xFC, 0x4F, 0xF4, 0x00, 0x11, 0x0D, 0xE0, 0xC1, 0x04, + 0x04, 0xD5, 0xFE, 0xF7, + 0x31, 0xFF, 0x4F, 0xF4, 0x80, 0x51, 0x06, 0xE0, 0x00, 0x05, 0x7F, 0xF5, + 0x6F, 0xAF, 0xFE, 0xF7, + 0x45, 0xFF, 0x4F, 0xF4, 0x00, 0x61, 0x00, 0x20, 0xFB, 0xF7, 0xC7, 0xFA, + 0x66, 0xE7, 0x00, 0x00, + 0x83, 0x9F, 0x30, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x58, 0x07, 0x10, 0x00, + 0x54, 0x07, 0x10, 0x00, + 0x60, 0x07, 0x10, 0x00, 0x64, 0x07, 0x10, 0x00, 0x5C, 0x07, 0x10, 0x00, + 0x20, 0x48, 0x10, 0xB5, + 0x01, 0x68, 0x20, 0x48, 0x02, 0x68, 0x13, 0x46, 0x92, 0xEA, 0x01, 0x0F, + 0x28, 0xD0, 0x1E, 0x4A, + 0xCC, 0x07, 0x12, 0x68, 0x25, 0xD0, 0x92, 0xF8, 0x21, 0x43, 0xE4, 0x07, + 0x02, 0xD0, 0x43, 0xF0, + 0x01, 0x03, 0x03, 0x60, 0x8B, 0x07, 0x1F, 0xD5, 0x92, 0xF8, 0x40, 0x33, + 0xDB, 0x07, 0x03, 0xD0, + 0x03, 0x68, 0x43, 0xF0, 0x02, 0x03, 0x03, 0x60, 0x0B, 0x07, 0x19, 0xD5, + 0x92, 0xF8, 0x60, 0x33, + 0xDB, 0x07, 0x03, 0xD0, 0x03, 0x68, 0x43, 0xF0, 0x08, 0x03, 0x03, 0x60, + 0x49, 0x06, 0x13, 0xD5, + 0x92, 0xF8, 0x60, 0x13, 0xC9, 0x07, 0x03, 0xD0, 0x01, 0x68, 0x41, 0xF0, + 0x40, 0x01, 0x01, 0x60, + 0x10, 0xBD, 0x23, 0xF0, 0x01, 0x03, 0xDC, 0xE7, 0x03, 0x68, 0x23, 0xF0, + 0x02, 0x03, 0xE2, 0xE7, + 0x03, 0x68, 0x23, 0xF0, 0x08, 0x03, 0xE8, 0xE7, 0x01, 0x68, 0x21, 0xF0, + 0x40, 0x01, 0xEE, 0xE7, + 0x70, 0x07, 0x10, 0x00, 0x48, 0x05, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x2D, 0xE9, 0xF0, 0x47, + 0xDF, 0xF8, 0x60, 0x92, 0x98, 0x4C, 0x00, 0x25, 0xD9, 0xF8, 0x00, 0x10, + 0x91, 0xF8, 0x31, 0x00, + 0x84, 0xF8, 0x30, 0x00, 0x91, 0xF8, 0x30, 0x20, 0x94, 0x49, 0x84, 0xF8, + 0x31, 0x20, 0x50, 0x43, + 0x09, 0x78, 0x84, 0xF8, 0x33, 0x10, 0x92, 0x49, 0x21, 0x60, 0x34, 0x39, + 0x06, 0xB2, 0x8B, 0x7B, + 0x84, 0xF8, 0x2D, 0x30, 0x88, 0x46, 0x77, 0x00, 0x0F, 0xE0, 0x2A, 0x46, + 0x31, 0x46, 0xD8, 0xF8, + 0x08, 0x00, 0x0E, 0xF0, 0x32, 0xF9, 0x01, 0x46, 0x22, 0x68, 0x06, 0xFB, + 0x05, 0xF0, 0x02, 0xEB, + 0x40, 0x00, 0x3A, 0x46, 0x12, 0xF0, 0x09, 0xF8, 0x6D, 0x1C, 0x94, 0xF8, + 0x2D, 0x00, 0xA8, 0x42, + 0xEB, 0xDC, 0x84, 0x48, 0x84, 0x49, 0x00, 0x78, 0x09, 0x78, 0x08, 0x43, + 0x40, 0x07, 0x11, 0xD5, + 0x82, 0x48, 0x60, 0x60, 0xD9, 0xF8, 0x00, 0x10, 0x91, 0xF8, 0xF1, 0x11, + 0x89, 0x07, 0x4A, 0x0F, + 0x94, 0xF8, 0x31, 0x10, 0x92, 0x1C, 0x4A, 0x43, 0xD8, 0xF8, 0x10, 0x10, + 0xBD, 0xE8, 0xF0, 0x47, + 0x11, 0xF0, 0xEB, 0xBF, 0xBD, 0xE8, 0xF0, 0x87, 0x2D, 0xE9, 0xF8, 0x43, + 0x75, 0x48, 0xDF, 0xF8, + 0xD8, 0x81, 0x00, 0x27, 0x05, 0x68, 0xD8, 0xF8, 0x00, 0x00, 0x05, 0x43, + 0x01, 0x20, 0xFB, 0xF7, + 0xC8, 0xFA, 0x38, 0x21, 0x6C, 0x48, 0x12, 0xF0, 0x79, 0xF8, 0xE8, 0x07, + 0x06, 0xD0, 0xFF, 0xF7, + 0x9D, 0xFF, 0xE8, 0x06, 0x01, 0xD5, 0x00, 0xF0, 0x9B, 0xF8, 0x01, 0x27, + 0x68, 0x4E, 0x66, 0x4C, + 0xA8, 0x07, 0xA6, 0xF1, 0x34, 0x06, 0x0A, 0xD5, 0x69, 0x48, 0xA0, 0x60, + 0x68, 0x49, 0x70, 0x69, + 0x89, 0x1E, 0x01, 0x27, 0x02, 0x68, 0x41, 0xF8, 0x02, 0x2F, 0x40, 0x68, + 0x48, 0x60, 0xA8, 0x05, + 0x11, 0xD5, 0x62, 0x4F, 0xCA, 0x3F, 0xA7, 0x61, 0x11, 0xF0, 0x81, 0xFC, + 0x00, 0x90, 0x04, 0x21, + 0x68, 0x46, 0xFC, 0xF7, 0x08, 0xF8, 0x84, 0xF8, 0x32, 0x00, 0xF0, 0x6A, + 0x01, 0x68, 0x39, 0x60, + 0x40, 0x68, 0x78, 0x60, 0x01, 0x27, 0x5B, 0x48, 0x00, 0x68, 0xC4, 0xE9, + 0x07, 0x05, 0xD8, 0xF8, + 0x00, 0x00, 0x60, 0x62, 0x70, 0x68, 0xA0, 0x62, 0xF0, 0x7B, 0x84, 0xF8, + 0x35, 0x00, 0x96, 0xF8, + 0x30, 0x00, 0x55, 0x4E, 0x84, 0xF8, 0x36, 0x00, 0x30, 0x78, 0x84, 0xF8, + 0x2C, 0x00, 0xE8, 0x07, + 0x1A, 0xD0, 0xE8, 0x06, 0x18, 0xD5, 0x47, 0x4D, 0x28, 0x68, 0x90, 0xF8, + 0x50, 0x02, 0xC0, 0x07, + 0x06, 0xD0, 0x00, 0xF0, 0xF4, 0xFD, 0x18, 0xB9, 0xE0, 0x69, 0x40, 0xF0, + 0x10, 0x00, 0xE0, 0x61, + 0x28, 0x68, 0x90, 0xF8, 0x80, 0x02, 0xC0, 0x07, 0x06, 0xD0, 0x00, 0xF0, + 0xE8, 0xFD, 0x18, 0xB9, + 0xE0, 0x69, 0x40, 0xF0, 0x20, 0x00, 0xE0, 0x61, 0x01, 0x20, 0xFB, 0xF7, + 0x7D, 0xFA, 0x00, 0x2F, + 0x0C, 0xD0, 0x30, 0x78, 0x05, 0x28, 0x07, 0xD0, 0x06, 0x28, 0x05, 0xD0, + 0x01, 0x21, 0xBD, 0xE8, + 0xF8, 0x43, 0x02, 0x20, 0xFB, 0xF7, 0x75, 0xB9, 0x02, 0x21, 0xF8, 0xE7, + 0xBD, 0xE8, 0xF8, 0x83, + 0x3A, 0x48, 0x10, 0xB5, 0x00, 0x78, 0x00, 0x28, 0x29, 0xD1, 0x31, 0x4C, + 0x34, 0x3C, 0xD4, 0xE9, + 0x06, 0x01, 0x00, 0xF0, 0xC7, 0xFD, 0x94, 0xF8, 0x31, 0x10, 0xA0, 0x6A, + 0x00, 0xF0, 0xC3, 0xFC, + 0xFF, 0xF7, 0x6A, 0xFF, 0x27, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x60, 0x03, + 0xC1, 0x07, 0x16, 0xD0, + 0x81, 0x07, 0x14, 0xD5, 0x00, 0x24, 0x40, 0x09, 0x12, 0xF0, 0x6C, 0xF8, + 0x00, 0xB1, 0x01, 0x24, + 0x27, 0x48, 0x80, 0x1E, 0x01, 0x78, 0x8C, 0x42, 0x09, 0xD0, 0x04, 0x70, + 0x0C, 0xB1, 0x08, 0x21, + 0x00, 0xE0, 0x10, 0x21, 0xBD, 0xE8, 0x10, 0x40, 0x03, 0x20, 0xFB, 0xF7, + 0x42, 0xB9, 0x10, 0xBD, + 0x2D, 0xE9, 0xF0, 0x41, 0x17, 0x48, 0x1A, 0x4E, 0x17, 0x4C, 0x00, 0x68, + 0x34, 0x3E, 0x90, 0xF8, + 0x31, 0x50, 0x90, 0xF8, 0x30, 0x70, 0xB1, 0x69, 0x39, 0xB1, 0x18, 0x48, + 0x84, 0xF8, 0x30, 0x50, + 0xC2, 0x38, 0x6A, 0x00, 0x20, 0x61, 0x11, 0xF0, 0x20, 0xFF, 0xF1, 0x69, + 0x39, 0xB1, 0x13, 0x48, + 0x84, 0xF8, 0x31, 0x70, 0x98, 0x38, 0x7A, 0x00, 0x60, 0x61, 0x11, 0xF0, + 0x16, 0xFF, 0x0D, 0x48, + 0x0D, 0x49, 0x00, 0x78, 0x09, 0x78, 0x08, 0x43, 0x80, 0x06, 0x08, 0xD5, + 0x0B, 0x48, 0x4C, 0x38, + 0xE0, 0x60, 0x6A, 0x00, 0x71, 0x6A, 0xBD, 0xE8, 0xF0, 0x41, 0x11, 0xF0, + 0x06, 0xBF, 0xBD, 0xE8, + 0xF0, 0x81, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xCC, 0x68, 0x10, 0x00, + 0x54, 0x05, 0x10, 0x00, + 0x1C, 0x11, 0x10, 0x00, 0x4C, 0x05, 0x10, 0x00, 0x50, 0x05, 0x10, 0x00, + 0xCC, 0x07, 0x01, 0x20, + 0x1A, 0x05, 0x10, 0x00, 0x48, 0x05, 0x10, 0x00, 0x40, 0x05, 0x10, 0x00, + 0x41, 0x05, 0x10, 0x00, + 0x10, 0xB5, 0x00, 0x24, 0xC1, 0x07, 0x0B, 0xD0, 0x3F, 0x49, 0x03, 0x24, + 0x09, 0x68, 0x91, 0xF8, + 0x50, 0x22, 0xD2, 0x07, 0x03, 0xD1, 0x91, 0xF8, 0x80, 0x12, 0xC9, 0x07, + 0x00, 0xD0, 0x0B, 0x24, + 0x82, 0x07, 0x4F, 0xF0, 0x01, 0x01, 0x03, 0xD5, 0x38, 0x4A, 0x44, 0xF0, + 0x10, 0x04, 0x11, 0x70, + 0x40, 0x06, 0x03, 0xD5, 0x36, 0x48, 0x44, 0xF0, 0x80, 0x04, 0x01, 0x70, + 0x00, 0x2C, 0x12, 0xD0, + 0xFA, 0xF7, 0x96, 0xFF, 0x33, 0x48, 0x01, 0x68, 0x21, 0x43, 0x01, 0x60, + 0xFA, 0xF7, 0x8E, 0xFF, + 0x01, 0x21, 0x05, 0x20, 0x0D, 0xF0, 0xCF, 0xFA, 0xBD, 0xE8, 0x10, 0x40, + 0x4F, 0xF4, 0x80, 0x71, + 0x00, 0x20, 0xFB, 0xF7, 0xC6, 0xB8, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0xF0, + 0xDE, 0xFD, 0x02, 0x21, + 0x01, 0x20, 0xFB, 0xF7, 0xEA, 0xF8, 0x01, 0x20, 0xFB, 0xF7, 0x9B, 0xF9, + 0x38, 0x21, 0x26, 0x48, + 0x11, 0xF0, 0x4C, 0xFF, 0x24, 0x49, 0x01, 0x20, 0x81, 0xF8, 0x2C, 0x00, + 0xFB, 0xF7, 0xAC, 0xF9, + 0x01, 0x21, 0x02, 0x20, 0xFB, 0xF7, 0xAD, 0xF8, 0xBD, 0xE8, 0x10, 0x40, + 0x00, 0xF0, 0x2D, 0xBB, + 0x70, 0xB5, 0x1E, 0x48, 0x1E, 0x4E, 0x05, 0x68, 0x30, 0x68, 0x90, 0xEA, + 0x05, 0x04, 0x1F, 0xD0, + 0x35, 0xB1, 0x40, 0xB1, 0x04, 0xEA, 0x05, 0x00, 0xFF, 0xF7, 0xA2, 0xFF, + 0x35, 0x60, 0x70, 0xBD, + 0xFF, 0xF7, 0xD2, 0xFF, 0xFA, 0xE7, 0x00, 0xF0, 0xB0, 0xFD, 0x02, 0x21, + 0x01, 0x20, 0xFB, 0xF7, + 0xBC, 0xF8, 0x00, 0xF0, 0xD8, 0xF8, 0x00, 0xF0, 0x08, 0xFB, 0x04, 0xEA, + 0x05, 0x00, 0xFF, 0xF7, + 0x8F, 0xFF, 0x00, 0xF0, 0xF1, 0xFA, 0x02, 0x21, 0x01, 0x20, 0xFB, 0xF7, + 0x82, 0xF8, 0xE5, 0xE7, + 0x00, 0x2D, 0xE4, 0xD1, 0x0B, 0x48, 0x00, 0x78, 0x05, 0x28, 0x01, 0xD0, + 0x06, 0x28, 0xDE, 0xD1, + 0x35, 0x60, 0xBD, 0xE8, 0x70, 0x40, 0xAF, 0xE7, 0x4C, 0x07, 0x10, 0x00, + 0x7B, 0x07, 0x10, 0x00, + 0x7C, 0x07, 0x10, 0x00, 0x54, 0x07, 0x10, 0x00, 0xCC, 0x68, 0x10, 0x00, + 0x6C, 0x07, 0x10, 0x00, + 0x44, 0x05, 0x10, 0x00, 0x40, 0x05, 0x10, 0x00, 0x70, 0xB5, 0xFF, 0x49, + 0x00, 0x20, 0x03, 0x46, + 0x09, 0x68, 0x91, 0xF8, 0x40, 0x20, 0xD2, 0x07, 0x38, 0xD0, 0xFC, 0x4A, + 0x15, 0x78, 0x02, 0x2D, + 0x16, 0xD0, 0x04, 0x2D, 0x03, 0xD0, 0x05, 0x2D, 0x0F, 0xD0, 0x06, 0x2D, + 0x0D, 0xD0, 0x91, 0xF8, + 0x41, 0x20, 0xF7, 0x49, 0x0C, 0x68, 0x64, 0x1C, 0x0C, 0x60, 0x94, 0x42, + 0x26, 0xDD, 0xF5, 0x4A, + 0x00, 0x20, 0x14, 0x78, 0x64, 0xB1, 0x08, 0x60, 0x0C, 0xE0, 0x91, 0xF8, + 0x43, 0x20, 0xF0, 0xE7, + 0x91, 0xF8, 0x42, 0x20, 0x91, 0xF8, 0x90, 0x10, 0xC9, 0x06, 0xEA, 0xD5, + 0x01, 0x23, 0xE8, 0xE7, + 0x13, 0xB1, 0x01, 0x20, 0x10, 0x70, 0x00, 0xE0, 0x08, 0x60, 0x05, 0x2D, + 0x0F, 0xD0, 0x00, 0xF0, + 0x11, 0xF9, 0x04, 0x46, 0x00, 0xF0, 0x14, 0xF9, 0x04, 0x43, 0x00, 0xF0, + 0x1F, 0xF9, 0x04, 0x43, + 0x00, 0xF0, 0x2B, 0xF9, 0x04, 0x43, 0x00, 0xF0, 0x35, 0xF9, 0x20, 0x43, + 0x70, 0xBD, 0x01, 0x20, + 0x70, 0xBD, 0x10, 0xB5, 0x01, 0x46, 0x34, 0x22, 0xDF, 0x48, 0x11, 0xF0, + 0x53, 0xFE, 0x01, 0x21, + 0xBD, 0xE8, 0x10, 0x40, 0x08, 0x46, 0xFB, 0xF7, 0x14, 0xB8, 0x2D, 0xE9, + 0xFF, 0x41, 0x80, 0x46, + 0xD6, 0x48, 0x00, 0x78, 0x02, 0x28, 0x24, 0xD0, 0x03, 0x28, 0x1E, 0xD0, + 0x04, 0x24, 0xD7, 0x4D, + 0xD7, 0x4E, 0x01, 0x27, 0x05, 0x28, 0x20, 0xD0, 0x06, 0x28, 0x68, 0x46, + 0x30, 0xD0, 0x00, 0xF0, + 0xB5, 0xF9, 0xD4, 0x48, 0x00, 0x90, 0xCC, 0x48, 0x00, 0x68, 0x90, 0xF8, + 0xB0, 0x00, 0xC0, 0x07, + 0x01, 0xD0, 0x8D, 0xF8, 0x0D, 0x80, 0x68, 0x46, 0x11, 0xF0, 0x71, 0xFA, + 0xCE, 0x49, 0xCF, 0x4A, + 0xC9, 0x78, 0x11, 0x70, 0x04, 0xB0, 0xBD, 0xE8, 0xF0, 0x81, 0x68, 0x46, + 0x00, 0xF0, 0x4A, 0xF9, + 0xE7, 0xE7, 0x68, 0x46, 0x00, 0xF0, 0x05, 0xF9, 0xE3, 0xE7, 0x68, 0x46, + 0x11, 0xF0, 0x3A, 0xFA, + 0xFF, 0xF7, 0x7A, 0xFF, 0x40, 0x21, 0xC2, 0x07, 0x01, 0xD0, 0x8D, 0xF8, + 0x04, 0x40, 0xC2, 0x06, + 0x01, 0xD5, 0x8D, 0xF8, 0x06, 0x70, 0x8D, 0xF8, 0x08, 0x70, 0x28, 0x60, + 0x31, 0x60, 0xD0, 0xE7, + 0x00, 0x27, 0x11, 0xF0, 0x27, 0xFA, 0x8D, 0xF8, 0x04, 0x40, 0x01, 0x20, + 0x2F, 0x60, 0x30, 0x60, + 0xC7, 0xE7, 0x10, 0xB5, 0x00, 0xF0, 0xE1, 0xFC, 0x02, 0x21, 0xBD, 0xE8, + 0x10, 0x40, 0x01, 0x20, + 0xFA, 0xF7, 0xBF, 0xBF, 0x10, 0xB5, 0x00, 0xF0, 0xDD, 0xFC, 0x20, 0x21, + 0xBD, 0xE8, 0x10, 0x40, + 0x01, 0x20, 0xFA, 0xF7, 0xB6, 0xBF, 0xAA, 0x49, 0x00, 0x20, 0x08, 0x60, + 0x70, 0x47, 0xA8, 0x49, + 0x00, 0x20, 0x08, 0x60, 0x70, 0x47, 0xF8, 0xB5, 0x00, 0x24, 0x20, 0x46, + 0xFB, 0xF7, 0x89, 0xF8, + 0x00, 0xF0, 0x32, 0xFA, 0xA1, 0x4E, 0x30, 0x78, 0x00, 0xF0, 0x93, 0xF9, + 0xAF, 0xF2, 0x4D, 0x01, + 0x00, 0xF0, 0xB3, 0xFC, 0x9C, 0x4F, 0xA6, 0x4D, 0x38, 0x68, 0x90, 0xF8, + 0xB0, 0x00, 0xC1, 0x07, + 0x09, 0xD0, 0x01, 0x24, 0xC0, 0xF3, 0xC1, 0x01, 0x02, 0x29, 0x00, 0xD1, + 0x00, 0x24, 0x80, 0x07, + 0x01, 0xD5, 0x00, 0x20, 0x28, 0x70, 0x20, 0x46, 0xFF, 0xF7, 0x77, 0xFF, + 0x96, 0x4C, 0x01, 0x28, + 0x0D, 0xD1, 0x01, 0x21, 0x6B, 0x46, 0x00, 0x22, 0x08, 0x46, 0xFA, 0xF7, + 0xCB, 0xFF, 0x01, 0x21, + 0x08, 0x46, 0xFA, 0xF7, 0xAA, 0xFF, 0x20, 0x78, 0x90, 0xB1, 0x0C, 0xF0, + 0x8E, 0xFF, 0x00, 0x20, + 0xFB, 0xF7, 0x72, 0xF8, 0x38, 0x68, 0x90, 0xF8, 0xB0, 0x10, 0xCA, 0x07, + 0x51, 0xD0, 0x89, 0x07, + 0x4F, 0xD5, 0x8D, 0x49, 0x49, 0x78, 0x00, 0x29, 0x4B, 0xD1, 0x29, 0x78, + 0x19, 0xB1, 0x28, 0xE0, + 0xFF, 0xF7, 0xF6, 0xFD, 0xEB, 0xE7, 0x32, 0x78, 0x8A, 0x49, 0x02, 0x2A, + 0x02, 0xD1, 0x83, 0x4A, + 0x12, 0x68, 0x2A, 0xB1, 0x09, 0x78, 0x49, 0x06, 0x0B, 0xD5, 0x90, 0xF8, + 0xC1, 0x00, 0x0A, 0xE0, + 0x09, 0x78, 0x49, 0x06, 0x02, 0xD5, 0x90, 0xF8, 0xC2, 0x00, 0x04, 0xE0, + 0x90, 0xF8, 0xBC, 0x00, + 0x01, 0xE0, 0x90, 0xF8, 0xBB, 0x00, 0xAF, 0xF2, 0xE3, 0x01, 0x00, 0xF0, + 0x68, 0xFC, 0x6B, 0x46, + 0x00, 0x22, 0x20, 0x21, 0x01, 0x20, 0xFA, 0xF7, 0x8D, 0xFF, 0x20, 0x21, + 0x01, 0x20, 0xFA, 0xF7, + 0x6C, 0xFF, 0x28, 0x78, 0x00, 0x28, 0x1C, 0xD1, 0xFB, 0xF7, 0x1B, 0xF8, + 0x00, 0x20, 0xFF, 0xF7, + 0x24, 0xFF, 0x01, 0x28, 0x0D, 0xD1, 0x01, 0x21, 0x6B, 0x46, 0x00, 0x22, + 0x08, 0x46, 0xFA, 0xF7, + 0x79, 0xFF, 0x01, 0x21, 0x08, 0x46, 0xFA, 0xF7, 0x58, 0xFF, 0x20, 0x78, + 0x30, 0xB1, 0x0C, 0xF0, + 0x3C, 0xFF, 0xBD, 0xE8, 0xF8, 0x40, 0x00, 0x20, 0xFB, 0xF7, 0x1E, 0xB8, + 0xFF, 0xF7, 0xB0, 0xFD, + 0xF7, 0xE7, 0xF8, 0xBD, 0x67, 0x48, 0x00, 0x78, 0xC0, 0x07, 0x00, 0xD0, + 0x01, 0x20, 0x70, 0x47, + 0x64, 0x48, 0x00, 0x78, 0xC0, 0x07, 0x07, 0xD0, 0x57, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x50, 0x02, + 0xC0, 0x07, 0x01, 0xD0, 0x10, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, + 0x5D, 0x48, 0x00, 0x78, + 0xC1, 0x07, 0x51, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x80, 0x02, 0x03, 0xD0, + 0xC1, 0x07, 0x01, 0xD0, + 0x10, 0x20, 0x70, 0x47, 0x00, 0xF0, 0x01, 0x00, 0x70, 0x47, 0x56, 0x48, + 0x00, 0x78, 0x80, 0x07, + 0x06, 0xD5, 0x49, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x61, 0x04, 0x08, 0xB1, + 0x02, 0x20, 0x70, 0x47, + 0x00, 0x20, 0x70, 0x47, 0x4F, 0x48, 0x00, 0x78, 0x40, 0x06, 0x08, 0xD5, + 0x42, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x2F, 0x0A, 0xC0, 0x07, 0x02, 0xD0, 0x4F, 0xF4, 0x00, 0x70, + 0x70, 0x47, 0x00, 0x20, + 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x41, 0x06, 0x46, 0x00, 0x27, 0x11, 0xF0, + 0x33, 0xF9, 0xFF, 0xF7, + 0x73, 0xFE, 0x05, 0x46, 0x43, 0x48, 0x00, 0x78, 0xC0, 0x07, 0x00, 0xD0, + 0x40, 0x27, 0xFF, 0xF7, + 0xD4, 0xFF, 0x40, 0xEA, 0x07, 0x04, 0x6D, 0xB1, 0x33, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x90, 0x00, + 0x00, 0x07, 0x07, 0xD5, 0x00, 0xF0, 0xE4, 0xF8, 0x40, 0xEA, 0x04, 0x07, + 0x00, 0xF0, 0xEE, 0xF8, + 0x40, 0xEA, 0x07, 0x04, 0x45, 0xEA, 0x04, 0x07, 0xF8, 0x07, 0x02, 0xD0, + 0x00, 0xF0, 0xF4, 0xF8, + 0x30, 0x71, 0x61, 0x07, 0x4F, 0xF0, 0x01, 0x00, 0x00, 0xD5, 0x70, 0x71, + 0xE9, 0x06, 0x00, 0xD5, + 0xB0, 0x71, 0x61, 0x06, 0x00, 0xD5, 0x30, 0x72, 0xA1, 0x06, 0x00, 0xD5, + 0xF0, 0x71, 0xB9, 0x07, + 0x00, 0xD5, 0x70, 0x72, 0xA9, 0x05, 0x00, 0xD5, 0xB0, 0x72, 0x24, 0x48, + 0x05, 0x60, 0x24, 0x48, + 0x04, 0x60, 0xB0, 0xE6, 0x2D, 0xE9, 0xF0, 0x41, 0x05, 0x46, 0x11, 0xF0, + 0xF3, 0xF8, 0xFF, 0xF7, + 0x33, 0xFE, 0x07, 0x46, 0xFF, 0xF7, 0x76, 0xFF, 0x04, 0x46, 0xFF, 0xF7, + 0x79, 0xFF, 0x04, 0x43, + 0xFF, 0xF7, 0x84, 0xFF, 0x04, 0x43, 0x00, 0xF0, 0xAB, 0xF8, 0x04, 0x43, + 0xFF, 0xF7, 0x8D, 0xFF, + 0x04, 0x43, 0xFF, 0xF7, 0x97, 0xFF, 0x04, 0x43, 0x00, 0xF0, 0xB0, 0xF8, + 0x40, 0xEA, 0x04, 0x06, + 0x47, 0xEA, 0x06, 0x04, 0xE0, 0x07, 0x02, 0xD0, 0x00, 0xF0, 0xB6, 0xF8, + 0x28, 0x71, 0x71, 0x07, + 0x4F, 0xF0, 0x01, 0x00, 0x00, 0xD5, 0x68, 0x71, 0xE1, 0x06, 0x00, 0xD5, + 0xA8, 0x71, 0xB1, 0x06, + 0x00, 0xD5, 0xE8, 0x71, 0xA1, 0x07, 0x00, 0xD5, 0x68, 0x72, 0xA1, 0x05, + 0x00, 0xD5, 0xA8, 0x72, + 0x06, 0x48, 0x07, 0x60, 0x06, 0x48, 0x17, 0xE0, 0x4C, 0x07, 0x10, 0x00, + 0x40, 0x05, 0x10, 0x00, + 0x24, 0x05, 0x10, 0x00, 0x41, 0x05, 0x10, 0x00, 0xE8, 0x10, 0x10, 0x00, + 0x50, 0x05, 0x10, 0x00, + 0x4C, 0x05, 0x10, 0x00, 0xE3, 0x54, 0x00, 0x00, 0x74, 0x07, 0x10, 0x00, + 0x54, 0x05, 0x10, 0x00, + 0x78, 0x07, 0x10, 0x00, 0x44, 0x05, 0x10, 0x00, 0x06, 0x60, 0x5C, 0xE6, + 0x2D, 0xE9, 0xF0, 0x41, + 0x05, 0x46, 0x11, 0xF0, 0x9F, 0xF8, 0xFF, 0xF7, 0xDF, 0xFD, 0x06, 0x46, + 0xFF, 0xF7, 0x22, 0xFF, + 0x04, 0x46, 0xFF, 0xF7, 0x25, 0xFF, 0x04, 0x43, 0xFF, 0xF7, 0x30, 0xFF, + 0x04, 0x43, 0x00, 0xF0, + 0x57, 0xF8, 0x04, 0x43, 0xFF, 0xF7, 0x39, 0xFF, 0x04, 0x43, 0xFF, 0xF7, + 0x43, 0xFF, 0x04, 0x43, + 0x00, 0xF0, 0x5C, 0xF8, 0x40, 0xEA, 0x04, 0x07, 0x46, 0xEA, 0x07, 0x04, + 0xE0, 0x07, 0x02, 0xD0, + 0x00, 0xF0, 0x62, 0xF8, 0x28, 0x71, 0x61, 0x07, 0x4F, 0xF0, 0x01, 0x00, + 0x00, 0xD5, 0x68, 0x71, + 0xE1, 0x06, 0x00, 0xD5, 0xA8, 0x71, 0xB9, 0x06, 0x00, 0xD5, 0xE8, 0x71, + 0xA1, 0x07, 0x00, 0xD5, + 0x68, 0x72, 0xA1, 0x05, 0x00, 0xD5, 0xA8, 0x72, 0x2E, 0x48, 0x06, 0x60, + 0x2E, 0x48, 0x07, 0x60, + 0x21, 0xE6, 0x38, 0xB5, 0x2D, 0x49, 0x80, 0x1E, 0x05, 0x28, 0x09, 0x68, + 0x13, 0xD2, 0xDF, 0xE8, + 0x00, 0xF0, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x00, 0x91, 0xF8, 0x73, 0x40, + 0x0C, 0xE0, 0x91, 0xF8, + 0x72, 0x40, 0x09, 0xE0, 0x91, 0xF8, 0x71, 0x40, 0x06, 0xE0, 0x91, 0xF8, + 0x74, 0x40, 0x03, 0xE0, + 0x91, 0xF8, 0x75, 0x40, 0x00, 0xE0, 0x01, 0x24, 0x00, 0x25, 0x0C, 0xF0, + 0x53, 0xFA, 0x00, 0xB1, + 0x01, 0x25, 0x69, 0x46, 0x03, 0x20, 0xFA, 0xF7, 0x26, 0xFE, 0x00, 0x98, + 0x00, 0xB9, 0x1D, 0xB1, + 0x14, 0x2C, 0x01, 0xD2, 0x14, 0x24, 0x01, 0xE0, 0x04, 0xB9, 0x01, 0x24, + 0x20, 0x46, 0x38, 0xBD, + 0x17, 0x48, 0x00, 0x78, 0xC0, 0x07, 0x07, 0xD0, 0x14, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0xF0, 0x01, + 0xC0, 0x07, 0x01, 0xD0, 0x04, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, + 0x10, 0x48, 0x00, 0x78, + 0xC0, 0x07, 0x07, 0xD0, 0x0D, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x10, 0x02, + 0xC0, 0x07, 0x01, 0xD0, + 0x20, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x08, 0x49, 0x01, 0x20, + 0x09, 0x68, 0x91, 0xF8, + 0xE7, 0x10, 0x09, 0x06, 0x03, 0xD5, 0x07, 0x48, 0x40, 0x78, 0x08, 0xB1, + 0x03, 0x20, 0x70, 0x47, + 0x02, 0x20, 0x70, 0x47, 0x50, 0x05, 0x10, 0x00, 0x4C, 0x05, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x44, 0x05, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, 0x10, 0xB5, 0x00, 0xF0, + 0x8B, 0xF9, 0x00, 0xF0, + 0x00, 0xFA, 0x5B, 0x49, 0x00, 0x20, 0x48, 0x60, 0x5A, 0x49, 0x02, 0x20, + 0x08, 0x70, 0x10, 0xBD, + 0x10, 0xB5, 0x00, 0xF0, 0x7F, 0xF9, 0x00, 0xF0, 0xF4, 0xF9, 0x55, 0x49, + 0x00, 0x20, 0x48, 0x60, + 0x54, 0x49, 0x03, 0x20, 0x08, 0x70, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0xF0, + 0x73, 0xF9, 0x00, 0xF0, + 0xE8, 0xF9, 0x4F, 0x49, 0x00, 0x20, 0x48, 0x60, 0x4E, 0x49, 0x04, 0x20, + 0x08, 0x70, 0x4E, 0x49, + 0x01, 0x20, 0x08, 0x70, 0x4D, 0x49, 0x08, 0x70, 0x10, 0xBD, 0x49, 0x49, + 0x00, 0x20, 0x48, 0x60, + 0x70, 0x47, 0x47, 0x49, 0x00, 0x20, 0x48, 0x60, 0x70, 0x47, 0x45, 0x49, + 0x00, 0x20, 0x48, 0x60, + 0x44, 0x49, 0x01, 0x20, 0x08, 0x70, 0x70, 0x47, 0x70, 0xB5, 0x42, 0x4D, + 0x00, 0x26, 0x40, 0x4C, + 0x28, 0x78, 0x80, 0x1E, 0x04, 0x28, 0x10, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, + 0x30, 0x1F, 0x02, 0x3E, + 0x00, 0xF0, 0x45, 0xF8, 0x01, 0x28, 0x07, 0xD0, 0x60, 0x68, 0x40, 0x1C, + 0x60, 0x60, 0x00, 0xF0, + 0x46, 0xF8, 0x01, 0x28, 0x02, 0xD0, 0x0B, 0xE0, 0x66, 0x60, 0x70, 0xBD, + 0x38, 0x48, 0x61, 0x68, + 0x00, 0x68, 0x90, 0xF8, 0x77, 0x00, 0x88, 0x42, 0x02, 0xD2, 0xBD, 0xE8, + 0x70, 0x40, 0xAF, 0xE7, + 0x00, 0xF0, 0x47, 0xF8, 0x01, 0x28, 0x0E, 0xD0, 0x70, 0xBD, 0x00, 0xF0, + 0x28, 0xF8, 0x01, 0x28, + 0x17, 0xD0, 0x60, 0x68, 0x40, 0x1C, 0x60, 0x60, 0x00, 0xF0, 0x3B, 0xF8, + 0x01, 0x28, 0x02, 0xD0, + 0x00, 0xF0, 0x25, 0xF8, 0x0B, 0xE0, 0xBD, 0xE8, 0x70, 0x40, 0x8D, 0xE7, + 0x00, 0xF0, 0x17, 0xF8, + 0x01, 0x28, 0x06, 0xD0, 0x60, 0x68, 0x40, 0x1C, 0x60, 0x60, 0x00, 0xF0, + 0x22, 0xF8, 0x01, 0x28, + 0xE2, 0xD0, 0xBD, 0xE8, 0x70, 0x40, 0x97, 0xE7, 0x00, 0xF0, 0x09, 0xF9, + 0x08, 0xB1, 0x21, 0x78, + 0x09, 0xB1, 0x20, 0x70, 0x70, 0xBD, 0x20, 0x70, 0x06, 0x20, 0x28, 0x70, + 0x70, 0xBD, 0x10, 0xB5, + 0x00, 0xF0, 0xFD, 0xF8, 0x04, 0x46, 0x0B, 0xF0, 0x43, 0xFD, 0x20, 0x43, + 0x10, 0xBD, 0x18, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0x70, 0x00, 0x80, 0x07, 0x01, 0xD5, 0x01, 0x20, + 0x70, 0x47, 0x00, 0x20, + 0x70, 0x47, 0x13, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x70, 0x00, 0xC0, 0x07, + 0x00, 0xD0, 0x01, 0x20, + 0x70, 0x47, 0x10, 0xB5, 0xFF, 0xF7, 0xF5, 0xFF, 0x01, 0x28, 0x0F, 0xD1, + 0x00, 0xF0, 0x5F, 0xF9, + 0x60, 0xB9, 0x0B, 0x48, 0x06, 0x49, 0x00, 0x68, 0x49, 0x68, 0x90, 0xF8, + 0x78, 0x00, 0x00, 0xEB, + 0x80, 0x00, 0xB1, 0xEB, 0x40, 0x0F, 0x01, 0xD9, 0x01, 0x20, 0x10, 0xBD, + 0x00, 0x20, 0x10, 0xBD, + 0x28, 0x05, 0x10, 0x00, 0x40, 0x05, 0x10, 0x00, 0x79, 0x07, 0x10, 0x00, + 0x7A, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x2D, 0xE9, 0xF0, 0x41, 0x8E, 0x4C, 0x07, 0x46, + 0x0E, 0x46, 0x20, 0x68, + 0x00, 0x25, 0x90, 0xF8, 0x98, 0x20, 0x8C, 0x48, 0x0E, 0xF0, 0xBD, 0xFA, + 0x02, 0x00, 0x8B, 0x48, + 0x29, 0x46, 0x34, 0xD0, 0x02, 0x78, 0x01, 0x25, 0x52, 0x1C, 0xD2, 0xB2, + 0x02, 0x70, 0x23, 0x68, + 0x93, 0xF8, 0x99, 0x30, 0x93, 0x42, 0x2B, 0xD2, 0x01, 0x70, 0x83, 0x48, + 0x76, 0x00, 0x32, 0x46, + 0x39, 0x46, 0x54, 0x38, 0x11, 0xF0, 0xB9, 0xFA, 0x7F, 0x48, 0x32, 0x46, + 0x39, 0x46, 0x2A, 0x38, + 0x11, 0xF0, 0xB3, 0xFA, 0x20, 0x68, 0x03, 0x26, 0x90, 0xF8, 0x50, 0x12, + 0xC9, 0x07, 0x03, 0xD1, + 0x90, 0xF8, 0x80, 0x02, 0xC0, 0x07, 0x00, 0xD0, 0x0B, 0x26, 0xFA, 0xF7, + 0x71, 0xFB, 0x78, 0x48, + 0x01, 0x68, 0x31, 0x43, 0x01, 0x60, 0xFA, 0xF7, 0x69, 0xFB, 0x20, 0x21, + 0x05, 0x20, 0x0C, 0xF0, + 0xAA, 0xFE, 0x4F, 0xF4, 0x80, 0x71, 0x00, 0x20, 0xFA, 0xF7, 0xA3, 0xFC, + 0x00, 0xE0, 0x01, 0x70, + 0x28, 0x46, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xF0, 0x47, 0x88, 0x46, + 0x00, 0x28, 0x6B, 0xD0, + 0xDF, 0xF8, 0xB0, 0xA1, 0x00, 0x21, 0x69, 0x4C, 0x9A, 0xF8, 0x00, 0x20, + 0x89, 0x46, 0x02, 0x2A, + 0x03, 0xD0, 0x03, 0x2A, 0x01, 0xD0, 0x05, 0x2A, 0x5D, 0xD1, 0x00, 0x21, + 0xB8, 0xF1, 0x00, 0x0F, + 0x00, 0xD0, 0x01, 0x21, 0xA2, 0x88, 0x00, 0xEB, 0x41, 0x00, 0x52, 0x1A, + 0x15, 0xB2, 0x07, 0x46, + 0xA2, 0x78, 0x29, 0x46, 0x00, 0xF0, 0x71, 0xF8, 0x5A, 0x4E, 0xA0, 0x70, + 0x30, 0x68, 0x90, 0xF8, + 0x90, 0x00, 0x80, 0x07, 0x04, 0xD5, 0x38, 0x46, 0x29, 0x46, 0xFF, 0xF7, + 0x8B, 0xFF, 0x81, 0x46, + 0x00, 0x22, 0x01, 0x21, 0xB8, 0xF1, 0x00, 0x0F, 0x1A, 0xD0, 0x00, 0x27, + 0xDF, 0xF8, 0x48, 0xC1, + 0x38, 0x46, 0x36, 0x68, 0x10, 0xE0, 0x00, 0xBF, 0x3C, 0xF9, 0x10, 0x30, + 0x00, 0x2B, 0x00, 0xDA, + 0x5B, 0x42, 0xB6, 0xF8, 0x92, 0x80, 0x43, 0x45, 0x04, 0xDD, 0x96, 0xF8, + 0x91, 0x30, 0x7F, 0x1C, + 0xBB, 0x42, 0x1B, 0xDD, 0x40, 0x1C, 0xC0, 0xB2, 0xA8, 0x42, 0xED, 0xDB, + 0x11, 0x46, 0x22, 0xE0, + 0x00, 0x23, 0x45, 0x4F, 0x18, 0x46, 0x36, 0x68, 0x0D, 0xE0, 0x00, 0xBF, + 0x37, 0xF9, 0x10, 0xC0, + 0xB6, 0xF8, 0x92, 0x80, 0xC4, 0x45, 0x04, 0xDD, 0x96, 0xF8, 0x91, 0xC0, + 0x5B, 0x1C, 0x9C, 0x45, + 0x04, 0xDD, 0x40, 0x1C, 0xC0, 0xB2, 0xA8, 0x42, 0xF0, 0xDB, 0xE7, 0xE7, + 0x9A, 0xF8, 0x00, 0x00, + 0x02, 0x28, 0x0B, 0xD0, 0x03, 0x28, 0x09, 0xD0, 0x05, 0x28, 0x04, 0xD1, + 0x60, 0x78, 0x10, 0xB9, + 0xB9, 0xF1, 0x00, 0x0F, 0x02, 0xD0, 0x61, 0x70, 0xBD, 0xE8, 0xF0, 0x87, + 0x61, 0x70, 0x00, 0xF0, + 0x44, 0xF9, 0xBD, 0xE8, 0xF0, 0x47, 0x02, 0x21, 0x01, 0x20, 0xFA, 0xF7, + 0x22, 0xBC, 0x2F, 0x48, + 0x40, 0x78, 0x70, 0x47, 0x2D, 0x48, 0x00, 0x21, 0x01, 0x22, 0x01, 0x70, + 0x82, 0x70, 0x29, 0x4A, + 0x12, 0x68, 0x92, 0xF8, 0x31, 0x20, 0x82, 0x80, 0x2A, 0x4A, 0x12, 0x78, + 0x05, 0x2A, 0x02, 0xD0, + 0x06, 0x2A, 0x00, 0xD0, 0x41, 0x70, 0x70, 0x47, 0xEC, 0xE7, 0x2D, 0xE9, + 0xFC, 0x41, 0x80, 0x46, + 0x22, 0x48, 0x14, 0x46, 0x0D, 0x46, 0x40, 0x78, 0x16, 0x46, 0x40, 0xB9, + 0x1E, 0x48, 0x0A, 0x46, + 0x7F, 0x23, 0x41, 0x46, 0x54, 0x38, 0x00, 0x94, 0x0E, 0xF0, 0x22, 0xFA, + 0x00, 0x26, 0x19, 0x4F, + 0x38, 0x68, 0x90, 0xF8, 0x90, 0x10, 0xC9, 0x07, 0x00, 0xD0, 0xEC, 0xB1, + 0x16, 0x48, 0x6A, 0x00, + 0x41, 0x46, 0x2A, 0x38, 0x11, 0xF0, 0xE1, 0xF9, 0x13, 0x4A, 0x2B, 0x46, + 0x54, 0x3A, 0x02, 0xF1, + 0x2A, 0x01, 0x11, 0x48, 0x0E, 0xF0, 0xE5, 0xF9, 0x38, 0x68, 0x90, 0xF8, + 0x90, 0x10, 0x49, 0x07, + 0x07, 0xD5, 0x90, 0xF8, 0x9A, 0x30, 0x23, 0xB1, 0x0B, 0x49, 0x2A, 0x46, + 0x08, 0x46, 0x0E, 0xF0, + 0x18, 0xFA, 0x30, 0x46, 0xBD, 0xE8, 0xFC, 0x81, 0xB0, 0xF9, 0x96, 0x10, + 0xCD, 0xE9, 0x00, 0x15, + 0x05, 0x4A, 0xB0, 0xF9, 0x94, 0x30, 0x54, 0x3A, 0x41, 0x46, 0x02, 0xF1, + 0x2A, 0x00, 0x0E, 0xF0, + 0x4F, 0xF9, 0xD9, 0xE7, 0x4C, 0x07, 0x10, 0x00, 0x50, 0x09, 0x01, 0x20, + 0x30, 0x05, 0x10, 0x00, + 0x54, 0x07, 0x10, 0x00, 0x40, 0x05, 0x10, 0x00, 0x70, 0xB5, 0x00, 0x28, + 0x04, 0x9E, 0x0D, 0xD0, + 0x00, 0x24, 0x06, 0xE0, 0x30, 0xF9, 0x11, 0x50, 0x9D, 0x42, 0x01, 0xDD, + 0x95, 0x42, 0x00, 0xDB, + 0x64, 0x1C, 0x49, 0x1E, 0xF6, 0xD2, 0xB4, 0x42, 0x01, 0xDD, 0x01, 0x20, + 0x70, 0xBD, 0x00, 0x20, + 0x70, 0xBD, 0x3F, 0x48, 0x00, 0x21, 0x01, 0x70, 0x41, 0x60, 0x70, 0x47, + 0xF9, 0xE7, 0x3C, 0x48, + 0x00, 0x78, 0x70, 0x47, 0x2D, 0xE9, 0xF3, 0x4F, 0xDF, 0xF8, 0xE8, 0xA0, + 0x84, 0x46, 0x4F, 0xF0, + 0x00, 0x08, 0xDA, 0xF8, 0x00, 0x00, 0xDF, 0xF8, 0xD8, 0xB0, 0x81, 0xB0, + 0x90, 0xF8, 0x80, 0x10, + 0x47, 0x46, 0xC9, 0x07, 0xC1, 0x46, 0x2B, 0xD0, 0x33, 0x49, 0x09, 0x78, + 0x03, 0x29, 0x2D, 0xD0, + 0x04, 0x29, 0x2B, 0xD0, 0x05, 0x29, 0x36, 0xD1, 0xB0, 0xF8, 0x88, 0x60, + 0xB0, 0xF8, 0x8A, 0x50, + 0x90, 0xF8, 0x87, 0x40, 0xBC, 0xF1, 0x00, 0x0F, 0x08, 0xD0, 0x00, 0x94, + 0x90, 0xF8, 0x31, 0x10, + 0x2B, 0xB2, 0x32, 0xB2, 0x60, 0x46, 0xFF, 0xF7, 0xB7, 0xFF, 0x80, 0x46, + 0x02, 0x98, 0x50, 0xB1, + 0x00, 0x94, 0xDA, 0xF8, 0x00, 0x00, 0x2B, 0xB2, 0x32, 0xB2, 0x90, 0xF8, + 0x30, 0x10, 0x02, 0x98, + 0xFF, 0xF7, 0xAA, 0xFF, 0x07, 0x46, 0xB8, 0xF1, 0x01, 0x0F, 0x0E, 0xD0, + 0x01, 0x2F, 0x0C, 0xD0, + 0x9B, 0xF8, 0x00, 0x10, 0x58, 0x46, 0x01, 0x29, 0x1D, 0xD0, 0x0A, 0xE0, + 0xB0, 0xF8, 0x82, 0x60, + 0xB0, 0xF8, 0x84, 0x50, 0x90, 0xF8, 0x86, 0x40, 0xD4, 0xE7, 0x9B, 0xF8, + 0x00, 0x10, 0x58, 0x46, + 0x19, 0xB1, 0xCB, 0xF8, 0x04, 0x90, 0xBD, 0xE8, 0xFE, 0x8F, 0x41, 0x68, + 0x49, 0x1C, 0x41, 0x60, + 0xDA, 0xF8, 0x00, 0x20, 0x92, 0xF8, 0x81, 0x20, 0x8A, 0x42, 0xF4, 0xDA, + 0x01, 0x21, 0x01, 0x70, + 0xCB, 0xF8, 0x04, 0x90, 0x0D, 0xE0, 0x41, 0x68, 0x49, 0x1C, 0x41, 0x60, + 0xDA, 0xF8, 0x00, 0x20, + 0x92, 0xF8, 0x81, 0x20, 0x8A, 0x42, 0xE6, 0xDA, 0x80, 0xF8, 0x00, 0x90, + 0x00, 0x21, 0xCB, 0xF8, + 0x04, 0x90, 0x03, 0xB0, 0x07, 0x20, 0xBD, 0xE8, 0xF0, 0x4F, 0x0C, 0xF0, + 0x2C, 0xBD, 0x00, 0x00, + 0x38, 0x05, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x40, 0x05, 0x10, 0x00, + 0x22, 0x49, 0x08, 0xB5, + 0x00, 0x20, 0x48, 0x60, 0x01, 0x22, 0x88, 0x60, 0x0A, 0x70, 0x48, 0x70, + 0x1F, 0x49, 0x08, 0x70, + 0x1F, 0x49, 0x08, 0x70, 0xFF, 0xF7, 0x08, 0xFF, 0xFF, 0xF7, 0x70, 0xFF, + 0xFF, 0xF7, 0x5F, 0xFB, + 0xFF, 0xF7, 0x8F, 0xFD, 0x6B, 0x46, 0x00, 0x22, 0x1E, 0x21, 0x01, 0x20, + 0xFA, 0xF7, 0x52, 0xFB, + 0x00, 0x98, 0x41, 0x07, 0x03, 0xD5, 0xFF, 0xF7, 0x5B, 0xFA, 0x04, 0x21, + 0x08, 0xE0, 0x01, 0x07, + 0x03, 0xD5, 0xFF, 0xF7, 0x73, 0xF8, 0x08, 0x21, 0x02, 0xE0, 0xC1, 0x06, + 0x04, 0xD5, 0x10, 0x21, + 0x01, 0x20, 0xFA, 0xF7, 0x22, 0xFB, 0xE5, 0xE7, 0x80, 0x07, 0xE3, 0xD5, + 0x02, 0x21, 0x01, 0x20, + 0xFA, 0xF7, 0x1B, 0xFB, 0xFF, 0xF7, 0x3F, 0xFB, 0xDC, 0xE7, 0x00, 0xEB, + 0x80, 0x00, 0x4F, 0xF6, + 0xFF, 0x72, 0x02, 0xEA, 0x40, 0x00, 0xFB, 0xF7, 0xAA, 0xBC, 0xFB, 0xF7, + 0xB8, 0xBC, 0x80, 0xB2, + 0xFB, 0xF7, 0xE9, 0xBB, 0xFB, 0xF7, 0xFB, 0xBB, 0x40, 0x05, 0x10, 0x00, + 0x78, 0x07, 0x10, 0x00, + 0x7D, 0x07, 0x10, 0x00, 0x01, 0xF0, 0x41, 0xBA, 0x5E, 0x48, 0x5F, 0x49, + 0x00, 0x7E, 0x09, 0x7E, + 0xC8, 0x42, 0x09, 0xD1, 0x5D, 0x48, 0x00, 0x78, 0x80, 0x06, 0x05, 0xD5, + 0x01, 0x23, 0x5C, 0x4A, + 0x59, 0x49, 0x58, 0x48, 0x00, 0xF0, 0x00, 0xBD, 0x70, 0x47, 0x3C, 0xB5, + 0x00, 0x23, 0x00, 0x93, + 0x01, 0x93, 0x6B, 0x46, 0x07, 0xE0, 0x44, 0x18, 0x64, 0x78, 0x14, 0xB1, + 0x1D, 0x5D, 0x6D, 0x1C, + 0x1D, 0x55, 0x49, 0x1C, 0xC9, 0xB2, 0x91, 0x42, 0xF5, 0xD9, 0x00, 0x20, + 0x01, 0x21, 0x1C, 0x5C, + 0x5A, 0x5C, 0xA2, 0x42, 0x00, 0xD9, 0x08, 0x46, 0x49, 0x1C, 0xC9, 0xB2, + 0x06, 0x29, 0xF6, 0xD3, + 0x3C, 0xBD, 0x70, 0xB5, 0x04, 0x46, 0x00, 0x20, 0x08, 0x70, 0x0E, 0x46, + 0x10, 0x70, 0x45, 0x48, + 0x45, 0x49, 0x15, 0x46, 0x00, 0x7E, 0x09, 0x7E, 0xC8, 0x42, 0x0B, 0xD0, + 0xE2, 0x78, 0xA1, 0x78, + 0x44, 0x48, 0xFF, 0xF7, 0xD2, 0xFF, 0x30, 0x70, 0x62, 0x78, 0x21, 0x78, + 0x42, 0x48, 0xFF, 0xF7, + 0xCC, 0xFF, 0x28, 0x70, 0x70, 0xBD, 0x70, 0xB5, 0x00, 0x24, 0x01, 0x23, + 0x05, 0x7E, 0x08, 0xE0, + 0xC6, 0x18, 0x96, 0xF9, 0x12, 0x60, 0x8E, 0x42, 0x02, 0xDB, 0x96, 0x42, + 0x00, 0xDC, 0x64, 0x1C, + 0x5B, 0x1C, 0x9D, 0x42, 0xF4, 0xD2, 0x01, 0x2C, 0x01, 0xDC, 0x01, 0x20, + 0x70, 0xBD, 0x00, 0x20, + 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x43, 0x99, 0x46, 0x00, 0x23, 0x1F, 0x46, + 0x47, 0xF6, 0xFF, 0x76, + 0x4F, 0xF0, 0xFF, 0x3C, 0x01, 0x25, 0x04, 0x7E, 0x0D, 0xE0, 0x00, 0xBF, + 0x00, 0xEB, 0x05, 0x08, + 0x98, 0xF9, 0x12, 0x80, 0x88, 0x45, 0x05, 0xDB, 0x90, 0x45, 0x03, 0xDC, + 0x43, 0x19, 0x93, 0xF9, + 0x12, 0x30, 0x02, 0xE0, 0x6D, 0x1C, 0xAC, 0x42, 0xF0, 0xD2, 0x64, 0x1C, + 0x0A, 0xE0, 0x05, 0x19, + 0x95, 0xF9, 0x12, 0x50, 0x8D, 0x42, 0x05, 0xDB, 0x95, 0x42, 0x03, 0xDC, + 0x20, 0x44, 0x90, 0xF9, + 0x12, 0x70, 0x01, 0xE0, 0x64, 0x1E, 0xF2, 0xD1, 0xBB, 0x42, 0x09, 0xD1, + 0x0A, 0xE0, 0x00, 0xBF, + 0x39, 0xF9, 0x13, 0x00, 0xB0, 0x42, 0x02, 0xDA, 0x06, 0x46, 0x4F, 0xFA, + 0x83, 0xFC, 0x5B, 0x1C, + 0xBB, 0x42, 0xF5, 0xDD, 0x60, 0x46, 0xBD, 0xE8, 0xF0, 0x83, 0x2D, 0xE9, + 0xF0, 0x41, 0x17, 0x46, + 0x0E, 0x46, 0x04, 0x46, 0xC2, 0x78, 0x81, 0x78, 0x0E, 0x48, 0xFF, 0xF7, + 0xA4, 0xFF, 0x05, 0x00, + 0x06, 0xD1, 0xE2, 0x78, 0xA1, 0x78, 0x11, 0x4B, 0x0A, 0x48, 0xFF, 0xF7, + 0xB2, 0xFF, 0x30, 0x70, + 0x62, 0x78, 0x21, 0x78, 0x08, 0x48, 0xFF, 0xF7, 0x96, 0xFF, 0x06, 0x00, + 0x06, 0xD1, 0x62, 0x78, + 0x21, 0x78, 0x0B, 0x4B, 0x04, 0x48, 0xFF, 0xF7, 0xA4, 0xFF, 0x38, 0x70, + 0x05, 0xEA, 0x06, 0x00, + 0xBD, 0xE8, 0xF0, 0x81, 0x18, 0x2A, 0x10, 0x00, 0x58, 0x2A, 0x10, 0x00, + 0x04, 0x07, 0x10, 0x00, + 0x40, 0x2B, 0x10, 0x00, 0x0A, 0x0C, 0x01, 0x20, 0x21, 0x0C, 0x01, 0x20, + 0x94, 0x0B, 0x01, 0x20, + 0xBE, 0x0B, 0x01, 0x20, 0x24, 0x48, 0x00, 0x21, 0x01, 0x61, 0x41, 0x61, + 0x23, 0x48, 0x01, 0x70, + 0x01, 0x21, 0x41, 0x70, 0x70, 0x47, 0x2D, 0xE9, 0xF8, 0x4F, 0x20, 0x4D, + 0x82, 0x46, 0x0E, 0x46, + 0x1D, 0x48, 0x69, 0x78, 0x10, 0x30, 0x01, 0x29, 0x0F, 0xD1, 0x1D, 0x49, + 0x09, 0x68, 0x91, 0xF8, + 0x40, 0x2A, 0x02, 0xF0, 0x0F, 0x03, 0x03, 0x80, 0x12, 0x09, 0x42, 0x80, + 0x91, 0xF8, 0x41, 0x1A, + 0x01, 0xF0, 0x0F, 0x02, 0x82, 0x80, 0x09, 0x09, 0xC1, 0x80, 0x13, 0x49, + 0x00, 0x27, 0x3C, 0x46, + 0x8F, 0x60, 0xCF, 0x60, 0x80, 0x46, 0x89, 0x46, 0x0B, 0xE0, 0x68, 0x78, + 0x00, 0x90, 0x38, 0xF9, + 0x14, 0x30, 0x0A, 0xEB, 0x44, 0x01, 0x09, 0xEB, 0x44, 0x00, 0x01, 0x22, + 0x0D, 0xF0, 0xDE, 0xFF, + 0x64, 0x1C, 0xB4, 0x42, 0xF1, 0xDB, 0x6F, 0x70, 0x03, 0x20, 0xFA, 0xF7, + 0xAA, 0xFA, 0x06, 0x49, + 0x33, 0x46, 0x08, 0x4A, 0x01, 0xF1, 0x08, 0x00, 0x0D, 0xF0, 0xC3, 0xFF, + 0xBD, 0xE8, 0xF8, 0x4F, + 0x03, 0x20, 0xFA, 0xF7, 0xB9, 0xBA, 0x00, 0x00, 0x7A, 0x09, 0x01, 0x20, + 0x55, 0x05, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0xFC, 0x4A, 0x01, 0x20, 0x2D, 0xE9, 0xF0, 0x5F, + 0x82, 0x46, 0x5E, 0x48, + 0x99, 0x46, 0x3A, 0xF9, 0x12, 0x30, 0x00, 0x68, 0x01, 0x26, 0x0A, 0x9C, + 0xB0, 0xF9, 0x3E, 0xB2, + 0x03, 0xFB, 0x02, 0xF0, 0x35, 0x46, 0x29, 0xE0, 0x57, 0x1B, 0x7F, 0xB2, + 0x00, 0x2F, 0x0F, 0xDB, + 0x76, 0xB1, 0x3A, 0xF9, 0x17, 0xC0, 0xDC, 0x45, 0x09, 0xDD, 0x0A, 0xEB, + 0x47, 0x08, 0xB8, 0xF9, + 0x02, 0x80, 0xC4, 0x45, 0x03, 0xDC, 0x0C, 0xFB, 0x07, 0x00, 0x63, 0x44, + 0x00, 0xE0, 0x00, 0x26, + 0x57, 0x19, 0x7F, 0xB2, 0x8F, 0x42, 0x0F, 0xDA, 0x76, 0xB1, 0x3A, 0xF9, + 0x17, 0xC0, 0xDC, 0x45, + 0x09, 0xDD, 0x0A, 0xEB, 0x47, 0x08, 0x38, 0xF9, 0x02, 0x8C, 0xC4, 0x45, + 0x03, 0xDC, 0x0C, 0xFB, + 0x07, 0x00, 0x63, 0x44, 0x00, 0xE0, 0x00, 0x26, 0x6D, 0x1C, 0xED, 0xB2, + 0x4D, 0x45, 0xD3, 0xD9, + 0x49, 0x1E, 0x83, 0xFB, 0x01, 0x23, 0x80, 0xFB, 0x04, 0x01, 0x10, 0xF0, + 0x42, 0xFF, 0x00, 0x28, + 0x00, 0xDA, 0x00, 0x20, 0x61, 0x1E, 0x88, 0x42, 0x00, 0xDD, 0x08, 0x46, + 0xBD, 0xE8, 0xF0, 0x9F, + 0x70, 0xB5, 0x00, 0x20, 0x96, 0xB0, 0x04, 0x46, 0x38, 0x4D, 0x34, 0xE0, + 0x22, 0x46, 0x37, 0x49, + 0x01, 0xA8, 0x00, 0xF0, 0x35, 0xF8, 0x34, 0x4E, 0x30, 0x68, 0xB0, 0xF9, + 0x34, 0x10, 0x00, 0x91, + 0x90, 0xF8, 0x40, 0x32, 0x32, 0x48, 0x2A, 0x57, 0x01, 0x78, 0x32, 0x48, + 0xFF, 0xF7, 0x9C, 0xFF, + 0x13, 0x90, 0x30, 0x68, 0xB0, 0xF9, 0x32, 0x10, 0x00, 0x91, 0x90, 0xF8, + 0x40, 0x32, 0x28, 0x19, + 0x90, 0xF9, 0x02, 0x20, 0x2C, 0x48, 0x01, 0x78, 0x2C, 0x48, 0xFF, 0xF7, + 0x8D, 0xFF, 0x14, 0x90, + 0x13, 0xA8, 0x07, 0xF0, 0xB5, 0xF8, 0x14, 0x99, 0xAD, 0xF8, 0x12, 0x10, + 0x13, 0x98, 0xAD, 0xF8, + 0x16, 0x10, 0xAD, 0xF8, 0x10, 0x00, 0xAD, 0xF8, 0x14, 0x00, 0x01, 0xA8, + 0x05, 0xF0, 0xB5, 0xFE, + 0x01, 0x20, 0x64, 0x1C, 0xE4, 0xB2, 0x29, 0x7A, 0xA1, 0x42, 0xC7, 0xD8, + 0x16, 0xB0, 0x70, 0xBD, + 0x70, 0xB5, 0x0E, 0x46, 0x15, 0x46, 0x04, 0x46, 0x48, 0x21, 0x10, 0xF0, + 0xB7, 0xFF, 0x71, 0x19, + 0x08, 0x79, 0x8A, 0x79, 0x50, 0x43, 0x03, 0x22, 0x84, 0xF8, 0x40, 0x20, + 0x18, 0x4A, 0x12, 0x88, + 0x52, 0x1C, 0x62, 0x86, 0xA2, 0x8C, 0x42, 0xF0, 0x20, 0x02, 0xA2, 0x84, + 0xE0, 0x84, 0x60, 0x85, + 0x42, 0x1C, 0x22, 0x85, 0x41, 0xF2, 0x88, 0x32, 0xE2, 0x61, 0xA2, 0x61, + 0x0A, 0x79, 0x8B, 0x79, + 0xD1, 0x18, 0x00, 0xD1, 0x01, 0x21, 0x42, 0x43, 0x58, 0x43, 0x52, 0x00, + 0x40, 0x00, 0xB2, 0xFB, + 0xF1, 0xF2, 0xB0, 0xFB, 0xF1, 0xF0, 0x82, 0x42, 0x02, 0xD9, 0xE2, 0x85, + 0x20, 0x86, 0x70, 0xBD, + 0xE0, 0x85, 0x22, 0x86, 0x70, 0xBD, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x0C, 0x2A, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0x94, 0x0B, 0x01, 0x20, 0xEE, 0x06, 0x10, 0x00, + 0xBE, 0x0B, 0x01, 0x20, + 0x8C, 0x06, 0x10, 0x00, 0x2D, 0xE9, 0xF0, 0x47, 0x00, 0x25, 0x82, 0x46, + 0xA6, 0xB0, 0x50, 0x1E, + 0xC7, 0xB2, 0x2C, 0x46, 0x28, 0x46, 0x6B, 0x46, 0x0D, 0xF1, 0x4C, 0x09, + 0x12, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x10, 0x60, 0x35, 0x44, 0x46, 0x1C, 0xB4, 0x46, 0x95, 0xFB, + 0xF6, 0xF6, 0x23, 0xF8, + 0x10, 0x60, 0x3E, 0x1A, 0x40, 0x1C, 0x31, 0xF9, 0x16, 0x80, 0x44, 0x44, + 0x94, 0xFB, 0xFC, 0xFC, + 0x29, 0xF8, 0x16, 0xC0, 0x90, 0x42, 0xEB, 0xDB, 0x48, 0x46, 0x0C, 0xE0, + 0x33, 0xF9, 0x12, 0x40, + 0x30, 0xF9, 0x12, 0x50, 0x2C, 0x44, 0x31, 0xF8, 0x12, 0x50, 0x04, 0xEB, + 0xD4, 0x74, 0xA5, 0xEB, + 0x64, 0x04, 0x2A, 0xF8, 0x12, 0x40, 0x52, 0x1E, 0xF0, 0xD2, 0x26, 0xB0, + 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xFF, 0x4F, 0x4F, 0xF0, 0x00, 0x0B, 0xA7, 0xB0, 0xC0, 0xF8, + 0x00, 0xB0, 0x81, 0x46, + 0xC0, 0xF8, 0x04, 0xB0, 0x98, 0x46, 0x14, 0x46, 0x5D, 0x46, 0x5E, 0x46, + 0xDA, 0x46, 0x5F, 0x46, + 0x28, 0x21, 0x01, 0xA8, 0x10, 0xF0, 0x32, 0xFF, 0x4C, 0x21, 0x0B, 0xA8, + 0x10, 0xF0, 0x2E, 0xFF, + 0xCD, 0xF8, 0x00, 0x80, 0x02, 0x23, 0x22, 0x46, 0x0B, 0xA8, 0x28, 0x99, + 0x0D, 0xF0, 0x9E, 0xFE, + 0x8E, 0x49, 0x01, 0x20, 0x02, 0x46, 0x00, 0x23, 0x0D, 0xF1, 0x04, 0x0E, + 0xD1, 0xF8, 0x00, 0x80, + 0x17, 0xE0, 0x0B, 0xA9, 0x31, 0xF9, 0x10, 0xC0, 0xB8, 0xF9, 0x4C, 0x12, + 0x8C, 0x45, 0x04, 0xDD, + 0x4F, 0xF0, 0x01, 0x0B, 0x0E, 0xF8, 0x00, 0x20, 0x0A, 0xE0, 0x49, 0x42, + 0x8C, 0x45, 0x05, 0xDA, + 0xFF, 0x21, 0x4F, 0xF0, 0x01, 0x0B, 0x0E, 0xF8, 0x00, 0x10, 0x01, 0xE0, + 0x0E, 0xF8, 0x00, 0x30, + 0x40, 0x1C, 0xA0, 0x42, 0xE5, 0xDB, 0xBB, 0xF1, 0x01, 0x0F, 0x42, 0xD1, + 0x01, 0x20, 0x71, 0x46, + 0x09, 0xE0, 0x0A, 0x5C, 0x32, 0xB1, 0xC5, 0xB2, 0x08, 0x56, 0x00, 0x28, + 0x05, 0xDD, 0x4F, 0xF0, + 0x01, 0x0A, 0x02, 0xE0, 0x40, 0x1C, 0xA0, 0x42, 0xF3, 0xDB, 0x60, 0x1E, + 0x07, 0xE0, 0x0A, 0x5C, + 0x2A, 0xB1, 0xC6, 0xB2, 0x08, 0x56, 0x00, 0x28, 0x03, 0xDA, 0x01, 0x27, + 0x01, 0xE0, 0x40, 0x1E, + 0xF5, 0xD2, 0xA4, 0xF1, 0x01, 0x08, 0xBA, 0xF1, 0x00, 0x0F, 0x01, 0xD0, + 0x97, 0xB9, 0x02, 0xE0, + 0x4F, 0xF0, 0x01, 0x05, 0x77, 0xB9, 0x08, 0xF0, 0xFF, 0x06, 0x0B, 0xE0, + 0xD9, 0xE9, 0x00, 0x47, + 0x2A, 0x46, 0x01, 0x20, 0x00, 0x21, 0x10, 0xF0, 0xF9, 0xFD, 0x04, 0x43, + 0x0F, 0x43, 0xC9, 0xE9, + 0x00, 0x47, 0x6D, 0x1C, 0xB5, 0x42, 0xF1, 0xDD, 0xD9, 0xE9, 0x00, 0x04, + 0x40, 0xF0, 0x01, 0x05, + 0x42, 0x46, 0x01, 0x20, 0x00, 0x21, 0x10, 0xF0, 0xE9, 0xFD, 0x05, 0x43, + 0x0C, 0x43, 0xC9, 0xE9, + 0x00, 0x54, 0x2B, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0x2D, 0xE9, 0xF8, 0x43, + 0x05, 0x46, 0x16, 0x46, + 0x0F, 0x46, 0x03, 0x20, 0xFA, 0xF7, 0xFD, 0xF8, 0x55, 0x4C, 0x56, 0x4A, + 0x29, 0x46, 0x23, 0x78, + 0x55, 0x48, 0x0D, 0xF0, 0x16, 0xFE, 0x55, 0x4D, 0x53, 0x48, 0x55, 0x4A, + 0x2B, 0x78, 0x39, 0x46, + 0x2A, 0x30, 0x0D, 0xF0, 0x0E, 0xFE, 0x03, 0x20, 0xFA, 0xF7, 0x06, 0xF9, + 0xDF, 0xF8, 0x2C, 0x81, + 0xD8, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0xE0, 0x13, 0x89, 0x07, 0x12, 0xD5, + 0x90, 0xF8, 0xF4, 0x03, + 0x00, 0x96, 0x00, 0xF0, 0x0F, 0x07, 0x3B, 0x46, 0x22, 0x78, 0x47, 0x49, + 0x49, 0x48, 0x0D, 0xF0, + 0x05, 0xFE, 0x45, 0x49, 0x00, 0x96, 0x3B, 0x46, 0x2A, 0x78, 0x2A, 0x31, + 0x46, 0x48, 0x0D, 0xF0, + 0xFD, 0xFD, 0x22, 0x78, 0x40, 0x49, 0x45, 0x48, 0x00, 0xF0, 0x5B, 0xF8, + 0x3E, 0x49, 0x2A, 0x78, + 0x2A, 0x31, 0x43, 0x48, 0x00, 0xF0, 0x55, 0xF8, 0x42, 0x4F, 0x00, 0x96, + 0x22, 0x78, 0x3F, 0x49, + 0x41, 0x48, 0x3B, 0x68, 0x0D, 0xF0, 0xEA, 0xFD, 0x00, 0x96, 0x2A, 0x78, + 0x3C, 0x49, 0x3F, 0x48, + 0x3B, 0x68, 0x0D, 0xF0, 0xE3, 0xFD, 0xD8, 0xF8, 0x00, 0x00, 0x47, 0x46, + 0x90, 0xF8, 0x30, 0x02, + 0xC0, 0x06, 0x0A, 0xD5, 0x22, 0x78, 0x38, 0x49, 0x39, 0x48, 0xFF, 0xF7, + 0xE3, 0xFE, 0x2A, 0x78, + 0x36, 0x49, 0x38, 0x48, 0xFF, 0xF7, 0xDE, 0xFE, 0x0B, 0xE0, 0x20, 0x78, + 0x32, 0x49, 0x42, 0x00, + 0x33, 0x48, 0x10, 0xF0, 0xB2, 0xFD, 0x28, 0x78, 0x30, 0x49, 0x42, 0x00, + 0x31, 0x48, 0x10, 0xF0, + 0xAC, 0xFD, 0x38, 0x68, 0x90, 0xF8, 0x30, 0x02, 0x80, 0x06, 0x04, 0xD5, + 0x2C, 0x49, 0x22, 0x78, + 0x08, 0x46, 0x00, 0xF0, 0x30, 0xF8, 0x38, 0x68, 0x90, 0xF8, 0x30, 0x02, + 0x40, 0x06, 0x04, 0xD5, + 0x28, 0x49, 0x2A, 0x78, 0x08, 0x46, 0x00, 0xF0, 0x26, 0xF8, 0x33, 0x46, + 0x22, 0x78, 0x1A, 0x49, + 0x25, 0x48, 0xFF, 0xF7, 0xED, 0xFE, 0x2A, 0x78, 0x01, 0xB0, 0x33, 0x46, + 0xBD, 0xE8, 0xF0, 0x43, + 0x15, 0x49, 0x21, 0x48, 0x2A, 0x31, 0x08, 0x30, 0xE2, 0xE6, 0x20, 0x49, + 0x00, 0x20, 0x08, 0x70, + 0x70, 0x47, 0x30, 0xB5, 0x00, 0x23, 0x03, 0x80, 0x01, 0x23, 0x09, 0xE0, + 0x00, 0xEB, 0x43, 0x04, + 0x31, 0xF8, 0x13, 0x50, 0x34, 0xF8, 0x02, 0x4C, 0x2C, 0x44, 0x20, 0xF8, + 0x13, 0x40, 0x5B, 0x1C, + 0x93, 0x42, 0xF3, 0xDB, 0x30, 0xBD, 0x08, 0xB5, 0x00, 0x92, 0x04, 0x4A, + 0x12, 0x68, 0xB2, 0xF9, + 0x4A, 0x32, 0xB2, 0xF9, 0x48, 0x22, 0x02, 0xF0, 0x78, 0xFA, 0x08, 0xBD, + 0x4C, 0x07, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0x7E, 0x4A, 0x01, 0x20, 0x92, 0x09, 0x01, 0x20, + 0xEE, 0x06, 0x10, 0x00, + 0xA8, 0x4A, 0x01, 0x20, 0xC8, 0x2A, 0x10, 0x00, 0xF2, 0x2A, 0x10, 0x00, + 0xA0, 0x0A, 0x01, 0x20, + 0xCE, 0x0A, 0x01, 0x20, 0x9C, 0x06, 0x10, 0x00, 0x1E, 0x0B, 0x01, 0x20, + 0x48, 0x0B, 0x01, 0x20, + 0x94, 0x0B, 0x01, 0x20, 0xBE, 0x0B, 0x01, 0x20, 0x50, 0x2B, 0x10, 0x00, + 0xF4, 0x06, 0x10, 0x00, + 0x10, 0xB5, 0x40, 0x21, 0xFE, 0x48, 0x10, 0xF0, 0xE1, 0xFD, 0xFD, 0x48, + 0x40, 0x21, 0x40, 0x30, + 0x10, 0xF0, 0xDC, 0xFD, 0xFA, 0x48, 0x00, 0x21, 0x80, 0x30, 0xC0, 0xE9, + 0x00, 0x11, 0xC0, 0xE9, + 0x02, 0x11, 0x10, 0x30, 0xC0, 0xE9, 0x00, 0x11, 0xC0, 0xE9, 0x02, 0x11, + 0x10, 0x30, 0xC0, 0xE9, + 0x00, 0x11, 0xC0, 0xE9, 0x02, 0x11, 0x08, 0x46, 0xF2, 0x49, 0x08, 0x60, + 0x10, 0xBD, 0x2D, 0xE9, + 0xFF, 0x5F, 0x06, 0x46, 0x89, 0x46, 0xF0, 0x48, 0xF0, 0x49, 0x98, 0x46, + 0x00, 0x78, 0x09, 0x68, + 0x14, 0x46, 0x01, 0x28, 0x50, 0xD0, 0xB1, 0xF9, 0x86, 0xA2, 0x91, 0xF8, + 0x88, 0x52, 0xB1, 0xF9, + 0x82, 0x72, 0x11, 0x46, 0x48, 0x46, 0x0D, 0xF0, 0xAE, 0xFD, 0x83, 0x46, + 0x21, 0x46, 0x48, 0x46, + 0x0D, 0xF0, 0xB4, 0xFD, 0x00, 0x90, 0x39, 0x46, 0x58, 0x46, 0x0C, 0xF0, + 0x91, 0xFD, 0x0F, 0xFA, + 0x80, 0xFB, 0x39, 0x46, 0x00, 0x98, 0x0C, 0xF0, 0x8B, 0xFD, 0x00, 0xB2, + 0xAB, 0xEB, 0x00, 0x00, + 0x68, 0x43, 0x64, 0x21, 0x90, 0xFB, 0xF1, 0xF0, 0x38, 0x44, 0x05, 0xB2, + 0xA8, 0xF8, 0x08, 0x50, + 0x70, 0x1C, 0x00, 0x21, 0x03, 0x90, 0xC8, 0xF8, 0x00, 0x10, 0xC8, 0xF8, + 0x04, 0x10, 0xB9, 0xF9, + 0x00, 0x00, 0xA8, 0x42, 0x02, 0xDD, 0x03, 0x99, 0x01, 0x20, 0x08, 0x70, + 0x09, 0xEB, 0x44, 0x00, + 0x76, 0x1C, 0x30, 0xF9, 0x02, 0x2C, 0x31, 0x19, 0xAA, 0x42, 0x02, 0xDD, + 0x01, 0x22, 0x01, 0xF8, + 0x01, 0x2C, 0xB9, 0xF9, 0x02, 0x30, 0x03, 0xEB, 0x0A, 0x02, 0x12, 0xB2, + 0xAB, 0x42, 0x18, 0xDD, + 0xB9, 0xF9, 0x00, 0x30, 0x93, 0x42, 0x03, 0xDD, 0xB9, 0xF9, 0x04, 0x30, + 0x93, 0x42, 0x0A, 0xDC, + 0x03, 0x9B, 0x01, 0x22, 0x5A, 0x70, 0x0C, 0xE0, 0xB1, 0xF9, 0x69, 0xA2, + 0x91, 0xF8, 0x64, 0x52, + 0xB1, 0xF9, 0x65, 0x72, 0xAD, 0xE7, 0xD8, 0xF8, 0x00, 0x60, 0x46, 0xF0, + 0x02, 0x06, 0xC8, 0xF8, + 0x00, 0x60, 0x30, 0xF9, 0x04, 0x3C, 0xA4, 0xF1, 0x02, 0x0B, 0x03, 0xEB, + 0x0A, 0x02, 0x12, 0xB2, + 0xAB, 0x42, 0x16, 0xDD, 0x30, 0xF9, 0x06, 0x3C, 0x93, 0x42, 0x03, 0xDD, + 0x30, 0xF9, 0x02, 0x0C, + 0x90, 0x42, 0x03, 0xDC, 0x01, 0x20, 0x01, 0xF8, 0x02, 0x0C, 0x0A, 0xE0, + 0xD8, 0xE9, 0x00, 0x64, + 0x5A, 0x46, 0x01, 0x20, 0x00, 0x21, 0x10, 0xF0, 0x69, 0xFC, 0x06, 0x43, + 0x0C, 0x43, 0xC8, 0xE9, + 0x00, 0x64, 0x02, 0x24, 0x58, 0xE0, 0x00, 0xBF, 0x39, 0xF9, 0x14, 0x00, + 0xA8, 0x42, 0x52, 0xDD, + 0x09, 0xEB, 0x44, 0x01, 0x02, 0x91, 0x50, 0x44, 0x31, 0xF9, 0x02, 0x1C, + 0x00, 0xB2, 0x81, 0x42, + 0x04, 0xDD, 0x02, 0x9A, 0xB2, 0xF9, 0x02, 0x20, 0x82, 0x42, 0x10, 0xDC, + 0x02, 0x9A, 0x32, 0xF9, + 0x04, 0x2C, 0x82, 0x42, 0x04, 0xDD, 0x02, 0x9A, 0xB2, 0xF9, 0x02, 0x20, + 0x82, 0x42, 0x06, 0xDC, + 0x81, 0x42, 0x35, 0xDD, 0x02, 0x99, 0xB1, 0xF9, 0x04, 0x10, 0x81, 0x42, + 0x30, 0xDD, 0xD8, 0xE9, + 0x00, 0x67, 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x10, 0xF0, 0x38, 0xFC, + 0xCD, 0xE9, 0x00, 0x01, + 0x06, 0x43, 0x0F, 0x43, 0x62, 0x1E, 0x01, 0x20, 0x00, 0x21, 0xC8, 0xE9, + 0x00, 0x67, 0x10, 0xF0, + 0x2D, 0xFC, 0x02, 0x46, 0x0B, 0x46, 0x06, 0xEA, 0x02, 0x00, 0x07, 0xEA, + 0x03, 0x01, 0x08, 0x43, + 0x19, 0xD0, 0x02, 0x98, 0x39, 0xF9, 0x14, 0x10, 0x30, 0xF9, 0x02, 0x0C, + 0x81, 0x42, 0x09, 0xDA, + 0x96, 0x43, 0x9F, 0x43, 0xC8, 0xE9, 0x00, 0x67, 0x03, 0x99, 0x01, 0x20, + 0x21, 0x44, 0x01, 0xF8, + 0x01, 0x0C, 0x08, 0xE0, 0xDD, 0xE9, 0x00, 0x10, 0x8E, 0x43, 0x87, 0x43, + 0xC8, 0xE9, 0x00, 0x67, + 0x03, 0x99, 0x01, 0x20, 0x08, 0x55, 0x64, 0x1C, 0x5C, 0x45, 0xA5, 0xD3, + 0xBD, 0xE8, 0xFF, 0x9F, + 0x2D, 0xE9, 0xFF, 0x4F, 0x81, 0xB0, 0x82, 0x46, 0x00, 0x21, 0x1D, 0x46, + 0x19, 0x76, 0x06, 0x20, + 0x90, 0x46, 0xC3, 0x1F, 0x7A, 0x4C, 0x07, 0xE0, 0x00, 0x22, 0x29, 0x18, + 0x0A, 0x73, 0x8B, 0x74, + 0x05, 0xEB, 0x40, 0x01, 0x22, 0x88, 0x0A, 0x80, 0x40, 0x1E, 0xF5, 0xD2, + 0x72, 0x48, 0x01, 0x78, + 0x72, 0x48, 0x01, 0x29, 0x00, 0x68, 0x06, 0xD0, 0xB0, 0xF9, 0x84, 0x22, + 0x4F, 0xF0, 0x00, 0x0B, + 0x59, 0x46, 0x58, 0x46, 0x16, 0xE0, 0xB0, 0xF9, 0x67, 0x22, 0xF7, 0xE7, + 0x0A, 0xEB, 0x00, 0x03, + 0x5C, 0x78, 0x74, 0xB1, 0x1A, 0xF8, 0x00, 0x40, 0x0C, 0xB9, 0x49, 0x1C, + 0xC9, 0xB2, 0x59, 0x70, + 0x02, 0x9B, 0x33, 0xF9, 0x10, 0x30, 0x93, 0x42, 0x03, 0xDD, 0x01, 0x23, + 0x8B, 0x40, 0x43, 0xEA, + 0x0B, 0x0B, 0x40, 0x1C, 0x40, 0x45, 0xE9, 0xD3, 0x62, 0x48, 0x00, 0x90, + 0x0E, 0x98, 0x4F, 0xF0, + 0x00, 0x09, 0x4C, 0x46, 0xC0, 0xE9, 0x00, 0x99, 0x37, 0xE0, 0x00, 0xBF, + 0x0A, 0xEB, 0x04, 0x00, + 0x42, 0x78, 0x8A, 0xB3, 0x01, 0x21, 0x91, 0x40, 0x11, 0xEA, 0x0B, 0x0F, + 0x02, 0xD1, 0x00, 0x21, + 0x41, 0x70, 0x29, 0xE0, 0x1A, 0xF8, 0x04, 0x10, 0x39, 0xB9, 0x09, 0xF1, + 0x01, 0x01, 0x01, 0xF0, + 0xFF, 0x09, 0x54, 0x49, 0x00, 0x91, 0x05, 0xF8, 0x19, 0x40, 0x80, 0xF8, + 0x01, 0x90, 0x0E, 0x98, + 0x22, 0x46, 0x00, 0x21, 0xD0, 0xE9, 0x00, 0x67, 0x01, 0x20, 0x10, 0xF0, + 0x9F, 0xFB, 0x06, 0x43, + 0x0E, 0x98, 0x0F, 0x43, 0xC0, 0xE9, 0x00, 0x67, 0x05, 0xEB, 0x09, 0x00, + 0x01, 0x7B, 0x49, 0x1C, + 0x01, 0x73, 0x05, 0xEB, 0x49, 0x01, 0x4C, 0x70, 0x02, 0x99, 0x00, 0x9A, + 0x31, 0xF9, 0x14, 0x10, + 0x91, 0x42, 0x01, 0xDD, 0x00, 0x91, 0x84, 0x74, 0x64, 0x1C, 0x44, 0x45, + 0xC6, 0xD3, 0x85, 0xF8, + 0x18, 0x90, 0x05, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0x2D, 0xE9, 0xF8, 0x4F, + 0x0C, 0x46, 0x05, 0x46, + 0x1E, 0x46, 0x91, 0x46, 0x17, 0x21, 0x3C, 0x48, 0x10, 0xF0, 0x2E, 0xFC, + 0x28, 0x21, 0x3B, 0x48, + 0x10, 0xF0, 0x2A, 0xFC, 0xDF, 0xF8, 0xE8, 0xA0, 0x3A, 0x4F, 0x09, 0xF1, + 0x08, 0x08, 0x9A, 0xF8, + 0x00, 0x10, 0x76, 0xB1, 0x0A, 0x46, 0x05, 0xF1, 0x20, 0x03, 0x37, 0x49, + 0x32, 0x48, 0xFF, 0xF7, + 0x76, 0xFE, 0x04, 0xF1, 0x20, 0x03, 0x3A, 0x78, 0x34, 0x49, 0x30, 0x48, + 0xFF, 0xF7, 0x6F, 0xFE, + 0x11, 0xE0, 0x4A, 0x46, 0x2C, 0x48, 0x00, 0xF0, 0x3D, 0xFA, 0x42, 0x46, + 0x39, 0x78, 0x2B, 0x48, + 0x00, 0xF0, 0x38, 0xFA, 0x00, 0x20, 0xC5, 0xE9, 0x08, 0x00, 0xC4, 0xE9, + 0x08, 0x00, 0x2C, 0x48, + 0x00, 0x88, 0x28, 0x85, 0x20, 0x85, 0x2B, 0x4E, 0x28, 0x8D, 0x2B, 0x46, + 0x26, 0xF8, 0x11, 0x0F, + 0x20, 0x8D, 0x70, 0x80, 0xCD, 0xF8, 0x00, 0x90, 0x9A, 0xF8, 0x00, 0x20, + 0x22, 0x49, 0x1E, 0x48, + 0xFF, 0xF7, 0x36, 0xFF, 0xCD, 0xF8, 0x00, 0x80, 0x23, 0x46, 0x3A, 0x78, + 0x1F, 0x49, 0x1B, 0x48, + 0xFF, 0xF7, 0x2E, 0xFF, 0x29, 0x7E, 0x30, 0x79, 0x61, 0xF3, 0x03, 0x00, + 0x30, 0x71, 0x21, 0x7E, + 0x61, 0xF3, 0x07, 0x10, 0x30, 0x71, 0xBD, 0xE8, 0xF8, 0x8F, 0x2D, 0xE9, + 0xFF, 0x4F, 0x15, 0x46, + 0x04, 0x46, 0xD1, 0xE9, 0x02, 0x70, 0xD1, 0xE9, 0x00, 0x92, 0x80, 0x46, + 0x81, 0xB0, 0x92, 0x46, + 0x4F, 0xF4, 0x66, 0x71, 0x28, 0x46, 0x10, 0xF0, 0xCF, 0xFB, 0x00, 0x20, + 0x01, 0x46, 0x00, 0x90, + 0x0E, 0x98, 0x01, 0x60, 0x00, 0x21, 0x28, 0x46, 0x10, 0xF0, 0xD8, 0xFC, + 0x83, 0x46, 0x1B, 0xE0, + 0x18, 0x2A, 0x10, 0x00, 0x58, 0x05, 0x10, 0x00, 0x66, 0x05, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xFC, 0x78, 0x01, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0x0A, 0x0C, 0x01, 0x20, + 0x21, 0x0C, 0x01, 0x20, + 0xED, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0x94, 0x0B, 0x01, 0x20, + 0xBE, 0x0B, 0x01, 0x20, + 0x68, 0x05, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0x00, 0x21, 0x20, 0x46, + 0x10, 0xF0, 0xAE, 0xFC, + 0x06, 0x46, 0x00, 0x25, 0x34, 0xE0, 0x2A, 0x46, 0x01, 0x20, 0x00, 0x21, + 0x10, 0xF0, 0xE6, 0xFA, + 0x00, 0xEA, 0x09, 0x00, 0x01, 0xEA, 0x0A, 0x01, 0x08, 0x43, 0x22, 0xD0, + 0x00, 0x24, 0x1C, 0xE0, + 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x10, 0xF0, 0xD9, 0xFA, 0x38, 0x40, + 0x01, 0xEA, 0x08, 0x01, + 0x08, 0x43, 0x11, 0xD0, 0x36, 0xF9, 0x14, 0x10, 0x04, 0x98, 0x81, 0x42, + 0x0C, 0xDD, 0x01, 0x20, + 0x0B, 0xF8, 0x04, 0x00, 0x00, 0x98, 0x40, 0x1C, 0x00, 0x90, 0x0E, 0x98, + 0x36, 0xF9, 0x14, 0x10, + 0x00, 0x68, 0x01, 0x44, 0x0E, 0x98, 0x01, 0x60, 0x64, 0x1C, 0xFE, 0x48, + 0x00, 0x78, 0x84, 0x42, + 0xDE, 0xDB, 0xFC, 0x48, 0x0B, 0xF1, 0x28, 0x0B, 0x6D, 0x1C, 0x00, 0x78, + 0x06, 0xEB, 0x40, 0x06, + 0xF9, 0x48, 0x00, 0x78, 0x85, 0x42, 0xC6, 0xDB, 0x00, 0x98, 0x2A, 0xE7, + 0x2D, 0xE9, 0xF0, 0x47, + 0x0F, 0x46, 0x1C, 0x46, 0x16, 0x46, 0x99, 0x78, 0x10, 0xF0, 0x62, 0xFC, + 0x05, 0x46, 0xA1, 0x78, + 0x38, 0x46, 0x10, 0xF0, 0x63, 0xFC, 0x02, 0x46, 0xEE, 0x48, 0x00, 0x23, + 0xA1, 0x78, 0x90, 0xF8, + 0x00, 0x90, 0x94, 0xF8, 0x03, 0xC0, 0x13, 0xE0, 0x20, 0x78, 0x67, 0x78, + 0x09, 0xE0, 0x00, 0xBF, + 0x15, 0xF8, 0x00, 0x80, 0xB0, 0x45, 0x02, 0xD1, 0x32, 0xF9, 0x10, 0x80, + 0x43, 0x44, 0x40, 0x1C, + 0xC0, 0xB2, 0x87, 0x42, 0xF4, 0xD2, 0x49, 0x1C, 0x02, 0xEB, 0x49, 0x02, + 0xC9, 0xB2, 0x28, 0x35, + 0x8C, 0x45, 0xE9, 0xD2, 0x18, 0x46, 0xBD, 0xE8, 0xF0, 0x87, 0x2D, 0xE9, + 0xF0, 0x4F, 0xDF, 0x48, + 0x87, 0xB0, 0xDF, 0xF8, 0x80, 0x83, 0x06, 0x68, 0x00, 0x20, 0x06, 0xF5, + 0x88, 0x74, 0x86, 0xF8, + 0x0E, 0x01, 0xDB, 0x48, 0x01, 0x23, 0x00, 0x22, 0x00, 0x68, 0x30, 0x60, + 0x31, 0x46, 0xD8, 0xF8, + 0x00, 0x00, 0x08, 0xF0, 0x85, 0xF8, 0xDF, 0xF8, 0x60, 0xA3, 0xDF, 0xF8, + 0x60, 0x93, 0x4F, 0xF0, + 0xFF, 0x37, 0x9A, 0xF8, 0x00, 0x00, 0x01, 0x28, 0x10, 0xD1, 0xD5, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x51, 0x02, 0xC0, 0x07, 0x01, 0xD0, 0x02, 0x23, 0x00, 0xE0, 0x01, 0x23, + 0x32, 0x46, 0xD9, 0xF8, + 0x00, 0x10, 0xD8, 0xF8, 0x00, 0x00, 0x00, 0xF0, 0x4D, 0xF9, 0x07, 0x46, + 0xCD, 0x49, 0x96, 0xF8, + 0x0E, 0x01, 0x48, 0x71, 0x00, 0x20, 0x01, 0x25, 0x05, 0x90, 0x51, 0xE0, + 0x01, 0x20, 0xA8, 0x40, + 0x38, 0x42, 0x4C, 0xD0, 0x06, 0xEB, 0x85, 0x00, 0x03, 0x90, 0x06, 0xEB, + 0x45, 0x00, 0x48, 0x21, + 0xB0, 0xF8, 0xB4, 0xB0, 0x20, 0x46, 0x10, 0xF0, 0x11, 0xFB, 0x03, 0x20, + 0x84, 0xF8, 0x40, 0x00, + 0xD9, 0xF8, 0x00, 0x00, 0x60, 0x60, 0xA0, 0x60, 0x84, 0xF8, 0x42, 0x50, + 0xA4, 0xF8, 0x2A, 0xB0, + 0xA4, 0xF8, 0x26, 0xB0, 0xE9, 0xB2, 0x23, 0x46, 0x03, 0x9A, 0xD8, 0xF8, + 0x00, 0x00, 0x07, 0xF0, + 0x40, 0xF8, 0x9A, 0xF8, 0x00, 0x00, 0x02, 0x28, 0x10, 0xD1, 0xB7, 0x48, + 0x04, 0xA9, 0xEA, 0xB2, + 0xB0, 0xF9, 0x00, 0x00, 0x02, 0x94, 0xCD, 0xE9, 0x00, 0x10, 0xD8, 0xF8, + 0x00, 0x10, 0x03, 0x9B, + 0x08, 0x46, 0x07, 0xF0, 0x68, 0xF8, 0xDD, 0xE9, 0x03, 0x01, 0x01, 0x60, + 0xE0, 0x8C, 0xB0, 0xB1, + 0xAD, 0x48, 0xB4, 0xF9, 0x32, 0x10, 0xB0, 0xF9, 0x00, 0x00, 0x81, 0x42, + 0x0F, 0xDD, 0x01, 0x20, + 0x05, 0x90, 0xE9, 0xB2, 0x23, 0x46, 0x03, 0x9A, 0xD8, 0xF8, 0x00, 0x00, + 0x08, 0xF0, 0x4A, 0xFA, + 0xE9, 0xB2, 0x23, 0x46, 0x03, 0x9A, 0xD8, 0xF8, 0x00, 0x00, 0x06, 0xF0, + 0x91, 0xFF, 0x6D, 0x1C, + 0x96, 0xF8, 0x0E, 0x01, 0xA8, 0x42, 0xA9, 0xD2, 0x05, 0x98, 0x07, 0xB0, + 0x6A, 0xE6, 0x9F, 0x49, + 0x10, 0xB5, 0x09, 0x78, 0x00, 0x20, 0x11, 0xB1, 0xFF, 0xF7, 0x67, 0xFF, + 0x04, 0xE0, 0x9C, 0x49, + 0x09, 0x7A, 0x09, 0xB1, 0xFF, 0xF7, 0xBC, 0xFA, 0x9A, 0x4A, 0x00, 0x21, + 0x11, 0x70, 0x9A, 0x4A, + 0x10, 0x70, 0x9A, 0x48, 0x01, 0x70, 0x10, 0xBD, 0x10, 0xB5, 0x91, 0x4C, + 0x20, 0x68, 0x90, 0xF8, + 0x30, 0x12, 0x09, 0x07, 0x1C, 0xD5, 0x96, 0x49, 0x09, 0x78, 0x11, 0xF0, + 0x30, 0x0F, 0x17, 0xD0, + 0xB0, 0xF9, 0x44, 0x12, 0x01, 0x22, 0x93, 0x48, 0x00, 0xF0, 0xEB, 0xFA, + 0x20, 0x68, 0x01, 0x22, + 0xB0, 0xF9, 0x46, 0x12, 0x8F, 0x48, 0x10, 0x30, 0x00, 0xF0, 0xE3, 0xFA, + 0x20, 0x68, 0x01, 0x22, + 0xB0, 0xF9, 0x42, 0x12, 0x8B, 0x48, 0xBD, 0xE8, 0x10, 0x40, 0x10, 0x38, + 0x00, 0xF0, 0xD9, 0xBA, + 0x88, 0x48, 0x4F, 0xF0, 0xFF, 0x31, 0xC0, 0xE9, 0x00, 0x11, 0xC0, 0xE9, + 0x02, 0x11, 0x10, 0x38, + 0xC0, 0xE9, 0x00, 0x11, 0xC0, 0xE9, 0x02, 0x11, 0x20, 0x30, 0xC0, 0xE9, + 0x00, 0x11, 0xC0, 0xE9, + 0x02, 0x11, 0x10, 0xBD, 0x2D, 0xE9, 0xFF, 0x5F, 0x15, 0x46, 0x03, 0x99, + 0x91, 0xF8, 0x40, 0x10, + 0x02, 0x29, 0x0C, 0xD0, 0x01, 0x29, 0x0C, 0xD0, 0x7A, 0x49, 0x10, 0x39, + 0x8A, 0x46, 0x4F, 0xF0, + 0x00, 0x0B, 0xA9, 0x78, 0x10, 0xF0, 0x5A, 0xFB, 0x81, 0x46, 0xA8, 0x78, + 0x2A, 0xE0, 0x75, 0x49, + 0xF4, 0xE7, 0x74, 0x49, 0x10, 0x31, 0xF1, 0xE7, 0x2C, 0x78, 0x1C, 0xE0, + 0x19, 0xF8, 0x04, 0x10, + 0x01, 0x98, 0x81, 0x42, 0x16, 0xD1, 0x01, 0x22, 0xDA, 0xF8, 0x00, 0x00, + 0x02, 0xFA, 0x08, 0xF2, + 0x10, 0x40, 0x00, 0x00, 0x24, 0xD0, 0xDA, 0xE9, 0x02, 0x76, 0x22, 0x46, + 0x01, 0x20, 0x00, 0x21, + 0x10, 0xF0, 0x74, 0xF9, 0x07, 0x40, 0x0E, 0x40, 0x37, 0x43, 0x19, 0xD0, + 0x0B, 0xF1, 0x01, 0x00, + 0x1F, 0xFA, 0x80, 0xFB, 0x64, 0x1C, 0x68, 0x78, 0xA0, 0x42, 0xDF, 0xDA, + 0x09, 0xF1, 0x28, 0x09, + 0x08, 0xF1, 0x01, 0x00, 0xE9, 0x78, 0x80, 0x46, 0x41, 0x45, 0xD5, 0xDA, + 0x03, 0x99, 0x5F, 0xEA, + 0x0B, 0x00, 0xA1, 0xF8, 0x26, 0xB0, 0x00, 0xD0, 0x01, 0x20, 0x04, 0xB0, + 0xBD, 0xE8, 0xF0, 0x9F, + 0x00, 0x21, 0x09, 0xF8, 0x04, 0x10, 0xE5, 0xE7, 0x2D, 0xE9, 0xF8, 0x4F, + 0x80, 0x46, 0x4F, 0xF0, + 0x00, 0x0B, 0x87, 0x78, 0x90, 0xF8, 0x03, 0xA0, 0x23, 0xE0, 0x00, 0xBF, + 0x52, 0x49, 0x01, 0x22, + 0xBA, 0x40, 0x08, 0x68, 0x98, 0xF8, 0x00, 0x40, 0x10, 0x40, 0x00, 0x90, + 0xD1, 0xE9, 0x02, 0x56, + 0x98, 0xF8, 0x01, 0x90, 0x12, 0xE0, 0x00, 0x99, 0x09, 0x00, 0x0E, 0xD0, + 0x22, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x10, 0xF0, 0x33, 0xF9, 0x05, 0xEA, 0x00, 0x02, 0x06, 0xEA, + 0x01, 0x00, 0x02, 0x43, + 0x03, 0xD0, 0x0B, 0xF1, 0x01, 0x00, 0x1F, 0xFA, 0x80, 0xFB, 0x64, 0x1C, + 0xA1, 0x45, 0xEA, 0xDA, + 0x7F, 0x1C, 0xBA, 0x45, 0xDA, 0xDA, 0xBB, 0xF1, 0x00, 0x0F, 0x01, 0xD0, + 0x01, 0x20, 0xF2, 0xE5, + 0x00, 0x20, 0xF0, 0xE5, 0x2D, 0xE9, 0xF0, 0x47, 0x91, 0x46, 0x45, 0x1C, + 0x0C, 0x46, 0x4F, 0xF0, + 0x01, 0x08, 0x0C, 0xE0, 0xD9, 0xE9, 0x00, 0x67, 0x22, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x10, 0xF0, + 0x0D, 0xF9, 0x06, 0x40, 0x0F, 0x40, 0x3E, 0x43, 0x01, 0xD0, 0x05, 0xF8, + 0x04, 0x80, 0x64, 0x1E, + 0xF0, 0xD2, 0x80, 0xE6, 0x2D, 0xE9, 0xF0, 0x47, 0x92, 0xF8, 0x0E, 0x41, + 0x86, 0xB0, 0x1D, 0x46, + 0x17, 0x46, 0x89, 0x46, 0x82, 0x46, 0xE8, 0x46, 0x05, 0x2C, 0x02, 0xD9, + 0x05, 0x24, 0x01, 0x26, + 0x01, 0xE0, 0x01, 0x26, 0x0C, 0xE0, 0x07, 0xEB, 0x86, 0x03, 0x32, 0x46, + 0x49, 0x46, 0x50, 0x46, + 0xFF, 0xF7, 0x3C, 0xFE, 0x08, 0xEB, 0x86, 0x01, 0x76, 0x1C, 0x41, 0xF8, + 0x04, 0x0C, 0xF6, 0xB2, + 0xA6, 0x42, 0xF0, 0xD9, 0x00, 0x20, 0x03, 0x46, 0x01, 0x22, 0x40, 0xE0, + 0x00, 0x27, 0x4F, 0xF0, + 0x00, 0x46, 0x01, 0x21, 0x0F, 0xE0, 0x00, 0xBF, 0x02, 0xFA, 0x01, 0xFC, + 0x1C, 0xEA, 0x00, 0x0F, + 0x07, 0xD1, 0x08, 0xEB, 0x81, 0x0C, 0x5C, 0xF8, 0x04, 0xCC, 0xB4, 0x45, + 0x01, 0xDD, 0x66, 0x46, + 0x0F, 0x46, 0x49, 0x1C, 0xC9, 0xB2, 0xA1, 0x42, 0xEE, 0xD9, 0x02, 0xFA, + 0x07, 0xF1, 0x08, 0x43, + 0x5B, 0x1C, 0x23, 0xE0, 0xEE, 0x06, 0x10, 0x00, 0xED, 0x06, 0x10, 0x00, + 0x58, 0x05, 0x10, 0x00, + 0x88, 0x06, 0x10, 0x00, 0x50, 0x06, 0x10, 0x00, 0x66, 0x05, 0x10, 0x00, + 0x14, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0x92, 0x06, 0x10, 0x00, + 0x57, 0x05, 0x10, 0x00, + 0x0C, 0x2A, 0x10, 0x00, 0xF6, 0x06, 0x10, 0x00, 0xF7, 0x06, 0x10, 0x00, + 0xF8, 0x06, 0x10, 0x00, + 0x04, 0x07, 0x10, 0x00, 0xA8, 0x2A, 0x10, 0x00, 0x50, 0x2B, 0x10, 0x00, + 0xDB, 0xB2, 0xAB, 0x42, + 0xBC, 0xD3, 0x06, 0xB0, 0x17, 0xE6, 0x00, 0x00, 0xA1, 0x4A, 0x10, 0xB5, + 0x13, 0x68, 0x00, 0x21, + 0xB3, 0xF8, 0x14, 0x22, 0x82, 0x42, 0x05, 0xDA, 0x93, 0xF8, 0x10, 0x22, + 0x52, 0x07, 0x01, 0xD5, + 0x02, 0x21, 0x08, 0xE0, 0xB3, 0xF8, 0x12, 0x22, 0x82, 0x42, 0x04, 0xDA, + 0x93, 0xF8, 0x10, 0x02, + 0x80, 0x07, 0x00, 0xD5, 0x01, 0x21, 0x97, 0x48, 0x97, 0x4C, 0x42, 0x78, + 0x91, 0x42, 0x14, 0xD1, + 0xA1, 0x78, 0x91, 0x42, 0x0D, 0xD0, 0x95, 0x4B, 0x1B, 0x78, 0x1A, 0x43, + 0x94, 0x4B, 0x1B, 0x78, + 0x1A, 0x43, 0x07, 0xD0, 0x41, 0x68, 0x49, 0x1E, 0x41, 0x60, 0x00, 0x29, + 0x01, 0xDC, 0x40, 0x78, + 0xA0, 0x70, 0x10, 0xBD, 0x41, 0x70, 0x41, 0x68, 0xF7, 0xE7, 0x59, 0xB1, + 0x02, 0x29, 0x01, 0xD1, + 0x01, 0x2A, 0x07, 0xD0, 0x93, 0xF8, 0x18, 0x22, 0x42, 0x60, 0x41, 0x70, + 0x00, 0x2A, 0xF0, 0xDC, + 0xA1, 0x70, 0x10, 0xBD, 0x93, 0xF8, 0x19, 0x22, 0xF6, 0xE7, 0x70, 0xB5, + 0x85, 0x4A, 0x86, 0x4B, + 0x81, 0x4D, 0x16, 0x78, 0x7E, 0x4A, 0x1C, 0x78, 0x00, 0x21, 0x12, 0x68, + 0xAB, 0x78, 0x01, 0x2E, + 0x02, 0xD1, 0x82, 0x4E, 0x36, 0x78, 0x4E, 0xB1, 0xB2, 0xF8, 0x14, 0x62, + 0x86, 0x42, 0x17, 0xDA, + 0x92, 0xF8, 0x10, 0x62, 0x76, 0x07, 0x13, 0xD5, 0x02, 0x21, 0x25, 0xE0, + 0xB2, 0xF8, 0x1C, 0x62, + 0x86, 0x42, 0x03, 0xDA, 0x92, 0xF8, 0x10, 0x62, 0x76, 0x07, 0xF5, 0xD4, + 0xB2, 0xF8, 0x1A, 0x62, + 0x08, 0xE0, 0x00, 0xBF, 0x92, 0xF8, 0x10, 0x02, 0x80, 0x07, 0x05, 0xD5, + 0x01, 0x21, 0x13, 0xE0, + 0xB2, 0xF8, 0x12, 0x62, 0x86, 0x42, 0xF5, 0xDB, 0x73, 0xB1, 0x6C, 0x48, + 0x00, 0x78, 0x01, 0x28, + 0x03, 0xD0, 0x6B, 0x48, 0x00, 0x78, 0x01, 0x28, 0x03, 0xD1, 0x92, 0xF8, + 0x10, 0x02, 0x00, 0x07, + 0x01, 0xD5, 0x01, 0x2C, 0x00, 0xD1, 0x19, 0x46, 0x62, 0x48, 0x34, 0xB1, + 0x19, 0xB1, 0x00, 0xBF, + 0x92, 0xF8, 0x19, 0x22, 0x42, 0x60, 0xA9, 0x70, 0x70, 0xBD, 0x00, 0x29, + 0xF8, 0xD1, 0x00, 0x2B, + 0xF6, 0xD0, 0x44, 0x68, 0x00, 0x2C, 0xF6, 0xDD, 0x92, 0xF8, 0x10, 0x12, + 0x0A, 0x07, 0x59, 0x49, + 0x49, 0x68, 0xA1, 0xF1, 0x01, 0x01, 0x02, 0xD5, 0x5D, 0x4A, 0x12, 0x78, + 0x02, 0xB1, 0x41, 0x60, + 0x19, 0x46, 0xE8, 0xE7, 0x52, 0x48, 0x53, 0x49, 0x00, 0x68, 0x90, 0xF8, + 0x10, 0x02, 0xC2, 0x06, + 0x4F, 0xF0, 0x00, 0x00, 0x03, 0xD4, 0x50, 0x4A, 0x90, 0x70, 0x48, 0x70, + 0x48, 0x60, 0x08, 0x70, + 0x70, 0x47, 0x10, 0xB5, 0x04, 0x46, 0x4A, 0x48, 0x00, 0x68, 0x90, 0xF8, + 0x10, 0x02, 0xC0, 0x06, + 0x20, 0x46, 0x02, 0xD5, 0xFF, 0xF7, 0x89, 0xFF, 0x01, 0xE0, 0xFF, 0xF7, + 0x45, 0xFF, 0x46, 0x48, + 0x82, 0x78, 0x4C, 0x48, 0x41, 0x7B, 0x62, 0xF3, 0x07, 0x11, 0x41, 0x73, + 0xA0, 0xF8, 0x2F, 0x40, + 0x10, 0xBD, 0x2D, 0xE9, 0xFC, 0x5F, 0x83, 0x46, 0x47, 0x48, 0x00, 0x25, + 0x0A, 0x46, 0x00, 0x78, + 0x2F, 0x46, 0x2C, 0x46, 0x01, 0x28, 0x00, 0xD1, 0x01, 0x24, 0x44, 0x48, + 0x06, 0x78, 0x00, 0x78, + 0x41, 0x00, 0x01, 0x2A, 0x1B, 0xD0, 0xDF, 0xF8, 0xD8, 0x80, 0xDF, 0xF8, + 0x04, 0xA1, 0xDF, 0xF8, + 0x04, 0x91, 0xD8, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x10, 0x22, 0x92, 0x06, + 0x14, 0xD5, 0x32, 0x1B, + 0xB0, 0xF9, 0x20, 0x12, 0xCD, 0xE9, 0x00, 0x12, 0xB0, 0xF9, 0x1E, 0x32, + 0x0A, 0xEB, 0x44, 0x02, + 0x0B, 0xEB, 0x44, 0x01, 0x09, 0xEB, 0x44, 0x00, 0x0C, 0xF0, 0x72, 0xFF, + 0x09, 0xE0, 0x34, 0x48, + 0x4C, 0x38, 0x10, 0xF0, 0x59, 0xF8, 0x41, 0xE0, 0x0A, 0x46, 0x59, 0x46, + 0x31, 0x48, 0x0F, 0xF0, + 0xD4, 0xFF, 0x2F, 0x48, 0x4C, 0x38, 0x34, 0xE0, 0x3A, 0xF9, 0x14, 0x20, + 0x39, 0xF9, 0x14, 0x10, + 0x51, 0x1A, 0x00, 0xD5, 0x49, 0x42, 0xD8, 0xF8, 0x00, 0x30, 0x09, 0xB2, + 0x93, 0xF8, 0x10, 0x22, + 0x52, 0x06, 0x0B, 0xD5, 0x20, 0x4A, 0x12, 0x78, 0x01, 0x2A, 0x07, 0xD1, + 0x26, 0x4A, 0x12, 0x78, + 0x22, 0xB9, 0xB3, 0xF8, 0x22, 0x22, 0x8A, 0x42, 0x00, 0xDA, 0x01, 0x27, + 0x30, 0xF9, 0x14, 0x20, + 0x8A, 0x42, 0x02, 0xDA, 0x93, 0xF8, 0x16, 0x32, 0x01, 0xE0, 0x93, 0xF8, + 0x17, 0x32, 0x5A, 0x43, + 0xC3, 0xF5, 0x80, 0x73, 0x01, 0xFB, 0x03, 0x21, 0xCA, 0x17, 0x01, 0xEB, + 0x12, 0x61, 0x09, 0x12, + 0x20, 0xF8, 0x14, 0x10, 0x30, 0xF9, 0x14, 0x10, 0xA9, 0x42, 0x00, 0xDD, + 0x0D, 0x46, 0x64, 0x1C, + 0x24, 0xB2, 0xB4, 0x42, 0xC8, 0xDB, 0x28, 0x46, 0xFF, 0xF7, 0x73, 0xFF, + 0x72, 0x00, 0x59, 0x46, + 0x0F, 0x48, 0x0F, 0xF0, 0x92, 0xFF, 0x03, 0x48, 0x07, 0x70, 0xBD, 0xE8, + 0xFC, 0x9F, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x5C, 0x05, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, + 0xF5, 0x06, 0x10, 0x00, + 0x64, 0x05, 0x10, 0x00, 0xF6, 0x06, 0x10, 0x00, 0xFD, 0x06, 0x10, 0x00, + 0xF7, 0x06, 0x10, 0x00, + 0xFA, 0x06, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0xF4, 0x06, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0x54, 0x0A, 0x01, 0x20, 0xA0, 0x0A, 0x01, 0x20, 0x74, 0x05, 0x10, 0x00, + 0x2D, 0xE9, 0xF0, 0x4F, + 0x81, 0x46, 0xDD, 0xE9, 0x09, 0xB5, 0x01, 0x20, 0x47, 0xF6, 0xFF, 0x77, + 0x9A, 0x46, 0x84, 0x46, + 0xFE, 0x43, 0x2C, 0x46, 0x15, 0xE0, 0x00, 0xBF, 0x32, 0xF8, 0x14, 0x30, + 0x31, 0xF8, 0x14, 0x80, + 0xA3, 0xEB, 0x08, 0x03, 0x1B, 0xB2, 0xBB, 0x42, 0x00, 0xDA, 0x1F, 0x46, + 0xB3, 0x42, 0x00, 0xDD, + 0x1E, 0x46, 0x00, 0x2B, 0x02, 0xDD, 0x4F, 0xF0, 0x00, 0x0C, 0x02, 0xE0, + 0x01, 0xDA, 0x4F, 0xF0, + 0x00, 0x00, 0x64, 0x1E, 0xE8, 0xD2, 0x20, 0xB1, 0xBC, 0xF1, 0x00, 0x0F, + 0x01, 0xD0, 0x00, 0x23, + 0x09, 0xE0, 0x50, 0xEA, 0x0C, 0x03, 0x06, 0xD0, 0x20, 0xB9, 0xBC, 0xF1, + 0x00, 0x0F, 0x01, 0xD0, + 0x33, 0x46, 0x00, 0xE0, 0x3B, 0x46, 0x00, 0x27, 0x3C, 0x46, 0x28, 0x46, + 0xCB, 0xF1, 0x00, 0x0C, + 0x0E, 0xE0, 0x00, 0xBF, 0x32, 0xF8, 0x10, 0x60, 0x31, 0xF8, 0x10, 0x80, + 0xA6, 0xEB, 0x08, 0x06, + 0xF6, 0x1A, 0x36, 0xB2, 0x56, 0x45, 0x03, 0xDA, 0x66, 0x45, 0x01, 0xDD, + 0x37, 0x44, 0x64, 0x1C, + 0x40, 0x1E, 0xEF, 0xD2, 0x04, 0xB9, 0x01, 0x24, 0x97, 0xFB, 0xF4, 0xF0, + 0x18, 0x44, 0x04, 0xE0, + 0x31, 0xF8, 0x15, 0x20, 0x02, 0x44, 0x29, 0xF8, 0x15, 0x20, 0x6D, 0x1E, + 0xF8, 0xD2, 0xBD, 0xE8, + 0xF0, 0x8F, 0x2D, 0xE9, 0xF0, 0x41, 0x04, 0x46, 0x03, 0x46, 0xFC, 0x48, + 0x15, 0x46, 0x0E, 0x46, + 0x0A, 0x46, 0x01, 0x78, 0xFA, 0x48, 0x00, 0xF0, 0x51, 0xFA, 0xFA, 0x48, + 0x04, 0xF1, 0x08, 0x03, + 0x1F, 0x46, 0x01, 0x78, 0xF6, 0x48, 0x32, 0x46, 0x2A, 0x30, 0x00, 0xF0, + 0x47, 0xFA, 0x00, 0x2D, + 0x07, 0xD0, 0x20, 0x46, 0x10, 0xF0, 0x6C, 0xF8, 0x38, 0x46, 0xBD, 0xE8, + 0xF0, 0x41, 0x10, 0xF0, + 0x67, 0xB8, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xFC, 0x41, 0x07, 0x46, + 0x14, 0x46, 0x88, 0x46, + 0x03, 0x20, 0xF9, 0xF7, 0xD6, 0xF9, 0xEC, 0x4D, 0xE8, 0x4E, 0x00, 0x94, + 0xE8, 0x48, 0x32, 0x78, + 0x39, 0x46, 0x76, 0x38, 0x2B, 0x68, 0x0C, 0xF0, 0xF9, 0xFE, 0x00, 0x94, + 0xE5, 0x4C, 0xE4, 0x48, + 0x41, 0x46, 0x22, 0x78, 0x4C, 0x38, 0x2B, 0x68, 0x0C, 0xF0, 0xF0, 0xFE, + 0xE3, 0x4D, 0x28, 0x68, + 0x90, 0xF8, 0x30, 0x12, 0xC9, 0x07, 0x1A, 0xD0, 0x32, 0x78, 0xB0, 0xF9, + 0x34, 0x12, 0xCD, 0xE9, + 0x00, 0x12, 0xDB, 0x49, 0xB0, 0xF9, 0x32, 0x32, 0x76, 0x39, 0xDD, 0x4A, + 0x08, 0x46, 0xFF, 0xF7, + 0x55, 0xFF, 0x28, 0x68, 0x22, 0x78, 0xB0, 0xF9, 0x38, 0x12, 0xCD, 0xE9, + 0x00, 0x12, 0xD4, 0x49, + 0xB0, 0xF9, 0x36, 0x32, 0x4C, 0x39, 0xD7, 0x4A, 0x08, 0x46, 0xFF, 0xF7, + 0x47, 0xFF, 0xD0, 0x49, + 0x33, 0x78, 0xD3, 0x4A, 0x76, 0x39, 0xCE, 0x48, 0x0C, 0xF0, 0xBB, 0xFE, + 0xCC, 0x49, 0x23, 0x78, + 0x4C, 0x39, 0xD0, 0x4A, 0x01, 0xF1, 0x76, 0x00, 0x0C, 0xF0, 0xB3, 0xFE, + 0x28, 0x68, 0x90, 0xF8, + 0x30, 0x12, 0x8A, 0x07, 0x04, 0xD4, 0xCC, 0x4A, 0x12, 0x78, 0x8A, 0xB1, + 0x49, 0x07, 0x0F, 0xD5, + 0xC3, 0x49, 0x90, 0xF8, 0x41, 0x32, 0x32, 0x78, 0x08, 0x46, 0x0C, 0xF0, + 0xE2, 0xFE, 0x28, 0x68, + 0xBF, 0x49, 0x22, 0x78, 0x90, 0xF8, 0x41, 0x32, 0x2A, 0x31, 0x08, 0x46, + 0x0C, 0xF0, 0xD9, 0xFE, + 0xBD, 0xE8, 0xFC, 0x41, 0x03, 0x20, 0xF9, 0xF7, 0x8F, 0xB9, 0x70, 0xB5, + 0xBF, 0x4C, 0xC0, 0x49, + 0x00, 0x25, 0xA5, 0x70, 0x01, 0x20, 0x08, 0x70, 0xB8, 0x48, 0x25, 0x70, + 0x65, 0x70, 0x00, 0x68, + 0xB0, 0xF8, 0x3A, 0x02, 0xA0, 0x80, 0x00, 0xF0, 0xE3, 0xF9, 0xFF, 0xF7, + 0xEE, 0xF8, 0xA5, 0x60, + 0xE5, 0x60, 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x0E, 0x46, 0xB5, 0x49, + 0x07, 0x46, 0xB3, 0x4C, + 0x0D, 0x78, 0x00, 0x20, 0x08, 0x70, 0x60, 0x70, 0x00, 0xF0, 0xD2, 0xF9, + 0xB1, 0x48, 0x2A, 0x46, + 0x31, 0x46, 0x00, 0x78, 0x00, 0x28, 0x38, 0x46, 0x02, 0xD0, 0xFF, 0xF7, + 0x45, 0xF8, 0x01, 0xE0, + 0xFF, 0xF7, 0x69, 0xFF, 0xAC, 0x48, 0x41, 0x78, 0xA4, 0x48, 0xA9, 0xB1, + 0xA1, 0x78, 0x01, 0x29, + 0x12, 0xD0, 0x00, 0x68, 0xB0, 0xF9, 0x3C, 0x12, 0xA8, 0x4D, 0xA1, 0x80, + 0x01, 0x22, 0x28, 0x46, + 0xFF, 0xF7, 0x37, 0xFF, 0xD5, 0xE9, 0x00, 0x01, 0x08, 0x43, 0x09, 0xD0, + 0xD5, 0xE9, 0x02, 0x01, + 0x08, 0x43, 0x05, 0xD0, 0x01, 0x20, 0x04, 0xE0, 0x00, 0x68, 0xB0, 0xF9, + 0x3A, 0x12, 0xEB, 0xE7, + 0x00, 0x20, 0x20, 0x70, 0x45, 0xE7, 0x2D, 0xE9, 0xF0, 0x4F, 0x04, 0x46, + 0x9C, 0x48, 0xA7, 0xB0, + 0x4F, 0xF0, 0x01, 0x09, 0x01, 0x78, 0x91, 0x48, 0x01, 0x29, 0x00, 0x68, + 0x15, 0xD0, 0x92, 0x49, + 0x09, 0x78, 0xA9, 0xB1, 0xB0, 0xF9, 0x54, 0x62, 0x88, 0x48, 0x00, 0x21, + 0x4F, 0xF0, 0x01, 0x0A, + 0x00, 0x78, 0x94, 0x4D, 0x40, 0x1E, 0x00, 0xF0, 0xFF, 0x08, 0x86, 0x48, + 0x83, 0x46, 0x03, 0x78, + 0x9A, 0x1E, 0x02, 0xF0, 0xFF, 0x0C, 0x22, 0x46, 0x13, 0xE0, 0xB0, 0xF9, + 0x59, 0x62, 0xEB, 0xE7, + 0xB0, 0xF9, 0x52, 0x62, 0xE8, 0xE7, 0x50, 0x46, 0x06, 0xE0, 0x00, 0xBF, + 0x32, 0xF9, 0x10, 0x70, + 0xAF, 0x42, 0x00, 0xDD, 0x3D, 0x46, 0x40, 0x1C, 0x60, 0x45, 0xF7, 0xDD, + 0x02, 0xEB, 0x43, 0x02, + 0x49, 0x1C, 0x41, 0x45, 0xEF, 0xDD, 0x5F, 0x46, 0x5A, 0x00, 0x04, 0xEB, + 0x43, 0x01, 0x68, 0x46, + 0x0F, 0xF0, 0xFB, 0xFD, 0x80, 0x4A, 0x38, 0x78, 0x6B, 0x46, 0x12, 0x88, + 0x41, 0x42, 0x02, 0xEB, + 0x41, 0x01, 0x09, 0xB2, 0x42, 0x00, 0x04, 0xEB, 0x41, 0x01, 0x03, 0xEB, + 0x40, 0x00, 0x0F, 0xF0, + 0xEC, 0xFD, 0x38, 0x78, 0x69, 0x46, 0x42, 0x00, 0x08, 0x46, 0x0C, 0xF0, + 0x50, 0xFE, 0x28, 0x1A, + 0x00, 0xB2, 0xB0, 0x42, 0x01, 0xDD, 0x4F, 0xF0, 0x00, 0x09, 0x48, 0x46, + 0x27, 0xB0, 0xC6, 0xE6, + 0x2D, 0xE9, 0xF0, 0x4F, 0x71, 0x49, 0x70, 0x4A, 0x00, 0x27, 0x0C, 0x68, + 0xB2, 0xF9, 0x00, 0x20, + 0x4F, 0xF0, 0x01, 0x0A, 0x21, 0x8E, 0x3B, 0x46, 0x91, 0x42, 0x49, 0xD1, + 0x62, 0x49, 0x0A, 0x78, + 0x5E, 0x49, 0x0E, 0x68, 0x8A, 0xB1, 0xB6, 0xF9, 0x54, 0x12, 0x00, 0x25, + 0x89, 0x46, 0x57, 0x49, + 0x4F, 0xF0, 0x02, 0x0E, 0x09, 0x78, 0x49, 0x1E, 0x01, 0xF0, 0xFF, 0x0B, + 0x55, 0x49, 0x09, 0x78, + 0xC9, 0x1E, 0x01, 0xF0, 0xFF, 0x0C, 0x32, 0x34, 0x2A, 0xE0, 0xB6, 0xF9, + 0x52, 0x12, 0xEC, 0xE7, + 0x72, 0x46, 0x1C, 0xE0, 0x34, 0xF8, 0x12, 0x10, 0x30, 0xF8, 0x12, 0x80, + 0xA1, 0xEB, 0x08, 0x01, + 0x09, 0xB2, 0x00, 0x29, 0x01, 0xDB, 0x88, 0x46, 0x01, 0xE0, 0xC1, 0xF1, + 0x00, 0x08, 0xB8, 0x45, + 0x05, 0xDD, 0x00, 0x29, 0x01, 0xDB, 0x0F, 0x46, 0x00, 0xE0, 0x4F, 0x42, + 0x3F, 0xB2, 0x00, 0x29, + 0x00, 0xDA, 0x49, 0x42, 0x49, 0x45, 0x01, 0xDD, 0x5B, 0x1C, 0x9B, 0xB2, + 0x52, 0x1C, 0x62, 0x45, + 0xE0, 0xDD, 0x96, 0xF8, 0x30, 0x10, 0x6D, 0x1C, 0x04, 0xEB, 0x41, 0x04, + 0x00, 0xEB, 0x41, 0x00, + 0x5D, 0x45, 0xD5, 0xDD, 0x96, 0xF8, 0x56, 0x02, 0x98, 0x42, 0x01, 0xD2, + 0x4F, 0xF0, 0x00, 0x0A, + 0x47, 0x48, 0x20, 0xF8, 0x33, 0x7F, 0x83, 0x70, 0x50, 0x46, 0x68, 0xE6, + 0x2D, 0xE9, 0xF0, 0x41, + 0x06, 0x46, 0x44, 0x48, 0x00, 0x24, 0x00, 0x78, 0xC0, 0x06, 0x5E, 0xD5, + 0x3C, 0x48, 0x36, 0x4D, + 0x00, 0x78, 0x88, 0xB1, 0x40, 0x48, 0x31, 0x4B, 0x34, 0x49, 0x02, 0x68, + 0x18, 0x68, 0x08, 0x31, + 0xB0, 0xF8, 0x5D, 0x02, 0x40, 0x42, 0x07, 0xB2, 0x00, 0x20, 0xC8, 0x80, + 0x88, 0x80, 0x08, 0x60, + 0x35, 0x48, 0xB0, 0xF9, 0x00, 0x00, 0x29, 0xE0, 0x2C, 0x48, 0x2C, 0x78, + 0x00, 0x78, 0x08, 0xB1, + 0x01, 0x29, 0x02, 0xD0, 0x08, 0x43, 0x02, 0xD0, 0x3B, 0xE0, 0x01, 0x24, + 0x3A, 0xE0, 0x00, 0x24, + 0x67, 0xE0, 0x00, 0xBF, 0x32, 0xF9, 0x10, 0xC0, 0xBC, 0xF1, 0x00, 0x0F, + 0x16, 0xDA, 0xB1, 0xF8, + 0x04, 0xC0, 0x0C, 0xF1, 0x01, 0x0C, 0xA1, 0xF8, 0x04, 0xC0, 0x32, 0xF9, + 0x10, 0xE0, 0xD1, 0xF8, + 0x00, 0xC0, 0xF4, 0x44, 0xC1, 0xF8, 0x00, 0xC0, 0x32, 0xF9, 0x10, 0xC0, + 0xBC, 0x45, 0x05, 0xDA, + 0xB1, 0xF8, 0x06, 0xC0, 0x0C, 0xF1, 0x01, 0x0C, 0xA1, 0xF8, 0x06, 0xC0, + 0x40, 0x1E, 0xE1, 0xD2, + 0x08, 0x68, 0x40, 0x42, 0x08, 0x60, 0x15, 0x48, 0x19, 0x68, 0x08, 0x30, + 0x02, 0x68, 0xB1, 0xF8, + 0x5F, 0x32, 0x9A, 0x42, 0x3D, 0xDD, 0xB0, 0xF9, 0x06, 0x00, 0x91, 0xF8, + 0x61, 0x12, 0x88, 0x42, + 0x37, 0xDD, 0x1A, 0x48, 0x11, 0x4A, 0xB0, 0xF9, 0x00, 0x10, 0x30, 0x46, + 0x00, 0xF0, 0x20, 0xF9, + 0x04, 0x46, 0x6C, 0xB3, 0x00, 0xF0, 0xF2, 0xF8, 0x2D, 0xE0, 0x3D, 0xE0, + 0xED, 0x06, 0x10, 0x00, + 0x94, 0x0B, 0x01, 0x20, 0xEE, 0x06, 0x10, 0x00, 0x9C, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x7E, 0x4A, 0x01, 0x20, 0xA8, 0x4A, 0x01, 0x20, 0x74, 0x05, 0x10, 0x00, + 0x64, 0x05, 0x10, 0x00, + 0x7A, 0x07, 0x10, 0x00, 0xF4, 0x06, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, + 0x40, 0x2B, 0x10, 0x00, + 0x79, 0x05, 0x10, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFE, 0x06, 0x10, 0x00, + 0x50, 0x07, 0x10, 0x00, + 0x0A, 0x44, 0x01, 0x20, 0x04, 0x07, 0x10, 0x00, 0x14, 0x07, 0x10, 0x00, + 0x98, 0x06, 0x10, 0x00, + 0xFF, 0xE7, 0x00, 0xF0, 0xD9, 0xF8, 0x51, 0x4E, 0x28, 0x78, 0x31, 0x78, + 0x88, 0x42, 0x06, 0xD0, + 0x08, 0xB1, 0x01, 0x21, 0x00, 0xE0, 0x00, 0x21, 0x06, 0x20, 0x0B, 0xF0, + 0xEC, 0xF8, 0x28, 0x78, + 0x30, 0x70, 0x0C, 0xB1, 0x01, 0x20, 0xE4, 0xE5, 0x00, 0x20, 0xE2, 0xE5, + 0x70, 0xB5, 0x03, 0x20, + 0xF8, 0xF7, 0xBF, 0xFF, 0x00, 0xF0, 0x48, 0xF8, 0x04, 0x46, 0x03, 0x20, + 0xF8, 0xF7, 0xD4, 0xFF, + 0x43, 0x49, 0xC8, 0x7B, 0x64, 0xF3, 0x05, 0x10, 0xC8, 0x73, 0x42, 0x48, + 0x01, 0x78, 0x21, 0xB1, + 0x00, 0x21, 0x01, 0x70, 0x20, 0x46, 0x00, 0xF0, 0x30, 0xF9, 0x3F, 0x4D, + 0x3F, 0x48, 0x21, 0x46, + 0x2A, 0x78, 0x00, 0x68, 0xFF, 0xF7, 0x3A, 0xFF, 0xA8, 0x70, 0x70, 0xBD, + 0x2D, 0xE9, 0xF0, 0x47, + 0x1D, 0x46, 0x4F, 0xF0, 0x00, 0x08, 0xC5, 0xE9, 0x00, 0x88, 0x91, 0x46, + 0x82, 0x46, 0x0C, 0x46, + 0x11, 0xE0, 0x00, 0xBF, 0x3A, 0xF9, 0x14, 0x10, 0x49, 0x45, 0x0C, 0xDD, + 0xD5, 0xE9, 0x00, 0x67, + 0x4F, 0xF0, 0x01, 0x08, 0x22, 0x46, 0x40, 0x46, 0x00, 0x21, 0x0F, 0xF0, + 0x67, 0xFC, 0x06, 0x43, + 0x0F, 0x43, 0xC5, 0xE9, 0x00, 0x67, 0x64, 0x1E, 0xEC, 0xD2, 0x40, 0x46, + 0xBD, 0xE8, 0xF0, 0x87, + 0x2B, 0x48, 0x00, 0x21, 0xC0, 0xE9, 0x00, 0x11, 0xC0, 0xE9, 0x02, 0x11, + 0x08, 0x46, 0x29, 0x49, + 0x08, 0x76, 0x29, 0x49, 0x08, 0x76, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x41, + 0x27, 0x48, 0x00, 0x78, + 0x02, 0x28, 0x35, 0xD9, 0x26, 0x4E, 0x30, 0x68, 0x90, 0xF8, 0x50, 0x02, + 0x41, 0x07, 0x25, 0x48, + 0x00, 0x68, 0x02, 0xD5, 0x24, 0x49, 0x09, 0x78, 0x81, 0xB1, 0xFF, 0xF7, + 0x3C, 0xFE, 0x05, 0x46, + 0x30, 0x68, 0x90, 0xF8, 0x50, 0x02, 0x00, 0x07, 0x21, 0xD5, 0x22, 0x48, + 0x1F, 0x4B, 0x20, 0x49, + 0x02, 0x78, 0x02, 0x2A, 0x1B, 0xDB, 0x20, 0x4C, 0x50, 0x1E, 0x08, 0xE0, + 0xFF, 0xF7, 0x88, 0xFE, + 0xED, 0xE7, 0x00, 0xBF, 0x33, 0xF9, 0x10, 0x70, 0xA7, 0x42, 0x00, 0xDD, + 0x3C, 0x46, 0x40, 0x1E, + 0xF8, 0xD1, 0x98, 0x1C, 0x92, 0x1E, 0x0C, 0xF0, 0xC2, 0xFC, 0x31, 0x68, + 0x20, 0x1A, 0x00, 0xB2, + 0xB1, 0xF9, 0x57, 0x12, 0x88, 0x42, 0x02, 0xDD, 0x35, 0xB1, 0x02, 0x20, + 0x59, 0xE5, 0x0D, 0xB1, + 0x00, 0x20, 0x56, 0xE5, 0x01, 0x20, 0x54, 0xE5, 0x03, 0x20, 0x52, 0xE5, + 0x75, 0x05, 0x10, 0x00, + 0x0A, 0x44, 0x01, 0x20, 0x78, 0x05, 0x10, 0x00, 0x64, 0x05, 0x10, 0x00, + 0x14, 0x07, 0x10, 0x00, + 0x40, 0x2B, 0x10, 0x00, 0x18, 0x2A, 0x10, 0x00, 0x58, 0x2A, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x1C, 0x07, 0x10, 0x00, 0x79, 0x05, 0x10, 0x00, + 0xA8, 0x4A, 0x01, 0x20, + 0xCE, 0x0A, 0x01, 0x20, 0xEE, 0x06, 0x10, 0x00, 0x00, 0x80, 0xFF, 0xFF, + 0xFE, 0x48, 0x00, 0x21, + 0xC1, 0x70, 0x02, 0x78, 0x00, 0x2A, 0x0E, 0xD1, 0x82, 0x78, 0xFC, 0x4B, + 0x52, 0x1C, 0xD2, 0xB2, + 0x82, 0x70, 0x1B, 0x68, 0x93, 0xF8, 0x62, 0x32, 0x03, 0xF0, 0x0F, 0x03, + 0x93, 0x42, 0x02, 0xD2, + 0x01, 0x22, 0x02, 0x70, 0x81, 0x70, 0x70, 0x47, 0xF3, 0x48, 0x00, 0x21, + 0x81, 0x70, 0x02, 0x78, + 0x00, 0x2A, 0x0C, 0xD0, 0xC2, 0x78, 0xF1, 0x4B, 0x52, 0x1C, 0xD2, 0xB2, + 0xC2, 0x70, 0x1B, 0x68, + 0x93, 0xF8, 0x62, 0x32, 0xB2, 0xEB, 0x13, 0x1F, 0x01, 0xD9, 0x01, 0x70, + 0xC1, 0x70, 0x70, 0x47, + 0x2D, 0xE9, 0xF7, 0x4F, 0x86, 0xB0, 0x8A, 0x46, 0xD2, 0xE9, 0x00, 0x01, + 0xCD, 0xE9, 0x00, 0x01, + 0xD2, 0xE9, 0x02, 0x01, 0xCD, 0xE9, 0x04, 0x01, 0x68, 0x46, 0x0F, 0xF0, + 0x61, 0xFD, 0x04, 0xA8, + 0x0F, 0xF0, 0x5E, 0xFD, 0xE2, 0x48, 0x00, 0x27, 0xB9, 0x46, 0x06, 0x78, + 0x28, 0xE0, 0xF1, 0xB2, + 0x06, 0x98, 0x0F, 0xF0, 0x6B, 0xFD, 0x80, 0x46, 0xDE, 0x48, 0xDD, 0xE9, + 0x04, 0xB1, 0x05, 0x78, + 0x01, 0x24, 0x00, 0x98, 0xB4, 0x40, 0x04, 0x40, 0x02, 0x91, 0x17, 0xE0, + 0x38, 0xF9, 0x15, 0x10, + 0x51, 0x45, 0x13, 0xDD, 0x20, 0x00, 0x0F, 0xD0, 0x2A, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x0F, 0xF0, + 0x95, 0xFB, 0x02, 0x9A, 0x00, 0xEA, 0x0B, 0x00, 0x11, 0x40, 0x08, 0x43, + 0x04, 0xD0, 0x09, 0xF1, + 0x01, 0x00, 0x1F, 0xFA, 0x80, 0xF9, 0x01, 0xE0, 0x7F, 0x1C, 0xBF, 0xB2, + 0x6D, 0x1E, 0xE5, 0xD2, + 0x76, 0x1E, 0xD4, 0xD2, 0xC9, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x5B, 0x12, + 0xB9, 0x42, 0x07, 0xD8, + 0x90, 0xF8, 0x5C, 0x12, 0x49, 0x45, 0x03, 0xD3, 0x01, 0x20, 0x09, 0xB0, + 0xBD, 0xE8, 0xF0, 0x8F, + 0x00, 0x20, 0xFA, 0xE7, 0xC0, 0x48, 0x10, 0xB5, 0x41, 0x78, 0x01, 0x70, + 0x00, 0x21, 0x81, 0x70, + 0xC1, 0x70, 0xFF, 0xF7, 0x1A, 0xFD, 0xBD, 0xE8, 0x10, 0x40, 0xFE, 0xF7, + 0x59, 0xBE, 0xBA, 0x48, + 0x00, 0x21, 0xBA, 0x4A, 0x01, 0x70, 0x41, 0x70, 0x12, 0x68, 0x92, 0xF8, + 0x50, 0x22, 0x92, 0x07, + 0x00, 0xD5, 0x01, 0x21, 0x41, 0x71, 0x01, 0x71, 0x70, 0x47, 0xB3, 0x49, + 0x4A, 0x79, 0x01, 0x2A, + 0x02, 0xD1, 0x00, 0x28, 0x00, 0xD1, 0x48, 0x71, 0x70, 0x47, 0xF0, 0xB5, + 0x00, 0x24, 0x1C, 0x72, + 0x04, 0x7E, 0x0D, 0x7E, 0x6C, 0x43, 0x04, 0xF0, 0xFF, 0x0C, 0x4F, 0xF0, + 0xFF, 0x34, 0xE7, 0x07, + 0x26, 0x46, 0x00, 0x25, 0x08, 0xE0, 0x00, 0xBF, 0x52, 0xF8, 0x25, 0xE0, + 0xBE, 0x45, 0x01, 0xDD, + 0x77, 0x46, 0x6E, 0xB2, 0x6D, 0x1C, 0xED, 0xB2, 0x65, 0x45, 0xF5, 0xD3, + 0x00, 0x2E, 0x17, 0xDB, + 0x01, 0x25, 0x1D, 0x72, 0x0D, 0x7E, 0x96, 0xFB, 0xF5, 0xF5, 0x6D, 0x1C, + 0xED, 0xB2, 0x05, 0x44, + 0xAF, 0x7C, 0x1F, 0x70, 0x2D, 0x7B, 0x1D, 0x71, 0x0D, 0x7E, 0x96, 0xFB, + 0xF5, 0xF7, 0x05, 0xFB, + 0x17, 0x65, 0x6D, 0x1C, 0xED, 0xB2, 0x0D, 0x44, 0xAF, 0x7C, 0x9F, 0x70, + 0x2D, 0x7B, 0x9D, 0x71, + 0xBC, 0xF1, 0x01, 0x0F, 0x30, 0xD9, 0x95, 0x4D, 0x2D, 0x68, 0x95, 0xF8, + 0x51, 0x52, 0xED, 0x07, + 0x2A, 0xD0, 0x25, 0x46, 0x00, 0x27, 0x3C, 0x46, 0x0A, 0xE0, 0x00, 0xBF, + 0x52, 0xF8, 0x24, 0xE0, + 0xBE, 0x45, 0x03, 0xDD, 0xA6, 0x42, 0x01, 0xD0, 0x77, 0x46, 0x65, 0xB2, + 0x64, 0x1C, 0xE4, 0xB2, + 0x64, 0x45, 0xF3, 0xD3, 0x00, 0x2D, 0x17, 0xDB, 0x02, 0x22, 0x1A, 0x72, + 0x0A, 0x7E, 0x95, 0xFB, + 0xF2, 0xF2, 0x52, 0x1C, 0xD2, 0xB2, 0x10, 0x44, 0x82, 0x7C, 0x5A, 0x70, + 0x00, 0x7B, 0x58, 0x71, + 0x08, 0x7E, 0x95, 0xFB, 0xF0, 0xF2, 0x00, 0xFB, 0x12, 0x50, 0x40, 0x1C, + 0xC0, 0xB2, 0x08, 0x44, + 0x81, 0x7C, 0xD9, 0x70, 0x00, 0x7B, 0xD8, 0x71, 0xF0, 0xBD, 0x2D, 0xE9, + 0xFF, 0x47, 0x0F, 0x46, + 0x06, 0x46, 0xD2, 0xE9, 0x00, 0x01, 0xCD, 0xE9, 0x00, 0x01, 0xD2, 0xE9, + 0x02, 0x01, 0xCD, 0xE9, + 0x02, 0x01, 0x68, 0x46, 0x0F, 0xF0, 0x84, 0xFC, 0x02, 0xA8, 0x0F, 0xF0, + 0x81, 0xFC, 0x00, 0x25, + 0xDF, 0xF8, 0xD0, 0x91, 0xDF, 0xF8, 0xC8, 0x81, 0x2F, 0xE0, 0x2A, 0x46, + 0x01, 0x20, 0x00, 0x21, + 0x0F, 0xF0, 0xCC, 0xFA, 0xDD, 0xE9, 0x00, 0x23, 0x10, 0x40, 0x19, 0x40, + 0x08, 0x43, 0x01, 0xD0, + 0x00, 0x24, 0x17, 0xE0, 0x99, 0xF8, 0x00, 0x00, 0x39, 0x46, 0x42, 0x00, + 0x30, 0x46, 0x0F, 0xF0, + 0xF4, 0xFA, 0x13, 0xE0, 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x0F, 0xF0, + 0xB7, 0xFA, 0xDD, 0xE9, + 0x02, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x03, 0xD1, 0x37, 0xF8, + 0x14, 0x00, 0x26, 0xF8, + 0x14, 0x00, 0x64, 0x1C, 0x99, 0xF8, 0x00, 0x00, 0x84, 0x42, 0xEB, 0xDB, + 0x99, 0xF8, 0x00, 0x00, + 0x6D, 0x1C, 0x07, 0xEB, 0x40, 0x07, 0x06, 0xEB, 0x40, 0x06, 0x98, 0xF8, + 0x00, 0x00, 0x85, 0x42, + 0xCB, 0xDB, 0xBD, 0xE8, 0xFF, 0x87, 0x2D, 0xE9, 0xFF, 0x4F, 0x81, 0x46, + 0x84, 0x1C, 0x80, 0x78, + 0x81, 0xB0, 0x9A, 0x46, 0x15, 0x46, 0x60, 0xB1, 0x40, 0x1E, 0xC2, 0xB2, + 0x22, 0x70, 0xD5, 0xE9, + 0x00, 0x67, 0x01, 0x20, 0x00, 0x21, 0x0F, 0xF0, 0x89, 0xFA, 0x06, 0x43, + 0x0F, 0x43, 0xC5, 0xE9, + 0x00, 0x67, 0x4F, 0xF0, 0x01, 0x08, 0xAA, 0xF1, 0x01, 0x0A, 0x2D, 0xE0, + 0x09, 0xEB, 0x48, 0x00, + 0x00, 0xF1, 0x02, 0x0B, 0x82, 0x78, 0x60, 0x78, 0xC1, 0x1C, 0x8A, 0x42, + 0x1F, 0xD9, 0x50, 0x45, + 0x0C, 0xDA, 0x40, 0x1C, 0xC2, 0xB2, 0x62, 0x70, 0xD5, 0xE9, 0x00, 0x76, + 0x01, 0x20, 0x00, 0x21, + 0x0F, 0xF0, 0x6C, 0xFA, 0x07, 0x43, 0x0E, 0x43, 0xC5, 0xE9, 0x00, 0x76, + 0x9B, 0xF8, 0x00, 0x00, + 0x68, 0xB1, 0x40, 0x1E, 0x8B, 0xF8, 0x00, 0x00, 0x22, 0x78, 0xD5, 0xE9, + 0x00, 0x67, 0x01, 0x20, + 0x00, 0x21, 0x0F, 0xF0, 0x5B, 0xFA, 0x06, 0x43, 0x0F, 0x43, 0xC5, 0xE9, + 0x00, 0x67, 0x08, 0xF1, + 0x01, 0x00, 0x5C, 0x46, 0x00, 0xF0, 0xFF, 0x08, 0x99, 0xF8, 0x18, 0x00, + 0x40, 0x45, 0xCD, 0xD8, + 0x60, 0x78, 0x50, 0x45, 0x0C, 0xDA, 0x40, 0x1C, 0xC2, 0xB2, 0x62, 0x70, + 0xD5, 0xE9, 0x00, 0x46, + 0x01, 0x20, 0x00, 0x21, 0x0F, 0xF0, 0x42, 0xFA, 0x04, 0x43, 0x0E, 0x43, + 0xC5, 0xE9, 0x00, 0x46, + 0x01, 0x20, 0x04, 0x46, 0x00, 0x90, 0x66, 0xE0, 0x02, 0x98, 0x22, 0x46, + 0x00, 0x21, 0xD0, 0xE9, + 0x00, 0x67, 0x01, 0x20, 0x0F, 0xF0, 0x32, 0xFA, 0x80, 0x46, 0x8B, 0x46, + 0x06, 0xEA, 0x08, 0x06, + 0x07, 0xEA, 0x0B, 0x07, 0x3E, 0x43, 0x27, 0xD0, 0xD5, 0xE9, 0x00, 0x67, + 0x46, 0xEA, 0x08, 0x06, + 0x47, 0xEA, 0x0B, 0x07, 0x62, 0x1E, 0x01, 0x20, 0x00, 0x21, 0xC5, 0xE9, + 0x00, 0x67, 0x0F, 0xF0, + 0x1D, 0xFA, 0x06, 0x40, 0x0F, 0x40, 0x3E, 0x43, 0x05, 0xD0, 0x00, 0x99, + 0x09, 0xEB, 0x41, 0x00, + 0x41, 0x78, 0x49, 0x1C, 0x41, 0x70, 0xD5, 0xE9, 0x00, 0x67, 0x62, 0x1C, + 0x01, 0x20, 0x00, 0x21, + 0x0F, 0xF0, 0x0C, 0xFA, 0x06, 0x40, 0x0F, 0x40, 0x3E, 0x43, 0x05, 0xD0, + 0x00, 0x99, 0x09, 0xEB, + 0x41, 0x01, 0x88, 0x78, 0x40, 0x1E, 0x88, 0x70, 0xD5, 0xE9, 0x00, 0x67, + 0x62, 0x1E, 0x01, 0x20, + 0x00, 0x21, 0x0F, 0xF0, 0xFB, 0xF9, 0x30, 0x40, 0x39, 0x40, 0x08, 0x43, + 0x21, 0xD0, 0x58, 0xEA, + 0x0B, 0x01, 0x0F, 0xD0, 0x00, 0x20, 0x07, 0xE0, 0x74, 0x05, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0x06, 0x40, 0x07, 0xEA, + 0xE0, 0x77, 0x3E, 0x43, + 0x0B, 0xD1, 0x01, 0xE0, 0x01, 0x20, 0xEE, 0xE7, 0x02, 0x99, 0xD1, 0xE9, + 0x00, 0x01, 0x00, 0xEA, + 0x08, 0x00, 0x01, 0xEA, 0x0B, 0x01, 0x08, 0x43, 0x03, 0xD0, 0x00, 0x98, + 0x40, 0x1C, 0xC0, 0xB2, + 0x00, 0x90, 0x64, 0x1C, 0xE4, 0xB2, 0x54, 0x45, 0x96, 0xDB, 0x05, 0xB0, + 0x56, 0xE6, 0x2D, 0xE9, + 0xFF, 0x5F, 0x05, 0x46, 0xFE, 0x49, 0xDD, 0xF8, 0x38, 0xB0, 0x00, 0x20, + 0x05, 0xEB, 0x40, 0x03, + 0x40, 0x1C, 0x0C, 0x88, 0xC0, 0xB2, 0x1C, 0x80, 0x06, 0x28, 0xF7, 0xD3, + 0x00, 0x20, 0x28, 0x73, + 0xF8, 0x48, 0x00, 0x68, 0xB0, 0xF9, 0x6E, 0x82, 0xB2, 0xF9, 0x08, 0x00, + 0x40, 0x45, 0x02, 0xDB, + 0xB8, 0xF1, 0x00, 0x0F, 0x00, 0xD1, 0x80, 0x46, 0x4F, 0xF0, 0x01, 0x0A, + 0x00, 0x24, 0x28, 0xE0, + 0x03, 0x98, 0x05, 0xEB, 0x4A, 0x09, 0x22, 0x46, 0xD0, 0xE9, 0x00, 0x67, + 0x01, 0x20, 0x00, 0x21, + 0x0F, 0xF0, 0xA4, 0xF9, 0x06, 0x40, 0x0F, 0x40, 0x3E, 0x43, 0x04, 0xD1, + 0x01, 0x98, 0x30, 0xF9, + 0x14, 0x10, 0x41, 0x45, 0x0B, 0xDD, 0x99, 0xF8, 0x00, 0x00, 0xFF, 0x28, + 0x04, 0xD1, 0x89, 0xF8, + 0x00, 0x40, 0x28, 0x7B, 0x40, 0x1C, 0x28, 0x73, 0x89, 0xF8, 0x01, 0x40, + 0x07, 0xE0, 0x99, 0xF8, + 0x00, 0x00, 0xFF, 0x28, 0x03, 0xD0, 0x0A, 0xF1, 0x01, 0x00, 0x00, 0xF0, + 0xFF, 0x0A, 0x64, 0x1C, + 0xE4, 0xB2, 0x5C, 0x45, 0xD4, 0xD3, 0xBD, 0xE8, 0xFF, 0x9F, 0x2D, 0xE9, + 0xFF, 0x4F, 0x85, 0xB0, + 0x00, 0x20, 0x05, 0x46, 0x02, 0x90, 0x04, 0x90, 0xD7, 0x48, 0x9B, 0x46, + 0x8A, 0x46, 0x06, 0x68, + 0x01, 0x20, 0x81, 0x46, 0x05, 0x98, 0x01, 0x7E, 0x49, 0x45, 0x7D, 0xD3, + 0x05, 0x98, 0x01, 0x27, + 0x10, 0xF8, 0x19, 0x10, 0x40, 0x46, 0x61, 0xF3, 0x17, 0x40, 0x05, 0x99, + 0x01, 0xEB, 0x49, 0x01, + 0x49, 0x78, 0x61, 0xF3, 0x1F, 0x60, 0x80, 0x46, 0x69, 0xE0, 0x00, 0xBF, + 0x1A, 0xF8, 0x17, 0x10, + 0x40, 0x46, 0x61, 0xF3, 0x07, 0x00, 0x0A, 0xEB, 0x47, 0x01, 0x01, 0x23, + 0x49, 0x78, 0x61, 0xF3, + 0x0F, 0x20, 0x80, 0x46, 0x00, 0x20, 0x86, 0xF8, 0x0E, 0x01, 0x02, 0x46, + 0xC3, 0x48, 0xC6, 0xF8, + 0x00, 0x80, 0x44, 0x46, 0x31, 0x46, 0x00, 0x68, 0x06, 0xF0, 0x62, 0xFF, + 0x0B, 0xEB, 0x85, 0x00, + 0x44, 0x66, 0x00, 0x20, 0x4B, 0xF8, 0x25, 0x00, 0x4F, 0xF0, 0x00, 0x40, + 0x01, 0x90, 0x00, 0x20, + 0x01, 0x24, 0x03, 0x90, 0x3C, 0xE0, 0x00, 0xBF, 0x06, 0xEB, 0x44, 0x00, + 0xB0, 0xF8, 0xB4, 0x10, + 0x07, 0x98, 0x81, 0x42, 0x2D, 0xD9, 0xB6, 0x48, 0x06, 0xEB, 0x84, 0x03, + 0xE2, 0xB2, 0x01, 0x68, + 0xB2, 0x48, 0x00, 0x68, 0xFE, 0xF7, 0x7A, 0xFE, 0x01, 0x99, 0x00, 0x90, + 0x88, 0x42, 0x0F, 0xDD, + 0x03, 0x98, 0x48, 0xB1, 0xC1, 0xB2, 0xAD, 0x48, 0x32, 0x46, 0x00, 0x68, + 0x07, 0xF0, 0x2D, 0xF8, + 0x02, 0x98, 0x40, 0x1E, 0xC0, 0xB2, 0x02, 0x90, 0x00, 0x98, 0x01, 0x90, + 0x60, 0xB2, 0x03, 0x90, + 0x5B, 0xF8, 0x25, 0x10, 0x00, 0x98, 0x01, 0x44, 0x4B, 0xF8, 0x25, 0x10, + 0x02, 0x98, 0x04, 0x99, + 0x40, 0x1C, 0xC0, 0xB2, 0x02, 0x90, 0x01, 0x20, 0xA8, 0x40, 0x08, 0x43, + 0x80, 0xB2, 0x04, 0x90, + 0x05, 0xE0, 0x9E, 0x48, 0xE1, 0xB2, 0x32, 0x46, 0x00, 0x68, 0x07, 0xF0, + 0x0E, 0xF8, 0x64, 0x1C, + 0x96, 0xF8, 0x0E, 0x01, 0xA0, 0x42, 0xBF, 0xD2, 0x6D, 0x1C, 0xED, 0xB2, + 0x7F, 0x1C, 0x9A, 0xF8, + 0x18, 0x00, 0xB8, 0x42, 0x92, 0xD2, 0x00, 0xE0, 0x02, 0xE0, 0x09, 0xF1, + 0x01, 0x00, 0x78, 0xE7, + 0x94, 0x48, 0x04, 0x99, 0xA0, 0xF8, 0x19, 0x10, 0x02, 0x98, 0x6E, 0xE5, + 0x2D, 0xE9, 0xFF, 0x5F, + 0xDF, 0xF8, 0x44, 0x92, 0x91, 0x4E, 0x09, 0xF1, 0x20, 0x00, 0x03, 0x90, + 0x06, 0xF1, 0x20, 0x00, + 0x02, 0x90, 0x90, 0x49, 0x8E, 0x48, 0xDF, 0xF8, 0x40, 0xB2, 0x1E, 0xC9, + 0x80, 0xE8, 0x1E, 0x00, + 0x8E, 0x49, 0x00, 0x20, 0x8B, 0xF8, 0x00, 0x00, 0x08, 0x72, 0x82, 0x48, + 0x31, 0x7E, 0x00, 0x68, + 0x90, 0xF8, 0x51, 0x02, 0x00, 0xF0, 0x01, 0x08, 0x99, 0xF8, 0x18, 0x00, + 0xC8, 0x42, 0x05, 0xD1, + 0x43, 0x46, 0x83, 0x4A, 0x31, 0x46, 0x48, 0x46, 0xFE, 0xF7, 0x3E, 0xFD, + 0x99, 0xF8, 0x18, 0x40, + 0x37, 0x7E, 0x04, 0xFB, 0x07, 0xF0, 0x10, 0xF0, 0xFF, 0x05, 0x77, 0xD0, + 0x19, 0x2D, 0x75, 0xD2, + 0x05, 0x2C, 0x73, 0xD8, 0x05, 0x2F, 0x71, 0xD8, 0x79, 0x48, 0xFC, 0x21, + 0x10, 0x30, 0x0F, 0xF0, + 0x85, 0xF9, 0x77, 0x48, 0x39, 0x46, 0x10, 0x30, 0x80, 0xF8, 0xFA, 0x50, + 0x20, 0x46, 0x0B, 0xF0, + 0x67, 0xF9, 0x00, 0xF0, 0xFF, 0x0A, 0x72, 0x48, 0x08, 0x30, 0x01, 0x90, + 0xB8, 0xF1, 0x00, 0x0F, + 0x0D, 0xD0, 0x73, 0x48, 0x6E, 0x4A, 0x03, 0x99, 0x03, 0x78, 0x48, 0x46, + 0xFF, 0xF7, 0xFB, 0xFD, + 0x70, 0x48, 0xDD, 0xE9, 0x01, 0x21, 0x03, 0x78, 0x30, 0x46, 0xFF, 0xF7, + 0xF4, 0xFD, 0x6E, 0x48, + 0x00, 0x90, 0x6E, 0x48, 0x66, 0x49, 0xB0, 0xF9, 0x00, 0x30, 0x60, 0x48, + 0x02, 0x68, 0x60, 0x48, + 0x00, 0x68, 0xFE, 0xF7, 0x5A, 0xFD, 0x6A, 0x49, 0x5A, 0x4F, 0x61, 0x4B, + 0x08, 0x60, 0x38, 0x68, + 0x10, 0x33, 0x31, 0x46, 0x90, 0xF8, 0x6D, 0x22, 0x48, 0x46, 0xFF, 0xF7, + 0xF6, 0xFE, 0x04, 0x46, + 0x38, 0x68, 0x90, 0xF8, 0x51, 0x02, 0x80, 0x07, 0x28, 0xD5, 0x5D, 0x48, + 0xDF, 0xF8, 0x58, 0x81, + 0x56, 0x4F, 0x00, 0x78, 0x08, 0xF1, 0x30, 0x08, 0x00, 0x90, 0x30, 0x37, + 0x54, 0x4B, 0x5D, 0x49, + 0x40, 0x46, 0x03, 0x9A, 0xFF, 0xF7, 0x93, 0xFE, 0x56, 0x48, 0x5B, 0x49, + 0x00, 0x78, 0x00, 0x90, + 0xDD, 0xE9, 0x01, 0x32, 0x38, 0x46, 0xFF, 0xF7, 0x8A, 0xFE, 0x4A, 0x48, + 0x98, 0xF8, 0x0C, 0x20, + 0x81, 0x7D, 0x62, 0xF3, 0x03, 0x01, 0x81, 0x75, 0x3A, 0x7B, 0x62, 0xF3, + 0x07, 0x11, 0x81, 0x75, + 0x47, 0x4A, 0x39, 0x46, 0x10, 0x32, 0x40, 0x46, 0x00, 0xF0, 0x3A, 0xF8, + 0xA2, 0x45, 0x06, 0xD8, + 0xAC, 0x42, 0x04, 0xD8, 0x01, 0x21, 0x8B, 0xF8, 0x00, 0x10, 0x0A, 0xE0, + 0x10, 0xE0, 0x00, 0x20, + 0x3F, 0x4A, 0x8B, 0xF8, 0x00, 0x00, 0x41, 0x4B, 0x10, 0x32, 0x31, 0x46, + 0x48, 0x46, 0xFF, 0xF7, + 0xE4, 0xFC, 0x38, 0x48, 0x01, 0x7E, 0x6A, 0xF3, 0x03, 0x01, 0x64, 0xF3, + 0x07, 0x11, 0x01, 0x76, + 0xA9, 0xE6, 0x10, 0xB5, 0x01, 0x21, 0x31, 0x48, 0x08, 0xF0, 0x31, 0xFD, + 0x02, 0x21, 0x3F, 0x48, + 0x08, 0xF0, 0xD5, 0xFC, 0x04, 0x21, 0x2C, 0x48, 0x08, 0xF0, 0xD1, 0xFC, + 0xFF, 0xF7, 0x36, 0xFF, + 0xFE, 0xF7, 0x2D, 0xFE, 0x02, 0x21, 0x39, 0x48, 0x08, 0xF0, 0xE6, 0xFC, + 0x04, 0x21, 0x26, 0x48, + 0x08, 0xF0, 0xE2, 0xFC, 0xBD, 0xE8, 0x10, 0x40, 0x01, 0x21, 0x24, 0x48, + 0x08, 0xF0, 0xAA, 0xBD, + 0x2D, 0xE9, 0xF0, 0x47, 0x14, 0x46, 0x0D, 0x46, 0x06, 0x46, 0x00, 0xF0, + 0x8B, 0xF8, 0x30, 0x7B, + 0x29, 0x7B, 0x1C, 0x4F, 0x48, 0x43, 0xC5, 0xB2, 0x01, 0x20, 0x30, 0xE0, + 0x00, 0x21, 0x0A, 0x46, + 0x94, 0xF8, 0xFA, 0x60, 0x0C, 0xE0, 0x00, 0xBF, 0x54, 0xF8, 0x22, 0x30, + 0x8B, 0x42, 0x06, 0xDD, + 0x04, 0xEB, 0x02, 0x0C, 0x9C, 0xF8, 0xE1, 0xC0, 0x84, 0x45, 0x00, 0xD1, + 0x19, 0x46, 0x52, 0x1C, + 0x96, 0x42, 0xF1, 0xD8, 0x3A, 0x68, 0xB2, 0xF8, 0x70, 0x22, 0x8A, 0x42, + 0x15, 0xDA, 0x00, 0x22, + 0x0F, 0xE0, 0xA3, 0x18, 0x93, 0xF8, 0xE1, 0x60, 0x86, 0x42, 0x09, 0xD1, + 0x54, 0xF8, 0x22, 0x60, + 0x4F, 0xF0, 0x64, 0x0C, 0x06, 0xFB, 0x0C, 0xF6, 0x96, 0xFB, 0xF1, 0xF6, + 0x83, 0xF8, 0xC8, 0x60, + 0x52, 0x1C, 0x94, 0xF8, 0xFA, 0x30, 0x93, 0x42, 0xEB, 0xD8, 0x40, 0x1C, + 0xC0, 0xB2, 0x27, 0xE0, + 0xFC, 0x78, 0x01, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x58, 0x05, 0x10, 0x00, + 0x50, 0x06, 0x10, 0x00, + 0x14, 0x07, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0x18, 0x2A, 0x10, 0x00, + 0x58, 0x2A, 0x10, 0x00, + 0x60, 0x2B, 0x10, 0x00, 0x40, 0x2B, 0x10, 0x00, 0x57, 0x05, 0x10, 0x00, + 0x0C, 0x2A, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0x84, 0x06, 0x10, 0x00, + 0x92, 0x06, 0x10, 0x00, + 0x7C, 0x06, 0x10, 0x00, 0x94, 0x0B, 0x01, 0x20, 0xBE, 0x0B, 0x01, 0x20, + 0x60, 0x06, 0x10, 0x00, + 0xA8, 0x42, 0xA3, 0xD9, 0x00, 0x26, 0x35, 0x46, 0xB8, 0x46, 0xB1, 0x46, + 0xDF, 0xF8, 0xD4, 0xA0, + 0x18, 0xE0, 0xD8, 0xF8, 0x00, 0x00, 0x67, 0x19, 0x97, 0xF8, 0xC8, 0x10, + 0x90, 0xF8, 0x72, 0x02, + 0x81, 0x42, 0x0E, 0xD2, 0x04, 0xEB, 0x85, 0x01, 0x00, 0x22, 0x64, 0x31, + 0xDA, 0xF8, 0x00, 0x00, + 0x06, 0xF0, 0xCE, 0xFC, 0x44, 0xF8, 0x25, 0x90, 0x97, 0xF8, 0xC8, 0x00, + 0xB0, 0x42, 0x00, 0xD2, + 0x06, 0x46, 0x6D, 0x1C, 0x94, 0xF8, 0xFA, 0x00, 0xA8, 0x42, 0xE2, 0xD8, + 0x26, 0x48, 0xC6, 0x75, + 0xBD, 0xE8, 0xF0, 0x87, 0x2D, 0xE9, 0xF8, 0x4F, 0x82, 0x46, 0x01, 0x24, + 0x16, 0x46, 0x0F, 0x46, + 0x20, 0x46, 0x9A, 0xF8, 0x0C, 0x10, 0x81, 0x46, 0x49, 0x45, 0x38, 0xD3, + 0x1A, 0xF8, 0x14, 0x00, + 0x8D, 0xF8, 0x02, 0x00, 0x0A, 0xEB, 0x44, 0x00, 0x40, 0x78, 0x8D, 0xF8, + 0x03, 0x00, 0x01, 0x20, + 0x26, 0xE0, 0x00, 0xBF, 0x17, 0xF8, 0x14, 0x00, 0x8D, 0xF8, 0x00, 0x00, + 0x07, 0xEB, 0x44, 0x00, + 0x00, 0x25, 0x40, 0x78, 0x8D, 0xF8, 0x01, 0x00, 0x12, 0xE0, 0x00, 0xBF, + 0x06, 0xEB, 0x05, 0x0B, + 0x9B, 0xF8, 0xE1, 0x00, 0x58, 0xB9, 0x06, 0xEB, 0x85, 0x01, 0x68, 0x46, + 0x64, 0x31, 0x06, 0xF0, + 0x7B, 0xFC, 0x20, 0xB1, 0x8B, 0xF8, 0xE1, 0x40, 0x64, 0x20, 0x8B, 0xF8, + 0xC8, 0x00, 0x6D, 0x1C, + 0x96, 0xF8, 0xFA, 0x00, 0xA8, 0x42, 0xE9, 0xD8, 0x64, 0x1C, 0xE4, 0xB2, + 0x08, 0xF1, 0x01, 0x00, + 0x39, 0x7B, 0x80, 0x46, 0x41, 0x45, 0xD5, 0xD2, 0x09, 0xF1, 0x01, 0x00, + 0xC1, 0xE7, 0xBD, 0xE8, + 0xF8, 0x8F, 0x00, 0x00, 0x50, 0x06, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, + 0x2D, 0xE9, 0xFF, 0x4F, + 0xCE, 0x4B, 0x83, 0xB0, 0x1B, 0x68, 0xB3, 0xF9, 0xC2, 0x42, 0xB3, 0xF9, + 0xC4, 0xE2, 0x99, 0xE0, + 0x47, 0xF6, 0xFF, 0x76, 0xF7, 0x43, 0x06, 0x9D, 0x08, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x15, 0x30, + 0xB3, 0x42, 0x00, 0xDA, 0x1E, 0x46, 0xBB, 0x42, 0x00, 0xDD, 0x1F, 0x46, + 0x6D, 0x1E, 0xF5, 0xD1, + 0xAB, 0x46, 0x00, 0x2F, 0x01, 0xDA, 0xBB, 0x46, 0x02, 0xE0, 0x00, 0x2E, + 0x00, 0xDD, 0xB3, 0x46, + 0x00, 0x26, 0x37, 0x46, 0xB2, 0x46, 0x35, 0x46, 0xB1, 0x46, 0x06, 0x9B, + 0x13, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x13, 0x80, 0xA8, 0xEB, 0x0B, 0x0C, 0xA4, 0x45, 0x0C, 0xDA, + 0x0C, 0xEB, 0x04, 0x08, + 0xB8, 0xF1, 0x00, 0x0F, 0x07, 0xDD, 0x03, 0xFB, 0x03, 0x77, 0x03, 0xFB, + 0x0C, 0x55, 0x1E, 0x44, + 0xE2, 0x44, 0x09, 0xF1, 0x01, 0x09, 0x5B, 0x1E, 0xEA, 0xD1, 0x07, 0xFB, + 0x09, 0xF3, 0x06, 0xFB, + 0x16, 0x33, 0x02, 0x93, 0x05, 0xFB, 0x09, 0xF3, 0x06, 0xFB, 0x1A, 0x33, + 0x07, 0xFB, 0x0A, 0xF7, + 0x01, 0x93, 0x05, 0xFB, 0x16, 0x73, 0x4F, 0xF0, 0x00, 0x0C, 0x00, 0x93, + 0x67, 0x46, 0x66, 0x46, + 0xE2, 0x46, 0x06, 0x9B, 0x28, 0xE0, 0xDD, 0xF8, 0x08, 0x80, 0x00, 0x25, + 0xB8, 0xF1, 0x00, 0x0F, + 0x0D, 0xD0, 0xDD, 0xE9, 0x00, 0x58, 0x08, 0xFB, 0x03, 0x58, 0x02, 0x9D, + 0x98, 0xFB, 0xF5, 0xF5, + 0xA5, 0x42, 0x01, 0xDD, 0x25, 0x46, 0x02, 0xE0, 0xE5, 0x42, 0x00, 0xD5, + 0x65, 0x42, 0x31, 0xF8, + 0x13, 0x80, 0x5D, 0x44, 0xA8, 0xEB, 0x05, 0x05, 0x2D, 0xB2, 0x7F, 0x1C, + 0xA9, 0x46, 0xAC, 0x44, + 0x75, 0x45, 0x07, 0xDA, 0x05, 0xEB, 0x0E, 0x08, 0xB8, 0xF1, 0x00, 0x0F, + 0x02, 0xDD, 0x4E, 0x44, + 0x0A, 0xF1, 0x01, 0x0A, 0x20, 0xF8, 0x13, 0x90, 0x5B, 0x1E, 0xD4, 0xD1, + 0x9C, 0xFB, 0xF7, 0xF5, + 0xBA, 0xF1, 0x00, 0x0F, 0x01, 0xD1, 0x4F, 0xF0, 0x01, 0x0A, 0x96, 0xFB, + 0xFA, 0xF3, 0x00, 0x2D, + 0x01, 0xDB, 0x2F, 0x46, 0x00, 0xE0, 0x6F, 0x42, 0x1E, 0x1E, 0x00, 0xDA, + 0x5E, 0x42, 0xB7, 0xEB, + 0x46, 0x0F, 0x00, 0xDD, 0x1D, 0x46, 0x06, 0x9B, 0x05, 0xE0, 0x00, 0xBF, + 0x30, 0xF8, 0x13, 0x60, + 0x76, 0x1B, 0x20, 0xF8, 0x13, 0x60, 0x5B, 0x1E, 0xF8, 0xD1, 0x06, 0x9B, + 0x01, 0xEB, 0x43, 0x01, + 0x00, 0xEB, 0x43, 0x00, 0x52, 0x1E, 0xBF, 0xF4, 0x63, 0xAF, 0x07, 0xB0, + 0xBD, 0xE8, 0xF0, 0x8F, + 0x2D, 0xE9, 0xF7, 0x4F, 0x79, 0x4D, 0x7A, 0x4C, 0x7A, 0x4F, 0x28, 0x68, + 0x0E, 0x46, 0x90, 0xF8, + 0xC0, 0x02, 0xC0, 0x07, 0x00, 0xD0, 0x3C, 0x68, 0x03, 0x20, 0xF8, 0xF7, + 0x9A, 0xF9, 0x77, 0x48, + 0xDF, 0xF8, 0xD4, 0xB1, 0x31, 0x46, 0x02, 0x68, 0xBB, 0xF9, 0x00, 0x30, + 0x20, 0x46, 0x0B, 0xF0, + 0xB0, 0xFE, 0x03, 0x20, 0xF8, 0xF7, 0xA8, 0xF9, 0x28, 0x68, 0xDF, 0xF8, + 0xC4, 0xA1, 0x71, 0x4E, + 0x90, 0xF8, 0xC0, 0x02, 0xC0, 0x07, 0x06, 0xD0, 0x9A, 0xF8, 0x00, 0x30, + 0x32, 0x78, 0x21, 0x46, + 0x67, 0x48, 0xFF, 0xF7, 0x2B, 0xFF, 0xB9, 0x46, 0x65, 0x4A, 0x33, 0x78, + 0x4F, 0xF0, 0x00, 0x08, + 0x54, 0x46, 0x38, 0x68, 0x16, 0xE0, 0x00, 0xBF, 0xA0, 0xF8, 0x00, 0x80, + 0x01, 0x21, 0x09, 0xE0, + 0x00, 0xEB, 0x41, 0x07, 0x32, 0xF8, 0x11, 0xC0, 0x37, 0xF8, 0x02, 0x7C, + 0x67, 0x44, 0x20, 0xF8, + 0x11, 0x70, 0x49, 0x1C, 0x27, 0x78, 0xB9, 0x42, 0xF2, 0xDB, 0xF9, 0xB2, + 0x02, 0xEB, 0x41, 0x02, + 0x00, 0xEB, 0x41, 0x00, 0x5B, 0x1E, 0xE7, 0xD2, 0x5B, 0x48, 0x5C, 0x4F, + 0x02, 0x9B, 0x02, 0x68, + 0xD9, 0xF8, 0x00, 0x10, 0x38, 0x68, 0x00, 0xF0, 0x73, 0xFA, 0x28, 0x68, + 0x90, 0xF8, 0xC0, 0x02, + 0x80, 0x07, 0x06, 0xD5, 0x23, 0x78, 0x32, 0x78, 0x39, 0x68, 0x00, 0x98, + 0x00, 0xF0, 0x1C, 0xF8, + 0x06, 0xE0, 0xBB, 0xF9, 0x00, 0x00, 0x39, 0x68, 0x42, 0x00, 0x00, 0x98, + 0x0E, 0xF0, 0x55, 0xFE, + 0x28, 0x68, 0x90, 0xF8, 0xC0, 0x02, 0x00, 0x07, 0x08, 0xD5, 0x00, 0x99, + 0x23, 0x78, 0x32, 0x78, + 0x03, 0xB0, 0x08, 0x46, 0xBD, 0xE8, 0xF0, 0x4F, 0x00, 0xF0, 0x05, 0xBC, + 0xBD, 0xE8, 0xFE, 0x8F, + 0x47, 0x49, 0x00, 0x20, 0x08, 0x70, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x4F, + 0xA7, 0xB0, 0x1C, 0x46, + 0x0D, 0x46, 0x06, 0x46, 0x17, 0x46, 0xEA, 0x46, 0x0D, 0xF1, 0x4C, 0x0B, + 0x3C, 0xE0, 0x00, 0x22, + 0x60, 0x1E, 0x00, 0xF0, 0xFF, 0x09, 0x11, 0x46, 0x10, 0x46, 0x11, 0xE0, + 0x35, 0xF9, 0x10, 0x30, + 0x1A, 0x44, 0x43, 0x1C, 0x92, 0xFB, 0xF3, 0xFC, 0x2A, 0xF8, 0x10, 0xC0, + 0xA9, 0xEB, 0x00, 0x0C, + 0x40, 0x1C, 0x35, 0xF9, 0x1C, 0x80, 0x41, 0x44, 0x91, 0xFB, 0xF3, 0xF3, + 0x2B, 0xF8, 0x1C, 0x30, + 0xA0, 0x42, 0xEB, 0xDB, 0x20, 0x46, 0x52, 0x46, 0x5B, 0x46, 0x0C, 0xE0, + 0x32, 0xF9, 0x10, 0x10, + 0x33, 0xF9, 0x10, 0xC0, 0x61, 0x44, 0x35, 0xF8, 0x10, 0xC0, 0x01, 0xEB, + 0xD1, 0x71, 0xAC, 0xEB, + 0x61, 0x01, 0x26, 0xF8, 0x10, 0x10, 0x40, 0x1E, 0xF0, 0xD2, 0x20, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0xC0, 0x02, 0x40, 0x07, 0x04, 0xD5, 0x31, 0x46, 0x22, 0x46, 0x08, 0x46, + 0x00, 0xF0, 0x08, 0xF8, + 0x05, 0xEB, 0x44, 0x05, 0x06, 0xEB, 0x44, 0x06, 0x7F, 0x1E, 0xC0, 0xD2, + 0x27, 0xB0, 0x35, 0xE7, + 0xF0, 0xB5, 0x16, 0x4B, 0x00, 0x26, 0x35, 0x46, 0xD3, 0xF8, 0x00, 0xE0, + 0x34, 0x46, 0x13, 0x46, + 0xBE, 0xF9, 0xC6, 0x72, 0xC7, 0xF1, 0x00, 0x0C, 0x06, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x13, 0x70, + 0x67, 0x45, 0x01, 0xDA, 0x3E, 0x44, 0x6D, 0x1C, 0x5B, 0x1E, 0xF7, 0xD2, + 0x00, 0x2D, 0x01, 0xDD, + 0x96, 0xFB, 0xF5, 0xF4, 0xBE, 0xF8, 0xC8, 0x32, 0x5E, 0x42, 0xA6, 0x42, + 0x00, 0xDD, 0x1C, 0x44, + 0x53, 0x1B, 0x63, 0x43, 0x93, 0xFB, 0xF2, 0xF3, 0x05, 0xE0, 0x00, 0xBF, + 0x31, 0xF8, 0x12, 0x40, + 0xE4, 0x1A, 0x20, 0xF8, 0x12, 0x40, 0x52, 0x1E, 0xF8, 0xD2, 0xF0, 0xBD, + 0x4C, 0x07, 0x10, 0x00, + 0x4A, 0x0C, 0x01, 0x20, 0x80, 0x05, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, + 0x1C, 0x07, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, 0xED, 0x06, 0x10, 0x00, 0x9C, 0x06, 0x10, 0x00, + 0x18, 0x07, 0x10, 0x00, + 0xF3, 0x06, 0x10, 0x00, 0x2D, 0xE9, 0xFF, 0x4F, 0x83, 0xB0, 0x9A, 0x46, + 0x17, 0x46, 0x89, 0x46, + 0x00, 0x25, 0x4F, 0xF0, 0xAA, 0x0B, 0xDD, 0xF8, 0x40, 0x80, 0x5B, 0xE0, + 0x11, 0x98, 0x05, 0xFB, + 0x00, 0xF6, 0x05, 0xEB, 0x85, 0x00, 0xC4, 0x00, 0x1A, 0xF8, 0x04, 0x00, + 0x08, 0xB9, 0x38, 0x5D, + 0xE8, 0xB3, 0x0A, 0xF8, 0x04, 0xB0, 0x39, 0xF9, 0x16, 0x00, 0x00, 0xF0, + 0xC9, 0xF8, 0x29, 0xF8, + 0x16, 0x00, 0x38, 0x5D, 0x98, 0xB3, 0x39, 0x19, 0x01, 0x91, 0x11, 0xF8, + 0x28, 0x1C, 0x81, 0x42, + 0x1E, 0xD0, 0xAA, 0x28, 0x1C, 0xD0, 0x01, 0x98, 0x00, 0xF8, 0x28, 0xBC, + 0x11, 0x98, 0x31, 0x1A, + 0x03, 0x98, 0x00, 0x91, 0x30, 0xF9, 0x11, 0x00, 0x00, 0xF0, 0xB2, 0xF8, + 0x03, 0x9A, 0x00, 0x99, + 0x22, 0xF8, 0x11, 0x00, 0x0A, 0xEB, 0x04, 0x01, 0x01, 0xF8, 0x28, 0xBC, + 0x00, 0x99, 0x39, 0xF9, + 0x11, 0x00, 0x00, 0xF0, 0xA5, 0xF8, 0x00, 0x99, 0x29, 0xF8, 0x11, 0x00, + 0x38, 0x5D, 0x70, 0xB1, + 0x01, 0x98, 0x90, 0xF8, 0x28, 0x10, 0x38, 0x5D, 0x81, 0x42, 0x1A, 0xD0, + 0xAA, 0x28, 0x18, 0xD0, + 0x01, 0x98, 0x80, 0xF8, 0x28, 0xB0, 0x11, 0x98, 0x06, 0x44, 0x03, 0x98, + 0x00, 0xE0, 0x10, 0xE0, + 0x30, 0xF9, 0x16, 0x00, 0x00, 0xF0, 0x8C, 0xF8, 0x03, 0x99, 0x21, 0xF8, + 0x16, 0x00, 0x0A, 0xEB, + 0x04, 0x01, 0x81, 0xF8, 0x28, 0xB0, 0x39, 0xF9, 0x16, 0x00, 0x00, 0xF0, + 0x81, 0xF8, 0x29, 0xF8, + 0x16, 0x00, 0x6D, 0x1C, 0x45, 0x45, 0xA1, 0xD3, 0x07, 0xB0, 0xBD, 0xE8, + 0xF0, 0x8F, 0x44, 0x49, + 0x00, 0x20, 0x08, 0x60, 0x70, 0x47, 0x42, 0x49, 0x08, 0x60, 0x70, 0x47, + 0x2D, 0xE9, 0xF0, 0x4F, + 0x05, 0x46, 0x40, 0x48, 0x8B, 0xB0, 0x17, 0x46, 0x00, 0x78, 0x8A, 0x46, + 0x00, 0x28, 0x65, 0xD0, + 0x3D, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x00, 0x04, 0x80, 0x07, 0x5F, 0xD5, + 0x3B, 0x48, 0x04, 0x90, + 0x3B, 0x48, 0xDF, 0xF8, 0xDC, 0xB0, 0x01, 0x24, 0x90, 0xF8, 0x00, 0x80, + 0xDB, 0xF8, 0x00, 0x90, + 0x22, 0xE0, 0x01, 0x20, 0xA0, 0x40, 0x10, 0xEA, 0x09, 0x0F, 0x1C, 0xD1, + 0x35, 0x48, 0x00, 0xEB, + 0x84, 0x06, 0x04, 0x98, 0xB1, 0x78, 0x0E, 0xF0, 0xA9, 0xFE, 0x01, 0x46, + 0xB2, 0x78, 0x00, 0x23, + 0x0E, 0xE0, 0x30, 0x78, 0x06, 0xE0, 0x00, 0xBF, 0x11, 0xF8, 0x00, 0xC0, + 0xA4, 0x45, 0x00, 0xD1, + 0x0B, 0x54, 0x40, 0x1C, 0x96, 0xF8, 0x01, 0xC0, 0x84, 0x45, 0xF5, 0xDA, + 0x28, 0x31, 0x52, 0x1C, + 0xF0, 0x78, 0x90, 0x42, 0xED, 0xDA, 0x64, 0x1C, 0x44, 0x45, 0xDA, 0xD9, + 0xA8, 0x46, 0x05, 0xF1, + 0x02, 0x09, 0x00, 0x21, 0x21, 0x48, 0x0E, 0xF0, 0x89, 0xFE, 0x20, 0x4E, + 0x07, 0x90, 0x00, 0x21, + 0x70, 0x1C, 0x0E, 0xF0, 0x83, 0xFE, 0x05, 0xEB, 0x47, 0x04, 0xA5, 0x1E, + 0x3E, 0x44, 0x06, 0x90, + 0x70, 0x1E, 0x00, 0x21, 0x24, 0x1F, 0x0E, 0xF0, 0x79, 0xFE, 0x03, 0x90, + 0xB0, 0x1E, 0x00, 0x21, + 0x0E, 0xF0, 0x74, 0xFE, 0xCD, 0xE9, 0x00, 0xA7, 0xDD, 0xE9, 0x06, 0x32, + 0x06, 0x46, 0x49, 0x46, + 0x40, 0x46, 0xFF, 0xF7, 0x27, 0xFF, 0xCD, 0xE9, 0x00, 0xA7, 0x33, 0x46, + 0x21, 0x46, 0x28, 0x46, + 0x03, 0x9A, 0xFF, 0xF7, 0x1F, 0xFF, 0x00, 0x20, 0xCB, 0xF8, 0x00, 0x00, + 0x0B, 0xB0, 0x84, 0xE7, + 0x09, 0x49, 0x09, 0x68, 0x91, 0xF8, 0x08, 0x24, 0x42, 0x43, 0x64, 0x20, + 0x92, 0xFB, 0xF0, 0xF0, + 0xB1, 0xF8, 0x06, 0x24, 0x00, 0xB2, 0x82, 0x42, 0x01, 0xDA, 0xB1, 0xF9, + 0x06, 0x04, 0x70, 0x47, + 0x7C, 0x05, 0x10, 0x00, 0xA4, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0xC2, 0x18, 0x01, 0x20, + 0x39, 0x06, 0x10, 0x00, 0x5A, 0x1C, 0x01, 0x20, 0x2D, 0xE9, 0xF0, 0x4F, + 0xFE, 0x4C, 0x80, 0x25, + 0xFE, 0x4E, 0x23, 0x68, 0x93, 0xF8, 0x31, 0x10, 0x93, 0xF8, 0x30, 0x00, + 0x01, 0xFB, 0x00, 0xF2, + 0x02, 0xE0, 0x00, 0xBF, 0x26, 0xF8, 0x12, 0x50, 0x52, 0x1E, 0xFB, 0xD2, + 0x93, 0xF8, 0xA0, 0x22, + 0xA6, 0x46, 0x12, 0x07, 0x4F, 0xF0, 0x64, 0x08, 0x31, 0xD5, 0x4A, 0x1E, + 0x02, 0xFB, 0x00, 0xFA, + 0xDF, 0xF8, 0xC8, 0xB3, 0x03, 0xF5, 0x94, 0x69, 0x02, 0x46, 0x26, 0xE0, + 0x19, 0xF8, 0x02, 0x30, + 0x0A, 0xEB, 0x02, 0x04, 0xDB, 0x01, 0xB3, 0xFB, 0xF8, 0xF3, 0x0B, 0xEB, + 0x44, 0x05, 0x0C, 0x46, + 0x19, 0xE0, 0x80, 0x2B, 0x05, 0xDD, 0xC3, 0xF1, 0x80, 0x06, 0x66, 0x43, + 0x96, 0xFB, 0xF1, 0xF6, + 0x06, 0xE0, 0xA3, 0xF1, 0x80, 0x06, 0x06, 0xFB, 0x04, 0xF7, 0x97, 0xFB, + 0xF1, 0xF7, 0xF6, 0x1B, + 0xB5, 0xF9, 0x00, 0x70, 0x80, 0x36, 0x77, 0x43, 0xFE, 0x17, 0x07, 0xEB, + 0x56, 0x66, 0xF6, 0x11, + 0x2E, 0x80, 0xA5, 0xEB, 0x40, 0x05, 0x64, 0x1E, 0xE3, 0xD2, 0x52, 0x1E, + 0xD6, 0xD2, 0xDE, 0xF8, + 0x00, 0x20, 0xF2, 0x46, 0x92, 0xF8, 0xA0, 0x32, 0xDB, 0x06, 0x2F, 0xD5, + 0x02, 0xF5, 0x98, 0x69, + 0xD6, 0x4B, 0x4A, 0x1E, 0x42, 0x43, 0x03, 0xEB, 0x42, 0x05, 0x0A, 0x46, + 0x24, 0xE0, 0x00, 0xBF, + 0x19, 0xF8, 0x02, 0x30, 0xDB, 0x01, 0xB3, 0xFB, 0xF8, 0xF6, 0x03, 0x46, + 0x18, 0xE0, 0x80, 0x2E, + 0x05, 0xDD, 0xC6, 0xF1, 0x80, 0x04, 0x5C, 0x43, 0x94, 0xFB, 0xF0, 0xF4, + 0x06, 0xE0, 0xA6, 0xF1, + 0x80, 0x04, 0x04, 0xFB, 0x03, 0xF7, 0x97, 0xFB, 0xF0, 0xF7, 0xE4, 0x1B, + 0x35, 0xF9, 0x13, 0x70, + 0x80, 0x34, 0x67, 0x43, 0xFC, 0x17, 0x07, 0xEB, 0x54, 0x64, 0xE4, 0x11, + 0x25, 0xF8, 0x13, 0x40, + 0x5B, 0x1E, 0xE4, 0xD2, 0xA5, 0xEB, 0x40, 0x05, 0x52, 0x1E, 0xD9, 0xD2, + 0xDA, 0xF8, 0x00, 0x40, + 0x94, 0xF8, 0xA1, 0x22, 0xD2, 0x07, 0x20, 0xD0, 0xBC, 0x4E, 0x00, 0x23, + 0x04, 0xF5, 0x9C, 0x64, + 0x19, 0xE0, 0x00, 0xBF, 0x03, 0xFB, 0x00, 0xF2, 0x06, 0xEB, 0x42, 0x07, + 0x00, 0x22, 0x0F, 0xE0, + 0xA5, 0x5C, 0xED, 0x01, 0xB5, 0xFB, 0xF8, 0xFC, 0x37, 0xF9, 0x12, 0x50, + 0x05, 0xFB, 0x0C, 0xF5, + 0x4F, 0xEA, 0xE5, 0x7C, 0x05, 0xEB, 0x5C, 0x65, 0xED, 0x11, 0x27, 0xF8, + 0x12, 0x50, 0x52, 0x1C, + 0x82, 0x42, 0xED, 0xD3, 0x5B, 0x1C, 0x8B, 0x42, 0xE4, 0xD3, 0xBD, 0xE8, + 0xF0, 0x8F, 0x30, 0xB5, + 0x0B, 0xE0, 0x00, 0xBF, 0x31, 0xF9, 0x13, 0x40, 0x32, 0xF9, 0x13, 0x50, + 0x6C, 0x43, 0xE5, 0x17, + 0x04, 0xEB, 0x55, 0x64, 0xE4, 0x11, 0x20, 0xF8, 0x13, 0x40, 0x5B, 0x1E, + 0xF2, 0xD2, 0x30, 0xBD, + 0x08, 0xB5, 0x00, 0x93, 0x13, 0x46, 0xA2, 0x4A, 0xB2, 0xF9, 0x00, 0x20, + 0x0B, 0xF0, 0x06, 0xFC, + 0x08, 0xBD, 0x2D, 0xE9, 0xF0, 0x5F, 0xDF, 0xF8, 0x70, 0x92, 0xDF, 0xF8, + 0x78, 0xB2, 0xD9, 0xF8, + 0x00, 0x10, 0xDB, 0xF8, 0x00, 0xC0, 0xB1, 0xF9, 0x00, 0x23, 0xB1, 0xF9, + 0x22, 0x33, 0xB1, 0xF9, + 0x42, 0x63, 0x5F, 0xEA, 0x8C, 0x70, 0x07, 0xD5, 0x97, 0x48, 0x00, 0x78, + 0x01, 0x28, 0x03, 0xD1, + 0xB1, 0xF9, 0x4E, 0x33, 0xB1, 0xF9, 0x50, 0x23, 0x94, 0x48, 0x47, 0x78, + 0x01, 0x2F, 0x7C, 0xD0, + 0x02, 0x2F, 0x04, 0xD3, 0xB1, 0xF8, 0x04, 0x03, 0x08, 0xB1, 0xB1, 0xF9, + 0x04, 0x23, 0x90, 0x4D, + 0x28, 0x78, 0x98, 0xB1, 0x91, 0xF8, 0x69, 0x03, 0x64, 0x24, 0x00, 0xFB, + 0x02, 0xF8, 0x98, 0xFB, + 0xF4, 0xF8, 0x42, 0x44, 0x00, 0xFB, 0x03, 0xF8, 0x70, 0x43, 0x98, 0xFB, + 0xF4, 0xF8, 0x90, 0xFB, + 0xF4, 0xF0, 0x43, 0x44, 0x30, 0x44, 0x12, 0xB2, 0x1B, 0xB2, 0x06, 0xB2, + 0x85, 0x4C, 0xDF, 0xF8, + 0x18, 0xA2, 0xDF, 0xF8, 0x18, 0xE2, 0x22, 0x80, 0xAA, 0xF8, 0x00, 0x30, + 0xAE, 0xF8, 0x00, 0x60, + 0x91, 0xF8, 0x02, 0x03, 0xDF, 0xF8, 0x08, 0x92, 0x10, 0x1A, 0x00, 0xB2, + 0xA9, 0xF8, 0x00, 0x00, + 0x91, 0xF8, 0x24, 0x83, 0xA3, 0xEB, 0x08, 0x08, 0x7E, 0x4B, 0xA3, 0xF8, + 0x00, 0x80, 0x91, 0xF8, + 0x44, 0x13, 0x76, 0x1A, 0x7C, 0x49, 0x5F, 0xEA, 0xCC, 0x78, 0x0E, 0x80, + 0x01, 0xD0, 0x02, 0x2F, + 0x02, 0xD3, 0xAA, 0xF8, 0x00, 0x20, 0x18, 0x80, 0xDA, 0x46, 0x5F, 0xEA, + 0x8C, 0x76, 0x01, 0xD5, + 0x02, 0x2F, 0x02, 0xD3, 0xAE, 0xF8, 0x00, 0x20, 0x08, 0x80, 0xB1, 0xF9, + 0x00, 0x20, 0xB3, 0xF9, + 0x00, 0x10, 0xC8, 0x46, 0x4F, 0x46, 0x0A, 0xF0, 0xF1, 0xFB, 0x70, 0x4E, + 0x00, 0xB2, 0x70, 0x4A, + 0x30, 0x80, 0x21, 0x88, 0x6F, 0x4B, 0x11, 0x80, 0xDF, 0xF8, 0x7C, 0x91, + 0x39, 0x88, 0x19, 0x80, + 0xD9, 0xF8, 0x00, 0x10, 0x91, 0xF8, 0x00, 0x74, 0xFF, 0x07, 0x10, 0xD0, + 0x5F, 0x4F, 0x7F, 0x78, + 0x0F, 0xB1, 0x91, 0xF8, 0x05, 0x74, 0xB1, 0xF8, 0x02, 0xC4, 0x67, 0x44, + 0x17, 0x80, 0x91, 0xF8, + 0x04, 0x14, 0x79, 0x1A, 0x09, 0xB2, 0x19, 0x80, 0x0A, 0xF0, 0xDE, 0xFB, + 0x30, 0x80, 0x62, 0x4F, + 0x62, 0x4A, 0x20, 0x88, 0x38, 0x80, 0x10, 0x80, 0x00, 0xE0, 0x0C, 0xE0, + 0x60, 0x49, 0xB8, 0xF8, + 0x00, 0x00, 0x08, 0x80, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x40, 0x34, + 0xDB, 0x07, 0x26, 0xD0, + 0x2B, 0x78, 0x6B, 0xB1, 0x23, 0xE0, 0x91, 0xF8, 0x03, 0x03, 0x10, 0x44, + 0x02, 0xB2, 0x91, 0xF8, + 0x25, 0x03, 0x18, 0x44, 0x03, 0xB2, 0x91, 0xF8, 0x45, 0x03, 0x30, 0x44, + 0x06, 0xB2, 0x6E, 0xE7, + 0xB0, 0xF8, 0x42, 0x34, 0x13, 0xB1, 0xB0, 0xF8, 0x42, 0x34, 0x3B, 0x80, + 0xB0, 0xF8, 0x44, 0x34, + 0x33, 0xB1, 0xB0, 0xF8, 0x44, 0x34, 0x13, 0x80, 0x90, 0xF8, 0x46, 0x04, + 0x18, 0x1A, 0x08, 0x80, + 0xB1, 0xF9, 0x00, 0x10, 0xB6, 0xF9, 0x00, 0x00, 0x0A, 0xF0, 0xA6, 0xFB, + 0x30, 0x80, 0x49, 0x4E, + 0x20, 0x88, 0x30, 0x80, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x20, 0x14, + 0xC9, 0x07, 0x07, 0xD0, + 0x29, 0x78, 0x29, 0xB9, 0xB0, 0xF8, 0x21, 0x14, 0x11, 0xB1, 0xB0, 0xF8, + 0x21, 0x14, 0x31, 0x80, + 0x9A, 0xF8, 0x00, 0x10, 0xC9, 0x06, 0x07, 0xD5, 0x3F, 0x49, 0x09, 0x78, + 0x21, 0xB1, 0xB0, 0xF8, + 0x6B, 0x12, 0x21, 0x80, 0xA8, 0xF8, 0x00, 0x10, 0x3C, 0x4C, 0xB0, 0xF9, + 0xB2, 0x02, 0x20, 0x80, + 0xB7, 0xF9, 0x00, 0x10, 0x0A, 0xF0, 0x80, 0xFB, 0x00, 0xB2, 0x20, 0x80, + 0xB6, 0xF9, 0x00, 0x10, + 0x0A, 0xF0, 0x7A, 0xFB, 0x20, 0x80, 0xBD, 0xE8, 0xF0, 0x9F, 0x2D, 0xE9, + 0xFF, 0x4F, 0x8A, 0x46, + 0x81, 0x46, 0x33, 0x49, 0x0D, 0x98, 0x93, 0x46, 0x4A, 0x0C, 0x04, 0x46, + 0x08, 0xE0, 0x00, 0xBF, + 0x3A, 0xF9, 0x14, 0x30, 0x93, 0x42, 0x00, 0xDA, 0x1A, 0x46, 0x8B, 0x42, + 0x00, 0xDD, 0x19, 0x46, + 0x64, 0x1E, 0xF5, 0xD2, 0x00, 0x25, 0x00, 0x29, 0x01, 0xDA, 0x0D, 0x46, + 0x02, 0xE0, 0x00, 0x2A, + 0x00, 0xDD, 0x15, 0x46, 0x00, 0x23, 0x1C, 0x46, 0x1E, 0x46, 0x19, 0x46, + 0x1F, 0x46, 0x02, 0x46, + 0x12, 0xE0, 0x00, 0xBF, 0x3A, 0xF9, 0x12, 0xC0, 0xAC, 0xEB, 0x05, 0x0C, + 0xDC, 0x45, 0x0B, 0xDA, + 0x0C, 0xEB, 0x0B, 0x08, 0xB8, 0xF1, 0x00, 0x0F, 0x06, 0xDD, 0x02, 0xFB, + 0x02, 0x44, 0x02, 0xFB, + 0x0C, 0x11, 0x13, 0x44, 0x66, 0x44, 0x7F, 0x1C, 0x52, 0x1E, 0xEB, 0xD2, + 0x04, 0xFB, 0x07, 0xF2, + 0x03, 0xFB, 0x13, 0x2E, 0x2E, 0xE0, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x86, 0x12, 0x01, 0x20, + 0xFE, 0x06, 0x10, 0x00, 0x04, 0x07, 0x10, 0x00, 0xF9, 0x06, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0xFD, 0x06, 0x10, 0x00, 0x8C, 0x06, 0x10, 0x00, 0x8E, 0x06, 0x10, 0x00, + 0x90, 0x06, 0x10, 0x00, + 0x92, 0x06, 0x10, 0x00, 0x94, 0x06, 0x10, 0x00, 0x96, 0x06, 0x10, 0x00, + 0x98, 0x06, 0x10, 0x00, + 0xA0, 0x06, 0x10, 0x00, 0xA2, 0x06, 0x10, 0x00, 0xA8, 0x06, 0x10, 0x00, + 0xAA, 0x06, 0x10, 0x00, + 0xAC, 0x06, 0x10, 0x00, 0xA6, 0x06, 0x10, 0x00, 0x74, 0x05, 0x10, 0x00, + 0x9A, 0x06, 0x10, 0x00, + 0x00, 0x80, 0xFF, 0xFF, 0x01, 0xFB, 0x07, 0xF2, 0x03, 0xFB, 0x16, 0x27, + 0x74, 0x43, 0x01, 0xFB, + 0x13, 0x46, 0x00, 0x24, 0x21, 0x46, 0x02, 0x46, 0x25, 0xE0, 0x00, 0x23, + 0xBE, 0xF1, 0x00, 0x0F, + 0x0F, 0xD0, 0x07, 0xFB, 0x02, 0x6C, 0x9C, 0xFB, 0xFE, 0xF3, 0xDC, 0x46, + 0x5B, 0x45, 0x01, 0xDD, + 0x63, 0x46, 0x06, 0xE0, 0xDD, 0xF8, 0x0C, 0xC0, 0x13, 0xEB, 0x0C, 0x0F, + 0x01, 0xD5, 0x03, 0x9B, + 0x5B, 0x42, 0x3A, 0xF8, 0x12, 0xC0, 0x2B, 0x44, 0xAC, 0xEB, 0x03, 0x03, + 0xDD, 0xF8, 0x0C, 0xC0, + 0x1B, 0xB2, 0x63, 0x45, 0x05, 0xDA, 0x9C, 0x44, 0xBC, 0xF1, 0x00, 0x0F, + 0x01, 0xDD, 0x1C, 0x44, + 0x49, 0x1C, 0x29, 0xF8, 0x12, 0x30, 0x52, 0x1E, 0xD7, 0xD2, 0x01, 0xB9, + 0x01, 0x21, 0x94, 0xFB, + 0xF1, 0xF1, 0x04, 0xE0, 0x39, 0xF8, 0x10, 0x20, 0x52, 0x1A, 0x29, 0xF8, + 0x10, 0x20, 0x40, 0x1E, + 0xF8, 0xD2, 0xBD, 0xE8, 0xFF, 0x8F, 0x2D, 0xE9, 0xF8, 0x43, 0x1F, 0x46, + 0xFE, 0x4B, 0x0E, 0x46, + 0x05, 0x46, 0x1B, 0x68, 0x14, 0x46, 0xB3, 0xF9, 0xCA, 0x92, 0xB3, 0xF9, + 0xCC, 0x82, 0x0A, 0xE0, + 0x43, 0x46, 0x4A, 0x46, 0x31, 0x46, 0x28, 0x46, 0x00, 0x97, 0xFF, 0xF7, + 0x3E, 0xFF, 0x06, 0xEB, + 0x47, 0x06, 0x05, 0xEB, 0x47, 0x05, 0x64, 0x1E, 0xF2, 0xD2, 0xBD, 0xE8, + 0xF8, 0x83, 0x08, 0xE0, + 0x30, 0xF9, 0x12, 0x30, 0x00, 0x2B, 0x00, 0xDA, 0x5B, 0x42, 0x8B, 0x42, + 0x01, 0xDD, 0x01, 0x20, + 0x70, 0x47, 0x52, 0x1E, 0xF4, 0xD2, 0x00, 0x20, 0x70, 0x47, 0x05, 0xE0, + 0x30, 0xF9, 0x12, 0x30, + 0x8B, 0x42, 0x01, 0xDD, 0x01, 0x20, 0x70, 0x47, 0x52, 0x1E, 0xF7, 0xD2, + 0x00, 0x20, 0x70, 0x47, + 0x2D, 0xE9, 0xFC, 0x47, 0x04, 0x46, 0xE5, 0x48, 0xE5, 0x4F, 0x13, 0x46, + 0x02, 0x68, 0x38, 0x68, + 0xFF, 0xF7, 0x0E, 0xFE, 0x03, 0x20, 0xF7, 0xF7, 0xEC, 0xFC, 0xDF, 0xF8, + 0x7C, 0x93, 0xDF, 0xF8, + 0x84, 0x83, 0xE1, 0x4D, 0xD9, 0xF8, 0x00, 0x00, 0xE0, 0x4E, 0x90, 0xF8, + 0xA0, 0x02, 0x80, 0x07, + 0x15, 0xD5, 0xDF, 0x48, 0xB0, 0xF9, 0x00, 0x20, 0xDE, 0x48, 0xB0, 0xF9, + 0x00, 0x10, 0xDE, 0x48, + 0xB0, 0xF9, 0x00, 0x00, 0x0A, 0xF0, 0x62, 0xFA, 0x03, 0xB2, 0x29, 0x78, + 0x30, 0x78, 0xCD, 0xE9, + 0x00, 0x01, 0x39, 0x68, 0xD8, 0xF8, 0x00, 0x20, 0x08, 0x46, 0x00, 0xF0, + 0x3F, 0xF9, 0xD7, 0x48, + 0xD8, 0xF8, 0x00, 0x20, 0x39, 0x68, 0xB0, 0xF9, 0x00, 0x30, 0x20, 0x46, + 0x0B, 0xF0, 0xE1, 0xF9, + 0x03, 0x20, 0xF7, 0xF7, 0xD9, 0xFC, 0xD9, 0xF8, 0x00, 0x00, 0x4F, 0x46, + 0x90, 0xF8, 0xA0, 0x02, + 0x00, 0x06, 0x05, 0xD5, 0x21, 0x46, 0x2B, 0x78, 0x32, 0x78, 0x08, 0x46, + 0xFF, 0xF7, 0x83, 0xFF, + 0x38, 0x68, 0x90, 0xF8, 0xA0, 0x02, 0x40, 0x07, 0x25, 0xD5, 0x30, 0x78, + 0x2E, 0x78, 0x32, 0x46, + 0x1F, 0xE0, 0x00, 0x21, 0x03, 0x46, 0x0C, 0xE0, 0x03, 0xFB, 0x06, 0x27, + 0x34, 0xF9, 0x17, 0x50, + 0x00, 0x2D, 0x04, 0xDD, 0x09, 0xB1, 0x8D, 0x42, 0x03, 0xDA, 0x29, 0x46, + 0x01, 0xE0, 0x00, 0x21, + 0x43, 0x1C, 0x5B, 0x1E, 0xF0, 0xD2, 0x00, 0x29, 0x0B, 0xDD, 0x03, 0x46, + 0x07, 0xE0, 0x00, 0xBF, + 0x03, 0xFB, 0x06, 0x25, 0x34, 0xF8, 0x15, 0x70, 0x7F, 0x1A, 0x24, 0xF8, + 0x15, 0x70, 0x5B, 0x1E, + 0xF6, 0xD2, 0x52, 0x1E, 0xDD, 0xD2, 0xBD, 0xE8, 0xFC, 0x87, 0x2D, 0xE9, + 0xF0, 0x5F, 0x92, 0x46, + 0xB3, 0x4A, 0x4F, 0xF0, 0x00, 0x08, 0x8B, 0x46, 0x15, 0x78, 0x06, 0x46, + 0x82, 0xF8, 0x00, 0x80, + 0xFF, 0xF7, 0x9F, 0xFD, 0x02, 0x21, 0xAF, 0x48, 0x07, 0xF0, 0x59, 0xFE, + 0xAE, 0x48, 0xAD, 0x4C, + 0x2A, 0x46, 0x00, 0x78, 0x31, 0x46, 0x01, 0x28, 0x20, 0x68, 0x5F, 0xD0, + 0xFF, 0xF7, 0x70, 0xFF, + 0x9D, 0x4D, 0xA1, 0x4F, 0xDF, 0xF8, 0x84, 0x92, 0x28, 0x68, 0x90, 0xF8, + 0xA1, 0x02, 0x80, 0x07, + 0x06, 0xD5, 0x21, 0x68, 0x3B, 0x78, 0x99, 0xF8, 0x00, 0x20, 0x08, 0x46, + 0x00, 0xF0, 0xDE, 0xF9, + 0x29, 0x68, 0x9E, 0x4E, 0x91, 0xF8, 0xA0, 0x02, 0x02, 0x07, 0x05, 0xD4, + 0xC0, 0x06, 0x03, 0xD4, + 0x91, 0xF8, 0xA1, 0x02, 0xC0, 0x07, 0x06, 0xD0, 0x21, 0x68, 0xB6, 0xF9, + 0x00, 0x30, 0x9B, 0x4A, + 0x08, 0x46, 0xFF, 0xF7, 0x54, 0xFD, 0xB6, 0xF9, 0x00, 0x00, 0x21, 0x68, + 0x42, 0x00, 0x98, 0x48, + 0x00, 0x68, 0x0E, 0xF0, 0x52, 0xF9, 0x3A, 0x78, 0x99, 0xF8, 0x00, 0x10, + 0x20, 0x68, 0xFF, 0xF7, + 0x0D, 0xFC, 0xDF, 0xF8, 0x50, 0x92, 0x99, 0xF8, 0x00, 0x00, 0x10, 0xF0, + 0x30, 0x0F, 0x04, 0xD0, + 0x51, 0x46, 0x58, 0x46, 0x22, 0x68, 0xFE, 0xF7, 0xCD, 0xFA, 0x8F, 0x48, + 0x8F, 0x4F, 0x40, 0x78, + 0x02, 0x28, 0x28, 0x68, 0x90, 0xF8, 0xA0, 0x12, 0x4F, 0xEA, 0x81, 0x61, + 0x19, 0xD3, 0x00, 0x29, + 0x07, 0xDA, 0x21, 0x68, 0xB0, 0xF9, 0xB0, 0x22, 0xB6, 0xF9, 0x00, 0x30, + 0x08, 0x46, 0x00, 0xF0, + 0x3E, 0xF9, 0x28, 0x68, 0x90, 0xF8, 0xA0, 0x12, 0x49, 0x06, 0x15, 0xD5, + 0xB0, 0xF9, 0xAE, 0x32, + 0x83, 0x4A, 0x21, 0x68, 0x38, 0x68, 0x06, 0xF0, 0xF9, 0xFA, 0x14, 0xE0, + 0xFF, 0xF7, 0x60, 0xFA, + 0x9E, 0xE7, 0x00, 0x29, 0x08, 0xDA, 0xB0, 0xF9, 0xB0, 0x22, 0xB6, 0xF9, + 0x00, 0x30, 0x21, 0x68, + 0x38, 0x68, 0x00, 0xF0, 0x24, 0xF9, 0x06, 0xE0, 0xB6, 0xF9, 0x00, 0x00, + 0x21, 0x68, 0x42, 0x00, + 0x38, 0x68, 0x0E, 0xF0, 0x0A, 0xF9, 0x02, 0x21, 0x6E, 0x48, 0x07, 0xF0, + 0x6B, 0xFE, 0x75, 0x48, + 0x00, 0x78, 0x60, 0xB1, 0xD9, 0xF8, 0x00, 0x00, 0x73, 0x49, 0xC2, 0x06, + 0x02, 0xD5, 0x0A, 0x78, + 0x01, 0x2A, 0x21, 0xD0, 0x80, 0x06, 0x02, 0xD5, 0x08, 0x78, 0x02, 0x28, + 0x1E, 0xD0, 0x6F, 0x48, + 0xB6, 0xF9, 0x00, 0x20, 0xB0, 0xF9, 0x00, 0x10, 0x38, 0x68, 0xFF, 0xF7, + 0xD6, 0xFE, 0x6C, 0x49, + 0x6C, 0x4D, 0xA8, 0xB1, 0x01, 0x20, 0x08, 0x70, 0x01, 0x46, 0x02, 0x24, + 0x6A, 0x48, 0x07, 0xF0, + 0xB6, 0xFD, 0x6B, 0x48, 0x69, 0x4B, 0xB0, 0xF9, 0x00, 0x20, 0x67, 0x48, + 0x01, 0x68, 0x38, 0x68, + 0x00, 0xF0, 0xFF, 0xF8, 0x28, 0x60, 0x0E, 0xE0, 0x03, 0x20, 0xE4, 0xE5, + 0x04, 0x20, 0xE2, 0xE5, + 0x64, 0x4A, 0xC5, 0xF8, 0x00, 0x80, 0x01, 0x24, 0xC2, 0xF8, 0x00, 0x80, + 0x5F, 0x4A, 0xC2, 0xF8, + 0x00, 0x80, 0x81, 0xF8, 0x00, 0x80, 0x20, 0x46, 0xD5, 0xE5, 0x4E, 0x49, + 0x10, 0xB5, 0x00, 0x20, + 0x08, 0x60, 0x57, 0x49, 0x08, 0x70, 0xFF, 0xF7, 0x7B, 0xFA, 0xFF, 0xF7, + 0x78, 0xFB, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0xF0, 0x01, 0xB8, 0x07, 0xE4, 0x3B, 0x48, 0x10, 0xB5, + 0x00, 0x68, 0x42, 0x49, + 0x40, 0x4B, 0xB0, 0xF8, 0x00, 0x23, 0x0A, 0x80, 0xB0, 0xF8, 0x22, 0x13, + 0x3C, 0x4C, 0x19, 0x80, + 0xB0, 0xF8, 0x42, 0x33, 0x23, 0x80, 0x50, 0x4C, 0x22, 0x80, 0x50, 0x4A, + 0x11, 0x80, 0x50, 0x49, + 0x0B, 0x80, 0x4B, 0x49, 0xB0, 0xF8, 0xB2, 0x02, 0x08, 0x80, 0x10, 0xBD, + 0x2D, 0xE9, 0xFF, 0x4F, + 0x9B, 0x46, 0xDD, 0xE9, 0x0D, 0x19, 0x86, 0x46, 0xA5, 0xE0, 0x00, 0xBF, + 0x01, 0x9A, 0x01, 0xFB, + 0x09, 0xF0, 0x02, 0xEB, 0x40, 0x04, 0x02, 0x9A, 0x46, 0x4F, 0x02, 0xEB, + 0x40, 0x06, 0x4F, 0xF0, + 0x01, 0x0C, 0x0E, 0xEB, 0x40, 0x05, 0x7B, 0x0C, 0xE2, 0x46, 0x4A, 0x46, + 0x15, 0xE0, 0x00, 0xBF, + 0x36, 0xF8, 0x12, 0x00, 0x34, 0xF8, 0x12, 0x80, 0xA0, 0xEB, 0x08, 0x00, + 0x00, 0xB2, 0x98, 0x42, + 0x00, 0xDA, 0x03, 0x46, 0xB8, 0x42, 0x00, 0xDD, 0x07, 0x46, 0x00, 0x28, + 0x02, 0xDD, 0x4F, 0xF0, + 0x00, 0x0A, 0x02, 0xE0, 0x01, 0xDA, 0x4F, 0xF0, 0x00, 0x0C, 0x52, 0x1E, + 0xE8, 0xD2, 0xBC, 0xF1, + 0x00, 0x0F, 0x04, 0xD0, 0xBA, 0xF1, 0x00, 0x0F, 0x01, 0xD0, 0x00, 0x20, + 0x0B, 0xE0, 0x5C, 0xEA, + 0x0A, 0x00, 0x08, 0xD0, 0xBC, 0xF1, 0x00, 0x0F, 0x04, 0xD1, 0xBA, 0xF1, + 0x00, 0x0F, 0x01, 0xD0, + 0x38, 0x46, 0x00, 0xE0, 0x18, 0x46, 0x00, 0x27, 0x3B, 0x46, 0x4A, 0x46, + 0xCB, 0xF1, 0x00, 0x0A, + 0x10, 0xE0, 0x00, 0xBF, 0x36, 0xF8, 0x12, 0xC0, 0x34, 0xF8, 0x12, 0x80, + 0xAC, 0xEB, 0x08, 0x0C, + 0xAC, 0xEB, 0x00, 0x0C, 0x0F, 0xFA, 0x8C, 0xFC, 0xDC, 0x45, 0x03, 0xDA, + 0xD4, 0x45, 0x01, 0xDD, + 0x67, 0x44, 0x5B, 0x1C, 0x52, 0x1E, 0x3F, 0xE0, 0x4C, 0x07, 0x10, 0x00, + 0x9C, 0x06, 0x10, 0x00, + 0x18, 0x07, 0x10, 0x00, 0x1C, 0x07, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0x90, 0x06, 0x10, 0x00, 0x8E, 0x06, 0x10, 0x00, 0x8C, 0x06, 0x10, 0x00, + 0xFE, 0x06, 0x10, 0x00, + 0x79, 0x07, 0x10, 0x00, 0x80, 0x05, 0x10, 0x00, 0xF3, 0x06, 0x10, 0x00, + 0x86, 0x12, 0x01, 0x20, + 0x14, 0x07, 0x10, 0x00, 0x04, 0x07, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, + 0x10, 0x07, 0x10, 0x00, + 0x0E, 0x7A, 0x01, 0x00, 0x64, 0x05, 0x10, 0x00, 0x66, 0x05, 0x10, 0x00, + 0x98, 0x06, 0x10, 0x00, + 0xF5, 0x06, 0x10, 0x00, 0x7C, 0x06, 0x10, 0x00, 0x50, 0x06, 0x10, 0x00, + 0x84, 0x06, 0x10, 0x00, + 0x9A, 0x06, 0x10, 0x00, 0x80, 0x06, 0x10, 0x00, 0x92, 0x06, 0x10, 0x00, + 0x94, 0x06, 0x10, 0x00, + 0x96, 0x06, 0x10, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xAC, 0xD2, 0x03, 0xB9, + 0x01, 0x23, 0x97, 0xFB, + 0xF3, 0xF2, 0x02, 0x44, 0x48, 0x46, 0x04, 0xE0, 0x34, 0xF8, 0x10, 0x30, + 0x13, 0x44, 0x25, 0xF8, + 0x10, 0x30, 0x40, 0x1E, 0xF8, 0xD2, 0x49, 0x1E, 0xBF, 0xF4, 0x58, 0xAF, + 0xA9, 0xE5, 0x70, 0xB5, + 0x00, 0x24, 0x26, 0x46, 0x0A, 0xE0, 0x00, 0xBF, 0x31, 0xF9, 0x14, 0x50, + 0x95, 0x42, 0x02, 0xDA, + 0x20, 0xF8, 0x14, 0x60, 0x01, 0xE0, 0x20, 0xF8, 0x14, 0x50, 0x64, 0x1C, + 0x9C, 0x42, 0xF3, 0xDB, + 0x70, 0xBD, 0x2D, 0xE9, 0xFF, 0x5F, 0x45, 0x4C, 0x88, 0x46, 0x00, 0x26, + 0x07, 0x46, 0x92, 0x46, + 0x35, 0x46, 0x4F, 0xF4, 0x66, 0x71, 0x40, 0x46, 0x26, 0x60, 0x0E, 0xF0, + 0x4D, 0xF8, 0x00, 0x21, + 0x40, 0x46, 0x0E, 0xF0, 0x5B, 0xF9, 0x81, 0x46, 0x00, 0x21, 0x38, 0x46, + 0x0E, 0xF0, 0x4E, 0xF9, + 0x00, 0x22, 0x3B, 0x4B, 0x3B, 0x4F, 0x29, 0xE0, 0x00, 0x21, 0x4F, 0xF0, + 0x01, 0x0E, 0xDF, 0xF8, + 0xE8, 0xB0, 0x18, 0xE0, 0x30, 0xF9, 0x11, 0x80, 0xD0, 0x45, 0x05, 0xDD, + 0x09, 0xF8, 0x01, 0xE0, + 0x30, 0xF9, 0x11, 0xC0, 0x76, 0x1C, 0x65, 0x44, 0xDB, 0xF8, 0x00, 0xC0, + 0x30, 0xF9, 0x11, 0x80, + 0xBC, 0xF8, 0x55, 0xC3, 0xE0, 0x45, 0x05, 0xDD, 0xD4, 0xF8, 0x00, 0xC0, + 0x0C, 0xF1, 0x01, 0x0C, + 0xC4, 0xF8, 0x00, 0xC0, 0x49, 0x1C, 0x93, 0xF8, 0x00, 0xC0, 0x61, 0x45, + 0xE2, 0xDB, 0x0C, 0xF0, + 0xFF, 0x01, 0x09, 0xF1, 0x28, 0x09, 0x00, 0xEB, 0x41, 0x00, 0x52, 0x1C, + 0x39, 0x78, 0x8A, 0x42, + 0xD2, 0xDB, 0x03, 0x98, 0x05, 0x60, 0x30, 0x46, 0x04, 0xB0, 0x9C, 0xE4, + 0x2D, 0xE9, 0xF0, 0x43, + 0x91, 0x46, 0x1C, 0x46, 0x35, 0xE0, 0x21, 0x4D, 0x4F, 0xF0, 0x01, 0x0C, + 0x6A, 0x0C, 0xE0, 0x46, + 0x4F, 0x46, 0x11, 0xE0, 0x07, 0xFB, 0x03, 0x46, 0x31, 0xF9, 0x16, 0x60, + 0x96, 0x42, 0x00, 0xDA, + 0x32, 0x46, 0xAE, 0x42, 0x00, 0xDD, 0x35, 0x46, 0x00, 0x2E, 0x02, 0xDD, + 0x4F, 0xF0, 0x00, 0x08, + 0x02, 0xE0, 0x01, 0xDA, 0x4F, 0xF0, 0x00, 0x0C, 0x7F, 0x1E, 0xEB, 0xD2, + 0xBC, 0xF1, 0x00, 0x0F, + 0x02, 0xD0, 0xB8, 0xF1, 0x00, 0x0F, 0x14, 0xD1, 0x5C, 0xEA, 0x08, 0x06, + 0x11, 0xD0, 0xBC, 0xF1, + 0x00, 0x0F, 0x03, 0xD1, 0xB8, 0xF1, 0x00, 0x0F, 0x00, 0xD0, 0x2A, 0x46, + 0x4E, 0x46, 0x06, 0xE0, + 0x06, 0xFB, 0x03, 0x45, 0x31, 0xF8, 0x15, 0x70, 0xBF, 0x1A, 0x20, 0xF8, + 0x15, 0x70, 0x76, 0x1E, + 0xF6, 0xD2, 0x64, 0x1E, 0xC7, 0xD2, 0xBD, 0xE8, 0xF0, 0x83, 0x00, 0x00, + 0x80, 0x06, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, 0xED, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x00, 0x80, 0xFF, 0xFF, + 0x70, 0x47, 0xA5, 0x4A, 0x30, 0xB4, 0x12, 0x68, 0x92, 0xF8, 0xA4, 0x23, + 0x12, 0x09, 0x80, 0xF8, + 0x28, 0x20, 0x0A, 0x68, 0x02, 0x62, 0x4A, 0x68, 0x42, 0x62, 0xB1, 0xF9, + 0x02, 0x20, 0xD3, 0x17, + 0x1B, 0x04, 0x43, 0xEA, 0x12, 0x43, 0x12, 0x04, 0x82, 0x60, 0xC3, 0x60, + 0xB1, 0xF9, 0x00, 0x10, + 0xCA, 0x17, 0x12, 0x04, 0x42, 0xEA, 0x11, 0x42, 0x09, 0x04, 0x01, 0x60, + 0x42, 0x60, 0x10, 0x22, + 0x01, 0x46, 0x30, 0xBC, 0x10, 0x30, 0x0D, 0xF0, 0x20, 0xBF, 0x2D, 0xE9, + 0xF0, 0x4F, 0x92, 0x4F, + 0x81, 0x46, 0x8A, 0x46, 0x38, 0x68, 0x8F, 0xB0, 0x16, 0x46, 0xB0, 0xF8, + 0xA6, 0x13, 0x90, 0xF8, + 0xAA, 0x53, 0x01, 0xFB, 0x01, 0xFB, 0xB0, 0xF8, 0xA8, 0x13, 0x01, 0xFB, + 0x01, 0xF8, 0x0E, 0xF0, + 0x5B, 0xF8, 0x00, 0x28, 0x38, 0x68, 0x02, 0xD0, 0x90, 0xF8, 0xAC, 0x43, + 0x01, 0xE0, 0x90, 0xF8, + 0xAB, 0x43, 0xAC, 0x42, 0x00, 0xD2, 0x25, 0x46, 0x00, 0x2E, 0x02, 0xDB, + 0x89, 0xF8, 0x28, 0x60, + 0x19, 0xE0, 0x09, 0xF1, 0x24, 0x01, 0x99, 0xF8, 0x28, 0x60, 0x08, 0x1F, + 0x0A, 0xF0, 0x5B, 0xF8, + 0x58, 0x45, 0x01, 0xDB, 0x26, 0x46, 0x02, 0xE0, 0x40, 0x45, 0x00, 0xDC, + 0x2E, 0x46, 0x38, 0x68, + 0x99, 0xF8, 0x28, 0x10, 0x90, 0xF8, 0xA4, 0x03, 0x00, 0xF0, 0x0F, 0x02, + 0x30, 0x46, 0x0A, 0xF0, + 0x6D, 0xF8, 0x89, 0xF8, 0x28, 0x00, 0x99, 0xF8, 0x28, 0x10, 0x74, 0x48, + 0x00, 0xEB, 0x81, 0x00, + 0x01, 0x68, 0xCA, 0x17, 0xCD, 0xE9, 0x07, 0x21, 0x41, 0x6C, 0xCA, 0x17, + 0xCD, 0xE9, 0x04, 0x12, + 0xD0, 0xF8, 0xCC, 0x20, 0xD0, 0xF8, 0x88, 0x50, 0xD4, 0x17, 0x01, 0x94, + 0x93, 0x46, 0xDD, 0xE9, + 0x07, 0x21, 0xD9, 0xF8, 0x08, 0x30, 0xD9, 0xF8, 0x0C, 0x40, 0xA3, 0xFB, + 0x01, 0x07, 0x04, 0xFB, + 0x01, 0x71, 0x03, 0xFB, 0x02, 0x11, 0xEE, 0x17, 0x4F, 0xF4, 0x80, 0x32, + 0x00, 0x23, 0x0D, 0xF0, + 0x98, 0xFE, 0xBA, 0xF9, 0x02, 0x30, 0xB9, 0xF9, 0x26, 0x20, 0x01, 0x9C, + 0x9F, 0x18, 0xA7, 0xFB, + 0x0B, 0x38, 0x4F, 0xEA, 0xE7, 0x7C, 0x0C, 0xFB, 0x0B, 0x82, 0x07, 0xFB, + 0x04, 0x24, 0xB9, 0xF9, + 0x22, 0x20, 0xA2, 0xFB, 0x05, 0xC8, 0xD7, 0x17, 0x07, 0xFB, 0x05, 0x87, + 0x13, 0xEB, 0x0C, 0x03, + 0x02, 0xFB, 0x06, 0x72, 0x54, 0x41, 0x1F, 0x1A, 0x64, 0xEB, 0x01, 0x04, + 0xDD, 0xE9, 0x04, 0x12, + 0xD9, 0xF8, 0x18, 0x30, 0xD9, 0xF8, 0x1C, 0xC0, 0xA3, 0xFB, 0x01, 0x08, + 0x0C, 0xFB, 0x01, 0x81, + 0x03, 0xFB, 0x02, 0x11, 0x4F, 0xF4, 0x80, 0x32, 0x00, 0x23, 0x0D, 0xF0, + 0x6A, 0xFE, 0x38, 0x1A, + 0x64, 0xEB, 0x01, 0x04, 0xCD, 0xE9, 0x0D, 0x04, 0x06, 0x94, 0x0A, 0x90, + 0xDD, 0xE9, 0x07, 0x21, + 0xD9, 0xF8, 0x00, 0x30, 0xD9, 0xF8, 0x04, 0x40, 0xA3, 0xFB, 0x01, 0x07, + 0x04, 0xFB, 0x01, 0x71, + 0x03, 0xFB, 0x02, 0x11, 0x4F, 0xF4, 0x80, 0x32, 0x00, 0x23, 0x0D, 0xF0, + 0x52, 0xFE, 0xBA, 0xF9, + 0x00, 0x30, 0xB9, 0xF9, 0x24, 0x20, 0x01, 0x9C, 0x13, 0x44, 0xA3, 0xFB, + 0x0B, 0xC8, 0xDF, 0x17, + 0x07, 0xFB, 0x0B, 0x82, 0x03, 0xFB, 0x04, 0x27, 0xB9, 0xF9, 0x20, 0x20, + 0xA2, 0xFB, 0x05, 0x48, + 0xD3, 0x17, 0x03, 0xFB, 0x05, 0x83, 0x02, 0xFB, 0x06, 0x32, 0x1C, 0xEB, + 0x04, 0x03, 0x57, 0x41, + 0x1C, 0x1A, 0x67, 0xEB, 0x01, 0x07, 0xDD, 0xE9, 0x04, 0x12, 0xD9, 0xF8, + 0x10, 0x30, 0xD9, 0xF8, + 0x14, 0x50, 0xA3, 0xFB, 0x01, 0x06, 0x05, 0xFB, 0x01, 0x61, 0x03, 0xFB, + 0x02, 0x11, 0x4F, 0xF4, + 0x80, 0x32, 0x00, 0x23, 0x0D, 0xF0, 0x25, 0xFE, 0x25, 0x1A, 0x67, 0xEB, + 0x01, 0x07, 0xCD, 0xE9, + 0x0B, 0x57, 0xD9, 0xF8, 0x20, 0x10, 0xC9, 0xF8, 0x24, 0x10, 0xDA, 0xF8, + 0x00, 0x10, 0xC9, 0xF8, + 0x20, 0x10, 0x10, 0x22, 0x49, 0x46, 0x09, 0xF1, 0x10, 0x00, 0x0D, 0xF0, + 0x36, 0xFE, 0x10, 0x22, + 0x0B, 0xA9, 0x48, 0x46, 0x0D, 0xF0, 0x31, 0xFE, 0x0A, 0x98, 0x4F, 0xF4, + 0x00, 0x41, 0x06, 0x9C, + 0x40, 0x18, 0x44, 0xF1, 0x00, 0x01, 0x4F, 0xF4, 0x80, 0x32, 0x00, 0x23, + 0x0D, 0xF0, 0x01, 0xFE, + 0xAA, 0xF8, 0x02, 0x00, 0x4F, 0xF4, 0x00, 0x40, 0x28, 0x18, 0x47, 0xF1, + 0x00, 0x01, 0x4F, 0xF4, + 0x80, 0x32, 0x00, 0x23, 0x0D, 0xF0, 0xF5, 0xFD, 0xAA, 0xF8, 0x00, 0x00, + 0x0F, 0xB0, 0xBD, 0xE8, + 0xF0, 0x8F, 0x70, 0xB5, 0x0D, 0x46, 0x04, 0x46, 0x01, 0x46, 0x10, 0x22, + 0x10, 0x30, 0x0D, 0xF0, + 0x0C, 0xFE, 0xB5, 0xF9, 0x02, 0x00, 0xC1, 0x17, 0x09, 0x04, 0x41, 0xEA, + 0x10, 0x41, 0x00, 0x04, + 0xA0, 0x60, 0xE1, 0x60, 0xB5, 0xF9, 0x00, 0x00, 0xC1, 0x17, 0x09, 0x04, + 0x41, 0xEA, 0x10, 0x41, + 0x00, 0x04, 0x20, 0x60, 0x61, 0x60, 0x70, 0xBD, 0x4C, 0x07, 0x10, 0x00, + 0xFE, 0x78, 0x01, 0x00, + 0x70, 0xB5, 0x04, 0x46, 0x00, 0x20, 0x84, 0xF8, 0x42, 0x01, 0x94, 0xF8, + 0x3F, 0x01, 0xF8, 0x4D, + 0x0E, 0x46, 0x01, 0x28, 0x0B, 0xD0, 0x0D, 0xF0, 0x37, 0xFF, 0x00, 0x28, + 0x94, 0xF9, 0x4C, 0x01, + 0x35, 0xD0, 0xB0, 0x42, 0x28, 0x68, 0x90, 0xF8, 0x9B, 0x03, 0x1A, 0xD1, + 0x11, 0xE0, 0xF1, 0x48, + 0x00, 0x78, 0x58, 0xB1, 0x0D, 0xF0, 0x28, 0xFF, 0x00, 0x28, 0x94, 0xF9, + 0x4C, 0x01, 0x0B, 0xD0, + 0xB0, 0x42, 0x28, 0x68, 0x90, 0xF8, 0x4D, 0x03, 0x03, 0xD0, 0x0A, 0xE0, + 0x28, 0x68, 0x90, 0xF8, + 0x4B, 0x03, 0x00, 0xF0, 0x0F, 0x00, 0x05, 0xE0, 0xB0, 0x42, 0x28, 0x68, + 0x90, 0xF8, 0x4C, 0x03, + 0xF7, 0xD0, 0x00, 0x09, 0x84, 0xF8, 0x42, 0x01, 0xE3, 0x48, 0x00, 0x78, + 0x48, 0xB1, 0x29, 0x68, + 0x94, 0xF8, 0x42, 0x01, 0x91, 0xF8, 0x63, 0x12, 0x01, 0xF0, 0x0F, 0x01, + 0x08, 0x44, 0x84, 0xF8, + 0x42, 0x01, 0x20, 0x46, 0x00, 0xF0, 0x4A, 0xF9, 0x01, 0x28, 0x06, 0xD0, + 0x0F, 0xE0, 0xB0, 0x42, + 0x28, 0x68, 0x90, 0xF8, 0x9A, 0x03, 0xE4, 0xD1, 0xDB, 0xE7, 0x29, 0x68, + 0x94, 0xF8, 0x42, 0x01, + 0x91, 0xF8, 0x9C, 0x13, 0x01, 0xF0, 0x0F, 0x01, 0x08, 0x44, 0x84, 0xF8, + 0x42, 0x01, 0xD3, 0x48, + 0xD3, 0x49, 0x00, 0x78, 0x09, 0x78, 0x08, 0x43, 0x07, 0xD0, 0x29, 0x68, + 0x94, 0xF8, 0x42, 0x01, + 0x91, 0xF8, 0x9D, 0x13, 0x08, 0x44, 0x84, 0xF8, 0x42, 0x01, 0x70, 0xBD, + 0xC9, 0x49, 0x10, 0xB5, + 0x0C, 0x78, 0xC7, 0x49, 0x90, 0xF8, 0x42, 0x21, 0x09, 0x68, 0x91, 0xF8, + 0x9A, 0x33, 0x03, 0xF0, + 0x0F, 0x03, 0x5C, 0xB1, 0x91, 0xF8, 0x4C, 0x13, 0x01, 0xF0, 0x0F, 0x01, + 0xC9, 0x1A, 0x51, 0x1A, + 0x00, 0x29, 0x00, 0xDC, 0x00, 0x21, 0x80, 0xF8, 0x42, 0x11, 0x10, 0xBD, + 0x91, 0xF8, 0x4B, 0x13, + 0xF2, 0xE7, 0xC0, 0x49, 0x00, 0x20, 0x08, 0x70, 0xBF, 0x49, 0x08, 0x70, + 0xB9, 0x49, 0x08, 0x70, + 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x4F, 0x8B, 0xB0, 0x4F, 0xF0, 0x00, 0x09, + 0x00, 0xF5, 0x80, 0x55, + 0x04, 0x46, 0x8D, 0xF8, 0x10, 0x90, 0x8D, 0xF8, 0x14, 0x90, 0xB5, 0xF8, + 0xEC, 0x03, 0xB5, 0x4A, + 0x00, 0x04, 0x00, 0x0C, 0x0A, 0xD0, 0x4F, 0xF0, 0xFF, 0x36, 0x10, 0x78, + 0x31, 0x46, 0x4F, 0xF0, + 0x00, 0x48, 0x93, 0x46, 0x4F, 0xF0, 0x01, 0x0A, 0xF8, 0xB9, 0x04, 0xE0, + 0x48, 0x46, 0x82, 0xF8, + 0x00, 0x90, 0xAD, 0x49, 0xDE, 0xE0, 0x04, 0xF5, 0x80, 0x52, 0x00, 0x20, + 0x92, 0xF9, 0xF4, 0x73, + 0x22, 0xE0, 0x00, 0xBF, 0xD2, 0xF8, 0xEC, 0xC3, 0x0A, 0xFA, 0x00, 0xF3, + 0x1C, 0xEA, 0x03, 0x0F, + 0x18, 0xD0, 0x00, 0xEB, 0x00, 0x13, 0x03, 0xEB, 0x83, 0x03, 0x04, 0xEB, + 0x83, 0x03, 0x93, 0xF8, + 0x3E, 0xC1, 0xBC, 0xF1, 0x01, 0x0F, 0x01, 0xD0, 0x31, 0x46, 0x0F, 0xE0, + 0xB3, 0xF8, 0x44, 0xC0, + 0xBC, 0xF1, 0x00, 0x0F, 0x06, 0xD0, 0x5B, 0x6B, 0x93, 0xFB, 0xFC, 0xF3, + 0x98, 0x45, 0x01, 0xDA, + 0x98, 0x46, 0x01, 0x46, 0x40, 0x1C, 0x40, 0xB2, 0x87, 0x42, 0xDB, 0xDA, + 0x00, 0x27, 0xDF, 0xF8, + 0x40, 0x82, 0x01, 0x91, 0x9D, 0xE0, 0x00, 0xBF, 0xD5, 0xF8, 0xEC, 0x13, + 0x0A, 0xFA, 0x07, 0xF0, + 0x01, 0x42, 0x60, 0xD0, 0x07, 0xEB, 0x07, 0x10, 0x00, 0xEB, 0x80, 0x00, + 0x04, 0xEB, 0x80, 0x06, + 0x96, 0xF8, 0x3E, 0x01, 0x01, 0x28, 0x02, 0xD0, 0x05, 0x28, 0x08, 0xD0, + 0x10, 0xE0, 0x30, 0x46, + 0x01, 0x99, 0xFF, 0xF7, 0x0D, 0xFF, 0x02, 0x20, 0x86, 0xF8, 0x3E, 0x01, + 0x11, 0xE0, 0x30, 0x46, + 0x00, 0xF0, 0xB0, 0xF8, 0x06, 0x20, 0x86, 0xF8, 0x3E, 0x01, 0x30, 0x46, + 0x00, 0xF0, 0x48, 0xF9, + 0x96, 0xF8, 0x3E, 0x01, 0x02, 0x28, 0x04, 0xD0, 0x06, 0x28, 0x32, 0xD0, + 0x07, 0x28, 0x3B, 0xD0, + 0x46, 0xE0, 0x96, 0xF8, 0x42, 0x00, 0xC0, 0x07, 0x13, 0xD0, 0x30, 0x46, + 0x00, 0xF0, 0x7E, 0xF8, + 0x78, 0xB9, 0xD8, 0xF8, 0x00, 0x10, 0x96, 0xF8, 0x42, 0x01, 0x91, 0xF8, + 0x9C, 0x13, 0x01, 0xF0, + 0x0F, 0x01, 0x88, 0x42, 0x03, 0xD9, 0x40, 0x1A, 0x86, 0xF8, 0x42, 0x01, + 0x01, 0xE0, 0x86, 0xF8, + 0x42, 0x91, 0x6E, 0x48, 0x00, 0x78, 0x40, 0xB1, 0x96, 0xF8, 0x42, 0x01, + 0x10, 0xBB, 0xD8, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0x9D, 0x03, 0x86, 0xF8, 0x42, 0x01, 0x96, 0xF8, + 0x42, 0x01, 0xC8, 0xB9, + 0x03, 0x20, 0x86, 0xF8, 0x3E, 0x01, 0x9B, 0xF8, 0x00, 0x00, 0x40, 0x1C, + 0x8B, 0xF8, 0x00, 0x00, + 0x2B, 0xE0, 0x96, 0xF8, 0x43, 0x01, 0x18, 0xBB, 0x96, 0xF8, 0x42, 0x00, + 0x80, 0x07, 0x03, 0xD5, + 0x07, 0x20, 0x86, 0xF8, 0x3E, 0x01, 0x32, 0xE0, 0x08, 0x20, 0x86, 0xF8, + 0x3E, 0x01, 0x30, 0x46, + 0x00, 0xF0, 0xA7, 0xF8, 0x96, 0xF8, 0x3E, 0x01, 0x02, 0x28, 0x07, 0xD0, + 0x06, 0x28, 0x0C, 0xD0, + 0xC0, 0xB2, 0x03, 0x28, 0x11, 0xD0, 0x04, 0x28, 0x0F, 0xD0, 0x20, 0xE0, + 0x96, 0xF8, 0x42, 0x01, + 0xE8, 0xB1, 0x40, 0x1E, 0x86, 0xF8, 0x42, 0x01, 0x19, 0xE0, 0x96, 0xF8, + 0x43, 0x01, 0xB0, 0xB1, + 0xC0, 0xB2, 0x40, 0x1E, 0x86, 0xF8, 0x43, 0x01, 0x11, 0xE0, 0x96, 0xF8, + 0x3F, 0x01, 0x01, 0x28, + 0x02, 0xD0, 0x03, 0x28, 0x06, 0xD0, 0x0A, 0xE0, 0x9D, 0xF8, 0x14, 0x00, + 0x40, 0x1C, 0x8D, 0xF8, + 0x14, 0x00, 0x04, 0xE0, 0x9D, 0xF8, 0x10, 0x00, 0x40, 0x1C, 0x8D, 0xF8, + 0x10, 0x00, 0x7F, 0x1C, + 0x7F, 0xB2, 0x95, 0xF9, 0xF4, 0x03, 0xB8, 0x42, 0xBF, 0xF6, 0x5E, 0xAF, + 0x05, 0xAA, 0x04, 0xA9, + 0x20, 0x46, 0x00, 0xF0, 0x87, 0xF8, 0x41, 0x49, 0x9D, 0xF8, 0x10, 0x00, + 0x08, 0x70, 0x9D, 0xF8, + 0x14, 0x00, 0x3F, 0x49, 0x08, 0x70, 0x0B, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, + 0x90, 0xF8, 0x5B, 0x10, + 0x90, 0xF8, 0x5A, 0x20, 0x8A, 0x1A, 0xB0, 0xF8, 0x42, 0x10, 0x52, 0x1C, + 0x02, 0x2A, 0x0B, 0xD9, + 0x90, 0xF8, 0x5D, 0x20, 0x90, 0xF8, 0x5C, 0x30, 0x9A, 0x42, 0x05, 0xD1, + 0x41, 0xF0, 0x01, 0x01, + 0xA0, 0xF8, 0x42, 0x10, 0x01, 0x20, 0x70, 0x47, 0x21, 0xF0, 0x01, 0x01, + 0xA0, 0xF8, 0x42, 0x10, + 0x00, 0x20, 0x70, 0x47, 0x70, 0xB5, 0x00, 0x25, 0x04, 0x46, 0x80, 0xF8, + 0x43, 0x51, 0x0D, 0xF0, + 0x93, 0xFD, 0x01, 0x00, 0x22, 0x48, 0x0C, 0xD0, 0x01, 0x68, 0x01, 0x25, + 0x91, 0xF8, 0x9E, 0x13, + 0x5F, 0xEA, 0x11, 0x11, 0x84, 0xF8, 0x43, 0x11, 0x94, 0xF8, 0x3F, 0x11, + 0x01, 0x29, 0x06, 0xD0, + 0x0E, 0xE0, 0x01, 0x68, 0x91, 0xF8, 0x9E, 0x13, 0x01, 0xF0, 0x0F, 0x01, + 0xF2, 0xE7, 0x02, 0x68, + 0x94, 0xF8, 0x43, 0x11, 0x92, 0xF8, 0x4B, 0x23, 0x01, 0xEB, 0x12, 0x11, + 0x84, 0xF8, 0x43, 0x11, + 0x1D, 0xB9, 0x94, 0xF8, 0x42, 0x10, 0x89, 0x07, 0x0D, 0xD4, 0x01, 0x68, + 0xE2, 0x6A, 0x91, 0xF8, + 0x9F, 0x13, 0x01, 0xF0, 0x0F, 0x03, 0x9A, 0x42, 0x05, 0xD9, 0x94, 0xF8, + 0x43, 0x21, 0x02, 0xEB, + 0x11, 0x11, 0x84, 0xF8, 0x43, 0x11, 0x0C, 0x49, 0x09, 0x78, 0x00, 0x29, + 0x08, 0xD0, 0x00, 0x68, + 0x94, 0xF8, 0x43, 0x11, 0x90, 0xF8, 0x63, 0x02, 0x01, 0xEB, 0x10, 0x10, + 0x84, 0xF8, 0x43, 0x01, + 0x70, 0xBD, 0x08, 0x49, 0x08, 0x78, 0x00, 0x28, 0x01, 0xD0, 0x40, 0x1E, + 0x08, 0x70, 0x70, 0x47, + 0x4C, 0x07, 0x10, 0x00, 0xF9, 0x06, 0x10, 0x00, 0x74, 0x05, 0x10, 0x00, + 0x76, 0x06, 0x10, 0x00, + 0x7D, 0x07, 0x10, 0x00, 0xFA, 0x06, 0x10, 0x00, 0x20, 0x07, 0x10, 0x00, + 0xFB, 0x06, 0x10, 0x00, + 0xFC, 0x06, 0x10, 0x00, 0x2D, 0xE9, 0xF0, 0x47, 0x16, 0x46, 0x07, 0x46, + 0x0B, 0x78, 0x34, 0x4A, + 0x01, 0x20, 0x23, 0xB9, 0x33, 0x78, 0x13, 0xB1, 0x10, 0x70, 0xBD, 0xE8, + 0xF0, 0x87, 0x00, 0x23, + 0x13, 0x70, 0x00, 0x29, 0xF9, 0xD0, 0x31, 0x78, 0x00, 0x29, 0xF6, 0xD0, + 0x00, 0x24, 0x07, 0xF5, + 0x80, 0x55, 0x80, 0x46, 0x4F, 0xF0, 0x02, 0x09, 0x1D, 0xE0, 0x00, 0xBF, + 0xD5, 0xF8, 0xEC, 0x13, + 0x08, 0xFA, 0x04, 0xF0, 0x01, 0x42, 0x14, 0xD0, 0x04, 0xEB, 0x04, 0x10, + 0x00, 0xEB, 0x80, 0x00, + 0x07, 0xEB, 0x80, 0x00, 0x90, 0xF8, 0x3E, 0x11, 0x03, 0x29, 0x0A, 0xD1, + 0x90, 0xF8, 0x3F, 0x11, + 0x01, 0x29, 0x06, 0xD1, 0x80, 0xF8, 0x3E, 0x91, 0xFF, 0xF7, 0xB3, 0xFF, + 0x30, 0x78, 0x40, 0x1E, + 0x30, 0x70, 0x64, 0x1C, 0x64, 0xB2, 0x95, 0xF9, 0xF4, 0x03, 0xA0, 0x42, + 0xDE, 0xDA, 0xCC, 0xE7, + 0x2D, 0xE9, 0xF0, 0x41, 0x17, 0x4D, 0x04, 0x46, 0x28, 0x68, 0x90, 0xF8, + 0x81, 0x03, 0xC0, 0x07, + 0x24, 0xD0, 0x21, 0x46, 0x20, 0x1D, 0x09, 0xF0, 0x06, 0xFD, 0x07, 0x46, + 0x21, 0x46, 0x04, 0xF1, + 0x20, 0x00, 0x09, 0xF0, 0x00, 0xFD, 0x06, 0x46, 0x0D, 0xF0, 0xE6, 0xFC, + 0x00, 0x28, 0x28, 0x68, + 0x05, 0xD0, 0xB0, 0xF8, 0x93, 0x13, 0xB0, 0xF8, 0x8F, 0x03, 0x49, 0x43, + 0x04, 0xE0, 0xB0, 0xF8, + 0x91, 0x13, 0xB0, 0xF8, 0x8D, 0x03, 0x49, 0x43, 0x40, 0x43, 0x86, 0x42, + 0x06, 0xDD, 0x8F, 0x42, + 0x04, 0xDD, 0x34, 0xF8, 0x42, 0x0F, 0x40, 0xF0, 0x02, 0x00, 0x20, 0x80, + 0xBD, 0xE8, 0xF0, 0x81, + 0xF9, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xF8, 0xB5, 0x15, 0x46, + 0x0E, 0x46, 0x04, 0x46, + 0x0D, 0xF0, 0xC2, 0xFC, 0x01, 0x00, 0xF9, 0x48, 0x0B, 0xD0, 0x00, 0x68, + 0x90, 0xF8, 0xB4, 0x13, + 0xB0, 0xF8, 0xB7, 0x23, 0x01, 0xF0, 0x0F, 0x03, 0x0C, 0x09, 0xB0, 0xF8, + 0xB5, 0x13, 0x49, 0x43, + 0x10, 0xE0, 0x94, 0xF8, 0x3F, 0x11, 0x02, 0x29, 0x13, 0xD0, 0x00, 0x68, + 0x01, 0x29, 0x14, 0xD0, + 0x90, 0xF8, 0xB9, 0x13, 0xB0, 0xF8, 0xC0, 0x23, 0x01, 0xF0, 0x0F, 0x03, + 0x0C, 0x09, 0xB0, 0xF8, + 0xBE, 0x13, 0x49, 0x43, 0x52, 0x43, 0x30, 0x46, 0x00, 0x94, 0x09, 0xF0, + 0xC2, 0xFC, 0x2C, 0x60, + 0xF8, 0xBD, 0x00, 0x68, 0x90, 0xF8, 0xBA, 0x13, 0xEC, 0xE7, 0x90, 0xF8, + 0xBB, 0x13, 0xB0, 0xF8, + 0xC4, 0x23, 0x01, 0xF0, 0x0F, 0x03, 0x0C, 0x09, 0xB0, 0xF8, 0xC2, 0x13, + 0x49, 0x43, 0xE9, 0xE7, + 0x2D, 0xE9, 0xF8, 0x43, 0x04, 0x46, 0x90, 0xF8, 0x3E, 0x01, 0x88, 0x46, + 0x04, 0xF1, 0x78, 0x07, + 0x03, 0x28, 0x0B, 0xD0, 0xD9, 0x4E, 0x04, 0x28, 0x0D, 0xD0, 0x07, 0x28, + 0x3B, 0xD0, 0x08, 0x28, + 0x37, 0xD1, 0x38, 0x46, 0xBD, 0xE8, 0xF8, 0x43, 0x00, 0xF0, 0xC5, 0xBB, + 0x38, 0x46, 0xBD, 0xE8, + 0xF8, 0x43, 0x00, 0xF0, 0x8E, 0xBB, 0x20, 0x46, 0x0D, 0xF0, 0x83, 0xFC, + 0x18, 0xB1, 0x20, 0x46, + 0x0D, 0xF0, 0x7A, 0xFC, 0x1D, 0xE0, 0x04, 0xF1, 0x0C, 0x01, 0x08, 0x1D, + 0x09, 0xF0, 0x7B, 0xFC, + 0x01, 0x46, 0x6A, 0x46, 0x20, 0x46, 0xFF, 0xF7, 0x97, 0xFF, 0x05, 0x46, + 0x94, 0xF8, 0x41, 0x01, + 0x80, 0xB9, 0x20, 0x46, 0x0D, 0xF0, 0x6A, 0xFC, 0x10, 0xB1, 0x00, 0x98, + 0x85, 0x42, 0x09, 0xDB, + 0x30, 0x68, 0xD4, 0xF8, 0x80, 0x10, 0x90, 0xF8, 0xBC, 0x03, 0x02, 0x09, + 0x28, 0x46, 0x09, 0xF0, + 0x85, 0xFC, 0x05, 0x46, 0x2A, 0x46, 0x41, 0x46, 0x38, 0x46, 0x00, 0xF0, + 0x64, 0xFB, 0xC4, 0xF8, + 0x80, 0x50, 0xBD, 0xE8, 0xF8, 0x83, 0x30, 0x68, 0x00, 0x24, 0x90, 0xF8, + 0x81, 0x13, 0x89, 0x07, + 0x0A, 0xD5, 0x90, 0xF8, 0xBD, 0x03, 0x00, 0xF0, 0x0F, 0x04, 0x0D, 0xF0, + 0x35, 0xFC, 0x18, 0xB1, + 0x30, 0x68, 0x90, 0xF8, 0xBD, 0x03, 0x04, 0x09, 0x22, 0x46, 0x41, 0x46, + 0x38, 0x46, 0xBD, 0xE8, + 0xF8, 0x43, 0x00, 0xF0, 0x60, 0xBB, 0x2D, 0xE9, 0xF0, 0x43, 0xDF, 0xF8, + 0xB0, 0x92, 0x4F, 0xF0, + 0x00, 0x0C, 0xB0, 0xF9, 0x02, 0x30, 0xD9, 0xF8, 0x00, 0x40, 0x67, 0x46, + 0x66, 0x46, 0x65, 0x46, + 0x00, 0x2B, 0x02, 0xDA, 0x4F, 0xF0, 0x01, 0x0C, 0x04, 0xE0, 0xB4, 0xF8, + 0x32, 0x80, 0x98, 0x45, + 0x00, 0xDA, 0x01, 0x27, 0xB0, 0xF9, 0x00, 0x30, 0x00, 0x2B, 0x01, 0xDA, + 0x01, 0x26, 0x04, 0xE0, + 0xB4, 0xF8, 0x34, 0x80, 0x98, 0x45, 0x00, 0xDA, 0x01, 0x25, 0x00, 0x23, + 0xBC, 0xF1, 0x00, 0x0F, + 0x02, 0xD0, 0x0E, 0xB1, 0x43, 0x80, 0x03, 0xE0, 0x4F, 0xB1, 0x26, 0xB1, + 0x61, 0x8E, 0x38, 0xE0, + 0x03, 0x80, 0xBD, 0xE8, 0xF0, 0x83, 0x15, 0xB1, 0x62, 0x8E, 0x42, 0x80, + 0x04, 0xE0, 0xBC, 0xF1, + 0x00, 0x0F, 0x30, 0xD0, 0x2D, 0xB1, 0x43, 0x80, 0xD9, 0xF8, 0x00, 0x10, + 0x89, 0x8E, 0x01, 0x80, + 0xEF, 0xE7, 0xB2, 0xF8, 0x02, 0xC0, 0xBC, 0xF1, 0x00, 0x0F, 0x24, 0xD0, + 0x43, 0x80, 0xB1, 0xF9, + 0x02, 0x40, 0x67, 0x42, 0x2C, 0xE0, 0x00, 0xBF, 0x0C, 0xFB, 0x07, 0xFC, + 0x00, 0x2C, 0x00, 0xDA, + 0x64, 0x42, 0x9C, 0xFB, 0xF4, 0xF4, 0x0F, 0x88, 0x3C, 0x44, 0x04, 0x80, + 0x46, 0xB3, 0xB2, 0xF9, + 0x00, 0x40, 0x2C, 0xB3, 0xB1, 0xF9, 0x00, 0x50, 0xB2, 0xF9, 0x02, 0x20, + 0x6D, 0x42, 0x00, 0xD5, + 0x6D, 0x42, 0x6A, 0x43, 0x00, 0x2C, 0x00, 0xDA, 0x64, 0x42, 0x92, 0xFB, + 0xF4, 0xF2, 0x49, 0x88, + 0x11, 0x44, 0x41, 0x80, 0xC4, 0xE7, 0x00, 0x2F, 0xE8, 0xD0, 0x57, 0x88, + 0x00, 0x2F, 0xE5, 0xD0, + 0x64, 0x8E, 0x44, 0x80, 0xD9, 0xF8, 0x00, 0x40, 0xB1, 0xF9, 0x02, 0x70, + 0x64, 0x8E, 0xE7, 0x1B, + 0xB2, 0xF9, 0x02, 0x40, 0xB2, 0xF9, 0x00, 0xC0, 0x00, 0x2F, 0xCD, 0xDA, + 0x7F, 0x42, 0xCB, 0xE7, + 0x00, 0x2D, 0xAE, 0xD0, 0xB2, 0xF9, 0x00, 0x30, 0x00, 0x2B, 0xAA, 0xD0, + 0xD9, 0xF8, 0x00, 0x40, + 0xB1, 0xF9, 0x00, 0x60, 0xB2, 0xF9, 0x02, 0x20, 0xA4, 0x8E, 0xA4, 0x1B, + 0x00, 0xD5, 0x64, 0x42, + 0x62, 0x43, 0x00, 0x2B, 0x00, 0xDA, 0x5B, 0x42, 0x92, 0xFB, 0xF3, 0xF2, + 0x49, 0x88, 0x11, 0x44, + 0x41, 0x80, 0xA1, 0xE7, 0x2D, 0xE9, 0xF0, 0x5F, 0x04, 0x46, 0x61, 0x48, + 0x0D, 0x46, 0x00, 0x21, + 0x41, 0x80, 0x01, 0x80, 0xA0, 0xF1, 0x10, 0x08, 0x28, 0x68, 0xC8, 0xF8, + 0x00, 0x00, 0x17, 0x46, + 0x4F, 0xF0, 0x01, 0x0B, 0x46, 0x46, 0x29, 0x46, 0x20, 0x46, 0x00, 0xF0, + 0x67, 0xFF, 0xDF, 0xF8, + 0x5C, 0x91, 0x28, 0x68, 0x70, 0x60, 0xD9, 0xF8, 0x00, 0x00, 0x04, 0xF1, + 0x0C, 0x0A, 0x90, 0xF8, + 0x80, 0x03, 0x41, 0x07, 0x22, 0xD5, 0x94, 0xF8, 0x3E, 0x01, 0x04, 0xF1, + 0x84, 0x06, 0x02, 0x28, + 0x0A, 0xD0, 0x03, 0x28, 0x08, 0xD0, 0x04, 0x28, 0x0B, 0xD0, 0x06, 0x28, + 0x12, 0xD0, 0x07, 0x28, + 0x10, 0xD0, 0x08, 0x28, 0x0E, 0xD0, 0x11, 0xE0, 0x51, 0x46, 0x30, 0x46, + 0xFF, 0xF7, 0xC9, 0xFA, + 0x0C, 0xE0, 0x20, 0x46, 0x00, 0xF0, 0xDD, 0xF9, 0x02, 0x46, 0x29, 0x46, + 0x30, 0x46, 0xFF, 0xF7, + 0xE4, 0xFA, 0x03, 0xE0, 0x29, 0x46, 0x30, 0x46, 0xFF, 0xF7, 0xEB, 0xFB, + 0x29, 0x68, 0xC8, 0xF8, + 0x08, 0x10, 0xD9, 0xF8, 0x00, 0x00, 0x4E, 0x46, 0x90, 0xF8, 0x80, 0x03, + 0x00, 0x07, 0x09, 0xD5, + 0x94, 0xF8, 0x42, 0x00, 0x10, 0xF0, 0xC8, 0x0F, 0x35, 0xD0, 0x51, 0x46, + 0x04, 0xF1, 0xB0, 0x00, + 0x00, 0xF0, 0xF3, 0xFD, 0x29, 0x68, 0xC8, 0xF8, 0x0C, 0x10, 0x30, 0x68, + 0x90, 0xF8, 0x80, 0x13, + 0x49, 0x06, 0x0F, 0xD4, 0x90, 0xF8, 0x40, 0x14, 0x49, 0x06, 0x03, 0xD5, + 0x94, 0xF8, 0x42, 0x10, + 0x09, 0x07, 0x07, 0xD4, 0x90, 0xF8, 0x20, 0x04, 0x80, 0x07, 0x07, 0xD5, + 0x94, 0xF8, 0x42, 0x00, + 0x00, 0x06, 0x03, 0xD5, 0x29, 0x46, 0x20, 0x46, 0x01, 0xF0, 0xBC, 0xFC, + 0x30, 0x68, 0x90, 0xF8, + 0x80, 0x03, 0x80, 0x06, 0x03, 0xD5, 0x29, 0x46, 0x20, 0x46, 0xFF, 0xF7, + 0x89, 0xFE, 0x30, 0x68, + 0x90, 0xF8, 0x80, 0x03, 0x01, 0x07, 0x11, 0xD5, 0xC0, 0x06, 0x0F, 0xD5, + 0x94, 0xF8, 0x3E, 0x01, + 0x07, 0x28, 0x05, 0xD0, 0x0A, 0xE0, 0x29, 0x46, 0x20, 0x46, 0x00, 0xF0, + 0xB2, 0xF9, 0xC9, 0xE7, + 0x1B, 0x4A, 0x04, 0xF1, 0xF4, 0x01, 0x28, 0x46, 0xFF, 0xF7, 0xD5, 0xFE, + 0x30, 0x68, 0xB0, 0xF9, + 0x32, 0x10, 0xB5, 0xF9, 0x02, 0x00, 0x09, 0xF0, 0xD7, 0xFA, 0x68, 0x80, + 0x30, 0x68, 0xB0, 0xF9, + 0x34, 0x10, 0xB5, 0xF9, 0x00, 0x00, 0x09, 0xF0, 0xCF, 0xFA, 0x28, 0x80, + 0x94, 0xF8, 0x3E, 0x01, + 0x03, 0x28, 0x06, 0xD0, 0x04, 0x28, 0x08, 0xD0, 0x07, 0x28, 0x1B, 0xD0, + 0x08, 0x28, 0x19, 0xD0, + 0x1B, 0xE0, 0x38, 0x88, 0xA4, 0xF8, 0x50, 0x00, 0x17, 0xE0, 0x30, 0x68, + 0x34, 0xF8, 0x50, 0x2F, + 0x90, 0xF8, 0xBC, 0x03, 0x00, 0xF0, 0x0F, 0x01, 0xC1, 0xF1, 0x10, 0x00, + 0x4A, 0x43, 0x39, 0x88, + 0x01, 0xFB, 0x00, 0x20, 0x00, 0x09, 0x20, 0x80, 0x06, 0xE0, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x94, 0x05, 0x10, 0x00, 0xB4, 0xF8, 0x50, 0x00, 0x38, 0x80, 0x58, 0x46, + 0xBD, 0xE8, 0xF0, 0x9F, + 0x2D, 0xE9, 0xF3, 0x4F, 0xE4, 0x49, 0x83, 0xB0, 0x4F, 0xF0, 0x00, 0x08, + 0xC1, 0xF8, 0x00, 0x80, + 0xE2, 0x49, 0xE3, 0x4D, 0x83, 0x46, 0xC1, 0xF8, 0x00, 0x80, 0x85, 0xF8, + 0x00, 0x80, 0x46, 0x46, + 0xDF, 0xF8, 0x80, 0xA3, 0x4F, 0xF0, 0x01, 0x09, 0x00, 0xF5, 0x80, 0x57, + 0x77, 0xE0, 0x00, 0xBF, + 0xD7, 0xF8, 0xEC, 0x13, 0x09, 0xFA, 0x06, 0xF0, 0x01, 0x42, 0x6F, 0xD0, + 0x06, 0xEB, 0x06, 0x10, + 0x00, 0xEB, 0x80, 0x01, 0x0B, 0xEB, 0x81, 0x04, 0x94, 0xF8, 0x3E, 0x01, + 0x03, 0x28, 0x05, 0xD0, + 0x04, 0x28, 0x03, 0xD0, 0x07, 0x28, 0x01, 0xD0, 0x08, 0x28, 0x5F, 0xD1, + 0xE0, 0x68, 0x00, 0x90, + 0xB4, 0xF8, 0x4E, 0x00, 0xAD, 0xF8, 0x04, 0x00, 0x04, 0xF1, 0x0C, 0x01, + 0xCA, 0x4A, 0x08, 0x1D, + 0x00, 0xF0, 0x06, 0xF9, 0x01, 0xAA, 0x69, 0x46, 0x20, 0x46, 0xFF, 0xF7, + 0xF3, 0xFE, 0x02, 0x90, + 0xC6, 0x4A, 0x69, 0x46, 0x04, 0xF1, 0x24, 0x00, 0x00, 0xF0, 0xFA, 0xF8, + 0x94, 0xF8, 0x3F, 0x01, + 0x01, 0x28, 0x08, 0xD1, 0xC4, 0x48, 0x00, 0x78, 0x28, 0xB9, 0x94, 0xF8, + 0x3E, 0x01, 0x08, 0x28, + 0x01, 0xD0, 0x00, 0x20, 0x02, 0x90, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0x00, 0x04, 0xC0, 0x07, + 0x0E, 0xD0, 0x94, 0xF8, 0x42, 0x00, 0x40, 0x07, 0x02, 0xD5, 0x00, 0x20, + 0x02, 0x90, 0x07, 0xE0, + 0x94, 0xF8, 0x34, 0x01, 0x01, 0x28, 0x03, 0xD1, 0x20, 0x6A, 0x00, 0x90, + 0x84, 0xF8, 0x34, 0x81, + 0x94, 0xF8, 0x3F, 0x01, 0x03, 0x28, 0x09, 0xD1, 0x28, 0x78, 0x40, 0x1C, + 0xC0, 0xB2, 0x28, 0x70, + 0x94, 0xF8, 0x42, 0x10, 0x49, 0x07, 0x01, 0xD5, 0x40, 0x1E, 0x28, 0x70, + 0x00, 0x98, 0x60, 0x62, + 0xBD, 0xF8, 0x04, 0x00, 0xA4, 0xF8, 0x50, 0x00, 0x02, 0x98, 0x01, 0x28, + 0x0E, 0xD1, 0x00, 0x98, + 0xA0, 0x61, 0xBD, 0xF8, 0x04, 0x00, 0xA4, 0xF8, 0x52, 0x00, 0x04, 0x98, + 0x94, 0xF8, 0x4C, 0x21, + 0x00, 0x68, 0x09, 0xFA, 0x02, 0xF1, 0x08, 0x43, 0x04, 0x99, 0x08, 0x60, + 0x76, 0x1C, 0x97, 0xF9, + 0xF4, 0x03, 0xB0, 0x42, 0x84, 0xDA, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0x00, 0x04, 0x00, 0x07, + 0x0E, 0xD5, 0x29, 0x78, 0x9D, 0x48, 0x29, 0xB1, 0x9D, 0x49, 0x09, 0x78, + 0x01, 0x29, 0x01, 0xD1, + 0x80, 0xF8, 0x00, 0x90, 0xD7, 0xF8, 0xF0, 0x13, 0x00, 0x29, 0x01, 0xD1, + 0x80, 0xF8, 0x00, 0x80, + 0x05, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0x2D, 0xE9, 0xF0, 0x47, 0x89, 0x46, + 0x06, 0x46, 0x00, 0x27, + 0x4F, 0xF0, 0x01, 0x08, 0x00, 0xF5, 0x80, 0x55, 0x3D, 0xE0, 0x00, 0xBF, + 0xD5, 0xF8, 0xEC, 0x13, + 0x08, 0xFA, 0x07, 0xF2, 0x11, 0x42, 0x35, 0xD0, 0x07, 0xEB, 0x07, 0x11, + 0x01, 0xEB, 0x81, 0x01, + 0x06, 0xEB, 0x81, 0x04, 0x94, 0xF8, 0x3E, 0x11, 0x03, 0x29, 0x05, 0xD0, + 0x04, 0x29, 0x03, 0xD0, + 0x07, 0x29, 0x01, 0xD0, 0x08, 0x29, 0x25, 0xD1, 0x94, 0xF8, 0x4C, 0x31, + 0xD9, 0xF8, 0x00, 0x20, + 0x08, 0xFA, 0x03, 0xF0, 0x02, 0x42, 0x1D, 0xD0, 0x03, 0x29, 0x03, 0xD1, + 0x21, 0x46, 0x30, 0x46, + 0x02, 0xF0, 0x7A, 0xF8, 0x94, 0xF9, 0x4D, 0x01, 0x00, 0x28, 0x13, 0xDB, + 0x94, 0xF8, 0x3F, 0x01, + 0x00, 0x21, 0x01, 0x28, 0x04, 0xD0, 0x02, 0x28, 0x04, 0xD0, 0x04, 0x28, + 0x04, 0xD0, 0x04, 0xE0, + 0x03, 0x21, 0x02, 0xE0, 0x04, 0x21, 0x00, 0xE0, 0x05, 0x21, 0x84, 0xF8, + 0x40, 0x11, 0x20, 0x46, + 0x08, 0xF0, 0x7D, 0xFC, 0x7F, 0x1C, 0x95, 0xF9, 0xF4, 0x03, 0xB8, 0x42, + 0xBE, 0xDA, 0x00, 0x24, + 0x47, 0x46, 0x24, 0xE0, 0xD5, 0xF8, 0xEC, 0x03, 0x07, 0xFA, 0x04, 0xF1, + 0x08, 0x42, 0x1D, 0xD0, + 0x04, 0xEB, 0x04, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x08, + 0x98, 0xF8, 0x3E, 0x01, + 0x08, 0x28, 0x13, 0xD1, 0x98, 0xF8, 0x4C, 0x21, 0xD9, 0xF8, 0x00, 0x10, + 0x07, 0xFA, 0x02, 0xF0, + 0x01, 0x42, 0x07, 0xD0, 0x98, 0xF9, 0x4D, 0x01, 0x00, 0x28, 0x03, 0xDB, + 0x41, 0x46, 0x30, 0x46, + 0x02, 0xF0, 0x55, 0xF8, 0x41, 0x46, 0x30, 0x46, 0x02, 0xF0, 0x18, 0xF8, + 0x64, 0x1C, 0x95, 0xF9, + 0xF4, 0x03, 0xA0, 0x42, 0xD6, 0xDA, 0xBD, 0xE8, 0xF0, 0x87, 0x53, 0x49, + 0x10, 0xB5, 0x00, 0x20, + 0x08, 0x60, 0x52, 0x49, 0x08, 0x60, 0xFF, 0xF7, 0x03, 0xF9, 0x00, 0xF0, + 0x2F, 0xFC, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0xF0, 0xAD, 0xB8, 0x38, 0xB5, 0x04, 0x46, 0x00, 0x20, + 0x00, 0x90, 0x69, 0x46, + 0x20, 0x46, 0xFF, 0xF7, 0xC5, 0xFE, 0x69, 0x46, 0x20, 0x46, 0xFF, 0xF7, + 0x6C, 0xFF, 0x38, 0xBD, + 0x10, 0xB5, 0x14, 0x46, 0x09, 0xF0, 0x97, 0xF9, 0x21, 0x68, 0x81, 0x42, + 0x00, 0xDA, 0x20, 0x60, + 0x10, 0xBD, 0x10, 0xB5, 0x02, 0x46, 0x43, 0x49, 0xB2, 0xF8, 0x42, 0x30, + 0x4F, 0xF0, 0xFF, 0x30, + 0x09, 0x68, 0x5C, 0x06, 0x03, 0xD5, 0x91, 0xF8, 0xA5, 0x03, 0x00, 0x09, + 0x10, 0xBD, 0x1C, 0x07, + 0x02, 0xD5, 0x91, 0xF8, 0x4F, 0x04, 0x03, 0xE0, 0x1B, 0x06, 0x04, 0xD5, + 0x91, 0xF8, 0x2A, 0x04, + 0x00, 0xF0, 0x0F, 0x00, 0x10, 0xBD, 0x92, 0xF8, 0x3F, 0x21, 0x01, 0x2A, + 0x06, 0xD0, 0x39, 0x4A, + 0x12, 0x78, 0x01, 0x2A, 0xF6, 0xD9, 0x91, 0xF9, 0xAA, 0x03, 0x10, 0xBD, + 0x91, 0xF8, 0xA5, 0x03, + 0xEE, 0xE7, 0x30, 0xB4, 0x0C, 0x46, 0x90, 0xF8, 0x3E, 0x11, 0x00, 0xF1, + 0xB0, 0x03, 0x03, 0x29, + 0x23, 0xD0, 0x04, 0x29, 0x03, 0xD0, 0x06, 0x29, 0x01, 0xD0, 0x07, 0x29, + 0x41, 0xD1, 0x29, 0x4A, + 0x12, 0x68, 0x92, 0xF8, 0x80, 0x23, 0xD2, 0x06, 0x2D, 0xD5, 0x90, 0xF8, + 0x5B, 0x20, 0x90, 0xF8, + 0x5A, 0x50, 0x52, 0x1B, 0xC0, 0xF8, 0x24, 0x21, 0x90, 0xF8, 0x5D, 0x20, + 0x90, 0xF8, 0x5C, 0x50, + 0x52, 0x1B, 0xC0, 0xF8, 0x28, 0x21, 0x82, 0x6B, 0xC0, 0xF8, 0x20, 0x21, + 0x22, 0x4A, 0x07, 0x29, + 0x12, 0x88, 0xC0, 0xF8, 0x2C, 0x21, 0x06, 0xD0, 0x0F, 0xE0, 0x00, 0xF1, + 0x0C, 0x01, 0x30, 0xBC, + 0x18, 0x46, 0x00, 0xF0, 0xDA, 0xBB, 0x90, 0xF8, 0x31, 0x11, 0x03, 0x29, + 0x05, 0xD9, 0x21, 0x46, + 0x30, 0xBC, 0x1A, 0x4A, 0x18, 0x46, 0x00, 0xF0, 0x68, 0xBC, 0x90, 0xF8, + 0x31, 0x11, 0x49, 0x1C, + 0x80, 0xF8, 0x31, 0x11, 0x03, 0xE0, 0x90, 0xF8, 0x31, 0x21, 0x03, 0x2A, + 0x04, 0xD9, 0x21, 0x46, + 0x30, 0xBC, 0x18, 0x46, 0x00, 0xF0, 0x26, 0xBC, 0x04, 0x29, 0x04, 0xD0, + 0x00, 0x21, 0x80, 0xF8, + 0x31, 0x11, 0x30, 0xBC, 0x70, 0x47, 0x52, 0x1C, 0x80, 0xF8, 0x31, 0x21, + 0x21, 0x46, 0x30, 0xBC, + 0x18, 0x46, 0x00, 0xF0, 0x00, 0xBC, 0x00, 0x00, 0x24, 0x07, 0x10, 0x00, + 0x28, 0x07, 0x10, 0x00, + 0x20, 0x07, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xF9, 0x06, 0x10, 0x00, + 0xA5, 0x06, 0x10, 0x00, + 0xA4, 0x06, 0x10, 0x00, 0xFA, 0x06, 0x10, 0x00, 0x78, 0x06, 0x10, 0x00, + 0x94, 0x05, 0x10, 0x00, + 0x70, 0x47, 0x00, 0xF0, 0x35, 0xB8, 0x7C, 0xB5, 0x04, 0x46, 0x15, 0x46, + 0x0E, 0x46, 0x68, 0x46, + 0x00, 0xF0, 0x2E, 0xF8, 0x01, 0x99, 0x2A, 0x46, 0x60, 0x68, 0x00, 0xF0, + 0x3B, 0xF8, 0x60, 0x60, + 0x00, 0x99, 0x2A, 0x46, 0x20, 0x68, 0x00, 0xF0, 0x35, 0xF8, 0x20, 0x60, + 0x21, 0x46, 0x30, 0x46, + 0x00, 0xF0, 0x27, 0xF8, 0x7C, 0xBD, 0x7C, 0xB5, 0x04, 0x46, 0x15, 0x46, + 0x0E, 0x46, 0x68, 0x46, + 0x00, 0xF0, 0x16, 0xF8, 0x01, 0x99, 0x2A, 0x46, 0x60, 0x68, 0x00, 0xF0, + 0x23, 0xF8, 0x60, 0x60, + 0x00, 0x99, 0x2A, 0x46, 0x20, 0x68, 0x00, 0xF0, 0x1D, 0xF8, 0x20, 0x60, + 0x21, 0x46, 0x30, 0x46, + 0x00, 0xF0, 0x0F, 0xF8, 0x7C, 0xBD, 0x0A, 0x46, 0x01, 0x46, 0x10, 0x46, + 0x00, 0xF0, 0x09, 0xB8, + 0xB1, 0xF9, 0x02, 0x20, 0x12, 0x02, 0x42, 0x60, 0xB1, 0xF9, 0x00, 0x10, + 0x09, 0x02, 0x01, 0x60, + 0x70, 0x47, 0x4A, 0x68, 0x80, 0x32, 0x12, 0x12, 0x42, 0x80, 0x09, 0x68, + 0x80, 0x31, 0x09, 0x12, + 0x01, 0x80, 0x70, 0x47, 0xC2, 0xF1, 0x10, 0x03, 0x50, 0x43, 0x01, 0xFB, + 0x03, 0x00, 0x00, 0x11, + 0x70, 0x47, 0x00, 0x00, 0x2D, 0xE9, 0xF0, 0x41, 0xFE, 0x4A, 0x12, 0x68, + 0x51, 0xB3, 0x51, 0x8E, + 0x92, 0xF8, 0x30, 0x30, 0x82, 0x6F, 0x04, 0x6F, 0xC0, 0x6F, 0x64, 0x26, + 0x40, 0x00, 0x00, 0xFB, + 0x02, 0x40, 0x48, 0x43, 0xA0, 0xFB, 0x00, 0x25, 0x00, 0x21, 0x01, 0xFB, + 0x00, 0x55, 0x00, 0xFB, + 0x01, 0x51, 0xA2, 0xFB, 0x06, 0x07, 0x00, 0x25, 0x01, 0xFB, 0x06, 0x71, + 0x02, 0xFB, 0x05, 0x11, + 0x5C, 0x43, 0x22, 0x46, 0x2B, 0x46, 0x0C, 0xF0, 0x72, 0xFE, 0x22, 0x46, + 0x00, 0x23, 0x0C, 0xF0, + 0x6E, 0xFE, 0xED, 0x4B, 0x00, 0x22, 0x1B, 0x1A, 0x8A, 0x41, 0x01, 0xD2, + 0xEA, 0x48, 0x00, 0x21, + 0xBD, 0xE8, 0xF0, 0x81, 0x91, 0x8E, 0x92, 0xF8, 0x31, 0x30, 0x42, 0x6F, + 0xD3, 0xE7, 0x7C, 0xB5, + 0x04, 0x46, 0xE6, 0x48, 0xB4, 0xF9, 0x02, 0x10, 0x00, 0x78, 0x01, 0x28, + 0x30, 0xD0, 0xB4, 0xF9, + 0x06, 0x00, 0xB4, 0xF9, 0x0A, 0x20, 0x09, 0x1A, 0x80, 0x1A, 0x08, 0x1A, + 0x01, 0x90, 0xB4, 0xF9, + 0x00, 0x10, 0xB4, 0xF9, 0x04, 0x00, 0xB4, 0xF9, 0x08, 0x20, 0x09, 0x1A, + 0x80, 0x1A, 0x08, 0x1A, + 0xD8, 0x49, 0x00, 0x90, 0x20, 0x6C, 0x09, 0x68, 0x01, 0x9B, 0x91, 0xF8, + 0xB3, 0x23, 0x50, 0x43, + 0xC2, 0xF1, 0x80, 0x02, 0x53, 0x43, 0xC2, 0x17, 0x00, 0xEB, 0x52, 0x60, + 0x03, 0xEB, 0xE0, 0x10, + 0x20, 0x64, 0x91, 0xF8, 0xB3, 0x13, 0xE0, 0x6B, 0x00, 0x9A, 0x48, 0x43, + 0xC1, 0xF1, 0x80, 0x01, + 0x4A, 0x43, 0xC1, 0x17, 0x00, 0xEB, 0x51, 0x60, 0x02, 0xEB, 0xE0, 0x10, + 0xE0, 0x63, 0x7C, 0xBD, + 0xB4, 0xF9, 0x46, 0x00, 0xB4, 0xF9, 0x4A, 0x20, 0x09, 0x1A, 0x80, 0x1A, + 0x08, 0x1A, 0x01, 0x90, + 0xB4, 0xF9, 0x00, 0x10, 0xB4, 0xF9, 0x44, 0x00, 0xB4, 0xF9, 0x48, 0x20, + 0x09, 0x1A, 0x80, 0x1A, + 0x08, 0x1A, 0x00, 0x90, 0x04, 0xF1, 0x50, 0x00, 0x03, 0x22, 0x69, 0x46, + 0x05, 0x46, 0x09, 0xF0, + 0x08, 0xF8, 0x94, 0xF8, 0x80, 0x00, 0x03, 0x28, 0x02, 0xD2, 0x40, 0x1C, + 0x84, 0xF8, 0x80, 0x00, + 0xC2, 0xB2, 0x29, 0x46, 0x04, 0xF1, 0x68, 0x00, 0x00, 0xF0, 0x98, 0xFB, + 0x7C, 0xBD, 0x2D, 0xE9, + 0xF0, 0x4F, 0x89, 0xB0, 0x00, 0x26, 0x05, 0x96, 0x06, 0x96, 0x07, 0x96, + 0x01, 0x24, 0x0D, 0xF1, + 0x14, 0x08, 0x08, 0x96, 0x02, 0x25, 0xCD, 0xE9, 0x01, 0x48, 0x07, 0x46, + 0xCD, 0xE9, 0x03, 0x54, + 0x00, 0xF1, 0x0C, 0x03, 0xAD, 0x48, 0x9B, 0x46, 0x2A, 0x46, 0x29, 0x46, + 0x20, 0x30, 0x00, 0x95, + 0x08, 0xF0, 0x70, 0xFF, 0xDF, 0xF8, 0xA4, 0x92, 0x4F, 0xF4, 0x80, 0x7A, + 0x99, 0xF8, 0x00, 0x00, + 0x01, 0x28, 0x48, 0xD0, 0x38, 0x6C, 0x00, 0x90, 0x01, 0x23, 0x02, 0x22, + 0x07, 0xA9, 0x09, 0xF1, + 0x08, 0x00, 0x08, 0xF0, 0x36, 0xFF, 0x07, 0xA9, 0x01, 0x23, 0x02, 0x22, + 0x08, 0x46, 0xCD, 0xF8, + 0x00, 0xA0, 0x08, 0xF0, 0x20, 0xFF, 0x02, 0x23, 0x5A, 0x46, 0x07, 0xA9, + 0x05, 0xA8, 0x00, 0x94, + 0x08, 0xF0, 0x34, 0xFF, 0x05, 0x96, 0x06, 0x96, 0x07, 0x96, 0x08, 0x96, + 0xCD, 0xE9, 0x01, 0x48, + 0xCD, 0xE9, 0x03, 0x54, 0x95, 0x48, 0x07, 0xF1, 0x14, 0x03, 0x00, 0x95, + 0x02, 0x22, 0x1D, 0x46, + 0x11, 0x46, 0x20, 0x30, 0x08, 0xF0, 0x3E, 0xFF, 0x99, 0xF8, 0x00, 0x00, + 0x01, 0x28, 0x1F, 0xD0, + 0xF8, 0x6B, 0x00, 0x90, 0x8D, 0x48, 0x01, 0x23, 0x02, 0x22, 0x07, 0xA9, + 0x08, 0x30, 0x08, 0xF0, + 0x08, 0xFF, 0x07, 0xA9, 0x01, 0x23, 0x02, 0x22, 0x08, 0x46, 0xCD, 0xF8, + 0x00, 0xA0, 0x08, 0xF0, + 0xF2, 0xFE, 0x02, 0x23, 0x2A, 0x46, 0x07, 0xA9, 0x05, 0xA8, 0x00, 0x94, + 0x08, 0xF0, 0x06, 0xFF, + 0x09, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0xDD, 0xE9, 0x05, 0x01, 0xC7, 0xE9, + 0x03, 0x01, 0xC9, 0xE7, + 0xDD, 0xE9, 0x05, 0x01, 0xC7, 0xE9, 0x05, 0x01, 0xF2, 0xE7, 0x2D, 0xE9, + 0xF0, 0x4F, 0x8D, 0xB0, + 0x00, 0x26, 0x02, 0x24, 0x05, 0x96, 0x06, 0x96, 0x07, 0x96, 0x08, 0x96, + 0x09, 0x96, 0x0A, 0x96, + 0x0B, 0x96, 0x05, 0xAF, 0x0C, 0x96, 0xCD, 0xE9, 0x01, 0x47, 0x05, 0x46, + 0x73, 0x48, 0x05, 0xF1, + 0x1C, 0x03, 0x03, 0x94, 0x04, 0x94, 0x9B, 0x46, 0x22, 0x46, 0x21, 0x46, + 0x20, 0x30, 0x00, 0x94, + 0x08, 0xF0, 0xF8, 0xFE, 0x0D, 0xF1, 0x24, 0x0A, 0xCD, 0xE9, 0x01, 0x4A, + 0x6B, 0x4B, 0x02, 0x22, + 0x03, 0x94, 0x04, 0x94, 0x30, 0x33, 0x11, 0x46, 0x05, 0xA8, 0x00, 0x94, + 0x08, 0xF0, 0xEA, 0xFE, + 0xDF, 0xF8, 0x98, 0x81, 0x4F, 0xF0, 0x04, 0x09, 0x98, 0xF8, 0x00, 0x00, + 0x01, 0x28, 0x12, 0xD1, + 0xE8, 0x6E, 0x02, 0x23, 0x08, 0xF1, 0x60, 0x01, 0x00, 0x90, 0x1A, 0x46, + 0xA1, 0xF1, 0x10, 0x00, + 0x08, 0xF0, 0xAF, 0xFE, 0x02, 0x23, 0x08, 0xF1, 0x60, 0x01, 0x1A, 0x46, + 0x08, 0x46, 0xCD, 0xF8, + 0x00, 0x90, 0x08, 0xF0, 0x98, 0xFE, 0x59, 0x49, 0x02, 0x23, 0x5A, 0x46, + 0x60, 0x31, 0x09, 0xA8, + 0x00, 0x94, 0x08, 0xF0, 0xAB, 0xFE, 0x05, 0x96, 0x06, 0x96, 0x07, 0x96, + 0x08, 0x96, 0x09, 0x96, + 0x0A, 0x96, 0x0B, 0x96, 0x0C, 0x96, 0xCD, 0xE9, 0x01, 0x47, 0x50, 0x48, + 0x05, 0xF1, 0x2C, 0x03, + 0x02, 0x22, 0x03, 0x94, 0x04, 0x94, 0x1E, 0x46, 0x11, 0x46, 0x20, 0x30, + 0x00, 0x94, 0x08, 0xF0, + 0xB1, 0xFE, 0xCD, 0xE9, 0x01, 0x4A, 0x49, 0x4B, 0x02, 0x22, 0x03, 0x94, + 0x04, 0x94, 0x30, 0x33, + 0x11, 0x46, 0x05, 0xA8, 0x00, 0x94, 0x08, 0xF0, 0xA5, 0xFE, 0x98, 0xF8, + 0x00, 0x00, 0x01, 0x28, + 0x12, 0xD1, 0x42, 0x49, 0xA8, 0x6E, 0x02, 0x23, 0x60, 0x31, 0x00, 0x90, + 0x1A, 0x46, 0xA1, 0xF1, + 0x10, 0x00, 0x08, 0xF0, 0x6E, 0xFE, 0x3D, 0x49, 0x02, 0x23, 0x60, 0x31, + 0x1A, 0x46, 0x08, 0x46, + 0xCD, 0xF8, 0x00, 0x90, 0x08, 0xF0, 0x57, 0xFE, 0x38, 0x49, 0x02, 0x23, + 0x32, 0x46, 0x60, 0x31, + 0x09, 0xA8, 0x00, 0x94, 0x08, 0xF0, 0x6A, 0xFE, 0x0D, 0xB0, 0x62, 0xE7, + 0x2D, 0xE9, 0xF0, 0x4F, + 0x89, 0xB0, 0x00, 0x26, 0x01, 0x24, 0x05, 0x96, 0x06, 0x96, 0x0D, 0xF1, + 0x14, 0x0A, 0x07, 0x96, + 0xCD, 0xE9, 0x01, 0x4A, 0x05, 0x46, 0x00, 0xF1, 0x0C, 0x03, 0x4F, 0xF0, + 0x02, 0x09, 0x2B, 0x48, + 0x93, 0x46, 0x0F, 0x46, 0x03, 0x94, 0x98, 0x46, 0x4A, 0x46, 0x21, 0x46, + 0x10, 0x30, 0xCD, 0xF8, + 0x00, 0x90, 0x04, 0x94, 0x08, 0xF0, 0x66, 0xFE, 0xB5, 0xF9, 0x02, 0x00, + 0x05, 0x99, 0x01, 0x23, + 0x40, 0x1A, 0x05, 0x90, 0x00, 0x90, 0x02, 0x22, 0x06, 0xA9, 0x38, 0x46, + 0x08, 0xF0, 0x31, 0xFE, + 0x64, 0x27, 0x41, 0x46, 0x01, 0x23, 0x02, 0x22, 0x08, 0x46, 0x00, 0x97, + 0x08, 0xF0, 0x29, 0xFE, + 0x42, 0x46, 0x02, 0x23, 0x06, 0xA9, 0x10, 0x46, 0x00, 0x94, 0x08, 0xF0, + 0x2F, 0xFE, 0x41, 0x46, + 0x01, 0x23, 0x02, 0x22, 0x08, 0x46, 0x00, 0x97, 0x08, 0xF0, 0x0D, 0xFE, + 0x05, 0x96, 0x06, 0x96, + 0x07, 0x96, 0xCD, 0xE9, 0x01, 0x4A, 0x11, 0x48, 0x05, 0xF1, 0x14, 0x03, + 0x03, 0x94, 0x1E, 0x46, + 0x02, 0x22, 0x01, 0x21, 0x10, 0x30, 0xCD, 0xF8, 0x00, 0x90, 0x04, 0x94, + 0x08, 0xF0, 0x32, 0xFE, + 0xB5, 0xF9, 0x00, 0x00, 0x05, 0x99, 0x01, 0x23, 0x40, 0x1A, 0x05, 0x90, + 0x00, 0x90, 0x02, 0x22, + 0x06, 0xA9, 0x58, 0x46, 0x08, 0xF0, 0xFD, 0xFD, 0x01, 0x23, 0x31, 0x46, + 0x02, 0x22, 0x08, 0x46, + 0x00, 0x97, 0x05, 0xE0, 0x4C, 0x07, 0x10, 0x00, 0x40, 0x42, 0x0F, 0x00, + 0x98, 0x05, 0x10, 0x00, + 0x08, 0xF0, 0xEF, 0xFD, 0x32, 0x46, 0x02, 0x23, 0x06, 0xA9, 0x10, 0x46, + 0x00, 0x94, 0x08, 0xF0, + 0xF5, 0xFD, 0x31, 0x46, 0x01, 0x23, 0x02, 0x22, 0x08, 0x46, 0x00, 0x97, + 0x08, 0xF0, 0xD3, 0xFD, + 0xE6, 0xE6, 0x2D, 0xE9, 0xF7, 0x4F, 0x8A, 0xB0, 0x00, 0x26, 0x05, 0x96, + 0x06, 0x96, 0x07, 0x96, + 0x08, 0x96, 0x01, 0x24, 0x4F, 0xF0, 0x02, 0x09, 0x0D, 0xF1, 0x14, 0x0A, + 0x09, 0x96, 0xCD, 0xE9, + 0x01, 0x4A, 0xCD, 0xE9, 0x03, 0x94, 0x07, 0x46, 0x07, 0xF1, 0x1C, 0x00, + 0x4D, 0x46, 0xFD, 0x4B, + 0x4A, 0x46, 0x49, 0x46, 0x80, 0x46, 0xCD, 0xF8, 0x00, 0x90, 0x08, 0xF0, + 0xEB, 0xFD, 0x07, 0xA8, + 0xCD, 0xE9, 0x01, 0x50, 0xF7, 0x48, 0xCD, 0xE9, 0x03, 0x45, 0x43, 0x46, + 0x02, 0x22, 0x01, 0x21, + 0x08, 0x38, 0x00, 0x95, 0x08, 0xF0, 0xDE, 0xFD, 0x0D, 0xF1, 0x24, 0x0B, + 0xCD, 0xE9, 0x01, 0x4B, + 0x03, 0x94, 0xF0, 0x4B, 0x02, 0x22, 0x01, 0x21, 0x07, 0xA8, 0x00, 0x95, + 0x04, 0x94, 0x08, 0xF0, + 0xD1, 0xFD, 0xEC, 0x4D, 0x18, 0x3D, 0x28, 0x78, 0x01, 0x28, 0x04, 0xD1, + 0x01, 0x21, 0x38, 0x46, + 0xFF, 0xF7, 0xA8, 0xFD, 0x68, 0x60, 0x09, 0x98, 0x69, 0x68, 0x4F, 0xF0, + 0x64, 0x08, 0x08, 0x44, + 0x05, 0xA9, 0x09, 0x90, 0x01, 0x23, 0x02, 0x22, 0xCD, 0xF8, 0x00, 0x80, + 0x08, 0x46, 0x08, 0xF0, + 0x90, 0xFD, 0x09, 0x98, 0x00, 0x90, 0x01, 0x23, 0x02, 0x22, 0x05, 0xA8, + 0x0B, 0x99, 0x08, 0xF0, + 0x7A, 0xFD, 0x07, 0x96, 0x08, 0x96, 0x05, 0x96, 0x06, 0x96, 0x09, 0x96, + 0xCD, 0xE9, 0x01, 0x4A, + 0xCD, 0xE9, 0x03, 0x94, 0x4E, 0x46, 0x02, 0x22, 0x07, 0xF1, 0x2C, 0x00, + 0xCD, 0xF8, 0x00, 0x90, + 0xD4, 0x4B, 0x11, 0x46, 0x81, 0x46, 0x08, 0xF0, 0x9D, 0xFD, 0x07, 0xA8, + 0xCD, 0xE9, 0x01, 0x60, + 0xCD, 0xE9, 0x03, 0x46, 0xCF, 0x48, 0x4B, 0x46, 0x02, 0x22, 0x01, 0x21, + 0x08, 0x38, 0x00, 0x96, + 0x08, 0xF0, 0x90, 0xFD, 0xCD, 0xE9, 0x01, 0x4B, 0x03, 0x94, 0xCA, 0x4B, + 0x02, 0x22, 0x01, 0x21, + 0x07, 0xA8, 0x00, 0x96, 0x04, 0x94, 0x08, 0xF0, 0x85, 0xFD, 0x28, 0x78, + 0x01, 0x28, 0x04, 0xD1, + 0x00, 0x21, 0x38, 0x46, 0xFF, 0xF7, 0x5E, 0xFD, 0x68, 0x60, 0x09, 0x98, + 0x69, 0x68, 0x01, 0x23, + 0x08, 0x44, 0x05, 0xA9, 0x09, 0x90, 0x02, 0x22, 0xCD, 0xF8, 0x00, 0x80, + 0x08, 0x46, 0x08, 0xF0, + 0x48, 0xFD, 0x09, 0x98, 0x00, 0x90, 0x01, 0x23, 0x02, 0x22, 0x05, 0xA8, + 0x0C, 0x99, 0x08, 0xF0, + 0x32, 0xFD, 0xE1, 0xE6, 0x2D, 0xE9, 0xF7, 0x4F, 0x8E, 0xB0, 0x00, 0x25, + 0x05, 0x95, 0x06, 0x95, + 0x07, 0x95, 0x02, 0x24, 0x08, 0x95, 0x09, 0x95, 0x0A, 0x95, 0x0B, 0x95, + 0x05, 0xAF, 0x0C, 0x95, + 0xCD, 0xE9, 0x01, 0x47, 0x8C, 0x46, 0x4F, 0xF0, 0x01, 0x0A, 0xAE, 0x4B, + 0x06, 0x46, 0x03, 0x94, + 0x08, 0x3B, 0x52, 0x46, 0x21, 0x46, 0x60, 0x46, 0xCD, 0xF8, 0x00, 0xA0, + 0x04, 0x94, 0x08, 0xF0, + 0x49, 0xFD, 0xA8, 0x48, 0x05, 0xAA, 0x02, 0x23, 0x11, 0x46, 0x28, 0x30, + 0x00, 0x94, 0x08, 0xF0, + 0x33, 0xFD, 0x0D, 0xF1, 0x24, 0x08, 0xCD, 0xE9, 0x01, 0x48, 0x06, 0xF1, + 0x1C, 0x03, 0x02, 0x22, + 0x03, 0x94, 0x04, 0x94, 0x9B, 0x46, 0x11, 0x46, 0x05, 0xA8, 0x00, 0x94, + 0x08, 0xF0, 0x32, 0xFD, + 0x4F, 0xF0, 0x64, 0x09, 0x02, 0x23, 0x1A, 0x46, 0x59, 0x46, 0x09, 0xA8, + 0xCD, 0xF8, 0x00, 0x90, + 0x08, 0xF0, 0xF1, 0xFC, 0x05, 0x95, 0x06, 0x95, 0x07, 0x95, 0x08, 0x95, + 0x09, 0x95, 0x0A, 0x95, + 0x0B, 0x95, 0x0C, 0x95, 0xCD, 0xE9, 0x01, 0x47, 0x92, 0x4B, 0x03, 0x94, + 0x08, 0x3B, 0x01, 0x22, + 0x02, 0x21, 0xCD, 0xF8, 0x00, 0xA0, 0x04, 0x94, 0x10, 0x98, 0x08, 0xF0, + 0x13, 0xFD, 0x8D, 0x48, + 0x05, 0xAA, 0x02, 0x23, 0x11, 0x46, 0x28, 0x30, 0x00, 0x94, 0x08, 0xF0, + 0xFD, 0xFC, 0xCD, 0xE9, + 0x01, 0x48, 0x03, 0x94, 0x04, 0x94, 0x06, 0xF1, 0x2C, 0x03, 0x00, 0x94, + 0x02, 0x22, 0x1C, 0x46, + 0x11, 0x46, 0x05, 0xA8, 0x08, 0xF0, 0xFE, 0xFC, 0x02, 0x23, 0x1A, 0x46, + 0x21, 0x46, 0x09, 0xA8, + 0xCD, 0xF8, 0x00, 0x90, 0x08, 0xF0, 0xBF, 0xFC, 0x11, 0xB0, 0xD2, 0xE5, + 0x38, 0xB5, 0x7E, 0x48, + 0x7C, 0x4C, 0x01, 0x68, 0x18, 0x3C, 0x91, 0xF8, 0x80, 0x03, 0xC0, 0xF3, + 0x00, 0x12, 0x22, 0x70, + 0xB1, 0xF8, 0xB1, 0x03, 0x1A, 0xB1, 0x64, 0x21, 0x48, 0x43, 0x0D, 0x46, + 0x01, 0xE0, 0xD1, 0xF8, + 0xAD, 0x53, 0x74, 0x49, 0x80, 0x08, 0x02, 0x23, 0x48, 0x31, 0x00, 0x90, + 0x1A, 0x46, 0xA1, 0xF1, + 0x10, 0x00, 0x08, 0xF0, 0xAE, 0xFC, 0x65, 0x60, 0x38, 0xBD, 0xF8, 0xB5, + 0x04, 0x46, 0x08, 0x68, + 0x20, 0x60, 0x48, 0x68, 0x60, 0x60, 0x88, 0x68, 0xA0, 0x60, 0x00, 0x25, + 0x25, 0x64, 0xE5, 0x63, + 0xB1, 0xF9, 0x02, 0x00, 0xC4, 0xE9, 0x03, 0x05, 0xB1, 0xF9, 0x00, 0x00, + 0xC4, 0xE9, 0x05, 0x05, + 0x64, 0x48, 0x18, 0x38, 0x01, 0x78, 0x01, 0x29, 0x09, 0xD0, 0x60, 0x30, + 0x1C, 0x34, 0x0F, 0xC8, + 0x0F, 0xC4, 0x84, 0xE8, 0x0F, 0x00, 0x2C, 0x3C, 0x84, 0xF8, 0x81, 0x50, + 0xF8, 0xBD, 0x50, 0x30, + 0x1C, 0x34, 0x0F, 0xC8, 0x0F, 0xC4, 0x5C, 0x4E, 0x0F, 0xC4, 0x30, 0x68, + 0x64, 0x21, 0x02, 0x23, + 0xB0, 0xF8, 0xB1, 0x03, 0x1A, 0x46, 0x48, 0x43, 0x80, 0x08, 0xA4, 0xF1, + 0x20, 0x01, 0x00, 0x90, + 0x08, 0x46, 0x3C, 0x3C, 0x08, 0xF0, 0x75, 0xFC, 0x30, 0x68, 0x64, 0x21, + 0x02, 0x23, 0xB0, 0xF8, + 0xB1, 0x03, 0x1A, 0x46, 0x48, 0x43, 0x80, 0x08, 0x04, 0xF1, 0x2C, 0x01, + 0x00, 0x90, 0x08, 0x46, + 0x08, 0xF0, 0x67, 0xFC, 0x94, 0xE8, 0x07, 0x00, 0x04, 0xF1, 0x44, 0x03, + 0x83, 0xE8, 0x07, 0x00, + 0x84, 0xF8, 0x80, 0x50, 0xD0, 0xE7, 0x10, 0xB5, 0x04, 0x46, 0x03, 0x22, + 0x08, 0xF0, 0xDC, 0xFC, + 0x20, 0x46, 0xFF, 0xF7, 0x94, 0xFC, 0xB4, 0xF9, 0x02, 0x00, 0xE0, 0x60, + 0xB4, 0xF9, 0x06, 0x10, + 0x40, 0x1A, 0x20, 0x61, 0xB4, 0xF9, 0x00, 0x00, 0x60, 0x61, 0xB4, 0xF9, + 0x04, 0x10, 0x40, 0x1A, + 0xA0, 0x61, 0x10, 0xBD, 0x7F, 0xB5, 0x0D, 0x46, 0x04, 0x46, 0x03, 0x22, + 0x08, 0xF0, 0xC4, 0xFC, + 0x20, 0x46, 0xFF, 0xF7, 0x7C, 0xFC, 0x20, 0x46, 0xFF, 0xF7, 0xD9, 0xFC, + 0x20, 0x46, 0xFF, 0xF7, + 0x4C, 0xFD, 0x00, 0x20, 0x00, 0x90, 0x01, 0x90, 0x02, 0x90, 0x03, 0x90, + 0x02, 0xAA, 0x69, 0x46, + 0x20, 0x46, 0xFF, 0xF7, 0x4E, 0xFE, 0x02, 0xAA, 0x69, 0x46, 0x20, 0x46, + 0xFF, 0xF7, 0xCE, 0xFD, + 0x02, 0xAA, 0x69, 0x46, 0x20, 0x46, 0xFF, 0xF7, 0xE5, 0xFE, 0xA0, 0x89, + 0x68, 0x80, 0xA0, 0x8A, + 0x28, 0x80, 0x28, 0x48, 0x18, 0x38, 0x00, 0x78, 0x01, 0x28, 0x05, 0xD1, + 0x03, 0x22, 0x29, 0x46, + 0x04, 0xF1, 0x44, 0x00, 0x08, 0xF0, 0x98, 0xFC, 0x7F, 0xBD, 0x2D, 0xE9, + 0xF0, 0x47, 0x06, 0x46, + 0x48, 0x88, 0xB6, 0xF8, 0x4A, 0x30, 0x89, 0x46, 0xC0, 0x1A, 0xB6, 0xF8, + 0x46, 0x40, 0x92, 0x46, + 0x01, 0xB2, 0xB9, 0xF8, 0x00, 0x00, 0xB6, 0xF8, 0x48, 0x20, 0xE3, 0x1A, + 0x1C, 0xB2, 0x80, 0x1A, + 0xB6, 0xF8, 0x44, 0x30, 0x00, 0xB2, 0x9A, 0x1A, 0x15, 0xB2, 0x0C, 0xB9, + 0x00, 0x2D, 0x27, 0xD0, + 0x49, 0x43, 0x00, 0xFB, 0x00, 0x10, 0x64, 0x21, 0x48, 0x43, 0x04, 0xFB, + 0x04, 0xF1, 0x05, 0xFB, + 0x05, 0x11, 0xB0, 0xFB, 0xF1, 0xF0, 0x08, 0xF0, 0xC7, 0xFB, 0x44, 0x43, + 0x0A, 0x22, 0x45, 0x43, + 0x21, 0xB2, 0x28, 0xB2, 0x91, 0xFB, 0xF2, 0xF1, 0x90, 0xFB, 0xF2, 0xF0, + 0xB6, 0xF8, 0x46, 0x20, + 0x61, 0xF3, 0x1F, 0x48, 0x11, 0x44, 0x61, 0xF3, 0x1F, 0x47, 0xB6, 0xF8, + 0x44, 0x10, 0x60, 0xF3, + 0x0F, 0x08, 0x08, 0x44, 0x60, 0xF3, 0x0F, 0x07, 0xC9, 0xF8, 0x00, 0x70, + 0xCA, 0xF8, 0x00, 0x80, + 0xBD, 0xE8, 0xF0, 0x87, 0xB0, 0x05, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0xF0, 0xB5, 0x4F, 0xF0, + 0x00, 0x0C, 0x63, 0x46, 0x65, 0x46, 0x14, 0x46, 0x07, 0xE0, 0x00, 0xBF, + 0x01, 0xEB, 0xC4, 0x06, + 0x76, 0x68, 0x35, 0x44, 0x51, 0xF8, 0x34, 0x60, 0x33, 0x44, 0x64, 0x1E, + 0xF6, 0xD2, 0x95, 0xFB, + 0xF2, 0xF6, 0x93, 0xFB, 0xF2, 0xF7, 0xC0, 0xF8, 0x04, 0xC0, 0x15, 0x46, + 0x42, 0xF2, 0x10, 0x74, + 0xC0, 0xF8, 0x00, 0xC0, 0x17, 0xE0, 0x00, 0xBF, 0x01, 0xEB, 0xC5, 0x03, + 0x5B, 0x68, 0x9B, 0x1B, + 0x5B, 0x43, 0xA3, 0x42, 0x00, 0xDD, 0x23, 0x46, 0xD0, 0xF8, 0x04, 0xC0, + 0x63, 0x44, 0x43, 0x60, + 0x51, 0xF8, 0x35, 0x30, 0xDB, 0x1B, 0x5B, 0x43, 0xA3, 0x42, 0x00, 0xDD, + 0x23, 0x46, 0xD0, 0xF8, + 0x00, 0xC0, 0x63, 0x44, 0x03, 0x60, 0x6D, 0x1E, 0xE6, 0xD2, 0x41, 0x68, + 0x64, 0x23, 0x59, 0x43, + 0x91, 0xFB, 0xF2, 0xF1, 0x41, 0x60, 0x01, 0x68, 0x59, 0x43, 0x91, 0xFB, + 0xF2, 0xF1, 0x01, 0x60, + 0xF0, 0xBD, 0x00, 0x00, 0x10, 0xB5, 0x14, 0x21, 0x4B, 0x48, 0x0C, 0xF0, + 0x6F, 0xFB, 0xF6, 0xF7, + 0xD3, 0xFE, 0x64, 0x21, 0x48, 0x43, 0x48, 0x49, 0x08, 0x60, 0x10, 0xBD, + 0x2D, 0xE9, 0xF0, 0x41, + 0xDF, 0xF8, 0x18, 0x81, 0x04, 0x46, 0x0D, 0x46, 0xD8, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0xA0, 0x13, + 0x90, 0xF8, 0x80, 0x03, 0x01, 0xF0, 0x0F, 0x06, 0xC6, 0xF1, 0x10, 0x07, + 0x80, 0x07, 0x0F, 0xD5, + 0xB4, 0xF8, 0x42, 0x00, 0x01, 0x07, 0x0B, 0xD4, 0x00, 0x06, 0x09, 0xD4, + 0x0C, 0xF0, 0xFC, 0xFB, + 0x30, 0xB9, 0x3B, 0x48, 0x00, 0x78, 0x18, 0xB9, 0x3A, 0x48, 0x00, 0x78, + 0x01, 0x28, 0x02, 0xD9, + 0x00, 0x20, 0x20, 0x63, 0x18, 0xE0, 0x20, 0x6B, 0x02, 0x28, 0x18, 0xD8, + 0x40, 0x1C, 0x20, 0x63, + 0x02, 0x28, 0x07, 0xD9, 0x94, 0xF8, 0x3E, 0x11, 0x04, 0x29, 0x10, 0xD0, + 0x06, 0x29, 0x0E, 0xD0, + 0x07, 0x29, 0x0C, 0xD0, 0x02, 0x28, 0x07, 0xD1, 0xE0, 0x89, 0x61, 0x8A, + 0x40, 0x1A, 0x60, 0x85, + 0xA0, 0x89, 0x21, 0x8A, 0x40, 0x1A, 0x20, 0x85, 0x00, 0x20, 0xBD, 0xE8, + 0xF0, 0x81, 0xE0, 0x89, + 0x61, 0x8A, 0x22, 0x8A, 0x40, 0x1A, 0x01, 0xB2, 0xA0, 0x89, 0x79, 0x43, + 0x80, 0x1A, 0xB4, 0xF9, + 0x2A, 0x20, 0x00, 0xB2, 0x02, 0xFB, 0x06, 0x11, 0x09, 0x11, 0x61, 0x85, + 0xB4, 0xF9, 0x28, 0x10, + 0x78, 0x43, 0x01, 0xFB, 0x06, 0x00, 0x00, 0x11, 0x20, 0x85, 0xF6, 0xF7, + 0x2B, 0xFE, 0x1A, 0x4A, + 0x91, 0x89, 0x08, 0x1A, 0x11, 0x7C, 0x01, 0x29, 0x01, 0xD1, 0x51, 0x68, + 0x08, 0x44, 0x00, 0x28, + 0x00, 0xDA, 0x00, 0x20, 0x00, 0xEB, 0x80, 0x01, 0x13, 0x68, 0x49, 0x00, + 0xB1, 0xFB, 0xF3, 0xF7, + 0xD8, 0xF8, 0x00, 0x60, 0xB6, 0xF8, 0xA1, 0x13, 0x8F, 0x42, 0x03, 0xD9, + 0x59, 0x43, 0x0A, 0x20, + 0xB1, 0xFB, 0xF0, 0xF0, 0xB4, 0xF9, 0x2A, 0x10, 0x96, 0xF8, 0xA3, 0x33, + 0x92, 0x68, 0x59, 0x43, + 0x64, 0x26, 0x41, 0x43, 0x72, 0x43, 0xB4, 0xF9, 0x28, 0x40, 0x91, 0xFB, + 0xF2, 0xF1, 0x5C, 0x43, + 0x44, 0x43, 0x94, 0xFB, 0xF2, 0xF0, 0x6A, 0x88, 0x11, 0x44, 0x69, 0x80, + 0x29, 0x88, 0x08, 0x44, + 0x28, 0x80, 0x01, 0x20, 0xB1, 0xE7, 0x00, 0x00, 0x6C, 0x2C, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x74, 0x05, 0x10, 0x00, 0x20, 0x07, 0x10, 0x00, 0xB0, 0xF8, 0x44, 0x20, + 0xB1, 0xF8, 0x44, 0x30, + 0x1A, 0x44, 0xA0, 0xF8, 0x44, 0x20, 0xB0, 0xF8, 0x46, 0x20, 0xB1, 0xF8, + 0x46, 0x30, 0x1A, 0x44, + 0xA0, 0xF8, 0x46, 0x20, 0x42, 0x6B, 0x4B, 0x6B, 0x1A, 0x44, 0x42, 0x63, + 0x82, 0x6B, 0x8B, 0x6B, + 0x1A, 0x44, 0x82, 0x63, 0xB1, 0xF9, 0x54, 0x20, 0xB0, 0xF9, 0x54, 0x30, + 0x9A, 0x42, 0x01, 0xDD, + 0xA0, 0xF8, 0x54, 0x20, 0xB1, 0xF9, 0x56, 0x20, 0xB0, 0xF9, 0x56, 0x30, + 0x9A, 0x42, 0x01, 0xDD, + 0xA0, 0xF8, 0x56, 0x20, 0x90, 0xF8, 0x46, 0x21, 0x91, 0xF8, 0x46, 0x31, + 0x9A, 0x42, 0x0A, 0xD0, + 0x30, 0xF8, 0x48, 0x2F, 0xB1, 0xF8, 0x48, 0x30, 0x1A, 0x44, 0x20, 0xF8, + 0x0C, 0x29, 0xC9, 0x6B, + 0x02, 0x68, 0x11, 0x44, 0x01, 0x60, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x4F, + 0x97, 0xB0, 0x80, 0x46, + 0x00, 0xF5, 0x80, 0x50, 0x00, 0x26, 0x11, 0x90, 0xBF, 0xE0, 0x00, 0x20, + 0x08, 0x90, 0x05, 0x90, + 0x10, 0x90, 0x12, 0x90, 0x81, 0x46, 0x82, 0x46, 0x83, 0x46, 0x05, 0x46, + 0x07, 0x46, 0x0A, 0x90, + 0x0B, 0x90, 0x0C, 0x90, 0x0D, 0x90, 0x08, 0xEB, 0x86, 0x00, 0x00, 0xF5, + 0x80, 0x50, 0x14, 0x90, + 0xD0, 0xF8, 0x68, 0x04, 0x0A, 0xAA, 0x04, 0x46, 0x17, 0xE0, 0x00, 0xBF, + 0x90, 0xF8, 0x46, 0x11, + 0x08, 0xEB, 0x01, 0x0C, 0x53, 0x5C, 0x0C, 0xF5, 0x80, 0x5C, 0x5B, 0x1C, + 0xDB, 0xB2, 0x53, 0x54, + 0x9C, 0xF8, 0x56, 0xC4, 0x63, 0x45, 0x06, 0xD1, 0x01, 0x2B, 0x04, 0xD9, + 0x01, 0x23, 0x8B, 0x40, + 0x12, 0x99, 0x0B, 0x43, 0x12, 0x93, 0xD0, 0xF8, 0x50, 0x01, 0x00, 0x28, + 0xE6, 0xD1, 0x40, 0xE0, + 0x94, 0xF8, 0x46, 0x11, 0x01, 0x20, 0x00, 0xFA, 0x01, 0xFC, 0x12, 0x99, + 0x1C, 0xEA, 0x01, 0x0F, + 0x12, 0xD1, 0xA0, 0x6B, 0xB4, 0xF9, 0x0E, 0x30, 0x05, 0x9A, 0x49, 0x46, + 0xC0, 0xFB, 0x03, 0x12, + 0x05, 0x92, 0x89, 0x46, 0xB4, 0xF9, 0x0C, 0x30, 0x51, 0x46, 0x5A, 0x46, + 0xC0, 0xFB, 0x03, 0x12, + 0x8A, 0x46, 0x93, 0x46, 0x05, 0x44, 0x19, 0xE0, 0x08, 0x99, 0x1C, 0xEA, + 0x01, 0x0F, 0x15, 0xD1, + 0xE0, 0x6B, 0xB4, 0xF9, 0x1E, 0x30, 0x05, 0x9A, 0x49, 0x46, 0xC0, 0xFB, + 0x03, 0x12, 0x05, 0x92, + 0x89, 0x46, 0xB4, 0xF9, 0x1C, 0x30, 0x51, 0x46, 0x5A, 0x46, 0xC0, 0xFB, + 0x03, 0x12, 0x8A, 0x46, + 0x08, 0x99, 0x05, 0x44, 0x4C, 0xEA, 0x01, 0x00, 0x93, 0x46, 0x08, 0x90, + 0x20, 0x46, 0x00, 0xF0, + 0x98, 0xFB, 0x01, 0x28, 0x02, 0xD1, 0x10, 0x98, 0x40, 0x1C, 0x10, 0x90, + 0xD4, 0xF8, 0x50, 0x41, + 0x7F, 0x1C, 0x00, 0x2C, 0xBC, 0xD1, 0x00, 0x2F, 0x45, 0xDD, 0xE8, 0x17, + 0x04, 0x46, 0x03, 0x46, + 0x2A, 0x46, 0x48, 0x46, 0x05, 0x99, 0x0C, 0xF0, 0x4C, 0xF9, 0xAD, 0xF8, + 0x1E, 0x00, 0x2A, 0x46, + 0x23, 0x46, 0x50, 0x46, 0x59, 0x46, 0x0C, 0xF0, 0x44, 0xF9, 0xAD, 0xF8, + 0x1C, 0x00, 0x14, 0x98, + 0x4F, 0xF0, 0xFF, 0x37, 0x00, 0x25, 0xD0, 0xF8, 0x68, 0x44, 0x23, 0xE0, + 0x20, 0x46, 0x00, 0xF0, + 0x70, 0xFB, 0x01, 0x28, 0x01, 0xD0, 0x10, 0x98, 0x90, 0xB9, 0x04, 0xF1, + 0x10, 0x01, 0x07, 0xA8, + 0x08, 0xF0, 0xB9, 0xFA, 0xB8, 0x42, 0x0B, 0xD2, 0x07, 0x46, 0x3D, 0xB1, + 0x29, 0x46, 0x20, 0x46, + 0xFF, 0xF7, 0x1A, 0xFF, 0x29, 0x46, 0x40, 0x46, 0x00, 0xF0, 0x72, 0xFB, + 0x25, 0x46, 0x07, 0xE0, + 0x21, 0x46, 0x28, 0x46, 0xFF, 0xF7, 0x10, 0xFF, 0x21, 0x46, 0x40, 0x46, + 0x00, 0xF0, 0x68, 0xFB, + 0xD4, 0xF8, 0x50, 0x41, 0x00, 0x2C, 0xD9, 0xD1, 0x07, 0x98, 0x45, 0xF8, + 0x0C, 0x0F, 0xE8, 0x8E, + 0x40, 0xF0, 0x40, 0x00, 0xE8, 0x86, 0x11, 0x98, 0x76, 0x1C, 0x90, 0xF8, + 0xE0, 0x04, 0xB0, 0x42, + 0x3F, 0xF7, 0x3B, 0xAF, 0x17, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0x2D, 0xE9, + 0xF7, 0x4F, 0x05, 0x46, + 0x0E, 0x46, 0x01, 0xEB, 0x06, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x82, 0xB0, + 0x05, 0xEB, 0x80, 0x0A, + 0x00, 0x24, 0x4F, 0xF0, 0x01, 0x08, 0xDF, 0xF8, 0x98, 0xB5, 0x05, 0xF5, + 0x80, 0x57, 0x7F, 0xE0, + 0xD7, 0xF8, 0xEC, 0x23, 0x08, 0xFA, 0x04, 0xF9, 0x12, 0xEA, 0x09, 0x0F, + 0x77, 0xD0, 0xB4, 0x42, + 0x75, 0xD0, 0xDB, 0xF8, 0x08, 0x10, 0x31, 0xF8, 0x16, 0x10, 0x11, 0xEA, + 0x09, 0x0F, 0x6E, 0xD1, + 0x04, 0xEB, 0x04, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x05, 0xEB, 0x80, 0x00, + 0x00, 0x90, 0x00, 0xF0, + 0x0A, 0xFB, 0x01, 0x28, 0x04, 0xD0, 0x00, 0x98, 0x00, 0xF0, 0x0B, 0xFB, + 0x01, 0x28, 0x5E, 0xD1, + 0x00, 0x98, 0x00, 0xF0, 0xF8, 0xFA, 0xE8, 0xBB, 0x00, 0x99, 0x0A, 0xF1, + 0x0C, 0x00, 0x0C, 0x31, + 0x08, 0xF0, 0x51, 0xFA, 0x01, 0x90, 0xDB, 0xF8, 0x08, 0x00, 0x08, 0xFA, + 0x06, 0xF2, 0x30, 0xF8, + 0x16, 0x30, 0x43, 0xEA, 0x09, 0x03, 0x20, 0xF8, 0x16, 0x30, 0x30, 0xF8, + 0x14, 0x30, 0x13, 0x43, + 0x20, 0xF8, 0x14, 0x30, 0x50, 0x46, 0xDB, 0xF8, 0x00, 0x90, 0x00, 0xF0, + 0xF6, 0xFA, 0x01, 0x28, + 0x04, 0xD1, 0x00, 0x98, 0x00, 0xF0, 0xDF, 0xFA, 0x01, 0x28, 0x1D, 0xD0, + 0x50, 0x46, 0x00, 0xF0, + 0xDA, 0xFA, 0x01, 0x28, 0x04, 0xD1, 0x00, 0x98, 0x00, 0xF0, 0xE7, 0xFA, + 0x01, 0x28, 0x13, 0xD0, + 0x50, 0x46, 0x00, 0xF0, 0xD0, 0xFA, 0x01, 0x28, 0x1E, 0xD1, 0x00, 0x98, + 0x00, 0xF0, 0xCB, 0xFA, + 0x01, 0x28, 0x19, 0xD1, 0x00, 0x99, 0x9A, 0xF8, 0x42, 0x00, 0x91, 0xF8, + 0x42, 0x10, 0x08, 0x43, + 0x80, 0x06, 0x00, 0xE0, 0x1B, 0xE0, 0x0F, 0xD5, 0xBA, 0xF8, 0x42, 0x00, + 0xDB, 0xF8, 0x04, 0x90, + 0x40, 0xF0, 0x20, 0x01, 0xAA, 0xF8, 0x42, 0x10, 0x00, 0x98, 0xB0, 0xF8, + 0x42, 0x00, 0x40, 0xF0, + 0x20, 0x01, 0x00, 0x98, 0xA0, 0xF8, 0x42, 0x10, 0x01, 0x98, 0x48, 0x45, + 0x07, 0xD2, 0x41, 0xF2, + 0x68, 0x40, 0x51, 0x46, 0x28, 0x44, 0x04, 0x9B, 0x00, 0x9A, 0x00, 0xF0, + 0xD0, 0xFA, 0x64, 0x1C, + 0x97, 0xF9, 0xF4, 0x03, 0xA0, 0x42, 0xBF, 0xF6, 0x7B, 0xAF, 0x05, 0xB0, + 0x63, 0xE7, 0x2D, 0xE9, + 0xF8, 0x4F, 0x88, 0x46, 0x06, 0x46, 0x01, 0xEB, 0x08, 0x10, 0x00, 0xEB, + 0x80, 0x00, 0x06, 0xEB, + 0x80, 0x04, 0xDF, 0xF8, 0x6C, 0xA4, 0x94, 0xF8, 0x42, 0x00, 0x4F, 0xF0, + 0x04, 0x0B, 0x40, 0x06, + 0x4F, 0xF0, 0x01, 0x09, 0x06, 0xF5, 0x80, 0x55, 0x2E, 0xD5, 0x00, 0x27, + 0x04, 0xF1, 0x0C, 0x0B, + 0x24, 0xE0, 0x00, 0xBF, 0xD5, 0xF8, 0xEC, 0x13, 0x09, 0xFA, 0x07, 0xF0, + 0x01, 0x42, 0x1C, 0xD0, + 0x47, 0x45, 0x1A, 0xD0, 0x07, 0xEB, 0x07, 0x10, 0x00, 0xEB, 0x80, 0x00, + 0x06, 0xEB, 0x80, 0x00, + 0x00, 0x90, 0x00, 0xF0, 0x70, 0xFA, 0x01, 0x28, 0x0F, 0xD1, 0x00, 0x98, + 0x00, 0xF0, 0x63, 0xFA, + 0x58, 0xB9, 0x00, 0x99, 0x58, 0x46, 0x10, 0x31, 0x08, 0xF0, 0xBD, 0xF9, + 0xDA, 0xF8, 0x04, 0x10, + 0x88, 0x42, 0x02, 0xD2, 0x04, 0x20, 0x84, 0xF8, 0x3E, 0x01, 0x7F, 0x1C, + 0x95, 0xF9, 0xF4, 0x03, + 0xB8, 0x42, 0xD7, 0xDA, 0xBD, 0xE8, 0xF8, 0x8F, 0xFE, 0x48, 0xE1, 0x6A, + 0x00, 0x68, 0x90, 0xF8, + 0x95, 0x03, 0x81, 0x42, 0xF6, 0xD9, 0x00, 0x27, 0x31, 0xE0, 0x00, 0xBF, + 0xD5, 0xF8, 0xEC, 0x13, + 0x09, 0xFA, 0x07, 0xF0, 0x01, 0x42, 0x29, 0xD0, 0x47, 0x45, 0x27, 0xD0, + 0x07, 0xEB, 0x07, 0x10, + 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x00, 0x00, 0x90, 0x00, 0xF0, + 0x3C, 0xFA, 0x01, 0x28, + 0x1C, 0xD1, 0x00, 0x98, 0x94, 0xF8, 0x46, 0x11, 0x90, 0xF8, 0x47, 0x01, + 0x81, 0x42, 0x15, 0xD1, + 0x00, 0x98, 0x00, 0xF0, 0x28, 0xFA, 0x88, 0xB9, 0x00, 0x99, 0x04, 0xF1, + 0x0C, 0x00, 0x10, 0x31, + 0x08, 0xF0, 0x81, 0xF9, 0xDA, 0xF8, 0x04, 0x10, 0x88, 0x42, 0x07, 0xD2, + 0x84, 0xF8, 0x3E, 0xB1, + 0xB4, 0xF8, 0x42, 0x00, 0x40, 0xF0, 0x40, 0x00, 0xA4, 0xF8, 0x42, 0x00, + 0x7F, 0x1C, 0x95, 0xF9, + 0xF4, 0x03, 0xB8, 0x42, 0xCA, 0xDA, 0x00, 0x27, 0x0C, 0x34, 0x26, 0xE0, + 0xD5, 0xF8, 0xEC, 0x13, + 0x09, 0xFA, 0x07, 0xF0, 0x01, 0x42, 0x1F, 0xD0, 0x47, 0x45, 0x1D, 0xD0, + 0x07, 0xEB, 0x07, 0x10, + 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x00, 0x83, 0x46, 0x00, 0xF0, + 0x0A, 0xFA, 0x01, 0x28, + 0x12, 0xD1, 0x58, 0x46, 0x00, 0xF0, 0xF7, 0xF9, 0x70, 0xB9, 0x0B, 0xF1, + 0x10, 0x01, 0x20, 0x46, + 0x08, 0xF0, 0x51, 0xF9, 0xDA, 0xF8, 0x04, 0x10, 0x88, 0x42, 0x05, 0xD2, + 0xBB, 0xF8, 0x42, 0x00, + 0x40, 0xF0, 0x40, 0x01, 0xAB, 0xF8, 0x42, 0x10, 0x7F, 0x1C, 0x95, 0xF9, + 0xF4, 0x03, 0xB8, 0x42, + 0xD4, 0xDA, 0x8F, 0xE7, 0x2D, 0xE9, 0xF8, 0x43, 0x06, 0x46, 0xFF, 0x20, + 0x00, 0x25, 0x8D, 0xF8, + 0x00, 0x00, 0x01, 0x27, 0x06, 0xF5, 0x80, 0x54, 0x1A, 0xE0, 0x00, 0xBF, + 0x05, 0xEB, 0x05, 0x10, + 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x08, 0xD4, 0xF8, 0xEC, 0x03, + 0x07, 0xFA, 0x05, 0xF1, + 0x08, 0x42, 0x0C, 0xD0, 0x40, 0x46, 0x00, 0xF0, 0xC6, 0xF9, 0x01, 0x28, + 0x07, 0xD0, 0x98, 0xF8, + 0x3E, 0x01, 0x05, 0x28, 0x03, 0xD1, 0x29, 0x46, 0x30, 0x46, 0xFF, 0xF7, + 0x28, 0xFF, 0x6D, 0x1C, + 0x94, 0xF9, 0xF4, 0x03, 0xA8, 0x42, 0xE1, 0xDA, 0x00, 0x25, 0x1B, 0xE0, + 0x05, 0xEB, 0x05, 0x10, + 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x08, 0xD4, 0xF8, 0xEC, 0x03, + 0x07, 0xFA, 0x05, 0xF1, + 0x08, 0x42, 0x0E, 0xD0, 0x40, 0x46, 0x00, 0xF0, 0xA6, 0xF9, 0x01, 0x28, + 0x09, 0xD0, 0x40, 0x46, + 0x00, 0xF0, 0xAF, 0xF9, 0x01, 0x28, 0x04, 0xD1, 0x6A, 0x46, 0x29, 0x46, + 0x30, 0x46, 0xFF, 0xF7, + 0x6C, 0xFE, 0x6D, 0x1C, 0x94, 0xF9, 0xF4, 0x03, 0xA8, 0x42, 0xDF, 0xDA, + 0x00, 0x25, 0xB8, 0x46, + 0x21, 0xE0, 0x00, 0xBF, 0x05, 0xEB, 0x05, 0x10, 0x00, 0xEB, 0x80, 0x00, + 0x06, 0xEB, 0x80, 0x07, + 0xD4, 0xF8, 0xEC, 0x13, 0x08, 0xFA, 0x05, 0xF0, 0x01, 0x42, 0x13, 0xD0, + 0x38, 0x46, 0x00, 0xF0, + 0x82, 0xF9, 0x01, 0x28, 0x0E, 0xD0, 0x38, 0x46, 0x00, 0xF0, 0x85, 0xF9, + 0x01, 0x28, 0x04, 0xD1, + 0x6A, 0x46, 0x29, 0x46, 0x30, 0x46, 0xFF, 0xF7, 0x48, 0xFE, 0x37, 0xF8, + 0x42, 0x0F, 0x20, 0xF0, + 0x20, 0x00, 0x38, 0x80, 0x6D, 0x1C, 0x94, 0xF9, 0xF4, 0x03, 0xA8, 0x42, + 0xDA, 0xDA, 0x9D, 0xF8, + 0x00, 0x00, 0x40, 0x1C, 0x84, 0xF8, 0xE0, 0x04, 0xBD, 0xE8, 0xF8, 0x83, + 0x10, 0xB5, 0x04, 0x46, + 0x87, 0x48, 0x03, 0x21, 0x08, 0x30, 0x05, 0xF0, 0xD2, 0xFB, 0x85, 0x48, + 0x1E, 0x21, 0x80, 0x68, + 0x0B, 0xF0, 0xD2, 0xFF, 0x41, 0xF2, 0x68, 0x40, 0x7C, 0x21, 0x20, 0x44, + 0x0B, 0xF0, 0xEE, 0xFF, + 0x80, 0x48, 0x02, 0x68, 0x80, 0x48, 0xB2, 0xF8, 0x96, 0x13, 0x00, 0x78, + 0x49, 0x43, 0x10, 0xB1, + 0xB2, 0xF8, 0x6C, 0x13, 0x49, 0x43, 0xB2, 0xF8, 0x98, 0x23, 0x02, 0xFB, + 0x02, 0x10, 0x78, 0x4A, + 0x11, 0x60, 0x11, 0x1D, 0x08, 0x60, 0x20, 0x46, 0xFF, 0xF7, 0x5C, 0xFF, + 0x20, 0x46, 0xFF, 0xF7, + 0x3B, 0xFD, 0x73, 0x48, 0x03, 0x21, 0xBD, 0xE8, 0x10, 0x40, 0x08, 0x30, + 0x05, 0xF0, 0xC4, 0xBB, + 0xF0, 0xB4, 0x84, 0x6B, 0xC2, 0x68, 0x8B, 0x6B, 0xCE, 0x68, 0x17, 0x14, + 0x67, 0x43, 0x4F, 0xEA, + 0x26, 0x4C, 0x03, 0xFB, 0x0C, 0x77, 0xE5, 0x18, 0x97, 0xFB, 0xF5, 0xF7, + 0x67, 0xF3, 0x1F, 0x42, + 0x17, 0xB2, 0x67, 0x43, 0x34, 0xB2, 0x03, 0xFB, 0x04, 0x73, 0x93, 0xFB, + 0xF5, 0xF3, 0x63, 0xF3, + 0x0F, 0x02, 0xC2, 0x60, 0xF0, 0xBC, 0xDF, 0xE4, 0x62, 0x4A, 0x12, 0x68, + 0x92, 0xF8, 0x40, 0x24, + 0x92, 0x06, 0x11, 0xD5, 0x90, 0xF8, 0x49, 0x31, 0x23, 0xB1, 0x91, 0xF8, + 0x49, 0x21, 0x0A, 0xB1, + 0x93, 0x42, 0x07, 0xD1, 0x90, 0xF8, 0x4A, 0x01, 0x30, 0xB1, 0x91, 0xF8, + 0x4A, 0x11, 0x19, 0xB1, + 0x88, 0x42, 0x01, 0xD0, 0x00, 0x20, 0x70, 0x47, 0x01, 0x20, 0x70, 0x47, + 0x2D, 0xE9, 0xFE, 0x4F, + 0x00, 0xF5, 0x80, 0x54, 0x05, 0x46, 0xD4, 0xF8, 0xF8, 0x13, 0xD4, 0xF8, + 0xEC, 0x03, 0x01, 0x40, + 0x00, 0x28, 0xC4, 0xF8, 0xF8, 0x13, 0x4F, 0xF0, 0x00, 0x00, 0x0C, 0xD0, + 0x81, 0x46, 0x0F, 0x21, + 0x4E, 0x48, 0x0B, 0xF0, 0x61, 0xFF, 0x00, 0x26, 0xDF, 0xF8, 0x30, 0xA1, + 0x4F, 0xF0, 0x01, 0x08, + 0x41, 0xF2, 0xFC, 0x3B, 0x5A, 0xE0, 0xC4, 0xF8, 0xF8, 0x03, 0xBD, 0xE8, + 0xFE, 0x8F, 0xD4, 0xF8, + 0xEC, 0x23, 0x08, 0xFA, 0x06, 0xF1, 0x40, 0x46, 0x0A, 0x42, 0x4E, 0xD0, + 0x06, 0xEB, 0x06, 0x12, + 0x02, 0xEB, 0x82, 0x02, 0x05, 0xEB, 0x82, 0x07, 0x97, 0xF8, 0x40, 0x20, + 0x12, 0x06, 0xD4, 0xF8, + 0xF8, 0x23, 0x11, 0xD5, 0x0A, 0x43, 0x05, 0xEB, 0x86, 0x01, 0xC4, 0xF8, + 0xF8, 0x23, 0x01, 0xF5, + 0x9C, 0x51, 0xD7, 0xF8, 0x5A, 0x20, 0xCA, 0x67, 0x97, 0xF8, 0x46, 0x11, + 0x88, 0x40, 0x40, 0xEA, + 0x09, 0x09, 0x0A, 0xF8, 0x01, 0x60, 0x30, 0xE0, 0x0A, 0x42, 0x2E, 0xD0, + 0x97, 0xF8, 0x3E, 0x21, + 0x06, 0x2A, 0x14, 0xD0, 0x05, 0x2A, 0x12, 0xD0, 0x97, 0xF8, 0x46, 0x11, + 0x08, 0xFA, 0x01, 0xF0, + 0x40, 0xEA, 0x09, 0x09, 0x0A, 0xF8, 0x01, 0x60, 0x05, 0xEB, 0x86, 0x01, + 0x01, 0xEB, 0x0B, 0x00, + 0x5A, 0x37, 0x39, 0x46, 0x00, 0x90, 0x03, 0xF0, 0x8F, 0xFB, 0x98, 0xB1, + 0x15, 0xE0, 0xB7, 0xF8, + 0x42, 0x00, 0x20, 0xF0, 0x08, 0x00, 0xA7, 0xF8, 0x42, 0x00, 0xD4, 0xF8, + 0xF8, 0x03, 0x88, 0x43, + 0xC4, 0xF8, 0xF8, 0x03, 0x22, 0x49, 0x05, 0xEB, 0x86, 0x00, 0x00, 0xF5, + 0x9C, 0x50, 0x09, 0x68, + 0xC1, 0x67, 0xE1, 0xE7, 0x00, 0x98, 0x39, 0x68, 0x01, 0x60, 0x76, 0x1C, + 0x94, 0xF9, 0xF4, 0x03, + 0xB0, 0x42, 0xA4, 0xDA, 0x00, 0x27, 0x72, 0xE0, 0xD4, 0xF8, 0xEC, 0x23, + 0x08, 0xFA, 0x07, 0xF1, + 0x0A, 0x42, 0x6B, 0xD0, 0xD4, 0xF8, 0xF8, 0x23, 0x0A, 0x42, 0x67, 0xD1, + 0x07, 0xEB, 0x07, 0x11, + 0x01, 0xEB, 0x81, 0x01, 0x05, 0xEB, 0x81, 0x01, 0x00, 0x91, 0x91, 0xF8, + 0x3E, 0x11, 0x02, 0x29, + 0x01, 0xD0, 0x01, 0x29, 0x5A, 0xD1, 0x00, 0x99, 0x43, 0x46, 0x91, 0xF8, + 0x46, 0x11, 0x08, 0xFA, + 0x01, 0xF0, 0x10, 0xEA, 0x09, 0x0F, 0x23, 0xD0, 0x1A, 0xF8, 0x01, 0x00, + 0xB8, 0x42, 0x4D, 0xD0, + 0x00, 0xEB, 0x00, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x05, 0xEB, 0x80, 0x00, + 0x06, 0x46, 0x09, 0xE0, + 0x08, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xFD, 0x06, 0x10, 0x00, + 0x80, 0x2C, 0x10, 0x00, + 0x36, 0x7A, 0x01, 0x00, 0x00, 0x99, 0xFF, 0xF7, 0x2F, 0xFF, 0x01, 0x28, + 0x36, 0xD1, 0x30, 0x46, + 0x00, 0x99, 0xFF, 0xF7, 0x0D, 0xFF, 0x28, 0x46, 0x00, 0x99, 0x00, 0xF0, + 0xF7, 0xFD, 0x2D, 0xE0, + 0x00, 0x98, 0x98, 0x46, 0x5A, 0x30, 0x00, 0x26, 0x02, 0x90, 0x23, 0xE0, + 0xD4, 0xF8, 0xF8, 0x13, + 0x08, 0xFA, 0x06, 0xF0, 0x01, 0x42, 0x1C, 0xD0, 0x06, 0xEB, 0x06, 0x10, + 0x00, 0xEB, 0x80, 0x00, + 0x05, 0xEB, 0x80, 0x00, 0x05, 0xEB, 0x86, 0x01, 0x01, 0x90, 0x59, 0x44, + 0x02, 0x98, 0x03, 0xF0, + 0x13, 0xFB, 0x01, 0x28, 0x0D, 0xD1, 0xDD, 0xE9, 0x00, 0x10, 0xFF, 0xF7, + 0x05, 0xFF, 0x01, 0x28, + 0x07, 0xD1, 0xDD, 0xE9, 0x00, 0x10, 0xFF, 0xF7, 0xE3, 0xFE, 0x28, 0x46, + 0x00, 0x99, 0x00, 0xF0, + 0xCD, 0xFD, 0x76, 0x1C, 0x94, 0xF9, 0xF4, 0x03, 0xB0, 0x42, 0xD7, 0xDA, + 0x7F, 0x1C, 0x94, 0xF9, + 0xF4, 0x03, 0xB8, 0x42, 0x88, 0xDA, 0x28, 0xE7, 0x33, 0x49, 0x00, 0x20, + 0x88, 0x60, 0x0F, 0x21, + 0x32, 0x48, 0x0B, 0xF0, 0x79, 0xBE, 0x90, 0xF8, 0x42, 0x00, 0x40, 0x07, + 0x01, 0xD5, 0x01, 0x20, + 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x90, 0xF8, 0x3E, 0x01, 0x01, 0x28, + 0x00, 0xD0, 0x00, 0x20, + 0x70, 0x47, 0x90, 0xF8, 0x3E, 0x01, 0x02, 0x28, 0x05, 0xD0, 0x03, 0x28, + 0x03, 0xD0, 0x04, 0x28, + 0x01, 0xD0, 0x00, 0x20, 0x70, 0x47, 0x01, 0x20, 0x70, 0x47, 0x10, 0xB5, + 0x90, 0xF8, 0x42, 0x10, + 0x49, 0x06, 0x03, 0xD5, 0xFF, 0xF7, 0xED, 0xFF, 0x01, 0x28, 0x00, 0xD0, + 0x00, 0x20, 0x10, 0xBD, + 0x91, 0xF8, 0x3E, 0x21, 0x01, 0x2A, 0x08, 0xD0, 0x02, 0x2A, 0x06, 0xD0, + 0x06, 0x20, 0x81, 0xF8, + 0x3E, 0x01, 0x00, 0x20, 0x81, 0xF8, 0x43, 0x01, 0x70, 0x47, 0x00, 0xF0, + 0x87, 0xBD, 0xF0, 0xB5, + 0x91, 0xF9, 0x4B, 0x61, 0x93, 0xF9, 0x00, 0x40, 0x92, 0xF9, 0x4B, 0x51, + 0x77, 0x1C, 0x02, 0xD0, + 0x6D, 0x1C, 0x15, 0xD0, 0x0B, 0xE0, 0x6E, 0x1C, 0x0B, 0xD0, 0x00, 0xEB, + 0x85, 0x02, 0x00, 0xEB, + 0x84, 0x00, 0xD2, 0x6B, 0xC2, 0xF8, 0x50, 0x11, 0xC1, 0x63, 0x81, 0xF8, + 0x4B, 0x41, 0x1C, 0x70, + 0xF0, 0xBD, 0x64, 0x1C, 0x64, 0xB2, 0x40, 0xF8, 0x24, 0x10, 0x81, 0xF8, + 0x4B, 0x41, 0x02, 0xE0, + 0x00, 0xEB, 0x86, 0x01, 0xC9, 0x6B, 0x00, 0xEB, 0x84, 0x00, 0xC1, 0xF8, + 0x50, 0x21, 0xC2, 0x63, + 0x82, 0xF8, 0x4B, 0x41, 0xEB, 0xE7, 0x00, 0x00, 0x08, 0x06, 0x10, 0x00, + 0x80, 0x2C, 0x10, 0x00, + 0xF0, 0xB5, 0x44, 0x88, 0x4E, 0x88, 0x01, 0x25, 0xA4, 0x1B, 0x24, 0xB2, + 0x00, 0x2C, 0x01, 0xDB, + 0x26, 0x46, 0x00, 0xE0, 0x66, 0x42, 0x5E, 0x80, 0x56, 0x42, 0x94, 0x42, + 0x02, 0xDD, 0x44, 0x88, + 0xA4, 0x1A, 0x03, 0xE0, 0xB4, 0x42, 0x03, 0xDA, 0x44, 0x88, 0x14, 0x44, + 0x4C, 0x80, 0x00, 0x25, + 0x04, 0x88, 0x0F, 0x88, 0xE4, 0x1B, 0x24, 0xB2, 0x00, 0x2C, 0x01, 0xDB, + 0x27, 0x46, 0x00, 0xE0, + 0x67, 0x42, 0x1F, 0x80, 0x94, 0x42, 0x02, 0xDD, 0x00, 0x88, 0x80, 0x1A, + 0x03, 0xE0, 0xB4, 0x42, + 0x03, 0xDA, 0x00, 0x88, 0x10, 0x44, 0x08, 0x80, 0x00, 0x25, 0x28, 0x46, + 0xF0, 0xBD, 0x2D, 0xE9, + 0xF0, 0x41, 0x96, 0x4D, 0x0F, 0x46, 0x06, 0x46, 0x81, 0x89, 0x28, 0x68, + 0x90, 0x46, 0xF9, 0xB1, + 0x90, 0xF8, 0xC7, 0x43, 0x0B, 0xF0, 0xA8, 0xFE, 0x18, 0xB1, 0x28, 0x68, + 0x90, 0xF8, 0xC9, 0x43, + 0x12, 0xE0, 0xB0, 0x7D, 0x02, 0x28, 0x04, 0xD0, 0x01, 0x28, 0x06, 0xD0, + 0x03, 0x28, 0x08, 0xD0, + 0x0A, 0xE0, 0x28, 0x68, 0x90, 0xF8, 0xCE, 0x43, 0x06, 0xE0, 0x28, 0x68, + 0x90, 0xF8, 0x51, 0x44, + 0x02, 0xE0, 0x28, 0x68, 0x90, 0xF8, 0x2C, 0x44, 0xB0, 0x89, 0x40, 0x1E, + 0xB0, 0x81, 0x11, 0xE0, + 0xB1, 0x7D, 0x90, 0xF8, 0xCB, 0x43, 0x02, 0x29, 0x04, 0xD0, 0x01, 0x29, + 0x05, 0xD0, 0x03, 0x29, + 0x06, 0xD0, 0x07, 0xE0, 0x90, 0xF8, 0xCE, 0x43, 0x04, 0xE0, 0x90, 0xF8, + 0x52, 0x44, 0x01, 0xE0, + 0x90, 0xF8, 0x2D, 0x44, 0x29, 0x68, 0xB2, 0x7D, 0x91, 0xF8, 0xCA, 0x03, + 0x02, 0x2A, 0x04, 0xD0, + 0x01, 0x2A, 0x05, 0xD0, 0x03, 0x2A, 0x06, 0xD0, 0x07, 0xE0, 0x91, 0xF8, + 0xCD, 0x03, 0x04, 0xE0, + 0x91, 0xF8, 0x53, 0x04, 0x01, 0xE0, 0x91, 0xF8, 0x2E, 0x04, 0x38, 0x80, + 0xA8, 0xF8, 0x00, 0x40, + 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xF0, 0x4F, 0x00, 0xF1, 0x5E, 0x04, + 0x85, 0xB0, 0x4F, 0xF0, + 0x00, 0x0B, 0x84, 0xF8, 0x15, 0xB0, 0xDF, 0xF8, 0xA4, 0x91, 0x0E, 0x46, + 0x80, 0xF8, 0x74, 0xB0, + 0x05, 0x46, 0xB0, 0xF8, 0x42, 0x10, 0x4F, 0xF0, 0x01, 0x08, 0xD9, 0xF8, + 0x00, 0x00, 0x4A, 0x06, + 0xC2, 0x46, 0x01, 0xD5, 0x02, 0x21, 0x0F, 0xE0, 0x0A, 0x07, 0x06, 0xD5, + 0x90, 0xF8, 0x40, 0x24, + 0x52, 0x06, 0x02, 0xD5, 0x84, 0xF8, 0x16, 0xA0, 0x07, 0xE0, 0x90, 0xF8, + 0x20, 0x24, 0x92, 0x07, + 0x03, 0xD5, 0x09, 0x06, 0x01, 0xD5, 0x03, 0x21, 0xA1, 0x75, 0x95, 0xF8, + 0x3E, 0x11, 0x03, 0x29, + 0x09, 0xD0, 0xA2, 0x7C, 0x01, 0x2A, 0x06, 0xD0, 0x04, 0x29, 0x2D, 0xD0, + 0x07, 0x29, 0x2B, 0xD0, + 0x08, 0x29, 0x76, 0xD0, 0x9C, 0xE0, 0x90, 0xF8, 0xC6, 0x73, 0x0B, 0xF0, + 0x25, 0xFE, 0x18, 0xB1, + 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0xC8, 0x73, 0x95, 0xF8, 0x3E, 0x01, + 0x03, 0x28, 0x00, 0xD0, + 0x00, 0x27, 0xA0, 0x7D, 0x01, 0x28, 0x02, 0xD0, 0x03, 0x28, 0x05, 0xD0, + 0x08, 0xE0, 0xD9, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0x50, 0x74, 0x03, 0xE0, 0xD9, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x2B, 0x74, + 0xA7, 0x81, 0x31, 0x68, 0x21, 0x60, 0x31, 0x68, 0x61, 0x60, 0x84, 0xF8, + 0x14, 0xA0, 0x84, 0xF8, + 0x13, 0xA0, 0x84, 0xF8, 0x12, 0xB0, 0x73, 0xE0, 0x02, 0xAA, 0x01, 0xA9, + 0x20, 0x46, 0xFF, 0xF7, + 0x46, 0xFF, 0x03, 0xAB, 0xBD, 0xF9, 0x08, 0x20, 0x21, 0x46, 0x30, 0x46, + 0xFF, 0xF7, 0x10, 0xFF, + 0x83, 0x46, 0x04, 0xAB, 0xBD, 0xF9, 0x04, 0x20, 0x21, 0x1D, 0x30, 0x46, + 0xFF, 0xF7, 0x08, 0xFF, + 0x07, 0x46, 0xBB, 0xF1, 0x01, 0x0F, 0x03, 0xD0, 0x20, 0x7D, 0x01, 0x28, + 0x4D, 0xD0, 0x4E, 0xE0, + 0xBD, 0xF9, 0x0C, 0x00, 0xBD, 0xF9, 0x0E, 0x10, 0x81, 0x42, 0x00, 0xDD, + 0x08, 0x46, 0xD9, 0xF8, + 0x00, 0x10, 0x91, 0xF8, 0xCC, 0x23, 0x02, 0xF0, 0x0F, 0x03, 0x4F, 0xEA, + 0x12, 0x1C, 0xA2, 0x7D, + 0x02, 0x2A, 0x04, 0xD0, 0x01, 0x2A, 0x05, 0xD0, 0x03, 0x2A, 0x06, 0xD0, + 0x0B, 0xE0, 0x91, 0xF8, + 0xCF, 0x13, 0x04, 0xE0, 0x91, 0xF8, 0x54, 0x14, 0x01, 0xE0, 0x91, 0xF8, + 0x2F, 0x14, 0x01, 0xF0, + 0x0F, 0x03, 0x4F, 0xEA, 0x11, 0x1C, 0x01, 0x2F, 0x0C, 0xD0, 0xCD, 0xF8, + 0x00, 0xC0, 0xBD, 0xF9, + 0x08, 0x20, 0xBD, 0xF9, 0x04, 0x10, 0x07, 0xF0, 0xDC, 0xFD, 0x21, 0x7D, + 0x01, 0x29, 0x0D, 0xD0, + 0x18, 0xE0, 0x23, 0xE0, 0xA0, 0x68, 0x30, 0x60, 0xD9, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x80, 0x03, + 0x00, 0x06, 0x01, 0xD4, 0x4F, 0xF0, 0x00, 0x08, 0x60, 0x46, 0xEE, 0xE7, + 0x95, 0xF8, 0x41, 0x11, + 0x41, 0xB9, 0xD9, 0xF8, 0x00, 0x10, 0x91, 0xF8, 0xBC, 0x13, 0x0A, 0x09, + 0xD4, 0xF8, 0x0E, 0x10, + 0x07, 0xF0, 0xD4, 0xFD, 0xC4, 0xF8, 0x0E, 0x00, 0x01, 0xE0, 0x84, 0xF8, + 0x15, 0xA0, 0x84, 0xF8, + 0x14, 0xB0, 0xE7, 0x74, 0xB8, 0xF1, 0x00, 0x0F, 0x02, 0xD1, 0x03, 0xE0, + 0xA0, 0x68, 0x30, 0x60, + 0x30, 0x68, 0xA0, 0x60, 0x05, 0xB0, 0x40, 0x46, 0xBD, 0xE8, 0xF0, 0x8F, + 0x4C, 0x07, 0x10, 0x00, + 0x2D, 0xE9, 0xF0, 0x41, 0x17, 0x46, 0x06, 0x46, 0xDD, 0xE9, 0x06, 0xC2, + 0xC8, 0x78, 0x00, 0x25, + 0x0C, 0x46, 0x03, 0x28, 0x30, 0xD2, 0xFE, 0x48, 0xDF, 0xF8, 0xF8, 0xE3, + 0x01, 0x68, 0x91, 0xF8, + 0x0A, 0x14, 0xA1, 0x70, 0xDE, 0xF8, 0x04, 0xE0, 0xBE, 0xF1, 0x00, 0x0F, + 0x06, 0xDD, 0xD0, 0xF8, + 0x00, 0xE0, 0x9E, 0xF8, 0x0B, 0xE4, 0xA1, 0xEB, 0x0E, 0x01, 0xA1, 0x70, + 0x00, 0x68, 0x71, 0x6B, + 0xB0, 0xF8, 0x0C, 0x04, 0x81, 0x42, 0x15, 0xDD, 0xDB, 0xB2, 0x39, 0x46, + 0x60, 0x46, 0x00, 0xF0, + 0xE8, 0xFA, 0xE0, 0x78, 0x40, 0x1C, 0xC0, 0xB2, 0xE0, 0x70, 0x03, 0x28, + 0x06, 0xD0, 0xEE, 0x49, + 0xB6, 0xF9, 0x56, 0x00, 0xB1, 0xF9, 0x00, 0x10, 0x88, 0x42, 0x05, 0xDD, + 0x03, 0x20, 0xE0, 0x70, + 0x01, 0x25, 0x01, 0xE0, 0x00, 0x20, 0xE0, 0x70, 0x28, 0x46, 0xBD, 0xE8, + 0xF0, 0x81, 0x2D, 0xE9, + 0xFC, 0x5F, 0x4F, 0xF0, 0x00, 0x0B, 0x0C, 0x46, 0x81, 0x46, 0x5D, 0x46, + 0x4F, 0xF0, 0x02, 0x0A, + 0x01, 0x26, 0x00, 0xF5, 0x80, 0x57, 0x7C, 0xE0, 0xD7, 0xF8, 0xEC, 0x03, + 0x06, 0xFA, 0x05, 0xFE, + 0x10, 0xEA, 0x0E, 0x0F, 0x74, 0xD0, 0x05, 0xEB, 0x05, 0x10, 0x00, 0xEB, + 0x80, 0x01, 0x09, 0xEB, + 0x81, 0x00, 0x00, 0xF5, 0x9A, 0x71, 0x90, 0xF8, 0x3E, 0x81, 0xB0, 0xF9, + 0x0E, 0xC0, 0xB8, 0xF1, + 0x01, 0x0F, 0x0F, 0xD0, 0xB8, 0xF1, 0x02, 0x0F, 0x0C, 0xD0, 0x90, 0xF8, + 0x42, 0x00, 0x40, 0x07, + 0x51, 0xD5, 0xD2, 0x48, 0xEB, 0xB2, 0x61, 0x46, 0xB0, 0xF9, 0x08, 0x20, + 0x20, 0x46, 0x00, 0xF0, + 0xA0, 0xFA, 0x55, 0xE0, 0xCE, 0x4B, 0xB0, 0xF9, 0x54, 0x20, 0xB3, 0xF9, + 0x00, 0x30, 0x9A, 0x42, + 0x4E, 0xDB, 0xB8, 0xF1, 0x01, 0x0F, 0x03, 0xD1, 0x00, 0x22, 0x0A, 0x60, + 0x4A, 0x60, 0x0A, 0x81, + 0xC6, 0x4A, 0xB2, 0xF9, 0x00, 0x30, 0x63, 0x45, 0x03, 0xDC, 0xB2, 0xF9, + 0x02, 0x30, 0x63, 0x45, + 0x0C, 0xDA, 0xB0, 0xF8, 0x42, 0x30, 0x43, 0xF0, 0x04, 0x03, 0xA0, 0xF8, + 0x42, 0x30, 0xC3, 0x68, + 0x4B, 0x60, 0x81, 0xF8, 0x08, 0xA0, 0xB2, 0xF9, 0x00, 0x20, 0x19, 0xE0, + 0xB2, 0xF9, 0x08, 0x30, + 0x63, 0x45, 0x03, 0xDC, 0xB2, 0xF9, 0x0A, 0x30, 0x63, 0x45, 0x19, 0xDA, + 0xB0, 0xF8, 0x42, 0x30, + 0x43, 0xF0, 0x04, 0x03, 0xA0, 0xF8, 0x42, 0x30, 0x90, 0xF8, 0x3E, 0x31, + 0x01, 0x2B, 0x02, 0xD0, + 0x0B, 0x7A, 0x02, 0x2B, 0x01, 0xD1, 0xC3, 0x68, 0x4B, 0x60, 0x0E, 0x72, + 0xB2, 0xF9, 0x08, 0x20, + 0x2B, 0x46, 0xCD, 0xE9, 0x00, 0x42, 0x62, 0x46, 0xFF, 0xF7, 0x4A, 0xFF, + 0x83, 0x46, 0x0F, 0xE0, + 0x00, 0x20, 0x08, 0x72, 0x08, 0xE0, 0xA9, 0x48, 0xB0, 0xF9, 0x08, 0x10, + 0x61, 0x45, 0x07, 0xDA, + 0xB0, 0xF9, 0x0A, 0x00, 0x60, 0x45, 0x03, 0xDD, 0xA0, 0x68, 0x40, 0xEA, + 0x0E, 0x00, 0xA0, 0x60, + 0x6D, 0x1C, 0x97, 0xF9, 0xF4, 0x03, 0xA8, 0x42, 0xBF, 0xF4, 0x7E, 0xAF, + 0x20, 0x68, 0x61, 0x68, + 0x9C, 0x4A, 0x50, 0xEA, 0x01, 0x03, 0xA3, 0x68, 0x01, 0xD0, 0x23, 0xB1, + 0x04, 0xE0, 0x1B, 0xB1, + 0x82, 0xF8, 0x00, 0xA0, 0x00, 0xE0, 0x16, 0x70, 0x98, 0x4A, 0x18, 0x32, + 0x13, 0x68, 0x98, 0x43, + 0x20, 0x60, 0x50, 0x68, 0x81, 0x43, 0x61, 0x60, 0x96, 0x49, 0xA0, 0x68, + 0x09, 0x78, 0x08, 0x43, + 0x05, 0xD1, 0x92, 0x49, 0x18, 0x22, 0x18, 0x39, 0x90, 0x48, 0x0B, 0xF0, + 0x8B, 0xFB, 0x58, 0x46, + 0xBD, 0xE8, 0xFC, 0x9F, 0x8B, 0x4A, 0x10, 0xB5, 0x12, 0x78, 0x00, 0x21, + 0x01, 0x2A, 0x01, 0xD1, + 0x03, 0xB1, 0x01, 0x21, 0x90, 0xF8, 0x3E, 0x21, 0x04, 0x2A, 0x18, 0xD1, + 0x84, 0x4A, 0x12, 0x68, + 0x92, 0xF8, 0x00, 0x34, 0x5B, 0x07, 0x12, 0xD5, 0xB0, 0xF8, 0x4A, 0x30, + 0xB0, 0xF8, 0x4C, 0x40, + 0x1B, 0x1B, 0x82, 0x4C, 0xA4, 0x8A, 0xA3, 0x42, 0x09, 0xDD, 0x90, 0xF8, + 0x5B, 0x30, 0x90, 0xF8, + 0x5A, 0x00, 0x92, 0xF8, 0x09, 0x24, 0x18, 0x1A, 0x90, 0x42, 0x00, 0xDD, + 0x01, 0x21, 0x08, 0x46, + 0x10, 0xBD, 0x30, 0xB5, 0x79, 0x4D, 0x00, 0x24, 0x18, 0x35, 0x09, 0xB1, + 0x29, 0x68, 0x11, 0xB9, + 0x12, 0xB1, 0x69, 0x68, 0x01, 0xB1, 0x01, 0x24, 0x72, 0x49, 0x09, 0x78, + 0x01, 0x29, 0x01, 0xD1, + 0x03, 0xB1, 0x01, 0x24, 0x6E, 0x49, 0x09, 0x68, 0x91, 0xF8, 0x00, 0x24, + 0x52, 0x07, 0x16, 0xD5, + 0x90, 0xF8, 0x3E, 0x21, 0x04, 0x2A, 0x12, 0xD1, 0xB0, 0xF8, 0x4A, 0x20, + 0xB0, 0xF8, 0x4C, 0x30, + 0xD2, 0x1A, 0x6A, 0x4B, 0x9B, 0x8A, 0x9A, 0x42, 0x09, 0xDD, 0x90, 0xF8, + 0x5B, 0x20, 0x90, 0xF8, + 0x5A, 0x00, 0x91, 0xF8, 0x09, 0x14, 0x10, 0x1A, 0x88, 0x42, 0x00, 0xDD, + 0x01, 0x24, 0x20, 0x46, + 0x30, 0xBD, 0x2D, 0xE9, 0xF3, 0x4F, 0x8D, 0xB0, 0x5E, 0x48, 0x00, 0x25, + 0x8B, 0x46, 0x0A, 0x95, + 0x01, 0x78, 0x5E, 0x48, 0x18, 0x38, 0x01, 0x29, 0x06, 0xD1, 0xDB, 0xF8, + 0x08, 0x10, 0x19, 0xB1, + 0xD0, 0xF8, 0x1C, 0x80, 0x47, 0x6A, 0x02, 0xE0, 0xD0, 0xF8, 0x18, 0x80, + 0x07, 0x6A, 0x0D, 0x9E, + 0x00, 0x24, 0x4F, 0xF0, 0x01, 0x09, 0x06, 0xF5, 0x80, 0x56, 0x0F, 0xE1, + 0x09, 0xFA, 0x04, 0xF0, + 0xD6, 0xF8, 0xEC, 0x13, 0x0B, 0x90, 0x01, 0x42, 0x1A, 0xD0, 0x04, 0xEB, + 0x04, 0x10, 0x00, 0xEB, + 0x80, 0x01, 0x0D, 0x98, 0x00, 0xEB, 0x81, 0x0A, 0x9A, 0xF8, 0x42, 0x00, + 0x40, 0x07, 0x0F, 0xD5, + 0x0A, 0xF5, 0x9A, 0x70, 0x01, 0x90, 0xBA, 0xF9, 0x0E, 0x00, 0x02, 0x90, + 0x9A, 0xF8, 0x3E, 0x01, + 0x01, 0x28, 0x06, 0xD0, 0x02, 0x28, 0x04, 0xD0, 0x04, 0x28, 0x1F, 0xD0, + 0x05, 0x28, 0x7D, 0xD0, + 0xEB, 0xE0, 0xDB, 0xF8, 0x00, 0x10, 0xDB, 0xF8, 0x04, 0x20, 0xDB, 0xF8, + 0x08, 0x30, 0x50, 0x46, + 0xFF, 0xF7, 0x60, 0xFF, 0x01, 0x28, 0x02, 0xD1, 0x01, 0x99, 0x81, 0xF8, + 0x01, 0x90, 0xDB, 0xF8, + 0x00, 0x10, 0xDB, 0xF8, 0x04, 0x20, 0xDB, 0xF8, 0x08, 0x30, 0x50, 0x46, + 0xFF, 0xF7, 0x79, 0xFF, + 0x01, 0x28, 0xE5, 0xD1, 0x01, 0x99, 0x00, 0x20, 0x88, 0x70, 0xCE, 0xE0, + 0xDB, 0xF8, 0x00, 0x10, + 0xDB, 0xF8, 0x04, 0x20, 0xDB, 0xF8, 0x08, 0x30, 0x50, 0x46, 0xFF, 0xF7, + 0x6A, 0xFF, 0x01, 0x28, + 0x09, 0xD0, 0x01, 0x98, 0x80, 0x78, 0x48, 0xB1, 0x01, 0x99, 0x40, 0x1E, + 0x10, 0xF0, 0xFF, 0x00, + 0x88, 0x70, 0x03, 0xD0, 0x07, 0xE0, 0x01, 0x99, 0x00, 0x20, 0x88, 0x70, + 0x9A, 0xF8, 0x48, 0x11, + 0x09, 0xFA, 0x01, 0xF0, 0x05, 0x43, 0xDB, 0xF8, 0x00, 0x10, 0xDB, 0xF8, + 0x04, 0x20, 0xDB, 0xF8, + 0x08, 0x30, 0x50, 0x46, 0xFF, 0xF7, 0x26, 0xFF, 0x01, 0x28, 0x02, 0xD1, + 0x01, 0x99, 0x81, 0xF8, + 0x01, 0x90, 0x01, 0x98, 0xC0, 0x78, 0x03, 0x28, 0x1D, 0xD2, 0x01, 0x99, + 0x89, 0x78, 0xD1, 0xB1, + 0x17, 0x49, 0xDA, 0xF8, 0x34, 0x20, 0x09, 0x68, 0xB1, 0xF8, 0x0C, 0x14, + 0x8A, 0x42, 0x0F, 0xDD, + 0x40, 0x1C, 0x01, 0x99, 0xC0, 0xB2, 0x03, 0x28, 0xC8, 0x70, 0x06, 0xD0, + 0x12, 0x49, 0xBA, 0xF9, + 0x56, 0x00, 0xB1, 0xF9, 0x00, 0x10, 0x88, 0x42, 0x05, 0xDD, 0x01, 0x20, + 0x0A, 0x90, 0x02, 0xE0, + 0x01, 0x99, 0x00, 0x20, 0xC8, 0x70, 0x02, 0x98, 0x0F, 0xFA, 0x88, 0xF2, + 0x82, 0x42, 0x04, 0xDC, + 0x02, 0x98, 0x4F, 0xEA, 0x28, 0x41, 0x81, 0x42, 0x16, 0xDA, 0x01, 0x98, + 0x02, 0x21, 0xE3, 0xB2, + 0x01, 0x72, 0x01, 0x98, 0xDA, 0xF8, 0x0C, 0x10, 0x41, 0x60, 0x37, 0xE0, + 0x56, 0xE0, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x14, 0x06, 0x10, 0x00, 0x8C, 0x06, 0x10, 0x00, + 0xA8, 0x2C, 0x10, 0x00, + 0xA0, 0x06, 0x10, 0x00, 0x20, 0x07, 0x10, 0x00, 0x38, 0xB2, 0x02, 0x99, + 0x04, 0x90, 0x88, 0x42, + 0x03, 0xDC, 0x02, 0x98, 0x39, 0x14, 0x81, 0x42, 0x25, 0xDA, 0x01, 0x98, + 0x00, 0x7A, 0x02, 0x28, + 0x06, 0xD1, 0x01, 0x99, 0x81, 0xF8, 0x08, 0x90, 0x01, 0x98, 0xDA, 0xF8, + 0x0C, 0x10, 0x41, 0x60, + 0x01, 0x98, 0x40, 0x78, 0x80, 0xB9, 0x01, 0x98, 0x53, 0x46, 0x80, 0x78, + 0x00, 0x28, 0x82, 0x48, + 0x02, 0x69, 0x04, 0xD0, 0x01, 0x98, 0x0A, 0xF1, 0x0C, 0x01, 0x00, 0x1D, + 0x02, 0xE0, 0x0A, 0xF1, + 0x10, 0x01, 0x08, 0x1F, 0x00, 0xF0, 0xE2, 0xF8, 0x04, 0x9A, 0xE3, 0xB2, + 0x58, 0x46, 0x02, 0x99, + 0x00, 0xF0, 0xCF, 0xF8, 0x31, 0xE0, 0xDB, 0xF8, 0x08, 0x00, 0x0B, 0x99, + 0x08, 0x43, 0xCB, 0xF8, + 0x08, 0x00, 0x01, 0x98, 0x80, 0x78, 0x20, 0xB1, 0x01, 0x99, 0x00, 0x22, + 0x50, 0x46, 0x09, 0x1D, + 0x03, 0xE0, 0x01, 0x22, 0x0A, 0xF1, 0x0C, 0x01, 0x50, 0x46, 0x00, 0xF0, + 0xA8, 0xF8, 0xBA, 0xF8, + 0x42, 0x00, 0x20, 0xF0, 0x04, 0x01, 0xAA, 0xF8, 0x42, 0x10, 0x16, 0xE0, + 0x01, 0x98, 0x00, 0x7A, + 0x01, 0x28, 0x12, 0xD1, 0x01, 0x98, 0x80, 0x78, 0x78, 0xB1, 0x01, 0x99, + 0x01, 0x22, 0x50, 0x46, + 0x09, 0x1D, 0x00, 0xF0, 0x94, 0xF8, 0xBA, 0xF8, 0x42, 0x00, 0x20, 0xF0, + 0x04, 0x01, 0xAA, 0xF8, + 0x42, 0x10, 0xBA, 0xF8, 0x56, 0x10, 0xAA, 0xF8, 0x54, 0x10, 0x64, 0x1C, + 0x96, 0xF9, 0xF4, 0x03, + 0xA0, 0x42, 0xBF, 0xF4, 0xEB, 0xAE, 0x5D, 0x48, 0x00, 0x68, 0x90, 0xF8, + 0x00, 0x04, 0x80, 0x07, + 0x02, 0xD5, 0x28, 0x46, 0xFC, 0xF7, 0x6F, 0xFC, 0x59, 0x48, 0x15, 0xB1, + 0x80, 0xF8, 0x00, 0x90, + 0x01, 0xE0, 0x00, 0x21, 0x01, 0x70, 0x0A, 0x98, 0x0F, 0xB0, 0xBD, 0xE8, + 0xF0, 0x8F, 0x53, 0x49, + 0x0B, 0x68, 0x51, 0x49, 0x5A, 0x8E, 0x18, 0x39, 0x12, 0x1A, 0x08, 0x80, + 0x4A, 0x80, 0x93, 0xF8, + 0x0F, 0x34, 0x18, 0x44, 0x88, 0x80, 0xD0, 0x1A, 0xC8, 0x80, 0x70, 0x47, + 0x4B, 0x49, 0x0B, 0x68, + 0x49, 0x49, 0x5A, 0x8E, 0x18, 0x39, 0x12, 0x1A, 0x08, 0x81, 0x4A, 0x81, + 0x93, 0xF8, 0x12, 0x34, + 0x18, 0x44, 0x88, 0x81, 0xD0, 0x1A, 0xC8, 0x81, 0x70, 0x47, 0x10, 0xB5, + 0x43, 0x4C, 0x20, 0x68, + 0x90, 0xF8, 0x0E, 0x04, 0xFF, 0xF7, 0xDB, 0xFF, 0x20, 0x68, 0x90, 0xF8, + 0x0E, 0x04, 0xFF, 0xF7, + 0xE5, 0xFF, 0x22, 0x68, 0x3C, 0x49, 0x92, 0xF8, 0x10, 0x04, 0x18, 0x39, + 0x40, 0x43, 0x08, 0x61, + 0x92, 0xF8, 0x11, 0x04, 0x88, 0x82, 0x18, 0x22, 0x37, 0x48, 0x0B, 0xF0, + 0xB3, 0xF9, 0x38, 0x49, + 0x00, 0x20, 0x35, 0x4A, 0x08, 0x70, 0x37, 0x49, 0x18, 0x3A, 0x48, 0x60, + 0x10, 0x63, 0x50, 0x63, + 0x90, 0x63, 0x35, 0x4A, 0x10, 0x70, 0x08, 0x70, 0x10, 0xBD, 0xFE, 0xB5, + 0x00, 0x24, 0x06, 0x46, + 0x00, 0x94, 0x01, 0x94, 0x69, 0x46, 0x02, 0x94, 0xFF, 0xF7, 0x61, 0xFD, + 0x05, 0x46, 0x69, 0x46, + 0x30, 0x46, 0xFF, 0xF7, 0x66, 0xFE, 0x40, 0xEA, 0x05, 0x01, 0x2A, 0x48, + 0x01, 0x29, 0x01, 0xD0, + 0x41, 0x68, 0x05, 0xE0, 0x25, 0x49, 0x09, 0x68, 0x91, 0xF8, 0x0A, 0x14, + 0x49, 0x1F, 0x41, 0x60, + 0x00, 0x29, 0x04, 0xDD, 0x49, 0x1E, 0x41, 0x60, 0x21, 0x49, 0x09, 0x78, + 0x01, 0xB9, 0x44, 0x60, + 0x1D, 0x48, 0x9D, 0xE8, 0x0E, 0x00, 0x18, 0x30, 0x80, 0xE8, 0x0E, 0x00, + 0xFE, 0xBD, 0x02, 0x23, + 0x80, 0xF8, 0x3E, 0x31, 0x00, 0x23, 0x80, 0xF8, 0x42, 0x31, 0x01, 0x2A, + 0x05, 0xD0, 0x09, 0x68, + 0x01, 0x62, 0x01, 0x21, 0x80, 0xF8, 0x34, 0x11, 0x70, 0x47, 0x03, 0x22, + 0x0C, 0x30, 0x07, 0xF0, + 0x67, 0xBA, 0x10, 0xB5, 0x01, 0x24, 0x9C, 0x40, 0x91, 0x42, 0x03, 0xDA, + 0x01, 0x68, 0x21, 0x43, + 0x01, 0x60, 0x10, 0xBD, 0x41, 0x68, 0x21, 0x43, 0x41, 0x60, 0x10, 0xBD, + 0x70, 0xB5, 0x15, 0x46, + 0x0A, 0x46, 0x06, 0x46, 0x01, 0x46, 0x1C, 0x46, 0x10, 0x46, 0x07, 0xF0, + 0x74, 0xFA, 0xA8, 0x42, + 0x09, 0xDD, 0x00, 0x22, 0x31, 0x46, 0x20, 0x46, 0xFF, 0xF7, 0xD1, 0xFF, + 0x34, 0xF8, 0x42, 0x0F, + 0x20, 0xF0, 0x04, 0x00, 0x20, 0x80, 0x70, 0xBD, 0xA8, 0x2C, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xA4, 0x06, 0x10, 0x00, 0x14, 0x06, 0x10, 0x00, 0xA5, 0x06, 0x10, 0x00, + 0x10, 0xB5, 0x41, 0xF2, + 0xE4, 0x41, 0x82, 0x48, 0x0B, 0xF0, 0x92, 0xF9, 0x40, 0xF2, 0x3C, 0x41, + 0x80, 0x48, 0x0B, 0xF0, + 0x8D, 0xF9, 0x80, 0x48, 0xFF, 0x21, 0x80, 0xF8, 0xF4, 0x13, 0x00, 0xF0, + 0x95, 0xFC, 0xFF, 0xF7, + 0xE3, 0xFA, 0xFF, 0xF7, 0x5A, 0xFF, 0x00, 0xF0, 0xFB, 0xF8, 0xFD, 0xF7, + 0x6A, 0xFB, 0xFE, 0xF7, + 0x8C, 0xF8, 0xBD, 0xE8, 0x10, 0x40, 0xFE, 0xF7, 0x05, 0xBE, 0x70, 0xB5, + 0x76, 0x4D, 0x00, 0x24, + 0x72, 0x48, 0xAC, 0x71, 0x00, 0xF0, 0x86, 0xFC, 0x74, 0x4E, 0x30, 0x68, + 0x90, 0xF8, 0x40, 0x04, + 0xC1, 0x06, 0x04, 0xD5, 0xC0, 0x07, 0x02, 0xD0, 0x6C, 0x48, 0xFF, 0xF7, + 0xCF, 0xF9, 0x30, 0x68, + 0x90, 0xF8, 0x00, 0x04, 0xC0, 0x07, 0x05, 0xD0, 0x68, 0x48, 0xFF, 0xF7, + 0x5E, 0xFF, 0x67, 0x48, + 0x00, 0xF0, 0xD7, 0xF8, 0x65, 0x48, 0xFD, 0xF7, 0x4C, 0xFB, 0x64, 0x48, + 0xFE, 0xF7, 0x73, 0xF8, + 0x63, 0x48, 0x80, 0xF8, 0x38, 0x44, 0x63, 0x48, 0xB0, 0xF8, 0xF8, 0x03, + 0xA5, 0xF8, 0x1F, 0x00, + 0x70, 0xBD, 0x70, 0xB5, 0x5E, 0x4D, 0x60, 0x4E, 0x95, 0xF8, 0x38, 0x04, + 0x88, 0xB3, 0xB0, 0x71, + 0x29, 0x46, 0x5A, 0x48, 0x00, 0xF0, 0x88, 0xFC, 0x5C, 0x4C, 0x20, 0x68, + 0x90, 0xF8, 0x40, 0x04, + 0xC1, 0x06, 0x04, 0xD5, 0xC0, 0x07, 0x02, 0xD0, 0x54, 0x48, 0xFF, 0xF7, + 0x9F, 0xF9, 0x20, 0x68, + 0x90, 0xF8, 0x00, 0x04, 0xC0, 0x07, 0x02, 0xD0, 0x50, 0x48, 0xFF, 0xF7, + 0x2E, 0xFF, 0x20, 0x68, + 0x90, 0xF8, 0x80, 0x03, 0xC0, 0x07, 0x02, 0xD0, 0x4C, 0x48, 0xFF, 0xF7, + 0x27, 0xF9, 0x4B, 0x48, + 0x00, 0xF0, 0x9F, 0xF8, 0x49, 0x48, 0xFD, 0xF7, 0x14, 0xFB, 0x48, 0x48, + 0xFE, 0xF7, 0x3B, 0xF8, + 0x00, 0x20, 0x85, 0xF8, 0x38, 0x04, 0x47, 0x48, 0xB0, 0xF8, 0xF8, 0x03, + 0xA6, 0xF8, 0x1F, 0x00, + 0x70, 0xBD, 0xFF, 0xE7, 0xFF, 0xF7, 0x99, 0xFF, 0xF5, 0xE7, 0x10, 0xB5, + 0x40, 0x4C, 0x01, 0x46, + 0x94, 0xF8, 0x38, 0x04, 0x0F, 0x28, 0x0B, 0xD2, 0x00, 0xEB, 0xC0, 0x00, + 0x04, 0xEB, 0xC0, 0x00, + 0x48, 0x22, 0x0B, 0xF0, 0xA7, 0xF8, 0x94, 0xF8, 0x38, 0x04, 0x40, 0x1C, + 0x84, 0xF8, 0x38, 0x04, + 0x10, 0xBD, 0x10, 0xB5, 0x00, 0xF5, 0x80, 0x50, 0x00, 0x21, 0xD0, 0xF8, + 0xEC, 0x33, 0x01, 0x22, + 0x02, 0xFA, 0x01, 0xF4, 0x23, 0x42, 0x0B, 0xD1, 0x8A, 0x40, 0x13, 0x43, + 0xC0, 0xF8, 0xEC, 0x33, + 0x90, 0xF9, 0xF4, 0x23, 0x8A, 0x42, 0x01, 0xDA, 0x80, 0xF8, 0xF4, 0x13, + 0x48, 0xB2, 0x10, 0xBD, + 0x49, 0x1C, 0x0F, 0x29, 0xEC, 0xDB, 0x4F, 0xF0, 0xFF, 0x30, 0x10, 0xBD, + 0x10, 0xB5, 0x00, 0xF5, + 0x80, 0x50, 0x91, 0xF8, 0x4C, 0x41, 0x01, 0x23, 0xD0, 0xF8, 0xEC, 0x23, + 0xA3, 0x40, 0x9A, 0x43, + 0xC0, 0xF8, 0xEC, 0x23, 0x00, 0x22, 0x81, 0xF8, 0x3E, 0x21, 0x90, 0xF9, + 0xF4, 0x23, 0x91, 0xF9, + 0x4C, 0x11, 0x8A, 0x42, 0x07, 0xD1, 0xD0, 0xF8, 0xEC, 0x13, 0xB1, 0xFA, + 0x81, 0xF1, 0xC1, 0xF1, + 0x1F, 0x01, 0x80, 0xF8, 0xF4, 0x13, 0x10, 0xBD, 0x30, 0xB5, 0x00, 0xF5, + 0x80, 0x50, 0x00, 0x22, + 0xD0, 0xF8, 0xF0, 0x43, 0x01, 0x23, 0x00, 0xBF, 0x03, 0xFA, 0x02, 0xF5, + 0x2C, 0x42, 0x06, 0xD1, + 0x93, 0x40, 0x1C, 0x43, 0xC0, 0xF8, 0xF0, 0x43, 0x81, 0xF8, 0x4D, 0x21, + 0x30, 0xBD, 0x52, 0x1C, + 0x52, 0xB2, 0x0A, 0x2A, 0xF0, 0xDB, 0xFF, 0x20, 0x81, 0xF8, 0x4D, 0x01, + 0x30, 0xBD, 0x10, 0xB5, + 0x00, 0xF5, 0x80, 0x50, 0x91, 0xF8, 0x4D, 0x41, 0x01, 0x23, 0xD0, 0xF8, + 0xF0, 0x23, 0xA3, 0x40, + 0x9A, 0x43, 0xC0, 0xF8, 0xF0, 0x23, 0xFF, 0x20, 0x81, 0xF8, 0x4D, 0x01, + 0x10, 0xBD, 0x04, 0x48, + 0x70, 0x47, 0x03, 0x48, 0x90, 0xF8, 0x38, 0x04, 0x70, 0x47, 0x00, 0x00, + 0xCC, 0x2C, 0x10, 0x00, + 0xB0, 0x41, 0x10, 0x00, 0xCC, 0x3C, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, + 0x4C, 0x07, 0x10, 0x00, + 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x5F, 0x00, 0x24, 0x06, 0x46, 0x01, 0x27, + 0xDF, 0xF8, 0x0C, 0x81, + 0xDF, 0xF8, 0x0C, 0x91, 0xDF, 0xF8, 0x0C, 0xA1, 0x4F, 0xF0, 0x05, 0x0B, + 0x00, 0xF5, 0x80, 0x55, + 0x76, 0xE0, 0x00, 0xBF, 0xD5, 0xF8, 0xEC, 0x03, 0x07, 0xFA, 0x04, 0xF1, + 0x08, 0x42, 0x6D, 0xD0, + 0x04, 0xEB, 0x04, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x06, 0xEB, 0x80, 0x01, + 0x91, 0xF8, 0x3E, 0x01, + 0x01, 0x28, 0x04, 0xD0, 0x02, 0x28, 0x02, 0xD0, 0x04, 0x28, 0x3B, 0xD0, + 0x5E, 0xE0, 0x91, 0xF8, + 0x3F, 0x01, 0x03, 0x28, 0x06, 0xD0, 0x04, 0x28, 0x04, 0xD0, 0x02, 0x28, + 0x21, 0xD0, 0x01, 0x28, + 0x29, 0xD0, 0x53, 0xE0, 0x30, 0x48, 0xB1, 0xF8, 0x42, 0x20, 0xB0, 0xF9, + 0x00, 0x00, 0x53, 0x07, + 0x01, 0xD5, 0xB8, 0xF9, 0x00, 0x00, 0x13, 0x07, 0x02, 0xD5, 0x2C, 0x48, + 0xB0, 0xF9, 0x00, 0x00, + 0xB1, 0xF9, 0x54, 0x30, 0x83, 0x42, 0x41, 0xDA, 0xD0, 0x05, 0x06, 0xD5, + 0xB9, 0xF9, 0x00, 0x00, + 0x83, 0x42, 0x02, 0xDD, 0x81, 0xF8, 0x3F, 0x71, 0x38, 0xE0, 0x30, 0x46, + 0xFF, 0xF7, 0x56, 0xFF, + 0x34, 0xE0, 0x91, 0xF8, 0x42, 0x20, 0x00, 0x20, 0x52, 0x07, 0x01, 0xD5, + 0xB8, 0xF9, 0x00, 0x00, + 0xB1, 0xF9, 0x54, 0x20, 0x03, 0xE0, 0xB1, 0xF9, 0x54, 0x20, 0xB9, 0xF9, + 0x00, 0x00, 0x82, 0x42, + 0xEB, 0xDB, 0x23, 0xE0, 0x91, 0xF8, 0x40, 0x00, 0x10, 0xF0, 0x06, 0x0F, + 0x1E, 0xD0, 0x91, 0xF8, + 0x42, 0x00, 0x40, 0x07, 0x1A, 0xD4, 0x17, 0x4A, 0x15, 0x48, 0x12, 0x78, + 0xB0, 0xF9, 0x00, 0x00, + 0x01, 0x2A, 0x01, 0xD1, 0xBA, 0xF9, 0x00, 0x00, 0x91, 0xF8, 0x3F, 0x21, + 0x03, 0x2A, 0x02, 0xD0, + 0x02, 0x2A, 0x05, 0xD0, 0x0A, 0xE0, 0xB1, 0xF9, 0x54, 0x20, 0xBA, 0xF9, + 0x00, 0x00, 0x01, 0xE0, + 0xB1, 0xF9, 0x54, 0x20, 0x82, 0x42, 0x01, 0xDA, 0x81, 0xF8, 0x3E, 0xB1, + 0x64, 0x1C, 0x64, 0xB2, + 0x95, 0xF9, 0xF4, 0x03, 0xA0, 0x42, 0x85, 0xDA, 0xBD, 0xE8, 0xF0, 0x9F, + 0xA0, 0x06, 0x10, 0x00, + 0x90, 0x06, 0x10, 0x00, 0x92, 0x06, 0x10, 0x00, 0x8C, 0x06, 0x10, 0x00, + 0xAA, 0x06, 0x10, 0x00, + 0x94, 0x06, 0x10, 0x00, 0xA5, 0x06, 0x10, 0x00, 0x90, 0xF8, 0x40, 0x10, + 0x09, 0x06, 0x14, 0xD5, + 0xB0, 0xF8, 0x42, 0x10, 0x0A, 0x07, 0x0C, 0xD4, 0xFE, 0x4A, 0x12, 0x68, + 0x92, 0xF8, 0x40, 0x34, + 0x5B, 0x06, 0x06, 0xD5, 0x92, 0xF8, 0x80, 0x23, 0x52, 0x06, 0x02, 0xD4, + 0x01, 0x22, 0x80, 0xF8, + 0x70, 0x20, 0x41, 0xF0, 0x08, 0x01, 0xA0, 0xF8, 0x42, 0x10, 0x70, 0x47, + 0xB0, 0xF8, 0x40, 0x10, + 0xC9, 0x05, 0x14, 0xD5, 0xB0, 0xF8, 0x42, 0x10, 0x0A, 0x06, 0x0C, 0xD4, + 0xF1, 0x4A, 0x12, 0x68, + 0x92, 0xF8, 0x20, 0x34, 0x9B, 0x07, 0x06, 0xD5, 0x92, 0xF8, 0x80, 0x23, + 0x52, 0x06, 0x02, 0xD4, + 0x01, 0x22, 0x80, 0xF8, 0x70, 0x20, 0x41, 0xF0, 0x80, 0x01, 0xA0, 0xF8, + 0x42, 0x10, 0x70, 0x47, + 0x2D, 0xE9, 0xF0, 0x47, 0x82, 0x46, 0x92, 0xF8, 0x40, 0x00, 0x15, 0x46, + 0x0C, 0x46, 0x02, 0x28, + 0x01, 0xD1, 0x28, 0x69, 0xE8, 0x60, 0x04, 0xF1, 0x0C, 0x07, 0x4F, 0xF0, + 0x00, 0x08, 0x4F, 0xF0, + 0xFF, 0x39, 0x05, 0xF1, 0x0C, 0x06, 0x63, 0xB3, 0x01, 0x20, 0x84, 0xF8, + 0x3E, 0x01, 0x95, 0xF8, + 0x40, 0x00, 0x84, 0xF8, 0x3F, 0x01, 0x84, 0xF8, 0x4D, 0x91, 0x84, 0xF8, + 0x42, 0x81, 0x84, 0xF8, + 0x43, 0x81, 0xA4, 0xF8, 0x42, 0x80, 0xC4, 0xF8, 0x2C, 0x80, 0x84, 0xF8, + 0x41, 0x81, 0x84, 0xF8, + 0x44, 0x81, 0x95, 0xF8, 0x42, 0x00, 0x84, 0xF8, 0x47, 0x01, 0x68, 0x8E, + 0xA4, 0xF8, 0x56, 0x00, + 0x95, 0xF8, 0x41, 0x00, 0x84, 0xF8, 0x48, 0x01, 0xE8, 0x68, 0x20, 0x62, + 0x03, 0x22, 0x31, 0x46, + 0x20, 0x46, 0x07, 0xF0, 0x1D, 0xF8, 0x03, 0x22, 0x31, 0x46, 0x38, 0x46, + 0x07, 0xF0, 0x18, 0xF8, + 0x14, 0xE0, 0x11, 0x46, 0x20, 0x46, 0x00, 0xF0, 0x5F, 0xFB, 0xE0, 0x6A, + 0x03, 0x22, 0x40, 0x1C, + 0xE0, 0x62, 0x31, 0x46, 0x20, 0x46, 0x06, 0xF0, 0xFF, 0xFF, 0x03, 0x22, + 0x31, 0x46, 0x38, 0x46, + 0x06, 0xF0, 0xFA, 0xFF, 0x94, 0xF8, 0x46, 0x01, 0x84, 0xF8, 0x47, 0x01, + 0x95, 0xF8, 0x40, 0x00, + 0x84, 0xF8, 0x3F, 0x01, 0x95, 0xF8, 0x42, 0x00, 0x84, 0xF8, 0x46, 0x01, + 0xE8, 0x8C, 0xA4, 0xF8, + 0x44, 0x00, 0x28, 0x8D, 0xA4, 0xF8, 0x46, 0x00, 0x68, 0x8D, 0xA4, 0xF8, + 0x48, 0x00, 0xE8, 0x8D, + 0xA4, 0xF8, 0x4A, 0x00, 0x28, 0x8E, 0xA4, 0xF8, 0x4C, 0x00, 0x28, 0x8B, + 0xA4, 0xF8, 0x4E, 0x00, + 0xB5, 0xF9, 0x32, 0x00, 0xA4, 0xF8, 0x54, 0x00, 0xA9, 0x69, 0x61, 0x63, + 0xE9, 0x69, 0xA1, 0x63, + 0x29, 0x6A, 0xE1, 0x63, 0xA9, 0x8E, 0xA4, 0xF8, 0x58, 0x10, 0xA9, 0x8C, + 0xA4, 0xF8, 0x40, 0x10, + 0xD5, 0xF8, 0x36, 0x10, 0xC4, 0xF8, 0x5A, 0x10, 0x69, 0x69, 0xE1, 0x61, + 0x95, 0xF8, 0x43, 0x10, + 0x84, 0xF8, 0x49, 0x11, 0x95, 0xF8, 0x44, 0x10, 0x84, 0xF8, 0x4A, 0x11, + 0xB4, 0xF9, 0x56, 0x10, + 0x81, 0x42, 0x01, 0xDA, 0xA4, 0xF8, 0x56, 0x00, 0xC4, 0xF8, 0x50, 0x81, + 0x84, 0xF8, 0x4B, 0x91, + 0xA8, 0x8C, 0x80, 0x05, 0xB4, 0xF8, 0x42, 0x00, 0x02, 0xD5, 0x40, 0xF4, + 0x80, 0x70, 0x01, 0xE0, + 0x20, 0xF4, 0x80, 0x70, 0xA4, 0xF8, 0x42, 0x00, 0x21, 0x46, 0x50, 0x46, + 0x00, 0xF0, 0xD3, 0xFA, + 0x20, 0x46, 0xFF, 0xF7, 0x21, 0xFF, 0x20, 0x46, 0xBD, 0xE8, 0xF0, 0x47, + 0x36, 0xE7, 0xF0, 0xB5, + 0xB1, 0xF9, 0x02, 0x60, 0xB2, 0xF9, 0x02, 0x50, 0x78, 0x24, 0x06, 0xFB, + 0x05, 0xF7, 0x00, 0x2F, + 0x2A, 0xDD, 0xB1, 0xF9, 0x00, 0x70, 0xB2, 0xF9, 0x00, 0xC0, 0x07, 0xFB, + 0x0C, 0xF7, 0x00, 0x2F, + 0x22, 0xDD, 0x76, 0x43, 0x5D, 0x43, 0x96, 0xFB, 0xF5, 0xF5, 0x2D, 0xB2, + 0x45, 0x80, 0xB1, 0xF9, + 0x00, 0x10, 0xB2, 0xF9, 0x00, 0x20, 0x49, 0x43, 0x5A, 0x43, 0x91, 0xFB, + 0xF2, 0xF1, 0x0A, 0xB2, + 0x02, 0x80, 0x78, 0x2D, 0x00, 0xDD, 0x44, 0x80, 0xB0, 0xF9, 0x02, 0x30, + 0x6F, 0xF0, 0x77, 0x01, + 0x8B, 0x42, 0x00, 0xDA, 0x41, 0x80, 0x78, 0x2A, 0x00, 0xDD, 0x04, 0x80, + 0xB0, 0xF9, 0x00, 0x20, + 0x8A, 0x42, 0x00, 0xDA, 0x01, 0x80, 0xF0, 0xBD, 0x00, 0x21, 0x41, 0x80, + 0xFA, 0xE7, 0x2D, 0xE9, + 0xFF, 0x4F, 0xDF, 0xF8, 0xD4, 0x81, 0x0F, 0x46, 0x72, 0x4E, 0xD8, 0xF8, + 0x08, 0x10, 0x8F, 0xB0, + 0x00, 0x20, 0x08, 0x60, 0x30, 0x68, 0xB0, 0xF8, 0x82, 0x53, 0x0A, 0xF0, + 0x77, 0xFF, 0x01, 0x28, + 0x04, 0xD1, 0x30, 0x68, 0xB0, 0xF8, 0x84, 0x03, 0x00, 0xB1, 0x05, 0x46, + 0x0A, 0xF0, 0x64, 0xFF, + 0x80, 0xB1, 0x30, 0x68, 0x69, 0x49, 0xB0, 0xF8, 0x86, 0x53, 0xB0, 0xF8, + 0x8A, 0x03, 0x09, 0x68, + 0x88, 0x42, 0x07, 0xDA, 0x0A, 0xF0, 0x62, 0xFF, 0x01, 0x28, 0x03, 0xD1, + 0x30, 0x68, 0xB0, 0xF8, + 0x88, 0x03, 0x05, 0x44, 0xDF, 0xF8, 0x88, 0xB1, 0x62, 0x48, 0x63, 0x4B, + 0xBB, 0xF9, 0x00, 0x20, + 0x62, 0x49, 0xDF, 0xF8, 0x8C, 0xA1, 0x12, 0xB1, 0x01, 0x2A, 0x3E, 0xD0, + 0x7B, 0xE0, 0xB0, 0xF9, + 0x00, 0x00, 0xBA, 0xF9, 0x00, 0x20, 0xD1, 0x46, 0x42, 0x43, 0x03, 0xEB, + 0x42, 0x04, 0x42, 0x00, + 0x09, 0x68, 0x20, 0x46, 0x0A, 0xF0, 0xE9, 0xFD, 0xD8, 0xF8, 0x04, 0x20, + 0x05, 0x21, 0x92, 0xFB, + 0xF1, 0xF3, 0x01, 0xFB, 0x13, 0x22, 0x41, 0xF6, 0x5A, 0x61, 0x11, 0x44, + 0x21, 0x80, 0x55, 0x49, + 0x40, 0x46, 0x49, 0x79, 0x61, 0x80, 0x54, 0x49, 0x09, 0x88, 0xA1, 0x80, + 0x53, 0x49, 0x09, 0x88, + 0xE1, 0x80, 0x53, 0x49, 0x09, 0x88, 0x21, 0x81, 0x52, 0x49, 0x09, 0x88, + 0x61, 0x81, 0x52, 0x49, + 0x09, 0x88, 0xA1, 0x81, 0x51, 0x49, 0x09, 0x88, 0xE1, 0x81, 0xB9, 0xF8, + 0x00, 0x10, 0x49, 0x1C, + 0x09, 0xB2, 0xA9, 0xF8, 0x00, 0x10, 0x42, 0x68, 0x52, 0x1C, 0xC8, 0xF8, + 0x04, 0x20, 0x05, 0x29, + 0x41, 0xDB, 0x00, 0x21, 0xA9, 0xF8, 0x00, 0x10, 0x3D, 0xE0, 0xBA, 0xF9, + 0x00, 0x40, 0x0A, 0x2C, + 0x36, 0xDA, 0xB0, 0xF9, 0x00, 0x00, 0xD1, 0x46, 0x00, 0xFB, 0x04, 0xF2, + 0x03, 0xEB, 0x42, 0x04, + 0x42, 0x00, 0x09, 0x68, 0x20, 0x46, 0x0A, 0xF0, 0xA8, 0xFD, 0xD8, 0xF8, + 0x04, 0x20, 0x05, 0x21, + 0x92, 0xFB, 0xF1, 0xF3, 0x01, 0xFB, 0x13, 0x22, 0x41, 0xF6, 0x5A, 0x61, + 0x11, 0x44, 0x21, 0x80, + 0x34, 0x49, 0x40, 0x46, 0x49, 0x79, 0x61, 0x80, 0x33, 0x49, 0x09, 0x88, + 0xA1, 0x80, 0x33, 0x49, + 0x09, 0x88, 0xE1, 0x80, 0x32, 0x49, 0x09, 0x88, 0x21, 0x81, 0x32, 0x49, + 0x09, 0x88, 0x61, 0x81, + 0x31, 0x49, 0x09, 0x88, 0xA1, 0x81, 0x31, 0x49, 0x09, 0x88, 0xE1, 0x81, + 0xB9, 0xF8, 0x00, 0x10, + 0x49, 0x1C, 0xA9, 0xF8, 0x00, 0x10, 0x41, 0x68, 0x49, 0x1C, 0xC8, 0xF8, + 0x04, 0x10, 0x02, 0xE0, + 0x02, 0x20, 0xAB, 0xF8, 0x00, 0x00, 0x6D, 0x43, 0x02, 0x95, 0x30, 0x68, + 0x0F, 0x9E, 0x00, 0x25, + 0x90, 0xF8, 0x8C, 0x03, 0x04, 0x90, 0x06, 0xF5, 0x80, 0x56, 0x96, 0xE0, + 0x4F, 0xF0, 0x01, 0x09, + 0xD6, 0xF8, 0xEC, 0x03, 0x09, 0xFA, 0x05, 0xF1, 0x08, 0x42, 0x7D, 0xD0, + 0x05, 0xEB, 0x05, 0x10, + 0x00, 0xEB, 0x80, 0x01, 0x0F, 0x98, 0x00, 0xEB, 0x81, 0x04, 0x94, 0xF8, + 0x3E, 0x01, 0x07, 0x28, + 0x72, 0xD0, 0x21, 0x46, 0x20, 0x1D, 0x06, 0xF0, 0xBE, 0xFE, 0x00, 0x90, + 0xB0, 0xF5, 0x80, 0x5F, + 0x08, 0xDD, 0x01, 0x46, 0xAD, 0x20, 0x06, 0xF0, 0x69, 0xF9, 0xAB, 0xF8, + 0x00, 0x90, 0x05, 0x20, + 0xAA, 0xF8, 0x00, 0x00, 0x04, 0x99, 0x00, 0x98, 0x48, 0x43, 0x00, 0xFB, + 0x01, 0xF9, 0x02, 0x99, + 0x89, 0x45, 0x1D, 0xE0, 0x4C, 0x07, 0x10, 0x00, 0x1C, 0x06, 0x10, 0x00, + 0x24, 0x07, 0x10, 0x00, + 0x84, 0x07, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, 0x20, 0x4D, 0x01, 0x20, + 0x10, 0x07, 0x10, 0x00, + 0x82, 0x07, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0x86, 0x07, 0x10, 0x00, + 0x88, 0x07, 0x10, 0x00, + 0x8A, 0x07, 0x10, 0x00, 0x8C, 0x07, 0x10, 0x00, 0x8E, 0x07, 0x10, 0x00, + 0x90, 0x07, 0x10, 0x00, + 0x00, 0xDA, 0x89, 0x46, 0x22, 0x46, 0x21, 0x1D, 0x08, 0xA8, 0x06, 0xF0, + 0x7A, 0xFE, 0x22, 0x1D, + 0x11, 0x1D, 0x0A, 0xA8, 0x06, 0xF0, 0x75, 0xFE, 0xBD, 0xF9, 0x20, 0x00, + 0x64, 0x30, 0xC8, 0x28, + 0x04, 0xD8, 0xBD, 0xF9, 0x22, 0x00, 0x64, 0x30, 0xC8, 0x28, 0x01, 0xD9, + 0x01, 0x23, 0x00, 0xE0, + 0x03, 0x23, 0x0A, 0xAA, 0x08, 0xA9, 0x09, 0xA8, 0xFF, 0xF7, 0xA1, 0xFE, + 0x60, 0x88, 0xBD, 0xF8, + 0x26, 0x10, 0x08, 0x44, 0xAD, 0xF8, 0x2E, 0x00, 0x20, 0x88, 0xBD, 0xF8, + 0x24, 0x10, 0x00, 0x24, + 0x08, 0x44, 0xAD, 0xF8, 0x2C, 0x00, 0x1A, 0xE0, 0x04, 0xEB, 0xC4, 0x00, + 0x07, 0xEB, 0xC0, 0x01, + 0x0B, 0xA8, 0x0C, 0x31, 0x06, 0xF0, 0x57, 0xFE, 0x48, 0x45, 0x0E, 0xDA, + 0xD8, 0xF8, 0x08, 0x10, + 0x0A, 0x68, 0x02, 0xEB, 0x42, 0x02, 0x00, 0xE0, 0x0D, 0xE0, 0x01, 0xEB, + 0x42, 0x02, 0x50, 0x60, + 0x54, 0x72, 0x15, 0x72, 0x08, 0x68, 0x40, 0x1C, 0x08, 0x60, 0x64, 0x1C, + 0xE4, 0xB2, 0x97, 0xF8, + 0x38, 0x04, 0xA0, 0x42, 0xE0, 0xD8, 0x6D, 0x1C, 0x6D, 0xB2, 0x96, 0xF9, + 0xF4, 0x03, 0xA8, 0x42, + 0xBF, 0xF6, 0x64, 0xAF, 0xD8, 0xF8, 0x08, 0x00, 0x45, 0x46, 0x01, 0x68, + 0x00, 0x29, 0x78, 0xD0, + 0x00, 0xF0, 0xC2, 0xF9, 0x00, 0x26, 0x4F, 0xF0, 0x04, 0x09, 0xDF, 0xF8, + 0xC4, 0xA3, 0x4F, 0xF0, + 0x06, 0x0B, 0x6A, 0xE0, 0x06, 0xEB, 0x46, 0x01, 0x00, 0xEB, 0x41, 0x00, + 0x90, 0xF9, 0x08, 0x40, + 0x90, 0xF9, 0x09, 0x30, 0x11, 0x98, 0x02, 0x68, 0x01, 0x20, 0x00, 0xFA, + 0x04, 0xF1, 0x0A, 0x42, + 0x5A, 0xD1, 0xDD, 0xF8, 0x48, 0xC0, 0x00, 0xFA, 0x03, 0xF8, 0xDC, 0xF8, + 0x00, 0xC0, 0x1C, 0xEA, + 0x08, 0x0F, 0x51, 0xD1, 0x11, 0x98, 0x0A, 0x43, 0x02, 0x60, 0x12, 0x98, + 0x12, 0x99, 0x00, 0x68, + 0x40, 0xEA, 0x08, 0x00, 0x08, 0x60, 0x04, 0xEB, 0x04, 0x10, 0x00, 0xEB, + 0x80, 0x01, 0x0F, 0x98, + 0x00, 0xEB, 0x81, 0x04, 0x03, 0xEB, 0xC3, 0x00, 0x07, 0xEB, 0xC0, 0x02, + 0x00, 0x23, 0x21, 0x46, + 0x0F, 0x98, 0xFF, 0xF7, 0x7D, 0xFD, 0x94, 0xF8, 0x3E, 0x01, 0x03, 0x28, + 0x04, 0xD0, 0x04, 0x28, + 0x04, 0xD0, 0x06, 0x28, 0x08, 0xD0, 0x2F, 0xE0, 0x01, 0x20, 0x00, 0xE0, + 0x00, 0x20, 0x84, 0xF8, + 0x41, 0x01, 0x84, 0xF8, 0x3E, 0x91, 0x27, 0xE0, 0x84, 0xF8, 0x3E, 0x91, + 0x94, 0xF8, 0x40, 0x00, + 0x10, 0xF0, 0x06, 0x0F, 0x20, 0xD0, 0x94, 0xF8, 0x42, 0x00, 0x40, 0x07, + 0x1C, 0xD4, 0xCA, 0x49, + 0xC8, 0x48, 0x09, 0x78, 0xB0, 0xF9, 0x00, 0x00, 0x01, 0x29, 0x01, 0xD1, + 0xBA, 0xF9, 0x00, 0x00, + 0x94, 0xF8, 0x3F, 0x11, 0x03, 0x29, 0x02, 0xD0, 0x02, 0x29, 0x09, 0xD0, + 0x0C, 0xE0, 0xB4, 0xF9, + 0x54, 0x10, 0xBA, 0xF9, 0x00, 0x00, 0x05, 0xE0, 0x84, 0xF8, 0x3E, 0xB1, + 0x04, 0xE0, 0x08, 0xE0, + 0xB4, 0xF9, 0x54, 0x10, 0x81, 0x42, 0xF7, 0xDB, 0x76, 0x1C, 0xA8, 0x68, + 0x01, 0x68, 0xB1, 0x42, + 0x90, 0xDC, 0x13, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0xB8, 0x48, 0x00, 0x21, + 0x01, 0x70, 0x81, 0x60, + 0xC1, 0x60, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x41, 0x05, 0x46, 0x41, 0xF2, + 0x38, 0x40, 0x2E, 0x21, + 0x28, 0x44, 0x0A, 0xF0, 0xE3, 0xFC, 0x00, 0x24, 0x05, 0xF5, 0x80, 0x56, + 0x01, 0x27, 0x4F, 0xF0, + 0x05, 0x08, 0x1B, 0xE0, 0xD6, 0xF8, 0xEC, 0x03, 0x07, 0xFA, 0x04, 0xF1, + 0x08, 0x42, 0x14, 0xD0, + 0x04, 0xEB, 0x04, 0x10, 0x00, 0xEB, 0x80, 0x00, 0x05, 0xEB, 0x80, 0x01, + 0x91, 0xF8, 0x3E, 0x01, + 0x03, 0x28, 0x04, 0xD0, 0x04, 0x28, 0x02, 0xD0, 0x02, 0x28, 0x03, 0xD0, + 0x05, 0xE0, 0x81, 0xF8, + 0x3E, 0x81, 0x02, 0xE0, 0x28, 0x46, 0xFF, 0xF7, 0xE1, 0xFB, 0x64, 0x1C, + 0x96, 0xF9, 0xF4, 0x03, + 0xA0, 0x42, 0xDF, 0xDA, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xFC, 0x47, + 0x04, 0x46, 0x00, 0x25, + 0x9A, 0x48, 0x0E, 0x46, 0x00, 0x95, 0x01, 0x21, 0x08, 0x30, 0x01, 0x95, + 0x04, 0xF0, 0x87, 0xF8, + 0x96, 0x48, 0x05, 0x21, 0x0C, 0x30, 0x04, 0xF0, 0x82, 0xF8, 0x41, 0xF2, + 0x38, 0x40, 0x2E, 0x21, + 0x20, 0x44, 0x0A, 0xF0, 0xA3, 0xFC, 0x91, 0x4F, 0xFF, 0x22, 0x2D, 0x21, + 0xF8, 0x68, 0x0A, 0xF0, + 0x73, 0xFC, 0x3D, 0x70, 0x04, 0xF5, 0x80, 0x57, 0x4F, 0xF0, 0x01, 0x08, + 0xD7, 0xF8, 0xEC, 0x03, + 0x58, 0xB3, 0x6B, 0x46, 0x01, 0xAA, 0x31, 0x46, 0x20, 0x46, 0xFF, 0xF7, + 0xC0, 0xFD, 0x4F, 0xF0, + 0x05, 0x09, 0x1E, 0xE0, 0xD7, 0xF8, 0xEC, 0x13, 0x08, 0xFA, 0x05, 0xF0, + 0x01, 0x42, 0x17, 0xD0, + 0x01, 0x99, 0x08, 0x42, 0x14, 0xD1, 0x05, 0xEB, 0x05, 0x10, 0x00, 0xEB, + 0x80, 0x00, 0x04, 0xEB, + 0x80, 0x01, 0x91, 0xF8, 0x3E, 0x01, 0x03, 0x28, 0x04, 0xD0, 0x04, 0x28, + 0x02, 0xD0, 0x02, 0x28, + 0x03, 0xD0, 0x05, 0xE0, 0x81, 0xF8, 0x3E, 0x91, 0x02, 0xE0, 0x20, 0x46, + 0xFF, 0xF7, 0x8E, 0xFB, + 0x6D, 0x1C, 0x97, 0xF9, 0xF4, 0x03, 0xA8, 0x42, 0xDC, 0xDA, 0x00, 0x25, + 0x47, 0x46, 0x1A, 0xE0, + 0x00, 0x99, 0x07, 0xFA, 0x05, 0xF0, 0x08, 0x42, 0x14, 0xD1, 0x20, 0x46, + 0xFF, 0xF7, 0x61, 0xFB, + 0x00, 0x28, 0x0F, 0xDB, 0x00, 0xEB, 0x00, 0x11, 0x01, 0xEB, 0x81, 0x01, + 0x04, 0xEB, 0x81, 0x01, + 0x05, 0xEB, 0xC5, 0x02, 0x81, 0xF8, 0x4C, 0x01, 0x06, 0xEB, 0xC2, 0x02, + 0x01, 0x23, 0x20, 0x46, + 0xFF, 0xF7, 0x96, 0xFC, 0x6D, 0x1C, 0x96, 0xF8, 0x38, 0x04, 0xA8, 0x42, + 0xE0, 0xD8, 0x63, 0x48, + 0x01, 0x21, 0x08, 0x30, 0x04, 0xF0, 0x38, 0xF8, 0x60, 0x48, 0x05, 0x21, + 0x0C, 0x30, 0x04, 0xF0, + 0x33, 0xF8, 0xBD, 0xE8, 0xFC, 0x87, 0x30, 0xB5, 0x5C, 0x4A, 0x91, 0xF8, + 0x46, 0x51, 0xD4, 0x68, + 0x63, 0x5D, 0xFF, 0x2B, 0x05, 0xD1, 0x13, 0x78, 0x63, 0x55, 0x0F, 0x2B, + 0x01, 0xD2, 0x5B, 0x1C, + 0x13, 0x70, 0x91, 0xF8, 0x46, 0x21, 0xA2, 0x5C, 0x81, 0xF8, 0x46, 0x21, + 0x00, 0xEB, 0x42, 0x02, + 0x02, 0xF5, 0x80, 0x52, 0x91, 0xF8, 0x4C, 0x51, 0xB2, 0xF8, 0x38, 0x34, + 0x01, 0x24, 0xAC, 0x40, + 0x23, 0x43, 0xA2, 0xF8, 0x38, 0x34, 0x91, 0xF8, 0x46, 0x11, 0x41, 0xF2, + 0x56, 0x42, 0x10, 0x44, + 0x0A, 0x5C, 0x52, 0x1C, 0x0A, 0x54, 0x30, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, + 0x04, 0x46, 0x91, 0xF8, + 0x40, 0x00, 0x00, 0x26, 0x0D, 0x46, 0x01, 0x28, 0x01, 0xD1, 0x84, 0xF8, + 0x44, 0x61, 0x94, 0xF8, + 0x3F, 0x01, 0x43, 0x4F, 0xDF, 0xF8, 0x0C, 0x81, 0x01, 0x28, 0x1F, 0xD1, + 0x95, 0xF8, 0x40, 0x00, + 0x03, 0x28, 0x4D, 0xD1, 0x94, 0xF8, 0x3E, 0x01, 0x02, 0x28, 0x04, 0xD0, + 0x03, 0x28, 0x06, 0xD0, + 0x04, 0x28, 0x04, 0xD0, 0x1E, 0xE0, 0x20, 0x46, 0xFC, 0xF7, 0xC0, 0xFD, + 0x0E, 0xE0, 0xD8, 0xF8, + 0x00, 0x10, 0x94, 0xF8, 0x44, 0x01, 0x91, 0xF8, 0x4B, 0x13, 0x01, 0xF0, + 0x0F, 0x01, 0x88, 0x42, + 0x02, 0xD8, 0x39, 0x78, 0x01, 0x29, 0x06, 0xD0, 0x84, 0xF8, 0x44, 0x61, + 0x95, 0xF8, 0x40, 0x00, + 0x03, 0x28, 0x07, 0xD0, 0x08, 0xE0, 0x40, 0x1C, 0x84, 0xF8, 0x44, 0x01, + 0x01, 0x20, 0x85, 0xF8, + 0x40, 0x00, 0x01, 0xE0, 0x84, 0xF8, 0x45, 0x61, 0x94, 0xF8, 0x3F, 0x01, + 0x03, 0x28, 0x1F, 0xD1, + 0x95, 0xF8, 0x40, 0x00, 0x01, 0x28, 0x1B, 0xD1, 0x94, 0xF8, 0x3E, 0x01, + 0x04, 0x28, 0x17, 0xD1, + 0x38, 0x78, 0xB0, 0xB9, 0xD8, 0xF8, 0x00, 0x00, 0xB4, 0xF9, 0x56, 0x10, + 0xB0, 0xF8, 0x52, 0x23, + 0x91, 0x42, 0x0E, 0xDA, 0x94, 0xF8, 0x45, 0x11, 0x90, 0xF8, 0x54, 0x03, + 0x81, 0x42, 0x07, 0xD2, + 0x03, 0x20, 0x85, 0xF8, 0x40, 0x00, 0x94, 0xF8, 0x45, 0x01, 0x40, 0x1C, + 0x84, 0xF8, 0x45, 0x01, + 0xF0, 0xE6, 0x84, 0xF8, 0x45, 0x61, 0xED, 0xE6, 0x7C, 0xB5, 0x00, 0x21, + 0x1C, 0xE0, 0x01, 0xEB, + 0x41, 0x03, 0x4A, 0x1C, 0x00, 0xEB, 0x43, 0x03, 0x12, 0xE0, 0x02, 0xEB, + 0x42, 0x04, 0x00, 0xEB, + 0x44, 0x04, 0x5E, 0x68, 0x65, 0x68, 0xAE, 0x42, 0x09, 0xDD, 0x00, 0x96, + 0x1E, 0x89, 0xAD, 0xF8, + 0x04, 0x60, 0x5D, 0x60, 0x25, 0x89, 0x1D, 0x81, 0x00, 0x9D, 0x65, 0x60, + 0x26, 0x81, 0x52, 0x1C, + 0x04, 0x68, 0x94, 0x42, 0xE9, 0xDC, 0x49, 0x1C, 0x02, 0x68, 0x8A, 0x42, + 0xDF, 0xDC, 0x7C, 0xBD, + 0x92, 0x06, 0x10, 0x00, 0x94, 0x06, 0x10, 0x00, 0xA5, 0x06, 0x10, 0x00, + 0x1C, 0x06, 0x10, 0x00, + 0xF9, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x2D, 0xE9, 0xF8, 0x4F, + 0x00, 0x22, 0x91, 0x46, + 0x15, 0x46, 0x14, 0x46, 0x00, 0x92, 0xFE, 0x4A, 0xFE, 0x4B, 0x12, 0x68, + 0xB3, 0xF9, 0x00, 0xC0, + 0xFD, 0x4B, 0x17, 0x8E, 0x1E, 0x68, 0x67, 0x45, 0x60, 0xD1, 0x86, 0x46, + 0xFB, 0x48, 0x02, 0xF1, + 0x32, 0x0A, 0x8B, 0x46, 0x90, 0xF8, 0x00, 0xC0, 0xF9, 0x48, 0x07, 0x78, + 0x4D, 0xE0, 0x3A, 0x46, + 0x43, 0xE0, 0x00, 0xBF, 0x3A, 0xF8, 0x12, 0x10, 0x3E, 0xF8, 0x12, 0x00, + 0x3B, 0xF8, 0x12, 0x30, + 0x08, 0x1A, 0xC9, 0x1A, 0x00, 0xB2, 0x0B, 0xB2, 0x00, 0x28, 0x01, 0xDB, + 0x01, 0x46, 0x00, 0xE0, + 0x41, 0x42, 0x49, 0x45, 0x06, 0xDD, 0x00, 0x28, 0x01, 0xDB, 0x01, 0x46, + 0x00, 0xE0, 0x41, 0x42, + 0x0F, 0xFA, 0x81, 0xF9, 0x19, 0x1A, 0x01, 0xD4, 0x88, 0x46, 0x01, 0xE0, + 0xC1, 0xF1, 0x00, 0x08, + 0xA8, 0x45, 0x05, 0xDD, 0x00, 0x29, 0x01, 0xDB, 0x0D, 0x46, 0x00, 0xE0, + 0x4D, 0x42, 0x2D, 0xB2, + 0x00, 0x29, 0x00, 0xDA, 0x49, 0x42, 0xB6, 0xF8, 0xE2, 0x83, 0x41, 0x45, + 0x15, 0xDD, 0x00, 0x2B, + 0x00, 0xDA, 0x5B, 0x42, 0x01, 0x1E, 0x00, 0xDA, 0x41, 0x42, 0x8B, 0x42, + 0x02, 0xDD, 0x64, 0x1C, + 0xA4, 0xB2, 0x0A, 0xE0, 0x00, 0x28, 0x00, 0xDA, 0x40, 0x42, 0xB6, 0xF8, + 0xE4, 0x13, 0x88, 0x42, + 0x03, 0xDD, 0x4F, 0xF0, 0x00, 0x0C, 0x64, 0x46, 0x01, 0xE0, 0x52, 0x1E, + 0xBA, 0xD1, 0x0A, 0xEB, + 0x47, 0x0A, 0x0E, 0xEB, 0x47, 0x0E, 0x0B, 0xEB, 0x47, 0x0B, 0xBC, 0xF1, + 0x01, 0x0C, 0xAE, 0xD2, + 0x96, 0xF8, 0xE6, 0x03, 0xA0, 0x42, 0x01, 0xD2, 0x01, 0x20, 0x00, 0x90, + 0x96, 0xF8, 0xE7, 0x13, + 0xCC, 0x48, 0x00, 0x9A, 0x06, 0xF0, 0x71, 0xFB, 0xCB, 0x49, 0x21, 0xF8, + 0x25, 0x5F, 0x21, 0xF8, + 0x02, 0x9C, 0x8C, 0x70, 0xBD, 0xE8, 0xF8, 0x8F, 0x10, 0xB5, 0x0C, 0x46, + 0xC3, 0x49, 0x09, 0x78, + 0x4A, 0x00, 0x01, 0x46, 0xC5, 0x48, 0x0A, 0xF0, 0x50, 0xFA, 0xC1, 0x48, + 0x21, 0x46, 0x00, 0x78, + 0x42, 0x00, 0xC3, 0x48, 0x0A, 0xF0, 0x49, 0xFA, 0xC2, 0x49, 0x01, 0x20, + 0x08, 0x70, 0x10, 0xBD, + 0xB8, 0x49, 0x10, 0xB5, 0xB1, 0xF9, 0x00, 0x10, 0x4A, 0x00, 0x01, 0x46, + 0xBE, 0x48, 0x00, 0x68, + 0x0A, 0xF0, 0x3B, 0xFA, 0xBD, 0x49, 0x01, 0x20, 0x08, 0x70, 0x10, 0xBD, + 0x10, 0xB5, 0x01, 0x23, + 0x0A, 0xE0, 0x00, 0xBF, 0x30, 0xF9, 0x13, 0x40, 0x00, 0x2C, 0x00, 0xDA, + 0x64, 0x42, 0x8C, 0x42, + 0x01, 0xDD, 0x01, 0x20, 0x10, 0xBD, 0x5B, 0x1C, 0x93, 0x42, 0xF3, 0xDB, + 0x00, 0x20, 0x10, 0xBD, + 0x2D, 0xE9, 0xFF, 0x5F, 0xDF, 0xF8, 0xAC, 0xB2, 0x00, 0x24, 0xAB, 0xF1, + 0x01, 0x0B, 0xDF, 0xF8, + 0x98, 0x92, 0xCB, 0xF8, 0x04, 0x40, 0x8B, 0xF8, 0x00, 0x40, 0xD9, 0xF8, + 0x00, 0x00, 0x1F, 0x46, + 0x26, 0x46, 0x90, 0xF8, 0xE0, 0x03, 0x25, 0x46, 0xA0, 0x46, 0xC0, 0x07, + 0x0E, 0xD0, 0x03, 0x20, + 0xF3, 0xF7, 0xF7, 0xFC, 0xA4, 0x48, 0x01, 0x68, 0x00, 0x98, 0xFF, 0xF7, + 0x2D, 0xFF, 0x04, 0x46, + 0x11, 0x25, 0x03, 0x20, 0xF3, 0xF7, 0x08, 0xFD, 0x00, 0x2C, 0x63, 0xD1, + 0xA0, 0x48, 0x00, 0x78, + 0x10, 0xF0, 0x30, 0x0F, 0x5E, 0xD0, 0xFA, 0xF7, 0x21, 0xFD, 0xD9, 0xF8, + 0x00, 0x00, 0xDF, 0xF8, + 0x74, 0xA2, 0x90, 0xF8, 0xE0, 0x03, 0x80, 0x07, 0x0B, 0xD5, 0x9B, 0x4A, + 0x9B, 0x49, 0xDA, 0xF8, + 0x00, 0x00, 0x00, 0xF0, 0xFB, 0xF8, 0x04, 0x00, 0x4F, 0xF0, 0x30, 0x05, + 0x4F, 0xF0, 0x01, 0x06, + 0x48, 0xD1, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0xE1, 0x03, 0xC0, 0x07, + 0x0B, 0xD0, 0x94, 0x4A, + 0x94, 0x49, 0xDA, 0xF8, 0x00, 0x00, 0x00, 0xF0, 0x7B, 0xF8, 0x04, 0x00, + 0x4F, 0xF0, 0x30, 0x05, + 0x4F, 0xF0, 0x01, 0x06, 0x36, 0xD1, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0xE1, 0x03, 0x80, 0x07, + 0x0B, 0xD5, 0x8B, 0x4A, 0x8B, 0x49, 0xDA, 0xF8, 0x00, 0x00, 0x00, 0xF0, + 0xA4, 0xF8, 0x04, 0x00, + 0x4F, 0xF0, 0x31, 0x05, 0x4F, 0xF0, 0x01, 0x06, 0x24, 0xD1, 0x87, 0x48, + 0x00, 0x78, 0x01, 0x28, + 0x20, 0xD1, 0x86, 0x48, 0x01, 0x7E, 0x86, 0x48, 0x00, 0x7E, 0x01, 0xFB, + 0x00, 0xF2, 0x19, 0x2A, + 0x03, 0xD2, 0x05, 0x29, 0x01, 0xD8, 0x05, 0x28, 0x02, 0xD9, 0x32, 0x25, + 0x01, 0x26, 0x11, 0xE0, + 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0xE1, 0x03, 0x40, 0x07, 0x0B, 0xD5, + 0x03, 0x20, 0xF3, 0xF7, + 0x90, 0xFC, 0x71, 0x48, 0x7B, 0x4A, 0x00, 0x99, 0x00, 0x68, 0xFA, 0xF7, + 0x7E, 0xFE, 0x03, 0x20, + 0xF3, 0xF7, 0xA2, 0xFC, 0x0A, 0xF0, 0x00, 0xFB, 0x01, 0x46, 0x77, 0x48, + 0x01, 0x70, 0x54, 0xB3, + 0x6E, 0xB1, 0x87, 0xF8, 0x00, 0x80, 0x29, 0x46, 0x05, 0x20, 0x05, 0xF0, + 0x9C, 0xFD, 0x00, 0x98, + 0xFF, 0xF7, 0x46, 0xFF, 0xDD, 0xE9, 0x01, 0x01, 0xFF, 0xF7, 0x2E, 0xFF, + 0x17, 0xE0, 0x01, 0x20, + 0x38, 0x70, 0x8B, 0xF8, 0x00, 0x50, 0xDB, 0xF8, 0x04, 0x10, 0x41, 0xF0, + 0x02, 0x01, 0xCB, 0xF8, + 0x04, 0x10, 0xD9, 0xF8, 0x00, 0x20, 0x92, 0xF8, 0x50, 0x32, 0xDB, 0x07, + 0x03, 0xD1, 0x92, 0xF8, + 0x80, 0x22, 0xD2, 0x07, 0x03, 0xD0, 0x41, 0xF0, 0x08, 0x01, 0xCB, 0xF8, + 0x04, 0x10, 0x01, 0x20, + 0x04, 0xB0, 0xBD, 0xE8, 0xF0, 0x9F, 0x87, 0xF8, 0x00, 0x80, 0x00, 0x78, + 0xF8, 0xE7, 0x4D, 0x48, + 0x00, 0x21, 0x40, 0x1E, 0x41, 0x60, 0x01, 0x70, 0xA0, 0xF8, 0x01, 0x10, + 0xC1, 0x70, 0x70, 0x47, + 0x2D, 0xE9, 0xF7, 0x4F, 0xDF, 0xF8, 0x10, 0x81, 0x93, 0x46, 0x0B, 0x46, + 0xD8, 0xF8, 0x00, 0x00, + 0x00, 0x25, 0x2C, 0x46, 0x90, 0xF8, 0xEC, 0x73, 0xB0, 0xF9, 0xE8, 0x63, + 0xB0, 0xF9, 0xEA, 0xA3, + 0x3E, 0x48, 0x31, 0x46, 0x02, 0x78, 0x18, 0x46, 0xFB, 0xF7, 0x21, 0xFF, + 0x81, 0x46, 0x3C, 0x48, + 0x31, 0x46, 0x02, 0x78, 0x58, 0x46, 0xFB, 0xF7, 0x1A, 0xFF, 0x01, 0x46, + 0xB9, 0xF1, 0x00, 0x0F, + 0x00, 0xD0, 0x51, 0xB9, 0x33, 0x48, 0x51, 0x46, 0xB0, 0xF9, 0x00, 0x20, + 0x00, 0x98, 0x00, 0xF0, + 0xBE, 0xF8, 0x04, 0x46, 0xB8, 0x42, 0x00, 0xD9, 0x01, 0x25, 0xD8, 0xF8, + 0x00, 0x00, 0x2A, 0x46, + 0x90, 0xF8, 0xED, 0x13, 0x2F, 0x48, 0x40, 0x1C, 0x06, 0xF0, 0x37, 0xFA, + 0x2E, 0x49, 0x81, 0xF8, + 0x31, 0x40, 0xBD, 0xE8, 0xFE, 0x8F, 0x2D, 0xE9, 0xF0, 0x47, 0x27, 0x4E, + 0x89, 0x46, 0x92, 0x46, + 0x31, 0x68, 0x24, 0x4A, 0x00, 0x25, 0x91, 0xF8, 0xF2, 0x73, 0xB1, 0xF9, + 0xF0, 0x83, 0x2C, 0x46, + 0xB1, 0xF9, 0xEE, 0x13, 0xB2, 0xF9, 0x00, 0x20, 0xFB, 0xF7, 0xF7, 0xFE, + 0x88, 0xB9, 0x1F, 0x48, + 0x41, 0x46, 0x02, 0x78, 0x48, 0x46, 0x00, 0xF0, 0x92, 0xF8, 0x04, 0x46, + 0x1C, 0x48, 0x41, 0x46, + 0x02, 0x78, 0x50, 0x46, 0x00, 0xF0, 0x8B, 0xF8, 0x20, 0x44, 0xC4, 0xB2, + 0xBC, 0x42, 0x00, 0xD9, + 0x01, 0x25, 0x30, 0x68, 0x2A, 0x46, 0x90, 0xF8, 0xF3, 0x13, 0x16, 0x48, + 0x80, 0x1C, 0x06, 0xF0, + 0x04, 0xFA, 0x15, 0x49, 0x81, 0xF8, 0x32, 0x40, 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xF0, 0x5F, + 0x0D, 0x4E, 0x83, 0x46, 0x0B, 0x46, 0x30, 0x68, 0x20, 0x49, 0x00, 0x25, + 0x90, 0xF8, 0xF5, 0x73, + 0xB0, 0xF9, 0xF6, 0xC3, 0xB0, 0xF9, 0xFA, 0x93, 0x09, 0x78, 0x92, 0x46, + 0x2C, 0x46, 0x09, 0xB1, + 0xB0, 0xF9, 0xF8, 0xC3, 0x1A, 0x48, 0x00, 0x78, 0xB0, 0xB3, 0x1A, 0x48, + 0x00, 0x78, 0x34, 0xE0, + 0x50, 0x07, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, 0x2D, 0x06, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, + 0x7E, 0x4A, 0x01, 0x20, + 0xA8, 0x4A, 0x01, 0x20, 0x7A, 0x07, 0x10, 0x00, 0x1C, 0x07, 0x10, 0x00, + 0x79, 0x07, 0x10, 0x00, + 0x04, 0x07, 0x10, 0x00, 0x10, 0x07, 0x10, 0x00, 0xF2, 0x2A, 0x10, 0x00, + 0xC8, 0x2A, 0x10, 0x00, + 0xBE, 0x0B, 0x01, 0x20, 0x94, 0x0B, 0x01, 0x20, 0x66, 0x05, 0x10, 0x00, + 0x18, 0x2A, 0x10, 0x00, + 0x58, 0x2A, 0x10, 0x00, 0x60, 0x2B, 0x10, 0x00, 0x76, 0x06, 0x10, 0x00, + 0xF9, 0x06, 0x10, 0x00, + 0x74, 0x05, 0x10, 0x00, 0x64, 0x05, 0x10, 0x00, 0x01, 0xE0, 0x90, 0xB1, + 0x1C, 0xE0, 0x1C, 0x48, + 0x61, 0x46, 0x02, 0x78, 0x18, 0x46, 0xFF, 0xF7, 0x61, 0xFE, 0x80, 0x46, + 0x19, 0x48, 0x61, 0x46, + 0x02, 0x78, 0x50, 0x46, 0xFF, 0xF7, 0x5A, 0xFE, 0x01, 0x46, 0xB8, 0xF1, + 0x00, 0x0F, 0x00, 0xD0, + 0x51, 0xB9, 0x15, 0x48, 0x49, 0x46, 0xB0, 0xF9, 0x00, 0x20, 0x58, 0x46, + 0x00, 0xF0, 0x0F, 0xF8, + 0x04, 0x46, 0xB8, 0x42, 0x00, 0xD9, 0x01, 0x25, 0x30, 0x68, 0x2A, 0x46, + 0x90, 0xF8, 0xFC, 0x13, + 0x0E, 0x48, 0x06, 0xF0, 0x8A, 0xF9, 0x0E, 0x49, 0x81, 0xF8, 0x31, 0x40, + 0x09, 0xE7, 0x10, 0xB5, + 0x04, 0x46, 0x00, 0x20, 0x09, 0xE0, 0x00, 0xBF, 0x34, 0xF9, 0x12, 0x30, + 0x00, 0x2B, 0x00, 0xDA, + 0x5B, 0x42, 0x8B, 0x42, 0x01, 0xDD, 0x40, 0x1C, 0xC0, 0xB2, 0x52, 0x1E, + 0xF4, 0xD2, 0x10, 0xBD, + 0xED, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, + 0x2E, 0x06, 0x10, 0x00, + 0x0A, 0x44, 0x01, 0x20, 0x2D, 0xE9, 0xFF, 0x4F, 0x87, 0xB0, 0x00, 0x20, + 0x81, 0x46, 0x03, 0x90, + 0x02, 0x90, 0x01, 0x90, 0xFF, 0x48, 0x88, 0x46, 0x93, 0x46, 0x00, 0x68, + 0xB0, 0xF8, 0xB0, 0x02, + 0x06, 0x90, 0x89, 0x78, 0x50, 0x68, 0x0A, 0xF0, 0xD1, 0xF9, 0x00, 0x90, + 0x98, 0xF8, 0x02, 0x50, + 0x98, 0xF8, 0x03, 0x00, 0x05, 0x90, 0x32, 0xE0, 0x07, 0x98, 0x98, 0xF8, + 0x00, 0x40, 0x00, 0xEB, + 0xC5, 0x00, 0x04, 0x90, 0x98, 0xF8, 0x01, 0xA0, 0x1F, 0xE0, 0x04, 0x98, + 0x22, 0x46, 0x00, 0x21, + 0xD0, 0xE9, 0x00, 0x67, 0x01, 0x20, 0x09, 0xF0, 0xF9, 0xFF, 0x06, 0x40, + 0x0F, 0x40, 0x3E, 0x43, + 0x12, 0xD0, 0x00, 0x98, 0x06, 0x99, 0x30, 0xF9, 0x14, 0x00, 0x88, 0x42, + 0x0C, 0xDD, 0x02, 0x99, + 0x81, 0x44, 0x04, 0xFB, 0x00, 0x11, 0x02, 0x91, 0x01, 0x99, 0x05, 0xFB, + 0x00, 0x10, 0x01, 0x90, + 0x03, 0x98, 0x40, 0x1C, 0x80, 0xB2, 0x03, 0x90, 0x64, 0x1C, 0xA2, 0x45, + 0xDD, 0xDA, 0xE2, 0x49, + 0x00, 0x98, 0x6D, 0x1C, 0x09, 0x78, 0x00, 0xEB, 0x41, 0x00, 0x00, 0x90, + 0x05, 0x98, 0xA8, 0x42, + 0xCA, 0xDA, 0xDC, 0x48, 0x00, 0x25, 0x04, 0x68, 0x01, 0x98, 0xA1, 0x8E, + 0xC2, 0x17, 0xA1, 0xFB, + 0x00, 0x36, 0x05, 0xFB, 0x00, 0x60, 0x01, 0xFB, 0x02, 0x02, 0x4F, 0xF6, + 0xFF, 0x76, 0xA3, 0xFB, + 0x06, 0x07, 0x02, 0xFB, 0x06, 0x72, 0x03, 0xFB, 0x05, 0x21, 0x94, 0xF8, + 0x31, 0x30, 0x30, 0x34, + 0x5B, 0x1E, 0x89, 0xFB, 0x03, 0x23, 0x09, 0xF0, 0xCC, 0xFF, 0x72, 0x10, + 0x80, 0x18, 0xB0, 0x46, + 0x41, 0xF1, 0x00, 0x01, 0x42, 0x46, 0x00, 0x23, 0x09, 0xF0, 0xC3, 0xFF, + 0x07, 0x46, 0x02, 0x98, + 0x61, 0x88, 0xC2, 0x17, 0xA1, 0xFB, 0x00, 0x36, 0x05, 0xFB, 0x00, 0x60, + 0x01, 0xFB, 0x02, 0x01, + 0x42, 0x46, 0xA3, 0xFB, 0x02, 0x06, 0x01, 0xFB, 0x02, 0x61, 0x03, 0xFB, + 0x05, 0x11, 0x23, 0x78, + 0x5B, 0x1E, 0x89, 0xFB, 0x03, 0x23, 0x09, 0xF0, 0xAC, 0xFF, 0x47, 0xF6, + 0xFF, 0x72, 0x80, 0x18, + 0x41, 0xF1, 0x00, 0x01, 0x42, 0x46, 0x00, 0x23, 0x09, 0xF0, 0xA3, 0xFF, + 0xCB, 0xF8, 0x1C, 0x90, + 0x03, 0x99, 0xAB, 0xF8, 0x28, 0x10, 0x0A, 0x99, 0x48, 0x60, 0x0A, 0x99, + 0x0F, 0x60, 0x0B, 0xB0, + 0xBD, 0xE8, 0xF0, 0x8F, 0x2D, 0xE9, 0xFF, 0x4F, 0x81, 0x46, 0xB2, 0x48, + 0x00, 0x26, 0x8A, 0x46, + 0x00, 0x68, 0x14, 0x46, 0x95, 0xB0, 0x90, 0xF8, 0x21, 0x03, 0x4F, 0xF6, + 0xFF, 0x75, 0x32, 0x46, + 0x31, 0x46, 0x43, 0x07, 0xAA, 0xF1, 0x01, 0x07, 0x4C, 0xD5, 0x00, 0x07, + 0x02, 0xD5, 0x8C, 0xB3, + 0xBC, 0x42, 0x48, 0xDA, 0x68, 0x46, 0xD4, 0x46, 0xA3, 0x46, 0x00, 0x23, + 0x08, 0xE0, 0x00, 0xBF, + 0x39, 0xF8, 0x13, 0x40, 0x00, 0xEB, 0x43, 0x08, 0x5B, 0x1C, 0xA8, 0xF8, + 0x02, 0x40, 0xDB, 0xB2, + 0x63, 0x45, 0xF5, 0xD3, 0x43, 0x88, 0x03, 0x80, 0x00, 0xEB, 0x4C, 0x04, + 0x30, 0xF8, 0x1C, 0x30, + 0x63, 0x80, 0x01, 0x23, 0x10, 0xE0, 0x00, 0xBF, 0x00, 0xEB, 0x43, 0x04, + 0x34, 0xF8, 0x02, 0x8C, + 0x64, 0x88, 0x44, 0x44, 0x30, 0xF8, 0x13, 0x80, 0x04, 0xEB, 0x48, 0x04, + 0x09, 0xEB, 0x43, 0x08, + 0x5B, 0x1C, 0x28, 0xF8, 0x02, 0x4C, 0xDB, 0xB2, 0x63, 0x45, 0xED, 0xD9, + 0x93, 0x4B, 0xD8, 0x46, + 0x00, 0x20, 0x09, 0xE0, 0x1B, 0xE0, 0x00, 0xBF, 0x39, 0xF9, 0x10, 0x40, + 0x9C, 0x42, 0x01, 0xDD, + 0x23, 0x46, 0x80, 0x46, 0x40, 0x1C, 0xC0, 0xB2, 0x60, 0x45, 0xF5, 0xD3, + 0x5F, 0xEA, 0x08, 0x04, + 0x01, 0xD1, 0xBD, 0xF9, 0x00, 0x20, 0xBC, 0x42, 0x04, 0xDB, 0x69, 0x46, + 0x01, 0xEB, 0x4A, 0x00, + 0x30, 0xF9, 0x02, 0x1C, 0x1C, 0xB1, 0x09, 0xEB, 0x44, 0x00, 0x30, 0xF9, + 0x02, 0x2C, 0x39, 0xF9, + 0x14, 0xA0, 0xBC, 0x42, 0x03, 0xDA, 0x09, 0xEB, 0x44, 0x00, 0xB0, 0xF9, + 0x02, 0x10, 0x10, 0x46, + 0x88, 0x46, 0x8A, 0x42, 0x01, 0xDD, 0x80, 0x46, 0x08, 0x46, 0x8A, 0x1A, + 0xA2, 0xFB, 0x05, 0x1C, + 0xD3, 0x17, 0x03, 0xFB, 0x05, 0xC3, 0x02, 0xFB, 0x06, 0x3C, 0x0A, 0xEB, + 0x08, 0x02, 0x40, 0x42, + 0x02, 0xEB, 0x40, 0x02, 0x08, 0x46, 0xD3, 0x17, 0x61, 0x46, 0x09, 0xF0, + 0x12, 0xFF, 0xA4, 0xFB, + 0x05, 0x3C, 0x00, 0x22, 0x02, 0xFB, 0x05, 0xC2, 0x04, 0xFB, 0x06, 0x22, + 0x1B, 0x18, 0x4A, 0x41, + 0x18, 0x99, 0xA3, 0xFB, 0x01, 0x0C, 0xCC, 0x17, 0x02, 0xFB, 0x01, 0xC1, + 0x03, 0xFB, 0x04, 0x11, + 0xFB, 0x17, 0x3A, 0x46, 0x09, 0xF0, 0xFD, 0xFE, 0x04, 0x46, 0x0F, 0x46, + 0x02, 0x22, 0x00, 0x23, + 0x28, 0x46, 0x31, 0x46, 0x09, 0xF0, 0xF5, 0xFE, 0x00, 0x19, 0x79, 0x41, + 0x2A, 0x46, 0x33, 0x46, + 0x09, 0xF0, 0xEF, 0xFE, 0x19, 0xB0, 0x53, 0xE7, 0x2D, 0xE9, 0xFF, 0x4F, + 0x9F, 0xB0, 0x00, 0x20, + 0x1B, 0x90, 0x16, 0x90, 0x1C, 0x90, 0x0C, 0x46, 0x90, 0x46, 0x89, 0x78, + 0x50, 0x68, 0x0A, 0xF0, + 0x8D, 0xF8, 0x13, 0x90, 0x94, 0xF8, 0x02, 0x90, 0x94, 0xF8, 0x03, 0xB0, + 0x2E, 0xE0, 0x1F, 0x98, + 0x25, 0x78, 0x00, 0xEB, 0xC9, 0x00, 0x1D, 0x90, 0x94, 0xF8, 0x01, 0xA0, + 0x1A, 0xE0, 0x1D, 0x98, + 0x2A, 0x46, 0x00, 0x21, 0xD0, 0xE9, 0x00, 0x67, 0x01, 0x20, 0x09, 0xF0, + 0xB7, 0xFE, 0x06, 0x40, + 0x0F, 0x40, 0x3E, 0x43, 0x0C, 0xD0, 0x13, 0x98, 0x1C, 0x99, 0x30, 0xF9, + 0x15, 0x00, 0x88, 0x42, + 0x06, 0xDD, 0x16, 0x99, 0x08, 0x44, 0x16, 0x90, 0x1B, 0x98, 0x40, 0x1C, + 0x80, 0xB2, 0x1B, 0x90, + 0x6D, 0x1C, 0xED, 0xB2, 0xAA, 0x45, 0xE2, 0xD2, 0x43, 0x49, 0x13, 0x98, + 0x09, 0x78, 0x00, 0xEB, + 0x41, 0x00, 0x13, 0x90, 0x09, 0xF1, 0x01, 0x00, 0x00, 0xF0, 0xFF, 0x09, + 0xCB, 0x45, 0xCE, 0xD2, + 0x16, 0x98, 0xC8, 0xF8, 0x1C, 0x00, 0x1B, 0x98, 0xA8, 0xF8, 0x28, 0x00, + 0x98, 0xF8, 0x3E, 0x70, + 0x98, 0xF8, 0x3F, 0x90, 0x4C, 0x21, 0x68, 0x46, 0x09, 0xF0, 0x60, 0xFF, + 0xA1, 0x78, 0xD8, 0xF8, + 0x04, 0x00, 0x0A, 0xF0, 0x43, 0xF8, 0x34, 0x4A, 0xA1, 0x78, 0x6D, 0x46, + 0x12, 0x78, 0x07, 0xE0, + 0x30, 0xF8, 0x17, 0x30, 0x25, 0xF8, 0x11, 0x30, 0x49, 0x1C, 0x00, 0xEB, + 0x42, 0x00, 0xC9, 0xB2, + 0xE3, 0x78, 0x8B, 0x42, 0xF4, 0xD2, 0x2B, 0x4E, 0x4A, 0x46, 0x30, 0x68, + 0xB0, 0xF9, 0x34, 0x30, + 0x90, 0xF8, 0x31, 0x10, 0x28, 0x46, 0xFF, 0xF7, 0xE5, 0xFE, 0x22, 0x99, + 0x08, 0x60, 0x4C, 0x21, + 0x68, 0x46, 0x09, 0xF0, 0x3B, 0xFF, 0x49, 0x46, 0xD8, 0xF8, 0x04, 0x00, + 0x0A, 0xF0, 0x1E, 0xF8, + 0x21, 0x78, 0x05, 0xE0, 0x30, 0xF8, 0x11, 0x20, 0x25, 0xF8, 0x11, 0x20, + 0x49, 0x1C, 0xC9, 0xB2, + 0x62, 0x78, 0x8A, 0x42, 0xF6, 0xD2, 0x30, 0x68, 0x3A, 0x46, 0xB0, 0xF9, + 0x32, 0x30, 0x90, 0xF8, + 0x30, 0x10, 0x68, 0x46, 0xFF, 0xF7, 0xC6, 0xFE, 0x22, 0x99, 0x48, 0x60, + 0x23, 0xB0, 0xBF, 0xE6, + 0x10, 0xB5, 0x14, 0x49, 0x43, 0x68, 0x00, 0x22, 0x09, 0x68, 0x00, 0x2B, + 0x01, 0xDA, 0x42, 0x60, + 0x03, 0xE0, 0x4C, 0x8E, 0xA3, 0x42, 0x00, 0xDD, 0x44, 0x60, 0x03, 0x68, + 0x00, 0x2B, 0x01, 0xDA, + 0x02, 0x60, 0x10, 0xBD, 0x89, 0x8E, 0x8B, 0x42, 0xFB, 0xDD, 0x01, 0x60, + 0x10, 0xBD, 0x2D, 0xE9, + 0xFF, 0x47, 0x14, 0x46, 0x88, 0x46, 0x81, 0x46, 0x00, 0x27, 0x01, 0x26, + 0x6B, 0x46, 0xFF, 0xF7, + 0x01, 0xFE, 0x07, 0x48, 0x03, 0x4D, 0x00, 0x78, 0x78, 0xB1, 0x28, 0x68, + 0x90, 0xF8, 0x07, 0x05, + 0x00, 0x07, 0x07, 0xE0, 0x4C, 0x07, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, + 0x00, 0x80, 0xFF, 0xFF, + 0xA4, 0x06, 0x10, 0x00, 0x01, 0xD5, 0x04, 0x27, 0x3E, 0x46, 0x94, 0xF8, + 0x40, 0x00, 0x03, 0x28, + 0x04, 0xD0, 0x02, 0x28, 0x06, 0xD0, 0x01, 0x28, 0x14, 0xD0, 0x1C, 0xE0, + 0x28, 0x68, 0x06, 0xE0, + 0x39, 0x46, 0x15, 0xE0, 0x28, 0x68, 0x90, 0xF8, 0x21, 0x13, 0x89, 0x07, + 0x04, 0xD5, 0x90, 0xF8, + 0x07, 0x05, 0xC0, 0x07, 0xF4, 0xD1, 0x0E, 0xE0, 0x90, 0xF8, 0x07, 0x05, + 0x80, 0x07, 0x0A, 0xD5, + 0x31, 0x46, 0x05, 0xE0, 0x28, 0x68, 0x90, 0xF8, 0x07, 0x05, 0x40, 0x07, + 0x03, 0xD5, 0x02, 0x21, + 0x68, 0x46, 0x01, 0xF0, 0xC1, 0xFD, 0x68, 0x46, 0xFF, 0xF7, 0xA2, 0xFF, + 0xDD, 0xE9, 0x00, 0x01, + 0xCD, 0xE9, 0x02, 0x01, 0x94, 0xF8, 0x40, 0x00, 0x02, 0x28, 0x41, 0xD1, + 0x28, 0x68, 0x90, 0xF8, + 0x21, 0x03, 0x80, 0x07, 0x3C, 0xD5, 0x02, 0xAB, 0x22, 0x46, 0x41, 0x46, + 0x48, 0x46, 0xFF, 0xF7, + 0xFB, 0xFE, 0x28, 0x68, 0x90, 0xF8, 0x07, 0x05, 0x80, 0x07, 0x03, 0xD5, + 0x31, 0x46, 0x02, 0xA8, + 0x01, 0xF0, 0xA2, 0xFD, 0x02, 0xA8, 0xFF, 0xF7, 0x83, 0xFF, 0x29, 0x68, + 0xE3, 0x69, 0x91, 0xF8, + 0x2D, 0x23, 0x02, 0xF0, 0x0F, 0x00, 0x15, 0x09, 0xB1, 0xF8, 0x2E, 0x23, + 0xB1, 0xF8, 0x30, 0x13, + 0x93, 0x42, 0x0D, 0xDD, 0x8B, 0x42, 0x01, 0xDB, 0x28, 0x46, 0x09, 0xE0, + 0x91, 0x42, 0x00, 0xD1, + 0x49, 0x1C, 0x9B, 0x1A, 0x2D, 0x1A, 0x6B, 0x43, 0x89, 0x1A, 0x93, 0xFB, + 0xF1, 0xF1, 0x08, 0x44, + 0x01, 0x9A, 0x03, 0x9B, 0xC0, 0xF1, 0x10, 0x01, 0x42, 0x43, 0x03, 0xFB, + 0x01, 0x22, 0x12, 0x11, + 0x03, 0x92, 0x00, 0x9A, 0x42, 0x43, 0x02, 0x98, 0x00, 0xFB, 0x01, 0x20, + 0x00, 0x11, 0x02, 0x90, + 0x01, 0x98, 0xE0, 0x81, 0x00, 0x98, 0xA0, 0x81, 0x03, 0x98, 0x60, 0x82, + 0x02, 0x98, 0x20, 0x82, + 0x94, 0xF8, 0x24, 0x00, 0xC0, 0x06, 0x01, 0xD4, 0xE0, 0x68, 0x60, 0x61, + 0xBD, 0xE8, 0xFF, 0x87, + 0x2D, 0xE9, 0xF0, 0x47, 0x05, 0x46, 0x90, 0xF8, 0x02, 0x80, 0x0F, 0x46, + 0x88, 0x68, 0x14, 0x46, + 0x01, 0x26, 0x41, 0x46, 0x09, 0xF0, 0x42, 0xFF, 0x81, 0x46, 0xA8, 0xF1, + 0x01, 0x00, 0xC1, 0xB2, + 0xB8, 0x68, 0x09, 0xF0, 0x3B, 0xFF, 0x29, 0x78, 0x09, 0xEB, 0x41, 0x02, + 0x32, 0xF9, 0x02, 0x2C, + 0xA2, 0x42, 0x03, 0xDB, 0x30, 0xF9, 0x11, 0x10, 0xA1, 0x42, 0x00, 0xDA, + 0x00, 0x26, 0x69, 0x78, + 0x09, 0xEB, 0x41, 0x02, 0xB2, 0xF9, 0x02, 0x20, 0xA2, 0x42, 0x03, 0xDB, + 0x30, 0xF9, 0x11, 0x00, + 0xA0, 0x42, 0x00, 0xDA, 0x00, 0x26, 0x95, 0xF8, 0x03, 0x80, 0xB8, 0x68, + 0x41, 0x46, 0x09, 0xF0, + 0x1D, 0xFF, 0x81, 0x46, 0x08, 0xF1, 0x01, 0x00, 0xC1, 0xB2, 0xB8, 0x68, + 0x09, 0xF0, 0x16, 0xFF, + 0x29, 0x78, 0x09, 0xEB, 0x41, 0x02, 0x32, 0xF9, 0x02, 0x2C, 0xA2, 0x42, + 0x03, 0xDB, 0x30, 0xF9, + 0x11, 0x10, 0xA1, 0x42, 0x00, 0xDA, 0x00, 0x26, 0x69, 0x78, 0x09, 0xEB, + 0x41, 0x02, 0xB2, 0xF9, + 0x02, 0x20, 0xA2, 0x42, 0x03, 0xDB, 0x30, 0xF9, 0x11, 0x00, 0xA0, 0x42, + 0x00, 0xDA, 0x00, 0x26, + 0x30, 0x46, 0xBD, 0xE8, 0xF0, 0x87, 0x2D, 0xE9, 0xFF, 0x4F, 0x97, 0xB0, + 0x99, 0x46, 0x92, 0x46, + 0xFE, 0x48, 0xDF, 0xF8, 0xFC, 0x83, 0x01, 0x22, 0x04, 0x68, 0x51, 0x46, + 0xD8, 0xF8, 0x00, 0x00, + 0x01, 0xF0, 0x6E, 0xFA, 0xFB, 0x48, 0x00, 0x68, 0xB0, 0xF9, 0x4B, 0x14, + 0x11, 0x91, 0x90, 0xF8, + 0x4A, 0x04, 0x0A, 0x90, 0xF8, 0x48, 0x9A, 0xF8, 0x02, 0x70, 0x9A, 0xF8, + 0x03, 0x60, 0x00, 0x78, + 0x9A, 0xF8, 0x00, 0xB0, 0x9A, 0xF8, 0x01, 0x50, 0x40, 0x1E, 0x87, 0x42, + 0x01, 0xDA, 0x7F, 0x1C, + 0xFF, 0xB2, 0x0E, 0xB1, 0x76, 0x1E, 0xF6, 0xB2, 0xF0, 0x49, 0x09, 0x78, + 0x49, 0x1E, 0x8B, 0x45, + 0x03, 0xDA, 0x0B, 0xF1, 0x01, 0x00, 0x00, 0xF0, 0xFF, 0x0B, 0x0D, 0xB1, + 0x6D, 0x1E, 0xED, 0xB2, + 0xB8, 0x1E, 0xC1, 0xB2, 0xD9, 0xF8, 0x08, 0x00, 0x09, 0xF0, 0xC0, 0xFE, + 0x0B, 0x90, 0x78, 0x1E, + 0xC1, 0xB2, 0xD9, 0xF8, 0x08, 0x00, 0x09, 0xF0, 0xB9, 0xFE, 0x04, 0x90, + 0x39, 0x46, 0xD9, 0xF8, + 0x08, 0x00, 0x09, 0xF0, 0xB3, 0xFE, 0x01, 0x90, 0x78, 0x1C, 0xC1, 0xB2, + 0xD9, 0xF8, 0x08, 0x00, + 0x09, 0xF0, 0xAC, 0xFE, 0x02, 0x90, 0xB8, 0x1C, 0xC1, 0xB2, 0xD9, 0xF8, + 0x08, 0x00, 0x09, 0xF0, + 0xA5, 0xFE, 0x03, 0x90, 0x39, 0x46, 0x17, 0x98, 0x09, 0xF0, 0x9A, 0xFE, + 0x08, 0x90, 0xD4, 0x48, + 0x39, 0x46, 0x00, 0x68, 0x09, 0xF0, 0xA2, 0xFE, 0x86, 0x46, 0x00, 0x20, + 0x7A, 0xB2, 0xD4, 0x4F, + 0x0C, 0x90, 0xB7, 0xE0, 0x4F, 0xFA, 0x8B, 0xF0, 0x94, 0xE0, 0x00, 0x21, + 0x0E, 0xF8, 0x00, 0x10, + 0x08, 0x99, 0x18, 0x9B, 0x09, 0x5C, 0x99, 0x42, 0x75, 0xD1, 0xDF, 0xF8, + 0x28, 0xC3, 0x01, 0x9B, + 0xDC, 0xF8, 0x00, 0xC0, 0x33, 0xF9, 0x10, 0x30, 0xBC, 0xF8, 0x4D, 0xC4, + 0x63, 0x45, 0x6A, 0xDA, + 0x00, 0x21, 0x14, 0x91, 0x13, 0x91, 0x11, 0x99, 0x19, 0x44, 0x04, 0x9B, + 0x09, 0xB2, 0x33, 0xF9, + 0x10, 0x30, 0x10, 0x93, 0x8B, 0x42, 0x06, 0xDD, 0x02, 0x9B, 0x33, 0xF9, + 0x10, 0x30, 0x8B, 0x42, + 0x01, 0xDD, 0x01, 0x23, 0x13, 0x93, 0x01, 0x9B, 0x03, 0xEB, 0x40, 0x03, + 0x33, 0xF9, 0x02, 0x8C, + 0x88, 0x45, 0x07, 0xDD, 0xB3, 0xF9, 0x02, 0xC0, 0x8C, 0x45, 0x03, 0xDD, + 0x4F, 0xF0, 0x01, 0x0C, + 0xCD, 0xF8, 0x50, 0xC0, 0x01, 0x2A, 0x0F, 0xDD, 0xDD, 0xF8, 0x2C, 0xC0, + 0x3C, 0xF9, 0x10, 0xC0, + 0x8C, 0x45, 0x09, 0xDD, 0xDD, 0xF8, 0x08, 0xC0, 0x3C, 0xF9, 0x10, 0xC0, + 0x8C, 0x45, 0x03, 0xDD, + 0x4F, 0xF0, 0x01, 0x0C, 0xCD, 0xF8, 0x4C, 0xC0, 0xDF, 0xF8, 0xAC, 0xC2, + 0x9C, 0xF8, 0x00, 0xC0, + 0xAC, 0xF1, 0x02, 0x0C, 0x62, 0x45, 0x0D, 0xDA, 0xDD, 0xF8, 0x40, 0xC0, + 0x8C, 0x45, 0x09, 0xDD, + 0xDD, 0xF8, 0x0C, 0xC0, 0x3C, 0xF9, 0x10, 0xC0, 0x8C, 0x45, 0x03, 0xDD, + 0x4F, 0xF0, 0x01, 0x0C, + 0xCD, 0xF8, 0x4C, 0xC0, 0x01, 0x28, 0x0B, 0xDD, 0x33, 0xF9, 0x04, 0xCC, + 0x8C, 0x45, 0x07, 0xDD, + 0xB3, 0xF9, 0x02, 0xC0, 0x8C, 0x45, 0x03, 0xDD, 0x4F, 0xF0, 0x01, 0x0C, + 0xCD, 0xF8, 0x50, 0xC0, + 0xDF, 0xF8, 0x68, 0xC2, 0x9C, 0xF8, 0x00, 0xC0, 0xAC, 0xF1, 0x02, 0x0C, + 0x60, 0x45, 0x05, 0xDA, + 0x88, 0x45, 0x03, 0xDD, 0xB3, 0xF9, 0x04, 0x30, 0x8B, 0x42, 0x12, 0xDC, + 0x14, 0x99, 0x81, 0xB9, + 0x13, 0x99, 0x0D, 0xE0, 0xFF, 0xE7, 0x99, 0xB9, 0x01, 0x99, 0xB7, 0xF9, + 0x00, 0x30, 0x31, 0xF9, + 0x10, 0x10, 0x99, 0x42, 0x0C, 0xDA, 0x8B, 0x49, 0x09, 0x68, 0x91, 0xF8, + 0x41, 0x14, 0xC9, 0x07, + 0x31, 0xB1, 0x01, 0x21, 0x0E, 0xF8, 0x00, 0x10, 0x0C, 0x99, 0x49, 0x1C, + 0x89, 0xB2, 0x0C, 0x91, + 0x40, 0x1C, 0x40, 0xB2, 0xA8, 0x42, 0x7F, 0xF7, 0x68, 0xAF, 0x84, 0x48, + 0x0B, 0x99, 0x0E, 0xF1, + 0x28, 0x0E, 0x00, 0x78, 0x01, 0xEB, 0x40, 0x01, 0x0B, 0x91, 0x04, 0x99, + 0x01, 0xEB, 0x40, 0x01, + 0x04, 0x91, 0x01, 0x99, 0x01, 0xEB, 0x40, 0x01, 0x01, 0x91, 0x02, 0x99, + 0x01, 0xEB, 0x40, 0x01, + 0x02, 0x91, 0x03, 0x99, 0x01, 0xEB, 0x40, 0x00, 0x03, 0x90, 0x08, 0x98, + 0x28, 0x30, 0x52, 0x1C, + 0x52, 0xB2, 0x08, 0x90, 0xB2, 0x42, 0x7F, 0xF7, 0x45, 0xAF, 0x0A, 0x99, + 0x0C, 0x98, 0x88, 0x42, + 0x2A, 0xD9, 0x00, 0x20, 0x84, 0xF8, 0x0E, 0x01, 0xDA, 0xF8, 0x00, 0x00, + 0x20, 0x60, 0x6C, 0x48, + 0x00, 0x23, 0x1A, 0x46, 0x21, 0x46, 0x00, 0x68, 0x01, 0xF0, 0x22, 0xFA, + 0x01, 0x25, 0x17, 0xE0, + 0x04, 0xEB, 0x85, 0x00, 0x06, 0x46, 0x51, 0x46, 0x00, 0xF0, 0x53, 0xF9, + 0x70, 0xB1, 0x04, 0xEB, + 0x45, 0x00, 0xB0, 0xF8, 0xB4, 0x10, 0x0A, 0x98, 0x81, 0x42, 0x07, 0xD9, + 0x30, 0x46, 0xB7, 0xF9, + 0x00, 0x20, 0x49, 0x46, 0xFF, 0xF7, 0x64, 0xFE, 0x01, 0x28, 0x06, 0xD0, + 0x6D, 0x1C, 0xED, 0xB2, + 0x94, 0xF8, 0x0E, 0x01, 0xA8, 0x42, 0xE3, 0xD2, 0x00, 0x20, 0x1B, 0xB0, + 0xBD, 0xE8, 0xF0, 0x8F, + 0x2D, 0xE9, 0xF8, 0x4F, 0x04, 0x46, 0x55, 0x48, 0xDF, 0xF8, 0x54, 0x81, + 0x91, 0x46, 0x8B, 0x46, + 0x05, 0x68, 0x01, 0x22, 0x21, 0x46, 0xD8, 0xF8, 0x00, 0x00, 0x01, 0xF0, + 0x19, 0xF9, 0x00, 0x27, + 0xA6, 0x78, 0x4F, 0xF0, 0x01, 0x0A, 0x1D, 0xE0, 0x31, 0x46, 0xD8, 0xF8, + 0x00, 0x00, 0x09, 0xF0, + 0x95, 0xFD, 0x00, 0x90, 0x31, 0x46, 0xDB, 0xF8, 0x08, 0x00, 0x09, 0xF0, + 0x87, 0xFD, 0x01, 0x46, + 0x20, 0x78, 0x52, 0x46, 0x09, 0xE0, 0x00, 0xBF, 0x31, 0xF9, 0x10, 0xC0, + 0xCC, 0x45, 0x02, 0xDA, + 0x00, 0x9B, 0x01, 0x27, 0x1A, 0x54, 0x40, 0x1C, 0xC0, 0xB2, 0x63, 0x78, + 0x83, 0x42, 0xF3, 0xD2, + 0x76, 0x1C, 0xF6, 0xB2, 0xE0, 0x78, 0xB0, 0x42, 0xDE, 0xD2, 0x01, 0x2F, + 0x2E, 0xD1, 0x00, 0x20, + 0x85, 0xF8, 0x0E, 0x01, 0x20, 0x68, 0x28, 0x60, 0x00, 0x23, 0x1A, 0x46, + 0x29, 0x46, 0xD8, 0xF8, + 0x00, 0x00, 0x01, 0xF0, 0xBD, 0xF9, 0x01, 0x26, 0xDF, 0xF8, 0xD8, 0x80, + 0x1A, 0xE0, 0x00, 0xBF, + 0x05, 0xEB, 0x86, 0x07, 0x21, 0x46, 0x38, 0x46, 0x00, 0xF0, 0xEB, 0xF8, + 0x80, 0xB1, 0x05, 0xEB, + 0x46, 0x00, 0xB0, 0xF8, 0xB4, 0x10, 0xD8, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0x4A, 0x04, 0x81, 0x42, + 0x06, 0xD9, 0x38, 0x46, 0x4A, 0x46, 0x59, 0x46, 0xFF, 0xF7, 0xFA, 0xFD, + 0x01, 0x28, 0x06, 0xD0, + 0x76, 0x1C, 0xF6, 0xB2, 0x95, 0xF8, 0x0E, 0x01, 0xB0, 0x42, 0xE1, 0xD2, + 0x00, 0x20, 0xBD, 0xE8, + 0xF8, 0x8F, 0x2D, 0xE9, 0xF0, 0x41, 0x23, 0x4D, 0x0F, 0x46, 0x80, 0x46, + 0x29, 0x68, 0x14, 0x46, + 0x24, 0x48, 0x1E, 0x46, 0x9A, 0x69, 0xB1, 0xF8, 0x47, 0x34, 0x00, 0x78, + 0x9A, 0x42, 0x10, 0xDC, + 0xF2, 0x8C, 0x04, 0x2A, 0x0D, 0xD9, 0x62, 0x78, 0x23, 0x78, 0x91, 0xF8, + 0x49, 0x14, 0xD2, 0x1A, + 0x52, 0x1C, 0x8A, 0x42, 0x05, 0xDC, 0xE2, 0x78, 0xA3, 0x78, 0xD2, 0x1A, + 0x52, 0x1C, 0x8A, 0x42, + 0x02, 0xDD, 0x00, 0x20, 0xBD, 0xE8, 0xF0, 0x81, 0x00, 0x28, 0xFB, 0xD1, + 0x14, 0x48, 0x31, 0x46, + 0xB0, 0xF9, 0x00, 0x20, 0x20, 0x46, 0xFF, 0xF7, 0x6B, 0xFF, 0x00, 0x28, + 0xF2, 0xD1, 0x29, 0x68, + 0x91, 0xF8, 0x40, 0x24, 0x92, 0x07, 0xED, 0xD5, 0x91, 0xF8, 0xE0, 0x22, + 0x52, 0x06, 0x09, 0xD5, + 0x0D, 0x4A, 0x52, 0x78, 0x02, 0xB3, 0xB1, 0xF8, 0xF0, 0x12, 0x0C, 0x4A, + 0x49, 0x43, 0x12, 0x68, + 0x8A, 0x42, 0xDF, 0xDC, 0x33, 0x46, 0x22, 0x46, 0x39, 0x46, 0x11, 0xE0, + 0x6C, 0x06, 0x10, 0x00, + 0x54, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xED, 0x06, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, + 0xA8, 0x06, 0x10, 0x00, 0x34, 0x06, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, + 0x24, 0x07, 0x10, 0x00, + 0x40, 0x46, 0xBD, 0xE8, 0xF0, 0x41, 0xE6, 0xE5, 0xB1, 0xF8, 0xEE, 0x12, + 0xDD, 0xE7, 0x2D, 0xE9, + 0xFF, 0x4F, 0x81, 0xB0, 0xDF, 0xF8, 0x04, 0xB1, 0xDD, 0xF8, 0x38, 0x90, + 0x5F, 0xEA, 0x03, 0x08, + 0x15, 0x46, 0x1C, 0xD4, 0x2C, 0x78, 0x0B, 0xEB, 0xC8, 0x0A, 0x15, 0xE0, + 0x08, 0xF0, 0xFF, 0x01, + 0x01, 0x98, 0x09, 0xF0, 0xD3, 0xFC, 0x00, 0x90, 0xDA, 0xE9, 0x00, 0x67, + 0x22, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x09, 0xF0, 0x03, 0xFB, 0x06, 0x40, 0x0F, 0x40, 0x3E, 0x43, + 0x02, 0xD1, 0x00, 0x98, + 0x00, 0x21, 0x01, 0x55, 0x64, 0x1C, 0xE4, 0xB2, 0x68, 0x78, 0xA0, 0x42, + 0xE6, 0xD2, 0xB9, 0xF1, + 0x00, 0x00, 0x1E, 0xDB, 0x02, 0x46, 0xAC, 0x78, 0x01, 0x20, 0x00, 0x21, + 0x09, 0xF0, 0xEE, 0xFA, + 0x06, 0x46, 0x0F, 0x46, 0x4F, 0xF0, 0x00, 0x08, 0x10, 0xE0, 0x21, 0x46, + 0x01, 0x98, 0x09, 0xF0, + 0xAD, 0xFC, 0x0B, 0xEB, 0xC4, 0x01, 0x02, 0x46, 0xD1, 0xE9, 0x00, 0x01, + 0x30, 0x40, 0x39, 0x40, + 0x08, 0x43, 0x01, 0xD1, 0x02, 0xF8, 0x09, 0x80, 0x64, 0x1C, 0xE4, 0xB2, + 0xE8, 0x78, 0xA0, 0x42, + 0xEB, 0xD2, 0x05, 0xB0, 0xEA, 0xE6, 0x70, 0xB5, 0x1E, 0x4B, 0x1D, 0x4A, + 0x8C, 0x69, 0x1B, 0x68, + 0x12, 0x78, 0xB3, 0xF8, 0x47, 0x54, 0xAC, 0x42, 0x10, 0xDC, 0xCC, 0x8C, + 0x04, 0x2C, 0x0D, 0xD9, + 0x44, 0x78, 0x05, 0x78, 0x93, 0xF8, 0x49, 0x34, 0x64, 0x1B, 0x64, 0x1C, + 0x9C, 0x42, 0x05, 0xDC, + 0xC4, 0x78, 0x85, 0x78, 0x64, 0x1B, 0x64, 0x1C, 0x9C, 0x42, 0x01, 0xDD, + 0x00, 0x22, 0x06, 0xE0, + 0x2A, 0xB9, 0x11, 0x4A, 0xB2, 0xF9, 0x00, 0x20, 0xFF, 0xF7, 0xCA, 0xFE, + 0x02, 0x46, 0x10, 0x46, + 0x70, 0xBD, 0x02, 0x78, 0x0B, 0x78, 0x9A, 0x42, 0x0B, 0xD9, 0x42, 0x78, + 0x4B, 0x78, 0x9A, 0x42, + 0x07, 0xD2, 0x82, 0x78, 0x8B, 0x78, 0x9A, 0x42, 0x03, 0xD9, 0xC0, 0x78, + 0xC9, 0x78, 0x88, 0x42, + 0x01, 0xD3, 0x00, 0x20, 0x70, 0x47, 0x01, 0x20, 0x70, 0x47, 0x00, 0x00, + 0x98, 0x46, 0x10, 0x00, + 0x34, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x92, 0x06, 0x10, 0x00, + 0x70, 0xB5, 0xFE, 0x4C, + 0x00, 0xEB, 0x43, 0x05, 0x04, 0x9E, 0x00, 0xEB, 0x83, 0x03, 0x86, 0xB1, + 0x8E, 0x69, 0xA6, 0x60, + 0xCE, 0x8C, 0x66, 0x80, 0x09, 0x68, 0x61, 0x61, 0xB5, 0xF8, 0xB4, 0x10, + 0xA1, 0x80, 0x19, 0x68, + 0xE1, 0x60, 0x90, 0xF8, 0x0E, 0x01, 0x20, 0x70, 0x10, 0x68, 0x20, 0x61, + 0x70, 0xBD, 0xA6, 0x68, + 0x8E, 0x61, 0x66, 0x88, 0xCE, 0x84, 0x66, 0x69, 0x0E, 0x60, 0xA1, 0x88, + 0xA5, 0xF8, 0xB4, 0x10, + 0xE1, 0x68, 0x19, 0x60, 0x21, 0x78, 0x80, 0xF8, 0x0E, 0x11, 0x20, 0x69, + 0x10, 0x60, 0x70, 0xBD, + 0x2D, 0xE9, 0xF0, 0x47, 0xE9, 0x4D, 0x81, 0x46, 0xE9, 0x4F, 0x28, 0x68, + 0x1C, 0x46, 0x16, 0x46, + 0x90, 0xF8, 0x30, 0x02, 0x88, 0x46, 0x00, 0x07, 0x07, 0xD5, 0x38, 0x78, + 0x01, 0x28, 0x04, 0xD0, + 0x48, 0x46, 0xF9, 0xF7, 0xAF, 0xF8, 0x00, 0x28, 0x40, 0xD0, 0x28, 0x68, + 0x90, 0xF8, 0x30, 0x02, + 0x00, 0x06, 0x0A, 0xD5, 0x38, 0x78, 0x01, 0x28, 0x07, 0xD0, 0xDE, 0x48, + 0x00, 0x78, 0x20, 0xB1, + 0x30, 0x46, 0xF9, 0xF7, 0xF1, 0xF8, 0x00, 0x28, 0x30, 0xD0, 0xDB, 0x4B, + 0x32, 0x46, 0x41, 0x46, + 0x48, 0x46, 0x00, 0xF0, 0x34, 0xFF, 0x00, 0x28, 0x28, 0xD0, 0x94, 0xF8, + 0x40, 0x00, 0x03, 0x28, + 0x08, 0xD1, 0x29, 0x68, 0xE0, 0x8C, 0x91, 0xF8, 0x07, 0x13, 0x88, 0x42, + 0x02, 0xD9, 0x04, 0x20, + 0x84, 0xF8, 0x40, 0x00, 0x30, 0x68, 0xC4, 0xF8, 0x36, 0x00, 0x04, 0xF1, + 0x44, 0x02, 0x51, 0x1E, + 0x30, 0x46, 0xF8, 0xF7, 0xBE, 0xF9, 0x22, 0x46, 0x31, 0x46, 0xCB, 0x48, + 0x00, 0xF0, 0x7A, 0xFD, + 0x31, 0x46, 0xC9, 0x48, 0x00, 0xF0, 0xAC, 0xFE, 0x22, 0x46, 0x31, 0x46, + 0xC6, 0x48, 0xFF, 0xF7, + 0xE6, 0xFB, 0x20, 0x46, 0xBD, 0xE8, 0xF0, 0x47, 0xFE, 0xF7, 0xD7, 0xB9, + 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xF0, 0x41, 0x0D, 0x46, 0x1F, 0x46, 0x16, 0x46, 0x04, 0x46, + 0x48, 0x21, 0x09, 0xF0, + 0xDD, 0xFA, 0x00, 0x20, 0x84, 0xF8, 0x40, 0x00, 0xBC, 0x48, 0x00, 0x68, + 0x60, 0x60, 0xA0, 0x60, + 0x06, 0xEB, 0x45, 0x00, 0x84, 0xF8, 0x42, 0x50, 0x30, 0xF8, 0xB4, 0x1F, + 0x61, 0x85, 0x00, 0x88, + 0xE0, 0x84, 0x06, 0xEB, 0x85, 0x00, 0x00, 0x68, 0xC4, 0xF8, 0x3A, 0x00, + 0xAE, 0x48, 0x81, 0x69, + 0x21, 0x60, 0x01, 0x21, 0xA9, 0x40, 0x39, 0x42, 0x01, 0xD0, 0x40, 0x6A, + 0x20, 0x60, 0xBD, 0xE8, + 0xF0, 0x81, 0x2D, 0xE9, 0xF0, 0x47, 0x89, 0x46, 0x1C, 0x46, 0x16, 0x46, + 0xAC, 0x4D, 0x03, 0xF1, + 0x3E, 0x08, 0x91, 0x78, 0x09, 0xF0, 0x94, 0xFB, 0x07, 0x46, 0xB1, 0x78, + 0x60, 0x68, 0x09, 0xF0, + 0x95, 0xFB, 0x02, 0x46, 0x00, 0x20, 0xA0, 0x61, 0xB1, 0x78, 0x1F, 0xE0, + 0x30, 0x78, 0x13, 0xE0, + 0x17, 0xF8, 0x00, 0xC0, 0xCC, 0x45, 0x0D, 0xD1, 0x32, 0xF9, 0x10, 0x30, + 0xD4, 0xF8, 0x18, 0xC0, + 0xAB, 0x42, 0x9C, 0x44, 0xC4, 0xF8, 0x18, 0xC0, 0x04, 0xDD, 0x88, 0xF8, + 0x00, 0x00, 0x1D, 0x46, + 0x88, 0xF8, 0x01, 0x10, 0x40, 0x1C, 0xC0, 0xB2, 0x73, 0x78, 0x83, 0x42, + 0xE8, 0xD2, 0x99, 0x48, + 0x49, 0x1C, 0xC9, 0xB2, 0x00, 0x78, 0x28, 0x37, 0x02, 0xEB, 0x40, 0x02, + 0xF0, 0x78, 0x88, 0x42, + 0xDC, 0xD2, 0x65, 0x86, 0x9A, 0xE7, 0x2D, 0xE9, 0xFF, 0x4F, 0x81, 0xB0, + 0x0C, 0x46, 0x1E, 0x46, + 0x99, 0x78, 0xDD, 0xF8, 0x40, 0x80, 0x0E, 0x9D, 0x09, 0xF0, 0x68, 0xFB, + 0x00, 0x90, 0xB1, 0x78, + 0x20, 0x46, 0x09, 0xF0, 0x55, 0xFB, 0x83, 0x46, 0xB1, 0x78, 0xD8, 0xF8, + 0x04, 0x00, 0x09, 0xF0, + 0x55, 0xFB, 0x81, 0x46, 0x88, 0x48, 0x4F, 0xF0, 0x00, 0x0A, 0xC8, 0xF8, + 0x18, 0xA0, 0x00, 0x68, + 0x28, 0x60, 0xB7, 0x78, 0x42, 0xE0, 0x34, 0x78, 0x32, 0xE0, 0x00, 0xBF, + 0x1B, 0xF8, 0x04, 0x10, + 0x03, 0x98, 0x81, 0x42, 0x2A, 0xD1, 0x39, 0xF9, 0x14, 0x10, 0x0F, 0x98, + 0x81, 0x42, 0x22, 0xDD, + 0x00, 0x99, 0x03, 0x98, 0x08, 0x55, 0x29, 0x78, 0x20, 0x46, 0x05, 0xF0, + 0x35, 0xFA, 0x28, 0x70, + 0x69, 0x78, 0x20, 0x46, 0x05, 0xF0, 0x34, 0xFA, 0x68, 0x70, 0xA9, 0x78, + 0x38, 0x46, 0x05, 0xF0, + 0x2B, 0xFA, 0xA8, 0x70, 0xE9, 0x78, 0x38, 0x46, 0x05, 0xF0, 0x2A, 0xFA, + 0xE8, 0x70, 0x0A, 0xF1, + 0x01, 0x00, 0x1F, 0xFA, 0x80, 0xFA, 0x39, 0xF9, 0x14, 0x00, 0xD8, 0xF8, + 0x18, 0x10, 0x01, 0x44, + 0xC8, 0xF8, 0x18, 0x10, 0x02, 0xE0, 0x00, 0x99, 0x00, 0x20, 0x08, 0x55, + 0x64, 0x1C, 0xE4, 0xB2, + 0x70, 0x78, 0xA0, 0x42, 0xCA, 0xD2, 0x00, 0x98, 0x66, 0x49, 0x28, 0x30, + 0x00, 0x90, 0x09, 0x78, + 0x7F, 0x1C, 0x0B, 0xF1, 0x28, 0x0B, 0x09, 0xEB, 0x41, 0x09, 0xFF, 0xB2, + 0xF0, 0x78, 0xB8, 0x42, + 0xB9, 0xD2, 0xA8, 0xF8, 0x26, 0xA0, 0x05, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, + 0x2D, 0xE9, 0xFF, 0x41, + 0x17, 0x46, 0x0A, 0xAA, 0x80, 0x46, 0x92, 0xE8, 0x31, 0x00, 0x5C, 0x4A, + 0x1E, 0x46, 0xB2, 0xF9, + 0x00, 0x20, 0x82, 0x42, 0x02, 0xDB, 0x00, 0x20, 0x04, 0xB0, 0x48, 0xE7, + 0x03, 0xAA, 0xCD, 0xE9, + 0x00, 0x20, 0x02, 0x94, 0x3A, 0x46, 0x40, 0x46, 0xFF, 0xF7, 0x7D, 0xFF, + 0x01, 0x21, 0x28, 0x68, + 0xB9, 0x40, 0x08, 0x43, 0x28, 0x60, 0xC4, 0xF8, 0x00, 0x80, 0xE0, 0x8C, + 0x10, 0xB1, 0x03, 0x98, + 0x30, 0x60, 0xE8, 0xE7, 0x01, 0x20, 0xE7, 0xE7, 0x2D, 0xE9, 0xFF, 0x4F, + 0x81, 0xB0, 0x90, 0x46, + 0x0E, 0x9C, 0x8B, 0x46, 0x04, 0xEB, 0x88, 0x00, 0x94, 0xF8, 0x0E, 0x71, + 0xDD, 0xF8, 0x40, 0xA0, + 0x00, 0x68, 0x1E, 0x46, 0x20, 0x60, 0x01, 0x23, 0x21, 0x46, 0x58, 0x46, + 0x00, 0xF0, 0x20, 0xFF, + 0x01, 0x98, 0x58, 0x45, 0x1F, 0xD0, 0xB5, 0x78, 0x1A, 0xE0, 0x29, 0x46, + 0x01, 0x98, 0x09, 0xF0, + 0xC5, 0xFA, 0x81, 0x46, 0x29, 0x46, 0x58, 0x46, 0x09, 0xF0, 0xC0, 0xFA, + 0x01, 0x46, 0x30, 0x78, + 0x09, 0xE0, 0x00, 0xBF, 0x19, 0xF8, 0x00, 0x30, 0x43, 0x45, 0x02, 0xD1, + 0x0B, 0x5C, 0x09, 0xF8, + 0x00, 0x30, 0x40, 0x1C, 0xC0, 0xB2, 0x72, 0x78, 0x82, 0x42, 0xF3, 0xD2, + 0x6D, 0x1C, 0xED, 0xB2, + 0xF0, 0x78, 0xA8, 0x42, 0xE1, 0xD2, 0x94, 0xF8, 0x0E, 0x01, 0x00, 0x25, + 0x01, 0x21, 0xB8, 0x42, + 0x12, 0xD0, 0x11, 0x98, 0x78, 0xB1, 0x7F, 0x1C, 0xF8, 0xB2, 0x08, 0xE0, + 0xDA, 0xF8, 0x00, 0x20, + 0x01, 0xFA, 0x00, 0xF3, 0x1A, 0x43, 0x40, 0x1C, 0xC0, 0xB2, 0xCA, 0xF8, + 0x00, 0x20, 0x94, 0xF8, + 0x0E, 0x21, 0x82, 0x42, 0xF2, 0xD2, 0x01, 0x25, 0x00, 0x91, 0x43, 0x46, + 0x52, 0x46, 0x20, 0x46, + 0x0F, 0x99, 0xFF, 0xF7, 0x33, 0xFE, 0x28, 0x46, 0x7D, 0xE7, 0x10, 0xB5, + 0x17, 0x4A, 0x20, 0x4C, + 0x13, 0x68, 0x64, 0x78, 0x93, 0xF8, 0x06, 0x23, 0x4C, 0xB1, 0x91, 0xF8, + 0x24, 0x10, 0x09, 0x07, + 0x02, 0xD5, 0x93, 0xF8, 0x09, 0x13, 0x01, 0xE0, 0x93, 0xF8, 0x08, 0x13, + 0x0A, 0x44, 0x90, 0x42, + 0x01, 0xD9, 0x01, 0x20, 0x10, 0xBD, 0x00, 0x20, 0x10, 0xBD, 0x2D, 0xE9, + 0xF0, 0x47, 0x1C, 0x46, + 0x17, 0x46, 0x88, 0x46, 0x81, 0x46, 0x01, 0xF0, 0xED, 0xF8, 0x08, 0x4E, + 0xE1, 0x8C, 0x30, 0x68, + 0x90, 0xF8, 0x0E, 0x23, 0x91, 0x42, 0x7C, 0xD8, 0x03, 0x21, 0x84, 0xF8, + 0x40, 0x10, 0x90, 0xF8, + 0xE0, 0x12, 0x00, 0x25, 0x8A, 0x07, 0x15, 0xE0, 0x38, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x66, 0x05, 0x10, 0x00, 0xF4, 0x06, 0x10, 0x00, 0xF0, 0x45, 0x10, 0x00, + 0x10, 0x07, 0x10, 0x00, + 0x00, 0x80, 0xFF, 0xFF, 0xEE, 0x06, 0x10, 0x00, 0x36, 0x7A, 0x01, 0x00, + 0x9A, 0x06, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, 0x01, 0xD4, 0x49, 0x07, 0x00, 0xD5, 0x01, 0x25, + 0xFF, 0x4A, 0xB0, 0xF8, + 0x0A, 0x13, 0x52, 0x78, 0x22, 0xB1, 0xFE, 0x4A, 0x12, 0x78, 0x0A, 0xB9, + 0xB0, 0xF8, 0x0C, 0x13, + 0xA2, 0x8D, 0x8A, 0x42, 0x02, 0xD2, 0xFB, 0x49, 0x09, 0x78, 0x21, 0xB1, + 0x61, 0x8D, 0x03, 0x29, + 0x06, 0xD2, 0x00, 0x25, 0x2C, 0xE0, 0x61, 0x8D, 0x00, 0x25, 0x03, 0x29, + 0xF9, 0xD3, 0x27, 0xE0, + 0x35, 0xB3, 0x90, 0xF8, 0x40, 0x04, 0xC1, 0x07, 0x0D, 0xD0, 0x40, 0x07, + 0x0B, 0xD5, 0x21, 0x46, + 0x38, 0x46, 0xFF, 0xF7, 0x80, 0xFD, 0xF0, 0x49, 0x08, 0x70, 0x20, 0xB1, + 0xA0, 0x8C, 0x40, 0xF0, + 0x80, 0x00, 0xA0, 0x84, 0xE5, 0xE7, 0x30, 0x68, 0x90, 0xF8, 0x20, 0x04, + 0xC0, 0x07, 0x0F, 0xD0, + 0xEA, 0x48, 0xEB, 0x49, 0xB0, 0xF9, 0x00, 0x00, 0xB1, 0xF9, 0x00, 0x10, + 0x88, 0x42, 0x07, 0xDB, + 0x23, 0x46, 0x3A, 0x46, 0x41, 0x46, 0x48, 0x46, 0x02, 0xF0, 0x4D, 0xF9, + 0x01, 0x28, 0x04, 0xD0, + 0xA0, 0x8C, 0x10, 0xF4, 0xC0, 0x7F, 0x19, 0xD1, 0x04, 0xE0, 0xA0, 0x8C, + 0x40, 0xF4, 0x80, 0x70, + 0xA0, 0x84, 0x13, 0xE0, 0x95, 0xB1, 0x30, 0x68, 0x90, 0xF8, 0xE0, 0x02, + 0xC0, 0x07, 0x03, 0xD0, + 0x21, 0x46, 0x38, 0x46, 0x01, 0xF0, 0x3B, 0xFA, 0x23, 0x46, 0x3A, 0x46, + 0x41, 0x46, 0x48, 0x46, + 0x00, 0xE0, 0x0A, 0xE0, 0xBD, 0xE8, 0xF0, 0x47, 0x01, 0xF0, 0xFD, 0xBF, + 0x23, 0x46, 0x3A, 0x46, + 0x41, 0x46, 0x48, 0x46, 0xBD, 0xE8, 0xF0, 0x47, 0xAA, 0xE5, 0x04, 0x20, + 0x84, 0xF8, 0x40, 0x00, + 0xF4, 0xE7, 0xD0, 0x48, 0x00, 0x78, 0x80, 0x07, 0x0B, 0xD5, 0xCF, 0x48, + 0xCF, 0x4A, 0x00, 0x68, + 0x12, 0x68, 0x90, 0xF8, 0x57, 0x13, 0x91, 0x42, 0x05, 0xD2, 0x90, 0xF8, + 0x40, 0x03, 0x80, 0x07, + 0x01, 0xD5, 0x00, 0x20, 0x70, 0x47, 0x01, 0x20, 0x70, 0x47, 0x91, 0xF8, + 0x24, 0x10, 0xC6, 0x4A, + 0xCB, 0x07, 0xC7, 0x49, 0x12, 0x68, 0x09, 0x78, 0x06, 0xD0, 0x11, 0xB1, + 0x92, 0xF8, 0x48, 0x13, + 0x05, 0xE0, 0x92, 0xF8, 0x49, 0x13, 0x02, 0xE0, 0x59, 0xB1, 0x92, 0xF8, + 0x46, 0x13, 0xB7, 0x4B, + 0x5B, 0x78, 0x13, 0xB1, 0x92, 0xF8, 0x4A, 0x23, 0x11, 0x44, 0x88, 0x42, + 0x04, 0xD9, 0x01, 0x20, + 0x70, 0x47, 0x92, 0xF8, 0x47, 0x13, 0xF2, 0xE7, 0x00, 0x20, 0x70, 0x47, + 0x2D, 0xE9, 0xFF, 0x4F, + 0xB8, 0x48, 0xDF, 0xF8, 0xD4, 0x92, 0x87, 0xB0, 0xB0, 0xF9, 0x00, 0x80, + 0xD9, 0xF8, 0x00, 0x00, + 0x0C, 0x46, 0x00, 0x26, 0x90, 0xF8, 0x40, 0x04, 0xDF, 0xF8, 0xCC, 0xB2, + 0xC1, 0x07, 0x14, 0x98, + 0x4F, 0xF0, 0x01, 0x07, 0x15, 0x46, 0x07, 0xFA, 0x00, 0xF7, 0xB2, 0x46, + 0x3A, 0xD0, 0xAF, 0x49, + 0xA7, 0x4A, 0xB1, 0xF9, 0x00, 0x00, 0xB2, 0xF9, 0x00, 0x20, 0x90, 0x42, + 0x32, 0xDA, 0x2A, 0x68, + 0x3A, 0x42, 0x2F, 0xD1, 0xE2, 0x8C, 0x04, 0x2A, 0x2C, 0xD9, 0x8D, 0xE8, + 0x31, 0x00, 0x0A, 0x9B, + 0x14, 0x9A, 0xDB, 0xF8, 0x18, 0x10, 0xDB, 0xF8, 0x24, 0x00, 0xFF, 0xF7, + 0x67, 0xFE, 0x06, 0x00, + 0x20, 0xD1, 0x23, 0x46, 0x20, 0x68, 0x0A, 0x9A, 0x14, 0x99, 0xFF, 0xF7, + 0x22, 0xFC, 0x96, 0x49, + 0x08, 0x70, 0xA0, 0xB1, 0x70, 0x1E, 0x8D, 0xF8, 0x10, 0x00, 0x8D, 0xF8, + 0x14, 0x00, 0xD9, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0x41, 0x04, 0x80, 0x07, 0x05, 0xD5, 0x05, 0xAA, + 0x04, 0xA9, 0x0A, 0x98, + 0xF7, 0xF7, 0x93, 0xFF, 0xA8, 0xB3, 0xA0, 0x8C, 0x40, 0xF0, 0x80, 0x00, + 0xA0, 0x84, 0x93, 0x48, + 0xB0, 0xF9, 0x00, 0x80, 0xD9, 0xF8, 0x00, 0x00, 0x90, 0xF8, 0x20, 0x04, + 0xC0, 0x07, 0x53, 0xD0, + 0x94, 0xF8, 0x24, 0x00, 0x00, 0x06, 0x4F, 0xD4, 0x84, 0x48, 0x85, 0x4A, + 0xB0, 0xF9, 0x00, 0x10, + 0xB2, 0xF9, 0x00, 0x20, 0x91, 0x42, 0x47, 0xDA, 0x81, 0x46, 0x41, 0x45, + 0x17, 0xD0, 0x28, 0x68, + 0x38, 0x42, 0x07, 0xD0, 0xCD, 0xF8, 0x00, 0xA0, 0x2A, 0x46, 0x21, 0x46, + 0x14, 0x9B, 0x07, 0x98, + 0xFF, 0xF7, 0xD4, 0xFC, 0xB9, 0xF9, 0x00, 0x00, 0x8D, 0xE8, 0x31, 0x00, + 0x0A, 0x9B, 0x14, 0x9A, + 0xDB, 0xF8, 0x18, 0x10, 0xDB, 0xF8, 0x24, 0x00, 0xFF, 0xF7, 0x18, 0xFE, + 0x06, 0x46, 0xFE, 0xB1, + 0x2A, 0xE0, 0xFF, 0xE7, 0x7A, 0x49, 0x9D, 0xF9, 0x10, 0x30, 0x01, 0xF8, + 0x36, 0x3F, 0x9D, 0xF9, + 0x14, 0x00, 0x48, 0x70, 0x00, 0x90, 0x20, 0x68, 0x0A, 0x9A, 0x07, 0x99, + 0xFF, 0xF7, 0x27, 0xFC, + 0x07, 0x98, 0x04, 0xF1, 0x3A, 0x03, 0x8D, 0xE8, 0x31, 0x04, 0x21, 0x68, + 0x14, 0x9A, 0xDB, 0xF8, + 0x18, 0x00, 0xFF, 0xF7, 0x21, 0xFE, 0x00, 0x28, 0xB1, 0xD0, 0x01, 0x20, + 0x0B, 0xB0, 0xF3, 0xE5, + 0x23, 0x46, 0x20, 0x68, 0x0A, 0x9A, 0x14, 0x99, 0x02, 0xF0, 0x45, 0xF8, + 0x01, 0x28, 0x03, 0xD1, + 0xA0, 0x8C, 0x40, 0xF4, 0x80, 0x70, 0xA0, 0x84, 0xA0, 0x8C, 0x10, 0xF4, + 0xC0, 0x7F, 0x0A, 0xD1, + 0x28, 0x68, 0x38, 0x42, 0x07, 0xD0, 0xCD, 0xF8, 0x00, 0xA0, 0x2A, 0x46, + 0x21, 0x46, 0x14, 0x9B, + 0x07, 0x98, 0xFF, 0xF7, 0x8B, 0xFC, 0x30, 0x46, 0xE0, 0xE7, 0x2D, 0xE9, + 0xF0, 0x4F, 0x5D, 0x49, + 0x53, 0x48, 0xE7, 0xB0, 0xB1, 0xF9, 0x00, 0x10, 0xB0, 0xF9, 0x00, 0x00, + 0x4F, 0xF0, 0x00, 0x08, + 0xCD, 0xE9, 0x62, 0x01, 0x54, 0x48, 0xC3, 0x46, 0xC1, 0x46, 0x47, 0x46, + 0x01, 0x21, 0x1C, 0x30, + 0x02, 0xF0, 0x0D, 0xFC, 0x50, 0x48, 0x01, 0x21, 0x24, 0x30, 0x02, 0xF0, + 0x08, 0xFC, 0x4E, 0x48, + 0x02, 0x21, 0x20, 0x30, 0x02, 0xF0, 0x03, 0xFC, 0x02, 0x21, 0x4F, 0x48, + 0x02, 0xF0, 0xA7, 0xFB, + 0x04, 0x21, 0x4E, 0x48, 0x02, 0xF0, 0xA3, 0xFB, 0x47, 0x4C, 0x4F, 0xF4, + 0x66, 0x75, 0x29, 0x46, + 0xE0, 0x69, 0x08, 0xF0, 0xA1, 0xFF, 0x29, 0x46, 0x60, 0x6A, 0x08, 0xF0, + 0x9D, 0xFF, 0x48, 0x48, + 0xB0, 0xF9, 0x00, 0x00, 0x41, 0x00, 0x20, 0x6A, 0x08, 0xF0, 0x96, 0xFF, + 0x29, 0x46, 0x45, 0x48, + 0x08, 0xF0, 0x92, 0xFF, 0x4F, 0xF0, 0x00, 0x0A, 0x55, 0x46, 0x84, 0xF8, + 0x01, 0xA0, 0xF8, 0xF7, + 0xFB, 0xFC, 0xF7, 0xF7, 0x41, 0xFE, 0x40, 0x48, 0x8D, 0xF8, 0x72, 0x51, + 0x01, 0x23, 0x00, 0x68, + 0x19, 0x90, 0x00, 0x22, 0x19, 0xA9, 0xA0, 0x69, 0x00, 0xF0, 0xE2, 0xFC, + 0x3B, 0x48, 0x5D, 0x95, + 0x00, 0x26, 0xB0, 0xF9, 0x00, 0x10, 0x2A, 0x48, 0xB0, 0xF9, 0x00, 0x00, + 0x04, 0xF0, 0x7C, 0xFF, + 0x00, 0xB2, 0x06, 0x90, 0x9D, 0xF8, 0x72, 0x01, 0x01, 0x28, 0x02, 0xD9, + 0x22, 0x49, 0x81, 0xF8, + 0x00, 0xA0, 0x0D, 0xF1, 0x56, 0x00, 0x01, 0x25, 0x60, 0x90, 0x9B, 0xE1, + 0x00, 0x20, 0x01, 0x90, + 0x19, 0xA8, 0x00, 0xEB, 0x85, 0x00, 0x05, 0x90, 0x19, 0xAA, 0x29, 0x46, + 0x07, 0xA8, 0x5D, 0x9B, + 0xFF, 0xF7, 0x96, 0xFC, 0x07, 0xAB, 0x29, 0x46, 0x05, 0x9A, 0x07, 0x98, + 0xFF, 0xF7, 0xB9, 0xFC, + 0x01, 0x24, 0x2B, 0x46, 0x5D, 0xAA, 0x07, 0xA9, 0x19, 0xA8, 0x00, 0x94, + 0xFF, 0xF7, 0x06, 0xFC, + 0x0D, 0xF1, 0x5A, 0x00, 0x00, 0xF0, 0xFE, 0xFA, 0x78, 0xB1, 0xBD, 0xF8, + 0x40, 0x00, 0x40, 0xF0, + 0x01, 0x00, 0xAD, 0xF8, 0x40, 0x00, 0x07, 0xA8, 0x00, 0xF0, 0x41, 0xFC, + 0x28, 0xB1, 0x1C, 0x48, + 0x14, 0x49, 0x00, 0x88, 0x08, 0x80, 0x0A, 0x49, 0x08, 0x80, 0x06, 0x48, + 0x00, 0x78, 0x88, 0xB3, + 0xBD, 0xF8, 0x40, 0x00, 0x10, 0xF0, 0x06, 0x0F, 0x30, 0xD1, 0x2C, 0xE0, + 0x74, 0x07, 0x10, 0x00, + 0xFD, 0x06, 0x10, 0x00, 0xA4, 0x06, 0x10, 0x00, 0x34, 0x06, 0x10, 0x00, + 0xA6, 0x06, 0x10, 0x00, + 0x92, 0x06, 0x10, 0x00, 0x04, 0x07, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x80, 0x06, 0x10, 0x00, + 0xF9, 0x06, 0x10, 0x00, 0x9A, 0x06, 0x10, 0x00, 0x38, 0x06, 0x10, 0x00, + 0xA8, 0x06, 0x10, 0x00, + 0x0A, 0x44, 0x01, 0x20, 0x94, 0x06, 0x10, 0x00, 0x60, 0x06, 0x10, 0x00, + 0x6C, 0x06, 0x10, 0x00, + 0xFE, 0x06, 0x10, 0x00, 0xC2, 0x18, 0x01, 0x20, 0x88, 0x06, 0x10, 0x00, + 0xAC, 0x06, 0x10, 0x00, + 0xA2, 0x06, 0x10, 0x00, 0x02, 0xE0, 0xFE, 0x48, 0x00, 0x68, 0x08, 0x90, + 0x05, 0x98, 0x00, 0xF0, + 0xC3, 0xFA, 0x28, 0xB1, 0xBD, 0xF8, 0x40, 0x00, 0x40, 0xF0, 0x08, 0x00, + 0xAD, 0xF8, 0x40, 0x00, + 0x01, 0x24, 0x5D, 0x98, 0xAC, 0x40, 0x04, 0x42, 0x41, 0xD1, 0xF6, 0x48, + 0x00, 0x78, 0xC0, 0x07, + 0x3D, 0xD0, 0xF5, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x28, 0x13, 0xF4, 0x48, + 0x00, 0x68, 0x81, 0x42, + 0xF3, 0x48, 0x40, 0x78, 0x01, 0xD2, 0x90, 0xBB, 0x01, 0xE0, 0x02, 0x28, + 0x2F, 0xD2, 0xF1, 0x48, + 0x5D, 0xAA, 0x07, 0xA9, 0xB0, 0xF9, 0x00, 0x00, 0x8D, 0xE8, 0x07, 0x00, + 0xEE, 0x48, 0x2A, 0x46, + 0x05, 0x9B, 0x81, 0x69, 0x40, 0x6A, 0xFF, 0xF7, 0xD9, 0xFC, 0x01, 0x90, + 0xB8, 0xB9, 0x07, 0xAB, + 0x29, 0x46, 0x05, 0x9A, 0x07, 0x98, 0x00, 0xF0, 0xA6, 0xF9, 0x80, 0xB1, + 0x4F, 0xF0, 0x02, 0x0C, + 0x8D, 0xF8, 0x5C, 0xC0, 0x29, 0x46, 0x07, 0xAB, 0x05, 0x9A, 0x07, 0x98, + 0xAD, 0xF8, 0x4A, 0xC0, + 0xAD, 0xF8, 0x4C, 0xC0, 0xFF, 0xF7, 0x9C, 0xFB, 0x4F, 0xF0, 0x01, 0x0B, + 0xCF, 0xE0, 0x2B, 0x46, + 0x5D, 0xAA, 0x07, 0xA9, 0x19, 0xA8, 0xCD, 0xF8, 0x00, 0xA0, 0xFF, 0xF7, + 0x67, 0xFB, 0xBD, 0xF9, + 0x4E, 0x00, 0x06, 0x99, 0x88, 0x42, 0x6A, 0xDD, 0x00, 0x95, 0x5D, 0xAA, + 0x07, 0xA9, 0x19, 0xA8, + 0x05, 0x9B, 0xFF, 0xF7, 0x13, 0xFE, 0x00, 0x28, 0x7E, 0xD1, 0x5D, 0x98, + 0x04, 0x42, 0x3A, 0xD1, + 0xBD, 0xF8, 0x40, 0x00, 0x10, 0xF4, 0xC0, 0x7F, 0x35, 0xD1, 0xD0, 0x48, + 0x5D, 0xAA, 0x07, 0xA9, + 0xB0, 0xF9, 0x00, 0x00, 0x8D, 0xE8, 0x07, 0x00, 0xCB, 0x48, 0x2A, 0x46, + 0x05, 0x9B, 0x81, 0x69, + 0x40, 0x6A, 0xFF, 0xF7, 0x93, 0xFC, 0x01, 0x90, 0x5D, 0x98, 0x04, 0x42, + 0x23, 0xD0, 0xC2, 0x48, + 0xBD, 0xF8, 0x42, 0x20, 0x00, 0x68, 0x90, 0xF8, 0x0E, 0x33, 0x9A, 0x42, + 0x05, 0xD8, 0x90, 0xF8, + 0xE0, 0x02, 0x82, 0x07, 0x17, 0xD4, 0x40, 0x07, 0x15, 0xD4, 0x01, 0x23, + 0x5D, 0xAA, 0x07, 0xA9, + 0x19, 0xA8, 0x8D, 0xE8, 0x0F, 0x00, 0xBC, 0x48, 0x2A, 0x46, 0x60, 0x9B, + 0x41, 0x6A, 0x80, 0x69, + 0xFF, 0xF7, 0x9A, 0xFC, 0x01, 0x90, 0x01, 0x20, 0x00, 0x90, 0x2B, 0x46, + 0x5D, 0xAA, 0x07, 0xA9, + 0x19, 0xA8, 0xFF, 0xF7, 0x1B, 0xFB, 0x01, 0x98, 0xC8, 0xB9, 0xBD, 0xF8, + 0x42, 0x00, 0x07, 0xA9, + 0xFF, 0xF7, 0xE3, 0xFC, 0x98, 0xB1, 0x07, 0xA8, 0x00, 0x90, 0xB1, 0x48, + 0x29, 0x46, 0x60, 0x9A, + 0xB0, 0xF9, 0x00, 0x30, 0xAC, 0x48, 0x80, 0x69, 0x00, 0xF0, 0x84, 0xF9, + 0x07, 0xAB, 0x29, 0x46, + 0x05, 0x9A, 0x07, 0x98, 0xFF, 0xF7, 0xE9, 0xFC, 0x4F, 0xF0, 0x01, 0x08, + 0x5F, 0xE0, 0x2B, 0x46, + 0x5D, 0xAA, 0x07, 0xA9, 0x19, 0xA8, 0xCD, 0xF8, 0x00, 0xA0, 0xFF, 0xF7, + 0xF7, 0xFA, 0xA4, 0x48, + 0xBD, 0xF9, 0x4E, 0x10, 0xB0, 0xF9, 0x00, 0x00, 0x81, 0x42, 0x50, 0xDD, + 0xFF, 0xF7, 0x71, 0xFD, + 0xF0, 0xB3, 0x5D, 0x98, 0x04, 0x42, 0x2F, 0xD1, 0x9D, 0x48, 0x5D, 0xAA, + 0x07, 0xA9, 0xB0, 0xF9, + 0x00, 0x00, 0x8D, 0xE8, 0x07, 0x00, 0x98, 0x48, 0x2A, 0x46, 0x05, 0x9B, + 0x81, 0x69, 0x40, 0x6A, + 0xFF, 0xF7, 0x2C, 0xFC, 0x01, 0x90, 0x00, 0xE0, 0x52, 0xE0, 0x8F, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x40, 0x03, 0xC0, 0x06, 0x18, 0xD4, 0x5D, 0x98, 0x04, 0x42, 0x15, 0xD0, + 0x01, 0x23, 0x5D, 0xAA, + 0x07, 0xA9, 0x19, 0xA8, 0x8D, 0xE8, 0x0F, 0x00, 0x8B, 0x48, 0x2A, 0x46, + 0x60, 0x9B, 0x41, 0x6A, + 0x80, 0x69, 0xFF, 0xF7, 0x39, 0xFC, 0x01, 0x90, 0x01, 0x20, 0x00, 0x90, + 0x2B, 0x46, 0x5D, 0xAA, + 0x07, 0xA9, 0x19, 0xA8, 0xFF, 0xF7, 0xBA, 0xFA, 0x01, 0x98, 0x80, 0xB9, + 0xBD, 0xF8, 0x42, 0x00, + 0x07, 0xA9, 0xFF, 0xF7, 0x4A, 0xFD, 0x50, 0xB1, 0x07, 0xAB, 0x29, 0x46, + 0x05, 0x9A, 0x00, 0xE0, + 0x0D, 0xE0, 0x07, 0x98, 0x00, 0xF0, 0x6F, 0xF9, 0x4F, 0xF0, 0x01, 0x09, + 0x07, 0xE0, 0x2B, 0x46, + 0x5D, 0xAA, 0x07, 0xA9, 0x19, 0xA8, 0xCD, 0xF8, 0x00, 0xA0, 0xFF, 0xF7, + 0x9F, 0xFA, 0x5D, 0x99, + 0x44, 0xEA, 0x01, 0x00, 0x73, 0x49, 0x5D, 0x90, 0x63, 0x98, 0x08, 0x80, + 0x73, 0x49, 0x62, 0x98, + 0x08, 0x80, 0x74, 0x48, 0x01, 0x78, 0x31, 0xB1, 0x9D, 0xF8, 0x72, 0x11, + 0x26, 0x43, 0x01, 0x29, + 0x01, 0xD9, 0x80, 0xF8, 0x00, 0xA0, 0xBD, 0xF8, 0x40, 0x00, 0xC0, 0x05, + 0x00, 0xD5, 0x27, 0x43, + 0x6D, 0x1C, 0xED, 0xB2, 0x9D, 0xF8, 0x72, 0x01, 0xA8, 0x42, 0xBF, 0xF4, + 0x5F, 0xAE, 0x66, 0x48, + 0x6A, 0x4A, 0x69, 0x4B, 0x41, 0x78, 0xA2, 0xF5, 0x66, 0x70, 0x01, 0xF0, + 0x7A, 0xFC, 0x68, 0x48, + 0x9D, 0xF8, 0x72, 0x11, 0x00, 0xF8, 0x05, 0x1F, 0x68, 0x49, 0x06, 0x83, + 0x87, 0x83, 0x65, 0x48, + 0x80, 0xF8, 0x00, 0xB0, 0x64, 0x48, 0x80, 0xF8, 0x00, 0x80, 0x81, 0xF8, + 0x00, 0x90, 0x02, 0x21, + 0x63, 0x48, 0x02, 0xF0, 0xC1, 0xF9, 0x04, 0x21, 0x62, 0x48, 0x02, 0xF0, + 0xBD, 0xF9, 0x56, 0x48, + 0x01, 0x21, 0x18, 0x30, 0x02, 0xF0, 0x86, 0xFA, 0x53, 0x48, 0x01, 0x21, + 0x1C, 0x30, 0x02, 0xF0, + 0x81, 0xFA, 0x51, 0x48, 0x01, 0x21, 0x24, 0x30, 0x02, 0xF0, 0x7C, 0xFA, + 0x4E, 0x48, 0x02, 0x21, + 0x20, 0x30, 0x02, 0xF0, 0x77, 0xFA, 0x67, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, + 0x51, 0x49, 0x00, 0x20, + 0x08, 0x70, 0x51, 0x49, 0x08, 0x70, 0x51, 0x49, 0x08, 0x70, 0x4A, 0x49, + 0x08, 0x70, 0xA8, 0x21, + 0x49, 0x48, 0x08, 0xF0, 0xA3, 0xBD, 0x44, 0x49, 0x00, 0x20, 0x4D, 0x4A, + 0x08, 0x62, 0x88, 0x61, + 0xC8, 0x61, 0x10, 0x60, 0x4B, 0x4A, 0x10, 0x60, 0x46, 0x4A, 0x10, 0x70, + 0x46, 0x4A, 0x10, 0x70, + 0x46, 0x4A, 0x10, 0x70, 0x3F, 0x4A, 0x10, 0x70, 0x48, 0x70, 0x70, 0x47, + 0x3A, 0x49, 0x10, 0xB5, + 0x00, 0x20, 0x48, 0x70, 0x4F, 0xF4, 0x66, 0x71, 0x43, 0x48, 0x08, 0xF0, + 0x65, 0xFD, 0x3A, 0x48, + 0xA8, 0x21, 0xA8, 0x38, 0x08, 0xF0, 0x82, 0xFD, 0xBD, 0xE8, 0x10, 0x40, + 0xA8, 0x21, 0x36, 0x48, + 0x08, 0xF0, 0x7C, 0xBD, 0x2D, 0xE9, 0xF7, 0x4F, 0x2F, 0x48, 0x0D, 0x46, + 0x41, 0x78, 0x0F, 0x29, + 0x01, 0xD2, 0x49, 0x1C, 0x41, 0x70, 0x01, 0xF0, 0xFF, 0x09, 0x30, 0x49, + 0x82, 0xF8, 0x41, 0x90, + 0x01, 0xEB, 0x89, 0x00, 0x29, 0x68, 0x01, 0x60, 0xA9, 0x78, 0x33, 0x48, + 0x08, 0xF0, 0x56, 0xFE, + 0x82, 0x46, 0xA8, 0x78, 0x19, 0xE0, 0x00, 0x98, 0x2C, 0x78, 0x00, 0xEB, + 0xC8, 0x0B, 0x0D, 0xE0, + 0xDB, 0xE9, 0x00, 0x67, 0x22, 0x46, 0x01, 0x20, 0x00, 0x21, 0x08, 0xF0, + 0x7F, 0xFC, 0x06, 0x40, + 0x0F, 0x40, 0x3E, 0x43, 0x01, 0xD0, 0x0A, 0xF8, 0x04, 0x90, 0x64, 0x1C, + 0x68, 0x78, 0xA0, 0x42, + 0xEE, 0xDA, 0x0A, 0xF1, 0x28, 0x0A, 0x08, 0xF1, 0x01, 0x00, 0xE9, 0x78, + 0x80, 0x46, 0x41, 0x45, + 0xE1, 0xDA, 0xBD, 0xE8, 0xFE, 0x8F, 0x2D, 0xE9, 0xF0, 0x41, 0x0F, 0x4C, + 0x10, 0x4F, 0xB3, 0xF8, + 0x26, 0xC0, 0x24, 0x68, 0x7F, 0x78, 0x00, 0x26, 0x94, 0xF8, 0x29, 0x53, + 0x17, 0xB1, 0x94, 0xF8, + 0x2A, 0x73, 0x3D, 0x44, 0x93, 0xF8, 0x24, 0xE0, 0x94, 0xF8, 0x2B, 0x73, + 0x5F, 0xEA, 0xCE, 0x7E, + 0x01, 0xD0, 0x94, 0xF8, 0x2C, 0x73, 0xAC, 0x45, 0x39, 0xD9, 0xBC, 0x45, + 0x37, 0xD8, 0x25, 0xE0, + 0x14, 0x07, 0x10, 0x00, 0x04, 0x07, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x7C, 0x06, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, 0x94, 0x06, 0x10, 0x00, 0x38, 0x06, 0x10, 0x00, + 0x92, 0x06, 0x10, 0x00, + 0x96, 0x06, 0x10, 0x00, 0x34, 0x06, 0x10, 0x00, 0x98, 0x46, 0x10, 0x00, + 0x5A, 0x1C, 0x01, 0x20, + 0x0A, 0x44, 0x01, 0x20, 0xF6, 0x06, 0x10, 0x00, 0xF7, 0x06, 0x10, 0x00, + 0xF8, 0x06, 0x10, 0x00, + 0x60, 0x06, 0x10, 0x00, 0x6C, 0x06, 0x10, 0x00, 0xC2, 0x18, 0x01, 0x20, + 0x45, 0x4F, 0xB3, 0xF9, + 0x32, 0x50, 0xB7, 0xF9, 0x00, 0x70, 0xBD, 0x42, 0x09, 0xDD, 0xB4, 0xF8, + 0x26, 0x43, 0x9D, 0x69, + 0xA5, 0x42, 0x04, 0xDA, 0x00, 0xF0, 0xDB, 0xFC, 0x01, 0x28, 0x00, 0xD1, + 0x01, 0x26, 0x30, 0x46, + 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, 0xFF, 0x5F, 0x8B, 0x46, 0x14, 0x46, + 0x91, 0x78, 0x0E, 0x9D, + 0x08, 0xF0, 0xC6, 0xFD, 0x06, 0x46, 0xA1, 0x78, 0x68, 0x68, 0x08, 0xF0, + 0xC7, 0xFD, 0x07, 0x46, + 0x4F, 0xF0, 0x00, 0x09, 0xFF, 0xF7, 0xF5, 0xFB, 0x00, 0x28, 0x32, 0xD0, + 0x32, 0x49, 0xB5, 0xF9, + 0x32, 0x00, 0xB1, 0xF9, 0x00, 0x10, 0x88, 0x42, 0x2B, 0xDC, 0x30, 0x48, + 0xA1, 0x78, 0xE3, 0x78, + 0x90, 0xF8, 0x00, 0xA0, 0x19, 0xE0, 0x20, 0x78, 0x62, 0x78, 0x0F, 0xE0, + 0x16, 0xF8, 0x00, 0x80, + 0xD8, 0x45, 0x09, 0xD1, 0x37, 0xF9, 0x10, 0x80, 0xDD, 0xF8, 0x0C, 0xC0, + 0xE0, 0x45, 0x03, 0xDD, + 0x09, 0xF1, 0x01, 0x0C, 0x1F, 0xFA, 0x8C, 0xF9, 0x40, 0x1C, 0xC0, 0xB2, + 0x82, 0x42, 0xED, 0xD2, + 0x49, 0x1C, 0x07, 0xEB, 0x4A, 0x07, 0xC9, 0xB2, 0x28, 0x36, 0x8B, 0x42, + 0xE3, 0xD2, 0x29, 0x46, + 0x48, 0x46, 0xFF, 0xF7, 0xDA, 0xFB, 0x00, 0x28, 0x03, 0xD0, 0xA8, 0x8C, + 0x40, 0xF4, 0x00, 0x70, + 0xA8, 0x84, 0xBD, 0xE8, 0xFF, 0x9F, 0x2D, 0xE9, 0xF0, 0x41, 0x80, 0x46, + 0x01, 0x20, 0x83, 0xF8, + 0x40, 0x00, 0x1C, 0x46, 0x16, 0x46, 0x0F, 0x46, 0x40, 0x46, 0x00, 0xF0, + 0x0B, 0xFC, 0x14, 0x4D, + 0x28, 0x68, 0x90, 0xF8, 0x40, 0x03, 0x41, 0x07, 0x04, 0xD5, 0x21, 0x46, + 0x30, 0x46, 0x00, 0xF0, + 0xDF, 0xFD, 0x05, 0xE0, 0x00, 0x07, 0x03, 0xD5, 0x21, 0x46, 0x30, 0x46, + 0x00, 0xF0, 0xC7, 0xFD, + 0x28, 0x68, 0x23, 0x46, 0x32, 0x46, 0x90, 0xF8, 0x40, 0x03, 0x39, 0x46, + 0xC0, 0x06, 0x40, 0x46, + 0x03, 0xD5, 0xBD, 0xE8, 0xF0, 0x41, 0x01, 0xF0, 0x86, 0xBB, 0xBD, 0xE8, + 0xF0, 0x41, 0xFF, 0xF7, + 0x37, 0xB9, 0x00, 0x00, 0x94, 0x06, 0x10, 0x00, 0x8C, 0x06, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x01, 0x78, 0x59, 0xB1, 0x80, 0x4A, 0x12, 0x78, + 0x52, 0x1E, 0x91, 0x42, + 0x06, 0xD0, 0x40, 0x78, 0x20, 0xB1, 0x7E, 0x49, 0x09, 0x78, 0x49, 0x1E, + 0x88, 0x42, 0x01, 0xD1, + 0x01, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x01, 0x78, 0x29, 0xB1, + 0x77, 0x49, 0x42, 0x78, + 0x09, 0x78, 0x49, 0x1E, 0x8A, 0x42, 0x09, 0xD1, 0x81, 0x78, 0x29, 0xB1, + 0xC1, 0x78, 0x74, 0x48, + 0x00, 0x78, 0x40, 0x1E, 0x81, 0x42, 0x01, 0xD1, 0x01, 0x20, 0x70, 0x47, + 0x00, 0x20, 0x70, 0x47, + 0xF0, 0xB5, 0x70, 0x4D, 0x00, 0x22, 0x05, 0xEB, 0xC2, 0x06, 0x00, 0x23, + 0xC6, 0xE9, 0x00, 0x33, + 0x52, 0x1C, 0xD2, 0xB2, 0x17, 0x2A, 0xF6, 0xD3, 0x8A, 0x78, 0x2C, 0xE0, + 0x00, 0xEB, 0xC2, 0x03, + 0xD3, 0xE9, 0x00, 0x76, 0x57, 0xEA, 0x06, 0x03, 0x23, 0xD0, 0x74, 0x08, + 0x4F, 0xEA, 0x37, 0x03, + 0x17, 0xEB, 0x07, 0x0E, 0x46, 0xEB, 0x06, 0x0C, 0x44, 0xEA, 0x0C, 0x04, + 0x34, 0x43, 0x43, 0xEA, + 0x0E, 0x03, 0x05, 0xEB, 0xC2, 0x06, 0x3B, 0x43, 0xD6, 0xE9, 0x00, 0x7C, + 0x1F, 0x43, 0x4C, 0xEA, + 0x04, 0x0C, 0xC6, 0xE9, 0x00, 0x7C, 0xD6, 0xE9, 0x02, 0x7C, 0x1F, 0x43, + 0x4C, 0xEA, 0x04, 0x0C, + 0xC6, 0xE9, 0x02, 0x7C, 0xD6, 0xE9, 0x04, 0x7C, 0x1F, 0x43, 0x4C, 0xEA, + 0x04, 0x0C, 0xC6, 0xE9, + 0x04, 0x7C, 0x52, 0x1C, 0xD2, 0xB2, 0xCB, 0x78, 0x93, 0x42, 0xCF, 0xD2, + 0x00, 0x22, 0x50, 0x4B, + 0x0A, 0xE0, 0x00, 0xBF, 0x05, 0xEB, 0xC2, 0x04, 0x00, 0xEB, 0xC2, 0x07, + 0xD4, 0xE9, 0x02, 0x64, + 0xC7, 0xE9, 0x00, 0x64, 0x52, 0x1C, 0xD2, 0xB2, 0x1C, 0x78, 0xA2, 0x42, + 0xF2, 0xD3, 0x08, 0x78, + 0x08, 0xB1, 0x40, 0x1E, 0x08, 0x70, 0x45, 0x4A, 0x48, 0x78, 0x12, 0x78, + 0x52, 0x1E, 0x90, 0x42, + 0x01, 0xDA, 0x40, 0x1C, 0x48, 0x70, 0x88, 0x78, 0x08, 0xB1, 0x40, 0x1E, + 0x88, 0x70, 0x1A, 0x78, + 0xC8, 0x78, 0x52, 0x1E, 0x90, 0x42, 0x01, 0xDA, 0x40, 0x1C, 0xC8, 0x70, + 0xF0, 0xBD, 0x2D, 0xE9, + 0xFF, 0x5F, 0x94, 0x78, 0x16, 0x46, 0x04, 0xEB, 0x84, 0x02, 0x8B, 0x46, + 0x00, 0xEB, 0xC2, 0x00, + 0x00, 0x21, 0x00, 0xF1, 0x29, 0x08, 0x20, 0xE0, 0x00, 0x20, 0x81, 0x46, + 0x82, 0x46, 0x35, 0x78, + 0x77, 0x78, 0x0F, 0xE0, 0x18, 0xF8, 0x05, 0x20, 0x5A, 0x45, 0x09, 0xD1, + 0x2A, 0x46, 0x01, 0x20, + 0x00, 0x21, 0x08, 0xF0, 0xEB, 0xFA, 0x41, 0xEA, 0x0A, 0x0A, 0x40, 0xEA, + 0x09, 0x09, 0x01, 0x21, + 0x6D, 0x1C, 0xED, 0xB2, 0xAF, 0x42, 0xED, 0xD2, 0x03, 0x9B, 0x08, 0xF1, + 0x28, 0x08, 0x03, 0xEB, + 0xC4, 0x03, 0x64, 0x1C, 0xC3, 0xE9, 0x00, 0x9A, 0xE4, 0xB2, 0xF0, 0x78, + 0xA0, 0x42, 0xDB, 0xD2, + 0x04, 0xB0, 0x08, 0x46, 0xBD, 0xE8, 0xF0, 0x9F, 0x0A, 0x78, 0x43, 0x78, + 0x9A, 0x42, 0x0B, 0xD8, + 0x4A, 0x78, 0x03, 0x78, 0x9A, 0x42, 0x07, 0xD3, 0x8A, 0x78, 0xC3, 0x78, + 0x9A, 0x42, 0x03, 0xD8, + 0xC9, 0x78, 0x80, 0x78, 0x81, 0x42, 0x01, 0xD2, 0x00, 0x20, 0x70, 0x47, + 0x01, 0x20, 0x70, 0x47, + 0x70, 0xB5, 0x0C, 0x78, 0x8B, 0x78, 0x4D, 0x78, 0xC9, 0x78, 0x9A, 0xB1, + 0x0C, 0xB1, 0x64, 0x1E, + 0xE4, 0xB2, 0x12, 0x4A, 0x12, 0x78, 0x52, 0x1E, 0x95, 0x42, 0x01, 0xDA, + 0x6D, 0x1C, 0xED, 0xB2, + 0x0B, 0xB1, 0x5B, 0x1E, 0xDB, 0xB2, 0x0E, 0x4A, 0x12, 0x78, 0x52, 0x1E, + 0x91, 0x42, 0x01, 0xDA, + 0x49, 0x1C, 0xC9, 0xB2, 0x03, 0xEB, 0x83, 0x02, 0x00, 0xEB, 0xC2, 0x02, + 0x00, 0x26, 0x29, 0x32, + 0x09, 0xE0, 0x20, 0x46, 0x02, 0xE0, 0x16, 0x54, 0x40, 0x1C, 0xC0, 0xB2, + 0xA8, 0x42, 0xFA, 0xD9, + 0x5B, 0x1C, 0xDB, 0xB2, 0x28, 0x32, 0x8B, 0x42, 0xF3, 0xD9, 0x70, 0xBD, + 0xEE, 0x06, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0x40, 0x47, 0x10, 0x00, 0x2D, 0xE9, 0xF0, 0x47, + 0xDF, 0xF8, 0xA0, 0x90, + 0x80, 0x46, 0x0C, 0x78, 0x99, 0xF8, 0x00, 0x00, 0x0D, 0x46, 0x80, 0x1E, + 0x01, 0x2C, 0x05, 0xD9, + 0x69, 0x78, 0x81, 0x42, 0x02, 0xDA, 0x00, 0x20, 0xBD, 0xE8, 0xF0, 0x87, + 0x02, 0x2C, 0x01, 0xD2, + 0x02, 0x27, 0x01, 0xE0, 0x6F, 0x78, 0xC4, 0xB2, 0x4F, 0xF0, 0x00, 0x0A, + 0xA9, 0x78, 0xD8, 0xF8, + 0x08, 0x00, 0x08, 0xF0, 0x2B, 0xFC, 0x06, 0x46, 0xA9, 0x78, 0xD8, 0xF8, + 0x04, 0x00, 0x08, 0xF0, + 0x25, 0xFC, 0xAA, 0x78, 0x01, 0x46, 0xED, 0x78, 0x99, 0xF8, 0x00, 0x30, + 0x13, 0xE0, 0x20, 0x46, + 0x0A, 0xE0, 0x00, 0xBF, 0x36, 0xF9, 0x10, 0xC0, 0x31, 0xF9, 0x10, 0x80, + 0xC4, 0x45, 0x02, 0xD0, + 0x4F, 0xF0, 0x01, 0x0A, 0x02, 0xE0, 0x40, 0x1C, 0xB8, 0x42, 0xF3, 0xD9, + 0x06, 0xEB, 0x43, 0x06, + 0x01, 0xEB, 0x43, 0x01, 0x52, 0x1C, 0x95, 0x42, 0xE9, 0xD2, 0x50, 0x46, + 0xCC, 0xE7, 0x08, 0x49, + 0x09, 0x78, 0x49, 0x1E, 0xCA, 0xB2, 0x90, 0xF8, 0x3E, 0x10, 0x09, 0xB1, + 0x91, 0x42, 0x05, 0xD1, + 0x81, 0x8C, 0x41, 0xF0, 0x04, 0x01, 0x81, 0x84, 0x01, 0x20, 0x70, 0x47, + 0x00, 0x20, 0x70, 0x47, + 0xEE, 0x06, 0x10, 0x00, 0x30, 0xB5, 0xB0, 0xB1, 0x88, 0x42, 0x14, 0xD0, + 0x02, 0xD2, 0x0A, 0x46, + 0x01, 0x46, 0x10, 0x46, 0xDE, 0x4A, 0x53, 0x68, 0x03, 0xEB, 0x40, 0x03, + 0x1C, 0x78, 0x8C, 0x42, + 0x09, 0xD0, 0x5C, 0x78, 0x8C, 0x42, 0x06, 0xD0, 0x95, 0x68, 0x2A, 0x5C, + 0x02, 0x2A, 0x02, 0xD2, + 0x54, 0x1C, 0x2C, 0x54, 0x99, 0x54, 0x08, 0x46, 0x30, 0xBD, 0xF0, 0xB5, + 0x03, 0xEB, 0x82, 0x04, + 0xA5, 0x78, 0x05, 0xEB, 0x85, 0x06, 0x00, 0xEB, 0xC6, 0x06, 0xE0, 0x78, + 0x28, 0x36, 0xA8, 0x42, + 0x0F, 0xD3, 0x20, 0x78, 0x07, 0xE0, 0x37, 0x18, 0x97, 0xF8, 0x01, 0xC0, + 0x94, 0x45, 0x00, 0xD1, + 0x79, 0x70, 0x40, 0x1C, 0xC0, 0xB2, 0x67, 0x78, 0x87, 0x42, 0xF4, 0xD2, + 0x6D, 0x1C, 0xED, 0xB2, + 0xEB, 0xE7, 0x03, 0xEB, 0x81, 0x00, 0x25, 0x68, 0x05, 0x60, 0x03, 0xEB, + 0x42, 0x00, 0x03, 0xEB, + 0x41, 0x01, 0x30, 0xF8, 0xB4, 0x2F, 0xA1, 0xF8, 0xB4, 0x20, 0xC2, 0x49, + 0x09, 0x68, 0x21, 0x60, + 0x00, 0x21, 0x01, 0x80, 0x93, 0xF8, 0x0E, 0x01, 0x40, 0x1E, 0x83, 0xF8, + 0x0E, 0x01, 0xF0, 0xBD, + 0x2D, 0xE9, 0xFF, 0x4F, 0x88, 0x46, 0x08, 0x46, 0x09, 0x78, 0x8F, 0xB0, + 0xFF, 0x29, 0x13, 0xD0, + 0x8A, 0x46, 0xB9, 0x49, 0x42, 0x78, 0x09, 0x78, 0x8A, 0x42, 0x00, 0xD2, + 0x51, 0x1C, 0xCE, 0xB2, + 0xB6, 0x49, 0x90, 0xF8, 0x02, 0x90, 0xC0, 0x78, 0x09, 0x78, 0x88, 0x42, + 0x01, 0xD2, 0x40, 0x1C, + 0x00, 0xE0, 0x08, 0x46, 0xC7, 0xB2, 0x04, 0xE0, 0x4F, 0xF0, 0x00, 0x0A, + 0x56, 0x46, 0xD1, 0x46, + 0x57, 0x46, 0x11, 0x98, 0x4F, 0xF0, 0x00, 0x0B, 0x08, 0xB1, 0x98, 0xF8, + 0x0E, 0xB1, 0xA8, 0x4A, + 0x11, 0x68, 0x01, 0xF1, 0x5A, 0x00, 0xC2, 0xE9, 0x01, 0x10, 0x02, 0x46, + 0x5F, 0xF0, 0x2C, 0x00, + 0x00, 0x23, 0x01, 0xF8, 0x10, 0x00, 0x13, 0x54, 0x40, 0x1E, 0xC0, 0xB2, + 0xF8, 0xD2, 0x0B, 0xF1, + 0x01, 0x00, 0x0D, 0x90, 0xC0, 0xB2, 0x06, 0x90, 0x0F, 0x98, 0x09, 0xEB, + 0x89, 0x01, 0x00, 0xEB, + 0xC1, 0x05, 0x09, 0xF1, 0x01, 0x00, 0x09, 0x95, 0x39, 0xE0, 0x00, 0xBF, + 0x0A, 0xF1, 0x01, 0x00, + 0x0A, 0x95, 0xC4, 0xB2, 0x28, 0x35, 0x2E, 0xE0, 0x29, 0x19, 0x08, 0x68, + 0xE0, 0xB1, 0x28, 0x5D, + 0x38, 0xB3, 0x11, 0xF8, 0x01, 0x1C, 0x00, 0x20, 0x01, 0xB1, 0x08, 0x46, + 0x0A, 0x99, 0x09, 0x5D, + 0x09, 0xB1, 0xFF, 0xF7, 0x57, 0xFF, 0x12, 0x99, 0x61, 0xB1, 0x0A, 0x99, + 0x21, 0x44, 0x0E, 0x91, + 0x11, 0xF8, 0x01, 0x1C, 0x09, 0xB1, 0xFF, 0xF7, 0x4D, 0xFF, 0x0E, 0x99, + 0x49, 0x78, 0x09, 0xB1, + 0xFF, 0xF7, 0x48, 0xFF, 0x18, 0xB1, 0x0B, 0xE0, 0xE4, 0x1C, 0xE4, 0xB2, + 0x09, 0xE0, 0x06, 0x98, + 0x2D, 0x28, 0x03, 0xD2, 0x41, 0x1C, 0xC9, 0xB2, 0x06, 0x91, 0x01, 0xE0, + 0x40, 0x1E, 0xC0, 0xB2, + 0x28, 0x55, 0x64, 0x1C, 0xE4, 0xB2, 0xB4, 0x42, 0xCE, 0xD9, 0x07, 0x98, + 0x40, 0x1C, 0xC0, 0xB2, + 0x07, 0x90, 0xB8, 0x42, 0xC2, 0xD9, 0x06, 0x98, 0x00, 0xF0, 0x99, 0xF8, + 0x06, 0x90, 0x0D, 0x98, + 0x00, 0x22, 0xC0, 0xB2, 0x77, 0x4C, 0x09, 0xE0, 0x08, 0xEB, 0x80, 0x03, + 0x21, 0x68, 0x19, 0x60, + 0x08, 0xEB, 0x40, 0x01, 0x40, 0x1C, 0xA1, 0xF8, 0xB4, 0x20, 0xC0, 0xB2, + 0x06, 0x99, 0x88, 0x42, + 0xF2, 0xD3, 0x09, 0x98, 0x4D, 0x46, 0x28, 0x30, 0x00, 0x90, 0x39, 0xE0, + 0x54, 0x46, 0x30, 0xE0, + 0x20, 0x44, 0x01, 0x21, 0x09, 0x58, 0xE9, 0xB3, 0x41, 0x78, 0x41, 0xB3, + 0x68, 0x4A, 0x52, 0x68, + 0x12, 0xF8, 0x11, 0x10, 0x41, 0x70, 0x08, 0xEB, 0x41, 0x00, 0x08, 0xEB, + 0x81, 0x09, 0x30, 0xF8, + 0xB4, 0x2F, 0x52, 0x1C, 0x02, 0x80, 0x99, 0xF8, 0x00, 0x10, 0x20, 0x46, + 0x04, 0xF0, 0xEC, 0xF9, + 0x89, 0xF8, 0x00, 0x00, 0x99, 0xF8, 0x01, 0x10, 0x20, 0x46, 0x04, 0xF0, + 0xE9, 0xF9, 0x89, 0xF8, + 0x01, 0x00, 0x99, 0xF8, 0x02, 0x10, 0x28, 0x46, 0x04, 0xF0, 0xDE, 0xF9, + 0x89, 0xF8, 0x02, 0x00, + 0x99, 0xF8, 0x03, 0x10, 0x28, 0x46, 0x04, 0xF0, 0xDB, 0xF9, 0x89, 0xF8, + 0x03, 0x00, 0x64, 0x1C, + 0xE4, 0xB2, 0x00, 0x98, 0xB4, 0x42, 0xCB, 0xD3, 0x28, 0x30, 0x6D, 0x1C, + 0xED, 0xB2, 0x00, 0x90, + 0xBD, 0x42, 0xC3, 0xD3, 0x06, 0x98, 0x40, 0x1E, 0xC2, 0xB2, 0x88, 0xF8, + 0x0E, 0x21, 0x11, 0x98, + 0x00, 0x28, 0x00, 0xE0, 0x0B, 0xE0, 0x0D, 0xD0, 0xA2, 0xEB, 0x0B, 0x00, + 0x01, 0x28, 0x09, 0xD1, + 0x11, 0x99, 0x0F, 0x98, 0x13, 0xB0, 0x43, 0x46, 0xBD, 0xE8, 0xF0, 0x4F, + 0xDD, 0xE6, 0xE4, 0x1C, + 0xE4, 0xB2, 0xDC, 0xE7, 0x13, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0xF0, 0xB5, + 0x02, 0xEB, 0x81, 0x03, + 0x00, 0x26, 0x9D, 0x78, 0x18, 0xE0, 0x00, 0xBF, 0x05, 0xEB, 0x85, 0x04, + 0x00, 0xEB, 0xC4, 0x07, + 0x1C, 0x78, 0x28, 0x37, 0x0A, 0xE0, 0x00, 0xBF, 0x07, 0xEB, 0x04, 0x0C, + 0x9C, 0xF8, 0x01, 0xE0, + 0x8E, 0x45, 0x01, 0xD1, 0x8C, 0xF8, 0x01, 0x60, 0x64, 0x1C, 0xE4, 0xB2, + 0x93, 0xF8, 0x01, 0xC0, + 0xA4, 0x45, 0xF1, 0xD2, 0x6D, 0x1C, 0xED, 0xB2, 0xDC, 0x78, 0xAC, 0x42, + 0xE4, 0xD2, 0x31, 0x48, + 0x00, 0x68, 0x18, 0x60, 0x02, 0xEB, 0x41, 0x00, 0xA0, 0xF8, 0xB4, 0x60, + 0xF0, 0xBD, 0x2D, 0xE9, + 0xF0, 0x5F, 0x07, 0x46, 0x00, 0x25, 0xDF, 0xF8, 0xA8, 0xB0, 0x2C, 0xE0, + 0xDB, 0xF8, 0x08, 0x10, + 0x4E, 0x5D, 0xDB, 0xF8, 0x04, 0x10, 0x01, 0xEB, 0x45, 0x0A, 0x1A, 0xE0, + 0x0A, 0xEB, 0x06, 0x00, + 0x80, 0x46, 0x10, 0xF8, 0x01, 0x1C, 0x10, 0xF8, 0x02, 0x9C, 0x08, 0x46, + 0x00, 0xF0, 0x35, 0xF8, + 0x04, 0x46, 0x48, 0x46, 0x00, 0xF0, 0x31, 0xF8, 0x84, 0x42, 0x02, 0xD2, + 0x01, 0x46, 0x20, 0x46, + 0x0C, 0x46, 0xDB, 0xF8, 0x04, 0x10, 0x76, 0x1E, 0xF6, 0xB2, 0x01, 0xF8, + 0x10, 0x40, 0x08, 0xF8, + 0x02, 0x4C, 0x01, 0x2E, 0xE2, 0xD8, 0x04, 0xD1, 0x28, 0x46, 0x00, 0xF0, + 0x1E, 0xF8, 0x8A, 0xF8, + 0x00, 0x00, 0x6D, 0x1C, 0xED, 0xB2, 0xBD, 0x42, 0xD0, 0xD3, 0x00, 0x21, + 0x08, 0x46, 0xDB, 0xF8, + 0x04, 0x40, 0x0D, 0xE0, 0x04, 0xEB, 0x40, 0x02, 0x13, 0x78, 0x83, 0x42, + 0x03, 0xD1, 0x11, 0x70, + 0x49, 0x1C, 0xC9, 0xB2, 0x02, 0xE0, 0x14, 0xF8, 0x13, 0x30, 0x13, 0x70, + 0x40, 0x1C, 0xC0, 0xB2, + 0xB8, 0x42, 0xEF, 0xD3, 0x08, 0x46, 0xBD, 0xE8, 0xF0, 0x9F, 0x05, 0x4A, + 0xD2, 0xE9, 0x01, 0x12, + 0x02, 0xE0, 0x00, 0xBF, 0x11, 0xF8, 0x10, 0x00, 0x13, 0x5C, 0x00, 0x2B, + 0xFA, 0xD1, 0x70, 0x47, + 0x60, 0x06, 0x10, 0x00, 0x36, 0x7A, 0x01, 0x00, 0xEE, 0x06, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0xF0, 0xB5, 0xB2, 0xF9, 0x00, 0x40, 0x06, 0x68, 0xB4, 0x42, 0x02, 0xDD, + 0xB3, 0xF9, 0x00, 0x10, + 0x30, 0xE0, 0x02, 0xEB, 0x41, 0x04, 0x34, 0xF9, 0x02, 0x5C, 0xB5, 0x42, + 0x04, 0xDA, 0x03, 0xEB, + 0x41, 0x01, 0x31, 0xF9, 0x02, 0x1C, 0x25, 0xE0, 0x00, 0x25, 0x2C, 0x46, + 0x4F, 0x1E, 0x0C, 0xE0, + 0x32, 0xF9, 0x14, 0xC0, 0xB4, 0x45, 0x07, 0xDC, 0x02, 0xEB, 0x44, 0x0C, + 0xBC, 0xF9, 0x02, 0xC0, + 0xB4, 0x45, 0x01, 0xDB, 0x25, 0x46, 0x0C, 0x46, 0x64, 0x1C, 0xBC, 0x42, + 0xF0, 0xDB, 0x32, 0xF9, + 0x15, 0x40, 0x03, 0xEB, 0x45, 0x01, 0x33, 0xF9, 0x15, 0x30, 0xB1, 0xF9, + 0x02, 0x10, 0x02, 0xEB, + 0x45, 0x02, 0x36, 0x1B, 0xC9, 0x1A, 0xB2, 0xF9, 0x02, 0x20, 0x71, 0x43, + 0x12, 0x1B, 0x91, 0xFB, + 0xF2, 0xF1, 0x19, 0x44, 0x01, 0x60, 0xF0, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, + 0x07, 0x46, 0x2A, 0x48, + 0x00, 0x68, 0x00, 0xF2, 0x0F, 0x53, 0xE9, 0xB1, 0x01, 0x29, 0x22, 0xD0, + 0x02, 0x29, 0x2C, 0xD0, + 0x03, 0x29, 0x31, 0xD0, 0x04, 0x29, 0x36, 0xD0, 0x00, 0x21, 0x0C, 0x46, + 0x0E, 0xEB, 0x01, 0x00, + 0x20, 0x44, 0x64, 0x28, 0x3D, 0xDC, 0x01, 0x29, 0x03, 0xDD, 0x38, 0x1D, + 0x63, 0x46, 0xFF, 0xF7, + 0xA7, 0xFF, 0x01, 0x2C, 0x35, 0xDD, 0x38, 0x46, 0x33, 0x46, 0x2A, 0x46, + 0x21, 0x46, 0xBD, 0xE8, + 0xF0, 0x41, 0x9D, 0xE7, 0x90, 0xF8, 0x08, 0x15, 0x90, 0xF8, 0x09, 0x45, + 0x90, 0xF8, 0x0A, 0xE5, + 0x05, 0xE0, 0x90, 0xF8, 0x08, 0x15, 0x90, 0xF8, 0x09, 0x45, 0x90, 0xF8, + 0x0B, 0xE5, 0x9C, 0x46, + 0x03, 0xEB, 0x41, 0x06, 0x03, 0xEB, 0x4E, 0x02, 0x18, 0xE0, 0x90, 0xF8, + 0x08, 0x15, 0x90, 0xF8, + 0x09, 0x45, 0x90, 0xF8, 0x0C, 0xE5, 0xF2, 0xE7, 0x90, 0xF8, 0x08, 0x15, + 0x90, 0xF8, 0x09, 0x45, + 0x90, 0xF8, 0x0D, 0xE5, 0xEB, 0xE7, 0x90, 0xF8, 0x08, 0x15, 0x90, 0xF8, + 0x09, 0x45, 0x90, 0xF8, + 0x0E, 0x05, 0x9C, 0x46, 0x03, 0xEB, 0x41, 0x06, 0x03, 0xEB, 0x40, 0x02, + 0x02, 0xEB, 0x41, 0x05, + 0xBC, 0xE7, 0xBD, 0xE8, 0xF0, 0x81, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x30, 0xB5, 0x42, 0x78, + 0x03, 0x78, 0xCD, 0x8C, 0xD2, 0x1A, 0xC3, 0x78, 0x80, 0x78, 0x52, 0x1C, + 0x1B, 0x1A, 0x5B, 0x1C, + 0x05, 0xFB, 0x02, 0xF0, 0xD4, 0x18, 0x5D, 0x43, 0x40, 0x00, 0x6A, 0x00, + 0xB0, 0xFB, 0xF4, 0xF0, + 0xB2, 0xFB, 0xF4, 0xF2, 0x90, 0x42, 0x02, 0xD9, 0xC8, 0x85, 0x0A, 0x86, + 0x30, 0xBD, 0xCA, 0x85, + 0x08, 0x86, 0x30, 0xBD, 0x2D, 0xE9, 0xFF, 0x4F, 0x00, 0x27, 0x83, 0xB0, + 0x15, 0x46, 0x01, 0x97, + 0x00, 0x97, 0x3E, 0x46, 0x3C, 0x46, 0xBB, 0x46, 0x91, 0x78, 0x08, 0xF0, + 0x61, 0xF9, 0x82, 0x46, + 0xAB, 0x78, 0x95, 0xF8, 0x03, 0x90, 0x28, 0xE0, 0x29, 0x78, 0x95, 0xF8, + 0x01, 0xC0, 0x8E, 0x46, + 0x1D, 0xE0, 0x00, 0xBF, 0x1A, 0xF8, 0x01, 0x20, 0x04, 0x98, 0x82, 0x42, + 0x15, 0xD1, 0xA1, 0xEB, + 0x0E, 0x02, 0x52, 0x1C, 0xDD, 0xF8, 0x00, 0x80, 0xA9, 0xEB, 0x03, 0x00, + 0x02, 0xFB, 0x02, 0x88, + 0x40, 0x1C, 0xCD, 0xF8, 0x00, 0x80, 0xDD, 0xF8, 0x04, 0x80, 0x16, 0x44, + 0x02, 0xFB, 0x00, 0x82, + 0x00, 0xFB, 0x00, 0xBB, 0x04, 0x44, 0x7F, 0x1C, 0x01, 0x92, 0x49, 0x1C, + 0xC9, 0xB2, 0x8C, 0x45, + 0xE0, 0xD2, 0x5B, 0x1C, 0x0A, 0xF1, 0x28, 0x0A, 0xDB, 0xB2, 0x99, 0x45, + 0xD4, 0xD2, 0x4F, 0xF4, + 0x7A, 0x70, 0x70, 0x43, 0x90, 0xFB, 0xF7, 0xF1, 0x4F, 0xF4, 0x7A, 0x70, + 0x60, 0x43, 0x90, 0xFB, + 0xF7, 0xF3, 0x4F, 0xF4, 0x7A, 0x72, 0x01, 0xFB, 0x04, 0xF0, 0x71, 0x43, + 0x90, 0xFB, 0xF2, 0xF7, + 0x91, 0xFB, 0xF2, 0xF6, 0x63, 0x43, 0x93, 0xFB, 0xF2, 0xF3, 0x01, 0x98, + 0x00, 0x99, 0xC0, 0x1B, + 0x89, 0x1B, 0xAB, 0xEB, 0x03, 0x02, 0x06, 0x9C, 0x8B, 0x1A, 0x00, 0xD5, + 0x5B, 0x42, 0x00, 0x28, + 0x00, 0xDA, 0x40, 0x42, 0x03, 0xEB, 0x40, 0x00, 0x11, 0x44, 0x0A, 0x18, + 0x08, 0x1A, 0x52, 0x10, + 0x40, 0x10, 0x4F, 0xF4, 0x7A, 0x71, 0x48, 0x43, 0x90, 0xFB, 0xF2, 0xF0, + 0xC0, 0xF5, 0x7A, 0x70, + 0xA0, 0x85, 0x06, 0x99, 0x07, 0xB0, 0x28, 0x46, 0xBD, 0xE8, 0xF0, 0x4F, + 0x6E, 0xE7, 0x01, 0x20, + 0x70, 0x47, 0x00, 0x00, 0x2D, 0xE9, 0xF0, 0x5F, 0x8A, 0x46, 0x0A, 0x9F, + 0x00, 0x25, 0x98, 0x46, + 0x14, 0x46, 0x83, 0x46, 0x2E, 0x46, 0x39, 0x46, 0x08, 0xF0, 0xF0, 0xF8, + 0x30, 0xF9, 0x18, 0x00, + 0xA0, 0x42, 0x2E, 0xDD, 0x78, 0x1E, 0x44, 0xB2, 0x7F, 0x1C, 0x27, 0xE0, + 0x00, 0x2C, 0x21, 0xDB, + 0xB0, 0x48, 0x00, 0x78, 0x84, 0x42, 0x1D, 0xDA, 0xE1, 0xB2, 0x58, 0x46, + 0x08, 0xF0, 0xDE, 0xF8, + 0xAD, 0x49, 0x81, 0x46, 0xA8, 0xF1, 0x01, 0x00, 0x0A, 0x78, 0x40, 0xB2, + 0x08, 0xF1, 0x01, 0x01, + 0x0D, 0xE0, 0x00, 0x28, 0x07, 0xDB, 0x90, 0x42, 0x05, 0xDA, 0x39, 0xF9, + 0x10, 0xC0, 0x3A, 0xF9, + 0x15, 0x30, 0x0C, 0xFB, 0x03, 0x66, 0x6D, 0x1C, 0x40, 0x1C, 0xED, 0xB2, + 0x40, 0xB2, 0x88, 0x42, + 0xEF, 0xDD, 0x01, 0xE0, 0xED, 0x1C, 0xED, 0xB2, 0x64, 0x1C, 0x64, 0xB2, + 0xBC, 0x42, 0xD5, 0xDD, + 0x00, 0xE0, 0x06, 0x46, 0x01, 0x20, 0x96, 0xFB, 0xF0, 0xF0, 0x00, 0xB2, + 0xBD, 0xE8, 0xF0, 0x9F, + 0x2D, 0xE9, 0xFF, 0x4F, 0x83, 0xB0, 0x91, 0x46, 0x10, 0x99, 0x08, 0x78, + 0x00, 0xB1, 0x40, 0x1E, + 0xC4, 0xB2, 0x88, 0x78, 0x00, 0xB1, 0x40, 0x1E, 0xDF, 0xF8, 0x4C, 0xA2, + 0xC5, 0xB2, 0x4A, 0x78, + 0x9A, 0xF8, 0x00, 0x00, 0x43, 0x1E, 0x9A, 0x42, 0x01, 0xDA, 0x50, 0x1C, + 0x00, 0xE0, 0x40, 0x1E, + 0xDF, 0xF8, 0x30, 0xB2, 0xC6, 0xB2, 0xC9, 0x78, 0x9B, 0xF8, 0x00, 0x00, + 0x42, 0x1E, 0x91, 0x42, + 0x01, 0xDA, 0x48, 0x1C, 0x00, 0xE0, 0x40, 0x1E, 0xC7, 0xB2, 0xCC, 0xB9, + 0xA8, 0x46, 0x12, 0xE0, + 0x01, 0x46, 0x03, 0x98, 0x08, 0xF0, 0x98, 0xF8, 0xCD, 0xE9, 0x00, 0x80, + 0x23, 0x46, 0x49, 0x46, + 0x06, 0x9A, 0x04, 0x98, 0xFF, 0xF7, 0x86, 0xFF, 0x01, 0x99, 0x21, 0xF8, + 0x14, 0x00, 0x08, 0xF1, + 0x01, 0x00, 0x00, 0xF0, 0xFF, 0x08, 0x40, 0x46, 0xB8, 0x45, 0xE9, 0xD9, + 0x64, 0x1C, 0xE4, 0xB2, + 0x79, 0x48, 0x00, 0x78, 0x40, 0x1E, 0x86, 0x42, 0x19, 0xD1, 0xA8, 0x46, + 0x12, 0xE0, 0x01, 0x46, + 0x03, 0x98, 0x08, 0xF0, 0x79, 0xF8, 0x82, 0x46, 0x33, 0x46, 0xCD, 0xF8, + 0x00, 0x80, 0x49, 0x46, + 0x06, 0x9A, 0x04, 0x98, 0xFF, 0xF7, 0x66, 0xFF, 0x2A, 0xF8, 0x16, 0x00, + 0x08, 0xF1, 0x01, 0x00, + 0x00, 0xF0, 0xFF, 0x08, 0x40, 0x46, 0xB8, 0x45, 0xE9, 0xD9, 0x76, 0x1E, + 0xF6, 0xB2, 0xC5, 0xB9, + 0x29, 0x46, 0x03, 0x98, 0x08, 0xF0, 0x60, 0xF8, 0x82, 0x46, 0xA0, 0x46, + 0x0C, 0xE0, 0x03, 0x46, + 0x00, 0x95, 0x49, 0x46, 0x06, 0x9A, 0x04, 0x98, 0xFF, 0xF7, 0x4C, 0xFF, + 0x2A, 0xF8, 0x18, 0x00, + 0x08, 0xF1, 0x01, 0x00, 0x00, 0xF0, 0xFF, 0x08, 0x40, 0x46, 0xB0, 0x45, + 0xEF, 0xD9, 0x6D, 0x1C, + 0xED, 0xB2, 0x9B, 0xF8, 0x00, 0x00, 0x40, 0x1E, 0x87, 0x42, 0x18, 0xD1, + 0x39, 0x46, 0x03, 0x98, + 0x08, 0xF0, 0x42, 0xF8, 0x82, 0x46, 0xA0, 0x46, 0x0C, 0xE0, 0x03, 0x46, + 0x00, 0x97, 0x49, 0x46, + 0x06, 0x9A, 0x04, 0x98, 0xFF, 0xF7, 0x2E, 0xFF, 0x2A, 0xF8, 0x18, 0x00, + 0x08, 0xF1, 0x01, 0x00, + 0x00, 0xF0, 0xFF, 0x08, 0x40, 0x46, 0xB0, 0x45, 0xEF, 0xD9, 0x7F, 0x1E, + 0xFF, 0xB2, 0xB9, 0xF9, + 0x12, 0x00, 0x5F, 0xEA, 0x00, 0x0A, 0x64, 0xD1, 0x4F, 0xF0, 0x01, 0x0A, + 0x61, 0xE0, 0x29, 0x46, + 0x03, 0x98, 0x08, 0xF0, 0x21, 0xF8, 0x01, 0x90, 0x68, 0x1E, 0xC1, 0xB2, + 0x04, 0x98, 0x08, 0xF0, + 0x0D, 0xF8, 0x00, 0x90, 0x29, 0x46, 0x04, 0x98, 0x08, 0xF0, 0x08, 0xF8, + 0x21, 0x46, 0x4C, 0xE0, + 0x30, 0xF9, 0x11, 0x20, 0x06, 0x9B, 0x9A, 0x42, 0x42, 0xDD, 0x00, 0x9A, + 0xB9, 0xF9, 0x00, 0x80, + 0x02, 0xEB, 0x41, 0x02, 0x00, 0x23, 0x32, 0xF9, 0x02, 0xCD, 0x0C, 0xFB, + 0x08, 0x33, 0xB2, 0xF9, + 0x02, 0xC0, 0xB9, 0xF9, 0x02, 0x80, 0x0C, 0xFB, 0x08, 0x33, 0xB2, 0xF9, + 0x04, 0xC0, 0xB9, 0xF9, + 0x04, 0x80, 0x0C, 0xFB, 0x08, 0x3B, 0x34, 0x4B, 0xB9, 0xF9, 0x06, 0x80, + 0x93, 0xF8, 0x00, 0xE0, + 0x02, 0xEB, 0x4E, 0x02, 0xB2, 0xF9, 0x00, 0xC0, 0x0C, 0xFB, 0x08, 0xB3, + 0xB2, 0xF9, 0x02, 0xC0, + 0xB9, 0xF9, 0x08, 0x80, 0x0C, 0xFB, 0x08, 0x33, 0xB2, 0xF9, 0x04, 0xC0, + 0xB9, 0xF9, 0x0A, 0x80, + 0x02, 0xEB, 0x4E, 0x02, 0x0C, 0xFB, 0x08, 0x3B, 0xB2, 0xF9, 0x00, 0xC0, + 0xB9, 0xF9, 0x0C, 0x80, + 0x0C, 0xFB, 0x08, 0xB3, 0xB2, 0xF9, 0x02, 0xC0, 0xB9, 0xF9, 0x0E, 0x80, + 0x0C, 0xFB, 0x08, 0x33, + 0xB2, 0xF9, 0x04, 0xC0, 0xB9, 0xF9, 0x10, 0x20, 0x0C, 0xFB, 0x02, 0x32, + 0x92, 0xFB, 0xFA, 0xF2, + 0x01, 0x9B, 0x23, 0xF8, 0x11, 0x20, 0x49, 0x1C, 0xC9, 0xB2, 0xB1, 0x42, + 0xB0, 0xD9, 0x6D, 0x1C, + 0xED, 0xB2, 0xBD, 0x42, 0x9B, 0xD9, 0x07, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, + 0x1C, 0xB5, 0x17, 0x4C, + 0x24, 0x68, 0x01, 0x94, 0x01, 0xAC, 0x00, 0x94, 0xFF, 0xF7, 0xF2, 0xFE, + 0x1C, 0xBD, 0x38, 0xB5, + 0x16, 0x4D, 0x00, 0x90, 0x12, 0x48, 0x0C, 0x46, 0x12, 0x4A, 0x00, 0x68, + 0xB0, 0xF9, 0xE2, 0x32, + 0x11, 0x48, 0x01, 0x68, 0x28, 0x68, 0xFF, 0xF7, 0xE3, 0xFE, 0x28, 0x68, + 0xA0, 0x60, 0x38, 0xBD, + 0x38, 0xB5, 0x0E, 0x4D, 0x00, 0x90, 0x0A, 0x48, 0x0C, 0x46, 0x0A, 0x4A, + 0x00, 0x68, 0x14, 0x3A, + 0xB0, 0xF9, 0xE2, 0x32, 0x08, 0x48, 0x01, 0x68, 0x28, 0x68, 0xFF, 0xF7, + 0xD1, 0xFE, 0x28, 0x68, + 0x60, 0x60, 0x38, 0xBD, 0xED, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, + 0x88, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x22, 0x7A, 0x01, 0x00, 0x10, 0x07, 0x10, 0x00, + 0x58, 0x06, 0x10, 0x00, + 0x2D, 0xE9, 0xFF, 0x5F, 0x89, 0x46, 0x14, 0x46, 0x91, 0x78, 0x0F, 0x9D, + 0x07, 0xF0, 0x68, 0xFF, + 0x82, 0x46, 0xA1, 0x78, 0xA8, 0x68, 0x07, 0xF0, 0x69, 0xFF, 0x47, 0xF6, + 0xFF, 0x76, 0xA7, 0x78, + 0xF5, 0x43, 0xFE, 0x49, 0x94, 0xF8, 0x03, 0x80, 0x91, 0xF8, 0x00, 0xB0, + 0x18, 0xE0, 0x22, 0x78, + 0x94, 0xF8, 0x01, 0xC0, 0x0D, 0xE0, 0x00, 0xBF, 0x1A, 0xF8, 0x02, 0x10, + 0x49, 0x45, 0x07, 0xD1, + 0x30, 0xF9, 0x12, 0x30, 0xB3, 0x42, 0x00, 0xDA, 0x1E, 0x46, 0xAB, 0x42, + 0x00, 0xDD, 0x1D, 0x46, + 0x52, 0x1C, 0x94, 0x45, 0xF0, 0xD2, 0x0A, 0xF1, 0x28, 0x0A, 0x00, 0xEB, + 0x4B, 0x00, 0x7F, 0x1C, + 0xB8, 0x45, 0xE4, 0xD2, 0x03, 0x98, 0x06, 0x80, 0x0E, 0x98, 0x05, 0x80, + 0xBD, 0xE8, 0xFF, 0x9F, + 0x2D, 0xE9, 0xFF, 0x4F, 0xEA, 0x48, 0x85, 0xB0, 0x9A, 0x46, 0x04, 0x68, + 0x03, 0xA9, 0xCD, 0xE9, + 0x00, 0x1A, 0xDD, 0xE9, 0x05, 0x01, 0x15, 0x46, 0x04, 0xF5, 0x88, 0x79, + 0x02, 0xAB, 0xFF, 0xF7, + 0xB7, 0xFF, 0xE4, 0x48, 0xBD, 0xF9, 0x0C, 0x20, 0xDF, 0xF8, 0x8C, 0xB3, + 0x00, 0x68, 0x5F, 0x46, + 0x90, 0xF8, 0xE4, 0x12, 0xBD, 0xF9, 0x08, 0x00, 0x12, 0x1A, 0x4A, 0x43, + 0x64, 0x21, 0x92, 0xFB, + 0xF1, 0xF1, 0x0E, 0x18, 0x01, 0x22, 0x29, 0x46, 0xDB, 0xF8, 0x00, 0x00, + 0xFF, 0xF7, 0x98, 0xFA, + 0xD7, 0xF8, 0x00, 0x80, 0xDD, 0xE9, 0x05, 0x07, 0x31, 0xB2, 0x01, 0x91, + 0xA9, 0x78, 0x07, 0xF0, + 0x07, 0xFF, 0x06, 0x46, 0xA9, 0x78, 0x40, 0x46, 0x07, 0xF0, 0x10, 0xFF, + 0x00, 0x90, 0xA9, 0x78, + 0xDA, 0xF8, 0x08, 0x00, 0x07, 0xF0, 0x02, 0xFF, 0x01, 0x46, 0xAA, 0x78, + 0x01, 0x23, 0xDF, 0xF8, + 0x2C, 0xE3, 0x1D, 0xE0, 0x28, 0x78, 0x0E, 0xE0, 0x16, 0xF8, 0x00, 0xC0, + 0xBC, 0x45, 0x09, 0xD1, + 0x31, 0xF9, 0x10, 0x80, 0xDD, 0xF8, 0x04, 0xC0, 0xE0, 0x45, 0x03, 0xDD, + 0xDD, 0xF8, 0x00, 0xC0, + 0x0C, 0xF8, 0x00, 0x30, 0x40, 0x1C, 0x95, 0xF8, 0x01, 0xC0, 0x84, 0x45, + 0xEC, 0xD2, 0x00, 0x98, + 0x52, 0x1C, 0x28, 0x30, 0x00, 0x90, 0x9E, 0xF8, 0x00, 0x00, 0x28, 0x36, + 0x01, 0xEB, 0x40, 0x01, + 0xE8, 0x78, 0x90, 0x42, 0xDE, 0xD2, 0x00, 0x20, 0x84, 0xF8, 0x0E, 0x01, + 0x28, 0x68, 0x20, 0x60, + 0x01, 0x23, 0x00, 0x22, 0x21, 0x46, 0x5E, 0x46, 0xDB, 0xF8, 0x00, 0x00, + 0xFF, 0xF7, 0x28, 0xFB, + 0x94, 0xF8, 0x0E, 0x01, 0x01, 0x28, 0x26, 0xD9, 0x01, 0x25, 0x1D, 0xE0, + 0x48, 0x22, 0x51, 0x46, + 0x48, 0x46, 0x07, 0xF0, 0x7F, 0xFD, 0x04, 0xEB, 0x45, 0x00, 0x04, 0xEB, + 0x85, 0x07, 0xB0, 0xF8, + 0xB4, 0x10, 0xA9, 0xF8, 0x26, 0x10, 0x49, 0x46, 0x38, 0x46, 0xFF, 0xF7, + 0x27, 0xFD, 0x3A, 0x46, + 0xE9, 0xB2, 0x4B, 0x46, 0x30, 0x68, 0xFE, 0xF7, 0x0C, 0xFB, 0x3A, 0x46, + 0xE9, 0xB2, 0x4B, 0x46, + 0x30, 0x68, 0xFE, 0xF7, 0x85, 0xFA, 0x6D, 0x1C, 0x94, 0xF8, 0x0E, 0x01, + 0xA8, 0x42, 0xDD, 0xD2, + 0x09, 0xB0, 0xBD, 0xE8, 0xF0, 0x8F, 0xDD, 0xE9, 0x05, 0x01, 0x53, 0x46, + 0x2A, 0x46, 0xFE, 0xF7, + 0x77, 0xFA, 0xF5, 0xE7, 0x2D, 0xE9, 0xFF, 0x5F, 0x06, 0x46, 0x9A, 0x48, + 0x1D, 0x46, 0x0B, 0x46, + 0x00, 0x68, 0xDD, 0xE9, 0x0F, 0xB4, 0x92, 0x46, 0x98, 0x49, 0xB0, 0xF9, + 0xE6, 0x22, 0x00, 0x92, + 0x09, 0x78, 0x11, 0xB1, 0xB0, 0xF9, 0x62, 0x03, 0x00, 0x90, 0x18, 0x46, + 0x0E, 0x99, 0x07, 0xF0, + 0x7F, 0xFE, 0x81, 0x46, 0x30, 0x46, 0x0E, 0x99, 0x07, 0xF0, 0x88, 0xFE, + 0x03, 0x90, 0xA0, 0x68, + 0x0E, 0x99, 0x07, 0xF0, 0x7B, 0xFE, 0x2C, 0x78, 0x6D, 0x78, 0x80, 0x46, + 0x5C, 0xB9, 0x99, 0xF8, + 0x00, 0x10, 0x51, 0x45, 0x06, 0xD1, 0xB8, 0xF9, 0x00, 0x10, 0x59, 0x45, + 0x02, 0xDD, 0x03, 0x99, + 0x01, 0x20, 0x08, 0x70, 0x01, 0x24, 0x81, 0x48, 0x00, 0x78, 0x40, 0x1E, + 0x85, 0x42, 0x54, 0xD1, + 0x19, 0xF8, 0x05, 0x10, 0x51, 0x45, 0x06, 0xD1, 0x38, 0xF9, 0x15, 0x10, + 0x59, 0x45, 0x02, 0xDD, + 0x03, 0x99, 0x01, 0x20, 0x48, 0x55, 0x6D, 0x1E, 0xED, 0xB2, 0x46, 0xE0, + 0x19, 0xF8, 0x04, 0x10, + 0x51, 0x45, 0x41, 0xD1, 0x38, 0xF9, 0x14, 0x00, 0x01, 0x90, 0x58, 0x45, + 0x3C, 0xDD, 0x00, 0x20, + 0x02, 0x90, 0x77, 0x49, 0x0E, 0x98, 0x22, 0x46, 0x01, 0xEB, 0xC0, 0x00, + 0x00, 0x21, 0xD0, 0xE9, + 0x00, 0x67, 0x01, 0x20, 0x07, 0xF0, 0x82, 0xFC, 0x06, 0x40, 0x0F, 0x40, + 0x3E, 0x43, 0x28, 0xD1, + 0xDD, 0xE9, 0x00, 0x01, 0x08, 0xEB, 0x44, 0x02, 0x08, 0x44, 0x32, 0xF9, + 0x02, 0x1C, 0x00, 0xB2, + 0x81, 0x42, 0x05, 0xDD, 0xB2, 0xF9, 0x02, 0x30, 0x83, 0x42, 0x01, 0xDD, + 0x01, 0x23, 0x02, 0x93, + 0x01, 0x2C, 0x09, 0xD9, 0x32, 0xF9, 0x04, 0x3C, 0x83, 0x42, 0x05, 0xDD, + 0xB2, 0xF9, 0x02, 0x30, + 0x83, 0x42, 0x01, 0xDD, 0x01, 0x23, 0x02, 0x93, 0x5C, 0x4B, 0x1B, 0x78, + 0x9B, 0x1E, 0x9C, 0x42, + 0x05, 0xD2, 0x81, 0x42, 0x03, 0xDD, 0xB2, 0xF9, 0x04, 0x10, 0x81, 0x42, + 0x04, 0xDC, 0x02, 0x98, + 0x10, 0xB9, 0x03, 0x99, 0x01, 0x20, 0x08, 0x55, 0x64, 0x1C, 0xAC, 0x42, + 0xB6, 0xD9, 0xCD, 0xE6, + 0x2D, 0xE9, 0xFF, 0x4F, 0xDF, 0xF8, 0x54, 0xA1, 0xDF, 0xF8, 0x48, 0x81, + 0x9B, 0xB0, 0x8B, 0x46, + 0x9A, 0xF8, 0x00, 0x10, 0x28, 0x9E, 0xD8, 0xF8, 0x00, 0x00, 0x1D, 0x46, + 0x11, 0xB1, 0x90, 0xF8, + 0x68, 0x43, 0x01, 0xE0, 0x90, 0xF8, 0xE5, 0x42, 0x4E, 0x4F, 0xAC, 0xB1, + 0x03, 0xA8, 0xCD, 0xE9, + 0x00, 0x06, 0x02, 0xAB, 0x2A, 0x46, 0x58, 0x46, 0x1D, 0x99, 0xFF, 0xF7, + 0x79, 0xFE, 0xBD, 0xF9, + 0x0C, 0x00, 0xBD, 0xF9, 0x08, 0x10, 0x40, 0x1A, 0x60, 0x43, 0x64, 0x21, + 0x90, 0xFB, 0xF1, 0xF0, + 0x39, 0x88, 0x08, 0x44, 0x00, 0xB2, 0x01, 0xE0, 0xB7, 0xF9, 0x00, 0x00, + 0x42, 0x49, 0x81, 0x46, + 0x38, 0x88, 0x08, 0x80, 0x41, 0x49, 0xA1, 0xF8, 0x00, 0x90, 0xD8, 0xF8, + 0x00, 0x00, 0xB0, 0xF9, + 0xE6, 0x12, 0x11, 0x91, 0xB0, 0xF9, 0xE8, 0x12, 0x0C, 0x91, 0x9A, 0xF8, + 0x00, 0x10, 0x29, 0xB1, + 0xB0, 0xF9, 0x62, 0x13, 0x11, 0x91, 0xB0, 0xF9, 0x64, 0x03, 0x0C, 0x90, + 0xAC, 0x78, 0x95, 0xF8, + 0x03, 0x80, 0x4C, 0xB9, 0xCD, 0xE9, 0x00, 0x49, 0x02, 0x96, 0x2B, 0x46, + 0x59, 0x46, 0x1D, 0x9A, + 0x1B, 0x98, 0xFF, 0xF7, 0x1F, 0xFF, 0x01, 0x24, 0x31, 0x49, 0x09, 0x78, + 0x49, 0x1E, 0x88, 0x45, + 0x0D, 0xD1, 0xCD, 0xF8, 0x00, 0x80, 0xCD, 0xE9, 0x01, 0x96, 0x2B, 0x46, + 0x59, 0x46, 0x1D, 0x9A, + 0x1B, 0x98, 0xFF, 0xF7, 0x0F, 0xFF, 0xA8, 0xF1, 0x01, 0x00, 0x00, 0xF0, + 0xFF, 0x08, 0xA0, 0x1E, + 0xC1, 0xB2, 0xB0, 0x68, 0x07, 0xF0, 0xA2, 0xFD, 0x0D, 0x90, 0x60, 0x1E, + 0xC1, 0xB2, 0xB0, 0x68, + 0x07, 0xF0, 0x9C, 0xFD, 0x03, 0x90, 0x21, 0x46, 0xB0, 0x68, 0x07, 0xF0, + 0x97, 0xFD, 0x02, 0x90, + 0x60, 0x1C, 0xC1, 0xB2, 0xB0, 0x68, 0x07, 0xF0, 0x91, 0xFD, 0x01, 0x90, + 0xA0, 0x1C, 0xC1, 0xB2, + 0xB0, 0x68, 0x07, 0xF0, 0x8B, 0xFD, 0x04, 0x90, 0x21, 0x46, 0x58, 0x46, + 0x07, 0xF0, 0x80, 0xFD, + 0x83, 0x46, 0x21, 0x46, 0x1B, 0x98, 0x07, 0xF0, 0x89, 0xFD, 0x05, 0x90, + 0x00, 0x20, 0x14, 0x90, + 0x01, 0x20, 0x13, 0x90, 0x00, 0x20, 0x12, 0x90, 0x0A, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x40, 0x14, + 0xCA, 0x07, 0x29, 0xD0, 0x09, 0x07, 0x27, 0xD5, 0x69, 0x78, 0x2A, 0x78, + 0x8A, 0x1A, 0x90, 0xF8, + 0x49, 0x14, 0x52, 0x1C, 0x8A, 0x42, 0x1F, 0xDC, 0xEA, 0x78, 0x13, 0xE0, + 0xEE, 0x06, 0x10, 0x00, + 0x6C, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x54, 0x06, 0x10, 0x00, + 0xFD, 0x06, 0x10, 0x00, + 0x98, 0x46, 0x10, 0x00, 0x92, 0x06, 0x10, 0x00, 0x8E, 0x07, 0x10, 0x00, + 0x90, 0x07, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, 0xAB, 0x78, 0xD2, 0x1A, 0x52, 0x1C, 0x8A, 0x42, + 0x04, 0xDC, 0xB0, 0xF8, + 0x47, 0x04, 0xB1, 0x69, 0x81, 0x42, 0x01, 0xDD, 0x00, 0x20, 0x13, 0x90, + 0xA2, 0x46, 0xF1, 0xE0, + 0x2C, 0x78, 0xCE, 0xE0, 0x1B, 0xF8, 0x04, 0x10, 0x1D, 0x98, 0x81, 0x42, + 0x6B, 0xD1, 0x00, 0x20, + 0x10, 0x90, 0xFB, 0x49, 0x16, 0x90, 0x15, 0x90, 0x01, 0xEB, 0xCA, 0x00, + 0x22, 0x46, 0xD0, 0xE9, + 0x00, 0x67, 0x01, 0x20, 0x00, 0x21, 0x07, 0xF0, 0x71, 0xFB, 0x06, 0x40, + 0x0F, 0x40, 0x3E, 0x43, + 0x7E, 0xD1, 0xF4, 0x49, 0x40, 0xF2, 0xD2, 0x40, 0x08, 0x80, 0x02, 0x98, + 0x0C, 0x9A, 0x30, 0xF8, + 0x14, 0x10, 0x11, 0x98, 0x08, 0x44, 0x11, 0x44, 0x03, 0x9A, 0x00, 0xB2, + 0x09, 0xB2, 0x32, 0xF9, + 0x14, 0x20, 0x82, 0x42, 0x07, 0xDD, 0x01, 0x9B, 0x33, 0xF9, 0x14, 0x30, + 0x83, 0x42, 0x02, 0xDD, + 0x01, 0x23, 0x10, 0x93, 0x15, 0x93, 0xEC, 0xB3, 0xE7, 0x4B, 0x93, 0xF8, + 0x00, 0xE0, 0xAE, 0xF1, + 0x01, 0x03, 0x9C, 0x42, 0x68, 0xD0, 0x02, 0x9B, 0x03, 0xEB, 0x44, 0x0C, + 0x3C, 0xF9, 0x02, 0x6C, + 0x86, 0x42, 0x06, 0xDD, 0xBC, 0xF9, 0x02, 0x30, 0x83, 0x42, 0x02, 0xDD, + 0x01, 0x23, 0x10, 0x93, + 0x16, 0x93, 0x03, 0x9B, 0x03, 0xEB, 0x44, 0x03, 0x33, 0xF9, 0x02, 0x7C, + 0x8F, 0x42, 0x08, 0xDD, + 0x01, 0x9F, 0x07, 0xEB, 0x44, 0x07, 0xB7, 0xF9, 0x02, 0x70, 0x8F, 0x42, + 0x01, 0xDD, 0x01, 0x27, + 0x10, 0x97, 0xB3, 0xF9, 0x02, 0x30, 0x8B, 0x42, 0x06, 0xDD, 0x01, 0x9B, + 0x03, 0xEB, 0x44, 0x03, + 0x33, 0xF9, 0x02, 0x3C, 0x8B, 0x42, 0x41, 0xDC, 0x10, 0x99, 0x59, 0xB9, + 0xBA, 0xF1, 0x01, 0x0F, + 0x0F, 0xD9, 0x0D, 0x99, 0x31, 0xF9, 0x14, 0x10, 0x81, 0x42, 0x0A, 0xDD, + 0x01, 0x99, 0x31, 0xF9, + 0x14, 0x10, 0x01, 0xE0, 0x30, 0xE0, 0x5B, 0xE0, 0x81, 0x42, 0x02, 0xDD, + 0x01, 0x21, 0x10, 0x91, + 0x15, 0x91, 0xC6, 0x4B, 0x1B, 0x78, 0x9B, 0x1E, 0x9A, 0x45, 0x09, 0xD2, + 0x82, 0x42, 0x07, 0xDD, + 0x04, 0x99, 0x31, 0xF9, 0x14, 0x10, 0x81, 0x42, 0x02, 0xDD, 0x01, 0x21, + 0x10, 0x91, 0x15, 0x91, + 0x01, 0x2C, 0x0A, 0xD9, 0x3C, 0xF9, 0x04, 0x1C, 0x81, 0x42, 0x06, 0xDD, + 0xBC, 0xF9, 0x02, 0x10, + 0x81, 0x42, 0x02, 0xDD, 0x01, 0x21, 0x10, 0x91, 0x16, 0x91, 0xAE, 0xF1, + 0x02, 0x01, 0x00, 0xE0, + 0x17, 0xE0, 0x8C, 0x42, 0x08, 0xD2, 0x86, 0x42, 0x06, 0xDD, 0xBC, 0xF9, + 0x04, 0x10, 0x81, 0x42, + 0x02, 0xDD, 0x01, 0x20, 0x16, 0x90, 0x01, 0xE0, 0x10, 0x98, 0x48, 0xB1, + 0xB0, 0x49, 0x41, 0xF2, + 0xB3, 0x50, 0x08, 0x80, 0xAF, 0x48, 0xB0, 0x49, 0x04, 0x80, 0xA1, 0xF8, + 0x00, 0xA0, 0x09, 0xE0, + 0x40, 0xB9, 0x02, 0x98, 0x30, 0xF9, 0x14, 0x10, 0x49, 0x45, 0x03, 0xDD, + 0x05, 0x99, 0x01, 0x20, + 0x08, 0x55, 0x15, 0xE0, 0x16, 0x98, 0x98, 0xB1, 0x15, 0x98, 0x88, 0xB1, + 0x13, 0x98, 0x78, 0xB1, + 0x05, 0x98, 0x01, 0x21, 0x01, 0x55, 0x12, 0x98, 0x40, 0x1C, 0x80, 0xB2, + 0x12, 0x90, 0xA3, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0x4A, 0x14, 0x12, 0x98, 0x81, 0x42, 0x01, 0xD2, + 0x01, 0x20, 0x14, 0x90, + 0x64, 0x1C, 0x68, 0x78, 0xA0, 0x42, 0xBF, 0xF4, 0x2D, 0xAF, 0x97, 0x48, + 0x0D, 0x99, 0x0B, 0xF1, + 0x28, 0x0B, 0x00, 0x78, 0x0A, 0xF1, 0x01, 0x0A, 0x01, 0xEB, 0x40, 0x01, + 0x0D, 0x91, 0x03, 0x99, + 0x01, 0xEB, 0x40, 0x01, 0x03, 0x91, 0x02, 0x99, 0x01, 0xEB, 0x40, 0x01, + 0x02, 0x91, 0x01, 0x99, + 0x01, 0xEB, 0x40, 0x01, 0x01, 0x91, 0x04, 0x99, 0x01, 0xEB, 0x40, 0x00, + 0x04, 0x90, 0x05, 0x98, + 0x28, 0x30, 0x05, 0x90, 0xC2, 0x45, 0x7F, 0xF6, 0x0B, 0xAF, 0x14, 0x98, + 0x1F, 0xB0, 0xA8, 0xE5, + 0x2D, 0xE9, 0xF0, 0x47, 0x04, 0x46, 0x91, 0x42, 0x5A, 0xD0, 0x07, 0xD9, + 0x01, 0xEB, 0x02, 0x00, + 0xA0, 0xEB, 0x02, 0x01, 0xCA, 0xB2, 0xA0, 0xEB, 0x02, 0x00, 0xC1, 0xB2, + 0x01, 0xEB, 0xC1, 0x00, + 0x04, 0xEB, 0xC0, 0x01, 0x02, 0xEB, 0xC2, 0x00, 0x04, 0xEB, 0xC0, 0x00, + 0xB1, 0xF9, 0x32, 0x50, + 0xB0, 0xF9, 0x32, 0x30, 0x81, 0x46, 0x9D, 0x42, 0x00, 0xDA, 0x4B, 0x86, + 0xCB, 0x8C, 0xC5, 0x8C, + 0x2B, 0x44, 0xCB, 0x84, 0x0B, 0x8D, 0x05, 0x8D, 0x2B, 0x44, 0x0B, 0x85, + 0x4B, 0x8D, 0x45, 0x8D, + 0x2B, 0x44, 0x4B, 0x85, 0x8B, 0x69, 0x85, 0x69, 0x2B, 0x44, 0x8B, 0x61, + 0xC7, 0x69, 0xCE, 0x69, + 0xCB, 0x68, 0xD9, 0xF8, 0x0C, 0x00, 0x4F, 0xEA, 0x23, 0x4C, 0x4F, 0xEA, + 0x20, 0x48, 0x0C, 0xFB, + 0x06, 0xFC, 0xF5, 0x19, 0x07, 0xFB, 0x08, 0xCC, 0x9C, 0xFB, 0xF5, 0xFC, + 0x6C, 0xF3, 0x1F, 0x43, + 0x0F, 0xFA, 0x83, 0xFC, 0x0C, 0xFB, 0x06, 0xFC, 0x00, 0xB2, 0x07, 0xFB, + 0x00, 0xC0, 0x90, 0xFB, + 0xF5, 0xF0, 0x60, 0xF3, 0x0F, 0x03, 0xCD, 0x61, 0xCB, 0x60, 0x94, 0xF8, + 0x38, 0x04, 0x41, 0x1E, + 0x91, 0x42, 0x08, 0xD0, 0x00, 0xEB, 0xC0, 0x00, 0x04, 0xEB, 0xC0, 0x01, + 0x48, 0x46, 0x48, 0x22, + 0x48, 0x39, 0x07, 0xF0, 0xAF, 0xFA, 0x94, 0xF8, 0x38, 0x04, 0x40, 0x1E, + 0x84, 0xF8, 0x38, 0x04, + 0xBD, 0xE8, 0xF0, 0x87, 0x2D, 0xE9, 0xFE, 0x4F, 0x07, 0x46, 0x58, 0x48, + 0x8A, 0x46, 0x00, 0x25, + 0x01, 0x68, 0xB1, 0xF8, 0xEA, 0x02, 0x00, 0xFB, 0x00, 0xF9, 0x55, 0x48, + 0x00, 0x78, 0x18, 0xB1, + 0xB1, 0xF8, 0x66, 0x03, 0x00, 0xFB, 0x00, 0xF9, 0x54, 0x46, 0x4F, 0xF0, + 0x01, 0x0B, 0xB0, 0xE0, + 0x0B, 0xFA, 0x04, 0xF0, 0x26, 0x46, 0x00, 0x90, 0x66, 0xE0, 0x00, 0xBF, + 0x00, 0x99, 0x0B, 0xFA, + 0x06, 0xF0, 0x08, 0x42, 0x5F, 0xD0, 0x06, 0xEB, 0xC6, 0x00, 0x07, 0xEB, + 0xC0, 0x00, 0xC2, 0x68, + 0x20, 0x46, 0x4D, 0xE0, 0xB0, 0x42, 0x4A, 0xD0, 0x00, 0xEB, 0xC0, 0x01, + 0x07, 0xEB, 0xC1, 0x01, + 0xC9, 0x68, 0x4F, 0xEA, 0x21, 0x4C, 0xAC, 0xEB, 0x22, 0x4C, 0x89, 0x1A, + 0x0F, 0xFA, 0x8C, 0xFC, + 0x09, 0xB2, 0x6C, 0xF3, 0x1F, 0x45, 0x61, 0xF3, 0x0F, 0x05, 0x8E, 0x46, + 0x3B, 0x49, 0xCD, 0xF8, + 0x04, 0xC0, 0x09, 0x68, 0x91, 0xF8, 0xE0, 0xC2, 0xCD, 0xF8, 0x08, 0xC0, + 0x5F, 0xEA, 0x8C, 0x6C, + 0x0B, 0xD5, 0x91, 0xF8, 0xED, 0x82, 0x0E, 0xFB, 0x08, 0xFC, 0x4F, 0xF0, + 0x64, 0x08, 0x9C, 0xFB, + 0xF8, 0xF8, 0x08, 0xEB, 0x0E, 0x0C, 0x6C, 0xF3, 0x0F, 0x05, 0xDD, 0xF8, + 0x08, 0xC0, 0x5F, 0xEA, + 0xCC, 0x6C, 0x0C, 0xD5, 0x91, 0xF8, 0xED, 0x12, 0xDD, 0xF8, 0x04, 0xC0, + 0x0C, 0xFB, 0x01, 0xFC, + 0x64, 0x21, 0x9C, 0xFB, 0xF1, 0xFC, 0x01, 0x99, 0x61, 0x44, 0x61, 0xF3, + 0x1F, 0x45, 0x4F, 0xEA, + 0x25, 0x4C, 0x0C, 0xFB, 0x0C, 0xFC, 0x29, 0xB2, 0x01, 0xFB, 0x01, 0xC1, + 0x49, 0x45, 0x06, 0xD2, + 0xDD, 0xF8, 0x00, 0xC0, 0x0B, 0xFA, 0x00, 0xF1, 0x41, 0xEA, 0x0C, 0x01, + 0x00, 0x91, 0x40, 0x1C, + 0x83, 0x42, 0xAF, 0xD8, 0x04, 0x21, 0x68, 0x46, 0xF1, 0xF7, 0x3D, 0xFA, + 0x01, 0x28, 0x02, 0xD1, + 0x00, 0x98, 0x40, 0x00, 0x00, 0x90, 0x76, 0x1C, 0x97, 0xF8, 0x38, 0x34, + 0xB3, 0x42, 0x95, 0xD8, + 0x04, 0x21, 0x68, 0x46, 0xF1, 0xF7, 0x2F, 0xFA, 0x01, 0x28, 0x0B, 0xD0, + 0x04, 0x21, 0x68, 0x46, + 0xF1, 0xF7, 0x29, 0xFA, 0x97, 0xF8, 0x38, 0x64, 0xA6, 0xEB, 0x0A, 0x01, + 0x88, 0x42, 0x06, 0xD1, + 0x87, 0xF8, 0x38, 0xA4, 0xBD, 0xE8, 0xFE, 0x8F, 0x64, 0x1C, 0xE4, 0xB2, + 0x01, 0xE0, 0x00, 0x99, + 0x58, 0x46, 0x00, 0xFA, 0x04, 0xF2, 0x0A, 0x42, 0xF6, 0xD0, 0xD8, 0x46, + 0x1C, 0xE0, 0x00, 0x00, + 0x98, 0x46, 0x10, 0x00, 0x86, 0x07, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, + 0xED, 0x06, 0x10, 0x00, + 0x88, 0x07, 0x10, 0x00, 0x8A, 0x07, 0x10, 0x00, 0x8C, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xFD, 0x06, 0x10, 0x00, 0x00, 0x99, 0x08, 0xFA, 0x06, 0xF0, 0x08, 0x42, + 0x04, 0xD0, 0xF2, 0xB2, + 0x21, 0x46, 0x38, 0x46, 0xFF, 0xF7, 0xDC, 0xFE, 0x76, 0x1E, 0xA6, 0x42, + 0xF2, 0xD8, 0x64, 0x1C, + 0xE4, 0xB2, 0x97, 0xF8, 0x38, 0x04, 0xA0, 0x42, 0x3F, 0xF6, 0x4A, 0xAF, + 0xCA, 0xE7, 0x2D, 0xE9, + 0xFF, 0x4F, 0xFB, 0x48, 0xFB, 0x4C, 0x93, 0x46, 0x06, 0x68, 0x81, 0xB0, + 0x1D, 0x46, 0x06, 0xF5, + 0x88, 0x7A, 0x01, 0x22, 0x59, 0x46, 0x20, 0x68, 0xFE, 0xF7, 0x92, 0xFE, + 0x00, 0x95, 0xDD, 0xE9, + 0x01, 0x12, 0x5B, 0x46, 0x20, 0x68, 0xFF, 0xF7, 0xFB, 0xFC, 0x03, 0x00, + 0x4F, 0xF0, 0x01, 0x01, + 0x05, 0xD0, 0xF1, 0x48, 0x01, 0x70, 0xA8, 0x8C, 0x40, 0xF0, 0x80, 0x00, + 0xA8, 0x84, 0xEF, 0x48, + 0x00, 0x78, 0x50, 0xB1, 0x4B, 0xB9, 0x95, 0xF8, 0x24, 0x00, 0x10, 0xF0, + 0x06, 0x0F, 0x04, 0xD1, + 0x59, 0x46, 0x28, 0x46, 0xFE, 0xF7, 0xA8, 0xFE, 0x03, 0x46, 0x00, 0x20, + 0x86, 0xF8, 0x0E, 0x01, + 0xDB, 0xF8, 0x00, 0x00, 0x30, 0x60, 0xE3, 0x48, 0x00, 0x22, 0x31, 0x46, + 0x00, 0x68, 0xFE, 0xF7, + 0x3F, 0xFF, 0x96, 0xF8, 0x0E, 0x01, 0x00, 0x24, 0x01, 0x28, 0x79, 0xD9, + 0xFC, 0xF7, 0x61, 0xF9, + 0x81, 0x46, 0xFC, 0xF7, 0x5C, 0xF9, 0x80, 0x46, 0xDB, 0xF8, 0x00, 0x20, + 0xDD, 0xE9, 0x01, 0x01, + 0x00, 0x92, 0xDB, 0x4B, 0x6A, 0x46, 0xFE, 0xF7, 0x0A, 0xFE, 0x60, 0xB1, + 0x69, 0x46, 0xD8, 0x48, + 0xFE, 0xF7, 0x9E, 0xFD, 0x2A, 0x46, 0x69, 0x46, 0xD5, 0x48, 0xFD, 0xF7, + 0xD8, 0xFA, 0xE9, 0x68, + 0x69, 0x61, 0xE9, 0x69, 0x29, 0x62, 0x01, 0x27, 0x2F, 0xE0, 0x48, 0x22, + 0x29, 0x46, 0x50, 0x46, + 0x07, 0xF0, 0x78, 0xF9, 0xCF, 0x49, 0x06, 0xEB, 0x47, 0x00, 0x09, 0x68, + 0xB0, 0xF8, 0xB4, 0x20, + 0x91, 0xF8, 0xEC, 0x12, 0x8A, 0x42, 0x1F, 0xD9, 0xBA, 0xF8, 0x24, 0x10, + 0x41, 0xF0, 0x10, 0x02, + 0xAA, 0xF8, 0x24, 0x20, 0xB0, 0xF8, 0xB4, 0x10, 0xAA, 0xF8, 0x26, 0x10, + 0x06, 0xEB, 0x87, 0x00, + 0x51, 0x46, 0x00, 0x90, 0xFF, 0xF7, 0x12, 0xF9, 0xBE, 0x48, 0xF9, 0xB2, + 0x53, 0x46, 0x00, 0x9A, + 0x00, 0x68, 0xFD, 0xF7, 0xF6, 0xFE, 0xBB, 0x48, 0xF9, 0xB2, 0x53, 0x46, + 0x00, 0x9A, 0x00, 0x68, + 0xFD, 0xF7, 0x6E, 0xFE, 0x64, 0x1C, 0xE4, 0xB2, 0x7F, 0x1C, 0x96, 0xF8, + 0x0E, 0x01, 0xB8, 0x42, + 0xCB, 0xD2, 0xB8, 0x4E, 0x30, 0x68, 0x90, 0xF8, 0xE0, 0x02, 0x00, 0x07, + 0x0A, 0xD5, 0x01, 0x2C, + 0x08, 0xD9, 0x49, 0x46, 0x40, 0x46, 0xFF, 0xF7, 0x95, 0xFE, 0xFC, 0xF7, + 0x02, 0xF9, 0xA0, 0xEB, + 0x09, 0x00, 0xC4, 0xB2, 0x31, 0x68, 0x91, 0xF8, 0xE0, 0x02, 0x00, 0x06, + 0x13, 0xD5, 0x20, 0x46, + 0x0F, 0xE0, 0x00, 0xBF, 0x09, 0xEB, 0x00, 0x02, 0xD2, 0xB2, 0x02, 0xEB, + 0xC2, 0x03, 0x08, 0xEB, + 0xC3, 0x02, 0x91, 0xF8, 0x07, 0x33, 0xD2, 0x8C, 0x9A, 0x42, 0x02, 0xD9, + 0x88, 0xF8, 0x38, 0x94, + 0x05, 0xE0, 0x40, 0x1E, 0xEE, 0xD2, 0x01, 0x2C, 0x0A, 0xD0, 0x00, 0x2C, + 0x0E, 0xD1, 0xDD, 0xE9, + 0x01, 0x01, 0x05, 0xB0, 0x2B, 0x46, 0x5A, 0x46, 0xBD, 0xE8, 0xF0, 0x4F, + 0xFD, 0xF7, 0x30, 0xBE, + 0x98, 0xF8, 0x38, 0x04, 0x40, 0x1E, 0x88, 0xF8, 0x38, 0x04, 0xF0, 0xE7, + 0x05, 0xB0, 0xBD, 0xE8, + 0xF0, 0x8F, 0x2D, 0xE9, 0xFF, 0x4F, 0x97, 0x48, 0x81, 0xB0, 0x00, 0x68, + 0x90, 0xF8, 0xE1, 0x02, + 0xC0, 0x07, 0xF3, 0xD0, 0xA8, 0x21, 0x04, 0x98, 0x07, 0xF0, 0x58, 0xF9, + 0x01, 0x25, 0x44, 0xE0, + 0x03, 0x98, 0x00, 0xEB, 0x85, 0x00, 0x82, 0x46, 0x84, 0x78, 0x90, 0xF8, + 0x03, 0x90, 0x8E, 0x48, + 0x00, 0x78, 0x40, 0x1E, 0x84, 0x42, 0x01, 0xDA, 0x64, 0x1C, 0xE4, 0xB2, + 0xB9, 0xF1, 0x00, 0x0F, + 0x03, 0xD0, 0xA9, 0xF1, 0x01, 0x00, 0x00, 0xF0, 0xFF, 0x09, 0x21, 0x46, + 0x01, 0x98, 0x07, 0xF0, + 0x1F, 0xFA, 0x83, 0x46, 0xA0, 0x46, 0x24, 0xE0, 0x03, 0x98, 0x04, 0x99, + 0x10, 0xF8, 0x25, 0x40, + 0x01, 0xEB, 0xC8, 0x00, 0x00, 0x90, 0x12, 0xE0, 0x1B, 0xF8, 0x04, 0x00, + 0xA8, 0x42, 0x0C, 0xD1, + 0x00, 0x98, 0x22, 0x46, 0x00, 0x21, 0xD0, 0xE9, 0x00, 0x67, 0x01, 0x20, + 0x07, 0xF0, 0x4E, 0xF8, + 0x06, 0x43, 0x00, 0x98, 0x0F, 0x43, 0xC0, 0xE9, 0x00, 0x67, 0x64, 0x1C, + 0xE4, 0xB2, 0x9A, 0xF8, + 0x01, 0x00, 0xA0, 0x42, 0xE8, 0xD2, 0x08, 0xF1, 0x01, 0x00, 0x0B, 0xF1, + 0x28, 0x0B, 0x00, 0xF0, + 0xFF, 0x08, 0xC8, 0x45, 0xD8, 0xD9, 0x6D, 0x1C, 0xED, 0xB2, 0x02, 0x98, + 0x85, 0x42, 0xB7, 0xD9, + 0x00, 0x21, 0x6D, 0x4E, 0x13, 0xE0, 0x04, 0x98, 0x00, 0xEB, 0xC1, 0x05, + 0x01, 0xF1, 0x01, 0x01, + 0xD5, 0xE9, 0x00, 0x32, 0xDC, 0x18, 0x42, 0xEB, 0x02, 0x00, 0x52, 0x08, + 0x4F, 0xEA, 0x33, 0x03, + 0x04, 0xEA, 0x03, 0x04, 0x00, 0xEA, 0x02, 0x00, 0xC5, 0xE9, 0x00, 0x40, + 0xC9, 0xB2, 0x30, 0x78, + 0x81, 0x42, 0xE8, 0xD3, 0x8A, 0xE7, 0xF0, 0xB4, 0x60, 0x4D, 0x00, 0x24, + 0x2C, 0x80, 0x60, 0x4D, + 0x2C, 0x80, 0x60, 0x4D, 0x2C, 0x80, 0x60, 0x4D, 0x2C, 0x80, 0x14, 0x68, + 0xC3, 0xF8, 0x3A, 0x40, + 0x58, 0x4C, 0x25, 0x68, 0x95, 0xF8, 0xE0, 0x42, 0xA6, 0x07, 0x13, 0xD4, + 0x93, 0xF8, 0x40, 0x60, + 0x01, 0x2E, 0x0F, 0xD0, 0x66, 0x07, 0x13, 0xD5, 0x64, 0x06, 0x09, 0xD5, + 0x57, 0x4C, 0x64, 0x78, + 0x5C, 0xB1, 0xB5, 0xF8, 0xF0, 0x42, 0x56, 0x4D, 0x64, 0x43, 0x2D, 0x68, + 0xA5, 0x42, 0x07, 0xDC, + 0xF0, 0xBC, 0x94, 0xE6, 0xF0, 0xBC, 0xFF, 0xF7, 0x73, 0xBA, 0xB5, 0xF8, + 0xEE, 0x42, 0xF2, 0xE7, + 0xF0, 0xBC, 0xFD, 0xF7, 0x85, 0xBD, 0x2D, 0xE9, 0xFF, 0x4F, 0x94, 0x78, + 0xD7, 0x78, 0x15, 0x78, + 0x56, 0x78, 0x81, 0xB0, 0x98, 0x46, 0x82, 0x46, 0x04, 0xB9, 0x01, 0x24, + 0x42, 0x48, 0x00, 0x78, + 0x40, 0x1E, 0x87, 0x42, 0x01, 0xD1, 0x7F, 0x1E, 0xFF, 0xB2, 0x05, 0xB9, + 0x01, 0x25, 0xDF, 0xF8, + 0x14, 0xB1, 0x9B, 0xF8, 0x00, 0x00, 0x40, 0x1E, 0x86, 0x42, 0x01, 0xD1, + 0x76, 0x1E, 0xF6, 0xB2, + 0x60, 0x1E, 0xC1, 0xB2, 0xD8, 0xF8, 0x08, 0x00, 0x07, 0xF0, 0x88, 0xF9, + 0x00, 0x90, 0x21, 0x46, + 0xD8, 0xF8, 0x08, 0x00, 0x07, 0xF0, 0x82, 0xF9, 0x81, 0x46, 0x60, 0x1C, + 0xC1, 0xB2, 0xD8, 0xF8, + 0x08, 0x00, 0x07, 0xF0, 0x7B, 0xF9, 0x80, 0x46, 0x21, 0x46, 0x50, 0x46, + 0x07, 0xF0, 0x70, 0xF9, + 0x35, 0xE0, 0x2C, 0x4A, 0x29, 0x46, 0xD2, 0xF8, 0x00, 0xA0, 0x24, 0xE0, + 0x43, 0x5C, 0x02, 0x9A, + 0x93, 0x42, 0x1E, 0xD1, 0x39, 0xF8, 0x11, 0x30, 0x9A, 0xF8, 0x27, 0x24, + 0x1A, 0x44, 0x00, 0x9B, + 0x12, 0xB2, 0x03, 0xEB, 0x41, 0x03, 0x33, 0xF9, 0x02, 0xCC, 0x94, 0x45, + 0x05, 0xDD, 0x08, 0xEB, + 0x41, 0x0C, 0xBC, 0xF9, 0x02, 0xC0, 0x94, 0x45, 0x09, 0xDC, 0xB3, 0xF9, + 0x02, 0x30, 0x93, 0x42, + 0x07, 0xDD, 0x08, 0xEB, 0x41, 0x03, 0x33, 0xF9, 0x02, 0x3C, 0x93, 0x42, + 0x01, 0xDD, 0x01, 0x20, + 0xFC, 0xE6, 0x49, 0x1C, 0xC9, 0xB2, 0xB1, 0x42, 0xD8, 0xD9, 0xCD, 0xF8, + 0x00, 0x90, 0x9B, 0xF8, + 0x00, 0x20, 0x64, 0x1C, 0xC1, 0x46, 0x08, 0xEB, 0x42, 0x08, 0xE4, 0xB2, + 0x28, 0x30, 0xBC, 0x42, + 0xC7, 0xD9, 0x00, 0x20, 0xEA, 0xE6, 0x2D, 0xE9, 0xF8, 0x4F, 0x4F, 0xF0, + 0x00, 0x0A, 0x89, 0x46, + 0x04, 0x46, 0x01, 0x26, 0x57, 0x46, 0xD0, 0x46, 0x85, 0x78, 0x46, 0xE0, + 0x29, 0x46, 0xD9, 0xF8, + 0x08, 0x00, 0x07, 0xF0, 0x2B, 0xF9, 0x02, 0x46, 0x00, 0x20, 0x21, 0x78, + 0x63, 0x78, 0x20, 0xE0, + 0x6C, 0x06, 0x10, 0x00, 0x54, 0x06, 0x10, 0x00, 0x34, 0x06, 0x10, 0x00, + 0xA4, 0x06, 0x10, 0x00, + 0xF0, 0x45, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xED, 0x06, 0x10, 0x00, + 0x86, 0x07, 0x10, 0x00, + 0x88, 0x07, 0x10, 0x00, 0x8A, 0x07, 0x10, 0x00, 0x8C, 0x07, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0x24, 0x07, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0x32, 0xF9, 0x11, 0xC0, + 0x49, 0x1C, 0x60, 0x44, + 0xC9, 0xB2, 0x8B, 0x42, 0xF8, 0xD2, 0xA1, 0x78, 0x4A, 0x1C, 0xAA, 0x42, + 0x10, 0xD2, 0x46, 0x4A, + 0x12, 0x68, 0xB2, 0xF8, 0x28, 0x34, 0x03, 0xEB, 0x08, 0x02, 0xBA, 0x42, + 0x01, 0xDA, 0x82, 0x42, + 0x33, 0xDB, 0x89, 0x1C, 0xA9, 0x42, 0x03, 0xD2, 0x52, 0x45, 0x01, 0xDA, + 0x82, 0x42, 0x2C, 0xDB, + 0xBA, 0x46, 0x47, 0x46, 0x6D, 0x1C, 0x80, 0x46, 0xED, 0xB2, 0xE0, 0x78, + 0xA8, 0x42, 0xB5, 0xD2, + 0x00, 0x20, 0x00, 0x90, 0x82, 0x46, 0x83, 0x46, 0x25, 0x78, 0x2E, 0xE0, + 0x4F, 0xF0, 0x00, 0x08, + 0xA7, 0x78, 0x09, 0xE0, 0x39, 0x46, 0xD9, 0xF8, 0x08, 0x00, 0x07, 0xF0, + 0xD7, 0xF8, 0x30, 0xF9, + 0x15, 0x10, 0x7F, 0x1C, 0x88, 0x44, 0xFF, 0xB2, 0xE0, 0x78, 0xB8, 0x42, + 0xF2, 0xD2, 0x20, 0x78, + 0x41, 0x1C, 0xA9, 0x42, 0x13, 0xD2, 0x2C, 0x49, 0x09, 0x68, 0xB1, 0xF8, + 0x28, 0x24, 0x02, 0xEB, + 0x0B, 0x01, 0x51, 0x45, 0x03, 0xDA, 0x41, 0x45, 0x01, 0xDA, 0x00, 0x26, + 0x10, 0xE0, 0x80, 0x1C, + 0xA8, 0x42, 0x04, 0xD2, 0x00, 0x98, 0x81, 0x42, 0x01, 0xDA, 0x41, 0x45, + 0xF5, 0xDB, 0xCD, 0xF8, + 0x00, 0xA0, 0xDA, 0x46, 0x6D, 0x1C, 0xC3, 0x46, 0xED, 0xB2, 0x60, 0x78, + 0xA8, 0x42, 0xCD, 0xD2, + 0x30, 0x46, 0xBD, 0xE8, 0xF8, 0x8F, 0x2D, 0xE9, 0xF0, 0x41, 0x07, 0x46, + 0x98, 0x8C, 0x14, 0x46, + 0x00, 0x26, 0x1D, 0x46, 0xC2, 0x05, 0x02, 0xD5, 0x01, 0x20, 0xBD, 0xE8, + 0xF0, 0x81, 0x00, 0x06, + 0x27, 0xD4, 0x15, 0x48, 0xEA, 0x8C, 0x00, 0x68, 0x90, 0xF8, 0x23, 0x34, + 0x9A, 0x42, 0x20, 0xD3, + 0xB0, 0xF8, 0x24, 0x34, 0xAA, 0x69, 0x9A, 0x42, 0x1B, 0xDC, 0x62, 0x78, + 0x23, 0x78, 0x90, 0xF8, + 0x26, 0x04, 0xD2, 0x1A, 0x52, 0x1C, 0x82, 0x42, 0x13, 0xDC, 0xE2, 0x78, + 0xA3, 0x78, 0xD2, 0x1A, + 0x52, 0x1C, 0x82, 0x42, 0x0D, 0xDC, 0x2B, 0x46, 0x22, 0x46, 0x38, 0x46, + 0xFF, 0xF7, 0xD3, 0xFE, + 0x01, 0x28, 0x06, 0xD1, 0x29, 0x46, 0x20, 0x46, 0xFF, 0xF7, 0x3D, 0xFF, + 0x01, 0x28, 0x00, 0xD1, + 0x01, 0x26, 0x30, 0x46, 0xD1, 0xE7, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x70, 0x47, 0xF0, 0xB5, + 0x99, 0x4B, 0x02, 0x46, 0x0C, 0x46, 0x1F, 0x78, 0x98, 0x4B, 0x1E, 0x68, + 0x98, 0x4B, 0x1D, 0x78, + 0x19, 0xE0, 0x2B, 0x46, 0x11, 0xE0, 0x00, 0xBF, 0x34, 0xF8, 0x13, 0xC0, + 0x32, 0xF8, 0x13, 0xE0, + 0xAC, 0xEB, 0x0E, 0x0C, 0xB6, 0xF9, 0x46, 0xE0, 0x0F, 0xFA, 0x8C, 0xFC, + 0x1E, 0xEB, 0x0C, 0x0F, + 0x22, 0xD4, 0xB6, 0xF8, 0x48, 0xE0, 0xE6, 0x45, 0x1E, 0xDB, 0x5B, 0x1E, + 0xEC, 0xD1, 0x02, 0xEB, + 0x45, 0x02, 0x04, 0xEB, 0x45, 0x04, 0x7F, 0x1E, 0xE3, 0xD2, 0x96, 0xF8, + 0x44, 0x20, 0x89, 0x4B, + 0x02, 0xF0, 0x0F, 0x02, 0xC2, 0xF1, 0x10, 0x04, 0xB3, 0xF9, 0x00, 0x30, + 0x0A, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x13, 0x50, 0x30, 0xF9, 0x13, 0x60, 0x55, 0x43, 0x06, 0xFB, + 0x04, 0x55, 0x2D, 0x11, + 0x21, 0xF8, 0x13, 0x50, 0x5B, 0x1E, 0xF3, 0xD2, 0xF0, 0xBD, 0xF0, 0xB5, + 0x14, 0x46, 0x05, 0x9F, + 0x0B, 0xE0, 0x00, 0xBF, 0x31, 0xF9, 0x14, 0x50, 0x30, 0xF9, 0x14, 0x60, + 0x05, 0xEB, 0x03, 0x0C, + 0xB4, 0x45, 0x19, 0xDB, 0xED, 0x1B, 0xB5, 0x42, 0x16, 0xDC, 0x64, 0x1E, + 0xF2, 0xD1, 0x73, 0x4B, + 0x1B, 0x68, 0x93, 0xF8, 0x45, 0x30, 0x1B, 0x09, 0xC3, 0xF1, 0x10, 0x04, + 0x0A, 0xE0, 0x00, 0xBF, + 0x31, 0xF9, 0x12, 0x50, 0x30, 0xF9, 0x12, 0x60, 0x5D, 0x43, 0x06, 0xFB, + 0x04, 0x55, 0x2D, 0x11, + 0x21, 0xF8, 0x12, 0x50, 0x52, 0x1E, 0xF3, 0xD2, 0xF0, 0xBD, 0x2D, 0xE9, + 0xF0, 0x43, 0x81, 0x46, + 0x66, 0x48, 0x69, 0x4C, 0x00, 0x68, 0x30, 0xF9, 0x5B, 0x6F, 0xB0, 0xF9, + 0x02, 0x70, 0x10, 0xF8, + 0x01, 0x0C, 0x00, 0xF0, 0x0F, 0x03, 0xC3, 0xF1, 0x10, 0x08, 0x00, 0x20, + 0x17, 0xE0, 0x00, 0xBF, + 0x34, 0xF9, 0x10, 0x20, 0x39, 0xF9, 0x10, 0x50, 0x02, 0xEB, 0x06, 0x0C, + 0x65, 0x45, 0x0C, 0xDC, + 0xA2, 0xEB, 0x07, 0x0C, 0x65, 0x45, 0x08, 0xDB, 0x5A, 0x43, 0x05, 0xFB, + 0x08, 0x22, 0xD5, 0x17, + 0x02, 0xEB, 0x15, 0x72, 0x12, 0x11, 0x24, 0xF8, 0x10, 0x20, 0x40, 0x1C, + 0xC0, 0xB2, 0x88, 0x42, + 0xE6, 0xD3, 0xBD, 0xE8, 0xF0, 0x83, 0x2D, 0xE9, 0xF8, 0x4F, 0x0D, 0x46, + 0x04, 0x46, 0x01, 0xF0, + 0x7F, 0xF8, 0x00, 0x28, 0x5B, 0xD1, 0xE8, 0x07, 0x08, 0xD0, 0x50, 0x48, + 0x50, 0x49, 0x00, 0x78, + 0x09, 0x68, 0x01, 0x28, 0x20, 0x68, 0x2D, 0xD0, 0x00, 0xF0, 0x53, 0xF8, + 0x47, 0x4E, 0xE8, 0x06, + 0x17, 0xD5, 0x30, 0x68, 0xB0, 0xF9, 0x50, 0x10, 0x00, 0x91, 0x43, 0x49, + 0xB0, 0xF9, 0x4E, 0x30, + 0x20, 0x69, 0x0A, 0x78, 0x47, 0x49, 0xFF, 0xF7, 0x88, 0xFF, 0x30, 0x68, + 0xB0, 0xF9, 0x54, 0x10, + 0x00, 0x91, 0x3F, 0x49, 0xB0, 0xF9, 0x52, 0x30, 0x60, 0x69, 0x0A, 0x78, + 0x42, 0x49, 0xFF, 0xF7, + 0x7C, 0xFF, 0xA8, 0x07, 0x2B, 0xD5, 0x36, 0x68, 0x41, 0x49, 0xA7, 0x68, + 0x96, 0xF8, 0x45, 0x00, + 0xDF, 0xF8, 0xF8, 0x90, 0x00, 0xF0, 0x0F, 0x03, 0xC3, 0xF1, 0x10, 0x0A, + 0x00, 0x20, 0xB1, 0xF9, + 0x00, 0xC0, 0x1A, 0xE0, 0xFF, 0xF7, 0x2B, 0xFF, 0xD0, 0xE7, 0x00, 0xBF, + 0x39, 0xF9, 0x10, 0x10, + 0xB6, 0xF9, 0x56, 0x80, 0x37, 0xF9, 0x10, 0x20, 0x88, 0x44, 0x90, 0x45, + 0x0B, 0xDB, 0xB6, 0xF9, + 0x58, 0x80, 0xA1, 0xEB, 0x08, 0x08, 0x90, 0x45, 0x05, 0xDC, 0x59, 0x43, + 0x02, 0xFB, 0x0A, 0x11, + 0x0A, 0x11, 0x29, 0xF8, 0x10, 0x20, 0x40, 0x1C, 0x00, 0xB2, 0x60, 0x45, + 0xE6, 0xDB, 0xA8, 0x05, + 0x05, 0xD5, 0x94, 0xF8, 0x32, 0x10, 0xA0, 0x69, 0xBD, 0xE8, 0xF8, 0x4F, + 0x6D, 0xE7, 0xBD, 0xE8, + 0xF8, 0x8F, 0x2D, 0xE9, 0xF0, 0x43, 0x81, 0x46, 0x26, 0x48, 0x03, 0x78, + 0x1B, 0x48, 0x05, 0x2B, + 0x00, 0x68, 0x90, 0xF8, 0x44, 0x20, 0x0C, 0xD0, 0x30, 0xF9, 0x46, 0x5F, + 0x02, 0xF0, 0x0F, 0x03, + 0xB0, 0xF9, 0x02, 0x60, 0x17, 0x48, 0xC3, 0xF1, 0x10, 0x04, 0xB0, 0xF9, + 0x00, 0x00, 0x02, 0x46, + 0x11, 0xE0, 0x30, 0xF9, 0x4A, 0x5F, 0x13, 0x09, 0xB0, 0xF9, 0x02, 0x60, + 0xF2, 0xE7, 0x00, 0xBF, + 0x31, 0xF9, 0x12, 0x70, 0x39, 0xF9, 0x12, 0xC0, 0x07, 0xEB, 0x05, 0x08, + 0xE0, 0x45, 0x11, 0xDB, + 0xBF, 0x1B, 0x67, 0x45, 0x0E, 0xDC, 0x52, 0x1E, 0xF2, 0xD2, 0x09, 0xE0, + 0x31, 0xF9, 0x10, 0x20, + 0x39, 0xF9, 0x10, 0x50, 0x5A, 0x43, 0x05, 0xFB, 0x04, 0x22, 0x12, 0x11, + 0x21, 0xF8, 0x10, 0x20, + 0x40, 0x1E, 0xF3, 0xD2, 0x5D, 0xE7, 0x00, 0x00, 0xED, 0x06, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, 0xFC, 0x4A, 0x01, 0x20, + 0xF3, 0x06, 0x10, 0x00, + 0x1C, 0x07, 0x10, 0x00, 0x7E, 0x4A, 0x01, 0x20, 0xA8, 0x4A, 0x01, 0x20, + 0xF4, 0x4A, 0x01, 0x20, + 0x00, 0x07, 0x10, 0x00, 0xEC, 0x06, 0x10, 0x00, 0x87, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x90, 0x02, + 0x40, 0x07, 0x07, 0xD5, 0x85, 0x48, 0x86, 0x49, 0xC0, 0x78, 0x09, 0x78, + 0x88, 0x42, 0x01, 0xD0, + 0x01, 0x20, 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x7F, 0x48, 0x10, 0xB5, + 0x00, 0x68, 0x90, 0xF8, + 0x90, 0x12, 0x89, 0x07, 0x27, 0xD5, 0x7F, 0x49, 0x0A, 0x78, 0x52, 0x1C, + 0xD2, 0xB2, 0x0A, 0x70, + 0x90, 0xF8, 0x92, 0x32, 0x93, 0x42, 0x1E, 0xD2, 0x00, 0x22, 0x0A, 0x70, + 0x90, 0xF8, 0x50, 0x12, + 0x03, 0x24, 0xC9, 0x07, 0x03, 0xD1, 0x90, 0xF8, 0x80, 0x02, 0xC0, 0x07, + 0x00, 0xD0, 0x0B, 0x24, + 0xEF, 0xF7, 0x36, 0xFE, 0x74, 0x48, 0x01, 0x68, 0x21, 0x43, 0x01, 0x60, + 0xEF, 0xF7, 0x2E, 0xFE, + 0x10, 0x21, 0x05, 0x20, 0x02, 0xF0, 0x6F, 0xF9, 0xBD, 0xE8, 0x10, 0x40, + 0x4F, 0xF4, 0x80, 0x71, + 0x00, 0x20, 0xEF, 0xF7, 0x66, 0xBF, 0x10, 0xBD, 0x68, 0x48, 0x6C, 0x49, + 0x4F, 0xF0, 0x00, 0x02, + 0x43, 0x78, 0x09, 0x78, 0x0B, 0x43, 0x67, 0x49, 0x08, 0xD1, 0x4B, 0x78, + 0x5B, 0x1C, 0xDB, 0xB2, + 0x4B, 0x70, 0x05, 0x2B, 0x03, 0xD9, 0x01, 0x23, 0x43, 0x70, 0x83, 0x70, + 0x4A, 0x70, 0x70, 0x47, + 0x2D, 0xE9, 0xF3, 0x4F, 0x62, 0x48, 0x00, 0x27, 0xDF, 0xF8, 0x88, 0xA1, + 0x90, 0xF8, 0x00, 0x80, + 0x59, 0x48, 0x81, 0xB0, 0x3C, 0x46, 0x00, 0x68, 0xB9, 0x46, 0x90, 0xF8, + 0x90, 0x02, 0xC0, 0x07, + 0x1A, 0xD0, 0x00, 0x26, 0x4F, 0xF0, 0x01, 0x0B, 0x01, 0x9D, 0x12, 0xE0, + 0x28, 0x46, 0x02, 0x99, + 0x00, 0xF0, 0x32, 0xF8, 0x10, 0xF0, 0x01, 0x0F, 0x05, 0xD0, 0x0B, 0xFA, + 0x06, 0xF0, 0x38, 0x43, + 0x64, 0x1C, 0xC7, 0xB2, 0xE4, 0xB2, 0xBA, 0xF9, 0x00, 0x00, 0x76, 0x1C, + 0x05, 0xEB, 0x40, 0x05, + 0x36, 0xB2, 0x46, 0x45, 0xEA, 0xDB, 0x01, 0xE0, 0x44, 0x46, 0xFF, 0x27, + 0x4E, 0x48, 0x07, 0x70, + 0x4C, 0xB1, 0x00, 0x94, 0xBA, 0xF8, 0x00, 0x00, 0x3B, 0x46, 0x82, 0xB2, + 0x41, 0x46, 0x01, 0x98, + 0x00, 0xF0, 0x45, 0xF8, 0x07, 0xE0, 0x49, 0x48, 0xB0, 0xF9, 0x00, 0x10, + 0x03, 0x20, 0x02, 0xF0, + 0x12, 0xF9, 0x4F, 0xF0, 0x01, 0x09, 0x48, 0x46, 0xBD, 0xE8, 0xFE, 0x8F, + 0x70, 0x47, 0x3D, 0x48, + 0x00, 0x21, 0x01, 0x70, 0x41, 0x70, 0x70, 0x47, 0x70, 0xB5, 0x37, 0x4A, + 0x3B, 0x4C, 0x12, 0x68, + 0x24, 0x78, 0xB2, 0xF9, 0x93, 0x32, 0x0C, 0xB1, 0xB2, 0xF9, 0x99, 0x32, + 0x33, 0x4C, 0x64, 0x78, + 0x01, 0x2C, 0x02, 0xD0, 0x02, 0x2C, 0x03, 0xD0, 0x04, 0xE0, 0xB2, 0xF9, + 0x95, 0x32, 0x01, 0xE0, + 0xB2, 0xF9, 0x97, 0x32, 0x33, 0x4A, 0x36, 0x4C, 0xB2, 0xF9, 0x00, 0x20, + 0x25, 0x78, 0x12, 0xE0, + 0x30, 0xF9, 0x12, 0x40, 0x31, 0xF9, 0x12, 0x60, 0xA4, 0x1B, 0x00, 0xD5, + 0x64, 0x42, 0x24, 0xB2, + 0x9C, 0x42, 0x08, 0xDD, 0x92, 0xFB, 0xF5, 0xF6, 0x05, 0xFB, 0x16, 0x26, + 0x1E, 0xB1, 0x2B, 0x48, + 0x04, 0x80, 0x00, 0x20, 0x70, 0xBD, 0x52, 0x1E, 0xEA, 0xD2, 0x01, 0x20, + 0x70, 0xBD, 0x2D, 0xE9, + 0xF0, 0x03, 0x06, 0x9F, 0x00, 0x2F, 0x19, 0xD0, 0x01, 0x25, 0x01, 0x2F, + 0x02, 0xD0, 0x14, 0x46, + 0xA9, 0x46, 0x2E, 0xE0, 0x00, 0x24, 0x0F, 0xE0, 0x05, 0xFA, 0x04, 0xF6, + 0x1E, 0x42, 0x0A, 0xD0, + 0x00, 0x2C, 0x0B, 0xD0, 0x53, 0x00, 0x62, 0x43, 0xBD, 0xE8, 0xF0, 0x03, + 0x00, 0xEB, 0x42, 0x01, + 0x1A, 0x46, 0x06, 0xF0, 0xAA, 0xBC, 0x64, 0x1C, 0x8C, 0x42, 0xED, 0xDB, + 0xBD, 0xE8, 0xF0, 0x03, + 0x70, 0x47, 0x00, 0xBF, 0x00, 0x26, 0x00, 0xEB, 0x44, 0x0C, 0x35, 0x46, + 0x0B, 0xE0, 0x00, 0xBF, + 0x09, 0xFA, 0x05, 0xF8, 0x18, 0xEA, 0x03, 0x0F, 0x02, 0xD0, 0xBC, 0xF9, + 0x00, 0x80, 0x46, 0x44, + 0x0C, 0xEB, 0x42, 0x0C, 0x6D, 0x1C, 0x8D, 0x42, 0xF2, 0xDB, 0x96, 0xFB, + 0xF7, 0xF5, 0x20, 0xF8, + 0x14, 0x50, 0x64, 0x1E, 0xE6, 0xD2, 0xE1, 0xE7, 0x4C, 0x07, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0xEF, 0x06, 0x10, 0x00, 0x70, 0x06, 0x10, 0x00, 0x54, 0x07, 0x10, 0x00, + 0x74, 0x05, 0x10, 0x00, + 0xF0, 0x06, 0x10, 0x00, 0xFE, 0x06, 0x10, 0x00, 0x75, 0x06, 0x10, 0x00, + 0x7A, 0x06, 0x10, 0x00, + 0xEE, 0x06, 0x10, 0x00, 0x10, 0xB5, 0xF6, 0xF7, 0x3D, 0xFC, 0xF7, 0xF7, + 0xC3, 0xF8, 0xBD, 0xE8, + 0x10, 0x40, 0xF5, 0xF7, 0x9F, 0xBB, 0x2D, 0xE9, 0xF0, 0x47, 0x81, 0x46, + 0x1F, 0x46, 0x90, 0x46, + 0x0E, 0x46, 0x03, 0x20, 0x08, 0x9D, 0xEF, 0xF7, 0x4C, 0xFF, 0x5C, 0x48, + 0x01, 0x68, 0x48, 0x46, + 0xFF, 0xF7, 0x16, 0xFF, 0x04, 0x46, 0x03, 0x20, 0xEF, 0xF7, 0x5E, 0xFF, + 0x64, 0xB1, 0xFF, 0xF7, + 0xFB, 0xFE, 0xFF, 0xF7, 0xC9, 0xFE, 0x31, 0x46, 0x48, 0x46, 0xFF, 0xF7, + 0x4F, 0xFF, 0x54, 0x48, + 0x04, 0x70, 0x20, 0x46, 0xBD, 0xE8, 0xF0, 0x87, 0xFF, 0xF7, 0x49, 0xFF, + 0x16, 0xB1, 0x30, 0x46, + 0x00, 0xF0, 0xE8, 0xFC, 0x65, 0xB1, 0x4F, 0x48, 0x01, 0x78, 0x28, 0x46, + 0xF6, 0xF7, 0x31, 0xFC, + 0x4D, 0x48, 0x80, 0x78, 0x20, 0xB1, 0x4D, 0x48, 0x01, 0x68, 0x21, 0xF0, + 0x30, 0x01, 0x01, 0x60, + 0x06, 0xF0, 0x6C, 0xFD, 0x05, 0x46, 0xFF, 0xF7, 0x97, 0xFE, 0x50, 0xEA, + 0x05, 0x04, 0xDA, 0xD1, + 0x3A, 0x46, 0x41, 0x46, 0x48, 0x46, 0x00, 0xF0, 0x32, 0xF8, 0x04, 0x46, + 0xD3, 0xE7, 0x10, 0xB5, + 0xF8, 0xF7, 0x5B, 0xFB, 0xFD, 0xF7, 0x1F, 0xFF, 0xFB, 0xF7, 0x28, 0xFB, + 0xFF, 0xF7, 0xAA, 0xFF, + 0xFF, 0xF7, 0x1D, 0xFF, 0xFC, 0xF7, 0xB3, 0xFA, 0x39, 0x49, 0x00, 0x20, + 0x08, 0x70, 0x48, 0x70, + 0x88, 0x80, 0xC8, 0x80, 0x88, 0x70, 0x88, 0x60, 0xC8, 0x60, 0x08, 0x61, + 0x14, 0x31, 0x08, 0x70, + 0x88, 0x70, 0x37, 0x48, 0x00, 0x68, 0x10, 0xF8, 0x30, 0x2F, 0x4A, 0x70, + 0x40, 0x78, 0xC8, 0x70, + 0x10, 0xBD, 0x10, 0xB5, 0xF8, 0xF7, 0x47, 0xFB, 0xFD, 0xF7, 0x10, 0xFF, + 0x00, 0xF0, 0x15, 0xFD, + 0xF7, 0xF7, 0x5D, 0xF8, 0x2C, 0x48, 0x00, 0x21, 0x41, 0x70, 0x81, 0x70, + 0x10, 0xBD, 0xF8, 0xB5, + 0x07, 0x46, 0x00, 0x24, 0x15, 0x46, 0x0E, 0x46, 0x8D, 0xF8, 0x00, 0x40, + 0x02, 0x20, 0xEF, 0xF7, + 0xD8, 0xFE, 0x2A, 0x46, 0x31, 0x46, 0x38, 0x46, 0xF8, 0xF7, 0x4F, 0xFA, + 0x25, 0x49, 0x01, 0x28, + 0xCA, 0x78, 0x60, 0xF3, 0x03, 0x02, 0xCA, 0x70, 0x2A, 0xD0, 0x02, 0x28, + 0x2D, 0xD0, 0x03, 0x28, + 0x2E, 0xD0, 0x04, 0x28, 0x00, 0xD0, 0x01, 0x24, 0x6B, 0x46, 0x2A, 0x46, + 0x31, 0x46, 0x38, 0x46, + 0xFC, 0xF7, 0xAE, 0xF9, 0x40, 0xEA, 0x04, 0x05, 0x02, 0x20, 0xEF, 0xF7, + 0xD5, 0xFE, 0x9D, 0xF8, + 0x00, 0x00, 0x98, 0xB1, 0xEF, 0xF7, 0x94, 0xFC, 0x17, 0x48, 0x18, 0x4A, + 0x01, 0x68, 0x12, 0x68, + 0x11, 0x43, 0x01, 0x60, 0xEF, 0xF7, 0x8A, 0xFC, 0x15, 0x48, 0x01, 0x78, + 0x05, 0x20, 0x01, 0xF0, + 0xCA, 0xFF, 0x4F, 0xF4, 0x80, 0x71, 0x00, 0x20, 0xEF, 0xF7, 0xC3, 0xFD, + 0x28, 0x46, 0xF8, 0xBD, + 0xFD, 0xF7, 0xA4, 0xFE, 0xFB, 0xF7, 0xD9, 0xFA, 0xD6, 0xE7, 0xFD, 0xF7, + 0x5E, 0xFC, 0x01, 0xE0, + 0xF7, 0xF7, 0x47, 0xFB, 0xFB, 0xF7, 0xFD, 0xFA, 0xCE, 0xE7, 0x00, 0x00, + 0x1C, 0x07, 0x10, 0x00, + 0x74, 0x06, 0x10, 0x00, 0x79, 0x07, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, + 0x04, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, 0x54, 0x07, 0x10, 0x00, + 0x30, 0x06, 0x10, 0x00, + 0x2C, 0x06, 0x10, 0x00, 0x06, 0x28, 0x08, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, + 0x07, 0x03, 0x03, 0x03, + 0x05, 0x05, 0x01, 0x20, 0x70, 0x47, 0x02, 0x20, 0x70, 0x47, 0x00, 0x20, + 0x70, 0x47, 0x10, 0xB5, + 0x04, 0x46, 0x08, 0x46, 0xFF, 0xF7, 0xEE, 0xFF, 0xA8, 0x4A, 0x01, 0x21, + 0x81, 0x40, 0x12, 0x68, + 0x11, 0x42, 0x09, 0xD1, 0x02, 0x28, 0x07, 0xDC, 0xA5, 0x49, 0x51, 0xF8, + 0x20, 0x10, 0x21, 0x60, + 0xA4, 0x49, 0x41, 0xF8, 0x20, 0x40, 0x10, 0xBD, 0x00, 0x20, 0x20, 0x60, + 0x21, 0x46, 0xBD, 0xE8, + 0x10, 0x40, 0x48, 0x20, 0x01, 0xF0, 0x2D, 0xBD, 0x70, 0xB5, 0x04, 0x46, + 0x08, 0x46, 0xFF, 0xF7, + 0xD1, 0xFF, 0x00, 0x25, 0x88, 0xB1, 0x02, 0x28, 0x0F, 0xDC, 0x99, 0x4A, + 0x21, 0x68, 0x52, 0xF8, + 0x20, 0x20, 0x91, 0x42, 0x09, 0xD1, 0x95, 0x49, 0x01, 0x22, 0x82, 0x40, + 0x0B, 0x68, 0x93, 0x43, + 0x0B, 0x60, 0x94, 0x49, 0x41, 0xF8, 0x20, 0x50, 0x03, 0xE0, 0x21, 0x46, + 0x49, 0x20, 0x01, 0xF0, + 0x10, 0xFD, 0x25, 0x60, 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x01, 0x24, + 0x8B, 0x4E, 0x8D, 0x4F, + 0x4F, 0xF0, 0x00, 0x08, 0x25, 0x46, 0x00, 0xBF, 0x31, 0x68, 0x05, 0xFA, + 0x04, 0xF0, 0x08, 0x42, + 0x08, 0xD0, 0x81, 0x43, 0x31, 0x60, 0x57, 0xF8, 0x24, 0x10, 0x4A, 0x20, + 0x01, 0xF0, 0xF9, 0xFC, + 0x47, 0xF8, 0x24, 0x80, 0x64, 0x1C, 0x02, 0x2C, 0xEE, 0xDD, 0xBD, 0xE8, + 0xF0, 0x81, 0x2D, 0xE9, + 0xF0, 0x41, 0x80, 0x4D, 0x0A, 0x46, 0x00, 0x27, 0x0C, 0x35, 0x7C, 0x4B, + 0x7E, 0x4C, 0x05, 0xF1, + 0x14, 0x06, 0x03, 0xF1, 0x08, 0x01, 0x07, 0x60, 0x01, 0x2A, 0x63, 0xD0, + 0x02, 0x2A, 0x39, 0xD0, + 0x03, 0x2A, 0x6A, 0xD1, 0x5F, 0xF0, 0x00, 0x02, 0x11, 0xF8, 0x02, 0xC0, + 0xBC, 0xF1, 0x00, 0x0F, + 0x10, 0xD1, 0x01, 0xEB, 0x02, 0x0C, 0x9C, 0xF8, 0x01, 0xE0, 0xBE, 0xF1, + 0x00, 0x0F, 0x09, 0xD1, + 0x9C, 0xF8, 0x02, 0xE0, 0xBE, 0xF1, 0x00, 0x0F, 0x04, 0xD1, 0x9C, 0xF8, + 0x03, 0xE0, 0xBE, 0xF1, + 0x00, 0x0F, 0x0B, 0xD0, 0x02, 0xF1, 0x04, 0x0C, 0x52, 0x1C, 0xBC, 0xF1, + 0x05, 0x0F, 0xE3, 0xDB, + 0x59, 0x68, 0x04, 0x29, 0x47, 0xD3, 0x01, 0x46, 0x4C, 0x20, 0x48, 0xE0, + 0x73, 0x27, 0x57, 0x43, + 0x04, 0xEB, 0xC7, 0x04, 0x04, 0x60, 0x45, 0xF8, 0x22, 0x40, 0x46, 0xF8, + 0x22, 0x00, 0x03, 0x20, + 0x88, 0x54, 0x11, 0x44, 0x48, 0x70, 0x8C, 0xF8, 0x02, 0x00, 0x8C, 0xF8, + 0x03, 0x00, 0x58, 0x68, + 0x00, 0x1F, 0x45, 0xE0, 0x5F, 0xF0, 0x00, 0x02, 0x11, 0xF8, 0x02, 0xC0, + 0xBC, 0xF1, 0x00, 0x0F, + 0x06, 0xD1, 0x01, 0xEB, 0x02, 0x0C, 0x9C, 0xF8, 0x01, 0xC0, 0xBC, 0xF1, + 0x00, 0x0F, 0x09, 0xD0, + 0x02, 0xF1, 0x02, 0x0C, 0x52, 0x1C, 0xBC, 0xF1, 0x05, 0x0F, 0xED, 0xDB, + 0x59, 0x68, 0x02, 0x29, + 0xD1, 0xD2, 0x18, 0xE0, 0x73, 0x27, 0x57, 0x43, 0x04, 0xEB, 0xC7, 0x04, + 0x04, 0x60, 0x45, 0xF8, + 0x22, 0x40, 0x46, 0xF8, 0x22, 0x00, 0x02, 0x20, 0x88, 0x54, 0x11, 0x44, + 0x48, 0x70, 0x58, 0x68, + 0x80, 0x1E, 0x1D, 0xE0, 0x5F, 0xF0, 0x04, 0x02, 0x11, 0xF8, 0x02, 0xC0, + 0xBC, 0xF1, 0x00, 0x0F, + 0x09, 0xD0, 0x52, 0x1E, 0xF8, 0xD2, 0x00, 0x2F, 0x13, 0xD1, 0x01, 0x46, + 0x4B, 0x20, 0xBD, 0xE8, + 0xF0, 0x41, 0x01, 0xF0, 0x6E, 0xBC, 0x73, 0x27, 0x57, 0x43, 0x04, 0xEB, + 0xC7, 0x04, 0x04, 0x60, + 0x45, 0xF8, 0x22, 0x40, 0x46, 0xF8, 0x22, 0x00, 0x01, 0x20, 0x88, 0x54, + 0x58, 0x68, 0x40, 0x1E, + 0x58, 0x60, 0x6A, 0xE7, 0xF0, 0xB4, 0x37, 0x4D, 0x34, 0x4C, 0x00, 0x22, + 0x04, 0x23, 0x0C, 0x35, + 0x06, 0x68, 0x08, 0x34, 0x55, 0xF8, 0x23, 0x70, 0xB7, 0x42, 0x14, 0xD1, + 0xE7, 0x5C, 0x8F, 0x42, + 0x11, 0xD1, 0x5A, 0x1C, 0x13, 0xD0, 0x00, 0x22, 0x02, 0x60, 0x45, 0xF8, + 0x23, 0x20, 0x2D, 0x4D, + 0x20, 0x35, 0x01, 0x29, 0x45, 0xF8, 0x23, 0x20, 0xE2, 0x54, 0x11, 0xD0, + 0x02, 0x29, 0x11, 0xD0, + 0x03, 0x29, 0x04, 0xD1, 0x08, 0xE0, 0x5B, 0x1E, 0xE4, 0xD2, 0x00, 0x2A, + 0x08, 0xD1, 0xF0, 0xBC, + 0x01, 0x46, 0x4D, 0x20, 0x01, 0xF0, 0x35, 0xBC, 0xE0, 0x18, 0x42, 0x70, + 0x82, 0x70, 0xC2, 0x70, + 0xF0, 0xBC, 0x70, 0x47, 0xE0, 0x18, 0x42, 0x70, 0xFA, 0xE7, 0x2D, 0xE9, + 0xF0, 0x41, 0x1D, 0x4E, + 0x1A, 0x4F, 0x0C, 0x36, 0x05, 0x24, 0x06, 0xF1, 0x14, 0x05, 0x08, 0x37, + 0x0D, 0xE0, 0x00, 0xBF, + 0x56, 0xF8, 0x24, 0x00, 0x48, 0xB1, 0x55, 0xF8, 0x24, 0x10, 0x4E, 0x20, + 0x01, 0xF0, 0x19, 0xFC, + 0x39, 0x5D, 0x55, 0xF8, 0x24, 0x00, 0xFF, 0xF7, 0xB5, 0xFF, 0x64, 0x1E, + 0xF0, 0xD2, 0x1C, 0xE7, + 0x30, 0xB5, 0x0E, 0x4A, 0x01, 0x20, 0x01, 0x46, 0x0E, 0x4B, 0x10, 0x60, + 0x5F, 0xF0, 0x00, 0x00, + 0x43, 0xF8, 0x21, 0x00, 0x49, 0x1C, 0x02, 0x29, 0xFA, 0xDD, 0x05, 0x21, + 0x09, 0x4C, 0x51, 0x60, + 0x0C, 0x34, 0x06, 0x4A, 0x04, 0x21, 0x08, 0x32, 0x04, 0xF1, 0x14, 0x03, + 0x44, 0xF8, 0x21, 0x00, + 0x50, 0x54, 0x43, 0xF8, 0x21, 0x00, 0x49, 0x1E, 0xF8, 0xD2, 0x30, 0xBD, + 0xB0, 0x06, 0x10, 0x00, + 0x3C, 0x7A, 0x01, 0x00, 0x9C, 0x4E, 0x10, 0x00, 0xD4, 0x56, 0x10, 0x00, + 0x73, 0x49, 0x00, 0x20, + 0x74, 0x4B, 0x08, 0x70, 0x72, 0x49, 0x01, 0x22, 0x88, 0x60, 0xC8, 0x60, + 0x08, 0x70, 0x1A, 0x70, + 0xC1, 0xF8, 0x01, 0x00, 0x70, 0x47, 0xFE, 0xB5, 0x6F, 0x4C, 0x6E, 0x4D, + 0x70, 0x4F, 0x22, 0x68, + 0xB2, 0xF8, 0x7A, 0x14, 0xAD, 0xF8, 0x04, 0x10, 0xB2, 0xF8, 0x7C, 0x14, + 0xAD, 0xF8, 0x06, 0x10, + 0xB2, 0xF8, 0x7E, 0x14, 0xAD, 0xF8, 0x08, 0x10, 0xB2, 0xF8, 0x80, 0x14, + 0xAD, 0xF8, 0x0A, 0x10, + 0x66, 0x49, 0x03, 0x68, 0x0B, 0x60, 0x43, 0x68, 0x4B, 0x60, 0x29, 0x78, + 0x00, 0x91, 0x92, 0xF8, + 0x82, 0x14, 0xB7, 0xF9, 0x00, 0x20, 0x01, 0xF0, 0x0F, 0x03, 0x01, 0x46, + 0x5F, 0x48, 0x08, 0x30, + 0x03, 0xF0, 0x0C, 0xFA, 0x00, 0x26, 0x2E, 0x70, 0x03, 0x20, 0xEF, 0xF7, + 0xDA, 0xFC, 0x5B, 0x49, + 0xB7, 0xF9, 0x00, 0x30, 0x08, 0x31, 0x5B, 0x4A, 0x01, 0xF1, 0x08, 0x00, + 0x03, 0xF0, 0xF1, 0xF9, + 0x03, 0x20, 0xEF, 0xF7, 0xE9, 0xFC, 0x55, 0x48, 0x01, 0xA9, 0x10, 0x30, + 0x00, 0xF0, 0x27, 0xF8, + 0x4E, 0x49, 0x4F, 0x4D, 0xC0, 0xB1, 0x01, 0x26, 0x0E, 0x70, 0x21, 0x68, + 0x91, 0xF8, 0x60, 0x14, + 0x89, 0x07, 0x12, 0xD5, 0x04, 0x46, 0x00, 0x90, 0x04, 0x21, 0x68, 0x46, + 0xF0, 0xF7, 0x23, 0xFA, + 0xC0, 0xB2, 0x01, 0x28, 0x02, 0xD9, 0xA8, 0x68, 0x10, 0xB1, 0x04, 0x46, + 0x20, 0x46, 0x04, 0xE0, + 0x28, 0x78, 0x86, 0x40, 0x34, 0x43, 0xF9, 0xE7, 0x0E, 0x70, 0xA9, 0x68, + 0x00, 0xF0, 0x43, 0xF8, + 0xA9, 0x68, 0x88, 0x42, 0x02, 0xD0, 0xA8, 0x60, 0x01, 0xF0, 0xA4, 0xFD, + 0xFE, 0xBD, 0x2D, 0xE9, + 0xFC, 0x43, 0x04, 0x46, 0x00, 0x20, 0x89, 0x46, 0xDF, 0xF8, 0xEC, 0xC0, + 0x80, 0x46, 0x6E, 0x46, + 0x00, 0x90, 0x03, 0x46, 0x02, 0x46, 0x01, 0x21, 0xCD, 0xF8, 0x04, 0x00, + 0xDC, 0xF8, 0x00, 0x50, + 0x95, 0xF8, 0x61, 0x74, 0x01, 0xFA, 0x02, 0xF5, 0x2F, 0x42, 0x05, 0xD0, + 0x34, 0xF8, 0x13, 0x50, + 0x5B, 0x1C, 0x26, 0xF8, 0x12, 0x50, 0x1B, 0xB2, 0x52, 0x1C, 0x12, 0xB2, + 0x04, 0x2A, 0xED, 0xDB, + 0x2F, 0x4B, 0x34, 0x46, 0x00, 0x22, 0x2A, 0x4E, 0xB3, 0xF9, 0x00, 0x50, + 0x0F, 0xE0, 0x00, 0xBF, + 0x34, 0xF9, 0x12, 0x30, 0x39, 0xF9, 0x12, 0x70, 0xBB, 0x42, 0x06, 0xDD, + 0x01, 0xFA, 0x02, 0xF7, + 0x38, 0x43, 0x43, 0x45, 0x01, 0xDD, 0x98, 0x46, 0x32, 0x70, 0x52, 0x1C, + 0x12, 0xB2, 0xAA, 0x42, + 0xEE, 0xDB, 0xBD, 0xE8, 0xFC, 0x83, 0x2D, 0xE9, 0xF0, 0x43, 0x1D, 0x4F, + 0x89, 0x46, 0x00, 0x22, + 0xF9, 0x68, 0x4F, 0xF0, 0x01, 0x08, 0x80, 0xEA, 0x01, 0x04, 0x1B, 0x49, + 0x7B, 0x1C, 0x0D, 0x68, + 0x1B, 0x49, 0xB1, 0xF9, 0x00, 0x60, 0x1B, 0xE0, 0x08, 0xFA, 0x02, 0xF1, + 0x21, 0x42, 0x0A, 0xD0, + 0x95, 0xF8, 0x83, 0xC4, 0x01, 0x42, 0x02, 0xD0, 0x0C, 0xF0, 0x0F, 0x0C, + 0x01, 0xE0, 0x4F, 0xEA, + 0x1C, 0x1C, 0x03, 0xF8, 0x02, 0xC0, 0x13, 0xF9, 0x02, 0xC0, 0xBC, 0xF1, + 0x00, 0x0F, 0x0D, 0xD0, + 0x03, 0xDD, 0xAC, 0xF1, 0x01, 0x0C, 0x03, 0xF8, 0x02, 0xC0, 0x02, 0xF1, + 0x01, 0x02, 0x12, 0xB2, + 0xB2, 0x42, 0xE1, 0xDB, 0xF8, 0x60, 0x48, 0x46, 0xBD, 0xE8, 0xF0, 0x83, + 0x01, 0x42, 0x02, 0xD0, + 0x41, 0xEA, 0x09, 0x09, 0xF1, 0xE7, 0x29, 0xEA, 0x01, 0x09, 0xEE, 0xE7, + 0x2C, 0x07, 0x10, 0x00, + 0xC0, 0x06, 0x10, 0x00, 0x7B, 0x07, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x9A, 0x1C, 0x01, 0x20, + 0x00, 0x07, 0x10, 0x00, 0xF4, 0x4A, 0x01, 0x20, 0xF0, 0xB5, 0x06, 0x46, + 0xF8, 0x48, 0x00, 0x24, + 0xA7, 0xB0, 0x00, 0x78, 0x0D, 0x46, 0x01, 0x28, 0x00, 0xD1, 0x01, 0x24, + 0x98, 0x21, 0x68, 0x46, + 0x06, 0xF0, 0xC4, 0xF9, 0xF3, 0x4A, 0x00, 0x21, 0x68, 0x46, 0x13, 0x78, + 0x11, 0xE0, 0x00, 0xBF, + 0x01, 0xFB, 0x03, 0xF7, 0x22, 0x46, 0x09, 0xE0, 0x07, 0xEB, 0x02, 0x0E, + 0x50, 0xF8, 0x22, 0xC0, + 0x36, 0xF9, 0x1E, 0xE0, 0xF4, 0x44, 0x40, 0xF8, 0x22, 0xC0, 0x52, 0x1C, + 0x9A, 0x42, 0xF3, 0xDB, + 0x49, 0x1C, 0xA9, 0x42, 0xEC, 0xDB, 0x21, 0x46, 0x07, 0xE0, 0x00, 0xBF, + 0x50, 0xF8, 0x21, 0x20, + 0x92, 0xFB, 0xF5, 0xF2, 0x40, 0xF8, 0x21, 0x20, 0x49, 0x1C, 0x99, 0x42, + 0xF6, 0xDB, 0x00, 0x21, + 0x17, 0xE0, 0x00, 0x27, 0x3A, 0x46, 0x0C, 0xE0, 0x02, 0xFB, 0x03, 0x4C, + 0x50, 0xF8, 0x24, 0xE0, + 0x36, 0xF9, 0x1C, 0xC0, 0xBC, 0xEB, 0x0E, 0x0C, 0x01, 0xD5, 0xCC, 0xF1, + 0x00, 0x0C, 0x67, 0x44, + 0x52, 0x1C, 0xAA, 0x42, 0xF0, 0xDB, 0x97, 0xFB, 0xF5, 0xF2, 0x8A, 0x42, + 0x00, 0xDD, 0x11, 0x46, + 0x64, 0x1C, 0x9C, 0x42, 0xE5, 0xDB, 0xB1, 0xF5, 0x80, 0x3F, 0x03, 0xDB, + 0x4F, 0xF6, 0xFF, 0x70, + 0x27, 0xB0, 0xF0, 0xBD, 0x88, 0xB2, 0xFB, 0xE7, 0xF0, 0xB5, 0xCF, 0x49, + 0xCF, 0x4B, 0x09, 0x68, + 0x91, 0xF8, 0xA0, 0x22, 0xD2, 0x07, 0x34, 0xD0, 0xCD, 0x4A, 0x57, 0x78, + 0x4F, 0xB1, 0x91, 0xF8, + 0xAB, 0x42, 0xB1, 0xF8, 0xA8, 0x52, 0x04, 0xF0, 0x0F, 0x02, 0x26, 0x09, + 0xB1, 0xF8, 0xA6, 0x42, + 0x08, 0xE0, 0x91, 0xF8, 0xAA, 0x42, 0xB1, 0xF8, 0xA4, 0x52, 0x04, 0xF0, + 0x0F, 0x02, 0x26, 0x09, + 0xB1, 0xF8, 0xA2, 0x42, 0xDF, 0xF8, 0x0C, 0xC3, 0x9C, 0xF8, 0x00, 0xC0, + 0xBC, 0xF1, 0x03, 0x0F, + 0x06, 0xD1, 0x91, 0xF8, 0xAC, 0x12, 0x0F, 0xB1, 0x0A, 0x09, 0x01, 0xE0, + 0x01, 0xF0, 0x0F, 0x02, + 0xA0, 0x42, 0x01, 0xDC, 0x1A, 0x60, 0xF0, 0xBD, 0xA8, 0x42, 0x01, 0xDB, + 0x1E, 0x60, 0xF0, 0xBD, + 0x00, 0x1B, 0xB1, 0x1A, 0x48, 0x43, 0x29, 0x1B, 0x90, 0xFB, 0xF1, 0xF0, + 0x10, 0x44, 0x18, 0x60, + 0xF0, 0xBD, 0x00, 0x20, 0xFB, 0xE7, 0xB0, 0x48, 0xB1, 0x49, 0x00, 0x68, + 0x0A, 0x78, 0x00, 0xF5, + 0xF9, 0x70, 0x80, 0x5C, 0xC8, 0x70, 0x70, 0x47, 0x2D, 0xE9, 0xF0, 0x0F, + 0x83, 0x46, 0xAA, 0x48, + 0xDF, 0xF8, 0xAC, 0x92, 0xDF, 0xF8, 0xB0, 0xA2, 0x01, 0x68, 0x99, 0xF8, + 0x00, 0x70, 0x00, 0x20, + 0x91, 0xF8, 0x0A, 0x62, 0x91, 0xF8, 0x09, 0x12, 0x3A, 0xF8, 0x17, 0x40, + 0x6F, 0xF0, 0x00, 0x42, + 0x4F, 0xEA, 0x11, 0x18, 0x0B, 0x07, 0x1C, 0xD0, 0x01, 0xF0, 0x0F, 0x05, + 0x9E, 0x4B, 0x00, 0x21, + 0x8C, 0x46, 0x1B, 0x68, 0xB4, 0x42, 0x93, 0xF8, 0x08, 0x32, 0x05, 0xDB, + 0xA6, 0x1B, 0x06, 0xFB, + 0x08, 0xF6, 0x96, 0xFB, 0xF5, 0xF5, 0x2B, 0x44, 0x97, 0x4D, 0x99, 0xF8, + 0x01, 0x60, 0x2D, 0x68, + 0x01, 0x2E, 0x95, 0xF8, 0xF1, 0x51, 0x06, 0xD0, 0x02, 0x2E, 0x07, 0xD0, + 0x05, 0xF0, 0x03, 0x06, + 0x13, 0xE0, 0x01, 0x25, 0xE2, 0xE7, 0xC5, 0xF3, 0x81, 0x06, 0x0E, 0xE0, + 0xC5, 0xF3, 0x01, 0x16, + 0x0B, 0xE0, 0x00, 0xBF, 0x3A, 0xF8, 0x1C, 0x50, 0xAA, 0x42, 0x01, 0xDD, + 0x2A, 0x46, 0x60, 0x46, + 0xA9, 0x42, 0x00, 0xDA, 0x29, 0x46, 0x0C, 0xF1, 0x01, 0x0C, 0xB4, 0x45, + 0xF2, 0xDD, 0xAB, 0xF8, + 0x00, 0x10, 0xA1, 0x1A, 0x99, 0x42, 0x01, 0xDC, 0xB7, 0x42, 0x04, 0xDD, + 0x89, 0xF8, 0x00, 0x00, + 0xBD, 0xE8, 0xF0, 0x0F, 0x9F, 0xE7, 0xBD, 0xE8, 0xF0, 0x0F, 0x70, 0x47, + 0x83, 0x49, 0x10, 0xB5, + 0x0B, 0x78, 0x7D, 0x49, 0x00, 0x22, 0x01, 0x2B, 0x09, 0x68, 0x02, 0xD1, + 0x80, 0x4B, 0x1B, 0x78, + 0x4B, 0xB1, 0xB1, 0xF8, 0xFC, 0x31, 0x83, 0x42, 0x18, 0xD2, 0x91, 0xF8, + 0xF0, 0x31, 0x1B, 0x07, + 0x14, 0xD5, 0x03, 0x22, 0x25, 0xE0, 0xB1, 0xF8, 0x02, 0x32, 0x83, 0x42, + 0x03, 0xD2, 0x91, 0xF8, + 0xF0, 0x31, 0x1B, 0x07, 0xF5, 0xD4, 0xB1, 0xF8, 0x00, 0x32, 0x83, 0x42, + 0x03, 0xD2, 0x91, 0xF8, + 0xF0, 0x31, 0x5B, 0x07, 0x0A, 0xD4, 0xB1, 0xF8, 0xFE, 0x31, 0x0B, 0xE0, + 0xB1, 0xF8, 0xFA, 0x31, + 0x83, 0x42, 0x05, 0xD2, 0x91, 0xF8, 0xF0, 0x31, 0x5B, 0x07, 0x01, 0xD5, + 0x02, 0x22, 0x08, 0xE0, + 0xB1, 0xF8, 0xF8, 0x31, 0x83, 0x42, 0x04, 0xD2, 0x91, 0xF8, 0xF0, 0x01, + 0x80, 0x07, 0x00, 0xD5, + 0x01, 0x22, 0x65, 0x48, 0x62, 0x4C, 0x14, 0x38, 0x03, 0x78, 0x9A, 0x42, + 0x11, 0xD1, 0x61, 0x78, + 0x99, 0x42, 0x1A, 0xD0, 0x63, 0x4A, 0x12, 0x78, 0x13, 0x43, 0x07, 0xD0, + 0x81, 0x68, 0x49, 0x1E, + 0x81, 0x60, 0x00, 0x29, 0x11, 0xDC, 0x00, 0x78, 0x60, 0x70, 0x0E, 0xE0, + 0x01, 0x70, 0x81, 0x68, + 0xF7, 0xE7, 0x8A, 0xB1, 0x02, 0x2A, 0x01, 0xD1, 0x01, 0x2B, 0x0D, 0xD0, + 0x91, 0xF8, 0xF6, 0x11, + 0x81, 0x60, 0x02, 0x70, 0x00, 0x29, 0x00, 0xDC, 0x62, 0x70, 0x57, 0x48, + 0x62, 0x78, 0x41, 0x7B, + 0x62, 0xF3, 0x03, 0x01, 0x41, 0x73, 0x10, 0xBD, 0x91, 0xF8, 0xF7, 0x11, + 0xF0, 0xE7, 0x4A, 0x4A, + 0x12, 0x68, 0x92, 0xF8, 0xF0, 0x21, 0xD2, 0x06, 0x07, 0xD5, 0x42, 0x1A, + 0x00, 0x2A, 0x04, 0xDC, + 0xC1, 0xEB, 0xC1, 0x11, 0x08, 0x44, 0xC0, 0xF3, 0xCF, 0x10, 0x70, 0x47, + 0x44, 0x49, 0x00, 0x20, + 0x41, 0x4A, 0x48, 0x70, 0x44, 0x49, 0x14, 0x39, 0x48, 0x60, 0x88, 0x60, + 0x08, 0x70, 0x12, 0x68, + 0x92, 0xF8, 0xA0, 0x32, 0xDB, 0x07, 0x03, 0xD0, 0x92, 0xF8, 0xAB, 0x22, + 0x12, 0x09, 0x00, 0xE0, + 0x00, 0x22, 0x3A, 0x4B, 0x1A, 0x60, 0xC8, 0x60, 0x08, 0x61, 0x48, 0x61, + 0x88, 0x61, 0x70, 0x47, + 0x2D, 0xE9, 0xF8, 0x4F, 0x00, 0x21, 0xAD, 0xF8, 0x00, 0x10, 0x32, 0x49, + 0xDF, 0xF8, 0xD8, 0x90, + 0xDF, 0xF8, 0xD4, 0x80, 0x0D, 0x78, 0x4F, 0xF0, 0x10, 0x0B, 0x2F, 0x01, + 0x06, 0x46, 0x00, 0x24, + 0xA9, 0xF1, 0x08, 0x09, 0xA8, 0xF1, 0x14, 0x0A, 0x10, 0xE0, 0x2A, 0x46, + 0x59, 0x46, 0x30, 0x46, + 0xFF, 0xF7, 0x5A, 0xFE, 0x29, 0xF8, 0x14, 0x00, 0x43, 0x46, 0x38, 0xF8, + 0x14, 0x10, 0xFF, 0xF7, + 0xB6, 0xFF, 0x23, 0xF8, 0x14, 0x00, 0x06, 0xEB, 0x47, 0x06, 0x64, 0x1C, + 0x9A, 0xF8, 0x01, 0x00, + 0x84, 0x42, 0xEA, 0xDD, 0x68, 0x46, 0xFF, 0xF7, 0xE7, 0xFE, 0x1F, 0x48, + 0x20, 0x4D, 0x00, 0x68, + 0x90, 0xF8, 0xF0, 0x01, 0x40, 0x06, 0x02, 0xD5, 0xBD, 0xF8, 0x00, 0x40, + 0x02, 0xE0, 0x29, 0x78, + 0x38, 0xF8, 0x11, 0x40, 0x21, 0x48, 0x04, 0x80, 0x20, 0x46, 0xFF, 0xF7, + 0x2F, 0xFF, 0x20, 0x46, + 0xFF, 0xF7, 0x8A, 0xFE, 0x29, 0x78, 0x39, 0xF8, 0x11, 0x00, 0x1B, 0x49, + 0xA1, 0xF8, 0x1B, 0x00, + 0xBD, 0xE8, 0xF8, 0x8F, 0x2D, 0xE9, 0xFC, 0x5F, 0x0E, 0x49, 0x4F, 0xF0, + 0x00, 0x09, 0x0D, 0x78, + 0x0B, 0x49, 0x09, 0x78, 0x01, 0x29, 0x00, 0xD1, 0x89, 0x46, 0x0F, 0x49, + 0x10, 0x26, 0x14, 0x39, + 0x04, 0x46, 0x4A, 0x68, 0x12, 0x48, 0x92, 0xFB, 0xF6, 0xF3, 0x06, 0xFB, + 0x13, 0x22, 0x6A, 0x43, + 0x4F, 0x78, 0x4F, 0xEA, 0x05, 0x1A, 0x00, 0xEB, 0x42, 0x08, 0x83, 0x46, + 0x7F, 0x1C, 0x3D, 0xE0, + 0xF3, 0x06, 0x10, 0x00, 0xEE, 0x06, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x9C, 0x06, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, 0xEC, 0x06, 0x10, 0x00, 0xE4, 0x06, 0x10, 0x00, + 0xF6, 0x06, 0x10, 0x00, + 0xF7, 0x06, 0x10, 0x00, 0xF5, 0x06, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, + 0x78, 0x06, 0x10, 0x00, + 0xB2, 0x1C, 0x01, 0x20, 0x2A, 0x48, 0x00, 0x68, 0x90, 0xF8, 0xF0, 0x11, + 0x89, 0x06, 0x14, 0xD5, + 0x28, 0x49, 0x49, 0x68, 0x00, 0x29, 0x0E, 0xDD, 0xA5, 0xEB, 0x09, 0x02, + 0xB0, 0xF9, 0x06, 0x12, + 0xCD, 0xE9, 0x00, 0x12, 0xB0, 0xF9, 0x04, 0x32, 0x04, 0xEB, 0x49, 0x00, + 0x0B, 0xEB, 0x49, 0x02, + 0x01, 0x46, 0x02, 0xF0, 0x9D, 0xFE, 0x0B, 0xEB, 0x4A, 0x0B, 0x6A, 0x00, + 0x21, 0x46, 0x40, 0x46, + 0x05, 0xF0, 0x03, 0xFF, 0x04, 0xEB, 0x45, 0x04, 0x08, 0xEB, 0x4A, 0x08, + 0x7F, 0x1E, 0xD9, 0xD2, + 0x18, 0x48, 0x4F, 0xF0, 0xFF, 0x31, 0x01, 0xEB, 0x46, 0x01, 0x42, 0x68, + 0x52, 0x1C, 0x42, 0x60, + 0x91, 0x42, 0x00, 0xDA, 0x46, 0x60, 0x40, 0x68, 0xB0, 0x42, 0x03, 0xDB, + 0xBD, 0xE8, 0xFC, 0x5F, + 0x11, 0x48, 0x45, 0xE7, 0xBD, 0xE8, 0xFC, 0x9F, 0x28, 0xE7, 0x10, 0xB5, + 0x0C, 0x4C, 0x20, 0x68, + 0x90, 0xF8, 0xF1, 0x01, 0xC0, 0xF3, 0x01, 0x12, 0xC0, 0xF3, 0x81, 0x01, + 0x00, 0xF0, 0x03, 0x00, + 0x01, 0xF0, 0x5B, 0xFF, 0x07, 0x49, 0x48, 0x70, 0x20, 0x68, 0x08, 0x49, + 0x90, 0xF8, 0xEC, 0x00, + 0x00, 0xF0, 0x03, 0x00, 0x08, 0x70, 0xFF, 0xF7, 0x36, 0xFE, 0xBD, 0xE8, + 0x10, 0x40, 0x0D, 0xE7, + 0x4C, 0x07, 0x10, 0x00, 0xD0, 0x06, 0x10, 0x00, 0xB2, 0x1C, 0x01, 0x20, + 0x74, 0x07, 0x10, 0x00, + 0x10, 0xB5, 0xBA, 0x48, 0x00, 0x24, 0x84, 0x61, 0x04, 0x62, 0xC4, 0x61, + 0xFF, 0xF7, 0xB9, 0xFA, + 0xFF, 0xF7, 0x6E, 0xFC, 0xB6, 0x48, 0x04, 0x80, 0xBD, 0xE8, 0x10, 0x40, + 0x00, 0xF0, 0x11, 0xB9, + 0x10, 0xB5, 0xB4, 0x48, 0xB1, 0x4C, 0x90, 0xF8, 0x30, 0x10, 0x61, 0x70, + 0x90, 0xF8, 0x31, 0x20, + 0xA2, 0x70, 0x51, 0x43, 0x61, 0x82, 0x90, 0xF8, 0x33, 0x10, 0xE1, 0x70, + 0x10, 0xF8, 0x2C, 0x1F, + 0x21, 0x70, 0x41, 0x78, 0x21, 0x71, 0x81, 0x78, 0x61, 0x71, 0xC1, 0x78, + 0xA1, 0x71, 0x41, 0x7A, + 0xE1, 0x71, 0x80, 0x7A, 0x20, 0x72, 0xA8, 0x48, 0x60, 0x62, 0x00, 0xF2, + 0x3C, 0x60, 0xA0, 0x62, + 0xA0, 0xF6, 0x78, 0x40, 0xE0, 0x62, 0xA5, 0x48, 0x20, 0x63, 0xA5, 0x48, + 0x01, 0x21, 0x00, 0x68, + 0x00, 0xF2, 0x61, 0x40, 0xEF, 0xF7, 0xDF, 0xFE, 0xA0, 0x82, 0x10, 0xBD, + 0x9D, 0x48, 0x10, 0xB5, + 0x9B, 0x49, 0x90, 0xF8, 0x2C, 0x00, 0x99, 0x4A, 0x88, 0x70, 0x08, 0x79, + 0x53, 0x7A, 0x63, 0xF3, + 0x00, 0x00, 0xD3, 0x7A, 0x63, 0xF3, 0xC3, 0x00, 0x93, 0x7A, 0x63, 0xF3, + 0x82, 0x00, 0x13, 0x7B, + 0x63, 0xF3, 0x41, 0x00, 0x97, 0x4B, 0xDB, 0x78, 0x0B, 0x72, 0x93, 0x7B, + 0xCB, 0x71, 0x53, 0x7B, + 0xD4, 0x7B, 0x63, 0xF3, 0x04, 0x10, 0x11, 0xF8, 0x0E, 0x3F, 0x12, 0x7C, + 0x64, 0xF3, 0x03, 0x03, + 0x62, 0xF3, 0x07, 0x13, 0x90, 0x4A, 0x01, 0xF8, 0x0B, 0x39, 0x12, 0x78, + 0x81, 0xF8, 0x25, 0x20, + 0x8E, 0x4A, 0x12, 0x88, 0xCA, 0x84, 0x8E, 0x4A, 0x12, 0x78, 0x62, 0xF3, + 0xC7, 0x10, 0x48, 0x70, + 0x8C, 0x48, 0x00, 0x88, 0x08, 0x85, 0x8C, 0x48, 0x00, 0x88, 0x48, 0x85, + 0x8B, 0x48, 0x02, 0x78, + 0x08, 0x7B, 0x62, 0xF3, 0x03, 0x00, 0x08, 0x73, 0x89, 0x48, 0x02, 0x78, + 0x48, 0x7B, 0x62, 0xF3, + 0x00, 0x00, 0x88, 0x4A, 0x12, 0x78, 0x62, 0xF3, 0x41, 0x00, 0x20, 0xF0, + 0x04, 0x00, 0x48, 0x73, + 0x10, 0xBD, 0x70, 0xB5, 0x0D, 0x46, 0x80, 0xEA, 0x05, 0x04, 0xE0, 0x06, + 0x01, 0xD5, 0xF6, 0xF7, + 0x89, 0xFA, 0xA0, 0x06, 0x01, 0xD5, 0xF4, 0xF7, 0x65, 0xFD, 0x14, 0xF0, + 0x48, 0x0F, 0x05, 0xD0, + 0x6E, 0x48, 0x15, 0xF0, 0x48, 0x01, 0x00, 0xD0, 0x01, 0x21, 0x41, 0x74, + 0x70, 0xBD, 0x70, 0xB5, + 0x79, 0x4D, 0x2C, 0x68, 0x00, 0x2C, 0x0D, 0xD0, 0x68, 0x49, 0xA0, 0xB2, + 0x0A, 0x7A, 0xC9, 0x79, + 0x01, 0xF0, 0x44, 0xF9, 0x28, 0x68, 0xA0, 0x43, 0x28, 0x60, 0x03, 0xD1, + 0xBD, 0xE8, 0x70, 0x40, + 0x01, 0xF0, 0xB7, 0xB9, 0x70, 0xBD, 0xF8, 0xB5, 0x00, 0x26, 0x00, 0xF0, + 0xC1, 0xFF, 0x01, 0x20, + 0xEF, 0xF7, 0xF7, 0xF8, 0x00, 0xF0, 0x8F, 0xF8, 0x5C, 0x4D, 0x5E, 0x4C, + 0x95, 0xF8, 0x20, 0x00, + 0x80, 0x07, 0x02, 0xD5, 0xA0, 0x68, 0xFF, 0xF7, 0xE6, 0xFB, 0x95, 0xF8, + 0x20, 0x00, 0xC0, 0x07, + 0x09, 0xD0, 0xE0, 0x68, 0x00, 0x90, 0xD4, 0xE9, 0x00, 0x01, 0xD4, 0xE9, + 0x04, 0x23, 0xFF, 0xF7, + 0x8A, 0xF9, 0x06, 0x00, 0x0A, 0xD1, 0x28, 0x8C, 0x80, 0x05, 0x07, 0xD5, + 0x94, 0xF8, 0x32, 0x10, + 0xA0, 0x69, 0xF4, 0xF7, 0xF8, 0xFD, 0xE8, 0x69, 0x18, 0xB9, 0x0C, 0xE0, + 0xE8, 0x69, 0x50, 0xB1, + 0x4E, 0xB9, 0x03, 0x20, 0xEF, 0xF7, 0xCD, 0xF8, 0x4A, 0x48, 0xE9, 0x69, + 0xFE, 0xF7, 0x8B, 0xFF, + 0x03, 0x20, 0xEF, 0xF7, 0xE1, 0xF8, 0xFF, 0xF7, 0x51, 0xFF, 0xFF, 0xF7, + 0xB0, 0xFF, 0xFF, 0xF7, + 0x6C, 0xFB, 0xFF, 0xF7, 0x88, 0xFA, 0xBD, 0xE8, 0xF8, 0x40, 0x01, 0x20, + 0xEF, 0xF7, 0xD4, 0xB8, + 0x3E, 0x48, 0x81, 0x7A, 0x01, 0x29, 0x08, 0xD0, 0xC1, 0x7A, 0x01, 0x29, + 0x05, 0xD0, 0x01, 0x7B, + 0x01, 0x29, 0x02, 0xD0, 0x80, 0x7B, 0x00, 0x28, 0x00, 0xD0, 0x01, 0x20, + 0x70, 0x47, 0x08, 0xB5, + 0xFF, 0xF7, 0xF6, 0xFE, 0x6B, 0x46, 0x00, 0x22, 0x03, 0x21, 0x02, 0x20, + 0xEF, 0xF7, 0x0A, 0xF8, + 0x00, 0x98, 0xC0, 0x07, 0x05, 0xD0, 0x01, 0x21, 0x02, 0x20, 0xEE, 0xF7, + 0xE6, 0xFF, 0xFF, 0xF7, + 0x9A, 0xFF, 0x00, 0x98, 0x80, 0x07, 0xED, 0xD5, 0x02, 0x21, 0x08, 0x46, + 0xEE, 0xF7, 0xDD, 0xFF, + 0xE8, 0xE7, 0x2F, 0x48, 0x10, 0xB5, 0x02, 0x68, 0x28, 0x48, 0x00, 0x24, + 0x92, 0xF8, 0x31, 0x10, + 0x41, 0x70, 0x92, 0xF8, 0x30, 0x20, 0x82, 0x70, 0x51, 0x43, 0x41, 0x82, + 0x29, 0x49, 0xC9, 0x78, + 0xC1, 0x70, 0x01, 0x21, 0x01, 0x71, 0x41, 0x71, 0x81, 0x71, 0x01, 0x70, + 0x84, 0x82, 0xC4, 0x71, + 0x04, 0x72, 0xC4, 0x73, 0x04, 0x74, 0xFF, 0xF7, 0x62, 0xF9, 0xFF, 0xF7, + 0x5F, 0xFB, 0xFE, 0xF7, + 0x9D, 0xFE, 0x43, 0xF6, 0x58, 0x61, 0x29, 0x48, 0x05, 0xF0, 0xFE, 0xFD, + 0x28, 0x48, 0x04, 0x80, + 0x28, 0x48, 0x04, 0x80, 0x10, 0xBD, 0x70, 0xB5, 0x14, 0x4E, 0x16, 0x4D, + 0x31, 0x6A, 0x28, 0x6A, + 0x81, 0xEA, 0x00, 0x04, 0x19, 0xB9, 0x10, 0xB1, 0xFF, 0xF7, 0xAA, 0xFE, + 0x11, 0xE0, 0xA0, 0x07, + 0x01, 0xD5, 0xFF, 0xF7, 0x43, 0xFB, 0xE0, 0x07, 0x03, 0xD0, 0xFF, 0xF7, + 0x40, 0xF9, 0xFF, 0xF7, + 0x7B, 0xFE, 0xE0, 0x06, 0x01, 0xD5, 0xFF, 0xF7, 0xED, 0xF8, 0xA0, 0x05, + 0x01, 0xD5, 0xF4, 0xF7, + 0x61, 0xFD, 0xE9, 0x69, 0xB0, 0x69, 0xFF, 0xF7, 0x1C, 0xFF, 0xE8, 0x69, + 0xB0, 0x61, 0x28, 0x6A, + 0x30, 0x62, 0x68, 0x6A, 0xF0, 0x61, 0xBD, 0xE8, 0x70, 0x40, 0x99, 0xE6, + 0xEC, 0x06, 0x10, 0x00, + 0x0A, 0x44, 0x01, 0x20, 0xCC, 0x68, 0x10, 0x00, 0xEE, 0x35, 0x01, 0x20, + 0x42, 0x44, 0x01, 0x20, + 0x4C, 0x07, 0x10, 0x00, 0x74, 0x07, 0x10, 0x00, 0x75, 0x06, 0x10, 0x00, + 0x7A, 0x06, 0x10, 0x00, + 0x7D, 0x07, 0x10, 0x00, 0x7E, 0x07, 0x10, 0x00, 0x80, 0x07, 0x10, 0x00, + 0x66, 0x05, 0x10, 0x00, + 0x64, 0x05, 0x10, 0x00, 0x74, 0x05, 0x10, 0x00, 0x68, 0x07, 0x10, 0x00, + 0x20, 0x4D, 0x01, 0x20, + 0x82, 0x07, 0x10, 0x00, 0x84, 0x07, 0x10, 0x00, 0x0B, 0x4D, 0x00, 0x20, + 0x0B, 0x4C, 0x28, 0x60, + 0x28, 0x68, 0x40, 0x1C, 0x28, 0x60, 0xEE, 0xF7, 0xEB, 0xFD, 0xF0, 0xF7, + 0x70, 0xF9, 0x01, 0x28, + 0x20, 0x68, 0x06, 0xD0, 0x40, 0xF0, 0x04, 0x00, 0x20, 0x60, 0xEE, 0xF7, + 0xDF, 0xFD, 0x30, 0xBF, + 0xEE, 0xE7, 0x20, 0xF0, 0x04, 0x00, 0xF7, 0xE7, 0x30, 0x07, 0x10, 0x00, + 0x10, 0xED, 0x00, 0xE0, + 0x2D, 0xE9, 0xF0, 0x47, 0x1C, 0x4D, 0xDF, 0xF8, 0x74, 0x90, 0xA8, 0x46, + 0x20, 0x21, 0x1A, 0x48, + 0x05, 0xF0, 0x82, 0xFD, 0x18, 0x48, 0x00, 0xF0, 0x53, 0xFB, 0x47, 0x1E, + 0xD9, 0xF8, 0x00, 0x00, + 0x98, 0xF8, 0x00, 0x60, 0x08, 0xF1, 0x01, 0x04, 0x90, 0xF8, 0xA0, 0x00, + 0xC0, 0x07, 0x05, 0xD0, + 0x3A, 0x46, 0x21, 0x46, 0x30, 0x46, 0x00, 0xF0, 0x23, 0xF8, 0x28, 0xB9, + 0x3A, 0x46, 0x21, 0x46, + 0x30, 0x46, 0x00, 0xF0, 0xD3, 0xF8, 0x18, 0xB1, 0x01, 0x20, 0x29, 0x68, + 0x01, 0xF0, 0xF3, 0xF8, + 0x00, 0xF0, 0x50, 0xFB, 0x00, 0x28, 0xD9, 0xD1, 0xBD, 0xE8, 0xF0, 0x87, + 0x38, 0xB5, 0x0C, 0x46, + 0x05, 0x46, 0xEE, 0xF7, 0xE6, 0xFE, 0x69, 0x46, 0x28, 0x46, 0xEE, 0xF7, + 0x1C, 0xFF, 0x00, 0x99, + 0x21, 0x42, 0xF8, 0xD1, 0x38, 0xBD, 0x00, 0x00, 0xD0, 0x4E, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0x70, 0xB5, 0x0D, 0x46, 0x00, 0x24, 0xA0, 0xF1, 0x10, 0x01, 0x03, 0x29, + 0x01, 0xD8, 0x52, 0x48, + 0x05, 0xE0, 0xA0, 0xF1, 0x30, 0x01, 0x0A, 0x29, 0x06, 0xD8, 0x4F, 0x48, + 0x20, 0x30, 0x50, 0xF8, + 0x31, 0x30, 0x00, 0xEB, 0xC1, 0x00, 0x0A, 0xE0, 0x62, 0x28, 0x10, 0xD1, + 0x4A, 0x49, 0xA0, 0xF1, + 0x62, 0x00, 0xA1, 0xF1, 0x08, 0x01, 0x51, 0xF8, 0x30, 0x30, 0x01, 0xEB, + 0xC0, 0x00, 0x4F, 0xF0, + 0x01, 0x04, 0x40, 0x68, 0x90, 0x42, 0x02, 0xD1, 0x11, 0x46, 0x28, 0x46, + 0x98, 0x47, 0x20, 0x46, + 0x70, 0xBD, 0x42, 0x49, 0x43, 0x20, 0x08, 0x60, 0x04, 0x21, 0x01, 0x20, + 0xFF, 0xF7, 0xBE, 0xBF, + 0x3E, 0x49, 0x00, 0x20, 0x08, 0x60, 0x04, 0x21, 0x01, 0x20, 0xFF, 0xF7, + 0xB7, 0xBF, 0xEF, 0xF7, + 0x92, 0xBB, 0x10, 0xB5, 0xEE, 0xF7, 0x5C, 0xFD, 0x39, 0x49, 0x1E, 0x20, + 0x08, 0x60, 0xEE, 0xF7, + 0x55, 0xFD, 0x02, 0x21, 0x05, 0x20, 0x01, 0xF0, 0x96, 0xF8, 0xBD, 0xE8, + 0x10, 0x40, 0x4F, 0xF4, + 0x80, 0x71, 0x00, 0x20, 0xFF, 0xF7, 0xA2, 0xBF, 0x32, 0x49, 0x02, 0x78, + 0x0A, 0x70, 0x42, 0x78, + 0x4A, 0x70, 0x01, 0x78, 0x4B, 0x07, 0x30, 0x49, 0x0A, 0x68, 0x02, 0xD5, + 0x42, 0xF0, 0x04, 0x02, + 0x01, 0xE0, 0x22, 0xF0, 0x04, 0x02, 0x0A, 0x60, 0x02, 0x78, 0x12, 0x07, + 0x0A, 0x68, 0x02, 0xD5, + 0x42, 0xF0, 0x02, 0x02, 0x01, 0xE0, 0x22, 0xF0, 0x02, 0x02, 0x0A, 0x60, + 0x02, 0x78, 0xD2, 0x06, + 0x0A, 0x68, 0x02, 0xD5, 0x42, 0xF0, 0x01, 0x02, 0x01, 0xE0, 0x22, 0xF0, + 0x01, 0x02, 0x0A, 0x60, + 0x00, 0x78, 0x40, 0x06, 0x02, 0xD5, 0x42, 0xF0, 0x10, 0x00, 0x01, 0xE0, + 0x22, 0xF0, 0x10, 0x00, + 0x08, 0x60, 0x08, 0x21, 0x01, 0x20, 0xFF, 0xF7, 0x71, 0xBF, 0x00, 0x78, + 0x28, 0xB1, 0x01, 0x28, + 0x05, 0xD1, 0x10, 0x21, 0x01, 0x20, 0xFF, 0xF7, 0x69, 0xBF, 0x04, 0x21, + 0xFA, 0xE7, 0x70, 0x47, + 0x02, 0x78, 0x15, 0x48, 0x01, 0x68, 0x22, 0xB1, 0x01, 0x2A, 0x05, 0xD0, + 0x02, 0x2A, 0x08, 0xD1, + 0x0B, 0xE0, 0x21, 0xF0, 0x08, 0x01, 0x01, 0xE0, 0x41, 0xF0, 0x08, 0x01, + 0x21, 0xF0, 0x40, 0x01, + 0x01, 0x60, 0x08, 0x21, 0x01, 0x20, 0xFF, 0xF7, 0x51, 0xBF, 0x21, 0xF0, + 0x08, 0x01, 0x41, 0xF0, + 0x40, 0x01, 0xF5, 0xE7, 0x70, 0x47, 0x70, 0x47, 0x70, 0x47, 0x70, 0x47, + 0x70, 0x47, 0x70, 0x47, + 0x70, 0x47, 0x70, 0x47, 0x00, 0xF0, 0x21, 0xBC, 0x50, 0x7A, 0x01, 0x00, + 0x6C, 0x07, 0x10, 0x00, + 0x54, 0x07, 0x10, 0x00, 0xF0, 0x4F, 0x10, 0x00, 0x70, 0x07, 0x10, 0x00, + 0x0B, 0x46, 0x10, 0xB5, + 0x00, 0x21, 0xA0, 0x38, 0x09, 0x28, 0x06, 0xD8, 0xF7, 0x49, 0x51, 0xF8, + 0x20, 0x40, 0x11, 0x46, + 0x18, 0x46, 0xA0, 0x47, 0x01, 0x46, 0x08, 0x46, 0x10, 0xBD, 0x00, 0x20, + 0x70, 0x47, 0x70, 0xB5, + 0x00, 0x23, 0x00, 0x29, 0x11, 0xDD, 0x02, 0x78, 0x49, 0x1E, 0x03, 0x2A, + 0x0D, 0xD2, 0xEE, 0x4D, + 0x40, 0x1C, 0x28, 0x35, 0x55, 0xF8, 0x32, 0x40, 0x05, 0xEB, 0xC2, 0x02, + 0x52, 0x68, 0x00, 0x2A, + 0x03, 0xDB, 0x91, 0x42, 0x01, 0xD1, 0xA0, 0x47, 0x03, 0x46, 0x18, 0x46, + 0x70, 0xBD, 0x10, 0xB5, + 0x00, 0x78, 0x00, 0x21, 0xC2, 0x07, 0x00, 0xD0, 0x01, 0x21, 0x82, 0x07, + 0x01, 0xD5, 0x41, 0xF0, + 0x02, 0x01, 0xC0, 0x06, 0x01, 0xD5, 0x41, 0xF0, 0x40, 0x01, 0xE0, 0x48, + 0x02, 0x68, 0x8A, 0x42, + 0x04, 0xD0, 0x01, 0x60, 0x04, 0x21, 0x01, 0x20, 0xFF, 0xF7, 0xF8, 0xFE, + 0x01, 0x20, 0x10, 0xBD, + 0x00, 0x20, 0x70, 0x47, 0x70, 0xB5, 0x00, 0x23, 0x00, 0x29, 0x0F, 0xDD, + 0x02, 0x78, 0x49, 0x1E, + 0x05, 0x2A, 0x0B, 0xD2, 0xD4, 0x4D, 0x40, 0x1C, 0x40, 0x35, 0x55, 0xF8, + 0x32, 0x40, 0x05, 0xEB, + 0xC2, 0x02, 0x52, 0x68, 0x91, 0x42, 0x01, 0xD1, 0xA0, 0x47, 0x03, 0x46, + 0x18, 0x46, 0x70, 0xBD, + 0x10, 0xB5, 0x00, 0x78, 0xC2, 0x07, 0xCE, 0x48, 0x01, 0x68, 0x02, 0xD0, + 0x41, 0xF0, 0x02, 0x01, + 0x01, 0xE0, 0x21, 0xF0, 0x02, 0x01, 0x01, 0x60, 0x08, 0x21, 0x01, 0x20, + 0xFF, 0xF7, 0xCE, 0xFE, + 0x01, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x78, 0xC2, 0x07, 0xC5, 0x48, + 0x01, 0x68, 0x02, 0xD0, + 0x41, 0xF0, 0x04, 0x01, 0x01, 0xE0, 0x21, 0xF0, 0x04, 0x01, 0x01, 0x60, + 0x08, 0x21, 0x01, 0x20, + 0xFF, 0xF7, 0xBC, 0xFE, 0x01, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x01, 0x78, + 0xCB, 0x07, 0xBC, 0x49, + 0x0A, 0x68, 0x02, 0xD0, 0x42, 0xF0, 0x08, 0x02, 0x01, 0xE0, 0x22, 0xF0, + 0x08, 0x02, 0x0A, 0x60, + 0x00, 0x78, 0x80, 0x07, 0x02, 0xD5, 0x42, 0xF0, 0x40, 0x00, 0x01, 0xE0, + 0x22, 0xF0, 0x40, 0x00, + 0x08, 0x60, 0x08, 0x21, 0x01, 0x20, 0xFF, 0xF7, 0xA1, 0xFE, 0x01, 0x20, + 0x10, 0xBD, 0x00, 0x20, + 0x70, 0x47, 0x00, 0x20, 0x70, 0x47, 0x70, 0xB5, 0x00, 0x23, 0x00, 0x29, + 0x0F, 0xDD, 0x02, 0x78, + 0x49, 0x1E, 0x0A, 0x2A, 0x0B, 0xD2, 0xA8, 0x4D, 0x40, 0x1C, 0x68, 0x35, + 0x55, 0xF8, 0x32, 0x40, + 0x05, 0xEB, 0xC2, 0x02, 0x52, 0x68, 0x91, 0x42, 0x01, 0xD1, 0xA0, 0x47, + 0x03, 0x46, 0x18, 0x46, + 0x70, 0xBD, 0x01, 0x46, 0x00, 0x20, 0x09, 0x78, 0x04, 0x29, 0x06, 0xD2, + 0x9E, 0x48, 0xB8, 0x30, + 0x50, 0xF8, 0x21, 0x20, 0x00, 0x21, 0x08, 0x46, 0x10, 0x47, 0x70, 0x47, + 0x10, 0xB5, 0xEF, 0xF7, + 0x52, 0xFA, 0x01, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0xF0, 0x4F, 0xFB, + 0x01, 0x20, 0x10, 0xBD, + 0x10, 0xB5, 0x4F, 0xF4, 0x00, 0x61, 0x00, 0x20, 0xFF, 0xF7, 0x68, 0xFE, + 0x01, 0x20, 0x10, 0xBD, + 0x10, 0xB5, 0x4F, 0xF4, 0x80, 0x51, 0x00, 0x20, 0xFF, 0xF7, 0x60, 0xFE, + 0x01, 0x20, 0x10, 0xBD, + 0x10, 0xB5, 0x00, 0x78, 0xC0, 0x07, 0x02, 0xD0, 0x00, 0xF0, 0xD8, 0xFA, + 0x01, 0xE0, 0x00, 0xF0, + 0xCC, 0xFA, 0x01, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x88, 0x00, 0x24, + 0xC1, 0x07, 0x00, 0xD0, + 0x02, 0x24, 0x81, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x04, 0x04, 0x41, 0x07, + 0x01, 0xD5, 0x44, 0xF0, + 0x08, 0x04, 0xC1, 0x06, 0x01, 0xD5, 0x44, 0xF0, 0x10, 0x04, 0x00, 0x06, + 0x01, 0xD5, 0x44, 0xF0, + 0x80, 0x04, 0x94, 0xB1, 0xEE, 0xF7, 0xE4, 0xFB, 0x7E, 0x48, 0x01, 0x68, + 0x21, 0x43, 0x01, 0x60, + 0xEE, 0xF7, 0xDC, 0xFB, 0x02, 0x21, 0x05, 0x20, 0x00, 0xF0, 0x1D, 0xFF, + 0x4F, 0xF4, 0x80, 0x71, + 0x00, 0x20, 0xFF, 0xF7, 0x2B, 0xFE, 0x01, 0x20, 0x10, 0xBD, 0x00, 0x20, + 0x10, 0xBD, 0x10, 0xB5, + 0x00, 0x88, 0x00, 0x24, 0xC1, 0x07, 0x00, 0xD0, 0x01, 0x24, 0x81, 0x07, + 0x01, 0xD5, 0x44, 0xF0, + 0x02, 0x04, 0x41, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x04, 0x04, 0x01, 0x07, + 0x01, 0xD5, 0x44, 0xF0, + 0x08, 0x04, 0xC1, 0x05, 0x01, 0xD5, 0x44, 0xF4, 0x00, 0x74, 0x81, 0x05, + 0x01, 0xD5, 0x44, 0xF4, + 0x80, 0x64, 0xC1, 0x06, 0x01, 0xD5, 0x44, 0xF0, 0x10, 0x04, 0x00, 0x06, + 0x01, 0xD5, 0x44, 0xF0, + 0x80, 0x04, 0x6C, 0xB1, 0xEE, 0xF7, 0xAC, 0xFB, 0x63, 0x48, 0x01, 0x68, + 0x21, 0x43, 0x01, 0x60, + 0xEE, 0xF7, 0xA4, 0xFB, 0x02, 0x21, 0x00, 0x20, 0xFF, 0xF7, 0xF8, 0xFD, + 0x01, 0x20, 0x10, 0xBD, + 0x00, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x88, 0x00, 0x24, 0xC1, 0x07, + 0x00, 0xD0, 0x01, 0x24, + 0x81, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x02, 0x04, 0x41, 0x07, 0x01, 0xD5, + 0x44, 0xF0, 0x04, 0x04, + 0x01, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x08, 0x04, 0xC0, 0x06, 0x01, 0xD5, + 0x44, 0xF0, 0x10, 0x04, + 0x74, 0xB1, 0xEE, 0xF7, 0x85, 0xFB, 0x51, 0x48, 0x01, 0x68, 0x21, 0x43, + 0x01, 0x60, 0xEE, 0xF7, + 0x7D, 0xFB, 0x4F, 0xF4, 0x00, 0x11, 0x00, 0x20, 0xFF, 0xF7, 0xD0, 0xFD, + 0x01, 0x20, 0x10, 0xBD, + 0x00, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x88, 0x00, 0x24, 0xC1, 0x07, + 0x00, 0xD0, 0x01, 0x24, + 0x81, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x02, 0x04, 0x41, 0x07, 0x01, 0xD5, + 0x44, 0xF0, 0x04, 0x04, + 0x01, 0x07, 0x01, 0xD5, 0x44, 0xF0, 0x08, 0x04, 0xC1, 0x06, 0x01, 0xD5, + 0x44, 0xF0, 0x10, 0x04, + 0x81, 0x06, 0x01, 0xD5, 0x44, 0xF0, 0x20, 0x04, 0x41, 0x06, 0x01, 0xD5, + 0x44, 0xF0, 0x40, 0x04, + 0x01, 0x06, 0x01, 0xD5, 0x44, 0xF0, 0x80, 0x04, 0xC1, 0x05, 0x01, 0xD5, + 0x44, 0xF4, 0x80, 0x74, + 0x81, 0x05, 0x01, 0xD5, 0x44, 0xF4, 0x00, 0x74, 0x40, 0x05, 0x01, 0xD5, + 0x44, 0xF4, 0x80, 0x64, + 0x6C, 0xB1, 0xEE, 0xF7, 0x45, 0xFB, 0x32, 0x48, 0x01, 0x68, 0x21, 0x43, + 0x01, 0x60, 0xEE, 0xF7, + 0x3D, 0xFB, 0x80, 0x21, 0x00, 0x20, 0xFF, 0xF7, 0x91, 0xFD, 0x01, 0x20, + 0x10, 0xBD, 0x00, 0x20, + 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x78, 0x00, 0x24, 0xC1, 0x07, 0x00, 0xD0, + 0x01, 0x24, 0x81, 0x07, + 0x01, 0xD5, 0x44, 0xF0, 0x02, 0x04, 0x40, 0x07, 0x01, 0xD5, 0x44, 0xF0, + 0x04, 0x04, 0x74, 0xB1, + 0xEE, 0xF7, 0x26, 0xFB, 0x23, 0x48, 0x01, 0x68, 0x21, 0x43, 0x01, 0x60, + 0xEE, 0xF7, 0x1E, 0xFB, + 0x4F, 0xF4, 0x80, 0x61, 0x00, 0x20, 0xFF, 0xF7, 0x71, 0xFD, 0x01, 0x20, + 0x10, 0xBD, 0x00, 0x20, + 0x10, 0xBD, 0x10, 0xB5, 0x00, 0x78, 0x00, 0x24, 0x31, 0x28, 0x39, 0xD0, + 0x10, 0xDC, 0x12, 0x28, + 0x32, 0xD0, 0x06, 0xDC, 0x01, 0x28, 0x1C, 0xD0, 0x10, 0x28, 0x2D, 0xD0, + 0x11, 0x28, 0x31, 0xD1, + 0x2A, 0xE0, 0x13, 0x28, 0x28, 0xD0, 0x14, 0x28, 0x26, 0xD0, 0x30, 0x28, + 0x2A, 0xD1, 0x27, 0xE0, + 0x51, 0x28, 0x29, 0xD0, 0x06, 0xDC, 0x32, 0x28, 0x22, 0xD0, 0x33, 0x28, + 0x20, 0xD0, 0x50, 0x28, + 0x20, 0xD1, 0x21, 0xE0, 0x52, 0x28, 0x1F, 0xD0, 0x53, 0x28, 0x1D, 0xD0, + 0x54, 0x28, 0x19, 0xD1, + 0x1A, 0xE0, 0x00, 0xF0, 0x5B, 0xFC, 0x11, 0xE0, 0xC8, 0x7A, 0x01, 0x00, + 0x6C, 0x07, 0x10, 0x00, + 0x70, 0x07, 0x10, 0x00, 0x54, 0x07, 0x10, 0x00, 0x58, 0x07, 0x10, 0x00, + 0x5C, 0x07, 0x10, 0x00, + 0x64, 0x07, 0x10, 0x00, 0x60, 0x07, 0x10, 0x00, 0x00, 0xF0, 0xDC, 0xFC, + 0x01, 0x24, 0x01, 0xE0, + 0x00, 0xF0, 0xF8, 0xFC, 0x20, 0x46, 0x10, 0xBD, 0x00, 0xF0, 0xE2, 0xFC, + 0xF6, 0xE7, 0x00, 0x00, + 0x08, 0xB5, 0x00, 0xF0, 0x3B, 0xFC, 0x00, 0xF0, 0xE3, 0xFD, 0x17, 0x4C, + 0x6B, 0x46, 0x00, 0x22, + 0x19, 0x21, 0x03, 0x20, 0xEE, 0xF7, 0x4E, 0xFC, 0x00, 0x98, 0xC0, 0x07, + 0x05, 0xD0, 0x01, 0x21, + 0x03, 0x20, 0xEE, 0xF7, 0x2A, 0xFC, 0xFF, 0xF7, 0xE3, 0xFC, 0x00, 0x98, + 0x00, 0x07, 0x0B, 0xD5, + 0x08, 0x21, 0x03, 0x20, 0xEE, 0xF7, 0x21, 0xFC, 0x20, 0x68, 0x08, 0x21, + 0x40, 0xF0, 0x08, 0x00, + 0x20, 0x60, 0x01, 0x20, 0xFF, 0xF7, 0x02, 0xFD, 0x00, 0x98, 0xC0, 0x06, + 0xDE, 0xD5, 0x10, 0x21, + 0x03, 0x20, 0xEE, 0xF7, 0x12, 0xFC, 0x20, 0x68, 0x08, 0x21, 0x20, 0xF0, + 0x08, 0x00, 0x20, 0x60, + 0x01, 0x20, 0xFF, 0xF7, 0xF3, 0xFC, 0xD1, 0xE7, 0x70, 0x07, 0x10, 0x00, + 0x1F, 0x48, 0x00, 0x21, + 0x01, 0x70, 0x41, 0x70, 0x81, 0x70, 0x70, 0x47, 0x10, 0xB5, 0x1C, 0x4C, + 0x03, 0x46, 0xA0, 0x78, + 0x10, 0x28, 0x14, 0xD2, 0x0F, 0x29, 0x00, 0xD9, 0x0F, 0x21, 0x19, 0x48, + 0x22, 0x78, 0x00, 0xEB, + 0x02, 0x10, 0x0A, 0x46, 0x00, 0xF8, 0x01, 0x1B, 0x19, 0x46, 0x05, 0xF0, + 0xB6, 0xF9, 0x20, 0x78, + 0x40, 0x1C, 0x00, 0xF0, 0x0F, 0x00, 0x20, 0x70, 0xA0, 0x78, 0x40, 0x1C, + 0xA0, 0x70, 0x10, 0xBD, + 0x70, 0xB5, 0x0E, 0x4C, 0x00, 0x25, 0xA1, 0x78, 0x91, 0xB1, 0x0D, 0x49, + 0x62, 0x78, 0x01, 0xEB, + 0x02, 0x11, 0x11, 0xF8, 0x01, 0x5B, 0x2A, 0x46, 0x05, 0xF0, 0x9F, 0xF9, + 0x60, 0x78, 0x40, 0x1C, + 0x00, 0xF0, 0x0F, 0x00, 0x60, 0x70, 0x72, 0xB6, 0xA0, 0x78, 0x40, 0x1E, + 0xA0, 0x70, 0x62, 0xB6, + 0x28, 0x46, 0x70, 0xBD, 0x01, 0x48, 0x80, 0x78, 0x70, 0x47, 0x00, 0x00, + 0x34, 0x07, 0x10, 0x00, + 0xF0, 0x4E, 0x10, 0x00, 0x70, 0xB5, 0x14, 0x46, 0x00, 0x20, 0x05, 0xF0, + 0xAB, 0xFA, 0x00, 0xF0, + 0x01, 0x05, 0x01, 0x20, 0x05, 0xF0, 0xA6, 0xFA, 0x00, 0xF0, 0x01, 0x00, + 0x45, 0xEA, 0x00, 0x10, + 0x20, 0x70, 0x01, 0x20, 0x70, 0xBD, 0x80, 0x20, 0x10, 0x70, 0x01, 0x20, + 0x70, 0x47, 0x10, 0xB5, + 0x14, 0x46, 0xEF, 0xF7, 0x64, 0xF8, 0x53, 0x21, 0x21, 0x70, 0x54, 0x21, + 0x61, 0x70, 0x01, 0x0A, + 0xA1, 0x70, 0xE0, 0x70, 0xEF, 0xF7, 0x5F, 0xF8, 0x20, 0x71, 0x05, 0x20, + 0x10, 0xBD, 0x38, 0xB5, + 0x14, 0x46, 0x70, 0x4A, 0x13, 0x68, 0x59, 0x8E, 0x98, 0x8E, 0x93, 0xF8, + 0x36, 0x30, 0xDB, 0x07, + 0x0A, 0xD0, 0x03, 0x0A, 0x23, 0x70, 0x60, 0x70, 0x0D, 0x0A, 0xA5, 0x70, + 0xE1, 0x70, 0x23, 0x71, + 0x60, 0x71, 0xA5, 0x71, 0xE1, 0x71, 0x09, 0xE0, 0x0B, 0x0A, 0x23, 0x70, + 0x61, 0x70, 0x05, 0x0A, + 0xA5, 0x70, 0xE0, 0x70, 0x23, 0x71, 0x61, 0x71, 0xA5, 0x71, 0xE0, 0x71, + 0x10, 0x68, 0x90, 0xF8, + 0x31, 0x10, 0x21, 0x72, 0x10, 0xF8, 0x30, 0x1F, 0x61, 0x72, 0x90, 0xF8, + 0x31, 0x04, 0x8D, 0xF8, + 0x00, 0x00, 0x01, 0x21, 0x68, 0x46, 0xEF, 0xF7, 0x8E, 0xF9, 0xA0, 0x72, + 0x0B, 0x20, 0x38, 0xBD, + 0xA2, 0x20, 0x10, 0x70, 0x33, 0x20, 0x50, 0x70, 0x00, 0x20, 0x90, 0x70, + 0xD0, 0x70, 0x10, 0x71, + 0x50, 0x71, 0x06, 0x20, 0x70, 0x47, 0x08, 0xB5, 0x02, 0x23, 0x00, 0x93, + 0x52, 0x4B, 0x00, 0xF0, + 0x8D, 0xF8, 0x02, 0x20, 0x08, 0xBD, 0x08, 0xB5, 0x01, 0x23, 0x00, 0x93, + 0x4E, 0x4B, 0x9B, 0x1C, + 0x00, 0xF0, 0x84, 0xF8, 0x01, 0x20, 0x08, 0xBD, 0x08, 0xB5, 0x01, 0x23, + 0x00, 0x93, 0x4A, 0x4B, + 0xDB, 0x1C, 0x00, 0xF0, 0x7B, 0xF8, 0x01, 0x20, 0x08, 0xBD, 0x08, 0xB5, + 0x01, 0x23, 0x00, 0x93, + 0x45, 0x4B, 0x1B, 0x1D, 0x00, 0xF0, 0x72, 0xF8, 0x01, 0x20, 0x08, 0xBD, + 0x08, 0xB5, 0x01, 0x23, + 0x00, 0x93, 0x41, 0x4B, 0x5B, 0x1D, 0x00, 0xF0, 0x69, 0xF8, 0x01, 0x20, + 0x08, 0xBD, 0x08, 0xB5, + 0x01, 0x23, 0x00, 0x93, 0x3C, 0x4B, 0x9B, 0x1D, 0x00, 0xF0, 0x60, 0xF8, + 0x01, 0x20, 0x08, 0xBD, + 0x08, 0xB5, 0x02, 0x23, 0x00, 0x93, 0x38, 0x4B, 0xDB, 0x1D, 0x00, 0xF0, + 0x57, 0xF8, 0x02, 0x20, + 0x08, 0xBD, 0x08, 0xB5, 0x02, 0x23, 0x00, 0x93, 0x33, 0x4B, 0x09, 0x33, + 0x00, 0xF0, 0x4E, 0xF8, + 0x02, 0x20, 0x08, 0xBD, 0x08, 0xB5, 0x01, 0x23, 0x00, 0x93, 0x2F, 0x4B, + 0x0B, 0x33, 0x00, 0xF0, + 0x45, 0xF8, 0x01, 0x20, 0x08, 0xBD, 0x08, 0xB5, 0x01, 0x23, 0x00, 0x93, + 0x2A, 0x4B, 0x0C, 0x33, + 0x00, 0xF0, 0x3C, 0xF8, 0x01, 0x20, 0x08, 0xBD, 0x08, 0xB5, 0x01, 0x23, + 0x00, 0x93, 0x26, 0x4B, + 0x0D, 0x33, 0x00, 0xF0, 0x33, 0xF8, 0x01, 0x20, 0x08, 0xBD, 0x2D, 0xE9, + 0xF0, 0x41, 0x0F, 0x46, + 0x04, 0x46, 0x00, 0x78, 0x49, 0x1E, 0xCE, 0xB2, 0x00, 0x25, 0x63, 0x1C, + 0xA0, 0xF1, 0x20, 0x01, + 0x04, 0x29, 0x09, 0xD8, 0x1D, 0x49, 0x01, 0xEB, 0x80, 0x00, 0x31, 0x46, + 0x50, 0xF8, 0x80, 0x4C, + 0x18, 0x46, 0xA0, 0x47, 0x05, 0x46, 0x16, 0xE0, 0xA0, 0xF1, 0x30, 0x01, + 0x0B, 0x29, 0x12, 0xD8, + 0x16, 0x49, 0x14, 0x31, 0x01, 0xEB, 0x80, 0x00, 0x31, 0x46, 0x50, 0xF8, + 0xC0, 0x5C, 0x18, 0x46, + 0xA8, 0x47, 0x05, 0x46, 0x3E, 0xB1, 0x39, 0x46, 0x20, 0x46, 0xFF, 0xF7, + 0xD5, 0xFE, 0x01, 0x21, + 0x03, 0x20, 0xEE, 0xF7, 0xA6, 0xFA, 0x28, 0x46, 0xBD, 0xE8, 0xF0, 0x81, + 0x70, 0xB5, 0x1D, 0x46, + 0x04, 0x9C, 0x16, 0x46, 0x39, 0xB1, 0xA1, 0x42, 0x00, 0xD9, 0x21, 0x46, + 0x0A, 0x46, 0x01, 0x46, + 0x18, 0x46, 0x05, 0xF0, 0x8A, 0xF8, 0x22, 0x46, 0x29, 0x46, 0x30, 0x46, + 0xBD, 0xE8, 0x70, 0x40, + 0x05, 0xF0, 0x83, 0xB8, 0x4C, 0x07, 0x10, 0x00, 0xF0, 0x4F, 0x10, 0x00, + 0x90, 0x7B, 0x01, 0x00, + 0x10, 0xB5, 0x4F, 0xF4, 0x86, 0x71, 0x46, 0x48, 0x05, 0xF0, 0x18, 0xF9, + 0x44, 0x49, 0x01, 0x20, + 0xC1, 0xF8, 0x04, 0x01, 0x43, 0x49, 0x00, 0x20, 0x08, 0x70, 0x05, 0xF0, + 0xA1, 0xF9, 0x00, 0x21, + 0xBD, 0xE8, 0x10, 0x40, 0x01, 0x20, 0xEF, 0xF7, 0x20, 0xB9, 0x10, 0xB5, + 0x72, 0xB6, 0x00, 0x20, + 0x3C, 0x49, 0x08, 0x70, 0x05, 0xF0, 0x94, 0xF9, 0x62, 0xB6, 0x10, 0xBD, + 0x10, 0xB5, 0x72, 0xB6, + 0x01, 0x20, 0x38, 0x49, 0x08, 0x70, 0x36, 0x48, 0xD0, 0xF8, 0x08, 0x01, + 0x08, 0xB1, 0x05, 0xF0, + 0x2B, 0xF9, 0x62, 0xB6, 0x10, 0xBD, 0x10, 0xB5, 0x72, 0xB6, 0x31, 0x49, + 0xD1, 0xF8, 0x08, 0x31, + 0xD1, 0xF8, 0x00, 0x21, 0x20, 0x2B, 0x07, 0xD2, 0x5B, 0x1C, 0x52, 0x1C, + 0x22, 0xF0, 0x20, 0x02, + 0xC1, 0xF8, 0x08, 0x31, 0xC1, 0xF8, 0x00, 0x21, 0x01, 0xEB, 0xC2, 0x02, + 0x03, 0x68, 0x13, 0x60, + 0x40, 0x68, 0x50, 0x60, 0x27, 0x48, 0x00, 0x78, 0x01, 0x28, 0x05, 0xD1, + 0xD1, 0xF8, 0x08, 0x01, + 0x01, 0x28, 0x01, 0xD1, 0x05, 0xF0, 0x08, 0xF9, 0x62, 0xB6, 0x10, 0xBD, + 0x20, 0x4A, 0xD2, 0xF8, + 0x08, 0x01, 0x00, 0x28, 0x0E, 0xD0, 0xD2, 0xF8, 0x04, 0x01, 0x02, 0xEB, + 0xC0, 0x00, 0xC3, 0x79, + 0x23, 0xF0, 0x3F, 0x03, 0xC3, 0x71, 0x92, 0xF8, 0x08, 0x21, 0x52, 0x1E, + 0x02, 0xF0, 0x3F, 0x02, + 0x13, 0x43, 0xC3, 0x71, 0x70, 0x47, 0x10, 0xB5, 0x72, 0xB6, 0x15, 0x48, + 0xD0, 0xF8, 0x08, 0x11, + 0x59, 0xB1, 0x49, 0x1E, 0xC0, 0xF8, 0x08, 0x11, 0xD0, 0xF8, 0x04, 0x21, + 0x02, 0xF1, 0x01, 0x02, + 0x22, 0xF0, 0x20, 0x02, 0xC0, 0xF8, 0x04, 0x21, 0x05, 0xD1, 0x0E, 0x48, + 0x00, 0x78, 0x01, 0x28, + 0x01, 0xD1, 0x05, 0xF0, 0x35, 0xF9, 0x62, 0xB6, 0x10, 0xBD, 0x10, 0xB5, + 0x72, 0xB6, 0x00, 0x21, + 0x07, 0x48, 0xC0, 0xF8, 0x08, 0x11, 0xC0, 0xF8, 0x00, 0x11, 0x01, 0x21, + 0xC0, 0xF8, 0x04, 0x11, + 0x04, 0x48, 0x00, 0x78, 0x01, 0x28, 0x01, 0xD1, 0x05, 0xF0, 0x22, 0xF9, + 0x62, 0xB6, 0x10, 0xBD, + 0x68, 0x42, 0x01, 0x20, 0x37, 0x07, 0x10, 0x00, 0x18, 0x49, 0x00, 0x22, + 0x0A, 0x80, 0x4A, 0x80, + 0x4F, 0xF4, 0x70, 0x42, 0x8A, 0x80, 0x16, 0x4A, 0xCA, 0x80, 0x16, 0x4A, + 0x0A, 0x81, 0x16, 0x4A, + 0xC0, 0xE9, 0x00, 0x21, 0x05, 0x21, 0x01, 0x72, 0x70, 0x47, 0x1C, 0xB5, + 0x12, 0x49, 0xAD, 0xF8, + 0x04, 0x00, 0x02, 0x20, 0x8D, 0xF8, 0x06, 0x00, 0x04, 0x20, 0x09, 0x1F, + 0x8D, 0xF8, 0x07, 0x00, + 0x00, 0x91, 0x68, 0x46, 0xEF, 0xF7, 0x4B, 0xF9, 0x1C, 0xBD, 0x30, 0xB4, + 0x03, 0x46, 0x0A, 0x4A, + 0x00, 0x20, 0x14, 0x78, 0x9C, 0x42, 0x02, 0xD1, 0x30, 0xBC, 0xEF, 0xF7, + 0x76, 0xB9, 0x40, 0x1C, + 0xC0, 0xB2, 0x52, 0x1D, 0x05, 0x28, 0xF4, 0xD3, 0x30, 0xBC, 0x70, 0x47, + 0xFE, 0x4F, 0x10, 0x00, + 0x14, 0xA6, 0x01, 0x20, 0x6C, 0xA2, 0x01, 0x20, 0xD4, 0x7B, 0x01, 0x00, + 0x10, 0xB5, 0x88, 0xB3, + 0xA3, 0x49, 0xA4, 0x4A, 0x09, 0x78, 0x37, 0x29, 0x71, 0xD0, 0x11, 0xDC, + 0xA1, 0xF1, 0x20, 0x01, + 0x17, 0x29, 0x2C, 0xD2, 0xDF, 0xE8, 0x01, 0xF0, 0x6B, 0x6B, 0x6B, 0x6B, + 0x6B, 0x2B, 0x2B, 0x2B, + 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x2B, 0x6B, 0x6B, 0x6B, 0x6B, + 0x6B, 0x6B, 0x6B, 0x00, + 0x97, 0x4B, 0x70, 0x29, 0x5B, 0x78, 0x26, 0xD0, 0x0C, 0xDC, 0x3B, 0x29, + 0x57, 0xD0, 0x04, 0xDC, + 0x38, 0x29, 0x54, 0xD0, 0x3A, 0x29, 0x12, 0xD1, 0x51, 0xE0, 0x60, 0x29, + 0x19, 0xD0, 0x61, 0x29, + 0x0D, 0xD1, 0x16, 0xE0, 0x73, 0x29, 0x28, 0xD0, 0x05, 0xDC, 0x71, 0x29, + 0x15, 0xD0, 0x72, 0x29, + 0x05, 0xD1, 0x14, 0xE0, 0x0B, 0xE0, 0x85, 0x29, 0x0B, 0xD0, 0x86, 0x29, + 0x09, 0xD0, 0xC1, 0xB2, + 0x87, 0x48, 0xFF, 0xF7, 0xA9, 0xFD, 0x01, 0x21, 0x03, 0x20, 0xEE, 0xF7, + 0x7A, 0xF9, 0x00, 0x20, + 0x10, 0xBD, 0x02, 0x20, 0x10, 0xBD, 0x93, 0x70, 0xF9, 0xE7, 0xD3, 0x70, + 0xF7, 0xE7, 0x90, 0x78, + 0x01, 0x28, 0x08, 0xD0, 0x00, 0x28, 0xF2, 0xD1, 0x7F, 0x48, 0x81, 0xB2, + 0x5F, 0xF0, 0x72, 0x00, + 0xFF, 0xF7, 0x93, 0xFF, 0xEB, 0xE7, 0x7D, 0x48, 0xF7, 0xE7, 0xD0, 0x78, + 0x01, 0x28, 0x05, 0xD0, + 0x00, 0x28, 0xE4, 0xD1, 0x7A, 0x48, 0x81, 0xB2, 0x73, 0x20, 0xF1, 0xE7, + 0x79, 0x4C, 0x7A, 0x49, + 0x20, 0x68, 0x90, 0xF8, 0x31, 0x00, 0x42, 0x00, 0x71, 0x48, 0x10, 0x30, + 0x04, 0xF0, 0x45, 0xFF, + 0x20, 0x68, 0x10, 0xF8, 0x30, 0x1F, 0x4A, 0x00, 0x6D, 0x49, 0x40, 0x78, + 0x10, 0x31, 0x01, 0xEB, + 0x40, 0x00, 0x72, 0x49, 0x04, 0xF0, 0x39, 0xFF, 0x69, 0x48, 0x10, 0x30, + 0xE3, 0xE7, 0xC1, 0xB2, + 0x52, 0x68, 0x67, 0x48, 0xFF, 0xF7, 0x69, 0xFE, 0x6D, 0x49, 0x08, 0x70, + 0x01, 0x20, 0x10, 0xBD, + 0x2D, 0xE9, 0xF0, 0x5F, 0xDF, 0xF8, 0x88, 0xB1, 0x62, 0x4E, 0x62, 0x4D, + 0x89, 0x46, 0x07, 0x46, + 0x4F, 0xF0, 0x01, 0x0A, 0xAB, 0xF1, 0x10, 0x0B, 0x08, 0x36, 0x28, 0x78, + 0xA8, 0x46, 0x04, 0x46, + 0x07, 0x28, 0x76, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, 0x04, 0x21, 0x25, 0x40, + 0x5C, 0x78, 0x8A, 0x00, + 0x01, 0x2F, 0x02, 0xD0, 0x02, 0x2F, 0x0C, 0xD0, 0x6B, 0xE0, 0x48, 0x46, + 0xFF, 0xF7, 0x5E, 0xFF, + 0x02, 0x28, 0x02, 0xD0, 0x01, 0x28, 0x02, 0xD0, 0x63, 0xE0, 0x03, 0x24, + 0x61, 0xE0, 0x02, 0x24, + 0x5F, 0xE0, 0x68, 0x78, 0x01, 0x28, 0x04, 0xD0, 0x4D, 0x48, 0x10, 0x21, + 0x10, 0x38, 0x04, 0xF0, + 0x7B, 0xFF, 0x54, 0x46, 0x86, 0xF8, 0x00, 0xA0, 0x53, 0xE0, 0x02, 0x2F, + 0x4F, 0xD0, 0x00, 0x24, + 0x39, 0xE0, 0x02, 0x2F, 0x1A, 0xD1, 0x4E, 0x4C, 0x45, 0x48, 0xD8, 0xF8, + 0x04, 0x10, 0x22, 0x78, + 0x10, 0x38, 0x04, 0xF0, 0xEA, 0xFE, 0x03, 0x20, 0x30, 0x70, 0x20, 0x78, + 0xB0, 0x80, 0x98, 0xF8, + 0x00, 0x00, 0x04, 0x24, 0x88, 0xF8, 0x01, 0x00, 0x88, 0xF8, 0x00, 0x40, + 0x27, 0xE0, 0x00, 0x24, + 0x88, 0xF8, 0x01, 0x00, 0x2C, 0x70, 0xB8, 0xE7, 0x02, 0x2F, 0x02, 0xD0, + 0x01, 0x2F, 0xF6, 0xD0, + 0x2F, 0xE0, 0xFF, 0xF7, 0xA3, 0xFE, 0x08, 0x21, 0x28, 0xB1, 0x02, 0x22, + 0x32, 0x70, 0x70, 0x80, + 0xB1, 0x80, 0x05, 0x24, 0x25, 0xE0, 0x68, 0x78, 0x06, 0x28, 0x04, 0xD0, + 0x00, 0x22, 0xCB, 0xF8, + 0x00, 0x20, 0xCB, 0xF8, 0x04, 0x20, 0x03, 0x20, 0x30, 0x70, 0xB1, 0x80, + 0x06, 0x24, 0x18, 0xE0, + 0x02, 0x2F, 0x08, 0xD0, 0x02, 0x24, 0xC0, 0xB2, 0x88, 0xF8, 0x01, 0x00, + 0x2C, 0x70, 0x29, 0x48, + 0x08, 0x30, 0xBD, 0xE8, 0xF0, 0x9F, 0x68, 0x78, 0x04, 0x28, 0x08, 0xD0, + 0x0B, 0xEB, 0x09, 0x00, + 0x49, 0x46, 0x10, 0xF8, 0x01, 0x2C, 0x22, 0x48, 0x10, 0x38, 0x04, 0xF0, + 0x1D, 0xFF, 0x86, 0xF8, + 0x00, 0xA0, 0xA8, 0x46, 0x28, 0x78, 0xE7, 0xE7, 0x02, 0x2F, 0x05, 0xD0, + 0xB9, 0xF1, 0x08, 0x0F, + 0x93, 0xD1, 0xFF, 0xF7, 0x80, 0xFE, 0x90, 0xE7, 0xFF, 0xF7, 0x7D, 0xFE, + 0x98, 0xF8, 0x00, 0x00, + 0x03, 0x24, 0x88, 0xF8, 0x01, 0x00, 0x88, 0xF8, 0x00, 0x40, 0x6E, 0xE7, + 0x02, 0x2F, 0x4F, 0xF0, + 0x03, 0x04, 0xAD, 0xD0, 0xCF, 0xE7, 0x13, 0x49, 0x00, 0x22, 0x0A, 0x70, + 0x4A, 0x70, 0x18, 0x4A, + 0x52, 0x1C, 0x4A, 0x60, 0x17, 0x49, 0x01, 0x60, 0x0D, 0x49, 0x10, 0x39, + 0x81, 0x80, 0x10, 0x31, + 0xC1, 0x80, 0x10, 0x21, 0x01, 0x81, 0x0E, 0x21, 0x13, 0x48, 0x04, 0xF0, + 0xF5, 0xBE, 0x10, 0xB5, + 0x04, 0x46, 0x04, 0xF0, 0xA5, 0xFF, 0x06, 0x48, 0x21, 0x68, 0x10, 0x38, + 0x01, 0x60, 0x61, 0x68, + 0x41, 0x60, 0x0E, 0x48, 0xFF, 0xF7, 0x91, 0xFE, 0xBD, 0xE8, 0x10, 0x40, + 0x04, 0xF0, 0x3C, 0xBF, + 0x84, 0x43, 0x01, 0x20, 0x38, 0x07, 0x10, 0x00, 0x14, 0xA6, 0x01, 0x20, + 0xEE, 0x35, 0x01, 0x20, + 0x6C, 0xA2, 0x01, 0x20, 0x4C, 0x07, 0x10, 0x00, 0x94, 0x0B, 0x01, 0x20, + 0xBE, 0x0B, 0x01, 0x20, + 0x08, 0x50, 0x10, 0x00, 0xB1, 0x22, 0x01, 0x00, 0xF0, 0x4F, 0x10, 0x00, + 0x74, 0x43, 0x00, 0x00, + 0x70, 0xB5, 0x04, 0x4D, 0x38, 0x21, 0x28, 0x46, 0x2C, 0x88, 0x04, 0xF0, + 0xC5, 0xFE, 0x64, 0x1C, + 0x2C, 0x80, 0x70, 0xBD, 0x0A, 0x44, 0x01, 0x20, 0x37, 0x48, 0x00, 0x21, + 0x01, 0x60, 0x41, 0x60, + 0x70, 0x47, 0xC0, 0xB2, 0x01, 0x22, 0x00, 0xF0, 0x48, 0xFA, 0xFE, 0xE7, + 0x34, 0x4C, 0x00, 0x25, + 0x32, 0x4F, 0xC4, 0xE9, 0x02, 0x25, 0xC4, 0xE9, 0x00, 0x71, 0x06, 0x46, + 0x00, 0x68, 0x20, 0x61, + 0x70, 0x68, 0x60, 0x61, 0xB0, 0x68, 0xA0, 0x61, 0xF0, 0x68, 0xE0, 0x61, + 0x30, 0x69, 0x20, 0x62, + 0x70, 0x69, 0x60, 0x62, 0xB0, 0x69, 0xA0, 0x62, 0xF0, 0x69, 0xE0, 0x62, + 0x29, 0x48, 0x90, 0x46, + 0x89, 0x46, 0x00, 0x68, 0x20, 0x63, 0x27, 0x48, 0x10, 0x38, 0x00, 0x68, + 0x60, 0x63, 0x25, 0x48, + 0x0C, 0x38, 0x00, 0x68, 0xA0, 0x63, 0x23, 0x48, 0x08, 0x38, 0x00, 0x68, + 0xE0, 0x63, 0x21, 0x48, + 0x00, 0x1D, 0x00, 0x68, 0x20, 0x64, 0x1F, 0x48, 0x34, 0x38, 0x00, 0x68, + 0x60, 0x64, 0x1D, 0x48, + 0x14, 0x38, 0x00, 0x68, 0xC4, 0xE9, 0x12, 0x05, 0xEE, 0xF7, 0x9B, 0xF9, + 0x20, 0x65, 0xC4, 0xE9, + 0x15, 0x65, 0xE5, 0x65, 0x25, 0x66, 0x65, 0x66, 0xA5, 0x66, 0xE5, 0x66, + 0x25, 0x67, 0x65, 0x67, + 0xC4, 0xE9, 0x1E, 0x57, 0x41, 0x46, 0x48, 0x46, 0xFF, 0xF7, 0xB3, 0xFF, + 0x10, 0xB5, 0x04, 0x46, + 0xC0, 0xB2, 0x00, 0x22, 0x00, 0xF0, 0xF9, 0xF9, 0x0F, 0x49, 0x08, 0x68, + 0x08, 0x28, 0x03, 0xDA, + 0x09, 0x4A, 0x14, 0x54, 0x40, 0x1C, 0x08, 0x60, 0x10, 0xBD, 0x01, 0x28, + 0x06, 0xD0, 0x02, 0x28, + 0x08, 0xD1, 0x00, 0x22, 0x11, 0x46, 0x13, 0x20, 0x00, 0xF0, 0xE7, 0xB9, + 0x00, 0x22, 0x11, 0x46, + 0x12, 0x20, 0xF9, 0xE7, 0x70, 0x47, 0x00, 0x00, 0x70, 0xEF, 0x01, 0x20, + 0xAF, 0x05, 0x50, 0xFA, + 0x80, 0xEF, 0x01, 0x20, 0x38, 0xED, 0x00, 0xE0, 0x48, 0x07, 0x10, 0x00, + 0x2D, 0xE9, 0xF0, 0x41, + 0x40, 0xF2, 0x02, 0x71, 0xB9, 0x48, 0x04, 0xF0, 0x3F, 0xFE, 0xB8, 0x4C, + 0x01, 0x26, 0x00, 0x25, + 0x66, 0x70, 0xA5, 0x80, 0xA5, 0x71, 0x02, 0x20, 0xE0, 0x71, 0xEE, 0xF7, + 0xAC, 0xFC, 0x20, 0x81, + 0xEE, 0xF7, 0xA5, 0xFC, 0x07, 0x02, 0xEE, 0xF7, 0xA2, 0xFC, 0x47, 0xEA, + 0x10, 0x20, 0x60, 0x81, + 0x4A, 0xF2, 0x33, 0x20, 0x20, 0x82, 0x30, 0x02, 0x60, 0x82, 0xAD, 0x48, + 0x00, 0x68, 0x41, 0x8A, + 0xA1, 0x82, 0x01, 0x8A, 0xE1, 0x82, 0xC1, 0x8A, 0x21, 0x83, 0x81, 0x8A, + 0x61, 0x83, 0x90, 0xF8, + 0xDE, 0x10, 0x21, 0x77, 0xA7, 0x49, 0x09, 0x68, 0x09, 0x7E, 0x61, 0x77, + 0x90, 0xF8, 0xA0, 0x10, + 0x01, 0xF0, 0x01, 0x01, 0xA1, 0x77, 0x81, 0x69, 0x21, 0x63, 0xC1, 0x69, + 0x61, 0x63, 0xA5, 0x63, + 0xE5, 0x63, 0xA4, 0xF8, 0x40, 0x50, 0x84, 0xF8, 0x42, 0x50, 0x84, 0xF8, + 0x43, 0x60, 0x41, 0x8E, + 0xA4, 0xF8, 0x50, 0x10, 0x81, 0x8E, 0xA4, 0xF8, 0x52, 0x10, 0x90, 0xF8, + 0x31, 0x10, 0x84, 0xF8, + 0x54, 0x10, 0x90, 0xF8, 0x30, 0x10, 0x84, 0xF8, 0x55, 0x10, 0x01, 0x21, + 0x00, 0xF2, 0x61, 0x40, + 0xEE, 0xF7, 0xC9, 0xFD, 0x84, 0xF8, 0x56, 0x00, 0x93, 0x48, 0xA4, 0xF8, + 0x80, 0x00, 0x93, 0x48, + 0xA4, 0xF8, 0x88, 0x00, 0x92, 0x48, 0xA4, 0xF8, 0x8A, 0x00, 0x92, 0x48, + 0xA4, 0xF8, 0x8C, 0x00, + 0x91, 0x48, 0xA4, 0xF8, 0x8E, 0x00, 0x91, 0x48, 0xA4, 0xF8, 0x90, 0x00, + 0x90, 0x48, 0xA4, 0xF8, + 0x92, 0x00, 0x90, 0x48, 0xA4, 0xF8, 0x94, 0x00, 0x8F, 0x48, 0xA4, 0xF8, + 0x96, 0x00, 0x8F, 0x48, + 0xA4, 0xF8, 0x98, 0x00, 0x8E, 0x48, 0xA4, 0xF8, 0x9A, 0x00, 0x8E, 0x48, + 0xA4, 0xF8, 0x9C, 0x00, + 0x8D, 0x48, 0xA4, 0xF8, 0x9E, 0x00, 0x8D, 0x48, 0xA4, 0xF8, 0xA0, 0x00, + 0x8C, 0x48, 0xA4, 0xF8, + 0xA2, 0x00, 0x8C, 0x48, 0xA4, 0xF8, 0xA4, 0x00, 0x8C, 0x49, 0x8B, 0x48, + 0xA4, 0xF8, 0xA6, 0x00, + 0x48, 0x88, 0x40, 0x1C, 0x48, 0x80, 0xA5, 0x22, 0x22, 0x70, 0x66, 0x70, + 0x60, 0x80, 0x0E, 0x70, + 0xBD, 0xE8, 0xF0, 0x81, 0x70, 0xB5, 0x85, 0x4C, 0x05, 0x46, 0x00, 0x23, + 0x60, 0x88, 0x6F, 0x49, + 0x40, 0x1C, 0x82, 0xB2, 0x62, 0x80, 0x28, 0x46, 0x01, 0xF0, 0x80, 0xFA, + 0x25, 0x70, 0x70, 0xBD, + 0x70, 0xB5, 0x05, 0x46, 0x40, 0xF2, 0x02, 0x71, 0x68, 0x48, 0x04, 0xF0, + 0x9D, 0xFD, 0x7B, 0x4C, + 0x66, 0x49, 0x60, 0x88, 0x40, 0x1C, 0x82, 0xB2, 0x62, 0x80, 0x28, 0x46, + 0x01, 0xF0, 0xA6, 0xFA, + 0x25, 0x70, 0x70, 0xBD, 0x2D, 0xE9, 0xF0, 0x41, 0x74, 0x4C, 0x05, 0x46, + 0x20, 0x78, 0xA8, 0x42, + 0x04, 0xD0, 0x40, 0xF2, 0x02, 0x71, 0x5D, 0x48, 0x04, 0xF0, 0x86, 0xFD, + 0x70, 0x49, 0x65, 0x70, + 0x0F, 0x20, 0x08, 0x60, 0x5A, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x61, 0x24, + 0x0A, 0xB1, 0x1F, 0x22, + 0x0A, 0x60, 0x56, 0x49, 0x55, 0x4D, 0x10, 0x31, 0x61, 0x60, 0x38, 0x21, + 0x29, 0x71, 0x05, 0xF1, + 0x48, 0x03, 0xA3, 0x60, 0x90, 0xF8, 0x31, 0x20, 0x90, 0xF8, 0x30, 0x60, + 0x6A, 0x71, 0x02, 0xFB, + 0x06, 0xF1, 0x03, 0xEB, 0x41, 0x07, 0xAE, 0x71, 0xE7, 0x60, 0xEA, 0x71, + 0x11, 0x44, 0x03, 0xEB, + 0x41, 0x02, 0x22, 0x61, 0x31, 0x44, 0x2E, 0x72, 0x03, 0xEB, 0x41, 0x01, + 0x61, 0x61, 0x01, 0x21, + 0x00, 0xF2, 0x61, 0x40, 0xEE, 0xF7, 0x2F, 0xFD, 0x68, 0x72, 0xA1, 0xE7, + 0x2D, 0xE9, 0xF0, 0x41, + 0x05, 0x46, 0x56, 0x4C, 0x17, 0x46, 0x88, 0x46, 0xC0, 0x07, 0x04, 0xD0, + 0x38, 0x22, 0x42, 0x49, + 0x60, 0x68, 0x04, 0xF0, 0xCA, 0xFC, 0x3E, 0x4E, 0xA8, 0x07, 0x12, 0xD5, + 0x31, 0x68, 0x91, 0xF8, + 0x31, 0x00, 0x91, 0xF8, 0x30, 0x10, 0x48, 0x43, 0x61, 0x78, 0x30, 0x29, + 0x3E, 0xD0, 0x31, 0x29, + 0x3E, 0xD0, 0x32, 0x29, 0x42, 0xD0, 0x3B, 0x49, 0xA3, 0x68, 0x42, 0x00, + 0x18, 0x46, 0x04, 0xF0, + 0xB4, 0xFC, 0x68, 0x07, 0x0E, 0xD5, 0x30, 0x68, 0x90, 0xF8, 0x31, 0x20, + 0x60, 0x78, 0x30, 0x28, + 0x36, 0xD0, 0x31, 0x28, 0x36, 0xD0, 0x32, 0x28, 0x39, 0xD0, 0x36, 0x49, + 0x52, 0x00, 0xE0, 0x68, + 0x04, 0xF0, 0xA3, 0xFC, 0x28, 0x07, 0x0F, 0xD5, 0x30, 0x68, 0x61, 0x78, + 0x90, 0xF8, 0x30, 0x00, + 0x30, 0x29, 0x2E, 0xD0, 0x31, 0x29, 0x2E, 0xD0, 0x32, 0x29, 0x31, 0xD0, + 0x31, 0x49, 0x23, 0x69, + 0x42, 0x00, 0x18, 0x46, 0x04, 0xF0, 0x91, 0xFC, 0xE8, 0x06, 0x31, 0xD5, + 0x1F, 0x48, 0x42, 0x7A, + 0x60, 0x78, 0x30, 0x28, 0x26, 0xD0, 0x31, 0x28, 0x26, 0xD0, 0x32, 0x28, + 0x26, 0xD0, 0x2D, 0x49, + 0x60, 0x69, 0xBD, 0xE8, 0xF0, 0x41, 0x52, 0x00, 0x04, 0xF0, 0x7F, 0xBC, + 0x1B, 0x49, 0xC3, 0xE7, + 0x1B, 0x49, 0xB8, 0xF1, 0x00, 0x0F, 0xBF, 0xD0, 0x2A, 0x49, 0xBD, 0xE7, + 0x1A, 0x49, 0xBB, 0xE7, + 0x1A, 0x49, 0xCB, 0xE7, 0x1A, 0x49, 0x00, 0x2F, 0xC8, 0xD0, 0x27, 0x49, + 0xC6, 0xE7, 0x1A, 0x49, + 0xC4, 0xE7, 0x1A, 0x49, 0xD3, 0xE7, 0x1A, 0x49, 0x00, 0x2F, 0xD0, 0xD0, + 0x23, 0x49, 0xCE, 0xE7, + 0x19, 0x49, 0xCC, 0xE7, 0x19, 0x49, 0xDB, 0xE7, 0x19, 0x49, 0xD9, 0xE7, + 0x1A, 0x49, 0xD7, 0xE7, + 0x26, 0xE7, 0x06, 0x4A, 0xA5, 0x20, 0x10, 0x70, 0x18, 0x48, 0x41, 0x78, + 0x51, 0x70, 0x01, 0x70, + 0x41, 0x88, 0x49, 0x1C, 0x41, 0x80, 0x51, 0x80, 0x70, 0x47, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x20, + 0x4C, 0x07, 0x10, 0x00, 0x50, 0x07, 0x10, 0x00, 0x0A, 0x44, 0x01, 0x20, + 0x14, 0xA6, 0x01, 0x20, + 0xB2, 0x2F, 0x01, 0x20, 0xEE, 0x35, 0x01, 0x20, 0x42, 0x44, 0x01, 0x20, + 0x04, 0xA3, 0x01, 0x20, + 0x1E, 0x0B, 0x01, 0x20, 0x94, 0x0B, 0x01, 0x20, 0x7E, 0x4A, 0x01, 0x20, + 0x2E, 0xA3, 0x01, 0x20, + 0x48, 0x0B, 0x01, 0x20, 0xBE, 0x0B, 0x01, 0x20, 0xA8, 0x4A, 0x01, 0x20, + 0xB8, 0xA4, 0x01, 0x20, + 0xA2, 0x1C, 0x01, 0x20, 0xAA, 0x1C, 0x01, 0x20, 0xF4, 0x4A, 0x01, 0x20, + 0x94, 0x07, 0x10, 0x00, + 0x68, 0x07, 0x10, 0x00, 0x4A, 0x0C, 0x01, 0x20, 0x92, 0x09, 0x01, 0x20, + 0xBC, 0x09, 0x01, 0x20, + 0x1F, 0x48, 0x00, 0x68, 0x90, 0xF8, 0xA0, 0x00, 0xC0, 0x07, 0x01, 0xD0, + 0x00, 0xF0, 0x3A, 0xB8, + 0x00, 0xF0, 0xDC, 0xB8, 0x1A, 0x49, 0x09, 0x68, 0x91, 0xF8, 0xA0, 0x10, + 0xC9, 0x07, 0x02, 0xD0, + 0xC0, 0xB2, 0x00, 0xF0, 0x39, 0xB8, 0x01, 0x46, 0x00, 0x20, 0x00, 0xF0, + 0x2C, 0xB9, 0x38, 0xB5, + 0x04, 0x46, 0x69, 0x46, 0x18, 0x30, 0x00, 0xF0, 0xA2, 0xFD, 0x11, 0x48, + 0x00, 0x99, 0x00, 0x68, + 0x90, 0xF8, 0xA0, 0x00, 0xC0, 0x07, 0x20, 0x46, 0x02, 0xD0, 0x00, 0xF0, + 0x44, 0xF8, 0x38, 0xBD, + 0x00, 0xF0, 0xC6, 0xF8, 0x38, 0xBD, 0x00, 0xF0, 0x24, 0xB9, 0x09, 0x4B, + 0x1B, 0x68, 0x93, 0xF8, + 0xA0, 0x30, 0xDB, 0x07, 0x01, 0xD1, 0x00, 0xF0, 0x3A, 0xB9, 0x70, 0x47, + 0x04, 0x4A, 0x12, 0x68, + 0x92, 0xF8, 0xA0, 0x20, 0x52, 0x07, 0x01, 0xD5, 0x00, 0xF0, 0x43, 0xB9, + 0x70, 0x47, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x1C, 0xB5, 0x4F, 0x49, 0xD1, 0xE9, 0x00, 0x01, + 0xCD, 0xE9, 0x00, 0x01, + 0x68, 0x46, 0xFF, 0xF7, 0x80, 0xFB, 0x1C, 0xBD, 0x1C, 0xB5, 0x4A, 0x4A, + 0xD2, 0xE9, 0x02, 0x12, + 0xCD, 0xE9, 0x00, 0x12, 0x8D, 0xF8, 0x02, 0x00, 0x68, 0x46, 0xFF, 0xF7, + 0x74, 0xFB, 0x1C, 0xBD, + 0x88, 0x42, 0x0E, 0xD9, 0x90, 0x42, 0x01, 0xD3, 0xFF, 0x20, 0x70, 0x47, + 0x91, 0x42, 0x08, 0xD0, + 0x40, 0x1A, 0xC0, 0xEB, 0x00, 0x20, 0x51, 0x1A, 0xB0, 0xFB, 0xF1, 0xF0, + 0x10, 0xF0, 0xFF, 0x00, + 0xF3, 0xD1, 0x01, 0x20, 0x70, 0x47, 0x7C, 0xB5, 0x05, 0x46, 0x00, 0x20, + 0x00, 0x90, 0x01, 0x90, + 0x95, 0xF8, 0x4D, 0x21, 0x9D, 0xF8, 0x00, 0x00, 0x62, 0xF3, 0x85, 0x00, + 0x8D, 0xF8, 0x00, 0x00, + 0x95, 0xF8, 0x3E, 0x21, 0x03, 0x2A, 0x3E, 0xD0, 0x08, 0x2A, 0x40, 0xD0, + 0x20, 0xF0, 0xC0, 0x00, + 0x10, 0xF1, 0x80, 0x00, 0x8D, 0xF8, 0x00, 0x00, 0x0A, 0x14, 0x10, 0x09, + 0x8D, 0xF8, 0x01, 0x00, + 0x9D, 0xF8, 0x03, 0x00, 0x2C, 0x4E, 0x62, 0xF3, 0x07, 0x10, 0x0A, 0x09, + 0x8D, 0xF8, 0x02, 0x20, + 0x61, 0xF3, 0x03, 0x00, 0x8D, 0xF8, 0x03, 0x00, 0x30, 0x68, 0xB0, 0xF8, + 0xA3, 0x20, 0xB0, 0xF8, + 0xA1, 0x10, 0x35, 0xF8, 0x4A, 0x0F, 0xFF, 0xF7, 0xBB, 0xFF, 0x8D, 0xF8, + 0x04, 0x00, 0x30, 0x68, + 0xB0, 0xF8, 0xA7, 0x20, 0xB0, 0xF8, 0xA5, 0x10, 0x68, 0x88, 0xFF, 0xF7, + 0xB1, 0xFF, 0x8D, 0xF8, + 0x05, 0x00, 0x29, 0x7A, 0x9D, 0xF8, 0x06, 0x00, 0x61, 0xF3, 0x05, 0x00, + 0x8D, 0xF8, 0x06, 0x00, + 0x95, 0xF8, 0xF6, 0x10, 0x09, 0x29, 0x1E, 0xD2, 0xDF, 0xE8, 0x01, 0xF0, + 0x0C, 0x0E, 0x10, 0x12, + 0x14, 0x16, 0x18, 0x1A, 0x1C, 0x00, 0x20, 0xF0, 0xC0, 0x00, 0x40, 0x30, + 0xC2, 0xE7, 0x40, 0xF0, + 0xC0, 0x00, 0xBF, 0xE7, 0x00, 0x24, 0x0E, 0xE0, 0x01, 0x24, 0x0C, 0xE0, + 0x02, 0x24, 0x0A, 0xE0, + 0x03, 0x24, 0x08, 0xE0, 0x04, 0x24, 0x06, 0xE0, 0x05, 0x24, 0x04, 0xE0, + 0x06, 0x24, 0x02, 0xE0, + 0x07, 0x24, 0x00, 0xE0, 0x08, 0x24, 0xA1, 0x08, 0x61, 0xF3, 0x87, 0x10, + 0x8D, 0xF8, 0x06, 0x00, + 0x9D, 0xF8, 0x07, 0x00, 0x64, 0xF3, 0x87, 0x10, 0x8D, 0xF8, 0x07, 0x00, + 0x68, 0x46, 0xFF, 0xF7, + 0xEA, 0xFA, 0x7C, 0xBD, 0xF0, 0x7B, 0x01, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x1C, 0xB5, 0x54, 0x49, + 0xD1, 0xE9, 0x00, 0x01, 0xCD, 0xE9, 0x00, 0x01, 0x68, 0x46, 0xFF, 0xF7, + 0xDC, 0xFA, 0x1C, 0xBD, + 0x1C, 0xB5, 0x4F, 0x4B, 0xD3, 0xE9, 0x02, 0x23, 0xCD, 0xE9, 0x00, 0x23, + 0x90, 0xF8, 0x3E, 0x21, + 0x03, 0x2A, 0x19, 0xD0, 0x08, 0x2A, 0x9D, 0xF8, 0x00, 0x20, 0x22, 0xF0, + 0xF0, 0x02, 0x19, 0xD0, + 0x12, 0xF1, 0x20, 0x02, 0x8D, 0xF8, 0x00, 0x20, 0x90, 0xF8, 0x3F, 0x21, + 0x02, 0xF0, 0x0F, 0x02, + 0x01, 0x2A, 0x11, 0xD0, 0x02, 0x2A, 0x15, 0xD0, 0x04, 0x2A, 0x9D, 0xF8, + 0x01, 0x20, 0x22, 0xF0, + 0x0F, 0x02, 0x2E, 0xD0, 0x52, 0x1C, 0x12, 0xE0, 0x9D, 0xF8, 0x00, 0x20, + 0x22, 0xF0, 0xF0, 0x02, + 0x10, 0x32, 0xE7, 0xE7, 0x30, 0x32, 0xE5, 0xE7, 0x9D, 0xF8, 0x01, 0x20, + 0x22, 0xF0, 0x0F, 0x02, + 0x92, 0x1C, 0x04, 0xE0, 0x9D, 0xF8, 0x01, 0x20, 0x22, 0xF0, 0x0F, 0x02, + 0xD2, 0x1C, 0x8D, 0xF8, + 0x01, 0x20, 0x90, 0xF8, 0x4D, 0x01, 0xD2, 0xB2, 0x60, 0xF3, 0x07, 0x12, + 0x8D, 0xF8, 0x01, 0x20, + 0xBD, 0xF8, 0x02, 0x00, 0x0A, 0x0C, 0x62, 0xF3, 0x0B, 0x00, 0xAD, 0xF8, + 0x02, 0x00, 0xBD, 0xF8, + 0x03, 0x00, 0x61, 0xF3, 0x0F, 0x10, 0xAD, 0xF8, 0x03, 0x00, 0x68, 0x46, + 0xFF, 0xF7, 0x8B, 0xFA, + 0x1C, 0xBD, 0x12, 0x1D, 0xE3, 0xE7, 0x1C, 0xB5, 0x25, 0x4B, 0xD3, 0xE9, + 0x04, 0x23, 0xCD, 0xE9, + 0x00, 0x23, 0x8D, 0xF8, 0x01, 0x00, 0xCD, 0xF8, 0x02, 0x10, 0x68, 0x46, + 0xFF, 0xF7, 0x7B, 0xFA, + 0x1C, 0xBD, 0x1C, 0xB5, 0x1F, 0x4A, 0x12, 0x68, 0x92, 0xF8, 0xA0, 0x20, + 0x93, 0x07, 0x15, 0xD5, + 0x08, 0x28, 0x13, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, 0x12, 0x04, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, + 0x12, 0x06, 0x0B, 0xD5, 0x16, 0x4B, 0xD3, 0xE9, 0x06, 0x23, 0xCD, 0xE9, + 0x00, 0x23, 0x8D, 0xF8, + 0x01, 0x00, 0xCD, 0xF8, 0x02, 0x10, 0x68, 0x46, 0xFF, 0xF7, 0x5D, 0xFA, + 0x1C, 0xBD, 0x1C, 0xB5, + 0x0F, 0x4C, 0xD4, 0xE9, 0x08, 0x34, 0xCD, 0xE9, 0x00, 0x34, 0x8D, 0xF8, + 0x01, 0x00, 0xCD, 0xF8, + 0x02, 0x10, 0x68, 0x46, 0x12, 0xB1, 0xFF, 0xF7, 0x2A, 0xFC, 0x1C, 0xBD, + 0xFF, 0xF7, 0x4B, 0xFA, + 0x1C, 0xBD, 0x1C, 0xB5, 0x06, 0x4B, 0xD3, 0xE9, 0x0A, 0x23, 0xCD, 0xE9, + 0x00, 0x23, 0x8D, 0xF8, + 0x01, 0x00, 0xCD, 0xF8, 0x02, 0x10, 0x68, 0x46, 0xFF, 0xF7, 0x3D, 0xFA, + 0x1C, 0xBD, 0x00, 0x00, + 0x08, 0x7C, 0x01, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x2D, 0xE9, 0xFF, 0x41, + 0xED, 0xF7, 0xDC, 0xFB, + 0x23, 0x4D, 0x00, 0x24, 0xC4, 0xEB, 0xC4, 0x01, 0x05, 0xEB, 0x81, 0x00, + 0x00, 0xF1, 0x0C, 0x03, + 0x02, 0x7E, 0xC8, 0xCB, 0xCD, 0xE9, 0x02, 0x72, 0xCD, 0xE9, 0x00, 0x36, + 0xD0, 0xE9, 0x01, 0x23, + 0x55, 0xF8, 0x21, 0x00, 0x00, 0x21, 0xED, 0xF7, 0xB1, 0xFD, 0x18, 0xB1, + 0x21, 0x46, 0x43, 0x20, + 0xFF, 0xF7, 0x2F, 0xFC, 0x64, 0x1C, 0x05, 0x2C, 0xE4, 0xDB, 0x15, 0x4D, + 0x00, 0x24, 0x8C, 0x35, + 0x05, 0xEB, 0xC4, 0x00, 0x00, 0x21, 0x42, 0x68, 0x55, 0xF8, 0x34, 0x00, + 0xED, 0xF7, 0x25, 0xFD, + 0x18, 0xB1, 0x21, 0x46, 0x44, 0x20, 0xFF, 0xF7, 0x1C, 0xFC, 0x64, 0x1C, + 0x06, 0x2C, 0xEF, 0xDB, + 0x0B, 0x4D, 0x00, 0x24, 0x15, 0xF1, 0xBC, 0x05, 0x00, 0x21, 0x55, 0xF8, + 0x24, 0x00, 0xED, 0xF7, + 0x3A, 0xFC, 0x18, 0xB1, 0x21, 0x46, 0x45, 0x20, 0xFF, 0xF7, 0x0B, 0xFC, + 0x64, 0x1C, 0x04, 0x2C, + 0xF2, 0xDB, 0xBD, 0xE8, 0xFF, 0x81, 0x01, 0x46, 0x46, 0x20, 0xFF, 0xF7, + 0x02, 0xBC, 0x00, 0x00, + 0x38, 0x7C, 0x01, 0x00, 0x00, 0xF0, 0x1F, 0x03, 0x01, 0x22, 0x9A, 0x40, + 0x43, 0x09, 0x9B, 0x00, + 0x03, 0xF1, 0xE0, 0x23, 0xC3, 0xF8, 0x80, 0x22, 0x49, 0x07, 0x09, 0x0E, + 0x00, 0x28, 0x06, 0xDA, + 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF1, 0xE0, 0x20, 0x80, 0xF8, 0x14, 0x1D, + 0x03, 0xE0, 0x00, 0xF1, + 0xE0, 0x20, 0x80, 0xF8, 0x00, 0x14, 0xC3, 0xF8, 0x00, 0x21, 0x70, 0x47, + 0x2D, 0xE9, 0xF0, 0x41, + 0x64, 0x27, 0x07, 0x26, 0x00, 0x25, 0xFD, 0x4C, 0xFD, 0x48, 0xEE, 0xF7, + 0xF3, 0xF9, 0xFC, 0x48, + 0x03, 0x68, 0xD9, 0x1C, 0x3C, 0xD0, 0x42, 0x68, 0xD1, 0x1C, 0x39, 0xD0, + 0x81, 0x68, 0x11, 0xF1, + 0x03, 0x0F, 0x35, 0xD0, 0x00, 0x69, 0x10, 0xF1, 0x03, 0x0F, 0x31, 0xD0, + 0xB3, 0xF1, 0xFF, 0x3F, + 0x31, 0xD0, 0x13, 0xF1, 0x02, 0x0F, 0x2E, 0xD0, 0xB2, 0xF1, 0xFF, 0x3F, + 0x2B, 0xD0, 0x12, 0xF1, + 0x02, 0x0F, 0x28, 0xD0, 0xB1, 0xF1, 0xFF, 0x3F, 0x25, 0xD0, 0x11, 0xF1, + 0x02, 0x0F, 0x22, 0xD0, + 0xB0, 0xF1, 0xFF, 0x3F, 0x1F, 0xD0, 0x10, 0xF1, 0x02, 0x0F, 0x1C, 0xD0, + 0xDF, 0xB2, 0xD6, 0xB2, + 0xCD, 0xB2, 0x04, 0x46, 0x2A, 0x46, 0x31, 0x46, 0x38, 0x46, 0xEE, 0xF7, + 0xF1, 0xF8, 0x20, 0x46, + 0xEE, 0xF7, 0xFB, 0xF8, 0xE3, 0x48, 0xEE, 0xF7, 0x64, 0xF9, 0x03, 0x28, + 0x10, 0xD0, 0x01, 0x28, + 0x11, 0xD0, 0x02, 0x28, 0x0F, 0xD0, 0xDF, 0x48, 0x00, 0x68, 0x01, 0x28, + 0x10, 0xD0, 0x12, 0xE0, + 0x00, 0x21, 0x24, 0x20, 0x01, 0xE0, 0x00, 0x21, 0x25, 0x20, 0xFF, 0xF7, + 0xDF, 0xFB, 0xE1, 0xE7, + 0x00, 0x21, 0x29, 0x20, 0x01, 0xE0, 0x00, 0x21, 0x2A, 0x20, 0xFF, 0xF7, + 0xD7, 0xFB, 0x02, 0xE0, + 0xD4, 0x48, 0xED, 0xF7, 0x7B, 0xFD, 0xD2, 0x48, 0x14, 0x30, 0xEE, 0xF7, + 0x6C, 0xF9, 0x04, 0x46, + 0x03, 0x28, 0x04, 0xD0, 0x01, 0x2C, 0x05, 0xD0, 0x02, 0x2C, 0x03, 0xD0, + 0x06, 0xE0, 0x00, 0x21, + 0x2B, 0x20, 0x01, 0xE0, 0x00, 0x21, 0x2C, 0x20, 0xFF, 0xF7, 0xC0, 0xFB, + 0x21, 0x46, 0xBD, 0xE8, + 0xF0, 0x41, 0xC7, 0x48, 0x14, 0x30, 0x00, 0xF0, 0x81, 0xBF, 0x7C, 0xB5, + 0xC6, 0x4E, 0x01, 0xAA, + 0x69, 0x46, 0x30, 0x46, 0xEE, 0xF7, 0x09, 0xFA, 0xC4, 0x4C, 0x40, 0xF2, + 0xBC, 0x65, 0x01, 0x28, + 0x02, 0xD0, 0x00, 0x21, 0x22, 0x20, 0x10, 0xE0, 0x00, 0x98, 0xA0, 0xF5, + 0x80, 0x71, 0xAF, 0x39, + 0xF7, 0xD1, 0x2A, 0x46, 0x31, 0x46, 0x20, 0x68, 0x04, 0xF0, 0x8F, 0xF9, + 0x20, 0x68, 0xEE, 0xF7, + 0x07, 0xFA, 0x01, 0x28, 0x08, 0xD0, 0x00, 0x21, 0x23, 0x20, 0xFF, 0xF7, + 0x97, 0xFB, 0x29, 0x46, + 0x20, 0x68, 0x04, 0xF0, 0x01, 0xFA, 0x7C, 0xBD, 0xB5, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x70, 0x11, + 0x89, 0x07, 0x07, 0xD4, 0x90, 0xF8, 0x88, 0x11, 0xC9, 0x06, 0x03, 0xD4, + 0x90, 0xF8, 0xA0, 0x01, + 0xC0, 0x06, 0xF0, 0xD5, 0x24, 0x68, 0x26, 0x22, 0x04, 0xF2, 0x02, 0x61, + 0xAD, 0x48, 0x04, 0xF0, + 0x6C, 0xF9, 0xAC, 0x48, 0x1D, 0x22, 0x04, 0xF5, 0xC5, 0x61, 0x28, 0x30, + 0x04, 0xF0, 0x65, 0xF9, + 0xA8, 0x48, 0x26, 0x22, 0x04, 0xF2, 0x5E, 0x61, 0x48, 0x30, 0x04, 0xF0, + 0x5E, 0xF9, 0xA5, 0x48, + 0x1D, 0x22, 0x04, 0xF2, 0x84, 0x61, 0x70, 0x30, 0x04, 0xF0, 0x57, 0xF9, + 0x7C, 0xBD, 0xF8, 0xB5, + 0x0D, 0x46, 0x06, 0x46, 0x00, 0x24, 0x6A, 0x46, 0xEE, 0xF7, 0xB7, 0xF9, + 0x01, 0x28, 0x01, 0xD0, + 0x01, 0x24, 0x0B, 0xE0, 0x28, 0x68, 0x31, 0x46, 0x82, 0x00, 0x9B, 0x48, + 0x04, 0xF0, 0x8A, 0xF9, + 0x99, 0x48, 0xEE, 0xF7, 0xBD, 0xF9, 0x01, 0x28, 0x00, 0xD0, 0x02, 0x24, + 0x20, 0x46, 0xF8, 0xBD, + 0x2D, 0xE9, 0xF8, 0x43, 0x94, 0x4D, 0x95, 0x4F, 0x10, 0x35, 0x41, 0xF2, + 0xC8, 0x11, 0x94, 0x48, + 0x04, 0xF0, 0xD4, 0xF9, 0x69, 0x46, 0x38, 0x46, 0xFF, 0xF7, 0xD9, 0xFF, + 0x01, 0x28, 0x05, 0xD0, + 0x02, 0x28, 0x06, 0xD0, 0xE8, 0x78, 0x01, 0x28, 0x0A, 0xD1, 0x05, 0xE0, + 0x00, 0x21, 0xA0, 0x20, + 0x2E, 0xE0, 0x00, 0x21, 0xA1, 0x20, 0x2B, 0xE0, 0xA8, 0x78, 0x08, 0xB9, + 0x28, 0x88, 0x10, 0xB1, + 0x00, 0x21, 0xA2, 0x20, 0x24, 0xE0, 0x82, 0x4E, 0xE9, 0x88, 0x30, 0x68, + 0x82, 0x8A, 0x91, 0x42, + 0x02, 0xD0, 0x00, 0x21, 0xA3, 0x20, 0x1B, 0xE0, 0xA9, 0x88, 0xC0, 0x8A, + 0x81, 0x42, 0x02, 0xD0, + 0x00, 0x21, 0xA4, 0x20, 0x14, 0xE0, 0x00, 0x24, 0x00, 0x98, 0x69, 0x46, + 0x07, 0xEB, 0x80, 0x07, + 0x38, 0x46, 0xFF, 0xF7, 0xAC, 0xFF, 0x78, 0xB1, 0x01, 0x28, 0x03, 0xD0, + 0x00, 0x21, 0xA6, 0x20, + 0xFF, 0xF7, 0x0C, 0xFB, 0xE0, 0x07, 0x35, 0xD0, 0xA0, 0x07, 0x35, 0xD4, + 0x11, 0x21, 0xA7, 0x20, + 0xFF, 0xF7, 0x04, 0xFB, 0xBD, 0xE8, 0xF8, 0x83, 0x95, 0xF8, 0x01, 0x80, + 0x29, 0x46, 0x40, 0x46, + 0x00, 0xF0, 0xDE, 0xFD, 0xA0, 0xB1, 0xB8, 0xF1, 0x10, 0x0F, 0x14, 0xD0, + 0xB8, 0xF1, 0x11, 0x0F, + 0x14, 0xD0, 0xB8, 0xF1, 0x12, 0x0F, 0x14, 0xD0, 0xB8, 0xF1, 0x13, 0x0F, + 0x14, 0xD0, 0xB8, 0xF1, + 0x14, 0x0F, 0x14, 0xD0, 0xB8, 0xF1, 0x17, 0x0F, 0xCE, 0xD1, 0x44, 0xF0, + 0x20, 0x04, 0xCB, 0xE7, + 0x41, 0x46, 0xA8, 0x20, 0xD4, 0xE7, 0x44, 0xF0, 0x01, 0x04, 0xC5, 0xE7, + 0x44, 0xF0, 0x02, 0x04, + 0xC2, 0xE7, 0x44, 0xF0, 0x08, 0x04, 0xBF, 0xE7, 0x44, 0xF0, 0x10, 0x04, + 0xBC, 0xE7, 0x44, 0xF0, + 0x04, 0x04, 0xB9, 0xE7, 0x10, 0x21, 0xCA, 0xE7, 0x20, 0x07, 0x0A, 0xD4, + 0x30, 0x68, 0x90, 0xF8, + 0x50, 0x12, 0xC9, 0x07, 0x03, 0xD1, 0x90, 0xF8, 0x80, 0x02, 0xC0, 0x07, + 0x01, 0xD0, 0x12, 0x21, + 0xBD, 0xE7, 0xE0, 0x06, 0x01, 0xD4, 0x13, 0x21, 0xB9, 0xE7, 0x60, 0x07, + 0x05, 0xD4, 0x30, 0x68, + 0x90, 0xF8, 0x61, 0x04, 0x08, 0xB1, 0x14, 0x21, 0xB1, 0xE7, 0xA0, 0x06, + 0xB2, 0xD4, 0x30, 0x68, + 0x90, 0xF8, 0x2F, 0x0A, 0xC0, 0x07, 0xAD, 0xD0, 0x17, 0x21, 0xA8, 0xE7, + 0x10, 0xB5, 0x8E, 0xB0, + 0xED, 0xF7, 0x66, 0xF9, 0x00, 0x20, 0x01, 0x22, 0x41, 0xB2, 0x01, 0xF0, + 0x1F, 0x03, 0x02, 0xFA, + 0x03, 0xF3, 0x49, 0x09, 0x89, 0x00, 0x01, 0xF1, 0xE0, 0x21, 0xC1, 0xF8, + 0x80, 0x31, 0x40, 0x1C, + 0x1F, 0x28, 0xF1, 0xDB, 0xED, 0xF7, 0x52, 0xF9, 0xED, 0xF7, 0x5C, 0xFF, + 0xEE, 0xF7, 0x26, 0xF9, + 0x07, 0x21, 0x0A, 0x20, 0xFF, 0xF7, 0x46, 0xFE, 0x07, 0x21, 0x0B, 0x20, + 0xFF, 0xF7, 0x42, 0xFE, + 0xFE, 0xF7, 0xFE, 0xFF, 0xFE, 0xF7, 0xAA, 0xFE, 0x04, 0xA8, 0xFF, 0xF7, + 0xEC, 0xF9, 0x0A, 0xA9, + 0x07, 0xA8, 0xFF, 0xF7, 0x89, 0xF8, 0x04, 0xA8, 0x00, 0x90, 0x07, 0xA8, + 0x02, 0x90, 0x0A, 0xA8, + 0x03, 0x90, 0x68, 0x46, 0xEE, 0xF7, 0x26, 0xFA, 0x02, 0x21, 0x00, 0x20, + 0xFF, 0xF7, 0x2A, 0xFE, + 0xFF, 0xF7, 0x04, 0xF8, 0xFF, 0xF7, 0x20, 0xFA, 0xFF, 0xF7, 0x40, 0xFE, + 0xED, 0xF7, 0x60, 0xFF, + 0x28, 0x4C, 0x01, 0xAA, 0x69, 0x46, 0x20, 0x46, 0xEE, 0xF7, 0xBF, 0xF8, + 0x01, 0x28, 0x02, 0xD0, + 0x00, 0x21, 0x20, 0x20, 0x11, 0xE0, 0x00, 0x98, 0xB0, 0xF5, 0x25, 0x7F, + 0xF8, 0xD1, 0x21, 0x46, + 0x1B, 0x4C, 0x4F, 0xF4, 0x25, 0x62, 0x20, 0x68, 0x04, 0xF0, 0x47, 0xF8, + 0x20, 0x68, 0xEE, 0xF7, + 0xBF, 0xF8, 0x01, 0x28, 0x03, 0xD0, 0x00, 0x21, 0x21, 0x20, 0xFF, 0xF7, + 0x02, 0xFA, 0xFF, 0xF7, + 0x94, 0xFE, 0xFF, 0xF7, 0xFD, 0xFE, 0x00, 0xF0, 0x07, 0xF8, 0x00, 0xF0, + 0x55, 0xF8, 0x0E, 0xB0, + 0xBD, 0xE8, 0x10, 0x40, 0x00, 0xF0, 0x86, 0xB8, 0x10, 0xB5, 0xEE, 0xF7, + 0xBF, 0xFA, 0x0B, 0x48, + 0x00, 0x68, 0x01, 0x7C, 0xA5, 0x29, 0x1F, 0xD0, 0x4F, 0xF4, 0xFA, 0x40, + 0xEE, 0xF7, 0x61, 0xFC, + 0x00, 0x21, 0x28, 0x20, 0xFF, 0xF7, 0x32, 0xFA, 0x19, 0xE0, 0x00, 0x00, + 0x00, 0x90, 0xD0, 0x03, + 0x84, 0x7B, 0x10, 0x00, 0xE8, 0x84, 0x10, 0x00, 0xF0, 0x9F, 0x01, 0x00, + 0x50, 0x07, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0xE4, 0x9F, 0x01, 0x20, 0xD4, 0x56, 0x10, 0x00, + 0xF0, 0xAF, 0x01, 0x00, + 0x78, 0x8B, 0x01, 0x20, 0xF0, 0xEF, 0x01, 0x00, 0x40, 0x69, 0xEE, 0xF7, + 0x42, 0xFC, 0x04, 0x21, + 0x02, 0x20, 0xFF, 0xF7, 0xC7, 0xFD, 0x04, 0x21, 0x03, 0x20, 0xFF, 0xF7, + 0xC3, 0xFD, 0x04, 0x21, + 0x08, 0x46, 0xFF, 0xF7, 0xBF, 0xFD, 0x04, 0x21, 0x05, 0x20, 0xFF, 0xF7, + 0xBB, 0xFD, 0x04, 0x21, + 0x06, 0x20, 0xFF, 0xF7, 0xB7, 0xFD, 0x04, 0x21, 0x07, 0x20, 0xFF, 0xF7, + 0xB3, 0xFD, 0x04, 0x21, + 0x08, 0x20, 0xFF, 0xF7, 0xAF, 0xFD, 0x01, 0x21, 0x09, 0x20, 0xFF, 0xF7, + 0xAB, 0xFD, 0x04, 0x21, + 0xBD, 0xE8, 0x10, 0x40, 0x0F, 0x20, 0xA5, 0xE5, 0x38, 0xB5, 0x03, 0xF0, + 0xFB, 0xFB, 0x03, 0x21, + 0x01, 0x20, 0xFF, 0xF7, 0x9F, 0xFD, 0x28, 0x4C, 0x20, 0x68, 0x90, 0xF8, + 0xB0, 0x10, 0xC9, 0x07, + 0x27, 0xD0, 0x00, 0x25, 0x00, 0x95, 0x90, 0xF8, 0xC0, 0x00, 0x2B, 0x46, + 0xC0, 0xF3, 0x02, 0x10, + 0x01, 0x22, 0x29, 0x46, 0xEE, 0xF7, 0x87, 0xF8, 0x20, 0x68, 0x0A, 0x21, + 0x90, 0xF8, 0xC0, 0x00, + 0xC0, 0xF3, 0x02, 0x10, 0xEE, 0xF7, 0xA7, 0xF8, 0x00, 0x95, 0x20, 0x68, + 0x00, 0x23, 0x01, 0x22, + 0x90, 0xF8, 0xC0, 0x00, 0x19, 0x46, 0x00, 0xF0, 0x07, 0x00, 0xEE, 0xF7, + 0x74, 0xF8, 0x20, 0x68, + 0x01, 0x21, 0x90, 0xF8, 0xC0, 0x00, 0xBD, 0xE8, 0x38, 0x40, 0x00, 0xF0, + 0x07, 0x00, 0xEE, 0xF7, + 0x92, 0xB8, 0x38, 0xBD, 0x38, 0xB5, 0x10, 0x4C, 0x20, 0x68, 0x90, 0xF8, + 0x60, 0x03, 0xC1, 0x07, + 0x0F, 0xD0, 0x81, 0x07, 0x0D, 0xD5, 0x00, 0x21, 0x01, 0x23, 0x40, 0x09, + 0x1A, 0x46, 0x00, 0x91, + 0xEE, 0xF7, 0x59, 0xF8, 0x20, 0x68, 0x00, 0x21, 0x90, 0xF8, 0x60, 0x03, + 0x40, 0x09, 0xEE, 0xF7, + 0x7A, 0xF8, 0x20, 0x68, 0x90, 0xF8, 0x79, 0x00, 0xBD, 0xE8, 0x38, 0x40, + 0x00, 0xF0, 0x03, 0x01, + 0xC0, 0x09, 0xED, 0xF7, 0xA5, 0xBE, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x88, 0x42, 0x00, 0xD3, + 0x08, 0x46, 0x90, 0x42, 0x00, 0xD3, 0x10, 0x46, 0x70, 0x47, 0x88, 0x42, + 0x00, 0xD8, 0x08, 0x46, + 0x90, 0x42, 0x00, 0xD8, 0x10, 0x46, 0x70, 0x47, 0x88, 0x42, 0x00, 0xD3, + 0x08, 0x46, 0x70, 0x47, + 0x88, 0x42, 0x00, 0xD8, 0x08, 0x46, 0x70, 0x47, 0x02, 0x46, 0x00, 0x20, + 0x4F, 0xF0, 0x80, 0x41, + 0x00, 0xE0, 0x89, 0x08, 0x91, 0x42, 0xFC, 0xD8, 0x07, 0xE0, 0x43, 0x18, + 0x93, 0x42, 0x02, 0xD8, + 0xD2, 0x1A, 0x00, 0xEB, 0x41, 0x00, 0x40, 0x08, 0x89, 0x08, 0x00, 0x29, + 0xF5, 0xD1, 0x82, 0x42, + 0x00, 0xD9, 0x40, 0x1C, 0x70, 0x47, 0x10, 0xB5, 0x5A, 0x43, 0x02, 0x9C, + 0x06, 0xE0, 0x00, 0xBF, + 0x50, 0xF8, 0x22, 0x30, 0x93, 0xFB, 0xF4, 0xF3, 0x41, 0xF8, 0x22, 0x30, + 0x52, 0x1E, 0xF7, 0xD2, + 0x10, 0xBD, 0x10, 0xB5, 0x5A, 0x43, 0x02, 0x9C, 0x05, 0xE0, 0x00, 0xBF, + 0x50, 0xF8, 0x22, 0x30, + 0x63, 0x43, 0x41, 0xF8, 0x22, 0x30, 0x52, 0x1E, 0xF8, 0xD2, 0x10, 0xBD, + 0x30, 0xB5, 0x03, 0x9C, + 0x63, 0x43, 0x06, 0xE0, 0x50, 0xF8, 0x23, 0x40, 0x51, 0xF8, 0x23, 0x50, + 0x2C, 0x44, 0x42, 0xF8, + 0x23, 0x40, 0x5B, 0x1E, 0xF6, 0xD2, 0x30, 0xBD, 0x30, 0xB5, 0x03, 0x9C, + 0x63, 0x43, 0x06, 0xE0, + 0x50, 0xF8, 0x23, 0x40, 0x51, 0xF8, 0x23, 0x50, 0x64, 0x1B, 0x42, 0xF8, + 0x23, 0x40, 0x5B, 0x1E, + 0xF6, 0xD2, 0x30, 0xBD, 0x2D, 0xE9, 0xF0, 0x4F, 0x83, 0x46, 0xDD, 0xE9, + 0x09, 0x06, 0xDD, 0xF8, + 0x34, 0xE0, 0x8A, 0x46, 0x82, 0x42, 0x26, 0xD1, 0x00, 0x20, 0x22, 0xE0, + 0x00, 0xFB, 0x02, 0xF1, + 0x0B, 0xEB, 0x81, 0x09, 0x0B, 0x9D, 0x00, 0xFB, 0x0E, 0xF1, 0x00, 0x24, + 0x05, 0xEB, 0x81, 0x05, + 0x14, 0xE0, 0x00, 0x21, 0x0F, 0xE0, 0x00, 0xBF, 0x01, 0xFB, 0x06, 0xF8, + 0x03, 0xEB, 0x88, 0x08, + 0x59, 0xF8, 0x21, 0xC0, 0x55, 0xF8, 0x24, 0x70, 0x58, 0xF8, 0x24, 0x80, + 0x49, 0x1C, 0x0C, 0xFB, + 0x08, 0x77, 0x45, 0xF8, 0x24, 0x70, 0x91, 0x42, 0xEE, 0xDB, 0x64, 0x1C, + 0xB4, 0x42, 0xE8, 0xDB, + 0x40, 0x1C, 0x50, 0x45, 0xDA, 0xDB, 0xBD, 0xE8, 0xF0, 0x8F, 0x10, 0xB5, + 0x00, 0x23, 0x1C, 0x46, + 0x42, 0xB1, 0x02, 0x78, 0x52, 0x1C, 0xD2, 0xB2, 0x02, 0x70, 0x8A, 0x42, + 0x03, 0xD9, 0x04, 0x70, + 0x01, 0x23, 0x00, 0xE0, 0x04, 0x70, 0x18, 0x46, 0x10, 0xBD, 0x30, 0xB5, + 0x00, 0x24, 0x01, 0x23, + 0x05, 0xE0, 0x0C, 0x44, 0xE4, 0x1C, 0x04, 0xF0, 0x03, 0x05, 0x64, 0x1B, + 0x5B, 0x1C, 0x93, 0x42, + 0xF7, 0xDD, 0x00, 0xEB, 0x44, 0x00, 0x30, 0xBD, 0x88, 0x42, 0x01, 0xDD, + 0x08, 0x46, 0x70, 0x47, + 0x00, 0x28, 0xFC, 0xDA, 0x00, 0x20, 0x70, 0x47, 0x10, 0xB5, 0x04, 0xE0, + 0x00, 0xEB, 0x82, 0x03, + 0x53, 0xF8, 0x04, 0x4C, 0x1C, 0x60, 0x52, 0x1E, 0xF8, 0xD1, 0x09, 0x68, + 0x01, 0x60, 0x10, 0xBD, + 0x10, 0xB5, 0x03, 0xE0, 0x00, 0xEB, 0x82, 0x03, 0x0C, 0x68, 0x1C, 0x60, + 0x52, 0x1E, 0xF9, 0xD2, + 0x10, 0xBD, 0x30, 0xB5, 0x06, 0xE0, 0x00, 0xBF, 0x00, 0xEB, 0xC2, 0x03, + 0x73, 0xE9, 0x02, 0x45, + 0xC3, 0xE9, 0x02, 0x45, 0x52, 0x1E, 0xF7, 0xD1, 0xD1, 0xE9, 0x00, 0x21, + 0xC0, 0xE9, 0x00, 0x21, + 0x30, 0xBD, 0x10, 0xB5, 0x53, 0x88, 0x4C, 0x88, 0x1B, 0x1B, 0x43, 0x80, + 0x12, 0x88, 0x09, 0x88, + 0x51, 0x1A, 0x01, 0x80, 0x10, 0xBD, 0x08, 0xB5, 0x0A, 0x46, 0x01, 0x46, + 0x68, 0x46, 0xFF, 0xF7, + 0xF0, 0xFF, 0xBD, 0xF9, 0x00, 0x10, 0xBD, 0xF9, 0x02, 0x00, 0x49, 0x43, + 0x00, 0xFB, 0x00, 0x10, + 0x08, 0xBD, 0x10, 0xB5, 0x88, 0x42, 0x02, 0x9C, 0x01, 0xDC, 0x20, 0x46, + 0x10, 0xBD, 0x90, 0x42, + 0x01, 0xDB, 0x18, 0x46, 0x10, 0xBD, 0x8A, 0x42, 0x00, 0xD1, 0x52, 0x1C, + 0x40, 0x1A, 0xE3, 0x1A, + 0x58, 0x43, 0x51, 0x1A, 0x90, 0xFB, 0xF1, 0xF0, 0x20, 0x1A, 0x10, 0xBD, + 0x10, 0xB5, 0x00, 0x2A, + 0x03, 0xD0, 0x43, 0x1A, 0x93, 0x42, 0x01, 0xDD, 0x88, 0x18, 0x10, 0xBD, + 0x54, 0x42, 0xA3, 0x42, + 0xFB, 0xDA, 0x88, 0x1A, 0x10, 0xBD, 0x91, 0x42, 0x01, 0xD1, 0x00, 0xB2, + 0x70, 0x47, 0x50, 0x43, + 0xB0, 0xFB, 0xF1, 0xF0, 0x00, 0xB2, 0x90, 0x42, 0xF7, 0xD9, 0x10, 0x46, + 0xF5, 0xE7, 0x70, 0xB5, + 0x0B, 0x00, 0x02, 0x46, 0x3D, 0xD0, 0x1F, 0x4C, 0x20, 0x68, 0x46, 0x8E, + 0x85, 0x8E, 0xB2, 0xF9, + 0x02, 0x00, 0x31, 0xB2, 0xFF, 0xF7, 0x80, 0xFF, 0x58, 0x80, 0xB2, 0xF9, + 0x00, 0x00, 0x29, 0xB2, + 0xFF, 0xF7, 0x7A, 0xFF, 0x18, 0x80, 0x21, 0x68, 0x91, 0xF8, 0x36, 0x10, + 0x49, 0x07, 0x02, 0xD5, + 0x59, 0x88, 0x71, 0x1A, 0x59, 0x80, 0x21, 0x68, 0x91, 0xF8, 0x36, 0x10, + 0x89, 0x07, 0x01, 0xD5, + 0x28, 0x1A, 0x18, 0x80, 0x20, 0x68, 0x90, 0xF8, 0x36, 0x10, 0x09, 0x07, + 0x10, 0xD5, 0xB0, 0xF8, + 0x37, 0x20, 0xB3, 0xF9, 0x02, 0x00, 0x31, 0x46, 0xFF, 0xF7, 0xC5, 0xFF, + 0x58, 0x80, 0x20, 0x68, + 0x29, 0x46, 0xB0, 0xF8, 0x39, 0x20, 0xB3, 0xF9, 0x00, 0x00, 0xFF, 0xF7, + 0xBC, 0xFF, 0x18, 0x80, + 0x20, 0x68, 0x90, 0xF8, 0x36, 0x00, 0xC0, 0x07, 0x03, 0xD0, 0x58, 0x88, + 0x19, 0x88, 0x59, 0x80, + 0x18, 0x80, 0x70, 0xBD, 0x4C, 0x07, 0x10, 0x00, 0x31, 0xB5, 0xED, 0xF7, + 0xE1, 0xF9, 0x04, 0x00, + 0x08, 0xD4, 0xDD, 0xF8, 0x00, 0x00, 0x01, 0x22, 0x02, 0xFA, 0x04, 0xF1, + 0x01, 0x42, 0x01, 0xD1, + 0x64, 0x1E, 0xF9, 0xD5, 0x04, 0x21, 0x68, 0x46, 0xED, 0xF7, 0x5D, 0xFE, + 0xFE, 0x49, 0xC0, 0xB2, + 0x09, 0x68, 0x91, 0xF8, 0xE7, 0x10, 0xC1, 0xF3, 0x41, 0x11, 0x02, 0x29, + 0x0E, 0xD3, 0x10, 0xF0, + 0x03, 0x00, 0x05, 0xD0, 0x01, 0x28, 0x05, 0xD0, 0x02, 0x28, 0x05, 0xD0, + 0x1F, 0x20, 0x0A, 0xE0, + 0x0F, 0x20, 0x08, 0xE0, 0x7F, 0x20, 0x06, 0xE0, 0x3F, 0x20, 0x04, 0xE0, + 0xC0, 0x07, 0x01, 0xD0, + 0x07, 0x20, 0x00, 0xE0, 0x03, 0x20, 0x64, 0x1C, 0x00, 0x99, 0xA0, 0x40, + 0x08, 0x43, 0x38, 0xBD, + 0x10, 0xB5, 0xEE, 0x4C, 0x50, 0x28, 0x13, 0xD0, 0x09, 0xDC, 0xA0, 0xF1, + 0x10, 0x00, 0x08, 0x28, + 0x40, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, 0x0D, 0x20, 0x20, 0x20, 0x26, 0x3F, + 0x3F, 0x39, 0x51, 0x38, + 0x07, 0x28, 0x37, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, 0x17, 0x17, 0x17, 0x1D, + 0x36, 0x36, 0x30, 0x00, + 0x03, 0xF0, 0x8D, 0xFA, 0x20, 0x60, 0x03, 0xF0, 0x8C, 0xFA, 0xC4, 0xE9, + 0x04, 0x01, 0xDE, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0xE7, 0x00, 0x10, 0xF0, 0x60, 0x0F, 0x11, 0xD0, + 0x20, 0x68, 0xFF, 0xF7, + 0xA3, 0xFF, 0x20, 0x60, 0x0C, 0xE0, 0x03, 0xF0, 0x7A, 0xFA, 0x20, 0x60, + 0x03, 0xF0, 0x79, 0xFA, + 0x04, 0xE0, 0x03, 0xF0, 0x78, 0xFA, 0x20, 0x60, 0x03, 0xF0, 0x77, 0xFA, + 0xC4, 0xE9, 0x04, 0x01, + 0x04, 0x21, 0xD2, 0x48, 0xED, 0xF7, 0xFF, 0xFD, 0x60, 0x60, 0xD0, 0x48, + 0x08, 0x21, 0x10, 0x30, + 0xED, 0xF7, 0xF9, 0xFD, 0xA0, 0x60, 0x10, 0xBD, 0x03, 0xF0, 0x69, 0xFA, + 0x20, 0x60, 0x03, 0xF0, + 0x68, 0xFA, 0xEB, 0xE7, 0x00, 0x20, 0x01, 0x46, 0x20, 0x60, 0xE7, 0xE7, + 0x2D, 0xE9, 0xFF, 0x5F, + 0x04, 0x21, 0xDD, 0xE9, 0x0F, 0xAB, 0x68, 0x46, 0xED, 0xF7, 0xE5, 0xFD, + 0x81, 0x46, 0x08, 0x21, + 0x02, 0xA8, 0xED, 0xF7, 0xE0, 0xFD, 0x07, 0x46, 0x00, 0x24, 0x20, 0x46, + 0x35, 0xE0, 0x01, 0x20, + 0x00, 0x99, 0x00, 0xFA, 0x08, 0xF0, 0x08, 0x42, 0x2D, 0xD0, 0x00, 0x25, + 0x2E, 0x46, 0x27, 0xE0, + 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x03, 0xF0, 0x41, 0xFD, 0xDD, 0xE9, + 0x02, 0x23, 0x10, 0x40, + 0x19, 0x40, 0x08, 0x43, 0x1B, 0xD0, 0x11, 0x98, 0x60, 0xB1, 0x04, 0xFB, + 0x07, 0xF0, 0x0A, 0xEB, + 0x05, 0x01, 0x41, 0x56, 0x32, 0x46, 0x01, 0xEB, 0x0B, 0x03, 0x21, 0x46, + 0x0E, 0x98, 0xED, 0xF7, + 0xBC, 0xF9, 0x0B, 0xE0, 0x32, 0x46, 0x21, 0x46, 0x0E, 0x98, 0xED, 0xF7, + 0xAB, 0xF9, 0x04, 0xFB, + 0x07, 0xF1, 0x0A, 0xEB, 0x05, 0x02, 0xA0, 0xEB, 0x0B, 0x00, 0x88, 0x54, + 0x6D, 0x1C, 0x76, 0x1C, + 0xBD, 0x42, 0xD5, 0xDB, 0x64, 0x1C, 0x08, 0xF1, 0x01, 0x00, 0x80, 0x46, + 0x4C, 0x45, 0xC6, 0xDB, + 0xBD, 0xE8, 0xFF, 0x9F, 0x2D, 0xE9, 0xFF, 0x5F, 0x84, 0xB0, 0x04, 0x21, + 0xDD, 0xE9, 0x12, 0xAB, + 0x04, 0xA8, 0xED, 0xF7, 0x98, 0xFD, 0x81, 0x46, 0x08, 0x21, 0x06, 0xA8, + 0xED, 0xF7, 0x93, 0xFD, + 0x07, 0x46, 0x00, 0x25, 0x0A, 0xF1, 0x48, 0x00, 0x02, 0x90, 0x20, 0x30, + 0x01, 0x90, 0x48, 0x38, + 0x2C, 0x46, 0xA8, 0x46, 0x2E, 0x46, 0x00, 0x90, 0x31, 0xE0, 0x01, 0x20, + 0x04, 0x99, 0x00, 0xFA, + 0x08, 0xF0, 0x08, 0x42, 0x27, 0xD0, 0x16, 0x98, 0x90, 0xB1, 0x1B, 0xF8, + 0x05, 0x10, 0x14, 0x98, + 0x08, 0x44, 0xC2, 0xB2, 0x41, 0x46, 0x02, 0x98, 0xED, 0xF7, 0xDF, 0xF9, + 0x05, 0xEB, 0x09, 0x00, + 0xC1, 0x19, 0x1B, 0xF9, 0x01, 0x20, 0x41, 0x46, 0x50, 0x46, 0xED, 0xF7, + 0xAD, 0xF9, 0x10, 0xE0, + 0x41, 0x46, 0x02, 0x98, 0xED, 0xF7, 0xCF, 0xF9, 0x14, 0x99, 0x40, 0x1A, + 0x0B, 0xF8, 0x05, 0x00, + 0x41, 0x46, 0x50, 0x46, 0xED, 0xF7, 0x99, 0xF9, 0x05, 0xEB, 0x09, 0x01, + 0xCA, 0x19, 0x0B, 0xF8, + 0x02, 0x00, 0x6D, 0x1C, 0xED, 0xB2, 0x08, 0xF1, 0x01, 0x00, 0x00, 0xF0, + 0xFF, 0x08, 0x4D, 0x45, + 0xCB, 0xDB, 0x38, 0xE0, 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x03, 0xF0, + 0xBF, 0xFC, 0xDD, 0xE9, + 0x06, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x2B, 0xD0, 0x16, 0x98, + 0xA0, 0xB1, 0x04, 0xEB, + 0x09, 0x01, 0x15, 0x98, 0x1B, 0xF8, 0x01, 0x10, 0x08, 0x44, 0xC2, 0xB2, + 0x31, 0x46, 0x01, 0x98, + 0xED, 0xF7, 0xA3, 0xF9, 0x04, 0xEB, 0x49, 0x00, 0xC1, 0x19, 0x1B, 0xF9, + 0x01, 0x20, 0x31, 0x46, + 0x00, 0x98, 0xED, 0xF7, 0x71, 0xF9, 0x12, 0xE0, 0x31, 0x46, 0x01, 0x98, + 0xED, 0xF7, 0x93, 0xF9, + 0x15, 0x99, 0x04, 0xEB, 0x09, 0x02, 0x40, 0x1A, 0x0B, 0xF8, 0x02, 0x00, + 0x31, 0x46, 0x00, 0x98, + 0xED, 0xF7, 0x5B, 0xF9, 0x04, 0xEB, 0x49, 0x01, 0xCA, 0x19, 0x0B, 0xF8, + 0x02, 0x00, 0x64, 0x1C, + 0xE4, 0xB2, 0x76, 0x1C, 0xF6, 0xB2, 0xBC, 0x42, 0xC4, 0xDB, 0x08, 0xB0, + 0xBD, 0xE8, 0xF0, 0x9F, + 0x2D, 0xE9, 0xFF, 0x5F, 0x04, 0x21, 0xDD, 0xE9, 0x0E, 0xBA, 0x68, 0x46, + 0xED, 0xF7, 0x0B, 0xFD, + 0x81, 0x46, 0x08, 0x21, 0x02, 0xA8, 0xED, 0xF7, 0x06, 0xFD, 0x07, 0x46, + 0x00, 0x24, 0x20, 0x46, + 0x24, 0xE0, 0x01, 0x20, 0x00, 0x99, 0x00, 0xFA, 0x08, 0xF0, 0x08, 0x42, + 0x1C, 0xD0, 0x00, 0x25, + 0x2E, 0x46, 0x16, 0xE0, 0x32, 0x46, 0x01, 0x20, 0x00, 0x21, 0x03, 0xF0, + 0x67, 0xFC, 0xDD, 0xE9, + 0x02, 0x23, 0x10, 0x40, 0x19, 0x40, 0x08, 0x43, 0x0A, 0xD0, 0x32, 0x46, + 0x21, 0x46, 0x58, 0x46, + 0xED, 0xF7, 0xE0, 0xF8, 0x04, 0xFB, 0x07, 0x52, 0x80, 0x00, 0x2A, 0xF8, + 0x12, 0x00, 0x6D, 0x1C, + 0x76, 0x1C, 0xBD, 0x42, 0xE6, 0xDB, 0x64, 0x1C, 0x08, 0xF1, 0x01, 0x00, + 0x80, 0x46, 0x4C, 0x45, + 0xD7, 0xDB, 0x35, 0xE7, 0x2D, 0xE9, 0xFF, 0x5F, 0x04, 0x21, 0xDD, 0xE9, + 0x0E, 0x9B, 0x68, 0x46, + 0xED, 0xF7, 0xD1, 0xFC, 0x82, 0x46, 0x08, 0x21, 0x02, 0xA8, 0xED, 0xF7, + 0xCC, 0xFC, 0x00, 0x25, + 0x80, 0x46, 0x2C, 0x46, 0x2F, 0x46, 0x2E, 0x46, 0x36, 0xE0, 0x01, 0x20, + 0x00, 0x99, 0xB8, 0x40, + 0x08, 0x42, 0x2F, 0xD0, 0x39, 0x46, 0x09, 0xF1, 0x48, 0x00, 0xED, 0xF7, + 0x24, 0xF9, 0x2E, 0x49, + 0x99, 0xF8, 0x92, 0x30, 0x09, 0x68, 0x91, 0xF8, 0x43, 0xC1, 0x91, 0xF8, + 0x42, 0x11, 0x0C, 0xF0, + 0x0F, 0x02, 0x52, 0x1C, 0x53, 0x43, 0x01, 0x22, 0x02, 0xEB, 0x1C, 0x1C, + 0x00, 0xFB, 0x0C, 0x33, + 0x99, 0xF8, 0x90, 0x00, 0x02, 0xEB, 0x11, 0x11, 0x00, 0xFB, 0x01, 0x30, + 0x10, 0x99, 0x19, 0xB9, + 0x4F, 0xF6, 0xFF, 0x71, 0x01, 0xEA, 0x80, 0x00, 0x2B, 0xF8, 0x15, 0x00, + 0x39, 0x46, 0x48, 0x46, + 0xED, 0xF7, 0xD3, 0xF8, 0x05, 0xEB, 0x0A, 0x02, 0x80, 0x00, 0x42, 0x44, + 0x6D, 0x1C, 0x2B, 0xF8, + 0x12, 0x00, 0xED, 0xB2, 0x7F, 0x1C, 0xFF, 0xB2, 0x55, 0x45, 0xC6, 0xDB, + 0x45, 0xE0, 0x32, 0x46, + 0x01, 0x20, 0x00, 0x21, 0x03, 0xF0, 0xFA, 0xFB, 0xDD, 0xE9, 0x02, 0x23, + 0x10, 0x40, 0x19, 0x40, + 0x08, 0x43, 0x38, 0xD0, 0x31, 0x46, 0x09, 0xF1, 0x68, 0x00, 0xED, 0xF7, + 0xE4, 0xF8, 0x0E, 0x49, + 0x99, 0xF8, 0x93, 0x50, 0x09, 0x68, 0x91, 0xF8, 0x48, 0x21, 0x91, 0xF8, + 0x47, 0x11, 0x02, 0xF0, + 0x0F, 0x03, 0x5B, 0x1C, 0x5D, 0x43, 0x01, 0x23, 0x03, 0xEB, 0x12, 0x12, + 0x00, 0xFB, 0x02, 0x52, + 0x99, 0xF8, 0x91, 0x00, 0x03, 0xEB, 0x11, 0x11, 0x00, 0xFB, 0x01, 0x20, + 0x10, 0x99, 0x49, 0xB9, + 0x4F, 0xF6, 0xFF, 0x71, 0x04, 0xE0, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0xB0, 0x07, 0x10, 0x00, + 0x01, 0xEA, 0x80, 0x00, 0x04, 0xEB, 0x0A, 0x02, 0x31, 0x46, 0x2B, 0xF8, + 0x12, 0x00, 0x09, 0xF1, + 0x20, 0x00, 0xED, 0xF7, 0x8A, 0xF8, 0x04, 0xEB, 0x4A, 0x02, 0x80, 0x00, + 0x42, 0x44, 0x64, 0x1C, + 0x2B, 0xF8, 0x12, 0x00, 0xE4, 0xB2, 0x76, 0x1C, 0xF6, 0xB2, 0x44, 0x45, + 0xB7, 0xDB, 0x9F, 0xE6, + 0x2D, 0xE9, 0xF0, 0x43, 0x89, 0x46, 0x00, 0x27, 0x85, 0xB0, 0x90, 0x46, + 0x04, 0x46, 0x3E, 0x46, + 0xFC, 0x21, 0x03, 0xF0, 0x61, 0xFC, 0xFE, 0x4D, 0xB8, 0xF1, 0x01, 0x0F, + 0x28, 0x79, 0x20, 0x71, + 0x28, 0x7A, 0x60, 0x71, 0xFB, 0x48, 0x90, 0xF8, 0x52, 0x1E, 0xA1, 0x71, + 0x90, 0xF8, 0x53, 0x1E, + 0xE1, 0x71, 0x90, 0xF8, 0x54, 0x1E, 0xA1, 0x72, 0x90, 0xF8, 0x55, 0x1E, + 0xE1, 0x72, 0x90, 0xF8, + 0x50, 0x1E, 0x21, 0x73, 0x90, 0xF8, 0x51, 0x0E, 0x60, 0x73, 0x08, 0xD1, + 0xF2, 0x48, 0x00, 0x68, + 0x81, 0x7F, 0xA5, 0x29, 0x03, 0xD1, 0x90, 0xF9, 0x1F, 0x70, 0x90, 0xF9, + 0x20, 0x60, 0x04, 0xF1, + 0x10, 0x00, 0xCD, 0xE9, 0x01, 0x07, 0xED, 0x48, 0x00, 0x21, 0x00, 0x90, + 0xCD, 0xE9, 0x03, 0x61, + 0xD5, 0xE9, 0x04, 0x23, 0x28, 0x68, 0xFF, 0xF7, 0x65, 0xFE, 0xA5, 0x20, + 0x20, 0x70, 0x12, 0x20, + 0x60, 0x70, 0xA4, 0xF8, 0x02, 0x90, 0xD5, 0xE9, 0x01, 0x01, 0x08, 0x44, + 0x13, 0x30, 0x80, 0x08, + 0x05, 0xB0, 0xBD, 0xE8, 0xF0, 0x83, 0x2D, 0xE9, 0xF0, 0x43, 0x89, 0x46, + 0x00, 0x27, 0x85, 0xB0, + 0x90, 0x46, 0x04, 0x46, 0x3E, 0x46, 0xFC, 0x21, 0x03, 0xF0, 0x16, 0xFC, + 0xD8, 0x4D, 0xB8, 0xF1, + 0x01, 0x0F, 0x28, 0x79, 0x20, 0x71, 0x28, 0x7A, 0x60, 0x71, 0xD6, 0x48, + 0x90, 0xF8, 0xEA, 0x1E, + 0xA1, 0x71, 0x90, 0xF8, 0xEB, 0x1E, 0xE1, 0x71, 0x90, 0xF8, 0xEC, 0x1E, + 0xA1, 0x72, 0x90, 0xF8, + 0xED, 0x1E, 0xE1, 0x72, 0x90, 0xF8, 0xE8, 0x1E, 0x21, 0x73, 0x90, 0xF8, + 0xE9, 0x0E, 0x60, 0x73, + 0x09, 0xD1, 0xCD, 0x48, 0x00, 0x68, 0x90, 0xF8, 0x21, 0x10, 0xA5, 0x29, + 0x03, 0xD1, 0x10, 0xF9, + 0x22, 0x7F, 0x90, 0xF9, 0x01, 0x60, 0x04, 0xF1, 0x10, 0x00, 0xCD, 0xE9, + 0x01, 0x07, 0xC7, 0x48, + 0x00, 0x21, 0x98, 0x30, 0x00, 0x90, 0xCD, 0xE9, 0x03, 0x61, 0xD5, 0xE9, + 0x04, 0x23, 0x28, 0x68, + 0xFF, 0xF7, 0x18, 0xFE, 0xA5, 0x20, 0x20, 0x70, 0x13, 0x20, 0x60, 0x70, + 0xA4, 0xF8, 0x02, 0x90, + 0xD5, 0xE9, 0x01, 0x01, 0x08, 0x44, 0x13, 0x30, 0x80, 0x08, 0xB1, 0xE7, + 0x2D, 0xE9, 0xF0, 0x43, + 0x89, 0x46, 0x00, 0x27, 0x85, 0xB0, 0x90, 0x46, 0x04, 0x46, 0x3E, 0x46, + 0xFC, 0x21, 0x03, 0xF0, + 0xCB, 0xFB, 0xB3, 0x4D, 0xB8, 0xF1, 0x01, 0x0F, 0x28, 0x79, 0x20, 0x71, + 0x28, 0x7A, 0x60, 0x71, + 0xB0, 0x48, 0x90, 0xF8, 0x82, 0x1F, 0xA1, 0x71, 0x90, 0xF8, 0x83, 0x1F, + 0xE1, 0x71, 0x90, 0xF8, + 0x84, 0x1F, 0xA1, 0x72, 0x90, 0xF8, 0x85, 0x1F, 0xE1, 0x72, 0x90, 0xF8, + 0x80, 0x1F, 0x21, 0x73, + 0x90, 0xF8, 0x81, 0x0F, 0x60, 0x73, 0x09, 0xD1, 0xA7, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x26, 0x10, + 0xA5, 0x29, 0x03, 0xD1, 0x10, 0xF9, 0x27, 0x7F, 0x90, 0xF9, 0x01, 0x60, + 0x04, 0xF1, 0x10, 0x00, + 0xCD, 0xE9, 0x01, 0x07, 0xA2, 0x48, 0x00, 0x21, 0x00, 0x90, 0xCD, 0xE9, + 0x03, 0x61, 0xD5, 0xE9, + 0x04, 0x23, 0x28, 0x68, 0xFF, 0xF7, 0xCE, 0xFD, 0xA5, 0x20, 0x20, 0x70, + 0x17, 0x20, 0x60, 0x70, + 0xA4, 0xF8, 0x02, 0x90, 0xD5, 0xE9, 0x01, 0x01, 0x08, 0x44, 0x13, 0x30, + 0x80, 0x08, 0x67, 0xE7, + 0x2D, 0xE9, 0xFF, 0x41, 0x0D, 0x46, 0x07, 0x46, 0x00, 0x26, 0xFF, 0xF7, + 0x21, 0xFD, 0x01, 0x22, + 0x8F, 0x4C, 0x91, 0x49, 0x10, 0x3F, 0x05, 0xF1, 0x10, 0x00, 0x08, 0x2F, + 0x4E, 0xD2, 0xDF, 0xE8, + 0x07, 0xF0, 0x04, 0x15, 0x26, 0x2A, 0x2F, 0x4D, 0x4D, 0x51, 0x2B, 0x79, + 0x66, 0x68, 0xB3, 0x42, + 0x2E, 0xD1, 0x6B, 0x79, 0xA5, 0x68, 0xAB, 0x42, 0x2A, 0xD1, 0x09, 0x68, + 0x00, 0x23, 0x8D, 0x7E, + 0xA5, 0x2D, 0x01, 0xD1, 0x91, 0xF9, 0x1B, 0x30, 0x82, 0x49, 0x2D, 0xE0, + 0x2B, 0x79, 0x66, 0x68, + 0xB3, 0x42, 0x1D, 0xD1, 0x6B, 0x79, 0xA5, 0x68, 0xAB, 0x42, 0x19, 0xD1, + 0x09, 0x68, 0x00, 0x23, + 0x0D, 0x7F, 0xA5, 0x2D, 0x01, 0xD1, 0x91, 0xF9, 0x1D, 0x30, 0x7E, 0x49, + 0x1C, 0xE0, 0x28, 0x46, + 0x00, 0xF0, 0x12, 0xF9, 0x02, 0xE0, 0x28, 0x46, 0x00, 0xF0, 0x49, 0xF9, + 0x06, 0x46, 0x1D, 0xE0, + 0x2B, 0x79, 0x66, 0x68, 0xB3, 0x42, 0x03, 0xD1, 0x6B, 0x79, 0xA5, 0x68, + 0xAB, 0x42, 0x01, 0xD0, + 0x00, 0x26, 0x13, 0xE0, 0x09, 0x68, 0x00, 0x23, 0x91, 0xF8, 0x24, 0x50, + 0xA5, 0x2D, 0x01, 0xD1, + 0x91, 0xF9, 0x25, 0x30, 0x6D, 0x49, 0xA0, 0x39, 0xCD, 0xE9, 0x00, 0x10, + 0xCD, 0xE9, 0x02, 0x32, + 0xD4, 0xE9, 0x04, 0x23, 0x20, 0x68, 0xFF, 0xF7, 0x19, 0xFD, 0x01, 0x26, + 0x30, 0x46, 0x04, 0xB0, + 0xBD, 0xE8, 0xF0, 0x81, 0x28, 0x46, 0x00, 0xF0, 0x5E, 0xF9, 0xD7, 0xE7, + 0x2D, 0xE9, 0xF0, 0x41, + 0x1E, 0x46, 0x17, 0x46, 0x88, 0x46, 0x05, 0x46, 0x00, 0x24, 0xFF, 0xF7, + 0xB9, 0xFC, 0x10, 0x3D, + 0x08, 0x2D, 0x11, 0xD2, 0xDF, 0xE8, 0x05, 0xF0, 0x04, 0x0A, 0x12, 0x18, + 0x1E, 0x10, 0x10, 0x24, + 0x32, 0x46, 0x39, 0x46, 0x40, 0x46, 0x00, 0xF0, 0x81, 0xF9, 0x04, 0xE0, + 0x32, 0x46, 0x39, 0x46, + 0x40, 0x46, 0x00, 0xF0, 0xAC, 0xF9, 0x04, 0x46, 0x20, 0x46, 0xD9, 0xE7, + 0x32, 0x46, 0x39, 0x46, + 0x40, 0x46, 0xFF, 0xF7, 0x95, 0xFE, 0xF6, 0xE7, 0x32, 0x46, 0x39, 0x46, + 0x40, 0x46, 0xFF, 0xF7, + 0xDA, 0xFE, 0xF0, 0xE7, 0x32, 0x46, 0x39, 0x46, 0x40, 0x46, 0x00, 0xF0, + 0xC9, 0xF9, 0xEA, 0xE7, + 0x32, 0x46, 0x39, 0x46, 0x40, 0x46, 0xFF, 0xF7, 0x19, 0xFF, 0xE4, 0xE7, + 0xFE, 0xB5, 0x17, 0x46, + 0x06, 0x46, 0x0D, 0x46, 0xFF, 0xF7, 0x84, 0xFC, 0x41, 0x48, 0x47, 0x4A, + 0x05, 0xF1, 0x10, 0x04, + 0x01, 0x79, 0x29, 0x71, 0x01, 0x7A, 0x69, 0x71, 0xA6, 0xF1, 0x50, 0x01, + 0x08, 0x29, 0x26, 0xD2, + 0xDF, 0xE8, 0x01, 0xF0, 0x04, 0x06, 0x0F, 0x16, 0x2A, 0x25, 0x25, 0x2D, + 0x39, 0x49, 0x00, 0xE0, + 0x3C, 0x49, 0xCD, 0xE9, 0x00, 0x14, 0xD0, 0xE9, 0x04, 0x23, 0x00, 0x68, + 0xFF, 0xF7, 0x90, 0xFD, + 0x15, 0xE0, 0x11, 0x68, 0x35, 0x4A, 0x91, 0xF8, 0x42, 0x11, 0x01, 0xF0, + 0x01, 0x01, 0x06, 0xE0, + 0x11, 0x68, 0x32, 0x4A, 0x91, 0xF8, 0x92, 0x19, 0x98, 0x32, 0x01, 0xF0, + 0x01, 0x01, 0x00, 0x92, + 0xCD, 0xE9, 0x01, 0x41, 0xD0, 0xE9, 0x04, 0x23, 0x00, 0x68, 0xFF, 0xF7, + 0xB3, 0xFD, 0xA5, 0x20, + 0x28, 0x70, 0x6E, 0x70, 0x6F, 0x80, 0xFE, 0xBD, 0x28, 0x49, 0xA0, 0x39, + 0xD9, 0xE7, 0x11, 0x68, + 0x27, 0x4A, 0x91, 0xF8, 0x12, 0x1A, 0x01, 0xF0, 0x01, 0x01, 0xE8, 0xE7, + 0x2D, 0xE9, 0xF0, 0x41, + 0x0C, 0x46, 0x05, 0x46, 0x4F, 0xF4, 0x29, 0x71, 0x24, 0x48, 0x03, 0xF0, + 0xBF, 0xFA, 0x23, 0x48, + 0x00, 0x2C, 0x04, 0x60, 0x57, 0xD1, 0x80, 0x46, 0x04, 0xEB, 0x84, 0x00, + 0xC4, 0xEB, 0xC4, 0x01, + 0x05, 0xEB, 0xC0, 0x06, 0x08, 0xEB, 0x01, 0x17, 0x38, 0x1D, 0x28, 0x22, + 0x31, 0x46, 0x03, 0xF0, + 0x0C, 0xFA, 0xC4, 0xEB, 0x04, 0x10, 0x05, 0xEB, 0x80, 0x01, 0x07, 0xF1, + 0x2C, 0x00, 0x20, 0x22, + 0x78, 0x31, 0x03, 0xF0, 0x02, 0xFA, 0x06, 0xF5, 0x96, 0x71, 0x07, 0xF1, + 0x4C, 0x00, 0x28, 0x22, + 0x03, 0xF0, 0xFB, 0xF9, 0x64, 0x1C, 0x03, 0x2C, 0xDE, 0xDB, 0x00, 0x24, + 0x04, 0xEB, 0x84, 0x00, + 0xC4, 0xEB, 0xC4, 0x02, 0x05, 0xEB, 0xC0, 0x06, 0x08, 0xEB, 0x02, 0x17, + 0x06, 0xF5, 0xD2, 0x71, + 0x07, 0xF5, 0xAA, 0x70, 0x28, 0x22, 0x03, 0xF0, 0xE8, 0xF9, 0xC4, 0xEB, + 0x04, 0x10, 0x0F, 0xE0, + 0xB0, 0x07, 0x10, 0x00, 0x78, 0x8B, 0x01, 0x20, 0x50, 0x07, 0x10, 0x00, + 0x38, 0x99, 0x01, 0x20, + 0x68, 0x9A, 0x01, 0x20, 0x08, 0x92, 0x01, 0x20, 0x4C, 0x07, 0x10, 0x00, + 0x40, 0x9D, 0x01, 0x20, + 0x05, 0xEB, 0x80, 0x01, 0x07, 0xF5, 0xBE, 0x70, 0x20, 0x22, 0x01, 0xF5, + 0x07, 0x71, 0x03, 0xF0, + 0xCC, 0xF9, 0x06, 0xF5, 0x34, 0x71, 0x07, 0xF5, 0xCE, 0x70, 0x28, 0x22, + 0x03, 0xF0, 0xC5, 0xF9, + 0x64, 0x1C, 0x03, 0x2C, 0xCA, 0xDB, 0x13, 0xE7, 0x30, 0xB5, 0xA3, 0x49, + 0x02, 0x79, 0x85, 0xB0, + 0x4B, 0x68, 0x9A, 0x42, 0x03, 0xD1, 0x42, 0x79, 0x8B, 0x68, 0x9A, 0x42, + 0x02, 0xD0, 0x00, 0x20, + 0x05, 0xB0, 0x30, 0xBD, 0x9D, 0x4A, 0x85, 0x79, 0x00, 0x24, 0x82, 0xF8, + 0x52, 0x5E, 0xC5, 0x79, + 0x82, 0xF8, 0x53, 0x5E, 0x85, 0x7A, 0x82, 0xF8, 0x54, 0x5E, 0xC5, 0x7A, + 0x82, 0xF8, 0x55, 0x5E, + 0x05, 0x7B, 0x82, 0xF8, 0x50, 0x5E, 0x45, 0x7B, 0x82, 0xF8, 0x51, 0x5E, + 0x94, 0x4A, 0x23, 0x46, + 0x12, 0x68, 0x95, 0x7F, 0xA5, 0x2D, 0x03, 0xD1, 0x92, 0xF9, 0x1F, 0x40, + 0x92, 0xF9, 0x20, 0x30, + 0x10, 0x30, 0xCD, 0xE9, 0x01, 0x04, 0x8F, 0x48, 0x01, 0x22, 0x00, 0x90, + 0xCD, 0xE9, 0x03, 0x32, + 0xD1, 0xE9, 0x04, 0x23, 0x08, 0x68, 0xFF, 0xF7, 0x3D, 0xFC, 0x01, 0x20, + 0xD0, 0xE7, 0x30, 0xB5, + 0x85, 0x49, 0x02, 0x79, 0x85, 0xB0, 0x4B, 0x68, 0x9A, 0x42, 0x03, 0xD1, + 0x42, 0x79, 0x8B, 0x68, + 0x9A, 0x42, 0x01, 0xD0, 0x00, 0x20, 0xC3, 0xE7, 0x80, 0x4A, 0x85, 0x79, + 0x00, 0x24, 0x82, 0xF8, + 0xEA, 0x5E, 0xC5, 0x79, 0x82, 0xF8, 0xEB, 0x5E, 0x85, 0x7A, 0x82, 0xF8, + 0xEC, 0x5E, 0xC5, 0x7A, + 0x82, 0xF8, 0xED, 0x5E, 0x05, 0x7B, 0x82, 0xF8, 0xE8, 0x5E, 0x45, 0x7B, + 0x82, 0xF8, 0xE9, 0x5E, + 0x77, 0x4A, 0x23, 0x46, 0x12, 0x68, 0x92, 0xF8, 0x21, 0x50, 0xA5, 0x2D, + 0x03, 0xD1, 0x12, 0xF9, + 0x22, 0x4F, 0x92, 0xF9, 0x01, 0x30, 0x10, 0x30, 0xCD, 0xE9, 0x01, 0x04, + 0x71, 0x48, 0x01, 0x22, + 0x98, 0x30, 0x00, 0x90, 0xCD, 0xE9, 0x03, 0x32, 0xD1, 0xE9, 0x04, 0x23, + 0x08, 0x68, 0xFF, 0xF7, + 0x01, 0xFC, 0x01, 0x20, 0x94, 0xE7, 0x30, 0xB5, 0x67, 0x49, 0x02, 0x79, + 0x85, 0xB0, 0x4B, 0x68, + 0x9A, 0x42, 0x03, 0xD1, 0x42, 0x79, 0x8B, 0x68, 0x9A, 0x42, 0x01, 0xD0, + 0x00, 0x20, 0x87, 0xE7, + 0x62, 0x4A, 0x85, 0x79, 0x00, 0x24, 0x82, 0xF8, 0x82, 0x5F, 0xC5, 0x79, + 0x82, 0xF8, 0x83, 0x5F, + 0x85, 0x7A, 0x82, 0xF8, 0x84, 0x5F, 0xC5, 0x7A, 0x82, 0xF8, 0x85, 0x5F, + 0x05, 0x7B, 0x82, 0xF8, + 0x80, 0x5F, 0x45, 0x7B, 0x82, 0xF8, 0x81, 0x5F, 0x59, 0x4A, 0x23, 0x46, + 0x12, 0x68, 0x92, 0xF8, + 0x26, 0x50, 0xA5, 0x2D, 0x03, 0xD1, 0x12, 0xF9, 0x27, 0x4F, 0x92, 0xF9, + 0x01, 0x30, 0x10, 0x30, + 0xCD, 0xE9, 0x01, 0x04, 0x54, 0x48, 0x01, 0x22, 0x00, 0x90, 0xCD, 0xE9, + 0x03, 0x32, 0xD1, 0xE9, + 0x04, 0x23, 0x08, 0x68, 0xFF, 0xF7, 0xC6, 0xFB, 0x01, 0x20, 0x59, 0xE7, + 0x2D, 0xE9, 0xFF, 0x41, + 0x0F, 0x46, 0x15, 0x46, 0x04, 0x46, 0x00, 0x26, 0x40, 0xF2, 0x7A, 0x31, + 0x03, 0xF0, 0x84, 0xF9, + 0x45, 0x48, 0x01, 0x2D, 0x01, 0x79, 0x21, 0x71, 0x01, 0x7A, 0x61, 0x71, + 0x06, 0xD1, 0x44, 0x49, + 0x09, 0x68, 0x8A, 0x7E, 0xA5, 0x2A, 0x01, 0xD1, 0x91, 0xF9, 0x1B, 0x60, + 0x00, 0x22, 0x04, 0xF1, + 0x10, 0x01, 0x3E, 0x4B, 0xCD, 0xE9, 0x00, 0x31, 0xCD, 0xE9, 0x02, 0x62, + 0x05, 0x46, 0x00, 0x68, + 0xD5, 0xE9, 0x04, 0x23, 0xFF, 0xF7, 0x52, 0xFB, 0xA5, 0x20, 0x20, 0x70, + 0x10, 0x20, 0x60, 0x70, + 0x67, 0x80, 0xD5, 0xE9, 0x01, 0x01, 0x48, 0x43, 0x13, 0x30, 0x80, 0x08, + 0x2F, 0xE6, 0x2D, 0xE9, + 0xFF, 0x41, 0x0F, 0x46, 0x15, 0x46, 0x04, 0x46, 0x00, 0x26, 0x40, 0xF2, + 0x7A, 0x31, 0x03, 0xF0, + 0x53, 0xF9, 0x2D, 0x48, 0x01, 0x2D, 0x01, 0x79, 0x21, 0x71, 0x01, 0x7A, + 0x61, 0x71, 0x06, 0xD1, + 0x2B, 0x49, 0x09, 0x68, 0x0A, 0x7F, 0xA5, 0x2A, 0x01, 0xD1, 0x91, 0xF9, + 0x1D, 0x60, 0x00, 0x23, + 0x04, 0xF1, 0x10, 0x01, 0x29, 0x4A, 0xCD, 0xE9, 0x00, 0x21, 0xCD, 0xE9, + 0x02, 0x63, 0x05, 0x46, + 0x00, 0x68, 0xD5, 0xE9, 0x04, 0x23, 0xFF, 0xF7, 0x21, 0xFB, 0xA5, 0x20, + 0x20, 0x70, 0x11, 0x20, + 0x60, 0x70, 0x67, 0x80, 0xD5, 0xE9, 0x01, 0x01, 0x48, 0x43, 0x13, 0x30, + 0x80, 0x08, 0xFE, 0xE5, + 0x2D, 0xE9, 0xFF, 0x41, 0x0F, 0x46, 0x15, 0x46, 0x04, 0x46, 0x00, 0x26, + 0x40, 0xF2, 0x7A, 0x31, + 0x03, 0xF0, 0x22, 0xF9, 0x14, 0x48, 0x01, 0x2D, 0x01, 0x79, 0x21, 0x71, + 0x01, 0x7A, 0x61, 0x71, + 0x07, 0xD1, 0x13, 0x49, 0x09, 0x68, 0x91, 0xF8, 0x24, 0x20, 0xA5, 0x2A, + 0x01, 0xD1, 0x91, 0xF9, + 0x25, 0x60, 0x10, 0x4A, 0x00, 0x23, 0x04, 0xF1, 0x10, 0x01, 0xA0, 0x3A, + 0xCD, 0xE9, 0x00, 0x21, + 0xCD, 0xE9, 0x02, 0x63, 0x05, 0x46, 0x00, 0x68, 0xD5, 0xE9, 0x04, 0x23, + 0xFF, 0xF7, 0xEE, 0xFA, + 0xA5, 0x20, 0x20, 0x70, 0x14, 0x20, 0x60, 0x70, 0x67, 0x80, 0xD5, 0xE9, + 0x01, 0x01, 0x48, 0x43, + 0x13, 0x30, 0x80, 0x08, 0xCB, 0xE5, 0x00, 0x00, 0xB0, 0x07, 0x10, 0x00, + 0x78, 0x8B, 0x01, 0x20, + 0x50, 0x07, 0x10, 0x00, 0x38, 0x99, 0x01, 0x20, 0x68, 0x9A, 0x01, 0x20, + 0x08, 0x92, 0x01, 0x20, + 0x2D, 0xE9, 0xF0, 0x4F, 0x47, 0xF6, 0xFF, 0x77, 0xDD, 0xE9, 0x09, 0xB5, + 0x81, 0x46, 0xFE, 0x43, + 0x01, 0x20, 0x9A, 0x46, 0x84, 0x46, 0x2C, 0x46, 0x15, 0xE0, 0x00, 0xBF, + 0x32, 0xF8, 0x14, 0x30, + 0x31, 0xF8, 0x14, 0x80, 0xA3, 0xEB, 0x08, 0x03, 0x1B, 0xB2, 0xBB, 0x42, + 0x00, 0xDA, 0x1F, 0x46, + 0xB3, 0x42, 0x00, 0xDD, 0x1E, 0x46, 0x00, 0x2B, 0x02, 0xDD, 0x4F, 0xF0, + 0x00, 0x0C, 0x02, 0xE0, + 0x01, 0xDA, 0x4F, 0xF0, 0x00, 0x00, 0x64, 0x1E, 0xE8, 0xD2, 0x20, 0xB1, + 0xBC, 0xF1, 0x00, 0x0F, + 0x01, 0xD0, 0x00, 0x23, 0x09, 0xE0, 0x50, 0xEA, 0x0C, 0x03, 0x06, 0xD0, + 0x20, 0xB9, 0xBC, 0xF1, + 0x00, 0x0F, 0x01, 0xD0, 0x33, 0x46, 0x00, 0xE0, 0x3B, 0x46, 0x00, 0x27, + 0x3C, 0x46, 0x28, 0x46, + 0xCB, 0xF1, 0x00, 0x0C, 0x0E, 0xE0, 0x00, 0xBF, 0x32, 0xF8, 0x10, 0x60, + 0x31, 0xF8, 0x10, 0x80, + 0xA6, 0xEB, 0x08, 0x06, 0xF6, 0x1A, 0x36, 0xB2, 0x56, 0x45, 0x03, 0xDA, + 0x66, 0x45, 0x01, 0xDD, + 0x37, 0x44, 0x64, 0x1C, 0x40, 0x1E, 0xEF, 0xD2, 0x04, 0xB9, 0x01, 0x24, + 0x97, 0xFB, 0xF4, 0xF0, + 0x18, 0x44, 0x04, 0xE0, 0x31, 0xF8, 0x15, 0x20, 0x02, 0x44, 0x29, 0xF8, + 0x15, 0x20, 0x6D, 0x1E, + 0xF8, 0xD2, 0xBD, 0xE8, 0xF0, 0x8F, 0xF0, 0xB5, 0x00, 0x23, 0x06, 0x46, + 0x1D, 0x46, 0x18, 0x46, + 0x0E, 0xE0, 0x00, 0xBF, 0x36, 0xF9, 0x11, 0x40, 0x00, 0x2C, 0x01, 0xDB, + 0x27, 0x46, 0x00, 0xE0, + 0x67, 0x42, 0x97, 0x42, 0x04, 0xDD, 0x00, 0x2C, 0x01, 0xDD, 0x25, 0x44, + 0x00, 0xE0, 0x23, 0x44, + 0x49, 0x1E, 0xEF, 0xD2, 0x00, 0x2B, 0x00, 0xDA, 0x5B, 0x42, 0xAB, 0x42, + 0x00, 0xDD, 0x01, 0x20, + 0xF0, 0xBD, 0x30, 0xB5, 0x07, 0xE0, 0x00, 0xBF, 0x32, 0xF8, 0x13, 0x40, + 0x31, 0xF8, 0x13, 0x50, + 0x64, 0x1B, 0x20, 0xF8, 0x13, 0x40, 0x5B, 0x1E, 0xF6, 0xD2, 0x30, 0xBD, + 0xF0, 0xB4, 0x04, 0x9C, + 0x1C, 0xB9, 0x13, 0xB1, 0xC3, 0xF1, 0x10, 0x04, 0x0E, 0xE0, 0xF0, 0xBC, + 0x52, 0x00, 0x02, 0xF0, + 0xDC, 0xBF, 0x00, 0xBF, 0x30, 0xF9, 0x12, 0x50, 0x31, 0xF9, 0x12, 0x60, + 0x5D, 0x43, 0x06, 0xFB, + 0x04, 0x55, 0x2D, 0x11, 0x20, 0xF8, 0x12, 0x50, 0x52, 0x1E, 0xF3, 0xD2, + 0xF0, 0xBC, 0x70, 0x47, + 0xF0, 0xB4, 0x04, 0x9C, 0x1C, 0xB9, 0x13, 0xB1, 0xC3, 0xF1, 0x80, 0x04, + 0x0E, 0xE0, 0xF0, 0xBC, + 0x52, 0x00, 0x02, 0xF0, 0xC2, 0xBF, 0x00, 0xBF, 0x30, 0xF9, 0x12, 0x50, + 0x31, 0xF9, 0x12, 0x60, + 0x5D, 0x43, 0x06, 0xFB, 0x04, 0x55, 0xED, 0x11, 0x20, 0xF8, 0x12, 0x50, + 0x52, 0x1E, 0xF3, 0xD2, + 0xE4, 0xE7, 0xF0, 0xB5, 0x00, 0x2B, 0x19, 0xD0, 0x14, 0x46, 0x15, 0xE0, + 0x00, 0x27, 0x3E, 0x46, + 0xE5, 0x1A, 0x04, 0xEB, 0x03, 0x0C, 0x08, 0xE0, 0x00, 0x2D, 0x05, 0xDB, + 0x95, 0x42, 0x03, 0xDA, + 0x31, 0xF9, 0x15, 0xE0, 0x76, 0x1C, 0x77, 0x44, 0x6D, 0x1C, 0xAC, 0x45, + 0xF4, 0xDA, 0x1E, 0xB1, + 0x97, 0xFB, 0xF6, 0xF5, 0x20, 0xF8, 0x14, 0x50, 0x64, 0x1E, 0xE7, 0xD2, + 0xF0, 0xBD, 0x70, 0xB5, + 0x0C, 0x46, 0x15, 0x46, 0xA0, 0x42, 0x04, 0xD0, 0x01, 0x46, 0x6A, 0x00, + 0x20, 0x46, 0x02, 0xF0, + 0x8C, 0xFF, 0x00, 0x20, 0x17, 0xE0, 0x01, 0x46, 0x42, 0x1C, 0x07, 0xE0, + 0x34, 0xF9, 0x12, 0x60, + 0x34, 0xF9, 0x11, 0x30, 0x9E, 0x42, 0x00, 0xDA, 0x11, 0x46, 0x52, 0x1C, + 0xAA, 0x42, 0xF5, 0xD3, + 0x88, 0x42, 0x07, 0xD0, 0x34, 0xF8, 0x10, 0x20, 0x34, 0xF8, 0x11, 0x30, + 0x24, 0xF8, 0x10, 0x30, + 0x24, 0xF8, 0x11, 0x20, 0x40, 0x1C, 0xB0, 0xEB, 0x55, 0x0F, 0xE4, 0xD9, + 0xE9, 0x07, 0x25, 0xF0, + 0x01, 0x00, 0x01, 0xD0, 0x20, 0x5E, 0x70, 0xBD, 0x21, 0x5E, 0x20, 0x44, + 0x30, 0xF9, 0x02, 0x0C, + 0x08, 0x44, 0x40, 0x10, 0x70, 0xBD, 0x03, 0x46, 0x00, 0x20, 0x04, 0xE0, + 0x33, 0xF9, 0x11, 0x20, + 0x82, 0x42, 0x00, 0xDD, 0x10, 0x46, 0x49, 0x1E, 0xF8, 0xD2, 0x70, 0x47, + 0x03, 0x46, 0x47, 0xF6, + 0xFF, 0x70, 0x04, 0xE0, 0x33, 0xF9, 0x11, 0x20, 0x82, 0x42, 0x00, 0xDA, + 0x10, 0x46, 0x49, 0x1E, + 0xF8, 0xD2, 0x00, 0x28, 0x00, 0xDA, 0x00, 0x20, 0x70, 0x47, 0x02, 0x46, + 0xB0, 0xF9, 0x00, 0x00, + 0x05, 0xE0, 0x00, 0xBF, 0x32, 0xF9, 0x11, 0x30, 0x83, 0x42, 0x00, 0xDD, + 0x18, 0x46, 0x49, 0x1E, + 0xF8, 0xD2, 0x70, 0x47, 0x70, 0xB5, 0x05, 0x00, 0x03, 0xD0, 0xBD, 0xE8, + 0x70, 0x40, 0x02, 0xF0, + 0xE4, 0xBB, 0xFE, 0x4C, 0x21, 0x46, 0x60, 0x78, 0x09, 0x79, 0x30, 0xB1, + 0x0A, 0x46, 0xFC, 0x49, + 0x01, 0xF1, 0x98, 0x00, 0x02, 0xF0, 0x04, 0xFC, 0x0B, 0xE0, 0x20, 0x78, + 0x02, 0xF0, 0x42, 0xFD, + 0x21, 0x79, 0x4A, 0x00, 0xF6, 0x49, 0x01, 0xEB, 0x40, 0x01, 0xF5, 0x48, + 0x98, 0x30, 0x02, 0xF0, + 0x1C, 0xFF, 0xA0, 0x78, 0xF3, 0x4E, 0x28, 0xB1, 0xF1, 0x48, 0x21, 0x79, + 0x98, 0x30, 0x02, 0xF0, + 0x2F, 0xFD, 0x01, 0xE0, 0xEE, 0x48, 0x98, 0x30, 0xB0, 0x62, 0xE0, 0x78, + 0x86, 0xF8, 0x31, 0x00, + 0x28, 0x46, 0xD2, 0xE7, 0x2D, 0xE9, 0xF0, 0x47, 0xDF, 0xF8, 0xAC, 0xA3, + 0x01, 0x27, 0xB8, 0x46, + 0xDA, 0xF8, 0x00, 0x00, 0x00, 0xF2, 0x5E, 0x64, 0x90, 0xF8, 0xA6, 0x19, + 0x90, 0xF8, 0xA2, 0x59, + 0x01, 0xF0, 0x1F, 0x06, 0x90, 0xF8, 0xA3, 0x19, 0x01, 0xF0, 0x0F, 0x09, + 0x90, 0xF8, 0x82, 0x19, + 0x89, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x58, 0x16, 0x90, 0xF8, 0x59, 0x06, + 0x0A, 0x22, 0x04, 0xEB, + 0x40, 0x00, 0x02, 0xF0, 0x09, 0xFC, 0x07, 0x46, 0xDA, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x82, 0x19, + 0x49, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x68, 0x18, 0x90, 0xF8, 0x69, 0x08, + 0x0A, 0x22, 0x04, 0xEB, + 0x40, 0x00, 0x02, 0xF0, 0xF9, 0xFB, 0x80, 0x46, 0x4F, 0xF4, 0x80, 0x70, + 0x85, 0x42, 0x00, 0xD9, + 0x05, 0x46, 0x1F, 0x2E, 0x00, 0xD9, 0x1F, 0x26, 0x76, 0x1C, 0x75, 0x43, + 0x09, 0xF1, 0x01, 0x00, + 0x45, 0x43, 0xC5, 0xEB, 0x45, 0x20, 0x78, 0x43, 0x00, 0xFB, 0x08, 0xF0, + 0xC0, 0x13, 0xB0, 0xFA, + 0x80, 0xF0, 0xC0, 0xF1, 0x20, 0x00, 0xC0, 0xB2, 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xF0, 0x41, + 0x04, 0x46, 0xEC, 0xF7, 0x61, 0xFA, 0xC2, 0x48, 0xEC, 0xF7, 0x63, 0xFA, + 0xA4, 0xF8, 0x76, 0x00, + 0x02, 0xF0, 0xB2, 0xFB, 0x01, 0x46, 0x20, 0x46, 0xEC, 0xF7, 0xCC, 0xFC, + 0x02, 0xF0, 0xB0, 0xFB, + 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEC, 0xF7, 0xE7, 0xFC, 0x20, 0x46, + 0x02, 0xF0, 0xE2, 0xFC, + 0xB9, 0x4D, 0xB4, 0xF8, 0x56, 0x10, 0x28, 0x68, 0xB0, 0xF8, 0xBE, 0x20, + 0x62, 0xF3, 0x09, 0x01, + 0xA4, 0xF8, 0x56, 0x10, 0x90, 0xF8, 0xBD, 0x00, 0x94, 0xF8, 0x55, 0x10, + 0x60, 0xF3, 0x03, 0x01, + 0x84, 0xF8, 0x55, 0x10, 0x04, 0x21, 0x20, 0x46, 0xEC, 0xF7, 0x69, 0xFA, + 0x28, 0x68, 0x90, 0xF8, + 0xA2, 0x09, 0xA0, 0x70, 0x28, 0x68, 0x21, 0x8E, 0xB0, 0xF8, 0xA7, 0x29, + 0x62, 0xF3, 0x08, 0x01, + 0x21, 0x86, 0x90, 0xF8, 0xA3, 0x09, 0x00, 0xF0, 0x0F, 0x01, 0x20, 0x46, + 0xEC, 0xF7, 0xB7, 0xFA, + 0x28, 0x68, 0x34, 0xF8, 0x1A, 0x1F, 0xB0, 0xF8, 0x8E, 0x29, 0x62, 0xF3, + 0x0B, 0x01, 0x24, 0xF8, + 0x12, 0x19, 0xB0, 0xF8, 0x8C, 0x29, 0x21, 0x89, 0x62, 0xF3, 0x0B, 0x01, + 0x21, 0x81, 0xB0, 0xF8, + 0x8A, 0x29, 0xA1, 0x88, 0x62, 0xF3, 0x0B, 0x01, 0xA1, 0x80, 0x90, 0xF8, + 0xA4, 0x29, 0xA1, 0x7A, + 0x62, 0xF3, 0x01, 0x01, 0xA1, 0x72, 0x90, 0xF8, 0xA4, 0x29, 0x92, 0x08, + 0x62, 0xF3, 0x87, 0x11, + 0xA1, 0x72, 0x90, 0xF8, 0x82, 0x19, 0x14, 0xF8, 0x01, 0x2C, 0x61, 0xF3, + 0x00, 0x02, 0x04, 0xF8, + 0x01, 0x2C, 0x90, 0xF8, 0x85, 0x09, 0x60, 0x70, 0x90, 0x48, 0x90, 0xF8, + 0xE8, 0x1E, 0xA1, 0x75, + 0x90, 0xF8, 0xE9, 0x1E, 0x21, 0x77, 0x90, 0xF8, 0xEA, 0x1E, 0xE1, 0x75, + 0x90, 0xF8, 0xEB, 0x1E, + 0x61, 0x77, 0x90, 0xF8, 0xEC, 0x1E, 0x21, 0x76, 0x90, 0xF8, 0xED, 0x0E, + 0xA0, 0x77, 0x88, 0x48, + 0xEC, 0xF7, 0xE7, 0xF9, 0xA4, 0xF8, 0x78, 0x00, 0x85, 0x48, 0x20, 0x30, + 0xEC, 0xF7, 0xE1, 0xF9, + 0xA4, 0xF8, 0x7C, 0x00, 0x28, 0x68, 0x26, 0x7D, 0x90, 0xF8, 0x92, 0x19, + 0x09, 0x09, 0x61, 0xF3, + 0x07, 0x16, 0x26, 0x75, 0x90, 0xF8, 0x97, 0x19, 0x0A, 0x09, 0xA1, 0x7E, + 0x62, 0xF3, 0x07, 0x11, + 0xA1, 0x76, 0x90, 0xF8, 0x93, 0x29, 0x63, 0x7D, 0x62, 0xF3, 0x03, 0x03, + 0x63, 0x75, 0x90, 0xF8, + 0x98, 0x79, 0xE2, 0x7E, 0x67, 0xF3, 0x03, 0x02, 0xE2, 0x76, 0x90, 0xF8, + 0x93, 0x79, 0x3F, 0x09, + 0x67, 0xF3, 0x07, 0x13, 0x63, 0x75, 0x90, 0xF8, 0x98, 0x39, 0x1B, 0x09, + 0x63, 0xF3, 0x07, 0x12, + 0xE2, 0x76, 0x90, 0xF8, 0x92, 0x29, 0x62, 0xF3, 0x00, 0x06, 0x26, 0x75, + 0x90, 0xF8, 0x97, 0x29, + 0x62, 0xF3, 0x00, 0x01, 0xA1, 0x76, 0x90, 0xF8, 0x87, 0x09, 0x01, 0x09, + 0xE0, 0x78, 0x61, 0xF3, + 0x03, 0x00, 0xE0, 0x70, 0x66, 0x48, 0x48, 0x38, 0xEC, 0xF7, 0xA3, 0xF9, + 0xA4, 0xF8, 0x76, 0x00, + 0x63, 0x48, 0x28, 0x38, 0xEC, 0xF7, 0x9D, 0xF9, 0xA4, 0xF8, 0x7A, 0x00, + 0x29, 0x68, 0x91, 0xF8, + 0x84, 0x09, 0xC2, 0x08, 0x14, 0xF8, 0x1F, 0x0F, 0x62, 0xF3, 0x83, 0x00, + 0x20, 0x70, 0x91, 0xF8, + 0x84, 0x29, 0x52, 0x08, 0x62, 0xF3, 0x00, 0x00, 0x20, 0x70, 0x91, 0xF8, + 0x84, 0x29, 0x92, 0x08, + 0x62, 0xF3, 0x41, 0x00, 0x04, 0xF8, 0x27, 0x09, 0x91, 0xF8, 0x83, 0x09, + 0xC0, 0xF3, 0x81, 0x01, + 0x20, 0x46, 0xEC, 0xF7, 0xF9, 0xF9, 0x28, 0x68, 0x90, 0xF8, 0x83, 0x09, + 0x01, 0x09, 0x14, 0xF8, + 0x28, 0x0F, 0x61, 0xF3, 0x04, 0x10, 0x20, 0x70, 0x4E, 0x48, 0xEC, 0xF7, + 0x72, 0xF9, 0xA4, 0xF8, + 0x60, 0x00, 0x4C, 0x48, 0x20, 0x30, 0xEC, 0xF7, 0x6C, 0xF9, 0xA4, 0xF8, + 0x62, 0x00, 0x28, 0x68, + 0x90, 0xF8, 0x82, 0x19, 0xCA, 0x08, 0xE1, 0x7A, 0x62, 0xF3, 0x45, 0x11, + 0xE1, 0x72, 0x90, 0xF8, + 0x83, 0x09, 0x41, 0x08, 0x20, 0x78, 0x61, 0xF3, 0x45, 0x10, 0x04, 0xF8, + 0x28, 0x09, 0x20, 0x46, + 0x02, 0xF0, 0x8D, 0xFB, 0x28, 0x68, 0x90, 0xF8, 0x86, 0x09, 0x81, 0x09, + 0x20, 0x46, 0xEC, 0xF7, + 0xB8, 0xF9, 0x14, 0xF8, 0x32, 0x0F, 0x20, 0xF0, 0x0F, 0x00, 0x0A, 0x30, + 0x20, 0xF0, 0xF0, 0x00, + 0xA0, 0x30, 0x04, 0xF8, 0x1C, 0x09, 0x29, 0x68, 0x91, 0xF8, 0x82, 0x09, + 0x82, 0x09, 0x60, 0x7F, + 0x62, 0xF3, 0x00, 0x00, 0x60, 0x77, 0x91, 0xF8, 0x82, 0x29, 0x52, 0x09, + 0x62, 0xF3, 0x41, 0x00, + 0x60, 0x77, 0x91, 0xF8, 0x88, 0x29, 0x62, 0xF3, 0x82, 0x00, 0x60, 0x77, + 0x91, 0xF8, 0xA5, 0x09, + 0xE2, 0x7D, 0x60, 0xF3, 0x04, 0x02, 0xE2, 0x75, 0x91, 0xF8, 0xA6, 0x09, + 0xA1, 0x7D, 0x60, 0xF3, + 0x04, 0x01, 0x23, 0x48, 0xA1, 0x75, 0x08, 0x38, 0x94, 0xF8, 0x49, 0x10, + 0x40, 0x78, 0x60, 0xF3, + 0x04, 0x01, 0x23, 0x48, 0x84, 0xF8, 0x49, 0x10, 0xE8, 0x30, 0xEC, 0xF7, + 0x1A, 0xF9, 0xA4, 0xF8, + 0x64, 0x00, 0x28, 0x68, 0x21, 0x8B, 0xB0, 0xF8, 0x90, 0x29, 0x62, 0xF3, + 0x0B, 0x01, 0x21, 0x83, + 0x90, 0xF8, 0x86, 0x19, 0xCA, 0x08, 0x94, 0xF8, 0x22, 0x10, 0x62, 0xF3, + 0x02, 0x01, 0x84, 0xF8, + 0x22, 0x10, 0x10, 0xF8, 0xE0, 0x1F, 0x22, 0x7D, 0x61, 0xF3, 0x03, 0x02, + 0x22, 0x75, 0x10, 0xF8, + 0xE0, 0x1B, 0x0A, 0x09, 0x61, 0x7D, 0x62, 0xF3, 0x03, 0x01, 0x61, 0x75, + 0x90, 0xF8, 0xC7, 0x17, + 0xE2, 0x7C, 0x61, 0xF3, 0x02, 0x02, 0xE2, 0x74, 0x90, 0xF8, 0xC2, 0x17, + 0xCA, 0x09, 0xA1, 0x7F, + 0x62, 0xF3, 0x00, 0x01, 0xA1, 0x77, 0x94, 0xF8, 0x49, 0x10, 0x41, 0xF0, + 0x20, 0x01, 0x84, 0xF8, + 0x49, 0x10, 0x90, 0xF8, 0xC4, 0x27, 0xD2, 0x09, 0x0E, 0xE0, 0x00, 0x00, + 0xC8, 0x07, 0x10, 0x00, + 0x7C, 0xA0, 0x01, 0x20, 0xB4, 0x84, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x78, 0x8B, 0x01, 0x20, + 0x18, 0x9A, 0x01, 0x20, 0x48, 0xBF, 0x01, 0x20, 0x62, 0xF3, 0xC7, 0x11, + 0x84, 0xF8, 0x49, 0x10, + 0xB0, 0xF8, 0xDC, 0x27, 0xB4, 0xF8, 0x4A, 0x10, 0x62, 0xF3, 0x08, 0x01, + 0xA4, 0xF8, 0x4A, 0x10, + 0x00, 0x21, 0xE1, 0x64, 0x90, 0xF8, 0xC7, 0x17, 0xCA, 0x08, 0x61, 0x7F, + 0x62, 0xF3, 0xC3, 0x01, + 0x61, 0x77, 0x90, 0xF8, 0xC2, 0x27, 0x12, 0x09, 0x62, 0xF3, 0x04, 0x11, + 0x61, 0x77, 0x90, 0xF8, + 0xE5, 0x17, 0x4A, 0x09, 0x14, 0xF8, 0x0E, 0x1C, 0x62, 0xF3, 0x06, 0x11, + 0x04, 0xF8, 0x0E, 0x1C, + 0x90, 0xF8, 0xC3, 0x17, 0x4A, 0x09, 0xA1, 0x78, 0x62, 0xF3, 0xC3, 0x01, + 0xA1, 0x70, 0x90, 0xF8, + 0xC2, 0x27, 0x52, 0x08, 0x62, 0xF3, 0x04, 0x11, 0xA1, 0x70, 0x90, 0xF8, + 0xC4, 0x07, 0x80, 0x09, + 0x60, 0xF3, 0x86, 0x11, 0xA1, 0x70, 0xBD, 0xE8, 0xF0, 0x81, 0x2D, 0xE9, + 0xF0, 0x41, 0x04, 0x46, + 0x6A, 0x4D, 0x01, 0x20, 0x01, 0x29, 0xA8, 0x70, 0x08, 0xD0, 0x00, 0x26, + 0x68, 0x4F, 0x02, 0x29, + 0x08, 0xD0, 0x03, 0x29, 0x14, 0xD0, 0x04, 0x29, 0x2C, 0xD1, 0x3C, 0xE0, + 0x20, 0x46, 0x00, 0xF0, + 0xC0, 0xF8, 0x27, 0xE0, 0x63, 0x48, 0xFF, 0xF7, 0x19, 0xFE, 0x20, 0x46, + 0x00, 0xF0, 0xB9, 0xF8, + 0xB8, 0x78, 0x94, 0xF8, 0x5F, 0x10, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, + 0x5F, 0x10, 0x14, 0xE0, + 0x5C, 0x48, 0xFF, 0xF7, 0x0B, 0xFE, 0x20, 0x46, 0x00, 0xF0, 0xAB, 0xF8, + 0xF8, 0x78, 0x94, 0xF8, + 0x5F, 0x10, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x5F, 0x10, 0x94, 0xF8, + 0x27, 0x00, 0x20, 0xF0, + 0x02, 0x00, 0x40, 0xF0, 0x01, 0x00, 0x84, 0xF8, 0x27, 0x00, 0x00, 0x21, + 0x20, 0x46, 0xEC, 0xF7, + 0xEE, 0xF8, 0xAE, 0x70, 0x20, 0x46, 0x02, 0xF0, 0xD9, 0xFA, 0x94, 0xF8, + 0x27, 0x00, 0x40, 0xF3, + 0x00, 0x00, 0x40, 0x1C, 0xE8, 0x70, 0x4C, 0x48, 0x00, 0x68, 0x90, 0xF8, + 0x83, 0x09, 0xC0, 0xF3, + 0x80, 0x10, 0x68, 0x70, 0xAF, 0xE7, 0x20, 0x46, 0x00, 0xF0, 0x83, 0xF8, + 0x14, 0xF8, 0x37, 0x0F, + 0x40, 0xF0, 0x10, 0x00, 0x04, 0xF8, 0x1F, 0x09, 0xE0, 0x7E, 0x20, 0xF0, + 0x23, 0x00, 0xE0, 0x76, + 0x34, 0xF8, 0x0C, 0x0C, 0x6F, 0xF3, 0x0B, 0x00, 0x10, 0x30, 0x24, 0xF8, + 0x0C, 0x0C, 0x34, 0xF8, + 0x08, 0x0C, 0x6F, 0xF3, 0x0B, 0x00, 0x40, 0x30, 0x24, 0xF8, 0x08, 0x0C, + 0x08, 0x20, 0x04, 0xF8, + 0x16, 0x0C, 0x94, 0xF8, 0x47, 0x00, 0x20, 0xF0, 0x1F, 0x00, 0x84, 0xF8, + 0x47, 0x00, 0x34, 0xF8, + 0x18, 0x0F, 0x6F, 0xF3, 0x08, 0x00, 0x24, 0xF8, 0x03, 0x0B, 0x20, 0x78, + 0x40, 0xF0, 0x0C, 0x00, + 0x04, 0xF8, 0x0B, 0x09, 0x20, 0x78, 0x40, 0xF0, 0x20, 0x00, 0x04, 0xF8, + 0x28, 0x09, 0xB8, 0xE7, + 0x38, 0xB5, 0x02, 0xF0, 0x69, 0xF9, 0x00, 0x90, 0x04, 0x21, 0x68, 0x46, + 0xEC, 0xF7, 0xBB, 0xFC, + 0x26, 0x49, 0x27, 0x4D, 0x08, 0x71, 0x00, 0x20, 0x28, 0x60, 0x28, 0x71, + 0x01, 0x24, 0xE0, 0xB2, + 0xFF, 0xF7, 0x50, 0xFD, 0x28, 0x55, 0x64, 0x1C, 0x05, 0x2C, 0xF8, 0xDB, + 0x21, 0x48, 0xFF, 0xF7, + 0x95, 0xFD, 0x38, 0xBD, 0x30, 0xB5, 0x01, 0x7A, 0xA9, 0xB0, 0x79, 0xB3, + 0x68, 0x46, 0xFF, 0xF7, + 0x5C, 0xFF, 0x9D, 0xF8, 0x12, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x02, 0xF0, + 0xB7, 0xF9, 0x1A, 0x4C, + 0x20, 0x68, 0x00, 0xF2, 0x5E, 0x63, 0x00, 0xF6, 0x6E, 0x05, 0x90, 0xF8, + 0x58, 0x16, 0x90, 0xF8, + 0x59, 0x06, 0x03, 0xEB, 0x40, 0x00, 0x02, 0xF0, 0x7A, 0xF9, 0x20, 0x68, + 0x90, 0xF8, 0x68, 0x18, + 0x90, 0xF8, 0x69, 0x08, 0x05, 0xEB, 0x40, 0x00, 0x02, 0xF0, 0x88, 0xF9, + 0x0B, 0x48, 0x41, 0x78, + 0x01, 0xB1, 0x02, 0x21, 0x01, 0x70, 0xC9, 0xB2, 0x68, 0x46, 0xEC, 0xF7, + 0x7F, 0xFA, 0x0B, 0x49, + 0x68, 0x46, 0xEC, 0xF7, 0xB0, 0xFA, 0x00, 0x20, 0x29, 0xB0, 0x30, 0xBD, + 0xFF, 0xE7, 0x01, 0x20, + 0xFA, 0xE7, 0xA4, 0x22, 0x03, 0x49, 0x02, 0xF0, 0x18, 0xBC, 0x00, 0x00, + 0xC8, 0x07, 0x10, 0x00, + 0x74, 0xA0, 0x01, 0x20, 0xE0, 0x7E, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x95, 0x42, 0x01, 0x00, + 0x10, 0xB5, 0x04, 0x00, 0x03, 0xD0, 0xBD, 0xE8, 0x10, 0x40, 0x02, 0xF0, + 0xB6, 0xB8, 0xFE, 0x48, + 0x02, 0x46, 0x81, 0x78, 0x52, 0x78, 0x29, 0xB1, 0xFC, 0x49, 0xA1, 0xF1, + 0x0A, 0x00, 0x02, 0xF0, + 0xD7, 0xF8, 0x0B, 0xE0, 0x03, 0x78, 0x00, 0x21, 0x01, 0x2B, 0x00, 0xD8, + 0x11, 0x46, 0xF7, 0x48, + 0x52, 0x00, 0x00, 0xEB, 0x41, 0x01, 0x0A, 0x38, 0x02, 0xF0, 0xEF, 0xFB, + 0xF3, 0x48, 0xF4, 0x49, + 0x0A, 0x38, 0xC8, 0x62, 0x20, 0x46, 0xDE, 0xE7, 0x2D, 0xE9, 0xF0, 0x47, + 0xDF, 0xF8, 0xC4, 0xA3, + 0x01, 0x27, 0xB8, 0x46, 0xDA, 0xF8, 0x00, 0x00, 0x00, 0xF2, 0x5E, 0x64, + 0x90, 0xF8, 0x22, 0x1A, + 0x90, 0xF8, 0x1E, 0x5A, 0x01, 0xF0, 0x1F, 0x06, 0x90, 0xF8, 0x1F, 0x1A, + 0x01, 0xF0, 0x0F, 0x09, + 0x90, 0xF8, 0x02, 0x1A, 0x89, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x5C, 0x16, + 0x90, 0xF8, 0x5D, 0x06, + 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x02, 0xF0, 0xE7, 0xF8, 0x07, 0x46, + 0xDA, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x02, 0x1A, 0x49, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x6C, 0x18, + 0x90, 0xF8, 0x6D, 0x08, + 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x02, 0xF0, 0xD7, 0xF8, 0x80, 0x46, + 0x4F, 0xF4, 0x80, 0x70, + 0x85, 0x42, 0x00, 0xD9, 0x05, 0x46, 0x1F, 0x2E, 0x00, 0xD9, 0x1F, 0x26, + 0x76, 0x1C, 0x75, 0x43, + 0x09, 0xF1, 0x01, 0x00, 0x45, 0x43, 0xC5, 0xEB, 0x45, 0x20, 0x78, 0x43, + 0x00, 0xFB, 0x08, 0xF0, + 0xC0, 0x13, 0xB0, 0xFA, 0x80, 0xF0, 0xC0, 0xF1, 0x20, 0x00, 0xC0, 0xB2, + 0xBD, 0xE8, 0xF0, 0x87, + 0x2D, 0xE9, 0xF0, 0x41, 0x04, 0x46, 0xEB, 0xF7, 0x3F, 0xFF, 0xC8, 0x48, + 0xEB, 0xF7, 0x41, 0xFF, + 0xA4, 0xF8, 0x76, 0x00, 0x02, 0xF0, 0xA5, 0xF8, 0x01, 0x46, 0x20, 0x46, + 0xEC, 0xF7, 0xAA, 0xF9, + 0x02, 0xF0, 0xA4, 0xF8, 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEC, 0xF7, + 0xC5, 0xF9, 0x04, 0x21, + 0x20, 0x46, 0xEB, 0xF7, 0x5C, 0xFF, 0xBF, 0x4D, 0x28, 0x68, 0x90, 0xF8, + 0x1E, 0x0A, 0xA0, 0x70, + 0x28, 0x68, 0x21, 0x8E, 0xB0, 0xF8, 0x23, 0x2A, 0x62, 0xF3, 0x08, 0x01, + 0x21, 0x86, 0x90, 0xF8, + 0x1F, 0x0A, 0x00, 0xF0, 0x0F, 0x01, 0x20, 0x46, 0xEB, 0xF7, 0xA9, 0xFF, + 0x28, 0x68, 0x34, 0xF8, + 0x1A, 0x1F, 0xB0, 0xF8, 0x0E, 0x2A, 0x62, 0xF3, 0x0B, 0x01, 0x24, 0xF8, + 0x12, 0x19, 0xB0, 0xF8, + 0x0C, 0x2A, 0x21, 0x89, 0x62, 0xF3, 0x0B, 0x01, 0x21, 0x81, 0xB0, 0xF8, + 0x0A, 0x2A, 0xA1, 0x88, + 0x62, 0xF3, 0x0B, 0x01, 0xA1, 0x80, 0x90, 0xF8, 0x20, 0x2A, 0xA1, 0x7A, + 0x62, 0xF3, 0x01, 0x01, + 0xA1, 0x72, 0x90, 0xF8, 0x20, 0x2A, 0x92, 0x08, 0x62, 0xF3, 0x87, 0x11, + 0xA1, 0x72, 0x90, 0xF8, + 0x02, 0x1A, 0x14, 0xF8, 0x01, 0x2C, 0x61, 0xF3, 0x00, 0x02, 0x04, 0xF8, + 0x01, 0x2C, 0x90, 0xF8, + 0x05, 0x0A, 0x60, 0x70, 0xA0, 0x48, 0x90, 0xF8, 0x80, 0x1F, 0xA1, 0x75, + 0x90, 0xF8, 0x81, 0x1F, + 0x21, 0x77, 0x90, 0xF8, 0x82, 0x1F, 0xE1, 0x75, 0x90, 0xF8, 0x83, 0x1F, + 0x61, 0x77, 0x90, 0xF8, + 0x84, 0x1F, 0x21, 0x76, 0x90, 0xF8, 0x85, 0x0F, 0xA0, 0x77, 0x98, 0x48, + 0xEB, 0xF7, 0xD9, 0xFE, + 0xA4, 0xF8, 0x78, 0x00, 0x95, 0x48, 0x20, 0x30, 0xEB, 0xF7, 0xD3, 0xFE, + 0xA4, 0xF8, 0x7C, 0x00, + 0x28, 0x68, 0x23, 0x7D, 0x90, 0xF8, 0x12, 0x1A, 0x09, 0x09, 0x61, 0xF3, + 0x07, 0x13, 0x23, 0x75, + 0x90, 0xF8, 0x17, 0x1A, 0xA6, 0x7E, 0x09, 0x09, 0x61, 0xF3, 0x07, 0x16, + 0xA6, 0x76, 0x90, 0xF8, + 0x13, 0x1A, 0x62, 0x7D, 0x61, 0xF3, 0x03, 0x02, 0x62, 0x75, 0x90, 0xF8, + 0x18, 0x7A, 0xE1, 0x7E, + 0x67, 0xF3, 0x03, 0x01, 0xE1, 0x76, 0x90, 0xF8, 0x13, 0x7A, 0x3F, 0x09, + 0x67, 0xF3, 0x07, 0x12, + 0x62, 0x75, 0x90, 0xF8, 0x18, 0x2A, 0x12, 0x09, 0x62, 0xF3, 0x07, 0x11, + 0xE1, 0x76, 0x90, 0xF8, + 0x12, 0x1A, 0x61, 0xF3, 0x00, 0x03, 0x23, 0x75, 0x90, 0xF8, 0x17, 0x1A, + 0x61, 0xF3, 0x00, 0x06, + 0xA6, 0x76, 0x90, 0xF8, 0x07, 0x0A, 0x01, 0x09, 0xE0, 0x78, 0x61, 0xF3, + 0x03, 0x00, 0xE0, 0x70, + 0x76, 0x48, 0x48, 0x38, 0xEB, 0xF7, 0x95, 0xFE, 0xA4, 0xF8, 0x76, 0x00, + 0x73, 0x48, 0x28, 0x38, + 0xEB, 0xF7, 0x8F, 0xFE, 0xA4, 0xF8, 0x7A, 0x00, 0x28, 0x68, 0x90, 0xF8, + 0x04, 0x1A, 0xCA, 0x08, + 0x14, 0xF8, 0x1F, 0x1F, 0x62, 0xF3, 0x83, 0x01, 0x41, 0xF0, 0x01, 0x01, + 0x21, 0x70, 0x90, 0xF8, + 0x04, 0x2A, 0x92, 0x08, 0x62, 0xF3, 0x41, 0x01, 0x04, 0xF8, 0x27, 0x19, + 0x90, 0xF8, 0x03, 0x0A, + 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, 0xEB, 0xF7, 0xEF, 0xFE, 0x28, 0x68, + 0x90, 0xF8, 0x03, 0x0A, + 0x01, 0x09, 0x14, 0xF8, 0x28, 0x0F, 0x61, 0xF3, 0x04, 0x10, 0x20, 0x70, + 0x60, 0x48, 0xEB, 0xF7, + 0x68, 0xFE, 0xA4, 0xF8, 0x60, 0x00, 0x5E, 0x48, 0x20, 0x30, 0xEB, 0xF7, + 0x62, 0xFE, 0xA4, 0xF8, + 0x62, 0x00, 0x28, 0x68, 0x90, 0xF8, 0x02, 0x1A, 0xCA, 0x08, 0xE1, 0x7A, + 0x62, 0xF3, 0x45, 0x11, + 0xE1, 0x72, 0x90, 0xF8, 0x03, 0x0A, 0x41, 0x08, 0x20, 0x78, 0x61, 0xF3, + 0x45, 0x10, 0x04, 0xF8, + 0x28, 0x09, 0x20, 0x46, 0x02, 0xF0, 0x4A, 0xF8, 0x28, 0x68, 0x90, 0xF8, + 0x06, 0x0A, 0x81, 0x09, + 0x20, 0x46, 0xEB, 0xF7, 0xAE, 0xFE, 0x14, 0xF8, 0x32, 0x0F, 0x20, 0xF0, + 0x0F, 0x00, 0x0A, 0x30, + 0x20, 0xF0, 0xF0, 0x00, 0xA0, 0x30, 0x04, 0xF8, 0x1C, 0x09, 0x29, 0x68, + 0x91, 0xF8, 0x02, 0x0A, + 0x82, 0x09, 0x60, 0x7F, 0x62, 0xF3, 0x00, 0x00, 0x60, 0x77, 0x91, 0xF8, + 0x02, 0x2A, 0x52, 0x09, + 0x62, 0xF3, 0x41, 0x00, 0x60, 0x77, 0x91, 0xF8, 0x08, 0x2A, 0x62, 0xF3, + 0x82, 0x00, 0x60, 0x77, + 0x91, 0xF8, 0x21, 0x0A, 0xE2, 0x7D, 0x60, 0xF3, 0x04, 0x02, 0xE2, 0x75, + 0x91, 0xF8, 0x22, 0x0A, + 0xA1, 0x7D, 0x60, 0xF3, 0x04, 0x01, 0x35, 0x48, 0xA1, 0x75, 0x10, 0x38, + 0x94, 0xF8, 0x49, 0x10, + 0x40, 0x78, 0x60, 0xF3, 0x04, 0x01, 0x35, 0x48, 0x84, 0xF8, 0x49, 0x10, + 0x50, 0x30, 0xEB, 0xF7, + 0x10, 0xFE, 0xA4, 0xF8, 0x64, 0x00, 0x28, 0x68, 0x34, 0xF8, 0x18, 0x1F, + 0xB0, 0xF8, 0x10, 0x2A, + 0x62, 0xF3, 0x0B, 0x01, 0x24, 0xF8, 0x0A, 0x1B, 0x90, 0xF8, 0x06, 0x1A, + 0xCA, 0x08, 0x21, 0x78, + 0x62, 0xF3, 0x02, 0x01, 0x04, 0xF8, 0x0E, 0x19, 0x10, 0xF8, 0xE0, 0x1F, + 0x22, 0x78, 0x61, 0xF3, + 0x03, 0x02, 0x04, 0xF8, 0x01, 0x2B, 0x01, 0x78, 0x0A, 0x09, 0x21, 0x78, + 0x62, 0xF3, 0x03, 0x01, + 0x04, 0xF8, 0x02, 0x19, 0x90, 0xF8, 0x27, 0x19, 0x22, 0x78, 0x61, 0xF3, + 0x02, 0x02, 0x04, 0xF8, + 0x0B, 0x2B, 0x90, 0xF8, 0x22, 0x19, 0xCA, 0x09, 0x21, 0x78, 0x62, 0xF3, + 0x00, 0x01, 0x04, 0xF8, + 0x0E, 0x1B, 0x14, 0xF8, 0x1D, 0x1F, 0x41, 0xF0, 0x20, 0x01, 0x21, 0x70, + 0x90, 0xF8, 0x24, 0x29, + 0xD2, 0x09, 0x62, 0xF3, 0xC7, 0x11, 0x04, 0xF8, 0x01, 0x1B, 0xB0, 0xF8, + 0x3C, 0x29, 0x21, 0x88, + 0x62, 0xF3, 0x08, 0x01, 0x24, 0xF8, 0x02, 0x1B, 0x00, 0x21, 0x44, 0xF8, + 0x2F, 0x19, 0x90, 0xF8, + 0x27, 0x19, 0xCA, 0x08, 0x21, 0x78, 0x62, 0xF3, 0xC3, 0x01, 0x21, 0x70, + 0x90, 0xF8, 0x22, 0x29, + 0x12, 0x09, 0x62, 0xF3, 0x04, 0x11, 0x04, 0xF8, 0x0C, 0x19, 0x14, 0xF8, + 0x1F, 0x19, 0x21, 0xF0, + 0x10, 0x01, 0xE1, 0x77, 0x0E, 0xE0, 0x00, 0x00, 0xCD, 0x07, 0x10, 0x00, + 0x70, 0xA1, 0x01, 0x20, + 0xB4, 0x84, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x78, 0x8B, 0x01, 0x20, + 0xB0, 0x9A, 0x01, 0x20, + 0x48, 0xBF, 0x01, 0x20, 0x90, 0xF8, 0x41, 0x19, 0x4A, 0x09, 0x21, 0x78, + 0x62, 0xF3, 0x06, 0x11, + 0x21, 0x70, 0x90, 0xF8, 0x23, 0x19, 0x4A, 0x09, 0x21, 0x7C, 0x62, 0xF3, + 0xC3, 0x01, 0x21, 0x74, + 0x90, 0xF8, 0x22, 0x29, 0x52, 0x08, 0x62, 0xF3, 0x04, 0x11, 0x21, 0x74, + 0x90, 0xF8, 0x24, 0x09, + 0x80, 0x09, 0x60, 0xF3, 0x86, 0x11, 0x21, 0x74, 0xBD, 0xE8, 0xF0, 0x81, + 0xF8, 0xB5, 0x01, 0xF0, + 0xF0, 0xFE, 0x00, 0x90, 0x04, 0x21, 0x68, 0x46, 0xEC, 0xF7, 0x2D, 0xFA, + 0x45, 0x4E, 0x46, 0x4D, + 0x70, 0x70, 0x00, 0x20, 0x28, 0x60, 0x28, 0x71, 0x01, 0x24, 0xE0, 0xB2, + 0xFF, 0xF7, 0xE4, 0xFD, + 0x28, 0x55, 0x64, 0x1C, 0x05, 0x2C, 0xF8, 0xDB, 0x40, 0x48, 0xFF, 0xF7, + 0x29, 0xFE, 0x40, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0x03, 0x0A, 0xC0, 0xF3, 0x80, 0x10, 0xB0, 0x70, + 0xF8, 0xBD, 0x30, 0xB5, + 0x81, 0x7A, 0xA9, 0xB0, 0x79, 0xB3, 0x68, 0x46, 0x00, 0xF0, 0x30, 0xF8, + 0x9D, 0xF8, 0x12, 0x00, + 0x00, 0xF0, 0x03, 0x00, 0x01, 0xF0, 0x22, 0xFF, 0x35, 0x4C, 0x20, 0x68, + 0x00, 0xF2, 0x5E, 0x63, + 0x00, 0xF6, 0x6E, 0x05, 0x90, 0xF8, 0x5C, 0x16, 0x90, 0xF8, 0x5D, 0x06, + 0x03, 0xEB, 0x40, 0x00, + 0x01, 0xF0, 0xE5, 0xFE, 0x20, 0x68, 0x90, 0xF8, 0x6C, 0x18, 0x90, 0xF8, + 0x6D, 0x08, 0x05, 0xEB, + 0x40, 0x00, 0x01, 0xF0, 0xF3, 0xFE, 0x27, 0x48, 0x81, 0x78, 0x01, 0xB1, + 0x02, 0x21, 0x01, 0x70, + 0xC9, 0xB2, 0x68, 0x46, 0xEB, 0xF7, 0xEA, 0xFF, 0x26, 0x49, 0x68, 0x46, + 0xEC, 0xF7, 0x1B, 0xF8, + 0x00, 0x20, 0x29, 0xB0, 0x30, 0xBD, 0xFF, 0xE7, 0x01, 0x20, 0xFA, 0xE7, + 0x70, 0xB5, 0x01, 0x29, + 0x20, 0xD0, 0x1D, 0x4D, 0x03, 0x29, 0x21, 0xD0, 0x04, 0x29, 0x2E, 0xD1, + 0x04, 0x46, 0x1B, 0x48, + 0xFF, 0xF7, 0xDE, 0xFD, 0x20, 0x46, 0x00, 0xF0, 0x29, 0xF8, 0x28, 0x79, + 0x94, 0xF8, 0x5F, 0x10, + 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x5F, 0x10, 0x94, 0xF8, 0x27, 0x00, + 0x20, 0xF0, 0x02, 0x00, + 0x40, 0xF0, 0x01, 0x00, 0x84, 0xF8, 0x27, 0x00, 0x20, 0x46, 0xBD, 0xE8, + 0x70, 0x40, 0x00, 0x21, + 0xEB, 0xF7, 0x9D, 0xBD, 0xBD, 0xE8, 0x70, 0x40, 0x00, 0xF0, 0x10, 0xB8, + 0x04, 0x46, 0x0B, 0x48, + 0xFF, 0xF7, 0xBE, 0xFD, 0x20, 0x46, 0x00, 0xF0, 0x09, 0xF8, 0xE8, 0x78, + 0x94, 0xF8, 0x5F, 0x10, + 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x5F, 0x10, 0xE6, 0xE7, 0x70, 0xBD, + 0xA4, 0x22, 0x03, 0x49, + 0x02, 0xF0, 0x4B, 0xB9, 0xCD, 0x07, 0x10, 0x00, 0x60, 0xA1, 0x01, 0x20, + 0x84, 0x7F, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0xF1, 0x48, 0x01, 0x00, 0x10, 0xB5, 0x04, 0x00, + 0x03, 0xD0, 0xBD, 0xE8, + 0x10, 0x40, 0x01, 0xF0, 0xEA, 0xBD, 0x23, 0x48, 0x23, 0x49, 0x00, 0x78, + 0x42, 0x00, 0x01, 0xEB, + 0x40, 0x01, 0x21, 0x48, 0x98, 0x30, 0x02, 0xF0, 0x30, 0xF9, 0x1F, 0x48, + 0x1F, 0x49, 0x98, 0x30, + 0x48, 0x62, 0x20, 0x46, 0xEB, 0xE7, 0x38, 0xB5, 0x01, 0xF0, 0x26, 0xFE, + 0x00, 0x90, 0x04, 0x21, + 0x68, 0x46, 0xEC, 0xF7, 0x78, 0xF9, 0x17, 0x49, 0x19, 0x4C, 0x08, 0x70, + 0x20, 0x46, 0x00, 0xF0, + 0x19, 0xFB, 0x18, 0x48, 0x01, 0x68, 0xA0, 0x7C, 0x91, 0xF8, 0x50, 0x21, + 0x62, 0xF3, 0x01, 0x00, + 0xA0, 0x74, 0x91, 0xF8, 0x50, 0x11, 0x89, 0x08, 0x61, 0xF3, 0x87, 0x10, + 0xA0, 0x74, 0x38, 0xBD, + 0x10, 0xB5, 0x0F, 0x4C, 0xC0, 0x79, 0x98, 0xB1, 0x20, 0x46, 0x01, 0xF0, + 0x2F, 0xFF, 0xA0, 0x7C, + 0x00, 0xF0, 0x03, 0x00, 0x01, 0xF0, 0x72, 0xFE, 0x00, 0xF0, 0x8D, 0xFB, + 0x04, 0x21, 0x20, 0x46, + 0xEB, 0xF7, 0x54, 0xFF, 0x08, 0x49, 0x20, 0x46, 0xEB, 0xF7, 0x85, 0xFF, + 0x00, 0x20, 0x10, 0xBD, + 0x01, 0x20, 0x10, 0xBD, 0xD0, 0x07, 0x10, 0x00, 0x80, 0xA1, 0x01, 0x20, + 0xB4, 0x84, 0x10, 0x00, + 0x28, 0x80, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, 0x89, 0x4E, 0x01, 0x00, + 0xFE, 0x49, 0xC8, 0x68, + 0x40, 0x1C, 0xC8, 0x60, 0x02, 0x28, 0x03, 0xD2, 0xFC, 0x49, 0x51, 0xF8, + 0x20, 0x00, 0x00, 0x47, + 0x00, 0x20, 0x01, 0xF0, 0x8A, 0xBD, 0x00, 0x28, 0x01, 0xD1, 0xEB, 0xF7, + 0x55, 0xBF, 0x70, 0x47, + 0xF5, 0x49, 0x10, 0xB5, 0x0A, 0x79, 0x01, 0x20, 0x52, 0x1C, 0xD2, 0xB2, + 0x0A, 0x71, 0x0B, 0x7A, + 0x9A, 0x42, 0x0A, 0xD8, 0x48, 0x7A, 0x48, 0xB1, 0xEB, 0xF7, 0xB6, 0xFE, + 0x03, 0x20, 0xEB, 0xF7, + 0x91, 0xF9, 0xEF, 0x48, 0xEB, 0xF7, 0xA4, 0xFE, 0x00, 0x20, 0x10, 0xBD, + 0xEB, 0xF7, 0x3C, 0xFF, + 0xFA, 0xE7, 0x70, 0xB5, 0x18, 0xB1, 0xBD, 0xE8, 0x70, 0x40, 0x01, 0xF0, + 0x66, 0xBD, 0xE6, 0x4C, + 0x20, 0x7A, 0x08, 0xB1, 0xE7, 0x4D, 0x01, 0xE0, 0xE6, 0x4D, 0x76, 0x3D, + 0xA0, 0x78, 0xE6, 0x49, + 0x82, 0x00, 0x01, 0xF5, 0xAE, 0x70, 0x02, 0xF0, 0xED, 0xF8, 0x60, 0x79, + 0x28, 0xB1, 0xA2, 0x78, + 0xE1, 0x49, 0x28, 0x46, 0x01, 0xF0, 0x7C, 0xFD, 0x0C, 0xE0, 0xA1, 0x78, + 0x60, 0x78, 0x01, 0xF0, + 0xB9, 0xFE, 0xA1, 0x78, 0xC0, 0xB2, 0x4A, 0x00, 0xDB, 0x49, 0x01, 0xEB, + 0x40, 0x01, 0x28, 0x46, + 0x02, 0xF0, 0x93, 0xF8, 0xD7, 0x48, 0x23, 0x79, 0xA2, 0x78, 0x29, 0x46, + 0x76, 0x38, 0x01, 0xF0, + 0x77, 0xFD, 0xFF, 0xF7, 0xB5, 0xFF, 0x00, 0x28, 0x15, 0xD0, 0xA0, 0x79, + 0xD3, 0x4D, 0x01, 0x28, + 0x0B, 0xD0, 0xD0, 0x48, 0x76, 0x38, 0xA8, 0x61, 0xE0, 0x79, 0x85, 0xF8, + 0x30, 0x00, 0x20, 0x79, + 0x85, 0xF8, 0x20, 0x00, 0xBD, 0xE8, 0x70, 0x40, 0x90, 0xE7, 0xCA, 0x48, + 0xA1, 0x78, 0x76, 0x38, + 0x01, 0xF0, 0x8E, 0xFE, 0xEF, 0xE7, 0x70, 0xBD, 0x70, 0xB5, 0x18, 0xB1, + 0xBD, 0xE8, 0x70, 0x40, + 0x01, 0xF0, 0x1B, 0xBD, 0xC0, 0x4C, 0x20, 0x7A, 0x08, 0xB1, 0xC2, 0x4D, + 0x01, 0xE0, 0xC1, 0x4D, + 0x4C, 0x3D, 0xE0, 0x78, 0xC0, 0x49, 0x82, 0x00, 0x01, 0xF5, 0xD8, 0x70, + 0x02, 0xF0, 0xA2, 0xF8, + 0x60, 0x79, 0x28, 0xB1, 0xE2, 0x78, 0xBC, 0x49, 0x28, 0x46, 0x01, 0xF0, + 0x31, 0xFD, 0x0C, 0xE0, + 0xE1, 0x78, 0x60, 0x78, 0x01, 0xF0, 0x74, 0xFE, 0xE1, 0x78, 0xC0, 0xB2, + 0x4A, 0x00, 0xB6, 0x49, + 0x01, 0xEB, 0x40, 0x01, 0x28, 0x46, 0x02, 0xF0, 0x48, 0xF8, 0xB2, 0x48, + 0x23, 0x79, 0xE2, 0x78, + 0x29, 0x46, 0x4C, 0x38, 0x01, 0xF0, 0x2C, 0xFD, 0xFF, 0xF7, 0x6A, 0xFF, + 0x00, 0x28, 0x15, 0xD0, + 0xA0, 0x79, 0xAE, 0x4D, 0x01, 0x28, 0x0B, 0xD0, 0xAA, 0x48, 0x4C, 0x38, + 0xE8, 0x61, 0xE0, 0x79, + 0x85, 0xF8, 0x30, 0x00, 0x20, 0x79, 0x85, 0xF8, 0x21, 0x00, 0xBD, 0xE8, + 0x70, 0x40, 0x45, 0xE7, + 0xA4, 0x48, 0xE1, 0x78, 0x4C, 0x38, 0x01, 0xF0, 0x44, 0xFE, 0xEF, 0xE7, + 0x70, 0xBD, 0x2D, 0xE9, + 0xF0, 0x5F, 0xA3, 0x48, 0x01, 0x27, 0xB8, 0x46, 0x00, 0x68, 0x00, 0xF2, + 0x5E, 0x64, 0x90, 0xF8, + 0x33, 0x11, 0x90, 0xF8, 0x4E, 0x51, 0xC1, 0xF3, 0x80, 0x1B, 0x90, 0xF8, + 0x55, 0x11, 0x01, 0xF0, + 0x03, 0x0A, 0x90, 0xF8, 0x52, 0x11, 0x01, 0xF0, 0x1F, 0x06, 0x90, 0xF8, + 0x4F, 0x11, 0x01, 0xF0, + 0x0F, 0x09, 0x90, 0xF8, 0x32, 0x11, 0x89, 0x06, 0x09, 0xD5, 0x90, 0xF8, + 0x56, 0x16, 0x90, 0xF8, + 0x57, 0x06, 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x01, 0xF0, 0x1E, 0xFD, + 0x07, 0x46, 0x90, 0x48, + 0x00, 0x68, 0x90, 0xF8, 0x32, 0x11, 0x49, 0x06, 0x09, 0xD5, 0x90, 0xF8, + 0x66, 0x18, 0x90, 0xF8, + 0x67, 0x08, 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x01, 0xF0, 0x0E, 0xFD, + 0x80, 0x46, 0x4F, 0xF4, + 0x80, 0x70, 0x85, 0x42, 0x00, 0xD9, 0x05, 0x46, 0x1F, 0x2E, 0x00, 0xD9, + 0x1F, 0x26, 0x76, 0x1C, + 0x75, 0x43, 0x09, 0xF1, 0x01, 0x00, 0x45, 0x43, 0xC5, 0xEB, 0x45, 0x20, + 0x78, 0x43, 0x00, 0xFB, + 0x08, 0xF0, 0x0A, 0xF1, 0x01, 0x01, 0x48, 0x43, 0x0B, 0xF1, 0x01, 0x01, + 0x48, 0x43, 0xC0, 0x13, + 0xB0, 0xFA, 0x80, 0xF0, 0xC0, 0xF1, 0x20, 0x00, 0xC0, 0xB2, 0xBD, 0xE8, + 0xF0, 0x9F, 0x2D, 0xE9, + 0xF0, 0x41, 0x04, 0x46, 0xEB, 0xF7, 0x70, 0xFB, 0x73, 0x48, 0xEB, 0xF7, + 0x72, 0xFB, 0xA4, 0xF8, + 0x76, 0x00, 0x01, 0xF0, 0xC1, 0xFC, 0x01, 0x46, 0x20, 0x46, 0xEB, 0xF7, + 0xDB, 0xFD, 0x01, 0xF0, + 0xBF, 0xFC, 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEB, 0xF7, 0xF6, 0xFD, + 0x20, 0x46, 0x01, 0xF0, + 0xF1, 0xFD, 0x6B, 0x4D, 0xB4, 0xF8, 0x56, 0x10, 0x28, 0x68, 0xB0, 0xF8, + 0xBE, 0x20, 0x62, 0xF3, + 0x09, 0x01, 0xA4, 0xF8, 0x56, 0x10, 0x90, 0xF8, 0xBD, 0x10, 0x94, 0xF8, + 0x55, 0x00, 0x61, 0xF3, + 0x03, 0x00, 0x84, 0xF8, 0x55, 0x00, 0x04, 0x21, 0x20, 0x46, 0xEB, 0xF7, + 0x78, 0xFB, 0x28, 0x68, + 0x90, 0xF8, 0x4E, 0x01, 0xA0, 0x70, 0x28, 0x68, 0x21, 0x8E, 0xB0, 0xF8, + 0x53, 0x21, 0x62, 0xF3, + 0x08, 0x01, 0x21, 0x86, 0x90, 0xF8, 0x4F, 0x01, 0x00, 0xF0, 0x0F, 0x01, + 0x20, 0x46, 0xEB, 0xF7, + 0xC6, 0xFB, 0x28, 0x68, 0x34, 0xF8, 0x1A, 0x1F, 0xB0, 0xF8, 0x3E, 0x21, + 0x62, 0xF3, 0x0B, 0x01, + 0x24, 0xF8, 0x12, 0x19, 0xB0, 0xF8, 0x3C, 0x21, 0x21, 0x89, 0x62, 0xF3, + 0x0B, 0x01, 0x21, 0x81, + 0xB0, 0xF8, 0x3A, 0x21, 0xA1, 0x88, 0x62, 0xF3, 0x0B, 0x01, 0xA1, 0x80, + 0x90, 0xF8, 0x50, 0x21, + 0xA1, 0x7A, 0x62, 0xF3, 0x01, 0x01, 0xA1, 0x72, 0x90, 0xF8, 0x50, 0x21, + 0x92, 0x08, 0x62, 0xF3, + 0x87, 0x11, 0xA1, 0x72, 0x90, 0xF8, 0x32, 0x11, 0x14, 0xF8, 0x01, 0x2C, + 0x61, 0xF3, 0x00, 0x02, + 0x04, 0xF8, 0x01, 0x2C, 0x90, 0xF8, 0x35, 0x01, 0x60, 0x70, 0x42, 0x48, + 0x90, 0xF8, 0x50, 0x1E, + 0xA1, 0x75, 0x90, 0xF8, 0x51, 0x1E, 0x21, 0x77, 0x90, 0xF8, 0x52, 0x1E, + 0xE1, 0x75, 0x90, 0xF8, + 0x53, 0x1E, 0x61, 0x77, 0x90, 0xF8, 0x54, 0x1E, 0x21, 0x76, 0x90, 0xF8, + 0x55, 0x0E, 0xA0, 0x77, + 0x39, 0x48, 0xEB, 0xF7, 0xF6, 0xFA, 0xA4, 0xF8, 0x78, 0x00, 0x37, 0x48, + 0x20, 0x30, 0xEB, 0xF7, + 0xF0, 0xFA, 0xA4, 0xF8, 0x7C, 0x00, 0x28, 0x68, 0x90, 0xF8, 0x42, 0x11, + 0x0A, 0x09, 0x21, 0x7D, + 0x62, 0xF3, 0x07, 0x11, 0x21, 0x75, 0x90, 0xF8, 0x47, 0x21, 0xA3, 0x7E, + 0x12, 0x09, 0x62, 0xF3, + 0x07, 0x13, 0xA3, 0x76, 0x90, 0xF8, 0x43, 0x61, 0x62, 0x7D, 0x66, 0xF3, + 0x03, 0x02, 0x62, 0x75, + 0x90, 0xF8, 0x48, 0x71, 0xE6, 0x7E, 0x67, 0xF3, 0x03, 0x06, 0xE6, 0x76, + 0x90, 0xF8, 0x43, 0x71, + 0x3F, 0x09, 0x67, 0xF3, 0x07, 0x12, 0x62, 0x75, 0x90, 0xF8, 0x48, 0x21, + 0x12, 0x09, 0x62, 0xF3, + 0x07, 0x16, 0xE6, 0x76, 0x90, 0xF8, 0x42, 0x21, 0x62, 0xF3, 0x00, 0x01, + 0x21, 0x75, 0x90, 0xF8, + 0x47, 0x11, 0x61, 0xF3, 0x00, 0x03, 0xA3, 0x76, 0x90, 0xF8, 0x37, 0x01, + 0x01, 0x09, 0xE0, 0x78, + 0x61, 0xF3, 0x03, 0x00, 0xE0, 0x70, 0x18, 0x48, 0x48, 0x38, 0xEB, 0xF7, + 0xB2, 0xFA, 0xA4, 0xF8, + 0x76, 0x00, 0x15, 0x48, 0x28, 0x38, 0xEB, 0xF7, 0xAC, 0xFA, 0xA4, 0xF8, + 0x7A, 0x00, 0x29, 0x68, + 0x91, 0xF8, 0x34, 0x01, 0xC2, 0x08, 0x14, 0xF8, 0x1F, 0x0F, 0x62, 0xF3, + 0x83, 0x00, 0x20, 0x70, + 0x91, 0xF8, 0x34, 0x21, 0x52, 0x08, 0x62, 0xF3, 0x00, 0x00, 0x20, 0x70, + 0x91, 0xF8, 0x34, 0x21, + 0x92, 0x08, 0x62, 0xF3, 0x41, 0x00, 0x11, 0xE0, 0xD4, 0x07, 0x10, 0x00, + 0x04, 0x7D, 0x01, 0x00, + 0x57, 0x4F, 0x01, 0x00, 0x7A, 0xA3, 0x01, 0x20, 0x6C, 0xA2, 0x01, 0x20, + 0xB4, 0x84, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x78, 0x8B, 0x01, 0x20, 0x80, 0x99, 0x01, 0x20, + 0x04, 0xF8, 0x27, 0x09, + 0x91, 0xF8, 0x33, 0x01, 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, 0xEB, 0xF7, + 0xF5, 0xFA, 0x28, 0x68, + 0x90, 0xF8, 0x33, 0x01, 0x01, 0x09, 0x14, 0xF8, 0x28, 0x0F, 0x61, 0xF3, + 0x04, 0x10, 0x20, 0x70, + 0xF8, 0x48, 0xEB, 0xF7, 0x6E, 0xFA, 0xA4, 0xF8, 0x60, 0x00, 0xF6, 0x48, + 0x20, 0x30, 0xEB, 0xF7, + 0x68, 0xFA, 0xA4, 0xF8, 0x62, 0x00, 0x28, 0x68, 0x90, 0xF8, 0x32, 0x11, + 0xCA, 0x08, 0xE1, 0x7A, + 0x62, 0xF3, 0x45, 0x11, 0xE1, 0x72, 0x90, 0xF8, 0x33, 0x01, 0x41, 0x08, + 0x20, 0x78, 0x61, 0xF3, + 0x45, 0x10, 0x04, 0xF8, 0x28, 0x09, 0x20, 0x46, 0x01, 0xF0, 0x50, 0xFC, + 0x28, 0x68, 0x90, 0xF8, + 0x36, 0x01, 0x81, 0x09, 0x20, 0x46, 0xEB, 0xF7, 0xB4, 0xFA, 0x14, 0xF8, + 0x32, 0x0F, 0x20, 0xF0, + 0x0F, 0x00, 0x0A, 0x30, 0x20, 0xF0, 0xF0, 0x00, 0xA0, 0x30, 0x04, 0xF8, + 0x1C, 0x09, 0x29, 0x68, + 0x91, 0xF8, 0x32, 0x01, 0x82, 0x09, 0x60, 0x7F, 0x62, 0xF3, 0x00, 0x00, + 0x60, 0x77, 0x91, 0xF8, + 0x32, 0x21, 0x52, 0x09, 0x62, 0xF3, 0x41, 0x00, 0x60, 0x77, 0x91, 0xF8, + 0x38, 0x21, 0x62, 0xF3, + 0x82, 0x00, 0x60, 0x77, 0x91, 0xF8, 0x51, 0x01, 0xE2, 0x7D, 0x60, 0xF3, + 0x04, 0x02, 0xE2, 0x75, + 0x91, 0xF8, 0x52, 0x01, 0xA1, 0x7D, 0x60, 0xF3, 0x04, 0x01, 0xD3, 0x48, + 0xA1, 0x75, 0x94, 0xF8, + 0x49, 0x10, 0x40, 0x78, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x49, 0x10, + 0xCF, 0x48, 0xEB, 0xF7, + 0x18, 0xFA, 0xA4, 0xF8, 0x64, 0x00, 0x28, 0x68, 0x21, 0x8B, 0xB0, 0xF8, + 0x40, 0x21, 0x62, 0xF3, + 0x0B, 0x01, 0x21, 0x83, 0x90, 0xF8, 0x36, 0x11, 0xCA, 0x08, 0x94, 0xF8, + 0x22, 0x10, 0x62, 0xF3, + 0x02, 0x01, 0x84, 0xF8, 0x22, 0x10, 0x10, 0xF8, 0xE0, 0x1F, 0x22, 0x7D, + 0x61, 0xF3, 0x03, 0x02, + 0x22, 0x75, 0x10, 0xF8, 0x52, 0x1B, 0x0A, 0x09, 0x61, 0x7D, 0x62, 0xF3, + 0x03, 0x01, 0x61, 0x75, + 0x42, 0x79, 0xE1, 0x7C, 0x62, 0xF3, 0x02, 0x01, 0xE1, 0x74, 0x01, 0x78, + 0xCA, 0x09, 0xA1, 0x7F, + 0x62, 0xF3, 0x00, 0x01, 0xA1, 0x77, 0x94, 0xF8, 0x49, 0x10, 0x41, 0xF0, + 0x20, 0x01, 0x84, 0xF8, + 0x49, 0x10, 0x82, 0x78, 0xD2, 0x09, 0x62, 0xF3, 0xC7, 0x11, 0x84, 0xF8, + 0x49, 0x10, 0x42, 0x8B, + 0xB4, 0xF8, 0x4A, 0x10, 0x62, 0xF3, 0x08, 0x01, 0xA4, 0xF8, 0x4A, 0x10, + 0x00, 0x21, 0xE1, 0x64, + 0x41, 0x79, 0xCA, 0x08, 0x61, 0x7F, 0x62, 0xF3, 0xC3, 0x01, 0x61, 0x77, + 0x02, 0x78, 0x12, 0x09, + 0x62, 0xF3, 0x04, 0x11, 0x61, 0x77, 0xC1, 0x7F, 0x4A, 0x09, 0x14, 0xF8, + 0x0E, 0x1C, 0x62, 0xF3, + 0x06, 0x11, 0x04, 0xF8, 0x0E, 0x1C, 0x41, 0x78, 0x4A, 0x09, 0xA1, 0x78, + 0x62, 0xF3, 0xC3, 0x01, + 0xA1, 0x70, 0x02, 0x78, 0x52, 0x08, 0x62, 0xF3, 0x04, 0x11, 0xA1, 0x70, + 0x82, 0x78, 0x92, 0x09, + 0x62, 0xF3, 0x86, 0x11, 0xA1, 0x70, 0x40, 0x78, 0x9D, 0x49, 0xC0, 0xF3, + 0x80, 0x10, 0x48, 0x71, + 0xBD, 0xE8, 0xF0, 0x81, 0xA4, 0x22, 0x9B, 0x49, 0x01, 0xF0, 0xFF, 0xBD, + 0x2D, 0xE9, 0xF0, 0x41, + 0x97, 0x4D, 0x00, 0x26, 0x01, 0x27, 0x2E, 0x71, 0x2E, 0x72, 0xAF, 0x71, + 0x0C, 0x46, 0x6E, 0x72, + 0x01, 0x28, 0x07, 0xD0, 0x90, 0x4F, 0x02, 0x28, 0x2C, 0xD0, 0x03, 0x28, + 0x14, 0xD0, 0x04, 0x28, + 0x3A, 0xD1, 0x43, 0xE0, 0x08, 0x46, 0xFF, 0xF7, 0xE5, 0xFF, 0x8F, 0x48, + 0x01, 0x68, 0x91, 0xF8, + 0x38, 0x01, 0x42, 0x06, 0x30, 0xD5, 0x91, 0xF8, 0x55, 0x11, 0x00, 0x06, + 0x01, 0xF0, 0x03, 0x01, + 0x29, 0x72, 0x29, 0xD5, 0x6F, 0x72, 0x27, 0xE0, 0x86, 0x48, 0xFF, 0xF7, + 0x08, 0xFE, 0x20, 0x46, + 0xFF, 0xF7, 0xD0, 0xFF, 0xF8, 0x78, 0x94, 0xF8, 0x5F, 0x10, 0x60, 0xF3, + 0x04, 0x01, 0x84, 0xF8, + 0x5F, 0x10, 0x94, 0xF8, 0x27, 0x00, 0x20, 0xF0, 0x02, 0x00, 0x40, 0xF0, + 0x01, 0x00, 0x84, 0xF8, + 0x27, 0x00, 0x0C, 0xE0, 0x7B, 0x48, 0xFF, 0xF7, 0xF2, 0xFD, 0x20, 0x46, + 0xFF, 0xF7, 0xBA, 0xFF, + 0xB8, 0x78, 0x94, 0xF8, 0x5F, 0x10, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, + 0x5F, 0x10, 0x00, 0x21, + 0x20, 0x46, 0xEB, 0xF7, 0xEC, 0xF9, 0xAE, 0x71, 0x20, 0x46, 0x01, 0xF0, + 0xD7, 0xFB, 0x94, 0xF8, + 0x27, 0x00, 0x40, 0xF3, 0x00, 0x00, 0x40, 0x1C, 0xE8, 0x71, 0xA1, 0xE7, + 0x08, 0x46, 0xFF, 0xF7, + 0xA1, 0xFF, 0x14, 0xF8, 0x37, 0x0F, 0x40, 0xF0, 0x10, 0x00, 0x04, 0xF8, + 0x1F, 0x09, 0xE0, 0x7E, + 0x20, 0xF0, 0x23, 0x00, 0xE0, 0x76, 0x34, 0xF8, 0x0C, 0x0C, 0x6F, 0xF3, + 0x0B, 0x00, 0x10, 0x30, + 0x24, 0xF8, 0x0C, 0x0C, 0x34, 0xF8, 0x08, 0x0C, 0x6F, 0xF3, 0x0B, 0x00, + 0x40, 0x30, 0x24, 0xF8, + 0x08, 0x0C, 0x08, 0x20, 0x04, 0xF8, 0x16, 0x0C, 0x94, 0xF8, 0x47, 0x00, + 0x20, 0xF0, 0x1F, 0x00, + 0x84, 0xF8, 0x47, 0x00, 0x34, 0xF8, 0x18, 0x0F, 0x6F, 0xF3, 0x08, 0x00, + 0x24, 0xF8, 0x03, 0x0B, + 0x20, 0x78, 0x40, 0xF0, 0x0C, 0x00, 0x04, 0xF8, 0x0B, 0x09, 0x20, 0x78, + 0x40, 0xF0, 0x20, 0x00, + 0x04, 0xF8, 0x28, 0x09, 0xBF, 0xE7, 0x70, 0xB5, 0x53, 0x4D, 0x28, 0x68, + 0x00, 0xF2, 0x5E, 0x62, + 0x00, 0xF6, 0x6E, 0x04, 0x90, 0xF8, 0x56, 0x16, 0x90, 0xF8, 0x57, 0x06, + 0x02, 0xEB, 0x40, 0x00, + 0x01, 0xF0, 0xA5, 0xFA, 0x28, 0x68, 0x90, 0xF8, 0x66, 0x18, 0x90, 0xF8, + 0x67, 0x08, 0x04, 0xEB, + 0x40, 0x00, 0xBD, 0xE8, 0x70, 0x40, 0x01, 0xF0, 0xB1, 0xBA, 0x70, 0xB5, + 0x44, 0x4D, 0x45, 0x4C, + 0x68, 0x79, 0xA4, 0x34, 0x00, 0xB1, 0x02, 0x20, 0x68, 0x70, 0x21, 0x46, + 0x28, 0x78, 0xFF, 0xF7, + 0x4D, 0xFF, 0x41, 0x48, 0x01, 0x68, 0xA0, 0x7C, 0x91, 0xF8, 0x50, 0x21, + 0x62, 0xF3, 0x01, 0x00, + 0xA0, 0x74, 0x91, 0xF8, 0x50, 0x11, 0x89, 0x08, 0x61, 0xF3, 0x87, 0x10, + 0xA0, 0x74, 0x69, 0x78, + 0x20, 0x46, 0xEB, 0xF7, 0x93, 0xFB, 0xA0, 0x7C, 0x00, 0xF0, 0x03, 0x00, + 0x01, 0xF0, 0xA6, 0xFA, + 0xFF, 0xF7, 0xC1, 0xFF, 0x20, 0x46, 0xBD, 0xE8, 0x70, 0x40, 0x34, 0x49, + 0xEB, 0xF7, 0xBB, 0xBB, + 0x70, 0xB5, 0x2F, 0x4D, 0x2F, 0x4C, 0x68, 0x79, 0xA4, 0x34, 0x08, 0xB1, + 0x03, 0x20, 0x00, 0xE0, + 0x01, 0x20, 0x68, 0x70, 0x21, 0x46, 0x28, 0x78, 0xFF, 0xF7, 0x20, 0xFF, + 0x2A, 0x48, 0x01, 0x68, + 0x91, 0xF8, 0x50, 0x01, 0x02, 0x09, 0xA0, 0x7C, 0x62, 0xF3, 0x01, 0x00, + 0xA0, 0x74, 0x91, 0xF8, + 0x50, 0x11, 0x89, 0x09, 0x61, 0xF3, 0x87, 0x10, 0xA0, 0x74, 0x69, 0x78, + 0x20, 0x46, 0xEB, 0xF7, + 0x65, 0xFB, 0xA0, 0x7C, 0x00, 0xF0, 0x03, 0x00, 0x01, 0xF0, 0x78, 0xFA, + 0xFF, 0xF7, 0x93, 0xFF, + 0x20, 0x46, 0xBD, 0xE8, 0x70, 0x40, 0x1E, 0x49, 0xEB, 0xF7, 0x8D, 0xBB, + 0x7F, 0xB5, 0x01, 0xF0, + 0xFB, 0xF9, 0x01, 0x90, 0x01, 0xF0, 0xFC, 0xF9, 0xCD, 0xE9, 0x02, 0x01, + 0x04, 0x21, 0x01, 0xA8, + 0xEB, 0xF7, 0x49, 0xFD, 0x12, 0x4C, 0x08, 0x21, 0xA0, 0x70, 0x02, 0xA8, + 0xEB, 0xF7, 0x43, 0xFD, + 0xE0, 0x70, 0x0D, 0x4D, 0x01, 0x24, 0xE0, 0xB2, 0xFF, 0xF7, 0xC1, 0xFC, + 0x28, 0x55, 0x64, 0x1C, + 0x05, 0x2C, 0xF8, 0xDB, 0x0B, 0x48, 0xFF, 0xF7, 0x12, 0xFD, 0x7F, 0xBD, + 0x10, 0xB5, 0x80, 0x79, + 0xC0, 0xB1, 0x07, 0x49, 0x08, 0x70, 0x4F, 0xF0, 0xFF, 0x30, 0xC8, 0x60, + 0xFF, 0xF7, 0xEE, 0xFB, + 0x00, 0x20, 0x10, 0xBD, 0x48, 0xBF, 0x01, 0x20, 0x64, 0xA2, 0x01, 0x20, + 0x00, 0x9B, 0x01, 0x20, + 0xD4, 0x07, 0x10, 0x00, 0xCC, 0x80, 0x10, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x93, 0x4F, 0x01, 0x00, + 0x29, 0x50, 0x01, 0x00, 0x01, 0x20, 0xEC, 0xE7, 0x2D, 0xE9, 0xF0, 0x47, + 0xF9, 0x49, 0x02, 0x46, + 0x01, 0x27, 0x08, 0x68, 0xB8, 0x46, 0x00, 0xF2, 0x5E, 0x64, 0x02, 0x2A, + 0x01, 0xD0, 0x03, 0x2A, + 0x3C, 0xD0, 0x89, 0x46, 0x90, 0xF8, 0x23, 0x11, 0x90, 0xF8, 0x1F, 0x61, + 0x01, 0xF0, 0x1F, 0x05, + 0x90, 0xF8, 0x12, 0x11, 0x89, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x5A, 0x16, + 0x90, 0xF8, 0x5B, 0x06, + 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x01, 0xF0, 0xBF, 0xF9, 0x07, 0x46, + 0xD9, 0xF8, 0x00, 0x00, + 0x90, 0xF8, 0x12, 0x11, 0x49, 0x06, 0x09, 0xD5, 0x90, 0xF8, 0x6A, 0x18, + 0x90, 0xF8, 0x6B, 0x08, + 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x01, 0xF0, 0xAF, 0xF9, 0x80, 0x46, + 0x4F, 0xF4, 0x80, 0x70, + 0x86, 0x42, 0x00, 0xD9, 0x06, 0x46, 0x1F, 0x2D, 0x00, 0xD9, 0x1F, 0x25, + 0x6D, 0x1C, 0x6E, 0x43, + 0x70, 0x00, 0xC0, 0xEB, 0x40, 0x20, 0x78, 0x43, 0x00, 0xFB, 0x08, 0xF0, + 0xC0, 0x13, 0xB0, 0xFA, + 0x80, 0xF0, 0xC0, 0xF1, 0x20, 0x00, 0xC0, 0xB2, 0xBD, 0xE8, 0xF0, 0x87, + 0x10, 0xF8, 0xD3, 0x6F, + 0x00, 0x79, 0x00, 0xF0, 0x1F, 0x05, 0xE1, 0xE7, 0x70, 0xB5, 0x05, 0x00, + 0x03, 0xD0, 0xBD, 0xE8, + 0x70, 0x40, 0x01, 0xF0, 0x1A, 0xB9, 0xD0, 0x48, 0xD0, 0x4E, 0x00, 0x78, + 0x01, 0x28, 0x01, 0xD0, + 0xCF, 0x48, 0x16, 0xE0, 0xCB, 0x4C, 0xCE, 0x49, 0x22, 0x68, 0xA1, 0xF1, + 0x08, 0x00, 0x02, 0xF2, + 0x72, 0x42, 0x00, 0xF0, 0xD1, 0xF9, 0x22, 0x68, 0x92, 0xF8, 0x60, 0x04, + 0xC0, 0x07, 0x06, 0xD0, + 0xC7, 0x49, 0x02, 0xF2, 0x76, 0x42, 0xA1, 0xF1, 0x08, 0x00, 0x00, 0xF0, + 0xC5, 0xF9, 0xC4, 0x48, + 0x08, 0x38, 0x70, 0x61, 0x28, 0x46, 0xDA, 0xE7, 0x70, 0xB5, 0x04, 0x46, + 0xEA, 0xF7, 0xEC, 0xFF, + 0xBF, 0x48, 0xEA, 0xF7, 0xEE, 0xFF, 0xA4, 0xF8, 0x76, 0x00, 0x01, 0xF0, + 0x3D, 0xF9, 0x01, 0x46, + 0x00, 0x22, 0x20, 0x46, 0xEB, 0xF7, 0x88, 0xF9, 0x01, 0xF0, 0x3A, 0xF9, + 0x02, 0x46, 0x0B, 0x46, + 0x20, 0x46, 0xEB, 0xF7, 0xAD, 0xF9, 0xA0, 0x79, 0x00, 0x21, 0x20, 0xF0, + 0x02, 0x00, 0xA0, 0x71, + 0x94, 0xF8, 0x6F, 0x00, 0x20, 0xF0, 0x07, 0x00, 0x84, 0xF8, 0x6F, 0x00, + 0x94, 0xF8, 0x6E, 0x00, + 0x20, 0xF0, 0x0F, 0x00, 0x84, 0xF8, 0x6E, 0x00, 0x20, 0x46, 0xEB, 0xF7, + 0xB3, 0xF9, 0x94, 0xF8, + 0x5E, 0x00, 0x20, 0xF0, 0x01, 0x00, 0x84, 0xF8, 0x5E, 0x00, 0x20, 0x46, + 0x01, 0xF0, 0x52, 0xFA, + 0x04, 0x21, 0x20, 0x46, 0xEA, 0xF7, 0xEB, 0xFF, 0xA2, 0x4D, 0x28, 0x68, + 0x90, 0xF8, 0x1F, 0x01, + 0xA0, 0x70, 0x28, 0x68, 0x21, 0x8E, 0xB0, 0xF8, 0x24, 0x21, 0x62, 0xF3, + 0x08, 0x01, 0x21, 0x86, + 0x90, 0xF8, 0x20, 0x01, 0x00, 0xF0, 0x0F, 0x01, 0x20, 0x46, 0xEB, 0xF7, + 0x38, 0xF8, 0x28, 0x68, + 0x62, 0x7D, 0x90, 0xF8, 0x16, 0x11, 0x61, 0xF3, 0x03, 0x02, 0x62, 0x75, + 0xB0, 0xF8, 0x19, 0x21, + 0x21, 0x8A, 0x62, 0xF3, 0x0B, 0x01, 0x21, 0x82, 0x90, 0xF8, 0x21, 0x11, + 0xA2, 0x7D, 0x61, 0xF3, + 0x03, 0x02, 0xA2, 0x75, 0xB0, 0xF8, 0x1B, 0x21, 0xA1, 0x89, 0x62, 0xF3, + 0x0B, 0x01, 0xA1, 0x81, + 0x90, 0xF8, 0x20, 0x11, 0x0A, 0x09, 0xA1, 0x7C, 0x62, 0xF3, 0x01, 0x01, + 0xA1, 0x74, 0x90, 0xF8, + 0x20, 0x21, 0x92, 0x09, 0x62, 0xF3, 0x87, 0x11, 0xA1, 0x74, 0x90, 0xF8, + 0x12, 0x11, 0xE2, 0x79, + 0x61, 0xF3, 0x00, 0x02, 0xE2, 0x71, 0x90, 0xF8, 0x15, 0x11, 0x61, 0x72, + 0x90, 0xF8, 0x18, 0x01, + 0x01, 0x09, 0xE0, 0x7A, 0x61, 0xF3, 0x03, 0x00, 0xE0, 0x72, 0x82, 0x48, + 0xEA, 0xF7, 0x71, 0xFF, + 0xA4, 0xF8, 0x7C, 0x00, 0x29, 0x68, 0x91, 0xF8, 0x14, 0x01, 0xC2, 0x08, + 0x94, 0xF8, 0x27, 0x00, + 0x62, 0xF3, 0x83, 0x00, 0x20, 0xF0, 0x02, 0x00, 0x40, 0xF0, 0x01, 0x00, + 0x84, 0xF8, 0x27, 0x00, + 0x91, 0xF8, 0x13, 0x01, 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, 0xEA, 0xF7, + 0xD5, 0xFF, 0x28, 0x68, + 0x90, 0xF8, 0x13, 0x01, 0x01, 0x09, 0x14, 0xF8, 0x28, 0x0F, 0x61, 0xF3, + 0x04, 0x10, 0x20, 0x70, + 0x71, 0x48, 0xEA, 0xF7, 0x4E, 0xFF, 0xA4, 0xF8, 0x5E, 0x00, 0x28, 0x68, + 0x90, 0xF8, 0x12, 0x11, + 0xCA, 0x08, 0xE1, 0x7A, 0x62, 0xF3, 0x45, 0x11, 0xE1, 0x72, 0x90, 0xF8, + 0x13, 0x01, 0x41, 0x08, + 0x20, 0x78, 0x61, 0xF3, 0x45, 0x10, 0x04, 0xF8, 0x28, 0x09, 0x20, 0x46, + 0x01, 0xF0, 0x10, 0xF9, + 0x28, 0x68, 0x90, 0xF8, 0x18, 0x01, 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, + 0xEA, 0xF7, 0x99, 0xFF, + 0x14, 0xF8, 0x32, 0x0F, 0x20, 0xF0, 0x0F, 0x00, 0x0A, 0x30, 0x20, 0xF0, + 0xF0, 0x00, 0xA0, 0x30, + 0x04, 0xF8, 0x0A, 0x09, 0x29, 0x68, 0x91, 0xF8, 0x12, 0x01, 0x82, 0x09, + 0xE0, 0x7A, 0x62, 0xF3, + 0x00, 0x00, 0xE0, 0x72, 0x91, 0xF8, 0x12, 0x21, 0x52, 0x09, 0x62, 0xF3, + 0x41, 0x00, 0xE0, 0x72, + 0x91, 0xF8, 0x17, 0x21, 0xD2, 0x09, 0x62, 0xF3, 0x82, 0x00, 0xE0, 0x72, + 0x91, 0xF8, 0x22, 0x01, + 0x62, 0x79, 0x60, 0xF3, 0x04, 0x02, 0x62, 0x71, 0x91, 0xF8, 0x23, 0x01, + 0x21, 0x79, 0x60, 0xF3, + 0x04, 0x01, 0x4B, 0x48, 0x21, 0x71, 0x0C, 0x38, 0x41, 0x78, 0x94, 0xF8, + 0x37, 0x00, 0x61, 0xF3, + 0x04, 0x00, 0x84, 0xF8, 0x37, 0x00, 0x49, 0x48, 0xEA, 0xF7, 0xFB, 0xFE, + 0xA4, 0xF8, 0x52, 0x00, + 0x28, 0x68, 0xE1, 0x88, 0xB0, 0xF8, 0x1D, 0x21, 0x62, 0xF3, 0x0B, 0x01, + 0xE1, 0x80, 0x90, 0xF8, + 0x17, 0x11, 0xCA, 0x08, 0x21, 0x7C, 0x62, 0xF3, 0x02, 0x01, 0x21, 0x74, + 0x10, 0xF8, 0xDF, 0x2F, + 0xA1, 0x78, 0x62, 0xF3, 0x03, 0x01, 0xA1, 0x70, 0x10, 0xF8, 0x19, 0x1B, + 0x0A, 0x09, 0xE1, 0x78, + 0x62, 0xF3, 0x03, 0x01, 0xE1, 0x70, 0x81, 0x7F, 0x0A, 0x09, 0x61, 0x78, + 0x62, 0xF3, 0x02, 0x01, + 0x61, 0x70, 0x01, 0x7F, 0x8A, 0x09, 0x21, 0x78, 0x62, 0xF3, 0x00, 0x01, + 0x21, 0x70, 0x81, 0x7E, + 0xCA, 0x09, 0x21, 0x7B, 0x62, 0xF3, 0x00, 0x01, 0x21, 0x73, 0x94, 0xF8, + 0x37, 0x10, 0x41, 0xF0, + 0x20, 0x01, 0x84, 0xF8, 0x37, 0x10, 0x21, 0x8F, 0x6F, 0xF3, 0x08, 0x01, + 0x01, 0xF5, 0x80, 0x71, + 0x21, 0x87, 0x00, 0x21, 0xC4, 0xF8, 0x3A, 0x10, 0xC1, 0x7F, 0x8A, 0x09, + 0xE1, 0x7A, 0x62, 0xF3, + 0xC3, 0x01, 0xE1, 0x72, 0x80, 0x7E, 0x00, 0x09, 0x60, 0xF3, 0x04, 0x11, + 0xE1, 0x72, 0x70, 0xBD, + 0x70, 0xB5, 0x1F, 0x4D, 0x00, 0x20, 0x0C, 0x3D, 0x01, 0x24, 0x28, 0x60, + 0xE0, 0xB2, 0xFF, 0xF7, + 0x3B, 0xFE, 0x28, 0x55, 0x64, 0x1C, 0x04, 0x2C, 0xF8, 0xDB, 0xBD, 0xE8, + 0x70, 0x40, 0x1C, 0x48, + 0xAA, 0xE6, 0x70, 0xB5, 0x41, 0x7A, 0xAA, 0xB0, 0x59, 0xB1, 0x13, 0x4D, + 0x01, 0x20, 0x6C, 0x46, + 0x28, 0x70, 0x01, 0x29, 0x08, 0xD0, 0x00, 0x26, 0x02, 0x29, 0x09, 0xD0, + 0x03, 0x29, 0x2D, 0xD1, + 0x28, 0xE0, 0x01, 0x20, 0x2A, 0xB0, 0x70, 0xBD, 0x20, 0x46, 0x00, 0xF0, + 0x60, 0xF8, 0x25, 0xE0, + 0x20, 0x46, 0x00, 0xF0, 0x5C, 0xF8, 0x0A, 0x48, 0x9D, 0xF8, 0x5F, 0x10, + 0x0C, 0x38, 0x80, 0x78, + 0x60, 0xF3, 0x04, 0x01, 0x8D, 0xF8, 0x5F, 0x10, 0x00, 0x21, 0x20, 0x46, + 0xEA, 0xF7, 0x07, 0xFF, + 0x13, 0xE0, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, 0xE4, 0x07, 0x10, 0x00, + 0xB4, 0x84, 0x10, 0x00, + 0xC0, 0xA4, 0x01, 0x20, 0x98, 0x98, 0x01, 0x20, 0x20, 0xBF, 0x01, 0x20, + 0x00, 0x9B, 0x01, 0x20, + 0x14, 0x82, 0x10, 0x00, 0x20, 0x46, 0x00, 0xF0, 0x3E, 0xF8, 0x2E, 0x70, + 0x20, 0x46, 0x01, 0xF0, + 0xDD, 0xF8, 0x9D, 0xF8, 0x12, 0x00, 0x00, 0xF0, 0x03, 0x00, 0x01, 0xF0, + 0x1F, 0xF8, 0x37, 0x4C, + 0x20, 0x68, 0x00, 0xF2, 0x5E, 0x63, 0x00, 0xF6, 0x6E, 0x05, 0x90, 0xF8, + 0x5A, 0x16, 0x90, 0xF8, + 0x5B, 0x06, 0x03, 0xEB, 0x40, 0x00, 0x00, 0xF0, 0xE2, 0xFF, 0x20, 0x68, + 0x90, 0xF8, 0x6A, 0x18, + 0x90, 0xF8, 0x6B, 0x08, 0x05, 0xEB, 0x40, 0x00, 0x00, 0xF0, 0xF0, 0xFF, + 0x2C, 0x49, 0x68, 0x46, + 0xEB, 0xF7, 0x34, 0xF8, 0x00, 0x20, 0xAD, 0xE7, 0x40, 0xF2, 0xFF, 0x10, + 0xC1, 0xEB, 0x41, 0x21, + 0x91, 0xFB, 0xF0, 0xF0, 0x00, 0x20, 0x70, 0x47, 0x10, 0xB5, 0x00, 0x23, + 0xD4, 0x5C, 0x31, 0xF8, + 0x14, 0x40, 0x20, 0xF8, 0x13, 0x40, 0x5B, 0x1C, 0x04, 0x2B, 0xF7, 0xDB, + 0x10, 0xBD, 0xA4, 0x22, + 0x20, 0x49, 0x01, 0xF0, 0x7A, 0xBA, 0x70, 0xB5, 0x04, 0x46, 0x00, 0xF0, + 0x6A, 0xFB, 0x1E, 0x48, + 0xEA, 0xF7, 0x1F, 0xFE, 0xA4, 0xF8, 0x76, 0x00, 0x00, 0xF0, 0x77, 0xFF, + 0x17, 0x4D, 0x01, 0x46, + 0x28, 0x68, 0x90, 0xF8, 0xC9, 0x00, 0xC0, 0xF3, 0x41, 0x12, 0x20, 0x46, + 0xEA, 0xF7, 0xB4, 0xFF, + 0x00, 0xF0, 0x70, 0xFF, 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEA, 0xF7, + 0xD9, 0xFF, 0x13, 0x48, + 0xEA, 0xF7, 0x07, 0xFE, 0xA4, 0xF8, 0x7C, 0x00, 0x0F, 0x48, 0x0C, 0x38, + 0xC1, 0x78, 0x14, 0xF8, + 0x5F, 0x0F, 0x61, 0xF3, 0x04, 0x00, 0x20, 0x70, 0x29, 0x68, 0x00, 0xF0, + 0x1F, 0x00, 0x11, 0xF8, + 0xD3, 0x2F, 0xC9, 0x78, 0x01, 0xF0, 0x1F, 0x01, 0x49, 0x1C, 0xC1, 0xEB, + 0x41, 0x21, 0x49, 0x00, + 0x4A, 0x43, 0xC2, 0x40, 0x50, 0x08, 0xC4, 0xF8, 0x03, 0x00, 0x70, 0xBD, + 0x4C, 0x07, 0x10, 0x00, + 0x29, 0x58, 0x01, 0x00, 0x14, 0x82, 0x10, 0x00, 0xC0, 0xA4, 0x01, 0x20, + 0x98, 0x98, 0x01, 0x20, + 0x10, 0xB9, 0x66, 0x4A, 0x64, 0x49, 0x11, 0x61, 0x00, 0xF0, 0xDF, 0xBE, + 0x70, 0xB5, 0x64, 0x4D, + 0x04, 0x46, 0x28, 0x68, 0x90, 0xF8, 0xF1, 0x01, 0xC0, 0xF3, 0x01, 0x12, + 0xC0, 0xF3, 0x81, 0x01, + 0x00, 0xF0, 0x03, 0x00, 0xFD, 0xF7, 0xA1, 0xFA, 0x40, 0x1C, 0xC6, 0xB2, + 0x20, 0x46, 0x00, 0xF0, + 0x71, 0xFC, 0x59, 0x48, 0xEA, 0xF7, 0xC5, 0xFD, 0xA4, 0xF8, 0x76, 0x00, + 0x00, 0x22, 0x31, 0x46, + 0x20, 0x46, 0xEA, 0xF7, 0x82, 0xFF, 0xA0, 0x79, 0x40, 0xF0, 0x02, 0x00, + 0xA0, 0x71, 0x94, 0xF8, + 0x6F, 0x00, 0x66, 0xF3, 0x02, 0x00, 0x84, 0xF8, 0x6F, 0x00, 0x94, 0xF8, + 0x6E, 0x00, 0x20, 0xF0, + 0x0F, 0x00, 0x84, 0xF8, 0x6E, 0x00, 0x29, 0x68, 0xA0, 0x7C, 0x91, 0xF8, + 0x08, 0x21, 0x62, 0xF3, + 0x01, 0x00, 0xA0, 0x74, 0x91, 0xF8, 0x08, 0x21, 0x92, 0x08, 0x62, 0xF3, + 0x87, 0x10, 0xA0, 0x74, + 0xA0, 0x89, 0x6F, 0xF3, 0x0B, 0x00, 0xA0, 0x81, 0x91, 0xF8, 0x07, 0x01, + 0xA0, 0x70, 0x94, 0xF8, + 0x5E, 0x00, 0x00, 0x21, 0x20, 0xF0, 0x01, 0x00, 0x84, 0xF8, 0x5E, 0x00, + 0x20, 0x46, 0xEA, 0xF7, + 0x1E, 0xFE, 0x28, 0x68, 0x90, 0xF8, 0xF2, 0x11, 0x84, 0xF8, 0x66, 0x10, + 0x90, 0xF8, 0xF3, 0x11, + 0x84, 0xF8, 0x68, 0x10, 0x90, 0xF8, 0xF4, 0x11, 0x84, 0xF8, 0x6A, 0x10, + 0x90, 0xF8, 0xF5, 0x01, + 0x84, 0xF8, 0x6C, 0x00, 0x34, 0x48, 0x94, 0xF8, 0x5F, 0x10, 0x00, 0x1F, + 0x40, 0x78, 0x60, 0xF3, + 0x04, 0x01, 0x84, 0xF8, 0x5F, 0x10, 0x20, 0x46, 0xBD, 0xE8, 0x70, 0x40, + 0x00, 0xF0, 0x48, 0xBF, + 0x10, 0xB5, 0x2D, 0x4C, 0x00, 0x20, 0x24, 0x1F, 0x20, 0x80, 0x01, 0x20, + 0x00, 0xF0, 0x32, 0xF8, + 0x60, 0x70, 0xBD, 0xE8, 0x10, 0x40, 0x2B, 0x48, 0x88, 0xE7, 0x2D, 0xE9, + 0xF0, 0x41, 0x29, 0x4E, + 0x40, 0x79, 0x28, 0xB3, 0x30, 0x46, 0x00, 0xF0, 0xD9, 0xFF, 0xB0, 0x7C, + 0x00, 0xF0, 0x03, 0x00, + 0x00, 0xF0, 0x1C, 0xFF, 0x22, 0x4F, 0x3C, 0x68, 0x04, 0xF2, 0x5E, 0x60, + 0x94, 0xF8, 0x51, 0x26, + 0x04, 0xF6, 0x6E, 0x05, 0x94, 0xF8, 0x50, 0x16, 0x00, 0xEB, 0x42, 0x00, + 0x00, 0xF0, 0xDF, 0xFE, + 0x38, 0x68, 0x90, 0xF8, 0x60, 0x18, 0x90, 0xF8, 0x61, 0x08, 0x05, 0xEB, + 0x40, 0x00, 0x00, 0xF0, + 0xED, 0xFE, 0x19, 0x49, 0x30, 0x46, 0xEA, 0xF7, 0x31, 0xFF, 0x00, 0x20, + 0xBD, 0xE8, 0xF0, 0x81, + 0x01, 0x20, 0xFB, 0xE7, 0x12, 0x48, 0x4F, 0xF4, 0x80, 0x73, 0x02, 0x68, + 0x92, 0xF8, 0xF5, 0x10, + 0x92, 0xF8, 0x07, 0x01, 0x92, 0xF8, 0xF2, 0x20, 0x01, 0xF0, 0x1F, 0x01, + 0x02, 0xF0, 0x0F, 0x02, + 0x98, 0x42, 0x00, 0xD9, 0x18, 0x46, 0x1F, 0x29, 0x00, 0xD9, 0x1F, 0x21, + 0x49, 0x1C, 0x48, 0x43, + 0x40, 0x00, 0x52, 0x1C, 0x50, 0x43, 0xC0, 0xEB, 0x40, 0x20, 0xC0, 0x13, + 0xB0, 0xFA, 0x80, 0xF0, + 0xC0, 0xF1, 0x20, 0x00, 0xC0, 0xB2, 0x70, 0x47, 0xE4, 0xA4, 0x01, 0x20, + 0xB4, 0x84, 0x10, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0xB8, 0x82, 0x10, 0x00, 0xA1, 0x5C, 0x01, 0x00, + 0x2D, 0xE9, 0xF0, 0x47, + 0xFE, 0x49, 0x4F, 0xF0, 0x01, 0x08, 0x00, 0x27, 0x0A, 0x68, 0x80, 0x1E, + 0x02, 0xF2, 0x5E, 0x64, + 0xC1, 0x46, 0x06, 0x28, 0x52, 0xD2, 0xDF, 0xE8, 0x00, 0xF0, 0x51, 0x09, + 0x2D, 0x51, 0x2D, 0x03, + 0x12, 0xF8, 0xD3, 0x6F, 0x10, 0x79, 0x00, 0xF0, 0x1F, 0x05, 0x70, 0xE0, + 0x92, 0xF8, 0xF5, 0x00, + 0x92, 0xF8, 0x01, 0x61, 0x00, 0xF0, 0x1F, 0x05, 0x92, 0xF8, 0xF2, 0x00, + 0x8A, 0x46, 0x00, 0xF0, + 0x0F, 0x07, 0x92, 0xF8, 0xE6, 0x00, 0x80, 0x06, 0x09, 0xD5, 0x92, 0xF8, + 0x53, 0x06, 0x92, 0xF8, + 0x52, 0x16, 0x04, 0xEB, 0x40, 0x00, 0x0A, 0x22, 0x00, 0xF0, 0x4E, 0xFE, + 0x80, 0x46, 0xDA, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0xE6, 0x10, 0x49, 0x06, 0x51, 0xD5, 0x90, 0xF8, + 0x62, 0x18, 0x90, 0xF8, + 0x63, 0x08, 0x46, 0xE0, 0x92, 0xF8, 0xFC, 0x00, 0x92, 0xF8, 0xF8, 0x60, + 0x00, 0xF0, 0x1F, 0x05, + 0x92, 0xF8, 0xF9, 0x00, 0x8A, 0x46, 0x00, 0xF0, 0x0F, 0x07, 0x92, 0xF8, + 0xE6, 0x00, 0x80, 0x06, + 0x09, 0xD5, 0x92, 0xF8, 0x55, 0x06, 0x92, 0xF8, 0x54, 0x16, 0x04, 0xEB, + 0x40, 0x00, 0x0A, 0x22, + 0x00, 0xF0, 0x2A, 0xFE, 0x80, 0x46, 0xDA, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0xE6, 0x10, 0x49, 0x06, + 0x2D, 0xD5, 0x90, 0xF8, 0x64, 0x18, 0x90, 0xF8, 0x65, 0x08, 0x22, 0xE0, + 0x92, 0xF8, 0xF5, 0x00, + 0x92, 0xF8, 0xF1, 0x60, 0x00, 0xF0, 0x1F, 0x05, 0x92, 0xF8, 0xF2, 0x00, + 0x8A, 0x46, 0x00, 0xF0, + 0x0F, 0x07, 0x92, 0xF8, 0xE6, 0x00, 0x80, 0x06, 0x09, 0xD5, 0x92, 0xF8, + 0x51, 0x06, 0x92, 0xF8, + 0x50, 0x16, 0x04, 0xEB, 0x40, 0x00, 0x0A, 0x22, 0x00, 0xF0, 0x06, 0xFE, + 0x80, 0x46, 0xDA, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0xE6, 0x10, 0x49, 0x06, 0x09, 0xD5, 0x90, 0xF8, + 0x60, 0x18, 0x90, 0xF8, + 0x61, 0x08, 0x0A, 0x22, 0x04, 0xEB, 0x40, 0x00, 0x00, 0xF0, 0xF6, 0xFD, + 0x81, 0x46, 0x4F, 0xF4, + 0x80, 0x70, 0x86, 0x42, 0x00, 0xD9, 0x06, 0x46, 0x1F, 0x2D, 0x00, 0xD9, + 0x1F, 0x25, 0x6D, 0x1C, + 0x6E, 0x43, 0x70, 0x00, 0x7F, 0x1C, 0x78, 0x43, 0xC0, 0xEB, 0x40, 0x20, + 0x00, 0xFB, 0x08, 0xF0, + 0x00, 0xFB, 0x09, 0xF0, 0xC0, 0x13, 0xB0, 0xFA, 0x80, 0xF0, 0xC0, 0xF1, + 0x20, 0x00, 0xC0, 0xB2, + 0xBD, 0xE8, 0xF0, 0x87, 0x70, 0xB5, 0x06, 0x00, 0x03, 0xD0, 0xBD, 0xE8, + 0x70, 0x40, 0x00, 0xF0, + 0x64, 0xBD, 0x00, 0xF0, 0x18, 0xF8, 0x01, 0x28, 0x14, 0xD1, 0xA9, 0x4D, + 0xA9, 0x4C, 0x28, 0x78, + 0x01, 0x28, 0x09, 0xD0, 0xA8, 0x48, 0xA0, 0x60, 0x68, 0x78, 0xE0, 0x73, + 0xE8, 0x78, 0xA0, 0x73, + 0xE8, 0x88, 0xA0, 0x81, 0x30, 0x46, 0xE8, 0xE7, 0x6A, 0x79, 0x29, 0x79, + 0xA2, 0x48, 0x00, 0xF0, + 0xB6, 0xFE, 0xF0, 0xE7, 0x70, 0xBD, 0x9E, 0x4B, 0x10, 0xB5, 0xD9, 0x78, + 0x9F, 0x4C, 0x49, 0x1C, + 0xCA, 0xB2, 0xDA, 0x70, 0x99, 0x78, 0x01, 0x20, 0x8A, 0x42, 0x1B, 0xD8, + 0x19, 0x79, 0x58, 0x79, + 0x41, 0x43, 0x99, 0x48, 0xFD, 0xF7, 0xA9, 0xF9, 0xEA, 0xF7, 0x33, 0xFC, + 0xA4, 0xF8, 0x76, 0x00, + 0x92, 0x48, 0x00, 0x68, 0x90, 0xF8, 0xB0, 0x00, 0xC0, 0x07, 0x06, 0xD0, + 0x94, 0xF8, 0x4D, 0x00, + 0x20, 0xF0, 0x03, 0x00, 0x80, 0x1C, 0x84, 0xF8, 0x4D, 0x00, 0x91, 0x49, + 0x20, 0x46, 0xEA, 0xF7, + 0x15, 0xFE, 0x00, 0x20, 0x10, 0xBD, 0x70, 0xB5, 0x04, 0x46, 0xEA, 0xF7, + 0x15, 0xFC, 0x8A, 0x48, + 0xEA, 0xF7, 0x17, 0xFC, 0xA4, 0xF8, 0x76, 0x00, 0x00, 0xF0, 0x66, 0xFD, + 0x83, 0x4D, 0x01, 0x46, + 0x28, 0x68, 0x90, 0xF8, 0xE7, 0x00, 0xC0, 0xF3, 0x41, 0x12, 0x20, 0x46, + 0xEA, 0xF7, 0xAC, 0xFD, + 0x00, 0xF0, 0x5E, 0xFD, 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEA, 0xF7, + 0xD1, 0xFD, 0xA0, 0x79, + 0x20, 0xF0, 0x02, 0x00, 0xA0, 0x71, 0x94, 0xF8, 0x6F, 0x00, 0x20, 0xF0, + 0x07, 0x00, 0x84, 0xF8, + 0x6F, 0x00, 0x94, 0xF8, 0x6E, 0x00, 0x20, 0xF0, 0x0F, 0x00, 0x84, 0xF8, + 0x6E, 0x00, 0x28, 0x68, + 0x90, 0xF8, 0xE7, 0x00, 0xC0, 0xF3, 0x41, 0x11, 0x20, 0x46, 0xEA, 0xF7, + 0xD3, 0xFD, 0x28, 0x68, + 0x90, 0xF8, 0xE7, 0x00, 0x10, 0xF0, 0x60, 0x0F, 0x94, 0xF8, 0x5E, 0x00, + 0x7E, 0xD0, 0x40, 0xF0, + 0x01, 0x00, 0x00, 0xBF, 0x84, 0xF8, 0x5E, 0x00, 0x20, 0x46, 0x00, 0xF0, + 0x6B, 0xFE, 0x04, 0x21, + 0x20, 0x46, 0xEA, 0xF7, 0x04, 0xFC, 0x28, 0x68, 0x90, 0xF8, 0xF1, 0x00, + 0xA0, 0x70, 0x28, 0x68, + 0x21, 0x8E, 0xB0, 0xF8, 0xF6, 0x20, 0x62, 0xF3, 0x08, 0x01, 0x21, 0x86, + 0x90, 0xF8, 0xF2, 0x00, + 0x00, 0xF0, 0x0F, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0x52, 0xFC, 0x28, 0x68, + 0x62, 0x7D, 0x90, 0xF8, + 0xEA, 0x10, 0x61, 0xF3, 0x03, 0x02, 0x62, 0x75, 0xB0, 0xF8, 0xED, 0x20, + 0x21, 0x8A, 0x62, 0xF3, + 0x0B, 0x01, 0x21, 0x82, 0x90, 0xF8, 0xF3, 0x10, 0xA2, 0x7D, 0x61, 0xF3, + 0x03, 0x02, 0xA2, 0x75, + 0x10, 0xF8, 0xF2, 0x1F, 0x0A, 0x09, 0xA1, 0x7C, 0x62, 0xF3, 0x01, 0x01, + 0xA1, 0x74, 0x10, 0xF8, + 0x0C, 0x29, 0x92, 0x09, 0x62, 0xF3, 0x87, 0x11, 0xA1, 0x74, 0x01, 0x78, + 0xE2, 0x79, 0x61, 0xF3, + 0x00, 0x02, 0xE2, 0x71, 0xC1, 0x78, 0x61, 0x72, 0x80, 0x79, 0x01, 0x09, + 0xE0, 0x7A, 0x61, 0xF3, + 0x03, 0x00, 0xE0, 0x72, 0x4B, 0x48, 0xEA, 0xF7, 0x94, 0xFB, 0xA4, 0xF8, + 0x7C, 0x00, 0x29, 0x68, + 0x11, 0xF8, 0xE8, 0x0F, 0xC2, 0x08, 0x94, 0xF8, 0x27, 0x00, 0x62, 0xF3, + 0x83, 0x00, 0x84, 0xF8, + 0x27, 0x00, 0x11, 0xF8, 0x01, 0x29, 0x52, 0x08, 0x62, 0xF3, 0x00, 0x00, + 0x84, 0xF8, 0x27, 0x00, + 0x4A, 0x78, 0x92, 0x08, 0x62, 0xF3, 0x41, 0x00, 0x84, 0xF8, 0x27, 0x00, + 0x08, 0x78, 0xC0, 0xF3, + 0x81, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0xF0, 0xFB, 0x28, 0x68, 0x90, 0xF8, + 0xE7, 0x00, 0x01, 0x09, + 0x14, 0xF8, 0x28, 0x0F, 0x61, 0xF3, 0x04, 0x10, 0x20, 0x70, 0x37, 0x48, + 0xEA, 0xF7, 0x69, 0xFB, + 0xA4, 0xF8, 0x5E, 0x00, 0x28, 0x68, 0x10, 0xF8, 0xE6, 0x1F, 0x00, 0xE0, + 0xA6, 0xE0, 0xCA, 0x08, + 0xE1, 0x7A, 0x62, 0xF3, 0x45, 0x11, 0xE1, 0x72, 0x40, 0x78, 0x41, 0x08, + 0x20, 0x78, 0x61, 0xF3, + 0x45, 0x10, 0x04, 0xF8, 0x28, 0x09, 0x20, 0x46, 0x00, 0xF0, 0x2A, 0xFD, + 0x28, 0x68, 0x90, 0xF8, + 0xEC, 0x00, 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0xB3, 0xFB, + 0x14, 0xF8, 0x32, 0x0F, + 0x20, 0xF0, 0x0F, 0x00, 0x0A, 0x30, 0x20, 0xF0, 0xF0, 0x00, 0xA0, 0x30, + 0x04, 0xF8, 0x0A, 0x09, + 0x29, 0x68, 0x11, 0xF8, 0xE6, 0x0F, 0x82, 0x09, 0xE0, 0x7A, 0x62, 0xF3, + 0x00, 0x00, 0xE0, 0x72, + 0x0A, 0x78, 0x52, 0x09, 0x62, 0xF3, 0x41, 0x00, 0xE0, 0x72, 0x4A, 0x79, + 0xD2, 0x09, 0x62, 0xF3, + 0x82, 0x00, 0xE0, 0x72, 0x88, 0x7B, 0x62, 0x79, 0x60, 0xF3, 0x04, 0x02, + 0x62, 0x71, 0xC9, 0x7B, + 0x20, 0x79, 0x61, 0xF3, 0x04, 0x00, 0x20, 0x71, 0x14, 0x48, 0x94, 0xF8, + 0x37, 0x10, 0x40, 0x78, + 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x37, 0x10, 0x11, 0x48, 0xEA, 0xF7, + 0x1A, 0xFB, 0xA4, 0xF8, + 0x52, 0x00, 0x28, 0x68, 0xE1, 0x88, 0xB0, 0xF8, 0xEF, 0x20, 0x62, 0xF3, + 0x0B, 0x01, 0xE1, 0x80, + 0x90, 0xF8, 0xEB, 0x10, 0xCA, 0x08, 0x21, 0x7C, 0x14, 0xE0, 0x00, 0x00, + 0x4C, 0x07, 0x10, 0x00, + 0xE6, 0x07, 0x10, 0x00, 0xB4, 0x84, 0x10, 0x00, 0x14, 0xA6, 0x01, 0x20, + 0x00, 0x84, 0x10, 0x00, + 0x95, 0x5F, 0x01, 0x00, 0x78, 0x8B, 0x01, 0x20, 0x20, 0xBF, 0x01, 0x20, + 0x16, 0xBF, 0x01, 0x20, + 0x00, 0x9B, 0x01, 0x20, 0x62, 0xF3, 0x02, 0x01, 0x21, 0x74, 0x10, 0xF8, + 0xDF, 0x1F, 0xA2, 0x78, + 0x61, 0xF3, 0x03, 0x02, 0xA2, 0x70, 0x01, 0x78, 0x0A, 0x09, 0xE1, 0x78, + 0x62, 0xF3, 0x03, 0x01, + 0xE1, 0x70, 0xC1, 0x7A, 0x0A, 0x09, 0x61, 0x78, 0x62, 0xF3, 0x02, 0x01, + 0x61, 0x70, 0x41, 0x7A, + 0x8A, 0x09, 0x21, 0x78, 0x62, 0xF3, 0x00, 0x01, 0x21, 0x70, 0xC1, 0x79, + 0xCA, 0x09, 0x21, 0x7B, + 0x62, 0xF3, 0x00, 0x01, 0x21, 0x73, 0x94, 0xF8, 0x37, 0x10, 0x41, 0xF0, + 0x20, 0x01, 0x84, 0xF8, + 0x37, 0x10, 0x21, 0x8F, 0x6F, 0xF3, 0x08, 0x01, 0x01, 0xF5, 0x80, 0x71, + 0x21, 0x87, 0x00, 0x21, + 0xC4, 0xF8, 0x3A, 0x10, 0x01, 0x7B, 0x8A, 0x09, 0xE1, 0x7A, 0x62, 0xF3, + 0xC3, 0x01, 0xE1, 0x72, + 0xC0, 0x79, 0x00, 0x09, 0x60, 0xF3, 0x04, 0x11, 0xE1, 0x72, 0x70, 0xBD, + 0x20, 0xF0, 0x01, 0x00, + 0xD8, 0xE6, 0x70, 0xB5, 0x04, 0x46, 0xEA, 0xF7, 0xAF, 0xFA, 0xFD, 0x48, + 0xEA, 0xF7, 0xB1, 0xFA, + 0xA4, 0xF8, 0x76, 0x00, 0x00, 0xF0, 0x00, 0xFC, 0xFA, 0x4D, 0x01, 0x46, + 0x28, 0x68, 0x90, 0xF8, + 0xC9, 0x00, 0xC0, 0xF3, 0x41, 0x12, 0x20, 0x46, 0xEA, 0xF7, 0x46, 0xFC, + 0x00, 0xF0, 0xF8, 0xFB, + 0x02, 0x46, 0x0B, 0x46, 0x20, 0x46, 0xEA, 0xF7, 0x6B, 0xFC, 0xA0, 0x79, + 0x20, 0xF0, 0x02, 0x00, + 0xA0, 0x71, 0x94, 0xF8, 0x6F, 0x00, 0x20, 0xF0, 0x07, 0x00, 0x84, 0xF8, + 0x6F, 0x00, 0x94, 0xF8, + 0x6E, 0x00, 0x20, 0xF0, 0x0F, 0x00, 0x84, 0xF8, 0x6E, 0x00, 0x28, 0x68, + 0x90, 0xF8, 0xC9, 0x00, + 0xC0, 0xF3, 0x41, 0x11, 0x20, 0x46, 0xEA, 0xF7, 0x6D, 0xFC, 0x28, 0x68, + 0x90, 0xF8, 0xC9, 0x00, + 0x10, 0xF0, 0x60, 0x0F, 0x94, 0xF8, 0x5E, 0x00, 0x7E, 0xD0, 0x40, 0xF0, + 0x01, 0x00, 0x00, 0xBF, + 0x84, 0xF8, 0x5E, 0x00, 0x20, 0x46, 0x00, 0xF0, 0x05, 0xFD, 0x28, 0x68, + 0x90, 0xF8, 0xD3, 0x00, + 0xA0, 0x70, 0x28, 0x68, 0x21, 0x8E, 0xB0, 0xF8, 0xD8, 0x20, 0x62, 0xF3, + 0x08, 0x01, 0x21, 0x86, + 0x90, 0xF8, 0xD4, 0x00, 0x00, 0xF0, 0x0F, 0x01, 0x20, 0x46, 0xEA, 0xF7, + 0xF0, 0xFA, 0x28, 0x68, + 0x62, 0x7D, 0x90, 0xF8, 0xCC, 0x10, 0x61, 0xF3, 0x03, 0x02, 0x62, 0x75, + 0xB0, 0xF8, 0xCF, 0x20, + 0x21, 0x8A, 0x62, 0xF3, 0x0B, 0x01, 0x21, 0x82, 0x90, 0xF8, 0xD5, 0x10, + 0xA2, 0x7D, 0x61, 0xF3, + 0x03, 0x02, 0xA2, 0x75, 0x90, 0xF8, 0xF2, 0x21, 0xA1, 0x89, 0x62, 0xF3, + 0x0B, 0x01, 0xA1, 0x81, + 0x10, 0xF8, 0xD4, 0x1F, 0x0A, 0x09, 0xA1, 0x7C, 0x62, 0xF3, 0x01, 0x01, + 0xA1, 0x74, 0x10, 0xF8, + 0x0C, 0x29, 0x92, 0x09, 0x62, 0xF3, 0x87, 0x11, 0xA1, 0x74, 0x01, 0x78, + 0xE2, 0x79, 0x61, 0xF3, + 0x00, 0x02, 0xE2, 0x71, 0xC1, 0x78, 0x61, 0x72, 0x80, 0x79, 0x01, 0x09, + 0xE0, 0x7A, 0x61, 0xF3, + 0x03, 0x00, 0xE0, 0x72, 0xBC, 0x48, 0xEA, 0xF7, 0x2C, 0xFA, 0xA4, 0xF8, + 0x7C, 0x00, 0x29, 0x68, + 0x11, 0xF8, 0xCA, 0x0F, 0xC2, 0x08, 0x94, 0xF8, 0x27, 0x00, 0x62, 0xF3, + 0x83, 0x00, 0x84, 0xF8, + 0x27, 0x00, 0x11, 0xF8, 0x01, 0x29, 0x52, 0x08, 0x62, 0xF3, 0x00, 0x00, + 0x84, 0xF8, 0x27, 0x00, + 0x4A, 0x78, 0x92, 0x08, 0x62, 0xF3, 0x41, 0x00, 0x84, 0xF8, 0x27, 0x00, + 0x08, 0x78, 0xC0, 0xF3, + 0x81, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0x88, 0xFA, 0x28, 0x68, 0x90, 0xF8, + 0xC9, 0x00, 0x01, 0x09, + 0x14, 0xF8, 0x28, 0x0F, 0x61, 0xF3, 0x04, 0x10, 0x20, 0x70, 0xA8, 0x48, + 0xEA, 0xF7, 0x01, 0xFA, + 0xA4, 0xF8, 0x5E, 0x00, 0x28, 0x68, 0x00, 0xE0, 0xA1, 0xE0, 0x10, 0xF8, + 0xC8, 0x1F, 0xCA, 0x08, + 0xE1, 0x7A, 0x62, 0xF3, 0x45, 0x11, 0xE1, 0x72, 0x40, 0x78, 0x41, 0x08, + 0x20, 0x78, 0x61, 0xF3, + 0x45, 0x10, 0x04, 0xF8, 0x28, 0x09, 0x20, 0x46, 0x00, 0xF0, 0xC2, 0xFB, + 0x28, 0x68, 0x90, 0xF8, + 0xCE, 0x00, 0xC0, 0xF3, 0x81, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0x4B, 0xFA, + 0x14, 0xF8, 0x32, 0x0F, + 0x20, 0xF0, 0x0F, 0x00, 0x0A, 0x30, 0x20, 0xF0, 0xF0, 0x00, 0xA0, 0x30, + 0x04, 0xF8, 0x0A, 0x09, + 0x29, 0x68, 0x11, 0xF8, 0xC8, 0x0F, 0x82, 0x09, 0xE0, 0x7A, 0x62, 0xF3, + 0x00, 0x00, 0xE0, 0x72, + 0x0A, 0x78, 0x52, 0x09, 0x62, 0xF3, 0x41, 0x00, 0xE0, 0x72, 0x4A, 0x79, + 0xD2, 0x09, 0x62, 0xF3, + 0x82, 0x00, 0xE0, 0x72, 0x88, 0x7B, 0x62, 0x79, 0x60, 0xF3, 0x04, 0x02, + 0x62, 0x71, 0xC8, 0x7B, + 0x21, 0x79, 0x60, 0xF3, 0x04, 0x01, 0x86, 0x48, 0x21, 0x71, 0x94, 0xF8, + 0x37, 0x10, 0x40, 0x78, + 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, 0x37, 0x10, 0x82, 0x48, 0xEA, 0xF7, + 0xB2, 0xF9, 0xA4, 0xF8, + 0x52, 0x00, 0x28, 0x68, 0xE1, 0x88, 0xB0, 0xF8, 0xD1, 0x20, 0x62, 0xF3, + 0x0B, 0x01, 0xE1, 0x80, + 0x10, 0xF8, 0xCD, 0x1F, 0xCA, 0x08, 0x21, 0x7C, 0x62, 0xF3, 0x02, 0x01, + 0x21, 0x74, 0x10, 0xF8, + 0x12, 0x1F, 0xA2, 0x78, 0x61, 0xF3, 0x03, 0x02, 0xA2, 0x70, 0x10, 0xF8, + 0x17, 0x19, 0x0A, 0x09, + 0xE1, 0x78, 0x62, 0xF3, 0x03, 0x01, 0xE1, 0x70, 0x01, 0x79, 0x0A, 0x09, + 0x61, 0x78, 0x62, 0xF3, + 0x02, 0x01, 0x61, 0x70, 0x81, 0x78, 0x8A, 0x09, 0x21, 0x78, 0x62, 0xF3, + 0x00, 0x01, 0x21, 0x70, + 0x01, 0x78, 0xCA, 0x09, 0x21, 0x7B, 0x62, 0xF3, 0x00, 0x01, 0x21, 0x73, + 0x01, 0x79, 0xCA, 0x09, + 0x94, 0xF8, 0x37, 0x10, 0x62, 0xF3, 0x45, 0x11, 0x84, 0xF8, 0x37, 0x10, + 0x22, 0x8F, 0x01, 0xF0, + 0x1F, 0x01, 0x6F, 0xF3, 0x08, 0x02, 0x02, 0xF5, 0x80, 0x72, 0x22, 0x87, + 0x83, 0x7B, 0xC2, 0x7A, + 0x03, 0xF0, 0x1F, 0x03, 0x5B, 0x1C, 0xC3, 0xEB, 0x43, 0x23, 0x5B, 0x00, + 0x5A, 0x43, 0xCA, 0x40, + 0x51, 0x08, 0xC4, 0xF8, 0x3A, 0x10, 0x41, 0x79, 0x8A, 0x09, 0xE1, 0x7A, + 0x62, 0xF3, 0xC3, 0x01, + 0xE1, 0x72, 0x00, 0x78, 0x00, 0x09, 0x60, 0xF3, 0x04, 0x11, 0xE1, 0x72, + 0x70, 0xBD, 0x20, 0xF0, + 0x01, 0x00, 0xDD, 0xE6, 0x10, 0xB5, 0x04, 0x46, 0xA4, 0x22, 0x53, 0x49, + 0x00, 0xF0, 0xA5, 0xFD, + 0x52, 0x48, 0xC1, 0x78, 0xA0, 0x89, 0x61, 0xF3, 0x0B, 0x00, 0xA0, 0x81, + 0x10, 0xBD, 0x70, 0xB5, + 0x04, 0x46, 0xFF, 0xF7, 0xEF, 0xFF, 0x00, 0xF0, 0x97, 0xFA, 0x01, 0x46, + 0x00, 0x22, 0x20, 0x46, + 0xEA, 0xF7, 0xE2, 0xFA, 0x4A, 0x48, 0xEA, 0xF7, 0x3C, 0xF9, 0x42, 0x4D, + 0xA4, 0xF8, 0x7C, 0x00, + 0x28, 0x68, 0x90, 0xF8, 0xF8, 0x00, 0xA0, 0x70, 0x28, 0x68, 0x90, 0xF8, + 0xF9, 0x00, 0x00, 0xF0, + 0x0F, 0x01, 0x20, 0x46, 0xEA, 0xF7, 0xBB, 0xF9, 0x28, 0x68, 0x10, 0xF8, + 0xF9, 0x1F, 0x0A, 0x09, + 0xA1, 0x7C, 0x62, 0xF3, 0x01, 0x01, 0xA1, 0x74, 0x02, 0x78, 0x92, 0x09, + 0x62, 0xF3, 0x87, 0x11, + 0xA1, 0x74, 0x81, 0x78, 0x94, 0xF8, 0x2D, 0x20, 0x61, 0xF3, 0x04, 0x02, + 0x84, 0xF8, 0x2D, 0x20, + 0xC1, 0x78, 0x94, 0xF8, 0x2C, 0x20, 0x61, 0xF3, 0x04, 0x02, 0x84, 0xF8, + 0x2C, 0x20, 0x40, 0x78, + 0xA1, 0x7D, 0x60, 0xF3, 0x03, 0x01, 0xA1, 0x75, 0x00, 0x21, 0x20, 0x46, + 0xEA, 0xF7, 0xF2, 0xFA, + 0x14, 0xF8, 0x5E, 0x0F, 0x20, 0xF0, 0x01, 0x00, 0x04, 0xF8, 0x01, 0x0B, + 0x28, 0x48, 0x21, 0x78, + 0x00, 0x79, 0x60, 0xF3, 0x04, 0x01, 0x04, 0xF8, 0x2F, 0x19, 0x28, 0x68, + 0xB0, 0xF8, 0xFD, 0x10, + 0x20, 0x88, 0x61, 0xF3, 0x08, 0x00, 0x20, 0x80, 0x70, 0xBD, 0x70, 0xB5, + 0x1D, 0x4E, 0x03, 0x28, + 0x34, 0x68, 0x04, 0xF2, 0x5E, 0x62, 0x04, 0xF6, 0x6E, 0x05, 0x15, 0xD0, + 0x04, 0x28, 0x21, 0xD0, + 0x94, 0xF8, 0x51, 0x06, 0x94, 0xF8, 0x50, 0x16, 0x02, 0xEB, 0x40, 0x00, + 0x00, 0xF0, 0x77, 0xFA, + 0x30, 0x68, 0x90, 0xF8, 0x60, 0x18, 0x90, 0xF8, 0x61, 0x08, 0x00, 0xBF, + 0x05, 0xEB, 0x40, 0x00, + 0xBD, 0xE8, 0x70, 0x40, 0x00, 0xF0, 0x82, 0xBA, 0x94, 0xF8, 0x53, 0x06, + 0x94, 0xF8, 0x52, 0x16, + 0x02, 0xEB, 0x40, 0x00, 0x00, 0xF0, 0x63, 0xFA, 0x30, 0x68, 0x90, 0xF8, + 0x62, 0x18, 0x90, 0xF8, + 0x63, 0x08, 0xEB, 0xE7, 0x94, 0xF8, 0x55, 0x06, 0x94, 0xF8, 0x54, 0x16, + 0x02, 0xEB, 0x40, 0x00, + 0x00, 0xF0, 0x55, 0xFA, 0x30, 0x68, 0x90, 0xF8, 0x64, 0x18, 0x90, 0xF8, + 0x65, 0x08, 0xDD, 0xE7, + 0x14, 0xA6, 0x01, 0x20, 0x4C, 0x07, 0x10, 0x00, 0x78, 0x8B, 0x01, 0x20, + 0x20, 0xBF, 0x01, 0x20, + 0x16, 0xBF, 0x01, 0x20, 0x00, 0x9B, 0x01, 0x20, 0x5C, 0x83, 0x10, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0x08, 0x92, 0x01, 0x20, 0x2D, 0xE9, 0xF0, 0x47, 0x85, 0x4D, 0x4F, 0xF0, + 0x01, 0x09, 0x00, 0x26, + 0x85, 0xF8, 0x00, 0x90, 0xAE, 0x70, 0x83, 0x4F, 0xDF, 0xF8, 0x0C, 0x82, + 0x04, 0x46, 0xEE, 0x70, + 0x09, 0x29, 0x66, 0xD2, 0xDF, 0xE8, 0x01, 0xF0, 0x65, 0x05, 0x09, 0x18, + 0x44, 0x2F, 0x48, 0x5E, + 0x62, 0x00, 0x20, 0x46, 0xFF, 0xF7, 0x36, 0xFF, 0x5B, 0xE0, 0x20, 0x46, + 0xFF, 0xF7, 0x32, 0xFF, + 0xB8, 0x78, 0x94, 0xF8, 0x5F, 0x10, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, + 0x5F, 0x10, 0xD8, 0xF8, + 0x00, 0x00, 0x90, 0xF8, 0xFF, 0x00, 0x12, 0xE0, 0x20, 0x46, 0xFF, 0xF7, + 0x23, 0xFF, 0xD8, 0xF8, + 0x00, 0x10, 0x91, 0xF8, 0x01, 0x11, 0xA1, 0x70, 0xF9, 0x78, 0x94, 0xF8, + 0x5F, 0x20, 0x61, 0xF3, + 0x04, 0x02, 0x84, 0xF8, 0x5F, 0x20, 0xD8, 0xF8, 0x00, 0x00, 0x90, 0xF8, + 0x00, 0x01, 0x00, 0xF0, + 0x03, 0x00, 0xA8, 0x70, 0x35, 0xE0, 0x20, 0x46, 0xFF, 0xF7, 0x0C, 0xFF, + 0x00, 0x21, 0x20, 0x46, + 0xEA, 0xF7, 0xED, 0xF8, 0x94, 0xF8, 0x5E, 0x00, 0x20, 0xF0, 0x01, 0x00, + 0x84, 0xF8, 0x5E, 0x00, + 0x78, 0x79, 0x94, 0xF8, 0x5F, 0x10, 0x60, 0xF3, 0x04, 0x01, 0x84, 0xF8, + 0x5F, 0x10, 0x17, 0xE0, + 0x20, 0x46, 0xFF, 0xF7, 0x04, 0xFF, 0x1C, 0xE0, 0x20, 0x46, 0xFF, 0xF7, + 0x00, 0xFF, 0x00, 0x21, + 0x20, 0x46, 0xEA, 0xF7, 0xD4, 0xF8, 0xB8, 0x79, 0x94, 0xF8, 0x5F, 0x10, + 0x60, 0xF3, 0x04, 0x01, + 0x84, 0xF8, 0x5F, 0x10, 0x94, 0xF8, 0x5E, 0x00, 0x20, 0xF0, 0x01, 0x00, + 0x84, 0xF8, 0x5E, 0x00, + 0x2E, 0x70, 0x06, 0xE0, 0x20, 0x46, 0xFF, 0xF7, 0x7C, 0xFD, 0xF9, 0xE7, + 0x20, 0x46, 0x00, 0xF0, + 0x59, 0xF8, 0x20, 0x46, 0x00, 0xF0, 0xAA, 0xFA, 0x94, 0xF8, 0x27, 0x00, + 0xC0, 0x07, 0x01, 0xD0, + 0x6E, 0x70, 0x01, 0xE0, 0x85, 0xF8, 0x01, 0x90, 0xA0, 0x89, 0xC0, 0xF3, + 0x0B, 0x00, 0xE8, 0x80, + 0xBD, 0xE8, 0xF0, 0x87, 0x7F, 0xB5, 0x00, 0xF0, 0x6F, 0xF9, 0x01, 0x90, + 0x00, 0xF0, 0x70, 0xF9, + 0xCD, 0xE9, 0x02, 0x01, 0x04, 0x21, 0x01, 0xA8, 0xEA, 0xF7, 0xBD, 0xFC, + 0x3C, 0x4C, 0x08, 0x21, + 0x20, 0x71, 0x02, 0xA8, 0xEA, 0xF7, 0xB7, 0xFC, 0x60, 0x71, 0x3A, 0x48, + 0x00, 0x21, 0x80, 0x1E, + 0x38, 0x4D, 0x40, 0xF8, 0x02, 0x1F, 0x01, 0x24, 0x41, 0x60, 0x01, 0x72, + 0xE0, 0xB2, 0xFF, 0xF7, + 0xF5, 0xFA, 0x28, 0x55, 0x64, 0x1C, 0x09, 0x2C, 0xF8, 0xDB, 0x34, 0x48, + 0xFF, 0xF7, 0xDB, 0xFB, + 0x7F, 0xBD, 0x70, 0xB5, 0x31, 0x4D, 0x04, 0x79, 0xA4, 0x35, 0x8C, 0xB1, + 0x21, 0x46, 0x28, 0x46, + 0xFF, 0xF7, 0x48, 0xFF, 0xA8, 0x7C, 0x00, 0xF0, 0x03, 0x00, 0x00, 0xF0, + 0xAF, 0xF9, 0x20, 0x46, + 0xFF, 0xF7, 0xF3, 0xFE, 0x2A, 0x49, 0x28, 0x46, 0xEA, 0xF7, 0xD8, 0xF9, + 0x00, 0x20, 0x70, 0xBD, + 0x01, 0x20, 0x70, 0xBD, 0x40, 0xF2, 0xFF, 0x10, 0xC1, 0xEB, 0x41, 0x21, + 0x91, 0xFB, 0xF0, 0xF0, + 0x00, 0x20, 0x70, 0x47, 0x10, 0xB5, 0x04, 0x46, 0xFF, 0xF7, 0x7C, 0xFE, + 0x94, 0xF8, 0x37, 0x00, + 0x40, 0xF0, 0x10, 0x00, 0x84, 0xF8, 0x37, 0x00, 0xA1, 0x89, 0x94, 0xF8, + 0x33, 0x00, 0x6F, 0xF3, + 0x0B, 0x01, 0x10, 0x31, 0xA1, 0x81, 0x21, 0x8A, 0x20, 0xF0, 0x23, 0x00, + 0x6F, 0xF3, 0x0B, 0x01, + 0x40, 0x31, 0x21, 0x82, 0x08, 0x21, 0xA1, 0x70, 0x94, 0xF8, 0x5F, 0x10, + 0x40, 0xF0, 0x0C, 0x00, + 0x21, 0xF0, 0x1F, 0x01, 0x84, 0xF8, 0x5F, 0x10, 0x21, 0x8E, 0x6F, 0xF3, + 0x08, 0x01, 0x21, 0x86, + 0x84, 0xF8, 0x33, 0x00, 0x0C, 0x48, 0x01, 0x21, 0x00, 0x68, 0x90, 0xF8, + 0xE7, 0x00, 0xC0, 0xF3, + 0x41, 0x12, 0x20, 0x46, 0xEA, 0xF7, 0x48, 0xF9, 0x94, 0xF8, 0x28, 0x00, + 0x40, 0xF0, 0x20, 0x00, + 0x84, 0xF8, 0x28, 0x00, 0x20, 0x46, 0xBD, 0xE8, 0x10, 0x40, 0x00, 0xF0, + 0x71, 0xB9, 0x00, 0x00, + 0xE6, 0x07, 0x10, 0x00, 0x16, 0xBF, 0x01, 0x20, 0x4C, 0x07, 0x10, 0x00, + 0x5C, 0x83, 0x10, 0x00, + 0x95, 0x5F, 0x01, 0x00, 0x70, 0xB5, 0x00, 0xF0, 0x72, 0xFA, 0xFF, 0xF7, + 0x6B, 0xFF, 0xFF, 0xF7, + 0x17, 0xFA, 0xFF, 0xF7, 0xD5, 0xF8, 0xFE, 0xF7, 0xD9, 0xFE, 0xFE, 0xF7, + 0xF7, 0xF9, 0xFD, 0xF7, + 0x67, 0xFF, 0xFE, 0xF7, 0xA8, 0xFA, 0x50, 0x48, 0x00, 0x25, 0x70, 0x21, + 0x45, 0x60, 0x4F, 0x48, + 0x00, 0xF0, 0x6C, 0xFC, 0x4E, 0x48, 0x04, 0x68, 0x94, 0xF8, 0xE7, 0x00, + 0xC0, 0x06, 0x05, 0xD5, + 0x28, 0x22, 0x04, 0xF5, 0x0F, 0x61, 0x49, 0x48, 0x00, 0xF0, 0xBF, 0xFB, + 0x94, 0xF8, 0x33, 0x01, + 0xC0, 0x06, 0x0D, 0xD5, 0x45, 0x48, 0x20, 0x22, 0x04, 0xF6, 0x16, 0x11, + 0x28, 0x30, 0x00, 0xF0, + 0xB4, 0xFB, 0x42, 0x48, 0x28, 0x22, 0x04, 0xF6, 0x3F, 0x11, 0x48, 0x30, + 0x00, 0xF0, 0xAD, 0xFB, + 0x40, 0x48, 0x05, 0x70, 0x70, 0xBD, 0x38, 0xB1, 0x01, 0x28, 0x07, 0xD0, + 0x02, 0x28, 0x07, 0xD0, + 0x17, 0x20, 0x00, 0x21, 0xFB, 0xF7, 0x65, 0xBD, 0x14, 0x20, 0xFA, 0xE7, + 0x15, 0x20, 0xF8, 0xE7, + 0x16, 0x20, 0xF6, 0xE7, 0x00, 0x21, 0x01, 0x60, 0x41, 0x60, 0x81, 0x60, + 0xC1, 0x60, 0x70, 0x47, + 0x70, 0xB5, 0x31, 0x4C, 0x34, 0x4D, 0x20, 0x68, 0x09, 0xE0, 0x00, 0xBF, + 0x55, 0xF8, 0x20, 0x10, + 0x32, 0x48, 0x88, 0x47, 0x00, 0x28, 0x11, 0xD0, 0x20, 0x68, 0x40, 0x1C, + 0x20, 0x60, 0x09, 0x28, + 0xF4, 0xD3, 0x60, 0x68, 0x2D, 0x49, 0x40, 0x1C, 0x10, 0x31, 0x00, 0x22, + 0x60, 0x60, 0x0A, 0x70, + 0x48, 0x60, 0x2A, 0x48, 0x01, 0x68, 0x10, 0x30, 0x88, 0x47, 0x01, 0x20, + 0x70, 0xBD, 0x70, 0xB5, + 0x04, 0x46, 0x00, 0x79, 0x00, 0x25, 0x60, 0xB9, 0xE0, 0x79, 0x50, 0xB9, + 0xA0, 0x79, 0x40, 0xB9, + 0x20, 0x7A, 0x30, 0xB9, 0x60, 0x79, 0x20, 0xB9, 0x60, 0x7A, 0x10, 0xB9, + 0xA0, 0x7A, 0x00, 0x28, + 0x12, 0xD0, 0x1E, 0x48, 0x34, 0x21, 0x10, 0x30, 0x00, 0xF0, 0x00, 0xFC, + 0x94, 0xE8, 0x4E, 0x00, + 0x1A, 0x48, 0x80, 0xE8, 0x4E, 0x00, 0x14, 0x48, 0x16, 0x49, 0x05, 0x60, + 0x60, 0x7B, 0x08, 0x70, + 0x16, 0x48, 0xFF, 0xF7, 0xBD, 0xFF, 0x01, 0x20, 0x70, 0xBD, 0x0F, 0x49, + 0x50, 0xB1, 0x4A, 0x68, + 0x52, 0x1C, 0x4A, 0x60, 0x11, 0x49, 0x10, 0x31, 0x08, 0x70, 0x10, 0x48, + 0x4A, 0x60, 0x01, 0x68, + 0x10, 0x30, 0x08, 0x47, 0x08, 0x68, 0x40, 0x1C, 0x08, 0x60, 0x0C, 0x48, + 0xA8, 0xE7, 0x00, 0xF0, + 0x3B, 0xB8, 0x00, 0xF0, 0x3D, 0xB8, 0x00, 0xF0, 0x40, 0xB8, 0x00, 0xF0, + 0x43, 0xB8, 0x00, 0xF0, + 0x48, 0xB8, 0x00, 0xF0, 0x4B, 0xB8, 0x00, 0x00, 0xF0, 0x07, 0x10, 0x00, + 0x20, 0xBF, 0x01, 0x20, + 0x4C, 0x07, 0x10, 0x00, 0xF9, 0x07, 0x10, 0x00, 0x0C, 0x7D, 0x01, 0x00, + 0xA4, 0x84, 0x10, 0x00, + 0x70, 0xB5, 0x00, 0x23, 0x14, 0x46, 0x08, 0xE0, 0x31, 0xF8, 0x13, 0x50, + 0x31, 0xF8, 0x14, 0x60, + 0x35, 0x44, 0x20, 0xF8, 0x13, 0x50, 0x5B, 0x1C, 0x64, 0x1C, 0x93, 0x42, + 0xF4, 0xDB, 0x70, 0xBD, + 0x30, 0xB4, 0x00, 0x24, 0x43, 0xB9, 0x0B, 0xE0, 0x30, 0xF8, 0x14, 0x30, + 0x31, 0xF8, 0x14, 0x50, + 0x2B, 0x44, 0x20, 0xF8, 0x14, 0x30, 0x64, 0x1C, 0x94, 0x42, 0xF5, 0xDB, + 0x30, 0xBC, 0x70, 0x47, + 0x30, 0xBC, 0x52, 0x00, 0x00, 0xF0, 0x01, 0xBB, 0xBF, 0x48, 0x00, 0x68, + 0x80, 0x6A, 0x70, 0x47, + 0xBD, 0x48, 0x00, 0x68, 0x41, 0x6A, 0x00, 0x6A, 0x70, 0x47, 0xBB, 0x48, + 0x00, 0x68, 0xD0, 0xF8, + 0x6A, 0x04, 0x70, 0x47, 0xB8, 0x48, 0x00, 0x68, 0xD0, 0xF8, 0x66, 0x14, + 0xD0, 0xF8, 0x62, 0x04, + 0x70, 0x47, 0xB5, 0x48, 0x00, 0x68, 0xD0, 0xF8, 0x38, 0x0A, 0x70, 0x47, + 0xB2, 0x48, 0x00, 0x68, + 0x00, 0xF5, 0x23, 0x60, 0x03, 0xC8, 0x70, 0x47, 0xF0, 0xB5, 0x00, 0x24, + 0x25, 0x46, 0xAF, 0x4E, + 0x4F, 0xF4, 0x00, 0x67, 0x14, 0xE0, 0x00, 0xBF, 0x30, 0xF8, 0x15, 0x30, + 0xC3, 0xF3, 0x0B, 0x03, + 0x5F, 0xEA, 0xD3, 0x2C, 0x00, 0xD0, 0x33, 0x43, 0x00, 0x2B, 0x00, 0xDA, + 0x5B, 0x42, 0x9C, 0x42, + 0x00, 0xDA, 0x9C, 0xB2, 0xBC, 0x42, 0x02, 0xD3, 0x40, 0xF2, 0xFF, 0x74, + 0x02, 0xE0, 0x6D, 0x1C, + 0x8D, 0x42, 0xE9, 0xDB, 0xD4, 0x40, 0x01, 0x20, 0xA0, 0x40, 0x80, 0xB2, + 0xF0, 0xBD, 0x30, 0xB5, + 0xA0, 0x4B, 0x9F, 0x4C, 0x5A, 0x68, 0x82, 0x42, 0x02, 0xD1, 0xDA, 0x68, + 0x8A, 0x42, 0x0A, 0xD0, + 0x00, 0x22, 0x06, 0xE0, 0x30, 0xF8, 0x12, 0x50, 0xC5, 0xF3, 0x0B, 0x05, + 0x24, 0xF8, 0x12, 0x50, + 0x52, 0x1C, 0x8A, 0x42, 0xF6, 0xDB, 0xD9, 0x60, 0x58, 0x60, 0x30, 0xBD, + 0x30, 0xB5, 0x95, 0x4B, + 0x95, 0x4C, 0x9A, 0x68, 0x82, 0x42, 0x02, 0xD1, 0x1A, 0x69, 0x8A, 0x42, + 0x0D, 0xD0, 0x00, 0x22, + 0x07, 0xE0, 0x00, 0xBF, 0x30, 0xF8, 0x12, 0x50, 0xC5, 0xF3, 0x0B, 0x05, + 0x24, 0xF8, 0x12, 0x50, + 0x52, 0x1C, 0x8A, 0x42, 0xF6, 0xDB, 0x19, 0x61, 0x98, 0x60, 0x30, 0xBD, + 0x70, 0xB5, 0x04, 0x46, + 0x8A, 0x48, 0x01, 0x68, 0x02, 0x29, 0x0A, 0xD1, 0x86, 0x4D, 0x29, 0x78, + 0x8C, 0x42, 0x06, 0xD0, + 0x00, 0xEB, 0x84, 0x00, 0xD0, 0xF8, 0x9C, 0x00, 0xE9, 0xF7, 0x3D, 0xFE, + 0x2C, 0x70, 0x70, 0xBD, + 0x10, 0xB5, 0x04, 0x46, 0x90, 0xF8, 0x28, 0x00, 0x80, 0x06, 0x1B, 0xD5, + 0x7A, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x70, 0x01, 0x80, 0x07, 0x01, 0xD5, 0x7D, 0x48, 0x0F, 0xE0, + 0x7D, 0x49, 0x08, 0x68, + 0x00, 0x28, 0x0F, 0xD1, 0xA0, 0x7C, 0x94, 0xF8, 0x27, 0x20, 0x80, 0x09, + 0xC0, 0xEB, 0xC0, 0x00, + 0x12, 0xF0, 0x01, 0x0F, 0x01, 0xEB, 0x00, 0x10, 0x05, 0xD0, 0x00, 0x1D, + 0xE9, 0xF7, 0x09, 0xFE, + 0xA4, 0xF8, 0x8C, 0x00, 0x10, 0xBD, 0x00, 0xF5, 0xAA, 0x70, 0xF7, 0xE7, + 0x70, 0xB5, 0x04, 0x46, + 0x90, 0xF8, 0x28, 0x00, 0x80, 0x06, 0x28, 0xD5, 0x67, 0x48, 0x00, 0x68, + 0x90, 0xF8, 0x88, 0x01, + 0xC0, 0x06, 0x08, 0xD5, 0x6A, 0x48, 0x28, 0x30, 0xE9, 0xF7, 0xF3, 0xFD, + 0x24, 0xF8, 0x8E, 0x0F, + 0x67, 0x48, 0x48, 0x30, 0x16, 0xE0, 0x67, 0x48, 0x01, 0x68, 0x00, 0x29, + 0x15, 0xD1, 0xA1, 0x7C, + 0x94, 0xF8, 0x27, 0x20, 0x89, 0x09, 0xC1, 0xEB, 0xC1, 0x01, 0x12, 0xF0, + 0x01, 0x0F, 0x00, 0xEB, + 0x01, 0x15, 0x0B, 0xD0, 0x05, 0xF1, 0x2C, 0x00, 0xE9, 0xF7, 0xDB, 0xFD, + 0x24, 0xF8, 0x8E, 0x0F, + 0x05, 0xF1, 0x4C, 0x00, 0xE9, 0xF7, 0xD5, 0xFD, 0x60, 0x80, 0x70, 0xBD, + 0x05, 0xF5, 0xBE, 0x70, + 0xE9, 0xF7, 0xCF, 0xFD, 0x24, 0xF8, 0x8E, 0x0F, 0x05, 0xF5, 0xCE, 0x70, + 0xF2, 0xE7, 0x70, 0xB5, + 0x04, 0x46, 0x90, 0xF8, 0x28, 0x00, 0x80, 0x06, 0x0B, 0xD5, 0x4B, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x88, 0x01, 0xC0, 0x06, 0x06, 0xD5, 0x4E, 0x48, 0x70, 0x30, 0xE9, 0xF7, + 0xBA, 0xFD, 0xA4, 0xF8, + 0x8E, 0x00, 0x70, 0xBD, 0x4B, 0x48, 0x01, 0x68, 0x00, 0x29, 0xFA, 0xD1, + 0xA1, 0x7C, 0x94, 0xF8, + 0x27, 0x20, 0x89, 0x09, 0xC1, 0xEB, 0xC1, 0x01, 0x12, 0xF0, 0x01, 0x0F, + 0x00, 0xEB, 0x01, 0x15, + 0x0C, 0xD0, 0x05, 0xF1, 0x2C, 0x00, 0xE9, 0xF7, 0xA4, 0xFD, 0x24, 0xF8, + 0x8E, 0x0F, 0x05, 0xF1, + 0x4C, 0x00, 0x00, 0xBF, 0xE9, 0xF7, 0x9D, 0xFD, 0x60, 0x80, 0x70, 0xBD, + 0x05, 0xF5, 0xBE, 0x70, + 0xE9, 0xF7, 0x97, 0xFD, 0x24, 0xF8, 0x8E, 0x0F, 0x05, 0xF5, 0xCE, 0x70, + 0xF2, 0xE7, 0x70, 0x47, + 0x70, 0x47, 0x70, 0x47, 0x02, 0x00, 0x4F, 0xF0, 0x00, 0x00, 0x00, 0xD1, + 0x08, 0x46, 0x70, 0x47, + 0x02, 0x46, 0x00, 0x20, 0x01, 0x2A, 0x00, 0xD1, 0x08, 0x46, 0x70, 0x47, + 0x2A, 0x49, 0x10, 0xB5, + 0x09, 0x68, 0x91, 0xF8, 0xB0, 0x10, 0xCA, 0x07, 0x08, 0xD0, 0x2A, 0x4C, + 0x62, 0x78, 0x01, 0x2A, + 0x05, 0xD0, 0x02, 0x21, 0xE9, 0xF7, 0xA3, 0xFD, 0x00, 0x20, 0x60, 0x70, + 0x10, 0xBD, 0xC1, 0xF3, + 0xC1, 0x01, 0xF7, 0xE7, 0x20, 0x49, 0x0A, 0x68, 0x92, 0xF8, 0xB0, 0x20, + 0x93, 0x09, 0x10, 0xF8, + 0x3E, 0x2B, 0x63, 0xF3, 0x82, 0x02, 0x00, 0xF8, 0x3E, 0x2C, 0x0B, 0x68, + 0x93, 0xF8, 0xB0, 0x30, + 0x5B, 0x09, 0x63, 0xF3, 0x45, 0x12, 0x00, 0xF8, 0x3E, 0x2C, 0x09, 0x68, + 0xB1, 0xF8, 0xB7, 0x20, + 0x02, 0x82, 0x91, 0xF8, 0xB6, 0x20, 0x83, 0x7F, 0x62, 0xF3, 0x07, 0x13, + 0x83, 0x77, 0x91, 0xF8, + 0xB3, 0x20, 0x13, 0x09, 0x02, 0x7D, 0x63, 0xF3, 0x06, 0x12, 0x02, 0x75, + 0x31, 0xF8, 0xB1, 0x3F, + 0x02, 0x8B, 0x63, 0xF3, 0x09, 0x02, 0x02, 0x83, 0x11, 0xF8, 0x01, 0x2C, + 0x93, 0x08, 0x82, 0x7D, + 0x63, 0xF3, 0x86, 0x12, 0x82, 0x75, 0x8A, 0x78, 0xC3, 0x7D, 0x62, 0xF3, + 0x03, 0x03, 0xC3, 0x75, + 0xB1, 0xF8, 0x03, 0x30, 0xB0, 0xF8, 0x1B, 0x20, 0x63, 0xF3, 0x08, 0x02, + 0xA0, 0xF8, 0x1B, 0x20, + 0x09, 0x89, 0x41, 0x82, 0x70, 0x47, 0x00, 0x00, 0x4C, 0x07, 0x10, 0x00, + 0x00, 0xF0, 0xFF, 0xFF, + 0x00, 0x9B, 0x01, 0x20, 0xF8, 0x07, 0x10, 0x00, 0x00, 0x9D, 0x01, 0x20, + 0xE8, 0x84, 0x10, 0x00, + 0xE4, 0x9F, 0x01, 0x20, 0x40, 0x9D, 0x01, 0x20, 0x00, 0x20, 0xFF, 0xF7, + 0x1E, 0xBE, 0x70, 0x47, + 0x10, 0xB5, 0xE9, 0xF7, 0x64, 0xFF, 0x08, 0xB1, 0x01, 0x20, 0x10, 0xBD, + 0x0B, 0x48, 0xE9, 0xF7, + 0x47, 0xFF, 0x00, 0x20, 0x10, 0xBD, 0x10, 0xB5, 0x04, 0x46, 0x09, 0x48, + 0x00, 0x68, 0x90, 0xF8, + 0x70, 0x00, 0x40, 0x07, 0x01, 0xD5, 0xE9, 0xF7, 0x47, 0xFF, 0x20, 0x7B, + 0x20, 0xB1, 0x05, 0x49, + 0xEA, 0xF7, 0x12, 0xFC, 0x00, 0x20, 0x10, 0xBD, 0x01, 0x20, 0x10, 0xBD, + 0x6B, 0x6A, 0x01, 0x00, + 0x4C, 0x07, 0x10, 0x00, 0x29, 0x6E, 0x01, 0x00, 0x43, 0x48, 0x01, 0x68, + 0x21, 0xF0, 0x04, 0x01, + 0x01, 0x60, 0x70, 0x47, 0x00, 0xB5, 0xFF, 0xF7, 0xF7, 0xFF, 0x00, 0xBD, + 0x00, 0xB5, 0xFF, 0xF7, + 0xF3, 0xFF, 0x00, 0xBD, 0x00, 0xB5, 0xFF, 0xF7, 0xEF, 0xFF, 0x00, 0xBD, + 0x10, 0xB5, 0xFF, 0xF7, + 0xEB, 0xFF, 0xBD, 0xE8, 0x10, 0x40, 0xEA, 0xF7, 0x32, 0xBB, 0x10, 0xB5, + 0xFF, 0xF7, 0xE4, 0xFF, + 0xBD, 0xE8, 0x10, 0x40, 0xE9, 0xF7, 0xF8, 0xBC, 0x10, 0xB5, 0xFF, 0xF7, + 0xDD, 0xFF, 0xBD, 0xE8, + 0x10, 0x40, 0xEA, 0xF7, 0x28, 0xBC, 0x10, 0xB5, 0xFF, 0xF7, 0xD6, 0xFF, + 0xBD, 0xE8, 0x10, 0x40, + 0xEA, 0xF7, 0x66, 0xBC, 0x10, 0xB5, 0xFF, 0xF7, 0xCF, 0xFF, 0xBD, 0xE8, + 0x10, 0x40, 0xEA, 0xF7, + 0x90, 0xBC, 0x10, 0xB5, 0xFF, 0xF7, 0xC8, 0xFF, 0xBD, 0xE8, 0x10, 0x40, + 0xEA, 0xF7, 0xBA, 0xBC, + 0x10, 0xB5, 0xFF, 0xF7, 0xC1, 0xFF, 0xBD, 0xE8, 0x10, 0x40, 0xEA, 0xF7, + 0xC8, 0xBC, 0x10, 0xB5, + 0xFF, 0xF7, 0xBA, 0xFF, 0xBD, 0xE8, 0x10, 0x40, 0xEA, 0xF7, 0xE6, 0xBC, + 0x10, 0xB5, 0xFF, 0xF7, + 0xB3, 0xFF, 0xBD, 0xE8, 0x10, 0x40, 0xEA, 0xF7, 0xEF, 0xBC, 0x10, 0xB5, + 0xFF, 0xF7, 0xAC, 0xFF, + 0xBD, 0xE8, 0x10, 0x40, 0x00, 0xF0, 0xF2, 0xB9, 0x10, 0xB5, 0xFF, 0xF7, + 0xA5, 0xFF, 0xBD, 0xE8, + 0x10, 0x40, 0x00, 0xF0, 0xC7, 0xB9, 0x00, 0xB5, 0xFF, 0xF7, 0x9E, 0xFF, + 0x00, 0xBD, 0x00, 0xB5, + 0xFF, 0xF7, 0x9A, 0xFF, 0x00, 0xBD, 0x00, 0xB5, 0xFF, 0xF7, 0x96, 0xFF, + 0x00, 0xBD, 0x10, 0xB5, + 0xFF, 0xF7, 0x92, 0xFF, 0xBD, 0xE8, 0x10, 0x40, 0xEA, 0xF7, 0xFE, 0xBC, + 0x00, 0xB5, 0xFF, 0xF7, + 0x8B, 0xFF, 0x00, 0xBD, 0x00, 0xB5, 0xFF, 0xF7, 0x87, 0xFF, 0x00, 0xBD, + 0x00, 0xB5, 0xFF, 0xF7, + 0x83, 0xFF, 0x00, 0xBD, 0x00, 0xB5, 0xFF, 0xF7, 0x7F, 0xFF, 0x00, 0xBD, + 0x00, 0xB5, 0xFF, 0xF7, + 0x7B, 0xFF, 0x00, 0xBD, 0x70, 0x47, 0x00, 0x00, 0x10, 0xED, 0x00, 0xE0, + 0x10, 0xB5, 0x4A, 0xF2, + 0x33, 0x20, 0xE9, 0xF7, 0xB4, 0xFF, 0xFC, 0xF7, 0x19, 0xF8, 0xFB, 0xF7, + 0x2D, 0xFE, 0xE9, 0xF7, + 0x33, 0xFA, 0x00, 0x21, 0x47, 0x20, 0xFB, 0xF7, 0x74, 0xFA, 0x01, 0x20, + 0x10, 0xBD, 0x53, 0xEA, + 0x02, 0x0C, 0x00, 0xF0, 0x69, 0x80, 0x2D, 0xE9, 0xF0, 0x4B, 0x4F, 0xF0, + 0x00, 0x06, 0x00, 0x2B, + 0x1F, 0xBF, 0xB3, 0xFA, 0x83, 0xF5, 0x03, 0xFA, 0x05, 0xF4, 0x24, 0xFA, + 0x05, 0xF6, 0x5E, 0x40, + 0x12, 0xBF, 0x16, 0x43, 0xB2, 0xFA, 0x82, 0xF5, 0x02, 0xFA, 0x05, 0xF4, + 0xC5, 0xF1, 0x20, 0x05, + 0x1E, 0xBF, 0x22, 0xFA, 0x05, 0xFC, 0x44, 0xEA, 0x0C, 0x04, 0x20, 0x35, + 0x56, 0xEA, 0x04, 0x4C, + 0x4F, 0xEA, 0x14, 0x44, 0x18, 0xBF, 0x64, 0x1C, 0x4F, 0xF0, 0x00, 0x08, + 0x4F, 0xF0, 0x00, 0x09, + 0x90, 0x42, 0x71, 0xEB, 0x03, 0x0C, 0x39, 0xD3, 0x00, 0x29, 0x19, 0xBF, + 0xB1, 0xFA, 0x81, 0xF7, + 0x01, 0xFA, 0x07, 0xF6, 0xB0, 0xFA, 0x80, 0xF7, 0x00, 0xFA, 0x07, 0xF6, + 0xC7, 0xF1, 0x20, 0x07, + 0x1E, 0xBF, 0x20, 0xFA, 0x07, 0xFC, 0x46, 0xEA, 0x0C, 0x06, 0x20, 0x37, + 0xB6, 0xFB, 0xF4, 0xFC, + 0xA7, 0xEB, 0x05, 0x07, 0x10, 0x3F, 0x07, 0xF0, 0x1F, 0x0B, 0xCB, 0xF1, + 0x20, 0x06, 0x0C, 0xFA, + 0x0B, 0xFB, 0x2C, 0xFA, 0x06, 0xF6, 0x44, 0xBF, 0xB3, 0x46, 0x00, 0x26, + 0x20, 0x2F, 0xA4, 0xBF, + 0x5E, 0x46, 0x4F, 0xF0, 0x00, 0x0B, 0x5B, 0xEA, 0x06, 0x0C, 0x08, 0xBF, + 0x4F, 0xF0, 0x01, 0x0B, + 0x19, 0xEB, 0x0B, 0x09, 0xAB, 0xFB, 0x02, 0x7C, 0x48, 0xEB, 0x06, 0x08, + 0xC0, 0x1B, 0x06, 0xFB, + 0x02, 0xCC, 0x0B, 0xFB, 0x03, 0xCC, 0x71, 0xEB, 0x0C, 0x01, 0xC1, 0xE7, + 0x0B, 0x46, 0x02, 0x46, + 0x41, 0x46, 0x48, 0x46, 0xBD, 0xE8, 0xF0, 0x8B, 0x13, 0xB5, 0x4F, 0xF0, + 0x00, 0x00, 0x4F, 0xF0, + 0x00, 0x01, 0xAF, 0xF3, 0x00, 0x80, 0xBD, 0xE8, 0x1C, 0x40, 0x70, 0x47, + 0xB2, 0xF1, 0x20, 0x03, + 0x0A, 0xD5, 0xC2, 0xF1, 0x20, 0x03, 0x01, 0xFA, 0x02, 0xF1, 0x20, 0xFA, + 0x03, 0xF3, 0x00, 0xFA, + 0x02, 0xF0, 0x41, 0xEA, 0x03, 0x01, 0x70, 0x47, 0x00, 0xFA, 0x03, 0xF1, + 0x4F, 0xF0, 0x00, 0x00, + 0x70, 0x47, 0x10, 0xB5, 0x4C, 0x10, 0x84, 0xEA, 0x53, 0x04, 0x04, 0xD5, + 0x40, 0x42, 0xC1, 0xF1, + 0x00, 0x01, 0x38, 0xBF, 0x49, 0x1E, 0x1B, 0x42, 0x04, 0xD5, 0x52, 0x42, + 0xC3, 0xF1, 0x00, 0x03, + 0x38, 0xBF, 0x5B, 0x1E, 0xFF, 0xF7, 0x63, 0xFF, 0x14, 0xF0, 0x80, 0x4F, + 0x04, 0xD0, 0x40, 0x42, + 0xC1, 0xF1, 0x00, 0x01, 0x38, 0xBF, 0x49, 0x1E, 0x14, 0xF0, 0x00, 0x4F, + 0x04, 0xD0, 0x52, 0x42, + 0xC3, 0xF1, 0x00, 0x03, 0x38, 0xBF, 0x5B, 0x1E, 0x10, 0xBD, 0x03, 0x2A, + 0x40, 0xF2, 0x30, 0x80, + 0x10, 0xF0, 0x03, 0x0C, 0x00, 0xF0, 0x15, 0x80, 0x11, 0xF8, 0x01, 0x3B, + 0xBC, 0xF1, 0x02, 0x0F, + 0x62, 0x44, 0x98, 0xBF, 0x11, 0xF8, 0x01, 0xCB, 0x00, 0xF8, 0x01, 0x3B, + 0x38, 0xBF, 0x11, 0xF8, + 0x01, 0x3B, 0xA2, 0xF1, 0x04, 0x02, 0x98, 0xBF, 0x00, 0xF8, 0x01, 0xCB, + 0x38, 0xBF, 0x00, 0xF8, + 0x01, 0x3B, 0x11, 0xF0, 0x03, 0x03, 0x00, 0xF0, 0x25, 0x80, 0x08, 0x3A, + 0xC0, 0xF0, 0x08, 0x80, + 0x51, 0xF8, 0x04, 0x3B, 0x08, 0x3A, 0x51, 0xF8, 0x04, 0xCB, 0xA0, 0xE8, + 0x08, 0x10, 0xF5, 0xE7, + 0x12, 0x1D, 0x5C, 0xBF, 0x51, 0xF8, 0x04, 0x3B, 0x40, 0xF8, 0x04, 0x3B, + 0xAF, 0xF3, 0x00, 0x80, + 0xD2, 0x07, 0x24, 0xBF, 0x11, 0xF8, 0x01, 0x3B, 0x11, 0xF8, 0x01, 0xCB, + 0x48, 0xBF, 0x11, 0xF8, + 0x01, 0x2B, 0x24, 0xBF, 0x00, 0xF8, 0x01, 0x3B, 0x00, 0xF8, 0x01, 0xCB, + 0x48, 0xBF, 0x00, 0xF8, + 0x01, 0x2B, 0x70, 0x47, 0x10, 0xB5, 0x20, 0x3A, 0xC0, 0xF0, 0x0B, 0x80, + 0xB1, 0xE8, 0x18, 0x50, + 0x20, 0x3A, 0xA0, 0xE8, 0x18, 0x50, 0xB1, 0xE8, 0x18, 0x50, 0xA0, 0xE8, + 0x18, 0x50, 0xBF, 0xF4, + 0xF5, 0xAF, 0x5F, 0xEA, 0x02, 0x7C, 0x24, 0xBF, 0xB1, 0xE8, 0x18, 0x50, + 0xA0, 0xE8, 0x18, 0x50, + 0x44, 0xBF, 0x18, 0xC9, 0x18, 0xC0, 0xBD, 0xE8, 0x10, 0x40, 0x5F, 0xEA, + 0x82, 0x7C, 0x24, 0xBF, + 0x51, 0xF8, 0x04, 0x3B, 0x40, 0xF8, 0x04, 0x3B, 0x08, 0xBF, 0x70, 0x47, + 0xD2, 0x07, 0x28, 0xBF, + 0x31, 0xF8, 0x02, 0x3B, 0x48, 0xBF, 0x11, 0xF8, 0x01, 0x2B, 0x28, 0xBF, + 0x20, 0xF8, 0x02, 0x3B, + 0x48, 0xBF, 0x00, 0xF8, 0x01, 0x2B, 0x70, 0x47, 0x02, 0xF0, 0xFF, 0x03, + 0x43, 0xEA, 0x03, 0x22, + 0x42, 0xEA, 0x02, 0x42, 0x00, 0xF0, 0x02, 0xB8, 0x4F, 0xF0, 0x00, 0x02, + 0x04, 0x29, 0xC0, 0xF0, + 0x12, 0x80, 0x10, 0xF0, 0x03, 0x0C, 0x00, 0xF0, 0x1B, 0x80, 0xCC, 0xF1, + 0x04, 0x0C, 0xBC, 0xF1, + 0x02, 0x0F, 0x18, 0xBF, 0x00, 0xF8, 0x01, 0x2B, 0xA8, 0xBF, 0x20, 0xF8, + 0x02, 0x2B, 0xA1, 0xEB, + 0x0C, 0x01, 0x00, 0xF0, 0x0D, 0xB8, 0x5F, 0xEA, 0xC1, 0x7C, 0x24, 0xBF, + 0x00, 0xF8, 0x01, 0x2B, + 0x00, 0xF8, 0x01, 0x2B, 0x48, 0xBF, 0x00, 0xF8, 0x01, 0x2B, 0x70, 0x47, + 0x4F, 0xF0, 0x00, 0x02, + 0x00, 0xB5, 0x13, 0x46, 0x94, 0x46, 0x96, 0x46, 0x20, 0x39, 0x22, 0xBF, + 0xA0, 0xE8, 0x0C, 0x50, + 0xA0, 0xE8, 0x0C, 0x50, 0xB1, 0xF1, 0x20, 0x01, 0xBF, 0xF4, 0xF7, 0xAF, + 0x09, 0x07, 0x28, 0xBF, + 0xA0, 0xE8, 0x0C, 0x50, 0x48, 0xBF, 0x0C, 0xC0, 0x5D, 0xF8, 0x04, 0xEB, + 0x89, 0x00, 0x28, 0xBF, + 0x40, 0xF8, 0x04, 0x2B, 0x08, 0xBF, 0x70, 0x47, 0x48, 0xBF, 0x20, 0xF8, + 0x02, 0x2B, 0x11, 0xF0, + 0x80, 0x4F, 0x18, 0xBF, 0x00, 0xF8, 0x01, 0x2B, 0x70, 0x47, 0x04, 0x46, + 0xAF, 0xF3, 0x00, 0x80, + 0x20, 0x46, 0xE8, 0xF7, 0x93, 0xFF, 0x00, 0x00, 0x01, 0x49, 0x18, 0x20, + 0xAB, 0xBE, 0xFE, 0xE7, + 0x26, 0x00, 0x02, 0x00, 0x70, 0x47, 0x00, 0x00, 0x01, 0x49, 0x00, 0x20, + 0x08, 0x60, 0x70, 0x47, + 0x3C, 0x05, 0x00, 0x22, 0x2D, 0xE9, 0xF0, 0x41, 0x00, 0x24, 0x01, 0x27, + 0xDF, 0xF8, 0x38, 0x80, + 0x5F, 0xEA, 0x47, 0x75, 0x07, 0xFA, 0x04, 0xF0, 0xC6, 0xB2, 0x95, 0xF8, + 0x2F, 0x00, 0x30, 0x42, + 0x0C, 0xD0, 0x95, 0xF8, 0x39, 0x00, 0x30, 0x42, 0x08, 0xD0, 0x58, 0xF8, + 0x24, 0x00, 0x00, 0xB1, + 0x80, 0x47, 0x95, 0xF8, 0x2F, 0x00, 0xB0, 0x43, 0x85, 0xF8, 0x2F, 0x00, + 0x64, 0x1C, 0x06, 0x2C, + 0xE8, 0xDB, 0xBD, 0xE8, 0xF0, 0x81, 0x00, 0x00, 0xD4, 0x0E, 0x10, 0x00, + 0x2D, 0xE9, 0xF0, 0x41, + 0x00, 0x24, 0x01, 0x27, 0xDF, 0xF8, 0x38, 0x80, 0x5F, 0xEA, 0x47, 0x75, + 0x07, 0xFA, 0x04, 0xF0, + 0xC6, 0xB2, 0x95, 0xF8, 0x2E, 0x00, 0x30, 0x42, 0x0C, 0xD0, 0x95, 0xF8, + 0x38, 0x00, 0x30, 0x42, + 0x08, 0xD0, 0x58, 0xF8, 0x24, 0x00, 0x00, 0xB1, 0x80, 0x47, 0x95, 0xF8, + 0x2E, 0x00, 0xB0, 0x43, + 0x85, 0xF8, 0x2E, 0x00, 0x64, 0x1C, 0x06, 0x2C, 0xE8, 0xDB, 0xBD, 0xE8, + 0xF0, 0x81, 0x00, 0x00, + 0xB4, 0x0E, 0x10, 0x00, 0x01, 0x21, 0x81, 0x40, 0xC8, 0xB2, 0x4F, 0xF0, + 0x00, 0x51, 0x91, 0xF8, + 0x33, 0x10, 0x01, 0x42, 0x01, 0xD0, 0x01, 0x20, 0x70, 0x47, 0x00, 0x20, + 0x70, 0x47, 0x00, 0x00, + 0x01, 0x49, 0x01, 0x20, 0x08, 0x60, 0x70, 0x47, 0x3C, 0x05, 0x00, 0x22, + 0x07, 0x48, 0x41, 0x78, + 0x49, 0xB1, 0x80, 0x78, 0x38, 0xB1, 0x06, 0x48, 0x00, 0x78, 0x01, 0x28, + 0x03, 0xD1, 0x05, 0x48, + 0x00, 0x78, 0x01, 0x28, 0x00, 0xD0, 0x00, 0x20, 0x70, 0x47, 0x00, 0x00, + 0x74, 0x07, 0x10, 0x00, + 0xFD, 0x06, 0x10, 0x00, 0x5C, 0x05, 0x10, 0x00, 0x03, 0x48, 0x41, 0x78, + 0x11, 0xB9, 0x80, 0x78, + 0x00, 0x28, 0x00, 0xD0, 0x01, 0x20, 0x70, 0x47, 0x74, 0x07, 0x10, 0x00, + 0x01, 0x48, 0x00, 0x78, + 0x70, 0x47, 0x00, 0x00, 0x74, 0x06, 0x10, 0x00, 0xC0, 0x6E, 0x70, 0x47, + 0x90, 0xF8, 0x73, 0x00, + 0x70, 0x47, 0x90, 0xF8, 0x72, 0x00, 0x70, 0x47, 0x04, 0x48, 0x41, 0x78, + 0x82, 0x78, 0x00, 0x78, + 0x11, 0x44, 0x08, 0x18, 0x00, 0xD0, 0x01, 0x20, 0x70, 0x47, 0x00, 0x00, + 0x2D, 0x06, 0x10, 0x00, + 0x70, 0xB5, 0xD0, 0xE9, 0x00, 0x21, 0x4C, 0x08, 0x4F, 0xEA, 0x32, 0x03, + 0x96, 0x18, 0x41, 0xEB, + 0x01, 0x05, 0x33, 0x43, 0x2C, 0x43, 0x13, 0x43, 0x0C, 0x43, 0xC0, 0xE9, + 0x00, 0x34, 0x70, 0xBD, + 0x01, 0xEB, 0x81, 0x01, 0x00, 0xEB, 0xC1, 0x00, 0x29, 0x30, 0x70, 0x47, + 0x02, 0x4A, 0x12, 0x78, + 0x51, 0x43, 0x00, 0xEB, 0x41, 0x00, 0x70, 0x47, 0xEE, 0x06, 0x10, 0x00, + 0x01, 0xEB, 0x81, 0x01, + 0x00, 0xEB, 0xC1, 0x00, 0x29, 0x30, 0x70, 0x47, 0x02, 0x4A, 0x12, 0x78, + 0x51, 0x43, 0x00, 0xEB, + 0x41, 0x00, 0x70, 0x47, 0xEE, 0x06, 0x10, 0x00, 0x00, 0x04, 0x40, 0x00, + 0x10, 0x21, 0x00, 0x00, + 0x00, 0x1F, 0x01, 0x00, 0x06, 0x00, 0x00, 0x00, 0x30, 0x00, 0x01, 0x00, + 0x00, 0x04, 0x06, 0x00, + 0x08, 0x02, 0x50, 0x00, 0x60, 0x02, 0x0C, 0x0C, 0x00, 0x00, 0x60, 0x02, + 0x0C, 0x30, 0x0C, 0x1A, + 0x31, 0x10, 0x0F, 0x0F, 0x00, 0x00, 0x2F, 0x00, 0x01, 0x00, 0xAA, 0x2C, + 0x01, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x60, 0x02, 0x01, 0x80, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x0C, 0x00, + 0x0C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x07, 0x01, 0x26, 0x26, 0x12, 0x12, + 0x11, 0x00, 0x00, 0x00, + 0x00, 0x38, 0x00, 0x3C, 0x20, 0x3D, 0xD0, 0x41, 0xEC, 0x41, 0x08, 0x42, + 0x1C, 0x42, 0x30, 0x42, + 0x44, 0x42, 0x60, 0x42, 0x74, 0x42, 0x88, 0x42, 0xA4, 0x42, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, + 0x00, 0x01, 0x01, 0x02, + 0x01, 0x02, 0x02, 0x03, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x04, + 0x00, 0x00, 0x00, 0x00, + 0x1B, 0x00, 0x00, 0x80, 0x2D, 0x00, 0x00, 0x80, 0x36, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x00, 0x80, + 0x5A, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x80, + 0x99, 0x00, 0x00, 0x80, + 0x82, 0x00, 0x00, 0x00, 0xB4, 0x00, 0x00, 0x00, 0xAF, 0x00, 0x00, 0x80, + 0xD8, 0x00, 0x00, 0x00, + 0xC3, 0x00, 0x00, 0x80, 0xF5, 0x00, 0x00, 0x80, 0xEE, 0x00, 0x00, 0x00, + 0x29, 0x01, 0x00, 0x80, + 0x32, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x80, + 0x68, 0x01, 0x00, 0x00, + 0x73, 0x01, 0x00, 0x80, 0x45, 0x01, 0x00, 0x80, 0x5E, 0x01, 0x00, 0x00, + 0xB0, 0x01, 0x00, 0x00, + 0xAB, 0x01, 0x00, 0x80, 0x9D, 0x01, 0x00, 0x80, 0x86, 0x01, 0x00, 0x00, + 0xF1, 0x01, 0x00, 0x80, + 0xEA, 0x01, 0x00, 0x00, 0xDC, 0x01, 0x00, 0x00, 0xC7, 0x01, 0x00, 0x80, + 0x49, 0x02, 0x00, 0x80, + 0x52, 0x02, 0x00, 0x00, 0x64, 0x02, 0x00, 0x00, 0x7F, 0x02, 0x00, 0x80, + 0x08, 0x02, 0x00, 0x00, + 0x13, 0x02, 0x00, 0x80, 0x25, 0x02, 0x00, 0x80, 0x3E, 0x02, 0x00, 0x00, + 0xD0, 0x02, 0x00, 0x00, + 0xCB, 0x02, 0x00, 0x80, 0xFD, 0x02, 0x00, 0x80, 0xE6, 0x02, 0x00, 0x00, + 0x91, 0x02, 0x00, 0x80, + 0x8A, 0x02, 0x00, 0x00, 0xBC, 0x02, 0x00, 0x00, 0xA7, 0x02, 0x00, 0x80, + 0x60, 0x03, 0x00, 0x00, + 0x7B, 0x03, 0x00, 0x80, 0x4D, 0x03, 0x00, 0x80, 0x56, 0x03, 0x00, 0x00, + 0x21, 0x03, 0x00, 0x80, + 0x3A, 0x03, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x17, 0x03, 0x00, 0x80, + 0xF9, 0x03, 0x00, 0x80, + 0xE2, 0x03, 0x00, 0x00, 0xD4, 0x03, 0x00, 0x00, 0xCF, 0x03, 0x00, 0x80, + 0xB8, 0x03, 0x00, 0x00, + 0xA3, 0x03, 0x00, 0x80, 0x95, 0x03, 0x00, 0x80, 0x8E, 0x03, 0x00, 0x00, + 0x89, 0x04, 0x00, 0x80, + 0x92, 0x04, 0x00, 0x00, 0xA4, 0x04, 0x00, 0x00, 0xBF, 0x04, 0x00, 0x80, + 0xC8, 0x04, 0x00, 0x00, + 0xD3, 0x04, 0x00, 0x80, 0xE5, 0x04, 0x00, 0x80, 0xFE, 0x04, 0x00, 0x00, + 0x10, 0x04, 0x00, 0x00, + 0x0B, 0x04, 0x00, 0x80, 0x3D, 0x04, 0x00, 0x80, 0x26, 0x04, 0x00, 0x00, + 0x51, 0x04, 0x00, 0x80, + 0x4A, 0x04, 0x00, 0x00, 0x7C, 0x04, 0x00, 0x00, 0x67, 0x04, 0x00, 0x80, + 0xA0, 0x05, 0x00, 0x00, + 0xBB, 0x05, 0x00, 0x80, 0x8D, 0x05, 0x00, 0x80, 0x96, 0x05, 0x00, 0x00, + 0xE1, 0x05, 0x00, 0x80, + 0xFA, 0x05, 0x00, 0x00, 0xCC, 0x05, 0x00, 0x00, 0xD7, 0x05, 0x00, 0x80, + 0x39, 0x05, 0x00, 0x80, + 0x22, 0x05, 0x00, 0x00, 0x14, 0x05, 0x00, 0x00, 0x0F, 0x05, 0x00, 0x80, + 0x78, 0x05, 0x00, 0x00, + 0x63, 0x05, 0x00, 0x80, 0x55, 0x05, 0x00, 0x80, 0x4E, 0x05, 0x00, 0x00, + 0xC0, 0x06, 0x00, 0x00, + 0xDB, 0x06, 0x00, 0x80, 0xED, 0x06, 0x00, 0x80, 0xF6, 0x06, 0x00, 0x00, + 0x81, 0x06, 0x00, 0x80, + 0x9A, 0x06, 0x00, 0x00, 0xAC, 0x06, 0x00, 0x00, 0xB7, 0x06, 0x00, 0x80, + 0x59, 0x06, 0x00, 0x80, + 0x42, 0x06, 0x00, 0x00, 0x74, 0x06, 0x00, 0x00, 0x6F, 0x06, 0x00, 0x80, + 0x18, 0x06, 0x00, 0x00, + 0x03, 0x06, 0x00, 0x80, 0x35, 0x06, 0x00, 0x80, 0x2E, 0x06, 0x00, 0x00, + 0xE9, 0x07, 0x00, 0x80, + 0xF2, 0x07, 0x00, 0x00, 0xC4, 0x07, 0x00, 0x00, 0xDF, 0x07, 0x00, 0x80, + 0xA8, 0x07, 0x00, 0x00, + 0xB3, 0x07, 0x00, 0x80, 0x85, 0x07, 0x00, 0x80, 0x9E, 0x07, 0x00, 0x00, + 0x70, 0x07, 0x00, 0x00, + 0x6B, 0x07, 0x00, 0x80, 0x5D, 0x07, 0x00, 0x80, 0x46, 0x07, 0x00, 0x00, + 0x31, 0x07, 0x00, 0x80, + 0x2A, 0x07, 0x00, 0x00, 0x1C, 0x07, 0x00, 0x00, 0x07, 0x07, 0x00, 0x80, + 0x09, 0x09, 0x00, 0x80, + 0x12, 0x09, 0x00, 0x00, 0x24, 0x09, 0x00, 0x00, 0x3F, 0x09, 0x00, 0x80, + 0x48, 0x09, 0x00, 0x00, + 0x53, 0x09, 0x00, 0x80, 0x65, 0x09, 0x00, 0x80, 0x7E, 0x09, 0x00, 0x00, + 0x90, 0x09, 0x00, 0x00, + 0x8B, 0x09, 0x00, 0x80, 0xBD, 0x09, 0x00, 0x80, 0xA6, 0x09, 0x00, 0x00, + 0xD1, 0x09, 0x00, 0x80, + 0xCA, 0x09, 0x00, 0x00, 0xFC, 0x09, 0x00, 0x00, 0xE7, 0x09, 0x00, 0x80, + 0x20, 0x08, 0x00, 0x00, + 0x3B, 0x08, 0x00, 0x80, 0x0D, 0x08, 0x00, 0x80, 0x16, 0x08, 0x00, 0x00, + 0x61, 0x08, 0x00, 0x80, + 0x7A, 0x08, 0x00, 0x00, 0x4C, 0x08, 0x00, 0x00, 0x57, 0x08, 0x00, 0x80, + 0xB9, 0x08, 0x00, 0x80, + 0xA2, 0x08, 0x00, 0x00, 0x94, 0x08, 0x00, 0x00, 0x8F, 0x08, 0x00, 0x80, + 0xF8, 0x08, 0x00, 0x00, + 0xE3, 0x08, 0x00, 0x80, 0xD5, 0x08, 0x00, 0x80, 0xCE, 0x08, 0x00, 0x00, + 0x40, 0x0B, 0x00, 0x00, + 0x5B, 0x0B, 0x00, 0x80, 0x6D, 0x0B, 0x00, 0x80, 0x76, 0x0B, 0x00, 0x00, + 0x01, 0x0B, 0x00, 0x80, + 0x1A, 0x0B, 0x00, 0x00, 0x2C, 0x0B, 0x00, 0x00, 0x37, 0x0B, 0x00, 0x80, + 0xD9, 0x0B, 0x00, 0x80, + 0xC2, 0x0B, 0x00, 0x00, 0xF4, 0x0B, 0x00, 0x00, 0xEF, 0x0B, 0x00, 0x80, + 0x98, 0x0B, 0x00, 0x00, + 0x83, 0x0B, 0x00, 0x80, 0xB5, 0x0B, 0x00, 0x80, 0xAE, 0x0B, 0x00, 0x00, + 0x69, 0x0A, 0x00, 0x80, + 0x72, 0x0A, 0x00, 0x00, 0x44, 0x0A, 0x00, 0x00, 0x5F, 0x0A, 0x00, 0x80, + 0x28, 0x0A, 0x00, 0x00, + 0x33, 0x0A, 0x00, 0x80, 0x05, 0x0A, 0x00, 0x80, 0x1E, 0x0A, 0x00, 0x00, + 0xF0, 0x0A, 0x00, 0x00, + 0xEB, 0x0A, 0x00, 0x80, 0xDD, 0x0A, 0x00, 0x80, 0xC6, 0x0A, 0x00, 0x00, + 0xB1, 0x0A, 0x00, 0x80, + 0xAA, 0x0A, 0x00, 0x00, 0x9C, 0x0A, 0x00, 0x00, 0x87, 0x0A, 0x00, 0x80, + 0x80, 0x0D, 0x00, 0x00, + 0x9B, 0x0D, 0x00, 0x80, 0xAD, 0x0D, 0x00, 0x80, 0xB6, 0x0D, 0x00, 0x00, + 0xC1, 0x0D, 0x00, 0x80, + 0xDA, 0x0D, 0x00, 0x00, 0xEC, 0x0D, 0x00, 0x00, 0xF7, 0x0D, 0x00, 0x80, + 0x19, 0x0D, 0x00, 0x80, + 0x02, 0x0D, 0x00, 0x00, 0x34, 0x0D, 0x00, 0x00, 0x2F, 0x0D, 0x00, 0x80, + 0x58, 0x0D, 0x00, 0x00, + 0x43, 0x0D, 0x00, 0x80, 0x75, 0x0D, 0x00, 0x80, 0x6E, 0x0D, 0x00, 0x00, + 0xA9, 0x0C, 0x00, 0x80, + 0xB2, 0x0C, 0x00, 0x00, 0x84, 0x0C, 0x00, 0x00, 0x9F, 0x0C, 0x00, 0x80, + 0xE8, 0x0C, 0x00, 0x00, + 0xF3, 0x0C, 0x00, 0x80, 0xC5, 0x0C, 0x00, 0x80, 0xDE, 0x0C, 0x00, 0x00, + 0x30, 0x0C, 0x00, 0x00, + 0x2B, 0x0C, 0x00, 0x80, 0x1D, 0x0C, 0x00, 0x80, 0x06, 0x0C, 0x00, 0x00, + 0x71, 0x0C, 0x00, 0x80, + 0x6A, 0x0C, 0x00, 0x00, 0x5C, 0x0C, 0x00, 0x00, 0x47, 0x0C, 0x00, 0x80, + 0xC9, 0x0F, 0x00, 0x80, + 0xD2, 0x0F, 0x00, 0x00, 0xE4, 0x0F, 0x00, 0x00, 0xFF, 0x0F, 0x00, 0x80, + 0x88, 0x0F, 0x00, 0x00, + 0x93, 0x0F, 0x00, 0x80, 0xA5, 0x0F, 0x00, 0x80, 0xBE, 0x0F, 0x00, 0x00, + 0x50, 0x0F, 0x00, 0x00, + 0x4B, 0x0F, 0x00, 0x80, 0x7D, 0x0F, 0x00, 0x80, 0x66, 0x0F, 0x00, 0x00, + 0x11, 0x0F, 0x00, 0x80, + 0x0A, 0x0F, 0x00, 0x00, 0x3C, 0x0F, 0x00, 0x00, 0x27, 0x0F, 0x00, 0x80, + 0xE0, 0x0E, 0x00, 0x00, + 0xFB, 0x0E, 0x00, 0x80, 0xCD, 0x0E, 0x00, 0x80, 0xD6, 0x0E, 0x00, 0x00, + 0xA1, 0x0E, 0x00, 0x80, + 0xBA, 0x0E, 0x00, 0x00, 0x8C, 0x0E, 0x00, 0x00, 0x97, 0x0E, 0x00, 0x80, + 0x79, 0x0E, 0x00, 0x80, + 0x62, 0x0E, 0x00, 0x00, 0x54, 0x0E, 0x00, 0x00, 0x4F, 0x0E, 0x00, 0x80, + 0x38, 0x0E, 0x00, 0x00, + 0x23, 0x0E, 0x00, 0x80, 0x15, 0x0E, 0x00, 0x80, 0x0E, 0x0E, 0x00, 0x00, + 0xFF, 0x00, 0xBE, 0x94, + 0xFE, 0xFF, 0x27, 0xC4, 0xFE, 0xFF, 0x59, 0xF2, 0xFE, 0xFF, 0x6B, 0x1F, + 0xFF, 0xFF, 0x81, 0x4B, + 0xFF, 0xFF, 0xC5, 0x76, 0xFF, 0xFF, 0x67, 0xA1, 0xFF, 0xFF, 0x97, 0xCB, + 0xFF, 0xFF, 0x88, 0xF5, + 0xFF, 0xFF, 0x6C, 0x1F, 0x00, 0x00, 0x76, 0x49, 0x00, 0x00, 0xD9, 0x73, + 0x00, 0x00, 0xC6, 0x9E, + 0x00, 0x00, 0x6D, 0xCA, 0x00, 0x00, 0xFC, 0xF6, 0x00, 0x00, 0x9A, 0x24, + 0x01, 0x00, 0x66, 0x53, + 0x01, 0x00, 0xA3, 0x8D, 0x00, 0x00, 0x71, 0x74, 0x00, 0x00, 0x02, 0x60, + 0x00, 0x00, 0xA2, 0x4F, + 0x00, 0x00, 0xC8, 0x42, 0x00, 0x00, 0x0C, 0x39, 0x00, 0x00, 0x21, 0x32, + 0x00, 0x00, 0xD2, 0x2D, + 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x9B, 0x2C, 0x00, 0x00, 0xA9, 0x2F, + 0x00, 0x00, 0x40, 0x35, + 0x00, 0x00, 0x8B, 0x3D, 0x00, 0x00, 0xCB, 0x48, 0x00, 0x00, 0x59, 0x57, + 0x00, 0x00, 0xAD, 0x69, + 0x00, 0x00, 0x65, 0x80, 0x00, 0x00, 0x30, 0x11, 0x00, 0x00, 0x4C, 0x1C, + 0x00, 0x00, 0x2D, 0x29, + 0x00, 0x00, 0x86, 0x37, 0x00, 0x00, 0x24, 0x47, 0x00, 0x00, 0xE8, 0x57, + 0x00, 0x00, 0xC4, 0x69, + 0x00, 0x00, 0xB5, 0x7C, 0x00, 0x00, 0xC4, 0x90, 0x00, 0x00, 0x03, 0xA6, + 0x00, 0x00, 0x8F, 0xBC, + 0x00, 0x00, 0x8C, 0xD4, 0x00, 0x00, 0x29, 0xEE, 0x00, 0x00, 0x9C, 0x09, + 0x01, 0x00, 0x2B, 0x27, + 0x01, 0x00, 0x24, 0x47, 0x01, 0x00, 0xE6, 0x69, 0x01, 0x00, 0x98, 0x08, + 0x00, 0x00, 0x26, 0x0E, + 0x00, 0x00, 0x97, 0x14, 0x00, 0x00, 0xC3, 0x1B, 0x00, 0x00, 0x92, 0x23, + 0x00, 0x00, 0xF4, 0x2B, + 0x00, 0x00, 0xE2, 0x34, 0x00, 0x00, 0x5A, 0x3E, 0x00, 0x00, 0x62, 0x48, + 0x00, 0x00, 0x02, 0x53, + 0x00, 0x00, 0x48, 0x5E, 0x00, 0x00, 0x46, 0x6A, 0x00, 0x00, 0x14, 0x77, + 0x00, 0x00, 0xCE, 0x84, + 0x00, 0x00, 0x95, 0x93, 0x00, 0x00, 0x92, 0xA3, 0x00, 0x00, 0xF3, 0xB4, + 0x00, 0x00, 0x01, 0x00, + 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x00, + 0x02, 0x00, 0x01, 0x00, + 0x10, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x14, 0x00, + 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0x0C, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0xF8, 0x47, 0x10, 0x00, 0x44, 0x4D, 0x10, 0x00, 0xC5, 0x18, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0xC3, 0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0x17, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0xDF, 0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE3, 0x17, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x09, 0x18, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x6B, 0x18, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x81, 0x18, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xB5, 0x18, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0xB7, 0x18, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xB9, 0x18, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0xBB, 0x18, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0xBD, 0x18, 0x01, 0x00, + 0x02, 0x00, 0x00, 0x00, + 0xBF, 0x18, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xC1, 0x18, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0xC3, 0x18, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x01, 0x00, + 0xFB, 0x18, 0x01, 0x00, + 0x65, 0x19, 0x01, 0x00, 0xFB, 0x18, 0x01, 0x00, 0x17, 0x1A, 0x01, 0x00, + 0xFB, 0x18, 0x01, 0x00, + 0xFB, 0x18, 0x01, 0x00, 0xFB, 0x18, 0x01, 0x00, 0xFB, 0x18, 0x01, 0x00, + 0xFB, 0x18, 0x01, 0x00, + 0x2F, 0x19, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xFB, 0x18, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x61, 0x19, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x91, 0x19, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0xB5, 0x19, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0xD9, 0x19, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x0F, 0x1A, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x1A, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x43, 0x1A, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x91, 0x1A, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0xA7, 0x1A, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0xFF, 0x1A, 0x01, 0x00, + 0x02, 0x00, 0x00, 0x00, + 0xB5, 0x1B, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x33, 0x1C, 0x01, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x73, 0x1C, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x65, 0x1B, 0x01, 0x00, + 0x02, 0x00, 0x00, 0x00, + 0xFB, 0x18, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFB, 0x18, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x5D, 0x1A, 0x01, 0x00, 0x67, 0x1A, 0x01, 0x00, 0x71, 0x1A, 0x01, 0x00, + 0x81, 0x1A, 0x01, 0x00, + 0xF5, 0x1D, 0x01, 0x00, 0x17, 0x1E, 0x01, 0x00, 0x1F, 0x1E, 0x01, 0x00, + 0x3F, 0x1E, 0x01, 0x00, + 0xA1, 0x1E, 0x01, 0x00, 0xB7, 0x1E, 0x01, 0x00, 0xC7, 0x1E, 0x01, 0x00, + 0xD9, 0x1E, 0x01, 0x00, + 0xEB, 0x1E, 0x01, 0x00, 0xFD, 0x1E, 0x01, 0x00, 0x0F, 0x1F, 0x01, 0x00, + 0x21, 0x1F, 0x01, 0x00, + 0x33, 0x1F, 0x01, 0x00, 0x45, 0x1F, 0x01, 0x00, 0x57, 0x1F, 0x01, 0x00, + 0x69, 0x1F, 0x01, 0x00, + 0x85, 0x86, 0x60, 0x61, 0xD0, 0x02, 0x0F, 0x01, 0x00, 0xA6, 0x02, 0x0F, + 0x01, 0x00, 0xA8, 0x02, + 0x0B, 0x03, 0x00, 0x72, 0x00, 0x0B, 0x01, 0x00, 0x73, 0x00, 0x08, 0x01, + 0x00, 0x00, 0x00, 0x00, + 0x49, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF3, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0xE3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, + 0x04, 0x69, 0x10, 0x00, 0x00, 0x04, 0x00, 0x00, 0xB5, 0x4E, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x04, 0x6D, 0x10, 0x00, + 0x00, 0x04, 0x00, 0x00, 0xDD, 0x5E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x71, 0x10, 0x00, + 0x00, 0x08, 0x00, 0x00, + 0x8F, 0x15, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x04, 0x79, 0x10, 0x00, 0x00, 0x02, 0x00, 0x00, + 0x01, 0x1D, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x04, 0x7B, 0x10, 0x00, 0x80, 0x00, 0x00, 0x00, 0xB9, 0x16, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0xB1, 0x56, 0x01, 0x00, 0x5B, 0x56, 0x01, 0x00, + 0x31, 0x6E, 0x01, 0x00, + 0x23, 0x5B, 0x01, 0x00, 0x65, 0x48, 0x01, 0x00, 0x9B, 0x5D, 0x01, 0x00, + 0x8F, 0x4D, 0x01, 0x00, + 0x73, 0x68, 0x01, 0x00, 0xF1, 0x4E, 0x01, 0x00, 0x4D, 0x57, 0x01, 0x00, + 0x47, 0x6E, 0x01, 0x00, + 0x60, 0x7D, 0x01, 0x00, 0x00, 0x04, 0x10, 0x00, 0x0C, 0x04, 0x00, 0x00, + 0x1C, 0x01, 0x00, 0x00, + 0x98, 0x7D, 0x01, 0x00, 0x00, 0xFC, 0x10, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x78, 0x01, 0x00, 0x00, + 0x98, 0x7D, 0x01, 0x00, 0x0C, 0x08, 0x10, 0x00, 0x88, 0x7D, 0x00, 0x00, + 0x94, 0x01, 0x00, 0x00, + 0x01, 0x29, 0x04, 0xFF, 0x90, 0xD0, 0x03, 0x01, 0x71, 0x14, 0x90, 0x5F, + 0x01, 0x32, 0x01, 0x32, + 0x02, 0x29, 0x08, 0x41, 0xA9, 0x08, 0x09, 0x1A, 0x0C, 0xB2, 0x64, 0x29, + 0x0C, 0x69, 0x48, 0x29, + 0x04, 0x0A, 0x11, 0x04, 0x10, 0x01, 0xFF, 0x01, 0x46, 0x07, 0xA5, 0xF0, + 0x01, 0x20, 0x18, 0x50, + 0x10, 0xAA, 0xFF, 0x0C, 0x59, 0x01, 0x00, 0x00, 0x30, 0xB5, 0x72, 0xB6, + 0x01, 0x24, 0x0C, 0x4D, + 0x2C, 0x60, 0x0C, 0x4B, 0x00, 0x22, 0x89, 0xB1, 0xC3, 0xF8, 0x00, 0x40, + 0x4F, 0xF0, 0x00, 0x51, + 0x00, 0xF0, 0x1F, 0x00, 0x81, 0xF8, 0x6A, 0x00, 0x06, 0x48, 0x1C, 0x38, + 0x04, 0x60, 0x01, 0x68, + 0x00, 0x29, 0xFC, 0xD1, 0x1A, 0x60, 0x2A, 0x60, 0x62, 0xB6, 0x30, 0xBD, + 0x1A, 0x60, 0xED, 0xE7, + 0xC0, 0x1B, 0x00, 0x22, 0x78, 0x0D, 0x00, 0x22, 0xD5, 0xA1, 0xA1, 0x0A, + 0x93, 0x02, 0x00, 0x00, + 0x2A, 0x5E, 0x5E, 0xF5, 0x6C, 0xFD, 0xFF, 0xFF, 0xA1, 0x00, 0xA1, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x3F, + 0x00, 0x00, 0x00, 0x00, + 0xFF, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0x0F, 0xFF, 0x09, + 0x9F, 0x05, 0x09, 0xFF, + 0x09, 0x9F, 0x05, 0x1D, 0x02, 0x00, 0x00, 0x00, 0x01, 0x20, 0x40, 0x50, + 0xAA, 0x99, 0xC8, 0x00, + 0xC8, 0x00, 0xC8, 0x00, 0xC8, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x70, 0x00, + 0x70, 0x00, 0x08, 0xB0, 0x00, 0xB0, 0x00, 0x00, 0x07, 0xAA, 0x38, 0xC8, + 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x08, 0x09, 0x0A, + 0x14, 0x0A, 0x00, 0x02, + 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x13, 0xE8, 0x03, + 0x64, 0x00, 0x64, 0x00, + 0xD0, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x64, + 0x00, 0x00, 0x00, 0xFF, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x08, 0x00, 0x02, + 0x08, 0x00, 0x06, 0x00, + 0x00, 0x00, 0x00, 0x08, 0x41, 0x01, 0x08, 0x00, 0x13, 0x0C, 0x41, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x81, 0x06, 0x52, 0x4F, 0x04, 0xD8, 0x10, 0x50, 0x00, 0x2F, 0x00, 0x08, + 0xB0, 0x06, 0x03, 0x03, + 0x00, 0x00, 0xBB, 0xBB, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xE9, 0xA6, + 0x5E, 0x1F, 0x04, 0xD8, 0x18, 0x40, 0x00, 0x08, 0x00, 0x20, 0x50, 0x06, + 0x07, 0x00, 0x00, 0x00, + 0x20, 0x50, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x20, + 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x89, 0x16, + 0x50, 0x4F, 0x04, 0x18, + 0x00, 0x30, 0x00, 0x06, 0x00, 0x2F, 0x00, 0x40, 0x10, 0x06, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA9, 0x26, + 0x9A, 0x1F, 0x98, 0x18, + 0x01, 0x01, 0x30, 0x00, 0x60, 0x00, 0x60, 0x00, 0x2F, 0x00, 0x21, 0x01, + 0x00, 0x00, 0x1F, 0x21, + 0x01, 0x00, 0x00, 0x1F, 0x00, 0x01, 0x20, 0x00, 0x99, 0x24, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x0B, + 0x00, 0x00, 0x00, 0x00, + 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x1A, + 0x00, 0x00, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x11, 0x1A, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x11, 0x1A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x01, 0x64, 0x00, + 0x64, 0x00, 0xD0, 0x00, + 0x80, 0x0C, 0xF0, 0x0A, 0xD0, 0x00, 0x00, 0x15, 0x00, 0x12, 0x50, 0x01, + 0x50, 0x01, 0x00, 0x15, + 0x00, 0x12, 0x50, 0x01, 0x80, 0x0C, 0xF0, 0x0A, 0xD0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x0F, 0x00, 0x06, + 0x0A, 0x0F, 0x02, 0x64, + 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xFF, 0x0F, 0xFF, 0x0F, + 0x14, 0x14, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x02, 0x64, 0x90, 0x01, 0x90, 0x01, 0x80, 0x00, 0x80, 0x00, 0xF4, 0x01, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x00, 0x64, 0x00, + 0x80, 0x01, 0x64, 0x00, + 0x80, 0x01, 0x96, 0x00, 0x64, 0x00, 0x20, 0x00, 0x02, 0x00, 0x96, 0x00, + 0x64, 0x00, 0x64, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x05, 0x01, 0xF4, 0x01, + 0x2C, 0x01, 0x02, 0xFF, + 0x7F, 0xFF, 0x7F, 0x02, 0x32, 0x64, 0x00, 0x00, 0x02, 0x02, 0xA2, 0x30, + 0x29, 0x64, 0x00, 0x64, + 0x00, 0xC8, 0x00, 0x58, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x64, 0x00, + 0x32, 0x00, 0x01, 0x00, + 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x04, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x83, 0x02, 0x10, 0x00, + 0x20, 0x00, 0x18, 0x00, + 0x00, 0x01, 0x62, 0x84, 0x40, 0x01, 0x20, 0x00, 0x10, 0x00, 0x64, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x20, 0x00, + 0x40, 0x2C, 0x7D, 0x00, + 0x2C, 0x01, 0x64, 0x00, 0x00, 0x0A, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x01, 0x64, 0x00, + 0x2C, 0x01, 0x00, 0x20, + 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x5A, 0x00, + 0x14, 0x00, 0x01, 0x03, + 0x01, 0x0A, 0x00, 0x10, 0x11, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x50, 0x00, + 0x70, 0x00, 0x32, 0x00, + 0x40, 0x00, 0x00, 0x00, 0xC8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x03, 0x00, 0x01, + 0x00, 0x02, 0x00, 0x02, + 0x00, 0x02, 0x64, 0x00, 0x0A, 0x64, 0x00, 0x64, 0x00, 0x0E, 0x00, 0x05, + 0x00, 0x10, 0xC2, 0x00, + 0x32, 0x00, 0x20, 0x31, 0x0F, 0x02, 0x20, 0x1F, 0x00, 0x0A, 0x00, 0x14, + 0x92, 0x11, 0x15, 0x00, + 0x13, 0x00, 0x02, 0x10, 0x0A, 0x00, 0x40, 0x00, 0x00, 0x40, 0x00, 0x10, + 0xE8, 0x10, 0x00, 0x40, + 0x00, 0x62, 0x94, 0x94, 0x28, 0xF4, 0x0A, 0x00, 0x18, 0x00, 0x10, 0x00, + 0x30, 0x00, 0x05, 0x14, + 0x05, 0x20, 0x03, 0x10, 0xD8, 0x05, 0x32, 0xF8, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0xC8, 0x00, + 0xC8, 0x00, 0x0A, 0x0A, + 0x20, 0x00, 0x64, 0x00, 0x01, 0x03, 0x64, 0x00, 0x64, 0x00, 0x01, 0x03, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x08, 0x32, 0x1A, 0xFA, 0x00, 0x0A, 0x05, 0x20, 0x0A, 0x05, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x0A, 0x00, 0x14, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x03, 0x50, 0x00, + 0x2C, 0x01, 0x32, 0xFF, + 0x7F, 0x0B, 0x01, 0x32, 0x00, 0x20, 0x03, 0x00, 0x0A, 0x20, 0x14, 0x05, + 0xF8, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x00, 0x01, + 0x02, 0x03, 0x50, 0x01, 0x50, 0x01, 0x50, 0x01, 0x50, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x96, 0x7D, 0x6E, 0x67, + 0x65, 0x64, 0x64, 0x64, + 0x64, 0x64, 0x64, 0x64, 0x64, 0x65, 0x67, 0x6E, 0x7D, 0x96, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x0F, 0x13, 0x22, 0x22, 0x22, 0x00, 0x00, 0x0F, 0x00, 0x28, 0x00, 0x3C, + 0x00, 0x50, 0x00, 0xA0, + 0x00, 0x40, 0x01, 0xE0, 0x01, 0xD0, 0x02, 0xBF, 0x03, 0x5F, 0x04, 0xFF, + 0x04, 0x4F, 0x05, 0x63, + 0x05, 0x77, 0x05, 0x90, 0x05, 0x0F, 0x00, 0x28, 0x00, 0x3C, 0x00, 0x50, + 0x00, 0xA0, 0x00, 0x40, + 0x01, 0xE0, 0x01, 0xD0, 0x02, 0xC0, 0x03, 0x00, 0x05, 0x3F, 0x06, 0x2F, + 0x07, 0x1F, 0x08, 0xBF, + 0x08, 0x5F, 0x09, 0xAF, 0x09, 0xC3, 0x09, 0xD7, 0x09, 0xF5, 0x09, 0x00, + 0x00, 0x0A, 0x00, 0x19, + 0x00, 0x28, 0x00, 0x6C, 0x00, 0x27, 0x01, 0xD1, 0x01, 0xD0, 0x02, 0xC6, + 0x03, 0x72, 0x04, 0x21, + 0x05, 0x69, 0x05, 0x86, 0x05, 0x95, 0x05, 0x9F, 0x05, 0x00, 0x00, 0x0F, + 0x00, 0x1C, 0x00, 0x28, + 0x00, 0x78, 0x00, 0x1C, 0x01, 0xC6, 0x01, 0xBE, 0x02, 0xAE, 0x03, 0x00, + 0x05, 0x4F, 0x06, 0x44, + 0x07, 0x39, 0x08, 0xDE, 0x08, 0x8A, 0x09, 0xD8, 0x09, 0xE3, 0x09, 0xF1, + 0x09, 0xFF, 0x09, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 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, 0x00, 0x64, 0x00, + 0x00, 0x00, 0x64, 0x80, + 0x10, 0xE5, 0x00, 0x00, 0x64, 0x80, 0x40, 0x00, 0x80, 0x00, 0xC0, 0x00, + 0x00, 0x01, 0x40, 0x01, + 0x80, 0x01, 0xC0, 0x01, 0x00, 0x02, 0x40, 0x02, 0x80, 0x02, 0xC0, 0x02, + 0x00, 0x03, 0x40, 0x03, + 0x80, 0x03, 0xC0, 0x03, 0x00, 0x04, 0x3F, 0x04, 0x7F, 0x04, 0xBF, 0x04, + 0xFF, 0x04, 0x3F, 0x05, + 0x7F, 0x05, 0xBF, 0x05, 0xFF, 0x05, 0x3F, 0x06, 0x7F, 0x06, 0xBF, 0x06, + 0xFF, 0x06, 0x3F, 0x07, + 0x7F, 0x07, 0xBF, 0x07, 0xFF, 0x07, 0xFF, 0x07, 0xBF, 0x07, 0x7F, 0x07, + 0x3F, 0x07, 0xFF, 0x06, + 0xBF, 0x06, 0x7F, 0x06, 0x3F, 0x06, 0xFF, 0x05, 0xBF, 0x05, 0x7F, 0x05, + 0x3F, 0x05, 0xFF, 0x04, + 0xBF, 0x04, 0x7F, 0x04, 0x3F, 0x04, 0x00, 0x04, 0xC0, 0x03, 0x80, 0x03, + 0x40, 0x03, 0x00, 0x03, + 0xC0, 0x02, 0x80, 0x02, 0x40, 0x02, 0x00, 0x02, 0xC0, 0x01, 0x80, 0x01, + 0x40, 0x01, 0x00, 0x01, + 0xC0, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 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, 0x40, 0x00, 0x60, 0x00, + 0x80, 0x00, 0xA0, 0x00, + 0xC0, 0x00, 0xE0, 0x00, 0x00, 0x01, 0x00, 0x01, 0xE0, 0x00, 0xC0, 0x00, + 0xA0, 0x00, 0x80, 0x00, + 0x60, 0x00, 0x40, 0x00, 0x20, 0x00, 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, + 0x14, 0x05, 0x14, 0x05, + 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, + 0x14, 0x05, 0x14, 0x05, + 0x14, 0x05, 0x14, 0x05, 0x14, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x04, 0x20, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCD, 0x00, 0xCD, 0x00, 0xCD, 0x00, + 0xCD, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x07, + 0x08, 0x0C, 0x0D, 0x0F, + 0x0F, 0x0F, 0x0E, 0x0E, 0x0E, 0x0D, 0x0D, 0x0D, 0x0A, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA9, 0x64, + 0x9A, 0x1F, 0x18, 0x18, + 0x01, 0x01, 0x30, 0x00, 0x60, 0x00, 0x60, 0x00, 0x2F, 0x00, 0x21, 0x01, + 0x00, 0x00, 0x1F, 0x20, + 0x01, 0x00, 0x00, 0x1F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, + 0x98, 0x24, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x46, 0x50, 0x10, + 0x10, 0xB0, 0x20, 0xFF, + 0xD0, 0x00, 0x06, 0x14, 0x14, 0x2A, 0x3A, 0x40, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x14, 0x6E, 0x6E, 0x47, 0x1A, 0x38, 0x00, 0x00, 0x00, 0x01, 0x0F, + 0x1E, 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, 0xA9, 0x24, + 0x94, 0x1F, 0x18, 0x18, + 0x01, 0x00, 0x25, 0x00, 0x25, 0x00, 0x50, 0x00, 0x24, 0x00, 0x70, 0x01, + 0x00, 0x00, 0x1F, 0x80, + 0x01, 0x00, 0x00, 0x1F, 0x00, 0x01, 0x10, 0x00, 0x55, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x75, 0x6A, 0xB0, +}; + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/Makefile b/drivers/input/touchscreen/fts_521/fts_lib/Makefile new file mode 100644 index 000000000000..ca95cb0289ed --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the FTS touchscreen driver. +# + + +obj-$(CONFIG_TOUCHSCREEN_ST_FTS_V521) += ftsCompensation.o ftsCore.o ftsError.o ftsFrame.o ftsIO.o ftsTest.o ftsTime.o ftsTool.o ftsFlash.o ftsGesture.o + diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.c new file mode 100644 index 000000000000..477955361604 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.c @@ -0,0 +1,790 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS functions for getting Initialization Data * +* * +************************************************************************** +************************************************************************** + +*/ +/*! +* \file ftsCompensation.c +* \brief Contains all the function to work with Initialization Data +*/ + +#include "ftsCompensation.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsFrame.h" +#include "ftsHardware.h" +#include "ftsIO.h" +#include "ftsSoftware.h" +#include "ftsTime.h" +#include "ftsTool.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** +* Request to the FW to load the specified Initialization Data +* @param type type of Initialization data to load @link load_opt Load Host Data Option @endlink +* @return OK if success or an error code which specify the type of error encountered +*/ +int requestCompensationData(u8 type) +{ + int ret = ERROR_OP_NOT_ALLOW; + int retry = 0; + + logError(0, "%s %s: Requesting compensation data... \n", tag, __func__, + retry + 1); + while (retry < RETRY_COMP_DATA_READ) { + ret = writeSysCmd(SYS_CMD_LOAD_DATA, &type, 1); + if (ret < OK) { + logError(1, "%s %s: failed at %d attemp! \n", tag, + __func__, retry + 1); + retry += 1; + } else { + logError(0, + "%s %s: Request Compensation data FINISHED! \n", + tag, __func__); + return OK; + } + } + + logError(1, "%s %s: Requesting compensation data... ERROR %08X \n", tag, + __func__, ret | ERROR_REQU_COMP_DATA); + return ret | ERROR_REQU_COMP_DATA; + +} + +/** +* Read Initialization Data Header and check that the type loaded match with the one previously requested +* @param type type of Initialization data requested @link load_opt Load Host Data Option @endlink +* @param header pointer to DataHeader variable which will contain the header +* @param address pointer to a variable which will contain the updated address to the next data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readCompensationDataHeader(u8 type, DataHeader *header, u64 *address) +{ + + u64 offset = ADDR_FRAMEBUFFER; + u8 data[COMP_DATA_HEADER]; + int ret; + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, offset, data, + COMP_DATA_HEADER, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading data header ERROR %08X \n", + tag, __func__, ret); + return ret; + } + + logError(0, "%s Read Data Header done! \n", tag); + + if (data[0] != HEADER_SIGNATURE) { + logError(1, + "%s %s: The Header Signature was wrong! %02X != %02X ERROR %08X \n", + tag, __func__, data[0], HEADER_SIGNATURE, + ERROR_WRONG_DATA_SIGN); + return ERROR_WRONG_DATA_SIGN; + } + + if (data[1] != type) { + logError(1, "%s %s: Wrong type found! %02X!=%02X ERROR %08X\n", + tag, __func__, data[1], type, ERROR_DIFF_DATA_TYPE); + return ERROR_DIFF_DATA_TYPE; + } + + logError(0, "%s Type = %02X of Compensation data OK! \n", tag, type); + + header->type = type; + + *address = offset + COMP_DATA_HEADER; + + return OK; + +} + +/** +* Read MS Global Initialization data from the buffer such as Cx1 +* @param address pointer to a variable which contain the address from where to read the data and will contain the updated address to the next data +* @param global pointer to MutualSenseData variable which will contain the MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readMutualSenseGlobalData(u64 *address, MutualSenseData *global) +{ + + u8 data[COMP_DATA_GLOBAL]; + int ret; + + logError(0, "%s Address for Global data= %04X \n", tag, *address); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, *address, data, + COMP_DATA_GLOBAL, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s %s: error while reading info data ERROR %08X\n", + tag, __func__, ret); + return ret; + } + logError(0, "%s Global data Read !\n", tag); + + global->header.force_node = data[0]; + global->header.sense_node = data[1]; + global->cx1 = data[2]; + + logError(0, "%s force_len = %d sense_len = %d CX1 = %d \n", tag, + global->header.force_node, global->header.sense_node, + global->cx1); + + *address += COMP_DATA_GLOBAL; + return OK; + +} + +/** +* Read MS Initialization data for each node from the buffer +* @param address a variable which contain the address from where to read the data +* @param node pointer to MutualSenseData variable which will contain the MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readMutualSenseNodeData(u64 address, MutualSenseData *node) +{ + + int ret; + int size = node->header.force_node * node->header.sense_node; + + logError(0, "%s Address for Node data = %04X \n", tag, address); + + node->node_data = (i8 *) kmalloc(size * (sizeof(i8)), GFP_KERNEL); + + if (node->node_data == NULL) { + logError(1, "%s %s: can not allocate node_data... ERROR %08X", + tag, __func__, ERROR_ALLOC); + return ERROR_ALLOC; + } + + logError(0, "%s Node Data to read %d bytes \n", tag, size); + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, + node->node_data, size, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading node data ERROR %08X \n", + tag, __func__, ret); + kfree(node->node_data); + node->node_data = NULL; + return ret; + } + node->node_data_size = size; + + logError(0, "%s Read node data OK! \n", tag); + + return size; + +} + +/** +* Perform all the steps to read the necessary info for MS Initialization data from the buffer and store it in a MutualSenseData variable +* @param type type of MS Initialization data to read @link load_opt Load Host Data Option @endlink +* @param data pointer to MutualSenseData variable which will contain the MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readMutualSenseCompensationData(u8 type, MutualSenseData *data) +{ + + int ret; + u64 address; + data->node_data = NULL; + + if (! + (type == LOAD_CX_MS_TOUCH || type == LOAD_CX_MS_LOW_POWER + || type == LOAD_CX_MS_KEY || type == LOAD_CX_MS_FORCE)) { + logError(1, + "%s %s: Choose a MS type of compensation data ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + ret = requestCompensationData(type); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_REQU_COMP_DATA); + return (ret | ERROR_REQU_COMP_DATA); + } + + ret = readCompensationDataHeader(type, &(data->header), &address); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_HEADER); + return (ret | ERROR_COMP_DATA_HEADER); + } + + ret = readMutualSenseGlobalData(&address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X \n", tag, __func__, + ERROR_COMP_DATA_GLOBAL); + return (ret | ERROR_COMP_DATA_GLOBAL); + } + + ret = readMutualSenseNodeData(address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_NODE); + return (ret | ERROR_COMP_DATA_NODE); + } + + return OK; + +} + +/** +* Read SS Global Initialization data from the buffer such as Ix1/Cx1 for force and sense +* @param address pointer to a variable which contain the address from where to read the data and will contain the updated address to the next data +* @param global pointer to MutualSenseData variable which will contain the SS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readSelfSenseGlobalData(u64 *address, SelfSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %04X \n", tag, *address); + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, *address, data, + COMP_DATA_GLOBAL, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading the data... ERROR %08X \n", + tag, __func__, ret); + return ret; + } + + logError(0, "%s Global data Read !\n", tag); + + global->header.force_node = data[0]; + global->header.sense_node = data[1]; + global->f_ix1 = data[2]; + global->s_ix1 = data[3]; + global->f_cx1 = (i8) data[4]; + global->s_cx1 = (i8) data[5]; + global->f_max_n = data[6]; + global->s_max_n = data[7]; + + logError(0, + "%s force_len = %d sense_len = %d f_ix1 = %d s_ix1 = %d f_cx1 = %d s_cx1 = %d \n", + tag, global->header.force_node, global->header.sense_node, + global->f_ix1, global->s_ix1, global->f_cx1, global->s_cx1); + logError(0, "%s max_n = %d s_max_n = %d \n", tag, global->f_max_n, + global->s_max_n); + + *address += COMP_DATA_GLOBAL; + + return OK; + +} + +/** +* Read SS Initialization data for each node of force and sense channels from the buffer +* @param address a variable which contain the address from where to read the data +* @param node pointer to SelfSenseData variable which will contain the SS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readSelfSenseNodeData(u64 address, SelfSenseData *node) +{ + + int size = node->header.force_node * 2 + node->header.sense_node * 2; + u8 data[size]; + int ret; + + node->ix2_fm = + (u8 *) kmalloc(node->header.force_node * (sizeof(u8)), GFP_KERNEL); + if (node->ix2_fm == NULL) { + logError(1, + "%s %s: can not allocate memory for ix2_fm... ERROR %08X", + tag, __func__, ERROR_ALLOC); + return ERROR_ALLOC; + } + + node->cx2_fm = + (i8 *) kmalloc(node->header.force_node * (sizeof(i8)), GFP_KERNEL); + if (node->cx2_fm == NULL) { + logError(1, + "%s %s: can not allocate memory for cx2_fm ... ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix2_fm); + return ERROR_ALLOC; + } + node->ix2_sn = + (u8 *) kmalloc(node->header.sense_node * (sizeof(u8)), GFP_KERNEL); + if (node->ix2_sn == NULL) { + logError(1, + "%s %s: can not allocate memory for ix2_sn ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix2_fm); + kfree(node->cx2_fm); + return ERROR_ALLOC; + } + node->cx2_sn = + (i8 *) kmalloc(node->header.sense_node * (sizeof(i8)), GFP_KERNEL); + if (node->cx2_sn == NULL) { + logError(1, + "%s %s: can not allocate memory for cx2_sn ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix2_fm); + kfree(node->cx2_fm); + kfree(node->ix2_sn); + return ERROR_ALLOC; + } + + logError(0, "%s Address for Node data = %02X \n", tag, address); + + logError(0, "%s Node Data to read %d bytes \n", tag, size); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, data, + size, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s %s: error while reading data... ERROR %08X\n", + tag, ret); + kfree(node->ix2_fm); + kfree(node->cx2_fm); + kfree(node->ix2_sn); + kfree(node->cx2_sn); + return ret; + } + + logError(0, "%s Read node data ok! \n", tag); + + memcpy(node->ix2_fm, data, node->header.force_node); + memcpy(node->ix2_sn, &data[node->header.force_node], + node->header.sense_node); + memcpy(node->cx2_fm, + &data[node->header.force_node + node->header.sense_node], + node->header.force_node); + memcpy(node->cx2_sn, + &data[node->header.force_node * 2 + node->header.sense_node], + node->header.sense_node); + + return OK; + +} + +/** +* Perform all the steps to read the necessary info for SS Initialization data from the buffer and store it in a SelfSenseData variable +* @param type type of SS Initialization data to read @link load_opt Load Host Data Option @endlink +* @param data pointer to SelfSenseData variable which will contain the SS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readSelfSenseCompensationData(u8 type, SelfSenseData *data) +{ + + int ret; + u64 address; + + data->ix2_fm = NULL; + data->cx2_fm = NULL; + data->ix2_sn = NULL; + data->cx2_sn = NULL; + + if (! + (type == LOAD_CX_SS_TOUCH || type == LOAD_CX_SS_TOUCH_IDLE + || type == LOAD_CX_SS_KEY || type == LOAD_CX_SS_FORCE)) { + logError(1, + "%s %s: Choose a SS type of compensation data ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + ret = requestCompensationData(type); + if (ret < 0) { + logError(1, + "%s %s: error while requesting data... ERROR %08X\n", + tag, __func__, ERROR_REQU_COMP_DATA); + return (ret | ERROR_REQU_COMP_DATA); + } + + ret = readCompensationDataHeader(type, &(data->header), &address); + if (ret < 0) { + logError(1, + "%s %s: error while reading data header... ERROR %08X\n", + tag, __func__, ERROR_COMP_DATA_HEADER); + return (ret | ERROR_COMP_DATA_HEADER); + } + + ret = readSelfSenseGlobalData(&address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_GLOBAL); + return (ret | ERROR_COMP_DATA_GLOBAL); + } + + ret = readSelfSenseNodeData(address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_NODE); + return (ret | ERROR_COMP_DATA_NODE); + } + + return OK; + +} + +/** +* Read TOT MS Global Initialization data from the buffer such as number of force and sense channels +* @param address pointer to a variable which contain the address from where to read the data and will contain the updated address to the next data +* @param global pointer to a variable which will contain the TOT MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotMutualSenseGlobalData(u64 *address, TotMutualSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %04X \n", tag, *address); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, *address, data, + COMP_DATA_GLOBAL, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s %s: error while reading info data ERROR %08X\n", + tag, __func__, ret); + return ret; + } + logError(0, "%s Global data Read !\n", tag); + + global->header.force_node = data[0]; + global->header.sense_node = data[1]; + + logError(0, "%s force_len = %d sense_len = %d \n", tag, + global->header.force_node, global->header.sense_node); + + *address += COMP_DATA_GLOBAL; + return OK; + +} + +/** +* Read TOT MS Initialization data for each node from the buffer +* @param address a variable which contain the address from where to read the data +* @param node pointer to MutualSenseData variable which will contain the TOT MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotMutualSenseNodeData(u64 address, TotMutualSenseData *node) +{ + int ret, i; + int size = node->header.force_node * node->header.sense_node; + int toRead = size * sizeof(u16); + u8 data[toRead]; + + logError(0, "%s Address for Node data = %04X \n", tag, address); + + node->node_data = (short *)kmalloc(size * (sizeof(short)), GFP_KERNEL); + + if (node->node_data == NULL) { + logError(1, "%s %s: can not allocate node_data... ERROR %08X", + tag, __func__, ERROR_ALLOC); + return ERROR_ALLOC; + } + + logError(0, "%s Node Data to read %d bytes \n", tag, size); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, data, + toRead, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading node data ERROR %08X \n", + tag, __func__, ret); + kfree(node->node_data); + node->node_data = NULL; + return ret; + } + node->node_data_size = size; + + for (i = 0; i < size; i++) { + node->node_data[i] = + ((short)data[i * 2 + 1]) << 8 | data[i * 2]; + } + + logError(0, "%s Read node data OK! \n", tag); + + return size; + +} + +/** +* Perform all the steps to read the necessary info for TOT MS Initialization data from the buffer and store it in a TotMutualSenseData variable +* @param type type of TOT MS Initialization data to read @link load_opt Load Host Data Option @endlink +* @param data pointer to a variable which will contain the TOT MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotMutualSenseCompensationData(u8 type, TotMutualSenseData *data) +{ + int ret; + u64 address; + data->node_data = NULL; + + if (! + (type == LOAD_PANEL_CX_TOT_MS_TOUCH + || type == LOAD_PANEL_CX_TOT_MS_LOW_POWER + || type == LOAD_PANEL_CX_TOT_MS_KEY + || type == LOAD_PANEL_CX_TOT_MS_FORCE)) { + logError(1, + "%s %s: Choose a TOT MS type of compensation data ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + ret = requestCompensationData(type); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_REQU_COMP_DATA); + return (ret | ERROR_REQU_COMP_DATA); + } + + ret = readCompensationDataHeader(type, &(data->header), &address); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_HEADER); + return (ret | ERROR_COMP_DATA_HEADER); + } + + ret = readTotMutualSenseGlobalData(&address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X \n", tag, __func__, + ERROR_COMP_DATA_GLOBAL); + return (ret | ERROR_COMP_DATA_GLOBAL); + } + + ret = readTotMutualSenseNodeData(address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_NODE); + return (ret | ERROR_COMP_DATA_NODE); + } + + return OK; + +} + +/** +* Read TOT SS Global Initialization data from the buffer such as number of force and sense channels +* @param address pointer to a variable which contain the address from where to read the data and will contain the updated address to the next data +* @param global pointer to a variable which will contain the TOT SS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotSelfSenseGlobalData(u64 *address, TotSelfSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %04X \n", tag, *address); + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, *address, data, + COMP_DATA_GLOBAL, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading the data... ERROR %08X \n", + tag, __func__, ret); + return ret; + } + + logError(0, "%s Global data Read !\n", tag); + + global->header.force_node = data[0]; + global->header.sense_node = data[1]; + + logError(0, "%s force_len = %d sense_len = %d \n", tag, + global->header.force_node, global->header.sense_node); + + *address += COMP_DATA_GLOBAL; + + return OK; + +} + +/** +* Read TOT SS Global Initialization data from the buffer such as number of force and sense channels +* @param address pointer to a variable which contain the address from where to read the data and will contain the updated address to the next data +* @param node pointer to a variable which will contain the TOT SS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotSelfSenseNodeData(u64 address, TotSelfSenseData *node) +{ + + int size = node->header.force_node * 2 + node->header.sense_node * 2; + int toRead = size * 2; + u8 data[toRead]; + int ret, i, j = 0; + + node->ix_fm = + (u16 *) kmalloc(node->header.force_node * (sizeof(u16)), + GFP_KERNEL); + if (node->ix_fm == NULL) { + logError(1, + "%s %s: can not allocate memory for ix2_fm... ERROR %08X", + tag, __func__, ERROR_ALLOC); + return ERROR_ALLOC; + } + + node->cx_fm = + (short *)kmalloc(node->header.force_node * (sizeof(short)), + GFP_KERNEL); + if (node->cx_fm == NULL) { + logError(1, + "%s %s: can not allocate memory for cx2_fm ... ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix_fm); + return ERROR_ALLOC; + } + node->ix_sn = + (u16 *) kmalloc(node->header.sense_node * (sizeof(u16)), + GFP_KERNEL); + if (node->ix_sn == NULL) { + logError(1, + "%s %s: can not allocate memory for ix2_sn ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix_fm); + kfree(node->cx_fm); + return ERROR_ALLOC; + } + node->cx_sn = + (short *)kmalloc(node->header.sense_node * (sizeof(short)), + GFP_KERNEL); + if (node->cx_sn == NULL) { + logError(1, + "%s %s: can not allocate memory for cx2_sn ERROR %08X", + tag, __func__, ERROR_ALLOC); + kfree(node->ix_fm); + kfree(node->cx_fm); + kfree(node->ix_sn); + return ERROR_ALLOC; + } + + logError(0, "%s Address for Node data = %02X \n", tag, address); + + logError(0, "%s Node Data to read %d bytes \n", tag, size); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, data, + toRead, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s %s: error while reading data... ERROR %08X\n", + tag, ret); + kfree(node->ix_fm); + kfree(node->cx_fm); + kfree(node->ix_sn); + kfree(node->cx_sn); + return ret; + } + + logError(0, "%s Read node data ok! \n", tag); + + j = 0; + for (i = 0; i < node->header.force_node; i++) { + node->ix_fm[i] = ((u16) data[j + 1]) << 8 | data[j]; + j += 2; + } + + for (i = 0; i < node->header.sense_node; i++) { + node->ix_sn[i] = ((u16) data[j + 1]) << 8 | data[j]; + j += 2; + } + + for (i = 0; i < node->header.force_node; i++) { + node->cx_fm[i] = ((short)data[j + 1]) << 8 | data[j]; + j += 2; + } + + for (i = 0; i < node->header.sense_node; i++) { + node->cx_sn[i] = ((short)data[j + 1]) << 8 | data[j]; + j += 2; + } + + if (j != toRead) { + logError(1, "%s %s: parsed a wrong number of bytes %d!=%d \n", + tag, __func__, j, toRead); + } + + return OK; + +} + +/** +* Perform all the steps to read the necessary info for TOT SS Initialization data from the buffer and store it in a TotSelfSenseData variable +* @param type type of TOT MS Initialization data to read @link load_opt Load Host Data Option @endlink +* @param data pointer to a variable which will contain the TOT MS initialization data +* @return OK if success or an error code which specify the type of error encountered +*/ +int readTotSelfSenseCompensationData(u8 type, TotSelfSenseData *data) +{ + + int ret; + u64 address; + + data->ix_fm = NULL; + data->cx_fm = NULL; + data->ix_sn = NULL; + data->cx_sn = NULL; + + if (! + (type == LOAD_PANEL_CX_TOT_SS_TOUCH + || type == LOAD_PANEL_CX_TOT_SS_TOUCH_IDLE + || type == LOAD_PANEL_CX_TOT_SS_KEY + || type == LOAD_PANEL_CX_TOT_SS_FORCE + || type == STAPI_HOST_DATA_ID_PANEL_CX_SS_HVR)) { + logError(1, + "%s %s: Choose a TOT SS type of compensation data ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + ret = requestCompensationData(type); + if (ret < 0) { + logError(1, + "%s %s: error while requesting data... ERROR %08X\n", + tag, __func__, ERROR_REQU_COMP_DATA); + return (ret | ERROR_REQU_COMP_DATA); + } + + ret = readCompensationDataHeader(type, &(data->header), &address); + if (ret < 0) { + logError(1, + "%s %s: error while reading data header... ERROR %08X\n", + tag, __func__, ERROR_COMP_DATA_HEADER); + return (ret | ERROR_COMP_DATA_HEADER); + } + + ret = readTotSelfSenseGlobalData(&address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_GLOBAL); + return (ret | ERROR_COMP_DATA_GLOBAL); + } + + ret = readTotSelfSenseNodeData(address, data); + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_COMP_DATA_NODE); + return (ret | ERROR_COMP_DATA_NODE); + } + + return OK; + +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.h new file mode 100644 index 000000000000..1917e7484142 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsCompensation.h @@ -0,0 +1,110 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS functions for getting Initialization Data * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsCompensation.h +* \brief Contains all the definitions and structs to work with Initialization Data +*/ + +#ifndef FTS_COMPENSATION_H +#define FTS_COMPENSATION_H + +#include "ftsCore.h" +#include "ftsSoftware.h" + +#define RETRY_COMP_DATA_READ 2 + +/*Bytes dimension of Compensation Data Format*/ + +#define COMP_DATA_HEADER DATA_HEADER +#define COMP_DATA_GLOBAL (16 - COMP_DATA_HEADER) + +#define HEADER_SIGNATURE 0xA5 + +/** +* Struct which contains the general info about Frames and Initialization Data +*/ +typedef struct { + int force_node; /*Number of Force Channels in the frame/Initialization data*/ + int sense_node; /*Number of Sense Channels in the frame/Initialization data*/ + int type; /*Type of frame/Initialization data*/ +} DataHeader; + +/** +* Struct which contains the MS Initialization data +*/ +typedef struct { + DataHeader header; /*Header*/ + i8 cx1; /*Cx1 value (can be negative))*/ + i8 *node_data; /*Pointer to an array of bytes which contains the CX2 data (can be negative)*/ + int node_data_size; /*size of the data*/ +} MutualSenseData; + +/** +* Struct which contains the SS Initialization data +*/ +typedef struct { + DataHeader header; /*Header*/ + u8 f_ix1; /*IX1 Force*/ + u8 s_ix1; /*IX1 Sense*/ + i8 f_cx1; /*CX1 Force (can be negative)*/ + i8 s_cx1; /*< CX1 Sense (can be negative)*/ + u8 f_max_n; /*Force MaxN*/ + u8 s_max_n; /*Sense MaxN*/ + + u8 *ix2_fm; /*pointer to an array of bytes which contains Force Ix2 data node*/ + u8 *ix2_sn; /*pointer to an array of bytes which contains Sense Ix2 data node*/ + i8 *cx2_fm; /*pointer to an array of bytes which contains Force Cx2 data node (can be negative)*/ + i8 *cx2_sn; /*pointer to an array of bytes which contains Sense Cx2 data node (can be negative))*/ + +} SelfSenseData; + +/** +* Struct which contains the TOT MS Initialization data +*/ +typedef struct { + DataHeader header; /*Header*/ + short *node_data; /*pointer to an array of ushort which contains TOT MS Initialization data*/ + int node_data_size; /*size of data*/ +} TotMutualSenseData; + +/** +* Struct which contains the TOT SS Initialization data +*/ +typedef struct { + DataHeader header; /*Header*/ + + u16 *ix_fm; /*pointer to an array of ushort which contains TOT SS IX Force data*/ + u16 *ix_sn; /*pointer to an array of ushort which contains TOT SS IX Sense data*/ + short *cx_fm; /*pointer to an array of ushort which contains TOT SS CX Force data (can be negative)*/ + short *cx_sn; /*pointer to an array of ushort which contains TOT SS CX Sense data (can be negative)*/ + +} TotSelfSenseData; + +int requestCompensationData(u8 type); +int readCompensationDataHeader(u8 type, DataHeader *header, u64 *address); +int readMutualSenseGlobalData(u64 *address, MutualSenseData *global); +int readMutualSenseNodeData(u64 address, MutualSenseData *node); +int readMutualSenseCompensationData(u8 type, MutualSenseData *data); +int readSelfSenseGlobalData(u64 *address, SelfSenseData *global); +int readSelfSenseNodeData(u64 address, SelfSenseData *node); +int readSelfSenseCompensationData(u8 type, SelfSenseData *data); +int readToTMutualSenseGlobalData(u64 *address, TotMutualSenseData *global); +int readToTMutualSenseNodeData(u64 address, TotMutualSenseData *node); +int readTotMutualSenseCompensationData(u8 type, TotMutualSenseData *data); +int readTotSelfSenseGlobalData(u64 *address, TotSelfSenseData *global); +int readTotSelfSenseNodeData(u64 address, TotSelfSenseData *node); +int readTotSelfSenseCompensationData(u8 type, TotSelfSenseData *data); +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.c new file mode 100644 index 000000000000..f1a4806f55aa --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.c @@ -0,0 +1,1365 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Core functions * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsCore.c +* \brief Contains the implementation of the Core functions +*/ + +#include +#include +#include +#include +#include +#include "ftsCompensation.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsIO.h" +#include "ftsTest.h" +#include "ftsTime.h" +#include "ftsTool.h" + +extern struct fts_ts_info *fts_info; +/** @addtogroup system_info +* @{ +*/ +SysInfo systemInfo; /*Global System Info variable, accessible in all the driver*/ +/** @}*/ + +static int reset_gpio = GPIO_NOT_DEFINED; /*gpio number of the rest pin, the value is GPIO_NOT_DEFINED if the reset pin is not connected*/ +static int system_reseted_up; /*flag checked during resume to understand if there was a system reset and restore the proper state*/ +static int system_reseted_down; /*flag checked during suspend to understand if there was a system reset and restore the proper state*/ +static int disable_irq_count; /*count the number of call to disable_irq, start with 1 because at the boot IRQ are already disabled*/ +spinlock_t fts_int; /*spinlock to controll the access to the disable_irq_counter*/ + +/** +* Initialize core variables of the library. Must be called during the probe before any other lib function +* @param info pointer to fts_ts_info which contains info about the device and its hw setup +* @return OK if success or an error code which specify the type of error encountered +*/ +int initCore(struct fts_ts_info *info) +{ + int ret = OK; + logError(0, "%s %s: Initialization of the Core... \n", tag, __func__); + ret |= openChannel(info->client); + ret |= resetErrorList(); + ret |= initTestToDo(); + setResetGpio(info->board->reset_gpio); + if (ret < OK) { + logError(0, "%s %s: Initialization Core ERROR %08X! \n", tag, + __func__, ret); + } else { + logError(0, "%s %s: Initialization Finished! \n", tag, + __func__); + } + return ret; +} + +/** +* Set the reset_gpio variable with the actual gpio number of the board link to the reset pin +* @param gpio gpio number link to the reset pin of the IC +*/ +void setResetGpio(int gpio) +{ + reset_gpio = gpio; + logError(0, "%s setResetGpio: reset_gpio = %d\n", tag, reset_gpio); +} + +/** +* Perform a system reset of the IC. +* If the reset pin is associated to a gpio, the function execute an hw reset (toggling of reset pin) otherwise send an hw command to the IC +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_system_reset(void) +{ + u8 readData[FIFO_EVENT_SIZE]; + int event_to_search; + int res = -1; + int i; + u8 data[1] = { SYSTEM_RESET_VALUE }; + event_to_search = (int)EVT_ID_CONTROLLER_READY; + + logError(1, "%s System resetting...\n", tag); + if (fts_info) { + reinit_completion(&fts_info->tp_reset_completion); + atomic_set(&fts_info->system_is_resetting, 1); + } + for (i = 0; i < RETRY_SYSTEM_RESET && res < 0; i++) { + resetErrorList(); + fts_disableInterruptNoSync(); + + if (reset_gpio == GPIO_NOT_DEFINED) { + res = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, + ADDR_SYSTEM_RESET, data, + ARRAY_SIZE(data)); + } else { + gpio_set_value(reset_gpio, 0); + mdelay(10); + gpio_set_value(reset_gpio, 1); + res = OK; + } + if (res < OK) { + logError(1, "%s fts_system_reset: ERROR %08X\n", tag, + ERROR_BUS_W); + } else { + res = + pollForEvent(&event_to_search, 1, readData, + GENERAL_TIMEOUT); + if (res < OK) { + logError(1, "%s fts_system_reset: ERROR %08X\n", + tag, res); + } + } + } + if (fts_info) { + complete(&fts_info->tp_reset_completion); + atomic_set(&fts_info->system_is_resetting, 0); + } + if (res < OK) { + logError(1, + "%s fts_system_reset...failed after 3 attempts: ERROR %08X\n", + tag, (res | ERROR_SYSTEM_RESET_FAIL)); + return (res | ERROR_SYSTEM_RESET_FAIL); + } else { + logError(1, "%s System reset DONE!\n", tag); + system_reseted_down = 1; + system_reseted_up = 1; + return OK; + } + +} + +/** +* Return the value of system_resetted_down. +* @return the flag value: 0 if not set, 1 if set +*/ +int isSystemResettedDown(void) +{ + return system_reseted_down; +} + +/** +* Return the value of system_resetted_up. +* @return the flag value: 0 if not set, 1 if set +*/ +int isSystemResettedUp(void) +{ + return system_reseted_up; +} + +/** +* Set the value of system_reseted_down flag +* @param val value to write in the flag +*/ +void setSystemResetedDown(int val) +{ + system_reseted_down = val; +} + +/** +* Set the value of system_reseted_up flag +* @param val value to write in the flag +*/ +void setSystemResetedUp(int val) +{ + system_reseted_up = val; +} + +/** @addtogroup events_group + * @{ + */ + +/** +* Poll the FIFO looking for a specified event within a timeout. Support a retry mechanism. +* @param event_to_search pointer to an array of int where each element correspond to a byte of the event to find. If the element of the array has value -1, the byte of the event, in the same position of the element is ignored. +* @param event_bytes size of event_to_search +* @param readData pointer to an array of byte which will contain the event found +* @param time_to_wait time to wait before going in timeout +* @return OK if success or an error code which specify the type of error encountered +*/ +int pollForEvent(int *event_to_search, int event_bytes, u8 *readData, + int time_to_wait) +{ + int i, find, retry, count_err; + int time_to_count; + int err_handling = OK; + StopWatch clock; + + u8 cmd[1] = { FIFO_CMD_READONE }; + char temp[128] = { 0 }; + + find = 0; + retry = 0; + count_err = 0; + time_to_count = time_to_wait / TIMEOUT_RESOLUTION; + + startStopWatch(&clock); + while (find != 1 && retry < time_to_count + && fts_writeReadU8UX(cmd[0], 0, 0, readData, FIFO_EVENT_SIZE, + DUMMY_FIFO) >= OK) { + + if (readData[0] == EVT_ID_ERROR) { + + logError(1, "%s %s\n", tag, + printHex("ERROR EVENT = ", readData, + FIFO_EVENT_SIZE, temp)); + memset(temp, 0, 128); + count_err++; + err_handling = errorHandler(readData, FIFO_EVENT_SIZE); + if ((err_handling & 0xF0FF0000) == + ERROR_HANDLER_STOP_PROC) { + logError(0, + "%s pollForEvent: forced to be stopped! ERROR %08X\n", + tag, err_handling); + return err_handling; + } + } else { + if (readData[0] != EVT_ID_NOEVENT) { + logError(0, "%s %s\n", tag, + printHex("READ EVENT = ", readData, + FIFO_EVENT_SIZE, temp)); + memset(temp, 0, 128); + + } + if (readData[0] == EVT_ID_CONTROLLER_READY + && event_to_search[0] != EVT_ID_CONTROLLER_READY) { + logError(0, + "%s pollForEvent: Unmanned Controller Ready Event! Setting reset flags...\n", + tag); + setSystemResetedUp(1); + setSystemResetedDown(1); + } + } + + find = 1; + + for (i = 0; i < event_bytes; i++) { + + if (event_to_search[i] != -1 + && (int)readData[i] != event_to_search[i]) { + find = 0; + break; + } + } + + retry++; + mdelay(TIMEOUT_RESOLUTION); + } + stopStopWatch(&clock); + if ((retry >= time_to_count) && find != 1) { + logError(1, "%s pollForEvent: ERROR %02X \n", tag, + ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } else if (find == 1) { + logError(0, "%s %s\n", tag, + printHex("FOUND EVENT = ", readData, FIFO_EVENT_SIZE, + temp)); + memset(temp, 0, 128); + logError(0, + "%s Event found in %d ms (%d iterations)! Number of errors found = %d \n", + tag, elapsedMillisecond(&clock), retry, count_err); + return count_err; + } else { + logError(1, "%s pollForEvent: ERROR %08X \n", tag, ERROR_BUS_R); + return ERROR_BUS_R; + } +} + +/** @}*/ + +/** +* Check that the FW sent the echo even after a command was sent +* @param cmd pointer to an array of byte which contain the command previously sent +* @param size size of cmd +* @return OK if success or an error code which specify the type of error encountered +*/ +int checkEcho(u8 *cmd, int size) +{ + int ret, i; + int event_to_search[FIFO_EVENT_SIZE]; + u8 readData[FIFO_EVENT_SIZE]; + + if (size < 1) { + logError(1, "%s checkEcho: Error Size = %d not valid! \n", tag, + size, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } else { + if ((size + 3) > FIFO_EVENT_SIZE) + size = FIFO_EVENT_SIZE - 3; + + event_to_search[0] = EVT_ID_STATUS_UPDATE; + event_to_search[1] = EVT_TYPE_STATUS_ECHO; + for (i = 2; i < size + 2; i++) { + event_to_search[i] = cmd[i - 2]; + } + ret = + pollForEvent(event_to_search, size + 2, readData, + TIMEOUT_ECHO); + if (ret < OK) { + logError(1, + "%s checkEcho: Echo Event not found! ERROR %08X\n", + tag, ret); + return (ret | ERROR_CHECK_ECHO_FAIL); + } else if (ret > OK) { + logError(1, + "%s checkEcho: Echo Event found but with some error events before! num_error = %d \n", + tag, ret); + return ERROR_CHECK_ECHO_FAIL; + } + + logError(0, "%s ECHO OK!\n", tag); + return ret; + } + +} + +/** @addtogroup scan_mode +* @{ +*/ +/** +* Set a scan mode in the IC +* @param mode scan mode to set; possible values @link scan_opt Scan Mode Option @endlink +* @param settings option for the selected scan mode (for example @link active_bitmask Active Mode Bitmask @endlink) +* @return OK if success or an error code which specify the type of error encountered +*/ +int setScanMode(u8 mode, u8 settings) +{ + u8 cmd[3] = { FTS_CMD_SCAN_MODE, mode, settings }; + int ret, size = 3; + + logError(0, "%s %s: Setting scan mode: mode = %02X settings = %02X !\n", + tag, __func__, mode, settings); + if (mode == SCAN_MODE_LOW_POWER) + size = 2; + ret = fts_write_dma_safe(cmd, size); + if (ret < OK) { + logError(1, "%s %s: write failed...ERROR %08X !\n", tag, + __func__, ret); + return ret | ERROR_SET_SCAN_MODE_FAIL; + } + logError(0, "%s %s: Setting scan mode OK!\n", tag, __func__); + return OK; +} + +/** @}*/ + +/** @addtogroup feat_sel +* @{ +*/ +/** +* Set a feature and its option in the IC +* @param feat feature to set; possible values @link feat_opt Feature Selection Option @endlink +* @param settings pointer to an array of byte which store the options for the selected feature (for example the gesture mask to activate @link gesture_opt Gesture IDs @endlink) +* @param size in bytes of settings +* @return OK if success or an error code which specify the type of error encountered +*/ +int setFeatures(u8 feat, u8 *settings, int size) +{ + u8 cmd[2 + size]; + int i = 0; + int ret; + logError(0, "%s %s: Setting feature: feat = %02X !\n", tag, __func__, + feat); + cmd[0] = FTS_CMD_FEATURE; + cmd[1] = feat; + logError(0, "%s %s: Settings = ", tag, __func__); + for (i = 0; i < size; i++) { + cmd[2 + i] = settings[i]; + logError(0, "%02X ", settings[i]); + } + logError(0, "\n"); + ret = fts_write_dma_safe(cmd, 2 + size); + if (ret < OK) { + logError(1, "%s %s: write failed...ERROR %08X !\n", tag, + __func__, ret); + return ret | ERROR_SET_FEATURE_FAIL; + } + logError(0, "%s %s: Setting feature OK!\n", tag, __func__); + return OK; +} + +/** @}*/ + +/** @addtogroup sys_cmd +* @{ +*/ +/** +* Write a system command to the IC +* @param sys_cmd System Command to execute; possible values @link sys_opt System Command Option @endlink +* @param sett settings option for the selected system command (@link sys_special_opt Special Command Option @endlink, @link ito_opt ITO Test Option @endlink, @link load_opt Load Host Data Option @endlink) +* @param size in bytes of settings +* @return OK if success or an error code which specify the type of error encountered +*/ +int writeSysCmd(u8 sys_cmd, u8 *sett, int size) +{ + u8 *cmd = NULL; + int ret; + + cmd = (u8 *)kzalloc(sizeof(u8) * size + 2, GFP_KERNEL); + if (!cmd) { + ret = ERROR_ALLOC; + goto end; + } + + cmd[0] = FTS_CMD_SYSTEM; + cmd[1] = sys_cmd; + + logError(0, "%s %s: Command = %02X %02X ", tag, __func__, cmd[0], + cmd[1]); + for (ret = 0; ret < size; ret++) { + cmd[2 + ret] = sett[ret]; + logError(0, "%02X ", cmd[2 + ret]); + } + logError(0, "\n%s %s: Writing Sys command...\n", tag, __func__); + if (sys_cmd != SYS_CMD_LOAD_DATA) { + ret = fts_writeFwCmd(cmd, 2 + size); + } else { + if (size >= 1) { + ret = requestSyncFrame(sett[0]); + } else { + logError(1, "%s %s: No setting argument! ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + ret = ERROR_OP_NOT_ALLOW; + goto end; + } + } + if (ret < OK) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ret); + } else + logError(0, "%s %s: FINISHED! \n", tag, __func__); + +end: + if (cmd) + kfree(cmd); + return ret; +} + +/** @}*/ + +/** @addtogroup system_info +* @{ +*/ +/** +* Initialize the System Info Struct with default values according to the error found during the reading +* @param i2cError 1 if there was an I2C error while reading the System Info data from memory, other value if another error occurred +* @return OK if success or an error code which specify the type of error encountered +*/ +int defaultSysInfo(int i2cError) +{ + int i; + logError(0, "%s Setting default System Info... \n", tag); + + if (i2cError == 1) { + systemInfo.u16_fwVer = 0xFFFF; + systemInfo.u16_cfgProgectId = 0xFFFF; + for (i = 0; i < RELEASE_INFO_SIZE; i++) { + systemInfo.u8_releaseInfo[i] = 0xFF; + } + systemInfo.u16_cxVer = 0xFFFF; + } else { + systemInfo.u16_fwVer = 0x0000; + systemInfo.u16_cfgProgectId = 0x0000; + for (i = 0; i < RELEASE_INFO_SIZE; i++) { + systemInfo.u8_releaseInfo[i] = 0x00; + } + systemInfo.u16_cxVer = 0x0000; + } + + systemInfo.u8_scrRxLen = 0; + systemInfo.u8_scrTxLen = 0; + + logError(0, "%s default System Info DONE! \n", tag); + return OK; + +} + +/** +* Read the System Info data from memory. System Info is loaded automatically after every system reset. +* @param request if 1, will be asked to the FW to reload the data, otherwise attempt to read it directly from memory +* @return OK if success or an error code which specify the type of error encountered +*/ +int readSysInfo(int request) +{ + int ret, i, index = 0; + u8 sett = LOAD_SYS_INFO; + u8 data[SYS_INFO_SIZE] = { 0 }; + char temp[256] = { 0 }; + + if (request == 1) { + logError(0, "%s %s: Requesting System Info...\n", tag, + __func__); + + ret = writeSysCmd(SYS_CMD_LOAD_DATA, &sett, 1); + if (ret < OK) { + logError(1, + "%s %s: error while writing the sys cmd ERROR %08X\n", + tag, __func__, ret); + goto FAIL; + } + } + + logError(0, "%s %s: Reading System Info...\n", tag, __func__); + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, ADDR_FRAMEBUFFER, + data, SYS_INFO_SIZE, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, + "%s %s: error while reading the system data ERROR %08X\n", + tag, __func__, ret); + goto FAIL; + } + + logError(0, "%s %s: Parsing System Info...\n", tag, __func__); + + if (data[0] != HEADER_SIGNATURE) { + logError(1, + "%s %s: The Header Signature is wrong! sign: %02X != %02X ERROR %08X\n", + tag, __func__, data[0], HEADER_SIGNATURE, + ERROR_WRONG_DATA_SIGN); + ret = ERROR_WRONG_DATA_SIGN; + goto FAIL; + } + + if (data[1] != LOAD_SYS_INFO) { + logError(1, + "%s %s: The Data ID is wrong! ids: %02X != %02X ERROR %08X \n", + tag, __func__, data[3], LOAD_SYS_INFO, + ERROR_DIFF_DATA_TYPE); + ret = ERROR_DIFF_DATA_TYPE; + goto FAIL; + } + + index += 4; + u8ToU16(&data[index], &systemInfo.u16_apiVer_rev); + index += 2; + systemInfo.u8_apiVer_minor = data[index++]; + systemInfo.u8_apiVer_major = data[index++]; + u8ToU16(&data[index], &systemInfo.u16_chip0Ver); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_chip0Id); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_chip1Ver); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_chip1Id); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_fwVer); + index += 2; + logError(1, "%s FW VER = %04X \n", tag, systemInfo.u16_fwVer); + + u8ToU16(&data[index], &systemInfo.u16_svnRev); + index += 2; + logError(1, "%s SVN REV = %04X \n", tag, systemInfo.u16_svnRev); + u8ToU16(&data[index], &systemInfo.u16_cfgVer); + index += 2; + logError(1, "%s CONFIG VER = %04X \n", tag, systemInfo.u16_cfgVer); + u8ToU16(&data[index], &systemInfo.u16_cfgProgectId); + index += 2; + logError(1, "%s CONFIG PROJECT ID = %04X \n", tag, + systemInfo.u16_cfgProgectId); + u8ToU16(&data[index], &systemInfo.u16_cxVer); + index += 2; + logError(1, "%s CX VER = %04X \n", tag, systemInfo.u16_cxVer); + u8ToU16(&data[index], &systemInfo.u16_cxProjectId); + index += 2; + logError(1, "%s CX PROJECT ID = %04X \n", tag, + systemInfo.u16_cxProjectId); + systemInfo.u8_cfgAfeVer = data[index++]; + systemInfo.u8_cxAfeVer = data[index++]; + systemInfo.u8_panelCfgAfeVer = data[index++]; + logError(1, "%s AFE VER: CFG = %02X - CX = %02X - PANEL = %02X \n", tag, + systemInfo.u8_cfgAfeVer, systemInfo.u8_cxAfeVer, + systemInfo.u8_panelCfgAfeVer); + systemInfo.u8_protocol = data[index++]; + logError(0, "%s Protocol = %02X \n", tag, systemInfo.u8_protocol); + + for (i = 0; i < DIE_INFO_SIZE; i++) { + systemInfo.u8_dieInfo[i] = data[index++]; + + } + logError(0, "%s %s \n", tag, + printHex("Die Info = ", systemInfo.u8_dieInfo, DIE_INFO_SIZE, + temp)); + memset(temp, 0, 256); + + for (i = 0; i < RELEASE_INFO_SIZE; i++) { + systemInfo.u8_releaseInfo[i] = data[index++]; + } + + logError(1, "%s %s \n", tag, + printHex("Release Info = ", systemInfo.u8_releaseInfo, + RELEASE_INFO_SIZE, temp)); + memset(temp, 0, 256); + + u8ToU32(&data[index], &systemInfo.u32_fwCrc); + index += 4; + u8ToU32(&data[index], &systemInfo.u32_cfgCrc); + + index += 4; + + index += 8; + + u8ToU16(&data[index], &systemInfo.u16_scrResX); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_scrResY); + index += 2; + logError(0, "%s Screen Resolution = %d x %d \n", tag, + systemInfo.u16_scrResX, systemInfo.u16_scrResY); + systemInfo.u8_scrTxLen = data[index++]; + logError(0, "%s TX Len = %d \n", tag, systemInfo.u8_scrTxLen); + systemInfo.u8_scrRxLen = data[index++]; + logError(0, "%s RX Len = %d \n", tag, systemInfo.u8_scrRxLen); + systemInfo.u8_keyLen = data[index++]; + logError(0, "%s Key Len = %d \n", tag, systemInfo.u8_keyLen); + systemInfo.u8_forceLen = data[index++]; + logError(0, "%s Force Len = %d \n", tag, systemInfo.u8_forceLen); + + index += 40; + + u8ToU16(&data[index], &systemInfo.u16_dbgInfoAddr); + index += 2; + + index += 6; + + u8ToU16(&data[index], &systemInfo.u16_msTchRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_msTchFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_msTchStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_msTchBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssTchTxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchTxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchTxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchTxBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssTchRxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchRxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchRxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssTchRxBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_keyRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_keyFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_keyStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_keyBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_frcRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_frcFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_frcStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_frcBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssHvrTxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrTxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrTxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrTxBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssHvrRxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrRxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrRxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssHvrRxBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssPrxTxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxTxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxTxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxTxBaselineAddr); + index += 2; + + u8ToU16(&data[index], &systemInfo.u16_ssPrxRxRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxRxFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxRxStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssPrxRxBaselineAddr); + index += 2; + + logError(0, "%s Parsed %d bytes! \n", tag, index); + + if (index != SYS_INFO_SIZE) { + logError(1, "%s %s: index = %d different from %d ERROR %08X\n", + tag, __func__, index, SYS_INFO_SIZE, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + logError(0, "%s System Info Read DONE!\n", tag); + return OK; + +FAIL: + defaultSysInfo(isI2cError(ret)); + return ret; + +} + +/** @}*/ + +/** + * Read data from the Config Memory + * @param offset Starting address in the Config Memory of data to read + * @param outBuf pointer of a byte array which contain the bytes to read + * @param len number of bytes to read + * @return OK if success or an error code which specify the type of error encountered + */ +int readConfig(u16 offset, u8 *outBuf, int len) +{ + int ret; + u64 final_address = offset + ADDR_CONFIG_OFFSET; + + logError(0, "%s %s: Starting to read config memory at %08X ...", tag, + __func__, final_address); + ret = + fts_writeReadU8UX(FTS_CMD_CONFIG_R, BITS_16, final_address, outBuf, + len, DUMMY_CONFIG); + if (ret < OK) { + logError(1, + "%s %s: Impossible to read Config Memory... ERROR %08X!", + tag, __func__, ret); + return ret; + } + + logError(0, "%s %s: Read config memory FINISHED!", tag, __func__); + return OK; +} + +/** + * Disable the interrupt so the ISR of the driver can not be called + * @return OK if success or an error code which specify the type of error encountered + */ +int fts_disableInterrupt(void) +{ + if (getClient() != NULL) { + logError(0, "%s Number of disable = %d \n", tag, + disable_irq_count); + if (disable_irq_count == 0) { + logError(0, "%s Excecuting Disable... \n", tag); + disable_irq(getClient()->irq); + disable_irq_count++; + logError(1, "%s Interrupt Disabled!\n", tag); + } + return OK; + } else { + logError(1, "%s %s: Impossible get client irq... ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + +} + +/** + * Disable the interrupt async so the ISR of the driver can not be called + * @return OK if success or an error code which specify the type of error encountered + */ +int fts_disableInterruptNoSync(void) +{ + if (getClient() != NULL) { + spin_lock_irq(&fts_int); + logError(0, "%s Number of disable = %d \n", tag, + disable_irq_count); + if (disable_irq_count == 0) { + logError(0, "%s Executing Disable... \n", tag); + disable_irq_nosync(getClient()->irq); + disable_irq_count++; + } + + spin_unlock_irq(&fts_int); + logError(0, "%s Interrupt No Sync Disabled!\n", tag); + return OK; + } else { + logError(1, "%s %s: Impossible get client irq... ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } +} + +/** + * Reset the disable_irq count + * @return OK + */ +int fts_resetDisableIrqCount(void) +{ + disable_irq_count = 0; + return OK; +} + +/** + * Enable the interrupt so the ISR of the driver can be called + * @return OK if success or an error code which specify the type of error encountered + */ +int fts_enableInterrupt(void) +{ + if (getClient() != NULL) { + + logError(0, "%s Number of re-enable = %d \n", tag, + disable_irq_count); + while (disable_irq_count > 0) { + logError(0, "%s Excecuting Enable... \n", tag); + enable_irq(getClient()->irq); + disable_irq_count--; + logError(1, "%s Interrupt Enabled!\n", tag); + } + return OK; + } else { + logError(1, "%s %s: Impossible get client irq... ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } +} + +/** +* Check if there is a crc error in the IC which prevent the fw to run. +* @return OK if no CRC error, or a number >OK according the CRC error found +*/ +int fts_crc_check(void) +{ + u8 val; + u8 crc_status; + int res; + u8 error_to_search[6] = { EVT_TYPE_ERROR_CRC_CFG_HEAD, EVT_TYPE_ERROR_CRC_CFG, + EVT_TYPE_ERROR_CRC_CX, EVT_TYPE_ERROR_CRC_CX_HEAD, + EVT_TYPE_ERROR_CRC_CX_SUB, + EVT_TYPE_ERROR_CRC_CX_SUB_HEAD + }; + + res = + fts_writeReadU8UX(FTS_CMD_HW_REG_R, ADDR_SIZE_HW_REG, ADDR_CRC, + &val, 1, DUMMY_HW_REG); + if (res < OK) { + logError(1, "%s %s Cannot read crc status ERROR %08X\n", tag, + __func__, res); + return res; + } + + crc_status = val & CRC_MASK; + if (crc_status != OK) { + logError(1, "%s %s CRC ERROR = %02X \n", tag, __func__, + crc_status); + return CRC_CODE; + } + + logError(1, "%s %s: Verifying if Config CRC Error...\n", tag, __func__); + res = fts_system_reset(); + if (res >= OK) { + res = pollForErrorType(error_to_search, 2); + if (res < OK) { + logError(1, "%s %s: No Config CRC Error Found! \n", tag, + __func__); + logError(1, "%s %s: Verifying if Cx CRC Error...\n", + tag, __func__); + res = pollForErrorType(&error_to_search[2], 4); + if (res < OK) { + logError(1, "%s %s: No Cx CRC Error Found! \n", + tag, __func__); + return OK; + } else { + logError(1, + "%s %s: Cx CRC Error found! CRC ERROR = %02X\n", + tag, __func__, res); + return CRC_CX; + } + } else { + logError(1, + "%s %s: Config CRC Error found! CRC ERROR = %02X\n", + tag, __func__, res); + return CRC_CONFIG; + } + } else { + logError(1, + "%s %s: Error while executing system reset! ERROR %08X\n", + tag, __func__, res); + return res; + } + + return OK; +} + +/** + * Request a host data and use the sync method to understand when the FW load it + * @param type the type ID of host data to load (@link load_opt Load Host Data Option @endlink) + * @return OK if success or an error code which specify the type of error encountered + */ +int requestSyncFrame(u8 type) +{ + u8 request[3] = { FTS_CMD_SYSTEM, SYS_CMD_LOAD_DATA, type }; + u8 readData[DATA_HEADER] = { 0 }; + int ret, retry = 0, retry2 = 0, time_to_count; + int count, new_count; + + logError(0, "%s %s: Starting to get a sync frame...\n", tag, __func__); + + while (retry2 < RETRY_MAX_REQU_DATA) { + logError(0, "%s %s: Reading count...\n", tag, __func__); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, + ADDR_FRAMEBUFFER, readData, DATA_HEADER, + DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(0, + "%s %s: Error while reading count! ERROR %08X \n", + tag, __func__, ret | ERROR_REQU_DATA); + ret |= ERROR_REQU_DATA; + retry2++; + continue; + } + + if (readData[0] != HEADER_SIGNATURE) { + logError(1, + "%s %s: Invalid Signature while reading count! ERROR %08X \n", + tag, __func__, ret | ERROR_REQU_DATA); + ret |= ERROR_REQU_DATA; + retry2++; + continue; + } + + count = (readData[3] << 8) | readData[2]; + new_count = count; + logError(0, "%s %s: Base count = %d\n", tag, __func__, count); + + logError(0, "%s %s: Requesting frame %02X attempt = %d \n", + tag, __func__, type, retry2 + 1); + ret = fts_write_dma_safe(request, ARRAY_SIZE(request)); + if (ret >= OK) { + + logError(0, "%s %s: Polling for new count... \n", tag, + __func__); + time_to_count = TIMEOUT_REQU_DATA / TIMEOUT_RESOLUTION; + while (count == new_count && retry < time_to_count) { + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, + BITS_16, ADDR_FRAMEBUFFER, + readData, DATA_HEADER, + DUMMY_FRAMEBUFFER); + if (ret >= OK + && readData[0] == HEADER_SIGNATURE) { + new_count = + ((readData[3] << 8) | readData[2]); + } else { + logError(0, + "%s %s: invalid Signature or can not read count... ERROR %08X \n", + tag, __func__, ret); + } + retry++; + mdelay(TIMEOUT_RESOLUTION); + } + + if (count == new_count) { + logError(1, + "%s %s: New count not received! ERROR %08X \n", + tag, __func__, + ERROR_TIMEOUT | ERROR_REQU_DATA); + ret = ERROR_TIMEOUT | ERROR_REQU_DATA; + } else { + logError(0, + "%s %s: New count found! count = %d! Frame ready! \n", + tag, __func__, new_count); + return OK; + } + } + retry2++; + } + logError(1, "%s %s: Request Data failed! ERROR %08X \n", tag, __func__, + ret); + return ret; +} + +int calculateCRC8(u8 *u8_srcBuff, int size, u8 *crc) +{ + u8 u8_remainder; + u8 bit; + int i = 0; + u8_remainder = 0x00; + + logError(0, "%s %s: Start CRC computing...\n", tag, __func__); + if (size != 0 && u8_srcBuff != NULL) { + for (i = 0; i < size; i++) { + u8_remainder ^= u8_srcBuff[i]; + for (bit = 8; bit > 0; --bit) { + if (u8_remainder & (0x1 << 7)) { + u8_remainder = + (u8_remainder << 1) ^ 0x9B; + } else { + u8_remainder = (u8_remainder << 1); + } + } + } + *crc = u8_remainder; + logError(0, "%s %s: CRC value = %02X\n", tag, __func__, *crc); + return OK; + } else { + logError(1, + "%s %s: Arguments passed not valid! Data pointer = NULL or size = 0 (%d) ERROR %08X\n", + tag, __func__, size, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } +} + +int writeLockDownInfo(u8 *data, int size, u8 lock_id) +{ + int ret, i; + u8 crc_data = 0; + u8 crc_head = 0; + u8 cmd_lockdown_prepare[8] = { LOCKDOWN_SIGNATURE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + u8 cmd_lockdown_crc[4] = { 0x00 }; + u8 lockdown_save[3] = { 0xA4, 0x00, 0x04 }; + u8 *temp = NULL; + u8 error_to_search[4] = { EVT_TYPE_ERROR_LOCKDOWN_FLASH, EVT_TYPE_ERROR_LOCKDOWN_CRC, + EVT_TYPE_ERROR_LOCKDOWN_NO_DATA, + EVT_TYPE_ERROR_LOCKDOWN_WRITE_FULL + }; + + logError(0, "%s %s:enter", tag, __func__); + if (lock_id < 0x70 || lock_id > 0x77 || size <= 0 + || size > LOCKDOWN_LENGTH - 20) { + logError(1, + "%s %s the lock id type is:%02X size:%d not support\n", + tag, __func__, lock_id, size); + return ERROR_LOCKDOWN_CODE; + } + + temp = printHex_data("Lockdown Code = ", data, size); + if (temp != NULL) { + logError(1, "%s: %s", __func__, temp); + kfree(temp); + } + + logError(0, "%s: Writing Lockdown code into the IC ...\n", __func__); + fts_disableInterrupt(); + for (i = 0; i < 3; i++) { + cmd_lockdown_prepare[1] = lock_id; + ret = calculateCRC8(data, size, &crc_data); + if (ret < OK) { + logError(1, + "%s %s: Unable to compute data CRC.. ERROR %08X\n", + tag, __func__, ret); + ret = (ret | ERROR_LOCKDOWN_CODE); + continue; + } + logError(0, "%s %s: Get the data CRC value:%02X\n", tag, + __func__, crc_data); + ret = + fts_writeU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN, cmd_lockdown_prepare, + ARRAY_SIZE(cmd_lockdown_prepare)); + if (ret < OK) { + logError(1, + "%s %s: Unable to write Lockdown data prepare at %d iteration.. ERROR %08X\n", + tag, __func__, i, ret); + ret = (ret | ERROR_LOCKDOWN_CODE); + continue; + } + logError(0, "%s %s: Compute 8bit header CRC...\n", tag, + __func__); + + cmd_lockdown_crc[0] = (u8) size; + cmd_lockdown_crc[1] = crc_data; + cmd_lockdown_crc[2] = lock_id; + ret = calculateCRC8(cmd_lockdown_crc, 3, &crc_head); + if (ret < OK) { + logError(1, + "%s %s: Unable to compute head CRC.. ERROR %08X\n", + tag, __func__, ret); + ret = (ret | ERROR_LOCKDOWN_CODE); + continue; + } + cmd_lockdown_crc[3] = crc_head; + logError(0, "%s %s: Get the header CRC value:%02X\n", tag, + __func__, crc_head); + + ret = + fts_writeU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN + LOCKDOWN_DATA_OFFSET - + LOCKDOWN_HEAD_LENGTH, cmd_lockdown_crc, + ARRAY_SIZE(cmd_lockdown_crc)); + if (ret < OK) { + logError(1, + "%s %s: Unable to write Lockdown head at %d iteration.. ERROR %08X\n", + tag, __func__, i, ret); + ret = (ret | ERROR_LOCKDOWN_CODE); + continue; + } + mdelay(10); + ret = + fts_writeU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN + LOCKDOWN_DATA_OFFSET, data, + size); + if (ret < OK) { + logError(1, + "%s %s: Unable to write Lockdown head at %d iteration.. ERROR %08X\n", + tag, __func__, i, ret); + ret = (ret | ERROR_LOCKDOWN_CODE); + continue; + } + mdelay(10); + ret = fts_write_dma_safe(lockdown_save, 3); + mdelay(5); + ret = checkEcho(lockdown_save, 3); + if (ret < OK) { + logError(1, "%s No Echo received.. ERROR %08X !\n", tag, + ret); + continue; + } else { + logError(1, "%s Echo FOUND... OK!\n", tag, ret); + ret = pollForErrorType(error_to_search, 4); + if (ret < OK) { + logError(1, "%s %s: No Error Found! \n", tag, + __func__); + ret = OK; + } else { + logError(1, + "%s %s: have error when write lockdown ERROR = %02X\n", + tag, __func__, ret); + ret = ERROR_LOCKDOWN_CODE; + } + break; + } + } + if (ret < OK) + logError(1, "%s %s end, write lockdown failed\n", tag, __func__, + ret); + else + logError(1, "%s %s end, write lockdown success\n", tag, + __func__, ret); + + fts_enableInterrupt(); + return ret; +} + +int readLockDownInfo(u8 *lockData, u8 lock_id, int size) +{ + int ret = 0, i; + int loaded_cnt = 0; + int loaded_cnt_after = 0; + u8 *temp = NULL; + char *datatemp = NULL; + u8 cmd_lockdown[3] = { 0xA4, 0x06, 0x00 }; + + logError(0, "%s %s:enter", tag, __func__); + if (lock_id < 0x70 || lock_id > 0x77 || size <= 0 + || size > LOCKDOWN_LENGTH - 20) { + logError(1, "%s the lock id type is:%02X not support\n", tag, + lock_id); + return ERROR_LOCKDOWN_CODE; + } + + temp = (u8 *) kmalloc(LOCKDOWN_LENGTH * sizeof(u8), GFP_KERNEL); + if (temp == NULL) { + logError(1, "FTS temp alloc memory failed \n"); + return -ENOMEM; + } + memset(temp, 0, LOCKDOWN_LENGTH * sizeof(u8)); + + fts_disableInterrupt(); + for (i = 0; i < 3; i++) { + ret = + fts_writeReadU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN, temp, LOCKDOWN_HEAD_LENGTH, + DUMMY_CONFIG); + if (ret < OK) { + logError(1, + "%s %s: error while reading data ERROR %08X \n", + tag, __func__, ret); + goto END; + } + loaded_cnt = (int)((temp[3] & 0xFF) << 8) + (temp[2] & 0xFF); + cmd_lockdown[2] = lock_id; + fts_write_dma_safe(cmd_lockdown, 3); + mdelay(10); + ret = checkEcho(cmd_lockdown, 3); + if (ret < OK) { + logError(1, "%s No Echo received.. ERROR %08X !\n", tag, + ret); + continue; + } else { + logError(1, "%s Echo FOUND... OK!\n", tag, ret); + } + ret = + fts_writeReadU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN, temp, + size + LOCKDOWN_DATA_OFFSET, + DUMMY_CONFIG); + if (ret < OK) { + logError(1, + "%s %s: error while reading data ERROR %08X \n", + tag, __func__, ret); + goto END; + } + + loaded_cnt_after = + (int)((temp[3] & 0xFF) << 8) + (temp[2] & 0xFF); + if (temp[4] == EVT_TYPE_ERROR_LOCKDOWN_FLASH + || temp[4] == EVT_TYPE_ERROR_LOCKDOWN_NO_DATA) { + logError(1, + "%s %s: can not read the lockdown code ERROR type:%02X\n", + tag, __func__, temp[4]); + ret = ERROR_LOCKDOWN_CODE; + goto END; + } + + logError(1, + "%s %s signature:%02X id:%02X %02X beforecnt:%d,aftercnt:%d\n", + tag, __func__, temp[0], temp[1], lock_id, loaded_cnt, + loaded_cnt_after); + if (loaded_cnt_after == loaded_cnt + 1) { + ret = OK; + memcpy(lockData, &temp[LOCKDOWN_DATA_OFFSET], size); + break; + } + + } + + datatemp = printHex_data("Lockdown Code = ", lockData, size); + if (datatemp != NULL) { + logError(1, "%s %s", tag, datatemp); + kfree(datatemp); + } + +END: + fts_enableInterrupt(); + kfree(temp); + return ret; +} + +int fts_get_lockdown_info(u8 *lockData, struct fts_ts_info *info) +{ + int ret = 0, i; + int loaded_cnt = 0; + u8 lock_id = FTS_CMD_LOCKDOWN_ID; + int size = FTS_LOCKDOWN_SIZE; + int loaded_cnt_after = 0; + u8 *temp = NULL; + u8 cmd_lockdown[3] = { 0xA4, 0x06, 0x00 }; + char *datatemp = NULL; + + if (info == NULL) + return ERROR_LOCKDOWN_CODE; + if (info->lockdown_is_ok) { + logError(1, "%s %s aleady get,skip\n", tag, __func__); + return OK; + } + logError(0, "%s %s:enter", tag, __func__); + if (lock_id < 0x70 || lock_id > 0x77) { + logError(1, "%s the lock id type is not support\n", tag); + return ERROR_LOCKDOWN_CODE; + } + + temp = (u8 *) kmalloc(1024 * sizeof(u8), GFP_KERNEL); + if (temp == NULL) { + logError(1, "FTS temp alloc memory failed \n"); + return -ENOMEM; + } + memset(temp, 0, 1024 * sizeof(u8)); + + fts_disableInterrupt(); + + for (i = 0; i < LOCKDOWN_CODE_RETRY; i++) { + + ret = + fts_writeReadU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN, temp, LOCKDOWN_HEAD_LENGTH, + DUMMY_CONFIG); + if (ret < OK) { + logError(1, + "%s %s: error while reading data ERROR %08X \n", + tag, __func__, ret); + goto END; + } + loaded_cnt = (int)((temp[3] & 0xFF) << 8) + (temp[2] & 0xFF); + cmd_lockdown[2] = lock_id; + fts_write_dma_safe(cmd_lockdown, 3); + mdelay(10); + ret = checkEcho(cmd_lockdown, 3); + if (ret < OK) { + logError(1, "%s No Echo received.. ERROR %08X !\n", tag, + ret); + continue; + } else { + logError(1, "%s Echo FOUND... OK!\n", tag, ret); + } + ret = + fts_writeReadU8UX(LOCKDOWN_WRITEREAD_CMD, BITS_16, + ADDR_LOCKDOWN, temp, + size + LOCKDOWN_DATA_OFFSET, + DUMMY_CONFIG); + if (ret < OK) { + logError(1, + "%s %s: error while reading data ERROR %08X \n", + tag, __func__, ret); + goto END; + } + + loaded_cnt_after = + (int)((temp[3] & 0xFF) << 8) + (temp[2] & 0xFF); + if (temp[4] == EVT_TYPE_ERROR_LOCKDOWN_FLASH + || temp[4] == EVT_TYPE_ERROR_LOCKDOWN_NO_DATA) { + logError(1, + "%s %s: can not read the lockdown code ERROR type:%02X\n", + tag, __func__, temp[4]); + ret = ERROR_LOCKDOWN_CODE; + goto END; + } + + logError(1, + "%s %s signature:%02X id:%02X %02X beforecnt:%d,aftercnt:%d\n", + tag, __func__, temp[0], temp[1], lock_id, loaded_cnt, + loaded_cnt_after); + if (loaded_cnt_after == loaded_cnt + 1) { + ret = OK; + memcpy(lockData, &temp[LOCKDOWN_DATA_OFFSET], size); + break; + } + + } + + datatemp = printHex_data("Lockdown Code = ", lockData, size); + if (datatemp != NULL) { + logError(0, "%s %s", tag, datatemp); + kfree(datatemp); + } + +END: + fts_enableInterrupt(); + kfree(temp); + return ret; + +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.h new file mode 100644 index 000000000000..0022ceacc3d2 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsCore.h @@ -0,0 +1,180 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Core definitions * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsCore.h +* \brief Contains all the definitions and structs of Core functionalities +*/ + +#ifndef FTS_CORE_H +#define FTS_CORE_H + +#include "ftsHardware.h" +#include "ftsSoftware.h" +#include "../fts.h" + +/*HW DATA*/ +#define GPIO_NOT_DEFINED -1 /*value assumed by reset_gpio when the reset pin of the IC is not connected*/ + +#define ADDR_SIZE_HW_REG BITS_32 /*value of AddrSize for Hw register in FTI @see AddrSize*/ + +#define DATA_HEADER 4 /*size in byte of the header loaded with the data in the frambuffer*/ +#define LOCKDOWN_CODE_RETRY 2 +/** + * Type of CRC errors + */ +typedef enum { + CRC_CODE = 1, /*CRC in the code section*/ + CRC_CONFIG = 2, /*CRC in the config section*/ + CRC_CX = 3, /*CRC in the cx section*/ + CRC_PANEL = 4 /*CRC in the panel section*/ +} CRC_Error; + +/*CHIP INFO*/ +/** @defgroup system_info System Info +* System Info Data collect the most important informations about hw and fw +* @{ +*/ +#define SYS_INFO_SIZE 208 /*Size in bytes of System Info data*/ +#define DIE_INFO_SIZE 16 /*num bytes of die info*/ +#define EXTERNAL_RELEASE_INFO_SIZE 8 /*num bytes of external release in config*/ +#define RELEASE_INFO_SIZE (EXTERNAL_RELEASE_INFO_SIZE + 8) /*num bytes of release info in sys info (first bytes are external release)*/ +/** @}*/ + +/*RETRY MECHANISM*/ +#define RETRY_MAX_REQU_DATA 2 /*Max number of attemps performed when requesting data*/ +#define RETRY_SYSTEM_RESET 3 /*Max number of attemps performed to reset the IC*/ + +/*LOCKDOWN INFO*/ +#define LOCKDOWN_LENGTH 384 +#define LOCKDOWN_HEAD_LENGTH 4 +#define LOCKDOWN_DATA_OFFSET 20 +#define LOCKDOWN_SIGNATURE 0x5A +#define ADDR_LOCKDOWN ((u64)0x0000000000000000) +#define LOCKDOWN_WRITEREAD_CMD 0xA6 + +/** @addtogroup system_info +* @{ +*/ + +/** + * Struct which contains fundamental informations about the chip and its configuration + */ +typedef struct { + u16 u16_apiVer_rev; /*API revision version*/ + u8 u8_apiVer_minor; /*API minor version*/ + u8 u8_apiVer_major; /*API major version*/ + u16 u16_chip0Ver; /*Dev0 version*/ + u16 u16_chip0Id; /*Dev0 ID*/ + u16 u16_chip1Ver; /*Dev1 version*/ + u16 u16_chip1Id; /*Dev1 ID*/ + u16 u16_fwVer; /*Fw version*/ + u16 u16_svnRev; /*SVN Revision*/ + u16 u16_cfgVer; /*Config Version*/ + u16 u16_cfgProgectId; /*Config Project ID*/ + u16 u16_cxVer; /*Cx Version*/ + u16 u16_cxProjectId; /*Cx Project ID*/ + u8 u8_cfgAfeVer; /*AFE version in Config*/ + u8 u8_cxAfeVer; /*AFE version in CX*/ + u8 u8_panelCfgAfeVer; /*AFE version in PanelMem*/ + u8 u8_protocol; /*Touch Report Protocol*/ + u8 u8_dieInfo[DIE_INFO_SIZE]; /*Die information*/ + u8 u8_releaseInfo[RELEASE_INFO_SIZE]; /*Release information*/ + u32 u32_fwCrc; /*Crc of FW*/ + u32 u32_cfgCrc; /*Crc of config*/ + + u16 u16_scrResX; /*X resolution on main screen*/ + u16 u16_scrResY; /*Y resolution on main screen*/ + u8 u8_scrTxLen; /*Tx length*/ + u8 u8_scrRxLen; /*Rx length*/ + u8 u8_keyLen; /*Key Len*/ + u8 u8_forceLen; /*Force Len*/ + + u16 u16_dbgInfoAddr; /*Offset of debug Info structure*/ + + u16 u16_msTchRawAddr; /*Offset of MS touch raw frame*/ + u16 u16_msTchFilterAddr; /*Offset of MS touch filter frame*/ + u16 u16_msTchStrenAddr; /*Offset of MS touch strength frame*/ + u16 u16_msTchBaselineAddr; /*Offset of MS touch baseline frame*/ + + u16 u16_ssTchTxRawAddr; /*Offset of SS touch force raw frame*/ + u16 u16_ssTchTxFilterAddr; /*Offset of SS touch force filter frame*/ + u16 u16_ssTchTxStrenAddr; /*Offset of SS touch force strength frame*/ + u16 u16_ssTchTxBaselineAddr; /*Offset of SS touch force baseline frame*/ + + u16 u16_ssTchRxRawAddr; /*Offset of SS touch sense raw frame*/ + u16 u16_ssTchRxFilterAddr; /*Offset of SS touch sense filter frame*/ + u16 u16_ssTchRxStrenAddr; /*Offset of SS touch sense strength frame*/ + u16 u16_ssTchRxBaselineAddr; /*Offset of SS touch sense baseline frame*/ + + u16 u16_keyRawAddr; /*Offset of key raw frame*/ + u16 u16_keyFilterAddr; /*Offset of key filter frame*/ + u16 u16_keyStrenAddr; /*Offset of key strength frame*/ + u16 u16_keyBaselineAddr; /*Offset of key baseline frame*/ + + u16 u16_frcRawAddr; /*Offset of force touch raw frame*/ + u16 u16_frcFilterAddr; /*Offset of force touch filter frame*/ + u16 u16_frcStrenAddr; /*Offset of force touch strength frame*/ + u16 u16_frcBaselineAddr; /*Offset of force touch baseline frame*/ + + u16 u16_ssHvrTxRawAddr; /*Offset of SS hover Force raw frame*/ + u16 u16_ssHvrTxFilterAddr; /*Offset of SS hover Force filter frame*/ + u16 u16_ssHvrTxStrenAddr; /*Offset of SS hover Force strength frame*/ + u16 u16_ssHvrTxBaselineAddr; /*Offset of SS hover Force baseline frame*/ + + u16 u16_ssHvrRxRawAddr; /*Offset of SS hover Sense raw frame*/ + u16 u16_ssHvrRxFilterAddr; /*Offset of SS hover Sense filter frame*/ + u16 u16_ssHvrRxStrenAddr; /*Offset of SS hover Sense strength frame*/ + u16 u16_ssHvrRxBaselineAddr; /*Offset of SS hover Sense baseline frame*/ + + u16 u16_ssPrxTxRawAddr; /*Offset of SS proximity force raw frame*/ + u16 u16_ssPrxTxFilterAddr; /*Offset of SS proximity force filter frame*/ + u16 u16_ssPrxTxStrenAddr; /*Offset of SS proximity force strength frame*/ + u16 u16_ssPrxTxBaselineAddr; /*Offset of SS proximity force baseline frame*/ + + u16 u16_ssPrxRxRawAddr; /*Offset of SS proximity sense raw frame*/ + u16 u16_ssPrxRxFilterAddr; /*Offset of SS proximity sense filter frame*/ + u16 u16_ssPrxRxStrenAddr; /*Offset of SS proximity sense strength frame*/ + u16 u16_ssPrxRxBaselineAddr; /*Offset of SS proximity sense baseline frame*/ +} SysInfo; + +/** @}*/ + +int initCore(struct fts_ts_info *info); +void setResetGpio(int gpio); +int fts_system_reset(void); +int isSystemResettedUp(void); +int isSystemResettedDown(void); +void setSystemResetedUp(int val); +void setSystemResetedDown(int val); +int pollForEvent(int *event_to_search, int event_bytes, u8 *readData, int time_to_wait); +int checkEcho(u8 *cmd, int size); +int setScanMode(u8 mode, u8 settings); +int setFeatures(u8 feat, u8 *settings, int size); +int defaultSysInfo(int i2cError); +int writeSysCmd(u8 sys_cmd, u8 *sett, int size); +int readSysInfo(int request); +int readConfig(u16 offset, u8 *outBuf, int len); +int fts_disableInterrupt(void); +int fts_disableInterruptNoSync(void); +int fts_resetDisableIrqCount(void); +int fts_enableInterrupt(void); +int fts_crc_check(void); +int requestSyncFrame(u8 type); +int fts_get_lockdown_info(u8 *lockData, struct fts_ts_info *info); +int writeLockDownInfo(u8 *data, int size, u8 lock_id); +int readLockDownInfo(u8 *lockData, u8 lock_id, int size); + +#endif /* FTS_CORE_H */ diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsError.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsError.c new file mode 100644 index 000000000000..0435875f8533 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsError.c @@ -0,0 +1,357 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS error/info kernel log reporting * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsError.c +* \brief Contains all the function which handle with Error conditions +*/ + +#include +#include +#include +#include +#include + +#include "../fts.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsIO.h" +#include "ftsTool.h" +#include "ftsCompensation.h" + +static ErrorList errors; + +/** +* Print messages in the kernel log +* @param force if 1, the log is printed always otherwise only if DEBUG is defined, the log will be printed +* @param msg string containing the message to print +* @param ... additional parameters that are used in msg according the format of printf +*/ +void logError(int force, const char *msg, ...) +{ + if (force == 1 +#ifdef DEBUG + || 1 +#endif + ) { + va_list args; + va_start(args, msg); + vprintk(msg, args); + va_end(args); + } +} + +/** +* Check if an error code is related to an I2C failure +* @param error error code to check +* @return 1 if the first level error code is I2C related otherwise 0 +*/ +int isI2cError(int error) +{ + if (((error & 0x000000FF) >= (ERROR_BUS_R & 0x000000FF)) && + ((error & 0x000000FF) <= (ERROR_BUS_O & 0x000000FF))) + return 1; + else + return 0; +} + +/** + * Dump in the kernel log some debug info in case of FW hang + * @param outBuf (optional)pointer to bytes array where to copy the debug info, if NULL the data will just printed on the kernel log + * @param size dimension in bytes of outBuf, if > ERROR_DUMP_ROW_SIZE*ERROR_DUMP_COL_SIZE, only the first ERROR_DUMP_ROW_SIZE*ERROR_DUMP_COL_SIZE bytes will be copied + * @return OK if success or an error code which specify the type of error encountered + */ +int dumpErrorInfo(u8 *outBuf, int size) +{ + int ret, i; + u8 data[ERROR_DUMP_ROW_SIZE * ERROR_DUMP_COL_SIZE] = { 0 }; + u32 sign = 0; + + logError(0, "%s %s: Starting dump of error info...\n", tag, __func__); + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, ADDR_ERROR_DUMP, + data, ERROR_DUMP_ROW_SIZE * ERROR_DUMP_COL_SIZE, + DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s %s: reading data ERROR %08X\n", tag, __func__, + ret); + return ret; + } else { + if (outBuf != NULL) { + sign = + size > + ERROR_DUMP_ROW_SIZE * + ERROR_DUMP_COL_SIZE ? ERROR_DUMP_ROW_SIZE * + ERROR_DUMP_COL_SIZE : size; + memcpy(outBuf, data, sign); + logError(0, + "%s %s: error info copied in the buffer! \n", + tag, __func__); + } + logError(1, "%s %s: Error Info = \n", tag, __func__); + u8ToU32(data, &sign); + if (sign != ERROR_DUMP_SIGNATURE) + logError(1, + "%s %s: Wrong Error Signature! Data may be invalid! \n", + tag, __func__); + else + logError(1, + "%s %s: Error Signature OK! Data are valid! \n", + tag, __func__); + + for (i = 0; i < ERROR_DUMP_ROW_SIZE * ERROR_DUMP_COL_SIZE; i++) { + if (i % ERROR_DUMP_COL_SIZE == 0) { + logError(1, KERN_ERR "\n%s %s: %d) ", tag, + __func__, i / ERROR_DUMP_COL_SIZE); + } + logError(1, "%02X ", data[i]); + } + logError(1, "\n"); + + logError(0, "%s %s: dump of error info FINISHED!\n", tag, + __func__); + return OK; + } + +} + +/** +* Implement recovery strategies to be used when an error event is found while polling the FIFO +* @param event error event found during the polling +* @param size size of event +* @return OK if the error event doesn't require any action or the recovery strategy doesn't have any impact in the possible procedure that trigger the error, otherwise return an error code which specify the kind of error encountered. If ERROR_HANDLER_STOP_PROC the calling function must stop! +*/ +int errorHandler(u8 *event, int size) +{ + int res = OK; + struct fts_ts_info *info = NULL; + + if (getDev() != NULL) + info = dev_get_drvdata(getDev()); + + if (info != NULL && event != NULL && size > 1 + && event[0] == EVT_ID_ERROR) { + logError(0, "%s errorHandler: Starting handling...\n", tag); + addErrorIntoList(event, size); + switch (event[1]) { + case EVT_TYPE_ERROR_ESD: + res = fts_chip_powercycle(info); + if (res < OK) { + logError(1, + "%s errorHandler: Error performing powercycle ERROR %08X\n", + tag, res); + } + + res = fts_system_reset(); + if (res < OK) { + logError(1, + "%s errorHandler: Cannot reset the device ERROR %08X\n", + tag, res); + } + res = (ERROR_HANDLER_STOP_PROC | res); + break; + + case EVT_TYPE_ERROR_WATCHDOG: + dumpErrorInfo(NULL, 0); + res = fts_system_reset(); + if (res < OK) { + logError(1, + "%s errorHandler: Cannot reset the device ERROR %08X\n", + tag, res); + } + res = (ERROR_HANDLER_STOP_PROC | res); + break; + + case EVT_TYPE_ERROR_ITO_FORCETOGND: + logError(1, "%s errorHandler: Force Short to GND!\n", + tag); + break; + case EVT_TYPE_ERROR_ITO_SENSETOGND: + logError(1, "%s errorHandler: Sense short to GND! \n", + tag); + break; + case EVT_TYPE_ERROR_ITO_FORCETOVDD: + logError(1, "%s errorHandler: Force short to VDD!\n", + tag); + break; + case EVT_TYPE_ERROR_ITO_SENSETOVDD: + logError(1, "%s errorHandler: Sense short to VDD!\n", + tag); + break; + case EVT_TYPE_ERROR_ITO_FORCE_P2P: + logError(1, + "%s errorHandler: Force Pin to Pin Short!\n", + tag); + break; + case EVT_TYPE_ERROR_ITO_SENSE_P2P: + logError(1, + "%s errorHandler: Sense Pin to Pin Short!\n", + tag); + break; + case EVT_TYPE_ERROR_ITO_FORCEOPEN: + logError(1, "%s errorHandler: Force Open !\n", tag); + break; + case EVT_TYPE_ERROR_ITO_SENSEOPEN: + logError(1, "%s errorHandler: Sense Open !\n", tag); + break; + case EVT_TYPE_ERROR_ITO_KEYOPEN: + logError(1, "%s errorHandler: Key Open !\n", tag); + break; + + default: + logError(0, "%s errorHandler: No Action taken! \n", + tag); + break; + + } + logError(0, "%s errorHandler: handling Finished! res = %08X\n", + tag, res); + return res; + } else { + logError(1, + "%s errorHandler: event Null or not correct size! ERROR %08X \n", + tag, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + +} + +/** +* Add an error event into the Error List +* @param event error event to add +* @param size size of event +* @return OK +*/ +int addErrorIntoList(u8 *event, int size) +{ + int i = 0; + + logError(0, "%s Adding error in to ErrorList... \n", tag); + + memcpy(&errors.list[errors.last_index * FIFO_EVENT_SIZE], event, size); + i = FIFO_EVENT_SIZE - size; + if (i > 0) { + logError(0, + "%s Filling last %d bytes of the event with zero...\n", + tag, i); + memset(&errors.list[errors.last_index * FIFO_EVENT_SIZE + size], + 0, i); + } + logError(0, "%s Adding error in to ErrorList... FINISHED!\n", tag); + + errors.count += 1; + if (errors.count > FIFO_DEPTH) + logError(1, + "%s ErrorList is going in overflow... the first %d event(s) were override!\n", + tag, errors.count - FIFO_DEPTH); + errors.last_index = (errors.last_index + 1) % FIFO_DEPTH; + + return OK; +} + +/** +* Reset the Error List setting the count and last_index to 0. +* @return OK +*/ +int resetErrorList(void) +{ + errors.count = 0; + errors.last_index = 0; + memset(errors.list, 0, FIFO_DEPTH * FIFO_EVENT_SIZE); + return OK; +} + +/** +* Get the number of error events copied into the Error List +* @return the number of error events into the Error List +*/ +int getErrorListCount(void) +{ + if (errors.count > FIFO_DEPTH) + return FIFO_DEPTH; + else + return errors.count; +} + + +/** +* Scroll the Error List looking for the event specified +* @param event_to_search event_to_search pointer to an array of int where each element correspond to a byte of the event to find. If the element of the array has value -1, the byte of the event, in the same position of the element is ignored. +* @param event_bytes size of event_to_search +* @return a value >=0 if the event is found which represent the index of the Error List where the event is located otherwise an error code +*/ +int pollErrorList(int *event_to_search, int event_bytes) +{ + int i = 0, j = 0, find = 0; + int count = getErrorListCount(); + + logError(0, "%s Starting to poll ErrorList... \n", tag); + while (find != 1 && i < count) { + find = 1; + for (j = 0; j < event_bytes; j++) { + + if (event_to_search[i] != -1 + && (int)errors.list[i * FIFO_EVENT_SIZE + j] != + event_to_search[i]) { + find = 0; + break; + } + } + i++; + } + if (find == 1) { + logError(1, "%s Error Found into ErrorList! \n", tag); + return i - 1; + } else { + logError(0, "%s Error Not Found into ErrorList! ERROR %08X \n", + tag, ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } +} + +/** +* Poll the Error List looking for any error types passed in the arguments. Return at the first match! +* @param list pointer to a list of error types to look for +* @param size size of list +* @return error type found if success or ERROR_TIMEOUT +*/ +int pollForErrorType(u8 *list, int size) +{ + int i = 0, j = 0, find = 0; + int count = getErrorListCount(); + + logError(0, "%s %s: Starting to poll ErrorList... count = %d \n", tag, + __func__, count); + while (find != 1 && i < count) { + for (j = 0; j < size; j++) { + if (list[j] == errors.list[i * FIFO_EVENT_SIZE + 1]) { + find = 1; + break; + } + } + i++; + } + if (find == 1) { + logError(1, "%s %s: Error Type %02X into ErrorList! \n", tag, + __func__, list[j]); + return list[j]; + } else { + logError(0, + "%s %s: Error Type Not Found into ErrorList! ERROR %08X \n", + tag, __func__, ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsError.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsError.h new file mode 100644 index 000000000000..206a0b3ad400 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsError.h @@ -0,0 +1,145 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS error/info kernel log reporting * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsError.h +* \brief Contains all the definitions and structs which refer to Error conditions +*/ + +#ifndef FTS_ERROR_H +#define FTS_ERROR_H + +#include "ftsHardware.h" +#include "ftsSoftware.h" + +/** @defgroup error_codes Error Codes + * Error codes that can be reported by the driver functions. + * An error code is made up by 4 bytes, each byte indicate a logic error level.\n + * From the LSB to the MSB, the logic level increase going from a low level error (I2C,TIMEOUT) to an high level error (flashing procedure fail, production test fail etc) + * @{ + */ + +/*FIRST LEVEL ERROR CODE*/ +/** @defgroup first_level First Level Error Code +* @ingroup error_codes +* Errors related to low level operation which are not under control of driver, such as: communication protocol (I2C/SPI), timeout, file operations ... +* @{ +*/ +#define OK ((int)0x00000000) /*No ERROR*/ +#define ERROR_ALLOC ((int)0x80000001) /*allocation of memory failed*/ +#define ERROR_BUS_R ((int)0x80000002) /*i2c/spi read failed*/ +#define ERROR_BUS_W ((int)0x80000003) /*i2c/spi write failed*/ +#define ERROR_BUS_WR ((int)0x80000004) /*i2c/spi write/read failed*/ +#define ERROR_BUS_O ((int)0x80000005) /*error during opening an i2c device*/ +#define ERROR_OP_NOT_ALLOW ((int)0x80000006) /*operation not allowed*/ +#define ERROR_TIMEOUT ((int)0x80000007) /*timeout expired! exceed the max number of retries or the max waiting time*/ +#define ERROR_FILE_NOT_FOUND ((int)0x80000008) /*the file that i want to open is not found*/ +#define ERROR_FILE_PARSE ((int)0x80000009) /*error during parsing the file*/ +#define ERROR_FILE_READ ((int)0x8000000A) /*error during reading the file*/ +#define ERROR_LABEL_NOT_FOUND ((int)0x8000000B) /*label not found*/ +#define ERROR_FW_NO_UPDATE ((int)0x8000000C) /*fw in the chip newer than the one in the memmh*/ +#define ERROR_FLASH_UNKNOWN ((int)0x8000000D) /*flash status busy or unknown*/ +/** @}*/ + +/*SECOND LEVEL ERROR CODE */ +/** @defgroup second_level Second Level Error Code +* @ingroup error_codes +* Errors related to simple logic operations in the IC which require one command or which are part of a more complex procedure +* @{ +*/ +#define ERROR_DISABLE_INTER ((int)0x80000200) /*unable to disable the interrupt*/ +#define ERROR_ENABLE_INTER ((int)0x80000300) /*unable to activate the interrup*/ +#define ERROR_READ_CONFIG ((int)0x80000400) /*failed to read config memory*/ +#define ERROR_GET_OFFSET ((int)0x80000500) /*unable to read an offset from memory*/ +#define ERROR_GET_FRAME_DATA ((int)0x80000600) /*unable to retrieve the data of a required frame*/ +#define ERROR_DIFF_DATA_TYPE ((int)0x80000700) /*FW answers with an event that has a different address respect the request done*/ +#define ERROR_WRONG_DATA_SIGN ((int)0x80000800) /*the signature of the host data is not HEADER_SIGNATURE*/ +#define ERROR_SET_SCAN_MODE_FAIL ((int)0x80000900) /*setting the scanning mode failed (sense on/off etc...)*/ +#define ERROR_SET_FEATURE_FAIL ((int)0x80000A00) /*setting a specific feature failed*/ +#define ERROR_SYSTEM_RESET_FAIL ((int)0x80000B00) /*the comand SYSTEM RESET failed*/ +#define ERROR_FLASH_NOT_READY ((int)0x80000C00) /*flash status not ready within a timeout*/ +#define ERROR_FW_VER_READ ((int)0x80000D00) /*unable to retrieve fw_vers or the config_id*/ +#define ERROR_GESTURE_ENABLE_FAIL ((int)0x80000E00) /*unable to enable/disable the gesture*/ +#define ERROR_GESTURE_START_ADD ((int)0x80000F00) /*unable to start to add custom gesture*/ +#define ERROR_GESTURE_FINISH_ADD ((int)0x80001000) /*unable to finish to add custom gesture*/ +#define ERROR_GESTURE_DATA_ADD ((int)0x80001100) /*unable to add custom gesture data*/ +#define ERROR_GESTURE_REMOVE ((int)0x80001200) /*unable to remove custom gesture data*/ +#define ERROR_FEATURE_ENABLE_DISABLE ((int)0x80001300) /*unable to enable/disable a feature mode in the IC*/ +#define ERROR_NOISE_PARAMETERS ((int)0x80001400) /*unable to set/read noise parameter in the IC*/ +#define ERROR_CH_LEN ((int)0x80001500) /*unable to retrieve the force and/or sense length*/ +/** @}*/ + +/*THIRD LEVEL ERROR CODE */ +/** @defgroup third_level Third Level Error Code +* @ingroup error_codes +* Errors related to logic operations in the IC which require more commands/steps or which are part of a more complex procedure +* @{ +*/ +#define ERROR_REQU_COMP_DATA ((int)0x80010000) /*compensation data request failed*/ +#define ERROR_REQU_DATA ((int)0x80020000) /*data request failed*/ +#define ERROR_COMP_DATA_HEADER ((int)0x80030000) /*unable to retrieve the compensation data header*/ +#define ERROR_COMP_DATA_GLOBAL ((int)0x80040000) /*unable to retrieve the global compensation data*/ +#define ERROR_COMP_DATA_NODE ((int)0x80050000) /*unable to retrieve the compensation data for each node*/ +#define ERROR_TEST_CHECK_FAIL ((int)0x80060000) /*check of production limits or of fw answers failed*/ +#define ERROR_MEMH_READ ((int)0x80070000) /*memh reading failed*/ +#define ERROR_FLASH_BURN_FAILED ((int)0x80080000) /*flash burn failed*/ +#define ERROR_MS_TUNING ((int)0x80090000) /*ms tuning failed*/ +#define ERROR_SS_TUNING ((int)0x800A0000) /*ss tuning failed*/ +#define ERROR_LP_TIMER_TUNING ((int)0x800B0000) /*lp timer calibration failed*/ +#define ERROR_SAVE_CX_TUNING ((int)0x800C0000) /*save cx data to flash failed*/ +#define ERROR_HANDLER_STOP_PROC ((int)0x800D0000) /*stop the poll of the FIFO if particular errors are found*/ +#define ERROR_CHECK_ECHO_FAIL ((int)0x800E0000) /*unable to retrieve echo event*/ +#define ERROR_GET_FRAME ((int)0x800F0000) /*unable to get frame*/ +/** @}*/ + +/*FOURTH LEVEL ERROR CODE*/ +/** @defgroup fourth_level Fourth Level Error Code +* @ingroup error_codes +* Errors related to the highest logic operations in the IC which have an important impact on the driver flow or which require several commands and steps to be executed +* @{ +*/ +#define ERROR_PROD_TEST_DATA ((int)0x81000000) /*production data test failed*/ +#define ERROR_FLASH_PROCEDURE ((int)0x82000000) /*fw update procedure failed*/ +#define ERROR_PROD_TEST_ITO ((int)0x83000000) /*production ito test failed*/ +#define ERROR_PROD_TEST_INITIALIZATION ((int)0x84000000) /*production initialization test failed*/ +#define ERROR_GET_INIT_STATUS ((int)0x85000000) /*mismatch of the MS or SS tuning_version*/ +#define ERROR_LOCKDOWN_CODE ((int)0x80001600) /*unable to write/rewrite/read lockdown code in the IC*/ + +#define EVT_TYPE_ERROR_LOCKDOWN_FLASH 0x30 /*FW shall not proceed with any flash write/read*/ +#define EVT_TYPE_ERROR_LOCKDOWN_CRC 0x31 /*FW shall discard the record and do not write to flash*/ +#define EVT_TYPE_ERROR_LOCKDOWN_NO_DATA 0x32 /*No data of this type exisitng in flash*/ +#define EVT_TYPE_ERROR_LOCKDOWN_WRITE_FULL 0x33 /*FW shall not write this new record to flash*/ +/** @}*/ + +/** +* Struct which store an ordered list of the errors events encountered during the polling of a FIFO. +* The max number of error events that can be stored is equal to FIFO_DEPTH +*/ +typedef struct { + u8 list[FIFO_DEPTH * FIFO_EVENT_SIZE]; /*byte array which contains the series of error events encountered from the last reset of the list.*/ + int count; /*number of error events stored in the list*/ + int last_index; /*index of the list where will be stored the next error event. Subtract -1 to have the index of the last error event!*/ +} ErrorList; + +void logError(int force, const char *msg, ...); +int isI2cError(int error); +int dumpErrorInfo(u8 *outBuf, int size); +int errorHandler(u8 *event, int size); +int addErrorIntoList(u8 *event, int size); +int getErrorListCount(void); +int resetErrorList(void); +int pollErrorList(int *event_to_search, int event_bytes); +int pollForErrorType(u8 *list, int size); +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.c new file mode 100644 index 000000000000..de7ae36591ae --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.c @@ -0,0 +1,1032 @@ +/* + + ************************************************************************** + ** STMicroelectronics ** + ************************************************************************** + ** marco.cali@st.com ** + ************************************************************************** + * * + * FTS API for Flashing the IC * + * * + ************************************************************************** + ************************************************************************** + + */ + +/*! +* \file ftsFlash.c +* \brief Contains all the functions to handle the FW update process +*/ + +#include "ftsCore.h" +#include "ftsCompensation.h" +#include "ftsError.h" +#include "ftsFlash.h" +#include "ftsFrame.h" +#include "ftsIO.h" +#include "ftsSoftware.h" +#include "ftsTest.h" +#include "ftsTime.h" +#include "ftsTool.h" +#include "../fts.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef FW_H_FILE +#include "../fts_fw.h" +#endif + +extern SysInfo systemInfo; +extern struct fts_ts_info *fts_info; + +/** + * Read the fw version and config id from the chip + * @param fw_vers pointer to the variable which will contains the fw version + * @param config_id pointer to the variable which will contains the config id + * @return OK if success or an error code which specify the type of error encountered + */ +int getFirmwareVersion(u16 *fw_vers, u16 *config_id) +{ + u8 fwvers[DCHIP_FW_VER_BYTE]; + u8 confid[CONFIG_ID_BYTE]; + int res; + + res = + fts_writeReadU8UX(FTS_CMD_HW_REG_R, ADDR_SIZE_HW_REG, + ADDR_DCHIP_FW_VER, fwvers, DCHIP_FW_VER_BYTE, + DUMMY_HW_REG); + if (res < OK) { + logError(1, + "%s getFirmwareVersion: unable to read fw_version ERROR %08X\n", + tag, ERROR_FW_VER_READ); + return (res | ERROR_FW_VER_READ); + } + + u8ToU16(fwvers, fw_vers); + if (*fw_vers != 0) { + res = readConfig(ADDR_CONFIG_ID, confid, CONFIG_ID_BYTE); + if (res < OK) { + logError(1, + "%s getFirmwareVersion: unable to read config_id ERROR %08X\n", + tag, ERROR_FW_VER_READ); + return (res | ERROR_FW_VER_READ); + } + u8ToU16(confid, config_id); + } else { + *config_id = 0x0000; + } + + logError(0, "%s FW VERS = %04X\n", tag, *fw_vers); + logError(0, "%s CONFIG ID = %04X\n", tag, *config_id); + return OK; + +} + +/** +* Retrieve the actual FW data from the system (bin file or header file) +* @param pathToFile name of FW file to load or "NULL" if the FW data should be loaded by a .h file +* @param data pointer to the pointer which will contains the FW data +* @param size pointer to a variable which will contain the size of the loaded data +* @return OK if success or an error code which specify the type of error encountered +*/ +int getFWdata(const char *pathToFile, u8 **data, int *size) +{ + const struct firmware *fw = NULL; + struct device *dev = NULL; + int res, from = 0; + char *path = (char *)pathToFile; + + logError(1, "%s getFWdata starting ...\n", tag); + if (strncmp(pathToFile, "NULL", 4) == 0) { + from = 1; + path = (char *)fts_info->board->default_fw_name; + } + switch (from) { +#ifdef FW_H_FILE + case 1: + logError(1, "%s Read FW from .h file!\n", tag); + *size = FW_SIZE_NAME; + *data = (u8 *) kmalloc((*size) * sizeof(u8), GFP_KERNEL); + if (*data == NULL) { + logError(1, + "%s getFWdata: Impossible to allocate memory! ERROR %08X\n", + tag, ERROR_ALLOC); + return ERROR_ALLOC; + } + memcpy(*data, (u8 *) FW_ARRAY_NAME, (*size)); + + break; +#endif + default: + logError(1, "%s Read FW from BIN file %s !\n", tag, path); + dev = getDev(); + + if (dev != NULL) { + res = request_firmware(&fw, path, dev); + if (res == 0) { + *size = fw->size; + *data = + (u8 *) kmalloc((*size) * sizeof(u8), + GFP_KERNEL); + if (*data == NULL) { + logError(1, + "%s getFWdata: Impossible to allocate memory! ERROR %08X\n", + tag, ERROR_ALLOC); + release_firmware(fw); + return ERROR_ALLOC; + } + memcpy(*data, (u8 *) fw->data, (*size)); + release_firmware(fw); + } else { + logError(1, + "%s getFWdata: No File found! ERROR %08X\n", + tag, ERROR_FILE_NOT_FOUND); + return ERROR_FILE_NOT_FOUND; + } + + } else { + logError(1, + "%s getFWdata: No device found! ERROR %08X\n", + tag, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + } + + logError(1, "%s getFWdata Finished!\n", tag); + return OK; + +} + +/** +* Perform all the steps to read the FW that should be burnt in the IC from the system and parse it in order to fill a Firmware struct with the relevant info +* @param path name of FW file to load or "NULL" if the FW data should be loaded by a .h file +* @param fw pointer to a Firmware variable which will contains the FW data and info +* @param keep_cx if 1, the CX area will be loaded otherwise will be skipped +* @return OK if success or an error code which specify the type of error encountered +*/ +int readFwFile(const char *path, Firmware *fw, int keep_cx) +{ + int res; + int orig_size; + u8 *orig_data = NULL; + + res = getFWdata(path, &orig_data, &orig_size); + if (res < OK) { + logError(1, + "%s readFwFile: impossible retrieve FW... ERROR %08X\n", + tag, ERROR_MEMH_READ); + return (res | ERROR_MEMH_READ); + } + res = parseBinFile(orig_data, orig_size, fw, keep_cx); + if (res < OK) { + logError(1, "%s readFwFile: impossible parse ERROR %08X\n", tag, + ERROR_MEMH_READ); + return (res | ERROR_MEMH_READ); + } + + return OK; + +} + +/** +* Perform all the steps necessary to burn the FW into the IC +* @param path name of FW file to load or "NULL" if the FW data should be loaded by a .h file +* @param force if 1, the flashing procedure will be forced and executed regardless the additional info, otherwise the FW in the file will be burnt only if it is newer than the one running in the IC +* @param keep_cx if 1, the CX area will be loaded and burnt otherwise will be skipped and the area will be untouched +* @return OK if success or an error code which specify the type of error encountered +*/ +int flashProcedure(const char *path, int force, int keep_cx) +{ + Firmware fw; + int res; + + fw.data = NULL; + logError(0, "%s Reading Fw file... \n", tag); + res = readFwFile(path, &fw, keep_cx); + if (res < OK) { + logError(1, "%s flashProcedure: ERROR %08X \n", tag, + (res | ERROR_FLASH_PROCEDURE)); + kfree(fw.data); + return (res | ERROR_FLASH_PROCEDURE); + } + logError(0, "%s Fw file read COMPLETED! \n", tag); + + logError(0, "%s Starting flashing procedure... \n", tag); + res = flash_burn(fw, force, keep_cx); + if (res < OK && res != (ERROR_FW_NO_UPDATE | ERROR_FLASH_BURN_FAILED)) { + logError(1, "%s flashProcedure: ERROR %08X \n", tag, + ERROR_FLASH_PROCEDURE); + kfree(fw.data); + return (res | ERROR_FLASH_PROCEDURE); + } + logError(0, "%s flashing procedure Finished!\n", tag); + kfree(fw.data); + + return res; +} + + +/** +* Poll the Flash Status Registers after the execution of a command to check if the Flash becomes ready within a timeout +* @param type register to check according to the previous command sent +* @return OK if success or an error code which specify the type of error encountered +*/ +int wait_for_flash_ready(u8 type) +{ + + u8 cmd[5] = { FTS_CMD_HW_REG_R, 0x20, 0x00, 0x00, type }; + + u8 readData[2] = { 0 }; + int i, res = -1; + + logError(0, "%s Waiting for flash ready ... \n", tag); + for (i = 0; i < FLASH_RETRY_COUNT && res != 0; i++) { + res = fts_writeRead_dma_safe(cmd, ARRAY_SIZE(cmd), readData, 2); + if (res < OK) { + logError(1, "%s wait_for_flash_ready: ERROR % 08X\n", + tag, ERROR_BUS_W); + } else { +#ifdef I2C_INTERFACE + res = readData[0] & 0x80; +#else + res = readData[1] & 0x80; +#endif + + logError(0, "%s flash status = %d \n", tag, res); + } + mdelay(FLASH_WAIT_BEFORE_RETRY); + } + + if (i == FLASH_RETRY_COUNT && res != 0) { + logError(1, "%s Wait for flash TIMEOUT! ERROR %08X \n", tag, + ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } + + logError(0, "%s Flash READY! \n", tag); + return OK; +} + +/** + * Put the M3 in hold + * @return OK if success or an error code which specify the type of error encountered + */ +int hold_m3(void) +{ + int ret; + u8 cmd[1] = { 0x01 }; + + logError(0, "%s Command m3 hold... \n", tag); + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, ADDR_SYSTEM_RESET, + cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: ERROR %08X\n", tag, ret); + return ret; + } + logError(0, "%s Hold M3 DONE! \n", tag); + +#if !defined(I2C_INTERFACE) && defined(SPI4_WIRE) + logError(0, "%s Setting SPI4 mode... \n", tag); + cmd[0] = 0x10; + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, + ADDR_GPIO_DIRECTION, cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: can not set gpio dir ERROR %08X\n", + tag, ret); + return ret; + } + + cmd[0] = 0x02; + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, ADDR_GPIO_PULLUP, + cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: can not set gpio pull-up ERROR %08X\n", + tag, ret); + return ret; + } + + cmd[0] = 0x07; + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, + ADDR_GPIO_CONFIG_REG2, cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: can not set gpio config ERROR %08X\n", + tag, ret); + return ret; + } + + cmd[0] = 0x30; + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, + ADDR_GPIO_CONFIG_REG0, cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: can not set gpio config ERROR %08X\n", + tag, ret); + return ret; + } + + cmd[0] = SPI4_MASK; + ret = + fts_writeU8UX(FTS_CMD_HW_REG_W, ADDR_SIZE_HW_REG, ADDR_ICR, cmd, 1); + if (ret < OK) { + logError(1, "%s hold_m3: can not set spi4 mode ERROR %08X\n", + tag, ret); + return ret; + } + mdelay(1); +#endif + + return OK; +} + +/** +* Parse the raw data read from a FW file in order to fill properly the fields of a Firmware variable +* @param fw_data raw FW data loaded from system +* @param fw_size size of fw_data +* @param fwData pointer to a Firmware variable which will contain the processed data +* @param keep_cx if 1, the CX area will be loaded and burnt otherwise will be skipped and the area will be untouched +* @return OK if success or an error code which specify the type of error encountered +*/ +int parseBinFile(u8 *fw_data, int fw_size, Firmware *fwData, int keep_cx) +{ + + int dimension, index = 0; + u32 temp; + int res, i; + + if (fw_size < FW_HEADER_SIZE + FW_BYTES_ALLIGN || fw_data == NULL) { + logError(1, + "%s parseBinFile: Read only %d instead of %d... ERROR %08X\n", + tag, fw_size, FW_HEADER_SIZE + FW_BYTES_ALLIGN, + ERROR_FILE_PARSE); + res = ERROR_FILE_PARSE; + goto END; + } else { + u8ToU32(&fw_data[index], &temp); + if (temp != FW_HEADER_SIGNATURE) { + logError(1, + "%s parseBinFile: Wrong Signature %08X ... ERROR %08X\n", + tag, temp, ERROR_FILE_PARSE); + res = ERROR_FILE_PARSE; + goto END; + } + logError(0, "%s parseBinFile: Fw Signature OK!\n", tag); + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + if (temp != FW_FTB_VER) { + logError(1, + "%s parseBinFile: Wrong ftb_version %08X ... ERROR %08X\n", + tag, temp, ERROR_FILE_PARSE); + res = ERROR_FILE_PARSE; + goto END; + } + logError(0, "%s parseBinFile: ftb_version OK!\n", tag); + index += FW_BYTES_ALLIGN; + if (fw_data[index] != DCHIP_ID_0 + || fw_data[index + 1] != DCHIP_ID_1) { + logError(1, + "%s parseBinFile: Wrong target %02X != %02X %02X != %02X ... ERROR %08X\n", + tag, fw_data[index], DCHIP_ID_0, + fw_data[index + 1], DCHIP_ID_1, + ERROR_FILE_PARSE); + res = ERROR_FILE_PARSE; + goto END; + } + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + logError(1, "%s parseBinFile: FILE SVN REV = %08X\n", tag, + temp); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + fwData->fw_ver = temp; + logError(1, "%s parseBinFile: FILE Fw Version = %04X\n", tag, + fwData->fw_ver); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + fwData->config_id = temp; + logError(1, "%s parseBinFile: FILE Config Project ID = %08X\n", + tag, temp); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + logError(1, "%s parseBinFile: FILE Config Version = %08X\n", + tag, temp); + + index += FW_BYTES_ALLIGN * 2; + + index += FW_BYTES_ALLIGN; + logError(1, "%s parseBinFile: File External Release = ", tag); + for (i = 0; i < EXTERNAL_RELEASE_INFO_SIZE; i++) { + fwData->externalRelease[i] = fw_data[index++]; + logError(1, "%02X ", fwData->externalRelease[i]); + } + logError(1, "\n"); + + u8ToU32(&fw_data[index], &temp); + fwData->sec0_size = temp; + logError(1, "%s parseBinFile: sec0_size = %08X (%d bytes)\n", + tag, fwData->sec0_size, fwData->sec0_size); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + fwData->sec1_size = temp; + logError(1, "%s parseBinFile: sec1_size = %08X (%d bytes)\n", + tag, fwData->sec1_size, fwData->sec1_size); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + fwData->sec2_size = temp; + logError(1, "%s parseBinFile: sec2_size = %08X (%d bytes) \n", + tag, fwData->sec2_size, fwData->sec2_size); + + index += FW_BYTES_ALLIGN; + u8ToU32(&fw_data[index], &temp); + fwData->sec3_size = temp; + logError(1, "%s parseBinFile: sec3_size = %08X (%d bytes) \n", + tag, fwData->sec3_size, fwData->sec3_size); + + index += FW_BYTES_ALLIGN; + + dimension = + fwData->sec0_size + fwData->sec1_size + fwData->sec2_size + + fwData->sec3_size; + temp = fw_size; + + if (dimension + FW_HEADER_SIZE + FW_BYTES_ALLIGN != temp) { + logError(1, + "%s parseBinFile: Read only %d instead of %d... ERROR %08X\n", + tag, fw_size, + dimension + FW_HEADER_SIZE + FW_BYTES_ALLIGN, + ERROR_FILE_PARSE); + res = ERROR_FILE_PARSE; + goto END; + } + + fwData->data = + (u8 *) kmalloc(dimension * sizeof(u8), GFP_KERNEL); + if (fwData->data == NULL) { + logError(1, "%s parseBinFile: ERROR %08X\n", tag, + ERROR_ALLOC); + res = ERROR_ALLOC; + goto END; + } + + index += FW_BYTES_ALLIGN; + memcpy(fwData->data, &fw_data[index], dimension); + if (fwData->sec2_size != 0) { + u8ToU16(&fwData->data + [fwData->sec0_size + fwData->sec1_size + + FW_CX_VERSION], &fwData->cx_ver); + + } else { + logError(1, + "%s parseBinFile: Initialize cx_ver to default value! \n", + tag); + fwData->cx_ver = systemInfo.u16_cxVer; + } + + logError(1, "%s parseBinFile: CX Version = %04X \n", tag, + fwData->cx_ver); + + fwData->data_size = dimension; + + logError(0, "%s READ FW DONE %d bytes!\n", tag, + fwData->data_size); + res = OK; + goto END; + } + +END: + kfree(fw_data); + return res; +} + +/** + * Enable UVLO and Auto Power Down Mode + * @return OK if success or an error code which specify the type of error + */ +int flash_enable_uvlo_autopowerdown(void) +{ + u8 cmd[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_UVLO_ENABLE_CODE0, + FLASH_UVLO_ENABLE_CODE1 }; + u8 cmd1[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_AUTOPOWERDOWN_ENABLE_CODE0, + FLASH_AUTOPOWERDOWN_ENABLE_CODE1 }; + logError(0, "%s Command enable uvlo ...\n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s flash_enable_uvlo_autopowerdown: ERROR %08X\n", tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + if (fts_write_dma_safe(cmd1, ARRAY_SIZE(cmd1)) < OK) { + logError(1, "%s flash_enable_uvlo_autopowerdown: ERROR %08X\n", tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + logError(0, "%s Enable uvlo and flash auto power down DONE!\n", tag); + return OK; +} +/** + * Unlock the flash to be programmed + * @return OK if success or an error code which specify the type of error + */ +int flash_unlock(void) +{ + + u8 cmd[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_UNLOCK_CODE0, + FLASH_UNLOCK_CODE1 }; + + u8 cmd1[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_UNLOCK_CODE2, + FLASH_UNLOCK_CODE3 }; + + logError(0, "%s Command unlock ...\n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s flash_unlock: ERROR %08X\n", tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + + if (fts_write_dma_safe(cmd1, ARRAY_SIZE(cmd1)) < OK) { + logError(1, "%s Command unlock: ERROR %08X\n", tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + logError(0, "%s Unlock flash DONE!\n", tag); + + return OK; + +} + +/** +* Unlock the flash to be erased +* @return OK if success or an error code which specify the type of error encountered +*/ +int flash_erase_unlock(void) +{ + + u8 cmd[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_ERASE_UNLOCK_CODE0, + FLASH_ERASE_UNLOCK_CODE1 + }; + + logError(0, "%s Try to erase unlock flash... \n", tag); + + logError(0, "%s Command erase unlock ... \n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < 0) { + logError(1, "%s flash_erase_unlock: ERROR %08X\n", tag, + ERROR_BUS_W); + return ERROR_BUS_W; + } + + logError(0, "%s Erase Unlock flash DONE! \n", tag); + + return OK; + +} + +/** +* Erase the full flash +* @return OK if success or an error code which specify the type of error encountered +*/ +int flash_full_erase(void) +{ + int status; + + u8 cmd1[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_ERASE_CODE0 + 1, 0x00 }; + u8 cmd[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_ERASE_CODE0, + FLASH_ERASE_CODE1 + }; + + if (fts_write_dma_safe(cmd1, ARRAY_SIZE(cmd1)) < OK) { + logError(1, "%s flash_erase_page_by_page: ERROR %08X\n", tag, + ERROR_BUS_W); + return ERROR_BUS_W; + } + + logError(0, "%s Command full erase sent ... \n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s flash_full_erase: ERROR %08X\n", tag, + ERROR_BUS_W); + return ERROR_BUS_W; + } + + status = wait_for_flash_ready(FLASH_ERASE_CODE0); + + if (status != OK) { + logError(1, "%s flash_full_erase: ERROR %08X\n", tag, + ERROR_FLASH_NOT_READY); + return (status | ERROR_FLASH_NOT_READY); + } + + logError(0, "%s Full Erase flash DONE! \n", tag); + + return OK; + +} + +/** +* Erase the flash page by page, giving the possibility to skip the CX area and maintain therefore its value +* @param keep_cx if SKIP_PANEL_INIT the Panel Init pages will be skipped, if > SKIP_PANEL_CX_INIT Cx and Panel Init pages otherwise all the pages will be deleted +* @return OK if success or an error code which specify the type of error encountered +*/ +int flash_erase_page_by_page(ErasePage keep_cx) +{ + + u8 status, i = 0; + u8 cmd1[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_ERASE_CODE0 + 1, 0x00 }; + u8 cmd[6] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x00, FLASH_ERASE_CODE0, 0xA0 }; + u8 cmd2[9] = { FTS_CMD_HW_REG_W, 0x20, 0x00, 0x01, 0x28, 0xFF, 0xFF, 0xFF, 0xFF }; + u8 mask[4] = { 0 }; + + for (i = FLASH_CX_PAGE_START; + i <= FLASH_CX_PAGE_END && keep_cx >= SKIP_PANEL_CX_INIT; i++) { + logError(0, "%s Skipping erase CX page %d! \n", tag, i); + fromIDtoMask(i, mask, 4); + } + + for (i = FLASH_PANEL_PAGE_START; + i <= FLASH_PANEL_PAGE_END && keep_cx >= SKIP_PANEL_INIT; i++) { + logError(0, "%s Skipping erase Panel Init page %d! \n", tag, i); + fromIDtoMask(i, mask, 4); + } + + logError(0, "%s Setting the page mask = ", tag, i); + for (i = 0; i < 4; i++) { + cmd2[5 + i] = cmd2[5 + i] & (~mask[i]); + logError(0, "%02X ", cmd2[5 + i]); + } + + logError(0, "\n%s Writing page mask... \n", tag); + if (fts_write_dma_safe(cmd2, ARRAY_SIZE(cmd2)) < OK) { + logError(1, + "%s flash_erase_page_by_page: Page mask ERROR %08X\n", + tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + + if (fts_write_dma_safe(cmd1, ARRAY_SIZE(cmd1)) < OK) { + logError(1, + "%s flash_erase_page_by_page: Disable info ERROR %08X\n", + tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + + logError(0, "%s Command erase pages sent ... \n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s flash_erase_page_by_page: Erase ERROR %08X\n", + tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + + status = wait_for_flash_ready(FLASH_ERASE_CODE0); + + if (status != OK) { + + logError(1, "%s flash_erase_page_by_page: ERROR % 08X\n", tag, + ERROR_FLASH_NOT_READY); + return (status | ERROR_FLASH_NOT_READY); + } + + logError(0, "%s Erase flash page by page DONE! \n", tag); + + return OK; +} + +/** +* Start the DMA procedure which actually transfer and burn the data loaded from memory into the Flash +* @return OK if success or an error code which specify the type of error encountered +*/ +int start_flash_dma(void) +{ + int status; + u8 cmd[12] = { FLASH_CMD_WRITE_REGISTER, 0x20, 0x00, 0x00, + 0x6B, 0x00, 0x40, 0x42, 0x0F, 0x00, 0x00, FLASH_DMA_CODE1 }; + + + logError(0, "%s Command flash DMA ... \n", tag); + if (fts_write_dma_safe(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s start_flash_dma: ERROR %08X\n", tag, + ERROR_BUS_W); + return ERROR_BUS_W; + } + + status = wait_for_flash_ready(FLASH_DMA_CODE0); + + if (status != OK) { + logError(1, "%s start_flash_dma: ERROR %08X\n", tag, + ERROR_FLASH_NOT_READY); + return (status | ERROR_FLASH_NOT_READY); + } + + logError(0, "%s flash DMA DONE! \n", tag); + + return OK; +} + +/** +* Copy the FW data that should be burnt in the Flash into the memory and then the DMA will take care about burning it into the Flash +* @param address address in memory where to copy the data, possible values are FLASH_ADDR_CODE, FLASH_ADDR_CONFIG, FLASH_ADDR_CX +* @param data pointer to an array of byte which contain the data that should be copied into the memory +* @param size size of data +* @return OK if success or an error code which specify the type of error encountered +*/ +int fillFlash(u32 address, u8 *data, int size) +{ + int remaining = size, index = 0; + int toWrite = 0; + int byteBlock = 0; + int wheel = 0; + u32 addr = 0; + int res; + int delta; + u8 *buff = NULL; + u8 buff2[12] = { 0 }; + + buff = (u8 *) kmalloc((DMA_CHUNK + 5) * sizeof(u8), GFP_KERNEL); + if (buff == NULL) { + logError(1, "%s fillFlash: ERROR %08X\n", tag, ERROR_ALLOC); + return ERROR_ALLOC; + } + + while (remaining > 0) { + byteBlock = 0; + + addr = 0x00100000; + + while (byteBlock < FLASH_CHUNK && remaining > 0) { + index = 0; + if (remaining >= DMA_CHUNK) { + if ((byteBlock + DMA_CHUNK) <= FLASH_CHUNK) { + toWrite = DMA_CHUNK; + remaining -= DMA_CHUNK; + byteBlock += DMA_CHUNK; + } else { + delta = FLASH_CHUNK - byteBlock; + toWrite = delta; + remaining -= delta; + byteBlock += delta; + } + } else { + if ((byteBlock + remaining) <= FLASH_CHUNK) { + toWrite = remaining; + byteBlock += remaining; + remaining = 0; + + } else { + delta = FLASH_CHUNK - byteBlock; + toWrite = delta; + remaining -= delta; + byteBlock += delta; + } + } + + buff[index++] = FTS_CMD_HW_REG_W; + buff[index++] = (u8) ((addr & 0xFF000000) >> 24); + buff[index++] = (u8) ((addr & 0x00FF0000) >> 16); + buff[index++] = (u8) ((addr & 0x0000FF00) >> 8); + buff[index++] = (u8) (addr & 0x000000FF); + + memcpy(&buff[index], data, toWrite); + if (fts_write_dma_safe(buff, index + toWrite) < OK) { + logError(1, "%s fillFlash: ERROR %08X\n", tag, + ERROR_BUS_W); + kfree(buff); + return ERROR_BUS_W; + } + addr += toWrite; + data += toWrite; + } + + byteBlock = byteBlock / 4 - 1; + index = 0; + + buff2[index++] = FLASH_CMD_WRITE_REGISTER; + buff2[index++] = 0x20; + buff2[index++] = 0x00; + buff2[index++] = 0x00; + buff2[index++] = FLASH_DMA_CONFIG; + buff2[index++] = 0x00; + buff2[index++] = 0x00; + + addr = address + ((wheel * FLASH_CHUNK) / 4); + buff2[index++] = (u8) ((addr & 0x000000FF)); + buff2[index++] = (u8) ((addr & 0x0000FF00) >> 8); + buff2[index++] = (u8) (byteBlock & 0x000000FF); + buff2[index++] = (u8) ((byteBlock & 0x0000FF00) >> 8); + buff2[index++] = 0x00; + + logError(0, + "%s DMA Command = %02X , address = %02X %02X, words = %02X %02X \n", + tag, buff2[0], buff2[8], buff2[7], buff2[10], + buff2[9]); + + if (fts_write_dma_safe(buff2, index) < OK) { + logError(1, + "%s Error during filling Flash! ERROR %08X \n", + tag, ERROR_BUS_W); + kfree(buff); + return ERROR_BUS_W; + } + + res = start_flash_dma(); + if (res < OK) { + logError(1, + "%s Error during flashing DMA! ERROR %08X \n", + tag, res); + kfree(buff); + return res; + } + wheel++; + } + kfree(buff); + return OK; +} + +/** +* Execute the procedure to burn a FW in FTM4/FTI IC +* @param fw structure which contain the FW to be burnt +* @param force_burn if >0, the flashing procedure will be forced and executed regardless the additional info, otherwise the FW in the file will be burnt only if it is newer than the one running in the IC +* @param keep_cx if 1, the function preserve the CX/Panel Init area otherwise will be cleared +* @return OK if success or an error code which specify the type of error encountered +*/ +int flash_burn(Firmware fw, int force_burn, int keep_cx) +{ + int res; + + if (!force_burn) { + if (systemInfo.u16_fwVer != fw.fw_ver) + goto start; + for (res = EXTERNAL_RELEASE_INFO_SIZE - 1; res >= 0; res--) { + if (fw.externalRelease[res] != + systemInfo.u8_releaseInfo[res]) + goto start; + } + logError(1, + "%s flash_burn: Firmware in the chip newer or equal to the one to burn! NO UPDATE ERROR %08X \n", + tag, ERROR_FW_NO_UPDATE); + return (ERROR_FW_NO_UPDATE | ERROR_FLASH_BURN_FAILED); + } else { + if (force_burn == CRC_CX && fw.sec2_size == 0) { + for (res = EXTERNAL_RELEASE_INFO_SIZE - 1; res >= 0; + res--) { + if (fw.externalRelease[res] > + systemInfo.u8_releaseInfo[res]) + force_burn = 0; + goto start; + } + logError(1, + "%s flash_burn: CRC in CX but fw does not contain CX data! NO UPDATE ERROR %08X \n", + tag, ERROR_FW_NO_UPDATE); + return (ERROR_FW_NO_UPDATE | ERROR_FLASH_BURN_FAILED); + } + } + +start: + logError(0, "%s Programming Procedure for flashing started: \n\n", tag); + + logError(0, "%s 1) SYSTEM RESET: \n", tag); + res = fts_system_reset(); + if (res < 0) { + logError(1, "%s system reset FAILED!\n", tag); + if (res != (ERROR_SYSTEM_RESET_FAIL | ERROR_TIMEOUT)) + return (res | ERROR_FLASH_BURN_FAILED); + } else + logError(0, "%s system reset COMPLETED!\n\n", tag); + msleep(30); /* required by hw during flash procedure */ + logError(0, "%s 2) HOLD M3 : \n", tag); + res = hold_m3(); + if (res < OK) { + logError(1, "%s hold_m3 FAILED!\n", tag); + return (res | ERROR_FLASH_BURN_FAILED); + } else + logError(0, "%s hold_m3 COMPLETED!\n\n", tag); + + logError(0, "%s 3) ENABLE UVLO AND AUTO POWER DOWN MODE :\n", tag); + res = flash_enable_uvlo_autopowerdown(); + if (res < OK) { + logError(1, "%s flash_enable_uvlo_autopowerdown FAILED!\n", tag); + return res | ERROR_FLASH_BURN_FAILED; + } else + logError(0, "%s flash_enable_uvlo_autopowerdown COMPLETED!\n\n", tag); + logError(0, "%s 4) FLASH UNLOCK: \n", tag); + res = flash_unlock(); + if (res < OK) { + logError(1, "%s flash unlock FAILED! ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } else { + logError(0, "%s flash unlock COMPLETED!\n\n", tag); + } + + logError(0, "%s 5) FLASH ERASE UNLOCK: \n", tag); + res = flash_erase_unlock(); + if (res < 0) { + logError(1, "%s flash unlock FAILED! ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } else { + logError(0, "%s flash unlock COMPLETED!\n\n", tag); + } + + logError(0, "%s 6) FLASH ERASE: \n", tag); + if (keep_cx > 0) { + if (fw.sec2_size != 0 && force_burn == CRC_CX) + res = flash_erase_page_by_page(SKIP_PANEL_INIT); + else + res = flash_erase_page_by_page(SKIP_PANEL_CX_INIT); + } else { + res = flash_erase_page_by_page(SKIP_PANEL_INIT); + if (fw.sec2_size == 0) + logError(1, + "%s WARNING!!! Erasing CX memory but no CX in fw file! touch will not work right after fw update! \n", + tag); + } + + if (res < OK) { + logError(1, "%s flash erase FAILED! ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } else { + logError(0, "%s flash erase COMPLETED!\n\n", tag); + } + + logError(0, "%s 7) LOAD PROGRAM: \n", tag); + res = fillFlash(FLASH_ADDR_CODE, &fw.data[0], fw.sec0_size); + if (res < OK) { + logError(1, "%s load program ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } + logError(1, "%s load program DONE!\n", tag); + + logError(0, "%s 8) LOAD CONFIG: \n", tag); + res = + fillFlash(FLASH_ADDR_CONFIG, &(fw.data[fw.sec0_size]), + fw.sec1_size); + if (res < OK) { + logError(1, "%s load config ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } + logError(1, "%s load config DONE!\n", tag); + + if (fw.sec2_size != 0) { + if ((force_burn == CRC_CX) || (keep_cx <= 0)) { + logError(0, "%s 8.1) LOAD CX: \n", tag); + res = + fillFlash(FLASH_ADDR_CX, + &(fw.data[fw.sec0_size + fw.sec1_size]), + fw.sec2_size); + if (res < OK) { + logError(1, "%s load cx ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } + logError(1, "%s load cx DONE!\n", tag); + } + } + + logError(0, "%s Flash burn COMPLETED!\n\n", tag); + + logError(0, "%s 9) SYSTEM RESET: \n", tag); + res = fts_system_reset(); + if (res < 0) { + logError(1, "%s system reset FAILED! ERROR %08X\n", tag, + ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } + logError(0, "%s system reset COMPLETED!\n\n", tag); + + logError(0, "%s 10) FINAL CHECK: \n", tag); + res = readSysInfo(0); + if (res < 0) { + logError(1, + "%s flash_burn: Unable to retrieve Chip INFO! ERROR %08X\n", + tag, ERROR_FLASH_BURN_FAILED); + return (res | ERROR_FLASH_BURN_FAILED); + } + + for (res = 0; res < EXTERNAL_RELEASE_INFO_SIZE; res++) { + if (fw.externalRelease[res] != systemInfo.u8_releaseInfo[res]) { + logError(1, + "%s Firmware in the chip different from the one that was burn! \n", + tag); + return ERROR_FLASH_BURN_FAILED; + } + } + + logError(0, "%s Final check OK! \n", tag); + + return OK; +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.h new file mode 100644 index 000000000000..5a4c19221228 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsFlash.h @@ -0,0 +1,100 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS API for Flashing the IC * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsFlash.h +* \brief Contains all the definitions and structs to handle the FW update process +*/ + +#ifndef FTS_FLASH_H +#define FTS_FLASH_H + +#include "ftsSoftware.h" + +/*Flash possible status*/ +#define FLASH_READY 0 /*value to indicate that the flash is ready*/ +#define FLASH_BUSY 1 /*value to indicate that the flash is busy*/ +#define FLASH_UNKNOWN -1 /*value to indicate an unknown status of the flash*/ + +#define FLASH_STATUS_BYTES 1 /*number of bytes to check for read the flash status*/ + +/*Flash timing parameters*/ +#define FLASH_RETRY_COUNT 200 /*number of attemps to read the flash status*/ +#define FLASH_WAIT_BEFORE_RETRY 50 /*time to wait in ms between one status reading and another*/ + +#ifdef FW_H_FILE +#define PATH_FILE_FW "NULL" +#else +#define PATH_FILE_FW "st_fts.ftb" /*new FW bin file name*/ +#endif + +#define FLASH_CHUNK (64 * 1024) /*Max number of bytes that the DMA can burn on the flash in one shot in FTI*/ +#define DMA_CHUNK 32 /*Max number of bytes that can be written in I2C to the DMA*/ + +/** + * Define which kind of erase page by page should be performed + */ +typedef enum { + ERASE_ALL = 0, /*erase all the pages*/ + SKIP_PANEL_INIT = 1, /*skip erase Panel Init Pages*/ + SKIP_PANEL_CX_INIT = 2 /*skip erase Panel Init and CX Pages*/ +} ErasePage; + +/** @addtogroup fw_file + * @{ + */ + +/** +* Struct which contains information and data of the FW that should be burnt into the IC +*/ +typedef struct { + u8 *data; /*pointer to an array of bytes which represent the FW data*/ + u16 fw_ver; /*FW version of the FW file*/ + u16 config_id; /*Config ID of the FW file*/ + u16 cx_ver; /*Cx version of the FW file*/ + u8 externalRelease[EXTERNAL_RELEASE_INFO_SIZE]; /*External Release Info of the FW file*/ + int data_size; /*dimension of data (the actual data to be burnt)*/ + u32 sec0_size; /*dimension of section 0 (FW) in .ftb file*/ + u32 sec1_size; /*dimension of section 1 (Config) in .ftb file*/ + u32 sec2_size; /*dimension of section 2 (Cx) in .ftb file*/ + u32 sec3_size; /*dimension of section 3 (TBD) in .ftb file*/ + +} Firmware; + +/** @}*/ + +/** @addtogroup flash_command + * @{ + */ + +int wait_for_flash_ready(u8 type); +int hold_m3(void); +int flash_erase_unlock(void); +int flash_full_erase(void); +int flash_erase_page_by_page(ErasePage keep_cx); +int start_flash_dma(void); +int fillFlash(u32 address, u8 *data, int size); + +int flash_unlock(void); +int getFirmwareVersion(u16 *fw_vers, u16 *config_id); +int getFWdata(const char *pathToFile, u8 **data, int *size); +int parseBinFile(u8 *fw_data, int fw_size, Firmware *fw, int keep_cx); +int readFwFile(const char *path, Firmware *fw, int keep_cx); +int flash_burn(Firmware fw, int force_burn, int keep_cx); +int flashProcedure(const char *path, int force, int keep_cx); +int flash_enable_uvlo_autopowerdown(void); +#endif + +/** @}*/ diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.c new file mode 100644 index 000000000000..344bfa06cf2b --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.c @@ -0,0 +1,398 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS functions for getting frames * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsFrame.c +* \brief Contains all the functions to work with frames +*/ + +#include "ftsCompensation.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsFrame.h" +#include "ftsHardware.h" +#include "ftsIO.h" +#include "ftsSoftware.h" +#include "ftsTool.h" +#include "ftsTime.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern SysInfo systemInfo; + +/** + * Read the channels lengths from the config memory + * @return OK if success or an error code which specify the type of error encountered + */ +int getChannelsLength(void) +{ + int ret; + u8 data[2]; + + if (data == NULL) { + logError(1, "%s getChannelsLength: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + ret = readConfig(ADDR_CONFIG_SENSE_LEN, data, 2); + if (ret < OK) { + logError(1, "%s getChannelsLength: ERROR %08X\n", tag, ret); + + return ret; + } + + systemInfo.u8_scrRxLen = (int)data[0]; + systemInfo.u8_scrTxLen = (int)data[1]; + + logError(0, "%s Force_len = %d Sense_Len = %d \n", tag, + systemInfo.u8_scrTxLen, systemInfo.u8_scrRxLen); + + return OK; +} + +/** +* Read and pack the frame data related to the nodes +* @param address address in memory when the frame data node start +* @param size amount of data to read +* @param frame pointer to an array of bytes which will contain the frame node data +* @return OK if success or an error code which specify the type of error encountered +*/ +int getFrameData(u16 address, int size, short *frame) +{ + int i, j, ret; + u8 *data = (u8 *) kmalloc(size * sizeof(u8), GFP_KERNEL); + if (data == NULL) { + logError(1, "%s getFrameData: ERROR %08X\n", tag, ERROR_ALLOC); + return ERROR_ALLOC; + } + + ret = + fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, data, + size, DUMMY_FRAMEBUFFER); + if (ret < OK) { + logError(1, "%s getFrameData: ERROR %08X\n", tag, ERROR_BUS_R); + kfree(data); + return ERROR_BUS_R; + } + j = 0; + for (i = 0; i < size; i += 2) { + frame[j] = (short)((data[i + 1] << 8) + data[i]); + j++; + } + kfree(data); + return OK; +} + +/** + * Return the number of Sense Channels (Rx) + * @return number of Rx channels + */ +int getSenseLen(void) +{ + if (systemInfo.u8_scrRxLen == 0) { + getChannelsLength(); + } + return systemInfo.u8_scrRxLen; +} + +/** + * Return the number of Force Channels (Tx) + * @return number of Tx channels + */ +int getForceLen(void) +{ + if (systemInfo.u8_scrTxLen == 0) { + getChannelsLength(); + } + return systemInfo.u8_scrTxLen; +} + +/******************** New API **************************/ + +/** +* Read a MS Frame from frame buffer memory +* @param type type of MS frame to read +* @param frame pointer to MutualSenseFrame variable which will contain the data +* @return OK if success or an error code which specify the type of error encountered +*/ +int getMSFrame3(MSFrameType type, MutualSenseFrame *frame) +{ + u16 offset; + int ret, force_len, sense_len; + + force_len = getForceLen(); + sense_len = getSenseLen(); + + frame->node_data = NULL; + + logError(0, "%s %s: Starting to get frame %02X \n", tag, __func__, + type); + switch (type) { + case MS_RAW: + offset = systemInfo.u16_msTchRawAddr; + goto LOAD_NORM; + case MS_FILTER: + offset = systemInfo.u16_msTchFilterAddr; + + goto LOAD_NORM; + case MS_STRENGTH: + offset = systemInfo.u16_msTchStrenAddr; + goto LOAD_NORM; + case MS_BASELINE: + offset = systemInfo.u16_msTchBaselineAddr; +LOAD_NORM: + if (force_len == 0 || sense_len == 0) { + logError(1, + "%s %s: number of channels not initialized ERROR %08X\n", + tag, __func__, ERROR_CH_LEN); + return (ERROR_CH_LEN | ERROR_GET_FRAME); + } + + break; + + case MS_KEY_RAW: + offset = systemInfo.u16_keyRawAddr; + goto LOAD_KEY; + case MS_KEY_FILTER: + offset = systemInfo.u16_keyFilterAddr; + goto LOAD_KEY; + case MS_KEY_STRENGTH: + offset = systemInfo.u16_keyStrenAddr; + goto LOAD_KEY; + case MS_KEY_BASELINE: + offset = systemInfo.u16_keyBaselineAddr; +LOAD_KEY: + if (systemInfo.u8_keyLen == 0) { + logError(1, + "%s %s: number of channels not initialized ERROR %08X\n", + tag, __func__, ERROR_CH_LEN); + return (ERROR_CH_LEN | ERROR_GET_FRAME); + } + force_len = 1; + sense_len = systemInfo.u8_keyLen; + break; + + case FRC_RAW: + offset = systemInfo.u16_frcRawAddr; + goto LOAD_FRC; + case FRC_FILTER: + offset = systemInfo.u16_frcFilterAddr; + goto LOAD_FRC; + case FRC_STRENGTH: + offset = systemInfo.u16_frcStrenAddr; + goto LOAD_FRC; + case FRC_BASELINE: + offset = systemInfo.u16_frcBaselineAddr; +LOAD_FRC: + if (force_len == 0) { + logError(1, + "%s %s: number of channels not initialized ERROR %08X\n", + tag, __func__, ERROR_CH_LEN); + return (ERROR_CH_LEN | ERROR_GET_FRAME); + } + sense_len = 1; + break; + default: + logError(1, "%s %s: Invalid type ERROR %08X\n", tag, __func__, + ERROR_OP_NOT_ALLOW | ERROR_GET_FRAME); + return ERROR_OP_NOT_ALLOW | ERROR_GET_FRAME; + } + + frame->node_data_size = ((force_len) * sense_len); + frame->header.force_node = force_len; + frame->header.sense_node = sense_len; + frame->header.type = type; + + logError(0, "%s %s: Force_len = %d Sense_len = %d Offset = %04X \n", + tag, __func__, force_len, sense_len, offset); + + frame->node_data = + (short *)kmalloc(frame->node_data_size * sizeof(short), GFP_KERNEL); + if (frame->node_data == NULL) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_ALLOC | ERROR_GET_FRAME); + return ERROR_ALLOC | ERROR_GET_FRAME; + } + + ret = + getFrameData(offset, frame->node_data_size * BYTES_PER_NODE, + (frame->node_data)); + if (ret < OK) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, + ERROR_GET_FRAME_DATA); + kfree(frame->node_data); + frame->node_data = NULL; + return (ret | ERROR_GET_FRAME_DATA | ERROR_GET_FRAME); + } + logError(0, "%s Frame acquired! \n", tag); + return frame->node_data_size; + +} + +/** +* Read a SS Frame from frame buffer +* @param type type of SS frame to read +* @param frame pointer to SelfSenseFrame variable which will contain the data +* @return OK if success or an error code which specify the type of error encountered +*/ +int getSSFrame3(SSFrameType type, SelfSenseFrame *frame) +{ + u16 offset_force, offset_sense; + int ret; + + frame->force_data = NULL; + frame->sense_data = NULL; + + frame->header.force_node = getForceLen(); + frame->header.sense_node = getSenseLen(); + + if (frame->header.force_node == 0 || frame->header.sense_node == 0) { + logError(1, + "%s %s: number of channels not initialized ERROR %08X\n", + tag, __func__, ERROR_CH_LEN); + return (ERROR_CH_LEN | ERROR_GET_FRAME); + } + + logError(0, "%s %s: Starting to get frame %02X \n", tag, __func__, + type); + switch (type) { + case SS_RAW: + offset_force = systemInfo.u16_ssTchTxRawAddr; + offset_sense = systemInfo.u16_ssTchRxRawAddr; + break; + case SS_FILTER: + offset_force = systemInfo.u16_ssTchTxFilterAddr; + offset_sense = systemInfo.u16_ssTchRxFilterAddr; + break; + case SS_STRENGTH: + offset_force = systemInfo.u16_ssTchTxStrenAddr; + offset_sense = systemInfo.u16_ssTchRxStrenAddr; + break; + case SS_BASELINE: + offset_force = systemInfo.u16_ssTchTxBaselineAddr; + offset_sense = systemInfo.u16_ssTchRxBaselineAddr; + break; + + case SS_HVR_RAW: + offset_force = systemInfo.u16_ssHvrTxRawAddr; + offset_sense = systemInfo.u16_ssHvrRxRawAddr; + break; + case SS_HVR_FILTER: + offset_force = systemInfo.u16_ssHvrTxFilterAddr; + offset_sense = systemInfo.u16_ssHvrRxFilterAddr; + break; + case SS_HVR_STRENGTH: + offset_force = systemInfo.u16_ssHvrTxStrenAddr; + offset_sense = systemInfo.u16_ssHvrRxStrenAddr; + break; + case SS_HVR_BASELINE: + offset_force = systemInfo.u16_ssHvrTxBaselineAddr; + offset_sense = systemInfo.u16_ssHvrRxBaselineAddr; + break; + + case SS_PRX_RAW: + offset_force = systemInfo.u16_ssPrxTxRawAddr; + offset_sense = systemInfo.u16_ssPrxRxRawAddr; + break; + case SS_PRX_FILTER: + offset_force = systemInfo.u16_ssPrxTxFilterAddr; + offset_sense = systemInfo.u16_ssPrxRxFilterAddr; + break; + case SS_PRX_STRENGTH: + offset_force = systemInfo.u16_ssPrxTxStrenAddr; + offset_sense = systemInfo.u16_ssPrxRxStrenAddr; + break; + case SS_PRX_BASELINE: + offset_force = systemInfo.u16_ssPrxTxBaselineAddr; + offset_sense = systemInfo.u16_ssPrxRxBaselineAddr; + break; + + default: + logError(1, "%s %s: Invalid type ERROR %08X\n", tag, __func__, + ERROR_OP_NOT_ALLOW | ERROR_GET_FRAME); + return ERROR_OP_NOT_ALLOW | ERROR_GET_FRAME; + } + + frame->header.type = type; + + logError(0, + "%s %s: Force_len = %d Sense_len = %d Offset_force = %04X Offset_sense = %04X \n", + tag, __func__, frame->header.force_node, + frame->header.sense_node, offset_force, offset_sense); + + frame->force_data = + (short *)kmalloc(frame->header.force_node * sizeof(short), + GFP_KERNEL); + if (frame->force_data == NULL) { + logError(1, "%s %s: can not allocate force_data ERROR %08X\n", + tag, __func__, ERROR_ALLOC | ERROR_GET_FRAME); + return ERROR_ALLOC | ERROR_GET_FRAME; + } + + frame->sense_data = + (short *)kmalloc(frame->header.sense_node * sizeof(short), + GFP_KERNEL); + if (frame->sense_data == NULL) { + kfree(frame->force_data); + frame->force_data = NULL; + logError(1, "%s %s: can not allocate sense_data ERROR %08X\n", + tag, __func__, ERROR_ALLOC | ERROR_GET_FRAME); + return ERROR_ALLOC | ERROR_GET_FRAME; + } + + ret = + getFrameData(offset_force, + frame->header.force_node * BYTES_PER_NODE, + (frame->force_data)); + if (ret < OK) { + logError(1, + "%s %s: error while reading force data ERROR %08X\n", + tag, __func__, ERROR_GET_FRAME_DATA); + kfree(frame->force_data); + frame->force_data = NULL; + kfree(frame->sense_data); + frame->sense_data = NULL; + return (ret | ERROR_GET_FRAME_DATA | ERROR_GET_FRAME); + } + + ret = + getFrameData(offset_sense, + frame->header.sense_node * BYTES_PER_NODE, + (frame->sense_data)); + if (ret < OK) { + logError(1, + "%s %s: error while reading sense data ERROR %08X\n", + tag, __func__, ERROR_GET_FRAME_DATA); + kfree(frame->force_data); + frame->force_data = NULL; + kfree(frame->sense_data); + frame->sense_data = NULL; + return (ret | ERROR_GET_FRAME_DATA | ERROR_GET_FRAME); + } + + logError(0, "%s Frame acquired! \n", tag); + return frame->header.force_node + frame->header.sense_node; + +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.h new file mode 100644 index 000000000000..94bf412d1793 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsFrame.h @@ -0,0 +1,91 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS functions for getting frames * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsFrame.h +* \brief Contains all the definitions and structs to work with frames +*/ + +#ifndef FTS_FRAME_H +#define FTS_FRAME_H + +#include "ftsSoftware.h" + +/*Number of data bytes for each node */ +#define BYTES_PER_NODE 2 /*number of data bytes for each node*/ + +#define RETRY_FRAME_DATA_READ 2 /*max number of attempts to read a frame*/ + +/** +* Possible types of MS frames +*/ +typedef enum{ + MS_RAW = 0, /*Mutual Sense Raw Frame*/ + MS_FILTER = 1, /*Mutual Sense Filtered Frame*/ + MS_STRENGTH = 2, /*Mutual Sense Strength Frame (Baseline-Raw)*/ + MS_BASELINE = 3, /*Mutual Sense Baseline Frame*/ + MS_KEY_RAW = 4, /*Mutual Sense Key Raw Frame*/ + MS_KEY_FILTER = 5, /*Mutual Sense Key Filter Frame*/ + MS_KEY_STRENGTH = 6, /*Mutual Sense Key Strength Frame (Baseline-Raw)*/ + MS_KEY_BASELINE = 7, /*Mutual Sense Key Baseline Frame*/ + FRC_RAW = 8, /*Force Raw Frame*/ + FRC_FILTER = 9, /*Force Filtered Frame*/ + FRC_STRENGTH = 10, /*Force Strength Frame (Baseline-Raw)*/ + FRC_BASELINE = 11 /*Force Baseline Frame*/ +} MSFrameType; + +/** +* Possible types of SS frames +*/ +typedef enum{ + SS_RAW = 0, /*Self Sense Raw Frame*/ + SS_FILTER = 1, /*Self Sense Filtered Frame*/ + SS_STRENGTH = 2, /*Self Sense Strength Frame (Baseline-Raw)*/ + SS_BASELINE = 3, /*Self Sense Baseline Frame*/ + SS_HVR_RAW = 4, /*Self Sense Hover Raw Frame*/ + SS_HVR_FILTER = 5, /*Self Sense Hover Filter Frame*/ + SS_HVR_STRENGTH = 6, /*Self Sense Hover Strength Frame (Baseline-Raw)*/ + SS_HVR_BASELINE = 7, /*Self Sense Hover Baseline Frame*/ + SS_PRX_RAW = 8, /*Self Sense Proximity Raw Frame*/ + SS_PRX_FILTER = 9, /*Self Sense Proximity Filtered Frame*/ + SS_PRX_STRENGTH = 10, /*Self Sense Proximity Strength Frame (Baseline-Raw)*/ + SS_PRX_BASELINE = 11 /*Self Sense Proximity Baseline Frame*/ +} SSFrameType; + +/** +* Struct which contains the data of a MS Frame +*/ +typedef struct { + DataHeader header; /*Header which contain basic info of the frame*/ + short *node_data; /*Data of the frame*/ + int node_data_size; /*Dimension of the data of the frame*/ +} MutualSenseFrame; + +/** +* Struct which contains the data of a SS Frame +*/ +typedef struct { + DataHeader header; /*Header which contain basic info of the frame*/ + short *force_data; /*Force Channels Data*/ + short *sense_data; /*Sense Channels Data*/ +} SelfSenseFrame; + +int getChannelsLength(void); +int getFrameData(u16 address, int size, short *frame); +int getSenseLen(void); +int getForceLen(void); +int getMSFrame3(MSFrameType type, MutualSenseFrame *frame); +int getSSFrame3(SSFrameType type, SelfSenseFrame *frame); +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.c new file mode 100644 index 000000000000..3a4e2a66bf9e --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.c @@ -0,0 +1,349 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Gesture Utilities * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsGesture.c +* \brief Contains all the functions and variable to handle the Gesture Detection features +*/ + +#include "ftsSoftware.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsGesture.h" +#include "ftsIO.h" +#include "ftsTime.h" +#include "ftsTool.h" + +static u8 gesture_mask[GESTURE_MASK_SIZE] = { 0 }; +u16 gesture_coordinates_x[GESTURE_MAX_COORDS_PAIRS_REPORT] = { 0 }; +u16 gesture_coordinates_y[GESTURE_MAX_COORDS_PAIRS_REPORT] = { 0 }; +int gesture_coords_reported = ERROR_OP_NOT_ALLOW; +static u8 refreshGestureMask; +struct mutex gestureMask_mutex; + +/** + * Update the gesture mask stored in the driver and have to be used in gesture mode + * @param mask pointer to a byte array which store the gesture mask update that want to be performed. + * @param size dimension in byte of mask. This size can be <= GESTURE_MASK_SIZE. If size < GESTURE_MASK_SIZE the bytes of mask are considering continuos and starting from the less significant byte. + * @param en 0 = enable the gestures set in mask, 1 = disable the gestures set in mask + * @return OK if success or an error code which specify the type of error encountered + */ +int updateGestureMask(u8 *mask, int size, int en) +{ + u8 temp; + int i; + + if (mask != NULL) { + if (size <= GESTURE_MASK_SIZE) { + if (en == FEAT_ENABLE) { + mutex_lock(&gestureMask_mutex); + logError(0, + "%s updateGestureMask: setting gesture mask to enable...\n", + tag); + if (mask != NULL) { + for (i = 0; i < size; i++) { + gesture_mask[i] = gesture_mask[i] | mask[i]; + } + } + refreshGestureMask = 1; + logError(0, + "%s updateGestureMask: gesture mask to enable SET! \n", + tag); + mutex_unlock(&gestureMask_mutex); + return OK; + } + + else if (en == FEAT_DISABLE) { + mutex_lock(&gestureMask_mutex); + logError(0, + "%s updateGestureMask: setting gesture mask to disable...\n", + tag); + for (i = 0; i < size; i++) { + temp = gesture_mask[i] ^ mask[i]; + gesture_mask[i] = + temp & gesture_mask[i]; + } + logError(0, + "%s updateGestureMask: gesture mask to disable SET! \n", + tag); + refreshGestureMask = 1; + mutex_unlock(&gestureMask_mutex); + return OK; + } else { + logError(1, + "updateGestureMask: Enable parameter Invalid! %d != %d or %d ERROR %08X", + tag, FEAT_DISABLE, FEAT_ENABLE, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + } else { + logError(1, + "%s updateGestureMask: Size not valid! %d > %d ERROR %08X \n", + tag, size, GESTURE_MASK_SIZE); + return ERROR_OP_NOT_ALLOW; + } + } else { + logError(1, "%s updateGestureMask: Mask NULL! ERROR %08X \n", + tag, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + +} + +/** + * Enable in the FW the gesture mask to be used in gesture mode + * @param mask pointer to a byte array which store the gesture mask update that want to be sent to the FW, if NULL, will be used gesture_mask set previously without any changes. + * @param size dimension in byte of mask. This size can be <= GESTURE_MASK_SIZE. If size < GESTURE_MASK_SIZE the bytes of mask are considering continuos and starting from the less significant byte. + * @return OK if success or an error code which specify the type of error encountered + */ +int enableGesture(u8 *mask, int size) +{ + int i, res; + + logError(0, "%s Trying to enable gesture... \n", tag); + + if (size <= GESTURE_MASK_SIZE) { + mutex_lock(&gestureMask_mutex); + if (mask != NULL) { + for (i = 0; i < size; i++) { + gesture_mask[i] = gesture_mask[i] | mask[i]; + } + } + + res = + setFeatures(FEAT_SEL_GESTURE, gesture_mask, + GESTURE_MASK_SIZE); + if (res < OK) { + logError(1, "%s enableGesture: ERROR %08X \n", tag, + res); + goto END; + } + + logError(0, "%s enableGesture DONE! \n", tag); + res = OK; + +END: + mutex_unlock(&gestureMask_mutex); + return res; + } else { + logError(1, + "%s enableGesture: Size not valid! %d > %d ERROR %08X \n", + tag, size, GESTURE_MASK_SIZE); + return ERROR_OP_NOT_ALLOW; + } + +} + +/** + * Disable in the FW the gesture mask to be used in gesture mode + * @param mask pointer to a byte array which store the gesture mask update that want to be sent to the FW, if NULL, all the gestures will be disabled. + * @param size dimension in byte of mask. This size can be <= GESTURE_MASK_SIZE. If size < GESTURE_MASK_SIZE the bytes of mask are considering continuos and starting from the less significant byte. + * @return OK if success or an error code which specify the type of error encountered + */ +int disableGesture(u8 *mask, int size) +{ + u8 temp; + int i, res; + u8 *pointer; + + logError(0, "%s Trying to disable gesture... \n", tag); + + if (size <= GESTURE_MASK_SIZE) { + mutex_lock(&gestureMask_mutex); + if (mask != NULL) { + for (i = 0; i < size; i++) { + + temp = gesture_mask[i] ^ mask[i]; + gesture_mask[i] = temp & gesture_mask[i]; + } + + pointer = gesture_mask; + } else { + i = 0; + pointer = (u8 *)&i; + } + + res = setFeatures(FEAT_SEL_GESTURE, pointer, GESTURE_MASK_SIZE); + if (res < OK) { + logError(1, "%s disableGesture: ERROR %08X \n", tag, + res); + goto END; + } + + logError(0, "%s disableGesture DONE! \n", tag); + + res = OK; + +END: + mutex_unlock(&gestureMask_mutex); + return res; + } else { + logError(1, + "%s disableGesture: Size not valid! %d > %d ERROR %08X \n", + tag, size, GESTURE_MASK_SIZE); + return ERROR_OP_NOT_ALLOW; + } +} + +/** + * Perform all the steps required to put the chip in gesture mode + * @param reload if set to 1, before entering in gesture mode it will re-enable in the FW the last defined gesture mask + * @return OK if success or an error code which specify the type of error encountered + */ +int enterGestureMode(int reload) +{ + int res, ret; + + res = fts_disableInterruptNoSync(); + if (res < OK) { + logError(1, "%s enterGestureMode: ERROR %08X \n", tag, + res | ERROR_DISABLE_INTER); + return res | ERROR_DISABLE_INTER; + } + + if (reload == 1 || refreshGestureMask == 1) { + + res = enableGesture(NULL, 0); + if (res < OK) { + logError(1, + "%s enterGestureMode: enableGesture ERROR %08X \n", + tag, res); + goto END; + } + + refreshGestureMask = 0; + } + + res = setScanMode(SCAN_MODE_LOW_POWER, 0); + if (res < OK) { + logError(1, + "%s enterGestureMode: enter gesture mode ERROR %08X \n", + tag, res); + goto END; + } + + res = OK; +END: + ret = fts_enableInterrupt(); + if (ret < OK) { + logError(1, + "%s enterGestureMode: fts_enableInterrupt ERROR %08X \n", + tag, res | ERROR_ENABLE_INTER); + res |= ret | ERROR_ENABLE_INTER; + } + + return res; +} + +/** + * Check if one or more Gesture IDs are currently enabled in gesture_mask + * @return FEAT_ENABLE if one or more gesture ids are enabled, FEAT_DISABLE if all the gesture ids are currently disabled + */ +int isAnyGestureActive(void) +{ + int res = 0; + + while (res < (GESTURE_MASK_SIZE - 1) && gesture_mask[res] == 0) { + res++; + } + + if (gesture_mask[res] != 0) { + logError(0, + "%s %s: Active Gestures Found! gesture_mask[%d] = %02X !\n", + tag, __func__, res, gesture_mask[res]); + return FEAT_ENABLE; + } else { + logError(0, "%s %s: All Gestures Disabled!\n", tag, __func__); + return FEAT_DISABLE; + } +} + +/** + * Read from the frame buffer the gesture coordinates pairs of the points draw by an user when a gesture is detected + * @param event pointer to a byte array which contains the gesture event reported by the fw when a gesture is detected + * @return OK if success or an error code which specify the type of error encountered + */ +int readGestureCoords(u8 *event) +{ + int i = 0; + u64 address = 0; + int res; + + u8 val[GESTURE_MAX_COORDS_PAIRS_REPORT * 4]; + + if (event[0] == EVT_ID_USER_REPORT && event[1] == EVT_TYPE_USER_GESTURE) { + address = (event[4] << 8) | event[3]; + gesture_coords_reported = event[5]; + if (gesture_coords_reported > GESTURE_MAX_COORDS_PAIRS_REPORT) { + logError(1, + "%s %s: FW reported more than %d points for the gestures! Decreasing to %d \n", + tag, __func__, gesture_coords_reported, + GESTURE_MAX_COORDS_PAIRS_REPORT); + gesture_coords_reported = + GESTURE_MAX_COORDS_PAIRS_REPORT; + } + + logError(1, "%s %s: Offset: %08X , coords pairs = %d\n", tag, + __func__, address, gesture_coords_reported); + + res = fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, address, val, (gesture_coords_reported * 2 * 2), DUMMY_FRAMEBUFFER); + if (res < OK) { + logError(1, + "%s %s: Cannot read the coordinates! ERROR %08X \n", + tag, __func__, res); + gesture_coords_reported = ERROR_OP_NOT_ALLOW; + return res; + } + + for (i = 0; i < gesture_coords_reported; i++) { + gesture_coordinates_x[i] = + (((u16) val[i * 2 + 1]) & 0x0F) << 8 | + (((u16) val[i * 2]) & 0xFF); + gesture_coordinates_y[i] = (((u16) + val[gesture_coords_reported + * 2 + i * 2 + + 1]) & 0x0F) << 8 | + (((u16) + val[gesture_coords_reported * 2 + i * 2]) & 0xFF); + } + + logError(1, "%s %s: Reading Gesture Coordinates DONE! \n", tag, + __func__); + return OK; + + } else { + logError(1, + "%s %s: The event passsed as argument is invalid! ERROR %08X \n", + tag, __func__, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + +} + +/** + * Return the coordinates of the points stored during the last detected gesture + * @param x output parameter which will store the address of the array containing the x coordinates + * @param y output parameter which will store the address of the array containing the y coordinates + * @return the number of points (x,y) stored and therefore the size of the x and y array returned. + */ +int getGestureCoords(u16 **x, u16 **y) +{ + *x = gesture_coordinates_x; + *y = gesture_coordinates_y; + logError(1, + "%s %s: Number of gesture coordinates pairs returned = %d \n", + tag, __func__, gesture_coords_reported); + return gesture_coords_reported; +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.h new file mode 100644 index 000000000000..226c3b0b1b60 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsGesture.h @@ -0,0 +1,38 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Gesture Utilities * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsGesture.h +* \brief Contains all the macro and prototypes to handle the Gesture Detection features +*/ + +#ifndef FTS_GESTURE_H_ +#define FTS_GESTURE_H_ + +#include "ftsHardware.h" + +#define GESTURE_MASK_SIZE 4 + +#define GESTURE_MAX_COORDS_PAIRS_REPORT 100 + +int updateGestureMask(u8 *mask, int size, int en); +int disableGesture(u8 *mask, int size); +int enableGesture(u8 *mask, int size); +int enterGestureMode(int reload); +int isAnyGestureActive(void); +int readGestureCoords(u8 *event); +int getGestureCoords(u16 **x, u16 **y); + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsHardware.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsHardware.h new file mode 100644 index 000000000000..40c9e014cff7 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsHardware.h @@ -0,0 +1,191 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* HW related data * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsHardware.h +* \brief Contains all the definitions and information related to the IC from an hardware point of view +*/ + +#ifndef FTS_HARDWARE_H +#define FTS_HARDWARE_H + +/*DIGITAL CHIP INFO*/ +#define DCHIP_ID_0 0x36 /*LSB chip ID for FTM5*/ +#define DCHIP_ID_1 0x39 /*MSB chip ID for FTM5*/ + +#define DCHIP_FW_VER_BYTE 2 /*number of bytes of the fw versions*/ + +/*CHUNKS*/ +#define READ_CHUNK 1024 /*chunk dimension of a single i2c read, max allowed value is 2kB*/ +#define WRITE_CHUNK 1024 /*chunk dimension of a single i2c write, max allowed value is 2kB*/ +#define MEMORY_CHUNK 1024 /*chunk dimenasion of a single i2c write on mem, max allowed value is 2kB*/ + +/*PROTOCOL INFO*/ +#define I2C_INTERFACE /*comment if the chip use SPI bus*/ +#ifdef I2C_INTERFACE +#define I2C_SAD 0x49 /*slave address of the IC*/ +#else +#define SPI4_WIRE /*comment if the master is SPI3 wires (MOSI and MISO share same line)*/ +#define SPI_DELAY_CS 10 /*time in usec to wait before rising the CS*/ +#define SPI_CLOCK_FREQ 7000000 /*clock frequency in Hz of the SPI bus*/ +#endif + +#define IER_ENABLE 0x41 /*value to write in IER_ADDR to enable the interrupts*/ +#define IER_DISABLE 0x00 /*value to write in IER_ADDR to disable the interrupts*/ + +/*FLASH COMMAND*/ +/** @defgroup flash_command Flash Commands + * All the commands that works with the flash of the IC + * @{ + */ +#define FLASH_CMD_UNLOCK 0xF7 + +#define FLASH_CMD_READ_REGISTER 0xFA +#define FLASH_CMD_WRITE_REGISTER 0xFA + +/*FLASH UNLOCK PARAMETER*/ +#define FLASH_UNLOCK_CODE0 0x25 +#define FLASH_UNLOCK_CODE1 0x20 +#define FLASH_UNLOCK_CODE2 0x6B +#define FLASH_UNLOCK_CODE3 0x00 + +#define FLASH_UVLO_ENABLE_CODE0 0x1B +#define FLASH_UVLO_ENABLE_CODE1 0x66 +#define FLASH_AUTOPOWERDOWN_ENABLE_CODE0 0x68 +#define FLASH_AUTOPOWERDOWN_ENABLE_CODE1 0x13 +/*FLASH ERASE and DMA PARAMETER*/ +#define FLASH_ERASE_START 0x80 +#define FLASH_ERASE_CODE1 0xC0 +#define FLASH_DMA_CODE1 0xC0 +#define FLASH_ERASE_UNLOCK_CODE0 0xDE +#define FLASH_ERASE_UNLOCK_CODE1 0x03 +#define FLASH_ERASE_CODE0 0x6A +#define FLASH_DMA_CODE0 0x71 +#define FLASH_DMA_CONFIG 0x72 +#define FLASH_NUM_PAGE 32 /*number of pages in main flash*/ + +#define FLASH_CX_PAGE_START 28 /*starting page which contain Cx data*/ +#define FLASH_CX_PAGE_END 30 /*last page which contain Cx data*/ +#define FLASH_PANEL_PAGE_START 26 /*starting page which contain Panel Init data*/ +#define FLASH_PANEL_PAGE_END 27 /*last page which contain Panel Init data*/ + +/** @} */ + +/*FLASH ADDRESS*/ + +#define FLASH_ADDR_CODE 0x00000000 /*starting address (words) in the flash of the code in FTI*/ +#define FLASH_ADDR_CONFIG 0x00007C00 /*starting address (words) in the flash of the config in FTI*/ +#define FLASH_ADDR_CX 0x00007000 /*starting address (words) in the flash of the Init data in FTI*/ + +/*SIZES FW, CODE, CONFIG, MEMH*/ +/** @defgroup fw_file FW file info + * All the info related to the fw file + * @{ + */ + +#define FW_HEADER_SIZE 64 /*dimension of the header of the .fts file*/ +#define FW_HEADER_SIGNATURE 0xAA55AA55 /*header signature*/ +#define FW_FTB_VER 0x00000001 /*.ftb version*/ +#define FW_BYTES_ALLIGN 4 /*allignment of the info*/ +#define FW_BIN_VER_OFFSET 16 /*offset of the fw version in the .ftb file*/ +#define FW_BIN_CONFIG_ID_OFFSET 20 /*offset of the config id in the .ftb file*/ +#define FW_CX_VERSION (16 + 4) /*offset of CX version in the sec2 of FW file*/ + +/** @} */ + +/*FIFO*/ +#define FIFO_EVENT_SIZE 8 /*number of bytes of one event*/ +#define FIFO_DEPTH 32 /*max number of events that the FIFO can collect before going in overflow in FTM5*/ + +#ifdef I2C_INTERFACE +#define FIFO_CMD_READALL 0x86 /*command to read all the events in the FIFO*/ +#else +#define FIFO_CMD_READALL 0x87 /*command to read all the events in the FIFO*/ +#endif +#define FIFO_CMD_READONE FIFO_CMD_READALL /*commad to read one event from FIFO*/ + +/*OP CODES FOR MEMORY (based on protocol)*/ +#ifdef I2C_INTERFACE +#define FTS_CMD_HW_REG_R 0xFA /*command to read an hw register if FTI*/ +#define FTS_CMD_HW_REG_W 0xFA /*command to write an hw register if FTI*/ +#define FTS_CMD_FRAMEBUFFER_R 0xA6 /*command to read the framebuffer if FTI*/ +#define FTS_CMD_CONFIG_R 0xA8 /*command to read the config memory if FTI*/ +#define FTS_CMD_CONFIG_W 0xA8 /*command to write the config memory if FTI*/ +#else +#define FTS_CMD_HW_REG_R 0xFB /*command to read an hw register if FTI*/ +#define FTS_CMD_HW_REG_W 0xFA /*command to write an hw register if FTI*/ +#define FTS_CMD_FRAMEBUFFER_R 0xA7 /*command to read the framebuffer if FTI*/ +#define FTS_CMD_CONFIG_R 0xA9 /*command to read the config memory if FTI*/ +#define FTS_CMD_CONFIG_W 0xA8 /*command to write the config memory if FTI*/ +#endif + +/*DUMMY BYTES DATA*/ + +#ifndef I2C_INTERFACE +#define DUMMY_HW_REG 1 /*1 if the first byte read from HW register is dummy*/ +#define DUMMY_FRAMEBUFFER 1 /*1 if the first byte read from Frame buffer is dummy*/ +#define DUMMY_CONFIG 1 /*1 if the first byte read from Config Memory is dummy*/ +#define DUMMY_FIFO 1 /*1 if the first byte read from FIFO is dummy*/ +#else +#define DUMMY_HW_REG 0 /*1 if the first byte read from HW register is dummy*/ +#define DUMMY_FRAMEBUFFER 0 /*1 if the first byte read from Frame buffer is dummy*/ +#define DUMMY_CONFIG 0 /*1 if the first byte read from Config Memory is dummy*/ +#define DUMMY_FIFO 0 /*1 if the first byte read from FIFO is dummy*/ +#endif + +/** @defgroup hw_adr HW Address + * @ingroup address + * Important addresses of hardware registers (and sometimes their important values) + * @{ + */ + +/*IMPORTANT HW ADDRESSES (u64)*/ +#define ADDR_FRAMEBUFFER ((u64)0x0000000000000000) /*frame buffer address in memory*/ +#define ADDR_ERROR_DUMP ((u64)0x000000000000EF80) /*start address dump error log*/ + +/*SYSTEM RESET INFO*/ +#define ADDR_SYSTEM_RESET ((u64)0x0000000020000024) /*address of System control register in FTI*/ +#define SYSTEM_RESET_VALUE 0x80 /*value to write in SYSTEM_RESET_ADDRESS to perform a system reset in FTM5*/ + +/*REMAP REGISTER*/ +#define ADDR_BOOT_OPTION ((u64)0x0000000020000025) /*address of Boot option register in SONIA*/ + +/*INTERRUPT INFO*/ +#define ADDR_IER ((u64)0x0000000020000029) /*address of the Interrupt enable register in FTMI*/ + +/*Chip ID/Fw Version*/ +#define ADDR_DCHIP_ID ((u64)0x0000000020000000) /*chip id address for FTI*/ +#define ADDR_DCHIP_FW_VER ((u64)0x0000000020000004) /*fw version address for FTI*/ + +/*INTERFACE REGISTER*/ +#define ADDR_ICR ((u64)0x000000002000002D) /*address of Device control register to set the comunication protocol (SPI/I2C)*/ +#define SPI4_MASK 0x02 /*bit to set spi4*/ + +/*CRC ADDR*/ +#define ADDR_CRC ((u64)0x0000000020000078) /*address of the CRC control register in FTI*/ +#define CRC_MASK 0x03 /*bitmask which reveal if there is a CRC error in the flash*/ + +#define ADDR_CONFIG_OFFSET ((u64)0x0000000000000000) /*config address in memory if FTI*/ + +#define ADDR_GPIO_INPUT ((u64)0x0000000020000030) /*address of GPIO input register*/ +#define ADDR_GPIO_DIRECTION ((u64)0x0000000020000032) /*address of GPIO direction register*/ +#define ADDR_GPIO_PULLUP ((u64)0x0000000020000034) /*address of GPIO pullup register*/ +#define ADDR_GPIO_CONFIG_REG0 ((u64)0x000000002000003D) /*address of GPIO config register*/ +#define ADDR_GPIO_CONFIG_REG2 ((u64)0x000000002000003F) /*address of GPIO config register*/ + + +/**@}*/ + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.c new file mode 100644 index 000000000000..08ed56551e63 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.c @@ -0,0 +1,911 @@ +/* + + ************************************************************************** + ** STMicroelectronics ** + ************************************************************************** + ** marco.cali@st.com ** + ************************************************************************** + * * + * I2C/SPI Communication * + * * + ************************************************************************** + ************************************************************************** + + */ + +/*! +* \file ftsIO.c +* \brief Contains all the functions which handle with the I2C/SPI communication +*/ + +#include "ftsSoftware.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef I2C_INTERFACE +#include +#include +static u16 I2CSAD; +#include +#endif + +static void *client; + +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsHardware.h" +#include "ftsIO.h" + +extern struct fts_ts_info *fts_info; +static struct mutex rw_lock; +static u8 *buf1; +static u8 *buf2; + + +/** +* Initialize the static client variable of the fts_lib library in order to allow any i2c/spi transaction in the driver. (Must be called in the probe) +* @param clt pointer to i2c_client or spi_device struct which identify the bus slave device +* @return OK +*/ +int openChannel(void *clt) +{ + client = clt; +#ifdef I2C_INTERFACE + I2CSAD = ((struct i2c_client *)clt)->addr; + logError(0, "%s openChannel: SAD: %02X \n", tag, I2CSAD); +#else + logError(1, "%s %s: spi_master: flags = %04X !\n", tag, __func__, + ((struct spi_device *)client)->master->flags); + logError(1, + "%s %s: spi_device: max_speed = %d chip select = %02X bits_per_words = %d mode = %04X !\n", + tag, __func__, ((struct spi_device *)client)->max_speed_hz, + ((struct spi_device *)client)->chip_select, + ((struct spi_device *)client)->bits_per_word, + ((struct spi_device *)client)->mode); + logError(1, "%s openChannel: completed! \n", tag); +#endif + mutex_init(&rw_lock); + + if (!buf1) + buf1 = (u8 *)kzalloc(PAGE_SIZE, GFP_ATOMIC); + if (!buf2) + buf2 = (u8 *)kzalloc(PAGE_SIZE, GFP_ATOMIC); + if (!buf1 || !buf2) + return ERROR_ALLOC; + + return OK; +} + +#ifdef I2C_INTERFACE +/** +* Change the I2C slave address which will be used during the transaction (For Debug Only) +* @param sad new slave address id +* @return OK +*/ +int changeSAD(u8 sad) +{ + I2CSAD = sad; + return OK; +} +#endif + +/** +* Retrieve the pointer to the device struct of the IC +* @return a the device struct pointer if client was previously set or NULL in all the other cases +*/ +struct device *getDev(void) +{ + if (client != NULL) + return &(getClient()->dev); + else + return NULL; +} + +#ifdef I2C_INTERFACE +/** +* Retrieve the pointer of the i2c_client struct representing the IC as i2c slave +* @return client if it was previously set or NULL in all the other cases +*/ +struct i2c_client *getClient(void) +{ + if (client != NULL) + return (struct i2c_client *)client; + else + return NULL; +} +#else +/** +* Retrieve the pointer of the spi_device struct representing the IC as spi slave +* @return client if it was previously set or NULL in all the other cases +*/ +struct spi_device *getClient() +{ + if (client != NULL) + return (struct spi_device *)client; + else + return NULL; +} +#endif + +/****************** New I2C API *********************/ + +/** +* Perform a direct bus read +* @param outBuf pointer of a byte array which should contain the byte read from the IC +* @param byteToRead number of bytes to read +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_read(u8 *outBuf, int byteToRead) +{ + int ret = -1; + int retry = 0; + +#ifdef I2C_INTERFACE + struct i2c_msg I2CMsg[1]; + + I2CMsg[0].addr = (__u16) I2CSAD; + I2CMsg[0].flags = (__u16) I2C_M_RD; + I2CMsg[0].len = (__u16) byteToRead; + I2CMsg[0].buf = (__u8 *) outBuf; +#else + struct spi_message msg; + struct spi_transfer transfer[1] = { {0} }; + + spi_message_init(&msg); + + transfer[0].len = byteToRead; + transfer[0].delay_usecs = SPI_DELAY_CS; + transfer[0].tx_buf = NULL; + transfer[0].rx_buf = outBuf; + spi_message_add_tail(&transfer[0], &msg); +#endif + + if (client == NULL) + return ERROR_BUS_O; + while (retry < I2C_RETRY && ret < OK) { + +#ifdef I2C_INTERFACE + ret = i2c_transfer(getClient()->adapter, I2CMsg, 1); +#else + ret = spi_sync(getClient(), &msg); +#endif + + retry++; + if (ret < OK) + mdelay(I2C_WAIT_BEFORE_RETRY); + } + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ERROR_BUS_R); + return ERROR_BUS_R; + } + return OK; + +} + +/** +* Perform a bus write followed by a bus read without a stop condition +* @param cmd byte array containing the command to write +* @param cmdLength size of cmd +* @param outBuf pointer of a byte array which should contain the bytes read from the IC +* @param byteToRead number of bytes to read +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_writeRead(u8 *cmd, int cmdLength, u8 *outBuf, int byteToRead) +{ + int ret = -1; + int retry = 0; + +#ifdef I2C_INTERFACE + struct i2c_msg I2CMsg[2]; + + I2CMsg[0].addr = (__u16) I2CSAD; + I2CMsg[0].flags = (__u16) 0; + I2CMsg[0].len = (__u16) cmdLength; + I2CMsg[0].buf = (__u8 *) cmd; + + I2CMsg[1].addr = (__u16) I2CSAD; + I2CMsg[1].flags = I2C_M_RD; + I2CMsg[1].len = byteToRead; + I2CMsg[1].buf = (__u8 *) outBuf; + +#else + struct spi_message msg; + struct spi_transfer transfer[2] = { {0}, {0} }; + + spi_message_init(&msg); + + transfer[0].len = cmdLength; + transfer[0].tx_buf = cmd; + transfer[0].rx_buf = NULL; + spi_message_add_tail(&transfer[0], &msg); + + transfer[1].len = byteToRead; + transfer[1].delay_usecs = SPI_DELAY_CS; + transfer[1].tx_buf = NULL; + transfer[1].rx_buf = outBuf; + spi_message_add_tail(&transfer[1], &msg); + +#endif + + if (client == NULL) + return ERROR_BUS_O; + + while (retry < I2C_RETRY && ret < OK) { +#ifdef I2C_INTERFACE + ret = i2c_transfer(getClient()->adapter, I2CMsg, 2); +#else + ret = spi_sync(getClient(), &msg); +#endif + + retry++; + if (ret < OK) + mdelay(I2C_WAIT_BEFORE_RETRY); + } + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ERROR_BUS_WR); + return ERROR_BUS_WR; + } + return OK; +} + +/** +* Perform a bus write +* @param cmd byte array containing the command to write +* @param cmdLength size of cmd +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_write(u8 *cmd, int cmdLength) +{ + int ret = -1; + int retry = 0; + +#ifdef I2C_INTERFACE + struct i2c_msg I2CMsg[1]; + + I2CMsg[0].addr = (__u16) I2CSAD; + I2CMsg[0].flags = (__u16) 0; + I2CMsg[0].len = (__u16) cmdLength; + I2CMsg[0].buf = (__u8 *) cmd; +#else + struct spi_message msg; + struct spi_transfer transfer[1] = { {0} }; + + spi_message_init(&msg); + + transfer[0].len = cmdLength; + transfer[0].delay_usecs = SPI_DELAY_CS; + transfer[0].tx_buf = cmd; + transfer[0].rx_buf = NULL; + spi_message_add_tail(&transfer[0], &msg); +#endif + + if (client == NULL) + return ERROR_BUS_O; + while (retry < I2C_RETRY && ret < OK) { +#ifdef I2C_INTERFACE + ret = i2c_transfer(getClient()->adapter, I2CMsg, 1); +#else + ret = spi_sync(getClient(), &msg); +#endif + + retry++; + if (ret < OK) + mdelay(I2C_WAIT_BEFORE_RETRY); + } + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ERROR_BUS_W); + return ERROR_BUS_W; + } + return OK; +} +#ifdef CONFIG_I2C_BY_DMA +/** + * same as above but can be used when enable DMA. + */ +int fts_read_dma_safe(u8 *outBuf, int byteToRead) +{ + + int ret; + struct fts_dma_buf *dma = fts_info->dma_buf; + u8 *malcBuf = dma->rdBuf; + u8 *tmpBuf = NULL; + u8 *finalBuf; + + mutex_lock(&dma->dmaBufLock); + /*use malloc buf*/ + if (byteToRead > 1) { + /*extend malloc buf*/ + if (unlikely(byteToRead > PAGE_SIZE)) { + tmpBuf = kzalloc(byteToRead, GFP_KERNEL); + if (!tmpBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + mutex_unlock(&dma->dmaBufLock); + return ERROR_ALLOC; + } + finalBuf = tmpBuf; + } else { + finalBuf = malcBuf; + } + } else { + finalBuf = outBuf; + } + + ret = fts_read(finalBuf, byteToRead); + if ((ret == OK) && (byteToRead > 1)) { + memcpy(outBuf, finalBuf, byteToRead); + } + if (unlikely(tmpBuf)) + kfree(tmpBuf); + mutex_unlock(&dma->dmaBufLock); + + return ret; +} + +int fts_writeRead_dma_safe(u8 *cmd, int cmdLength, u8 *outBuf, int byteToRead) +{ + int ret; + struct fts_dma_buf *dma = fts_info->dma_buf; + u8 *malcRdBuf = dma->rdBuf; + u8 *malcWrBuf = dma->wrBuf; + u8 *rdBuf, *tmpRdBuf = NULL; + u8 *wrBuf, *tmpWrBuf = NULL; + + mutex_lock(&dma->dmaBufLock); + if (cmdLength > 1) { + if (unlikely(cmdLength > PAGE_SIZE)) { + tmpWrBuf = kzalloc(cmdLength, GFP_KERNEL); + if (!tmpWrBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + mutex_unlock(&dma->dmaBufLock); + return ERROR_ALLOC; + } + wrBuf = tmpWrBuf; + } else { + wrBuf = malcWrBuf; + } + memcpy(wrBuf, cmd, cmdLength); + } else { + wrBuf = cmd; + } + + if (byteToRead > 1) { + if (unlikely(byteToRead > PAGE_SIZE)) { + tmpRdBuf = kzalloc(byteToRead, GFP_KERNEL); + if (!tmpRdBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + if (tmpWrBuf) + kfree(tmpWrBuf); + mutex_unlock(&dma->dmaBufLock); + return ERROR_ALLOC; + } + rdBuf = tmpRdBuf; + } else { + rdBuf = malcRdBuf; + } + } else { + rdBuf = outBuf; + } + + ret = fts_writeRead(wrBuf, cmdLength, rdBuf, byteToRead); + if ((ret == OK) && (byteToRead > 1)) + memcpy(outBuf, rdBuf, byteToRead); + + if (unlikely(tmpRdBuf)) + kfree(tmpRdBuf); + if (unlikely(tmpWrBuf)) + kfree(tmpWrBuf); + mutex_unlock(&dma->dmaBufLock); + + return ret; +} + +int fts_write_dma_safe(u8 *cmd, int cmdLength) +{ + int ret; + struct fts_dma_buf *dma = fts_info->dma_buf; + u8 *malcBuf = dma->wrBuf; + u8 *tmpBuf = NULL; + u8 *finalBuf; + + mutex_lock(&dma->dmaBufLock); + /*use malloc buf*/ + if (cmdLength > 1) { + /*extend malloc buf*/ + if (unlikely(cmdLength > PAGE_SIZE)) { + tmpBuf = kzalloc(cmdLength, GFP_KERNEL); + if (!tmpBuf) { + logError(1, "%s %s:ERROR alloc mem failed!", tag, __func__); + mutex_unlock(&dma->dmaBufLock); + return ERROR_ALLOC; + } + finalBuf = tmpBuf; + } else { + finalBuf = malcBuf; + } + memcpy(finalBuf, cmd, cmdLength); + } else { + finalBuf = cmd; + } + + ret = fts_write(finalBuf, cmdLength); + + if (unlikely(tmpBuf)) + kfree(tmpBuf); + mutex_unlock(&dma->dmaBufLock); + + + return ret; +} +#else +int fts_read_dma_safe(u8 *outBuf, int byteToRead) +{ + return fts_read(outBuf, byteToRead); +} +int fts_writeRead_dma_safe(u8 *cmd, int cmdLength, u8 *outBuf, int byteToRead) +{ + return fts_writeRead(cmd, cmdLength, outBuf, byteToRead); +} +int fts_write_dma_safe(u8 *cmd, int cmdLength) +{ + return fts_write(cmd, cmdLength); +} +#endif + +/** +* Write a FW command to the IC and check automatically the echo event +* @param cmd byte array containing the command to send +* @param cmdLength size of cmd +* @return OK if success, or an error code which specify the type of error encountered +*/ +int fts_writeFwCmd(u8 *cmd, int cmdLength) +{ + int ret = -1; + int ret2 = -1; + int retry = 0; +#ifdef I2C_INTERFACE + struct i2c_msg I2CMsg[1]; + + I2CMsg[0].addr = (__u16) I2CSAD; + I2CMsg[0].flags = (__u16) 0; + I2CMsg[0].len = (__u16) cmdLength; + I2CMsg[0].buf = (__u8 *) cmd; +#else + struct spi_message msg; + struct spi_transfer transfer[1] = { {0} }; + + spi_message_init(&msg); + + transfer[0].len = cmdLength; + transfer[0].delay_usecs = SPI_DELAY_CS; + transfer[0].tx_buf = cmd; + transfer[0].rx_buf = NULL; + spi_message_add_tail(&transfer[0], &msg); +#endif + + if (client == NULL) + return ERROR_BUS_O; + resetErrorList(); + while (retry < I2C_RETRY && (ret < OK || ret2 < OK)) { +#ifdef I2C_INTERFACE + ret = i2c_transfer(getClient()->adapter, I2CMsg, 1); +#else + ret = spi_sync(getClient(), &msg); +#endif + retry++; + if (ret >= 0) + ret2 = checkEcho(cmd, cmdLength); + if (ret < OK || ret2 < OK) + mdelay(I2C_WAIT_BEFORE_RETRY); + } + if (ret < 0) { + logError(1, "%s fts_writeFwCmd: ERROR %08X\n", tag, + ERROR_BUS_W); + return ERROR_BUS_W; + } + if (ret2 < OK) { + logError(1, "%s fts_writeFwCmd: check echo ERROR %08X\n", tag, + ret2); + return ret2; + } + return OK; +} + +/** +* Perform two bus write and one bus read without any stop condition +* In case of FTI this function is not supported and the same sequence can be achieved calling fts_write followed by an fts_writeRead. +* @param writeCmd1 byte array containing the first command to write +* @param writeCmdLength size of writeCmd1 +* @param readCmd1 byte array containing the second command to write +* @param readCmdLength size of readCmd1 +* @param outBuf pointer of a byte array which should contain the bytes read from the IC +* @param byteToRead number of bytes to read +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_writeThenWriteRead(u8 *writeCmd1, int writeCmdLength, u8 *readCmd1, + int readCmdLength, u8 *outBuf, int byteToRead) +{ + int ret = -1; + int retry = 0; + +#ifdef I2C_INTERFACE + struct i2c_msg I2CMsg[3]; + + I2CMsg[0].addr = (__u16) I2CSAD; + I2CMsg[0].flags = (__u16) 0; + I2CMsg[0].len = (__u16) writeCmdLength; + I2CMsg[0].buf = (__u8 *) writeCmd1; + + I2CMsg[1].addr = (__u16) I2CSAD; + I2CMsg[1].flags = (__u16) 0; + I2CMsg[1].len = (__u16) readCmdLength; + I2CMsg[1].buf = (__u8 *) readCmd1; + + I2CMsg[2].addr = (__u16) I2CSAD; + I2CMsg[2].flags = I2C_M_RD; + I2CMsg[2].len = byteToRead; + I2CMsg[2].buf = (__u8 *) outBuf; +#else + struct spi_message msg; + struct spi_transfer transfer[3] = { {0}, {0}, {0} }; + + spi_message_init(&msg); + + transfer[0].len = writeCmdLength; + transfer[0].tx_buf = writeCmd1; + transfer[0].rx_buf = NULL; + spi_message_add_tail(&transfer[0], &msg); + + transfer[1].len = readCmdLength; + transfer[1].tx_buf = readCmd1; + transfer[1].rx_buf = NULL; + spi_message_add_tail(&transfer[1], &msg); + + transfer[2].len = byteToRead; + transfer[2].delay_usecs = SPI_DELAY_CS; + transfer[2].tx_buf = NULL; + transfer[2].rx_buf = outBuf; + spi_message_add_tail(&transfer[2], &msg); +#endif + + if (client == NULL) + return ERROR_BUS_O; + while (retry < I2C_RETRY && ret < OK) { +#ifdef I2C_INTERFACE + ret = i2c_transfer(getClient()->adapter, I2CMsg, 3); +#else + ret = spi_sync(getClient(), &msg); +#endif + retry++; + if (ret < OK) + mdelay(I2C_WAIT_BEFORE_RETRY); + } + + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ERROR_BUS_WR); + return ERROR_BUS_WR; + } + return OK; + +} + +/** +* Perform a chunked write with one byte op code and 1 to 8 bytes address +* @param cmd byte containing the op code to write +* @param addrSize address size in byte +* @param address the starting address +* @param data pointer of a byte array which contain the bytes to write +* @param dataSize size of data +* @return OK if success or an error code which specify the type of error encountered +*/ +/* this function works only if the address is max 8 bytes */ +int fts_writeU8UX(u8 cmd, AddrSize addrSize, u64 address, u8 *data, + int dataSize) +{ + + u8 *finalCmd = buf1; + int remaining = dataSize; + int toWrite = 0, i = 0; + + mutex_lock(&rw_lock); + if (addrSize <= sizeof(u64)) { + + while (remaining > 0) { + if (remaining >= WRITE_CHUNK) { + toWrite = WRITE_CHUNK; + remaining -= WRITE_CHUNK; + } else { + toWrite = remaining; + remaining = 0; + } + + finalCmd[0] = cmd; + logError(0, "%s %s: addrSize = %d \n", tag, __func__, + addrSize); + for (i = 0; i < addrSize; i++) { + finalCmd[i + 1] = + (u8) ((address >> ((addrSize - 1 - i) * 8)) + & 0xFF); + logError(1, "%s %s: cmd[%d] = %02X \n", tag, + __func__, i + 1, finalCmd[i + 1]); + } + + memcpy(&finalCmd[addrSize + 1], data, toWrite); + + if (fts_write(finalCmd, 1 + addrSize + toWrite) < OK) { + logError(1, "%s %s: ERROR %08X \n", tag, + __func__, ERROR_BUS_W); + mutex_unlock(&rw_lock); + return ERROR_BUS_W; + } + + address += toWrite; + + data += toWrite; + } + } else { + logError(1, + "%s %s: address size bigger than max allowed %d... ERROR %08X \n", + tag, __func__, sizeof(u64), ERROR_OP_NOT_ALLOW); + } + mutex_unlock(&rw_lock); + + return OK; +} + +/** +* Perform a chunked write read with one byte op code and 1 to 8 bytes address and dummy byte support. +* @param cmd byte containing the op code to write +* @param addrSize address size in byte +* @param address the starting address +* @param outBuf pointer of a byte array which contain the bytes to read +* @param byteToRead number of bytes to read +* @param hasDummyByte if the first byte of each reading is dummy (must be skipped) set to 1, otherwise if it is valid set to 0 (or any other value) +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_writeReadU8UX(u8 cmd, AddrSize addrSize, u64 address, u8 *outBuf, + int byteToRead, int hasDummyByte) +{ + u8 *finalCmd = buf1; + u8 *buff = buf2; + int remaining = byteToRead; + int toRead = 0, i = 0; + + mutex_lock(&rw_lock); + while (remaining > 0) { + if (remaining >= READ_CHUNK) { + toRead = READ_CHUNK; + remaining -= READ_CHUNK; + } else { + toRead = remaining; + remaining = 0; + } + + finalCmd[0] = cmd; + for (i = 0; i < addrSize; i++) { + finalCmd[i + 1] = + (u8) ((address >> ((addrSize - 1 - i) * 8)) & 0xFF); + } + + if (hasDummyByte == 1) { + if (fts_writeRead + (finalCmd, 1 + addrSize, buff, toRead + 1) < OK) { + logError(1, + "%s %s: read error... ERROR %08X \n", + tag, __func__, ERROR_BUS_WR); + mutex_unlock(&rw_lock); + return ERROR_BUS_WR; + } + memcpy(outBuf, buff + 1, toRead); + } else { + if (fts_writeRead(finalCmd, 1 + addrSize, buff, toRead) + < OK) { + logError(1, + "%s %s: read error... ERROR %08X \n", + tag, __func__, ERROR_BUS_WR); + mutex_unlock(&rw_lock); + return ERROR_BUS_WR; + } + memcpy(outBuf, buff, toRead); + } + + address += toRead; + + outBuf += toRead; + } + + mutex_unlock(&rw_lock); + + return OK; +} + +/** +* Perform a chunked write followed by a second write with one byte op code for each write and 1 to 8 bytes address (the sum of the 2 address size of the two writes can not exceed 8 bytes) +* @param cmd1 byte containing the op code of first write +* @param addrSize1 address size in byte of first write +* @param cmd2 byte containing the op code of second write +* @param addrSize2 address size in byte of second write +* @param address the starting address +* @param data pointer of a byte array which contain the bytes to write +* @param dataSize size of data +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_writeU8UXthenWriteU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, + AddrSize addrSize2, u64 address, u8 *data, + int dataSize) +{ + u8 *finalCmd1 = NULL; + u8 *finalCmd2 = buf1; + int remaining = dataSize; + int toWrite = 0, i = 0, ret = OK; + + mutex_lock(&rw_lock); + finalCmd1 = (u8 *)kzalloc(sizeof(u8) * 10, GFP_KERNEL); + if (!finalCmd1) { + ret = ERROR_ALLOC; + goto end; + } + + while (remaining > 0) { + if (remaining >= WRITE_CHUNK) { + toWrite = WRITE_CHUNK; + remaining -= WRITE_CHUNK; + } else { + toWrite = remaining; + remaining = 0; + } + + finalCmd1[0] = cmd1; + for (i = 0; i < addrSize1; i++) { + finalCmd1[i + 1] = + (u8) ((address >> + ((addrSize1 + addrSize2 - 1 - + i) * 8)) & 0xFF); + } + + finalCmd2[0] = cmd2; + for (i = addrSize1; i < addrSize1 + addrSize2; i++) { + finalCmd2[i - addrSize1 + 1] = + (u8) ((address >> + ((addrSize1 + addrSize2 - 1 - + i) * 8)) & 0xFF); + } + + memcpy(&finalCmd2[addrSize2 + 1], data, toWrite); + + if (fts_write(finalCmd1, 1 + addrSize1) < OK) { + logError(1, "%s %s: first write error... ERROR %08X \n", + tag, __func__, ERROR_BUS_W); + ret = ERROR_BUS_W; + goto end; + } + + if (fts_write(finalCmd2, 1 + addrSize2 + toWrite) < OK) { + logError(1, + "%s %s: second write error... ERROR %08X \n", + tag, __func__, ERROR_BUS_W); + ret = ERROR_BUS_W; + goto end; + } + + address += toWrite; + + data += toWrite; + } + +end: + if (finalCmd1) + kfree(finalCmd1); + mutex_unlock(&rw_lock); + + return ret; +} + +/** +* Perform a chunked write followed by a write read with one byte op code and 1 to 8 bytes address for each write and dummy byte support. +* @param cmd1 byte containing the op code of first write +* @param addrSize1 address size in byte of first write +* @param cmd2 byte containing the op code of second write read +* @param addrSize2 address size in byte of second write read +* @param address the starting address +* @param outBuf pointer of a byte array which contain the bytes to read +* @param byteToRead number of bytes to read +* @param hasDummyByte if the first byte of each reading is dummy (must be skipped) set to 1, otherwise if it is valid set to 0 (or any other value) +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_writeU8UXthenWriteReadU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, + AddrSize addrSize2, u64 address, u8 *outBuf, + int byteToRead, int hasDummyByte) +{ + u8 *finalCmd1 = NULL; + u8 *finalCmd2 = NULL; + u8 *buff = buf1; + int remaining = byteToRead; + int toRead = 0, i = 0, ret = OK; + + mutex_lock(&rw_lock); + finalCmd1 = (u8 *)kzalloc(sizeof(u8) * 10, GFP_KERNEL); + if (!finalCmd1) { + ret = ERROR_ALLOC; + goto end; + } + finalCmd2 = (u8 *)kzalloc(sizeof(u8) * 10, GFP_KERNEL); + if (!finalCmd2) { + ret = ERROR_ALLOC; + goto end; + } + + while (remaining > 0) { + if (remaining >= READ_CHUNK) { + toRead = READ_CHUNK; + remaining -= READ_CHUNK; + } else { + toRead = remaining; + remaining = 0; + } + + finalCmd1[0] = cmd1; + for (i = 0; i < addrSize1; i++) { + finalCmd1[i + 1] = + (u8) ((address >> + ((addrSize1 + addrSize2 - 1 - + i) * 8)) & 0xFF); + } + + finalCmd2[0] = cmd2; + for (i = addrSize1; i < addrSize1 + addrSize2; i++) { + finalCmd2[i - addrSize1 + 1] = + (u8) ((address >> + ((addrSize1 + addrSize2 - 1 - + i) * 8)) & 0xFF); + } + + if (fts_write(finalCmd1, 1 + addrSize1) < OK) { + logError(1, "%s %s: first write error... ERROR %08X \n", + tag, __func__, ERROR_BUS_W); + ret = ERROR_BUS_W; + goto end; + } + + if (hasDummyByte == 1) { + if (fts_writeRead + (finalCmd2, 1 + addrSize2, buff, toRead + 1) < OK) { + logError(1, + "%s %s: read error... ERROR %08X \n", + tag, __func__, ERROR_BUS_WR); + ret = ERROR_BUS_WR; + goto end; + } + memcpy(outBuf, buff + 1, toRead); + } else { + if (fts_writeRead + (finalCmd2, 1 + addrSize2, buff, toRead) < OK) { + logError(1, + "%s %s: read error... ERROR %08X \n", + tag, __func__, ERROR_BUS_WR); + ret = ERROR_BUS_WR; + goto end; + } + memcpy(outBuf, buff, toRead); + } + + address += toRead; + + outBuf += toRead; + } + +end: + if (finalCmd1) + kfree(finalCmd1); + if (finalCmd2) + kfree(finalCmd2); + mutex_unlock(&rw_lock); + return ret; +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.h new file mode 100644 index 000000000000..954c2f5148de --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsIO.h @@ -0,0 +1,59 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* I2C/SPI Communication * +* * +************************************************************************** +************************************************************************** + +*/ +/*! +* \file ftsIO.h +* \brief Contains all the definitions and prototypes used and implemented in ftsIO.c +*/ + +#ifndef FTS_IO_H +#define FTS_IO_H + +#include "ftsSoftware.h" + +#define I2C_RETRY 3 +#define I2C_WAIT_BEFORE_RETRY 2 + +#ifdef I2C_INTERFACE +#include +#include +struct i2c_client *getClient(void); +#else +#include +struct spi_device *getClient(void); +#endif + + + +int openChannel(void *clt); +struct device *getDev(void); + + + +/*************** NEW I2C API ****************/ +int changeSAD(u8 sad); +int fts_read(u8 *outBuf, int byteToRead); +int fts_writeRead(u8 *cmd, int cmdLength, u8 *outBuf, int byteToRead); +int fts_write(u8 *cmd, int cmdLength); +int fts_read_dma_safe(u8 *outBuf, int byteToRead); +int fts_writeRead_dma_safe(u8 *cmd, int cmdLength, u8 *outBuf, int byteToRead); +int fts_write_dma_safe(u8 *cmd, int cmdLength); +int fts_writeFwCmd(u8 *cmd, int cmdLenght); +int fts_writeThenWriteRead(u8 *writeCmd1, int writeCmdLength, u8 *readCmd1, + int readCmdLength, u8 *outBuf, int byteToRead); +int fts_writeU8UX(u8 cmd, AddrSize addrSize, u64 address, u8 *data, int dataSize); +int fts_writeReadU8UX(u8 cmd, AddrSize addrSize, u64 address, u8 *outBuf, int byteToRead, int hasDummyByte); +int fts_writeU8UXthenWriteU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, AddrSize addrSize2, u64 address, u8 *data, int dataSize); +int fts_writeU8UXthenWriteReadU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, AddrSize addrSize2, u64 address, u8 *outBuf, int count, int hasDummyByte); +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsSoftware.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsSoftware.h new file mode 100644 index 000000000000..b270a2bcded1 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsSoftware.h @@ -0,0 +1,379 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FW related data * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsSoftware.h +* \brief Contains all the definitions and information related to the IC from a fw/driver point of view +*/ + + +#ifndef FTS_SOFTWARE_H +#define FTS_SOFTWARE_H +#include +#include "ftsHardware.h" + +typedef signed char i8; /*basic type that represent one signed byte (or 8 bits)*/ + +/** + * Enumerator which contains all the possible address length expressed in bytes. + */ +typedef enum { + NO_ADDR = 0, + BITS_8 = 1, + BITS_16 = 2, + BITS_24 = 3, + BITS_32 = 4, + BITS_40 = 5, + BITS_48 = 6, + BITS_56 = 7, + BITS_64 = 8 +} AddrSize; + +/******************** NEW API *********************/ + +/** @defgroup host_command Fw Host op codes + * Valid op codes for fw commands + * @{ + */ + +/** @defgroup scan_mode Scan Mode +* @ingroup host_command +* Set the scanning mode required according to the parameters +* @{ +*/ +#define FTS_CMD_SCAN_MODE 0xA0 /*OP Code to set scan mode*/ +/** @} */ + +/** @defgroup feat_sel Feature Select +* @ingroup host_command +* Set the system defined features to enable/disable according the parameters +* @{ +*/ +#define FTS_CMD_FEATURE 0xA2 /*OP code to set features*/ +/** @} */ + +/** @defgroup sys_cmd System Command +* @ingroup host_command +* Execute a system command to perform core tasks +* @{ +*/ +#define FTS_CMD_SYSTEM 0xA4 /*OP code to write s system command*/ + +#define FTS_CMD_LOCKDOWN_ID 0x70 +#define FTS_CMD_CUSTOM 0xC0 +/** @} */ + +/** @} */ + +/*SCAN MODE OPTION (0xA0)*/ +/** @defgroup scan_opt Scan Mode Option +* @ingroup scan_mode +* Valid scanning modes and their options +* @{ +*/ +#define SCAN_MODE_ACTIVE 0x00 /*Select the Active scanning mode*/ +#define SCAN_MODE_LOW_POWER 0x01 /*Select the low power scanning mode*/ +#define SCAN_MODE_JIG_1 0x02 /*Select the Jig test 1*/ +#define SCAN_MODE_LOCKED 0x03 /*Select the Scan mode which will be locked*/ +/** @}*/ + +/** @defgroup active_bitmask Active Mode Bitmask +* @ingroup scan_opt +* Bitmask to use to enables the specific scanning with the SCAN_MODE_ACTIVE option +* @{ +*/ +#define ACTIVE_MULTI_TOUCH 0x01 /*Bit 0 MS/SS scan*/ +#define ACTIVE_KEY 0x02 /*Bit 1 Key scan*/ +#define ACTIVE_HOVER 0x04 /*Bit 2 Hover scan*/ +#define ACTIVE_PROXIMITY 0x08 /*Bit 3 Proximity scan*/ +#define ACTIVE_FORCE 0x10 /*Bit 4 Force scan*/ +/** @}*/ + +/** @defgroup locked_opt Locked Mode Option +* @ingroup scan_opt +* Options to enable and lock specific scanning with the SCAN_MODE_LOCKED option +* @{ +*/ +#define LOCKED_ACTIVE 0x00 /*Active Scan Mode*/ +#define LOCKED_HOVER 0x01 /*Hover Scan Mode*/ +#define LOCKED_IDLE 0x02 /*Idle Scan Mode*/ +#define LOCKED_LP_DETECT 0x10 /*Low Power SS*/ +#define LOCKED_LP_ACTIVE 0x11 /*Low Power MS*/ +/** @}*/ + +/** @defgroup feat_opt Feature Selection Option +* @ingroup feat_sel +* System defined features that can be enable/disable +* @{ +*/ +#define FEAT_SEL_GLOVE 0x00 /*Glove Mode*/ +#define FEAT_SEL_COVER 0x01 /*Cover Mode*/ +#define FEAT_SEL_CHARGER 0x02 /*Charger Mode*/ +#define FEAT_SEL_GESTURE 0x03 /*Gesture Mode*/ +#define FEAT_SEL_GRIP 0x04 /*Grip Detection*/ +#define FEAT_SEL_STYLUS 0x07 /*Stylus Mode (this is a driver define, not available in FW)*/ +/** @}*/ + +#define FEAT_ENABLE 1 /*General value to enable a feature*/ +#define FEAT_DISABLE 0 /*General value to disable a feature*/ + +/** @defgroup charger_opt Charger Mode Option +* @ingroup feat_sel +* Option for Charger Mode, it is a bitmask where the each bit indicate a different kind of chager +* @{ +*/ +#define CHARGER_CABLE 0x01 /*normal usb charger*/ +#define CHARGER_WIRLESS 0x02 /*wireless charger*/ +/** @}*/ + +/** @defgroup gesture_opt Gesture Mode Option +* @ingroup feat_sel +* Gesture IDs of the predefined gesture recognized by the fw. +* The ID represent also the position of the corresponding bit in the gesture mask +* @{ +*/ +#define GEST_ID_UP_1F 0x01 /*Bottom to Top line*/ +#define GEST_ID_DOWN_1F 0x02 /*Top to bottom line*/ +#define GEST_ID_LEFT_1F 0x03 /*Right to left line*/ +#define GEST_ID_RIGHT_1F 0x04 /*Left to right line*/ +#define GEST_ID_DBLTAP 0x05 /*Double Tap*/ +#define GEST_ID_O 0x06 /*'O'*/ +#define GEST_ID_C 0x07 /*'C'*/ +#define GEST_ID_M 0x08 /*'M'*/ +#define GEST_ID_W 0x09 /*'W'*/ +#define GEST_ID_E 0x0A /*'e'*/ +#define GEST_ID_L 0x0B /*'L'*/ +#define GEST_ID_F 0x0C /*'F'*/ +#define GEST_ID_V 0x0D /*'V'*/ +#define GEST_ID_AT 0x0E /*'@'*/ +#define GEST_ID_S 0x0F /*'S'*/ +#define GEST_ID_Z 0x10 /*'Z'*/ +#define GEST_ID_LEFTBRACE 0x11 /*'<'*/ +#define GEST_ID_RIGHTBRACE 0x12 /*'>'*/ +#define GEST_ID_CARET 0x13 /*'^'*/ +#define GEST_ID_LONG_PRESS 0x18 /*'^'*/ +#define GEST_ID_SINGTAP 0x19 /*'^'*/ +/** @}*/ + +/** @defgroup sys_opt System Command Option +* @ingroup sys_cmd +* Valid System Command Parameters +* @{ +*/ +#define SYS_CMD_SPECIAL 0x00 /*Special Commands*/ +#define SYS_CMD_INT 0x01 /*FW Interrupt Control*/ +#define SYS_CMD_FORCE_CAL 0x02 /*Force Calibration*/ +#define SYS_CMD_CX_TUNING 0x03 /*CX initialization*/ +#define SYS_CMD_ITO 0x04 /*ITO test*/ +#define SYS_CMD_SAVE_FLASH 0x05 /*Saving to flash*/ +#define SYS_CMD_LOAD_DATA 0x06 /*Load Host data memory*/ +#define SYS_CMD_SPECIAL_TUNING 0x08 /*Perform some special tuning*/ +/** @} */ + +/** @defgroup sys_special_opt Special Command Option +* @ingroup sys_cmd +* Valid special command +* @{ +*/ +#define SPECIAL_SYS_RESET 0x00 /*System Reset triggered by the FW*/ +#define SPECIAL_FIFO_FLUSH 0x01 /*Flush of the FIFO*/ +#define SPECIAL_PANEL_INIT 0x02 /*Panel Initialization*/ +#define SPECIAL_FULL_PANEL_INIT 0x03 /*Full panel initialization*/ +/** @} */ + +#define CAL_MS_TOUCH 0x00 /*Mutual Sense Touch*/ +#define CAL_MS_LOW_POWER 0x01 /*Mutual Sense Touch in low power mode*/ +#define CAL_SS_TOUCH 0x02 /*Self Sense Touch*/ +#define CAL_SS_IDLE 0x03 /*Self Sense Touch in idle mode*/ +#define CAL_MS_KEY 0x04 /*Mutual Sense Key*/ +#define CAL_SS_KEY 0x05 /*Self Sense Key*/ +#define CAL_MS_FORCE 0x06 /*Mutual Sense Force*/ +#define CAL_SS_FORCE 0x07 /*Self Sense Force*/ + +/** @defgroup ito_opt ITO Test Option +* @ingroup sys_cmd +* Valid option for the ITO test +* @{ +*/ +#define ITO_FORCE_OPEN 0x00 /*Check if some force channels is open*/ +#define ITO_SENSE_OPEN 0x01 /*Check if some sense channels is open*/ +#define ITO_FORCE_GROUND 0x02 /*Check if some force channels is short to ground*/ +#define ITO_SENSE_GROUND 0x03 /*Check if some sense channels is short to ground*/ +#define ITO_FORCE_VDD 0x04 /*Check if some force channels is short to VDD*/ +#define ITO_SENSE_VDD 0x05 /*Check if some sense channels is short to VDD*/ +#define ITO_FORCE_FORCE 0x06 /*Check force to force channels*/ +#define ITO_FORCE_SENSE 0x07 /*Check force to sense channels*/ +#define ITO_SENSE_SENSE 0x08 /*Check sense to sense channels*/ +#define ITO_KEY_FORCE_OPEN 0x09 /*Check if some force channels used for the key is open*/ +#define ITO_KEY_SENSE_OPEN 0x0A /*Check if some sense channels used for the key is open*/ +/** @}*/ + +/** @defgroup save_opt Save to Flash Option +* @ingroup sys_cmd +* Valid option for saving data to the Flash +* @{ +*/ +#define SAVE_FW_CONF 0x01 /*Save the confing to the flash*/ +#define SAVE_CX 0x02 /*Save the CX to the flash*/ +#define SAVE_PANEL_CONF 0x04 /*Save the Panel configuration to the flash*/ +/** @}*/ + +/** @defgroup load_opt Load Host Data Option +* @ingroup sys_cmd +* Valid option to ask to the FW to load host data into the memory +* @{ +*/ +#define LOAD_SYS_INFO 0x01 /*Load System Info*/ +#define LOAD_CX_MS_TOUCH 0x10 /*Load MS Init Data for Active Mode*/ +#define LOAD_CX_MS_LOW_POWER 0x11 /*Load MS Init Data for Low Power Mode*/ +#define LOAD_CX_SS_TOUCH 0x12 /*Load SS Init Data for Active Mode*/ +#define LOAD_CX_SS_TOUCH_IDLE 0x13 /*Load SS Init Data for Low Power Mode*/ +#define LOAD_CX_MS_KEY 0x14 /*Load MS Init Data for Key*/ +#define LOAD_CX_SS_KEY 0x15 /*Load SS Init Data for Key*/ +#define LOAD_CX_MS_FORCE 0x16 /*Load MS Init Data for Force*/ +#define LOAD_CX_SS_FORCE 0x17 /*Load SS Init Data for Force*/ +#define LOAD_CX_SS_HOVER 0x18 /*Load SS Hover Init Data for* Force */ +#define LOAD_SYNC_FRAME_RAW 0x30 /*Load a Synchronized Raw Frame*/ +#define LOAD_SYNC_FRAME_FILTER 0x31 /*Load a Synchronized Filter Frame*/ +#define LOAD_SYNC_FRAME_STRENGTH 0x33 /*Load a Synchronized Strength Frame*/ +#define LOAD_SYNC_FRAME_BASELINE 0x32 /*Load a Synchronized Baseline Frame*/ +#define LOAD_PANEL_CX_TOT_MS_TOUCH 0x50 /*Load TOT MS Init Data for Active Mode*/ +#define LOAD_PANEL_CX_TOT_MS_LOW_POWER 0x51 /*Load TOT MS Init Data for Low Power Mode*/ +#define LOAD_PANEL_CX_TOT_SS_TOUCH 0x52 /*Load TOT SS Init Data for Active Mode*/ +#define LOAD_PANEL_CX_TOT_SS_TOUCH_IDLE 0x53 /*Load TOT SS Init Data for Low Power Mode*/ +#define LOAD_PANEL_CX_TOT_MS_KEY 0x54 /*Load TOT MS Init Data for Key*/ +#define LOAD_PANEL_CX_TOT_SS_KEY 0x55 /*Load TOT SS Init Data for Key*/ +#define LOAD_PANEL_CX_TOT_MS_FORCE 0x56 /*Load TOT MS Init Data for Force*/ +#define LOAD_PANEL_CX_TOT_SS_FORCE 0x57 /*Load TOT SS Init Data for Force*/ +#define STAPI_HOST_DATA_ID_PANEL_CX_SS_HVR 0x58 /*Load HOVER TOT SS Init Data for Activity*/ + +/** @}*/ + +#define SPECIAL_TUNING_LP_TIMER 0x01 /*Perform LP Timer calibration*/ +#define SPECIAL_TUNING_IOFF 0x02 /*Perform Ioff calibration*/ + +/** @}*/ + +/** @defgroup events_group FW Event IDs and Types +* Event IDs and Types pushed by the FW into the FIFO +* @{ +*/ +#define EVT_ID_NOEVENT 0x00 /*No Events*/ +#define EVT_ID_CONTROLLER_READY 0x03 /*Controller ready, issued after a system reset.*/ +#define EVT_ID_ENTER_POINT 0x13 /*Touch enter in the sensing area*/ +#define EVT_ID_MOTION_POINT 0x23 /*Touch motion (a specific touch changed position)*/ +#define EVT_ID_LEAVE_POINT 0x33 /*Touch leave the sensing area*/ +#define EVT_ID_STATUS_UPDATE 0x43 /*FW report a system condition change*/ +#define EVT_ID_USER_REPORT 0x53 /*User related events triggered (keys, gestures, proximity etc)*/ +#define EVT_ID_DEBUG 0xE3 /*Debug Info*/ +#define EVT_ID_ERROR 0xF3 /*Error Event*/ + +#define NUM_EVT_ID (((EVT_ID_ERROR & 0xF0) >> 4) + 1) /*Max number of unique event IDs supported*/ +/** @}*/ + +/** @defgroup status_type Status Event Types +* @ingroup events_group +* Types of EVT_ID_STATUS_UPDATE events +* @{ +*/ +#define EVT_TYPE_STATUS_ECHO 0x01 /*Echo event, contain the first 5 bytes of the FW command sent*/ +#define EVT_TYPE_STATUS_FRAME_DROP 0x03 /*Some frame was skipped during the elaboration*/ +#define EVT_TYPE_STATUS_FORCE_CAL 0x05 /*Force Calibration has triggered*/ +#define EVT_TYPE_STATUS_WATER 0x06 /*Water Mode*/ +#define EVT_TYPE_STATUS_SS_RAW_SAT 0x07 /*Self Sense data saturated*/ +#define EVT_TYPE_STATUS_POCKET 0x09 +/** @} */ + +/** @defgroup user_type User Event Types +* @ingroup events_group +* Types of EVT_ID_USER_REPORT events generated by thw FW +* @{ +*/ +#define EVT_TYPE_USER_KEY 0x00 /*Keys pressed/relesed event report*/ +#define EVT_TYPE_USER_PROXIMITY 0x01 /*Proximity detection event report*/ +#define EVT_TYPE_USER_GESTURE 0x02 /*Gesture detection event report*/ +#define EVT_TYPE_USER_EARDET 0x03 /*ear detection event report*/ + +/** @}*/ + +/** @defgroup error_type Error Event Types +* @ingroup events_group +* Types of EVT_ID_ERROR events reported by the FW +* @{ +*/ +#define EVT_TYPE_ERROR_WATCHDOG 0x06 /*Watchdog timer expired*/ + +#define EVT_TYPE_ERROR_CRC_CFG_HEAD 0x20 /*CRC error in the Config Area Header*/ +#define EVT_TYPE_ERROR_CRC_CFG 0x21 /*CRC error in the Config Area*/ +#define EVT_TYPE_ERROR_CRC_PANEL_HEAD 0x22 /*CRC error in the Panel Area Header*/ +#define EVT_TYPE_ERROR_CRC_PANEL 0x23 /*CRC error in the Panel Area*/ + +#define EVT_TYPE_ERROR_ITO_FORCETOGND 0x60 /*Force channel/s short to ground*/ +#define EVT_TYPE_ERROR_ITO_SENSETOGND 0x61 /*Sense channel/s short to ground*/ +#define EVT_TYPE_ERROR_ITO_FORCETOVDD 0x62 /*Force channel/s short to VDD*/ +#define EVT_TYPE_ERROR_ITO_SENSETOVDD 0x63 /*Sense channel/s short to VDD*/ +#define EVT_TYPE_ERROR_ITO_FORCE_P2P 0x64 /*Pin to Pin short Force channel/s*/ +#define EVT_TYPE_ERROR_ITO_SENSE_P2P 0x65 /*Pin to Pin short Sense channel/s*/ +#define EVT_TYPE_ERROR_ITO_FORCEOPEN 0x66 /*Force Panel open*/ +#define EVT_TYPE_ERROR_ITO_SENSEOPEN 0x67 /*Sense Panel open*/ +#define EVT_TYPE_ERROR_ITO_KEYOPEN 0x68 /*Key open*/ + +#define EVT_TYPE_ERROR_CRC_CX_HEAD 0xA0 /*CRC error in the CX Area Header*/ +#define EVT_TYPE_ERROR_CRC_CX 0xA1 /*CRC error in the CX Area*/ +#define EVT_TYPE_ERROR_CRC_CX_SUB_HEAD 0xA5 /*CRC error in the CX Subsection Area Header*/ +#define EVT_TYPE_ERROR_CRC_CX_SUB 0xA6 /*CRC error in the CX Subsection Area*/ + +#define EVT_TYPE_ERROR_ESD 0xF0 /*ESD error*/ +/** @}*/ + +/** @defgroup address Chip Address + * Collection of HW and SW Addresses useful to collect different kind of data + * @{ + */ + +/** @defgroup config_adr SW Address + * @ingroup address + * Important addresses of data stored into Config memory (and sometimes their dimensions) + * @{ + */ +#define ADDR_CONFIG_ID 0x0010 /*Starting Address of the config ID*/ +#define CONFIG_ID_BYTE 2 /*Number of bytes of config ID*/ +#define ADDR_CONFIG_SENSE_LEN 0x0030 /*Address where is stored the number of sense channels*/ +#define ADDR_CONFIG_FORCE_LEN 0x0031 /*Address where is stored the number of force channels*/ +/** @}*/ + +/** @}*/ + +#define ERROR_DUMP_ROW_SIZE 32 /*number of rows of the error memory*/ +#define ERROR_DUMP_COL_SIZE 4 /*number of bytes for each row of the error memory*/ +#define ERROR_DUMP_SIGNATURE 0xFA5005AF /*first row signature of a proper dump*/ + +#define TOUCH_TYPE_INVALID 0x00 /*Invalid touch type*/ +#define TOUCH_TYPE_FINGER 0x01 /*Finger touch*/ +#define TOUCH_TYPE_GLOVE 0x02 /*Glove touch*/ +#define TOUCH_TYPE_STYLUS 0x03 /*Stylus touch*/ +#define TOUCH_TYPE_PALM 0x04 /*Palm touch*/ +#define TOUCH_TYPE_HOVER 0x05 /*Hovering touch*/ + +#define FTS_KEY_0 0x01 /*Key 0 bit*/ +#define FTS_KEY_1 0x02 /*Key 1 bit*/ +#define FTS_KEY_2 0x04 /*Key 2 bit*/ +#define FTS_KEY_3 0x08 /*Key 3 bit*/ +#define FTS_KEY_4 0x10 /*Key 4 bit*/ +#define FTS_KEY_5 0x20 /*Key 5 bit*/ +#define FTS_KEY_6 0x40 /*Key 6 bit*/ +#define FTS_KEY_7 0x80 /*Key 7 bit*/ + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.c new file mode 100644 index 000000000000..3ec1e4a9605f --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.c @@ -0,0 +1,5936 @@ +/* + + ************************************************************************** + ** STMicroelectronics ** + ************************************************************************** + ** marco.cali@st.com ** + ************************************************************************** + * * + * FTS API for MP test * + * * + ************************************************************************** + ************************************************************************** + + */ + +/*! + * \file ftsTest.c + * \brief Contains all the functions related to the Mass Production Test + */ + +#include "ftsCompensation.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsFrame.h" +#include "ftsHardware.h" +#include "ftsIO.h" +#include "ftsSoftware.h" +#include "ftsTest.h" +#include "ftsTime.h" +#include "ftsTool.h" +#include "../fts.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef LIMITS_H_FILE +#include "../fts_limits.h" +#endif + +TestToDo tests; +static LimitFile limit_file; + +/** + * Initialize the testToDo variable with the default tests to perform during the Mass Production Test + * @return OK + */ +int initTestToDo(void) +{ + /*** Initialize Limit File ***/ + limit_file.size = 0; + limit_file.data = NULL; + strlcpy(limit_file.name, " ", MAX_LIMIT_FILE_NAME); + tests.SelfHoverForceRaw=1; /* /< SS Hover Force Raw min/Max test */ + tests.SelfHoverSenceRaw=1; /* /< SS Hover Sence Raw min/Max test */ + tests.SelfHoverForceIxTotal=1; /* /< SS Hover Total Force Ix min/Max (for each node)* test */ + tests.SelfHoverSenceIxTotal=1; + tests.MutualRawAdjITO = 0; + tests.MutualRaw = 0; + tests.MutualRawEachNode = 1; + tests.MutualRawGap = 0; + tests.MutualRawAdj = 0; + tests.MutualRawLP = 0; + tests.MutualRawGapLP = 0; + tests.MutualRawAdjLP = 0; + tests.MutualCx1 = 0; + tests.MutualCx2 = 0; + tests.MutualCx2Adj = 0; + tests.MutualCxTotal = 0; + tests.MutualCxTotalAdj = 0; + + tests.MutualCx1LP = 0; + tests.MutualCx2LP = 1; + tests.MutualCx2AdjLP = 1; + tests.MutualCxTotalLP = 0; + tests.MutualCxTotalAdjLP = 0; +#ifdef PHONE_KEY + tests.MutualKeyRaw = 0; +#else + tests.MutualKeyRaw = 0; +#endif + tests.MutualKeyCx1 = 0; + tests.MutualKeyCx2 = 0; +#ifdef PHONE_KEY + tests.MutualKeyCxTotal = 0; +#else + tests.MutualKeyCxTotal = 0; +#endif + tests.SelfForceRaw = 1; + tests.SelfForceRawGap = 0; + tests.SelfForceRawLP = 0; + tests.SelfForceRawGapLP = 0; + tests.SelfForceIx1 = 0; + tests.SelfForceIx2 = 0; + tests.SelfForceIx2Adj = 0; + tests.SelfForceIxTotal = 1; + tests.SelfForceIxTotalAdj = 0; + tests.SelfForceCx1 = 0; + tests.SelfForceCx2 = 0; + tests.SelfForceCx2Adj = 0; + tests.SelfForceCxTotal = 0; + tests.SelfForceCxTotalAdj = 0; + tests.SelfSenseRaw = 1; + tests.SelfSenseRawGap = 0; + tests.SelfSenseRawLP = 0; + tests.SelfSenseRawGapLP = 0; + tests.SelfSenseIx1 = 0; + tests.SelfSenseIx2 = 0; + tests.SelfSenseIx2Adj = 0; + tests.SelfSenseIxTotal = 1; + tests.SelfSenseIxTotalAdj = 0; + tests.SelfSenseCx1 = 0; + tests.SelfSenseCx2 = 0; + tests.SelfSenseCx2Adj = 0; + tests.SelfSenseCxTotal = 0; + tests.SelfSenseCxTotalAdj = 0; + return OK; +} + +/** + * Compute the Horizontal adjacent matrix doing the abs of the difference between the column i with the i-1 one. \n + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of signed bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjHoriz(i8 *data, int row, int column, u8 **result) +{ + int i, j; + int size = row * (column - 1); + + if (column < 2) { + logError(1, "%s computeAdjHoriz: ERROR % 08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u8 *) kmalloc(size * sizeof(u8), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjHoriz: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 0; i < row; i++) { + for (j = 1; j < column; j++) { + *(*result + (i * (column - 1) + (j - 1))) = + abs(data[i * column + j] - + data[i * column + (j - 1)]); + } + } + + return OK; +} + +/** + * Compute the Horizontal adjacent matrix of short values doing the abs of the difference between the column i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of signed bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjHorizTotal(short *data, int row, int column, u16 **result) +{ + int i, j; + int size = row * (column - 1); + + if (column < 2) { + logError(1, "%s computeAdjHorizTotal: ERROR % 08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u16 *) kmalloc(size * sizeof(u16), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjHorizTotal: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 0; i < row; i++) { + for (j = 1; j < column; j++) { + *(*result + (i * (column - 1) + (j - 1))) = + abs(data[i * column + j] - + data[i * column + (j - 1)]); + } + } + + return OK; +} + +/** + * Compute the Vertical adjacent matrix doing the abs of the difference between the row i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other. \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of signed bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjVert(i8 *data, int row, int column, u8 **result) +{ + int i, j; + int size = (row - 1) * (column); + + if (row < 2) { + logError(1, "%s computeAdjVert: ERROR % 08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u8 *) kmalloc(size * sizeof(u8), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjVert: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 1; i < row; i++) { + for (j = 0; j < column; j++) { + *(*result + ((i - 1) * column + j)) = + abs(data[i * column + j] - + data[(i - 1) * column + j]); + } + } + + return OK; +} + +/** + * Compute the Vertical adjacent matrix of short values doing the abs of the difference between the row i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other. \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of signed bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjVertTotal(short *data, int row, int column, u16 **result) +{ + int i, j; + int size = (row - 1) * (column); + + if (row < 2) { + logError(1, "%s computeAdjVertTotal: ERROR %08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u16 *) kmalloc(size * sizeof(u16), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjVertTotal: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 1; i < row; i++) { + for (j = 0; j < column; j++) { + *(*result + ((i - 1) * column + j)) = + abs(data[i * column + j] - + data[(i - 1) * column + j]); + } + } + + return OK; +} + +/** + * Compute the Horizontal adjacent matrix doing the abs of the difference between the column i with the i-1 one. \n + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of unsigned bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjHorizFromU(u8 *data, int row, int column, u8 **result) +{ + int i, j; + int size = row * (column - 1); + + if (column < 2) { + logError(1, "%s computeAdjHoriz: ERROR %08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u8 *) kmalloc(size * sizeof(u8), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjHoriz: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 0; i < row; i++) { + for (j = 1; j < column; j++) { + *(*result + (i * (column - 1) + (j - 1))) = + abs(data[i * column + j] - + data[i * column + (j - 1)]); + } + } + + return OK; +} + +/** + * Compute the Horizontal adjacent matrix of u16 values doing the abs of the difference between the column i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of unsigned bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjHorizTotalFromU(u16 *data, int row, int column, u16 **result) +{ + int i, j; + int size = row * (column - 1); + + if (column < 2) { + logError(1, "%s computeAdjHorizTotal: ERROR %08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u16 *) kmalloc(size * sizeof(u16), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjHorizTotal: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 0; i < row; i++) { + for (j = 1; j < column; j++) { + *(*result + (i * (column - 1) + (j - 1))) = + abs(data[i * column + j] - + data[i * column + (j - 1)]); + } + } + + return OK; +} + +/** + * Compute the Vertical adjacent matrix doing the abs of the difference between the row i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other. \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of unsigned bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjVertFromU(u8 *data, int row, int column, u8 **result) +{ + int i, j; + int size = (row - 1) * (column); + + if (row < 2) { + logError(1, "%s computeAdjVert: ERROR %08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u8 *) kmalloc(size * sizeof(u8), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjVert: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 1; i < row; i++) { + for (j = 0; j < column; j++) { + *(*result + ((i - 1) * column + j)) = + abs(data[i * column + j] - + data[(i - 1) * column + j]); + } + } + + return OK; +} + +/** + * Compute the Vertical adjacent matrix of u16 values doing the abs of the difference between the row i with the i-1 one. + * Both the original data matrix and the adj matrix are disposed as 1 dimension array one row after the other. \n + * The resulting matrix has one column less than the starting original one \n + * @param data pointer to the array of unsigned bytes containing the original data + * @param row number of rows of the original data + * @param column number of columns of the original data + * @param result pointer of a pointer to an array of unsigned bytes which will contain the adj matrix + * @return OK if success or an error code which specify the type of error encountered + */ +int computeAdjVertTotalFromU(u16 *data, int row, int column, u16 **result) +{ + int i, j; + int size = (row - 1) * (column); + + if (row < 2) { + logError(1, "%s computeAdjVertTotal: ERROR %08X\n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + *result = (u16 *) kmalloc(size * sizeof(u16), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeAdjVertTotal: ERROR %08X\n", tag, + ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 1; i < row; i++) { + for (j = 0; j < column; j++) { + *(*result + ((i - 1) * column + j)) = + abs(data[i * column + j] - + data[(i - 1) * column + j]); + } + } + + return OK; +} + +int computeTotal(u8 *data, u8 main, int row, int column, int m, int n, + u16 **result) +{ + int i, j; + int size = (row) * (column); + *result = (u16 *) kmalloc(size * sizeof(u16), GFP_KERNEL); + + if (*result == NULL) { + logError(1, "%s computeTotal : ERROR %02X\n", tag, ERROR_ALLOC); + return ERROR_ALLOC; + } + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + *(*result + (i * column + j)) = + m * main + n * data[i * column + j]; + } + } + + return OK; +} + +/** + * Check that each value of a matrix of short doesn't exceed a min and a Max value (these values are included in the interval). \n + * The matrix is stored as 1 dimension array one row after the other. \n + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param min minimum value allowed + * @param max Maximum value allowed + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMinMax(short *data, int row, int column, int min, int max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min + || data[i * column + j] > max) { + logError(1, + "%s checkLimitsMinMax: Node[%d,%d] = %d exceed limit [%d, %d] \n", + tag, i, j, data[i * column + j], min, + max); + count++; + } + } + } + + return count; +} + +/** + * Check that the difference between the max and min of a matrix of short is less or equal to a threshold.\n + * The matrix is stored as 1 dimension array one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param threshold threshold value allowed + * @return OK if the difference is <= to threshold otherwise ERROR_TEST_CHECK_FAIL + */ +int checkLimitsGap(short *data, int row, int column, int threshold) +{ + int i, j; + int min_node; + int max_node; + + if (row == 0 || column == 0) { + logError(1, + "%s checkLimitsGap: invalid number of rows = %d or columns = %d ERROR %08X\n", + tag, row, column, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } + + min_node = data[0]; + max_node = data[0]; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min_node) { + min_node = data[i * column + j]; + } else { + if (data[i * column + j] > max_node) + max_node = data[i * column + j]; + } + } + } + + if (max_node - min_node > threshold) { + logError(1, "%s checkLimitsGap: GAP = %d exceed limit %d \n", + tag, max_node - min_node, threshold); + return ERROR_TEST_CHECK_FAIL; + } else + return OK; +} + +/** + * Check that each value of a matrix of i8 doesn't exceed a specific min and Max value set for each node (these values are included in the interval). \n + * The matrixes of data, min and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param min pointer to a matrix which specify the minimum value allowed for each node + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMap(i8 *data, int row, int column, int *min, int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min[i * column + j] + || data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMap: Node[%d,%d] = %d exceed limit [%d, %d] \n", + tag, i, j, data[i * column + j], + min[i * column + j], + max[i * column + j]); + count++; + } + } + } + + return count; +} + +/** + * Check that each value of a matrix of short doesn't exceed a specific min and Max value set for each node (these values are included in the interval). + * The matrixes of data, min and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param min pointer to a matrix which specify the minimum value allowed for each node + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMapTotal(short *data, int row, int column, int *min, int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min[i * column + j] + || data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMapTotal: Node[%d,%d] = %d exceed limit [%d, %d] \n", + tag, i, j, data[i * column + j], + min[i * column + j], + max[i * column + j]); + count++; + } + } + } + + return count; +} + +/** + * Check that each value of a matrix of u8 doesn't exceed a specific min and Max value set for each node (these values are included in the interval). \n + * The matrixes of data, min and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param min pointer to a matrix which specify the minimum value allowed for each node + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMapFromU(u8 *data, int row, int column, int *min, int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min[i * column + j] + || data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMap: Node[%d,%d] = %d exceed limit [%d, %d] \n", + tag, i, j, data[i * column + j], + min[i * column + j], + max[i * column + j]); + count++; + } + } + } + + return count; +} + +/** + * Check that each value of a matrix of u16 doesn't exceed a specific min and Max value set for each node (these values are included in the interval). + * The matrixes of data, min and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param min pointer to a matrix which specify the minimum value allowed for each node + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMapTotalFromU(u16 *data, int row, int column, int *min, + int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] < min[i * column + j] + || data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMapTotal: Node[%d,%d] = %d exceed limit [%d, %d] \n", + tag, i, j, data[i * column + j], + min[i * column + j], + max[i * column + j]); + count++; + } + logError(1, + "%s checkLimitsMapTotal: Node[%d,%d] = %d\n", + tag, i, j, data[i * column + j], + min[i * column + j], + max[i * column + j]); + } + } + + return count; +} + +/** + * Check that each value of a matrix of u8 doesn't exceed a specific Max value set for each node (max value is included in the interval). + * The matrixes of data and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMapAdj(u8 *data, int row, int column, int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMapAdj: Node[%d,%d] = %d exceed limit > %d \n", + tag, i, j, data[i * column + j], + max[i * column + j]); + count++; + } + } + } + + return count; +} + +/** + * Check that each value of a matrix of u16 doesn't exceed a specific Max value set for each node (max value is included in the interval). + * The matrixes of data and max values are stored as 1 dimension arrays one row after the other. + * @param data pointer to the array of short containing the data to check + * @param row number of rows of data + * @param column number of columns of data + * @param max pointer to a matrix which specify the Maximum value allowed for each node + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int checkLimitsMapAdjTotal(u16 *data, int row, int column, int *max) +{ + int i, j; + int count = 0; + + for (i = 0; i < row; i++) { + for (j = 0; j < column; j++) { + if (data[i * column + j] > max[i * column + j]) { + logError(1, + "%s checkLimitsMapAdjTotal: Node[%d,%d] = %d exceed limit > %d \n", + tag, i, j, data[i * column + j], + max[i * column + j]); + count++; + } + } + } + + return count; +} + +/** + * Perform an ITO test setting all the possible options (see @link ito_opt ITO Options @endlink) + * @return the number of elements that overcome the specified interval (0 = OK) + */ +int production_test_ito(char *path_limits, TestToDo *todo) +{ + int res = OK; + u8 sett[2] = { 0x00, 0x00 }; + MutualSenseFrame msRawFrame; + int *thresholds = NULL; + u16 *adj = NULL; + int trows, tcolumns; + logError(1, "%s ITO Production test is starting...\n", tag); + memset(&msRawFrame, 0x00, sizeof(msRawFrame)); + res = fts_system_reset(); + + if (res < 0) { + logError(1, "%s %s: ERROR %08X \n", tag, __func__, + ERROR_PROD_TEST_ITO); + return (res | ERROR_PROD_TEST_ITO); + } + + sett[0] = SPECIAL_TUNING_IOFF; + logError(0, "%s Trimming Ioff... \n", tag); + res = writeSysCmd(SYS_CMD_SPECIAL_TUNING, sett, 2); + + if (res < OK) { + logError(1, "%s production_test_ito: Trimm Ioff ERROR %08X \n", + tag, (res | ERROR_PROD_TEST_ITO)); + return (res | ERROR_PROD_TEST_ITO); + } + + sett[0] = 0xFF; + sett[1] = 0xFF; + logError(0, "%s ITO Check command sent... \n", tag); + res = writeSysCmd(SYS_CMD_ITO, sett, 2); + + if (res < OK) { + logError(1, "%s production_test_ito: ERROR %08X \n", tag, + (res | ERROR_PROD_TEST_ITO)); + return (res | ERROR_PROD_TEST_ITO); + } + + logError(0, "%s ITO Command = OK! \n", tag); + + if (todo->MutualRawAdjITO == 1) { + logError(1, "%s MS RAW ITO ADJ TEST: \n", tag); + logError(0, "%s Collecting MS Raw data... \n", tag); + res |= getMSFrame3(MS_RAW, &msRawFrame); + + if (res < OK) { + logError(1, "%s %s: getMSFrame failed... ERROR %08X \n", + tag, __func__, ERROR_PROD_TEST_ITO); + goto ERROR; + } + + logError(0, "%s MS RAW ITO ADJ HORIZONTAL TEST: \n", tag); + res = + computeAdjHorizTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, &adj); + + if (res < OK) { + logError(1, + "%s %s: computeAdjHoriz failed... ERROR %08X \n", + tag, __func__, ERROR_PROD_TEST_ITO); + goto ERROR; + } + + res = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_ITO_ADJH, &thresholds, + &trows, &tcolumns); + + if (res < OK + || (trows != msRawFrame.header.force_node + || tcolumns != msRawFrame.header.sense_node - 1)) { + logError(1, + "%s %s: parseProductionTestLimits MS_RAW_ITO_ADJH failed... ERROR %08X \n", + tag, __func__, ERROR_PROD_TEST_DATA); + goto ERROR; + } + + res = + checkLimitsMapAdjTotal(adj, msRawFrame.header.force_node, + msRawFrame.header.sense_node - 1, + thresholds); + + if (res != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ITO ADJH failed... ERROR COUNT = %d \n", + tag, res); + logError(0, + "%s MS RAW ITO ADJ HORIZONTAL TEST:.................FAIL \n\n", + tag); + print_frame_short("MS Raw ITO frame =", + array1dTo2d_short + (msRawFrame.node_data, + msRawFrame.node_data_size, + msRawFrame.header.sense_node), + msRawFrame.header.force_node, + msRawFrame.header.sense_node); + res = ERROR_PROD_TEST_ITO; + goto ERROR; + } else + logError(0, + "%s MS RAW ITO ADJ HORIZONTAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + logError(0, "%s MS RAW ITO ADJ VERTICAL TEST: \n", tag); + res = + computeAdjVertTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, &adj); + + if (res < OK) { + logError(1, + "%s %s: computeAdjVert failed... ERROR %08X \n", + tag, __func__, ERROR_PROD_TEST_ITO); + goto ERROR; + } + + res = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_ITO_ADJV, &thresholds, + &trows, &tcolumns); + + if (res < OK + || (trows != msRawFrame.header.force_node - 1 + || tcolumns != msRawFrame.header.sense_node)) { + logError(1, + "%s %s: parseProductionTestLimits MS_RAW_ITO_ADJV failed... ERROR %08X \n", + tag, __func__, ERROR_PROD_TEST_ITO); + goto ERROR; + } + + res = + checkLimitsMapAdjTotal(adj, + msRawFrame.header.force_node - 1, + msRawFrame.header.sense_node, + thresholds); + + if (res != OK) { + logError(1, + "%s %s: checkLimitsAdj MS RAW ITO ADJV failed... ERROR COUNT = %d \n", + tag, __func__, res); + logError(0, + "%s MS RAW ITO ADJ VERTICAL TEST:.................FAIL \n\n", + tag); + print_frame_short("MS Raw ITO frame =", + array1dTo2d_short + (msRawFrame.node_data, + msRawFrame.node_data_size, + msRawFrame.header.sense_node), + msRawFrame.header.force_node, + msRawFrame.header.sense_node); + res = ERROR_PROD_TEST_ITO; + goto ERROR; + } else + logError(0, + "%s MS RAW ITO ADJ VERTICAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + } else + logError(0, + "%s MS RAW ITO ADJ TEST:.................SKIPPED \n", + tag); + +ERROR: + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (adj != NULL) { + kfree(adj); + adj = NULL; + } + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + freeLimitsFile(&limit_file); + res |= fts_system_reset(); + + if (res < OK) { + logError(1, "%s production_test_ito: ERROR %08X \n", tag, + ERROR_PROD_TEST_ITO); + res = (res | ERROR_PROD_TEST_ITO); + } + + return res; +} + +/** + * Perform the Initialization of the IC + * @param type type of initialization to do (see @link sys_special_opt Initialization Options (Full or Panel) @endlink) + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_initialization(u8 type) +{ + int res; + logError(1, "%s INITIALIZATION Production test is starting,type:%d\n", tag, type); + + if (type != SPECIAL_PANEL_INIT && type != SPECIAL_FULL_PANEL_INIT) { + logError(1, + "%s production_test_initialization: Type incompatible! Type = %02X ERROR %08X \n", + tag, type, + ERROR_OP_NOT_ALLOW | ERROR_PROD_TEST_INITIALIZATION); + return (ERROR_OP_NOT_ALLOW | ERROR_PROD_TEST_INITIALIZATION); + } + + res = fts_system_reset(); + + if (res < 0) { + logError(1, "%s production_test_initialization: ERROR %08X \n", + tag, ERROR_PROD_TEST_INITIALIZATION); + return (res | ERROR_PROD_TEST_INITIALIZATION); + } + + logError(0, "%s INITIALIZATION command sent... %02X \n", tag, type); + res = writeSysCmd(SYS_CMD_SPECIAL, &type, 1); + + if (res < OK) { + logError(1, "%s production_test_initialization: ERROR %08X \n", + tag, (res | ERROR_PROD_TEST_INITIALIZATION)); + return (res | ERROR_PROD_TEST_INITIALIZATION); + } + + logError(0, "%s Refresh Sys Info...\n", tag); + res |= readSysInfo(1); + + if (res < 0) { + logError(1, + "%s production_test_initialization: read sys info ERROR %08X\n", + tag, ERROR_PROD_TEST_INITIALIZATION); + res = (res | ERROR_PROD_TEST_INITIALIZATION); + } + + return res; +} + +/** + * Perform a FULL (ITO + INIT + DATA CHECK) Mass Production Test of the IC + * @param pathThresholds name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param saveInit if >0 (possible values: NO_INIT, SPECIAL_PANEL_INIT or SPECIAL_FULL_PANEL_INIT), the Initialization of the IC is executed otherwise it is skipped + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_main(char *pathThresholds, int stop_on_fail, int saveInit, + TestToDo *todo) +{ + int res, ret; + logError(0, "%s MAIN Production test is starting...\n", tag); + logError(0, "%s \n", tag); + logError(0, "%s ITO TEST: \n", tag); + res = production_test_ito(pathThresholds, todo); + + if (res < 0) { + logError(0, "%s Error during ITO TEST! ERROR %08X\n", tag, res); + goto END; + } else { + logError(0, "%s ITO TEST OK!\n", tag); + } + + logError(0, "%s \n", tag); + logError(0, "%s INITIALIZATION TEST : \n", tag); + + if (saveInit != NO_INIT) { + res = production_test_initialization((u8) saveInit); + + if (res < 0) { + logError(0, + "%s Error during INITIALIZATION TEST! ERROR %08X\n", + tag, res); + + if (stop_on_fail) + goto END; + } else { + logError(0, "%s INITIALIZATION TEST OK!\n", tag); + } + } else + logError(0, + "%s INITIALIZATION TEST :................. SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (saveInit == 1) { + logError(0, "%s Cleaning up...\n", tag); + ret = fts_system_reset(); + + if (ret < 0) { + logError(1, + "%s production_test_main: system reset ERROR %08X\n", + tag, ret); + res |= ret; + + if (stop_on_fail) + goto END; + } + + logError(0, "%s \n", tag); + } + + logError(1, "%s PRODUCTION DATA TEST: \n", tag); + ret = production_test_data(pathThresholds, stop_on_fail, todo); + + if (ret < 0) { + logError(0, + "%s Error during PRODUCTION DATA TEST! ERROR %08X\n", + tag, ret); + } else { + logError(0, "%s PRODUCTION DATA TEST OK!\n", tag); + } + + res |= ret; +END: + + if (res < 0) { + logError(0, + "%s MAIN Production test finished.................FAILED \n", + tag); + return res; + } else { + logError(0, + "%s MAIN Production test finished.................OK\n", + tag); + return OK; + } +} + +/** + * Perform all the test selected in a TestTodo variable related to MS raw data (touch, keys etc..) + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ms_raw(char *path_limits, int stop_on_fail, TestToDo *todo) +{ + int ret, count_fail = 0; + MutualSenseFrame msRawFrame; + int *thresholds = NULL; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + int trows, tcolumns; + u16 *adj = NULL; + /******************************* Mutual Sense Test *******************************/ + logError(0, "%s \n", tag); + + if (todo->MutualRaw == 1 || todo->MutualRawGap == 1 + || todo->MutualRawAdj == 1 || todo->MutualRawEachNode == 1) { + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + mdelay(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + ret |= getMSFrame3(MS_RAW, &msRawFrame); + + if (ret < OK) { + logError(1, + "%s production_test_data: getMSFrame failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + + if (todo->MutualRaw == 1) { + logError(1, "%s MS RAW MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < OK || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + thresholds[0], thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS RAW failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW MIN MAX TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s MS RAW MIN MAX TEST:.................SKIPPED \n", + tag); + if (todo->MutualRawEachNode == 1) { + logError(1, "%s MS RAW EACH NODE MIN MAX TEST:\n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, MS_RAW_EACH_NODE_MIN, &thresholds_min, &trows, &tcolumns); + if (ret < OK || (trows != msRawFrame.header.force_node || tcolumns != msRawFrame.header.sense_node)) { + logError(1, "%s production_test_data: parseProductionTestLimits MS_RAW_EACH_NODE_MIN failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + ret = parseProductionTestLimits(path_limits, &limit_file, MS_RAW_EACH_NODE_MAX, &thresholds_max, &trows, &tcolumns); + if (ret < OK || (trows != msRawFrame.header.force_node || + tcolumns != msRawFrame.header.sense_node)) { + logError(1, "%s production_test_data: parseProductionTestLimits MS_RAW_EACH_NODE_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + ret = checkLimitsMapTotal(msRawFrame.node_data, msRawFrame.header.force_node, msRawFrame.header.sense_node, thresholds_min, thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMaxEachNodeData failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS_RAW EACH NODE MIN MAX TEST:.................FAIL\n\n", tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else { + logError(0, "%s MS_RAW_EACH_NODE_MAX TEST:.................OK\n", tag); + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + } else { + logError(0, "%s MS RAW EACH NODE MIN MAX TEST:.................SKIPPED\n", tag); + } + + logError(0, "%s \n", tag); + + if (todo->MutualRawGap == 1) { + logError(1, "%s MS RAW GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_GAP, &thresholds, + &trows, &tcolumns); + + if (ret < OK || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap MS RAW failed... ERROR = %08X \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW GAP TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s MS RAW GAP TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->MutualRawAdj == 1) { + logError(1, "%s MS RAW ADJ HORIZONTAL TEST: \n", tag); + ret = + computeAdjHorizTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + &adj); + + if (ret < OK) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_ADJH, &thresholds, + &trows, &tcolumns); + + if (ret < OK + || (trows != msRawFrame.header.force_node + || tcolumns != + msRawFrame.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(adj, + msRawFrame.header.force_node, + msRawFrame.header. + sense_node - 1, thresholds); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW ADJ HORIZONTAL TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ HORIZONTAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + logError(0, "%s MS RAW ADJ VERTICAL TEST: \n", tag); + ret = + computeAdjVertTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + &adj); + + if (ret < OK) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_ADJV, &thresholds, + &trows, &tcolumns); + + if (ret < OK + || (trows != msRawFrame.header.force_node - 1 + || tcolumns != msRawFrame.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(adj, + msRawFrame.header. + force_node - 1, + msRawFrame.header.sense_node, + thresholds); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJV failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW ADJ VERTICAL TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ VERTICAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + } else + logError(0, + "%s MS RAW ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, "%s MS RAW FRAME TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->MutualKeyRaw == 1) { + logError(1, "%s MS KEY RAW TEST:\n", tag); + ret = production_test_ms_key_raw(path_limits); + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ms_key_raw failed... ERROR = %08X \n", + tag, ret); + count_fail += 1; + + if (count_fail == 1) { + logError(0, + "%s MS RAW DATA TEST:.................FAIL fails_count = %d\n\n", + tag, count_fail); + goto ERROR_LIMITS; + } + } + } else + logError(0, "%s MS KEY RAW TEST:.................SKIPPED \n", + tag); + + ret = production_test_ms_raw_lp(path_limits, stop_on_fail, todo); + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ms_raw_lp failed... ERROR = %08X \n", + tag, ret); + count_fail += 1; + + if (count_fail == 1) { + logError(0, + "%s MS RAW DATA TEST:.................FAIL fails_count = %d\n\n", + tag, count_fail); + goto ERROR_LIMITS; + } + } + +ERROR: + logError(0, "%s \n", tag); + + if (count_fail == 0) { + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + + logError(0, + "%s MS RAW DATA TEST finished!.................OK\n", + tag); + return OK; + } else { + print_frame_short("MS Raw frame =", + array1dTo2d_short(msRawFrame.node_data, + msRawFrame.node_data_size, + msRawFrame.header. + sense_node), + msRawFrame.header.force_node, + msRawFrame.header.sense_node); + + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (adj != NULL) { + kfree(adj); + adj = NULL; + } + logError(0, + "%s MS RAW DATA TEST:.................FAIL fails_count = %d\n\n", + tag, count_fail); + return (ERROR_PROD_TEST_DATA | ERROR_TEST_CHECK_FAIL); + } + +ERROR_LIMITS: + + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + return ret; +} + +/** + * Perform all the test selected in a TestTodo variable related to MS low power raw data + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ms_raw_lp(char *path_limits, int stop_on_fail, + TestToDo *todo) +{ + int ret, count_fail = 0; + MutualSenseFrame msRawFrame; + int *thresholds = NULL; + int trows, tcolumns; + u16 *adj = NULL; + memset(&msRawFrame, 0x00, sizeof(msRawFrame)); + /******************************* Mutual Sense Test *******************************/ + logError(0, "%s \n", tag); + + if (todo->MutualRawLP == 1 || todo->MutualRawGapLP == 1 + || todo->MutualRawAdjLP == 1) { + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_ACTIVE); + mdelay(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + ret |= getMSFrame3(MS_RAW, &msRawFrame); + + if (ret < 0) { + logError(1, + "%s production_test_data: getMSFrame failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + + if (todo->MutualRawLP == 1) { + logError(1, "%s MS RAW LP MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_LP_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_LP_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + thresholds[0], thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS RAW LP failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW LP MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW LP MIN MAX TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s MS RAW LP MIN MAX TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->MutualRawGapLP == 1) { + logError(1, "%s MS RAW LP GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_LP_GAP, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_LP_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap MS RAW LP failed... ERROR = %08X \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW LP GAP TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s MS RAW LP GAP TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->MutualRawAdjLP == 1) { + logError(1, "%s MS RAW LP ADJ HORIZONTAL TEST: \n", + tag); + ret = + computeAdjHorizTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + &adj); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_LP_ADJH, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 + || (trows != msRawFrame.header.force_node + || tcolumns != + msRawFrame.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_LP_ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(adj, + msRawFrame.header.force_node, + msRawFrame.header. + sense_node - 1, thresholds); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW LP ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW LP ADJ HORIZONTAL TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW LP ADJ HORIZONTAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + logError(0, "%s MS RAW LP ADJ VERTICAL TEST: \n", tag); + ret = + computeAdjVertTotal(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, + &adj); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_RAW_LP_ADJV, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 + || (trows != msRawFrame.header.force_node - 1 + || tcolumns != msRawFrame.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(adj, + msRawFrame.header. + force_node - 1, + msRawFrame.header.sense_node, + thresholds); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJV failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS RAW LP ADJ VERTICAL TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW LP ADJ VERTICAL TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + kfree(adj); + adj = NULL; + } else + logError(0, + "%s MS RAW LP ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, + "%s MS RAW LP FRAME TEST:.................SKIPPED \n", + tag); + +ERROR: + logError(0, "%s \n", tag); + + if (count_fail == 0) { + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + + logError(0, + "%s MS RAW DATA TEST finished!.................OK\n", + tag); + return OK; + } else { + if (msRawFrame.node_data != NULL) { + print_frame_short("MS Raw LP frame =", + array1dTo2d_short + (msRawFrame.node_data, + msRawFrame.node_data_size, + msRawFrame.header.sense_node), + msRawFrame.header.force_node, + msRawFrame.header.sense_node); + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (adj != NULL) { + kfree(adj); + adj = NULL; + } + logError(0, + "%s MS RAW LP DATA TEST:.................FAIL fails_count = %d\n\n", + tag, count_fail); + return (ERROR_PROD_TEST_DATA | ERROR_TEST_CHECK_FAIL); + } + +ERROR_LIMITS: + + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + return ret; +} + +/** + * Perform MS raw test for keys data + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ms_key_raw(char *path_limits) +{ + int ret; + MutualSenseFrame msRawFrame; + int *thresholds = NULL; + int trows, tcolumns; + /******************************* Mutual Sense Test *******************************/ + logError(1, "%s MS KEY RAW DATA TEST is starting...\n", tag); + ret = setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + ret |= getMSFrame3(MS_KEY_RAW, &msRawFrame); + + if (ret < 0) { + logError(1, + "%s production_test_data: getMSKeyFrame failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_KEY_RAW_MIN_MAX, &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_RAW_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(msRawFrame.node_data, + msRawFrame.header.force_node, + msRawFrame.header.sense_node, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS KEY RAW failed... ERROR COUNT = %d \n", + tag, ret); + goto ERROR; + } else + logError(0, "%s MS KEY RAW TEST:.................OK \n\n", tag); + + kfree(thresholds); + thresholds = NULL; + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + return OK; +ERROR: + print_frame_short("MS Key Raw frame =", + array1dTo2d_short(msRawFrame.node_data, + msRawFrame.node_data_size, + msRawFrame.header.sense_node), + msRawFrame.header.force_node, + msRawFrame.header.sense_node); + + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + logError(0, "%s MS KEY RAW TEST:.................FAIL \n\n", tag); + return (ERROR_PROD_TEST_DATA | ERROR_TEST_CHECK_FAIL); +ERROR_LIMITS: + + if (msRawFrame.node_data != NULL) { + kfree(msRawFrame.node_data); + msRawFrame.node_data = NULL; + } + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + return ret; +} + +/** + * Perform all the tests selected in a TestTodo variable related to MS Init data (touch, keys etc..) + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ms_cx(char *path_limits, int stop_on_fail, TestToDo *todo) +{ + int ret; + int count_fail = 0; + int *thresholds = NULL; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + int trows, tcolumns; + MutualSenseData msCompData; + TotMutualSenseData totCompData; + u8 *adjhor = NULL; + u8 *adjvert = NULL; + u16 container; + u16 *total_adjhor = NULL; + u16 *total_adjvert = NULL; + logError(0, "%s \n", tag); + ret = readMutualSenseCompensationData(LOAD_CX_MS_TOUCH, &msCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: readMutualSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + ret = + readTotMutualSenseCompensationData(LOAD_PANEL_CX_TOT_MS_TOUCH, + &totCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: readTotMutualSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + kfree(msCompData.node_data); + msCompData.node_data = NULL; + return (ret | ERROR_PROD_TEST_DATA); + } + + + if (todo->MutualCx1 == 1) { + logError(1, "%s MS CX1 TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_CX1_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX1_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (u16) msCompData.cx1; + ret = + checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS CX1 failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, "%s MS CX1 TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, "%s MS CX1 TEST:.................OK \n\n", + tag); + } else + logError(0, "%s MS CX1 TEST:.................SKIPPED \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + + if (todo->MutualCx2 == 1) { + logError(1, "%s MS CX2 MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, MS_CX2_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node + || tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, MS_CX2_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node + || tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMap(msCompData.node_data, msCompData.header.force_node, msCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS CX2 MIN MAX failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS CX2 MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS CX2 MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s MS CX2 MIN MAX TEST:.................SKIPPED \n\n", + tag); + + + if (todo->MutualCx2Adj == 1) { + logError(1, "%s MS CX2 ADJ TEST: \n", tag); + ret = + computeAdjHoriz(msCompData.node_data, + msCompData.header.force_node, + msCompData.header.sense_node, &adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s MS CX2 ADJ HORIZ computed! \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_ADJH_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node + || tcolumns != msCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_ADJH_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdj(adjhor, msCompData.header.force_node, + msCompData.header.sense_node - 1, + thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj CX2 ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS CX2 ADJ HORIZ TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS CX2 ADJ HORIZ TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + logError(0, "%s MS CX2 ADJ VERT TEST: \n", tag); + ret = + computeAdjVert(msCompData.node_data, + msCompData.header.force_node, + msCompData.header.sense_node, &adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s MS CX2 ADJ VERT computed! \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node - 1 + || tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_ADJV_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdj(adjvert, msCompData.header.force_node - 1, + msCompData.header.sense_node - 1, + thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj CX2 ADJV failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS CX2 ADJ HORIZ TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS CX2 ADJ VERT TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, "%s MS CX2 ADJ TEST:.................SKIPPED \n\n", + tag); + + + if (todo->MutualCxTotal == 1 || todo->MutualCxTotalAdj == 1) { + + if (todo->MutualCxTotal == 1) { + logError(1, "%s MS TOTAL CX MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, MS_TOTAL_CX_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, MS_TOTAL_CX_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(totCompData.node_data, totCompData.header.force_node, totCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS TOTAL CX TEST failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS TOTAL CX MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s MS TOTAL CX MIN MAX TEST:.................SKIPPED \n\n", + tag); + + + if (todo->MutualCxTotalAdj == 1) { + logError(1, "%s MS TOTAL CX ADJ HORIZ TEST: \n", tag); + ret = + computeAdjHorizTotal(totCompData.node_data, + totCompData.header.force_node, + totCompData.header.sense_node, + &total_adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s MS TOTAL CX ADJ HORIZ computed! \n", + tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_TOTAL_CX_ADJH_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_ADJH_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(total_adjhor, + totCompData.header. + force_node, + totCompData.header. + sense_node - 1, + thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj MS TOTAL CX ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS TOTAL CX ADJ HORIZ TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX ADJ HORIZ TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjhor); + total_adjhor = NULL; + logError(0, "%s MS TOTAL CX ADJ VERT TEST: \n", tag); + ret = + computeAdjVertTotal(totCompData.node_data, + totCompData.header.force_node, + totCompData.header.sense_node, + &total_adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s MS TOTAL CX ADJ VERT computed! \n", + tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_TOTAL_CX_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node - 1 + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_ADJV_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(total_adjvert, + totCompData.header. + force_node - 1, + totCompData.header. + sense_node - 1, + thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj MS TOTAL CX ADJV failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS TOTAL CX ADJ HORIZ TEST:.................FAIL \n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX ADJ VERT TEST:.................OK \n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjvert); + total_adjvert = NULL; + } else + logError(0, + "%s MS TOTAL CX ADJ TEST:.................SKIPPED \n", + tag); + + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } else + logError(0, "%s MS TOTAL CX TEST:.................SKIPPED \n", + tag); + + if ((todo->MutualCx1LP | todo->MutualCx2LP | todo->MutualCx2AdjLP | + todo->MutualCxTotalLP | todo->MutualCxTotalAdjLP) == 1) { + ret = production_test_ms_cx_lp(path_limits, stop_on_fail, todo); + if (ret < OK) { + count_fail += 1; + logError(1, + "%s production_test_data: production_test_cx_lp failed... ERROR = %08X\n", + tag, ret); + logError(0, + "%s MS CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + return ret; + } + } else + logError(0, "%s MS KEY CX TEST:.................SKIPPED\n", + tag); + + if ((todo->MutualKeyCx1 | + todo->MutualKeyCx2 | todo->MutualKeyCxTotal) == 1) { + ret = + production_test_ms_key_cx(path_limits, stop_on_fail, todo); + + if (ret < 0) { + count_fail += 1; + logError(1, + "%s production_test_data: production_test_ms_key_cx failed... ERROR = %08X \n", + tag, ret); + logError(0, + "%s MS CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + return ret; + } + } else + logError(0, "%s MS KEY CX TEST:.................SKIPPED \n", + tag); + +ERROR: + logError(0, "%s \n", tag); + + if (count_fail == 0) { + logError(0, "%s MS CX testes finished!.................OK\n", + tag); + kfree(msCompData.node_data); + msCompData.node_data = NULL; + return OK; + } else { + print_frame_i8("MS Init Data (Cx2) =", + array1dTo2d_i8(msCompData.node_data, + msCompData.node_data_size, + msCompData.header.sense_node), + msCompData.header.force_node, + msCompData.header.sense_node); + print_frame_short(" TOT MS Init Data (Cx) =", + array1dTo2d_short(totCompData.node_data, + totCompData.node_data_size, + totCompData.header. + sense_node), + totCompData.header.force_node, + totCompData.header.sense_node); + logError(0, + "%s MS CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (adjhor != NULL) { + kfree(adjhor); + adjhor = NULL; + } + if (adjvert != NULL) { + kfree(adjvert); + adjvert = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + if (total_adjhor != NULL) { + kfree(total_adjhor); + total_adjhor = NULL; + } + if (total_adjvert != NULL) { + kfree(total_adjvert); + total_adjvert = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + return (ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA); + } + +ERROR_LIMITS: + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (adjhor != NULL) { + kfree(adjhor); + adjhor = NULL; + } + if (adjvert != NULL) { + kfree(adjvert); + adjvert = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + if (total_adjhor != NULL) { + kfree(total_adjhor); + total_adjhor = NULL; + } + if (total_adjvert != NULL) { + kfree(total_adjvert); + total_adjvert = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + return ret; +} + +/** + * Perform all the tests selected in a TestTodo variable related to MS Init data of the keys + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ms_key_cx(char *path_limits, int stop_on_fail, + TestToDo *todo) +{ + int ret; + int count_fail = 0; + int num_keys = 0; + int *thresholds = NULL; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + int trows, tcolumns; + MutualSenseData msCompData; + TotMutualSenseData totCompData; + short container; + ret = readMutualSenseCompensationData(LOAD_CX_MS_KEY, &msCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: readMutualSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + if (msCompData.header.force_node > msCompData.header.sense_node) + num_keys = msCompData.header.force_node; + else + num_keys = msCompData.header.sense_node; + + + if (todo->MutualKeyCx1 == 1) { + logError(1, "%s MS KEY CX1 TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + MS_KEY_CX1_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_CX1_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (short)msCompData.cx1; + ret = + checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS CX1 failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS KEY CX1 TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS KEY CX1 TEST:.................OK \n\n", + tag); + } else + logError(0, "%s MS KEY CX1 TEST:.................SKIPPED \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + + if (todo->MutualKeyCx2 == 1) { + logError(1, "%s MS KEY CX2 TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, MS_KEY_CX2_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node + || tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_CX2_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, MS_KEY_CX2_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != msCompData.header.force_node + || tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_CX2_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMap(msCompData.node_data, msCompData.header.force_node, msCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS KEY CX2 failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS KEY CX2 TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS KEY CX2 TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, "%s MS CX2 TEST:.................SKIPPED \n\n", + tag); + + + if (todo->MutualKeyCxTotal == 1) { + logError(1, "%s MS KEY TOTAL CX TEST: \n", tag); + ret = + readTotMutualSenseCompensationData(LOAD_PANEL_CX_TOT_MS_KEY, + &totCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeTotalCx failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, MS_KEY_TOTAL_CX_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_TOTAL_CX_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, MS_KEY_TOTAL_CX_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_KEY_TOTAL_CX_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(totCompData.node_data, totCompData.header.force_node, totCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS TOTAL KEY CX TEST failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s MS KEY TOTAL CX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS KEY TOTAL CX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } else + logError(0, + "%s MS KEY TOTAL CX TEST:.................SKIPPED \n", + tag); + +ERROR: + logError(0, "%s \n", tag); + + if (count_fail == 0) { + logError(0, + "%s MS KEY CX testes finished!.................OK\n", + tag); + kfree(msCompData.node_data); + msCompData.node_data = NULL; + return OK; + } else { + print_frame_i8("MS Key Init Data (Cx2) =", + array1dTo2d_i8(msCompData.node_data, + msCompData.node_data_size, + msCompData.header.sense_node), + msCompData.header.force_node, + msCompData.header.sense_node); + logError(0, + "%s MS Key CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + return (ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA); + } + +ERROR_LIMITS: + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + return ret; +} + +/** + * Perform all the tests selected in a TestTodo variable related to MS LowPower + * Init data (touch, keys etc..) + * @param path_limits name of Production Limit file to load or + * "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check + * failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error + */ +int production_test_ms_cx_lp(char *path_limits, int stop_on_fail, TestToDo *todo) +{ + int ret; + int count_fail = 0; + + int *thresholds = NULL; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + int trows, tcolumns; + + MutualSenseData msCompData; + TotMutualSenseData totCompData; + + u8 *adjhor = NULL; + + u8 *adjvert = NULL; + + u16 container; + /* u16 *total_cx = NULL; */ + u16 *total_adjhor = NULL; + u16 *total_adjvert = NULL; + + + /* MS CX TEST */ + logError(0, "%s\n", tag); + + ret = readMutualSenseCompensationData(LOAD_CX_MS_LOW_POWER, &msCompData); + /* read MS compensation data */ + if (ret < 0) { + logError(1, + "%s production_test_data: readMutualSenseCompensationData failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + return ret | ERROR_PROD_TEST_DATA; + } + + ret = readTotMutualSenseCompensationData(LOAD_PANEL_CX_TOT_MS_LOW_POWER, + &totCompData); + /* read TOT MS compensation data */ + if (ret < 0) { + logError(1, + "%s production_test_data: readTotMutualSenseCompensationData failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + kfree(msCompData.node_data); + msCompData.node_data = NULL; + return ret | ERROR_PROD_TEST_DATA; + } + + if (todo->MutualCx1LP == 1) { + logError(1, "%s MS LP CX1 TEST:\n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX1_LP_MIN_MAX, &thresholds, + &trows, &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX1_LP_MIN_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (u16)msCompData.cx1; + ret = checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax MS LP CX1 failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, "%s MS LP CX1 TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, "%s MS LP CX1 TEST:.................OK\n\n", + tag); + } else + logError(0, "%s MS LP CX1 TEST:.................SKIPPED\n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + + if (todo->MutualCx2LP == 1) { + logError(1, "%s MS LP CX2 MIN MAX TEST:\n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_LP_MAP_MIN, &thresholds_min, + &trows, &tcolumns); + /* load min thresholds */ + if (ret < 0 || (trows != msCompData.header.force_node || + tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_LP_MAP_MIN failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_LP_MAP_MAX, &thresholds_max, + &trows, &tcolumns); + /* load max thresholds */ + if (ret < 0 || (trows != msCompData.header.force_node || + tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMap(msCompData.node_data, + msCompData.header.force_node, + msCompData.header.sense_node, + thresholds_min, thresholds_max); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS LP CX2 MIN MAX failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS LP CX2 MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS LP CX2 MIN MAX TEST:.................OK\n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s MS LP CX2 MIN MAX TEST:.................SKIPPED\n\n", + tag); + + if (todo->MutualCx2AdjLP == 1) { + logError(1, "%s MS LP CX2 ADJ TEST:\n", tag); + /* MS CX2 ADJ HORIZ */ + logError(0, "%s MS LP CX2 ADJ HORIZ TEST:\n", tag); + + ret = computeAdjHoriz(msCompData.node_data, + msCompData.header.force_node, + msCompData.header.sense_node, + &adjhor); + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s MS LP CX2 ADJ HORIZ computed!\n", tag); + + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_ADJH_LP_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + if (ret < 0 || (trows != msCompData.header.force_node || + tcolumns != msCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_ADJH_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjhor, msCompData.header.force_node, + msCompData.header.sense_node - 1, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj CX2 ADJH LP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS LP CX2 ADJ HORIZ TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS LP CX2 ADJ HORIZ TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + + /* MS CX2 ADJ VERT */ + logError(0, "%s MS LP CX2 ADJ VERT TEST:\n", tag); + + ret = computeAdjVert(msCompData.node_data, + msCompData.header.force_node, + msCompData.header.sense_node, + &adjvert); + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s MS LP CX2 ADJ VERT computed!\n", tag); + + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_ADJV_LP_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + if (ret < 0 || (trows != msCompData.header.force_node - 1 || + tcolumns != msCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_CX2_ADJV_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjvert, msCompData.header.force_node - + 1, msCompData.header.sense_node - 1, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj CX2 ADJV LP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS LP CX2 ADJ HORIZ TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS LP CX2 ADJ VERT TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, "%s MS LP CX2 ADJ TEST:.................SKIPPED\n\n", + tag); + + /* START OF TOTAL CHECK */ + + if (todo->MutualCxTotalLP == 1 || todo->MutualCxTotalAdjLP == 1) { + if (todo->MutualCxTotalLP == 1) { + logError(1, "%s MS TOTAL LP CX MIN MAX TEST:\n", tag); + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_TOTAL_CX_LP_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load min thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_LP_MAP_MIN failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_TOTAL_CX_LP_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load max thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(totCompData.node_data, + totCompData.header.force_node, + totCompData.header.sense_node, + thresholds_min, + thresholds_max); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap MS TOTAL CX LP TEST failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS TOTAL CX LP MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX LP MIN MAX TEST:.................OK\n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s MS TOTAL CX LP MIN MAX TEST:.................SKIPPED\n\n", + tag); + + + if (todo->MutualCxTotalAdjLP == 1) { + /* MS TOTAL CX ADJ HORIZ */ + logError(1, "%s MS TOTAL CX ADJ HORIZ LP TEST:\n", tag); + + ret = computeAdjHorizTotal(totCompData.node_data, + totCompData.header.force_node, + totCompData.header.sense_node, + &total_adjhor); + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s MS TOTAL CX ADJ HORIZ LP computed!\n", + tag); + + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_TOTAL_CX_ADJH_LP_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_ADJH_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdjTotal(total_adjhor, + totCompData.header. + force_node, + totCompData.header. + sense_node - 1, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj MS TOTAL CX ADJH LP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS TOTAL CX ADJ HORIZ LP TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX ADJ HORIZ LP TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjhor); + total_adjhor = NULL; + + /* MS TOTAL CX ADJ VERT */ + logError(0, "%s MS TOTAL CX ADJ VERT LP TEST:\n", tag); + + ret = computeAdjVertTotal(totCompData.node_data, + totCompData.header.force_node, + totCompData.header.sense_node, + &total_adjvert); + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s MS TOTAL CX ADJ VERT LP computed!\n", tag); + + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_TOTAL_CX_ADJV_LP_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + if (ret < 0 || (trows != totCompData.header.force_node - + 1 || tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_TOTAL_CX_ADJV_LP_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdjTotal(total_adjvert, + totCompData.header. + force_node - 1, + totCompData.header. + sense_node - 1, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj MS TOTAL CX ADJV failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS TOTAL CX ADJ HORIZ LP TEST:.................FAIL\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s MS TOTAL CX ADJ VERT LP TEST:.................OK\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjvert); + total_adjvert = NULL; + } else + logError(0, + "%s MS TOTAL CX ADJ LP TEST:.................SKIPPED\n", + tag); + + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } else + logError(0, "%s MS TOTAL CX LP TEST:.................SKIPPED\n", + tag); + + + +ERROR: + logError(0, "%s\n", tag); + if (count_fail == 0) { + logError(0, "%s MS LP CX testes finished!.................OK\n", + tag); + kfree(msCompData.node_data); + msCompData.node_data = NULL; + return OK; + } else { + print_frame_i8("MS LP Init Data (Cx2) =", array1dTo2d_i8( + msCompData.node_data, + msCompData.node_data_size, + msCompData.header.sense_node), + msCompData.header.force_node, + msCompData.header.sense_node); + print_frame_short(" TOT MS LP Init Data (Cx) =", array1dTo2d_short( + totCompData.node_data, + totCompData.node_data_size, + totCompData.header.sense_node), + totCompData.header.force_node, + totCompData.header.sense_node); + logError(0, + "%s MS LP CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (adjhor != NULL) { + kfree(adjhor); + adjhor = NULL; + } + if (adjvert != NULL) { + kfree(adjvert); + adjvert = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + if (total_adjhor != NULL) { + kfree(total_adjhor); + total_adjhor = NULL; + } + if (total_adjvert != NULL) { + kfree(total_adjvert); + total_adjvert = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + return ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA; + } + +ERROR_LIMITS: + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = NULL; + } + if (adjhor != NULL) { + kfree(adjhor); + adjhor = NULL; + } + if (adjvert != NULL) { + kfree(adjvert); + adjvert = NULL; + } + if (totCompData.node_data != NULL) { + kfree(totCompData.node_data); + totCompData.node_data = NULL; + } + if (total_adjhor != NULL) { + kfree(total_adjhor); + total_adjhor = NULL; + } + if (total_adjvert != NULL) { + kfree(total_adjvert); + total_adjvert = NULL; + } + if (msCompData.node_data != NULL) { + kfree(msCompData.node_data); + msCompData.node_data = NULL; + } + return ret; +} + +int production_test_ss_hover_raw(char *path_limits, int stop_on_fail, + TestToDo *todo){ + int ret; + int rows, columns; + int *thresholds = NULL; + int trows, tcolumns; + u8 hover_cnt[4] = {0xa8, 0x0b, 0x01, 0x00}; + + SelfSenseFrame ssHoverRawFrame; + int count_fail = 0; + + ret = fts_write_dma_safe(hover_cnt, sizeof(hover_cnt)); + if (ret != OK) { + logError(1, + "%s hover clear count ERROR = %d\n", tag, ret); + goto ERROR_LIMITS; + } + + logError(0, "%s Getting SS Hover Frame...\n", tag); + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_HOVER); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(WAIT_AFTER_SENSEOFF); + ret |= getSSFrame3(SS_HVR_RAW, &ssHoverRawFrame); + /* SS Hover RAW FORCE TEST */ + logError(0, "%s SS Hover RAW FORCE TEST:\n", tag); + + logError(0, "%s SS RAW FORCE MIN MAX TEST:\n", tag); + if (todo->SelfHoverForceRaw == 1) { + columns = 1; + rows = ssHoverRawFrame.header.force_node; + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_HOVER_RAW_FORCE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_HOVER_RAW_FORCE_MIN_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMinMax(ssHoverRawFrame.force_data, rows,columns, thresholds[0], thresholds[1]); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS HOVER RAW FORCE failed... ERROR COUNT = %d\n",tag, ret); + logError(0, + "%s SS Hover RAW FORCE MIN MAX TEST:.................FAIL\n\n", tag); + count_fail += 1; + print_frame_short("SS Raw force frame =", + array1dTo2d_short( + ssHoverRawFrame.force_data, + rows * + columns, + columns), rows, + columns); + if (stop_on_fail) { + ret = ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW FORCE MIN MAX TEST:.................OK\n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW FORCE MIN MAX TEST:.................SKIPPED\n\n", + tag); + logError(0, "%s\n", tag); + /* SS Hover RAW SENSE TEST */ + logError(0, "%s SS Hover RAW SENSE TEST:\n", tag); + + logError(0, "%s SS RAW SENSE MIN MAX TEST:\n", tag); + if (todo->SelfHoverSenceRaw == 1) { + columns = ssHoverRawFrame.header.sense_node; + rows = 1; + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_HOVER_RAW_SENSE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_MIN_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMinMax(ssHoverRawFrame.sense_data, rows, columns, thresholds[0], thresholds[1]); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS Hover RAW SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS Hover RAW SENSE MIN MAX TEST:.................FAIL\n", + tag); + count_fail += 1; + print_frame_short("SS Hover Raw sense frame =", + array1dTo2d_short( + ssHoverRawFrame.sense_data, + rows * + columns, + columns), rows, + columns); + if (stop_on_fail) { + ret = ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS Hover RAW SENSE MIN MAX TEST:.................OK\n",tag); + + kfree(thresholds); + thresholds = NULL; + } + +ERROR_LIMITS: + if (ssHoverRawFrame.force_data != NULL) + kfree(ssHoverRawFrame.force_data); + if (ssHoverRawFrame.sense_data != NULL) + kfree(ssHoverRawFrame.sense_data); + if (thresholds != NULL) + kfree(thresholds); + + return ret; +} + +/** + * Perform all the test selected in a TestTodo variable related to SS raw data (touch, keys etc..) + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ss_raw(char *path_limits, int stop_on_fail, TestToDo *todo) +{ + int ret; + int count_fail = 0; + int rows, columns; + SelfSenseFrame ssRawFrame; + int *thresholds = NULL; + int trows, tcolumns; + logError(0, "%s \n", tag); + /******************************* Self Sense Test *******************************/ + logError(0, "%s Getting SS Frame... \n", tag); + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + mdelay(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + ret |= getSSFrame3(SS_RAW, &ssRawFrame); + + if (ret < 0) { + logError(1, + "%s production_test_data: getSSFrame failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + + if (todo->SelfForceRaw == 1 || todo->SelfForceRawGap == 1) { + columns = 1; + rows = ssRawFrame.header.force_node; + logError(0, "%s SS RAW FORCE MIN MAX TEST: \n", tag); + + if (todo->SelfForceRaw == 1) { + logError(1, "%s SS RAW FORCE MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_FORCE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(ssRawFrame.force_data, rows, + columns, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS RAW (PROXIMITY) FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + print_frame_short("SS Raw force frame =", + array1dTo2d_short + (ssRawFrame.force_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW (PROXIMITY) FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW (PROXIMITY) FORCE MIN MAX TEST:.................SKIPPED \n\n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfForceRawGap == 1) { + logError(1, "%s SS RAW FORCE GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_FORCE_GAP, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(ssRawFrame.force_data, rows, columns, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap SS RAW FORCE GAP failed... ERROR = %08X \n", + tag, ret); + logError(0, + "%s SS RAW FORCE GAP TEST:.................FAIL \n\n", + tag); + count_fail += 1; + print_frame_short("SS Raw force frame =", + array1dTo2d_short + (ssRawFrame.force_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW (PROXIMITY) FORCE GAP TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW (PROXIMITY) FORCE GAP TEST:.................SKIPPED \n\n", + tag); + + kfree(ssRawFrame.force_data); + ssRawFrame.force_data = NULL; + } else + logError(0, + "%s SS RAW (PROXIMITY) FORCE TEST:.................SKIPPED \n\n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfSenseRaw == 1 || todo->SelfSenseRawGap == 1) { + columns = ssRawFrame.header.sense_node; + rows = 1; + + if (todo->SelfSenseRaw == 1) { + logError(1, "%s SS RAW SENSE MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_SENSE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(ssRawFrame.sense_data, rows, + columns, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS RAW SENSE MIN MAX TEST:.................FAIL \n", + tag); + count_fail += 1; + print_frame_short("SS Raw sense frame =", + array1dTo2d_short + (ssRawFrame.sense_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW (PROXIMITY) SENSE MIN MAX TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW (PROXIMITY) SENSE MIN MAX TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfSenseRawGap == 1) { + logError(1, "%s SS RAW SENSE GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_SENSE_GAP, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(ssRawFrame.sense_data, rows, columns, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap SS RAW SENSE GAP failed... ERROR = %08X \n", + tag, ret); + logError(0, + "%s SS RAW SENSE GAP TEST:.................FAIL \n", + tag); + count_fail += 1; + print_frame_short("SS Raw sense frame =", + array1dTo2d_short + (ssRawFrame.sense_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW (PROXIMITY) SENSE GAP TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW (PROXIMITY) SENSE GAP TEST:.................SKIPPED \n", + tag); + + kfree(ssRawFrame.sense_data); + ssRawFrame.sense_data = NULL; + } + + ret = production_test_ss_raw_lp(path_limits, stop_on_fail, todo); + + if (ret < OK) { + logError(1, + "%s production_test_data: production_test_ss_raw_lp failed... ERROR = %08X \n", + tag, ret); + count_fail += 1; + } + if (todo->SelfHoverForceRaw == 1 || todo->SelfHoverSenceRaw) { + ret = production_test_ss_hover_raw(path_limits, stop_on_fail, todo); + if (ret < OK) { + logError(1, + "%s production_test_data: production_test_ss_hover_raw failed... ERROR = %08X\n", + tag, ret); + count_fail += 1; + } + } + + logError(0, "%s \n", tag); + + if (count_fail == 0) { + logError(0, "%s SS RAW testes finished!.................OK\n\n", + tag); + return OK; + } else { + logError(0, + "%s SS RAW testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + return (ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA); + } + +ERROR_LIMITS: + + if (ssRawFrame.force_data != NULL) + kfree(ssRawFrame.force_data); + + if (ssRawFrame.sense_data != NULL) + kfree(ssRawFrame.sense_data); + + if (thresholds != NULL) + kfree(thresholds); + + return ret; +} + +/** + * Perform all the test selected in a TestTodo variable related to SS raw data low power + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ss_raw_lp(char *path_limits, int stop_on_fail, + TestToDo *todo) +{ + int ret; + int count_fail = 0; + int rows, columns; + SelfSenseFrame ssRawFrame; + int *thresholds = NULL; + int trows, tcolumns; + logError(0, "%s \n", tag); + /******************************* Self Sense Test *******************************/ + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_DETECT); + mdelay(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + ret |= getSSFrame3(SS_RAW, &ssRawFrame); + + if (ret < 0) { + logError(1, + "%s production_test_data: getSSFrame failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + + if (todo->SelfForceRawLP == 1 || todo->SelfForceRawGapLP == 1) { + columns = 1; + rows = ssRawFrame.header.force_node; + + if (todo->SelfForceRawLP == 1) { + logError(1, "%s SS RAW LP FORCE MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_LP_FORCE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(ssRawFrame.force_data, rows, + columns, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS RAW LP FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + print_frame_short("SS Raw LP force frame =", + array1dTo2d_short + (ssRawFrame.force_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW LP FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW LP FORCE MIN MAX TEST:.................SKIPPED \n\n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfForceRawGapLP == 1) { + logError(1, "%s SS RAW LP FORCE GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_LP_FORCE_GAP, + &thresholds, &trows, + &tcolumns); + + if (ret < OK || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(ssRawFrame.force_data, rows, columns, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap SS RAW FORCE GAP failed... ERROR = %08X \n", + tag, ret); + logError(0, + "%s SS RAW LP FORCE GAP TEST:.................FAIL \n\n", + tag); + count_fail += 1; + print_frame_short("SS Raw LP force frame =", + array1dTo2d_short + (ssRawFrame.force_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW LP FORCE GAP TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW LP FORCE GAP TEST:.................SKIPPED \n\n", + tag); + + kfree(ssRawFrame.force_data); + ssRawFrame.force_data = NULL; + } else + logError(0, + "%s SS RAW LP FORCE TEST:.................SKIPPED \n\n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfSenseRawLP == 1 || todo->SelfSenseRawGapLP == 1) { + columns = ssRawFrame.header.sense_node; + rows = 1; + logError(0, "%s SS RAW LP SENSE MIN MAX TEST: \n", tag); + + if (todo->SelfSenseRawLP == 1) { + logError(1, "%s SS RAW LP SENSE MIN MAX TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_LP_SENSE_MIN_MAX, + &thresholds, &trows, + &tcolumns); + + if (ret < OK || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMinMax(ssRawFrame.sense_data, rows, + columns, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS RAW LP SENSE MIN MAX TEST:.................FAIL \n", + tag); + count_fail += 1; + print_frame_short("SS Raw LP sense frame =", + array1dTo2d_short + (ssRawFrame.sense_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW SENSE MIN MAX TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW LP SENSE MIN MAX TEST:.................SKIPPED \n", + tag); + + logError(0, "%s \n", tag); + + if (todo->SelfSenseRawGapLP == 1) { + logError(1, "%s SS RAW LP SENSE GAP TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_RAW_LP_SENSE_GAP, + &thresholds, &trows, + &tcolumns); + + if (ret < OK || (trows != 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_GAP failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsGap(ssRawFrame.sense_data, rows, columns, + thresholds[0]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsGap SS RAW SENSE GAP failed... ERROR = %08X \n", + tag, ret); + logError(0, + "%s SS RAW LP SENSE GAP TEST:.................FAIL \n", + tag); + count_fail += 1; + print_frame_short("SS Raw LP sense frame =", + array1dTo2d_short + (ssRawFrame.sense_data, + rows * columns, columns), + rows, columns); + + if (stop_on_fail) { + ret = + ERROR_PROD_TEST_DATA | + ERROR_TEST_CHECK_FAIL; + goto ERROR_LIMITS; + } + } else + logError(0, + "%s SS RAW LP SENSE GAP TEST:.................OK \n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW LP SENSE GAP TEST:.................SKIPPED \n", + tag); + + kfree(ssRawFrame.sense_data); + ssRawFrame.sense_data = NULL; + } + + logError(0, "%s \n", tag); + + if (count_fail == 0) { + logError(0, + "%s SS RAW LP testes finished!.................OK\n\n", + tag); + return OK; + } else { + logError(0, + "%s SS RAW LP testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + return (ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA); + } + +ERROR_LIMITS: + + if (ssRawFrame.force_data != NULL) + kfree(ssRawFrame.force_data); + + if (ssRawFrame.sense_data != NULL) + kfree(ssRawFrame.sense_data); + + if (thresholds != NULL) + kfree(thresholds); + + return ret; +} + +int production_test_ss_hover_ix(char *path_limits, int stop_on_fail, TestToDo *todo){ + TotSelfSenseData ssHoverCompData; + int ret; + int trows, tcolumns; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + int count_fail = 0; + + /* ret = readSelfSenseCompensationData(LOAD_CX_SS_HOVER, &ssHoverCompData); */ + ret = readTotSelfSenseCompensationData(STAPI_HOST_DATA_ID_PANEL_CX_SS_HVR, &ssHoverCompData); + /* read the SS compensation data */ + if (ret < 0) { + logError(1, + "%s production_test_data: readSelfSenseCompensationData failed... ERROR %08X\n",tag, ERROR_PROD_TEST_DATA); + return ret | ERROR_PROD_TEST_DATA; + } + + logError(0, "%s SS Hover TOTAL IX FORCE TEST:\n", tag); + logError(0, "%s SS Hover TOTAL IX FORCE MIN MAX TEST:\n", tag); + if (todo->SelfHoverForceIxTotal == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, SS_HOVER_TOTAL_IX_FORCE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != ssHoverCompData.header.force_node || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_FORCE_MAP_MIN failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file,SS_TOTAL_IX_FORCE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != + ssHoverCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_FORCE_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotalFromU(ssHoverCompData.ix_fm,ssHoverCompData.header. + force_node, 1, + thresholds_min, + thresholds_max); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL IX FORCE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX FORCE MIN MAX TEST:.................OK\n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS Hover TOTAL IX FORCE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS HOVER TOTAL IX SENSE MIN MAX TEST:\n", tag); + if (todo->SelfHoverSenceIxTotal == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_SENSE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssHoverCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_SENSE_MAP_MIN failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_SENSE_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssHoverCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_SENSE_MAP_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotalFromU(ssHoverCompData.ix_sn, 1, + ssHoverCompData.header. + sense_node, + thresholds_min, + thresholds_max); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS Hover TOTAL IX SENSE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX SENSE MIN MAX TEST:.................OK\n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS Hover TOTAL IX SENSE MIN MAX TEST:.................SKIPPED\n", + tag); +ERROR: + logError(0, "%s\n", tag); + if (count_fail == 0) { + kfree(ssHoverCompData.ix_fm); + ssHoverCompData.ix_fm = NULL; + kfree(ssHoverCompData.ix_sn); + ssHoverCompData.ix_sn = NULL; + kfree(ssHoverCompData.cx_fm); + ssHoverCompData.cx_fm = NULL; + kfree(ssHoverCompData.cx_sn); + ssHoverCompData.cx_sn = NULL; + logError(0, + "%s SS Hover IX testes finished!.................OK\n\n", + tag); + return OK; + } else { + print_frame_u16("TOT SS hover Init Data Ix_fm = ", array1dTo2d_u16( + ssHoverCompData.ix_fm, + ssHoverCompData.header.force_node, 1), + ssHoverCompData.header.force_node, 1); + print_frame_short("TOT SS hover hover Init Data Cx_fm = ", + array1dTo2d_short(ssHoverCompData.cx_fm, + ssHoverCompData.header. + force_node, 1), + ssHoverCompData.header.force_node, 1); + print_frame_u16("TOT SS hover Init Data Ix_sn = ", array1dTo2d_u16( + ssHoverCompData.ix_sn, + ssHoverCompData.header.sense_node, + ssHoverCompData.header.sense_node), 1, + ssHoverCompData.header.sense_node); + print_frame_short("TOT SS hover Init Data Cx_sn = ", + array1dTo2d_short(ssHoverCompData.cx_sn, + ssHoverCompData.header. + sense_node, + ssHoverCompData.header. + sense_node), + 1, ssHoverCompData.header.sense_node); + logError(0, + "%s SS hover IX CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + if (thresholds_min != NULL) + kfree(thresholds_min); + if (thresholds_max != NULL) + kfree(thresholds_max); + if (ssHoverCompData.ix_fm != NULL) + kfree(ssHoverCompData.ix_fm); + if (ssHoverCompData.ix_sn != NULL) + kfree(ssHoverCompData.ix_sn); + if (ssHoverCompData.cx_fm != NULL) + kfree(ssHoverCompData.cx_fm); + if (ssHoverCompData.cx_sn != NULL) + kfree(ssHoverCompData.cx_sn); + return ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA; + } +ERROR_LIMITS: + if (thresholds_min != NULL) + kfree(thresholds_min); + if (thresholds_max != NULL) + kfree(thresholds_max); + if (ssHoverCompData.ix_fm != NULL) + kfree(ssHoverCompData.ix_fm); + if (ssHoverCompData.ix_sn != NULL) + kfree(ssHoverCompData.ix_sn); + if (ssHoverCompData.cx_fm != NULL) + kfree(ssHoverCompData.cx_fm); + if (ssHoverCompData.cx_sn != NULL) + kfree(ssHoverCompData.cx_sn); + return ret; +} + +/** + * Perform all the tests selected in a TestTodo variable related to SS Init data (touch, keys etc..) + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_ss_ix_cx(char *path_limits, int stop_on_fail, + TestToDo *todo) +{ + int ret; + int count_fail = 0; + int *thresholds = NULL; + int trows, tcolumns; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + SelfSenseData ssCompData; + TotSelfSenseData totCompData; + u8 *adjhor = NULL; + u8 *adjvert = NULL; + short container; + u16 *total_adjhor = NULL; + u16 *total_adjvert = NULL; + logError(0, "%s \n", tag); + ret = readSelfSenseCompensationData(LOAD_CX_SS_TOUCH, &ssCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: readSelfSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + return (ret | ERROR_PROD_TEST_DATA); + } + + ret = + readTotSelfSenseCompensationData(LOAD_PANEL_CX_TOT_SS_TOUCH, + &totCompData); + + if (ret < 0) { + logError(1, + "%s production_test_data: readTotSelfSenseCompensationData failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + kfree(ssCompData.ix2_fm); + kfree(ssCompData.ix2_sn); + kfree(ssCompData.cx2_fm); + kfree(ssCompData.cx2_sn); + return (ret | ERROR_PROD_TEST_DATA); + } + + /********************************************************* SS FORCE IX ****************************************************************/ + + if (todo->SelfForceIx1 == 1) { + logError(1, "%s SS IX1 FORCE TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_IX1_FORCE_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX1_FORCE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (short)ssCompData.f_ix1; + ret = + checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS IX1 FORCE TEST failed... ERROR COUNT = %d \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX1 FORCE TEST:.................OK \n\n", + tag); + } else + logError(0, + "%s SS IX1 FORCE TEST:.................SKIPPED \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + + if (todo->SelfForceIx2 == 1) { + logError(1, "%s SS IX2 FORCE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_FORCE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_FORCE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_FORCE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_FORCE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapFromU(ssCompData.ix2_fm, ssCompData.header.force_node, 1, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS IX2 FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS IX2 FORCE MIN MAX TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfForceIx2Adj == 1) { + logError(1, "%s SS IX2 FORCE ADJ TEST: \n", tag); + ret = + computeAdjVertFromU(ssCompData.ix2_fm, + ssCompData.header.force_node, 1, + &adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS IX2 FORCE ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS IX2 FORCE ADJV computed! \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_FORCE_ADJV_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node - 1 + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_FORCE_ADJV_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjvert, ssCompData.header.force_node - 1, 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS IX2 FORCE ADJV TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 FORCE ADJV TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, + "%s SS IX2 FORCE ADJ TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfForceIxTotal == 1 || todo->SelfForceIxTotalAdj == 1) { + + if (todo->SelfForceIxTotal == 1) { + logError(1, "%s SS TOTAL IX FORCE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_FORCE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_FORCE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_FORCE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_FORCE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotalFromU(totCompData.ix_fm, totCompData.header.force_node, 1, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL IX FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS TOTAL IX FORCE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfForceIxTotalAdj == 1) { + logError(1, "%s SS TOTAL IX FORCE ADJVERT TEST: \n", + tag); + ret = + computeAdjVertTotalFromU(totCompData.ix_fm, + totCompData.header. + force_node, 1, + &total_adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS TOTAL IX FORCE ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS TOTAL IX FORCE ADJV computed! \n", + tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_FORCE_ADJV_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node - 1 + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_FORCE_ADJV_MAP_MAX... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdjTotal(total_adjvert, totCompData.header.force_node - 1, 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL IX FORCE ADJV TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX FORCE ADJV TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjvert); + total_adjvert = NULL; + } else + logError(0, + "%s SS TOTAL IX FORCE ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, + "%s SS TOTAL IX FORCE TEST:.................SKIPPED \n\n", + tag); + + /********************************************************* SS SENSE IX ****************************************************************/ + + if (todo->SelfSenseIx1 == 1) { + logError(1, "%s SS IX1 SENSE TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_IX1_SENSE_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX1_SENSE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (short)ssCompData.s_ix1; + ret = checkLimitsMinMax(&container, 1, 1, thresholds[0], thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS IX1 SENSE TEST failed... ERROR COUNT = %d \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX1 SENSE TEST:.................OK \n\n", + tag); + } else + logError(0, + "%s SS IX1 SENSE TEST:.................SKIPPED \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + + if (todo->SelfSenseIx2 == 1) { + logError(1, "%s SS IX2 SENSE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_SENSE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_SENSE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_SENSE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_SENSE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapFromU(ssCompData.ix2_sn, 1, ssCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS IX2 SENSE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 SENSE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS IX2 SENSE MIN MAX TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfSenseIx2Adj == 1) { + logError(1, "%s SS IX2 SENSE ADJHORIZ TEST: \n", tag); + ret = + computeAdjHorizFromU(ssCompData.ix2_sn, 1, + ssCompData.header.sense_node, &adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz SS IX2 SENSE ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS IX2 SENSE ADJ HORIZ computed! \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_IX2_SENSE_ADJH_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_SENSE_ADJH_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjhor, 1, ssCompData.header.sense_node - 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS IX2 SENSE ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS IX2 SENSE ADJH TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 SENSE ADJH TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + } else + logError(0, + "%s SS IX2 SENSE ADJ TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfSenseIxTotal == 1 || todo->SelfSenseIxTotalAdj == 1) { + + if (todo->SelfSenseIxTotal == 1) { + logError(1, "%s SS TOTAL IX SENSE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_SENSE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_SENSE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_SENSE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_SENSE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotalFromU(totCompData.ix_sn, 1, totCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL IX SENSE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX SENSE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS TOTAL IX SENSE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfSenseIxTotalAdj == 1) { + logError(1, "%s SS TOTAL IX SENSE ADJHORIZ TEST: \n", + tag); + ret = + computeAdjHorizTotalFromU(totCompData.ix_sn, 1, + totCompData.header. + sense_node, + &total_adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz SS TOTAL IX SENSE ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, + "%s SS TOTAL IX SENSE ADJ HORIZ computed! \n", + tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_IX_SENSE_ADJH_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_SENSE_ADJH_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdjTotal(total_adjhor, 1, totCompData.header.sense_node - 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS TOTAL IX SENSE ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL IX SENSE ADJH TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX SENSE ADJH TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjhor); + total_adjhor = NULL; + } else + logError(0, + "%s SS TOTAL IX SENSE ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, + "%s SS TOTAL IX SENSE TEST:.................SKIPPED \n", + tag); + + /********************************************************* SS SENSE CX ****************************************************************/ + + if (todo->SelfForceCx1 == 1) { + logError(1, "%s SS CX1 FORCE TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_CX1_FORCE_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX1_FORCE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (short)ssCompData.f_cx1; + ret = + checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS CX1 FORCE TEST failed... ERROR COUNT = %d \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX1 FORCE TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS CX1 FORCE TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfForceCx2 == 1) { + logError(1, "%s SS CX2 FORCE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_FORCE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_FORCE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_FORCE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_FORCE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMap(ssCompData.cx2_fm, ssCompData.header.force_node, 1, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS CX2 FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS CX2 FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS CX2 FORCE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfForceCx2Adj == 1) { + logError(1, "%s SS CX2 FORCE ADJVERT TEST: \n", tag); + ret = computeAdjVert(ssCompData.cx2_fm, ssCompData.header.force_node, 1, &adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS CX2 FORCE ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS CX2 FORCE ADJV computed! \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_FORCE_ADJV_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != ssCompData.header.force_node - 1 + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_FORCE_ADJV_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjvert, ssCompData.header.force_node - 1, 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS CX2 FORCE ADJV TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 FORCE ADJV TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, + "%s SS CX2 FORCE ADJ TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfForceCxTotal == 1 || todo->SelfForceCxTotalAdj == 1) { + + if (todo->SelfForceCxTotal == 1) { + logError(1, "%s SS TOTAL CX FORCE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_CX_FORCE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_FORCE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_CX_FORCE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_FORCE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(totCompData.cx_fm, totCompData.header.force_node, 1, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL FORCE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL FORCE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS TOTAL CX FORCE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfForceCxTotalAdj == 1) { + logError(1, "%s SS TOTAL CX FORCE ADJVERT TEST: \n", + tag); + ret = computeAdjVertTotal(totCompData.cx_fm, totCompData.header.force_node, 1, &total_adjvert); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS TOTAL CX FORCE ADJV failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS TOTAL CX FORCE ADJV computed! \n", + tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_TOTAL_CX_FORCE_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + + if (ret < 0 + || (trows != totCompData.header.force_node - 1 + || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_FORCE_ADJV_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = + checkLimitsMapAdjTotal(total_adjvert, + totCompData. + header.force_node - 1, 1, + thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL CX FORCE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL CX FORCE ADJV TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX FORCE ADJV TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjvert); + total_adjvert = NULL; + } else + logError(0, + "%s SS TOTAL CX FORCE ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, + "%s SS TOTAL CX FORCE TEST:.................SKIPPED \n\n", + tag); + + /********************************************************* SS SENSE CX ****************************************************************/ + + if (todo->SelfSenseCx1 == 1) { + logError(1, "%s SS CX1 SENSE TEST: \n", tag); + ret = + parseProductionTestLimits(path_limits, &limit_file, + SS_CX1_SENSE_MIN_MAX, &thresholds, + &trows, &tcolumns); + + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX1_SENSE_MIN_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + container = (short)ssCompData.s_cx1; + ret = + checkLimitsMinMax(&container, 1, 1, thresholds[0], + thresholds[1]); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS CX1 SENSE TEST failed... ERROR COUNT = %d \n", + tag, ret); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX1 SENSE TEST:.................OK \n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS CX1 SENSE TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfSenseCx2 == 1) { + logError(1, "%s SS CX2 SENSE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_SENSE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_SENSE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_SENSE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_SENSE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMap(ssCompData.cx2_sn, 1, ssCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS CX2 SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS CX2 SENSE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 SENSE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS CX2 SENSE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfSenseCx2Adj == 1) { + logError(1, "%s SS CX2 SENSE ADJHORIZ TEST: \n", tag); + ret = + computeAdjHoriz(ssCompData.cx2_sn, 1, + ssCompData.header.sense_node, &adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz SS CX2 SENSE ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, "%s SS CX2 SENSE ADJH computed! \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_CX2_SENSE_ADJH_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != ssCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_SENSE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdj(adjhor, 1, ssCompData.header.sense_node - 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS CX2 SENSE ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS CX2 SENSE ADJH TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 SENSE ADJH TEST:.................OK \n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + } else + logError(0, + "%s SS CX2 SENSE ADJ TEST:.................SKIPPED \n\n", + tag); + + + if (todo->SelfSenseCxTotal == 1 || todo->SelfSenseCxTotalAdj == 1) { + + if (todo->SelfSenseCxTotal == 1) { + logError(1, "%s SS TOTAL CX SENSE MIN MAX TEST: \n", tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_CX_SENSE_MAP_MIN, &thresholds_min, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_SENSE_MAP_MIN failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_CX_SENSE_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_SENSE_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(totCompData.cx_sn, 1, totCompData.header.sense_node, thresholds_min, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL CX SENSE failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL CX SENSE MIN MAX TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX SENSE MIN MAX TEST:.................OK \n\n", + tag); + + kfree(thresholds_min); + thresholds_min = NULL; + kfree(thresholds_max); + thresholds_max = NULL; + } else + logError(0, + "%s SS TOTAL CX SENSE MIN MAX TEST:.................SKIPPED \n", + tag); + + + if (todo->SelfSenseCxTotalAdj == 1) { + logError(1, "%s SS TOTAL CX SENSE ADJHORIZ TEST: \n", + tag); + ret = + computeAdjHorizTotal(totCompData.cx_sn, 1, + totCompData.header.sense_node, + &total_adjhor); + + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjHoriz SS TOTAL CX SENSE ADJH failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(0, + "%s SS TOTAL CX SENSE ADJ HORIZ computed! \n", + tag); + ret = parseProductionTestLimits(path_limits, &limit_file, SS_TOTAL_CX_SENSE_ADJH_MAP_MAX, &thresholds_max, &trows, &tcolumns); + + if (ret < 0 + || (trows != 1 + || tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_SENSE_ADJH_MAP_MAX failed... ERROR %08X \n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapAdjTotal(total_adjhor, 1, totCompData.header.sense_node - 1, thresholds_max); + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS TOTAL CX SENSE ADJH failed... ERROR COUNT = %d \n", + tag, ret); + logError(0, + "%s SS TOTAL CX SENSE ADJH TEST:.................FAIL \n\n", + tag); + count_fail += 1; + + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX SENSE ADJH TEST:.................OK \n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(total_adjhor); + total_adjhor = NULL; + } else + logError(0, + "%s SS TOTAL CX SENSE ADJ TEST:.................SKIPPED \n", + tag); + } else + logError(0, + "%s SS TOTAL CX SENSE TEST:.................SKIPPED \n", + tag); + if (todo->SelfHoverForceIxTotal == 1 || todo->SelfHoverSenceIxTotal == 1) { + ret = production_test_ss_hover_ix(path_limits, stop_on_fail, todo); + if (ret < OK) { + logError(1, + "%s production_test_data: production_test_ss_hover_ix_cx failed... ERROR = %08X\n", + tag, ret); + count_fail += 1; + } + } + +ERROR: + logError(0, "%s \n", tag); + + if (count_fail == 0) { + kfree(ssCompData.ix2_fm); + ssCompData.ix2_fm = NULL; + kfree(ssCompData.ix2_sn); + ssCompData.ix2_sn = NULL; + kfree(ssCompData.cx2_fm); + ssCompData.cx2_fm = NULL; + kfree(ssCompData.cx2_sn); + ssCompData.cx2_sn = NULL; + kfree(totCompData.ix_fm); + totCompData.ix_fm = NULL; + kfree(totCompData.ix_sn); + totCompData.ix_sn = NULL; + kfree(totCompData.cx_fm); + totCompData.cx_fm = NULL; + kfree(totCompData.cx_sn); + totCompData.cx_sn = NULL; + logError(0, + "%s SS IX CX testes finished!.................OK\n\n", + tag); + return OK; + } else { + print_frame_u8("SS Init Data Ix2_fm = ", + array1dTo2d_u8(ssCompData.ix2_fm, + ssCompData.header.force_node, 1), + ssCompData.header.force_node, 1); + print_frame_i8("SS Init Data Cx2_fm = ", + array1dTo2d_i8(ssCompData.cx2_fm, + ssCompData.header.force_node, 1), + ssCompData.header.force_node, 1); + print_frame_u8("SS Init Data Ix2_sn = ", + array1dTo2d_u8(ssCompData.ix2_sn, + ssCompData.header.sense_node, + ssCompData.header.sense_node), 1, + ssCompData.header.sense_node); + print_frame_i8("SS Init Data Cx2_sn = ", + array1dTo2d_i8(ssCompData.cx2_sn, + ssCompData.header.sense_node, + ssCompData.header.sense_node), 1, + ssCompData.header.sense_node); + print_frame_u16("TOT SS Init Data Ix_fm = ", + array1dTo2d_u16(totCompData.ix_fm, + totCompData.header.force_node, + 1), + totCompData.header.force_node, 1); + print_frame_short("TOT SS Init Data Cx_fm = ", + array1dTo2d_short(totCompData.cx_fm, + totCompData.header. + force_node, 1), + totCompData.header.force_node, 1); + print_frame_u16("TOT SS Init Data Ix_sn = ", + array1dTo2d_u16(totCompData.ix_sn, + totCompData.header.sense_node, + totCompData.header.sense_node), + 1, totCompData.header.sense_node); + print_frame_short("TOT SS Init Data Cx_sn = ", + array1dTo2d_short(totCompData.cx_sn, + totCompData.header. + sense_node, + totCompData.header. + sense_node), 1, + totCompData.header.sense_node); + logError(0, + "%s SS IX CX testes finished!.................FAILED fails_count = %d\n\n", + tag, count_fail); + + if (thresholds != NULL) + kfree(thresholds); + + if (thresholds_min != NULL) + kfree(thresholds_min); + + if (thresholds_max != NULL) + kfree(thresholds_max); + + if (adjhor != NULL) + kfree(adjhor); + + if (adjvert != NULL) + kfree(adjvert); + + if (total_adjhor != NULL) + kfree(total_adjhor); + + if (total_adjvert != NULL) + kfree(total_adjvert); + + if (ssCompData.ix2_fm != NULL) + kfree(ssCompData.ix2_fm); + + if (ssCompData.ix2_sn != NULL) + kfree(ssCompData.ix2_sn); + + if (ssCompData.cx2_fm != NULL) + kfree(ssCompData.cx2_fm); + + if (ssCompData.cx2_sn != NULL) + kfree(ssCompData.cx2_sn); + + if (totCompData.ix_fm != NULL) + kfree(totCompData.ix_fm); + + if (totCompData.ix_sn != NULL) + kfree(totCompData.ix_sn); + + if (totCompData.cx_fm != NULL) + kfree(totCompData.cx_fm); + + if (totCompData.cx_sn != NULL) + kfree(totCompData.cx_sn); + + return (ERROR_TEST_CHECK_FAIL | ERROR_PROD_TEST_DATA); + } + +ERROR_LIMITS: + + if (thresholds != NULL) + kfree(thresholds); + + if (thresholds_min != NULL) + kfree(thresholds_min); + + if (thresholds_max != NULL) + kfree(thresholds_max); + + if (adjhor != NULL) + kfree(adjhor); + + if (adjvert != NULL) + kfree(adjvert); + + if (total_adjhor != NULL) + kfree(total_adjhor); + + if (total_adjvert != NULL) + kfree(total_adjvert); + + if (ssCompData.ix2_fm != NULL) + kfree(ssCompData.ix2_fm); + + if (ssCompData.ix2_sn != NULL) + kfree(ssCompData.ix2_sn); + + if (ssCompData.cx2_fm != NULL) + kfree(ssCompData.cx2_fm); + + if (ssCompData.cx2_sn != NULL) + kfree(ssCompData.cx2_sn); + + if (totCompData.ix_fm != NULL) + kfree(totCompData.ix_fm); + + if (totCompData.ix_sn != NULL) + kfree(totCompData.ix_sn); + + if (totCompData.cx_fm != NULL) + kfree(totCompData.cx_fm); + + if (totCompData.cx_sn != NULL) + kfree(totCompData.cx_sn); + + return ret; +} + +/** + * Perform a complete Data Test check of the IC + * @param path_limits name of Production Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param stop_on_fail if 1, the test flow stops at the first data check failure otherwise it keeps going performing all the selected test + * @param todo pointer to a TestToDo variable which select the test to do + * @return OK if success or an error code which specify the type of error encountered + */ +int production_test_data(char *path_limits, int stop_on_fail, TestToDo *todo) +{ + int res = OK, ret; + + if (todo == NULL) { + logError(1, + "%s production_test_data: No TestToDo specified!! ERROR = %08X \n", + tag, (ERROR_OP_NOT_ALLOW | ERROR_PROD_TEST_DATA)); + return (ERROR_OP_NOT_ALLOW | ERROR_PROD_TEST_DATA); + } + + logError(1, "%s DATA Production test is starting...\n", tag); + ret = production_test_ms_raw(path_limits, stop_on_fail, todo); + res |= ret; + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ms_raw failed... ERROR = %08X \n", + tag, ret); + + if (stop_on_fail == 1) + goto END; + } + + ret = production_test_ms_cx(path_limits, stop_on_fail, todo); + res |= ret; + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ms_cx failed... ERROR = %08X \n", + tag, ret); + + if (stop_on_fail == 1) + goto END; + } + + ret = production_test_ss_raw(path_limits, stop_on_fail, todo); + res |= ret; + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ss_raw failed... ERROR = %08X \n", + tag, ret); + + if (stop_on_fail == 1) + goto END; + } + + ret = production_test_ss_ix_cx(path_limits, stop_on_fail, todo); + res |= ret; + + if (ret < 0) { + logError(1, + "%s production_test_data: production_test_ss_ix_cx failed... ERROR = %08X \n", + tag, ret); + + if (stop_on_fail == 1) + goto END; + } + +END: + freeLimitsFile(&limit_file); + + if (res < OK) + logError(0, "%s DATA Production test failed!\n", tag); + else + logError(0, "%s DATA Production test finished!\n", tag); + + return res; +} + +/** + * Retrieve the actual Test Limit data from the system (bin file or header file) + * @param path name of Production Test Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param file pointer to the LimitFile struct which will contains the limits data + * @return OK if success or an error code which specify the type of error encountered + */ +int getLimitsFile(char *path, LimitFile *file) +{ + const struct firmware *fw = NULL; + struct device *dev = NULL; + int fd = -1; + logError(0, "%s Get Limits File starting... %s\n", tag, path); + + if (file->data != NULL) { + logError(0, + "%s Pointer to Limits Data already contains something... freeing its content!\n", + tag); + kfree(file->data); + file->data = NULL; + file->size = 0; + } + + strlcpy(file->name, path, MAX_LIMIT_FILE_NAME); + + if (strncmp(path, "NULL", 4) == 0) { +#ifdef LIMITS_H_FILE + logError(0, "%s Loading Limits File from .h!\n", tag); + file->size = LIMITS_SIZE_NAME; + file->data = + (char *)kmalloc((file->size) * sizeof(char), GFP_KERNEL); + + if (file->data != NULL) { + memcpy(file->data, (char *)(LIMITS_ARRAY_NAME), + file->size); + return OK; + } else { + logError(1, + "%s Error while allocating data... ERROR %08X \n", + tag, path, ERROR_ALLOC); + return ERROR_ALLOC; + } + +#else + logError(1, "%s limit file path NULL... ERROR %08X \n", tag, + ERROR_FILE_NOT_FOUND); + return ERROR_FILE_NOT_FOUND; +#endif + } else { + dev = getDev(); + + if (dev != NULL) { + logError(0, "%s Loading Limits File from .csv!\n", tag); + fd = request_firmware(&fw, path, dev); + + if (fd == 0) { + logError(0, "%s Start to copy %s...\n", tag, + path); + file->size = fw->size; + file->data = + (char *)kmalloc((file->size) * sizeof(char), + GFP_KERNEL); + + if (file->data != NULL) { + memcpy(file->data, (char *)fw->data, + file->size); + logError(0, + "%s Limit file Size = %d \n", + tag, file->size); + release_firmware(fw); + return OK; + } else { + logError(1, + "%s Error while allocating data... ERROR %08X \n", + tag, path, ERROR_ALLOC); + release_firmware(fw); + return ERROR_ALLOC; + } + } else { + logError(1, + "%s Request the file %s failed... ERROR %08X \n", + tag, path, ERROR_FILE_NOT_FOUND); + return ERROR_FILE_NOT_FOUND; + } + } else { + logError(1, + "%s Error while getting the device ERROR %08X \n", + tag, ERROR_FILE_READ); + return ERROR_FILE_READ; + } + } +} + +/** + * Reset and release the memory which store a Production Limit File previously loaded + * @param file pointer to the LimitFile struct to free + * @return OK if success or an error code which specify the type of error encountered + */ + +int freeLimitsFile(LimitFile *file) +{ + logError(0, "%s Freeing Limit File ...\n", tag); + + if (file != NULL) { + if (file->data != NULL) { + kfree(file->data); + file->data = NULL; + } else + logError(0, "%s Limit File was already freed!\n", tag); + + file->size = 0; + strlcpy(file->name, " ", MAX_LIMIT_FILE_NAME); + return OK; + } else { + logError(1, "%s Passed a NULL argument! ERROR %08X \n", tag, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } +} + +/** + * Reset and release the memory which store the current Limit File previously loaded + * @return OK if success or an error code which specify the type of error encountered + */ + +int freeCurrentLimitsFile(void) +{ + return freeLimitsFile(&limit_file); +} + +/** + * Parse the raw data read from a Production test limit file in order to find the specified information + * If no limits file data are passed, the function loads and stores the limit file from the system + * @param path name of Production Test Limit file to load or "NULL" if the limits data should be loaded by a .h file + * @param file pointer to LimitFile struct that should be parsed or NULL if the limit file in the system should be loaded and then parsed + * @param label string which identify a particular set of data in the file that want to be loaded + * @param data pointer to the pointer which will contains the specified limits data as 1 dimension matrix with data arranged row after row + * @param row pointer to a int variable which will contain the number of row of data + * @param column pointer to a int variable which will contain the number of column of data + * @return OK if success or an error code which specify the type of error encountered + */ +int parseProductionTestLimits(char *path, LimitFile *file, char *label, + int **data, int *row, int *column) +{ + int find = 0; + char *token = NULL; + int i = 0; + int j = 0; + int z = 0; + char *line2 = NULL; + char line[800]; + char *buf = NULL; + int n, size, pointer = 0, ret = OK; + char *data_file = NULL; + + if (file == NULL || strcmp(path, file->name) != 0 || file->size == 0) { + logError(0, + "%s No limit File data passed... try to get them from the system!\n", + tag); + ret = getLimitsFile(LIMITS_FILE, &limit_file); + + if (ret < OK) { + logError(1, + "%s parseProductionTestLimits: ERROR %08X\n", + tag, ERROR_FILE_NOT_FOUND); + return ERROR_FILE_NOT_FOUND; + } + + size = limit_file.size; + data_file = limit_file.data; + } else { + logError(0, "%s Limit File data passed as arguments!\n", tag); + size = file->size; + data_file = file->data; + } + + logError(0, "%s The size of the limits file is %d bytes...\n", tag, + size); + + while (find == 0) { + if (readLine(&data_file[pointer], line, size - pointer, &n) < 0) { + find = -1; + break; + } + + pointer += n; + + if (line[0] == '*') { + line2 = kstrdup(line, GFP_KERNEL); + + if (line2 == NULL) { + logError(1, + "%s parseProductionTestLimits: kstrdup ERROR %08X\n", + tag, ERROR_ALLOC); + ret = ERROR_ALLOC; + goto END; + } + + buf = line2; + line2 += 1; + token = strsep(&line2, ","); + + if (strcmp(token, label) == 0) { + find = 1; + token = strsep(&line2, ","); + + if (token != NULL) { + sscanf(token, "%d", row); + logError(0, "%s Row = %d\n", tag, *row); + } else { + logError(1, + "%s parseProductionTestLimits 1: ERROR %08X\n", + tag, ERROR_FILE_PARSE); + ret = ERROR_FILE_PARSE; + goto END; + } + + token = strsep(&line2, ","); + + if (token != NULL) { + sscanf(token, "%d", column); + logError(0, "%s Column = %d\n", tag, + *column); + } else { + logError(1, + "%s parseProductionTestLimits 2: ERROR %08X\n", + tag, ERROR_FILE_PARSE); + ret = ERROR_FILE_PARSE; + goto END; + } + + kfree(buf); + buf = NULL; + *data = (int *)kmalloc(((*row) * (*column)) * sizeof(int), GFP_KERNEL); + j = 0; + + if (*data == NULL) { + logError(1, + "%s parseProductionTestLimits: ERROR %08X\n", + tag, ERROR_ALLOC); + ret = ERROR_ALLOC; + goto END; + } + + for (i = 0; i < *row; i++) { + if (readLine + (&data_file[pointer], line, + size - pointer, &n) < 0) { + logError(1, + "%s parseProductionTestLimits : ERROR %08X\n", + tag, ERROR_FILE_READ); + ret = ERROR_FILE_READ; + goto END; + } + + pointer += n; + line2 = kstrdup(line, GFP_KERNEL); + + if (line2 == NULL) { + logError(1, + "%s parseProductionTestLimits: kstrdup ERROR %08X\n", + tag, ERROR_ALLOC); + ret = ERROR_ALLOC; + goto END; + } + + buf = line2; + token = strsep(&line2, ","); + + for (z = 0; + (z < *column) && (token != NULL); + z++) { + sscanf(token, "%d", + ((*data) + j)); + j++; + token = strsep(&line2, ","); + } + + kfree(buf); + buf = NULL; + } + + if (j == ((*row) * (*column))) { + logError(0, "%s READ DONE!\n", tag); + ret = OK; + goto END; + } + + logError(1, + "%s parseProductionTestLimits 3: ERROR %08X\n", + tag, ERROR_FILE_PARSE); + ret = ERROR_FILE_PARSE; + goto END; + } + + kfree(buf); + buf = NULL; + } + } + + logError(1, "%s parseProductionTestLimits: ERROR %08X\n", tag, + ERROR_LABEL_NOT_FOUND); + ret = ERROR_LABEL_NOT_FOUND; +END: + + if (buf != NULL) + kfree(buf); + + return ret; +} + +/** + * Read one line of a text file passed as array of byte and terminate it with a termination character '\0' + * @param data text file as array of bytes + * @param line pointer to an array of char that will contain the line read + * @param size size of data + * @param n pointer to a int variable which will contain the number of characters of the line + * @return OK if success or an error code which specify the type of error encountered + */ +int readLine(char *data, char *line, int size, int *n) +{ + int i = 0; + + if (size < 1) + return -EINVAL; + + while (data[i] != '\n' && i < size) { + line[i] = data[i]; + i++; + } + + *n = i + 1; + line[i] = '\0'; + return OK; +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.h new file mode 100644 index 000000000000..127dce0478ee --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTest.h @@ -0,0 +1,293 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS API for MP test * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsTest.h +* \brief Contains all the definitions and structs related to the Mass Production Test +*/ + +#ifndef FTS_TEST_H +#define FTS_TEST_H + +#include "ftsSoftware.h" + +#ifndef LIMITS_H_FILE +#define LIMITS_FILE "stm_fts_production_limits.csv" /*Name of the Production Test Limit File*/ +#else +#define LIMITS_FILE "NULL" +#endif + +#define WAIT_FOR_FRESH_FRAMES 200 /*Time in ms to wait after start to sensing before reading a frame*/ +#define WAIT_AFTER_SENSEOFF 50 /*Time in ms to wait after stop sensing and before reading a frame from memory*/ + +#define NO_INIT 0 /*No Initialization required during the MP*/ + +#define RETRY_INIT_BOOT 3 /*number of retry of the initialization process at boot*/ + +/** @defgroup mp_test Mass Production Test + * Mass production test API. + * Mass Production Test (MP) should be executed at least one time in the life of every device \n + * It used to verify that tit is not present any hardware damage and initialize some value of the chip in order to guarantee the working performance \n + * The MP test is made up by 3 steps: + * - ITO test = production_test_ito() \n + * - Initialization = production_test_initialization() \n + * - Data Test = production_test_data(), it is possible to select which items test thanks to the TestToDo struct\n + * To execute the Data Test it is mandatory load some thresholds that are stored in the Limit File. + * @{ + */ + +/** @defgroup limit_file Limit File + * @ingroup mp_test + * Production Test Limit File is a csv which contains thresholds of the data to test. + * This file can be loaded from the file system or stored as a header file according to the LIMITS_H_FILE define \n + * For each selectable test item there can be one or more associated labels which store the corresponding thresholds \n + * @{ + */ + +/** @defgroup test_labels Test Items Labels + * @ingroup limit_file + * Labels present in the Limit File and associated to the test items of TestToDo + * @{ + */ +#define MS_RAW_MIN_MAX "MS_RAW_DATA_MIN_MAX" +#define MS_RAW_EACH_NODE_MIN "MS_RAW_DATA_EACH_MIN" +#define MS_RAW_EACH_NODE_MAX "MS_RAW_DATA_EACH_MAX" +#define MS_RAW_GAP "MS_RAW_DATA_GAP" +#define MS_RAW_ADJH "MS_RAW_DATA_ADJ_HORIZONTAL" +#define MS_RAW_ADJV "MS_RAW_DATA_ADJ_VERTICAL" +#define MS_RAW_ITO_ADJH "MS_RAW_ITO_DATA_ADJ_HORIZONTAL" +#define MS_RAW_ITO_ADJV "MS_RAW_ITO_DATA_ADJ_VERTICAL" +#define MS_RAW_LP_MIN_MAX "MS_RAW_LOWPOWER_DATA_MIN_MAX" +#define MS_RAW_LP_GAP "MS_RAW_LOWPOWER_DATA_GAP" +#define MS_RAW_LP_ADJH "MS_RAW_LOWPOWER_DATA_ADJ_HORIZONTAL" +#define MS_RAW_LP_ADJV "MS_RAW_LOWPOWER_DATA_ADJ_VERTICAL" +#define MS_CX1_MIN_MAX "MS_TOUCH_ACTIVE_CX1_MIN_MAX" +#define MS_CX2_MAP_MIN "MS_TOUCH_ACTIVE_CX2_MIN" +#define MS_CX2_MAP_MAX "MS_TOUCH_ACTIVE_CX2_MAX" +#define MS_CX2_ADJH_MAP_MAX "MS_TOUCH_ACTIVE_CX2_ADJ_HORIZONTAL" +#define MS_CX2_ADJV_MAP_MAX "MS_TOUCH_ACTIVE_CX2_ADJ_VERTICAL" +#define MS_TOTAL_CX_MAP_MIN "MS_TOUCH_ACTIVE_TOTAL_CX_MIN" +#define MS_TOTAL_CX_MAP_MAX "MS_TOUCH_ACTIVE_TOTAL_CX_MAX" +#define MS_TOTAL_CX_ADJH_MAP_MAX "MS_TOUCH_ACTIVE_TOTAL_CX_ADJ_HORIZONTAL" +#define MS_TOTAL_CX_ADJV_MAP_MAX "MS_TOUCH_ACTIVE_TOTAL_CX_ADJ_VERTICAL" +#define MS_CX1_LP_MIN_MAX "MS_TOUCH_LOWPOWER_CX1_MIN_MAX" +#define MS_CX2_LP_MAP_MIN "MS_TOUCH_LOWPOWER_CX2_MIN" +#define MS_CX2_LP_MAP_MAX "MS_TOUCH_LOWPOWER_CX2_MAX" +#define MS_CX2_ADJH_LP_MAP_MAX "MS_TOUCH_LOWPOWER_CX2_ADJ_HORIZONTAL" +#define MS_CX2_ADJV_LP_MAP_MAX "MS_TOUCH_LOWPOWER_CX2_ADJ_VERTICAL" +#define MS_TOTAL_CX_LP_MAP_MIN "MS_TOUCH_LOWPOWER_TOTAL_CX_MIN" +#define MS_TOTAL_CX_LP_MAP_MAX "MS_TOUCH_LOWPOWER_TOTAL_CX_MAX" +#define MS_TOTAL_CX_ADJH_LP_MAP_MAX "MS_TOUCH_LOWPOWER_TOTAL_CX_ADJ_HORIZONTAL" +#define MS_TOTAL_CX_ADJV_LP_MAP_MAX "MS_TOUCH_LOWPOWER_TOTAL_CX_ADJ_VERTICAL" +#define SS_RAW_FORCE_MIN_MAX "SS_RAW_DATA_FORCE_MIN_MAX" +#define SS_RAW_SENSE_MIN_MAX "SS_RAW_DATA_SENSE_MIN_MAX" +#define SS_RAW_FORCE_GAP "SS_RAW_DATA_FORCE_GAP" +#define SS_RAW_SENSE_GAP "SS_RAW_DATA_SENSE_GAP" +#define SS_RAW_LP_FORCE_MIN_MAX "SS_RAW_LOWPOWER_DATA_FORCE_MIN_MAX" +#define SS_RAW_LP_SENSE_MIN_MAX "SS_RAW_LOWPOWER_DATA_SENSE_MIN_MAX" +#define SS_RAW_LP_FORCE_GAP "SS_RAW_LOWPOWER_DATA_FORCE_GAP" +#define SS_RAW_LP_SENSE_GAP "SS_RAW_LOWPOWER_DATA_SENSE_GAP" +#define SS_IX1_FORCE_MIN_MAX "SS_TOUCH_ACTIVE_IX1_FORCE_MIN_MAX" +#define SS_IX1_SENSE_MIN_MAX "SS_TOUCH_ACTIVE_IX1_SENSE_MIN_MAX" +#define SS_CX1_FORCE_MIN_MAX "SS_TOUCH_ACTIVE_CX1_FORCE_MIN_MAX" +#define SS_CX1_SENSE_MIN_MAX "SS_TOUCH_ACTIVE_CX1_SENSE_MIN_MAX" +#define SS_IX2_FORCE_MAP_MIN "SS_TOUCH_ACTIVE_IX2_FORCE_MIN" +#define SS_IX2_FORCE_MAP_MAX "SS_TOUCH_ACTIVE_IX2_FORCE_MAX" +#define SS_IX2_SENSE_MAP_MIN "SS_TOUCH_ACTIVE_IX2_SENSE_MIN" +#define SS_IX2_SENSE_MAP_MAX "SS_TOUCH_ACTIVE_IX2_SENSE_MAX" +#define SS_IX2_FORCE_ADJV_MAP_MAX "SS_TOUCH_ACTIVE_IX2_ADJ_VERTICAL" +#define SS_IX2_SENSE_ADJH_MAP_MAX "SS_TOUCH_ACTIVE_IX2_ADJ_HORIZONTAL" +#define SS_CX2_FORCE_MAP_MIN "SS_TOUCH_ACTIVE_CX2_FORCE_MIN" +#define SS_CX2_FORCE_MAP_MAX "SS_TOUCH_ACTIVE_CX2_FORCE_MAX" +#define SS_CX2_SENSE_MAP_MIN "SS_TOUCH_ACTIVE_CX2_SENSE_MIN" +#define SS_CX2_SENSE_MAP_MAX "SS_TOUCH_ACTIVE_CX2_SENSE_MAX" +#define SS_CX2_FORCE_ADJV_MAP_MAX "SS_TOUCH_ACTIVE_CX2_ADJ_VERTICAL" +#define SS_CX2_SENSE_ADJH_MAP_MAX "SS_TOUCH_ACTIVE_CX2_ADJ_HORIZONTAL" + +#define SS_TOTAL_IX_FORCE_MAP_MIN "SS_TOUCH_ACTIVE_TOTAL_IX_FORCE_MIN" +#define SS_TOTAL_IX_FORCE_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_IX_FORCE_MAX" +#define SS_TOTAL_IX_SENSE_MAP_MIN "SS_TOUCH_ACTIVE_TOTAL_IX_SENSE_MIN" +#define SS_TOTAL_IX_SENSE_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_IX_SENSE_MAX" +#define SS_TOTAL_IX_FORCE_ADJV_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_IX_ADJ_VERTICAL" +#define SS_TOTAL_IX_SENSE_ADJH_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_IX_ADJ_HORIZONTAL" +#define SS_TOTAL_CX_FORCE_MAP_MIN "SS_TOUCH_ACTIVE_TOTAL_CX_FORCE_MIN" +#define SS_TOTAL_CX_FORCE_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_CX_FORCE_MAX" +#define SS_TOTAL_CX_SENSE_MAP_MIN "SS_TOUCH_ACTIVE_TOTAL_CX_SENSE_MIN" +#define SS_TOTAL_CX_SENSE_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_CX_SENSE_MAX" +#define SS_TOTAL_CX_FORCE_ADJV_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_CX_ADJ_VERTICAL" +#define SS_TOTAL_CX_SENSE_ADJH_MAP_MAX "SS_TOUCH_ACTIVE_TOTAL_CX_ADJ_HORIZONTAL" + +#define MS_KEY_RAW_MIN_MAX "MS_KEY_RAW_DATA_MIN_MAX" +#define MS_KEY_CX1_MIN_MAX "MS_KEY_CX1_MIN_MAX" +#define MS_KEY_CX2_MAP_MIN "MS_KEY_CX2_MIN" +#define MS_KEY_CX2_MAP_MAX "MS_KEY_CX2_MAX" +#define MS_KEY_TOTAL_CX_MAP_MIN "MS_KEY_TOTAL_CX_MIN" +#define MS_KEY_TOTAL_CX_MAP_MAX "MS_KEY_TOTAL_CX_MAX" + +#define SS_IX1_FORCE_W "IX1_FORCE_W" +#define SS_IX2_FORCE_W "IX2_FORCE_W" +#define SS_IX1_SENSE_W "IX1_SENSE_W" +#define SS_IX2_SENSE_W "IX2_SENSE_W" + +/* SS HOVER*/ +#define SS_HOVER_RAW_FORCE_MIN_MAX "SS_RAW_HOVER_DATA_FORCE_MIN_MAX" +#define SS_HOVER_TOTAL_IX_FORCE_MAP_MIN "SS_HOVER_TOTAL_IX_FORCE_MIN" +#define SS_HOVER_TOTAL_IX_FORCE_MAP_MAX "SS_HOVER_TOTAL_IX_FORCE_MAX" +#define SS_HOVER_RAW_SENSE_MIN_MAX "SS_RAW_HOVER_DATA_SENSE_MIN_MAX" +#define SS_HOVER_TOTAL_IX_SENSE_MAP_MIN "SS_HOVER_TOTAL_IX_SENSE_MIN" +#define SS_HOVER_TOTAL_IX_SENSE_MAP_MAX "SS_HOVER_TOTAL_IX_SENSE_MAX" + +/** @}*/ + +/** +* Struct used to specify which test perform during the Mass Production Test. +* For each test item selected in this structure, there should be one or more labels associated in the Limit file from where load the thresholds +*/ +typedef struct { + int MutualRaw; /*MS Raw min/Max test*/ + int MutualRawEachNode; + int MutualRawGap; /*MS Raw Gap(max-min) test*/ + int MutualRawAdj; /*MS Raw Adjacent test*/ + int MutualRawLP; /*MS Low Power Raw min/Max test*/ + int MutualRawGapLP; /*MS Low Power Raw Gap(max-min) test*/ + int MutualRawAdjLP; /*MS Low Power Raw Adjacent test*/ + int MutualRawAdjITO; /*MS Raw Adjacent test during ITO test*/ + + int MutualCx1; /*MS Cx1 min/Max test*/ + int MutualCx2; /*MS Cx2 min/Max (for each node) test*/ + int MutualCx2Adj; /*MS Vertical and Horizontal Adj Cx2 min/Max (for each node) test*/ + int MutualCxTotal; /*MS Total Cx min/Max (for each node) test*/ + int MutualCxTotalAdj; /*MS Total vertical and Horizontal Adj Cx2 min/Max (for each node) test*/ + int MutualCx1LP; /* /< MS LowPower Cx1 min/Max test */ + int MutualCx2LP; /* /< MS LowPower Cx2 min/Max (for each node) test */ + int MutualCx2AdjLP; /* /< MS LowPower Vertical and Horizontal Adj Cx2 min/Max + * (for each node) test */ + int MutualCxTotalLP; /* /< MS Total LowPower Cx min/Max (for each node) test + * */ + int MutualCxTotalAdjLP; /* /< MS Total LowPower vertical and Horizontal Adj Cx2 + * min/Max (for each node) test */ + + int MutualKeyRaw; /*MS Raw Key min/Max test*/ + int MutualKeyCx1; /*MS Cx1 Key min/Max test*/ + int MutualKeyCx2; /*MS Cx2 Key min/Max (for each node) test*/ + int MutualKeyCxTotal; /*MS Total Cx Key min/Max (for each node) test*/ + + int SelfHoverForceRaw; /* SS Hover Force Raw min/Max test */ + int SelfHoverSenceRaw; /*SS Hover Sence Raw min/Max test */ + int SelfHoverForceIxTotal; /*SS Hover Total Force Ix min/Max (for each node)* test */ + int SelfHoverSenceIxTotal; /*SS Hover Total Sence Ix min/Max (for each node)* test */ + + int SelfForceRaw; /*SS Force Raw min/Max test*/ + int SelfForceRawGap; /*SS Force Raw Gap(max-min) test*/ + int SelfForceRawLP; /*SS Low Power Force Raw min/Max test*/ + int SelfForceRawGapLP; /*SS Low Power Force Raw Gap(max-min) test*/ + + int SelfForceIx1; /*SS Force Ix1 min/Max test*/ + int SelfForceIx2; /*SS Force Ix2 min/Max (for each node) test*/ + int SelfForceIx2Adj; /*SS Vertical Adj Force Ix2 min/Max (for each node) test*/ + int SelfForceIxTotal; /*SS Total Force Ix min/Max (for each node) test*/ + int SelfForceIxTotalAdj; /*SS Total Vertical Adj Force Ix min/Max (for each node) test*/ + int SelfForceCx1; /*SS Force Cx1 min/Max test*/ + int SelfForceCx2; /*SS Force Cx2 min/Max (for each node) test*/ + int SelfForceCx2Adj; /*SS Vertical Adj Force Cx2 min/Max (for each node) test*/ + int SelfForceCxTotal; /*SS Total Force Cx min/Max (for each node) test*/ + int SelfForceCxTotalAdj; /*SS Total Vertical Adj Force Cx min/Max (for each node) test*/ + + int SelfSenseRaw; /*SS Sense Raw min/Max test*/ + int SelfSenseRawGap; /*SS Sense Raw Gap(max-min) test*/ + int SelfSenseRawLP; /*SS Low Power Sense Raw min/Max test*/ + int SelfSenseRawGapLP; /*SS Low Power Sense Raw Gap(max-min) test*/ + + int SelfSenseIx1; /*SS Sense Ix1 min/Max test*/ + int SelfSenseIx2; /*SS Sense Ix2 min/Max (for each node) test*/ + int SelfSenseIx2Adj; /*SS Horizontal Adj Sense Ix2 min/Max (for each node) test*/ + int SelfSenseIxTotal; /*SS Total Horizontal Sense Ix min/Max (for each node) test*/ + int SelfSenseIxTotalAdj; /*SS Total Horizontal Adj Sense Ix min/Max (for each node) test*/ + int SelfSenseCx1; /*SS Sense Cx1 min/Max test*/ + int SelfSenseCx2; /*SS Sense Cx2 min/Max (for each node) test*/ + int SelfSenseCx2Adj; /*SS Horizontal Adj Sense Cx2 min/Max (for each node) test*/ + int SelfSenseCxTotal; /*SS Total Sense Cx min/Max (for each node) test*/ + int SelfSenseCxTotalAdj; /*SS Total Horizontal Adj Sense Cx min/Max (for each node) test*/ + +} TestToDo; + +#define MAX_LIMIT_FILE_NAME 100 /*max number of chars of the limit file name*/ + +/** + * Struct which store the data coming from a Production Limit File + */ +typedef struct { + char *data; + int size; + char name[MAX_LIMIT_FILE_NAME]; +} LimitFile; + +int initTestToDo(void); +/**@}*/ + +/**@}*/ + +int computeAdjHoriz(i8 *data, int row, int column, u8 **result); +int computeAdjHorizTotal(short *data, int row, int column, u16 **result); +int computeAdjVert(i8 *data, int row, int column, u8 **result); +int computeAdjVertTotal(short *data, int row, int column, u16 **result); +int computeAdjHorizFromU(u8 *data, int row, int column, u8 **result); +int computeAdjHorizTotalFromU(u16 *data, int row, int column, u16 **result); +int computeAdjVertFromU(u8 *data, int row, int column, u8 **result); +int computeAdjVertTotalFromU(u16 *data, int row, int column, u16 **result); +int checkLimitsMinMax(short *data, int row, int column, int min, int max); +int checkLimitsMap(i8 *data, int row, int column, int *min, int *max); +int checkLimitsMapTotal(short *data, int row, int column, int *min, int *max); +int checkLimitsMapFromU(u8 *data, int row, int column, int *min, int *max); +int checkLimitsMapTotalFromU(u16 *data, int row, int column, int *min, + int *max); +int checkLimitsMapAdj(u8 *data, int row, int column, int *max); +int checkLimitsMapAdjTotal(u16 *data, int row, int column, int *max); + +/** @defgroup mp_api MP API + * @ingroup mp_test + * Functions to execute the MP test. + * The parameters of these functions allow to customize their behavior in order to satisfy different scenarios + * @{ + */ +int production_test_ito(char *path_limits, TestToDo *todo); +int production_test_initialization(u8 type); +int production_test_main(char *pathThresholds, int stop_on_fail, int saveInit, TestToDo *todo); +int production_test_ms_raw(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ms_raw_lp(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ms_cx(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ms_cx_lp(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ss_raw(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ss_raw_lp(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ss_ix_cx(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_data(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ms_key_cx(char *path_limits, int stop_on_fail, TestToDo *todo); +int production_test_ms_key_raw(char *path_limits); +int computeTotal(u8 *data, u8 main, int row, int column, int m, int n, + u16 **result); +/** @}*/ + +/** + * @addtogroup limit_file + * @{ + */ +int parseProductionTestLimits(char *path, LimitFile *file, char *label, int **data, int *row, int *column); +int readLine(char *data, char *line, int size, int *n); +int getLimitsFile(char *path, LimitFile *file); +int freeLimitsFile(LimitFile *file); +int freeCurrentLimitsFile(void); +/**@}*/ + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.c new file mode 100644 index 000000000000..39751d8b338a --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.c @@ -0,0 +1,80 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Utility for mesuring/handling the time * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsTime.c +* \brief Contains all functions to handle and measure the time in the driver +*/ + +#include "ftsTime.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +/** +* Take the starting time and save it in a StopWatch variable +* @param w pointer of a StopWatch struct +*/ +void startStopWatch(StopWatch *w) +{ + w->start = ktime_get(); +} + +/** +* Take the stop time and save it in a StopWatch variable +* @param w pointer of a StopWatch struct +*/ +void stopStopWatch(StopWatch *w) +{ + w->end = ktime_get(); +} + +/** +* Compute the amount of time spent from when the startStopWatch and then the stopStopWatch were called on the StopWatch variable +* @param w pointer of a StopWatch struct +* @return amount of time in ms (the return value is meaningless if the startStopWatch and stopStopWatch were not called before) +*/ +int elapsedMillisecond(StopWatch *w) +{ + u64 result; + + result = ktime_us_delta(w->end, w->start); + + return (int)(result / 1000); +} + +/** +* Compute the amount of time spent from when the startStopWatch and then the stopStopWatch were called on the StopWatch variable +* @param w pointer of a StopWatch struct +* @return amount of time in ns (the return value is meaningless if the startStopWatch and stopStopWatch were not called before) + +int elapsedNanosecond(StopWatch *w) +{ + int result; + + result = + ((w->end.tv_sec - w->start.tv_sec) * 1000000000) + (w->end.tv_nsec - + w->start.tv_nsec); + return result; +} +*/ \ No newline at end of file diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.h new file mode 100644 index 000000000000..d07472e46467 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTime.h @@ -0,0 +1,57 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Utility for measuring/handling the time * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsTime.h +* \brief Contains all the definitions and structs to handle and measure the time in the driver +*/ + +#ifndef FTS_TIME_H +#define FTS_TIME_H + +#include +#include + +/** @defgroup timeouts Timeouts +* Definitions of all the Timeout used in several operations +* @{ +*/ +#define TIMEOUT_RESOLUTION 2 /*timeout resolution in ms (all timeout should be multiples of this unit)*/ +#define GENERAL_TIMEOUT (50 * TIMEOUT_RESOLUTION) /*general timeout in ms*/ +#define RELEASE_INFO_TIMEOUT (15 * TIMEOUT_RESOLUTION) /* timeout to request release info in ms*/ + +#define TIMEOUT_REQU_COMP_DATA (100 * TIMEOUT_RESOLUTION) /*timeout to request compensation data in ms*/ +#define TIMEOUT_REQU_DATA (100 * TIMEOUT_RESOLUTION) /*timeout to request data in ms*/ +#define TIMEOUT_ITO_TEST_RESULT (100 * TIMEOUT_RESOLUTION) /*timeout to perform ito test in ms*/ +#define TIMEOUT_INITIALIZATION_TEST_RESULT (5000 * TIMEOUT_RESOLUTION) /*timeout to perform initialization test in ms*/ +#define TIMEOUT_ECHO TIMEOUT_INITIALIZATION_TEST_RESULT /*timeout of the echo command, should be the max of all the possible commands (used in worst case)*/ +/** @}*/ + +/** +* Struct used to measure the time elapsed between a starting and ending point. +*/ +typedef struct { +// struct timespec start; /*store the starting time*/ +// struct timespec end; /*store the finishing time*/ + ktime_t start; /*store the starting time*/ + ktime_t end; /*store the finishing time*/ +} StopWatch; + +void startStopWatch(StopWatch *w); +void stopStopWatch(StopWatch *w); +int elapsedMillisecond(StopWatch *w); +int elapsedNanosecond(StopWatch *w); + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.c b/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.c new file mode 100644 index 000000000000..a71efe86b169 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.c @@ -0,0 +1,648 @@ +/* + + ************************************************************************** + ** STMicroelectronics ** + ************************************************************************** + ** marco.cali@st.com ** + ************************************************************************** + * * + * FTS Utility Functions * + * * + ************************************************************************** + ************************************************************************** + + */ + +/*! +* \file ftsTool.c +* \brief Contains all the functions to support common operation inside the driver +*/ + +#include "ftsCompensation.h" +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsHardware.h" +#include "ftsIO.h" +#include "ftsSoftware.h" +#include "ftsTime.h" +#include "ftsTool.h" +#include "../fts.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** +* Print an array of byte in a HEX string and attach at the beginning a label. The function allocate memory that should be free outside the function itself +* @param label string to attach at the beginning +* @param buff pointer to the byte array that should be printed as HEX string +* @param count size of buff +* @return pointer to the array of characters that compose the HEX string. This point should be free outside when the string is no more needed +*/ +char *printHex(char *label, u8 *buff, int count, u8 *result) +{ + int i, offset; + + offset = strlen(label); + + strlcpy(result, label, offset); + + for (i = 0; i < count; i++) { + snprintf(&result[offset], 4, "%02X ", buff[i]); + offset += 3; + } + + return result; +} + +char *printHex_data(char *label, u8 *buff, int count) +{ + int i, offset; + char *result = NULL; + + offset = strlen(label); + result = + (char *)kmalloc(((offset + 4 * count) + 1) * sizeof(char), + GFP_KERNEL); + if (result != NULL) { + strlcpy(result, label, offset); + + for (i = 0; i < count; i++) { + snprintf(&result[offset], 4, "%02X ", buff[i]); + offset += 3; + } + + strlcat(result, "\n", ((offset + 4 * count) + 1) * sizeof(char)); + } + return result; +} + +/** + * Clear the FIFO from any event + * @return OK if success or an error code which specify the type of error encountered + */ +int flushFIFO(void) +{ + + int ret; + u8 sett = SPECIAL_FIFO_FLUSH; + ret = writeSysCmd(SYS_CMD_SPECIAL, &sett, 1); + if (ret < OK) { + logError(1, "%s flushFIFO: ERROR %08X \n", tag, ret); + return ret; + } + + logError(0, "%s FIFO flushed! \n", tag); + return OK; + +} + +/** +* Convert an array of bytes to an array of u16 taking two bytes at time, src has LSB first. +* @param src pointer to the source byte array +* @param src_length size of src +* @param dst pointer to the destination array. +* @return the final size of dst (half of the source) or ERROR_OP_NOT_ALLOW if the size of src is not multiple of 2. +*/ +int u8ToU16n(u8 *src, int src_length, u16 *dst) +{ + int i, j; + + if (src_length % 2 != 0) { + return ERROR_OP_NOT_ALLOW; + } else { + j = 0; + dst = + (u16 *) kmalloc((src_length / 2) * sizeof(u16), GFP_KERNEL); + for (i = 0; i < src_length; i += 2) { + dst[j] = + ((src[i + 1] & 0x00FF) << 8) + (src[i] & 0x00FF); + j++; + } + } + + return (src_length / 2); +} + +/** +* Convert an array of 2 bytes to a u16, src has LSB first (little endian). +* @param src pointer to the source byte array +* @param dst pointer to the destination u16. +* @return OK +*/ +int u8ToU16(u8 *src, u16 *dst) +{ + *dst = (u16) (((src[1] & 0x00FF) << 8) + (src[0] & 0x00FF)); + return OK; +} + +/** +* Convert an array of 2 bytes to a u16, src has MSB first (big endian). +* @param src pointer to the source byte array +* @param dst pointer to the destination u16. +* @return OK +*/ +int u8ToU16_be(u8 *src, u16 *dst) +{ + *dst = (u16) (((src[0] & 0x00FF) << 8) + (src[1] & 0x00FF)); + return OK; +} + +/** +* Convert an array of u16 to an array of u8, dst has MSB first (big endian). +* @param src pointer to the source array of u16 +* @param src_length size of src +* @param dst pointer to the destination array of u8. This array should be free when no need anymore +* @return size of dst (src size multiply by 2) +*/ +int u16ToU8n_be(u16 *src, int src_length, u8 *dst) +{ + int i, j; + dst = (u8 *) kmalloc((2 * src_length) * sizeof(u8), GFP_KERNEL); + j = 0; + for (i = 0; i < src_length; i++) { + dst[j] = (u8) (src[i] & 0xFF00) >> 8; + dst[j + 1] = (u8) (src[i] & 0x00FF); + j += 2; + } + + return src_length * 2; +} + +/** +* Convert a u16 to an array of 2 u8, dst has MSB first (big endian). +* @param src u16 to convert +* @param dst pointer to the destination array of 2 u8. +* @return OK +*/ +int u16ToU8_be(u16 src, u8 *dst) +{ + dst[0] = (u8) ((src & 0xFF00) >> 8); + dst[1] = (u8) (src & 0x00FF); + return OK; +} + +/** +* Convert a u16 to an array of 2 u8, dst has LSB first (little endian). +* @param src u16 to convert +* @param dst pointer to the destination array of 2 u8. +* @return OK +*/ +int u16ToU8(u16 src, u8 *dst) +{ + dst[1] = (u8) ((src & 0xFF00) >> 8); + dst[0] = (u8) (src & 0x00FF); + return OK; +} + +/** +* Convert an array of bytes to a u32, src has LSB first (little endian). +* @param src array of bytes to convert +* @param dst pointer to the destination u32 variable. +* @return OK +*/ +int u8ToU32(u8 *src, u32 *dst) +{ + *dst = + (u32) (((src[3] & 0xFF) << 24) + ((src[2] & 0xFF) << 16) + + ((src[1] & 0xFF) << 8) + (src[0] & 0xFF)); + return OK; +} + +/** +* Convert a u32 to an array of 4 bytes, dst has LSB first (little endian). +* @param src u32 value to convert +* @param dst pointer to the destination array of 4 bytes. +* @return OK +*/ +int u32ToU8(u32 src, u8 *dst) +{ + dst[3] = (u8) ((src & 0xFF000000) >> 24); + dst[2] = (u8) ((src & 0x00FF0000) >> 16); + dst[1] = (u8) ((src & 0x0000FF00) >> 8); + dst[0] = (u8) (src & 0x000000FF); + return OK; +} + +/** +* Convert a u32 to an array of 4 bytes, dst has MSB first (big endian). +* @param src u32 value to convert +* @param dst pointer to the destination array of 4 bytes. +* @return OK +*/ +int u32ToU8_be(u32 src, u8 *dst) +{ + dst[0] = (u8) ((src & 0xFF000000) >> 24); + dst[1] = (u8) ((src & 0x00FF0000) >> 16); + dst[2] = (u8) ((src & 0x0000FF00) >> 8); + dst[3] = (u8) (src & 0x000000FF); + return OK; +} + +/** +* Execute a function passed as argment and retry it defined number of times if not successfull +* @param code pointer to a function which return an int and doesn't have any parameters +* @param wait_before_retry interval of time in ms to wait between one trial and another one +* @param retry_count max number of retry to attemp +* @return last return value obtained from the last execution of the code function +*/ +int attempt_function(int (*code) (void), unsigned long wait_before_retry, + int retry_count) +{ + int result; + int count = 0; + + do { + result = code(); + count++; + mdelay(wait_before_retry); + } while (count < retry_count && result < 0); + + if (count == retry_count) + return (result | ERROR_TIMEOUT); + else + return result; + +} + +/** + * Enable all the possible sensing mode supported by the FW + * @return OK if success or an error code which specify the type of error encountered + */ +int senseOn(void) +{ + int ret; + + ret = setScanMode(SCAN_MODE_ACTIVE, 0x01); + if (ret < OK) { + logError(1, "%s senseOn: ERROR %08X\n", tag, ret); + return ret; + } + + logError(0, "%s senseOn: SENSE ON\n", tag); + return OK; +} + +/** + * Disable all the sensing mode + * @return OK if success or an error code which specify the type of error encountered + */ +int senseOff(void) +{ + int ret; + + ret = setScanMode(SCAN_MODE_ACTIVE, 0x00);; + if (ret < OK) { + logError(1, "%s senseOff: ERROR %08X\n", tag, ret); + return ret; + } + + logError(0, "%s senseOff: SENSE OFF\n", tag); + return OK; +} + +/** + * Clean up the IC status executing a system reset and giving the possibility to re-enabling the sensing + * @param enableTouch if 1, re-enable the sensing and the interrupt of the IC + * @return OK if success or an error code which specify the type of error encountered + */ +int cleanUp(int enableTouch) +{ + int res; + + logError(0, "%s cleanUp: system reset...\n", tag); + res = fts_system_reset(); + if (res < OK) + return res; + if (enableTouch) { + logError(0, "%s cleanUp: enabling touches...\n", tag); + res = senseOn(); + if (res < OK) + return res; + logError(0, "%s cleanUp: enabling interrupts...\n", tag); + res = fts_enableInterrupt(); + if (res < OK) + return res; + } + return OK; + +} + +/** +* Transform an array of short in a matrix of short with a defined number of columns and the resulting number of rows +* @param data array of bytes to convert +* @param size size of data +* @param columns number of columns that the resulting matrix should have. +* @return a reference to a matrix of short where for each row there are columns elements +*/ +short **array1dTo2d_short(short *data, int size, int columns) +{ + + int i; + short **matrix = + (short **)kmalloc(((int)(size / columns)) * sizeof(short *), + GFP_KERNEL); + if (matrix != NULL) { + for (i = 0; i < (int)(size / columns); i++) { + matrix[i] = + (short *)kmalloc(columns * sizeof(short), + GFP_KERNEL); + } + + for (i = 0; i < size; i++) { + matrix[i / columns][i % columns] = data[i]; + } + } + + return matrix; +} + +/** +* Transform an array of u16 in a matrix of u16 with a defined number of columns and the resulting number of rows +* @param data array of bytes to convert +* @param size size of data +* @param columns number of columns that the resulting matrix should have. +* @return a reference to a matrix of u16 where for each row there are columns elements +*/ +u16 **array1dTo2d_u16(u16 *data, int size, int columns) +{ + + int i; + u16 **matrix = (u16 **) kmalloc(((int)(size / columns)) * sizeof(u16 *), + GFP_KERNEL); + if (matrix != NULL) { + for (i = 0; i < (int)(size / columns); i++) { + matrix[i] = + (u16 *) kmalloc(columns * sizeof(u16), GFP_KERNEL); + } + + for (i = 0; i < size; i++) { + matrix[i / columns][i % columns] = data[i]; + } + } + + return matrix; +} + +/** +* Transform an array of u8 in a matrix of u8 with a defined number of columns and the resulting number of rows +* @param data array of bytes to convert +* @param size size of data +* @param columns number of columns that the resulting matrix should have. +* @return a reference to a matrix of short where for each row there are columns elements +*/ +u8 **array1dTo2d_u8(u8 *data, int size, int columns) +{ + + int i; + u8 **matrix = + (u8 **) kmalloc(((int)(size / columns)) * sizeof(u8 *), GFP_KERNEL); + if (matrix != NULL) { + for (i = 0; i < (int)(size / columns); i++) { + matrix[i] = + (u8 *) kmalloc(columns * sizeof(u8), GFP_KERNEL); + } + + for (i = 0; i < size; i++) { + matrix[i / columns][i % columns] = data[i]; + } + } + + return matrix; +} + +/** +* Transform an array of i8 in a matrix of i8 with a defined number of columns and the resulting number of rows +* @param data array of bytes to convert +* @param size size of data +* @param columns number of columns that the resulting matrix should have. +* @return a reference to a matrix of short where for each row there are columns elements +*/ +i8 **array1dTo2d_i8(i8 *data, int size, int columns) +{ + + int i; + i8 **matrix = + (i8 **) kmalloc(((int)(size / columns)) * sizeof(i8 *), GFP_KERNEL); + if (matrix != NULL) { + for (i = 0; i < (int)(size / columns); i++) { + matrix[i] = + (i8 *) kmalloc(columns * sizeof(i8), GFP_KERNEL); + } + + for (i = 0; i < size; i++) { + matrix[i / columns][i % columns] = data[i]; + } + } + + return matrix; +} + +/** +* Print in the kernel log a label followed by a matrix of short row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of short which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_short(char *label, short **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(1, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(1, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Print in the kernel log a label followed by a matrix of u16 row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of u16 which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_u16(char *label, u16 **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(0, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(0, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Print in the kernel log a label followed by a matrix of u8 row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of u8 which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_u8(char *label, u8 **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(1, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(1, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Print in the kernel log a label followed by a matrix of i8 row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of u8 which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_i8(char *label, i8 **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(1, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(1, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Print in the kernel log a label followed by a matrix of u32 row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of u32 which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_u32(char *label, u32 **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(0, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(0, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Print in the kernel log a label followed by a matrix of int row x columns and free its memory +* @param label pointer to the string to print before the actual matrix +* @param matrix reference to the matrix of int which contain the actual data +* @param row number of rows on which the matrix should be print +* @param column number of columns for each row +*/ +void print_frame_int(char *label, int **matrix, int row, int column) +{ + int i, j; + logError(1, "%s %s \n", tag, label); + for (i = 0; i < row; i++) { + logError(0, "%s ", tag); + for (j = 0; j < column; j++) { + printk("%d ", matrix[i][j]); + } + logError(0, "\n"); + kfree(matrix[i]); + } + kfree(matrix); +} + +/** +* Convert an array of bytes to an u64, src has MSB first (big endian). +* @param src array of bytes +* @param dest pointer to the destination u64. +* @param size size of src (can be <= 8) +* @return OK if success or ERROR_OP_NOT_ALLOW if size exceed 8 +*/ +int u8ToU64_be(u8 *src, u64 *dest, int size) +{ + int i = 0; + + if (size > sizeof(u64)) { + return ERROR_OP_NOT_ALLOW; + } else { + *dest = 0; + + for (i = 0; i < size; i++) { + *dest |= (u64) (src[i]) << ((size - 1 - i) * 8); + } + + return OK; + } +} + +/** +* Convert an u64 to an array of bytes, dest has MSB first (big endian). +* @param src value of u64 +* @param dest pointer to the destination array of bytes. +* @param size size of src (can be <= 8) +* @return OK if success or ERROR_OP_NOT_ALLOW if size exceed 8 +*/ +int u64ToU8_be(u64 src, u8 *dest, int size) +{ + int i = 0; + if (size > sizeof(u64)) { + return ERROR_OP_NOT_ALLOW; + } else { + for (i = 0; i < size; i++) { + dest[i] = (u8) ((src >> ((size - 1 - i) * 8)) & 0xFF); + } + } + + return OK; +} + +/*********** NEW API *************/ + +/** + * Convert a value of an id in a bitmask with a 1 in the position of the value of the id + * @param id Value of the ID to convert + * @param mask pointer to the bitmask that will be updated with the value of id + * @param size dimension in bytes of mask + * @return OK if success or ERROR_OP_NOT_ALLOW if size of mask is not enough to contain ID + */ +int fromIDtoMask(u8 id, u8 *mask, int size) +{ + if (((int)((id) / 8)) < size) { + logError(0, "%s %s: ID = %d Index = %d Position = %d !\n", tag, + __func__, id, ((int)((id) / 8)), (id % 8)); + mask[((int)((id) / 8))] |= 0x01 << (id % 8); + return OK; + } else { + logError(1, + "%s %s: Bitmask too small! Impossible contain ID = %d %d>=%d! ERROR %08X\n", + tag, __func__, id, ((int)((id) / 8)), size, + ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } +} diff --git a/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.h b/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.h new file mode 100644 index 000000000000..86e20fa94f60 --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_lib/ftsTool.h @@ -0,0 +1,56 @@ +/* + +************************************************************************** +** STMicroelectronics ** +************************************************************************** +** marco.cali@st.com ** +************************************************************************** +* * +* FTS Utility Functions * +* * +************************************************************************** +************************************************************************** + +*/ + +/*! +* \file ftsTool.h +* \brief Contains all the definitions to support common operations inside the driver +*/ + +#ifndef FTS_TOOL_H +#define FTS_TOOL_H + +char *printHex(char *label, u8 *buff, int count, u8 *result); +char *printHex_data(char *label, u8 *buff, int count); +int u8ToU16(u8 *src, u16 *dst); +int u8ToU16_be(u8 *src, u16 *dst); +int u8ToU16n(u8 *src, int src_length, u16 *dst); +int u16ToU8(u16 src, u8 *dst); +int u16ToU8_be(u16 src, u8 *dst); +int u16ToU8n_be(u16 *src, int src_length, u8 *dst); +int u8ToU32(u8 *src, u32 *dst); +int u32ToU8(u32 src, u8 *dst); +int u32ToU8_be(u32 src, u8 *dst); +int u8ToU64_be(u8 *src, u64 *dest, int size); +int u64ToU8_be(u64 src, u8 *dest, int size); +int attempt_function(int(*code)(void), unsigned long wait_before_retry, + int retry_count); +int senseOn(void); +int senseOff(void); +void print_frame_short(char *label, short **matrix, int row, int column); +short **array1dTo2d_short(short *data, int size, int columns); +void print_frame_u16(char *label, u16 **matrix, int row, int column); +u16 **array1dTo2d_u16(u16 *data, int size, int columns); +u8 **array1dTo2d_u8(u8 *data, int size, int columns); +i8 **array1dTo2d_i8(i8 *data, int size, int columns); +void print_frame_u8(char *label, u8 **matrix, int row, int column); +void print_frame_i8(char *label, i8 **matrix, int row, int column); +void print_frame_u32(char *label, u32 **matrix, int row, int column); +void print_frame_int(char *label, int **matrix, int row, int column); +int cleanUp(int enableTouch); +int flushFIFO(void); + +int fromIDtoMask(u8 id, u8 *mask, int size); + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_limits.h b/drivers/input/touchscreen/fts_521/fts_limits.h new file mode 100644 index 000000000000..46e09629061b --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_limits.h @@ -0,0 +1,2109 @@ +/*! +* \file fts_limits.h +* \brief Contains the size and the byte array of the production test limit file which contains thresholds used to test data +*/ + +#ifndef FTS_LIMITS_H +#define FTS_LIMITS_H +/*This is an auto generated header file*/ +/*--->Remember to change the name of the two variables!<---*/ +const uint32_t myArray2_size = 16725; + +/** + * Array containing the production limit file + */ +const uint8_t myArray2[] = { + 0x2A, 0x53, 0x54, 0x4F, 0x50, 0x5F, 0x4F, 0x4E, 0x5F, 0x46, 0x41, 0x49, + 0x4C, 0x2C, 0x31, 0x2C, + 0x31, 0x0A, 0x31, 0x0A, 0x2A, 0x53, 0x54, 0x4F, 0x50, 0x5F, 0x4F, 0x4E, + 0x5F, 0x45, 0x52, 0x52, + 0x4F, 0x52, 0x2C, 0x31, 0x2C, 0x31, 0x0A, 0x31, 0x0A, 0x2A, 0x46, 0x4F, + 0x52, 0x43, 0x45, 0x5F, + 0x46, 0x57, 0x5F, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x2C, 0x31, 0x2C, + 0x31, 0x0A, 0x30, 0x0A, + 0x2A, 0x53, 0x53, 0x5F, 0x49, 0x58, 0x31, 0x5F, 0x46, 0x4F, 0x52, 0x43, + 0x45, 0x5F, 0x57, 0x2C, + 0x31, 0x2C, 0x31, 0x0A, 0x32, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x49, 0x58, + 0x32, 0x5F, 0x46, 0x4F, + 0x52, 0x43, 0x45, 0x5F, 0x57, 0x2C, 0x31, 0x2C, 0x31, 0x0A, 0x31, 0x0A, + 0x2A, 0x53, 0x53, 0x5F, + 0x49, 0x58, 0x31, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x57, 0x2C, + 0x31, 0x2C, 0x31, 0x0A, + 0x32, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x49, 0x58, 0x32, 0x5F, 0x53, 0x45, + 0x4E, 0x53, 0x45, 0x5F, + 0x57, 0x2C, 0x31, 0x2C, 0x31, 0x0A, 0x31, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, + 0x52, 0x41, 0x57, 0x5F, + 0x44, 0x41, 0x54, 0x41, 0x5F, 0x4D, 0x49, 0x4E, 0x5F, 0x4D, 0x41, 0x58, + 0x2C, 0x31, 0x2C, 0x32, + 0x0A, 0x31, 0x30, 0x30, 0x30, 0x2C, 0x31, 0x35, 0x30, 0x30, 0x30, 0x0A, + 0x2A, 0x4D, 0x53, 0x5F, + 0x52, 0x41, 0x57, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x47, 0x41, 0x50, + 0x2C, 0x31, 0x2C, 0x31, + 0x0A, 0x33, 0x30, 0x30, 0x30, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, + 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, 0x58, 0x31, 0x5F, 0x4D, + 0x49, 0x4E, 0x5F, 0x4D, + 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x0A, 0x30, 0x2C, 0x36, 0x33, 0x0A, + 0x2A, 0x4D, 0x53, 0x5F, + 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, + 0x5F, 0x43, 0x58, 0x32, + 0x5F, 0x4D, 0x49, 0x4E, 0x2C, 0x32, 0x32, 0x2C, 0x32, 0x37, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x2A, + 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x5F, + 0x43, 0x58, 0x32, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x32, 0x32, 0x2C, 0x32, + 0x37, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, 0x58, 0x32, 0x5F, 0x41, 0x44, 0x4A, + 0x5F, 0x48, 0x4F, 0x52, + 0x49, 0x5A, 0x4F, 0x4E, 0x54, 0x41, 0x4C, 0x2C, 0x32, 0x32, 0x2C, 0x32, + 0x36, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, + 0x41, 0x43, 0x54, 0x49, + 0x56, 0x45, 0x5F, 0x43, 0x58, 0x32, 0x5F, 0x41, 0x44, 0x4A, 0x5F, 0x56, + 0x45, 0x52, 0x54, 0x49, + 0x43, 0x41, 0x4C, 0x2C, 0x32, 0x31, 0x2C, 0x32, 0x37, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x2A, + 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x5F, + 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, 0x58, 0x5F, 0x4D, 0x49, 0x4E, + 0x2C, 0x32, 0x32, 0x2C, + 0x32, 0x37, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, + 0x4F, 0x55, 0x43, 0x48, + 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, 0x4F, 0x54, 0x41, + 0x4C, 0x5F, 0x43, 0x58, + 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x32, 0x32, 0x2C, 0x32, 0x37, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, + 0x43, 0x54, 0x49, 0x56, + 0x45, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, 0x58, 0x5F, 0x41, + 0x44, 0x4A, 0x5F, 0x48, + 0x4F, 0x52, 0x49, 0x5A, 0x4F, 0x4E, 0x54, 0x41, 0x4C, 0x2C, 0x32, 0x32, + 0x2C, 0x32, 0x36, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, + 0x58, 0x5F, 0x41, 0x44, + 0x4A, 0x5F, 0x56, 0x45, 0x52, 0x54, 0x49, 0x43, 0x41, 0x4C, 0x2C, 0x32, + 0x31, 0x2C, 0x32, 0x37, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, 0x34, + 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x2C, 0x36, 0x34, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x4B, 0x45, + 0x59, 0x5F, 0x52, 0x41, + 0x57, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x4D, 0x49, 0x4E, 0x5F, 0x4D, + 0x41, 0x58, 0x2C, 0x31, + 0x2C, 0x32, 0x0A, 0x30, 0x2C, 0x38, 0x30, 0x30, 0x30, 0x0A, 0x2A, 0x4D, + 0x53, 0x5F, 0x4B, 0x45, + 0x59, 0x5F, 0x43, 0x58, 0x31, 0x5F, 0x4D, 0x49, 0x4E, 0x5F, 0x4D, 0x41, + 0x58, 0x2C, 0x31, 0x2C, + 0x32, 0x0A, 0x30, 0x2C, 0x36, 0x34, 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x4B, + 0x45, 0x59, 0x5F, 0x43, + 0x58, 0x32, 0x5F, 0x4D, 0x49, 0x4E, 0x2C, 0x31, 0x2C, 0x33, 0x0A, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x2A, 0x4D, 0x53, 0x5F, 0x4B, 0x45, 0x59, 0x5F, 0x43, 0x58, 0x32, + 0x5F, 0x4D, 0x41, 0x58, + 0x2C, 0x31, 0x2C, 0x33, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, 0x36, + 0x34, 0x0A, 0x2A, 0x4D, + 0x53, 0x5F, 0x4B, 0x45, 0x59, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, + 0x43, 0x58, 0x5F, 0x4D, + 0x49, 0x4E, 0x2C, 0x31, 0x2C, 0x33, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x0A, 0x2A, 0x4D, 0x53, + 0x5F, 0x4B, 0x45, 0x59, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, + 0x58, 0x5F, 0x4D, 0x41, + 0x58, 0x2C, 0x31, 0x2C, 0x33, 0x0A, 0x36, 0x34, 0x2C, 0x36, 0x34, 0x2C, + 0x36, 0x34, 0x0A, 0x2A, + 0x53, 0x53, 0x5F, 0x52, 0x41, 0x57, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, + 0x46, 0x4F, 0x52, 0x43, + 0x45, 0x5F, 0x4D, 0x49, 0x4E, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, + 0x32, 0x0A, 0x31, 0x30, + 0x30, 0x30, 0x2C, 0x31, 0x35, 0x30, 0x30, 0x30, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x52, 0x41, 0x57, + 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, + 0x47, 0x41, 0x50, 0x2C, + 0x31, 0x2C, 0x31, 0x0A, 0x33, 0x30, 0x30, 0x0A, 0x2A, 0x53, 0x53, 0x5F, + 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, 0x31, + 0x5F, 0x46, 0x4F, 0x52, + 0x43, 0x45, 0x5F, 0x4D, 0x49, 0x4E, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, + 0x2C, 0x32, 0x0A, 0x30, + 0x2C, 0x36, 0x33, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, 0x32, 0x5F, 0x46, 0x4F, 0x52, + 0x43, 0x45, 0x5F, 0x4D, + 0x49, 0x4E, 0x2C, 0x32, 0x32, 0x2C, 0x31, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, 0x32, 0x5F, 0x46, 0x4F, 0x52, + 0x43, 0x45, 0x5F, 0x4D, + 0x41, 0x58, 0x2C, 0x32, 0x32, 0x2C, 0x31, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, + 0x5F, 0x49, 0x58, 0x32, 0x5F, 0x41, 0x44, 0x4A, 0x5F, 0x56, 0x45, 0x52, + 0x54, 0x49, 0x43, 0x41, + 0x4C, 0x2C, 0x32, 0x31, 0x2C, 0x31, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, + 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x2A, + 0x53, 0x53, 0x5F, 0x54, + 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, + 0x54, 0x4F, 0x54, 0x41, + 0x4C, 0x5F, 0x49, 0x58, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, 0x4D, + 0x49, 0x4E, 0x2C, 0x32, + 0x32, 0x2C, 0x31, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, + 0x30, 0x0A, 0x30, 0x0A, + 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, + 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x49, 0x58, 0x5F, 0x46, 0x4F, + 0x52, 0x43, 0x45, 0x5F, + 0x4D, 0x41, 0x58, 0x2C, 0x32, 0x32, 0x2C, 0x31, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, + 0x43, 0x54, 0x49, 0x56, + 0x45, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x49, 0x58, 0x5F, 0x41, + 0x44, 0x4A, 0x5F, 0x56, + 0x45, 0x52, 0x54, 0x49, 0x43, 0x41, 0x4C, 0x2C, 0x32, 0x31, 0x2C, 0x31, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, + 0x43, 0x54, 0x49, 0x56, + 0x45, 0x5F, 0x43, 0x58, 0x31, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, + 0x4D, 0x49, 0x4E, 0x5F, + 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x0A, 0x30, 0x2C, 0x36, 0x33, + 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, + 0x45, 0x5F, 0x43, 0x58, + 0x32, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, 0x4D, 0x49, 0x4E, 0x2C, + 0x32, 0x32, 0x2C, 0x31, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, + 0x45, 0x5F, 0x43, 0x58, + 0x32, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, 0x4D, 0x41, 0x58, 0x2C, + 0x32, 0x32, 0x2C, 0x31, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, + 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, + 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, 0x58, + 0x32, 0x5F, 0x41, 0x44, + 0x4A, 0x5F, 0x56, 0x45, 0x52, 0x54, 0x49, 0x43, 0x41, 0x4C, 0x2C, 0x32, + 0x31, 0x2C, 0x31, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, + 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, + 0x58, 0x5F, 0x46, 0x4F, + 0x52, 0x43, 0x45, 0x5F, 0x4D, 0x49, 0x4E, 0x2C, 0x32, 0x32, 0x2C, 0x31, + 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, + 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x30, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, + 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, 0x4F, + 0x54, 0x41, 0x4C, 0x5F, + 0x43, 0x58, 0x5F, 0x46, 0x4F, 0x52, 0x43, 0x45, 0x5F, 0x4D, 0x41, 0x58, + 0x2C, 0x32, 0x32, 0x2C, + 0x31, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, + 0x4F, 0x54, 0x41, 0x4C, + 0x5F, 0x43, 0x58, 0x5F, 0x41, 0x44, 0x4A, 0x5F, 0x56, 0x45, 0x52, 0x54, + 0x49, 0x43, 0x41, 0x4C, + 0x2C, 0x32, 0x31, 0x2C, 0x31, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, + 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x52, 0x41, + 0x57, 0x5F, 0x44, 0x41, 0x54, 0x41, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, + 0x5F, 0x4D, 0x49, 0x4E, + 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x0A, 0x31, 0x30, 0x30, + 0x30, 0x2C, 0x31, 0x35, + 0x30, 0x30, 0x30, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x52, 0x41, 0x57, 0x5F, + 0x44, 0x41, 0x54, 0x41, + 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x47, 0x41, 0x50, 0x2C, 0x31, + 0x2C, 0x31, 0x0A, 0x33, + 0x30, 0x30, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, + 0x5F, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, 0x31, 0x5F, 0x53, 0x45, 0x4E, 0x53, + 0x45, 0x5F, 0x4D, 0x49, + 0x4E, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x0A, 0x30, 0x2C, + 0x36, 0x33, 0x0A, 0x2A, + 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x5F, + 0x49, 0x58, 0x32, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x49, + 0x4E, 0x2C, 0x31, 0x2C, + 0x32, 0x37, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, + 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, + 0x32, 0x5F, 0x53, 0x45, + 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x37, + 0x0A, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, + 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x49, 0x58, + 0x32, 0x5F, 0x41, 0x44, + 0x4A, 0x5F, 0x48, 0x4F, 0x52, 0x49, 0x5A, 0x4F, 0x4E, 0x54, 0x41, 0x4C, + 0x2C, 0x31, 0x2C, 0x32, + 0x36, 0x0A, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, + 0x4F, 0x54, 0x41, 0x4C, + 0x5F, 0x49, 0x58, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x49, + 0x4E, 0x2C, 0x31, 0x2C, + 0x32, 0x37, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, + 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x2A, 0x53, 0x53, + 0x5F, 0x54, 0x4F, 0x55, + 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, 0x4F, + 0x54, 0x41, 0x4C, 0x5F, + 0x49, 0x58, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x41, 0x58, + 0x2C, 0x31, 0x2C, 0x32, + 0x37, 0x0A, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, + 0x56, 0x45, 0x5F, 0x54, + 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x49, 0x58, 0x5F, 0x41, 0x44, 0x4A, 0x5F, + 0x48, 0x4F, 0x52, 0x49, + 0x5A, 0x4F, 0x4E, 0x54, 0x41, 0x4C, 0x2C, 0x31, 0x2C, 0x32, 0x36, 0x0A, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x2C, + 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, + 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, 0x58, 0x31, 0x5F, 0x53, 0x45, 0x4E, + 0x53, 0x45, 0x5F, 0x4D, + 0x49, 0x4E, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, 0x0A, 0x30, + 0x2C, 0x36, 0x33, 0x0A, + 0x2A, 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, + 0x54, 0x49, 0x56, 0x45, + 0x5F, 0x43, 0x58, 0x32, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, + 0x49, 0x4E, 0x2C, 0x31, + 0x2C, 0x32, 0x37, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, + 0x58, 0x32, 0x5F, 0x53, + 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x41, 0x58, 0x2C, 0x31, 0x2C, 0x32, + 0x37, 0x0A, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, + 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x43, + 0x58, 0x32, 0x5F, 0x41, + 0x44, 0x4A, 0x5F, 0x48, 0x4F, 0x52, 0x49, 0x5A, 0x4F, 0x4E, 0x54, 0x41, + 0x4C, 0x2C, 0x31, 0x2C, + 0x32, 0x36, 0x0A, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x0A, 0x2A, + 0x53, 0x53, 0x5F, 0x54, + 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, + 0x54, 0x4F, 0x54, 0x41, + 0x4C, 0x5F, 0x43, 0x58, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, + 0x49, 0x4E, 0x2C, 0x31, + 0x2C, 0x32, 0x37, 0x0A, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, + 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x2C, 0x30, 0x0A, 0x2A, 0x53, + 0x53, 0x5F, 0x54, 0x4F, + 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5F, 0x54, + 0x4F, 0x54, 0x41, 0x4C, + 0x5F, 0x43, 0x58, 0x5F, 0x53, 0x45, 0x4E, 0x53, 0x45, 0x5F, 0x4D, 0x41, + 0x58, 0x2C, 0x31, 0x2C, + 0x32, 0x37, 0x0A, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, + 0x35, 0x35, 0x0A, 0x2A, + 0x53, 0x53, 0x5F, 0x54, 0x4F, 0x55, 0x43, 0x48, 0x5F, 0x41, 0x43, 0x54, + 0x49, 0x56, 0x45, 0x5F, + 0x54, 0x4F, 0x54, 0x41, 0x4C, 0x5F, 0x43, 0x58, 0x5F, 0x41, 0x44, 0x4A, + 0x5F, 0x48, 0x4F, 0x52, + 0x49, 0x5A, 0x4F, 0x4E, 0x54, 0x41, 0x4C, 0x2C, 0x31, 0x2C, 0x32, 0x36, + 0x0A, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, + 0x2C, 0x32, 0x35, 0x35, 0x0A, +}; + +#endif diff --git a/drivers/input/touchscreen/fts_521/fts_proc.c b/drivers/input/touchscreen/fts_521/fts_proc.c new file mode 100644 index 000000000000..850247991e0e --- /dev/null +++ b/drivers/input/touchscreen/fts_521/fts_proc.c @@ -0,0 +1,2451 @@ +/* + + ************************************************************************** + ** STMicroelectronics ** + ************************************************************************** + ** marco.cali@st.com ** + ************************************************************************** + * * + * Utilities published in /proc/fts * + * * + ************************************************************************** + ************************************************************************** + + */ + +/*! +* \file fts_proc.c +* \brief contains the function and variables needed to publish a file node in the file system which allow to communicate with the IC from userspace +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "fts.h" +#include "fts_lib/ftsCompensation.h" +#include "fts_lib/ftsCore.h" +#include "fts_lib/ftsIO.h" +#include "fts_lib/ftsError.h" +#include "fts_lib/ftsFrame.h" +#include "fts_lib/ftsFlash.h" +#include "fts_lib/ftsTest.h" +#include "fts_lib/ftsTime.h" +#include "fts_lib/ftsTool.h" + +#define DRIVER_TEST_FILE_NODE "driver_test" +#define CHUNK_PROC 1024 +#define DIAGNOSTIC_NUM_FRAME 10 + +/** @defgroup proc_file_code Proc File Node +* @ingroup file_nodes +* The /proc/fts/driver_test file node provide expose the most important API implemented into the driver to execute any possible operation into the IC \n +* Thanks to a series of Operation Codes, each of them, with a different set of parameter, it is possible to select a function to execute\n +* The result of the function is usually returned into the shell as an ASCII hex string where each byte is encoded in two chars.\n +* @{ +*/ + +/*Bus operations*/ +#define CMD_READ 0x00 +#define CMD_WRITE 0x01 +#define CMD_WRITEREAD 0x02 +#define CMD_WRITETHENWRITEREAD 0x03 +#define CMD_WRITEU8UX 0x04 +#define CMD_WRITEREADU8UX 0x05 +#define CMD_WRITEU8UXTHENWRITEU8UX 0x06 +#define CMD_WRITEU8UXTHENWRITEREADU8UX 0x07 +#define CMD_GETLIMITSFILE 0x08 +#define CMD_GETFWFILE 0x09 +#define CMD_VERSION 0x0A +#define CMD_READCONFIG 0x0B + +/*GUI utils byte ver*/ +#define CMD_READ_BYTE 0xF0 +#define CMD_WRITE_BYTE 0xF1 +#define CMD_WRITEREAD_BYTE 0xF2 +#define CMD_WRITETHENWRITEREAD_BYTE 0xF3 +#define CMD_WRITEU8UX_BYTE 0xF4 +#define CMD_WRITEREADU8UX_BYTE 0xF5 +#define CMD_WRITEU8UXTHENWRITEU8UX_BYTE 0xF6 +#define CMD_WRITEU8UXTHENWRITEREADU8UX_BYTE 0xF7 +#define CMD_GETLIMITSFILE_BYTE 0xF8 +#define CMD_GETFWFILE_BYTE 0xF9 +#define CMD_VERSION_BYTE 0xFA +#define CMD_CHANGE_OUTPUT_MODE 0xFF + +/*Core/Tools*/ +#define CMD_POLLFOREVENT 0x11 +#define CMD_SYSTEMRESET 0x12 +#define CMD_CLEANUP 0x13 +#define CMD_POWERCYCLE 0x14 +#define CMD_READSYSINFO 0x15 +#define CMD_FWWRITE 0x16 +#define CMD_INTERRUPT 0x17 + +/*Frame*/ +#define CMD_GETFORCELEN 0x20 +#define CMD_GETSENSELEN 0x21 +#define CMD_GETMSFRAME 0x23 +#define CMD_GETSSFRAME 0x24 + +/*Compensation*/ +#define CMD_REQCOMPDATA 0x30 +#define CMD_READCOMPDATAHEAD 0x31 +#define CMD_READMSCOMPDATA 0x32 +#define CMD_READSSCOMPDATA 0x33 +#define CMD_READTOTMSCOMPDATA 0x35 +#define CMD_READTOTSSCOMPDATA 0x36 + +/*FW Update*/ +#define CMD_GETFWVER 0x40 +#define CMD_FLASHUNLOCK 0x42 +#define CMD_READFWFILE 0x43 +#define CMD_FLASHPROCEDURE 0x44 +#define CMD_FLASHERASEUNLOCK 0x45 +#define CMD_FLASHERASEPAGE 0x46 + +/*MP test*/ +#define CMD_ITOTEST 0x50 +#define CMD_INITTEST 0x51 +#define CMD_MSRAWTEST 0x52 +#define CMD_MSINITDATATEST 0x53 +#define CMD_SSRAWTEST 0x54 +#define CMD_SSINITDATATEST 0x55 +#define CMD_MAINTEST 0x56 +#define CMD_FREELIMIT 0x57 + +/*Diagnostic*/ +#define CMD_DIAGNOSTIC 0x60 + + +#define CMD_CHANGE_SAD 0x70 + +static u8 bin_output; +/** @}*/ + +/** @defgroup scriptless Scriptless Protocol + * @ingroup proc_file_code + * Scriptless Protocol allows ST Software (such as FingerTip Studio etc) to communicate with the IC from an user space. + * This mode gives access to common bus operations (write, read etc) and support additional functionalities. \n + * The protocol is based on exchange of binary messages included between a start and an end byte + * @{ + */ + +#define MESSAGE_START_BYTE 0x7B +#define MESSAGE_END_BYTE 0x7D +#define MESSAGE_MIN_HEADER_SIZE 8 + +/** + * Possible actions that can be requested by an host + */ +typedef enum { + ACTION_WRITE = (u16) 0x0001, + ACTION_READ = (u16) 0x0002, + ACTION_WRITE_READ = (u16) 0x0003, + ACTION_GET_VERSION = (u16) 0x0004, + ACTION_WRITEU8UX = (u16) 0x0011, + ACTION_WRITEREADU8UX = (u16) 0x0012, + ACTION_WRITETHENWRITEREAD = (u16) 0x0013, + ACTION_WRITEU8XTHENWRITEREADU8UX = (u16) 0x0014, + ACTION_WRITEU8UXTHENWRITEU8UX = (u16) 0x0015, + ACTION_GET_FW = (u16) 0x1000, + ACTION_GET_LIMIT = (u16) 0x1001 +} Actions; + +/** + * Struct used to contain info of the message received by the host in Scriptless mode + */ +typedef struct { + u16 msg_size; + u16 counter; + Actions action; + u8 dummy; +} Message; + +/** @}*/ + +extern TestToDo tests; +extern SysInfo systemInfo; + +static int limit; +static int chunk; +static int printed; +static struct proc_dir_entry *fts_dir; +static u8 *driver_test_buff; +char buf_chunk[CHUNK_PROC]; +static Message mess; + +/************************ SEQUENTIAL FILE UTILITIES **************************/ +/** +* This function is called at the beginning of the stream to a sequential file or every time into the sequential were already written PAGE_SIZE bytes and the stream need to restart +* @param s pointer to the sequential file on which print the data +* @param pos pointer to the offset where write the data +* @return NULL if there is no data to print or the pointer to the beginning of the data that need to be printed +*/ +static void *fts_seq_start(struct seq_file *s, loff_t *pos) +{ + logError(0, + "%s %s: Entering start(), pos = %Ld limit = %d printed = %d \n", + tag, __func__, *pos, limit, printed); + + if (driver_test_buff == NULL && *pos == 0) { + logError(1, "%s %s: No data to print!\n", tag, __func__); + driver_test_buff = (u8 *) kmalloc(13 * sizeof(u8), GFP_KERNEL); + + snprintf(driver_test_buff, PAGE_SIZE, "{ %08X }\n", ERROR_OP_NOT_ALLOW); + + limit = strlen(driver_test_buff); + } else { + if (*pos != 0) + *pos += chunk - 1; + + if (*pos >= limit) { + return NULL; + } + } + + chunk = CHUNK_PROC; + if (limit - *pos < CHUNK_PROC) + chunk = limit - *pos; + memset(buf_chunk, 0, CHUNK_PROC); + memcpy(buf_chunk, &driver_test_buff[(int)*pos], chunk); + + return buf_chunk; +} + +/** +* This function actually print a chunk amount of data in the sequential file +* @param s pointer to the sequential file where to print the data +* @param v pointer to the data to print +* @return 0 +*/ +static int fts_seq_show(struct seq_file *s, void *v) +{ + seq_write(s, (u8 *) v, chunk); + printed += chunk; + return 0; +} + +/** +* This function update the pointer and the counters to the next data to be printed +* @param s pointer to the sequential file where to print the data +* @param v pointer to the data to print +* @param pos pointer to the offset where write the next data +* @return NULL if there is no data to print or the pointer to the beginning of the next data that need to be printed +*/ +static void *fts_seq_next(struct seq_file *s, void *v, loff_t *pos) +{ + (*pos) += chunk; + chunk = CHUNK_PROC; + + if (*pos >= limit) + return NULL; + else { + if (limit - *pos < CHUNK_PROC) + chunk = limit - *pos; + } + + memset(buf_chunk, 0, CHUNK_PROC); + memcpy(buf_chunk, &driver_test_buff[(int)*pos], chunk); + return buf_chunk; +} + +/** +* This function is called when there are no more data to print the stream need to be terminated or when PAGE_SIZE data were already written into the sequential file +* @param s pointer to the sequential file where to print the data +* @param v pointer returned by fts_seq_next +*/ +static void fts_seq_stop(struct seq_file *s, void *v) +{ + + if (v) { + /*logError(0, "%s %s: v is %X.\n", tag, __func__, v);*/ + } else { + limit = 0; + chunk = 0; + printed = 0; + if (driver_test_buff != NULL) { + kfree(driver_test_buff); + driver_test_buff = NULL; + + } else { + /*logError(0, "%s %s: driver_test_buff is already null.\n", tag, __func__);*/ + } + } + +} + +/** +* Struct where define and specify the functions which implements the flow for writing on a sequential file +*/ +static struct seq_operations fts_seq_ops = { + .start = fts_seq_start, + .next = fts_seq_next, + .stop = fts_seq_stop, + .show = fts_seq_show +}; + +/** +* This function open a sequential file +* @param inode Inode in the file system that was called and triggered this function +* @param file file associated to the file node +* @return error code, 0 if success +*/ +static int fts_open(struct inode *inode, struct file *file) +{ + return seq_open(file, &fts_seq_ops); +}; + +/*****************************************************************************/ + +/**************************** DRIVER TEST ************************************/ + +/** @addtogroup proc_file_code + * @{ + */ + +/** + * Receive the OP code and the inputs from shell when the file node is called, parse it and then execute the corresponding function + * echo cmd+parameters > /proc/fts/driver_test to execute the select command + * cat /proc/fts/driver_test to obtain the result into the shell \n + * the string returned in the shell is made up as follow: \n + * { = start byte \n + * the answer content and format strictly depend on the cmd executed. In general can be: an HEX string or a byte array (e.g in case of 0xF- commands) \n + * } = end byte \n + */ +static ssize_t fts_driver_test_write(struct file *file, const char __user *buf, + size_t count, loff_t *pos) +{ + int numberParam = 0; + struct fts_ts_info *info = dev_get_drvdata(getDev()); + char *p = NULL; + char pbuf[count]; + char path[100] = { 0 }; + int res = -1, j, index = 0; + int size = 6; + int temp, byte_call = 0; + u16 byteToRead = 0; + u32 fileSize = 0; + u8 *readData = NULL; + u8 *cmd = NULL; + u32 funcToTest[((count + 1) / 3)]; + u64 addr = 0; + MutualSenseFrame frameMS; + SelfSenseFrame frameSS; + + DataHeader dataHead; + MutualSenseData compData; + SelfSenseData comData; + TotMutualSenseData totCompData; + TotSelfSenseData totComData; + + u64 address; + u16 fw_version; + u16 config_id; + + Firmware fw; + LimitFile lim; + + mess.dummy = 0; + mess.action = 0; + mess.msg_size = 0; + + cmd = (u8 *)kzalloc(sizeof(u8) * count, GFP_KERNEL); + if (!cmd) { + res = ERROR_ALLOC; + goto END; + } + if (access_ok(buf, count) < OK + || copy_from_user(pbuf, buf, count) != 0) { + res = ERROR_ALLOC; + goto END; + } + + p = pbuf; + if (count > MESSAGE_MIN_HEADER_SIZE - 1 && p[0] == MESSAGE_START_BYTE) { + logError(0, "%s Enter in Byte Mode! \n", tag); + byte_call = 1; + mess.msg_size = (p[1] << 8) | p[2]; + mess.counter = (p[3] << 8) | p[4]; + mess.action = (p[5] << 8) | p[6]; + logError(0, + "%s Message received: size = %d, counter_id = %d, action = %04X \n", + tag, mess.msg_size, mess.counter, mess.action); + size = MESSAGE_MIN_HEADER_SIZE + 2; + if (count < mess.msg_size || p[count - 2] != MESSAGE_END_BYTE) { + logError(1, + "%s number of byte received or end byte wrong! msg_size = %d != %d, last_byte = %02X != %02X ... ERROR %08X\n", + tag, mess.msg_size, count, p[count - 1], + MESSAGE_END_BYTE, ERROR_OP_NOT_ALLOW); + res = ERROR_OP_NOT_ALLOW; + goto END; + + } else { + numberParam = mess.msg_size - MESSAGE_MIN_HEADER_SIZE + 1; + size = MESSAGE_MIN_HEADER_SIZE + 2; + switch (mess.action) { + case ACTION_READ: + cmd[0] = funcToTest[0] = CMD_READ_BYTE; + break; + + case ACTION_WRITE: + cmd[0] = funcToTest[0] = CMD_WRITE_BYTE; + break; + + case ACTION_WRITE_READ: + cmd[0] = funcToTest[0] = CMD_WRITEREAD_BYTE; + break; + + case ACTION_GET_VERSION: + cmd[0] = funcToTest[0] = CMD_VERSION_BYTE; + break; + + case ACTION_WRITETHENWRITEREAD: + cmd[0] = funcToTest[0] = + CMD_WRITETHENWRITEREAD_BYTE; + break; + + case ACTION_WRITEU8UX: + cmd[0] = funcToTest[0] = CMD_WRITEU8UX_BYTE; + break; + + case ACTION_WRITEREADU8UX: + cmd[0] = funcToTest[0] = CMD_WRITEREADU8UX_BYTE; + break; + + case ACTION_WRITEU8UXTHENWRITEU8UX: + cmd[0] = funcToTest[0] = + CMD_WRITEU8UXTHENWRITEU8UX_BYTE; + break; + + case ACTION_WRITEU8XTHENWRITEREADU8UX: + cmd[0] = funcToTest[0] = + CMD_WRITEU8UXTHENWRITEREADU8UX_BYTE; + break; + + case ACTION_GET_FW: + cmd[0] = funcToTest[0] = CMD_GETFWFILE_BYTE; + break; + + case ACTION_GET_LIMIT: + cmd[0] = funcToTest[0] = CMD_GETLIMITSFILE_BYTE; + break; + + default: + logError(1, + "%s Invalid Action = %d ... ERROR %08X\n", + tag, mess.action, ERROR_OP_NOT_ALLOW); + res = ERROR_OP_NOT_ALLOW; + goto END; + } + + if (numberParam - 1 != 0) + memcpy(&cmd[1], &p[7], numberParam - 1); + } + } else { + if (((count + 1) / 3) >= 1) { + sscanf(p, "%02X ", &funcToTest[0]); + p += 3; + cmd[0] = (u8) funcToTest[0]; + numberParam = 1; + } else { + res = ERROR_OP_NOT_ALLOW; + goto END; + } + + logError(1, "%s functionToTest[0] = %02X cmd[0]= %02X\n", tag, + funcToTest[0], cmd[0]); + switch (funcToTest[0]) { + case CMD_GETFWFILE: + case CMD_GETLIMITSFILE: + if (count - 2 - 1 > 1) { + numberParam = 2; + sscanf(p, "%100s", path); + } + break; + + default: + for (; numberParam < (count + 1) / 3; numberParam++) { + sscanf(p, "%02X ", &funcToTest[numberParam]); + p += 3; + cmd[numberParam] = (u8) funcToTest[numberParam]; + logError(1, + "%s functionToTest[%d] = %02X cmd[%d]= %02X\n", + tag, numberParam, + funcToTest[numberParam], numberParam, + cmd[numberParam]); + } + } + + } + + fw.data = NULL; + lim.data = NULL; + + logError(1, "%s Number of Parameters = %d \n", tag, numberParam); + + if (numberParam >= 1) { + switch (funcToTest[0]) { + case CMD_VERSION_BYTE: + logError(0, "%s %s: Get Version Byte \n", tag, __func__, + res); + byteToRead = 2; + mess.dummy = 0; + readData = + (u8 *) kmalloc(byteToRead * sizeof(u8), GFP_KERNEL); + size += byteToRead; + if (readData != NULL) { + readData[0] = (u8) (FTS_TS_DRV_VER >> 24); + readData[1] = (u8) (FTS_TS_DRV_VER >> 16); + res = OK; + logError(0, "%s %s: Version = %02X%02X \n", tag, + __func__, readData[0], readData[1]); + } else { + res = ERROR_ALLOC; + logError(1, + "%s %s: Impossible allocate memory... ERROR %08X \n", + tag, __func__, res); + } + break; + + case CMD_VERSION: + byteToRead = 2 * sizeof(u32); + mess.dummy = 0; + readData = + (u8 *) kmalloc(byteToRead * sizeof(u8), GFP_KERNEL); + u32ToU8_be(FTS_TS_DRV_VER, readData); + fileSize = 0; +#ifdef FW_H_FILE + fileSize |= 0x00010000; +#endif + +#ifdef LIMITS_H_FILE + fileSize |= 0x00020000; +#endif + +#ifdef USE_ONE_FILE_NODE + fileSize |= 0x00040000; +#endif + +#ifdef FW_UPDATE_ON_PROBE + fileSize |= 0x00080000; +#endif + +#ifdef PRE_SAVED_METHOD + fileSize |= 0x00100000; +#endif + +#ifdef USE_GESTURE_MASK + fileSize |= 0x00100000; +#endif + +#ifdef I2C_INTERFACE + fileSize |= 0x00200000; +#endif + +#ifdef PHONE_KEY + fileSize |= 0x00000100; +#endif + +#ifdef GESTURE_MODE + fromIDtoMask(FEAT_SEL_GESTURE, (u8 *)&fileSize, 4); +#endif + +#ifdef GRIP_MODE + fromIDtoMask(FEAT_SEL_GRIP, (u8 *)&fileSize, 4); +#endif + +#ifdef CHARGER_MODE + fromIDtoMask(FEAT_SEL_CHARGER, (u8 *)&fileSize, 4); +#endif + +#ifdef GLOVE_MODE + fromIDtoMask(FEAT_SEL_GLOVE, (u8 *)&fileSize, 4); +#endif + +#ifdef COVER_MODE + fromIDtoMask(FEAT_SEL_COVER, (u8 *)&fileSize, 4); +#endif + +#ifdef STYLUS_MODE + fromIDtoMask(FEAT_SEL_STYLUS, (u8 *)&fileSize, 4); +#endif + + u32ToU8_be(fileSize, &readData[4]); + res = OK; + size += (byteToRead * sizeof(u8)); + break; + + case CMD_WRITEREAD: + case CMD_WRITEREAD_BYTE: + if (numberParam >= 5) { + temp = numberParam - 4; + if (cmd[numberParam - 1] == 0) { + mess.dummy = 0; + } else + mess.dummy = 1; + + u8ToU16_be(&cmd[numberParam - 3], &byteToRead); + logError(0, "%s bytesToRead = %d \n", tag, + byteToRead + mess.dummy); + + readData = + (u8 *) kmalloc((byteToRead + mess.dummy) * + sizeof(u8), GFP_KERNEL); + res = + fts_writeRead_dma_safe(&cmd[1], temp, readData, + byteToRead + mess.dummy); + size += (byteToRead * sizeof(u8)); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITE: + case CMD_WRITE_BYTE: + if (numberParam >= 2) { + temp = numberParam - 1; + res = fts_write_dma_safe(&cmd[1], temp); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READ: + case CMD_READ_BYTE: + if (numberParam >= 3) { + if (numberParam == 3 + || (numberParam == 4 + && cmd[numberParam - 1] == 0)) { + mess.dummy = 0; + } else + mess.dummy = 1; + u8ToU16_be(&cmd[1], &byteToRead); + readData = + (u8 *) kmalloc((byteToRead + mess.dummy) * + sizeof(u8), GFP_KERNEL); + res = + fts_read_dma_safe(readData, byteToRead + mess.dummy); + size += (byteToRead * sizeof(u8)); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITETHENWRITEREAD: + case CMD_WRITETHENWRITEREAD_BYTE: + if (numberParam >= 6) { + u8ToU16_be(&cmd[numberParam - 2], &byteToRead); + readData = + (u8 *) kmalloc(byteToRead * sizeof(u8), + GFP_KERNEL); + res = + fts_writeThenWriteRead(&cmd[3], cmd[1], + &cmd[3 + + (int)cmd[1]], + cmd[2], readData, + byteToRead); + size += (byteToRead * sizeof(u8)); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITEU8UX: + case CMD_WRITEU8UX_BYTE: + if (numberParam >= 4) { + if (cmd[2] <= sizeof(u64)) { + u8ToU64_be(&cmd[3], &addr, cmd[2]); + logError(0, "%s addr = %016X %ld \n", + tag, addr, addr); + res = + fts_writeU8UX(cmd[1], cmd[2], addr, + &cmd[3 + cmd[2]], + (numberParam - + cmd[2] - 3)); + } else { + logError(1, "%s Wrong address size!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITEREADU8UX: + case CMD_WRITEREADU8UX_BYTE: + if (numberParam >= 6) { + + if (cmd[2] <= sizeof(u64)) { + + u8ToU64_be(&cmd[3], &addr, cmd[2]); + u8ToU16_be(&cmd[numberParam - 3], + &byteToRead); + readData = + (u8 *) kmalloc(byteToRead * + sizeof(u8), + GFP_KERNEL); + logError(0, + "%s addr = %016X byteToRead = %d \n", + tag, addr, byteToRead); + res = + fts_writeReadU8UX(cmd[1], cmd[2], + addr, readData, + byteToRead, + cmd[numberParam - + 1]); + size += (byteToRead * sizeof(u8)); + + } else { + logError(1, "%s Wrong address size!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITEU8UXTHENWRITEU8UX: + case CMD_WRITEU8UXTHENWRITEU8UX_BYTE: + if (numberParam >= 6) { + if ((cmd[2] + cmd[4]) <= sizeof(u64)) { + u8ToU64_be(&cmd[5], &addr, + cmd[2] + cmd[4]); + logError(0, "%s addr = %016X %ld \n", + tag, addr, addr); + res = + fts_writeU8UXthenWriteU8UX(cmd[1], + cmd[2], + cmd[3], + cmd[4], + addr, + &cmd[5 + + cmd + [2] + + + cmd + [4]], + (numberParam + - + cmd[2] - + cmd[4] - + 5)); + } else { + logError(1, "%s Wrong address size! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_WRITEU8UXTHENWRITEREADU8UX: + case CMD_WRITEU8UXTHENWRITEREADU8UX_BYTE: + if (numberParam >= 8) { + if ((cmd[2] + cmd[4]) <= sizeof(u64)) { + u8ToU64_be(&cmd[5], &addr, + cmd[2] + cmd[4]); + logError(1, + "%s %s: cmd[5] = %02X, addr = %016X \n", + tag, __func__, cmd[5], addr); + u8ToU16_be(&cmd[numberParam - 3], + &byteToRead); + readData = + (u8 *) kmalloc(byteToRead * + sizeof(u8), + GFP_KERNEL); + res = + fts_writeU8UXthenWriteReadU8UX(cmd + [1], + cmd + [2], + cmd + [3], + cmd + [4], + addr, + readData, + byteToRead, + cmd + [numberParam + - + 1]); + size += (byteToRead * sizeof(u8)); + } else { + logError(1, + "%s Wrong total address size! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + break; + + case CMD_CHANGE_OUTPUT_MODE: + if (numberParam >= 2) { + bin_output = cmd[1]; + logError(0, + "%s Setting Scriptless output mode: %d \n", + tag, bin_output); + res = OK; + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_FWWRITE: + if (numberParam >= 3) { + if (numberParam >= 2) { + temp = numberParam - 1; + res = fts_writeFwCmd(&cmd[1], temp); + } else { + logError(1, "%s Wrong parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_INTERRUPT: + if (numberParam >= 2) { + if (cmd[1] == 1) + res = fts_enableInterrupt(); + else + res = fts_disableInterrupt(); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READCONFIG: + if (numberParam == 5) { + byteToRead = + ((funcToTest[3] << 8) | funcToTest[4]); + readData = + (u8 *) kmalloc(byteToRead * sizeof(u8), + GFP_KERNEL); + res = + readConfig((u16) + ((((u8) funcToTest[1] & 0x00FF) + << 8) + + ((u8) funcToTest[2] & 0x00FF)), + readData, byteToRead); + size += (byteToRead * sizeof(u8)); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_POLLFOREVENT: + if (numberParam >= 5) { + temp = (int)funcToTest[1]; + if (numberParam == 5 + (temp - 1) && temp != 0) { + readData = + (u8 *) kmalloc(FIFO_EVENT_SIZE * + sizeof(u8), + GFP_KERNEL); + res = + pollForEvent((int *)&funcToTest[2], + temp, readData, + ((funcToTest[temp + 2] + & 0x00FF) << 8) + + (funcToTest[temp + 3] & + 0x00FF)); + if (res >= OK) + res = OK; + size += (FIFO_EVENT_SIZE * sizeof(u8)); + byteToRead = FIFO_EVENT_SIZE; + } else { + logError(1, "%s Wrong parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_SYSTEMRESET: + res = fts_system_reset(); + + break; + + case CMD_READSYSINFO: + if (numberParam == 2) { + res = readSysInfo(funcToTest[1]); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + break; + + case CMD_CLEANUP: + if (numberParam == 2) { + res = cleanUp(funcToTest[1]); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + break; + + case CMD_GETFORCELEN: + temp = getForceLen(); + if (temp < OK) + res = temp; + else { + size += (1 * sizeof(u8)); + res = OK; + } + break; + + case CMD_GETSENSELEN: + temp = getSenseLen(); + if (temp < OK) + res = temp; + else { + size += (1 * sizeof(u8)); + res = OK; + } + break; + + case CMD_GETMSFRAME: + if (numberParam == 2) { + logError(0, "%s Get 1 MS Frame \n", tag); + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + flushFIFO(); + res = + getMSFrame3((MSFrameType) cmd[1], &frameMS); + if (res < 0) { + logError(0, + "%s Error while taking the MS frame... ERROR %08X \n", + tag, res); + + } else { + logError(0, + "%s The frame size is %d words\n", + tag, res); + size += (res * sizeof(short) + 2); + /* set res to OK because if getMSFrame is + successful res = number of words read + */ + res = OK; + print_frame_short("MS frame =", + array1dTo2d_short + (frameMS.node_data, + frameMS. + node_data_size, + frameMS.header. + sense_node), + frameMS.header. + force_node, + frameMS.header. + sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + /*read self raw */ + case CMD_GETSSFRAME: + if (numberParam == 2) { + logError(0, "%s Get 1 SS Frame \n", tag); + flushFIFO(); + setScanMode(SCAN_MODE_ACTIVE, 0x01); + mdelay(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + mdelay(WAIT_AFTER_SENSEOFF); + res = + getSSFrame3((SSFrameType) cmd[1], &frameSS); + + if (res < OK) { + logError(0, + "%s Error while taking the SS frame... ERROR %08X \n", + tag, res); + + } else { + logError(0, + "%s The frame size is %d words\n", + tag, res); + size += (res * sizeof(short) + 2); + /* set res to OK because if getMSFrame is + successful res = number of words read + */ + res = OK; + print_frame_short("SS force frame =", + array1dTo2d_short + (frameSS.force_data, + frameSS.header. + force_node, 1), + frameSS.header. + force_node, 1); + print_frame_short("SS sense frame =", + array1dTo2d_short + (frameSS.sense_data, + frameSS.header. + sense_node, + frameSS.header. + sense_node), 1, + frameSS.header. + sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_REQCOMPDATA: + if (numberParam == 2) { + logError(0, + "%s Requesting Compensation Data \n", + tag); + res = requestCompensationData(cmd[1]); + + if (res < OK) { + logError(0, + "%s Error requesting compensation data ERROR %08X \n", + tag, res); + } else { + logError(0, + "%s Requesting Compensation Data Finished! \n", + tag); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READCOMPDATAHEAD: + if (numberParam == 2) { + logError(0, + "%s Requesting Compensation Data \n", + tag); + res = requestCompensationData(cmd[1]); + if (res < OK) { + logError(0, + "%s Error requesting compensation data ERROR %08X \n", + tag, res); + } else { + logError(0, + "%s Requesting Compensation Data Finished! \n", + tag); + res = + readCompensationDataHeader((u8) + funcToTest + [1], + &dataHead, + &address); + if (res < OK) { + logError(0, + "%s Read Compensation Data Header ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s Read Compensation Data Header OK!\n", + tag); + size += (1 * sizeof(u8)); + } + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READMSCOMPDATA: + if (numberParam == 2) { + logError(0, "%s Get MS Compensation Data \n", + tag); + res = + readMutualSenseCompensationData(cmd[1], + &compData); + + if (res < OK) { + logError(0, + "%s Error reading MS compensation data ERROR %08X \n", + tag, res); + } else { + logError(0, + "%s MS Compensation Data Reading Finished! \n", + tag); + size = + ((compData.node_data_size + + 10) * sizeof(i8)); + print_frame_i8("MS Data (Cx2) =", + array1dTo2d_i8(compData. + node_data, + compData. + node_data_size, + compData. + header. + sense_node), + compData.header. + force_node, + compData.header. + sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READSSCOMPDATA: + if (numberParam == 2) { + logError(0, "%s Get SS Compensation Data... \n", + tag); + res = + readSelfSenseCompensationData(cmd[1], + &comData); + if (res < OK) { + logError(0, + "%s Error reading SS compensation data ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s SS Compensation Data Reading Finished! \n", + tag); + size = + ((comData.header.force_node + + comData.header.sense_node) * 2 + + 13) * sizeof(i8); + print_frame_i8("SS Data Ix2_fm = ", + array1dTo2d_i8(comData. + ix2_fm, + comData. + header. + force_node, + comData. + header. + force_node), + 1, + comData.header. + force_node); + print_frame_i8("SS Data Cx2_fm = ", + array1dTo2d_i8(comData. + cx2_fm, + comData. + header. + force_node, + comData. + header. + force_node), + 1, + comData.header. + force_node); + print_frame_i8("SS Data Ix2_sn = ", + array1dTo2d_i8(comData. + ix2_sn, + comData. + header. + sense_node, + comData. + header. + sense_node), + 1, + comData.header. + sense_node); + print_frame_i8("SS Data Cx2_sn = ", + array1dTo2d_i8(comData. + cx2_sn, + comData. + header. + sense_node, + comData. + header. + sense_node), + 1, + comData.header. + sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READTOTMSCOMPDATA: + if (numberParam == 2) { + logError(0, + "%s Get TOT MS Compensation Data \n", + tag); + res = + readTotMutualSenseCompensationData(cmd[1], + &totCompData); + + if (res < OK) { + logError(0, + "%s Error reading TOT MS compensation data ERROR %08X \n", + tag, res); + } else { + logError(0, + "%s TOT MS Compensation Data Reading Finished! \n", + tag); + size = + (totCompData.node_data_size * + sizeof(short) + 9); + print_frame_short("MS Data (TOT Cx) =", + array1dTo2d_short + (totCompData. + node_data, + totCompData. + node_data_size, + totCompData.header. + sense_node), + totCompData.header. + force_node, + totCompData.header. + sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_READTOTSSCOMPDATA: + if (numberParam == 2) { + logError(0, + "%s Get TOT SS Compensation Data... \n", + tag); + res = + readTotSelfSenseCompensationData(cmd[1], + &totComData); + if (res < OK) { + logError(0, + "%s Error reading TOT SS compensation data ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s TOT SS Compensation Data Reading Finished! \n", + tag); + size = + ((totComData.header.force_node + + totComData.header.sense_node) * + 2 * sizeof(short) + 9); + print_frame_u16("SS Data TOT Ix_fm = ", + array1dTo2d_u16 + (totComData.ix_fm, + totComData.header. + force_node, + totComData.header. + force_node), 1, + totComData.header. + force_node); + print_frame_short + ("SS Data TOT Cx_fm = ", + array1dTo2d_short(totComData.cx_fm, + totComData. + header. + force_node, + totComData. + header. + force_node), 1, + totComData.header.force_node); + print_frame_u16("SS Data TOT Ix_sn = ", + array1dTo2d_u16 + (totComData.ix_sn, + totComData.header. + sense_node, + totComData.header. + sense_node), 1, + totComData.header. + sense_node); + print_frame_short + ("SS Data TOT Cx_sn = ", + array1dTo2d_short(totComData.cx_sn, + totComData. + header. + sense_node, + totComData. + header. + sense_node), 1, + totComData.header.sense_node); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETFWVER: + res = getFirmwareVersion(&fw_version, &config_id); + if (res < OK) { + logError(1, + "%s Error reading firmware version and config id ERROR %02X\n", + tag, res); + } else { + logError(0, + "%s getFirmwareVersion Finished! \n", + tag); + size += (4) * sizeof(u8); + } + break; + + case CMD_FLASHUNLOCK: + res = flash_unlock(); + if (res < OK) { + logError(1, + "%s Impossible Unlock Flash ERROR %08X\n", + tag, res); + } else { + logError(0, "%s Flash Unlock OK!\n", tag); + } + break; + + case CMD_READFWFILE: + if (numberParam == 2) { + logError(0, "%s Reading FW File... \n", tag); + res = + readFwFile(PATH_FILE_FW, &fw, + funcToTest[1]); + if (res < OK) { + logError(0, + "%s Error reading FW File ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s Read FW File Finished! \n", + tag); + } + kfree(fw.data); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_FLASHPROCEDURE: + if (numberParam == 3) { + logError(0, + "%s Starting Flashing Procedure... \n", + tag); + res = + flashProcedure(PATH_FILE_FW, cmd[1], + cmd[2]); + if (res < OK) { + logError(0, + "%s Error during flash procedure ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s Flash Procedure Finished! \n", + tag); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_FLASHERASEUNLOCK: + res = flash_erase_unlock(); + if (res < OK) { + logError(0, + "%s Error during flash erase unlock... ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s Flash Erase Unlock Finished! \n", + tag); + } + break; + + case CMD_FLASHERASEPAGE: + if (numberParam == 2) { + logError(0, + "%s Starting Flashing Page Erase... \n", + tag); + res = flash_erase_page_by_page(cmd[1]); + if (res < OK) { + logError(0, + "%s Error during flash page erase... ERROR %08X\n", + tag, res); + } else { + logError(0, + "%s Flash Page Erase Finished! \n", + tag); + } + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + /*ITO TEST */ + case CMD_ITOTEST: + res = production_test_ito(LIMITS_FILE, &tests); + break; + + /*Initialization */ + case CMD_INITTEST: + if (numberParam == 2) { + res = production_test_initialization(cmd[1]); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_MSRAWTEST: + if (numberParam == 2) + res = + production_test_ms_raw(LIMITS_FILE, cmd[1], + &tests); + else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_MSINITDATATEST: + if (numberParam == 2) + res = + production_test_ms_cx(LIMITS_FILE, cmd[1], + &tests); + else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_SSRAWTEST: + if (numberParam == 2) + res = + production_test_ss_raw(LIMITS_FILE, cmd[1], + &tests); + else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_SSINITDATATEST: + if (numberParam == 2) + res = + production_test_ss_ix_cx(LIMITS_FILE, + cmd[1], &tests); + else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + /*PRODUCTION TEST */ + case CMD_MAINTEST: + if (numberParam == 3) + res = + production_test_main(LIMITS_FILE, cmd[1], + cmd[2], &tests); + else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_FREELIMIT: + res = freeCurrentLimitsFile(); + break; + + case CMD_POWERCYCLE: + res = fts_chip_powercycle(info); + break; + + case CMD_GETLIMITSFILE: + if (numberParam >= 1) { + lim.data = NULL; + lim.size = 0; + if (numberParam == 1) + res = getLimitsFile(LIMITS_FILE, &lim); + else + res = getLimitsFile(path, &lim); + readData = lim.data; + fileSize = lim.size; + size += (fileSize * sizeof(u8)); + if (byte_call == 1) + size += sizeof(u32); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETLIMITSFILE_BYTE: + if (numberParam >= 3) { + lim.data = NULL; + lim.size = 0; + + u8ToU16_be(&cmd[1], &byteToRead); + addr = ((u64) byteToRead) * 4; + + res = getLimitsFile(LIMITS_FILE, &lim); + + readData = lim.data; + fileSize = lim.size; + + if (fileSize > addr) { + logError(1, + "%s Limits dimension expected by Host is less than actual size: expected = %d, real = %d \n", + tag, byteToRead, fileSize); + res = ERROR_OP_NOT_ALLOW; + } + + size += (addr * sizeof(u8)); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETFWFILE: + if (numberParam >= 1) { + + if (numberParam == 1) + res = + getFWdata(PATH_FILE_FW, &readData, + &fileSize); + else + res = + getFWdata(path, &readData, + &fileSize); + + size += (fileSize * sizeof(u8)); + if (byte_call == 1) + size += sizeof(u32); + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETFWFILE_BYTE: + if (numberParam == 3) { + + u8ToU16_be(&cmd[1], &byteToRead); + addr = ((u64) byteToRead) * 4; + + res = + getFWdata(PATH_FILE_FW, &readData, + &fileSize); + if (fileSize > addr) { + logError(1, + "%s FW dimension expected by Host is less than actual size: expected = %d, real = %d \n", + tag, byteToRead, fileSize); + res = ERROR_OP_NOT_ALLOW; + } + + size += (addr * sizeof(u8)); + + } else { + logError(1, "%s Wrong number of parameters! \n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; +/* +* finish all the diagnostic command with a goto ERROR in order to skip the modification on driver_test_buff +* remember to set properly the limit and printed variables in order to make the seq_file logic to work +*/ + case CMD_DIAGNOSTIC: + index = 0; + size = 0; + fileSize = 256 * 1024 * sizeof(char); + driver_test_buff = (u8 *) kzalloc(fileSize, GFP_KERNEL); + readData = + (u8 *) + kmalloc((ERROR_DUMP_ROW_SIZE * + ERROR_DUMP_COL_SIZE) * sizeof(u8), + GFP_KERNEL); + if (driver_test_buff == NULL || readData == NULL) { + res = ERROR_ALLOC; + logError(1, + "%s Impossible allocate memory for buffers! ERROR %08X! \n", + tag, res); + goto END; + } + j = snprintf(&driver_test_buff[index], fileSize - index, + "DIAGNOSTIC TEST:\n1) I2C Test: "); + index += j; + + res = + fts_writeReadU8UX(FTS_CMD_HW_REG_R, + ADDR_SIZE_HW_REG, ADDR_DCHIP_ID, + (u8 *)&temp, 2, DUMMY_HW_REG); + if (res < OK) { + logError(1, + "%s Error during I2C test: ERROR %08X! \n", + tag, res); + j = snprintf(&driver_test_buff[index], + fileSize - index, "ERROR %08X \n", + res); + index += j; + res = ERROR_OP_NOT_ALLOW; + goto END_DIAGNOSTIC; + } + + temp &= 0xFFFF; + logError(1, "%s Chip ID = %04X! \n", tag, temp); + j = snprintf(&driver_test_buff[index], fileSize - index, + "DATA = %04X, expected = %02X%02X \n", + temp, DCHIP_ID_1, DCHIP_ID_0); + index += j; + if (temp != ((DCHIP_ID_1 << 8) | DCHIP_ID_0)) { + logError(1, + "%s Wrong CHIP ID, Diagnostic failed! \n", + tag, res); + res = ERROR_OP_NOT_ALLOW; + goto END_DIAGNOSTIC; + } + + j = snprintf(&driver_test_buff[index], fileSize - index, + "Present Driver Mode: %08X \n", + info->mode); + index += j; + + j = snprintf(&driver_test_buff[index], fileSize - index, + "2) FW running: Sensing On..."); + index += j; + logError(1, "%s Sensing On! \n", tag, temp); + readData[0] = FTS_CMD_SCAN_MODE; + readData[1] = SCAN_MODE_ACTIVE; + readData[2] = 0x1; + fts_write(readData, 3); + res = checkEcho(readData, 3); + if (res < OK) { + logError(1, + "%s No Echo received.. ERROR %08X !\n", + tag, res); + j = snprintf(&driver_test_buff[index], + fileSize - index, + "No echo found... ERROR %08X!\n", + res); + index += j; + goto END_DIAGNOSTIC; + } else { + logError(1, "%s Echo FOUND... OK!\n", tag, res); + j = snprintf(&driver_test_buff[index], + fileSize - index, + "Echo FOUND... OK!\n"); + index += j; + } + + logError(1, "%s Reading Frames...! \n", tag, temp); + j = snprintf(&driver_test_buff[index], fileSize - index, + "3) Read Frames: \n"); + index += j; + for (temp = 0; temp < DIAGNOSTIC_NUM_FRAME; temp++) { + logError(1, "%s Iteration n. %d...\n", tag, + temp + 1); + j = snprintf(&driver_test_buff[index], + fileSize - index, + "Iteration n. %d...\n", temp + 1); + index += j; + for (addr = 0; addr < 3; addr++) { + switch (addr) { + case 0: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "MS RAW FRAME ="); + index += j; + res |= + getMSFrame3(MS_RAW, + &frameMS); + break; + case 2: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "MS STRENGTH FRAME ="); + index += j; + res |= + getMSFrame3(MS_STRENGTH, + &frameMS); + break; + case 1: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "MS BASELINE FRAME ="); + index += j; + res |= + getMSFrame3(MS_BASELINE, + &frameMS); + break; + } + if (res < OK) { + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "No data! ERROR %08X \n", + res); + index += j; + } else { + for (address = 0; + address < + frameMS.node_data_size; + address++) { + if (address % + frameMS.header. + sense_node == 0) { + j = snprintf + (&driver_test_buff + [index], + fileSize - + index, + "\n"); + index += j; + } + j = snprintf + (&driver_test_buff + [index], + fileSize - index, + "%5d, ", + frameMS. + node_data + [address]); + index += j; + } + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "\n"); + index += j; + } + if (frameMS.node_data != NULL) + kfree(frameMS.node_data); + } + for (addr = 0; addr < 3; addr++) { + switch (addr) { + case 0: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "SS RAW FRAME = \n"); + index += j; + res |= + getSSFrame3(SS_RAW, + &frameSS); + break; + case 2: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "SS STRENGTH FRAME = \n"); + index += j; + res |= + getSSFrame3(SS_STRENGTH, + &frameSS); + break; + case 1: + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "SS BASELINE FRAME = \n"); + index += j; + res |= + getSSFrame3(SS_BASELINE, + &frameSS); + break; + } + if (res < OK) { + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "No data! ERROR %08X \n", + res); + index += j; + } else { + for (address = 0; + address < + frameSS.header.force_node; + address++) { + j = snprintf + (&driver_test_buff + [index], + fileSize - index, + "%d\n", + frameSS. + force_data + [address]); + + index += j; + } + for (address = 0; + address < + frameSS.header.sense_node; + address++) { + j = snprintf + (&driver_test_buff + [index], + fileSize - index, + "%d, ", + frameSS. + sense_data + [address]); + + index += j; + } + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "\n"); + index += j; + } + if (frameSS.force_data != NULL) + kfree(frameSS.force_data); + if (frameSS.sense_data != NULL) + kfree(frameSS.sense_data); + } + } + + logError(1, "%s Reading error info... \n", tag, temp); + j = snprintf(&driver_test_buff[index], fileSize - index, + "4) FW INFO DUMP: "); + index += j; + temp = dumpErrorInfo(readData, ERROR_DUMP_ROW_SIZE * ERROR_DUMP_COL_SIZE); + if (temp < OK) { + logError(1, + "%s Error during dump: ERROR %08X! \n", + tag, res); + j = snprintf(&driver_test_buff[index], + fileSize - index, "ERROR %08X \n", + temp); + index += j; + } else { + logError(1, "%s DUMP OK! \n", tag, res); + for (temp = 0; + temp < + ERROR_DUMP_ROW_SIZE * ERROR_DUMP_COL_SIZE; + temp++) { + if (temp % ERROR_DUMP_COL_SIZE == 0) { + j = snprintf(&driver_test_buff + [index], + fileSize - index, + "\n%2d - ", + temp / + ERROR_DUMP_COL_SIZE); + index += j; + } + j = snprintf(&driver_test_buff[index], + fileSize - index, "%02X ", + readData[temp]); + index += j; + } + } + res |= temp; + +END_DIAGNOSTIC: + if (res < OK) { + j = snprintf(&driver_test_buff[index], + fileSize - index, + "\nRESULT = FAIL \n"); + index += j; + } else { + j = snprintf(&driver_test_buff[index], + fileSize - index, + "\nRESULT = FINISHED \n"); + index += j; + } + limit = index; + printed = 0; + goto ERROR; + break; + case CMD_CHANGE_SAD: + res = changeSAD(cmd[1]); + break; + + default: + logError(1, "%s COMMAND ID NOT VALID!!! \n", tag); + res = ERROR_OP_NOT_ALLOW; + break; + } + + } else { + logError(1, + "%s NO COMMAND SPECIFIED!!! do: 'echo [cmd_code] [args] > stm_fts_cmd' before looking for result!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + + } + +END: + if (driver_test_buff != NULL) { + logError(1, + "%s Consecutive echo on the file node, free the buffer with the previous result\n", + tag); + kfree(driver_test_buff); + } + + if (byte_call == 0) { + size *= 2; + size += 2; + } else { + if (bin_output != 1) { + size *= 2; + size -= 1; + } else + size += 1; + } + + logError(0, "%s Size = %d\n", tag, size); + driver_test_buff = (u8 *) kzalloc(size, GFP_KERNEL); + logError(0, "%s Finish to allocate memory! \n", tag); + if (driver_test_buff == NULL) { + logError(0, + "%s Unable to allocate driver_test_buff! ERROR %08X\n", + tag, ERROR_ALLOC); + goto ERROR; + } + + if (byte_call == 0) { + index = 0; + snprintf(&driver_test_buff[index], 3, "{ "); + index += 2; + snprintf(&driver_test_buff[index], 9, "%08X", res); + + index += 8; + if (res >= OK) { + /*all the other cases are already fine printing only the res. */ + switch (funcToTest[0]) { + case CMD_VERSION: + case CMD_READ: + case CMD_WRITEREAD: + case CMD_WRITETHENWRITEREAD: + case CMD_WRITEREADU8UX: + case CMD_WRITEU8UXTHENWRITEREADU8UX: + case CMD_READCONFIG: + case CMD_POLLFOREVENT: + if (mess.dummy == 1) + j = 1; + else + j = 0; + for (; j < byteToRead + mess.dummy; j++) { + snprintf(&driver_test_buff[index], 3, "%02X", readData[j]); + index += 2; + } + break; + case CMD_GETFWFILE: + case CMD_GETLIMITSFILE: + logError(0, "%s Start To parse! \n", tag); + for (j = 0; j < fileSize; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", readData[j]); + index += 2; + } + logError(0, "%s Finish to parse! \n", tag); + break; + case CMD_GETFORCELEN: + case CMD_GETSENSELEN: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) temp); + index += 2; + + break; + + case CMD_GETMSFRAME: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) frameMS.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) frameMS.header.sense_node); + index += 2; + + for (j = 0; j < frameMS.node_data_size; j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (frameMS. + node_data[j] & 0xFF00) >> 8, + frameMS.node_data[j] & 0xFF); + index += 4; + } + + kfree(frameMS.node_data); + break; + + case CMD_GETSSFRAME: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) frameSS.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) frameSS.header.sense_node); + index += 2; + for (j = 0; j < frameSS.header.force_node; j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (frameSS. + force_data[j] & 0xFF00) >> 8, + frameSS.force_data[j] & 0xFF); + index += 4; + } + + for (j = 0; j < frameSS.header.sense_node; j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (frameSS. + sense_data[j] & 0xFF00) >> 8, + frameSS.sense_data[j] & 0xFF); + index += 4; + } + + kfree(frameSS.force_data); + kfree(frameSS.sense_data); + break; + + case CMD_READMSCOMPDATA: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) compData.header.type); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) compData.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) compData.header.sense_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + compData.cx1 & 0xFF); + index += 2; + + for (j = 0; j < compData.node_data_size; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + compData.node_data[j] & 0xFF); + index += 2; + } + + kfree(compData.node_data); + break; + + case CMD_READSSCOMPDATA: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) comData.header.type); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.header.sense_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.f_ix1 & 0xFF); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.s_ix1 & 0xFF); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.f_cx1 & 0xFF); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.s_cx1 & 0xFF); + index += 2; + + for (j = 0; j < comData.header.force_node; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + comData.ix2_fm[j] & 0xFF); + index += 2; + + } + + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + comData.ix2_sn[j] & 0xFF); + index += 2; + + } + + for (j = 0; j < comData.header.force_node; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + comData.cx2_fm[j] & 0xFF); + + index += 2; + } + + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + comData.cx2_sn[j] & 0xFF); + index += 2; + } + + kfree(comData.ix2_fm); + kfree(comData.ix2_sn); + kfree(comData.cx2_fm); + kfree(comData.cx2_sn); + break; + + case CMD_READTOTMSCOMPDATA: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) totCompData.header.type); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) totCompData.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) totCompData.header.sense_node); + + index += 2; + + for (j = 0; j < totCompData.node_data_size; j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (totCompData. + node_data[j] & 0xFF00) >> 8, + totCompData. + node_data[j] & 0xFF); + index += 4; + } + + kfree(totCompData.node_data); + break; + + case CMD_READTOTSSCOMPDATA: + snprintf(&driver_test_buff[index], 3, "%02X", + (u8) totComData.header.type); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + totComData.header.force_node); + index += 2; + + snprintf(&driver_test_buff[index], 3, "%02X", + totComData.header.sense_node); + index += 2; + + for (j = 0; j < totComData.header.force_node; + j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (totComData. + ix_fm[j] & 0xFF00) >> 8, + totComData.ix_fm[j] & 0xFF); + index += 4; + } + + for (j = 0; j < totComData.header.sense_node; + j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (totComData. + ix_sn[j] & 0xFF00) >> 8, + totComData.ix_sn[j] & 0xFF); + index += 4; + } + + for (j = 0; j < totComData.header.force_node; + j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (totComData. + cx_fm[j] & 0xFF00) >> 8, + totComData.cx_fm[j] & 0xFF); + + index += 4; + } + + for (j = 0; j < totComData.header.sense_node; + j++) { + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (totComData. + cx_sn[j] & 0xFF00) >> 8, + totComData.cx_sn[j] & 0xFF); + index += 4; + } + + kfree(totComData.ix_fm); + kfree(totComData.ix_sn); + kfree(totComData.cx_fm); + kfree(totComData.cx_sn); + break; + + case CMD_GETFWVER: + snprintf(&driver_test_buff[index], 5, "%04X", + fw_version); + index += 4; + + snprintf(&driver_test_buff[index], 5, "%04X", + config_id); + index += 4; + break; + + case CMD_READCOMPDATAHEAD: + snprintf(&driver_test_buff[index], 3, "%02X", + dataHead.type); + index += 2; + break; + + default: + break; + } + } + + snprintf(&driver_test_buff[index], 4, " }\n"); + limit = size - 1; + printed = 0; + } else { + + driver_test_buff[index++] = MESSAGE_START_BYTE; + if (bin_output == 1) { + + driver_test_buff[index++] = (size & 0xFF00) >> 8; + driver_test_buff[index++] = (size & 0x00FF); + + driver_test_buff[index++] = + (mess.counter & 0xFF00) >> 8; + driver_test_buff[index++] = (mess.counter & 0x00FF); + + driver_test_buff[index++] = (mess.action & 0xFF00) >> 8; + driver_test_buff[index++] = (mess.action & 0x00FF); + + driver_test_buff[index++] = (res & 0xFF00) >> 8; + driver_test_buff[index++] = (res & 0x00FF); + + } else { + if (funcToTest[0] == CMD_GETLIMITSFILE_BYTE + || funcToTest[0] == CMD_GETFWFILE_BYTE) + snprintf(&driver_test_buff[index], 5, + "%02X%02X", + (((fileSize + 3) / 4) & 0xFF00) >> 8, + ((fileSize + 3) / 4) & 0x00FF); + else + snprintf(&driver_test_buff[index], 5, + "%02X%02X", (size & 0xFF00) >> 8, + size & 0xFF); + index += 4; + index += + snprintf(&driver_test_buff[index], 5, "%04X", + (u16) mess.counter); + index += + snprintf(&driver_test_buff[index], 5, "%04X", + (u16) mess.action); + index += + snprintf(&driver_test_buff[index], 5, "%02X%02X", + (res & 0xFF00) >> 8, res & 0xFF); + } + + switch (funcToTest[0]) { + case CMD_VERSION_BYTE: + case CMD_READ_BYTE: + case CMD_WRITEREAD_BYTE: + case CMD_WRITETHENWRITEREAD_BYTE: + case CMD_WRITEREADU8UX_BYTE: + case CMD_WRITEU8UXTHENWRITEREADU8UX_BYTE: + if (bin_output == 1) { + if (mess.dummy == 1) + memcpy(&driver_test_buff[index], + &readData[1], byteToRead); + else + memcpy(&driver_test_buff[index], + readData, byteToRead); + index += byteToRead; + } else { + j = mess.dummy; + for (; j < byteToRead + mess.dummy; j++) + index += + snprintf(&driver_test_buff[index], + 3, "%02X", + (u8) readData[j]); + } + break; + + case CMD_GETLIMITSFILE_BYTE: + case CMD_GETFWFILE_BYTE: + if (bin_output == 1) { + driver_test_buff[1] = + (((fileSize + 3) / 4) & 0xFF00) >> 8; + driver_test_buff[2] = + (((fileSize + 3) / 4) & 0x00FF); + + if (readData != NULL) { + memcpy(&driver_test_buff[index], + readData, fileSize); + } else { + logError(0, + "%s readData = NULL... returning junk data!", + tag); + } + index += addr; + } else { + for (j = 0; j < fileSize; j++) { + index += + snprintf(&driver_test_buff[index], + 3, "%02X", + (u8) readData[j]); + } + for (; j < addr; j++) + index += snprintf(&driver_test_buff[index], 3, "%02X", 0); + } + break; + default: + break; + } + + driver_test_buff[index++] = MESSAGE_END_BYTE; + driver_test_buff[index] = '\n'; + limit = size; + printed = 0; + } +ERROR: + numberParam = 0; + if (readData != NULL) + kfree(readData); + if (cmd) + kfree(cmd); + return count; +} + +/** @}*/ + +/** + * file_operations struct which define the functions for the canonical operation on a device file node (open. read, write etc.) + */ +static struct proc_ops fts_driver_test_ops = { + .proc_open = fts_open, + .proc_read = seq_read, + .proc_write = fts_driver_test_write, + .proc_lseek = seq_lseek, + .proc_release = seq_release +}; + +/*****************************************************************************/ + +/** +* This function is called in the probe to initialize and create the directory /proc/fts and the driver test file node DRIVER_TEST_FILE_NODE into the /proc file system +* @return OK if success or an error code which specify the type of error encountered +*/ +int fts_proc_init(void) +{ + struct proc_dir_entry *entry; + + int retval = 0; + + fts_dir = proc_mkdir_data("fts", 0777, NULL, NULL); + if (fts_dir == NULL) { + retval = -ENOMEM; + goto out; + } + + entry = proc_create(DRIVER_TEST_FILE_NODE, 0644, fts_dir, + &fts_driver_test_ops); + + if (entry) { + logError(1, "%s %s: proc entry CREATED! \n", tag, __func__); + } else { + logError(1, "%s %s: error creating proc entry! \n", tag, + __func__); + retval = -ENOMEM; + goto badfile; + } + return OK; +badfile: + remove_proc_entry("fts", NULL); +out: + return retval; +} + +/** +* Delete and Clean from the file system, all the references to the driver test file node +* @return OK +*/ +int fts_proc_remove(void) +{ + remove_proc_entry(DRIVER_TEST_FILE_NODE, fts_dir); + remove_proc_entry("fts", NULL); + return OK; +} diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h index d0f66a5e1b2a..704311d5f847 100644 --- a/include/linux/of_gpio.h +++ b/include/linux/of_gpio.h @@ -17,8 +17,26 @@ struct device_node; +/* + * This is Linux-specific flags. By default controllers' and Linux' mapping + * match, but GPIO controllers are free to translate their own flags to + * Linux-specific in their .xlate callback. Though, 1:1 mapping is recommended. + */ + enum of_gpio_flags { + OF_GPIO_ACTIVE_LOW = 0x1, + OF_GPIO_SINGLE_ENDED = 0x2, + OF_GPIO_OPEN_DRAIN = 0x4, + OF_GPIO_TRANSITORY = 0x8, + OF_GPIO_PULL_UP = 0x10, + OF_GPIO_PULL_DOWN = 0x20, + OF_GPIO_PULL_DISABLE = 0x40, +}; + #ifdef CONFIG_OF_GPIO +extern int of_get_named_gpio_flags(struct device_node *np, + const char *list_name, int index, enum of_gpio_flags *flags); + extern int of_get_named_gpio(const struct device_node *np, const char *list_name, int index); @@ -27,6 +45,15 @@ extern int of_get_named_gpio(const struct device_node *np, #include /* Drivers may not strictly depend on the GPIO support, so let them link. */ +static inline int of_get_named_gpio_flags(struct device_node *np, + const char *list_name, int index, enum of_gpio_flags *flags) +{ +if (flags) + *flags = 0; + +return -ENOSYS; +} + static inline int of_get_named_gpio(const struct device_node *np, const char *propname, int index) { -- Armbian