diff --git a/drivers/input/touchscreen/stmicro_mmi/Makefile b/drivers/input/touchscreen/stmicro_mmi/Makefile new file mode 100644 index 000000000000..cbc87ef09709 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/Makefile @@ -0,0 +1,6 @@ +# +# Makefile for the touchscreen drivers. +# + +obj-y += fts.o fts_proc.o fts_lib/ + diff --git a/drivers/input/touchscreen/stmicro_mmi/fts.c b/drivers/input/touchscreen/stmicro_mmi/fts.c new file mode 100644 index 000000000000..f19149cb9ed2 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts.c @@ -0,0 +1,4243 @@ +/* + * 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 +#include + +#include +#include +#include + +#include +#include + +#ifdef KERNEL_ABOVE_2_6_38 +#include +#endif + + +#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" + + + +/** + * 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) \ + (_i->event_dispatch_table[event_id(_evt)] = handler_name(_hnd)) + + + +#ifdef KERNEL_ABOVE_2_6_38 +#define TYPE_B_PROTOCOL +#endif + + +extern SysInfo systemInfo; +extern TestToDo tests; +#ifdef GESTURE_MODE +extern struct mutex gestureMask_mutex; +#endif + +char tag[8] = "[ FTS ]\0"; +char fts_ts_phys[64]; /* /< buffer which store the input device name assigned + * by the kernel */ + +static u32 typeOfComand[CMD_STR_LEN] = { 0 }; /* /< buffer used to store the + * command sent from the MP + * device file node */ +static int numberParameters; /* /< number of parameter passed through the MP + * device file node */ +#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 + +#ifdef PHONE_KEY +static u8 key_mask = 0x00; /* /< store the last update of the key mask + * published by the IC */ +#endif + + +extern spinlock_t fts_int; + + + +static void fts_interrupt_enable(struct fts_ts_info *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); + + +/** + * 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 + 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; +#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); + + /* default(if not specified by user) set force = 0 and keep_cx to 1 */ + mode[0] = 0; + mode[1] = 1; + + /* reading out firmware upgrade parameters */ + if (sscanf(buf, "%100s %d %d", path, &mode[0], &mode[1]) >= 1) { + logError(1, "%s fts_fwupdate_store: file = %s, force = %d, keep_cx = %d\n", + tag, path, mode[0], mode[1]); + + + 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); + } else + logError(1, "%s %s Wrong number of parameters! ERROR %08X\n", + tag, __func__, ERROR_OP_NOT_ALLOW); + + 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, 14, "{ %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 \n + * (first the less significant byte) \n + * cat appid show the 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]; + + 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, 14, "{ %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 external release + * 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] = { 0 }; + + fw.data = NULL; + ret = readFwFile(PATH_FILE_FW, &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; +} + + +#if 0 +/** + * File node to obtain and show strength frame + * cat strength_frame to obtain strength data \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 + * **** if error code is all 0s **** \n + * FF = 1 byte in HEX format number of rows \n + * SS = 1 byte in HEX format number of columns \n + * N1, ... = the decimal value of each node separated by a coma \n + * ********************************* \n + * } = end byte + */ +static ssize_t fts_strength_frame_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + MutualSenseFrame frame; + int res, count, j, size = (6 * 2) + 1, index = 0; + char *all_strbuff = NULL; + /* char buff[CMD_STR_LEN] = {0}; */ + /* struct i2c_client *client = to_i2c_client(dev); */ + struct fts_ts_info *info = dev_get_drvdata(dev); + + frame.node_data = NULL; + + res = fts_disableInterrupt(); + if (res < OK) + goto END; + + res = senseOn(); + if (res < OK) { + logError(1, "%s %s: could not start scanning! ERROR %08X\n", + tag, __func__, res); + goto END; + } + msleep(WAIT_FOR_FRESH_FRAMES); + res = senseOff(); + if (res < OK) { + logError(1, "%s %s: could not finish scanning! ERROR %08X\n", + tag, __func__, res); + goto END; + } + + msleep(WAIT_AFTER_SENSEOFF); + flushFIFO(); + + 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; + } else { + size += (res * 6); + logError(0, "%s The frame size is %d words\n", tag, res); + res = OK; + print_frame_short("MS Strength frame =", array1dTo2d_short( + frame.node_data, frame.node_data_size, + frame.header.sense_node), + frame.header.force_node, + frame.header.sense_node); + } + +END: + flushFIFO(); + release_all_touches(info); + fts_mode_handler(info, 1); + + all_strbuff = (char *)kzalloc(size * sizeof(char), GFP_KERNEL); + + if (all_strbuff != NULL) { + snprintf(&all_strbuff[index], 11, "{ %08X", res); + + index += 10; + + if (res >= OK) { + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frame.header.force_node); + index += 2; + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frame.header.sense_node); + + index += 2; + + for (j = 0; j < frame.node_data_size; j++) { + snprintf(&all_strbuff[index], 10, "%d,%n", + frame.node_data[j], &count); + index += count; + } + + kfree(frame.node_data); + } + + snprintf(&all_strbuff[index], 3, " }"); + index += 2; + + 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, + ERROR_ALLOC); + + fts_enableInterrupt(); + return count; +} +#endif + +/***************************************** 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; + +/* Example based on the status of the screen and on the feature + * that is trying to enable */ + /*res=ERROR_OP_NOT_ALLOW; + * if(info->resume_bit ==0){ + * switch(feature){ + #ifdef GESTURE_MODE + * case FEAT_SEL_GESTURE: + * res = OK; + * break; + #endif + * default: + * logError(1,"%s %s: Feature not allowed in this + * operating mode! ERROR %08X\n", + * tag,__func__,res); + * break; + * + * } + * }else{ + * switch(feature){ + #ifdef GESTURE_MODE + * case FEAT_SEL_GESTURE: + #endif + * case FEAT__SEL_GLOVE: // glove mode can only activate + *during sense on + * res = OK; + * break; + * + * default: + * logError(1,"%s %s: Feature not allowed in this + *operating mode! ERROR %08X\n",tag,__func__,res); + * break; + * + * } + * }*/ + + +/* Example based only on the feature that is going to be activated */ + 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 + * cat feature_enable to show the result of enabling/disabling process + * echo XX 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, temp2; + 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 { + if (sscanf(p, "%02X %02X ", &temp, &temp2) == 2) { + p += 3; + res = check_feature_feasibility(info, temp); + if (res >= OK) { + switch (temp) { + #ifdef GESTURE_MODE + case FEAT_SEL_GESTURE: + info->gesture_enabled = temp2; + logError(1, + "%s fts_feature_enable: Gesture Enabled = %d\n", + tag, info->gesture_enabled); + break; + #endif + + #ifdef GLOVE_MODE + case FEAT_SEL_GLOVE: + info->glove_enabled = temp2; + logError(1, + "%s fts_feature_enable: Glove Enabled = %d\n", + tag, info->glove_enabled); + + break; + #endif + + #ifdef STYLUS_MODE + case FEAT_SEL_STYLUS: + info->stylus_enabled = temp2; + logError(1, + "%s fts_feature_enable: Stylus Enabled = %d\n", + tag, info->stylus_enabled); + + break; + #endif + + #ifdef COVER_MODE + case FEAT_SEL_COVER: + info->cover_enabled = temp2; + logError(1, + "%s fts_feature_enable: Cover Enabled = %d\n", + tag, info->cover_enabled); + + break; + #endif + + #ifdef CHARGER_MODE + case FEAT_SEL_CHARGER: + info->charger_enabled = temp2; + logError(1, + "%s fts_feature_enable: Charger Enabled = %d\n", + tag, info->charger_enabled); + + break; + #endif + + #ifdef GRIP_MODE + case FEAT_SEL_GRIP: + info->grip_enabled = temp2; + 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); + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + + + } + 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__, (int)((count + 1) / 3), 1); + else { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + +/* 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); + } + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + } + + 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__, (int)((count + 1) / 3), 1); + else { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + +/* 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); + } + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + + } + + 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__, (int)((count + 1) / 3), 1); + else { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + +/* 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); + } + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + } + + return count; +} +#endif + + +#ifdef COVER_MODE +/* echo 01/00 > cover_mode to enable/disable cover mode */ +/* cat cover_mode to show the status of the cover_enabled switch + * (example output in the terminal = "AA00000001BB" if the switch is enabled) */ +/* echo 01/00 > cover_mode; cat cover_mode to enable/disable cover mode and + * see the switch status in just one call */ +/* NOTE: the cover can be handled also using a notifier, in this case the body + * of these functions should be copied in the notifier callback */ +/** + * 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__, (int)((count + 1) / 3), 1); + else { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + +/* 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); + } + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + } + + 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__, (int)((count + 1) / 3), 1); + else { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + info->stylus_enabled = temp; + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + + } + + return count; +} +#endif + +#endif + +/***************************************** GESTURES + * ***************************************************/ +#ifdef GESTURE_MODE +#ifdef USE_GESTURE_MASK /* if this define is used, a gesture bit mask is used as + * method to select the gestures to enable/disable */ + +/** + * 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, (int)((count + 1) / 3), GESTURE_MASK_SIZE); + mask[0] = 0; + } else { + mask[0] = ((count + 1) / 3) - 1; + for (n = 1; n <= (count + 1) / 3; n++) { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + mask[n] = (u8)temp; + logError(1, "%s mask[%d] = %02X\n", + tag, n, mask[n]); + } else + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + + } + } + + return count; +} + +#else /* if this define is not used, to select the gestures to enable/disable + * are used the IDs of the gestures */ +/* echo EE X1 X2 ... > gesture_mask set the gesture to disable/enable; + * EE = 00(disable) or 01(enable); X1 ... = gesture IDs + * (example 01 02 05... represent the gestures with ID = 1, 2 and 5) + * there is no limit of the parameters that can be passed, + * of course the gesture IDs should be valid (all the valid IDs are listed in + * ftsGesture.h) */ +/* cat gesture_mask enable/disable the given gestures, 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. + * At the end an error code will be printed + * (example output in the terminal = "AA00000000BB" if there are no errors) */ +/* echo EE X1 X2 ... > gesture_mask; cat gesture_mask perform in one command + * both actions stated before */ +/** + * 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; + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + mask[1] = (u8)temp; + for (n = 1; n < (count + 1) / 3; n++) { + if (sscanf(p, "%02X ", &temp) == 1) { + p += 3; + fromIDtoMask((u8)temp, &mask[2], + GESTURE_MASK_SIZE); + } else { + logError(1, "%s %s: Error when reading the mask with sscanf!\n", + tag, __func__); + mask[0] = 0; + goto END; + } + } + + for (n = 0; n < GESTURE_MASK_SIZE + 2; n++) + logError(1, "%s mask[%d] = %02X\n", tag, n, + mask[n]); + } else { + logError(1, "%s %s: Error when reading with sscanf!\n", + tag, __func__); + mask[0] = 0; + } + + } + +END: + 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 = + *OK) \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; + /* coords are pairs of x,y (*2) where each coord is + * short(2bytes=4char)(*4) + 1 byte(2char) num of coords (+2) + **/ + res = OK; /* set error code to 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, + __func__, 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 + * \n + * Possible commands (cmd): \n + * - 00 = MP Test -> return error_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 xx(optional) = Read 1 MS Raw Frame -> return additional data: + * MS frame row after row. if xx = 1, will read LP frame \n + * - 14 = Read MS Init Data -> return additional data: MS init data row after + * row \n + * - 15 xx(optional) = Read 1 SS Raw Frame -> return additional data: SS frame, + * force channels followed by sense channels. If xx = 1, will read LP frame \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)); + numberParameters = 0; + logError(1, "%s\n", tag); + for (n = 0; n < (count + 1) / 3; n++) { + if (sscanf(p, "%02X ", &typeOfComand[n]) == 1) { + p += 3; + logError(1, "%s typeOfComand[%d] = %02X\n", tag, n, + typeOfComand[n]); + numberParameters++; + } + } + + /* 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; + + int size = (6 * 2) + 1; + int init_type = SPECIAL_PANEL_INIT; + u8 *all_strbuff = 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; + } + + + + res = fb_unregister_client(&info->notifier); + if (res < 0) { + logError(1, "%s ERROR: unregister notifier failed!\n", + tag); + goto END; + } + + + switch (typeOfComand[0]) { + /*ITO TEST*/ + case 0x01: + res = production_test_ito(LIMITS_FILE, &tests); + break; + /*PRODUCTION TEST*/ + case 0x00: +#ifndef COMPUTE_INIT_METHOD + 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; + } +#else + if (systemInfo.u8_mpFlag != MP_FLAG_FACTORY) { + init_type = SPECIAL_FULL_PANEL_INIT; + logError(0, + "%s Select Full Panel Init!\n", tag); + } else { + init_type = NO_INIT; + logError(0, + "%s Skip Full Panel Init!\n", tag); + } +#endif + + res = production_test_main(LIMITS_FILE, 1, init_type, + &tests, MP_FLAG_FACTORY); + break; + /*read mutual raw*/ + case 0x13: + logError(0, "%s Get 1 MS Frame\n", tag); + if (numberParameters >= 2 && typeOfComand[1] == 1) + setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_ACTIVE); + else + setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + msleep(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(WAIT_AFTER_SENSEOFF); + flushFIFO(); /* delete the events related to some + * touch (allow to call this function + * while touching the screen without + * having a flooding of the FIFO) */ + 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) * 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); + } + break; + /*read self raw*/ + case 0x15: + logError(0, "%s Get 1 SS Frame\n", tag); + if (numberParameters >= 2 && typeOfComand[1] == 1) + setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_DETECT); + else + setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + msleep(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(WAIT_AFTER_SENSEOFF); + flushFIFO(); /* delete the events related to some + * touch (allow to call this function + * while touching the screen without + * having a flooding of the FIFO) */ + if (numberParameters >= 2 && typeOfComand[1] == 1) + res = getSSFrame3(SS_DETECT_RAW, &frameSS); + else + 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) * 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); + } + + break; + + case 0x14: /* read mutual comp data */ + 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 + 3) * + sizeof(u8)) * 2; + 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: /* read self comp data */ + 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 + 8) * + sizeof(u8) * 2; + 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: /* MS Raw DATA TEST */ + res = fts_system_reset(); + if (res >= OK) + res = production_test_ms_raw(LIMITS_FILE, 1, + &tests); + break; + + case 0x04: /* MS CX DATA TEST */ + res = fts_system_reset(); + if (res >= OK) + res = production_test_ms_cx(LIMITS_FILE, 1, + &tests); + break; + + case 0x05: /* SS RAW DATA TEST */ + res = fts_system_reset(); + if (res >= OK) + res = production_test_ss_raw(LIMITS_FILE, 1, + &tests); + break; + + case 0x06: /* SS IX CX DATA TEST */ + res = fts_system_reset(); + if (res >= OK) + res = production_test_ss_ix_cx(LIMITS_FILE, 1, + &tests); + break; + + + case 0xF0: + case 0xF1: /* TOUCH ENABLE/DISABLE */ + 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; + } + + + + if (fb_register_client(&info->notifier) < 0) + logError(1, "%s ERROR: register notifier failed!\n", tag); + + +END: + /* here start the reporting phase, assembling the data + * to send in the file node */ + all_strbuff = (u8 *)kzalloc(size, GFP_KERNEL); + + snprintf(&all_strbuff[index], 11, "{ %08X", res); + index += 10; + + if (res >= OK) { + /*all the other cases are already fine printing only the res.*/ + switch (typeOfComand[0]) { + case 0x13: + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frameMS.header.force_node); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frameMS.header.sense_node); + index += 2; + + for (j = 0; j < frameMS.node_data_size; j++) { + snprintf(&all_strbuff[index], 5, "%02X%02X", + (frameMS.node_data[j] & 0xFF00) >> 8, + frameMS.node_data[j] & 0xFF); + index += 4; + } + + kfree(frameMS.node_data); + break; + + case 0x15: + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frameSS.header.force_node); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (u8)frameSS.header.sense_node); + index += 2; + + /* Copying self raw data Force */ + for (j = 0; j < frameSS.header.force_node; j++) { + snprintf(&all_strbuff[index], 5, "%02X%02X", + (frameSS.force_data[j] & 0xFF00) >> 8, + frameSS.force_data[j] & 0xFF); + index += 4; + } + + + /* Copying self raw data Sense */ + for (j = 0; j < frameSS.header.sense_node; j++) { + snprintf(&all_strbuff[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 0x14: + snprintf(&all_strbuff[index], 3, "%02X", + (u8)compData.header.force_node); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (u8)compData.header.sense_node); + index += 2; + + /* Cpying CX1 value */ + snprintf(&all_strbuff[index], 3, "%02X", + (compData.cx1) & 0xFF); + index += 2; + + /* Copying CX2 values */ + for (j = 0; j < compData.node_data_size; j++) { + snprintf(&all_strbuff[index], 3, "%02X", + (compData.node_data[j]) & 0xFF); + index += 2; + } + + kfree(compData.node_data); + break; + + case 0x16: + snprintf(&all_strbuff[index], 3, "%02X", + comData.header.force_node); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + comData.header.sense_node); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.f_ix1) & 0xFF); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.s_ix1) & 0xFF); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.f_cx1) & 0xFF); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.s_cx1) & 0xFF); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.f_ix0) & 0xFF); + index += 2; + + snprintf(&all_strbuff[index], 3, "%02X", + (comData.s_ix0) & 0xFF); + index += 2; + + /* Copying IX2 Force */ + for (j = 0; j < comData.header.force_node; j++) { + snprintf(&all_strbuff[index], 3, "%02X", + comData.ix2_fm[j] & 0xFF); + index += 2; + } + + /* Copying IX2 Sense */ + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(&all_strbuff[index], 3, "%02X", + comData.ix2_sn[j] & 0xFF); + index += 2; + } + + /* Copying CX2 Force */ + for (j = 0; j < comData.header.force_node; j++) { + snprintf(&all_strbuff[index], 3, "%02X", + comData.cx2_fm[j] & 0xFF); + index += 2; + } + + /* Copying CX2 Sense */ + for (j = 0; j < comData.header.sense_node; j++) { + snprintf(&all_strbuff[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; + + default: + break; + } + } + + snprintf(&all_strbuff[index], 3, " }"); + index += 2; + + + count = snprintf(buf, TSP_BUF_SIZE, "%s\n", all_strbuff); + numberParameters = 0; + /* need to reset the number of parameters in order to wait the + * next command, comment if you want to repeat the last command sent + * just doing a cat */ + /* logError(0,"%s numberParameters = %d\n",tag, numberParameters); */ + kfree(all_strbuff); + + return count; +} + +static DEVICE_ATTR(fwupdate, (S_IRUGO | S_IWUSR | S_IWGRP), fts_fwupdate_show, + fts_fwupdate_store); +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(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 + +/* /sys/devices/soc.0/f9928000.i2c/i2c-6/6-0049 */ +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 + +#ifdef GESTURE_MODE + &dev_attr_gesture_mask.attr, + &dev_attr_gesture_coordinates.attr, +#endif + NULL, +}; + +/** @}*/ +/** @}*/ + + +/** + * @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]); +} + +/** + * 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; + + if (!info->resume_bit) + goto no_report; + + 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); + /* TODO: check with fw how they will report distance and pressure */ + z = PRESSURE_MAX; + distance = 0; /* if the tool is touching the display the distance + * should be 0 */ + + if (x == X_AXIS_MAX) + x--; + + if (y == Y_AXIS_MAX) + y--; + + 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) { /* if stylus_enabled is + * not ==1 it will be + * reported as normal + * touch */ + tool = MT_TOOL_PEN; + touch_condition = 1; + __set_bit(touchId, &info->stylus_id); + break; + } +#endif + /* TODO: customer can implement a different strategy for each kind of + * touch */ + 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; /* need to hover */ + z = 0; /* no pressure */ + __set_bit(touchId, &info->touch_id); + distance = DISTANCE_MAX; /* check with fw report the + * hovering distance */ + break; + + case TOUCH_TYPE_INVALID: + default: + logError(1, "%s %s : Invalid touch type = %d ! No Report...\n", + tag, __func__, touchType); + goto no_report; + } + + input_mt_report_slot_state(info->input_dev, tool, 1); + + /* logError(0, "%s %s : TouchID = %d,Touchcount = %d + *\n",tag,__func__,touchId,touchcount); */ + input_report_key(info->input_dev, BTN_TOUCH, touch_condition); + + /* 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_MAJOR, z); + input_report_abs(info->input_dev, ABS_MT_TOUCH_MINOR, z); + input_report_abs(info->input_dev, ABS_MT_PRESSURE, z); + input_report_abs(info->input_dev, ABS_MT_DISTANCE, distance); + /* logError(0, "%s %s : Event 0x%02x - ID[%d], (x, y) = (%3d, %3d) + * Size = %d\n", tag, __func__, *event, touchId, x, y, touchType); */ + +no_report: + return; +} + +/** + * 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; + unsigned int tool = MT_TOOL_FINGER; + u8 touchType; + + touchType = event[1] & 0x0F; + touchId = (event[1] & 0xF0) >> 4; + + + + 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) { + /* if stylus_enabled is not ==1 it will be reported as + * normal touch */ + 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__); */ + case TOUCH_TYPE_HOVER: + tool = MT_TOOL_FINGER; + __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; + } + + input_mt_report_slot_state(info->input_dev, tool, 0); + + /* logError(0, "%s %s : TouchID = %d, Touchcount = %d\n",tag,__func__, + * touchId,touchcount); */ + + + input_report_abs(info->input_dev, ABS_MT_TRACKING_ID, -1); + /* logError(0, "%s %s : Event 0x%02x - release ID[%d]\n", tag, + * __func__, event[0], touchId); */ +} + +/* EventId : EVT_ID_MOTION_POINT */ +#define fts_motion_pointer_event_handler fts_enter_pointer_event_handler +/* remap the motion event handler to the same function which handle the enter + * event */ + +/** + * 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(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]); + + switch (event[1]) { + case EVT_TYPE_ERROR_ESD:/* esd */ + {/* before reset clear all slot */ + 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_HARD_FAULT: /* hard fault */ + case EVT_TYPE_ERROR_WATCHDOG: /* watch dog timer */ + { + dumpErrorInfo(NULL, 0); + /* before reset clear all slots */ + 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(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]); + 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(1, + "%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; + } +} + + +/* key events reported in the user report */ +#ifdef PHONE_KEY +/* TODO: the customer should handle the events coming from the keys according + * his needs (this is just an sample code that report the click of a botton + * after a press->release action) */ +/** + * 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) +{ + /* int value; */ + 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) { + /* event[2] contain the bitmask of the keys that are actually + * pressed */ + + 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 + +/* gesture event must be handled in the user event handler */ +#ifdef GESTURE_MODE +/* TODO: Customer should implement their own actions in respond of a gesture + * event. This is an example that simply print the gesture received and simulate + * the click on a different button for each gesture. */ +/** + * 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; + + logError(0, + "%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; + /* default read the coordinates for all gestures excluding + * double tap */ + + switch (event[2]) { + case GEST_ID_DBLTAP: + value = KEY_WAKEUP; + logError(0, "%s %s: double tap !\n", tag, __func__); + 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; + } +} + +/** + * 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 void fts_event_handler(struct work_struct *work) +{ + struct fts_ts_info *info; + int error = 0, count = 0; + unsigned char regAdd; + unsigned char data[FIFO_EVENT_SIZE] = { 0 }; + unsigned char eventId; + + event_dispatch_handler_t event_handler; + + info = container_of(work, struct fts_ts_info, work); + + __pm_wakeup_event(&info->wakesrc, jiffies_to_msecs(HZ)); + + /* read the FIFO and parsing events */ + + + regAdd = FIFO_CMD_READONE; + + for (count = 0; count < FIFO_DEPTH; count++) { + error = fts_writeReadU8UX(regAdd, 0, 0, data, FIFO_EVENT_SIZE, + DUMMY_FIFO); + + /*logError(0, "%s %s event = %02X %02X %02X %02X %02X %02X %02X %02X\n", + tag, __func__, data[0], + data[1], data[2], data[3], data[4], data[5], data[6], + data[7]);*/ + if (error == OK && data[0] != EVT_ID_NOEVENT) + eventId = data[0] >> 4; + else + break; + /* if(data[7]&0x20) */ + /* logError(1, "%s %s overflow ID = %02X Last = %02X\n", tag, + * __func__, data[0], data[7]); */ + + + + + if (eventId < NUM_EVT_ID) { /* this check prevent array out + * of index in case of no sense + * event ID */ + event_handler = info->event_dispatch_table[eventId]; + event_handler(info, (data)); + } + } + input_sync(info->input_dev); + + + /* re-enable interrupts */ + + fts_interrupt_enable(info); +} +/** @}*/ + + + +/** + * 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) +{ + 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; + +#if defined(PRE_SAVED_METHOD) || defined (COMPUTE_INIT_METHOD) + int keep_cx = 1; +#else + int keep_cx = 0; +#endif + + + logError(1, "%s Fw Auto Update is starting...\n", tag); + + /* check CRC status */ + 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__); + } + + retval = flashProcedure(PATH_FILE_FW, 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); /* power reset */ + retval1 = flashProcedure(PATH_FILE_FW, 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 = 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); + /* this path of the code is used only in case there is a + * CRC error in code or config which not allow the fw to + * compute the CRC in the CX before */ + /* the only way to recover is to have CX in fw file... + * */ +#ifndef COMPUTE_INIT_METHOD + logError(1, + "%s %s: Try to recovery with CX in fw file...\n", + tag, + __func__); + flashProcedure(PATH_FILE_FW, CRC_CX, 0); + logError(1, "%s %s: Refresh panel init data...\n", tag, + __func__); +#else + logError(1, + "%s %s: Select Full Panel Init...\n", tag, + __func__); + init_type = SPECIAL_FULL_PANEL_INIT; +#endif + } + } else + logError(1, + "%s %s: Error while executing system reset! ERROR %08X\n", + tag, + __func__, ret); /* better skip initialization + * because the real state is + * unknown */ + + + if (init_type != SPECIAL_FULL_PANEL_INIT) { +#if defined(PRE_SAVED_METHOD) || defined(COMPUTE_INIT_METHOD) + if ((systemInfo.u8_cfgAfeVer != systemInfo.u8_cxAfeVer) +#ifdef COMPUTE_INIT_METHOD + || ((systemInfo.u8_mpFlag != MP_FLAG_BOOT) && + (systemInfo.u8_mpFlag != MP_FLAG_FACTORY)) +#endif + ) { + init_type = SPECIAL_FULL_PANEL_INIT; + logError(0, + "%s %s: Different CX AFE Ver: %02X != %02X or invalid MpFlag = %02X... Execute FULL Panel Init!\n", + tag, __func__, systemInfo.u8_cfgAfeVer, + systemInfo.u8_cxAfeVer, systemInfo.u8_mpFlag); + } 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) { /* initialization status not correct or + * after FW complete update, do + * initialization. */ + 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); +} +#endif + +/* TODO: define if need to do the full mp at the boot */ +/** + * 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; + + /* initialization error, retry initialization */ + for (retry = 0; retry < RETRY_INIT_BOOT; retry++) { +#ifndef COMPUTE_INIT_METHOD + ret2 = production_test_initialization(init_type); +#else + ret2 = production_test_main(LIMITS_FILE, 1, init_type, &tests, + MP_FLAG_BOOT); +#endif + 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) /* initialization error */ + + logError(1, "%s fts initialization failed %d times\n", tag, + RETRY_INIT_BOOT); + + + 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; + + 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 + * Set IRQ pin behavior (level triggered low) + * Register 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_irq(info->client->irq, fts_interrupt_handler, + IRQF_TRIGGER_LOW, FTS_TS_DRV_NAME, info)) { + logError(1, "%s Request irq failed\n", tag); + kfree(info->event_dispatch_table); + error = -EBUSY; + } + + 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); +} + +/** + * Enable the host side interrupt + */ +static void fts_interrupt_enable(struct fts_ts_info *info) +{ + /* logError(0, "%s %s : enable interrupts!\n",tag,__func__); */ + enable_irq(info->client->irq); +} + +/**@}*/ + +/** + * This function try to attempt to communicate with the IC for the first time + * during the boot up process in order to read the necessary info for the + * following stages. + * The function execute a system reset, read fundamental info (system info) + * @return OK if success or an error code which specify the type of error + */ +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); /* system reset OK */ + 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__); + /* if IRQ pin is short with DVDD a call to the ISR will triggered when + * the regulator is turned off if IRQ not disabled */ + fts_disableInterrupt(); + + 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 + msleep(300); + + /* in FTI power up first the digital and then the analog */ + 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__); + } + + msleep(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__); + } + + msleep(5); /* time needed by the regulators for reaching the regime + * values */ + + + if (info->board->reset_gpio != GPIO_NOT_DEFINED) { + msleep(10); /* time to wait before bring up the reset gpio + * after the power up of the regulators */ + 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 + * 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 + */ +static int fts_init_sensing(struct fts_ts_info *info) +{ + int error = 0; + + error |= fb_register_client(&info->notifier); /* register the + * suspend/resume + * function */ + error |= fts_interrupt_install(info); /* register event handler */ + error |= fts_mode_handler(info, 0); /* enable the features and + * sensing */ + /* error |= fts_enableInterrupt(); */ /* enable the interrupt */ + error |= fts_resetDisableIrqCount(); + + if (error < OK) + logError(1, "%s %s Init after Probe error (ERROR = %08X)\n", + tag, __func__, error); + + + return error; +} + +/* TODO: change this function according with the needs of customer in terms of + * feature to enable/disable */ + +/** + * @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 already enabled/disabled otherwise it will judge if + * the feature changed status or the IC had a system reset + * @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 }; + + /* disable irq wake because resuming from gesture mode */ + if (IS_POWER_MODE(info->mode, SCAN_MODE_LOW_POWER) && + (info->resume_bit == 1)) + disable_irq_wake(info->client->irq); + + info->mode = MODE_NOTHING; /* initialize the mode to nothing in + * order to be updated depending on the + * features enabled */ + + logError(0, "%s %s: Mode Handler starting...\n", tag, __func__); + switch (info->resume_bit) { + case 0: /* screen down */ + logError(0, "%s %s: Screen OFF...\n", tag, __func__); + /* do sense off in order to avoid the flooding of the fifo with + * touch events if someone is touching the panel during suspend + */ + logError(0, "%s %s: Sense OFF!\n", tag, __func__); + /* for speed reason (no need to check echo in this case and + * interrupt can be enabled) */ + ret = setScanMode(SCAN_MODE_ACTIVE, 0x00); + res |= ret; /* to avoid warning unsused ret variable when + * all the features are disabled */ + +#ifdef GESTURE_MODE + if (info->gesture_enabled == 1) { + logError(0, "%s %s: enter in gesture mode !\n", tag, + __func__); + res = enterGestureMode(isSystemResettedDown()); + if (res >= OK) { + enable_irq_wake(info->client->irq); + 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); + } +#endif + + setSystemResetedDown(0); + break; + + case 1: /* screen up */ + logError(0, "%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; + /* required to satisfy also the disable case */ + 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 + /* if some selective scan want to be enabled can be done an or + * of the following options */ + /* settings[0] = ACTIVE_MULTI_TOUCH | ACTIVE_KEY | ACTIVE_HOVER + * | ACTIVE_PROXIMITY | ACTIVE_FORCE; */ + settings[0] = 0xFF; /* enable all the possible scans mode + * supported by the config */ + logError(0, "%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]); + + + 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); + return res; +} + +/** + * 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); + + __pm_wakeup_event(&info->wakesrc, jiffies_to_msecs(HZ)); + + info->resume_bit = 1; + + fts_system_reset(); + + release_all_touches(info); + + fts_mode_handler(info, 0); + + info->sensor_sleep = false; + + 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); + + __pm_wakeup_event(&info->wakesrc, jiffies_to_msecs(HZ)); + + info->resume_bit = 0; + + fts_mode_handler(info, 0); + + release_all_touches(info); + + info->sensor_sleep = true; + + fts_enableInterrupt(); +} +/** @}*/ + +/** + * 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_fb_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 fb_event *evdata = data; + unsigned int blank; + + + if (val != FB_EVENT_BLANK) + return 0; + + logError(0, "%s %s: fts notifier begin!\n", tag, __func__); + + if (evdata && evdata->data && val == FB_EVENT_BLANK && info) { + blank = *(int *)(evdata->data); + + + switch (blank) { + case FB_BLANK_POWERDOWN: + if (info->sensor_sleep) + break; + + logError(0, "%s %s: FB_BLANK_POWERDOWN\n", tag, + __func__); + + queue_work(info->event_wq, &info->suspend_work); + + break; + + case FB_BLANK_UNBLANK: + if (!info->sensor_sleep) + break; + + logError(0, "%s %s: FB_BLANK_UNBLANK\n", tag, __func__); + + queue_work(info->event_wq, &info->resume_work); + break; + default: + break; + } + } + return NOTIFY_OK; +} + +static struct notifier_block fts_noti_block = { + .notifier_call = fts_fb_state_chg_callback, +}; + +/** + * 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 + */ +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 + */ +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->avdd_reg); + +disable_bus_reg: + if (info->vdd_reg) + regulator_disable(info->vdd_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); + msleep(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; +} + +/** + * 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 *np = dev->of_node; + + bdata->irq_gpio = of_get_named_gpio_flags(np, "st,irq-gpio", 0, NULL); + + logError(0, "%s irq_gpio = %d\n", tag, bdata->irq_gpio); + + + retval = of_property_read_string(np, "st,regulator_dvdd", &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, "st,regulator_avdd", &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, "st,reset-gpio")) { + bdata->reset_gpio = of_get_named_gpio_flags(np, + "st,reset-gpio", 0, + NULL); + logError(0, "%s reset_gpio =%d\n", tag, bdata->reset_gpio); + } else + bdata->reset_gpio = GPIO_NOT_DEFINED; + + return OK; +} + +/** + * 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, const struct i2c_device_id *idp) +{ +#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; + + logError(1, "%s %s: driver probe begin!\n", tag, __func__); + + + logError(1, "%s driver ver. %s\n", tag, FTS_TS_DRV_VERSION); + + + logError(1, "%s SET Bus Functionality :\n", tag); +#ifdef I2C_INTERFACE + logError(1, "%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(1, "%s i2c address: %x\n", tag, client->addr); + bus_type = BUS_I2C; +#else + logError(1, "%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(1, "%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; + } + + 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); + goto ProbeErrorExit_1; + } + parse_dt(&client->dev, info->board); + } + + logError(1, "%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__); + goto ProbeErrorExit_1; + } + + retval = fts_enable_reg(info, true); + if (retval < 0) { + logError(1, "%s %s: ERROR Failed to enable regulators\n", tag, + __func__); + goto ProbeErrorExit_2; + } + + logError(1, "%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__); + goto ProbeErrorExit_2; + } + info->client->irq = gpio_to_irq(info->board->irq_gpio); + + logError(1, "%s SET Event Handler:\n", tag); + wakeup_source_init(&info->wakesrc, "fts_tp"); + 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; + } + + INIT_WORK(&info->work, fts_event_handler); + + INIT_WORK(&info->resume_work, fts_resume_work); + INIT_WORK(&info->suspend_work, fts_suspend_work); + + info->dev = &info->client->dev; + + logError(1, "%s SET Input Device Property:\n", tag); + 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; + + __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, + X_AXIS_MAX, 0, 0); + input_set_abs_params(info->input_dev, ABS_MT_POSITION_Y, Y_AXIS_MIN, + Y_AXIS_MAX, 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_PRESSURE, PRESSURE_MIN, + PRESSURE_MAX, 0, 0); + 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 + + 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; + } + + 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->resume_bit = 1; + info->notifier = fts_noti_block; + + logError(1, "%s Init Core Lib:\n", tag); + initCore(info); + /* init hardware device */ + logError(1, "%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; + } + +#if defined(FW_UPDATE_ON_PROBE) && defined(FW_H_FILE) + logError(1, "%s FW Update and Sensing Initialization:\n", tag); + error = fts_fw_update(info); + if (error < OK) { + logError(1, + "%s Cannot execute fw upgrade the device ERROR %08X\n", + tag, + error); + error = -ENODEV; + goto ProbeErrorExit_7; + } + +#else + logError(1, "%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 + + logError(1, "%s SET Device File Nodes:\n", tag); + /* sysfs stuff */ + info->attrs.attrs = fts_attr_group; + error = sysfs_create_group(&client->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); + +#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_7: +#ifdef FW_UPDATE_ON_PROBE + fb_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: + /* destroy_workqueue(info->fwu_workqueue); */ + wakeup_source_trash(&info->wakesrc); + + 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 int 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); + + fb_unregister_client(&info->notifier); + + /* unregister the device */ + input_unregister_device(info->input_dev); + + /* input_free_device(info->input_dev ); */ + + /* Remove the work thread */ + destroy_workqueue(info->event_wq); + wakeup_source_trash(&info->wakesrc); +#ifndef FW_UPDATE_ON_PROBE + destroy_workqueue(info->fwu_workqueue); +#endif + + fts_enable_reg(info, false); + fts_get_reg(info, false); + + /* free all */ + kfree(info); + + return OK; +} + +/** + * 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, + }, + .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/stmicro_mmi/fts.h b/drivers/input/touchscreen/stmicro_mmi/fts.h new file mode 100644 index 000000000000..7c28b439d082 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts.h @@ -0,0 +1,355 @@ +/* + * 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 "fts_lib/ftsSoftware.h" +#include "fts_lib/ftsHardware.h" + + +/****************** 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.18" /* /< driver version string format */ +#define FTS_TS_DRV_VER 0x05021200 /* driver version u32 format */ + +#define DEBUG /* /< define to print more logs in the kernel log and better + * follow the code flow */ + +#define DRIVER_TEST /* /< if defined allow to use and test special functions + * of the driver and fts_lib from comand shell (usefull + * for enginering/debug operations) */ + + +/* If both COMPUTE_INIT_METHOD and PRE_SAVED_METHOD are not defined, + * driver will be automatically configured as GOLDEN_VALUE_METHOD */ +/*#define COMPUTE_INIT_METHOD*/ /* Allow to compute init data on phone during + production */ +#ifndef COMPUTE_INIT_METHOD + #define PRE_SAVED_METHOD /* Pre-Saved Method used + * during production */ +#endif + +/* #define FW_H_FILE */ /* include the FW data as header file */ +#ifdef FW_H_FILE + #define FW_SIZE_NAME myArray_size /* /< name of the variable in + * the FW header file which + * specified the dimension of + * the FW data array */ + #define FW_ARRAY_NAME myArray /* /< name of the variable in the FW + * header file which specified the FW + * data array */ +/* #define FW_UPDATE_ON_PROBE */ + /* if defined the FW update will be execute on the probe, if not it will be + * executed EXP_FN_WORK_DELAY_MS ms after the probe is completed */ +#endif + +#ifndef FW_UPDATE_ON_PROBE +/* #define LIMITS_H_FILE */ +/* include the Production Limit File as header file, can be commented to use a + * .csv file instead */ +#ifdef LIMITS_H_FILE + #define LIMITS_SIZE_NAME myArray2_size /* /< name of the + * variable in the + * limits header file + * which specified the + * dimension of the + * limits data array */ + #define LIMITS_ARRAY_NAME myArray2 /* /< name of the + * variable in the + * limits header file + * which specified the + * limits data array */ +#endif +#else +/* if execute fw update in the probe the limit file must be a .h */ +#define LIMITS_H_FILE /* /< include the Production Limit File as header file, + * DO NOT COMMENT! */ +#define LIMITS_SIZE_NAME myArray2_size /* /< name of the + * variable in the + * limits header file + * which specified the + * dimension of the + * limits data array */ +#define LIMITS_ARRAY_NAME myArray2 /* /< name of the + * variable in the + * limits header file + * which specified the + * limits data array */ +#endif + +#define USE_ONE_FILE_NODE +/* allow to enable/disable all the features just using one file node */ + +#ifndef FW_UPDATE_ON_PROBE +#define EXP_FN_WORK_DELAY_MS 1000 /* /< time in ms elapsed after the probe + * to start the work which execute FW + * update and the Initialization of the + * IC */ +#endif + +/* **** END **** */ + + +/* **** FEATURES USED IN THE IC **** */ +/* Enable the support of keys */ +/* #define PHONE_KEY */ + +#define GESTURE_MODE /* /< enable the support of the gestures */ +#ifdef GESTURE_MODE + #define USE_GESTURE_MASK /* /< the gestures to select are + * referred using a gesture bitmask + * instead of their gesture IDs */ +#endif + + +#define CHARGER_MODE /* /< enable the support to charger mode feature + * (comment to disable) */ + +#define GLOVE_MODE /* /< enable the support to glove mode feature (comment + * to disable) */ + +#define COVER_MODE /* /< enable the support to cover mode feature (comment + * to disable) */ + +#define STYLUS_MODE /* /< enable the support to stylus mode feature (comment + * to disable) */ + +#define GRIP_MODE /* /< enable the support to grip mode feature (comment + * to disable) */ + + +/* **** END **** */ + + +/* **** PANEL SPECIFICATION **** */ +#define X_AXIS_MAX 1440 /* /< Max X coordinate of the display */ +#define X_AXIS_MIN 0 /* /< min X coordinate of the display */ +#define Y_AXIS_MAX 2959 /* /< Max Y coordinate of the display */ +#define Y_AXIS_MIN 0 /* /< min Y coordinate of the display */ + +#define PRESSURE_MIN 0 /* /< min value of pressure reported */ +#define PRESSURE_MAX 127 /* /< Max value of pressure reported */ + +#define DISTANCE_MIN 0 /* /< min distance between the tool and the + * display */ +#define DISTANCE_MAX 127 /* /< Max distance between the tool and the + * display */ + +#define TOUCH_ID_MAX 10 /* /< Max number of simoultaneous touches + * reported */ + +#define AREA_MIN PRESSURE_MIN /* /< min value of Major/minor axis + * reported */ +#define AREA_MAX PRESSURE_MAX /* /< Man value of Major/minor axis + * reported */ +/* **** 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 /* /< nothing enabled (sense off) */ +#define MODE_ACTIVE(_mask, _sett) (_mask |= (SCAN_MODE_ACTIVE << 24) | \ + (_sett << 16)) +/* /< store the status of scan mode active and its setting */ +#define MODE_LOW_POWER(_mask, _sett) (_mask |= (SCAN_MODE_LOW_POWER << 24) | \ + (_sett << 16)) +/* /< store the status of scan mode low power and its setting */ +#define IS_POWER_MODE(_mask, _mode) ((_mask&(_mode<<24)) != 0x00) +/* /< check the current mode of the IC */ + +/** @}*/ + +#define CMD_STR_LEN 32 /* /< max number of parameters that can accept + * the MP file node (stm_fts_cmd) */ + +#define TSP_BUF_SIZE PAGE_SIZE /* /< max number of bytes printable on + * the shell in the normal file nodes */ + + +/** + * Struct which contains information about the HW platform and set up + */ +struct fts_hw_platform_data { + int (*power)(bool on); + int irq_gpio; /* /< number of the gpio associated to the interrupt pin + * */ + int reset_gpio; /* /< number of the gpio associated to the reset pin */ + const char *vdd_reg_name; /* /< name of the VDD regulator */ + const char *avdd_reg_name; /* /< name of the AVDD regulator */ +}; + +/* + * Forward declaration + */ +struct fts_ts_info; +extern char tag[8]; /* /< forward the definition of the label used + * to print the log in the kernel log */ + +/* + * Dispatch event handler + */ +typedef void (*event_dispatch_handler_t) + (struct fts_ts_info *info, unsigned char *data); + +/** + * 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 + * - wakesrc Wakeup Source 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; /* /< Pointer to the structure device */ +#ifdef I2C_INTERFACE + struct i2c_client *client; /* /< I2C client structure */ +#else + struct spi_device *client; /* /< SPI client structure */ +#endif + struct input_dev *input_dev; /* /< Input device structure */ + + struct work_struct work; /* /< Event work thread */ + struct work_struct suspend_work; /* /< Suspend work thread */ + struct work_struct resume_work; /* /< Resume work thread */ + struct workqueue_struct *event_wq; /* /< Workqueue used for event + * handler, suspend and resume + * work threads */ + +#ifndef FW_UPDATE_ON_PROBE + struct delayed_work fwu_work; /* /< Delayed work thread for fw update + * process */ + struct workqueue_struct *fwu_workqueue; /* /< Fw update work + * queue */ +#endif + event_dispatch_handler_t *event_dispatch_table; /* /< Event dispatch + * table handlers */ + + struct attribute_group attrs; /* /< SysFS attributes */ + + unsigned int mode; /* /< Device operating mode (bitmask: msb + * indicate if active or lpm) */ + unsigned long touch_id; /* /< Bitmask for touch id (mapped to input + * slots) */ +#ifdef STYLUS_MODE + unsigned long stylus_id; /* /< Bitmask for tracking the stylus + * touches (mapped using the touchId) */ +#endif + + + struct fts_hw_platform_data *board; /* /< HW info retrieved from + * device tree */ + struct regulator *vdd_reg; /* /< DVDD power regulator */ + struct regulator *avdd_reg; /* /< AVDD power regulator */ + + + int resume_bit; /* /< Indicate if screen off/on */ + int fwupdate_stat; /* /< Store the result of a fw update triggered + * by the host */ + + + struct notifier_block notifier; /* /< Used for be notified from a + * suspend/resume event */ + bool sensor_sleep; /* /< if true suspend was called while if false + * resume was called */ + struct wakeup_source wakesrc; /* Wake Lock struct */ + + /* input lock */ + struct mutex input_report_mutex; /* /< mutex for handling the report + * of the pressure of keys */ + + /* switches for features */ + int gesture_enabled; /* /< if set, the gesture mode will be enabled + * during the suspend */ + int glove_enabled; /* /< if set, the glove mode will be enabled + * when allowed */ + int charger_enabled; /* /< if set, the charger mode will be enabled + * when allowed */ + int stylus_enabled; /* /< if set, the stylus mode will be enabled + * when allowed */ + int cover_enabled; /* /< if set, the cover mode will be enabled + * when allowed */ + int grip_enabled; /* /< if set, the grip mode mode will be enabled + * when allowed */ +}; + + + +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); + +/* export declaration of functions in fts_proc.c */ +extern int fts_proc_init(void); +extern int fts_proc_remove(void); + +#endif diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_fw.h b/drivers/input/touchscreen/stmicro_mmi/fts_fw.h new file mode 100644 index 000000000000..eee021d00100 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_fw.h @@ -0,0 +1,12574 @@ +/*! + * \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/stmicro_mmi/fts_lib/Makefile b/drivers/input/touchscreen/stmicro_mmi/fts_lib/Makefile new file mode 100644 index 000000000000..49ac2e18229d --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/Makefile @@ -0,0 +1,7 @@ +# +# Makefile for the FTS touchscreen driver. +# + + +obj-y += 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/stmicro_mmi/fts_lib/ftsCompensation.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCompensation.c new file mode 100644 index 000000000000..2286efa91733 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCompensation.c @@ -0,0 +1,822 @@ +/* + * + ************************************************************************** + ** 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 + */ +int requestCompensationData(u8 type) +{ + int ret = ERROR_OP_NOT_ALLOW; + int retry = 0; + + logError(0, "%s %s: Requesting compensation data... attemp = %d\n", tag, + __func__, retry + 1); + while (retry < RETRY_COMP_DATA_READ) { + ret = writeSysCmd(SYS_CMD_LOAD_DATA, &type, 1); + /* send request to load in memory the Compensation Data */ + 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 + */ +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) { /* i2c function have already a retry mechanism */ + 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 + */ +int readMutualSenseGlobalData(u64 *address, MutualSenseData *global) +{ + u8 data[COMP_DATA_GLOBAL]; + int ret; + + logError(0, "%s Address for Global data= %08llX\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]; + /* all other bytes are reserved atm */ + + 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 + */ +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 = %08llX\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); + 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 + */ +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 + */ +int readSelfSenseGlobalData(u64 *address, SelfSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %08llX\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]; + global->f_ix0 = data[8]; + global->s_ix0 = data[9]; + + 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 f_ix0 = %d s_ix0 = %d\n", + tag, global->f_max_n, global->s_max_n, + global->f_ix0, global->s_ix0); + + *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 + */ +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 = %08llX\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, __func__, 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 + */ +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 + */ +int readTotMutualSenseGlobalData(u64 *address, TotMutualSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %04llX\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]; + /* all other bytes are reserved atm */ + + 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 + */ +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 = %04llX\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); + 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 + */ +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 + */ +int readTotSelfSenseGlobalData(u64 *address, TotSelfSenseData *global) +{ + int ret; + u8 data[COMP_DATA_GLOBAL]; + + logError(0, "%s Address for Global data= %04llX\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 + */ +int readTotSelfSenseNodeData(u64 address, TotSelfSenseData *node) +{ + int size = node->header.force_node * 2 + node->header.sense_node * 2; + int toRead = size * 2; /* *2 2 bytes each node */ + 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 = %04llX\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, __func__, 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 + */ +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)) { + 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/stmicro_mmi/fts_lib/ftsCompensation.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCompensation.h new file mode 100644 index 000000000000..04079e34c581 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCompensation.h @@ -0,0 +1,136 @@ +/* + * + ************************************************************************** + ** 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 /* /< max number of attempts to read + * initialization data */ + + +/* Bytes dimension of Compensation Data Format */ + +#define COMP_DATA_HEADER DATA_HEADER /* /< size in bytes of + * initialization data header */ +#define COMP_DATA_GLOBAL (16 - COMP_DATA_HEADER) /* /< size in bytes + * of initialization + *data general info */ + + +#define HEADER_SIGNATURE 0xA5 /* /< signature used as starting byte of + * data loaded in memory */ + + + +/** + * 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 f_ix0; /* /< IX0 Force */ + u8 s_ix0; /* /< IX0 Sense */ + 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/stmicro_mmi/fts_lib/ftsCore.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCore.c new file mode 100644 index 000000000000..b498fcf6cd72 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCore.c @@ -0,0 +1,1155 @@ +/* + * + ************************************************************************** + ** 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" + +/** @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 = 1; /* /< 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 + */ +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(1, "%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 + */ +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(0, "%s System resetting...\n", tag); + for (i = 0; i < RETRY_SYSTEM_RESET && res < 0; i++) { + resetErrorList(); + fts_disableInterrupt(); /* disable interrupt before resetting to + * be able to get boot events */ + + 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); + msleep(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 (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(0, "%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 + */ +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) { + /* Log of errors */ + 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(1, + "%s pollForEvent: forced to be stopped! ERROR %08X\n", + tag, err_handling); + return err_handling; + } + } else { + if (readData[0] != EVT_ID_NOEVENT) { + logError(1, "%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(1, + "%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++; + msleep(TIMEOUT_RESOLUTION); + } + stopStopWatch(&clock); + if ((retry >= time_to_count) && find != 1) { + logError(1, "%s pollForEvent: ERROR %08X\n", tag, + ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } else if (find == 1) { + /* temp = printHex("FOUND EVENT = ", readData, FIFO_EVENT_SIZE); + * */ + /* if (temp != NULL) */ + logError(0, "%s %s\n", tag, printHex("FOUND EVENT = ", readData, + FIFO_EVENT_SIZE, temp)); + memset(temp, 0, 128); + /* kfree(temp); */ + 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 + */ +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: Invalid Size = %d not valid! ERROR %08X\n", + tag, + size, ERROR_OP_NOT_ALLOW); + return ERROR_OP_NOT_ALLOW; + } else { + if ((size + 4) > FIFO_EVENT_SIZE) + size = FIFO_EVENT_SIZE - 4; + /* Echo event 0x43 0x01 xx xx xx xx xx fifo_status + * therefore command with more than 4 bytes will be trunked */ + + 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]; + if ((cmd[0] == FTS_CMD_SYSTEM) && (cmd[1] == SYS_CMD_SPECIAL) && + ((cmd[2] == SPECIAL_FULL_PANEL_INIT) || + (cmd[2] == SPECIAL_PANEL_INIT))) + ret = pollForEvent(event_to_search, size + 2, readData, + TIMEOUT_ECHO_FPI); + else if ((cmd[0] == FTS_CMD_SYSTEM) && + (cmd[1] == SYS_CMD_CX_TUNING)) + ret = pollForEvent(event_to_search, size + 2, readData, + TIMEOUT_ECHO_SINGLE_ENDED_SPECIAL_AUTOTUNE); + else + ret = pollForEvent(event_to_search, size + 2, readData, + TIEMOUT_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 + */ +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(cmd, size); /* use write instead of writeFw because + * can be called while the interrupt are + * enabled */ + 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 + */ +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(cmd, 2 + size); /* use write instead of writeFw because + * can be called while the interrupts + * are enabled */ + 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 + */ +int writeSysCmd(u8 sys_cmd, u8 *sett, int size) +{ + u8 cmd[2 + size]; + int ret; + + 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"); + logError(0, "%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); + return ERROR_OP_NOT_ALLOW; + } + } + if (ret < OK) + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ret); + + else + logError(0, "%s %s: FINISHED!\n", tag, __func__); + + 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 + */ +int defaultSysInfo(int i2cError) +{ + int i; + + logError(0, "%s Setting default System Info...\n", tag); + + if (i2cError == 1) { + systemInfo.u16_fwVer = 0xFFFF; + systemInfo.u16_cfgProjectId = 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_cfgProjectId = 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 + */ +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_cfgProjectId); + index += 2; + logError(1, "%s CONFIG PROJECT ID = %04X\n", tag, + systemInfo.u16_cfgProjectId); + 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(1, "%s Protocol = %02X\n", tag, systemInfo.u8_protocol); + /* index+= 1; + * reserved area */ + + /* logError(1, "%s Die Info = ", tag); */ + for (i = 0; i < DIE_INFO_SIZE; i++) + systemInfo.u8_dieInfo[i] = data[index++]; + /* logError(1, "%02X ", systemInfo.u8_dieInfo[i]); */ + /* logError(1, "\n"); */ + logError(1, "%s %s\n", tag, printHex("Die Info = ", + systemInfo.u8_dieInfo, + DIE_INFO_SIZE, temp)); + memset(temp, 0, 256); + + + /* logError(1, "%s Release Info = ", tag); */ + for (i = 0; i < RELEASE_INFO_SIZE; i++) + systemInfo.u8_releaseInfo[i] = data[index++]; + /* logError(1, "%02X ", systemInfo.u8_releaseInfo[i]); */ + /* logError(1, "\n"); */ + + 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 += 4; /* skip reserved area */ + + systemInfo.u8_mpFlag = data[index++]; + logError(1, "%s MP FLAG = %02X\n", tag, + systemInfo.u8_mpFlag); + + index += 3 + 4; /* +3 remaining from mp flag address */ + + systemInfo.u8_ssDetScanSet = data[index]; + logError(1, "%s SS Detect Scan Select = %d \n", tag, + systemInfo.u8_ssDetScanSet); + index += 4; + + u8ToU16(&data[index], &systemInfo.u16_scrResX); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_scrResY); + index += 2; + logError(1, "%s Screen Resolution = %d x %d\n", tag, + systemInfo.u16_scrResX, systemInfo.u16_scrResY); + systemInfo.u8_scrTxLen = data[index++]; + logError(1, "%s TX Len = %d\n", tag, systemInfo.u8_scrTxLen); + systemInfo.u8_scrRxLen = data[index++]; + logError(1, "%s RX Len = %d\n", tag, systemInfo.u8_scrRxLen); + systemInfo.u8_keyLen = data[index++]; + logError(1, "%s Key Len = %d\n", tag, systemInfo.u8_keyLen); + systemInfo.u8_forceLen = data[index++]; + logError(1, "%s Force Len = %d\n", tag, systemInfo.u8_forceLen); + index += 8; + + u8ToU32(&data[index], &systemInfo.u32_productionTimestamp); + logError(1, "%s Production Timestamp = %08X\n", + tag, systemInfo.u32_productionTimestamp); + + index += 32; /* skip reserved area */ + + u8ToU16(&data[index], &systemInfo.u16_dbgInfoAddr); + index += 2; + + index += 6; /* skip reserved area */ + + 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; + + u8ToU16(&data[index], &systemInfo.u16_ssDetRawAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssDetFilterAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssDetStrenAddr); + index += 2; + u8ToU16(&data[index], &systemInfo.u16_ssDetBaselineAddr); + index += 2; + + logError(1, "%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(1, "%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 + */ +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 %08llX ...\n", + 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!\n", + tag, + __func__, ret); + return ret; + } + + logError(0, "%s %s: Read config memory FINISHED!\n", tag, __func__); + return OK; +} + +/** + * Write data into the Config Memory + * @param offset Starting address in the Config Memory where write the data + * @param data pointer of a byte array which contain the data to write + * @param len number of bytes to write + * @return OK if success or an error code which specify the type of error + */ +int writeConfig(u16 offset, u8 *data, int len) +{ + int ret; + u64 final_address = offset + ADDR_CONFIG_OFFSET; + + logError(0, "%s %s: Starting to write config memory at %08llX ...\n", + tag, __func__, final_address); + ret = fts_writeU8UX(FTS_CMD_CONFIG_W, BITS_16, final_address, data, + len); + if (ret < OK) { + logError(1, + "%s %s: Impossible to write Config Memory... ERROR %08X!\n", + tag, __func__, ret); + return ret; + } + + logError(0, "%s %s: Write config memory FINISHED!\n", 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 + */ +int fts_disableInterrupt(void) +{ + unsigned long flag; + + if (getClient() != NULL) { + spin_lock_irqsave(&fts_int, flag); + 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(getClient()->irq); + disable_irq_count++; + } + /* disable_irq is re-entrant so it is required to keep track + * of the number of calls of this when reenabling */ + spin_unlock_irqrestore(&fts_int, flag); + logError(0, "%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 + */ +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++; + } + /* disable_irq is re-entrant so it is required to keep track + * of the number of calls of this when reenabling */ + + spin_unlock(&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 + */ +int fts_enableInterrupt(void) +{ + unsigned long flag; + + if (getClient() != NULL) { + spin_lock_irqsave(&fts_int, flag); + logError(0, "%s Number of re-enable = %d\n", tag, + disable_irq_count); + while (disable_irq_count > 0) { + /* loop N times according on the pending number of + * disable_irq to truly re-enable the int */ + logError(0, "%s Executing Enable...\n", tag); + enable_irq(getClient()->irq); + disable_irq_count--; + } + + spin_unlock_irqrestore(&fts_int, flag); + logError(0, "%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); + /* read 2 bytes because the first one is a dummy byte! */ + 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) { /* CRC error if crc_status!=0 */ + 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 + */ +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(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) && + (readData[1] == type)) + 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++; + msleep(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; +} + + +/** + * Save MP flag value into the flash + * @param mpflag Value to write in the MP Flag field + * @return OK if success or an error code which specify the type of error + */ +int saveMpFlag(u8 mpflag) +{ + int ret; + + logError(1, "%s %s: Saving MP Flag = %02X\n", tag, __func__, mpflag); + ret = writeSysCmd(SYS_CMD_MP_FLAG, &mpflag, 1); + if (ret < OK) { + logError(1, "%s %s: Error while writing MP flag on ram... ERROR %08X\n", + tag, __func__, ret); + return ret; + } + + mpflag = SAVE_PANEL_CONF; + ret = writeSysCmd(SYS_CMD_SAVE_FLASH, &mpflag, 1); + if (ret < OK) { + logError(1, "%s %s: Error while saving MP flag on flash... ERROR %08X\n", + tag, __func__, ret); + return ret; + } + + ret = readSysInfo(1); + if (ret < OK) { + logError(1, "%s %s: Error while refreshing SysInfo... ERROR %08X\n", + tag, __func__, ret); + return ret; + } + + logError(1, "%s %s: Saving MP Flag OK!\n", tag, __func__); + return OK; +} diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCore.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCore.h new file mode 100644 index 000000000000..3ffe21df319b --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsCore.h @@ -0,0 +1,219 @@ +/* + * + ************************************************************************** + ** 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 */ + +/** + * 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 + * @{ + */ +/* Size in bytes of System Info data */ +#define SYS_INFO_SIZE 216 /* Num bytes of die info */ +#define DIE_INFO_SIZE 16 /* Num bytes of external release + * in config */ +#define EXTERNAL_RELEASE_INFO_SIZE 8 /* Num bytes of release info in + * sys info + * (first bytes are external + *release) */ +#define RELEASE_INFO_SIZE (EXTERNAL_RELEASE_INFO_SIZE) +/** @}*/ + +/* 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 */ + +/** @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_cfgProjectId; /* /< 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 */ + u8 u8_mpFlag; /* /< MP Flag */ + u8 u8_ssDetScanSet; /* /< Type of Detect Scan Selected */ + + 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 */ + u32 u32_productionTimestamp; /* /< Production Timestamp */ + + 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 */ + + u16 u16_ssDetRawAddr; /* /< Offset of SS detect raw frame */ + u16 u16_ssDetFilterAddr; /* /< Offset of SS detect filter + * frame */ + u16 u16_ssDetStrenAddr; /* /< Offset of SS detect strength + * frame */ + u16 u16_ssDetBaselineAddr; /* /< Offset of SS detect 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 writeConfig(u16 offset, u8 *data, 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 saveMpFlag(u8 mpflag); + +#endif /* FTS_CORE_H */ diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.c new file mode 100644 index 000000000000..9b16c3d5aa6f --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.c @@ -0,0 +1,371 @@ +/* + * + ************************************************************************** + ** 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; /* /< private variable which implement the Error + * List */ + +/** + * 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 + */ +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(1, "%s errorHandler: Starting handling...\n", tag); + addErrorIntoList(event, size); + switch (event[1]) { /* TODO: write an error log for + * undefined command subtype 0xBA */ + case EVT_TYPE_ERROR_ESD: /* 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: /* 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(1, "%s errorHandler: No Action taken!\n", tag); + break; + } + logError(1, "%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); + /* if count is not considered is better reset also the list in order to + * avoid to read data previously copied into the list */ + 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; +} + +/* in case of success return the index of the event found */ +/** + * 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(1, "%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; /* there is i++ at the end of the while */ + } else { + logError(1, "%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(1, "%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(1, + "%s %s: Error Type Not Found into ErrorList! ERROR %08X\n", + tag, __func__, ERROR_TIMEOUT); + return ERROR_TIMEOUT; + } +} diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.h new file mode 100644 index 000000000000..3d44ee12d812 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsError.h @@ -0,0 +1,236 @@ +/* + * + ************************************************************************** + ** 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 read + * 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 + * 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 read + * 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 + * 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 MS + * or SS tuning_version + * */ +/** @}*/ + +/** @}*/ /* end of error_commands section */ + +/** + * 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; + +/* #define logError(_l, _msg, ...) pr_err(_msg, ##__VA_ARGS__) */ +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/stmicro_mmi/fts_lib/ftsFlash.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFlash.c new file mode 100644 index 000000000000..610c181cee8b --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFlash.c @@ -0,0 +1,1146 @@ +/* + * + ************************************************************************** + ** 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" /* needed for including the define FW_H_FILE */ + + +#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; /* /< forward declaration of the global variable + * of containing System Info Data */ + + +/** + * 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 + */ +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 = PATH_FILE_FW; + } + /* keep the switch case because if the argument passed is null but + * the option from .h is not set we still try to load from bin */ + 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 + */ +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 + */ +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 + */ +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(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 /* in case of spi there is a dummy byte */ + res = readData[0] & 0x80; +#else + res = readData[1] & 0x80; +#endif + + logError(0, "%s flash status = %d\n", tag, res); + } + msleep(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 + */ +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) + /* configure manually SPI4 because when no fw is running the chip use + * SPI3 by default */ + 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; + } + msleep(1); /* wait for the GPIO to stabilize */ +#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 + */ +int parseBinFile(u8 *fw_data, int fw_size, Firmware *fwData, int keep_cx) +{ + int dimension, index = 0; + u32 temp; + int res, i; + + /* the file should contain at least the header plus the content_crc */ + 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 { + /* start parsing of bytes */ + 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; /* skip reserved data */ + + 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"); + + /* index+=FW_BYTES_ALLIGN; */ + 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;/* skip header crc */ + + /* if (!keep_cx) */ + /* { */ + dimension = fwData->sec0_size + fwData->sec1_size + + fwData->sec2_size + fwData->sec3_size; + temp = fw_size; + /*} else + * { + * dimension = fwData->sec0_size + fwData->sec1_size; + * temp = fw_size - fwData->sec2_size - fwData->sec3_size; + * fwData->sec2_size = 0; + * fwData->sec3_size = 0; + * }*/ + + 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; + + index = FLASH_ORG_INFO_INDEX; + fwData->fw_code_size = fw_data[index++]; + fwData->panel_config_size = fw_data[index++]; + fwData->cx_area_size = fw_data[index++]; + fwData->fw_config_size = fw_data[index]; + + logError(0, "%s Code Pages: %d panel area Pages: %d" + " cx area Pages: %d fw config Pages: %d !\n", tag, + fwData->fw_code_size, fwData->panel_config_size, + fwData->cx_area_size, fwData->fw_config_size); + + if((fwData->fw_code_size == 0) || + (fwData->panel_config_size == 0) || + (fwData->cx_area_size == 0) || + (fwData->fw_config_size == 0)) + { + logError(0, "%s Using default flash Address\n", tag); + fwData->code_start_addr = FLASH_ADDR_CODE; + fwData->cx_start_addr = FLASH_ADDR_CX; + fwData->config_start_addr = FLASH_ADDR_CONFIG; + } + + else + { + fwData->code_start_addr = FLASH_ADDR_CODE; + fwData->cx_start_addr = (FLASH_ADDR_CODE + + (((fwData->fw_code_size + + fwData->panel_config_size) * + FLASH_PAGE_SIZE) / 4)); + fwData->config_start_addr = (FLASH_ADDR_CODE + + (((fwData->fw_code_size + + fwData->panel_config_size + + fwData->cx_area_size) * + FLASH_PAGE_SIZE) / 4)); + } + + logError(0, "%s Code start addr: 0x%08X cx start addr: 0x%08X" + " fw start addr: 0x%08X !\n", tag, + fwData->code_start_addr, fwData->cx_start_addr, + fwData->config_start_addr); + + 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(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(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(cmd, ARRAY_SIZE(cmd)) < OK) { + logError(1, "%s flash_unlock: ERROR %08X\n", tag, ERROR_BUS_W); + return ERROR_BUS_W; + } + + if (fts_write(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 + */ +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(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 + */ +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(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(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; + /* Flash not ready within the chosen time, better exit! */ + } + + 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 + * @param fw raw FW data loaded from system + * @return OK if success or an error code which specify the type of error + */ +int flash_erase_page_by_page(ErasePage keep_cx, Firmware *fw) +{ + u8 status, i = 0; + u8 flash_cx_start_page = FLASH_CX_PAGE_START; + u8 flash_cx_end_page = FLASH_CX_PAGE_END; + u8 flash_panel_start_page = FLASH_PANEL_PAGE_START; + u8 flash_panel_end_page = FLASH_PANEL_PAGE_END; + + 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 }; + + if ((fw->fw_code_size == 0) || (fw->panel_config_size == 0) || (fw->cx_area_size == 0) || (fw->fw_config_size == 0)) + { + logError(0, "%s using default page addresses!\n", tag); + } + + else + { + flash_panel_start_page = fw->fw_code_size; + if (fw->panel_config_size > 1) + flash_panel_end_page = flash_panel_start_page + (fw->panel_config_size - 1); + else + flash_panel_end_page = flash_panel_start_page; + + flash_cx_start_page = flash_panel_end_page + 1; + if (fw->cx_area_size > 1) + flash_cx_end_page = flash_cx_start_page + (fw->cx_area_size - 1); + else + flash_cx_end_page = flash_cx_start_page; + } + + logError(0, "%s CX Start page: %d CX end page: %d Panel Start Page: %d Panel End page: %d!\n", tag, flash_cx_start_page, flash_cx_end_page, + flash_panel_start_page, flash_panel_end_page); + + for (i = flash_cx_start_page; i <= flash_cx_end_page && 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_start_page; i <= flash_panel_end_page && 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); + 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(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(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(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; + /* Flash not ready within the chosen time, better exit! */ + } + + 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 + */ +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 }; + + /* write the command to erase the flash */ + + logError(0, "%s Command flash DMA ...\n", tag); + if (fts_write(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; + /* Flash not ready within the chosen time, better exit! */ + } + + 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 + */ +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) { + /* logError(1, "%s fillFlash: 1\n", + * tag); */ + toWrite = DMA_CHUNK; + remaining -= DMA_CHUNK; + byteBlock += DMA_CHUNK; + } else { + /* logError(1, "%s fillFlash: 2\n", + * tag); */ + delta = FLASH_CHUNK - byteBlock; + toWrite = delta; + remaining -= delta; + byteBlock += delta; + } + } else { + if ((byteBlock + remaining) <= FLASH_CHUNK) { + /* logError(1, "%s fillFlash: 3\n", + * tag); */ + toWrite = remaining; + byteBlock += remaining; + remaining = 0; + } else { + /* logError(1, "%s fillFlash: 4\n", + * tag); */ + 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); + /* logError(0, "%s Command = %02X , address = %02X %02X + * , bytes = %d, data = %02X %02X, %02X %02X\n", + * tag, buff[0], buff[1], buff[2], toWrite, buff[3], + * buff[4], buff[3 + toWrite-2], + * buff[3 + toWrite-1]); */ + if (fts_write(buff, index + toWrite) < OK) { + logError(1, "%s fillFlash: ERROR %08X\n", tag, + ERROR_BUS_W); + kfree(buff); + return ERROR_BUS_W; + } + + /* msleep(10); */ + addr += toWrite; + data += toWrite; + } + + + /* configuring the DMA */ + 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(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 + */ +int flash_burn(Firmware fw, int force_burn, int keep_cx) +{ + int res; + + + if (!force_burn) { + 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 matches(or later) the firmware to flash! NO UPDATE ERROR %08X\n", + tag, ERROR_FW_NO_UPDATE); + return ERROR_FW_NO_UPDATE | ERROR_FLASH_BURN_FAILED; + } else { + /* burn procedure to update the CX memory, if not present just + * skip it if there isn't a new fw release. */ + 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; + /* Avoid loading the CX because it is missing + * in the bin file, it just need to update + * to last fw+cfg because a new release */ + 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; + } + } + + /* programming procedure start */ +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 there is no firmware, there is no controller ready event + * and there will be a timeout, we can keep going. But if + * there is an I2C error, we must exit. + */ + 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(100); /* 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, &fw); + else + res = flash_erase_page_by_page(SKIP_PANEL_CX_INIT, &fw); + } else { + res = flash_erase_page_by_page(SKIP_PANEL_INIT, &fw); + 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(fw.code_start_addr, &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(fw.config_start_addr, &(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 && (force_burn == CRC_CX || keep_cx <= 0)) { + logError(0, "%s 8.1) LOAD CX:\n", tag); + res = fillFlash(fw.cx_start_addr, + &(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]) { + /* External release is printed during readSysInfo */ + 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/stmicro_mmi/fts_lib/ftsFlash.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFlash.h new file mode 100644 index 000000000000..a41d36da4b8f --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFlash.h @@ -0,0 +1,142 @@ +/* + * + ************************************************************************** + ** 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 status + * readings */ + + +#ifdef FW_H_FILE +#define PATH_FILE_FW "NULL" +#else +#define PATH_FILE_FW "st_fts.ftb" /* /< new FW bin file name */ +#endif + + +#ifdef ALIX +#define FLASH_CHUNK (32 * 1024) /* /< Max number of bytes that + * the + * DMA can burn on the flash in + *one shot in FTI */ +#else +#define FLASH_CHUNK (64 * 1024) /* /< Max number of bytes that + * the + * DMA can burn on the flash in + *one shot in FTI */ +#endif + + +#define DMA_CHUNK 32 /* /< Max number of bytes that can be + * written in I2C to the DMA */ + +#define FLASH_ORG_INFO_INDEX 280 + +#define FLASH_PAGE_SIZE (4 * 1024) //page size of 4KB + +/** + * 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 */ + u8 fw_code_size; /* /< size of fw code in pages in + .ftb file */ + u8 panel_config_size;/* /< size of panel area in pages in + .ftb file */ + u8 cx_area_size;/* /< size of cx area in pages in + .ftb file */ + u8 fw_config_size;/* /< size of fw config in pages in + .ftb file */ + u32 code_start_addr; /* start addr for fw code */ + u32 cx_start_addr; /* start addr for cx area */ + u32 config_start_addr; /* start addr for config area */ +} 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, Firmware *fw); +int start_flash_dma(void); +int fillFlash(u32 address, u8 *data, int size); + +int flash_unlock(void); +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/stmicro_mmi/fts_lib/ftsFrame.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFrame.c new file mode 100644 index 000000000000..537fb1ef7c3a --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFrame.c @@ -0,0 +1,698 @@ +/* + * + ************************************************************************** + ** 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; /* /< forward declaration of the global variable + * of containing System Info Data */ + + +/** + * Read the channels lengths from the config memory + * @return OK if success or an error code which specify the type of error + */ +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 + */ +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 > 0 if success specifying the number of node into the frame or + * an error code which specify the type of error + */ +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; + } + /* if you want to access one node i,j, + * compute the offset like: offset = i*columns + j = > frame[i, j] */ + + logError(0, "%s Frame acquired!\n", tag); + return frame->node_data_size; + /* return the number of data put inside frame */ +} + +/** + * 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 > 0 if success specifying the number of node into frame or an + * error code which specify the type of error + */ +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(); /* use getForce/SenseLen + * because introduce a + * recover mechanism in + * case of len =0 */ + 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; + case SS_DETECT_RAW: + if (systemInfo.u8_ssDetScanSet == 0) { + offset_force = systemInfo.u16_ssDetRawAddr; + offset_sense = 0; + frame->header.sense_node = 0; + } else { + offset_sense = systemInfo.u16_ssDetRawAddr; + offset_force = 0; + frame->header.force_node = 0; + } + break; + + case SS_DETECT_FILTER: + if (systemInfo.u8_ssDetScanSet == 0) { + offset_force = systemInfo.u16_ssDetFilterAddr; + offset_sense = 0; + frame->header.sense_node = 0; + } else { + offset_sense = systemInfo.u16_ssDetFilterAddr; + offset_force = 0; + frame->header.force_node = 0; + } + break; + + case SS_DETECT_BASELINE: + if (systemInfo.u8_ssDetScanSet == 0) { + offset_force = systemInfo.u16_ssDetBaselineAddr; + offset_sense = 0; + frame->header.sense_node = 0; + } else { + offset_sense = systemInfo.u16_ssDetBaselineAddr; + offset_force = 0; + frame->header.force_node = 0; + } + break; + + case SS_DETECT_STRENGTH: + if (systemInfo.u8_ssDetScanSet == 0) { + offset_force = systemInfo.u16_ssDetStrenAddr; + offset_sense = 0; + frame->header.sense_node = 0; + } else { + offset_sense = systemInfo.u16_ssDetStrenAddr; + offset_force = 0; + frame->header.force_node = 0; + } + 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; + } + /* if you want to access one node i,j, you should compute the offset + * like: offset = i*columns + j = > frame[i, j] */ + + logError(0, "%s Frame acquired!\n", tag); + return frame->header.force_node + frame->header.sense_node; + /* return the number of data put inside frame */ +} + + +/** + * 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 msHeader pointer to DataHeader variable which will contain the header + * info for the MS frame + * @param ssHeader pointer to DataHeader variable which will contain the header + * info for the SS frame + * @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 + */ +int readSyncDataHeader(u8 type, DataHeader *msHeader, DataHeader *ssHeader, + u64 *address) +{ + u64 offset = ADDR_FRAMEBUFFER; + u8 data[SYNCFRAME_DATA_HEADER]; + int ret; + + ret = fts_writeReadU8UX(FTS_CMD_FRAMEBUFFER_R, BITS_16, offset, data, + SYNCFRAME_DATA_HEADER, DUMMY_FRAMEBUFFER); + if (ret < OK) { /* i2c function have already a retry mechanism */ + 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 SyncFrame data OK!\n", tag, type); + + msHeader->force_node = data[5]; + msHeader->sense_node = data[6]; + logError(0, "%s MS Frame force_node = %d, sense_node = %d\n", tag, + msHeader->force_node, msHeader->sense_node); + + ssHeader->force_node = data[7]; + ssHeader->sense_node = data[8]; + logError(0, "%s SS Frame force_node = %d, sense_node = %d\n", tag, + ssHeader->force_node, ssHeader->sense_node); + + *address = offset + SYNCFRAME_DATA_HEADER + data[4]; + + return OK; +} + +/** + * Read a Sync Frame from frame buffer which contain MS and SS data collected + *for the same scan + * @param type type of Sync frame to read, possible values: + * LOAD_SYNC_FRAME_RAW, LOAD_SYNC_FRAME_FILTER, LOAD_SYNC_FRAME_BASELINE, + * LOAD_SYNC_FRAME_STRENGTH + * @param msFrame pointer to MutualSenseFrame variable which will contain the + *MS data + * @param ssFrame pointer to SelfSenseFrame variable which will contain the SS + *data + * @return >0 if success specifying the total number of nodes copied into + * msFrame and ssFrame or an error code which specify the type of error + */ +int getSyncFrame(u8 type, MutualSenseFrame *msFrame, SelfSenseFrame *ssFrame) +{ + int res; + u64 address; + + msFrame->node_data = NULL; + ssFrame->force_data = NULL; + ssFrame->sense_data = NULL; + + logError(0, "%s %s: Starting to get Sync Frame %02X...\n", tag, + __func__, type); + switch (type) { + case LOAD_SYNC_FRAME_RAW: + msFrame->header.type = MS_RAW; + ssFrame->header.type = SS_RAW; + break; + + case LOAD_SYNC_FRAME_FILTER: + msFrame->header.type = MS_FILTER; + ssFrame->header.type = SS_FILTER; + break; + + case LOAD_SYNC_FRAME_BASELINE: + msFrame->header.type = MS_BASELINE; + ssFrame->header.type = SS_BASELINE; + break; + + case LOAD_SYNC_FRAME_STRENGTH: + msFrame->header.type = MS_STRENGTH; + ssFrame->header.type = SS_STRENGTH; + break; + + default: + return ERROR_OP_NOT_ALLOW | ERROR_GET_FRAME; + } + + logError(0, "%s %s: Requesting Sync Frame %02X...\n", tag, __func__, + type); + res = requestSyncFrame(type); + if (res < OK) { + logError(1, + "%s %s: error while requesting Sync Frame ERROR %08X\n", + tag, + __func__, res | ERROR_GET_FRAME_DATA); + return res | ERROR_GET_FRAME_DATA; + } + + res = readSyncDataHeader(type, &(msFrame->header), &(ssFrame->header), + &address); + if (res < OK) { + logError(1, + "%s %s: error while reading Sync Frame header... ERROR %08X\n", + tag, __func__, res | ERROR_GET_FRAME_DATA); + return res | ERROR_GET_FRAME_DATA; + } + + msFrame->node_data_size = msFrame->header.force_node * + msFrame->header.sense_node; + + msFrame->node_data = (short *)kmalloc(msFrame->node_data_size * + sizeof(short), GFP_KERNEL); + if (msFrame->node_data == NULL) { + logError(1, + "%s %s: impossible allocate memory for MS frame... ERROR %08X\n", + tag, __func__, ERROR_ALLOC | ERROR_GET_FRAME); + return ERROR_ALLOC | ERROR_GET_FRAME; + } + + logError(0, "%s %s: Getting MS frame at %04llX...\n", tag, __func__, + address); + res = getFrameData(address, (msFrame->node_data_size) * BYTES_PER_NODE, + (msFrame->node_data)); + if (res < OK) { + logError(1, "%s %s: error while getting MS data...ERROR %08X\n", + tag, __func__, res); + res |= ERROR_GET_FRAME_DATA | ERROR_GET_FRAME; + goto ERROR; + } + + /* move the offset */ + address += (msFrame->node_data_size) * BYTES_PER_NODE; + + ssFrame->force_data = (short *)kmalloc(ssFrame->header.force_node * + sizeof(short), GFP_KERNEL); + if (ssFrame->force_data == NULL) { + logError(1, + "%s %s: impossible allocate memory for SS force frame...ERROR %08X\n", + tag, __func__, ERROR_ALLOC | ERROR_GET_FRAME); + res = ERROR_ALLOC | ERROR_GET_FRAME; + goto ERROR; + } + + logError(0, "%s %s: Getting SS force frame at %04llX...\n", tag, __func__, + address); + res = getFrameData(address, (ssFrame->header.force_node) * + BYTES_PER_NODE, (ssFrame->force_data)); + if (res < OK) { + logError(1, + "%s %s: error while getting SS force data...ERROR %08X\n", + tag, + __func__, res); + res |= ERROR_GET_FRAME_DATA | ERROR_GET_FRAME; + goto ERROR; + } + + /* move the offset */ + address += (ssFrame->header.force_node) * BYTES_PER_NODE; + + ssFrame->sense_data = (short *)kmalloc(ssFrame->header.sense_node * + sizeof(short), GFP_KERNEL); + if (ssFrame->sense_data == NULL) { + logError(1, + "%s %s: impossible allocate memory for SS sense frame...ERROR %08X\n", + tag, __func__, ERROR_ALLOC | ERROR_GET_FRAME); + res = ERROR_ALLOC | ERROR_GET_FRAME; + goto ERROR; + } + + logError(0, "%s %s: Getting SS sense frame at %04llX...\n", tag, __func__, + address); + res = getFrameData(address, (ssFrame->header.sense_node) * + BYTES_PER_NODE, (ssFrame->sense_data)); + if (res < OK) { + logError(1, + "%s %s: error while getting SS sense data...ERROR %08X\n", + tag, + __func__, res); + res |= ERROR_GET_FRAME_DATA | ERROR_GET_FRAME; + goto ERROR; + } + +ERROR: + if (res < OK) { + if (msFrame->node_data != NULL) { + kfree(msFrame->node_data); + msFrame->node_data = NULL; + } + + if (ssFrame->force_data != NULL) { + kfree(ssFrame->force_data); + ssFrame->force_data = NULL; + } + + if (ssFrame->sense_data != NULL) { + kfree(ssFrame->sense_data); + ssFrame->sense_data = NULL; + } + logError(0, "Getting Sync Frame FAILED! ERROR %08X!\n", res); + } else { + logError(0, "Getting Sync Frame FINISHED!\n"); + res = msFrame->node_data_size + ssFrame->header.force_node + + ssFrame->header.sense_node; + } + return res; +} diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFrame.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFrame.h new file mode 100644 index 000000000000..446dd7527bfe --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsFrame.h @@ -0,0 +1,114 @@ +/* + * + ************************************************************************** + ** 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" +#include "ftsCore.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 */ +#define SYNCFRAME_DATA_HEADER (DATA_HEADER + 12) /* /< number of bytes of + * Sync Frame Header */ +/** + * 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 */ + + SS_DETECT_RAW = 12, /* /< Self Sense Detect Raw Frame */ + SS_DETECT_FILTER = 13, /* /< Self Sense Detect Filter Frame */ + SS_DETECT_STRENGTH = 14, /* /< Self Sense Detect Strength Frame */ + SS_DETECT_BASELINE = 15 /* /< Self Sense Detect 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); +int getSyncFrame(u8 type, MutualSenseFrame *msFrame, SelfSenseFrame *ssFrame); +#endif diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsGesture.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsGesture.c new file mode 100644 index 000000000000..55ff6d38f9f8 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsGesture.c @@ -0,0 +1,405 @@ +/* + * + ************************************************************************** + ** 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" + +/* /< store the gesture bitmask which the host want to enable. + * If bit set 1 the corresponding gesture will be detected in Gesture Mode */ +static u8 gesture_mask[GESTURE_MASK_SIZE] = { 0 }; +/* /< store the x coordinates of the points draw by the user + * when a gesture is detected */ +u16 gesture_coordinates_x[GESTURE_MAX_COORDS_PAIRS_REPORT] = { 0 }; +/* /< store the y coordinates of the points draw by the user + * when a gesture is detected */ +u16 gesture_coordinates_y[GESTURE_MAX_COORDS_PAIRS_REPORT] = { 0 }; +/* /< number of coordinates pairs (points) reported with the detected gesture */ +int gesture_coords_reported = ERROR_OP_NOT_ALLOW; +static u8 refreshGestureMask; /* /< flag which indicate if there is + * the need to set the gesture mask in the FW */ +struct mutex gestureMask_mutex; /* /< mutex used to control access on gesture + * shared variables */ + +/** + * 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 + */ +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]; + /* back up of the gesture enabled */ + 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]; + /* enabled XOR disabled */ + gesture_mask[i] = temp & + gesture_mask[i]; + /* temp AND enabled + * disable the gestures that were + * enabled */ + } + logError(0, + "%s updateGestureMask: gesture mask to disable SET!\n", + tag); + refreshGestureMask = 1; + mutex_unlock(&gestureMask_mutex); + return OK; + } else { + logError(1, + "%s updateGestureMask: Enable parameter Invalid! %d != %d or %d ERROR %08X\n", + tag, en, 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, + ERROR_OP_NOT_ALLOW); + 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 + */ +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]; + /* back up of the gesture enabled */ + + 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, ERROR_OP_NOT_ALLOW); + 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 + */ +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]; + /* enabled mask XOR disabled mask */ + gesture_mask[i] = temp & gesture_mask[i]; + /* temp AND enabled + * disable the gestures that are specified and + * previously enabled */ + } + + pointer = gesture_mask; + } else { + i = 0; /* if NULL is passed disable all the possible + * gestures */ + 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, ERROR_OP_NOT_ALLOW); + 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 + */ +int enterGestureMode(int reload) +{ + int res, ret; + + res = fts_disableInterrupt(); + 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) + /* -1 because in any case the last gesture mask byte will + * be evaluated with the following if */ + 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 + */ +int readGestureCoords(u8 *event) +{ + int i = 0; + u64 address = 0; + int res; + + u8 val[GESTURE_MAX_COORDS_PAIRS_REPORT * 4]; + + /* the max coordinates to read are GESTURE_COORDS_REPORT_MAX*4 + * (because each coordinate is a short(*2) and we have x and y) */ + + + if (event[0] == EVT_ID_USER_REPORT && event[1] == + EVT_TYPE_USER_GESTURE) { + address = (event[4] << 8) | event[3]; /* Offset in framebuff */ + gesture_coords_reported = event[5]; /* number of pairs + * coords reported */ + 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: %08llX , 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); + /* *2 because each coord is made by 2 bytes, + * *2 because there are x and y */ + 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; + } + + /* all the points of the gesture are stored in val */ + 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/stmicro_mmi/fts_lib/ftsGesture.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsGesture.h new file mode 100644 index 000000000000..cb59737f76a9 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsGesture.h @@ -0,0 +1,47 @@ +/* + * + ************************************************************************** + ** 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 /* /< number of bytes of the + * gesture mask */ + +#define GESTURE_MAX_COORDS_PAIRS_REPORT 100 /* /< max number of gestures + * coordinates pairs reported */ + + + +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 /* ! _GESTURE_H_ */ diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsHardware.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsHardware.h new file mode 100644 index 000000000000..58f1a55355f1 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsHardware.h @@ -0,0 +1,308 @@ +/* + * + ************************************************************************** + ** 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 ALIX + +#ifdef ALIX +#define DCHIP_ID_0 0x36 /* /< LSB chip ID for FTM5 */ +#define DCHIP_ID_1 0x48 /* /< MSB chip ID for FTM5 */ +#else +#define DCHIP_ID_0 0x36 /* /< LSB chip ID for FTM5 */ +#define DCHIP_ID_1 0x39 /* /< MSB chip ID for FTM5 */ +#endif + + +#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 + + +/* FLASH UVLO ENABLE PARAMETER */ +#define FLASH_UVLO_ENABLE_CODE0 0x1B +#define FLASH_UVLO_ENABLE_CODE1 0x66 + +/* FLASH AUTOPOWERDOWN ENABLE PARAMETER */ +#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_W 0xA6 /* /< command to write the framebuffer 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_W 0xA6 /* /< command to write the framebuffer 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 reg + * in FTI */ +#define SYSTEM_RESET_VALUE 0x81 /* /< 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 */ + + +/* 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 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/stmicro_mmi/fts_lib/ftsIO.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsIO.c new file mode 100644 index 000000000000..db8dea961042 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsIO.c @@ -0,0 +1,745 @@ +/* + * + ************************************************************************** + ** 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; /* /< slave address of the IC in the i2c bus */ +#else +#include +#endif + +static void *client; /* /< bus client retrived by the OS and + * used to execute the bus transfers */ + + + +#include "ftsCore.h" +#include "ftsError.h" +#include "ftsHardware.h" +#include "ftsIO.h" + + +/** + * 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(1, "%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 + 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() +{ + 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 + */ +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) + msleep(I2C_WAIT_BEFORE_RETRY); + /* logError(1,"%s fts_writeCmd: attempt %d\n", tag, 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 + */ +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]; + + /* write msg */ + I2CMsg[0].addr = (__u16)I2CSAD; + I2CMsg[0].flags = (__u16)0; + I2CMsg[0].len = (__u16)cmdLength; + I2CMsg[0].buf = (__u8 *)cmd; + + /* read msg */ + 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) + msleep(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 + */ +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) + msleep(I2C_WAIT_BEFORE_RETRY); + /* logError(1,"%s fts_writeCmd: attempt %d\n", tag, retry); */ + } + if (ret < 0) { + logError(1, "%s %s: ERROR %08X\n", tag, __func__, ERROR_BUS_W); + return ERROR_BUS_W; + } + return OK; +} + +/** + * 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 + */ +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) + msleep(I2C_WAIT_BEFORE_RETRY); + /* logError(1,"%s fts_writeCmd: attempt %d\n", tag, 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 + */ +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]; + + /* write msg */ + I2CMsg[0].addr = (__u16)I2CSAD; + I2CMsg[0].flags = (__u16)0; + I2CMsg[0].len = (__u16)writeCmdLength; + I2CMsg[0].buf = (__u8 *)writeCmd1; + + /* write msg */ + I2CMsg[1].addr = (__u16)I2CSAD; + I2CMsg[1].flags = (__u16)0; + I2CMsg[1].len = (__u16)readCmdLength; + I2CMsg[1].buf = (__u8 *)readCmd1; + + /* read msg */ + 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) + msleep(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 + */ +/* 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[1 + addrSize + WRITE_CHUNK]; + int remaining = dataSize; + int toWrite = 0, i = 0; + + 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); + return ERROR_BUS_W; + } + + address += toWrite; + + data += toWrite; + } + } else + logError(1, + "%s %s: address size bigger than max allowed %ld... ERROR %08X\n", + tag, __func__, sizeof(u64), ERROR_OP_NOT_ALLOW); + + 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 + */ +int fts_writeReadU8UX(u8 cmd, AddrSize addrSize, u64 address, u8 *outBuf, int + byteToRead, int hasDummyByte) +{ + u8 finalCmd[1 + addrSize]; + u8 buff[READ_CHUNK + 1];/* worst case has dummy byte */ + int remaining = byteToRead; + int toRead = 0, i = 0; + + 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); + 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); + return ERROR_BUS_WR; + } + memcpy(outBuf, buff, toRead); + } + + address += toRead; + + outBuf += toRead; + } + + 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 + */ +/* this function works only if the sum of two addresses in the two commands is + * max 8 bytes */ +int fts_writeU8UXthenWriteU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, AddrSize + addrSize2, u64 address, u8 *data, int dataSize) +{ + u8 finalCmd1[1 + addrSize1]; + u8 finalCmd2[1 + addrSize2 + WRITE_CHUNK]; + int remaining = dataSize; + int toWrite = 0, i = 0; + + 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); + return ERROR_BUS_W; + } + + if (fts_write(finalCmd2, 1 + addrSize2 + toWrite) < OK) { + logError(1, + "%s %s: second write error... ERROR %08X\n", + tag, + __func__, ERROR_BUS_W); + return ERROR_BUS_W; + } + + address += toWrite; + + data += toWrite; + } + + return OK; +} + +/** + * 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 + */ +/* this function works only if the sum of two addresses in the two commands is + * max 8 bytes */ +int fts_writeU8UXthenWriteReadU8UX(u8 cmd1, AddrSize addrSize1, u8 cmd2, + AddrSize addrSize2, u64 address, u8 *outBuf, + int byteToRead, int hasDummyByte) +{ + u8 finalCmd1[1 + addrSize1]; + u8 finalCmd2[1 + addrSize2]; + u8 buff[READ_CHUNK + 1];/* worst case has dummy byte */ + int remaining = byteToRead; + int toRead = 0, i = 0; + + + 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); + /* logError(1, "%s %s: finalCmd1[%d] = %02X\n", + * tag, __func__, i+1, finalCmd1[i + 1]); */ + + 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); + return ERROR_BUS_W; + } + + 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); + return ERROR_BUS_WR; + } + 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); + return ERROR_BUS_WR; + } + memcpy(outBuf, buff, toRead); + } + + address += toRead; + + outBuf += toRead; + } + + return OK; +} diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsIO.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsIO.h new file mode 100644 index 000000000000..4dd2b6c67649 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsIO.h @@ -0,0 +1,66 @@ +/* + * + ************************************************************************** + ** 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 /* /< number of retry in case of i2c + * failure */ +#define I2C_WAIT_BEFORE_RETRY 2 /* /< wait in ms before retry an i2c + * transaction */ + +#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 ****************/ +#ifdef I2C_INTERFACE +int changeSAD(u8 sad); +#endif +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_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/stmicro_mmi/fts_lib/ftsSoftware.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsSoftware.h new file mode 100644 index 000000000000..e3162ce45cea --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsSoftware.h @@ -0,0 +1,512 @@ +/* + * + ************************************************************************** + ** 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" + + + +/* unsigned types */ +typedef uint8_t u8; /* /< basic type that represent one byte (or 8 bits) */ +typedef uint16_t u16; /* /< basic type that represent 2 bytes (or 16 bits) */ +typedef uint32_t u32; /* /< basic type that represent 4 bytes (or 32 bits) */ +typedef uint64_t u64; /* /< basic type that represent 8 bytes (or 64 bits) */ + +/* signed type */ +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 *********************/ + +/* HOST COMMAND */ +/** @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 + * */ +/** @} */ + +/** @} */ /* end host_command group */ + +/* SCAN MODE OPTION (0xA0) */ +/* Scan mode selection */ +/** @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 */ +/** @}*/ + +/* Active mode option (bitmask) */ +/** @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 */ +/** @}*/ + + +/* Locked mode option (locked mode) */ +/** @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 */ +/** @}*/ + +/* FEATURE SELECT OPTION (0xA2) */ +/* Feature Selection */ +/** @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) */ +/** @}*/ + +/* Feature Settings */ +#define FEAT_ENABLE 1 /* /< General value to enable a feature + * */ +#define FEAT_DISABLE 0 /* /< General value to disable a feature + * */ + + +/* Charger */ +/** @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 */ +/** @}*/ + +/* Gestures */ +/** @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 /* /< '^' */ +/** @}*/ + +/* WRYTE SYSTEM COMMAND (0xA4) */ +/* System command */ +/** @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 */ +#define SYS_CMD_MP_FLAG 0x0C /* /< Update value of MP flag in RAM */ +/** @} */ + +/* System command settings */ +/* Special commands */ +/** @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 */ +/** @} */ + + +/* Force Cal and Cx auto tuning */ +/** @defgroup forcecal_cx_opt Force Cal and Tuning Option + * @ingroup sys_cmd + * Valid bitmask for triggering forcecal or performing manual autotune + * @{ + */ +#define CAL_MS_TOUCH 0x01 /* /< Mutual Sense Touch */ +#define CAL_MS_LOW_POWER 0x02 /* /< Mutual Sense Touch in low power + * mode */ +#define CAL_SS_TOUCH 0x04 /* /< Self Sense Touch */ +#define CAL_SS_IDLE 0x08 /* /< Self Sense Touch in idle mode */ +#define CAL_MS_KEY 0x10 /* /< Mutual Sense Key */ +#define CAL_SS_KEY 0x20 /* /< Self Sense Key */ +#define CAL_MS_FORCE 0x40 /* /< Mutual Sense Force */ +#define CAL_SS_FORCE 0x80 /* /< Self Sense Force */ +/** @} */ + +/* ITO checks (position of the bit in the mask) */ +/** @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 */ +/** @}*/ + +/* Save flash */ +/** @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 + * */ +/** @}*/ + +/* Load Data */ +/** @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_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 */ +/** @}*/ + +/* Special Tuning */ +/** @defgroup spcl_tun_opt Special Tuning Option + * @ingroup sys_cmd + * Valid special tuning operations which the fw can perform (bitmask) + * @{ + */ +#define SPECIAL_TUNING_LP_TIMER 0x01 /* /< Perform LP Timer calibration */ +#define SPECIAL_TUNING_IOFF 0x02 /* /< Perform Ioff calibration */ + +/** @}*/ + +/* EVENT ID */ +/** @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 */ + +/* /< Max number of unique event IDs supported */ +#define NUM_EVT_ID (((EVT_ID_ERROR & 0xF0) >> 4)+1) + +/** @}*/ + +/* STATUS TYPE */ +/** @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 + * */ +/** @} */ + +/* USER TYPE */ +/** @defgroup user_type User Event Types + * @ingroup events_group + * Types of EVT_ID_USER_REPORT events generated by the 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 */ +/** @}*/ + +/* ERROR TYPE */ +/** @defgroup error_type Error Event Types + * @ingroup events_group + * Types of EVT_ID_ERROR events reported by the FW + * @{ + */ +#define EVT_TYPE_ERROR_HARD_FAULT 0x02 /* /< Hard Fault */ +#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 */ +/** @}*/ + +/** @}*/ + +/** @defgroup mp_flags MP Flags value + * @ingroup mp_test + * Specify the MP flags value which are written into the flash after performing + * a full panel initialization which pass all the tests. + * @{ + */ + +#define MP_FLAG_FACTORY 0xA5 /* /< Full Panel Init done in factory */ +#define MP_FLAG_BOOT 0x5A /* /< Full Panel Init done at boot */ +#define MP_FLAG_OTHERS 0xFF /* /< Full Panel Init done somewhere + * else */ + +/** @}*/ + +/* ERROR INFO */ +#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 */ + +/* Touch Types */ +#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 */ + +/* Keys code */ +#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/stmicro_mmi/fts_lib/ftsTest.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTest.c new file mode 100644 index 000000000000..1cd84708af1c --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTest.c @@ -0,0 +1,7723 @@ +/* + * + ************************************************************************** + ** 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; /* /< global variable that specify the tests to perform during + * the Mass Production Test */ +static LimitFile limit_file; /* /< variable which contains the limit file + * during test */ + +/** + * 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); + +#ifndef COMPUTE_INIT_METHOD + tests.MutualRawAdjITO = 1; + + tests.MutualRaw = 1; + tests.MutualRawMap = 0; + tests.MutualRawGap = 0; + tests.MutualRawAdj = 0; + tests.MutualRawAdjGap = 0; + tests.MutualRawAdjPeak = 0; + + tests.MutualRawLP = 1; + tests.MutualRawGapLP = 0; + tests.MutualRawMapLP = 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 = 1; +#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 = 1; + 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.SelfForceIx1LP = 0; + tests.SelfForceIx2LP = 0; + tests.SelfForceIx2AdjLP = 0; + tests.SelfForceIxTotalLP = 1; + tests.SelfForceIxTotalAdjLP = 0; + tests.SelfForceCx1LP = 0; + tests.SelfForceCx2LP = 0; + tests.SelfForceCx2AdjLP = 0; + tests.SelfForceCxTotalLP = 0; + tests.SelfForceCxTotalAdjLP = 0; + + tests.SelfSenseRaw = 1; + tests.SelfSenseRawGap = 0; + + tests.SelfSenseRawLP = 1; + 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; + tests.SelfSenseIx1LP = 0; + tests.SelfSenseIx2LP = 0; + tests.SelfSenseIx2AdjLP = 0; + tests.SelfSenseIxTotalLP = 1; + tests.SelfSenseIxTotalAdjLP = 0; + tests.SelfSenseCx1LP = 0; + tests.SelfSenseCx2LP = 0; + tests.SelfSenseCx2AdjLP = 0; + tests.SelfSenseCxTotalLP = 0; + tests.SelfSenseCxTotalAdjLP = 0; +#else + tests.MutualRawAdjITO = 1; + + tests.MutualRaw = 1; /* in case of YOCTA please use Map */ + tests.MutualRawMap = 0; + tests.MutualRawGap = 0; + tests.MutualRawAdj = 0; + tests.MutualRawAdjGap = 0; + tests.MutualRawAdjPeak = 0; + + tests.MutualRawLP = 0; /* in case of YOCTA please use Map */ + tests.MutualRawGapLP = 0; + tests.MutualRawMapLP = 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; /* in case of YOCTA please use Map */ + tests.SelfForceRawGap = 0; + tests.SelfForceRawMap = 0; + + tests.SelfForceRawLP = 0; /* in case of YOCTA please use Map */ + tests.SelfForceRawGapLP = 0; + tests.SelfForceRawMapLP = 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.SelfForceIx1LP = 0; + tests.SelfForceIx2LP = 0; + tests.SelfForceIx2AdjLP = 0; + tests.SelfForceIxTotalLP = 0; + tests.SelfForceIxTotalAdjLP = 0; + tests.SelfForceCx1LP = 0; + tests.SelfForceCx2LP = 0; + tests.SelfForceCx2AdjLP = 0; + tests.SelfForceCxTotalLP = 0; + tests.SelfForceCxTotalAdjLP = 0; + + tests.SelfSenseRaw = 1; + tests.SelfSenseRawGap = 0; + tests.SelfSenseRawMap = 0; + + tests.SelfSenseRawLP = 1; + tests.SelfSenseRawGapLP = 0; + tests.SelfSenseRawMapLP = 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; + tests.SelfSenseIx1LP = 0; + tests.SelfSenseIx2LP = 0; + tests.SelfSenseIx2AdjLP = 0; + tests.SelfSenseIxTotalLP = 1; + tests.SelfSenseIxTotalAdjLP = 0; + tests.SelfSenseCx1LP = 0; + tests.SelfSenseCx2LP = 0; + tests.SelfSenseCx2AdjLP = 0; + tests.SelfSenseCxTotalLP = 0; + tests.SelfSenseCxTotalAdjLP = 0; +#endif + + 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 + */ +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 + */ +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 + */ +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 + */ +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 + */ +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 + */ +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 + */ +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 + */ +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; +} + + + +/** + * 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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 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 + * @param row_start index of the starting column which should be considered + * @param column_start index of the starting column which should be considered + * @param row_end number of index to subtract to row to identify last + * valid row to check + * @param column_end number of index to subtract to column to identify last + * valid column to check + * @return OK if the difference is <= to threshold otherwise + * ERROR_TEST_CHECK_FAIL + */ +int checkLimitsGapOffsets(short *data, int row, int column, int threshold, + int row_start, int column_start, int row_end, int column_end) +{ + 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[row_start*column+column_start]; + max_node = data[row_start*column+column_start]; + + for (i = row_start; i < row-row_end; i++) { + for (j = column_start; j < column-column_end; 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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++; + } + } + } + + return count; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * 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; /* if count is 0 = OK, test completed successfully */ +} + +/** + * Perform an ITO test setting all the possible options + * (see @link ito_opt ITO Options @endlink) and checking MS Raw ADJ if enabled + * @param path_limits name of Production Limit file to load or + * "NULL" if the limits data should be loaded by a .h file + * @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_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(0, "%s ITO Production test is starting...\n", tag); + + 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); + + logError(0, "%s MS RAW ITO ADJ TEST:\n", tag); + if (todo->MutualRawAdjITO == 1) { + 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); + if (adj != NULL) + kfree(adj); + if (msRawFrame.node_data != NULL) + kfree(msRawFrame.node_data); + 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 + */ +int production_test_initialization(u8 type) +{ + int res; + + logError(0, "%s INITIALIZATION Production test is starting...\n", tag); + 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); /* need to update the chipInfo in order + * to refresh several versions */ + + 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 + * @param mpflag MP flag value to write in case of successful test + * @return OK if success or an error code which specify the type of error + */ +int production_test_main(char *pathThresholds, int stop_on_fail, int saveInit, + TestToDo *todo, u8 mpflag) +{ + 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;/* in case of ITO TEST failure is no sense keep going + * */ + } 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 != NO_INIT) { + 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(0, "%s PRODUCTION DATA TEST:\n", tag); + ret = production_test_data(pathThresholds, stop_on_fail, todo); + if (ret < OK) + logError(0, + "%s Error during PRODUCTION DATA TEST! ERROR %08X\n", + tag, ret); + else { + logError(0, "%s PRODUCTION DATA TEST OK!\n", tag); + +#ifdef COMPUTE_INIT_METHOD + if (saveInit != NO_INIT) { + /* save the mp flag to desired value + * because data check OK */ + ret = saveMpFlag(mpflag); + if (ret < OK) + logError(0, + "%s Error while saving MP FLAG! ERROR %08X\n", + tag, ret); + else + logError(0, "%s MP FLAG saving OK!\n", tag); + } +#endif + + } + + res |= ret; + /* the OR is important because if the data test is OK but + * the init test fail, the main production test result should = FAIL */ + + +END: + if (res < OK) { + 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 + */ +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 trows, tcolumns; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + u16 *adj = NULL; + + int maxAdjH, maxAdjV; + int i, z; + + msRawFrame.node_data = NULL; + + /************** Mutual Sense Test *************/ + logError(0, "%s\n", tag); + logError(0, "%s MS RAW DATA TEST is starting...\n", tag); + if (todo->MutualRaw == 1 || todo->MutualRawGap == 1 || + todo->MutualRawAdj == 1 || todo->MutualRawMap == 1 || + todo->MutualRawAdjGap == 1 || todo->MutualRawAdjPeak == 1) { + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(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; + } + + logError(0, "%s MS RAW MIN MAX TEST:\n", tag); + if (todo->MutualRaw == 1) { + 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); + logError(0, "%s MS RAW MAP MIN MAX TEST:\n", tag); + if (todo->MutualRawMap == 1) { + 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 MAP MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else{ + logError(0, "%s MS RAW MAP MIN 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 MAP MIN MAX TEST:.................SKIPPED\n", tag); + } + + logError(0, "%s\n", tag); + logError(0, "%s MS RAW GAP TEST:\n", tag); + if (todo->MutualRawGap == 1) { + 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); + logError(0, "%s MS RAW ADJ TEST:\n", tag); + if ((todo->MutualRawAdj == 1) || (todo->MutualRawAdjGap == 1) || + (todo->MutualRawAdjPeak == 1)) { + logError(0, "%s MS RAW ADJ HORIZONTAL TESTs:\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; + } + + if (todo->MutualRawAdj) { + logError(0, "%s MS RAW ADJ HORIZONTAL min/Max:\n", + tag); + + 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 min/Max:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ HORIZONTAL min/Max:.................OK\n", + tag); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + } + + + if (todo->MutualRawAdjGap) { + logError(0, "%s MS RAW ADJ HORIZONTAL GAP:\n", + tag); + + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_RAW_ADJH_GAP, + &thresholds, &trows, + &tcolumns); + if (ret < OK || (trows != 1 || + tcolumns != 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 = checkLimitsGapOffsets(adj, + msRawFrame.header. + force_node, + msRawFrame.header. + sense_node - 1, + thresholds[0], + 1,1,1,1); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJH GAP failed...\n", + tag); + logError(0, + "%s MS RAW ADJ HORIZONTAL GAP:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ HORIZONTAL GAP:.................OK\n", + tag); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + } + + + if (todo->MutualRawAdjPeak) { + logError(0, "%s MS RAW ADJ Peak: Getting max ADJH\n", + tag); + maxAdjH = abs(adj[msRawFrame.header.force_node + + 1]); + /* skip nodes on the edges */ + for (i = 1; i < msRawFrame.header + .force_node - 1; i++) { + for (z = 1; z < + (msRawFrame.header + .sense_node - 2); z++){ + if (maxAdjH < abs(adj[(i * + msRawFrame.header + .force_node) + z])) + maxAdjH = abs(adj[(i * + msRawFrame.header + .force_node) + z]); + } + + } + } + + kfree(adj); + adj = NULL; + + logError(0, "%s MS RAW ADJ VERTICAL TESTs:\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; + } + + if (todo->MutualRawAdj) { + logError(0, "%s MS RAW ADJ VERTICAL min/Max:\n", + tag); + 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 min/Max:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ VERTICAL min/Max:.................OK\n", + tag); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + } + + if (todo->MutualRawAdjGap) { + logError(0, "%s MS RAW ADJ VERTICAL GAP:\n", + tag); + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_RAW_ADJV_GAP, + &thresholds, &trows, + &tcolumns); + if (ret < OK || (trows != 1 || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_ADJV_GAP failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + + ret = checkLimitsGapOffsets(adj, + msRawFrame.header. + force_node - 1, + msRawFrame.header. + sense_node, + thresholds[0], + 1,1,1,1); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJV GAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS RAW ADJ VERTICAL GAP:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ VERTICAL GAP:.................OK\n", + tag); + + if (thresholds != NULL) { + kfree(thresholds); + thresholds = NULL; + } + } + + + if (todo->MutualRawAdjPeak) { + logError(0, "%s MS RAW ADJ Peak: Getting max ADJV\n", + tag); + maxAdjV = abs(adj[(msRawFrame.header.force_node) + + 1]); + + /* skip nodes on the edges */ + for (i = 1; i < (msRawFrame.header + .force_node - 2); i++) { + for (z = 1; z < msRawFrame.header + .sense_node - 1; z++) { + if (maxAdjV < abs(adj[(i * + msRawFrame.header + .force_node) + z])) + maxAdjV = abs(adj[(i * + msRawFrame.header + .force_node) + z]); + + } + } + + + + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_RAW_ADJ_PEAK, + &thresholds, &trows, + &tcolumns); + if (ret < OK || (trows != 1 || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits MS_RAW_ADJV_PEAK failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + logError(1, "%s maxAdjH = %d maxAdjV = %d threshold = %d\n", + tag, maxAdjH, maxAdjV, thresholds[0]); + + ret = OK; + if (maxAdjH > maxAdjV) { + if (maxAdjH > thresholds[0]) + ret = ERROR_PROD_TEST_DATA; + } else { + if (maxAdjV > thresholds[0]) + ret = ERROR_PROD_TEST_DATA; + } + + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsAdj MS RAW ADJV GAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s MS RAW ADJ PEAK:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else + logError(0, + "%s MS RAW ADJ PEAK:.................OK\n", + tag); + + if (thresholds != NULL) { + 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 DATA TEST:.................SKIPPED\n", + tag); + + logError(0, "%s\n", tag); + logError(0, "%s MS KEY RAW TEST:\n", tag); + if (todo->MutualKeyRaw == 1) { + 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); + if (thresholds != NULL) + kfree(thresholds); + if (adj != NULL) + kfree(adj); + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = 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); + if (thresholds != NULL) + kfree(thresholds); + 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 + */ +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; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + + u16 *adj = NULL; + msRawFrame.node_data = NULL; + + /************** Mutual Sense Test **************/ + logError(0, "%s\n", tag); + logError(0, "%s MS RAW LP DATA TEST:\n", tag); + if (todo->MutualRawLP == 1 || todo->MutualRawGapLP == 1 || + todo->MutualRawAdjLP == 1) { + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_ACTIVE); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(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; + } + + logError(0, "%s MS RAW LP MIN MAX TEST:\n", tag); + if (todo->MutualRawLP == 1) { + 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 MS RAW LP MAP MIN MAX TEST:\n", tag); + if (todo->MutualRawMapLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, MS_RAW_LP_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_LP_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_LP_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_LP_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 LP MAP MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail == 1) + goto ERROR; + } else{ + logError(0, "%s MS RAW LP MAP MIN 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 LP MAP MIN MAX TEST:.................SKIPPED\n", tag); + } + + logError(0, "%s\n", tag); + logError(0, "%s MS RAW LP GAP TEST:\n", tag); + if (todo->MutualRawGapLP == 1) { + 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); + logError(0, "%s MS RAW LP ADJ TEST:\n", tag); + if (todo->MutualRawAdjLP == 1) { + logError(0, "%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 DATA 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); + } + if (thresholds != NULL) + kfree(thresholds); + if (adj != NULL) + kfree(adj); + if (thresholds_min != NULL) { + kfree(thresholds_min); + thresholds_min = NULL; + } + if (thresholds_max != NULL) { + kfree(thresholds_max); + thresholds_max = 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); + if (thresholds != NULL) + kfree(thresholds); + 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 + */ +int production_test_ms_key_raw(char *path_limits) +{ + int ret; + MutualSenseFrame msRawFrame; + + int *thresholds = NULL; + int trows, tcolumns; + + /************** Mutual Sense Test **************/ + logError(0, "%s MS KEY RAW DATA TEST is starting...\n", tag); + ret = setScanMode(SCAN_MODE_ACTIVE, 0xFF); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(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); + if (thresholds != NULL) + kfree(thresholds); + 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); + if (thresholds != NULL) + kfree(thresholds); + 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 + */ +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_cx = NULL; */ + u16 *total_adjhor = NULL; + u16 *total_adjvert = NULL; + + + /* MS CX TEST */ + logError(0, "%s\n", tag); + logError(0, "%s MS CX Testes are starting...\n", tag); + + ret = readMutualSenseCompensationData(LOAD_CX_MS_TOUCH, &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_TOUCH, + &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; + } + + logError(0, "%s MS CX1 TEST:\n", tag); + if (todo->MutualCx1 == 1) { + 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]); + /* check the limits */ + 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; + + logError(0, "%s MS CX2 MIN MAX TEST:\n", tag); + if (todo->MutualCx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_CX2_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_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); + /* 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_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 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); + + logError(0, "%s MS CX2 ADJ TEST:\n", tag); + if (todo->MutualCx2Adj == 1) { + /* MS CX2 ADJ HORIZ */ + logError(0, "%s MS 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 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; + + /* MS CX2 ADJ VERT */ + 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); + + /* START OF TOTAL CHECK */ + logError(0, "%s MS TOTAL CX TEST:\n", tag); + + if (todo->MutualCxTotal == 1 || todo->MutualCxTotalAdj == 1) { + logError(0, "%s MS TOTAL CX MIN MAX TEST:\n", tag); + if (todo->MutualCxTotal == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + MS_TOTAL_CX_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_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); + /* 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_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 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); + + + logError(0, "%s MS TOTAL CX ADJ TEST:\n", tag); + if (todo->MutualCxTotalAdj == 1) { + /* MS TOTAL CX ADJ HORIZ */ + logError(0, "%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; + + /* MS TOTAL CX ADJ VERT */ + 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 CX LP 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); + 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 (totCompData.node_data != NULL) + kfree(totCompData.node_data); + if (total_adjhor != NULL) + kfree(total_adjhor); + if (total_adjvert != NULL) + kfree(total_adjvert); + if (msCompData.node_data != NULL) + kfree(msCompData.node_data); + 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 (totCompData.node_data != NULL) + kfree(totCompData.node_data); + if (total_adjhor != NULL) + kfree(total_adjhor); + if (total_adjvert != NULL) + kfree(total_adjvert); + if (msCompData.node_data != NULL) + kfree(msCompData.node_data); + 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 + */ +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; + + + /* MS CX TEST */ + logError(0, "%s MS KEY CX Testes are starting...\n", tag); + + ret = readMutualSenseCompensationData(LOAD_CX_MS_KEY, &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; + } + + if (msCompData.header.force_node > msCompData.header.sense_node) + /* the meaningful data are only in the first row, + * the other rows are only a copy of the first one */ + num_keys = msCompData.header.force_node; + else + num_keys = msCompData.header.sense_node; + + logError(0, "%s MS KEY CX1 TEST:\n", tag); + if (todo->MutualKeyCx1 == 1) { + 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]); /* check the limits */ + 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; + + logError(0, "%s MS KEY CX2 TEST:\n", tag); + if (todo->MutualKeyCx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + MS_KEY_CX2_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_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); + /* load max thresholds */ + 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); + /* check the limits */ + 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); + + /* START OF TOTAL CHECK */ + logError(0, "%s MS KEY TOTAL CX TEST:\n", tag); + + if (todo->MutualKeyCxTotal == 1) { + 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); + /* load min thresholds */ + 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); + /* load max thresholds */ + 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); + /* check the limits */ + 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); + if (thresholds_min != NULL) + kfree(thresholds_min); + if (thresholds_max != NULL) + kfree(thresholds_max); + if (msCompData.node_data != NULL) + kfree(msCompData.node_data); + if (totCompData.node_data != NULL) + kfree(totCompData.node_data); + 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 (msCompData.node_data != NULL) + kfree(msCompData.node_data); + if (totCompData.node_data != NULL) + kfree(totCompData.node_data); + 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); + logError(0, "%s MS LP CX Testes are starting...\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; + } + + logError(0, "%s MS LP CX1 TEST:\n", tag); + if (todo->MutualCx1LP == 1) { + 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; + + logError(0, "%s MS LP CX2 MIN MAX TEST:\n", tag); + if (todo->MutualCx2LP == 1) { + 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); + + logError(0, "%s MS LP CX2 ADJ TEST:\n", tag); + if (todo->MutualCx2AdjLP == 1) { + /* 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 */ + logError(0, "%s MS TOTAL LP CX TEST:\n", tag); + + if (todo->MutualCxTotalLP == 1 || todo->MutualCxTotalAdjLP == 1) { + logError(0, "%s MS TOTAL LP CX MIN MAX TEST:\n", tag); + if (todo->MutualCxTotalLP == 1) { + 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); + + + logError(0, "%s MS TOTAL CX ADJ LP TEST:\n", tag); + if (todo->MutualCxTotalAdjLP == 1) { + /* MS TOTAL CX ADJ HORIZ */ + logError(0, "%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); + 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 (totCompData.node_data != NULL) + kfree(totCompData.node_data); + if (total_adjhor != NULL) + kfree(total_adjhor); + if (total_adjvert != NULL) + kfree(total_adjvert); + if (msCompData.node_data != NULL) + kfree(msCompData.node_data); + 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 (totCompData.node_data != NULL) + kfree(totCompData.node_data); + if (total_adjhor != NULL) + kfree(total_adjhor); + if (total_adjvert != NULL) + kfree(total_adjvert); + if (msCompData.node_data != NULL) + kfree(msCompData.node_data); + 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 + */ +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; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + + /* SS TEST */ + logError(0, "%s\n", tag); + logError(0, "%s SS RAW Testes are starting...\n", tag); + + /************** Self Sense Test **************/ + + logError(0, "%s Getting SS Frame...\n", tag); + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_ACTIVE); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(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; + } + + /* SS RAW (PROXIMITY) FORCE TEST */ + logError(0, "%s SS RAW FORCE TEST:\n", tag); + + + + if (todo->SelfForceRaw == 1 || todo->SelfForceRawGap == 1 + || todo->SelfForceRawMap == 1) { + columns = 1; /* there are no data for the sense channels + * because is a force frame */ + rows = ssRawFrame.header.force_node; + + logError(0, "%s SS RAW FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceRaw == 1) { + 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 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 SS RAW FORCE MAP MIN MAX TEST:\n", tag); + if (todo->SelfForceRawMap == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, SS_RAW_FORCE_EACH_NODE_MIN, + &thresholds_min, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_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, SS_RAW_FORCE_EACH_NODE_MAX, + &thresholds_max, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_FORCE_EACH_NODE_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(ssRawFrame.force_data, rows, + columns, thresholds_min, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW FORCE MAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS RAW FORCE MAP 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 FORCE MAP MIN MAX TEST:.................OK\n\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 SS RAW FORCE MAP MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s\n", tag); + logError(0, "%s SS RAW FORCE GAP TEST:\n", tag); + if (todo->SelfForceRawGap == 1) { + 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 FORCE GAP TEST:.................OK\n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW FORCE GAP TEST:.................SKIPPED\n\n", + tag); + + kfree(ssRawFrame.force_data); + ssRawFrame.force_data = NULL; + } else + logError(0, + "%s SS RAW FORCE TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s\n", tag); + /* SS RAW (PROXIMITY) SENSE TEST */ + logError(0, "%s SS RAW SENSE TEST:\n", tag); + + if (todo->SelfSenseRaw == 1 || todo->SelfSenseRawGap == 1 || + todo->SelfSenseRawMap == 1) { + columns = ssRawFrame.header.sense_node; + rows = 1; /* there are no data for the force channels + * because is a sense frame */ + + logError(0, "%s SS RAW SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseRaw == 1) { + 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 SENSE MIN MAX TEST:.................OK\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW SENSE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS RAW SENSE MAP MIN MAX TEST:\n", tag); + if (todo->SelfSenseRawMap == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, SS_RAW_SENSE_EACH_NODE_MIN, + &thresholds_min, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_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, SS_RAW_SENSE_EACH_NODE_MAX, + &thresholds_max, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_SENSE_EACH_NODE_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(ssRawFrame.sense_data, rows, + columns, thresholds_min, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW SENSE MAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS RAW SENSE MAP MIN MAX TEST:.................FAIL\n\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 SENSE MAP MIN MAX TEST:.................OK\n\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 SS RAW SENSE MAP MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s\n", tag); + logError(0, "%s SS RAW SENSE GAP TEST:\n", tag); + if (todo->SelfSenseRawGap == 1) { + 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 SENSE GAP TEST:.................OK\n", + tag); + + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS RAW SENSE GAP TEST:.................SKIPPED\n", + tag); + + kfree(ssRawFrame.sense_data); + ssRawFrame.sense_data = NULL; + } else + logError(0, + "%s SS RAW SENSE TEST:.................SKIPPED\n\n", + tag); + + 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; + } + + 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); + if (thresholds_min != NULL) + kfree(thresholds_min); + if (thresholds_max != NULL) + kfree(thresholds_max); + + 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 + */ +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; + int *thresholds_min = NULL; + int *thresholds_max = NULL; + + /* SS TEST */ + logError(0, "%s\n", tag); + logError(0, "%s SS RAW LP Testes are starting...\n", tag); + + /************** Self Sense Test **************/ + + logError(0, "%s Getting SS LP Frame...\n", tag); + ret = setScanMode(SCAN_MODE_LOCKED, LOCKED_LP_DETECT); + msleep(WAIT_FOR_FRESH_FRAMES); + ret |= setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(WAIT_AFTER_SENSEOFF); + ret |= getSSFrame3(SS_DETECT_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; + } + + /* SS RAW (PROXIMITY) FORCE TEST */ + logError(0, "%s SS RAW LP FORCE TEST:\n", tag); + + + + if ((todo->SelfForceRawLP == 1 || todo->SelfForceRawGapLP == 1 || + todo->SelfForceRawMapLP == 1) && + ssRawFrame.header.force_node != 0) { + columns = 1; /* there are no data for the sense channels + * because is a force frame */ + rows = ssRawFrame.header.force_node; + + logError(0, "%s SS RAW LP FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceRawLP == 1) { + 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 SS RAW LP FORCE MAP MIN MAX TEST:\n", tag); + if (todo->SelfForceRawMapLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, SS_RAW_LP_FORCE_EACH_NODE_MIN, + &thresholds_min, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_LP_FORCE_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, SS_RAW_LP_FORCE_EACH_NODE_MAX, + &thresholds_max, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_LP_FORCE_EACH_NODE_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(ssRawFrame.force_data, rows, + columns, thresholds_min, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW LP FORCE MAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS RAW LP FORCE MAP 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 FORCE LP MAP MIN MAX TEST:.................OK\n\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 SS RAW FORCE LP MAP MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s\n", tag); + logError(0, "%s SS RAW LP FORCE GAP TEST:\n", tag); + if (todo->SelfForceRawGapLP == 1) { + 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); + /* SS RAW (PROXIMITY) SENSE TEST */ + logError(0, "%s SS RAW LP SENSE TEST:\n", tag); + + if ((todo->SelfSenseRawLP == 1 || todo->SelfSenseRawGapLP == 1 || + todo->SelfSenseRawMapLP == 1) && + ssRawFrame.header.sense_node != 0) { + columns = ssRawFrame.header.sense_node; + rows = 1; /* there are no data for the force channels + * because is a sense frame */ + + logError(0, "%s SS RAW LP SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseRawLP == 1) { + 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_LP_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 LP 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 SS RAW LP SENSE MAP MIN MAX TEST:\n", tag); + if (todo->SelfSenseRawMapLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, SS_RAW_LP_SENSE_EACH_NODE_MIN, + &thresholds_min, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_LP_SENSE_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, SS_RAW_LP_SENSE_EACH_NODE_MAX, + &thresholds_max, &trows, &tcolumns); + if (ret < OK || (trows != rows || + tcolumns != columns)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_RAW_LP_SENSE_EACH_NODE_MAX failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + + ret = checkLimitsMapTotal(ssRawFrame.sense_data, rows, + columns, thresholds_min, + thresholds_max); + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS RAW LP SENSE MAP failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS RAW LP SENSE MAP MIN MAX TEST:.................FAIL\n\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 MAP MIN MAX TEST:.................OK\n\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 SS RAW LP SENSE MAP MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s\n", tag); + logError(0, "%s SS RAW LP SENSE GAP TEST:\n", tag); + if (todo->SelfSenseRawGapLP == 1) { + 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_LP_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 LP 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; + } else + logError(0, + "%s SS RAW LP SENSE TEST:.................SKIPPED\n\n", + tag); + + 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); + if (thresholds_min != NULL) + kfree(thresholds_min); + if (thresholds_max != NULL) + kfree(thresholds_max); + 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 + */ +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); + logError(0, "%s SS IX CX testes are starting...\n", tag); + ret = readSelfSenseCompensationData(LOAD_CX_SS_TOUCH, &ssCompData); + /* 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; + } + + ret = readTotSelfSenseCompensationData(LOAD_PANEL_CX_TOT_SS_TOUCH, + &totCompData); + /* read the TOT SS compensation data */ + 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 **************/ + /* SS IX1 FORCE TEST */ + logError(0, "%s SS IX1 FORCE TEST:\n", tag); + if (todo->SelfForceIx1 == 1) { + 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]); + /* check the limits */ + 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; + /* SS IX2 FORCE TEST */ + logError(0, "%s SS IX2 FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceIx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX2_FORCE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); /* check the + * values with + * thresholds */ + 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); + + logError(0, "%s SS IX2 FORCE ADJ TEST:\n", tag); + if (todo->SelfForceIx2Adj == 1) { + /* SS IX2 FORCE ADJV TEST */ + logError(0, "%s SS IX2 FORCE ADJVERT 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); /* load the max + * thresholds */ + 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); /* check the + * values with + * thresholds */ + 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); + + /* SS TOTAL FORCE IX */ + logError(0, "%s SS TOTAL IX FORCE TEST:\n", tag); + if (todo->SelfForceIxTotal == 1 || todo->SelfForceIxTotalAdj == 1) { + logError(0, "%s SS TOTAL IX FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceIxTotal == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_FORCE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* 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 TOTAL IX FORCE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS TOTAL IX FORCE ADJ TEST:\n", tag); + if (todo->SelfForceIxTotalAdj == 1) { + /* SS TOTAL IX FORCE ADJV TEST */ + logError(0, "%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); + /* load the max thresholds */ + 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); + /* 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 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 **************/ + /* SS IX1 SENSE TEST */ + logError(0, "%s SS IX1 SENSE TEST:\n", tag); + if (todo->SelfSenseIx1 == 1) { + 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]); + /* check the limits */ + 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; + /* SS IX2 SENSE TEST */ + logError(0, "%s SS IX2 SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseIx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX2_SENSE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + logError(0, "%s SS IX2 SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseIx2Adj == 1) { + /* SS IX2 SENSE ADJH TEST */ + logError(0, "%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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + /* SS TOTAL IX SENSE */ + logError(0, "%s SS TOTAL IX SENSE TEST:\n", tag); + if (todo->SelfSenseIxTotal == 1 || todo->SelfSenseIxTotalAdj == 1) { + logError(0, "%s SS TOTAL IX SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseIxTotal == 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 != + 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); + /* load the max thresholds */ + 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); + /* 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 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); + + + logError(0, "%s SS TOTAL IX SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseIxTotalAdj == 1) { + /* SS TOTAL IX SENSE ADJH TEST */ + logError(0, "%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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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 **************/ + /* SS CX1 FORCE TEST */ + logError(0, "%s SS CX1 FORCE TEST:\n", tag); + if (todo->SelfForceCx1 == 1) { + 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]); + /* check the limits */ + 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); + + + + /* SS CX2 FORCE TEST */ + logError(0, "%s SS CX2 FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceCx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_FORCE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + logError(0, "%s SS CX2 FORCE ADJ TEST:\n", tag); + if (todo->SelfForceCx2Adj == 1) { + /* SS CX2 FORCE ADJV TEST */ + logError(0, "%s SS CX2 FORCE ADJVERT TEST:\n", tag); + ret = computeAdjVert(ssCompData.cx2_fm, + ssCompData.header.force_node, 1, &adjvert); + /* compute the ADJV for CX2 FORCE */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + /* SS TOTAL CX FORCE */ + logError(0, "%s SS TOTAL CX FORCE TEST:\n", tag); + if (todo->SelfForceCxTotal == 1 || todo->SelfForceCxTotalAdj == 1) { + logError(0, "%s SS TOTAL CX FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceCxTotal == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_FORCE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + /* SS TOTAL CX FORCE ADJV TEST */ + logError(0, "%s SS TOTAL CX FORCE ADJ TEST:\n", tag); + if (todo->SelfForceCxTotalAdj == 1) { + logError(0, "%s SS TOTAL CX FORCE ADJVERT TEST:\n", + tag); + ret = computeAdjVertTotal(totCompData.cx_fm, + totCompData.header.force_node, + 1, &total_adjvert); + /* compute the ADJV for CX2 FORCE */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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 *************/ + /* SS CX1 SENSE TEST */ + logError(0, "%s SS CX1 SENSE TEST:\n", tag); + if (todo->SelfSenseCx1 == 1) { + 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]); + /* check the limits */ + 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); + + + /* SS CX2 SENSE TEST */ + logError(0, "%s SS CX2 SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseCx2 == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_SENSE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + logError(0, "%s SS CX2 SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseCx2Adj == 1) { + /* SS CX2 SENSE ADJH TEST */ + logError(0, "%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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + /* SS TOTAL CX SENSE */ + logError(0, "%s SS TOTAL CX SENSE TEST:\n", tag); + if (todo->SelfSenseCxTotal == 1 || todo->SelfSenseCxTotalAdj == 1) { + logError(0, "%s SS TOTAL CX SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseCxTotal == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_SENSE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + 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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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); + + + /* SS TOTAL IX SENSE ADJH TEST */ + logError(0, "%s SS TOTAL CX SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseCxTotalAdj == 1) { + logError(0, "%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); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + 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->SelfSenseCx1LP | todo->SelfSenseCx2LP | + todo->SelfSenseCx2AdjLP | todo->SelfSenseCxTotalLP | + todo->SelfSenseCxTotalAdjLP | todo->SelfSenseIx1LP | + todo->SelfSenseIx2LP | todo->SelfSenseIx2AdjLP | + todo->SelfSenseIxTotalLP | todo->SelfSenseIxTotalAdjLP) == 1) { + ret = production_test_ss_ix_cx_lp(path_limits, stop_on_fail, + todo); + if (ret < OK) { + count_fail += 1; + logError(1, + "%s production_test_data: production_test_ss_ix_cx_lp failed... ERROR = %08X\n", + tag, ret); + goto ERROR; + } + } else + logError(0, "%s SS IX CX LP TEST:.................SKIPPED\n", + tag); + +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 all kind of data in just one row for readability reason */ + 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 all the tests selected in a TestTodo variable related to SS Init + * data for LP mode (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_ss_ix_cx_lp(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); + logError(0, "%s SS LP IX CX testes are starting...\n", tag); + ret = readSelfSenseCompensationData(LOAD_CX_SS_TOUCH_IDLE, &ssCompData); + /* read the SS LP 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; + } + + ret = readTotSelfSenseCompensationData(LOAD_PANEL_CX_TOT_SS_TOUCH_IDLE, + &totCompData); + /* read the TOT SS LP compensation data */ + 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 LP **************/ + /* SS IX1 LP FORCE TEST */ + logError(0, "%s SS IX1 LP FORCE TEST:\n", tag); + if (todo->SelfForceIx1LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX1_LP_FORCE_MIN_MAX, + &thresholds, &trows, &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX1_LP_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]); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS IX1 LP FORCE TEST failed... ERROR COUNT = %d\n", + tag, ret); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX1 LP FORCE TEST:.................OK\n\n", + tag); + } else + logError(0, + "%s SS IX1 LP FORCE TEST:.................SKIPPED\n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + /* SS IX2 LP FORCE TEST */ + logError(0, "%s SS IX2 LP FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceIx2LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX2_LP_FORCE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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_LP_FORCE_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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); /* check the + * values with + * thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS IX2 LP FORCE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 LP 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 LP FORCE MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s SS IX2 LP FORCE ADJ TEST:\n", tag); + if (todo->SelfForceIx2AdjLP == 1) { + /* SS IX2 FORCE ADJV TEST */ + logError(0, "%s SS IX2 LP FORCE ADJVERT 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 LP FORCE ADJV failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s SS IX2 LP FORCE ADJV computed!\n", tag); + + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX2_LP_FORCE_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); /* load the max + * thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node - 1 || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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); /* check the + * values with + * thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS IX2 LP FORCE ADJV TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 LP FORCE ADJV TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, + "%s SS IX2 LP FORCE ADJ TEST:.................SKIPPED\n\n", + tag); + + /* SS TOTAL FORCE IX */ + logError(0, "%s SS TOTAL IX LP FORCE TEST:\n", tag); + if (todo->SelfForceIxTotalLP == 1 || todo->SelfForceIxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL IX LP FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceIxTotalLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_LP_FORCE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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_LP_FORCE_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL IX LP FORCE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX LP 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 LP FORCE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS TOTAL IX LP FORCE ADJ TEST:\n", tag); + if (todo->SelfForceIxTotalAdjLP == 1) { + /* SS TOTAL IX FORCE ADJV TEST */ + logError(0, "%s SS TOTAL IX LP 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 LP 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 LP FORCE ADJV computed!\n", + tag); + + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_LP_FORCE_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != totCompData.header.force_node - + 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL IX LP FORCE ADJV TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX LP 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 LP FORCE ADJ TEST:.................SKIPPED\n", + tag); + } else + logError(0, + "%s SS TOTAL IX LP FORCE TEST:.................SKIPPED\n\n", + tag); + + + /************** SS SENSE IX LP **************/ + /* SS IX1 LP SENSE TEST */ + logError(0, "%s SS IX1 LP SENSE TEST:\n", tag); + if (todo->SelfSenseIx1LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX1_LP_SENSE_MIN_MAX, + &thresholds, &trows, &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX1_LP_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]); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS IX1 SENSE LP TEST failed... ERROR COUNT = %d\n", + tag, ret); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX1 LP SENSE TEST:.................OK\n\n", + tag); + } else + logError(0, + "%s SS IX1 LP SENSE TEST:.................SKIPPED\n\n", + tag); + + kfree(thresholds); + thresholds = NULL; + /* SS IX2 SENSE TEST */ + logError(0, "%s SS IX2 LP SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseIx2LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_IX2_LP_SENSE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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_LP_SENSE_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 LP SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS IX2 LP SENSE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 LP 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 LP SENSE MIN MAX TEST:.................SKIPPED\n\n", + tag); + + logError(0, "%s SS IX2 LP SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseIx2AdjLP == 1) { + /* SS IX2 SENSE ADJH TEST */ + logError(0, "%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); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_IX2_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS IX2 LP SENSE ADJH failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS IX2 LP SENSE ADJH TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS IX2 LP SENSE ADJH TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + } else + logError(0, + "%s SS IX2 LP SENSE ADJ TEST:.................SKIPPED\n", + tag); + + /* SS TOTAL IX SENSE */ + logError(0, "%s SS TOTAL IX LP SENSE TEST:\n", tag); + if (todo->SelfSenseIxTotalLP == 1 || todo->SelfSenseIxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL IX LP SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseIxTotalLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_LP_SENSE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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_LP_SENSE_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL IX LP SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL IX LP SENSE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX LP 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 LP SENSE MIN MAX TEST:.................SKIPPED\n", + tag); + + + logError(0, "%s SS TOTAL IX LP SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseIxTotalAdjLP == 1) { + /* SS TOTAL IX SENSE ADJH TEST */ + logError(0, "%s SS TOTAL IX LP 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 LP 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 LP SENSE ADJ HORIZ computed!\n", + tag); + + + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_IX_LP_SENSE_ADJH_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_IX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS TOTAL IX LP SENSE ADJH failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL IX LP SENSE ADJH TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL IX LP 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 LP SENSE ADJ TEST:.................SKIPPED\n", + tag); + } else + logError(0, + "%s SS TOTAL IX LP SENSE TEST:.................SKIPPED\n", + tag); + + /************* SS SENSE CX LP **************/ + /* SS CX1 LP FORCE TEST */ + logError(0, "%s SS CX1 LP FORCE TEST:\n", tag); + if (todo->SelfForceCx1LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX1_LP_FORCE_MIN_MAX, + &thresholds, &trows, &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX1_LP_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]); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS CX1 LP FORCE TEST failed... ERROR COUNT = %d\n", + tag, ret); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX1 LP FORCE TEST:.................OK\n\n", + tag); + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS CX1 LP FORCE TEST:.................SKIPPED\n\n", + tag); + + + + /* SS CX2 LP FORCE TEST */ + logError(0, "%s SS CX2 LP FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceCx2LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_LP_FORCE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_LP_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_LP_FORCE_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS CX2 LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS CX2 LP FORCE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 LP 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 LP FORCE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS CX2 LP FORCE ADJ TEST:\n", tag); + if (todo->SelfForceCx2AdjLP == 1) { + /* SS CX2 FORCE ADJV TEST */ + logError(0, "%s SS CX2 LP FORCE ADJVERT TEST:\n", tag); + ret = computeAdjVert(ssCompData.cx2_fm, + ssCompData.header.force_node, 1, &adjvert); + /* compute the ADJV for CX2 FORCE */ + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS CX2 LP FORCE ADJV failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s SS CX2 LP FORCE ADJV computed!\n", tag); + + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_LP_FORCE_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != ssCompData.header.force_node - 1 || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS IX2 LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS CX2 LP FORCE ADJV TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 LP FORCE ADJV TEST:.................OK\n\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjvert); + adjvert = NULL; + } else + logError(0, + "%s SS CX2 LP FORCE ADJ TEST:.................SKIPPED\n\n", + tag); + + /* SS TOTAL CX LP FORCE */ + logError(0, "%s SS TOTAL CX LP FORCE TEST:\n", tag); + if (todo->SelfForceCxTotalLP == 1 || todo->SelfForceCxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL CX LP FORCE MIN MAX TEST:\n", tag); + if (todo->SelfForceCxTotalLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_LP_FORCE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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_LP_FORCE_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != + totCompData.header.force_node || + tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL FORCE LP MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL FORCE LP 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 LP FORCE MIN MAX TEST:.................SKIPPED\n", + tag); + + /* SS TOTAL CX LP FORCE ADJV TEST */ + logError(0, "%s SS TOTAL CX LP FORCE ADJ TEST:\n", tag); + if (todo->SelfForceCxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL CX LP FORCE ADJVERT TEST:\n", + tag); + ret = computeAdjVertTotal(totCompData.cx_fm, + totCompData.header.force_node, + 1, &total_adjvert); + /* compute the ADJV for CX2 FORCE */ + if (ret < 0) { + logError(1, + "%s production_test_data: computeAdjVert SS TOTAL CX LP 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 LP FORCE ADJV computed!\n", + tag); + + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_LP_FORCE_ADJV_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != totCompData.header.force_node - + 1 || tcolumns != 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL CX LP FORCE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL CX LP FORCE ADJV TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX LP 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 LP FORCE ADJ TEST:.................SKIPPED\n", + tag); + } else + logError(0, + "%s SS TOTAL CX LP FORCE TEST:.................SKIPPED\n\n", + tag); + + + + /************* SS SENSE CX *************/ + /* SS CX1 SENSE TEST */ + logError(0, "%s SS CX1 LP SENSE TEST:\n", tag); + if (todo->SelfSenseCx1LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX1_LP_SENSE_MIN_MAX, + &thresholds, &trows, &tcolumns); + if (ret < 0 || (trows != 1 || tcolumns != 2)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX1_LP_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]); + /* check the limits */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMinMax SS CX1 LP SENSE TEST failed... ERROR COUNT = %d\n", + tag, ret); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX1 LP SENSE TEST:.................OK\n\n", + tag); + kfree(thresholds); + thresholds = NULL; + } else + logError(0, + "%s SS CX1 LP SENSE TEST:.................SKIPPED\n\n", + tag); + + + /* SS CX2 LP SENSE TEST */ + logError(0, "%s SS CX2 LP SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseCx2LP == 1) { + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_LP_SENSE_MAP_MIN, + &thresholds_min, &trows, + &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_LP_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_LP_SENSE_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + ssCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_CX2_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS CX2 LP SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS CX2 LP SENSE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 LP 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 LP SENSE MIN MAX TEST:.................SKIPPED\n", + tag); + + logError(0, "%s SS CX2 LP SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseCx2AdjLP == 1) { + /* SS CX2 SENSE ADJH TEST */ + logError(0, "%s SS CX2 LP 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 LP SENSE ADJH failed... ERROR %08X\n", + tag, ERROR_PROD_TEST_DATA); + ret |= ERROR_PROD_TEST_DATA; + goto ERROR_LIMITS; + } + logError(0, "%s SS CX2 LP SENSE ADJH computed!\n", tag); + + + ret = parseProductionTestLimits(path_limits, &limit_file, + SS_CX2_LP_SENSE_ADJH_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + 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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS CX2 LP SENSE ADJH failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS CX2 LP SENSE ADJH TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS CX2 LP SENSE ADJH TEST:.................OK\n", + tag); + + kfree(thresholds_max); + thresholds_max = NULL; + kfree(adjhor); + adjhor = NULL; + } else + logError(0, + "%s SS CX2 LP SENSE ADJ TEST:.................SKIPPED\n\n", + tag); + + /* SS TOTAL CX SENSE */ + logError(0, "%s SS TOTAL CX LP SENSE TEST:\n", tag); + if (todo->SelfSenseCxTotalLP == 1 || todo->SelfSenseCxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL CX LP SENSE MIN MAX TEST:\n", tag); + if (todo->SelfSenseCxTotalLP == 1) { + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_LP_SENSE_MAP_MIN, + &thresholds_min, + &trows, &tcolumns); + /* load the min thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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_LP_SENSE_MAP_MAX, + &thresholds_max, + &trows, &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMap SS TOTAL CX LP SENSE failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL CX LP SENSE MIN MAX TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX LP 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 LP SENSE MIN MAX TEST:.................SKIPPED\n", + tag); + + + /* SS TOTAL IX SENSE ADJH TEST */ + logError(0, "%s SS TOTAL CX LP SENSE ADJ TEST:\n", tag); + if (todo->SelfSenseCxTotalAdjLP == 1) { + logError(0, "%s SS TOTAL CX LP 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 LP 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 LP SENSE ADJ HORIZ computed!\n", + tag); + + + ret = parseProductionTestLimits(path_limits, + &limit_file, + SS_TOTAL_CX_LP_SENSE_ADJH_MAP_MAX, + &thresholds_max, &trows, + &tcolumns); + /* load the max thresholds */ + if (ret < 0 || (trows != 1 || tcolumns != + totCompData.header.sense_node - 1)) { + logError(1, + "%s production_test_data: parseProductionTestLimits SS_TOTAL_CX_LP_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); + /* check the values with thresholds */ + if (ret != OK) { + logError(1, + "%s production_test_data: checkLimitsMapAdj SS TOTAL CX LP SENSE ADJH failed... ERROR COUNT = %d\n", + tag, ret); + logError(0, + "%s SS TOTAL CX LP SENSE ADJH TEST:.................FAIL\n\n", + tag); + count_fail += 1; + if (stop_on_fail) + goto ERROR; + } else + logError(0, + "%s SS TOTAL CX LP 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 LP SENSE ADJ TEST:.................SKIPPED\n", + tag); + } else + logError(0, + "%s SS TOTAL CX LP SENSE TEST:.................SKIPPED\n", + tag); + + + +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 LP IX CX testes finished!.................OK\n\n", + tag); + return OK; + } else { + /* print all kind of data in just one row for readability reason */ + print_frame_u8("SS LP Init Data Ix2_fm = ", array1dTo2d_u8( + ssCompData.ix2_fm, + ssCompData.header.force_node, 1), + ssCompData.header.force_node, 1); + print_frame_i8("SS LP Init Data Cx2_fm = ", array1dTo2d_i8( + ssCompData.cx2_fm, + ssCompData.header.force_node, 1), + ssCompData.header.force_node, 1); + print_frame_u8("SS LP 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 LP 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 LP Init Data Ix_fm = ", array1dTo2d_u16( + totCompData.ix_fm, + totCompData.header.force_node, 1), + totCompData.header.force_node, 1); + print_frame_short("TOT SS LP Init Data Cx_fm = ", + array1dTo2d_short(totCompData.cx_fm, + totCompData.header. + force_node, 1), + totCompData.header.force_node, 1); + print_frame_u16("TOT SS LP 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 LP 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 LP 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 + */ +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(0, "%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); /* /< release the limit file loaded + * during the test */ + 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) {/* to avoid memory leak on consecutive call of + * the function with the same pointer */ + 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, 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 + */ +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) { + /* start to look for the wanted label */ + if (readLine(&data_file[pointer], line, size - pointer, &n) < + 0) { + find = -1; + break; + } + pointer += n; + if (line[0] == '*') { /* each header row start with * ex. + * *label,n_row,n_colum */ + 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) {/* if the row is the + * wanted one i retrieve + * rows and columns info + * */ + find = 1; + token = strsep(&line2, ","); + if (token != NULL) { + if (sscanf(token, "%d", row) == 1) + logError(0, "%s Row = %d\n", + tag, *row); + else { + logError(0, "%s ERROR while reading the row value! ERROR %08X\n", + tag, ERROR_FILE_PARSE); + ret = ERROR_FILE_PARSE; + goto END; + } + + } 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) { + if (sscanf(token, "%d", column) == 1) + logError(0, "%s Column = %d\n", + tag, *column); + else { + logError(0, "%s ERROR while reading the column value! ERROR %08X\n", + tag, ERROR_FILE_PARSE); + ret = ERROR_FILE_PARSE; + goto END; + } + + } 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); + /* allocate the memory for containing the data */ + j = 0; + if (*data == NULL) { + logError(1, + "%s parseProductionTestLimits: ERROR %08X\n", + tag, ERROR_ALLOC); + ret = ERROR_ALLOC; + goto END; + } + + + /* start to read the data */ + 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++) { + if (sscanf(token, "%d", + ((*data) + j)) == 1) { + j++; + token = + strsep(&line2, ","); + } + } + kfree(buf); + buf = NULL; + } + if (j == ((*row) * (*column))) {/* check that + * all the data + * are read */ + 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 + */ +int readLine(char *data, char *line, int size, int *n) +{ + int i = 0; + + if (size < 1) + return ERROR_OP_NOT_ALLOW; + + 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/stmicro_mmi/fts_lib/ftsTest.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTest.h new file mode 100644 index 000000000000..2a8588f0f82b --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTest.h @@ -0,0 +1,439 @@ +/* + * + ************************************************************************** + ** 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 +/* /< Name of the Production Test Limit File */ +#define LIMITS_FILE "stm_fts_production_limits.csv" +#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 + * @{ + */ +/* LABELS PRODUCTION TEST LIMITS FILE */ +/** @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_EACH_NODE_MIN "MS_RAW_LOWPOWER_DATA_EACH_MIN" +#define MS_RAW_LP_EACH_NODE_MAX "MS_RAW_LOWPOWER_DATA_EACH_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_RAW_ADJH_GAP "MS_RAW_DATA_ADJ_HORIZONTAL_P2P" +#define MS_RAW_ADJV_GAP "MS_RAW_DATA_ADJ_VERTICAL_P2P" +#define MS_RAW_ADJ_PEAK "MS_RAW_DATA_ADJ_PEAK" +#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_FORCE_EACH_NODE_MIN "SS_RAW_DATA_FORCE_EACH_MIN" +#define SS_RAW_FORCE_EACH_NODE_MAX "SS_RAW_DATA_FORCE_EACH_MAX" +#define SS_RAW_SENSE_MIN_MAX "SS_RAW_DATA_SENSE_MIN_MAX" +#define SS_RAW_SENSE_EACH_NODE_MIN "SS_RAW_DATA_SENSE_EACH_MIN" +#define SS_RAW_SENSE_EACH_NODE_MAX "SS_RAW_DATA_SENSE_EACH_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_EACH_NODE_MIN "SS_RAW_LOWPOWER_DATA_FORCE_EACH_MIN" +#define SS_RAW_LP_FORCE_EACH_NODE_MAX "SS_RAW_LOWPOWER_DATA_FORCE_EACH_MAX" +#define SS_RAW_LP_SENSE_MIN_MAX "SS_RAW_LOWPOWER_DATA_SENSE_MIN_MAX" +#define SS_RAW_LP_SENSE_EACH_NODE_MIN "SS_RAW_LOWPOWER_DATA_SENSE_EACH_MIN" +#define SS_RAW_LP_SENSE_EACH_NODE_MAX "SS_RAW_LOWPOWER_DATA_SENSE_EACH_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" + + +/* TOTAL SS */ +#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" + +/* Idle (LP) version*/ +#define SS_IX1_LP_FORCE_MIN_MAX "SS_TOUCH_IDLE_IX1_FORCE_MIN_MAX" +#define SS_IX1_LP_SENSE_MIN_MAX "SS_TOUCH_IDLE_IX1_SENSE_MIN_MAX" +#define SS_CX1_LP_FORCE_MIN_MAX "SS_TOUCH_IDLE_CX1_FORCE_MIN_MAX" +#define SS_CX1_LP_SENSE_MIN_MAX "SS_TOUCH_IDLE_CX1_SENSE_MIN_MAX" +#define SS_IX2_LP_FORCE_MAP_MIN "SS_TOUCH_IDLE_IX2_FORCE_MIN" +#define SS_IX2_LP_FORCE_MAP_MAX "SS_TOUCH_IDLE_IX2_FORCE_MAX" +#define SS_IX2_LP_SENSE_MAP_MIN "SS_TOUCH_IDLE_IX2_SENSE_MIN" +#define SS_IX2_LP_SENSE_MAP_MAX "SS_TOUCH_IDLE_IX2_SENSE_MAX" +#define SS_IX2_LP_FORCE_ADJV_MAP_MAX "SS_TOUCH_IDLE_IX2_ADJ_VERTICAL" +#define SS_IX2_LP_SENSE_ADJH_MAP_MAX "SS_TOUCH_IDLE_IX2_ADJ_HORIZONTAL" +#define SS_CX2_LP_FORCE_MAP_MIN "SS_TOUCH_IDLE_CX2_FORCE_MIN" +#define SS_CX2_LP_FORCE_MAP_MAX "SS_TOUCH_IDLE_CX2_FORCE_MAX" +#define SS_CX2_LP_SENSE_MAP_MIN "SS_TOUCH_IDLE_CX2_SENSE_MIN" +#define SS_CX2_LP_SENSE_MAP_MAX "SS_TOUCH_IDLE_CX2_SENSE_MAX" +#define SS_CX2_LP_FORCE_ADJV_MAP_MAX "SS_TOUCH_IDLE_CX2_ADJ_VERTICAL" +#define SS_CX2_LP_SENSE_ADJH_MAP_MAX "SS_TOUCH_IDLE_CX2_ADJ_HORIZONTAL" + + +/* TOTAL SS */ +#define SS_TOTAL_IX_LP_FORCE_MAP_MIN "SS_TOUCH_IDLE_TOTAL_IX_FORCE_MIN" +#define SS_TOTAL_IX_LP_FORCE_MAP_MAX "SS_TOUCH_IDLE_TOTAL_IX_FORCE_MAX" +#define SS_TOTAL_IX_LP_SENSE_MAP_MIN "SS_TOUCH_IDLE_TOTAL_IX_SENSE_MIN" +#define SS_TOTAL_IX_LP_SENSE_MAP_MAX "SS_TOUCH_IDLE_TOTAL_IX_SENSE_MAX" +#define SS_TOTAL_IX_LP_FORCE_ADJV_MAP_MAX \ + "SS_TOUCH_IDLE_TOTAL_IX_ADJ_VERTICAL" +#define SS_TOTAL_IX_LP_SENSE_ADJH_MAP_MAX \ + "SS_TOUCH_IDLE_TOTAL_IX_ADJ_HORIZONTAL" +#define SS_TOTAL_CX_LP_FORCE_MAP_MIN "SS_TOUCH_IDLE_TOTAL_CX_FORCE_MIN" +#define SS_TOTAL_CX_LP_FORCE_MAP_MAX "SS_TOUCH_IDLE_TOTAL_CX_FORCE_MAX" +#define SS_TOTAL_CX_LP_SENSE_MAP_MIN "SS_TOUCH_IDLE_TOTAL_CX_SENSE_MIN" +#define SS_TOTAL_CX_LP_SENSE_MAP_MAX "SS_TOUCH_IDLE_TOTAL_CX_SENSE_MAX" +#define SS_TOTAL_CX_LP_FORCE_ADJV_MAP_MAX \ + "SS_TOUCH_IDLE_TOTAL_CX_ADJ_VERTICAL" +#define SS_TOTAL_CX_LP_SENSE_ADJH_MAP_MAX \ + "SS_TOUCH_IDLE_TOTAL_CX_ADJ_HORIZONTAL" + +/* KEYS */ +#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" + +/* CONSTANT TOTAL IX */ +#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" +/** @}*/ + + +/** + * 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 MutualRawMap; /* /< MS Raw min/Max test for each node */ + int MutualRawGap; /* /< MS Raw Gap(max-min) test */ + int MutualRawAdj; /* /< MS Raw Adjacent test */ + int MutualRawAdjGap; /* /< MS Raw Adjacent Gap (max-min) test */ + int MutualRawAdjPeak; /* /< MS Raw Adjacent Peak + * max(max(adjv),max(adjh)) test */ + int MutualRawLP; /* /< MS Low Power Raw min/Max test */ + int MutualRawMapLP; /* /< MS Low Power Raw min/Max test + * for each node */ + 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 SelfForceRaw; /* /< SS Force Raw min/Max test */ + int SelfForceRawGap; /* /< SS Force Raw Gap(max-min) test */ + int SelfForceRawMap; /* /< SS Force Raw min/Max Map test */ + int SelfForceRawLP; /* /< SS Low Power Force Raw min/Max test */ + int SelfForceRawGapLP; /* /< SS Low Power Force Raw Gap(max-min)test */ + int SelfForceRawMapLP; /* /< SS Low Power Force Raw min/Max Map 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 SelfForceIx1LP; /* /< SS LP Force Ix1 min/Max test */ + int SelfForceIx2LP; /* /< SS LP Force Ix2 min/Max (for each node) + * test */ + int SelfForceIx2AdjLP; /* /< SS LP Vertical Adj Force Ix2 min/Max + * (for each node) test */ + int SelfForceIxTotalLP; /* /< SS LP Total Force Ix min/Max + * (for each node) test */ + int SelfForceIxTotalAdjLP; /* /< SS LP Total Vertical Adj Force Ix + * min/Max (for each node) test */ + int SelfForceCx1LP; /* /< SS LP Force Cx1 min/Max test */ + int SelfForceCx2LP; /* /< SS LP Force Cx2 min/Max (for each node) test */ + int SelfForceCx2AdjLP; /* /< SS LP Vertical Adj Force Cx2 min/Max (for + * each node) test */ + int SelfForceCxTotalLP; /* /< SS LP Total Force Cx min/Max + * (for each node) test */ + int SelfForceCxTotalAdjLP; /* /< SS LP 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 SelfSenseRawMap; /* /< SS Sense Raw min/Max test for each node */ + int SelfSenseRawLP; /* /< SS Low Power Sense Raw min/Max test */ + int SelfSenseRawGapLP; /* /< SS Low Power Sense Raw Gap(max-min) test */ + int SelfSenseRawMapLP; /* /< SS Low Power Sense Raw min/Max test for + * each node */ + + 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 */ + + int SelfSenseIx1LP; /* /< SS LP Sense Ix1 min/Max test */ + int SelfSenseIx2LP; /* /< SS LP Sense Ix2 min/Max (for each node) + * test */ + int SelfSenseIx2AdjLP; /* /< SS LP Horizontal Adj Sense Ix2 min/Max + * (for each node) test */ + int SelfSenseIxTotalLP; /* /< SS LP Total Horizontal Sense Ix min/Max + * (for each node) test */ + int SelfSenseIxTotalAdjLP; /* /< SS LP Total Horizontal Adj Sense Ix + * min/Max (for each node) test */ + int SelfSenseCx1LP; /* /< SS LP Sense Cx1 min/Max test */ + int SelfSenseCx2LP; /* /< SS LP Sense Cx2 min/Max (for each node) + * test */ + int SelfSenseCx2AdjLP; /* /< SS LP Horizontal Adj Sense Cx2 min/Max + * (for each node) test */ + int SelfSenseCxTotalLP; /* /< SS LP Total Sense Cx min/Max + * (for each node) test */ + int SelfSenseCxTotalAdjLP; /* /< SS LP 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; /* /< pointer to an array of char which contains + * the content of the Production Limit File */ + int size; /* /< size of data */ + char name[MAX_LIMIT_FILE_NAME]; /* /< identifier of the source from + * where the limits data were loaded (if + * loaded from a file it will be the + * file name, while if loaded from .h + * will be "NULL") */ +} 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); +int checkLimitsGap(short *data, int row, int column, int threshold); +int checkLimitsGapOffsets(short *data, int row, int column, int threshold, + int row_start, int column_start, int row_end, int column_end); + +/** @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, u8 mpflag); +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_ss_ix_cx_lp(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); +/** @}*/ + +/** + * @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/stmicro_mmi/fts_lib/ftsTime.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTime.c new file mode 100644 index 000000000000..c940ced20836 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTime.c @@ -0,0 +1,85 @@ +/* + * + ************************************************************************** + ** 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 = current_kernel_time(); +} + +/** + * Take the stop time and save it in a StopWatch variable + * @param w pointer of a StopWatch struct + */ +void stopStopWatch(StopWatch *w) +{ + w->end = current_kernel_time(); +} + +/** + * 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) +{ + int result; + + result = ((w->end.tv_sec - w->start.tv_sec) * 1000) + (w->end.tv_nsec - + w->start.tv_nsec) + / 1000000; + return result; +} + +/** + * 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; +} diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTime.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTime.h new file mode 100644 index 000000000000..743dd1da468f --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTime.h @@ -0,0 +1,73 @@ +/* + * + ************************************************************************** + ** 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 + +/* TIMEOUT */ +/** @defgroup timeouts Timeouts + * Definitions of all the Timeout used in several operations + * @{ + */ +#define TIMEOUT_RESOLUTION 50 +/* /< timeout resolution in ms (all timeout should be multiples of this unit) */ +#define GENERAL_TIMEOUT (15 * TIMEOUT_RESOLUTION) +/* /< general timeout in ms */ +#define RELEASE_INFO_TIMEOUT (2 * TIMEOUT_RESOLUTION) +/* /< timeout to request release info in ms */ + + +#define TIMEOUT_REQU_COMP_DATA (4 * TIMEOUT_RESOLUTION) +/* /< timeout to request compensation data in ms */ +#define TIMEOUT_REQU_DATA (8 * TIMEOUT_RESOLUTION) +/* /< timeout to request data in ms */ +#define TIMEOUT_ITO_TEST_RESULT (4 * 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 TIEMOUT_ECHO (50 * TIMEOUT_RESOLUTION) +/* /< timeout of the echo command,*/ +#define TIMEOUT_ECHO_FPI (200 * TIMEOUT_RESOLUTION) +/* /< timeout of the Full panel Init echo command */ +#define TIMEOUT_ECHO_SINGLE_ENDED_SPECIAL_AUTOTUNE \ + (100 * TIMEOUT_RESOLUTION) +/* /< timeout of the Single ended special Autotune echo command */ +/** @}*/ + + +/** + * 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 */ +} StopWatch; + + +void startStopWatch(StopWatch *w); +void stopStopWatch(StopWatch *w); +int elapsedMillisecond(StopWatch *w); +int elapsedNanosecond(StopWatch *w); + +#endif diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTool.c b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTool.c new file mode 100644 index 000000000000..f062bcbae00c --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTool.c @@ -0,0 +1,715 @@ +/* + * + ************************************************************************** + ** 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" /* needed for the tag define */ + + +#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 + * @param result pointer to the array of characters that compose the HEX final + * string + * @return pointer to the array of characters that compose the HEX string, + * (same address of result) + * @warning result MUST be allocated outside the function and should be + * big enough to contain the data converted as HEX! + */ +char *printHex(char *label, u8 *buff, int count, u8 *result) +{ + int i, offset; + + offset = strlen(label); + strlcpy(result, label, offset+1); /* +1 for terminator char */ + + for (i = 0; i < count; i++) { + snprintf(&result[offset], 4, "%02X ", buff[i]); + /* this append automatically a null terminator char */ + offset += 3; + } + return result; +} + +/** + * Clear the FIFO from any event + * @return OK if success or an error code which specify the type of error + */ +int flushFIFO(void) +{ + int ret; + u8 sett = SPECIAL_FIFO_FLUSH; + + ret = writeSysCmd(SYS_CMD_SPECIAL, &sett, 1); /* flush the FIFO */ + 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 an array of bytes to a u32, src has MSB first (big endian). + * @param src array of bytes to convert + * @param dst pointer to the destination u32 variable. + * @return OK + */ +int u8ToU32_be(u8 *src, u32 *dst) +{ + *dst = (u32)(((src[0] & 0xFF) << 24) + ((src[1] & 0xFF) << 16) + + ((src[2] & 0xFF) << 8) + (src[3] & 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++; + msleep(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 + */ +int senseOn(void) +{ + int ret; + + ret = setScanMode(SCAN_MODE_ACTIVE, 0xFF); /* enable all */ + 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 + */ +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 + */ +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(); /* already enable everything */ + 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 + * @warning If size = 0 it will be allocated a matrix 1*1 wich still should + * be free + */ +short **array1dTo2d_short(short *data, int size, int columns) +{ + int i; + short **matrix = NULL; + if (size == 0) { + matrix = (short **)kmalloc(1 * + sizeof(short *), GFP_KERNEL); + matrix[0] = (short *)kmalloc(0 * + sizeof(short), GFP_KERNEL); + } else { + 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 + * @warning If size = 0 it will be allocated a matrix 1*1 wich still should + * be free + */ +u16 **array1dTo2d_u16(u16 *data, int size, int columns) +{ + int i; + u16 **matrix = NULL; + + + if (size == 0) { + matrix = (u16 **)kmalloc(1 * + sizeof(u16 *), GFP_KERNEL); + matrix[0] = (u16 *)kmalloc(0 * + sizeof(u16), GFP_KERNEL); + } else { + 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 + * @warning If size = 0 it will be allocated a matrix 1*1 wich still should + * be free + */ +u8 **array1dTo2d_u8(u8 *data, int size, int columns) +{ + int i; + u8 **matrix = NULL; + + + if (size == 0) { + matrix = (u8 **)kmalloc(1 * + sizeof(u8 *), GFP_KERNEL); + + matrix[0] = (u8 *)kmalloc(0 * + sizeof(u8), GFP_KERNEL); + } else { + + 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 + * @warning If size = 0 it will be allocated a matrix 1*1 wich still should + * be free + */ +i8 **array1dTo2d_i8(i8 *data, int size, int columns) +{ + int i; + i8 **matrix = NULL; + + if (size == 0) { + matrix = (i8 **)kmalloc(1 * + sizeof(i8 *), GFP_KERNEL); + matrix[0] = (i8 *)kmalloc(0 * + sizeof(i8), GFP_KERNEL); + } else { + 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(0, "%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 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(0, "%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(0, "%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 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(0, "%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 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(0, "%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(0, "%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; + + /* u64 temp =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/stmicro_mmi/fts_lib/ftsTool.h b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTool.h new file mode 100644 index 000000000000..8fbf13296577 --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_lib/ftsTool.h @@ -0,0 +1,59 @@ +/* + * + ************************************************************************** + ** 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); +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 u8ToU32_be(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); + +/* New API */ +int fromIDtoMask(u8 id, u8 *mask, int size); + +#endif diff --git a/drivers/input/touchscreen/stmicro_mmi/fts_limits.h b/drivers/input/touchscreen/stmicro_mmi/fts_limits.h new file mode 100644 index 000000000000..ce225fca854e --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_limits.h @@ -0,0 +1,2111 @@ +/*! + * \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; /* /< size of the array containing the + * production limit file */ + +/** + * 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/stmicro_mmi/fts_proc.c b/drivers/input/touchscreen/stmicro_mmi/fts_proc.c new file mode 100644 index 000000000000..496c16ca3c4c --- /dev/null +++ b/drivers/input/touchscreen/stmicro_mmi/fts_proc.c @@ -0,0 +1,3073 @@ +/* + * + ************************************************************************** + ** 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" /* /< name of file node + * published */ +#define CHUNK_PROC 1024 /* /< Max chunk of data printed on the + * sequential file in each iteration */ +#define DIAGNOSTIC_NUM_FRAME 10 /* /< number of frames reading + * iterations during the diagnostic test + */ + + + +/** @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 /* /< I2C/SPI read: need + * to pass: byteToRead1 + * byteToRead0 + * (optional) dummyByte + * */ +#define CMD_WRITE 0x01 /* /< I2C/SPI write: + * need to pass: cmd[0] + * cmd[1] … + * cmd[cmdLength-1] */ +#define CMD_WRITEREAD 0x02 /* /< I2C/SPI writeRead: + * need to pass: cmd[0] + * cmd[1] … + * cmd[cmdLength-1] + * byteToRead1 + * byteToRead0 dummyByte + * */ +#define CMD_WRITETHENWRITEREAD 0x03 /* /< I2C/SPI write then + * writeRead: need to + * pass: cmdSize1 + * cmdSize2 cmd1[0] + * cmd1[1] … + * cmd1[cmdSize1-1] + * cmd2[0] cmd2[1] … + * cmd2[cmdSize2-1] + * byteToRead1 + * byteToRead0 */ +#define CMD_WRITEU8UX 0x04 /* /< I2C/SPI writeU8UX: + * need to pass: cmd + * addrSize addr[0] … + * addr[addrSize-1] + * data[0] data[1] … */ +#define CMD_WRITEREADU8UX 0x05 /* /< I2C/SPI + * writeReadU8UX: need + * to pass: cmd addrSize + * addr[0] … + * addr[addrSize-1] + * byteToRead1 + * byteToRead0 + * hasDummyByte */ +#define CMD_WRITEU8UXTHENWRITEU8UX 0x06 /* /< I2C/SPI writeU8UX + * then writeU8UX: need + * to pass: cmd1 + * addrSize1 cmd2 + * addrSize2 addr[0] … + * addr[addrSize1+addrSize2-1] + * data[0] data[1] … */ +#define CMD_WRITEU8UXTHENWRITEREADU8UX 0x07 /* /< I2C/SPI writeU8UX + * then writeReadU8UX: + * need to pass: cmd1 + * addrSize1 cmd2 + * addrSize2 addr[0] … + * addr[addrSize1+addrSize2-1] + * byteToRead1 + * byteToRead0 + * hasDummybyte */ +#define CMD_GETLIMITSFILE 0x08 /* /< Get the Production + * Limits File and print + * its content into the + * shell: need to pass: + * path(optional) + * otherwise select the + * approach chosen at + * compile time */ +#define CMD_GETFWFILE 0x09 /* /< Get the FW file + * and print its content + * into the shell: need + * to pass: path + * (optional) otherwise + * select the approach + * chosen at compile + * time */ +#define CMD_VERSION 0x0A /* /< Get the driver + * version and other + * driver setting info + * */ +#define CMD_READCONFIG 0x0B /* /< Read The config + * memory, need to pass: + * addr[0] addr[1] + * byteToRead0 + * byteToRead1 */ + + +/* GUI utils byte ver */ +#define CMD_READ_BYTE 0xF0 /* /< Byte output + * version of I2C/SPI + * read @see CMD_READ */ +#define CMD_WRITE_BYTE 0xF1 /* /< Byte output + * version of I2C/SPI + * write @see CMD_WRITE + * */ +#define CMD_WRITEREAD_BYTE 0xF2 /* /< Byte output + * version of I2C/SPI + * writeRead @see + * CMD_WRITEREAD */ +#define CMD_WRITETHENWRITEREAD_BYTE 0xF3 /* /< Byte output + * version of I2C/SPI + * write then writeRead + * @see + * CMD_WRITETHENWRITEREAD + * */ +#define CMD_WRITEU8UX_BYTE 0xF4 /* /< Byte output + * version of I2C/SPI + * writeU8UX @see + * CMD_WRITEU8UX */ +#define CMD_WRITEREADU8UX_BYTE 0xF5 /* /< Byte output + * version of I2C/SPI + * writeReadU8UX @see + * CMD_WRITEREADU8UX */ +#define CMD_WRITEU8UXTHENWRITEU8UX_BYTE 0xF6 /* /< Byte output + * version of I2C/SPI + * writeU8UX then + * writeU8UX @see + * CMD_WRITEU8UXTHENWRITEU8UX + * */ +#define CMD_WRITEU8UXTHENWRITEREADU8UX_BYTE 0xF7 /* /< Byte output + * version of I2C/SPI + * writeU8UX then + * writeReadU8UX @see + * CMD_WRITEU8UXTHENWRITEREADU8UX + * */ +#define CMD_GETLIMITSFILE_BYTE 0xF8 /* /< Byte output + * version of Production + * Limits File @see + * CMD_GETLIMITSFILE */ +#define CMD_GETFWFILE_BYTE 0xF9 /* /< Byte output + * version of FW file + * need to pass: @see + * CMD_GETFWFILE */ +#define CMD_VERSION_BYTE 0xFA /* /< Byte output + * version of driver + * version and setting + * @see CMD_VERSION */ +#define CMD_CHANGE_OUTPUT_MODE 0xFF /* /< Select the output + * mode of the + * scriptless protocol, + * need to pass: + * bin_output = 1 data + * returned as binary, + * bin_output =0 data + * returned as hex + * string */ + +/* Core/Tools */ +#define CMD_POLLFOREVENT 0x11 /* /< Poll the FIFO for + * an event: need to + * pass: eventLength + * event[0] event[1] … + * event[eventLength-1] + * timeToWait1 + * timeToWait0 */ +#define CMD_SYSTEMRESET 0x12 /* /< System Reset */ +#define CMD_CLEANUP 0x13 /* /< Perform a system + * reset and optionally + * re-enable the + * scanning, need to + * pass: enableTouch */ +#define CMD_POWERCYCLE 0x14 /* /< Execute a power + * cycle toggling the + * regulators */ +#define CMD_READSYSINFO 0x15 /* /< Read the System + * Info information from + * the framebuffer, need + * to pass: doRequest */ +#define CMD_FWWRITE 0x16 /* /< Write a FW + * command: need to + * pass: cmd[0] cmd[1] + * … cmd[cmdLength-1] */ +#define CMD_INTERRUPT 0x17 /* /< Allow to enable or + * disable the + * interrupts, need to + * pass: enable (if 1 + * will enable the + * interrupt) */ +#define CMD_SETSCANMODE 0x18 /* /< set Scan Mode + * need to pass: + * scanType option */ +#define CMD_SAVEMPFLAG 0x19 /* /< save manually a + * value in the MP flag + * need to pass: mpflag + */ + +/* Frame */ +#define CMD_GETFORCELEN 0x20 /* /< Get the number of + * Force channels */ +#define CMD_GETSENSELEN 0x21 /* /< Get the number of + * Sense channels */ +#define CMD_GETMSFRAME 0x23 /* /< Get a MS frame: + * need to pass: + * MSFrameType */ +#define CMD_GETSSFRAME 0x24 /* /< Get a SS frame: + * need to pass: + * SSFrameType */ +#define CMD_GETSYNCFRAME 0x25 /* /< Get a Sync Frame: + * need to pass: + * frameType */ + +/* Compensation */ +#define CMD_REQCOMPDATA 0x30 /* /< Request Init data: + * need to pass: type */ +#define CMD_READCOMPDATAHEAD 0x31 /* /< Read Init data + * header: need to pass: + * type */ +#define CMD_READMSCOMPDATA 0x32 /* /< Read MS Init data: + * need to pass: type */ +#define CMD_READSSCOMPDATA 0x33 /* /< Read SS Init data: + * need to pass: type */ +#define CMD_READTOTMSCOMPDATA 0x35 /* /< Read Tot MS Init + * data: need to pass: + * type */ +#define CMD_READTOTSSCOMPDATA 0x36 /* /< Read Tot SS Init + * data: need to pass: + * type */ + +/* FW Update */ +#define CMD_GETFWVER 0x40 /* /< Get the FW version + * of the IC */ +#define CMD_FLASHUNLOCK 0x42 /* /< Unlock the flash + * */ +#define CMD_READFWFILE 0x43 /* /< Try to read the FW + * file, need to pass: + * keep_cx */ +#define CMD_FLASHPROCEDURE 0x44 /* /< Perform a full + * flashing procedure: + * need to pass: force + * keep_cx */ +#define CMD_FLASHERASEUNLOCK 0x45 /* /< Unlock the erase + * of the flash */ +#define CMD_FLASHERASEPAGE 0x46 /* /< Erase page by page + * the flash, need to + * pass: keep_cx, if + * keep_cx>SKIP_PANEL_INIT + * Panel Init Page will + * be skipped, if + * >SKIP_PANEL_CX_INIT + * Cx and Panel Init + * Pages will be skipped + * otherwise if + * =ERASE_ALL all the + * pages will be deleted + * */ + + +/* MP test */ +#define CMD_ITOTEST 0x50 /* /< Perform an ITO + * test */ +#define CMD_INITTEST 0x51 /* /< Perform an + * Initialization test: + * need to pass: type */ +#define CMD_MSRAWTEST 0x52 /* /< Perform MS raw + * test: need to pass + * stop_on_fail */ +#define CMD_MSINITDATATEST 0x53 /* /< Perform MS Init + * data test: need to + * pass stop_on_fail */ +#define CMD_SSRAWTEST 0x54 /* /< Perform SS raw + * test: need to pass + * stop_on_fail */ +#define CMD_SSINITDATATEST 0x55 /* /< Perform SS Init + * data test: need to + * pass stop_on_fail */ +#define CMD_MAINTEST 0x56 /* /< Perform a full + * Mass production test: + * need to pass + * stop_on_fail saveInit + * mpflag + * */ +#define CMD_FREELIMIT 0x57 /* /< Free (if any) + * limit file which was + * loaded during any + * test procedure */ + +/* Diagnostic */ +#define CMD_DIAGNOSTIC 0x60 /* /< Perform a series + * of commands and + * collect severals data + * to detect any + * malfunction */ + + +#define CMD_CHANGE_SAD 0x70 /* /< Allow to change + * the SAD address (for + * debugging) */ + +static u8 bin_output; /* /< Select the output type of the scriptless + * protocol (binary = 1 or hex string = 0) */ +/** @}*/ + +/** @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 /* /< start byte of each message + * transferred in Scriptless Mode */ +#define MESSAGE_END_BYTE 0x7D /* /< end byte of each message + * transferred in Scriptless Mode */ +#define MESSAGE_MIN_HEADER_SIZE 8 /* /< minimun number of bytes of the + * structure of a messages exchanged + * with host (include start/end byte, + * counter, actions, msg_size) */ + +/** + * Possible actions that can be requested by an host + */ +typedef enum { + ACTION_WRITE = (u16) 0x0001, /* /< Bus Write + * */ + ACTION_READ = (u16) 0x0002, /* /< Bus Read + * */ + ACTION_WRITE_READ = (u16) 0x0003, /* /< Bus Write + * followed by a + * Read */ + ACTION_GET_VERSION = (u16) 0x0004, /* /< Get + * Version of + * the protocol + * (equal to the + * first 2 bye + * of driver + * version) */ + ACTION_WRITEU8UX = (u16) 0x0011, /* /< Bus Write + * with support + * to different + * address size + * */ + ACTION_WRITEREADU8UX = (u16) 0x0012, /* /< Bus + * writeRead + * with support + * to different + * address size + * */ + ACTION_WRITETHENWRITEREAD = (u16) 0x0013, /* /< Bus write + * followed by a + * writeRead */ + ACTION_WRITEU8XTHENWRITEREADU8UX = (u16) 0x0014, /* /< Bus write + * followed by a + * writeRead + * with support + * to different + * address size + * */ + ACTION_WRITEU8UXTHENWRITEU8UX = (u16) 0x0015, /* /< Bus write + * followed by a + * write with + * support to + * different + * address size + * */ + ACTION_GET_FW = (u16) 0x1000, /* /< Get Fw + * file content + * used by the + * driver */ + ACTION_GET_LIMIT = (u16) 0x1001 /* /< Get Limit + * File content + * used by the + * driver */ +} Actions; + +/** + * Struct used to contain info of the message received by the host in + * Scriptless mode + */ +typedef struct { + u16 msg_size; /* /< total size of the message in bytes */ + u16 counter; /* /< counter ID to identify a message */ + Actions action; /* /< type of operation requested by the host @see + * Actions */ + u8 dummy; /* /< (optional)in case of any kind of read operations, + * specify if the first byte is dummy */ +} Message; + +/** @}*/ + + + +extern TestToDo tests; +extern SysInfo systemInfo; + +static int limit; /* /< store the amount of data to print into the shell */ +static int chunk; /* /< store the chuk of data that should be printed in + * this iteration */ +static int printed; /* /< store the amount of data already printed in the + * shell */ +static struct proc_dir_entry *fts_dir; /* /< reference to the directory + * fts under /proc */ +static u8 *driver_test_buff; /* /< pointer to an array of bytes used + * to store the result of the function + * executed */ +char buf_chunk[CHUNK_PROC] = { 0 }; /* /< buffer used to store the message + * info received */ +static Message mess = { 0 }; /* /< store the information of the Scriptless + * message received */ + + +/************************ 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, 14, "{ %08X }\n", ERROR_OP_NOT_ALLOW); + + + limit = strlen(driver_test_buff); + /* logError(0, "%s %s: len = %d driver_test_buff = %s\n", tag, + * __func__, limit, driver_test_buff); */ + } else { + if (*pos != 0) + *pos += chunk - 1; + + if (*pos >= limit) + /* logError(0, "%s %s: Apparently, we're done.\n", tag, + * __func__); */ + return NULL; + } + + chunk = CHUNK_PROC; + if (limit - *pos < CHUNK_PROC) + chunk = limit - *pos; + /* logError(0, "%s %s: In start(), updated pos = %ld limit = %d printed = %d chunk = %d\n", + * tag, __func__, *pos, limit, printed, chunk); */ + 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) +{ + /* logError(0, "%s %s: In show()\n", tag, __func__); */ + 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) +{ + /* int* val_ptr; */ + /* logError(0, "%s %s: In next(), v = %X, pos = %ld.\n", tag, __func__, + * v, *pos); */ + (*pos) += chunk;/* increase my position counter */ + chunk = CHUNK_PROC; + + /* logError(0, "%s %s: In next(), updated pos = %ld limit = %d printed = %d\n", + * tag, __func__, *pos, limit,printed); */ + if (*pos >= limit) /* are we done? */ + 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) +{ + /* logError(0, "%s %s: Entering stop().\n", tag, __func__); */ + + if (v) { + /* logError(0, "%s %s: v is %X.\n", tag, __func__, v); */ + } else { + /* logError(0, "%s %s: v is null.\n", tag, __func__); */ + limit = 0; + chunk = 0; + printed = 0; + if (driver_test_buff != NULL) { + /* logError(0, "%s %s: Freeing and clearing driver_test_buff.\n", + * tag, __func__); */ + 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 const 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[count]; /* worst case needs count bytes */ + u32 funcToTest[((count + 1) / 3)]; + u64 addr = 0; + MutualSenseFrame frameMS; + SelfSenseFrame frameSS; + + DataHeader dataHead; + MutualSenseData compData; + SelfSenseData comData; + TotMutualSenseData totCompData; + TotSelfSenseData totComData; + + u64 address; + + Firmware fw; + LimitFile lim; + + mess.dummy = 0; + mess.action = 0; + mess.msg_size = 0; + + /*for(temp = 0; temp 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; /* +2 error code */ + 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, (int)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; /* +1 because put the internal + * op code */ + size = MESSAGE_MIN_HEADER_SIZE + 2; /* +2 send also + * the first 2 + * lsb of the + * error code */ + switch (mess.action) { + case ACTION_READ: + /* numberParam = + * mess.msg_size-MESSAGE_MIN_HEADER_SIZE+1; */ + 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); + /* -1 because i need to exclude the cmd[0] */ + } + } else { + if (((count + 1) / 3) >= 1) { + if (sscanf(p, "%02X ", &funcToTest[0]) == 1) { + 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) { + if (sscanf(p, "%100s", path) == 1) + numberParam = 2; + /* the first byte is an hex + * string coded in three byte (2 + * chars for hex and the space) + * and -1 for the space at the + * end */ + } + break; + + default: + for (; numberParam < (count + 1) / 3; numberParam++) { + if (sscanf(p, "%02X ", + &funcToTest[numberParam]) == 1) { + 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); + + /* elaborate input */ + if (numberParam >= 1) { + /*res = fts_disableInterrupt(); + * if (res < 0) + * { + * logError(0, "%s %s: ERROR %08X\n", tag, __func__, + *res); + * res = (res | ERROR_DISABLE_INTER); + * goto END; + * }*/ + switch (funcToTest[0]) { + case CMD_VERSION_BYTE: + logError(0, "%s %s: Get Version Byte\n", tag, + __func__); + 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; + /* first two bytes bitmask of features enabled in the + * IC, second two bytes bitmask of features enabled in + * the driver */ + +#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 COMPUTE_INIT_METHOD + fileSize |= 0x00200000; +#endif + +#ifdef USE_GESTURE_MASK + fileSize |= 0x00100000; +#endif + +#ifdef I2C_INTERFACE + fileSize |= 0x00200000; +#endif + +#ifdef SPI4_WIRE + fileSize |= 0x00400000; +#endif + +#ifdef PHONE_KEY /* it is a feature enabled in the config of the chip */ + 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) { /* need to pass: cmd[0] cmd[1] + * … cmd[cmdLength-1] + * byteToRead1 byteToRead0 + * dummyByte */ + 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(&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) { /* need to pass: cmd[0] cmd[1] + * … cmd[cmdLength-1] */ + temp = numberParam - 1; + + res = fts_write(&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) { /* need to pass: byteToRead1 + * byteToRead0 (optional) + * dummyByte */ + 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(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: + /* need to pass: cmdSize1 cmdSize2 cmd1[0] cmd1[1] … + * cmd1[cmdSize1-1] cmd2[0] cmd2[1] … cmd2[cmdSize2-1] + * byteToRead1 byteToRead0 */ + 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: + /* need to pass: cmd addrSize addr[0] … addr[addrSize-1] + * data[0] data[1] … */ + if (numberParam >= 4) { + if (cmd[2] <= sizeof(u64)) { + u8ToU64_be(&cmd[3], &addr, cmd[2]); + logError(0, "%s addr = %016llX %ld\n", + tag, addr, (long int)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: + /* need to pass: cmd addrSize addr[0] … addr[addrSize-1] + * byteToRead1 byteToRead0 hasDummyByte */ + 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 = %016llX 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: + /* need to pass: cmd1 addrSize1 cmd2 addrSize2 addr[0] … + * addr[addrSize1+addrSize2-1] data[0] data[1] … */ + if (numberParam >= 6) { + if ((cmd[2] + cmd[4]) <= sizeof(u64)) { + u8ToU64_be(&cmd[5], &addr, cmd[2] + + cmd[4]); + + logError(0, "%s addr = %016llX %lld\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: + /* need to pass: cmd1 addrSize1 cmd2 addrSize2 addr[0] … + * addr[addrSize1+addrSize2-1] byteToRead1 byteToRead0 + * hasDummybyte */ + 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 = %016llX\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: + /* need to pass: bin_output */ + 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) { /* need to pass: cmd[0] cmd[1] + * … cmd[cmdLength-1] */ + 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: + /* need to pass: enable */ + 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_SETSCANMODE: + /* need to pass: scanMode option */ + if (numberParam >= 3) + res = setScanMode(cmd[1], cmd[2]); + else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_SAVEMPFLAG: + /* need to pass: mpflag */ + if (numberParam == 2) + res = saveMpFlag(cmd[1]); + else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + + case CMD_READCONFIG: + if (numberParam == 5) { /* need to pass: addr[0] + * addr[1] byteToRead1 + * byteToRead0 */ + 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) { /* need to pass: eventLength + * event[0] event[1] … + * event[eventLength-1] + * timeTowait1 timeTowait0 */ + 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; /* pollForEvent + * return the + * number of + * error found + * */ + 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) /* need to pass: doRequest */ + res = readSysInfo(funcToTest[1]); + else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + break; + + case CMD_CLEANUP:/* TOUCH ENABLE/DISABLE */ + if (numberParam == 2) /* need to pass: enableTouch */ + res = cleanUp(funcToTest[1]); + else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + + break; + + case CMD_GETFORCELEN: /* read number Tx channels */ + temp = getForceLen(); + if (temp < OK) + res = temp; + else { + size += (1 * sizeof(u8)); + res = OK; + } + break; + + case CMD_GETSENSELEN: /* read number Rx channels */ + 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, 0xFF); + msleep(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(WAIT_AFTER_SENSEOFF); + flushFIFO(); */ /* delete the events related to + * some touch (allow to call this function while + * touching the screen without having a flooding + * of the FIFO) */ + 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); + /* +2 to add force and sense channels */ + /* 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(); //delete the events related to + * some touch (allow to call this function while + * touching the screen without having a flooding + * of the FIFO) */ + /* setScanMode(SCAN_MODE_ACTIVE, 0xFF); + msleep(WAIT_FOR_FRESH_FRAMES); + setScanMode(SCAN_MODE_ACTIVE, 0x00); + msleep(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); + /* +2 to add force and sense channels */ + /* 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_GETSYNCFRAME: + /* need to pass: frameType (this parameter can be + * one of LOAD_SYNC_FRAME_X) */ + if (numberParam == 2) { + logError(1, "%s Reading Sync Frame...\n", tag); + res = getSyncFrame(cmd[1], &frameMS, &frameSS); + if (res < OK) + logError(0, + "%s Error while taking the Sync Frame frame... ERROR %08X\n", + tag, res); + + else { + logError(0, + "%s The total frames size is %d words\n", + tag, res); + size += (res * sizeof(short) + 4); + /* +4 to add force and sense channels + * for MS and SS */ + /* set res to OK because if getSyncFrame + * 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); + 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: /* request comp data */ + 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: /* read comp data header */ + 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:/* read mutual comp data */ + 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) { /* read self comp data */ + 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 + 15) * + 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: /* read mutual comp data */ + 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) { /* read self comp data */ + 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: + size += (EXTERNAL_RELEASE_INFO_SIZE)*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) { /* read fw file */ + 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) { /* flashing procedure */ + 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) { /* need to pass: keep_cx */ + 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); + logError(0, + "%s Starting Flashing Page Erase...\n", + tag); + res = flash_erase_page_by_page(cmd[1], &fw); + 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); + kfree(fw.data); + } 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: /* MS Raw DATA TEST */ + if (numberParam == 2) /* need to specify if stopOnFail + * */ + 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:/* MS CX DATA TEST */ + if (numberParam == 2) /* need stopOnFail */ + 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: /* SS RAW DATA TEST */ + if (numberParam == 2) /* need stopOnFail */ + 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:/* SS IX CX DATA TEST */ + if (numberParam == 2) /* need stopOnFail */ + 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) { /* need to specify if stopOnFail + * saveInit and + * mpflag(optional)*/ + if (numberParam == 3) + res = production_test_main(LIMITS_FILE, + cmd[1], + cmd[2], &tests, + MP_FLAG_OTHERS); + else + res = production_test_main(LIMITS_FILE, + cmd[1], + cmd[2], &tests, + cmd[3]); + } 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: + /* need to pass: path(optional) return error code + + * number of byte read otherwise GUI could not now how + * many byte read */ + 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); /* transmit as + * first 4 bytes + * the size */ + } else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETLIMITSFILE_BYTE: + /* need to pass: byteToRead1 byteToRead0 */ + if (numberParam >= 3) { + lim.data = NULL; + lim.size = 0; + + u8ToU16_be(&cmd[1], &byteToRead); + addr = ((u64)byteToRead) * 4; /* number of + * words */ + + 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: + /* need to pass: from (optional) otherwise select the + * approach chosen at compile time */ + 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); /* transmit as + * first 4 bytes + * the size */ + } else { + logError(1, "%s Wrong number of parameters!\n", + tag); + res = ERROR_OP_NOT_ALLOW; + } + break; + + case CMD_GETFWFILE_BYTE: + /* need to pass: byteToRead1 byteToRead0 */ + if (numberParam == 3) { + u8ToU16_be(&cmd[1], &byteToRead); + addr = ((u64)byteToRead) * 4; /* number of + * words */ + + + 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)); /* return always + * the amount + * requested by + * host, if real + * size is + * smaller, the + * data are + * padded to + * zero */ + } 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 = 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); + 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); + j = snprintf(&driver_test_buff[index], + fileSize - index, + "Echo FOUND... OK!\n"); + index += j; + } + + logError(1, "%s Reading Frames...!\n", tag); + 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); + 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); + /* OR to detect if there are failures also in the + * previous reading of frames and write the correct + * result */ + 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); + 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; + } + /* the sting is already terminated with the null char by + * snprintf */ + limit = index; + printed = 0; + goto ERROR; + break; +#ifdef I2C_INTERFACE + case CMD_CHANGE_SAD: + res = changeSAD(cmd[1]); + break; +#endif + + default: + logError(1, "%s COMMAND ID NOT VALID!!!\n", tag); + res = ERROR_OP_NOT_ALLOW; + break; + } + + /*res2 = fts_enableInterrupt(); + * the interrupt was disabled on purpose in this node because it + * can be used for testing procedure and between one step and + * another the interrupt wan to be kept disabled + * if (res2 < 0) { + * logError(0, "%s stm_driver_test_show: ERROR %08X\n", + *tag, (res2 | 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; + } + +END: /* here start the reporting phase, assembling the data to send in the + * file node */ + 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; /* add \n and \0 (terminator char) */ + } else { + if (bin_output != 1) { + size *= 2; /* need to code each byte as HEX string */ + size -= 1; /* start byte is just one, the extra + * byte of end byte taken by \n */ + } else + size += 1; /* add \n */ + } + + 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: + /* logError(0, "%s Data = ", tag); */ + if (mess.dummy == 1) + j = 1; + else + j = 0; + for (; j < byteToRead + mess.dummy; j++) { + /* logError(0, "%02X ", readData[j]); */ + snprintf(&driver_test_buff[index], 3, + "%02X", readData[j]); + /* this approach is much more faster */ + index += 2; + } + /* logError(0, "\n"); */ + break; + case CMD_GETFWFILE: + case CMD_GETLIMITSFILE: + logError(0, "%s Start To parse!\n", tag); + for (j = 0; j < fileSize; j++) { + /* logError(0, "%02X ", readData[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; + /* Copying self raw data Force */ + 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; + } + + + /* Copying self raw data Sense */ + 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_GETSYNCFRAME: + 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; + + 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; + + /* Copying mutual data */ + 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; + } + + /* Copying self data Force */ + 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; + } + + + /* Copying self data Sense */ + 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(frameMS.node_data); + 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; + + /* Cpying CX1 value */ + snprintf(&driver_test_buff[index], 3, "%02X", + compData.cx1 & 0xFF); + index += 2; + + /* Copying CX2 values */ + 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; + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.f_ix0 & 0xFF); + index += 2; + + + snprintf(&driver_test_buff[index], 3, "%02X", + comData.s_ix0 & 0xFF); + index += 2; + + + /* Copying IX2 Force */ + for (j = 0; j < comData.header.force_node; + j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", comData.ix2_fm[j] & + 0xFF); + index += 2; + } + + /* Copying IX2 Sense */ + for (j = 0; j < comData.header.sense_node; + j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", comData.ix2_sn[j] & + 0xFF); + index += 2; + } + + /* Copying CX2 Force */ + for (j = 0; j < comData.header.force_node; + j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", comData.cx2_fm[j] & + 0xFF); + + index += 2; + } + + /* Copying CX2 Sense */ + 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; + + /* Copying TOT CX values */ + 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; + + /* Copying TOT IX Force */ + 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; + } + + /* Copying TOT IX Sense */ + 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; + } + + /* Copying TOT CX Force */ + 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; + } + + /* Copying CX2 Sense */ + 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: + for (j = 0; j < EXTERNAL_RELEASE_INFO_SIZE; + j++) { + snprintf(&driver_test_buff[index], 3, + "%02X", + systemInfo.u8_releaseInfo[j]); + index += 2; + } + 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;/* avoid to print \0 in the shell */ + printed = 0; + } else { + /* start byte */ + driver_test_buff[index++] = MESSAGE_START_BYTE; + if (bin_output == 1) { + /* msg_size */ + driver_test_buff[index++] = (size & 0xFF00) >> 8; + driver_test_buff[index++] = (size & 0x00FF); + /* counter id */ + driver_test_buff[index++] = (mess.counter & 0xFF00) >> + 8; + driver_test_buff[index++] = (mess.counter & 0x00FF); + /* action */ + driver_test_buff[index++] = (mess.action & 0xFF00) >> 8; + driver_test_buff[index++] = (mess.action & 0x00FF); + /* error */ + 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) { + /* override the msg_size with dimension in words + * */ + 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; /* in this case the byte to read + * are stored in addr because it + * is a u64 end byte need to be + * inserted at the end of the + * padded memory */ + } else { + /* snprintf(&driver_test_buff[1], 3, "%02X", + * (((fileSize + 3) / 4)&0xFF00) >> 8); */ + /* snprintf(&driver_test_buff[3], 3, "%02X", + * ((fileSize + 3) / 4)&0x00FF); */ + 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); /* pad memory + * with 0x00 */ + } + break; + default: + break; + } + + driver_test_buff[index++] = MESSAGE_END_BYTE; + driver_test_buff[index] = '\n'; + /*for(j=0; j