diff --git a/nfc/Makefile b/nfc/Makefile index 52c28951e7..debebf6b79 100644 --- a/nfc/Makefile +++ b/nfc/Makefile @@ -2,5 +2,5 @@ # Makefile for nfc devices # obj-$(CONFIG_NXP_NFC_I2C) += pn553_i2c.o -pn553_i2c-objs := common.o common_ese.o i2c_drv.o -#ccflags-y := -DDEBUG +pn553_i2c-objs := common.o common_ese.o i2c_drv.o recovery_seq.o recovery_fw.o +ccflags-y += -DRECOVERY_ENABLE -UDEBUG diff --git a/nfc/common.c b/nfc/common.c index ee6f64a39a..4f0264d9fb 100644 --- a/nfc/common.c +++ b/nfc/common.c @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2019-2020 NXP + * Copyright (C) 2019-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,10 +23,15 @@ #include "common.h" #include "common_ese.h" -int nfc_parse_dt(struct device *dev, platform_gpio_t * nfc_gpio, +#if defined(RECOVERY_ENABLE) +#include "recovery_seq.h" +#endif + +int nfc_parse_dt(struct device *dev, platform_configs_t *nfc_configs, uint8_t interface) { struct device_node *np = dev->of_node; + platform_gpio_t *nfc_gpio = &nfc_configs->gpio; if (!np) { pr_err("nfc of_node NULL\n"); @@ -45,11 +50,6 @@ int nfc_parse_dt(struct device *dev, platform_gpio_t * nfc_gpio, return -EINVAL; } pr_info("%s: irq %d\n", __func__, nfc_gpio->irq); - - nfc_gpio->dwl_req = of_get_named_gpio(np, DTS_FWDN_GPIO_STR, 0); - if ((!gpio_is_valid(nfc_gpio->dwl_req))) { - pr_err("nfc dwl_req gpio invalid %d\n", nfc_gpio->dwl_req); - } } nfc_gpio->ven = of_get_named_gpio(np, DTS_VEN_GPIO_STR, 0); if ((!gpio_is_valid(nfc_gpio->ven))) { @@ -57,6 +57,11 @@ int nfc_parse_dt(struct device *dev, platform_gpio_t * nfc_gpio, return -EINVAL; } + nfc_gpio->dwl_req = of_get_named_gpio(np, DTS_FWDN_GPIO_STR, 0); + if ((!gpio_is_valid(nfc_gpio->dwl_req))) { + pr_warn("nfc dwl_req gpio invalid %d\n", nfc_gpio->dwl_req); + } + pr_info("%s: %d, %d, %d, %d\n", __func__, nfc_gpio->irq, nfc_gpio->ven, nfc_gpio->dwl_req); return 0; @@ -68,7 +73,8 @@ void set_valid_gpio(int gpio, int value) pr_debug("%s gpio %d value %d\n", __func__, gpio, value); gpio_set_value(gpio, value); // hardware dependent delay - usleep_range(10000, 10100); + usleep_range(NFC_GPIO_SET_WAIT_TIME_USEC, + NFC_GPIO_SET_WAIT_TIME_USEC + 100); } } @@ -84,15 +90,17 @@ int get_valid_gpio(int gpio) void gpio_set_ven(struct nfc_dev *nfc_dev, int value) { - if (gpio_get_value(nfc_dev->gpio.ven) != value) { + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; + if (gpio_get_value(nfc_gpio->ven) != value) { pr_debug("%s: gpio_set_ven %d\n", __func__, value); /*reset on change in level from high to low */ if (value) { common_ese_on_hard_reset(nfc_dev); } - gpio_set_value(nfc_dev->gpio.ven, value); + gpio_set_value(nfc_gpio->ven, value); // hardware dependent delay - usleep_range(10000, 10100); + usleep_range(NFC_GPIO_SET_WAIT_TIME_USEC, + NFC_GPIO_SET_WAIT_TIME_USEC + 100); } } @@ -140,14 +148,15 @@ int configure_gpio(unsigned int gpio, int flag) void gpio_free_all(nfc_dev_t *nfc_dev) { - if (gpio_is_valid(nfc_dev->gpio.dwl_req)) { - gpio_free(nfc_dev->gpio.dwl_req); + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; + if (gpio_is_valid(nfc_gpio->dwl_req)) { + gpio_free(nfc_gpio->dwl_req); } - if (gpio_is_valid(nfc_dev->gpio.irq)) { - gpio_free(nfc_dev->gpio.irq); + if (gpio_is_valid(nfc_gpio->irq)) { + gpio_free(nfc_gpio->irq); } - if (gpio_is_valid(nfc_dev->gpio.ven)) { - gpio_free(nfc_dev->gpio.ven); + if (gpio_is_valid(nfc_gpio->ven)) { + gpio_free(nfc_gpio->ven); } } @@ -211,6 +220,7 @@ int nfc_misc_register(nfc_dev_t *nfc_dev, static int nfc_ioctl_power_states(nfc_dev_t *nfc_dev, unsigned long arg) { int ret = 0; + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; if (arg == NFC_POWER_OFF) { /* * We are attempting a hardware reset so let us disable @@ -218,12 +228,12 @@ static int nfc_ioctl_power_states(nfc_dev_t *nfc_dev, unsigned long arg) * layers. */ nfc_dev->nfc_disable_intr(nfc_dev); - set_valid_gpio(nfc_dev->gpio.dwl_req, 0); + set_valid_gpio(nfc_gpio->dwl_req, 0); gpio_set_ven(nfc_dev, 0); nfc_dev->nfc_ven_enabled = false; } else if (arg == NFC_POWER_ON) { nfc_dev->nfc_enable_intr(nfc_dev); - set_valid_gpio(nfc_dev->gpio.dwl_req, 0); + set_valid_gpio(nfc_gpio->dwl_req, 0); gpio_set_ven(nfc_dev, 1); nfc_dev->nfc_ven_enabled = true; @@ -233,10 +243,8 @@ static int nfc_ioctl_power_states(nfc_dev_t *nfc_dev, unsigned long arg) * in order to set the NFCC in the new mode */ nfc_dev->nfc_disable_intr(nfc_dev); - set_valid_gpio(nfc_dev->gpio.dwl_req, 1); - if (nfc_dev->interface == PLATFORM_IF_I2C) { - nfc_dev->nfc_state = NFC_STATE_FW_DWL; - } + set_valid_gpio(nfc_gpio->dwl_req, 1); + nfc_dev->nfc_state = NFC_STATE_FW_DWL; gpio_set_ven(nfc_dev, 0); gpio_set_ven(nfc_dev, 1); nfc_dev->nfc_enable_intr(nfc_dev); @@ -245,10 +253,8 @@ static int nfc_ioctl_power_states(nfc_dev_t *nfc_dev, unsigned long arg) * Setting firmware download gpio to HIGH * before FW download start */ - set_valid_gpio(nfc_dev->gpio.dwl_req, 1); - if (nfc_dev->interface == PLATFORM_IF_I2C) { - nfc_dev->nfc_state = NFC_STATE_FW_DWL; - } + set_valid_gpio(nfc_gpio->dwl_req, 1); + nfc_dev->nfc_state = NFC_STATE_FW_DWL; } else if (arg == NFC_VEN_FORCED_HARD_RESET) { nfc_dev->nfc_disable_intr(nfc_dev); @@ -260,10 +266,8 @@ static int nfc_ioctl_power_states(nfc_dev_t *nfc_dev, unsigned long arg) * Setting firmware download gpio to LOW * FW download finished */ - set_valid_gpio(nfc_dev->gpio.dwl_req, 0); - if (nfc_dev->interface == PLATFORM_IF_I2C) { - nfc_dev->nfc_state = NFC_STATE_NCI; - } + set_valid_gpio(nfc_gpio->dwl_req, 0); + nfc_dev->nfc_state = NFC_STATE_NCI; } else { pr_err("%s bad arg %lu\n", __func__, arg); ret = -ENOIOCTLCMD; @@ -305,8 +309,7 @@ long nfc_dev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg) pr_debug("nfc get state %d\n", ret); break; case NFC_GET_IRQ_STATE: - ret = 0; - ret = gpio_get_value(nfc_dev->gpio.irq); + ret = gpio_get_value(nfc_dev->configs.gpio.irq); break; default: pr_err("%s bad cmd %lu\n", __func__, arg); @@ -325,7 +328,7 @@ int nfc_dev_open(struct inode *inode, struct file *filp) filp->private_data = nfc_dev; if (nfc_dev->dev_ref_count == 0) { - set_valid_gpio(nfc_dev->gpio.dwl_req, 0); + set_valid_gpio(nfc_dev->configs.gpio.dwl_req, 0); nfc_dev->nfc_enable_intr(nfc_dev); } @@ -341,7 +344,7 @@ int nfc_dev_close(struct inode *inode, struct file *filp) mutex_lock(&nfc_dev->dev_ref_mutex); if (nfc_dev->dev_ref_count == 1) { nfc_dev->nfc_disable_intr(nfc_dev); - set_valid_gpio(nfc_dev->gpio.dwl_req, 0); + set_valid_gpio(nfc_dev->configs.gpio.dwl_req, 0); } if (nfc_dev->dev_ref_count > 0) nfc_dev->dev_ref_count = nfc_dev->dev_ref_count - 1; @@ -363,14 +366,6 @@ static int get_nfcc_boot_state(struct nfc_dev *nfc_dev) char get_version_cmd[] = { 0x00, 0x04, 0xF1, 0x00, 0x00, 0x00, 0x6E, 0xEF }; char get_session_state_cmd[] = { 0x00, 0x04, 0xF2, 0x00, 0x00, 0x00, 0xF5, 0x33 }; char rsp_buf[MAX_BUFFER_SIZE]; - /*clearing any data in the kbuf store */ - do { - ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, MAX_BUFFER_SIZE); - if (ret < 0) { - pr_err("%s: - nfc read ret %d\n", __func__, ret); - } - pr_info("%s: - nfc read ret %d\n", __func__, ret); - } while (ret > 0); pr_debug("%s:Sending GET_VERSION cmd\n", __func__); ret = nfc_dev->nfc_write(nfc_dev, get_version_cmd, @@ -381,18 +376,23 @@ static int get_nfcc_boot_state(struct nfc_dev *nfc_dev) } memset(rsp_buf, 0x00, MAX_BUFFER_SIZE); pr_debug("%s:Reading response of GET_VERSION cmd\n", __func__); - ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, MAX_BUFFER_SIZE); + ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, DL_GET_VERSION_RSP_LEN_2, NCI_CMD_RSP_TIMEOUT); if (ret <= 0) { pr_err("%s: - nfc get version rsp error ret %d\n", __func__, ret); goto err; - } else if (rsp_buf[0] == 0x0 - && ret == (FW_HDR_LEN + rsp_buf[FW_PAYLOAD_LEN_IDX] + FW_CRC_LEN) - && (ret == DL_GET_VERSION_RSP_LEN_1 || ret == DL_GET_VERSION_RSP_LEN_2)) { - + } else if (rsp_buf[0] == FW_MSG_CMD_RSP + && ret >= DL_GET_VERSION_RSP_LEN_2) { +#if defined(RECOVERY_ENABLE) + nfc_dev->fw_major_version = rsp_buf[FW_MAJOR_VER_OFFSET]; + /* recvoery neeeded only for SN1xx */ + if(rsp_buf[FW_ROM_CODE_VER_OFFSET] == RECOVERY_FW_SUPPORTED_ROM_VER && + nfc_dev->fw_major_version == RECOVERY_FW_SUPPORTED_MAJOR_VER) + nfc_dev->recovery_required = true; +#endif pr_info("%s:NFC chip_type 0x%02x rom_version 0x%02x fw_minor 0x%02x fw_major 0x%02x\n", __func__, rsp_buf[3], rsp_buf[4], rsp_buf[6], rsp_buf[7]); - } else if (rsp_buf[0] != 0x0 - && ret == (NCI_HDR_LEN + rsp_buf[NCI_PAYLOAD_LEN_IDX])) { + } else if (rsp_buf[0] != FW_MSG_CMD_RSP + && ret >= (NCI_HDR_LEN + rsp_buf[NCI_PAYLOAD_LEN_IDX])) { pr_info("%s:NFC response bytes 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__, rsp_buf[0], rsp_buf[1], rsp_buf[2], rsp_buf[3], rsp_buf[3]); pr_debug("%s NFCC booted in NCI mode %d\n", __func__, __LINE__); @@ -409,7 +409,7 @@ static int get_nfcc_boot_state(struct nfc_dev *nfc_dev) } memset(rsp_buf, 0x00, DL_GET_SESSION_STATE_RSP_LEN); pr_debug("%s:Reading response of GET_SESSION_STATE cmd\n", __func__); - ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, DL_GET_SESSION_STATE_RSP_LEN); + ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, DL_GET_SESSION_STATE_RSP_LEN, NCI_CMD_RSP_TIMEOUT); if (ret <= 0) { pr_err("%s: - nfc get session state rsp err %d\n", __func__, ret); goto err; @@ -431,11 +431,12 @@ err: int validate_nfc_state_nci(nfc_dev_t *nfc_dev) { - if (!gpio_get_value(nfc_dev->gpio.ven)) { + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; + if (!gpio_get_value(nfc_gpio->ven)) { pr_err("VEN LOW - NFCC powered off\n"); return -ENODEV; } else { - if (get_valid_gpio(nfc_dev->gpio.dwl_req) == 1) { + if (get_valid_gpio(nfc_gpio->dwl_req) == 1) { pr_err("FW download in-progress\n"); return -EBUSY; } else if (nfc_dev->nfc_state == NFC_STATE_FW_DWL) { @@ -445,3 +446,162 @@ int validate_nfc_state_nci(nfc_dev_t *nfc_dev) } return 0; } + +static int set_nfcc_nci_state(struct nfc_dev *nfc_dev) +{ + int ret = 0; + char dl_reset_cmd[] = { 0x00, 0x04, 0xF0, 0x00, 0x00, 0x00, 0x18, 0x5B }; + + pr_debug("%s:Sending DL_RESET to boot in NCI mode\n", __func__); + ret = nfc_dev->nfc_write(nfc_dev, dl_reset_cmd, + sizeof(dl_reset_cmd), MAX_RETRY_COUNT); + if (ret <= 0) { + pr_err("%s: nfc dl reset cmd err ret %d\n", __func__, ret); + goto err; + } + usleep_range(NFC_SOFT_RESET_WAIT_TIME_USEC, + NFC_SOFT_RESET_WAIT_TIME_USEC + 100); + pr_debug("%s NFCC booted in NCI mode %d\n", __func__, __LINE__); + return 0; + +err: + pr_err("%s Unlikely NFCC not booted in NCI mode %d\n", __func__, __LINE__); + return -1; +} + +static bool do_nci_reset(nfc_dev_t *nfc_dev) { + const uint8_t cmd_reset_nci[] = {0x20, 0x00, 0x01, 0x00}; + char rsp_buf[MAX_BUFFER_SIZE]; + int status = 0; + + if (NULL == nfc_dev) { + pr_err("%s invalid params ", __func__); + return false; + } + pr_debug("%s Entry \n", __func__); + gpio_set_ven(nfc_dev, 0); + gpio_set_ven(nfc_dev, 1); + pr_debug(" %s send core reset cmd \n", __func__); + status = nfc_dev->nfc_write(nfc_dev, cmd_reset_nci, + sizeof(cmd_reset_nci), NO_RETRY); + if (status <= 0) { + pr_err(" %s: nfc nci core reset cmd err status %d\n", __func__, status); + return false; + } + usleep_range(NCI_RESET_RESP_READ_DELAY, NCI_RESET_RESP_READ_DELAY + 100); + nfc_dev->nfc_enable_intr(nfc_dev); + pr_debug(" %s Reading response of NCI reset \n", __func__); + memset(rsp_buf, 0x00, MAX_BUFFER_SIZE); + status = nfc_dev->nfc_read(nfc_dev, rsp_buf, MAX_BUFFER_SIZE, NCI_RESET_RESP_TIMEOUT); + if (status <= 0) { + pr_err(" %s - nfc nci rest rsp error status %d\n", __func__, status); + nfc_dev->nfc_disable_intr(nfc_dev); + return false; + } + pr_debug(" %s: nci core reset response 0x%02x 0x%02x 0x%02x 0x%02x \n", + __func__, rsp_buf[0], rsp_buf[1],rsp_buf[2], rsp_buf[3]); + if(rsp_buf[0] != NCI_MSG_RSP) { + /* reset response failed response*/ + pr_err("%s invalid nci core reset response"); + nfc_dev->nfc_disable_intr(nfc_dev); + return false; + } + memset(rsp_buf, 0x00, MAX_BUFFER_SIZE); + /* read nci rest response ntf */ + status = nfc_dev->nfc_read(nfc_dev, rsp_buf, MAX_BUFFER_SIZE, NCI_CMD_RSP_TIMEOUT); + if (status <= 0) { + pr_err("%s - nfc nci rest rsp ntf error status %d\n" + , __func__, status); + } + pr_debug(" %s:NFC NCI Reset Response ntf 0x%02x 0x%02x 0x%02x 0x%02x \n", + __func__, rsp_buf[0], rsp_buf[1],rsp_buf[2], rsp_buf[3]); + nfc_dev->nfc_disable_intr(nfc_dev); + gpio_set_ven(nfc_dev, 0); + gpio_set_ven(nfc_dev, 1); + return true; +} + +/* Check for availability of NFC controller hardware */ +int nfcc_hw_check(struct nfc_dev *nfc_dev) +{ + int ret = 0; + uint8_t nfc_state = NFC_STATE_UNKNOWN; + if(do_nci_reset(nfc_dev)) { + pr_info("%s recovery not required", __func__); + return ret; + } + nfc_dev->nfc_enable_intr(nfc_dev); + + /*set download mode for i2c products with dwl pin */ + enable_dwnld_mode(nfc_dev, true); + + nfc_state = get_nfcc_boot_state(nfc_dev); + switch (nfc_state) { + case NFC_STATE_FW_DWL: + usleep_range(NFC_GPIO_SET_WAIT_TIME_USEC, + NFC_GPIO_SET_WAIT_TIME_USEC + 100); + if (set_nfcc_nci_state(nfc_dev)) { + pr_debug("%s: - NFCC DL Reset Fails\n", __func__); + } else { + nfc_state = NFC_STATE_NCI; + /*set NCI mode for i2c products with dwl pin */ + enable_dwnld_mode(nfc_dev, false); + } + /* fall-through */ + case NFC_STATE_NCI: + nfc_dev->nfc_ven_enabled = true; + pr_debug("%s: - NFCC HW detected\n", __func__); + break; + case NFC_STATE_FW_TEARED: + pr_warn("%s: - NFCC FW Teared State\n", __func__); +#if defined(RECOVERY_ENABLE) + if(nfc_dev->recovery_required && + (do_recovery(nfc_dev) == STATUS_SUCCESS)) { + pr_debug("%s: - NFCC HW detected\n", __func__); + } +#endif + nfc_dev->nfc_ven_enabled = true; + break; + case NFC_STATE_UNKNOWN: + default: + ret = -ENXIO; + pr_debug("%s: - NFCC HW not available\n", __func__); + }; + + nfc_dev->nfc_disable_intr(nfc_dev); + if (nfc_state == NFC_STATE_FW_TEARED) { + nfc_state = NFC_STATE_FW_DWL; + } + nfc_dev->nfc_state = nfc_state; + return ret; +} + +void enable_dwnld_mode(nfc_dev_t* nfc_dev, bool value) { + if(nfc_dev != NULL) { + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; + if (get_valid_gpio(nfc_gpio->dwl_req) != -1) { + set_valid_gpio(nfc_gpio->dwl_req, value); + gpio_set_ven(nfc_dev, 0); + gpio_set_ven(nfc_dev, 1); + } + } +} + +void set_nfcc_state_from_rsp(struct nfc_dev *dev, const char *buf, + const int count) +{ + int packet_size = 0; + if (buf[0] == FW_MSG_CMD_RSP && buf[1] >= FW_MIN_PAYLOAD_LEN) { + packet_size = FW_HDR_LEN + buf[FW_PAYLOAD_LEN_IDX] + FW_CRC_LEN; + if (packet_size == count && dev->nfc_state == NFC_STATE_NCI) + dev->nfc_state = NFC_STATE_FW_DWL; + } else { + packet_size = NCI_HDR_LEN + buf[NCI_PAYLOAD_LEN_IDX]; + if (packet_size == count && dev->nfc_state == NFC_STATE_FW_DWL) + dev->nfc_state = NFC_STATE_NCI; + } + if (count != packet_size) { + pr_err("%s: Unlikely mismatch in packet size received (%d/%d)/\n", __func__, + packet_size, count); + } +} diff --git a/nfc/common.h b/nfc/common.h index 30bb468e1d..65dabf2858 100644 --- a/nfc/common.h +++ b/nfc/common.h @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2019-2020 NXP + * Copyright (C) 2019-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -41,11 +41,16 @@ #define NCI_HDR_LEN 3 #define NCI_PAYLOAD_IDX 3 #define NCI_PAYLOAD_LEN_IDX 2 +/*Time to wait for first NCI rest response*/ +#define NCI_RESET_RESP_READ_DELAY (10000) // 10ms +#define NCI_RESET_RESP_TIMEOUT (500) // 500ms // FW DNLD packet details +#define FW_MSG_CMD_RSP 0x00 #define FW_HDR_LEN 2 #define FW_PAYLOAD_LEN_IDX 1 #define FW_CRC_LEN 2 +#define FW_MIN_PAYLOAD_LEN 4 #define MIN_NFC_DL_FRAME_SIZE 3 #define NCI_RESET_CMD_LEN (4) @@ -72,9 +77,17 @@ #define MAX_IRQ_WAIT_TIME (90) #define WAKEUP_SRC_TIMEOUT (2000) +#define NCI_MAX_CMD_RSP_TIMEOUT (5000) //5s /*command response timeout*/ #define NCI_CMD_RSP_TIMEOUT (2000) //2s - +/*Time to wait for NFCC to be ready again after any change in the GPIO*/ +#define NFC_GPIO_SET_WAIT_TIME_USEC (10000) +/*Time to wait after soft reset via any NCI/DL cmd*/ +#define NFC_SOFT_RESET_WAIT_TIME_USEC (5000) +/*Time to wait before retrying i2c writes*/ +#define WRITE_RETRY_WAIT_TIME_USEC (1000) +/*Time to wait before retrying read for some specific usecases*/ +#define READ_RETRY_WAIT_TIME_USEC (3500) #define NFC_MAGIC 0xE9 /*Ioctls*/ @@ -85,7 +98,7 @@ #define NFC_GET_PLATFORM_TYPE _IO(NFC_MAGIC, 0x04) #define NFC_GET_NFC_STATE _IO(NFC_MAGIC, 0x05) /* NFC HAL can call this ioctl to get the current IRQ state */ -#define NFC_GET_IRQ_STATE _IOW(NFC_MAGIC, 0x06, long) +#define NFC_GET_IRQ_STATE _IO(NFC_MAGIC, 0x06) #define DTS_IRQ_GPIO_STR "nxp,pn544-irq" #define DTS_VEN_GPIO_STR "nxp,pn544-ven" @@ -151,6 +164,11 @@ typedef struct platform_gpio { unsigned int dwl_req; } platform_gpio_t; +// NFC Struct to get all the required configs from DTS*/ +typedef struct platform_configs { + platform_gpio_t gpio; +} platform_configs_t; + //cold reset Features specific Parameters typedef struct cold_reset { bool rsp_pending; /*cmd rsp pending status */ @@ -180,14 +198,20 @@ typedef struct nfc_dev { uint8_t nfc_state; /* NFC VEN pin state */ bool nfc_ven_enabled; +#if defined(RECOVERY_ENABLE) + /* current firmware major version */ + uint8_t fw_major_version; + /* NFC recovery Required */ + bool recovery_required; +#endif union { i2c_dev_t i2c_dev; }; - platform_gpio_t gpio; + platform_configs_t configs; cold_reset_t cold_reset; /*funtion pointers for the common i2c functionality */ - int (*nfc_read) (struct nfc_dev *dev, char *buf, size_t count); + int (*nfc_read) (struct nfc_dev *dev, char *buf, size_t count, int timeout); int (*nfc_write) (struct nfc_dev *dev, const char *buf, const size_t count, int max_retry_cnt); int (*nfc_enable_intr) (struct nfc_dev *dev); @@ -198,7 +222,7 @@ typedef struct nfc_dev { int nfc_dev_open(struct inode *inode, struct file *filp); int nfc_dev_close(struct inode *inode, struct file *filp); long nfc_dev_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg); -int nfc_parse_dt(struct device *dev, platform_gpio_t *nfc_gpio, +int nfc_parse_dt(struct device *dev, platform_configs_t *nfc_configs, uint8_t interface); int nfc_misc_register(nfc_dev_t *nfc_dev, const struct file_operations *nfc_fops, int count, char *devname, @@ -208,4 +232,8 @@ int configure_gpio(unsigned int gpio, int flag); void gpio_set_ven(nfc_dev_t *nfc_dev, int value); void gpio_free_all(nfc_dev_t *nfc_dev); int validate_nfc_state_nci(nfc_dev_t *nfc_dev); +int nfcc_hw_check(nfc_dev_t *nfc_dev); +void set_nfcc_state_from_rsp(nfc_dev_t *dev, const char *buf, + const int count); +void enable_dwnld_mode(nfc_dev_t* nfc_dev, bool value); #endif //_COMMON_H_ diff --git a/nfc/common_ese.c b/nfc/common_ese.c index 10ff475969..9c418036f3 100644 --- a/nfc/common_ese.c +++ b/nfc/common_ese.c @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2020 NXP + * Copyright (C) 2020-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -143,6 +143,7 @@ static int perform_cold_reset_protection(nfc_dev_t *nfc_dev, unsigned long arg) { int ret = 0; struct file filp; + uint8_t cld_rst_rsp[MAX_BUFFER_SIZE]; cold_reset_t *cold_reset = &nfc_dev->cold_reset; bool nfc_dev_opened = false; @@ -212,13 +213,12 @@ static int perform_cold_reset_protection(nfc_dev_t *nfc_dev, unsigned long arg) } else { /* Read data as NFC thread is not active */ filp.private_data = nfc_dev; -#if IS_ENABLED(CONFIG_NXP_NFC_I2C) - if (nfc_dev->interface == PLATFORM_IF_I2C) { - filp.f_flags &= ~O_NONBLOCK; - ret = nfc_i2c_dev_read(&filp, NULL, 3, 0); - usleep_range(3500, 4000); - } -#endif //IS_ENABLED(CONFIG_NXP_NFC_I2C) + filp.f_flags &= ~O_NONBLOCK; + ret = nfc_dev->nfc_read(nfc_dev, cld_rst_rsp, 3, NCI_CMD_RSP_TIMEOUT); + if (!ret) + break; + usleep_range(READ_RETRY_WAIT_TIME_USEC, + READ_RETRY_WAIT_TIME_USEC + 500); } } while (ret == -ERESTARTSYS || ret == -EFAULT); @@ -250,6 +250,7 @@ err: int nfc_ese_pwr(nfc_dev_t *nfc_dev, unsigned long arg) { int ret = 0; + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; if (arg == ESE_POWER_ON) { /** * Let's store the NFC VEN pin state @@ -258,7 +259,7 @@ int nfc_ese_pwr(nfc_dev_t *nfc_dev, unsigned long arg) * VEN state will remain HIGH if NFC is enabled otherwise * it will be set as LOW */ - nfc_dev->nfc_ven_enabled = gpio_get_value(nfc_dev->gpio.ven); + nfc_dev->nfc_ven_enabled = gpio_get_value(nfc_gpio->ven); if (!nfc_dev->nfc_ven_enabled) { pr_debug("eSE HAL service setting ven HIGH\n"); gpio_set_ven(nfc_dev, 1); @@ -274,7 +275,7 @@ int nfc_ese_pwr(nfc_dev_t *nfc_dev, unsigned long arg) } } else if (arg == ESE_POWER_STATE) { // eSE get power state - ret = gpio_get_value(nfc_dev->gpio.ven); + ret = gpio_get_value(nfc_gpio->ven); } else if (IS_CLD_RST_REQ(arg) || IS_RST_PROT_REQ(arg)) { ret = perform_cold_reset_protection(nfc_dev, arg); } else { diff --git a/nfc/common_ese.h b/nfc/common_ese.h index 61f6fe4e91..f4ebb5d57a 100644 --- a/nfc/common_ese.h +++ b/nfc/common_ese.h @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2020 NXP + * Copyright (C) 2020-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by diff --git a/nfc/i2c_drv.c b/nfc/i2c_drv.c index 5f69aaabbd..2a0954e1d0 100644 --- a/nfc/i2c_drv.c +++ b/nfc/i2c_drv.c @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2013-2020 NXP + * Copyright (C) 2013-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -43,6 +43,8 @@ #include #include "common.h" #include "common_ese.h" + +static ssize_t i2c_read_internal(struct nfc_dev *dev, char *buf, size_t count, int timeout); /** * i2c_disable_irq() * @@ -100,23 +102,14 @@ static irqreturn_t i2c_irq_handler(int irq, void *dev_id) return IRQ_HANDLED; } -int i2c_read(struct nfc_dev *dev, char *buf, size_t count) -{ - int ret; - pr_debug("%s : reading %zu bytes.\n", __func__, count); - /* Read data */ - ret = i2c_master_recv(dev->i2c_dev.client, buf, count); - if (ret <= 0) { - pr_err("%s: i2c_master_recv returned %d\n", __func__, ret); - goto err; - } - if (ret > count) { - pr_err("%s: received too many bytes from i2c (%d)\n", - __func__, ret); - ret = -EIO; - } -err: - return ret; +int i2c_read(struct nfc_dev *dev, char *buf, size_t count, int timeout){ + + pr_debug("%s : reading %zu bytes.\n", __func__, count); + + if(timeout > NCI_MAX_CMD_RSP_TIMEOUT) + timeout = NCI_MAX_CMD_RSP_TIMEOUT; + + return i2c_read_internal(dev, buf, count, timeout); } int i2c_write(struct nfc_dev *dev, const char *buf, size_t count, @@ -132,53 +125,58 @@ int i2c_write(struct nfc_dev *dev, const char *buf, size_t count, if (ret <= 0) { pr_warn("%s: write failed, Maybe in Standby Mode - Retry(%d)\n", __func__, retry_cnt); - usleep_range(1000, 1100); + usleep_range(WRITE_RETRY_WAIT_TIME_USEC, + WRITE_RETRY_WAIT_TIME_USEC + 100); } else if (ret == count) break; } return ret; } -ssize_t nfc_i2c_dev_read(struct file * filp, char __user *buf, - size_t count, loff_t * offset) +static ssize_t i2c_read_internal(struct nfc_dev *dev, char *buf, size_t count, int timeout) { int ret; char tmp[MAX_BUFFER_SIZE]; - nfc_dev_t *nfc_dev = filp->private_data; + nfc_dev_t *nfc_dev = dev; i2c_dev_t *i2c_dev = &nfc_dev->i2c_dev; + platform_gpio_t *nfc_gpio = &nfc_dev->configs.gpio; if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; pr_debug("%s : reading %zu bytes.\n", __func__, count); mutex_lock(&nfc_dev->read_mutex); - if (!gpio_get_value(nfc_dev->gpio.irq)) { - if (filp->f_flags & O_NONBLOCK) { - pr_err(":f_falg has O_NONBLOCK. EAGAIN\n"); - ret = -EAGAIN; - goto err; - } + if (!gpio_get_value(nfc_gpio->irq)) { + while (1) { ret = 0; if (!i2c_dev->irq_enabled) { i2c_dev->irq_enabled = true; enable_irq(i2c_dev->client->irq); } - if (!gpio_get_value(nfc_dev->gpio.irq)) { - ret = wait_event_interruptible(nfc_dev->read_wq, - !i2c_dev-> - irq_enabled); + if (!gpio_get_value(nfc_gpio->irq)) { + if(timeout) { + ret = wait_event_interruptible_timeout(nfc_dev->read_wq, + !i2c_dev-> irq_enabled, msecs_to_jiffies(timeout)); - if (ret) { - pr_err("error wakeup of read wq\n"); - goto err; + if (ret <= 0) { + pr_err("%s timeout/error in read\n", __func__); + goto err; + } + } else { + ret = wait_event_interruptible(nfc_dev->read_wq, + !i2c_dev->irq_enabled); + if (ret) { + pr_err("%s error wakeup of read wq\n", __func__); + goto err; + } } } i2c_disable_irq(nfc_dev); - if (gpio_get_value(nfc_dev->gpio.irq)) + if (gpio_get_value(nfc_gpio->irq)) break; - if (!gpio_get_value(nfc_dev->gpio.ven)) { + if (!gpio_get_value(nfc_gpio->ven)) { pr_info("%s: releasing read\n", __func__); ret = -EIO; goto err; @@ -189,7 +187,7 @@ ssize_t nfc_i2c_dev_read(struct file * filp, char __user *buf, memset(tmp, 0x00, count); /* Read data */ - ret = i2c_read(nfc_dev, tmp, count); + ret = i2c_master_recv(nfc_dev->i2c_dev.client, tmp, count); if (ret <= 0) { pr_err("%s: i2c_read returned %d\n", __func__, ret); goto err; @@ -201,8 +199,7 @@ ssize_t nfc_i2c_dev_read(struct file * filp, char __user *buf, if (nfc_dev->cold_reset.rsp_pending) { if (IS_PROP_CMD_RSP(tmp)) { /* Read data */ - ret = - i2c_read(nfc_dev, &tmp[NCI_PAYLOAD_IDX], + ret = i2c_master_recv(nfc_dev->i2c_dev.client, &tmp[NCI_PAYLOAD_IDX], tmp[NCI_PAYLOAD_LEN_IDX]); if (ret <= 0) { pr_err("%s: failure to read prop cold reset/protection rsp header\n", __func__); @@ -228,6 +225,17 @@ err: return ret; } +ssize_t nfc_i2c_dev_read(struct file * filp, char __user *buf, + size_t count, loff_t * offset) +{ + pr_debug("%s : reading %zu bytes.\n", __func__, count); + if (filp->f_flags & O_NONBLOCK) { + pr_err(":f_falg has O_NONBLOCK. EAGAIN\n"); + return -EAGAIN; + } + return i2c_read_internal((nfc_dev_t *)filp->private_data, buf, count, 0); +} + ssize_t nfc_i2c_dev_write(struct file * filp, const char __user *buf, size_t count, loff_t * offset) { @@ -266,10 +274,11 @@ int nfc_i2c_dev_probe(struct i2c_client *client, const struct i2c_device_id *id) int ret = 0; nfc_dev_t *nfc_dev = NULL; i2c_dev_t *i2c_dev = NULL; - platform_gpio_t nfc_gpio; + platform_configs_t nfc_configs; + platform_gpio_t *nfc_gpio = &nfc_configs.gpio; pr_debug("%s: enter\n", __func__); /*retrive details of gpios from dt */ - ret = nfc_parse_dt(&client->dev, &nfc_gpio, PLATFORM_IF_I2C); + ret = nfc_parse_dt(&client->dev, &nfc_configs, PLATFORM_IF_I2C); if (ret) { pr_err("%s : failed to parse dt\n", __func__); goto err; @@ -293,26 +302,30 @@ int nfc_i2c_dev_probe(struct i2c_client *client, const struct i2c_device_id *id) nfc_dev->nfc_write = i2c_write; nfc_dev->nfc_enable_intr = i2c_enable_irq; nfc_dev->nfc_disable_intr = i2c_disable_irq; +#if defined(RECOVERY_ENABLE) + nfc_dev->recovery_required = false; + nfc_dev->fw_major_version = 0; +#endif - ret = configure_gpio(nfc_gpio.ven, GPIO_OUTPUT); + ret = configure_gpio(nfc_gpio->ven, GPIO_OUTPUT); if (ret) { - pr_err("%s: unable to request nfc reset gpio [%d]\n", __func__, nfc_gpio.ven); + pr_err("%s: unable to request nfc reset gpio [%d]\n", __func__, nfc_gpio->ven); goto err; } - ret = configure_gpio(nfc_gpio.irq, GPIO_IRQ); + ret = configure_gpio(nfc_gpio->irq, GPIO_IRQ); if (ret <= 0) { - pr_err("%s: unable to request nfc irq gpio [%d]\n", __func__, nfc_gpio.irq); + pr_err("%s: unable to request nfc irq gpio [%d]\n", __func__, nfc_gpio->irq); goto err; } client->irq = ret; - ret = configure_gpio(nfc_gpio.dwl_req, GPIO_OUTPUT); + ret = configure_gpio(nfc_gpio->dwl_req, GPIO_OUTPUT); if (ret) { pr_err("%s: unable to request nfc firm downl gpio [%d]\n", __func__, - nfc_gpio.dwl_req); + nfc_gpio->dwl_req); } /*copy the retrived gpio details from DT */ - memcpy(&nfc_dev->gpio, &nfc_gpio, sizeof(struct platform_gpio)); + memcpy(&nfc_dev->configs, &nfc_configs, sizeof(struct platform_configs)); /* init mutex and queues */ init_waitqueue_head(&nfc_dev->read_wq); @@ -337,16 +350,17 @@ int nfc_i2c_dev_probe(struct i2c_client *client, const struct i2c_device_id *id) goto err_nfc_misc_unregister; } i2c_disable_irq(nfc_dev); + + ret = nfcc_hw_check(nfc_dev); + if (ret || nfc_dev->nfc_state == NFC_STATE_UNKNOWN) { + pr_err("nfc hw check failed ret %d\n", ret); + } + device_init_wakeup(&client->dev, true); device_set_wakeup_capable(&client->dev, true); i2c_set_clientdata(client, nfc_dev); i2c_dev->irq_wake_up = false; - //reset nfc - usleep_range(10000, 10100); - gpio_set_value(nfc_dev->gpio.ven, 1); - usleep_range(10000, 10100); - pr_info("%s probing nfc i2c successfully", __func__); return 0; err_nfc_misc_unregister: @@ -357,10 +371,12 @@ err_mutex_destroy: mutex_destroy(&nfc_dev->ese_access_mutex); mutex_destroy(&nfc_dev->cold_reset.sync_mutex); err: - gpio_free_all(nfc_dev); - kfree(nfc_dev); - pr_err("%s: probing not successful, check hardware\n", __func__); - return ret; + if (nfc_dev) { + gpio_free_all(nfc_dev); + kfree(nfc_dev); + } + pr_err("%s: probing not successful, check hardware\n", __func__); + return ret; } int nfc_i2c_dev_remove(struct i2c_client *client) diff --git a/nfc/i2c_drv.h b/nfc/i2c_drv.h index 8b41d41dd2..745c211d72 100644 --- a/nfc/i2c_drv.h +++ b/nfc/i2c_drv.h @@ -1,5 +1,5 @@ /****************************************************************************** - * Copyright (C) 2019-2020 NXP + * Copyright (C) 2019-2021 NXP * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -40,6 +40,5 @@ int nfc_i2c_dev_probe(struct i2c_client *client, int nfc_i2c_dev_remove(struct i2c_client *client); int nfc_i2c_dev_suspend(struct device *device); int nfc_i2c_dev_resume(struct device *device); -ssize_t nfc_i2c_dev_read(struct file *filp, char __user *buf, size_t count, - loff_t * offset); + #endif //_I2C_DRV_H_ diff --git a/nfc/recovery_fw.c b/nfc/recovery_fw.c new file mode 100644 index 0000000000..c210337bd4 --- /dev/null +++ b/nfc/recovery_fw.c @@ -0,0 +1,1325 @@ +/******************************************************************************************** + * + * Copyright 2021 NXP + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"),to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE + * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + ********************************************************************************************/ +#include +const uint8_t gphDnldNfc_DlSequence[] = { + 0x01, 0x34, 0xC0, 0x00, 0xDE, 0x10, 0xAD, 0x69, 0xE0, 0x28, + 0xAC, 0xFA, 0xF2, 0x4A, 0x0F, 0x49, 0x7E, 0x6A, 0x61, 0xD1, + 0x00, 0xFD, 0x4A, 0x66, 0xDD, 0x42, 0x4D, 0xFF, 0x90, 0xA5, + 0x6C, 0x54, 0xF0, 0x53, 0x5E, 0x17, 0x1E, 0x28, 0x8B, 0xF2, + 0x56, 0x6D, 0x74, 0x7B, 0x4E, 0xBA, 0xEB, 0x8D, 0x22, 0x43, + 0x01, 0xE9, 0xC4, 0x85, 0x2B, 0xFB, 0xA7, 0xD9, 0x3C, 0x64, + 0x63, 0x2D, 0xBB, 0x63, 0x5C, 0xDB, 0x14, 0x4D, 0x86, 0xA0, + 0x73, 0xC1, 0x32, 0xA4, 0x12, 0xD0, 0xED, 0x12, 0x90, 0xCF, + 0xAF, 0x56, 0x35, 0x3D, 0x97, 0x6B, 0xAC, 0x81, 0x1B, 0xD6, + 0x77, 0x9A, 0x4F, 0x9C, 0x90, 0x7D, 0x16, 0x6E, 0xC4, 0xCD, + 0x2D, 0xD2, 0x57, 0x49, 0x99, 0x24, 0xBC, 0x06, 0x71, 0x04, + 0xA8, 0x14, 0xEF, 0x21, 0x55, 0x0D, 0xAD, 0x82, 0x88, 0x5C, + 0xEF, 0xDF, 0x03, 0x93, 0xB5, 0xE8, 0x21, 0x18, 0xE0, 0x54, + 0xB8, 0xE1, 0x7E, 0x88, 0xE9, 0xF7, 0xEE, 0x86, 0xD2, 0x36, + 0xD7, 0x4B, 0x99, 0x6C, 0x35, 0x8B, 0xE0, 0xA2, 0xA2, 0xFB, + 0xED, 0xB5, 0x9A, 0xA0, 0xEE, 0x19, 0x67, 0x66, 0x14, 0x14, + 0xEC, 0xEF, 0x3F, 0xC0, 0x25, 0x7C, 0xA8, 0x9F, 0x58, 0x11, + 0xCD, 0x99, 0x00, 0xBF, 0xB8, 0x6D, 0xD5, 0x06, 0x8A, 0x5D, + 0x40, 0xB0, 0x2C, 0x9A, 0x20, 0xA2, 0x30, 0xDA, 0xFD, 0xB0, + 0xE3, 0x05, 0x5F, 0xB7, 0x3B, 0x9C, 0xD6, 0xB8, 0x92, 0xAE, + 0x4B, 0xDC, 0xF2, 0x1D, 0xA4, 0x11, 0xCE, 0x0C, 0xFD, 0x37, + 0x6E, 0xBA, 0x8B, 0x6C, 0x84, 0x3E, 0x3A, 0x3D, 0x20, 0xBE, + 0x64, 0xA6, 0x56, 0x7F, 0x06, 0x66, 0x04, 0x38, 0x1D, 0x97, + 0xD9, 0x96, 0xE6, 0x07, 0x29, 0xE2, 0x1A, 0xC4, 0x5F, 0x0A, + 0xAC, 0x62, 0x50, 0xF8, 0xD2, 0x33, 0x3F, 0x7A, 0x50, 0x89, + 0x98, 0x44, 0xCB, 0xFD, 0x75, 0x79, 0x25, 0xB1, 0x3A, 0xDE, + 0x53, 0x86, 0x13, 0x54, 0x46, 0x0B, 0x5F, 0x94, 0xEC, 0x1B, + 0x72, 0x24, 0x35, 0x84, 0x67, 0xC8, 0xBE, 0xDB, 0xAC, 0xB2, + 0x0C, 0x94, 0x88, 0xE1, 0xC4, 0x36, 0xD1, 0x6B, 0xB9, 0x4C, + 0xAE, 0xB0, 0x55, 0xF8, 0xBE, 0xD4, 0x7D, 0x16, 0x76, 0x84, + 0x2E, 0x46, 0x0B, 0xF6, 0x0D, 0x43, 0xB6, 0xBB, 0x5F, 0x98, + 0x02, 0x26, 0xC0, 0x00, 0x02, 0x35, 0x79, 0x26, 0x91, 0x8C, + 0x34, 0x8D, 0x69, 0x6E, 0x7F, 0x6B, 0xBF, 0xBD, 0x81, 0x3F, + 0x9C, 0x94, 0x0C, 0x65, 0x47, 0xC5, 0x08, 0xA7, 0x14, 0x6F, + 0x5A, 0xAC, 0x7C, 0xAC, 0x0C, 0x15, 0xD5, 0x6F, 0xBF, 0xDC, + 0xCE, 0x97, 0xD0, 0xD5, 0xEB, 0x1D, 0x3C, 0x7A, 0xEB, 0x2A, + 0x4E, 0x76, 0x08, 0xF2, 0xEA, 0x3A, 0xA0, 0xB8, 0xFC, 0xA0, + 0x74, 0x92, 0x8F, 0x86, 0xB1, 0x15, 0x0D, 0x7D, 0x92, 0x0F, + 0x64, 0xCE, 0xCA, 0xC1, 0xC4, 0x20, 0xA2, 0x48, 0x2D, 0xB0, + 0x47, 0x24, 0xF1, 0x20, 0x77, 0xDF, 0x87, 0x0D, 0xFA, 0xC6, + 0x89, 0xEE, 0xBD, 0x5E, 0xD5, 0x85, 0x64, 0xBC, 0x40, 0x6E, + 0x86, 0x01, 0x3D, 0xB6, 0x83, 0x8C, 0xAA, 0xF3, 0x2D, 0x3A, + 0xBB, 0x0D, 0xE6, 0xA5, 0xC0, 0x64, 0x07, 0xCB, 0x57, 0x81, + 0x7E, 0xD8, 0x3C, 0x3D, 0x4A, 0x9F, 0x8E, 0xF0, 0x57, 0x2E, + 0x5E, 0x41, 0x42, 0x00, 0xB0, 0xC7, 0x4E, 0x17, 0xED, 0xC6, + 0xAB, 0x73, 0x71, 0x65, 0x1D, 0x60, 0x34, 0x2A, 0x2B, 0xAF, + 0x59, 0x82, 0x5E, 0x16, 0x48, 0x48, 0x0F, 0x86, 0x62, 0x0C, + 0x84, 0x56, 0x00, 0x03, 0x2A, 0xA6, 0x2C, 0x21, 0xD0, 0x70, + 0xF9, 0xE5, 0x37, 0x0E, 0x81, 0x20, 0x36, 0x4E, 0x86, 0x8D, + 0xCF, 0xED, 0xBD, 0x0D, 0x49, 0x75, 0x0E, 0x5B, 0x80, 0xF7, + 0xAF, 0x40, 0x56, 0x8B, 0xD8, 0xFC, 0xC6, 0xE4, 0x6D, 0xD6, + 0x2E, 0x0D, 0xD0, 0x76, 0x75, 0x39, 0x3E, 0xF0, 0xEA, 0xC5, + 0x23, 0x12, 0x06, 0x45, 0xEA, 0x04, 0x6D, 0xC1, 0xA2, 0x95, + 0x95, 0x40, 0xD6, 0x6B, 0x65, 0xD6, 0x7D, 0x62, 0xA5, 0xB4, + 0x6B, 0x6C, 0x24, 0x3E, 0xFB, 0xAB, 0x71, 0x4D, 0xFC, 0x24, + 0x9F, 0x71, 0x8C, 0x04, 0x9A, 0xEE, 0x6D, 0x72, 0x3A, 0x01, + 0x11, 0xC1, 0x01, 0xB2, 0xC2, 0xC8, 0xBA, 0x7D, 0x53, 0x56, + 0x0D, 0x3F, 0x35, 0xF6, 0x86, 0x46, 0x7C, 0x67, 0xBF, 0x83, + 0x04, 0x01, 0x98, 0xBC, 0x06, 0x08, 0xF3, 0x89, 0x88, 0x8E, + 0x93, 0xB3, 0xA9, 0x21, 0x18, 0x71, 0xFF, 0xFC, 0x4E, 0xF7, + 0xFE, 0x1A, 0x5D, 0xC9, 0x21, 0xF6, 0x3B, 0x27, 0x2C, 0x26, + 0x37, 0xE2, 0x4F, 0x8C, 0x94, 0x77, 0xC7, 0x0D, 0xB9, 0x74, + 0xCD, 0x9F, 0xE1, 0x70, 0xFD, 0x35, 0x11, 0xA2, 0xB6, 0xAC, + 0x39, 0x3D, 0xC9, 0x57, 0x94, 0x3F, 0x10, 0x89, 0x9F, 0x0F, + 0x7D, 0x49, 0x0E, 0xFE, 0x84, 0x34, 0x87, 0x5B, 0xA5, 0xA0, + 0x5E, 0x0D, 0xE4, 0x05, 0x5A, 0x45, 0x8B, 0x31, 0x28, 0xF0, + 0x80, 0x7A, 0xF9, 0x56, 0xE7, 0x60, 0xB0, 0x31, 0xBB, 0x75, + 0x7E, 0x30, 0x74, 0x53, 0x14, 0xF6, 0xDE, 0x24, 0x9E, 0xE0, + 0xB9, 0x9F, 0xE6, 0xB0, 0x5D, 0x5B, 0x7A, 0xF3, 0xFD, 0x0D, + 0x4C, 0xCA, 0xAD, 0x01, 0xE4, 0x3F, 0xFE, 0x1D, 0x03, 0xE7, + 0xD4, 0xC6, 0xC1, 0xE9, 0xF5, 0x9E, 0x72, 0x9C, 0x4A, 0x09, + 0x85, 0x2C, 0xBE, 0x46, 0x49, 0xE1, 0x0F, 0xBF, 0x27, 0xF2, + 0x81, 0xC3, 0x33, 0x95, 0xEC, 0xBE, 0x37, 0x2B, 0x65, 0xA5, + 0xEC, 0xF7, 0x69, 0x23, 0x3B, 0xA6, 0xA6, 0xC3, 0xC7, 0x9F, + 0x9B, 0x79, 0xE6, 0x37, 0xB4, 0xDB, 0x33, 0x3B, 0xC5, 0x19, + 0x50, 0x7B, 0xBB, 0x7B, 0x4B, 0xFF, 0x0A, 0x3A, 0x0F, 0xDE, + 0x9D, 0x1F, 0x70, 0xE0, 0x9C, 0x37, 0x9B, 0x61, 0x01, 0xD9, + 0xCB, 0x9F, 0xC7, 0x1F, 0x9B, 0x25, 0x7D, 0x18, 0xF0, 0x6F, + 0x12, 0x54, 0xC2, 0x17, 0x8F, 0xB2, 0x1F, 0x5D, 0x0F, 0x73, + 0xB2, 0xEE, 0xE9, 0x0E, 0xC4, 0xA1, 0x70, 0x48, 0xDF, 0x0B, + 0xB4, 0xDD, 0xFF, 0xC7, 0x01, 0xA6, 0xBC, 0x08, 0xCE, 0x0E, + 0xB4, 0x4A, 0xAE, 0xFF, 0x88, 0xA6, 0x4D, 0x60, 0xC7, 0x55, + 0x38, 0x74, 0x3C, 0x1D, 0x8F, 0x82, 0xD3, 0xD3, 0x31, 0x60, + 0xE4, 0xB2, 0x24, 0x76, 0xE7, 0xD8, 0x53, 0x05, 0x20, 0x3E, + 0x5C, 0xEF, 0x17, 0x4C, 0x20, 0x6F, 0x6A, 0x6D, 0x10, 0xA3, + 0xA4, 0xE9, 0xFB, 0x76, 0x66, 0x99, 0x5D, 0xD1, 0x34, 0x52, + 0x42, 0xBF, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x9E, 0xED, 0xAE, + 0xE5, 0x23, 0x85, 0x5C, 0xFF, 0xAD, 0x6E, 0x89, 0x02, 0x33, + 0x97, 0x74, 0x05, 0x59, 0x1E, 0x73, 0x4E, 0xD3, 0x9A, 0x97, + 0xD3, 0x85, 0x2B, 0x12, 0xFB, 0xA2, 0xF0, 0xA4, 0x4C, 0x2A, + 0x58, 0xFB, 0x56, 0x6C, 0xE9, 0xA6, 0x04, 0x07, 0x9F, 0xBC, + 0x76, 0x66, 0x01, 0x80, 0xB8, 0x1E, 0x4A, 0x8A, 0x0C, 0x76, + 0x8A, 0x3C, 0x5F, 0x25, 0xAD, 0x83, 0xF3, 0x10, 0x02, 0xE1, + 0x38, 0x4B, 0xFA, 0x81, 0xD2, 0xC5, 0x6D, 0x18, 0xA7, 0xD8, + 0x0A, 0x4E, 0xC9, 0xC7, 0xA3, 0x19, 0x52, 0x0D, 0xBB, 0xA9, + 0xDE, 0x9C, 0x90, 0x57, 0x71, 0x1A, 0x37, 0xA8, 0x70, 0x4D, + 0x75, 0x7E, 0x34, 0x90, 0x74, 0x0E, 0x02, 0xC8, 0x8A, 0x80, + 0x3D, 0x06, 0x67, 0xF4, 0xF2, 0xD4, 0x15, 0x66, 0x0D, 0x23, + 0xAE, 0x46, 0x0A, 0x23, 0x7B, 0x36, 0x96, 0x48, 0x7D, 0x99, + 0xF4, 0x09, 0xE3, 0xA9, 0x53, 0xAC, 0x94, 0xB7, 0x23, 0x7E, + 0x57, 0xCF, 0x90, 0xCD, 0x13, 0x0D, 0x50, 0xBD, 0xC9, 0xE4, + 0xC2, 0x22, 0x5F, 0x28, 0x11, 0xF8, 0x1F, 0x42, 0x33, 0xEE, + 0xF3, 0xB4, 0xED, 0x8F, 0xF4, 0xA0, 0xAE, 0xF5, 0xAE, 0x56, + 0x59, 0xC3, 0x65, 0xDB, 0xF2, 0x51, 0x6D, 0x15, 0xA3, 0xAF, + 0xA5, 0xC7, 0x9F, 0x7A, 0xE8, 0xCC, 0xB4, 0xD8, 0xCA, 0x39, + 0x3F, 0x79, 0xB3, 0x86, 0xDB, 0x37, 0x52, 0xDA, 0x5E, 0xDB, + 0x7F, 0x53, 0x60, 0x43, 0x75, 0x53, 0x93, 0xD4, 0xA2, 0xE2, + 0xE7, 0xB7, 0x42, 0xF0, 0x97, 0xA5, 0xB5, 0x52, 0xD3, 0xCF, + 0xE7, 0x70, 0x6F, 0x10, 0xD4, 0x85, 0xC4, 0x4B, 0x3D, 0x09, + 0xE1, 0x02, 0xB8, 0xED, 0xA5, 0xCC, 0x7B, 0x2D, 0x68, 0xEF, + 0xEF, 0x9E, 0x87, 0x8C, 0xB7, 0xC9, 0x85, 0xA8, 0x01, 0xC2, + 0xCF, 0x43, 0xB5, 0x6D, 0x30, 0x2A, 0x9F, 0x06, 0x96, 0xE0, + 0x43, 0xEC, 0x3F, 0xC1, 0x2F, 0x7D, 0x4D, 0x85, 0x76, 0xD3, + 0xF7, 0xFA, 0xC8, 0x84, 0x20, 0xA8, 0x3C, 0xD9, 0x3E, 0x4A, + 0xB4, 0x87, 0x05, 0xCF, 0x9B, 0x51, 0x68, 0xF9, 0x49, 0xBA, + 0x4D, 0x68, 0x97, 0x6E, 0x79, 0xDB, 0x04, 0x51, 0x66, 0x6F, + 0xF9, 0x59, 0x2D, 0x55, 0x96, 0x13, 0x59, 0x52, 0x30, 0xB8, + 0x73, 0xD1, 0x12, 0x33, 0x31, 0xEC, 0x4C, 0x0C, 0x8E, 0xD4, + 0x47, 0xE7, 0x30, 0xC6, 0x98, 0xB5, 0x5B, 0x35, 0x1B, 0xAC, + 0x51, 0xBB, 0xFA, 0xC3, 0x8D, 0x3E, 0x89, 0x83, 0x1C, 0xED, + 0xB1, 0x03, 0x9C, 0xC7, 0x5C, 0x89, 0xF9, 0xC2, 0xE3, 0x45, + 0x91, 0xDB, 0x41, 0x0A, 0x22, 0xD1, 0x90, 0x39, 0xD6, 0x9D, + 0x0A, 0xD8, 0x36, 0xDC, 0xDB, 0xDD, 0x63, 0x22, 0xF8, 0x7B, + 0x4D, 0x90, 0x4C, 0x27, 0x0F, 0xCC, 0x16, 0x0E, 0x32, 0x46, + 0xD7, 0x20, 0x5A, 0x43, 0xC4, 0xC5, 0x37, 0x2E, 0xEB, 0x3F, + 0x42, 0x2C, 0xFA, 0x99, 0xE2, 0xF9, 0x70, 0xB3, 0xC3, 0xCF, + 0x4C, 0x67, 0xEB, 0x7C, 0x9D, 0xAF, 0x96, 0x15, 0x97, 0xD2, + 0x07, 0x3B, 0xF6, 0xEF, 0x2F, 0x98, 0xAA, 0x1D, 0x45, 0xDC, + 0x11, 0xBA, 0xF6, 0x0C, 0x18, 0x64, 0x80, 0xF2, 0x6B, 0xBD, + 0x3C, 0x85, 0xC1, 0xCD, 0x78, 0xD0, 0x62, 0x79, 0x0F, 0xCD, + 0xCA, 0x3D, 0x94, 0x0A, 0x11, 0xEF, 0x11, 0x86, 0xFA, 0x3F, + 0x31, 0xB2, 0xF1, 0x2C, 0x74, 0x1B, 0x57, 0x05, 0xD4, 0x4F, + 0xAF, 0xE7, 0xCB, 0x60, 0x9E, 0x78, 0x82, 0xAD, 0xF3, 0x34, + 0x6A, 0x2F, 0xDC, 0xA1, 0xC9, 0xEA, 0x3E, 0x6E, 0x01, 0x80, + 0x17, 0x5B, 0xCC, 0xBB, 0xED, 0xD0, 0x30, 0x11, 0xBE, 0xEE, + 0x2E, 0x9F, 0xCE, 0xE1, 0xFF, 0x32, 0xB8, 0x7D, 0x40, 0xC8, + 0x46, 0x0F, 0x41, 0x16, 0xE1, 0xB3, 0x98, 0x47, 0xCE, 0xE1, + 0x41, 0xDE, 0x80, 0xA7, 0x56, 0x83, 0xA8, 0xDA, 0xC3, 0x49, + 0x33, 0x6F, 0x93, 0x68, 0xA0, 0xC6, 0x1A, 0x0B, 0x82, 0x38, + 0x56, 0xEE, 0xBB, 0x97, 0x5D, 0xBD, 0x8A, 0x32, 0x2D, 0xFE, + 0x40, 0xC7, 0x0D, 0xCA, 0x32, 0x08, 0xCC, 0xE2, 0x18, 0x57, + 0xBB, 0xC1, 0x60, 0x43, 0x02, 0x26, 0xC0, 0x00, 0x02, 0xAD, + 0x9E, 0x61, 0x0D, 0x67, 0x25, 0xE4, 0x6E, 0x8F, 0x6D, 0xEA, + 0x16, 0x98, 0xFA, 0x76, 0x6D, 0x6D, 0x3C, 0xED, 0x4B, 0x25, + 0x60, 0xC6, 0xAB, 0x59, 0x91, 0x43, 0xAA, 0xAA, 0xEC, 0x8F, + 0xA1, 0x3E, 0xB1, 0x78, 0x72, 0xEE, 0xD1, 0x91, 0xBA, 0xD9, + 0x9B, 0xE3, 0x55, 0x61, 0x98, 0x46, 0x4B, 0xC5, 0x41, 0x3B, + 0x9C, 0x88, 0x1D, 0x82, 0xD5, 0xD5, 0x99, 0x13, 0x64, 0x44, + 0x00, 0xBD, 0xBE, 0xC4, 0xF6, 0x6A, 0x2D, 0xE3, 0xD0, 0xE7, + 0x88, 0xD3, 0xA1, 0x48, 0x88, 0x84, 0x8A, 0x25, 0xAB, 0x90, + 0x43, 0xFB, 0x3D, 0x1B, 0x06, 0xB2, 0xFD, 0x24, 0x58, 0x0C, + 0xFA, 0x0A, 0xD3, 0x23, 0x73, 0xA7, 0xF8, 0x50, 0xC5, 0x1B, + 0x3A, 0x75, 0xF4, 0x24, 0xA8, 0x52, 0xFB, 0x1B, 0x61, 0xAB, + 0x79, 0x06, 0x54, 0xD9, 0x1D, 0x3A, 0x72, 0x4F, 0x8F, 0xD3, + 0xC7, 0x71, 0xA8, 0x66, 0x80, 0x49, 0x8D, 0x50, 0xD1, 0xBF, + 0xC8, 0x70, 0xAE, 0x4F, 0x64, 0x53, 0x26, 0x37, 0xDA, 0x6B, + 0x62, 0xFE, 0xF9, 0x60, 0xAD, 0xAD, 0x49, 0x51, 0x37, 0x2E, + 0x61, 0xA9, 0xAA, 0x72, 0xFD, 0x02, 0x20, 0x0B, 0xB0, 0xB0, + 0x07, 0x95, 0x0C, 0x38, 0x13, 0xB6, 0xA4, 0x33, 0xFA, 0xFA, + 0x12, 0xE1, 0x62, 0x00, 0x92, 0x46, 0x23, 0xAA, 0xD7, 0x9D, + 0xBD, 0xAF, 0x15, 0xCA, 0x8C, 0x88, 0x2A, 0x4B, 0x1B, 0xA8, + 0x06, 0xA0, 0xC2, 0x80, 0x8E, 0x98, 0x46, 0xA1, 0x84, 0x2C, + 0x4A, 0x0F, 0xEA, 0x70, 0xE6, 0xDD, 0x17, 0x30, 0x8A, 0x41, + 0x69, 0x8A, 0x1B, 0xC2, 0xC7, 0x18, 0xD5, 0xB3, 0x94, 0x4F, + 0x51, 0x15, 0xCC, 0x37, 0x9A, 0x9E, 0xFD, 0x12, 0x40, 0xC1, + 0xA3, 0x06, 0x0F, 0x36, 0xFC, 0x04, 0x18, 0x35, 0x40, 0x9C, + 0x9E, 0x46, 0x5E, 0x14, 0xB6, 0xF7, 0xBF, 0xE5, 0x21, 0x12, + 0xF2, 0xE2, 0x17, 0xB3, 0x63, 0x8C, 0xD1, 0xE3, 0xA9, 0x0A, + 0x80, 0x1B, 0x74, 0x7A, 0x58, 0x91, 0x88, 0x9D, 0xAE, 0xE6, + 0x05, 0x1D, 0x3C, 0x1E, 0xE9, 0x95, 0x08, 0x75, 0xEE, 0x20, + 0xA8, 0x4B, 0x3D, 0x36, 0xAF, 0xB0, 0xFA, 0x94, 0x62, 0x5D, + 0x9F, 0xD5, 0x50, 0x2A, 0x24, 0xFC, 0x1D, 0xDC, 0x39, 0xCB, + 0x0D, 0x5A, 0xA1, 0xDA, 0xEF, 0xC9, 0xB3, 0x62, 0xF8, 0x7D, + 0x0C, 0xE4, 0x6B, 0xEC, 0xF0, 0xF7, 0x96, 0x63, 0x58, 0x80, + 0x55, 0x22, 0x6D, 0x42, 0x38, 0xE9, 0x1D, 0x69, 0xD5, 0x2F, + 0x03, 0x3C, 0xCD, 0x27, 0x34, 0x99, 0x39, 0xF0, 0x5C, 0xE0, + 0x23, 0x70, 0x85, 0x4B, 0x30, 0xBD, 0x21, 0x01, 0xF6, 0x06, + 0x0B, 0xED, 0xBA, 0xA1, 0x6F, 0xE0, 0x6E, 0xD3, 0x78, 0xA8, + 0x56, 0x94, 0x92, 0x84, 0xA8, 0x60, 0x35, 0xA8, 0x86, 0x56, + 0x41, 0xEA, 0x12, 0x34, 0x86, 0x52, 0x18, 0x75, 0x43, 0x01, + 0x0A, 0xCE, 0xBA, 0x04, 0xF7, 0x32, 0x09, 0x2D, 0xB1, 0xAC, + 0x04, 0xB0, 0x4E, 0xEA, 0xBE, 0xDE, 0xDE, 0x95, 0x37, 0xDA, + 0x86, 0x72, 0xFE, 0x10, 0x16, 0xBB, 0xA7, 0xE9, 0x67, 0xC9, + 0x3C, 0x85, 0x18, 0xFF, 0xD7, 0x74, 0x25, 0x3A, 0x95, 0x04, + 0xD5, 0x7F, 0x99, 0x41, 0x6A, 0x6A, 0x2C, 0xF6, 0x3E, 0x3C, + 0x4B, 0xA7, 0xB9, 0xDA, 0x13, 0xFC, 0xF6, 0x46, 0xEF, 0x7E, + 0xB4, 0xA6, 0x1B, 0x36, 0x93, 0x5B, 0xDA, 0xDB, 0x6A, 0xC7, + 0x37, 0x58, 0x3C, 0x4F, 0x52, 0x7E, 0x39, 0xD7, 0xE2, 0xBA, + 0x79, 0xA7, 0x9A, 0x05, 0x8A, 0xF5, 0x65, 0x86, 0xF4, 0x52, + 0xBC, 0x79, 0x6D, 0xA9, 0xFE, 0xEE, 0xE6, 0xC5, 0x2B, 0x28, + 0x62, 0x8E, 0xF6, 0x6E, 0xD5, 0x08, 0x90, 0x96, 0x72, 0x7A, + 0x6B, 0x61, 0x8B, 0x6A, 0xE6, 0xCD, 0x05, 0x63, 0x12, 0x9A, + 0xF7, 0x01, 0xAC, 0xF7, 0x8F, 0x1F, 0xE0, 0xCA, 0x1E, 0xF9, + 0x86, 0xC1, 0xF6, 0x0D, 0x2D, 0x9F, 0x8A, 0x2C, 0x8B, 0x3C, + 0xE4, 0x89, 0xDF, 0x72, 0x86, 0x17, 0xA8, 0x7F, 0x9D, 0x8B, + 0x0D, 0x87, 0xCB, 0xC5, 0xAE, 0xE3, 0x90, 0xB1, 0xD9, 0x8B, + 0x5E, 0x04, 0x97, 0xAA, 0x19, 0x85, 0x02, 0x26, 0xC0, 0x00, + 0x02, 0x26, 0xDA, 0x00, 0x7E, 0x08, 0xC0, 0x08, 0x12, 0x9A, + 0x78, 0x4E, 0x9D, 0xA7, 0xB0, 0x5E, 0x0D, 0x76, 0x6D, 0x4D, + 0xC7, 0x89, 0x35, 0xDD, 0xB5, 0x58, 0x9F, 0x20, 0x3C, 0x41, + 0x77, 0x9B, 0x85, 0x06, 0x21, 0xA4, 0x99, 0x56, 0xF9, 0x5B, + 0x07, 0x01, 0x06, 0x1A, 0xE1, 0x1B, 0xC7, 0x9F, 0x46, 0x5D, + 0x1F, 0xB8, 0xB2, 0x91, 0xA5, 0xC2, 0x01, 0x94, 0xFA, 0x53, + 0x74, 0xFA, 0x6A, 0x5B, 0x63, 0x08, 0x2E, 0x24, 0xB0, 0xCF, + 0x03, 0x40, 0x9C, 0xA1, 0xF2, 0xDB, 0xA2, 0x35, 0xD7, 0xCA, + 0x78, 0x4E, 0x9D, 0x8B, 0x92, 0x4A, 0xD1, 0xEA, 0xF8, 0x14, + 0xCA, 0xA0, 0x32, 0x55, 0x95, 0xA0, 0x1F, 0xB7, 0x1D, 0x8B, + 0x8E, 0x8E, 0xA6, 0xF0, 0x2A, 0x30, 0x76, 0xB4, 0x9B, 0x6F, + 0xAB, 0xBC, 0xC7, 0xA8, 0xF6, 0x2B, 0x9D, 0x1D, 0xC2, 0x24, + 0x06, 0x10, 0x06, 0xE7, 0x59, 0x34, 0xE9, 0x30, 0xA8, 0xF5, + 0x61, 0x55, 0xEC, 0xFB, 0xA1, 0x43, 0x17, 0x10, 0x08, 0xFF, + 0x3C, 0x93, 0x03, 0xFF, 0x83, 0x35, 0x81, 0x77, 0x7E, 0x97, + 0xC2, 0xA0, 0x53, 0x2A, 0x26, 0xD4, 0xDF, 0xC0, 0xA3, 0x21, + 0x07, 0x14, 0x41, 0xD3, 0x7C, 0xE5, 0x40, 0x00, 0xDE, 0x32, + 0xF5, 0xB9, 0xBB, 0x61, 0x44, 0xBC, 0xA4, 0xFD, 0x67, 0xAA, + 0x69, 0xF4, 0x96, 0x93, 0xD2, 0xAF, 0xEA, 0xC5, 0x72, 0xDB, + 0xEA, 0x88, 0x2A, 0x5F, 0xC5, 0xAB, 0x00, 0xFA, 0xA9, 0x32, + 0x61, 0x58, 0xBE, 0xC0, 0x42, 0xA9, 0xFA, 0xB6, 0x44, 0xD6, + 0x59, 0xF8, 0x26, 0x8B, 0xB9, 0x0A, 0xD9, 0xE2, 0x5B, 0x1B, + 0x20, 0xD1, 0x34, 0x91, 0x81, 0xF3, 0xFF, 0xED, 0x6D, 0x81, + 0xF9, 0x7D, 0xE3, 0x73, 0x37, 0xC1, 0x01, 0x12, 0x28, 0x9B, + 0xEA, 0xDA, 0x0E, 0x3D, 0x68, 0x16, 0x23, 0xE1, 0x68, 0xFF, + 0x1A, 0x59, 0xCC, 0x89, 0xF8, 0x44, 0x70, 0x13, 0xB2, 0x98, + 0xB1, 0x31, 0xEA, 0xEC, 0x65, 0x21, 0x36, 0xEF, 0xCC, 0x85, + 0x62, 0xC3, 0xEC, 0x62, 0xE9, 0x06, 0xEC, 0xB3, 0x47, 0x94, + 0xE5, 0xF2, 0x6F, 0xFD, 0x80, 0xEE, 0x70, 0xB0, 0x06, 0x56, + 0x8B, 0xF2, 0xDC, 0x7A, 0x52, 0x90, 0xC2, 0xE4, 0x77, 0xDD, + 0xF7, 0xC2, 0x0C, 0x9C, 0xBE, 0x5A, 0x0F, 0xC6, 0x45, 0xB1, + 0x3A, 0x63, 0x38, 0x2C, 0xD9, 0xC4, 0x45, 0x08, 0x44, 0x90, + 0xE2, 0xBC, 0xA2, 0x5A, 0xE6, 0x2E, 0xFD, 0xCB, 0x36, 0x7F, + 0xA9, 0xAC, 0x8C, 0x34, 0x1A, 0x3C, 0xE2, 0x9B, 0x24, 0x45, + 0xE3, 0x9C, 0xCF, 0xF9, 0x96, 0xFE, 0x58, 0xB5, 0x29, 0x20, + 0x0B, 0xC9, 0x5C, 0xAF, 0xCF, 0x7F, 0xCB, 0x8A, 0x14, 0xE1, + 0xCD, 0xF7, 0x5B, 0x93, 0xBC, 0x7D, 0x7A, 0x3B, 0xD2, 0xF2, + 0xFA, 0x2B, 0x57, 0x02, 0x9C, 0xAC, 0xA2, 0x16, 0x11, 0x2D, + 0xDB, 0x3D, 0x42, 0x26, 0x87, 0xBE, 0x9F, 0x8B, 0x7B, 0x00, + 0x20, 0x09, 0x41, 0x05, 0xB0, 0x42, 0x98, 0x44, 0xD6, 0xCC, + 0x08, 0xA2, 0x20, 0x1F, 0x2A, 0x59, 0xB3, 0x05, 0x4F, 0xB4, + 0xA6, 0xF8, 0xF8, 0xFD, 0x27, 0xBB, 0xC5, 0xC3, 0x52, 0x4D, + 0x63, 0x37, 0xCF, 0xAE, 0x4C, 0x60, 0x1E, 0x98, 0x26, 0x12, + 0x3D, 0xB9, 0xE6, 0x87, 0x09, 0x17, 0xB1, 0xE4, 0x81, 0x2C, + 0x8E, 0x73, 0xA1, 0x40, 0x53, 0x96, 0xD8, 0x17, 0x7F, 0x39, + 0xA8, 0x4F, 0xE9, 0xEF, 0x30, 0xE2, 0x5E, 0xEF, 0x9C, 0x13, + 0x70, 0x21, 0x14, 0xA3, 0x5D, 0xEA, 0x43, 0xFB, 0xA6, 0x80, + 0x70, 0xB9, 0x4B, 0x68, 0x9C, 0x5A, 0x82, 0x59, 0x00, 0xFA, + 0x5E, 0x4C, 0x4F, 0x76, 0xB1, 0xF4, 0x45, 0xCD, 0xE6, 0x18, + 0x09, 0xE2, 0x36, 0x8A, 0x60, 0x4B, 0xF4, 0x61, 0x55, 0xC4, + 0xE9, 0x69, 0xC1, 0x03, 0x9E, 0x9C, 0xAF, 0x1C, 0xE5, 0xD1, + 0xFF, 0x45, 0x16, 0x43, 0xD7, 0xE5, 0x4B, 0xCC, 0xEA, 0x24, + 0x2E, 0xCE, 0xE3, 0x90, 0x17, 0xDB, 0xC4, 0x57, 0x4D, 0xF9, + 0xCB, 0xEC, 0x09, 0x62, 0xBD, 0xD8, 0x7A, 0x89, 0x55, 0x92, + 0x90, 0x7B, 0x22, 0x20, 0xD9, 0x9A, 0xC9, 0x19, 0x02, 0x26, + 0xC0, 0x00, 0x02, 0x2E, 0xA2, 0xCF, 0xDE, 0xE3, 0xDE, 0xA9, + 0x10, 0x3D, 0xEB, 0xD9, 0x4B, 0x51, 0x68, 0x41, 0x57, 0xCD, + 0x7C, 0xF4, 0x28, 0x84, 0x22, 0x1C, 0xA7, 0xA6, 0x8A, 0xDD, + 0x97, 0x5B, 0x8A, 0x07, 0x01, 0x97, 0x13, 0x20, 0x06, 0x12, + 0xC9, 0xBB, 0x6D, 0x12, 0x25, 0x6D, 0x08, 0x13, 0x3C, 0x32, + 0x48, 0xFE, 0x49, 0xD9, 0xC1, 0x3E, 0x00, 0x1C, 0xD9, 0xF0, + 0xE2, 0xB3, 0xE0, 0x07, 0xE1, 0x8F, 0xDF, 0x75, 0xE0, 0xB9, + 0x61, 0x1A, 0xBF, 0xAF, 0x66, 0xE0, 0xAB, 0x8A, 0x4B, 0x71, + 0xCB, 0x4F, 0xB7, 0x4C, 0x30, 0xC8, 0xB0, 0xC4, 0xC0, 0x38, + 0x73, 0xDD, 0x3C, 0xDC, 0x5D, 0x81, 0x40, 0x14, 0x23, 0x9C, + 0xD2, 0x48, 0xF9, 0xCB, 0xC4, 0x1B, 0xD5, 0xC7, 0x85, 0xB0, + 0x57, 0xC1, 0xF5, 0x41, 0x7A, 0x2E, 0xC6, 0x03, 0x86, 0x8C, + 0x4E, 0xAF, 0x24, 0x21, 0xB9, 0x0B, 0xE9, 0x24, 0x12, 0x02, + 0x3E, 0x35, 0x7C, 0x1D, 0x9A, 0x2D, 0x5E, 0xB7, 0xEE, 0x08, + 0x34, 0x2C, 0x2B, 0xAD, 0x8D, 0x02, 0xF6, 0xFE, 0x06, 0x88, + 0xD0, 0xA5, 0xA2, 0x1E, 0x5B, 0xD2, 0x88, 0x09, 0x9F, 0x43, + 0xDF, 0xC4, 0x85, 0x59, 0x50, 0x7B, 0x94, 0xD9, 0xBB, 0xBE, + 0xF5, 0x1D, 0x60, 0xD0, 0x90, 0x6F, 0xD5, 0x1E, 0x49, 0xF1, + 0x76, 0x04, 0x96, 0xCA, 0x3F, 0x44, 0x64, 0xBE, 0x41, 0xE7, + 0x4A, 0x6E, 0xA8, 0x11, 0x14, 0x21, 0xEA, 0x9E, 0x43, 0x6D, + 0x2E, 0xF6, 0x49, 0x7A, 0x8C, 0xD6, 0xF1, 0x4A, 0xC3, 0x17, + 0x16, 0x23, 0x3B, 0x02, 0x6A, 0xA7, 0x90, 0x1D, 0x8C, 0xBF, + 0xB4, 0x25, 0xDA, 0xB6, 0x0F, 0x2A, 0x60, 0xF5, 0xC1, 0x7F, + 0xFA, 0x1D, 0x0B, 0xAF, 0x28, 0x8A, 0x00, 0x8A, 0xBE, 0xA8, + 0x72, 0x20, 0x5F, 0xEC, 0x3F, 0x16, 0x6E, 0xAB, 0xC4, 0xFC, + 0x6B, 0x75, 0xD7, 0xFB, 0x73, 0x60, 0x7E, 0x25, 0xE5, 0xA3, + 0x91, 0x6A, 0x33, 0xD3, 0x9E, 0xAC, 0xFB, 0x8C, 0xD1, 0xC6, + 0x63, 0xF4, 0x3F, 0xB7, 0xD1, 0xD3, 0x88, 0x90, 0x4C, 0xA2, + 0x7E, 0x6B, 0x19, 0x61, 0xCC, 0xAB, 0x48, 0xDD, 0x8D, 0xE2, + 0x1B, 0xB7, 0x9E, 0x2F, 0x58, 0x10, 0x78, 0xAC, 0x94, 0xF6, + 0xD6, 0x62, 0x4D, 0x66, 0x78, 0x67, 0x9F, 0x1B, 0x3A, 0x78, + 0x4E, 0xA0, 0xDB, 0x47, 0x92, 0xC4, 0x43, 0x1A, 0x22, 0xFC, + 0x26, 0x38, 0xA4, 0xF2, 0x7A, 0x52, 0x31, 0x71, 0x63, 0x16, + 0x58, 0xF5, 0xA4, 0x4A, 0xCA, 0x73, 0xD5, 0x90, 0x39, 0x55, + 0x8F, 0xB2, 0xC0, 0x3F, 0x3A, 0xEC, 0x69, 0xC4, 0x42, 0xCE, + 0xB9, 0x1B, 0xA4, 0x32, 0x52, 0x14, 0x7C, 0xBB, 0xF6, 0xB3, + 0x5A, 0x7C, 0xF1, 0x75, 0x1E, 0x4B, 0xB8, 0xB0, 0xB3, 0x8E, + 0x13, 0x63, 0x7B, 0xF5, 0xB9, 0x93, 0x22, 0x98, 0xDF, 0x6C, + 0xEC, 0x51, 0x4F, 0xC8, 0x0B, 0xA0, 0x14, 0x57, 0x75, 0x1B, + 0xF6, 0xE9, 0x5D, 0xC2, 0x47, 0x65, 0xDF, 0x79, 0x0D, 0x48, + 0xBE, 0x4F, 0x46, 0xF0, 0x37, 0xA5, 0x7C, 0xA3, 0x6B, 0x3E, + 0xE6, 0xA2, 0x0E, 0x69, 0xAF, 0x3C, 0x46, 0x8A, 0x77, 0xD2, + 0xBF, 0x2A, 0x16, 0x00, 0x17, 0x2F, 0x9C, 0x4E, 0xD8, 0xA8, + 0x48, 0xD4, 0xCC, 0x0C, 0x29, 0xD1, 0x7A, 0xAE, 0x81, 0x4F, + 0x04, 0x76, 0x53, 0xCF, 0x22, 0x76, 0x39, 0x61, 0xB6, 0x76, + 0x42, 0xE6, 0x4E, 0x71, 0xB3, 0x06, 0xB9, 0x31, 0x04, 0x60, + 0x88, 0x04, 0x02, 0x89, 0x72, 0x13, 0xD8, 0x8E, 0xD7, 0xE7, + 0x88, 0xCC, 0x3B, 0x88, 0x4A, 0xC7, 0x96, 0x58, 0x12, 0xDA, + 0x75, 0x15, 0xE2, 0x9A, 0xFA, 0x9E, 0x7C, 0x0E, 0xD6, 0x86, + 0x64, 0x7F, 0x31, 0xE3, 0x5C, 0xD8, 0xCF, 0xC0, 0x6D, 0x9B, + 0x1A, 0x1D, 0x8E, 0x90, 0xED, 0x8E, 0x7B, 0xFD, 0xAF, 0xE0, + 0x85, 0xE2, 0x51, 0x49, 0xAE, 0xE6, 0x03, 0x78, 0x41, 0xB9, + 0x05, 0xA0, 0xB8, 0x25, 0x03, 0x51, 0xD1, 0x93, 0x05, 0xE1, + 0xAA, 0x19, 0x0F, 0x1A, 0xF0, 0xD6, 0x18, 0xB6, 0x23, 0xFD, + 0xBC, 0x6E, 0x10, 0xA5, 0x18, 0xE9, 0x3B, 0xE5, 0xA4, 0x22, + 0x02, 0x26, 0xC0, 0x00, 0x02, 0x55, 0x43, 0x38, 0x66, 0x6B, + 0x96, 0x00, 0x6F, 0x33, 0xEE, 0x72, 0x7A, 0x9E, 0xD2, 0x5C, + 0x1F, 0x87, 0x4C, 0xFC, 0xE9, 0x3C, 0xAB, 0xC7, 0x5E, 0x55, + 0xD6, 0xEF, 0x78, 0xB1, 0x4D, 0xA7, 0x92, 0x3F, 0x57, 0x3B, + 0xF5, 0x7F, 0xE0, 0xD6, 0xE0, 0xD0, 0x8D, 0xE5, 0xE1, 0xAE, + 0x48, 0xC1, 0xF7, 0xF3, 0xC3, 0xA4, 0xF7, 0x8F, 0xE7, 0x6F, + 0xB2, 0xB1, 0xA5, 0x6F, 0x6A, 0xCF, 0x5F, 0x3C, 0xF2, 0x50, + 0x31, 0x19, 0x89, 0xF1, 0x74, 0x55, 0xA2, 0xFF, 0x7A, 0x5D, + 0xCB, 0x96, 0xED, 0xE4, 0xEA, 0x28, 0x4B, 0xF7, 0xE4, 0x45, + 0x7D, 0x99, 0xAF, 0xC5, 0xDB, 0xC1, 0x2D, 0xE8, 0xE9, 0xEA, + 0x2B, 0xAD, 0x7E, 0x8E, 0x96, 0x25, 0xA0, 0x9E, 0xDA, 0x31, + 0xE4, 0xCD, 0xC6, 0x8D, 0x69, 0x39, 0x04, 0x53, 0x1B, 0xCA, + 0xEF, 0x96, 0x8E, 0xEF, 0xFB, 0x4E, 0xC8, 0x11, 0x8E, 0x42, + 0x03, 0xC2, 0x96, 0x1A, 0x2C, 0xD8, 0xCF, 0x17, 0x05, 0x36, + 0xF7, 0x02, 0xAB, 0xBD, 0x1A, 0xF3, 0x51, 0xC0, 0xE2, 0x1E, + 0x0D, 0x8D, 0xE9, 0x81, 0x57, 0xD1, 0xA1, 0x9A, 0x2C, 0x7D, + 0x43, 0xBD, 0x23, 0x50, 0xA9, 0x3D, 0x77, 0xC1, 0x5F, 0x2D, + 0x3A, 0x61, 0x56, 0xE1, 0x47, 0xB4, 0x6C, 0xB1, 0xDF, 0xD7, + 0x1E, 0x95, 0x00, 0x02, 0x5B, 0xDA, 0xBD, 0x39, 0x2A, 0x06, + 0x98, 0x2B, 0x54, 0x63, 0xC9, 0xDB, 0x30, 0xF2, 0xB6, 0xB6, + 0xC8, 0x22, 0xAB, 0xB5, 0x68, 0xA3, 0xB7, 0x94, 0x6C, 0x97, + 0x5B, 0xC0, 0x6F, 0xA5, 0x11, 0xFD, 0x9A, 0x52, 0x5A, 0xB5, + 0x3D, 0xEA, 0xC3, 0x23, 0xD1, 0xA7, 0x31, 0xA1, 0xCE, 0xA8, + 0x4A, 0x7C, 0x5D, 0xF6, 0x21, 0xC1, 0x38, 0x73, 0xA3, 0x83, + 0x00, 0x28, 0x9D, 0x76, 0x5A, 0xC5, 0x63, 0xDB, 0x47, 0x25, + 0xAB, 0xD7, 0x25, 0xAE, 0x7D, 0x87, 0xF1, 0xA1, 0xE6, 0x9C, + 0x83, 0x33, 0x30, 0xE1, 0xAD, 0x65, 0xFD, 0x0F, 0xBB, 0xD0, + 0xEF, 0xF5, 0xC3, 0x19, 0x9B, 0x9D, 0x13, 0xBA, 0xEF, 0x9F, + 0x13, 0x2F, 0x76, 0x55, 0x2C, 0x2A, 0xC3, 0x8B, 0x40, 0x79, + 0x49, 0x02, 0x88, 0xE7, 0x4B, 0x57, 0xF5, 0xC5, 0x56, 0x30, + 0xF2, 0xB8, 0x2D, 0x83, 0x6F, 0xB6, 0xBF, 0xE2, 0x7E, 0xFF, + 0x18, 0x61, 0x11, 0x6B, 0x77, 0xCC, 0x04, 0x8B, 0xE4, 0x7C, + 0xF9, 0x48, 0x9C, 0xE0, 0x10, 0x7F, 0x68, 0xFE, 0x40, 0xF0, + 0x23, 0x5C, 0x13, 0x56, 0xD7, 0xCC, 0xDA, 0x83, 0xD6, 0x5C, + 0xB2, 0xED, 0x3F, 0x4C, 0x1E, 0x0A, 0x2F, 0x9D, 0xA2, 0x08, + 0x95, 0xB1, 0x80, 0xFB, 0x04, 0xAC, 0xED, 0x88, 0x01, 0xDC, + 0x69, 0xC7, 0x2D, 0xE8, 0xEB, 0xD1, 0xCE, 0x8E, 0x32, 0x04, + 0x0B, 0xA5, 0x1E, 0xFA, 0x47, 0xA2, 0x8F, 0xB6, 0xF4, 0xC8, + 0xFE, 0x81, 0xFC, 0x68, 0xFF, 0x82, 0x9A, 0x9A, 0xB6, 0x2C, + 0x58, 0x55, 0xEE, 0xFC, 0xBB, 0x23, 0x47, 0xA4, 0xEB, 0xF8, + 0x08, 0xB1, 0xF0, 0xAA, 0xE3, 0x7A, 0xDC, 0xEF, 0xD6, 0xB4, + 0x60, 0x39, 0x6F, 0x0F, 0x8A, 0x4C, 0x65, 0x48, 0x65, 0x78, + 0x6D, 0xF8, 0x44, 0x13, 0xA2, 0x9A, 0x76, 0xE8, 0xA7, 0x06, + 0x33, 0x54, 0x74, 0x73, 0xE4, 0x69, 0x66, 0x27, 0xA0, 0x66, + 0xA0, 0x5A, 0x9E, 0x26, 0xF2, 0xA4, 0x3C, 0xA6, 0xCF, 0x86, + 0x0F, 0x9D, 0x0A, 0x75, 0xC1, 0x9C, 0x34, 0xD1, 0x40, 0x21, + 0x64, 0x62, 0x7B, 0xBF, 0xAE, 0xCD, 0x44, 0x17, 0x6D, 0x5F, + 0x21, 0x02, 0x17, 0x1A, 0x2C, 0xA4, 0x18, 0x1D, 0x4F, 0x2E, + 0xC8, 0xE2, 0xCF, 0xAE, 0x25, 0x4A, 0xC4, 0xA2, 0x5A, 0x2E, + 0x10, 0x09, 0x69, 0xB2, 0xEA, 0xF9, 0xB9, 0x4C, 0x36, 0xA4, + 0xD6, 0xCB, 0x03, 0x6E, 0x7B, 0xC1, 0xA4, 0x28, 0x1A, 0x09, + 0xBF, 0xF1, 0xA1, 0x3F, 0x75, 0xB8, 0x5A, 0xF3, 0x9F, 0x12, + 0x35, 0x4B, 0x16, 0x21, 0x3B, 0x8D, 0xF9, 0x87, 0xCB, 0x8A, + 0xEC, 0x29, 0x1B, 0xF0, 0xB3, 0x96, 0x77, 0xB7, 0x7B, 0xA8, + 0x6A, 0x98, 0xE4, 0x8B, 0x61, 0xB6, 0x47, 0xD7, 0x92, 0xB4, + 0x0B, 0x47, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x4B, 0x86, 0xD9, + 0x89, 0x5B, 0x11, 0x29, 0x1D, 0x8E, 0x56, 0xC4, 0x4A, 0x0D, + 0xD4, 0x9F, 0x43, 0x9F, 0xA2, 0x55, 0x58, 0xE1, 0xF6, 0xF6, + 0x58, 0xFB, 0xCD, 0x3F, 0x06, 0x4C, 0xC2, 0x60, 0x6D, 0xB7, + 0xB2, 0xFF, 0xFE, 0x89, 0x77, 0x7A, 0x1E, 0xA0, 0xC8, 0xDD, + 0x7F, 0x3E, 0x6B, 0x38, 0x2F, 0x41, 0x2B, 0xDF, 0x42, 0x14, + 0x50, 0x28, 0xEE, 0xDE, 0x3F, 0xD8, 0xFF, 0x09, 0x43, 0x7A, + 0x22, 0x4F, 0xF3, 0xFC, 0x60, 0x7E, 0x2C, 0x1A, 0xB6, 0x9E, + 0x21, 0x40, 0x76, 0x3B, 0x42, 0xFC, 0xBC, 0x1D, 0x00, 0xA4, + 0x55, 0x95, 0x47, 0xBD, 0x6E, 0x31, 0xAB, 0x05, 0xAD, 0x38, + 0x53, 0xB0, 0x24, 0x83, 0x7D, 0x0E, 0xA8, 0x40, 0xE6, 0x33, + 0x6D, 0xEF, 0x72, 0x35, 0xCF, 0x3C, 0x11, 0x67, 0x1D, 0x28, + 0xEF, 0x7B, 0x7A, 0x7A, 0x0E, 0xD2, 0x7F, 0xBA, 0xEB, 0xA0, + 0x49, 0x46, 0x29, 0x40, 0x5B, 0x62, 0xA9, 0xED, 0xC9, 0xAC, + 0xDD, 0xAF, 0xE9, 0xAF, 0xF9, 0x75, 0x70, 0xC7, 0xAD, 0xB2, + 0xB6, 0x51, 0x08, 0x23, 0x89, 0x1F, 0xCC, 0xDE, 0xB7, 0x6B, + 0x25, 0xC4, 0x77, 0x90, 0x01, 0xBA, 0x80, 0x62, 0x3E, 0xFF, + 0x93, 0x00, 0x15, 0x43, 0x7D, 0xBE, 0x80, 0x83, 0xBB, 0xB0, + 0xAA, 0x3B, 0xF2, 0x0A, 0x9D, 0x86, 0x23, 0xA4, 0xB7, 0xB7, + 0x44, 0x30, 0xA7, 0x17, 0x66, 0x70, 0xEE, 0x2D, 0x1F, 0xDF, + 0xBD, 0xD9, 0x14, 0x3E, 0x55, 0xC6, 0xC9, 0x5B, 0xC3, 0xF2, + 0xE5, 0x10, 0xD5, 0x1A, 0x93, 0xF6, 0x76, 0xAB, 0x71, 0x87, + 0xDE, 0xD5, 0x51, 0x99, 0x37, 0x6F, 0xEE, 0xB1, 0x63, 0xDA, + 0x7F, 0x3B, 0xAC, 0x77, 0x1B, 0x4B, 0xA3, 0xE3, 0x77, 0x41, + 0xEA, 0x23, 0xF3, 0xB9, 0x22, 0x75, 0x07, 0x8E, 0x64, 0x3E, + 0x32, 0xA9, 0x28, 0xAA, 0x93, 0x8F, 0xE8, 0xDA, 0x60, 0xE9, + 0xD7, 0x35, 0x7F, 0xD7, 0x8F, 0xC8, 0xE5, 0x5B, 0x61, 0x47, + 0xD6, 0xD4, 0xA7, 0xFF, 0x25, 0x8F, 0x03, 0xC3, 0x03, 0x07, + 0xED, 0x30, 0x45, 0x86, 0x73, 0x1E, 0x8F, 0x2F, 0x3D, 0xB4, + 0xC0, 0x37, 0x7A, 0xE7, 0x80, 0xEA, 0xA0, 0xDB, 0x98, 0xAE, + 0xF9, 0x24, 0x0C, 0x74, 0x36, 0x54, 0x13, 0x34, 0x30, 0xCF, + 0x0E, 0xC8, 0x9D, 0x94, 0xE7, 0xAF, 0x6A, 0xC0, 0x32, 0x32, + 0xA3, 0xDE, 0x3A, 0x5B, 0x72, 0x72, 0xE3, 0x8F, 0x91, 0xC5, + 0x44, 0xAB, 0x86, 0x7B, 0xE0, 0x6C, 0x80, 0x84, 0x64, 0x1D, + 0xC0, 0xF1, 0x28, 0x7C, 0x6A, 0x35, 0x76, 0xCF, 0x12, 0x56, + 0x84, 0x1C, 0x21, 0x51, 0x33, 0x00, 0xFF, 0xB2, 0x64, 0x30, + 0x44, 0x1C, 0xA5, 0x05, 0x09, 0xE2, 0x14, 0x8E, 0xF3, 0xD8, + 0x91, 0x21, 0x60, 0xC0, 0x51, 0x68, 0x62, 0xF5, 0x7E, 0x06, + 0xD5, 0xC0, 0xEE, 0xB8, 0x91, 0xF1, 0x52, 0x14, 0x6C, 0x27, + 0xB6, 0x6A, 0x1C, 0x64, 0xBF, 0x59, 0x47, 0x64, 0x03, 0x8D, + 0x4E, 0xEB, 0xA3, 0x73, 0x10, 0xE2, 0xBC, 0xA0, 0x30, 0x29, + 0xE6, 0xF5, 0xED, 0x04, 0xCA, 0xAA, 0xC2, 0xBA, 0xDB, 0x8E, + 0xBC, 0x00, 0x34, 0x3D, 0xB6, 0x12, 0xCB, 0xAF, 0xC0, 0x3D, + 0x97, 0xF7, 0x5A, 0x1B, 0x83, 0x90, 0x91, 0xD0, 0xE2, 0xCF, + 0xE6, 0x21, 0x07, 0xCF, 0x2E, 0xFD, 0x71, 0xA1, 0x10, 0x18, + 0x67, 0x3F, 0x8F, 0xE2, 0x86, 0xFA, 0xA6, 0xDF, 0x6D, 0xE4, + 0x31, 0x7D, 0x75, 0x12, 0x99, 0x23, 0xC7, 0xFB, 0xF2, 0x04, + 0x76, 0x4C, 0x93, 0x9B, 0xB9, 0x89, 0x1D, 0x88, 0x5A, 0x0E, + 0xDE, 0x5A, 0x27, 0x35, 0x88, 0xE7, 0x80, 0x14, 0x87, 0xCA, + 0x23, 0xE6, 0xEF, 0xA8, 0xEA, 0x73, 0x7D, 0x93, 0x0C, 0x61, + 0x81, 0x2E, 0x10, 0xDF, 0x13, 0x57, 0x96, 0xD9, 0x36, 0x68, + 0x93, 0x42, 0x7A, 0x67, 0x60, 0x44, 0x57, 0xD8, 0x6C, 0x4B, + 0xD4, 0xCC, 0x7E, 0x70, 0xE2, 0xCD, 0xC7, 0x14, 0x4A, 0xDE, + 0x32, 0x35, 0x8B, 0x4B, 0x14, 0xE0, 0x8D, 0x5C, 0x33, 0x72, + 0xC9, 0x5D, 0x1F, 0xF6, 0xD7, 0xC3, 0xCF, 0x72, 0xA1, 0x2C, + 0x98, 0x2C, 0x0E, 0xEA, 0x02, 0x26, 0xC0, 0x00, 0x02, 0xEC, + 0xFC, 0x5D, 0x99, 0x61, 0x74, 0x77, 0x64, 0xF2, 0x70, 0x18, + 0x1A, 0x0B, 0x9F, 0x5A, 0x64, 0xE4, 0xCE, 0xA9, 0xCE, 0xCF, + 0x15, 0x35, 0x0E, 0x90, 0x95, 0xD1, 0x78, 0xBC, 0x36, 0xDD, + 0x32, 0xB0, 0x72, 0xCF, 0xCE, 0xFE, 0x8D, 0xAA, 0xF4, 0x19, + 0x73, 0x80, 0x37, 0xB6, 0x7B, 0x88, 0xB5, 0x7F, 0x5B, 0x7E, + 0xC7, 0x1F, 0x40, 0x5E, 0xCF, 0xC5, 0xE3, 0x75, 0x43, 0xCA, + 0x9D, 0x7C, 0xA1, 0x5D, 0x12, 0xBE, 0x30, 0x0E, 0x2C, 0x6D, + 0xE1, 0xD4, 0xD9, 0xC0, 0x90, 0x9F, 0x13, 0x6C, 0x00, 0x75, + 0xC9, 0x98, 0xE8, 0x4A, 0x1E, 0x43, 0x27, 0xB2, 0x3D, 0x16, + 0x5D, 0xF7, 0x18, 0xF6, 0xF2, 0x57, 0xA8, 0x54, 0x57, 0x50, + 0xFD, 0x98, 0x0F, 0x99, 0x63, 0x9E, 0x94, 0x71, 0x8B, 0x6B, + 0x6A, 0xAC, 0x27, 0x7A, 0xE5, 0xFE, 0x49, 0x5F, 0xA9, 0x3F, + 0x72, 0x32, 0xE5, 0x67, 0x87, 0xE9, 0xCC, 0xBC, 0x64, 0xE9, + 0x6B, 0x15, 0x06, 0x60, 0x32, 0x43, 0x49, 0x53, 0x47, 0xB2, + 0x56, 0xCE, 0xBF, 0x5F, 0x9B, 0x16, 0x40, 0x7D, 0x90, 0x0E, + 0xFB, 0xFE, 0x66, 0x58, 0xB3, 0xFC, 0x42, 0xB5, 0x90, 0xE6, + 0xCA, 0x6C, 0xD0, 0x3C, 0xA0, 0x2D, 0x84, 0x5E, 0xA0, 0xE7, + 0xD7, 0x8B, 0xB0, 0x42, 0x56, 0x3D, 0x48, 0xAF, 0x18, 0xEF, + 0xAF, 0x27, 0x76, 0xE3, 0x26, 0x0B, 0xCA, 0xA0, 0x01, 0x4B, + 0x79, 0xD1, 0xAC, 0xD5, 0x8B, 0xCD, 0x70, 0x9F, 0x6E, 0xFB, + 0x72, 0xBB, 0x9B, 0xDA, 0x4A, 0xFA, 0x96, 0x45, 0x29, 0x59, + 0x16, 0x4B, 0x57, 0xC1, 0x7B, 0x5D, 0x94, 0x5E, 0xDA, 0xC1, + 0x2B, 0x3C, 0xD9, 0xD5, 0x6B, 0x23, 0xE7, 0x53, 0x9C, 0xAA, + 0x89, 0x07, 0xFC, 0x66, 0xBC, 0xBC, 0xDD, 0x5D, 0xC7, 0xC0, + 0x46, 0xAF, 0xF6, 0xCB, 0xBB, 0xD3, 0x37, 0xC1, 0x7F, 0xCD, + 0xAE, 0x69, 0x1F, 0xCA, 0x20, 0x07, 0x76, 0x3F, 0xD0, 0x71, + 0x4F, 0x19, 0x6A, 0x92, 0xA2, 0xD8, 0x81, 0xE7, 0x84, 0xC3, + 0x24, 0x55, 0xF3, 0x1F, 0xA6, 0x8B, 0xAF, 0x11, 0xA6, 0xAC, + 0x9B, 0x2D, 0x12, 0xD0, 0x0D, 0xBC, 0x20, 0x26, 0x01, 0x76, + 0x39, 0xBF, 0xAB, 0x52, 0xD6, 0x93, 0x76, 0x29, 0x4C, 0xD8, + 0x8F, 0xBA, 0xA9, 0xA1, 0xCE, 0x09, 0xCC, 0xB7, 0xC5, 0x34, + 0xCC, 0xC1, 0x27, 0xE9, 0x47, 0xFB, 0x02, 0xC0, 0x0B, 0xB7, + 0xE2, 0x1B, 0x9A, 0x05, 0x32, 0x99, 0x7E, 0xEF, 0xDA, 0xC3, + 0xE2, 0xB3, 0x0D, 0x2F, 0xD7, 0x32, 0x14, 0xAA, 0x90, 0x00, + 0x5B, 0x8F, 0xA9, 0x6D, 0xBD, 0x54, 0xAF, 0xE2, 0x47, 0x8C, + 0x20, 0xD4, 0x14, 0x34, 0x13, 0x08, 0x17, 0x1B, 0xA2, 0x3B, + 0xDC, 0x6D, 0x5A, 0x08, 0x04, 0x58, 0x38, 0xAC, 0x84, 0xBB, + 0x22, 0x64, 0x6B, 0xE6, 0xB9, 0x46, 0x4A, 0xB6, 0x39, 0xD2, + 0xF4, 0x6D, 0x13, 0x63, 0x7F, 0x79, 0x6F, 0x54, 0x38, 0x72, + 0x1A, 0x3D, 0x45, 0x28, 0x14, 0x8F, 0x9D, 0xFE, 0x51, 0x02, + 0x3F, 0x0C, 0xFD, 0xE4, 0x7A, 0xC4, 0xFC, 0x00, 0xF0, 0xF6, + 0x7E, 0x98, 0x36, 0x40, 0x35, 0x92, 0x3A, 0x42, 0xBE, 0xA6, + 0xAE, 0x3C, 0x55, 0xF5, 0x4E, 0x41, 0xF4, 0x22, 0x63, 0x80, + 0x2E, 0xC9, 0x65, 0x73, 0x43, 0x2F, 0xE7, 0xF9, 0xC5, 0x5C, + 0x21, 0xDD, 0xF5, 0x15, 0x38, 0xE4, 0xDD, 0x92, 0x08, 0x9D, + 0x75, 0x65, 0x13, 0x28, 0xA5, 0xF9, 0x45, 0x13, 0xE0, 0x8F, + 0xB2, 0x36, 0x91, 0xAA, 0xBE, 0x87, 0xD2, 0x78, 0x3F, 0xB0, + 0xEE, 0x0C, 0x4C, 0x8C, 0xD7, 0x56, 0x85, 0x21, 0x43, 0x40, + 0xC4, 0x26, 0x90, 0xC2, 0x63, 0xF0, 0xC3, 0x49, 0xA0, 0xF0, + 0x2A, 0xCA, 0xA3, 0x9A, 0x39, 0xA6, 0xAA, 0x98, 0x2B, 0x8E, + 0xBA, 0x0B, 0xD9, 0x21, 0xC4, 0xC9, 0x97, 0x1B, 0x57, 0x80, + 0x49, 0x3E, 0xC4, 0x4B, 0xD8, 0x5E, 0xE2, 0x43, 0xC2, 0x13, + 0x8D, 0x51, 0x28, 0x8B, 0x30, 0x7C, 0x17, 0xB0, 0x58, 0x15, + 0x5F, 0x56, 0xF8, 0xF3, 0x8F, 0x9A, 0xC0, 0x9B, 0x27, 0x90, + 0x23, 0x48, 0xED, 0x5E, 0x50, 0xE2, 0x02, 0x26, 0xC0, 0x00, + 0x02, 0x02, 0xCA, 0xFA, 0x0D, 0x3A, 0xC4, 0xBF, 0x20, 0x04, + 0xD3, 0xA1, 0x4F, 0xED, 0x80, 0x40, 0x81, 0x15, 0x67, 0x0D, + 0x65, 0x3E, 0x52, 0x9C, 0x30, 0x20, 0xD2, 0xD8, 0xAC, 0xAF, + 0x06, 0xE5, 0xDA, 0x8B, 0x8B, 0x3A, 0xCA, 0xDC, 0x59, 0x8F, + 0x2F, 0x93, 0x53, 0x5B, 0xAC, 0xCE, 0x1F, 0xDF, 0x3B, 0x50, + 0xBF, 0x70, 0xF1, 0x7A, 0xCC, 0xA2, 0x25, 0x88, 0xD1, 0xA0, + 0xBC, 0x9D, 0x41, 0x1F, 0x9C, 0x0A, 0x95, 0x27, 0xE2, 0x71, + 0x4C, 0x1C, 0x14, 0xDB, 0xEA, 0xCD, 0xA3, 0x7C, 0x39, 0x57, + 0x69, 0x95, 0xA5, 0x04, 0x4F, 0xA3, 0xC0, 0x24, 0xC1, 0x5B, + 0x39, 0xF4, 0x9F, 0xBC, 0xB2, 0xC3, 0x37, 0x28, 0x1F, 0xFA, + 0xB9, 0xD7, 0xFF, 0x7A, 0xA2, 0x52, 0x03, 0x1F, 0x96, 0x5B, + 0xC4, 0x83, 0x08, 0x75, 0xFF, 0xF6, 0xF2, 0xF9, 0x7C, 0x1D, + 0x09, 0xB4, 0x3B, 0xAE, 0xCD, 0x2E, 0xF2, 0x6F, 0x2F, 0x4F, + 0xBC, 0x2B, 0x5B, 0x6D, 0x9A, 0x1B, 0xE6, 0x5E, 0xF5, 0xA8, + 0x93, 0x98, 0xDC, 0x6E, 0x5E, 0x17, 0xCA, 0xAB, 0x90, 0xFD, + 0xFB, 0x68, 0x1F, 0x67, 0x88, 0x58, 0x85, 0x4F, 0xAA, 0xC3, + 0x68, 0x40, 0xD5, 0xBC, 0xAC, 0x1D, 0x94, 0xC5, 0xB6, 0x01, + 0x2A, 0xE8, 0xBD, 0xDD, 0xBB, 0x17, 0x9D, 0x0E, 0x55, 0x62, + 0x45, 0xFB, 0x21, 0xB6, 0x71, 0x76, 0xEB, 0xCC, 0xF5, 0xE7, + 0xF1, 0xCD, 0xB7, 0xCA, 0xBD, 0xFF, 0xA9, 0xF7, 0x1A, 0xAA, + 0x1A, 0xCD, 0xC1, 0x71, 0x62, 0xE3, 0xDD, 0x09, 0x06, 0xAA, + 0x23, 0xFD, 0xEF, 0x6B, 0xA7, 0x83, 0xD8, 0xE6, 0x70, 0x01, + 0xF0, 0xEF, 0x69, 0xA9, 0x4B, 0x9B, 0x83, 0x57, 0x77, 0xAD, + 0x51, 0xBE, 0xBA, 0xF6, 0x2A, 0x6F, 0x1F, 0x97, 0x9A, 0xFE, + 0xA8, 0xE2, 0xAA, 0x20, 0x51, 0x95, 0xBA, 0xAE, 0x66, 0xB3, + 0xA8, 0x61, 0xCF, 0x8B, 0xFA, 0x6B, 0x48, 0xC4, 0x22, 0xE1, + 0xDF, 0x3A, 0x0D, 0xA9, 0x09, 0xF1, 0x66, 0x0C, 0x46, 0x74, + 0x90, 0x8B, 0x68, 0x00, 0x4F, 0x4F, 0x3A, 0x90, 0x58, 0x56, + 0xF4, 0x8A, 0x71, 0xB6, 0x1A, 0x91, 0x59, 0x17, 0x5C, 0xC0, + 0x87, 0x82, 0x7E, 0xB0, 0x81, 0x90, 0xF1, 0x6A, 0x03, 0xB8, + 0xA0, 0xAB, 0xDD, 0x63, 0x96, 0x48, 0x19, 0x37, 0x1F, 0x0F, + 0x24, 0x7A, 0x70, 0x48, 0x7D, 0x28, 0x1F, 0xB3, 0xCD, 0x76, + 0x53, 0x83, 0xC5, 0x53, 0xE8, 0xAB, 0x3A, 0xFC, 0x5B, 0x8A, + 0xF0, 0x5A, 0x0F, 0xEF, 0xFF, 0xB0, 0xC1, 0x61, 0x61, 0x58, + 0x4A, 0x8C, 0x1C, 0x20, 0xFC, 0x46, 0x07, 0x58, 0xF0, 0x20, + 0x81, 0x66, 0x28, 0x0E, 0xC2, 0x16, 0xAB, 0x98, 0xFF, 0x6E, + 0x24, 0xAC, 0x78, 0x42, 0xAE, 0x7D, 0xAB, 0x6F, 0xB4, 0x11, + 0x1C, 0x0C, 0x40, 0xF8, 0xF4, 0x93, 0x63, 0xE4, 0x6A, 0xEB, + 0xC5, 0xD9, 0x6E, 0x35, 0xC9, 0xA7, 0x2D, 0x49, 0xEA, 0x5D, + 0x69, 0x73, 0x06, 0x1C, 0xC4, 0x7E, 0x46, 0xFD, 0x09, 0x88, + 0x77, 0x77, 0xE7, 0xEB, 0x31, 0x34, 0x16, 0x72, 0x76, 0x1B, + 0x4E, 0xF8, 0x67, 0x9F, 0xCA, 0x1C, 0x67, 0x4E, 0xD8, 0x88, + 0xAA, 0x01, 0x27, 0x8E, 0x08, 0x70, 0xF8, 0x0B, 0x23, 0xF6, + 0x84, 0x47, 0x2F, 0x4E, 0x5F, 0xB7, 0x2C, 0x39, 0xBF, 0x61, + 0xEC, 0x6D, 0x24, 0x5C, 0x57, 0xBE, 0xAE, 0x19, 0x20, 0xBE, + 0x55, 0x40, 0x1D, 0xB7, 0x5F, 0xC3, 0xF6, 0x5B, 0x19, 0xC6, + 0x8A, 0x94, 0x23, 0x5C, 0x95, 0x33, 0x4C, 0x90, 0xE0, 0x46, + 0xAC, 0x0A, 0x1D, 0x50, 0xFB, 0x0A, 0xAB, 0xA2, 0xEB, 0x2A, + 0x21, 0xBF, 0x15, 0xD5, 0x9E, 0x80, 0x3B, 0x16, 0xB0, 0x3F, + 0x6F, 0x6F, 0xF6, 0xBE, 0x92, 0xA1, 0x2F, 0x83, 0xA8, 0x3C, + 0xA6, 0xE7, 0x86, 0xCD, 0x3B, 0x96, 0xCE, 0xF1, 0x36, 0x7C, + 0x69, 0xD9, 0xD5, 0x0F, 0xC1, 0x4C, 0x7A, 0xE5, 0xAF, 0xAC, + 0x86, 0x90, 0x98, 0x3D, 0x2B, 0x94, 0xA2, 0x7C, 0x5B, 0xF7, + 0x27, 0xCD, 0xE5, 0x93, 0x60, 0x2C, 0x47, 0xE3, 0xFA, 0x18, + 0xCB, 0xEB, 0xDB, 0x0A, 0x49, 0x99, 0x0F, 0xAE, 0x02, 0x26, + 0xC0, 0x00, 0x02, 0xF3, 0x51, 0xA3, 0x96, 0x54, 0xDA, 0xE9, + 0x09, 0x47, 0x82, 0x50, 0xB8, 0x82, 0x39, 0x98, 0x54, 0x81, + 0x54, 0x91, 0x2C, 0xE6, 0xBC, 0x84, 0x03, 0x07, 0x26, 0x6D, + 0x0F, 0x5E, 0x2B, 0x45, 0xF5, 0x1D, 0x7B, 0xD6, 0x14, 0x03, + 0xD7, 0x09, 0x64, 0xEE, 0x05, 0xBA, 0xE0, 0x74, 0x67, 0x02, + 0xF5, 0x7E, 0x42, 0x42, 0xEC, 0x56, 0xE0, 0x9E, 0x82, 0x88, + 0x58, 0x3C, 0x96, 0xAF, 0x37, 0x95, 0x49, 0xC8, 0x87, 0xBD, + 0xFE, 0x7A, 0x6B, 0x4D, 0x37, 0xEE, 0x7C, 0xAA, 0x18, 0x5F, + 0x7E, 0x0B, 0x28, 0xA3, 0x95, 0x23, 0x42, 0xAB, 0xC1, 0xFA, + 0x41, 0xAE, 0xD5, 0xBD, 0x67, 0xA6, 0xC4, 0x7C, 0xAC, 0x2D, + 0xEF, 0x64, 0xC2, 0x5D, 0x30, 0x94, 0xF3, 0x97, 0x49, 0x00, + 0x39, 0x28, 0x57, 0x5D, 0x31, 0xBB, 0x1D, 0x10, 0x17, 0xE7, + 0x56, 0x55, 0xDF, 0x4C, 0xDD, 0xA6, 0x64, 0x02, 0xBC, 0x1C, + 0x2B, 0x4C, 0x30, 0xBF, 0x89, 0x7C, 0xFC, 0x7E, 0x84, 0xBC, + 0x51, 0x97, 0x6C, 0x74, 0x5B, 0x08, 0xE0, 0x96, 0x84, 0x81, + 0xF3, 0x17, 0x6B, 0xD6, 0xF6, 0x66, 0x06, 0x1B, 0x33, 0x4D, + 0xF8, 0xED, 0xC0, 0x53, 0x8B, 0x35, 0x6B, 0x85, 0x4F, 0x37, + 0x0F, 0x87, 0xF3, 0x85, 0x72, 0xAE, 0xCB, 0x3A, 0x23, 0x97, + 0xC0, 0xF6, 0xE7, 0x53, 0xDF, 0x57, 0x0E, 0x8E, 0x0B, 0x66, + 0x2A, 0xA2, 0x9D, 0xA8, 0xE2, 0x60, 0x57, 0xCA, 0x27, 0x7E, + 0xB1, 0xDB, 0x7B, 0x6A, 0xB0, 0xBE, 0xB5, 0x47, 0xEE, 0xE6, + 0xBA, 0x0E, 0xB2, 0x71, 0x0B, 0xF7, 0xE4, 0x27, 0x9D, 0x25, + 0xAA, 0x3F, 0xA9, 0x1A, 0x5B, 0xD9, 0x9D, 0xBB, 0x20, 0x32, + 0x37, 0xE1, 0xD3, 0x4A, 0xBA, 0x45, 0x9E, 0x00, 0x10, 0x3F, + 0x21, 0x6E, 0xA2, 0xCE, 0x30, 0xA0, 0x2A, 0x5B, 0x31, 0x51, + 0x05, 0xA1, 0x51, 0xED, 0x89, 0x5E, 0xB1, 0x09, 0xE6, 0x71, + 0xD8, 0x42, 0xFD, 0xA1, 0x04, 0x83, 0xFB, 0x09, 0x4F, 0x90, + 0x4D, 0x7E, 0x5A, 0xB9, 0x4C, 0xC9, 0xA3, 0x57, 0x4E, 0x54, + 0x98, 0xB3, 0xBD, 0xB7, 0x52, 0x9D, 0xDE, 0xF3, 0xD3, 0xE0, + 0x9C, 0x2D, 0x97, 0x46, 0x1B, 0xF9, 0x75, 0x37, 0x5D, 0x0A, + 0xA3, 0x4A, 0x18, 0x35, 0x80, 0xC5, 0x08, 0xA8, 0x37, 0x09, + 0x44, 0x92, 0xB1, 0x74, 0xFE, 0x28, 0x95, 0x55, 0xB6, 0x08, + 0xA0, 0x75, 0xE9, 0xA0, 0x4B, 0x8E, 0xE6, 0x61, 0x17, 0x2A, + 0xED, 0x15, 0x0B, 0x6C, 0x7C, 0xC3, 0x82, 0x57, 0x90, 0xC5, + 0xFF, 0xD8, 0xA5, 0xBF, 0xAA, 0xBE, 0xCF, 0x8E, 0x06, 0xFF, + 0x27, 0xDA, 0x40, 0x24, 0xDD, 0xC0, 0xBE, 0x4E, 0x19, 0x9D, + 0x23, 0xA2, 0x3A, 0x70, 0x64, 0xEB, 0xF6, 0xA7, 0xE9, 0x71, + 0x57, 0xE9, 0x63, 0x03, 0xAE, 0xEC, 0x73, 0x21, 0x23, 0x8D, + 0x61, 0x5A, 0x10, 0x54, 0xF9, 0x80, 0xE7, 0x47, 0x45, 0xD4, + 0x8B, 0x16, 0xEE, 0x2B, 0xD8, 0xC1, 0xEE, 0x0F, 0x4F, 0x78, + 0x40, 0x00, 0xB6, 0x25, 0x81, 0x2A, 0x37, 0x4D, 0x71, 0x92, + 0xFA, 0x56, 0x3F, 0xDC, 0x91, 0x01, 0x27, 0xC7, 0x17, 0xFD, + 0x27, 0x55, 0x6F, 0x32, 0x14, 0xE7, 0xEA, 0x18, 0xDA, 0x4A, + 0x70, 0x10, 0xF8, 0x72, 0x78, 0xA1, 0xC1, 0x13, 0x5F, 0x1B, + 0x98, 0x93, 0xC2, 0xBF, 0x29, 0xA3, 0x59, 0x79, 0x15, 0x57, + 0x17, 0xE5, 0x66, 0x7A, 0x3B, 0x8E, 0xB3, 0x3B, 0x9E, 0xC0, + 0x77, 0xBD, 0x2D, 0x95, 0x26, 0xF0, 0xD5, 0xB4, 0x30, 0xC8, + 0x0D, 0xCA, 0xB5, 0xDE, 0xB2, 0x21, 0x27, 0x9A, 0x27, 0xAF, + 0x89, 0xB4, 0x0D, 0x1B, 0x5A, 0x43, 0x3E, 0x69, 0x76, 0x25, + 0xAC, 0x42, 0x23, 0x5F, 0x5A, 0xA6, 0xDB, 0xE6, 0x77, 0x9D, + 0x2A, 0x99, 0x1B, 0xE7, 0x47, 0x05, 0x06, 0x47, 0x01, 0x14, + 0x0D, 0xEA, 0xF5, 0x28, 0x3A, 0x5B, 0x87, 0xF0, 0xFB, 0x7C, + 0x96, 0x39, 0x6C, 0x4A, 0x48, 0xA5, 0x7A, 0x94, 0xB0, 0xB8, + 0xBB, 0x03, 0xDA, 0xEA, 0x4F, 0xD1, 0x5B, 0x8B, 0x9D, 0x0A, + 0x5E, 0xAB, 0xD8, 0x89, 0x5C, 0x4D, 0xD1, 0xA7, 0xC4, 0x8A, + 0x02, 0x26, 0xC0, 0x00, 0x02, 0x14, 0x04, 0xA6, 0x12, 0xC1, + 0x4E, 0x67, 0x67, 0x6C, 0xEE, 0x9E, 0x7A, 0x55, 0x00, 0xCB, + 0x12, 0x7B, 0x69, 0x4C, 0x94, 0x57, 0x73, 0x71, 0xC8, 0x45, + 0xAA, 0x04, 0x75, 0x85, 0xED, 0x68, 0x7D, 0x09, 0xD5, 0x4A, + 0xD0, 0x86, 0xDB, 0x0B, 0xC3, 0x80, 0xD1, 0x11, 0xB3, 0x59, + 0xCF, 0xBD, 0x13, 0x7B, 0xD2, 0x30, 0xDF, 0xDD, 0x41, 0xD7, + 0xBC, 0x34, 0x11, 0x85, 0x58, 0x2A, 0x8E, 0x2B, 0xDC, 0x00, + 0x78, 0x94, 0x28, 0x52, 0xD9, 0x0C, 0x70, 0xCB, 0x7D, 0xE9, + 0xCF, 0x7C, 0x11, 0x91, 0x09, 0xA8, 0xD7, 0xBC, 0xC8, 0xA1, + 0xDF, 0xF3, 0xB4, 0x25, 0x3A, 0x88, 0x02, 0xF0, 0xBE, 0x8E, + 0x89, 0x2B, 0xA6, 0x43, 0x88, 0xD0, 0xCC, 0x27, 0x91, 0x77, + 0x8D, 0x01, 0x32, 0xA6, 0x0C, 0x3D, 0x86, 0x76, 0x03, 0x4F, + 0x01, 0xF6, 0x02, 0xB3, 0xD0, 0x7A, 0x39, 0x78, 0x1E, 0xF2, + 0x35, 0xB6, 0xB3, 0xC9, 0x50, 0xE7, 0x0A, 0xD1, 0x3C, 0xB4, + 0xE2, 0x02, 0x60, 0x13, 0x8A, 0x0F, 0x15, 0xEE, 0x48, 0x67, + 0x84, 0x9E, 0x8E, 0x56, 0x22, 0xB9, 0x0A, 0xE2, 0x36, 0xDE, + 0x97, 0x4E, 0x9F, 0x0A, 0xE0, 0xB8, 0x2A, 0x0D, 0x07, 0x7F, + 0xCE, 0x76, 0xEA, 0x58, 0x54, 0xBC, 0x7A, 0xA1, 0x87, 0x15, + 0x3F, 0xCE, 0xDA, 0x58, 0xA4, 0x51, 0x36, 0x49, 0xB0, 0x23, + 0xC0, 0x55, 0xFB, 0xE2, 0x47, 0xB6, 0xD6, 0x31, 0x90, 0xA9, + 0x99, 0x2A, 0xC3, 0x59, 0xAE, 0x60, 0x03, 0xC2, 0x56, 0xC0, + 0x03, 0xA9, 0x3E, 0xF0, 0xE9, 0x59, 0x30, 0xD5, 0x90, 0x15, + 0x72, 0x32, 0x30, 0xD1, 0xFA, 0xDD, 0xB3, 0x09, 0xF0, 0x1A, + 0xA3, 0x6E, 0x5E, 0xBB, 0xDE, 0x58, 0x08, 0x91, 0xFB, 0xA0, + 0xEC, 0x45, 0x7F, 0x05, 0x90, 0x78, 0xCF, 0x6F, 0x66, 0xF4, + 0x2A, 0x79, 0x93, 0x33, 0x17, 0x07, 0x86, 0xE6, 0xEC, 0xFD, + 0xEC, 0x07, 0x74, 0x17, 0x26, 0x84, 0x52, 0x54, 0x9A, 0xBC, + 0xDE, 0xEE, 0xD7, 0xE9, 0x2F, 0xA7, 0x60, 0xA6, 0x54, 0x74, + 0xB9, 0x83, 0x6D, 0xE6, 0xB7, 0x46, 0xDC, 0xC8, 0x09, 0x36, + 0x25, 0x1E, 0x8B, 0x61, 0x94, 0x2D, 0xBA, 0xE2, 0xAB, 0xE6, + 0xD0, 0xDB, 0x9C, 0x13, 0x74, 0x25, 0xDA, 0xD7, 0x69, 0x69, + 0xFA, 0x52, 0x3C, 0x15, 0xBB, 0xFC, 0x5D, 0xE2, 0x6E, 0xA5, + 0x26, 0x35, 0x65, 0xF4, 0xE0, 0x29, 0x77, 0xCF, 0xAB, 0xF9, + 0xAB, 0x8C, 0x9D, 0x7D, 0x60, 0xA4, 0xA0, 0x3D, 0x43, 0xB6, + 0x9D, 0xAE, 0x04, 0x46, 0x8A, 0xE2, 0x3B, 0x4C, 0xC8, 0xA4, + 0x5D, 0x61, 0xB4, 0x5B, 0x8B, 0x2E, 0xD5, 0x2A, 0x07, 0x27, + 0x6A, 0x34, 0x04, 0xBA, 0xF8, 0x72, 0x32, 0x99, 0x97, 0x8C, + 0xC0, 0xCD, 0x35, 0x68, 0xB8, 0xA9, 0x45, 0x76, 0xA5, 0xD4, + 0x17, 0x36, 0xB1, 0x25, 0xF7, 0x47, 0x69, 0x30, 0x68, 0x14, + 0x0B, 0x9C, 0x38, 0xB1, 0x29, 0x16, 0x88, 0xAD, 0xDF, 0x31, + 0x7E, 0x3C, 0x5F, 0xA4, 0x0D, 0x86, 0x5A, 0x29, 0x37, 0xA9, + 0x1B, 0xD5, 0x68, 0x9F, 0xE0, 0xE6, 0x32, 0x42, 0x12, 0x37, + 0x99, 0xC5, 0xB8, 0xA1, 0xD3, 0x5B, 0x90, 0x9C, 0xAD, 0x86, + 0x6B, 0x03, 0x82, 0x91, 0xD9, 0xF9, 0xDC, 0xD5, 0x41, 0x7B, + 0xF3, 0xE4, 0x08, 0x92, 0xCA, 0x6A, 0xAA, 0xBD, 0xFE, 0x25, + 0x50, 0xDC, 0x2C, 0x00, 0x65, 0x59, 0x9B, 0xD3, 0x30, 0xD2, + 0x39, 0xC0, 0x4D, 0xFD, 0x8C, 0x9D, 0x88, 0xD3, 0x52, 0xD6, + 0xC0, 0xA0, 0x1C, 0x08, 0x0B, 0x1F, 0x91, 0xAF, 0x60, 0x56, + 0xED, 0x8B, 0x37, 0xD3, 0x15, 0x08, 0x5C, 0xEA, 0xFA, 0x03, + 0x0A, 0x54, 0x92, 0x96, 0x34, 0x4F, 0x14, 0x0E, 0xD5, 0xB4, + 0xA0, 0x2E, 0xC0, 0xEC, 0x93, 0x8F, 0xA5, 0xF3, 0x82, 0x5F, + 0x0D, 0xA8, 0xBD, 0x28, 0x4B, 0x1C, 0x65, 0xC1, 0x97, 0x5B, + 0xEE, 0x99, 0xC5, 0xC2, 0xB9, 0x34, 0x4D, 0xDB, 0x6E, 0x42, + 0x26, 0x93, 0x49, 0x83, 0x36, 0x25, 0x72, 0x03, 0x08, 0xE2, + 0xE6, 0x67, 0x01, 0xBC, 0x7A, 0x10, 0x7A, 0xBC, 0x6B, 0x0B, + 0x4A, 0x94, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x72, 0x08, 0xBA, + 0x77, 0xE2, 0x2F, 0x48, 0xD4, 0x9E, 0xC4, 0x23, 0x45, 0x55, + 0xF1, 0x0B, 0x1B, 0x50, 0x47, 0x8C, 0x40, 0x7C, 0xF7, 0xE4, + 0xCF, 0xD6, 0x0A, 0x0A, 0xD3, 0x7F, 0x35, 0x85, 0x84, 0x78, + 0xF2, 0x28, 0xEA, 0x14, 0x06, 0x2A, 0xC0, 0x53, 0x22, 0x45, + 0x9B, 0xDA, 0xE9, 0xEE, 0x98, 0x5D, 0xEC, 0xEC, 0xEF, 0xA1, + 0x1A, 0xDD, 0x7C, 0xE2, 0x29, 0xFF, 0x2B, 0x8A, 0x00, 0x49, + 0xD6, 0x2E, 0x7C, 0x50, 0x26, 0x29, 0x65, 0x97, 0xB4, 0xA8, + 0x6B, 0x38, 0x95, 0xC0, 0x7F, 0x41, 0xAD, 0xD5, 0xA2, 0x54, + 0x37, 0xE1, 0x72, 0x3A, 0x28, 0x58, 0xCA, 0x88, 0xB4, 0xF8, + 0x34, 0x43, 0xFF, 0xE4, 0xE4, 0xC2, 0x37, 0x0B, 0x72, 0x77, + 0x2B, 0x94, 0x8C, 0xB8, 0xCD, 0x72, 0x1E, 0xDB, 0x0A, 0xFA, + 0x86, 0x0E, 0xBC, 0x76, 0xDE, 0x89, 0x20, 0xBB, 0x1A, 0xC3, + 0x07, 0xAA, 0x0F, 0x0D, 0xED, 0x58, 0x42, 0x74, 0x44, 0xD0, + 0x89, 0x61, 0x25, 0xAF, 0xC0, 0x18, 0xFE, 0x16, 0xC9, 0x37, + 0x03, 0x11, 0x11, 0xEC, 0x9F, 0xFF, 0x2B, 0x00, 0x4F, 0x37, + 0xB6, 0xEC, 0x54, 0x0A, 0xA1, 0x68, 0xE5, 0x69, 0x38, 0xD5, + 0x55, 0x9E, 0x94, 0xAF, 0x3D, 0x67, 0xFF, 0x4D, 0x5D, 0x66, + 0x1D, 0xD0, 0x45, 0x1B, 0xF9, 0x23, 0x5F, 0xCF, 0x18, 0xFB, + 0x3F, 0x13, 0x0A, 0x2E, 0x86, 0xC4, 0x44, 0x28, 0xAB, 0x72, + 0x78, 0x77, 0x14, 0xCA, 0x70, 0xBF, 0x3E, 0x79, 0x47, 0xAB, + 0x3D, 0x22, 0xB9, 0x57, 0xB8, 0x04, 0x4B, 0x62, 0x2A, 0x26, + 0x4C, 0xEE, 0x80, 0xF4, 0x1C, 0x5C, 0xE3, 0xFF, 0x23, 0xC8, + 0x7C, 0x27, 0x90, 0xC8, 0x61, 0xC3, 0x7C, 0xC8, 0x5B, 0x46, + 0xB8, 0xCC, 0x8A, 0x67, 0xFC, 0xB9, 0xF1, 0xE7, 0x21, 0x68, + 0x47, 0x37, 0x9D, 0xEB, 0x14, 0xC4, 0x55, 0x02, 0x43, 0xA6, + 0xAA, 0x50, 0xE2, 0x78, 0x66, 0xE9, 0x55, 0x2D, 0x4C, 0x84, + 0xDF, 0x81, 0xCF, 0x0C, 0xD4, 0x36, 0xCA, 0x3D, 0xF7, 0xEE, + 0x2A, 0x5D, 0x10, 0xC9, 0xEA, 0x19, 0xF2, 0xF3, 0xBD, 0x42, + 0xA9, 0xE1, 0xA6, 0xD1, 0x84, 0xE9, 0x1A, 0x26, 0xDC, 0xBE, + 0x72, 0x43, 0xC7, 0x79, 0x92, 0xD9, 0x5F, 0x7C, 0x42, 0xCD, + 0xFF, 0x76, 0xBE, 0xB9, 0x99, 0x60, 0x6B, 0x5E, 0xAD, 0xAC, + 0x62, 0xAD, 0xFD, 0x58, 0x1C, 0x4E, 0xC6, 0x6D, 0xE7, 0xF9, + 0x2E, 0xD1, 0xEC, 0x9F, 0x98, 0xAE, 0x4F, 0xB6, 0xE1, 0xB3, + 0x77, 0xDD, 0xA4, 0x5D, 0x24, 0x76, 0xF0, 0xED, 0xBE, 0x19, + 0xB1, 0x98, 0x85, 0x08, 0xAB, 0xF0, 0x39, 0x94, 0x1D, 0x12, + 0xCA, 0x8B, 0xD2, 0xCC, 0x97, 0x44, 0xCB, 0x89, 0x9B, 0x66, + 0x50, 0x51, 0x64, 0x9E, 0xB1, 0x9E, 0x2C, 0xAA, 0xE5, 0x91, + 0x59, 0x53, 0xB1, 0x5E, 0xB3, 0xBB, 0x99, 0x00, 0x53, 0xA9, + 0xC1, 0x6C, 0x59, 0x46, 0xFD, 0xCB, 0x53, 0x83, 0xDD, 0x37, + 0xA1, 0xA3, 0x65, 0x26, 0xC6, 0x48, 0x6D, 0x15, 0xE8, 0xC1, + 0xE3, 0x45, 0x10, 0x6E, 0x8A, 0xE1, 0xDB, 0x10, 0xDB, 0x58, + 0x16, 0x5C, 0x31, 0x2E, 0x06, 0xA8, 0xAE, 0xD7, 0xB2, 0x11, + 0x55, 0x07, 0x2E, 0x57, 0x57, 0x02, 0x48, 0xC0, 0x8B, 0x59, + 0x8C, 0xBE, 0x1A, 0x47, 0x52, 0x3E, 0xD0, 0x05, 0xEA, 0xBC, + 0x86, 0xEA, 0x31, 0xD9, 0x58, 0x52, 0xCF, 0x7D, 0xD2, 0x30, + 0x4E, 0x0D, 0x24, 0x6F, 0x39, 0xF6, 0xEB, 0xC8, 0x5D, 0xE4, + 0xFF, 0x8D, 0xB9, 0x71, 0x02, 0x71, 0x67, 0x89, 0xFA, 0xB8, + 0x4F, 0xC9, 0x77, 0x78, 0x60, 0x36, 0xDF, 0x0E, 0x96, 0xAC, + 0x4F, 0x44, 0x8A, 0x2C, 0xE5, 0x8C, 0xC3, 0x96, 0x79, 0xE2, + 0x43, 0x75, 0xF5, 0x59, 0xC0, 0x81, 0x0A, 0x54, 0xC2, 0xA3, + 0x28, 0x8A, 0x32, 0xCE, 0x91, 0x5A, 0x91, 0x06, 0x45, 0xEB, + 0x34, 0x1A, 0x87, 0xF9, 0x57, 0x91, 0x0D, 0x34, 0x7F, 0x82, + 0x91, 0x82, 0xC5, 0x26, 0xCB, 0xB3, 0x4F, 0xF2, 0x20, 0x6A, + 0x02, 0x95, 0x73, 0x7B, 0x4F, 0x4E, 0xAF, 0x8A, 0x40, 0x83, + 0xFE, 0xF9, 0xD2, 0xFD, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x0E, + 0xA2, 0xA8, 0x59, 0xF0, 0x82, 0x17, 0x4C, 0x0E, 0xF3, 0x83, + 0xA1, 0xB6, 0x36, 0x83, 0xCB, 0xFB, 0xA2, 0x66, 0x53, 0x65, + 0x40, 0x40, 0xAA, 0x3D, 0x82, 0x62, 0x54, 0x0A, 0x27, 0x6A, + 0xD6, 0x07, 0xAF, 0x91, 0xCF, 0x9B, 0x89, 0x58, 0xBC, 0xCE, + 0x74, 0x87, 0x9C, 0x7E, 0x30, 0xF3, 0x06, 0x2B, 0xF1, 0xB4, + 0x70, 0x9D, 0xAA, 0x41, 0xD7, 0x25, 0x75, 0xE5, 0x72, 0x25, + 0x00, 0xC7, 0x21, 0x9D, 0xEE, 0xD1, 0x24, 0x16, 0x0B, 0x12, + 0x22, 0x88, 0xB8, 0x9D, 0xA5, 0x38, 0xA0, 0x50, 0x39, 0x27, + 0xAE, 0x10, 0xF6, 0x9A, 0x0B, 0x77, 0x56, 0x3F, 0x96, 0xDF, + 0x22, 0xE5, 0xEA, 0xAC, 0x8F, 0xDF, 0xDD, 0x78, 0xEF, 0x5A, + 0x7B, 0x50, 0x72, 0x98, 0x92, 0xDD, 0x94, 0xB5, 0xDB, 0x99, + 0xCE, 0xF2, 0x7A, 0xF3, 0xFA, 0x80, 0xD3, 0xCD, 0x1F, 0xCA, + 0xA2, 0x2E, 0x21, 0x94, 0xF2, 0xB3, 0x71, 0x7C, 0x07, 0xE6, + 0xB9, 0x68, 0x1E, 0x13, 0x02, 0x15, 0xC8, 0x34, 0xA0, 0xB5, + 0xD9, 0x95, 0x1A, 0x9B, 0x57, 0xE7, 0xAF, 0xB0, 0xE1, 0xA7, + 0x95, 0xF2, 0x36, 0xA3, 0xF9, 0xC5, 0x2C, 0xF0, 0xC3, 0xE1, + 0xD1, 0x26, 0xA1, 0x8F, 0xE6, 0x07, 0xFB, 0x1F, 0x03, 0xFF, + 0xA5, 0x81, 0xF5, 0x5D, 0x21, 0x3B, 0x93, 0x66, 0x1A, 0x78, + 0x6F, 0xD4, 0x77, 0xB3, 0x91, 0x26, 0x6F, 0x1F, 0x5A, 0x8B, + 0x0F, 0x07, 0xEA, 0x24, 0x5F, 0x5E, 0x68, 0x9F, 0x89, 0x75, + 0x00, 0x23, 0x1C, 0x80, 0x55, 0x86, 0x93, 0x58, 0x94, 0x41, + 0x37, 0x0D, 0x23, 0xD3, 0x09, 0x72, 0x40, 0x79, 0xA2, 0x52, + 0x0D, 0xA3, 0x40, 0x3F, 0x54, 0x7E, 0x59, 0x55, 0x5B, 0x7D, + 0x0C, 0x52, 0xAA, 0x97, 0x0C, 0xC6, 0xCB, 0x0B, 0x6C, 0x83, + 0x45, 0x28, 0x62, 0x09, 0x0A, 0x74, 0x27, 0x1D, 0x4D, 0x02, + 0x07, 0xB3, 0xA5, 0x83, 0x9A, 0x43, 0xB3, 0x68, 0xF7, 0x97, + 0x3E, 0xD7, 0x34, 0x04, 0x83, 0xC7, 0x6F, 0x64, 0xB8, 0x0B, + 0xB9, 0xE9, 0x94, 0x46, 0xB9, 0x4D, 0xA7, 0xB4, 0x26, 0xF7, + 0x9C, 0x05, 0x94, 0x8B, 0xBE, 0x93, 0x03, 0xA7, 0x73, 0x65, + 0xAB, 0xC5, 0xE1, 0x2B, 0x3B, 0x4C, 0x56, 0x1F, 0x11, 0x7B, + 0xD3, 0xC0, 0x77, 0x48, 0x42, 0x27, 0x8D, 0x2A, 0xAA, 0x1E, + 0x18, 0x41, 0x76, 0xA1, 0x80, 0x99, 0x52, 0x50, 0x66, 0x7B, + 0x27, 0x4B, 0x49, 0xA1, 0xE8, 0xCA, 0xF1, 0x3E, 0x60, 0x2E, + 0x93, 0xEF, 0x4A, 0x20, 0x3C, 0xC4, 0xBB, 0x14, 0xD3, 0x8F, + 0x14, 0xAF, 0xC0, 0xF8, 0x4B, 0xC6, 0x49, 0x1A, 0x3B, 0x17, + 0x43, 0xC2, 0xAB, 0xF0, 0x01, 0xFC, 0x6E, 0x67, 0x86, 0xAC, + 0xE4, 0x6F, 0xF2, 0x26, 0xF2, 0xEC, 0x15, 0xA1, 0x96, 0x81, + 0xDD, 0xCF, 0xCA, 0xB4, 0xE1, 0x5A, 0xA0, 0xF5, 0xBB, 0x70, + 0xEB, 0xF9, 0xA6, 0x28, 0x66, 0xC3, 0xBE, 0xB9, 0xBD, 0xDD, + 0xEF, 0x8E, 0x9E, 0x3C, 0x91, 0x50, 0x38, 0x61, 0x40, 0x25, + 0x4D, 0xCD, 0xA0, 0xAF, 0xFE, 0x57, 0xB8, 0x96, 0xDD, 0x2B, + 0x52, 0x29, 0x91, 0x7A, 0x31, 0xE8, 0x9A, 0xBB, 0xC9, 0x70, + 0x2B, 0xE1, 0x40, 0x3A, 0x9F, 0xB7, 0x31, 0xBE, 0xE5, 0x46, + 0xDA, 0x8A, 0xDE, 0x13, 0x22, 0x87, 0x70, 0xFE, 0x96, 0x40, + 0x9F, 0xC1, 0x2B, 0xFE, 0x83, 0x31, 0xE9, 0xA5, 0x4C, 0x37, + 0xEB, 0xFD, 0xFB, 0x2C, 0xBD, 0x0C, 0x1F, 0xB2, 0x62, 0x32, + 0x0E, 0x76, 0x9A, 0x2C, 0xC2, 0x84, 0x34, 0xA0, 0x6D, 0x72, + 0x21, 0x47, 0xF9, 0x3E, 0xC6, 0x5C, 0xEE, 0xB6, 0xE1, 0xD9, + 0x2E, 0xDF, 0x50, 0xD6, 0x2C, 0x9B, 0x44, 0xBE, 0xF0, 0x01, + 0x8E, 0xB4, 0x34, 0x38, 0x9C, 0x6C, 0x3E, 0x26, 0xB2, 0x4C, + 0x8E, 0xF0, 0x41, 0x2F, 0x07, 0x0E, 0xE9, 0x69, 0x1C, 0x0A, + 0x00, 0x05, 0xB0, 0x09, 0xA7, 0x07, 0x18, 0x41, 0xD1, 0xF7, + 0x22, 0xE4, 0x85, 0x64, 0xB7, 0x83, 0xF7, 0xB1, 0xE2, 0xAC, + 0x2E, 0xD9, 0x83, 0x81, 0x18, 0xCB, 0xBD, 0xEE, 0xD9, 0x09, + 0x99, 0xBA, 0x95, 0x66, 0x1F, 0xBA, 0x02, 0x26, 0xC0, 0x00, + 0x02, 0x67, 0x72, 0x24, 0xB5, 0xFE, 0x8C, 0x50, 0x84, 0x47, + 0x41, 0x6A, 0x29, 0x1F, 0x17, 0xB2, 0x9E, 0x02, 0x67, 0x70, + 0x55, 0x03, 0x3F, 0x8F, 0x07, 0x20, 0x91, 0x6B, 0x22, 0x7F, + 0x06, 0xC3, 0xC9, 0x0A, 0xB5, 0x07, 0x0D, 0x91, 0x5F, 0x87, + 0x6D, 0xE2, 0xEE, 0x2B, 0x01, 0xE7, 0x45, 0x3F, 0x89, 0x1C, + 0x8B, 0x12, 0x33, 0x23, 0x61, 0x64, 0x3F, 0x4B, 0xF1, 0x27, + 0x0E, 0x8B, 0x7B, 0x7E, 0x64, 0x2E, 0xDE, 0xE0, 0x3F, 0x3E, + 0x5C, 0xAE, 0x8C, 0x73, 0xB2, 0x8B, 0x62, 0x0F, 0xF9, 0xEB, + 0xF0, 0x74, 0xBD, 0xB9, 0xCC, 0x43, 0x80, 0xC3, 0x05, 0x31, + 0x53, 0x6F, 0x72, 0x42, 0x8E, 0x14, 0xAD, 0xF0, 0x45, 0x36, + 0x88, 0xE4, 0xF9, 0x0F, 0xD9, 0xCA, 0x1E, 0x82, 0xC2, 0x89, + 0x44, 0xC3, 0x69, 0xC6, 0xDD, 0x27, 0xB5, 0xCA, 0xCF, 0x56, + 0x23, 0x5D, 0x50, 0xF9, 0x69, 0x87, 0xCF, 0x4D, 0x2F, 0xA8, + 0xEE, 0xD4, 0x55, 0x2A, 0xC7, 0x3A, 0x2D, 0x03, 0xCD, 0x38, + 0xDE, 0x4F, 0x29, 0x91, 0x14, 0xAD, 0x39, 0x05, 0x77, 0x5F, + 0x41, 0x48, 0x30, 0x63, 0xE6, 0x81, 0x40, 0x68, 0x75, 0x8D, + 0xC5, 0x70, 0x2D, 0xC9, 0xB9, 0x10, 0x75, 0xF3, 0x28, 0x91, + 0x99, 0x97, 0x16, 0x2E, 0x7C, 0xAD, 0x50, 0x80, 0x40, 0x00, + 0xEE, 0x8F, 0x59, 0xA1, 0x8F, 0x82, 0xDE, 0x1E, 0xDB, 0x56, + 0xA1, 0xD6, 0x2E, 0x06, 0x9D, 0x42, 0xCF, 0xA0, 0xB7, 0x1F, + 0x37, 0x22, 0x02, 0x2E, 0x33, 0xAE, 0xE4, 0x7B, 0x7C, 0xC6, + 0x11, 0x5E, 0xF6, 0xA5, 0x5B, 0x54, 0x8B, 0x28, 0x54, 0x01, + 0x4C, 0x41, 0x49, 0x8E, 0xAD, 0x22, 0xBB, 0x67, 0x7A, 0xF3, + 0xEC, 0xE3, 0x93, 0xE4, 0x3A, 0x71, 0xB2, 0x82, 0xC4, 0x8A, + 0x7B, 0x99, 0xA7, 0x6B, 0x69, 0x28, 0xE3, 0xC5, 0x89, 0xF7, + 0x3E, 0xF3, 0xC5, 0xB2, 0x40, 0x91, 0xF8, 0x6A, 0xE3, 0x63, + 0xB1, 0x5C, 0xE3, 0x79, 0xFF, 0x41, 0xE8, 0x2F, 0xCA, 0x11, + 0xA2, 0xED, 0x86, 0x59, 0x53, 0x9D, 0xF9, 0xE1, 0x15, 0x5D, + 0x38, 0x32, 0x69, 0x60, 0x45, 0x20, 0x74, 0xF5, 0xF6, 0x24, + 0xA2, 0x4E, 0xAE, 0xB5, 0x2F, 0xE2, 0xEE, 0xBD, 0xD3, 0x27, + 0xE1, 0x90, 0x89, 0x89, 0xA3, 0x7E, 0x2B, 0x73, 0x63, 0xB8, + 0x36, 0xFA, 0x17, 0x0C, 0x8F, 0x0F, 0xE8, 0xBE, 0xDC, 0x8D, + 0x52, 0x34, 0xB3, 0x52, 0x0E, 0xB1, 0x97, 0x8D, 0x69, 0xC8, + 0x27, 0x2E, 0xBC, 0xFC, 0xDB, 0x6C, 0x98, 0xE8, 0x50, 0xF1, + 0x7A, 0x14, 0xE7, 0xA4, 0x11, 0xD2, 0xDA, 0x71, 0xCB, 0x77, + 0x88, 0x7B, 0xEE, 0x24, 0x52, 0xF4, 0x83, 0x2F, 0x1B, 0x25, + 0x73, 0x7D, 0x57, 0xAE, 0x78, 0x42, 0xC7, 0x7F, 0x84, 0xDB, + 0x67, 0x7A, 0x81, 0xAB, 0xB5, 0xC4, 0x41, 0x38, 0xA0, 0x8D, + 0x8C, 0x50, 0x1F, 0x56, 0xF6, 0x9A, 0x2B, 0x57, 0x89, 0x20, + 0xA9, 0xE9, 0x1E, 0x55, 0x22, 0xD7, 0x88, 0xFA, 0x5D, 0x5F, + 0x51, 0x5C, 0x7C, 0x17, 0x6E, 0x1D, 0x1A, 0xE3, 0xE6, 0x24, + 0x67, 0xFE, 0xAA, 0xEF, 0x28, 0x25, 0xCA, 0xD7, 0x9B, 0x44, + 0x3A, 0x55, 0x6B, 0x2E, 0xDE, 0x7D, 0xD0, 0x1E, 0x16, 0xD6, + 0xA5, 0xA6, 0x97, 0xE0, 0x35, 0x90, 0x13, 0xD4, 0x16, 0x53, + 0xA2, 0x66, 0xCB, 0x12, 0xEE, 0xED, 0xA1, 0x42, 0x2C, 0x6A, + 0xF5, 0x13, 0x63, 0x5B, 0x2A, 0x0C, 0x8C, 0x3A, 0xC4, 0xAA, + 0x77, 0xFD, 0x03, 0x29, 0x47, 0x2E, 0x4E, 0xCE, 0x26, 0x2E, + 0xE2, 0x87, 0xD5, 0x49, 0xBE, 0xCE, 0x07, 0x71, 0x8F, 0xBB, + 0xDF, 0x5E, 0x73, 0x17, 0x28, 0x1B, 0x34, 0x55, 0xA2, 0xB1, + 0x99, 0x72, 0x90, 0xFD, 0xDF, 0xB3, 0xC7, 0x63, 0xFE, 0x1B, + 0x75, 0x6B, 0x6D, 0x73, 0xDE, 0x21, 0xD0, 0x18, 0xBE, 0x87, + 0xE8, 0xDA, 0x74, 0x1E, 0x78, 0x65, 0x6D, 0x30, 0x3B, 0xF1, + 0xEF, 0xE3, 0x32, 0xD6, 0xF8, 0x77, 0x31, 0xAB, 0x72, 0x72, + 0xF1, 0x43, 0x5C, 0x9F, 0xF1, 0x99, 0xA9, 0xB7, 0xD6, 0xEA, + 0x12, 0x4C, 0x96, 0x7E, 0x87, 0x76, 0xD2, 0xAB, 0x02, 0x26, + 0xC0, 0x00, 0x02, 0x91, 0x0F, 0xB9, 0x72, 0xF7, 0x06, 0x0A, + 0x2A, 0x92, 0x77, 0x84, 0x0C, 0xBE, 0x44, 0x6D, 0x58, 0x6C, + 0xBC, 0xE0, 0x19, 0x8A, 0xFC, 0x4C, 0x93, 0xDD, 0xB7, 0xC5, + 0x45, 0xBF, 0x0A, 0x66, 0x29, 0xEF, 0x95, 0x78, 0x07, 0x6D, + 0xD0, 0xAA, 0x6C, 0x32, 0xE9, 0xF8, 0xEA, 0x1A, 0x74, 0x79, + 0x51, 0x39, 0x25, 0xCB, 0x00, 0x7C, 0xD0, 0xE7, 0xBB, 0xC4, + 0x09, 0xC2, 0xFC, 0x0F, 0xA2, 0x29, 0x45, 0x30, 0x3F, 0x89, + 0x76, 0x36, 0xF2, 0x92, 0xAF, 0xAF, 0x60, 0xC3, 0x93, 0x3E, + 0x55, 0x6B, 0x87, 0xAE, 0xBF, 0x6E, 0x2C, 0x54, 0xFD, 0xAF, + 0x74, 0x4F, 0x0F, 0xAA, 0xC7, 0x4F, 0x4C, 0x6B, 0x18, 0xFE, + 0xC6, 0x84, 0x27, 0xC0, 0x78, 0xD2, 0xD9, 0xE3, 0x7B, 0x41, + 0x1C, 0x1C, 0xBF, 0xDA, 0xDF, 0xCC, 0x49, 0x41, 0xC0, 0xC0, + 0x65, 0xE0, 0x8F, 0x44, 0x19, 0xE4, 0x78, 0xAD, 0xCD, 0xC5, + 0x5A, 0x9D, 0x11, 0x22, 0x43, 0xD7, 0x6E, 0x39, 0xD5, 0x2B, + 0xA7, 0x73, 0x3F, 0x99, 0xA8, 0xA3, 0x02, 0x73, 0x99, 0xF0, + 0x62, 0x87, 0xF4, 0x8B, 0xD7, 0x4F, 0x47, 0x9C, 0x18, 0x72, + 0x98, 0xB0, 0x33, 0x1B, 0x5E, 0x29, 0x04, 0xEA, 0x71, 0x6B, + 0x45, 0xCB, 0xC0, 0x9E, 0x15, 0x6E, 0x92, 0xDA, 0x50, 0xC3, + 0x58, 0x07, 0x29, 0x5E, 0xC5, 0xBD, 0x3B, 0xCE, 0xAC, 0x11, + 0xE5, 0xBB, 0x3D, 0x7E, 0xB8, 0xC3, 0x1F, 0x94, 0x9F, 0xD9, + 0x63, 0x35, 0x56, 0x23, 0x45, 0xAF, 0x23, 0xF0, 0x0B, 0x7B, + 0xE3, 0xFB, 0x81, 0x2E, 0xD3, 0x20, 0xE3, 0x1D, 0x97, 0x84, + 0xC1, 0x88, 0x77, 0x87, 0x3C, 0xAB, 0xE9, 0x1E, 0x69, 0x04, + 0x7D, 0x7B, 0xE6, 0x6B, 0xDB, 0xE9, 0xF2, 0xB6, 0x66, 0x10, + 0x0F, 0x4D, 0x57, 0x3F, 0xF5, 0x3E, 0xDA, 0xEA, 0xBC, 0xD4, + 0x5B, 0xA1, 0x20, 0xB0, 0x69, 0xC0, 0x8A, 0xA1, 0x28, 0xC0, + 0xEF, 0xFE, 0x2D, 0x0B, 0xF8, 0x06, 0x23, 0x4B, 0x1C, 0x77, + 0x0A, 0x10, 0xBF, 0xA7, 0xD9, 0x24, 0x9E, 0xA2, 0x1B, 0x90, + 0x6C, 0xFD, 0x85, 0x3A, 0xD3, 0xC6, 0x39, 0xA7, 0xA2, 0x28, + 0xC5, 0xC1, 0x2F, 0xD2, 0x28, 0xDC, 0x4F, 0x63, 0x0D, 0x6B, + 0x54, 0xB4, 0x27, 0x95, 0xC3, 0xC1, 0xE0, 0x08, 0xB0, 0x9D, + 0x7F, 0x6C, 0xFE, 0xF5, 0x65, 0xCE, 0x0E, 0xCE, 0x24, 0xCD, + 0xAE, 0x4C, 0x0F, 0x82, 0x54, 0x48, 0xAF, 0x37, 0xAE, 0x64, + 0x31, 0x07, 0xEE, 0xE6, 0x6B, 0xEF, 0xAF, 0x7F, 0x2A, 0x07, + 0x2E, 0xB6, 0xD0, 0xAC, 0x70, 0x87, 0x19, 0x9E, 0xD3, 0xFB, + 0x89, 0xBD, 0xBA, 0xFF, 0xB9, 0x92, 0x4B, 0x25, 0x65, 0xA3, + 0x09, 0xCD, 0xFE, 0x32, 0x19, 0xF3, 0xF4, 0x05, 0xA4, 0x13, + 0xDF, 0x65, 0xA3, 0x4C, 0xE8, 0xF3, 0x3C, 0xA3, 0x11, 0x95, + 0xEA, 0xC3, 0x34, 0xCA, 0xC6, 0xB9, 0x34, 0x6B, 0x53, 0x18, + 0xCC, 0xF9, 0x44, 0x28, 0x1E, 0x90, 0x74, 0xA6, 0xB1, 0x59, + 0x4D, 0xAE, 0x18, 0x53, 0x1D, 0x60, 0xCF, 0xCC, 0x15, 0xDA, + 0x4E, 0x2B, 0x6F, 0x8F, 0x4E, 0x39, 0x89, 0xE3, 0x67, 0x05, + 0xB5, 0x9C, 0x36, 0x5B, 0x3C, 0xA0, 0x9F, 0x46, 0x24, 0xE7, + 0x61, 0x42, 0x1C, 0xA7, 0xD7, 0x27, 0x5B, 0x5C, 0xF5, 0xFD, + 0x5F, 0x03, 0x79, 0x5F, 0x36, 0xA0, 0x85, 0x13, 0x40, 0x48, + 0x8C, 0x44, 0xB4, 0x64, 0x54, 0x83, 0xD8, 0xB6, 0x83, 0xB8, + 0x4E, 0x46, 0xCF, 0x98, 0xA5, 0x1C, 0xAA, 0xF0, 0x03, 0xD6, + 0x26, 0x80, 0x0F, 0x2A, 0xC5, 0xF4, 0xD1, 0x28, 0x0C, 0x5F, + 0xF8, 0x63, 0x8D, 0x68, 0x26, 0x3A, 0xE5, 0x5D, 0xAE, 0x17, + 0x64, 0xF2, 0x60, 0x73, 0x6D, 0xBD, 0x75, 0x90, 0xD2, 0x50, + 0xC4, 0x9A, 0x4C, 0x3E, 0x4B, 0xAE, 0x57, 0xBE, 0xCD, 0x42, + 0xC1, 0xA7, 0xCB, 0xAD, 0x73, 0x15, 0xF6, 0x69, 0x36, 0xB5, + 0xC3, 0x15, 0x1D, 0xC0, 0x09, 0x4B, 0x6B, 0x4F, 0xA3, 0xD2, + 0xAF, 0x9E, 0xF4, 0x9A, 0xC1, 0x5F, 0xF5, 0x0A, 0x95, 0x93, + 0xA4, 0x57, 0xA9, 0x61, 0x8D, 0x98, 0xB1, 0x19, 0xCC, 0x95, + 0x02, 0x26, 0xC0, 0x00, 0x02, 0x6E, 0x4C, 0x0F, 0xB4, 0x2D, + 0xBC, 0x3A, 0x51, 0xAE, 0x16, 0xBA, 0xEC, 0x72, 0x04, 0x3E, + 0x8D, 0x3D, 0x4E, 0x0E, 0x29, 0x4B, 0x6F, 0x00, 0xF5, 0xE2, + 0x12, 0x0B, 0xAC, 0x73, 0x7E, 0xA5, 0x12, 0x8D, 0x59, 0x45, + 0x73, 0xC8, 0xB9, 0x57, 0xCB, 0x78, 0xAD, 0xA3, 0xBD, 0x95, + 0x18, 0x04, 0x86, 0xB9, 0xFE, 0x9F, 0xBF, 0x67, 0x03, 0x08, + 0xA9, 0x91, 0xF3, 0x71, 0x1A, 0x6C, 0xD2, 0x74, 0xAA, 0x40, + 0xCC, 0x30, 0x7D, 0x0B, 0x78, 0xEF, 0xC7, 0xDC, 0x95, 0xC3, + 0x29, 0x5D, 0x18, 0xBC, 0x38, 0x7C, 0xFE, 0x65, 0xEF, 0x44, + 0xF0, 0x61, 0x91, 0x3E, 0x59, 0x75, 0x96, 0x84, 0x75, 0xD9, + 0xA2, 0x99, 0xDB, 0xFA, 0x9B, 0x7D, 0x09, 0x06, 0x8D, 0xDA, + 0xCC, 0xA1, 0x6E, 0x2E, 0xDB, 0x12, 0x83, 0xA6, 0x2E, 0x9C, + 0xC8, 0x5A, 0xE9, 0xBB, 0xC3, 0x70, 0x16, 0x0C, 0x6E, 0x2A, + 0xDA, 0xD0, 0xDF, 0xF4, 0xAF, 0xAA, 0x42, 0x0A, 0x16, 0x8C, + 0x73, 0xAA, 0xAD, 0x75, 0x7B, 0xCC, 0x29, 0xB5, 0x18, 0xB9, + 0x58, 0xBF, 0xDB, 0x91, 0x44, 0x74, 0x25, 0x3E, 0x54, 0xC3, + 0x2D, 0x8A, 0x2E, 0x85, 0xD0, 0x92, 0x02, 0xAE, 0xA1, 0xF9, + 0x70, 0xC5, 0x33, 0x49, 0x57, 0xE1, 0x90, 0x48, 0x54, 0x73, + 0x04, 0xAD, 0x1E, 0x41, 0xE8, 0xD7, 0x24, 0xFE, 0x85, 0x83, + 0x47, 0x0F, 0x9C, 0x33, 0xF9, 0xF5, 0x10, 0xAD, 0x42, 0xFA, + 0x7B, 0xE7, 0x1C, 0x35, 0xB3, 0x8D, 0x0E, 0x2E, 0xD7, 0xCB, + 0x40, 0x32, 0x9C, 0x64, 0x3A, 0x68, 0x33, 0xF3, 0xBE, 0xD9, + 0xCD, 0xC9, 0x73, 0xEB, 0x67, 0x6E, 0x52, 0x25, 0x2F, 0xD9, + 0x7A, 0x93, 0x8B, 0x1D, 0x9D, 0xB2, 0xAF, 0xF3, 0xEE, 0x6F, + 0xB5, 0xC7, 0x8F, 0xD5, 0x4F, 0xC9, 0x7C, 0xAC, 0x05, 0x9A, + 0x16, 0x82, 0x04, 0xC4, 0xF5, 0x47, 0xD7, 0x61, 0xC7, 0xBC, + 0x8D, 0x76, 0xA9, 0xFA, 0xA6, 0x17, 0x32, 0x3A, 0x2C, 0x93, + 0x4D, 0x0B, 0x57, 0x50, 0xF5, 0xD8, 0xE6, 0xB2, 0x52, 0x4F, + 0xE5, 0x1F, 0xDB, 0xA0, 0x17, 0xEF, 0x44, 0x9A, 0x8D, 0xBF, + 0x8D, 0xB4, 0x66, 0x11, 0xF2, 0xB1, 0x51, 0x50, 0xB4, 0xDE, + 0xE0, 0x30, 0x5B, 0x1F, 0x92, 0xAC, 0x30, 0x43, 0xB3, 0x1F, + 0x32, 0xDC, 0x84, 0x2F, 0x29, 0xE9, 0x78, 0xBC, 0x5A, 0xA2, + 0x9A, 0xA8, 0xFC, 0xE2, 0xB4, 0xE7, 0x8C, 0xCC, 0x65, 0xA9, + 0x37, 0x85, 0xD8, 0x0B, 0xB3, 0xA3, 0x4F, 0x28, 0xBE, 0x4D, + 0x45, 0x97, 0xAA, 0x2E, 0xEC, 0x6D, 0x4C, 0x9E, 0x19, 0x5F, + 0xD1, 0x47, 0x87, 0x8A, 0x76, 0xCF, 0x20, 0xCC, 0xDC, 0xC5, + 0x37, 0xDD, 0x45, 0xE8, 0x13, 0xFD, 0x72, 0x92, 0x7E, 0x97, + 0xA4, 0xA7, 0x58, 0xC1, 0x0E, 0xB6, 0x9E, 0x20, 0xCC, 0xD3, + 0x5F, 0x94, 0x25, 0xD3, 0xB8, 0xB0, 0x51, 0x82, 0x45, 0x64, + 0x4B, 0x6D, 0xCB, 0x9F, 0xC6, 0x5F, 0xDD, 0x1D, 0x1B, 0xB0, + 0x7D, 0xEB, 0xEC, 0x85, 0xB0, 0x90, 0x36, 0xE0, 0xE5, 0x5F, + 0x66, 0xA3, 0x69, 0x72, 0x2C, 0x35, 0x52, 0x45, 0x8A, 0xD9, + 0x31, 0xCB, 0xD9, 0xDD, 0xF0, 0x62, 0x6A, 0x4B, 0x47, 0xEF, + 0x13, 0xD7, 0x65, 0x17, 0xC4, 0xE9, 0xD1, 0xA3, 0xF4, 0x5E, + 0x17, 0x73, 0x4C, 0xA5, 0x81, 0xD7, 0xBD, 0xB3, 0x34, 0x98, + 0x61, 0x01, 0x50, 0x1D, 0x7D, 0x7A, 0x82, 0x38, 0x93, 0x9F, + 0x0A, 0xAC, 0x42, 0x5B, 0x10, 0x4C, 0x57, 0x10, 0x4A, 0x97, + 0xD3, 0xCC, 0x8F, 0x23, 0xD1, 0xA6, 0xCB, 0xAD, 0x47, 0x8F, + 0x41, 0x24, 0x2B, 0xEB, 0xB9, 0x0B, 0x71, 0x1C, 0x27, 0x31, + 0x91, 0x21, 0x77, 0xA2, 0x01, 0x2D, 0x6F, 0x9B, 0x99, 0x5F, + 0xAC, 0xD4, 0x8E, 0x1D, 0xBB, 0x2C, 0xA3, 0xA1, 0xA2, 0xC3, + 0x2A, 0xAD, 0x6B, 0xA4, 0x62, 0xAA, 0xAE, 0xEA, 0xEE, 0x10, + 0x30, 0xB3, 0x9E, 0x2A, 0x13, 0x09, 0xF8, 0xC4, 0x2B, 0x8C, + 0xE1, 0x51, 0x62, 0xE7, 0x5D, 0xE8, 0x00, 0x50, 0x46, 0x7E, + 0xC7, 0x9A, 0x3F, 0x21, 0xD9, 0x0C, 0xB3, 0xA7, 0x2E, 0x5F, + 0x4B, 0x42, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x12, 0xA7, 0x07, + 0x49, 0x33, 0x98, 0x05, 0x3D, 0xD0, 0x14, 0xD2, 0x03, 0xA9, + 0xA5, 0x66, 0x6B, 0x53, 0x43, 0x97, 0x83, 0x21, 0x8F, 0x46, + 0x67, 0x3C, 0x86, 0xDB, 0x7B, 0xBA, 0xD2, 0xC5, 0xB4, 0x09, + 0x0F, 0x2D, 0xD3, 0x4E, 0xD2, 0xB7, 0xFC, 0x75, 0x52, 0x16, + 0x8A, 0x56, 0x5A, 0xCC, 0xE6, 0xFE, 0x5C, 0xE8, 0xAE, 0x48, + 0x7F, 0x81, 0xF2, 0x46, 0x00, 0xE5, 0x53, 0xAF, 0xC7, 0x01, + 0x12, 0x9A, 0xF9, 0xDC, 0x96, 0x79, 0xC6, 0x61, 0xC6, 0xAC, + 0xCE, 0x0B, 0x6C, 0x9F, 0xFD, 0x16, 0xCA, 0xD1, 0xD6, 0xAB, + 0xE4, 0xCB, 0x64, 0x88, 0xF7, 0x17, 0x7F, 0xCD, 0xBB, 0x8F, + 0xF9, 0x5C, 0x75, 0x7C, 0x3D, 0xBE, 0x03, 0x68, 0x30, 0xA8, + 0xC7, 0x82, 0x62, 0xDD, 0x5A, 0x42, 0x3D, 0x8D, 0x02, 0xD1, + 0x68, 0xF2, 0x04, 0x0B, 0xFA, 0xC2, 0x23, 0xB9, 0x26, 0xAA, + 0x5F, 0x43, 0x7D, 0xE5, 0xD2, 0x97, 0xB8, 0xD5, 0x6F, 0xBE, + 0x56, 0xC6, 0xCA, 0xE7, 0x56, 0xDA, 0x14, 0x4A, 0xA6, 0x35, + 0x3F, 0xBF, 0xBC, 0x9D, 0xCD, 0x51, 0x55, 0x98, 0xAB, 0xC0, + 0x42, 0xC8, 0x7D, 0x67, 0xB3, 0xDD, 0x2B, 0x6B, 0xA0, 0x06, + 0x9F, 0x13, 0x79, 0xBC, 0xE2, 0xC8, 0x9E, 0xC3, 0xFF, 0x94, + 0x9E, 0x3D, 0x60, 0xAE, 0xB3, 0x28, 0x44, 0xC5, 0xE1, 0xD8, + 0x40, 0x7F, 0xC0, 0x8F, 0x93, 0xFC, 0xDA, 0xEC, 0x70, 0x14, + 0xB1, 0x07, 0xA1, 0x21, 0x6D, 0xA2, 0xA3, 0xEF, 0x80, 0xF1, + 0xC4, 0xCC, 0xA1, 0x77, 0xD9, 0xA3, 0xD9, 0x31, 0xFB, 0xC5, + 0xE5, 0xDE, 0xC1, 0xF2, 0x6F, 0xFC, 0x73, 0x35, 0xC4, 0x1D, + 0x2C, 0x15, 0x57, 0x64, 0x57, 0x4A, 0x0D, 0x4F, 0xCB, 0xD3, + 0x3E, 0x12, 0x82, 0x5C, 0xFC, 0xED, 0x7B, 0xA1, 0x3F, 0x72, + 0x1E, 0x6B, 0x12, 0x6A, 0xB9, 0x55, 0xD2, 0xC3, 0x04, 0x52, + 0x01, 0xBB, 0x54, 0x20, 0x0A, 0xA5, 0xDA, 0xDD, 0x2D, 0x56, + 0xF4, 0xD0, 0x08, 0x62, 0x1E, 0x68, 0x30, 0x40, 0x57, 0x8A, + 0xC2, 0xDD, 0xBF, 0x0D, 0x7B, 0x28, 0xE0, 0x82, 0x1A, 0x3F, + 0xDC, 0xEA, 0x07, 0xC4, 0x32, 0x74, 0x14, 0x18, 0x9C, 0x00, + 0x9C, 0x91, 0xC0, 0x7A, 0x0A, 0x18, 0x89, 0xAD, 0xA8, 0x3D, + 0x42, 0x21, 0x0F, 0x08, 0x8D, 0xA4, 0xD5, 0xA7, 0x08, 0x09, + 0x3C, 0x21, 0x7E, 0x4E, 0x17, 0xB9, 0x1A, 0x80, 0x22, 0x45, + 0x33, 0x43, 0x24, 0xDD, 0xC4, 0x66, 0xD2, 0xB4, 0x4E, 0x40, + 0xD5, 0x5F, 0xEA, 0x86, 0x9F, 0x8B, 0x41, 0x9D, 0xD0, 0x96, + 0xC9, 0x64, 0x32, 0x39, 0xA1, 0x89, 0x56, 0x7E, 0x1D, 0x22, + 0x08, 0x08, 0xB5, 0x60, 0x1F, 0x52, 0x41, 0xA4, 0x8F, 0xC0, + 0x52, 0x6B, 0xA7, 0xBB, 0x52, 0x0E, 0x96, 0xEE, 0x62, 0x62, + 0x1A, 0xCF, 0x4C, 0x65, 0x59, 0x32, 0x2D, 0x3C, 0x1D, 0x40, + 0x57, 0xB0, 0xE9, 0xF2, 0xBA, 0x04, 0xD2, 0xBE, 0x22, 0xA9, + 0x93, 0x8E, 0xC2, 0x32, 0x06, 0x20, 0xDC, 0x9F, 0xE5, 0xC2, + 0x57, 0xFC, 0xC5, 0xDE, 0xE7, 0xD3, 0xCA, 0xB6, 0xD8, 0x85, + 0xB2, 0xE1, 0xAD, 0x23, 0x47, 0x02, 0x3F, 0xD7, 0xBD, 0x51, + 0x2A, 0x6B, 0x33, 0x2D, 0x23, 0x6D, 0xD5, 0x72, 0x1F, 0xEC, + 0x8F, 0x7F, 0x1B, 0x22, 0x2D, 0x9E, 0x44, 0x58, 0xE0, 0xA3, + 0x50, 0x54, 0xCF, 0x6B, 0x5E, 0x59, 0x7A, 0xF0, 0xDA, 0x2E, + 0x9C, 0xC4, 0xD3, 0xD9, 0x83, 0x56, 0xBB, 0x09, 0x58, 0xFF, + 0x00, 0xDD, 0xDA, 0x57, 0x5C, 0xC3, 0xED, 0x10, 0x6E, 0xD6, + 0xD0, 0xF0, 0xB9, 0xD1, 0x2C, 0x1E, 0x4E, 0x33, 0xA7, 0x44, + 0x9C, 0x87, 0xB2, 0x91, 0x16, 0x2C, 0x44, 0x1E, 0x66, 0x79, + 0x06, 0x12, 0x26, 0xB6, 0x36, 0x1F, 0xBA, 0x56, 0x9F, 0xAB, + 0x64, 0x63, 0xE4, 0x90, 0x75, 0x72, 0xF9, 0x35, 0x77, 0x2B, + 0x38, 0xE5, 0x4F, 0x29, 0xF1, 0x4C, 0xD8, 0xBD, 0x20, 0x60, + 0x65, 0x26, 0x57, 0xCE, 0x52, 0x4B, 0x18, 0xD4, 0xDF, 0xCE, + 0xC0, 0x78, 0x60, 0x83, 0xD4, 0xDF, 0xE9, 0xA2, 0x61, 0x37, + 0x78, 0x7D, 0xEB, 0xE5, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x47, + 0xA5, 0x8E, 0xA4, 0x38, 0x2C, 0xDC, 0x61, 0xFB, 0xD1, 0x29, + 0xFD, 0x30, 0xA5, 0xEE, 0xB0, 0x2F, 0xF6, 0x53, 0x4B, 0x4E, + 0xE9, 0x26, 0x67, 0x28, 0xC0, 0x06, 0x59, 0x13, 0x88, 0xF8, + 0x9B, 0xE8, 0x6B, 0x9E, 0x5A, 0xCF, 0x8D, 0x8D, 0xE1, 0x80, + 0x1A, 0xE1, 0x4A, 0x59, 0x92, 0x6A, 0x57, 0x38, 0x79, 0x1E, + 0x5D, 0xA4, 0x35, 0xA5, 0xD3, 0x80, 0x41, 0x97, 0x69, 0xB7, + 0xDF, 0xE8, 0x07, 0xFA, 0xA6, 0x64, 0xFD, 0xB2, 0xD0, 0x66, + 0xB4, 0x35, 0x52, 0xCC, 0xC9, 0x82, 0xCF, 0xFA, 0xB3, 0xE0, + 0xE6, 0x96, 0x35, 0xEF, 0xD5, 0xF6, 0xA1, 0x0B, 0xAD, 0xE0, + 0x50, 0x7D, 0x9B, 0x36, 0x8D, 0xD2, 0x6E, 0x27, 0x14, 0x2D, + 0x6D, 0xCE, 0xC2, 0xF8, 0xDA, 0x64, 0xDC, 0xFD, 0xC8, 0x79, + 0x72, 0x00, 0xE3, 0xF9, 0x3F, 0x40, 0x0D, 0x0F, 0x40, 0x3A, + 0xE3, 0xFE, 0xEA, 0x93, 0x18, 0x7F, 0x2D, 0xFA, 0x7C, 0x6B, + 0xCB, 0x45, 0x8C, 0xD5, 0x8E, 0xE3, 0x95, 0x4C, 0xF9, 0x60, + 0x83, 0x8E, 0x07, 0xC0, 0x17, 0xE9, 0x6C, 0xAF, 0x2C, 0x08, + 0x04, 0xF5, 0x8B, 0xB7, 0xB8, 0x09, 0xAD, 0x91, 0x02, 0x9A, + 0x28, 0x25, 0xE7, 0x80, 0x5C, 0xCB, 0x69, 0xA0, 0xDA, 0x43, + 0x4F, 0x4C, 0x4A, 0xA1, 0xCB, 0x45, 0x0E, 0x2F, 0x87, 0x77, + 0x43, 0x7E, 0x0E, 0x42, 0xE7, 0x21, 0x2B, 0x73, 0x90, 0x21, + 0x7B, 0x9B, 0x87, 0xEC, 0x27, 0x76, 0xFF, 0x9F, 0xEB, 0x79, + 0xF9, 0x70, 0xE6, 0x73, 0x51, 0x4B, 0x8D, 0xE4, 0xB6, 0x76, + 0xFF, 0x23, 0x71, 0xD9, 0x87, 0x43, 0x29, 0xE4, 0xA0, 0xDE, + 0xB7, 0xCF, 0x92, 0x03, 0x84, 0x07, 0x17, 0xA1, 0xE6, 0x7B, + 0x43, 0x14, 0xA3, 0x30, 0xC0, 0x1B, 0x44, 0x91, 0xCF, 0x80, + 0x48, 0x92, 0x2B, 0x6D, 0x59, 0x8E, 0x63, 0x8C, 0xE8, 0xC3, + 0xA9, 0x04, 0x33, 0x3F, 0x75, 0x6A, 0x2B, 0x7B, 0xEC, 0x74, + 0x26, 0xAD, 0x34, 0x68, 0xB9, 0x9F, 0x63, 0xEE, 0xEA, 0x42, + 0x0D, 0xC7, 0x24, 0x7B, 0xD4, 0x5E, 0x5A, 0x91, 0xF1, 0x41, + 0x2E, 0x6B, 0x0D, 0xB9, 0x75, 0xCE, 0x51, 0x1E, 0x6E, 0xF2, + 0x6B, 0x9C, 0xD4, 0xBD, 0xAF, 0x54, 0x63, 0x1A, 0xA0, 0x29, + 0x65, 0x22, 0x04, 0x9D, 0xE2, 0x6F, 0x37, 0x4B, 0xC2, 0xC2, + 0x62, 0x1B, 0x94, 0xE0, 0xF9, 0xC8, 0xB0, 0x94, 0x43, 0x29, + 0x0D, 0x4F, 0x23, 0x4A, 0xBA, 0x83, 0x15, 0x97, 0x96, 0xC8, + 0x0A, 0x85, 0xD2, 0x80, 0x8B, 0x0C, 0x16, 0x57, 0x32, 0xCA, + 0xA4, 0xF6, 0x20, 0xB5, 0x49, 0x30, 0xCC, 0xD3, 0x1C, 0xAB, + 0xE0, 0xAE, 0x52, 0x7B, 0x71, 0x40, 0x80, 0xAC, 0x30, 0x78, + 0xEE, 0x5A, 0xD3, 0x82, 0x3F, 0x51, 0x34, 0xE8, 0x38, 0xD4, + 0x8D, 0x09, 0xEB, 0xDC, 0x9E, 0x82, 0xF7, 0xE2, 0xAA, 0xCD, + 0x2D, 0x17, 0x0C, 0x08, 0x22, 0xAF, 0xED, 0xE4, 0xC0, 0xC1, + 0xBB, 0x9C, 0x47, 0xC1, 0x23, 0x81, 0x03, 0x85, 0xDD, 0x00, + 0x5C, 0x4D, 0x7F, 0xF1, 0x02, 0xF8, 0xA9, 0xA1, 0x8E, 0xB1, + 0xCD, 0xFC, 0x6F, 0xC5, 0x0D, 0x37, 0xD9, 0x83, 0x15, 0x23, + 0x14, 0x03, 0x54, 0x37, 0xFC, 0xAC, 0xB6, 0xC8, 0x0A, 0x47, + 0x3F, 0x22, 0x6F, 0xD7, 0xFA, 0xBB, 0x8D, 0x17, 0xB2, 0x7C, + 0x0F, 0x65, 0xB4, 0xA2, 0x3A, 0x5F, 0x55, 0x34, 0xEC, 0xCA, + 0x89, 0xDD, 0xD4, 0x44, 0x77, 0x30, 0x9A, 0x20, 0x6A, 0x1A, + 0x9D, 0xBE, 0x39, 0x25, 0x2E, 0xE2, 0x0C, 0xDD, 0xE0, 0x50, + 0x8F, 0xD7, 0x38, 0x01, 0xB1, 0x25, 0xC1, 0xFD, 0x06, 0xD0, + 0x60, 0xC9, 0xEB, 0x1D, 0x77, 0x6D, 0xA2, 0x18, 0xB2, 0x0B, + 0x03, 0xE6, 0xF7, 0x07, 0x51, 0xFC, 0xAF, 0xE9, 0xD4, 0xFC, + 0x80, 0x69, 0x1C, 0xE1, 0x82, 0x96, 0x39, 0x37, 0xC1, 0xD3, + 0xB1, 0x81, 0x62, 0xB7, 0x20, 0x7F, 0xDF, 0xB7, 0x84, 0xD2, + 0xCC, 0xFB, 0x7E, 0x90, 0xBB, 0x05, 0x1B, 0x81, 0xA2, 0xE0, + 0x66, 0x11, 0x8A, 0x37, 0x93, 0x0F, 0x67, 0x81, 0x77, 0x03, + 0xA6, 0xE2, 0x52, 0xB6, 0x0F, 0x9A, 0x02, 0x26, 0xC0, 0x00, + 0x02, 0x1D, 0x9D, 0x63, 0xD2, 0x5B, 0xB0, 0x79, 0x8A, 0xF4, + 0x7F, 0x08, 0x9B, 0x5E, 0xAB, 0x6E, 0xD1, 0xCC, 0x2B, 0x7C, + 0xFF, 0x0D, 0x0E, 0xDD, 0x5F, 0xAA, 0x4C, 0x53, 0x45, 0x53, + 0x48, 0xCD, 0xCD, 0xF7, 0xBA, 0x5B, 0xB9, 0x84, 0xBB, 0x00, + 0xC2, 0xF0, 0xFB, 0x30, 0x5F, 0x04, 0x4E, 0x25, 0x4C, 0x06, + 0x03, 0x8D, 0xC5, 0x37, 0xA6, 0x9D, 0x1C, 0xD8, 0x13, 0xA7, + 0x96, 0xBE, 0xED, 0x22, 0xD7, 0xBA, 0x9F, 0x4C, 0x2E, 0xF9, + 0xD0, 0x5B, 0xBB, 0xF8, 0xB8, 0x0A, 0xF3, 0xEC, 0x31, 0x3F, + 0x84, 0x6E, 0x3A, 0x12, 0x8B, 0x6A, 0x2E, 0x28, 0xCE, 0xB8, + 0x1A, 0xC6, 0xE6, 0x4A, 0xD9, 0x74, 0x04, 0x24, 0xD8, 0x79, + 0x8D, 0x62, 0x0C, 0xB0, 0xAE, 0xAF, 0x67, 0xB4, 0xA1, 0x3D, + 0x93, 0x1D, 0xA2, 0x52, 0x98, 0x3F, 0x57, 0x73, 0x94, 0xB6, + 0x94, 0xBD, 0x0F, 0x42, 0x6A, 0x64, 0x7B, 0x17, 0xAC, 0x8D, + 0x46, 0xD0, 0xE4, 0x1B, 0x8C, 0x56, 0xB6, 0x47, 0xCB, 0xFD, + 0x56, 0x61, 0x6E, 0xA0, 0xBF, 0x6B, 0x8E, 0x68, 0x05, 0x55, + 0xA4, 0xB3, 0x8C, 0x76, 0x48, 0x73, 0x4C, 0x8D, 0x9D, 0xA2, + 0xA0, 0xA1, 0xFB, 0xD0, 0x33, 0x32, 0x39, 0xD2, 0x10, 0x1C, + 0x3C, 0x93, 0xC9, 0xCA, 0x6A, 0x6E, 0x7C, 0xB6, 0xF1, 0x03, + 0xF3, 0x45, 0x51, 0x05, 0x48, 0x30, 0xF0, 0xC6, 0x84, 0xFD, + 0x4E, 0x3B, 0x03, 0xE0, 0x62, 0xB8, 0x53, 0x55, 0xB6, 0xB8, + 0x02, 0x7C, 0xB9, 0xD5, 0x5C, 0xA2, 0x9B, 0x97, 0x8A, 0xA4, + 0xDF, 0x42, 0xEB, 0x91, 0x2C, 0x98, 0x82, 0xA9, 0xAE, 0xB0, + 0x13, 0xF6, 0x6E, 0x90, 0x42, 0xFE, 0xD3, 0xAA, 0x1E, 0xBA, + 0x69, 0xFC, 0xF8, 0x20, 0xEA, 0x5D, 0xA8, 0xFE, 0x64, 0x56, + 0x26, 0x4C, 0x6C, 0x69, 0x8F, 0xAC, 0x30, 0xCF, 0xAE, 0x8B, + 0xD5, 0x63, 0x10, 0xDD, 0xCE, 0x6E, 0x0C, 0xAB, 0x31, 0x46, + 0xDF, 0x8A, 0x33, 0x28, 0x8A, 0x1C, 0xEB, 0xBE, 0xAA, 0x71, + 0x44, 0x5C, 0x89, 0xEA, 0x00, 0x34, 0x23, 0xEB, 0x18, 0x83, + 0x7F, 0xB1, 0x9B, 0x3A, 0xBF, 0x08, 0x68, 0xB6, 0xC8, 0xE2, + 0xD8, 0x2D, 0x5E, 0xA2, 0x99, 0xB9, 0xBC, 0xF8, 0x31, 0xD1, + 0xFD, 0x31, 0xD4, 0x32, 0x05, 0x58, 0x5C, 0xFB, 0xCD, 0x8C, + 0xFF, 0x75, 0x99, 0x93, 0xC8, 0x0C, 0xE8, 0xE8, 0x60, 0x11, + 0xB8, 0x5F, 0x15, 0xB5, 0x89, 0x47, 0xE1, 0x1C, 0x23, 0x1B, + 0x8E, 0x56, 0x02, 0xD3, 0x5F, 0xBD, 0xA9, 0x9F, 0x67, 0x06, + 0xCA, 0x0C, 0x6E, 0x9C, 0xFB, 0x2D, 0x3A, 0xE3, 0xF6, 0x2C, + 0x72, 0x86, 0xCD, 0x68, 0xAC, 0x7B, 0x22, 0xA3, 0x01, 0x15, + 0x50, 0xB7, 0xA0, 0x05, 0x88, 0xD0, 0xDF, 0xBD, 0xDA, 0x3B, + 0xC4, 0xFF, 0x40, 0xA1, 0x46, 0x55, 0x28, 0xB3, 0x0C, 0x1E, + 0xF8, 0xE9, 0x0A, 0x39, 0xD1, 0x66, 0xDF, 0x5B, 0x2B, 0x2C, + 0xCA, 0xA5, 0x36, 0x32, 0x0D, 0xAC, 0x8E, 0xDF, 0x75, 0x9A, + 0xE5, 0x8B, 0xE5, 0x99, 0x6B, 0xD6, 0xB7, 0x83, 0x6B, 0xFE, + 0xEA, 0xC9, 0x71, 0xB5, 0xB9, 0xAE, 0xBE, 0x74, 0xB6, 0x58, + 0x28, 0x06, 0x23, 0xCF, 0x8D, 0x09, 0xBC, 0xE3, 0x18, 0x6C, + 0xFA, 0x53, 0x02, 0xE8, 0x3D, 0x44, 0xB3, 0xFE, 0xB3, 0x11, + 0x70, 0x10, 0xDF, 0xC3, 0x93, 0x64, 0x0F, 0x19, 0x35, 0xF0, + 0x82, 0x3A, 0xE3, 0x04, 0xE3, 0x1D, 0xFE, 0x52, 0xE8, 0x52, + 0xA1, 0x7B, 0x19, 0x23, 0x8E, 0x3F, 0x5D, 0x16, 0x60, 0xCB, + 0x13, 0x1A, 0x26, 0x6D, 0xDB, 0x82, 0xEB, 0x72, 0xEE, 0x76, + 0x77, 0x36, 0xEC, 0xEE, 0x09, 0x90, 0xAF, 0x35, 0x25, 0x5A, + 0x29, 0x61, 0x7A, 0xE6, 0x8C, 0x6C, 0x2A, 0x3B, 0x3B, 0xC4, + 0xC5, 0xD4, 0xCF, 0x41, 0x40, 0x04, 0xF3, 0x0F, 0x4B, 0x1B, + 0x99, 0x7D, 0xCF, 0x1F, 0xC5, 0xEB, 0xC5, 0xF5, 0xA1, 0x16, + 0xA2, 0x2A, 0x2E, 0xD5, 0x78, 0xC5, 0xAD, 0x9C, 0x48, 0x76, + 0xF2, 0x58, 0xDE, 0x68, 0x19, 0x58, 0x8C, 0xEA, 0xF5, 0xD0, + 0x54, 0x4F, 0x73, 0x60, 0x92, 0x71, 0x27, 0xF7, 0x02, 0x26, + 0xC0, 0x00, 0x02, 0x24, 0xC2, 0xE1, 0xD7, 0x77, 0x1A, 0x4D, + 0x5F, 0x7B, 0xC6, 0xC7, 0x52, 0x42, 0x9C, 0x26, 0xBE, 0x75, + 0x2E, 0x37, 0x00, 0xD8, 0x2C, 0xEF, 0x37, 0xC2, 0xF8, 0x88, + 0x89, 0xBA, 0x60, 0x35, 0xCE, 0xD5, 0xC4, 0x3D, 0x00, 0x6A, + 0xF1, 0xE1, 0x66, 0x4C, 0xFF, 0x79, 0xC7, 0xDF, 0x04, 0x99, + 0x02, 0xEB, 0x0E, 0x9D, 0xBE, 0x2C, 0x06, 0xB8, 0xE1, 0xC8, + 0xAE, 0xC4, 0xE8, 0xB7, 0xE7, 0x66, 0xEF, 0x01, 0x72, 0x45, + 0xB2, 0xBF, 0x69, 0xF7, 0xA2, 0x72, 0xEC, 0x91, 0x82, 0x9D, + 0xE5, 0x91, 0x9A, 0x6D, 0x4D, 0x0D, 0x29, 0x58, 0xE3, 0xA2, + 0xBB, 0x4F, 0x7B, 0xED, 0xA6, 0xEC, 0x0D, 0x91, 0xF6, 0xE7, + 0x68, 0x61, 0xDF, 0x8A, 0x1A, 0x5A, 0x2A, 0x21, 0x51, 0x80, + 0x31, 0xD5, 0xD6, 0xFB, 0xE5, 0x0D, 0x01, 0x49, 0x22, 0x05, + 0xEE, 0xA2, 0x7A, 0xF6, 0x6C, 0xCD, 0x9D, 0x95, 0x79, 0x7E, + 0x9D, 0x22, 0x91, 0x59, 0x31, 0x80, 0x55, 0xC9, 0x66, 0xC8, + 0x33, 0x36, 0x56, 0x65, 0xCC, 0x26, 0x88, 0xE7, 0xC0, 0x01, + 0xF4, 0x22, 0xF9, 0xE6, 0xF1, 0x18, 0x69, 0xAB, 0x93, 0x80, + 0x95, 0xBF, 0xA4, 0xB7, 0x7F, 0x56, 0x7D, 0xC0, 0xEE, 0xA7, + 0x01, 0x5B, 0x9B, 0xA6, 0x80, 0x5A, 0x17, 0x31, 0xC8, 0x93, + 0xF6, 0x6F, 0xFD, 0x27, 0x9A, 0x09, 0xB8, 0x48, 0x04, 0xD5, + 0x1F, 0xBB, 0x8B, 0xED, 0xB7, 0x08, 0x43, 0xBF, 0x82, 0xB1, + 0xAF, 0xD9, 0x35, 0x03, 0xE8, 0x36, 0xB4, 0xCD, 0x74, 0x74, + 0x30, 0x85, 0x73, 0x1F, 0x51, 0xED, 0xA5, 0xFD, 0x64, 0xFC, + 0xF1, 0x22, 0x21, 0x36, 0x3C, 0x5E, 0x46, 0x74, 0x9D, 0x94, + 0x2C, 0x0F, 0xDF, 0x2B, 0x6E, 0x5E, 0xA8, 0x7C, 0x80, 0xA4, + 0x4C, 0xE4, 0x1A, 0xE2, 0x80, 0x29, 0x5F, 0x85, 0x76, 0x95, + 0xD0, 0x2D, 0x26, 0x50, 0xB2, 0x14, 0x37, 0xA3, 0x3A, 0x4E, + 0xB9, 0x68, 0xCB, 0x1D, 0x9A, 0x9B, 0x33, 0xD0, 0x3D, 0x1B, + 0x0F, 0x3F, 0xA2, 0x95, 0xE0, 0x80, 0xA1, 0x39, 0x03, 0x14, + 0x5F, 0x21, 0x27, 0x54, 0xB5, 0x4D, 0x1F, 0x7A, 0x9A, 0x1E, + 0xB1, 0xC9, 0x63, 0xBE, 0xEC, 0x0C, 0xC1, 0x16, 0x80, 0x0F, + 0xFD, 0x3B, 0x3F, 0xFD, 0x97, 0xF8, 0x4F, 0xD9, 0xFE, 0xC7, + 0x6A, 0xE5, 0x40, 0x5B, 0xB8, 0x50, 0xA8, 0x94, 0x6F, 0x9F, + 0xD8, 0x23, 0xE8, 0xBC, 0x16, 0x9B, 0xF8, 0xC5, 0x0C, 0x48, + 0x28, 0x1B, 0x51, 0x8B, 0x1C, 0x9F, 0x37, 0x97, 0x6B, 0x0B, + 0x1C, 0x2B, 0xCF, 0x7F, 0x9E, 0xC4, 0x54, 0x8F, 0x4D, 0xBF, + 0x43, 0xBB, 0x40, 0x20, 0x79, 0x1F, 0x29, 0xF2, 0x43, 0x65, + 0x0D, 0xC8, 0x16, 0xAC, 0xE4, 0xF3, 0x82, 0x67, 0x01, 0xD9, + 0x19, 0x80, 0xAD, 0x16, 0x1F, 0xF6, 0xFA, 0xD3, 0xD8, 0x74, + 0x6F, 0xE5, 0x00, 0x8E, 0x77, 0x95, 0x51, 0x83, 0xD4, 0xF2, + 0x8B, 0x79, 0x2D, 0xBA, 0xB1, 0x10, 0x0C, 0x0F, 0xCC, 0x7D, + 0x24, 0x7A, 0xF5, 0xDF, 0x54, 0x54, 0xC0, 0xAF, 0x80, 0x3D, + 0x7E, 0x9C, 0x8F, 0x27, 0xA7, 0x0A, 0xE4, 0x8C, 0xB7, 0x5C, + 0x61, 0xF4, 0xAD, 0xB3, 0xD8, 0xA9, 0x1B, 0xEC, 0x13, 0xCB, + 0xD8, 0xD3, 0x81, 0xBA, 0x9D, 0xCA, 0xD9, 0xAE, 0xC4, 0x43, + 0x69, 0xF4, 0xDE, 0xF9, 0xE0, 0xFE, 0x5D, 0x53, 0x6D, 0xDA, + 0x5F, 0xED, 0x5F, 0x30, 0x81, 0x2C, 0xDE, 0x92, 0x04, 0xDE, + 0x94, 0xBB, 0x45, 0xAF, 0x14, 0x84, 0xC9, 0xE3, 0xBD, 0xBD, + 0x7F, 0x52, 0xE9, 0x6B, 0x34, 0xCA, 0x06, 0x3A, 0xE1, 0x79, + 0x22, 0x3C, 0xA8, 0x34, 0xED, 0x7E, 0x26, 0x18, 0x84, 0xDB, + 0x92, 0x48, 0xFD, 0xD6, 0x82, 0x04, 0x1D, 0x82, 0x1A, 0xA6, + 0x28, 0x74, 0x31, 0xA5, 0x74, 0x1F, 0xD9, 0x0F, 0xF2, 0xC8, + 0x4C, 0x38, 0x8F, 0xAF, 0x2A, 0xE0, 0x5F, 0xD6, 0xA4, 0x1C, + 0xE3, 0xF8, 0x70, 0xD5, 0x4C, 0xF8, 0x3C, 0x92, 0x0A, 0x01, + 0xEF, 0xB7, 0xEA, 0x57, 0xA5, 0x88, 0x4C, 0x10, 0x68, 0x99, + 0xC8, 0x4F, 0x1D, 0x67, 0x8E, 0x43, 0x7D, 0x3D, 0x5E, 0x20, + 0x02, 0x26, 0xC0, 0x00, 0x02, 0x68, 0x4F, 0x5F, 0x8D, 0xC4, + 0x7F, 0x74, 0xCD, 0xFE, 0xFB, 0x21, 0x22, 0x03, 0x06, 0xFA, + 0x2E, 0x4C, 0xFF, 0x35, 0xBB, 0x9E, 0x93, 0x44, 0x35, 0x8A, + 0xFF, 0x97, 0x39, 0x36, 0x8D, 0x53, 0x4D, 0xFA, 0x04, 0xA8, + 0x98, 0x13, 0x9C, 0xAA, 0x87, 0x0D, 0x8B, 0x50, 0x0D, 0x9C, + 0xB1, 0xAC, 0x4C, 0x59, 0x9B, 0xA2, 0xE4, 0x4C, 0xFC, 0x46, + 0xC5, 0xA6, 0x00, 0x4A, 0xA8, 0xD3, 0x24, 0x40, 0x9E, 0x48, + 0x8F, 0xC0, 0x8C, 0x0E, 0x16, 0x02, 0x3C, 0xF5, 0x12, 0x3D, + 0x97, 0xCE, 0xDE, 0x11, 0xBE, 0x46, 0xE8, 0x8F, 0x15, 0x3B, + 0xB3, 0x1D, 0x74, 0xCB, 0xEE, 0x77, 0x2D, 0xEB, 0xAD, 0x87, + 0x39, 0x85, 0xD7, 0xBC, 0x38, 0x87, 0x2A, 0x0B, 0xB5, 0xB0, + 0xD1, 0x09, 0x7D, 0x12, 0xC6, 0x4D, 0x9A, 0xF8, 0x00, 0xC5, + 0xA2, 0xF9, 0x9A, 0xFF, 0x30, 0x5D, 0x6E, 0x79, 0xD7, 0xBA, + 0xB3, 0xCC, 0x2A, 0x43, 0x61, 0xAC, 0x38, 0x99, 0x10, 0xDF, + 0x60, 0x94, 0x7B, 0x49, 0xD9, 0xC2, 0x4C, 0x6D, 0x3F, 0xD7, + 0x38, 0x85, 0xE7, 0x91, 0x26, 0x9E, 0x7F, 0x7E, 0xA4, 0x91, + 0x9B, 0x92, 0x02, 0xC1, 0x1F, 0xAF, 0x5C, 0x6B, 0xBA, 0x27, + 0xAD, 0x33, 0xCC, 0xE6, 0x20, 0x23, 0x61, 0xBE, 0x4A, 0xDA, + 0x28, 0x63, 0xB2, 0xE2, 0xAC, 0xA9, 0x51, 0x50, 0x9A, 0xAB, + 0xCA, 0x8C, 0x5C, 0xF3, 0x0A, 0x44, 0x03, 0xA9, 0x94, 0x92, + 0x1D, 0xC5, 0xB2, 0x09, 0xF3, 0x0E, 0xB3, 0x6A, 0x1D, 0x72, + 0xDC, 0x71, 0x4A, 0xAE, 0x4E, 0x0B, 0x1B, 0xCF, 0xF3, 0xCF, + 0x4B, 0x38, 0xD1, 0xCA, 0x27, 0xC2, 0x6A, 0x41, 0x0F, 0x3A, + 0x1D, 0xCD, 0x3E, 0xB1, 0x1A, 0xF7, 0x16, 0x48, 0x4A, 0xAA, + 0xA7, 0x28, 0x16, 0x07, 0x9B, 0xE0, 0x41, 0x99, 0xF1, 0x47, + 0x8C, 0x48, 0x6C, 0x2D, 0x93, 0x9E, 0x47, 0x2B, 0x9A, 0x96, + 0x20, 0x44, 0xF4, 0x2A, 0xCB, 0xB0, 0xDA, 0xBD, 0x17, 0x38, + 0xCB, 0x45, 0x9F, 0x21, 0xA8, 0x93, 0x26, 0x67, 0x51, 0x36, + 0x6F, 0x05, 0x4A, 0x08, 0x72, 0xFB, 0xA3, 0x98, 0xBF, 0x9E, + 0x39, 0xEC, 0xAF, 0xDA, 0x8A, 0xFD, 0xC1, 0xB2, 0xC4, 0x4D, + 0xFE, 0xCD, 0xBD, 0x7F, 0xF8, 0xCE, 0x4F, 0x7E, 0x4E, 0xBA, + 0xD1, 0x87, 0x3E, 0x5F, 0x77, 0xA2, 0x96, 0x3E, 0x8B, 0x15, + 0xDE, 0xE7, 0xBF, 0x7F, 0x97, 0x0F, 0xE1, 0xE7, 0x2F, 0x58, + 0x5D, 0xEF, 0x56, 0x39, 0x66, 0x63, 0x61, 0x94, 0x3D, 0x31, + 0xC8, 0x8D, 0xA8, 0xAC, 0xB5, 0x4C, 0x20, 0x1A, 0xD4, 0x18, + 0x34, 0x61, 0xA2, 0x4F, 0x65, 0xB3, 0x12, 0xFE, 0xA9, 0x02, + 0xCC, 0x47, 0x8F, 0x1C, 0x39, 0xFD, 0xDB, 0x08, 0x62, 0xFD, + 0x74, 0x8D, 0xF9, 0xAA, 0x34, 0xCA, 0x20, 0x67, 0xE8, 0xBC, + 0xAB, 0xED, 0x8C, 0x09, 0xC1, 0xA1, 0xE2, 0x3A, 0x41, 0xB7, + 0x1D, 0x82, 0x99, 0xAA, 0x79, 0x93, 0xB5, 0x1D, 0x6A, 0xE8, + 0xFC, 0x31, 0xBF, 0x67, 0xD8, 0xE9, 0x36, 0xD4, 0xBF, 0x9E, + 0xBF, 0xAB, 0x13, 0x20, 0xE3, 0x01, 0x29, 0x60, 0x28, 0x19, + 0xD2, 0x0E, 0xBC, 0x21, 0x3E, 0xD6, 0xC0, 0xC3, 0xDD, 0x64, + 0xFC, 0x98, 0x45, 0x26, 0x9B, 0x5C, 0xCB, 0xE2, 0x76, 0x0A, + 0x0D, 0x13, 0x1A, 0x7F, 0xEF, 0xE2, 0x44, 0xA3, 0xD8, 0xCE, + 0xD6, 0x0E, 0x5A, 0xA8, 0x40, 0x7B, 0x9E, 0xA0, 0xBE, 0xD6, + 0x63, 0x56, 0x77, 0x57, 0x69, 0x2C, 0xF8, 0xB6, 0x8D, 0x08, + 0xF3, 0x80, 0xA1, 0x2F, 0x53, 0xE2, 0x2F, 0xFD, 0xE6, 0x86, + 0x91, 0x83, 0x12, 0x7E, 0x73, 0xCF, 0xC8, 0x12, 0x58, 0xCD, + 0x9B, 0x30, 0x2C, 0x1E, 0xB8, 0x1E, 0xA3, 0x66, 0x27, 0xE9, + 0x33, 0xB2, 0x57, 0x9B, 0xF7, 0xFC, 0x04, 0xE1, 0xDF, 0xA4, + 0xC5, 0x7A, 0x39, 0xCE, 0xDF, 0xEB, 0x03, 0x89, 0x37, 0xFB, + 0xB0, 0x17, 0x12, 0x55, 0x52, 0x60, 0x25, 0xD1, 0xA6, 0x54, + 0xED, 0xD2, 0xBA, 0xE9, 0x66, 0x5A, 0xCA, 0xE3, 0x71, 0xF8, + 0xE7, 0x35, 0x1C, 0xAC, 0x00, 0x2C, 0xBD, 0x52, 0x6F, 0xE0, + 0x96, 0x91, 0x02, 0x26, 0xC0, 0x00, 0x02, 0x02, 0xB1, 0x96, + 0x3E, 0x04, 0x9B, 0x7A, 0x13, 0x3F, 0xA3, 0x05, 0x16, 0xBF, + 0x79, 0xE5, 0x67, 0x77, 0x23, 0x1E, 0x4D, 0x4C, 0x26, 0x7C, + 0x9D, 0x3E, 0xF5, 0x37, 0x49, 0xAC, 0x5C, 0xA7, 0x9F, 0xD7, + 0x8B, 0x61, 0x4B, 0x21, 0xEC, 0x27, 0x9A, 0x62, 0x75, 0xD1, + 0xCB, 0xEB, 0x58, 0x98, 0x84, 0xD1, 0xD9, 0xD8, 0x00, 0x0E, + 0x38, 0xCB, 0x40, 0xE9, 0xC0, 0x87, 0x62, 0x6D, 0xD6, 0xBE, + 0x5E, 0x47, 0x40, 0xCE, 0x39, 0xD2, 0x28, 0xFF, 0x32, 0x08, + 0xFB, 0xF1, 0x86, 0xEF, 0xF1, 0x1F, 0xC7, 0x28, 0xE0, 0x2A, + 0x9B, 0xAA, 0xA7, 0xEC, 0xBA, 0x63, 0x27, 0x98, 0xCC, 0x4C, + 0x35, 0x48, 0xE2, 0x83, 0xE2, 0xE4, 0x7E, 0xCF, 0xF2, 0x38, + 0xED, 0x1C, 0xE7, 0x17, 0xCB, 0xAC, 0xCC, 0xDA, 0xF5, 0x3B, + 0xD3, 0xC5, 0xFE, 0xB5, 0x04, 0x3A, 0xFC, 0xF7, 0x66, 0x66, + 0x89, 0xB5, 0xAD, 0x1C, 0x18, 0xFE, 0x63, 0xF6, 0x9E, 0x8D, + 0x73, 0xDC, 0x9D, 0x54, 0xDD, 0x02, 0x3B, 0x1D, 0x3F, 0x3D, + 0xD1, 0x4C, 0xCB, 0x3C, 0x09, 0x8E, 0x5A, 0x06, 0x5C, 0x03, + 0x59, 0xF4, 0x7B, 0xF6, 0x39, 0x02, 0x2B, 0xDC, 0x76, 0x82, + 0x2A, 0x33, 0x34, 0x34, 0x57, 0x9F, 0xC8, 0xF0, 0xF0, 0x14, + 0x29, 0x0C, 0x6E, 0x92, 0x36, 0x56, 0x3B, 0xA6, 0x68, 0xF0, + 0x3B, 0x3C, 0xA7, 0x8F, 0x60, 0x85, 0x5D, 0xAD, 0x14, 0xBF, + 0xA7, 0x8B, 0x8E, 0xED, 0x20, 0x0A, 0x64, 0xB2, 0x05, 0xF9, + 0x59, 0x45, 0xC0, 0x97, 0x2D, 0x0D, 0x3A, 0x77, 0xC0, 0xBD, + 0xA2, 0x9F, 0xD4, 0x21, 0xA5, 0x23, 0x7D, 0x1A, 0xE2, 0x4D, + 0x72, 0x44, 0xF6, 0x3E, 0x2A, 0x12, 0xF6, 0xB3, 0xDD, 0x15, + 0x63, 0xCC, 0x7A, 0x5E, 0x60, 0xC2, 0xB0, 0xEE, 0x2C, 0x35, + 0x08, 0x35, 0xE8, 0xA8, 0x08, 0x86, 0xA6, 0xC9, 0xA2, 0x84, + 0xBF, 0x90, 0x14, 0x92, 0x95, 0x6A, 0x08, 0x39, 0x30, 0xB2, + 0x94, 0x3E, 0x0D, 0xE9, 0x3B, 0x28, 0xC7, 0x89, 0x6F, 0xFE, + 0xB9, 0x83, 0x00, 0xE9, 0x9A, 0xA5, 0x47, 0x82, 0xEB, 0xAE, + 0xA8, 0x2F, 0xD4, 0x89, 0xDB, 0x00, 0xC0, 0xA3, 0xE8, 0x79, + 0xC8, 0x5D, 0x90, 0xA5, 0x5F, 0xB6, 0x11, 0x42, 0x99, 0x1E, + 0x7C, 0x9C, 0xB5, 0xA6, 0x90, 0x85, 0xE8, 0xED, 0x14, 0x55, + 0x99, 0x13, 0x10, 0xFD, 0x94, 0xF6, 0x48, 0x86, 0x26, 0x5A, + 0x36, 0x15, 0x53, 0xE5, 0x02, 0xD4, 0x46, 0xA4, 0x3B, 0x97, + 0xB0, 0x65, 0x25, 0xD2, 0x52, 0x08, 0x7D, 0x12, 0x28, 0xC3, + 0x0A, 0x26, 0xF1, 0xCD, 0x10, 0x90, 0xB0, 0x61, 0x6C, 0x31, + 0xEE, 0xC4, 0x79, 0x86, 0x36, 0x94, 0x38, 0x26, 0xD8, 0xA0, + 0x44, 0x90, 0x38, 0x08, 0xCA, 0xCA, 0x8A, 0xEF, 0x6D, 0xFD, + 0xBF, 0xAC, 0xE2, 0x87, 0xC4, 0xD3, 0xB6, 0x68, 0xA5, 0x02, + 0x05, 0xB4, 0xC1, 0xA3, 0x38, 0x60, 0x1B, 0x7F, 0xA5, 0xF2, + 0xA8, 0x17, 0xB0, 0x17, 0x88, 0x0F, 0xE8, 0xE1, 0x25, 0x9C, + 0x4E, 0x82, 0x37, 0x0C, 0xC3, 0xFF, 0x6D, 0x99, 0x9F, 0xB3, + 0x8B, 0x92, 0x2B, 0x96, 0x6B, 0xD3, 0xDF, 0x3F, 0x45, 0xD8, + 0xA2, 0x46, 0xAA, 0x06, 0x7D, 0xA7, 0x57, 0xEC, 0x87, 0x99, + 0xFA, 0x2F, 0x93, 0x6D, 0x65, 0x77, 0xD3, 0x72, 0x2B, 0x3D, + 0xFC, 0x9D, 0x0D, 0x2C, 0x88, 0x75, 0x37, 0x4B, 0x18, 0xA9, + 0x2D, 0xA9, 0xD6, 0xE3, 0x75, 0xFA, 0x29, 0xCE, 0x91, 0x51, + 0x74, 0xF9, 0x71, 0xFB, 0x0B, 0x1F, 0x24, 0x3D, 0xA8, 0xF3, + 0x56, 0x67, 0x7A, 0x13, 0xAA, 0xFF, 0x1C, 0x6D, 0xDD, 0x0F, + 0x14, 0xBC, 0x34, 0x35, 0xE0, 0xAF, 0x7A, 0x55, 0x8C, 0x9A, + 0xE0, 0xA6, 0x35, 0x1F, 0xAB, 0xC3, 0xF7, 0x14, 0x7E, 0xFF, + 0x13, 0x64, 0xAF, 0x1C, 0x11, 0x68, 0x25, 0x4D, 0x07, 0x05, + 0x3F, 0x76, 0x61, 0x29, 0x32, 0xB5, 0xEF, 0xF7, 0x7E, 0xE8, + 0x5C, 0xE2, 0xAA, 0x17, 0x3F, 0x5C, 0x48, 0xFA, 0x05, 0xB0, + 0xDF, 0x1F, 0x2B, 0x9B, 0x25, 0xAA, 0xA8, 0x1F, 0x80, 0xF5, + 0xE5, 0x9C, 0xC2, 0xF5, 0x02, 0x06, 0xC0, 0x00, 0x02, 0x96, + 0xA3, 0xD9, 0x49, 0x25, 0x73, 0x8B, 0x32, 0xB3, 0xD6, 0x68, + 0x6E, 0x3F, 0xDE, 0x58, 0xCB, 0xA8, 0x00, 0x34, 0xB2, 0x7D, + 0x5A, 0x88, 0x7F, 0x1B, 0x3A, 0xA7, 0xD2, 0x56, 0x5B, 0x20, + 0x6F, 0x6B, 0x43, 0x58, 0xC9, 0x48, 0x1F, 0x76, 0xE3, 0xA5, + 0x79, 0x0D, 0xD3, 0xC7, 0xBB, 0x76, 0xE8, 0xC2, 0xD5, 0x77, + 0x2B, 0x39, 0x93, 0x7F, 0x9B, 0x33, 0xB3, 0x0C, 0x12, 0x50, + 0x8A, 0x95, 0xB3, 0x27, 0xCB, 0x49, 0xDB, 0x3C, 0x6A, 0xB9, + 0x06, 0xD8, 0x31, 0x8E, 0x14, 0x6A, 0x3F, 0x5B, 0x03, 0x98, + 0xD8, 0x5C, 0xCA, 0x46, 0x14, 0xDA, 0xAB, 0x51, 0xDF, 0x72, + 0x3A, 0xAD, 0x8E, 0xDA, 0x9A, 0x44, 0x0E, 0x4C, 0xB0, 0x92, + 0xF6, 0x6A, 0x0E, 0xC8, 0x37, 0x0F, 0x93, 0x73, 0xB0, 0xB5, + 0x11, 0x12, 0x3F, 0xCF, 0x29, 0x50, 0x6B, 0xD9, 0x22, 0x2C, + 0x76, 0x71, 0x07, 0xBC, 0x00, 0x10, 0xB8, 0x54, 0x6A, 0x9A, + 0x59, 0x82, 0x4E, 0xE9, 0x02, 0x8B, 0x9C, 0xC9, 0x4B, 0xD3, + 0x7F, 0xAD, 0xA5, 0xF9, 0x7C, 0xB4, 0x00, 0xB4, 0x5A, 0xAF, + 0x23, 0x12, 0xF2, 0x5B, 0xB9, 0x2C, 0xFD, 0x73, 0xB9, 0xFC, + 0x4B, 0x4F, 0xAF, 0xD2, 0x80, 0xC2, 0xF7, 0x15, 0xEC, 0xE1, + 0x4B, 0xEF, 0xA3, 0x99, 0x59, 0x0C, 0xD5, 0x2F, 0x98, 0xF5, + 0x38, 0xD2, 0xFC, 0xF3, 0x82, 0xA7, 0xE0, 0x15, 0x35, 0x27, + 0xCD, 0xCF, 0xCE, 0xA4, 0x65, 0x92, 0x1E, 0x6C, 0x25, 0x8F, + 0xB7, 0x78, 0x15, 0x5B, 0x7A, 0x9D, 0xB0, 0xEC, 0xDE, 0x0A, + 0xF5, 0x0B, 0xCD, 0xD4, 0xF6, 0xC4, 0xD5, 0xA9, 0xC1, 0x4E, + 0xE0, 0xA2, 0x8B, 0xC4, 0x43, 0x97, 0xAC, 0xC9, 0x41, 0xF2, + 0x5A, 0x36, 0xD1, 0xD6, 0x7E, 0xC2, 0xD3, 0x06, 0xCB, 0x78, + 0x47, 0x78, 0x05, 0x35, 0x61, 0xE6, 0xD4, 0xDC, 0x65, 0x75, + 0x63, 0x5B, 0x71, 0xD7, 0x3C, 0x27, 0x9B, 0x26, 0x70, 0xAB, + 0x4D, 0x97, 0xE5, 0x83, 0x7C, 0xEB, 0x5B, 0x8F, 0xD6, 0xBC, + 0x84, 0x9D, 0xF8, 0x08, 0x65, 0x10, 0x6E, 0x48, 0xBE, 0xD2, + 0x86, 0xC0, 0xEB, 0x08, 0x27, 0x38, 0xF8, 0x6E, 0x5D, 0xBA, + 0x5B, 0xC6, 0x78, 0xED, 0xB1, 0x8D, 0x57, 0xFC, 0xA4, 0xDD, + 0xF3, 0xDF, 0xB9, 0x36, 0x92, 0xB8, 0x00, 0x06, 0x5F, 0xAD, + 0x04, 0xE3, 0x8D, 0x64, 0x64, 0x7A, 0xE0, 0x57, 0x4C, 0x68, + 0x56, 0xDC, 0x1F, 0x93, 0xA5, 0xD7, 0xEE, 0xFC, 0x8A, 0xB9, + 0x26, 0x99, 0xC5, 0x1A, 0x63, 0xD6, 0x9B, 0xBC, 0xA2, 0xF3, + 0xE1, 0x84, 0xDC, 0xFB, 0x0C, 0x4F, 0xB4, 0x0D, 0x75, 0x8B, + 0xDD, 0xB6, 0x76, 0x2C, 0x33, 0x46, 0xDD, 0x94, 0xE0, 0x8C, + 0x37, 0x03, 0x14, 0x44, 0xC2, 0x0F, 0x6C, 0x03, 0xA6, 0x39, + 0x1E, 0xB5, 0x00, 0x83, 0xC6, 0x59, 0x81, 0xD6, 0x11, 0x3A, + 0x22, 0x6F, 0x74, 0x1C, 0x8B, 0x4C, 0xF3, 0x1C, 0x59, 0x2F, + 0x19, 0x18, 0xB5, 0x20, 0x24, 0x9C, 0x14, 0x45, 0x7E, 0x98, + 0xFB, 0x71, 0xC4, 0xCC, 0x19, 0x99, 0x28, 0x9E, 0x63, 0xC2, + 0xD6, 0x0D, 0x47, 0x2A, 0x3B, 0x36, 0xB7, 0x8C, 0xF1, 0x98, + 0x33, 0x96, 0x9D, 0x09, 0x99, 0x74, 0xE3, 0x41, 0xCD, 0x67, + 0xCE, 0x11, 0xBA, 0x35, 0xE3, 0x44, 0x3D, 0xE0, 0xB9, 0x53, + 0x79, 0x58, 0x0F, 0xC5, 0x98, 0xCC, 0xAB, 0xF8, 0x37, 0x5C, + 0x96, 0xCE, 0xB5, 0xDA, 0xB5, 0x05, 0x79, 0xD6, 0x96, 0x82, + 0xCA, 0x3F, 0x2C, 0x8A, 0x44, 0xCE, 0xCE, 0x99, 0xA2, 0x77, + 0x9E, 0xE0, 0xFE, 0x58, 0x97, 0x5A, 0xDA, 0x8B, 0xB8, 0x0A, + 0xA2, 0x3F, 0x26, 0x00, 0x5C, 0xAC, 0xD8, 0x33, 0x95, 0xBF, + 0x43, 0x0D, 0x09, 0xB5, 0x9A, 0x89, 0x4C, 0x46, 0x83, 0xAF, + 0xD1, 0xD3, 0x61, 0x33, 0xA1, 0x19, 0xD3, 0xD6, 0x81, 0xB0, + 0xDA, 0x55, 0x4B, 0xD3, +}; + +const uint32_t gphDnldNfc_DlSeqSz = sizeof(gphDnldNfc_DlSequence); diff --git a/nfc/recovery_seq.c b/nfc/recovery_seq.c new file mode 100644 index 0000000000..5842284e8e --- /dev/null +++ b/nfc/recovery_seq.c @@ -0,0 +1,281 @@ +/****************************************************************************** + * Copyright (C) 2021 NXP + * * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + ******************************************************************************/ +#if defined(RECOVERY_ENABLE) +#include "recovery_seq.h" + +recovery_info_t g_recovery_info; +recovery_frame_t g_recovery_frame; + +extern const uint32_t gphDnldNfc_DlSeqSz; /* Recovery user buffer size */ +extern const uint8_t gphDnldNfc_DlSequence[]; /* Recovery user buffer */ + +/** @brief Function to calculate crc value. + * + * @param pbuffer: input buffer for crc calculation. + * dwLength: length of input buffer + * @return calculated uint16_t crc valueof input buffer. + */ +static uint16_t calcCrc16(uint8_t* pbuffer, uint32_t dwLength) { + uint32_t i = 0; + uint16_t crc_new = 0; + uint16_t crc = DL_INVALID_CRC_VALUE; + if(NULL == pbuffer) { + pr_err("%s, invalid params", __func__); + return crc; + } + for (i = 0; i < dwLength; i++) { + crc_new = (uint8_t)(crc >> MSB_POS) | (crc << MSB_POS ); + crc_new ^= pbuffer[i]; + crc_new ^= (uint8_t)(crc_new & DL_CRC_MASK) >> 4; + crc_new ^= crc_new << 12; + crc_new ^= (crc_new & DL_CRC_MASK) << 5; + crc = crc_new; + } + return crc; +} + +/** @brief Function to build command frame for recover. + * + * @return status code of recovery_status_t type. + */ +static recovery_status_t build_cmd_frame() { + uint16_t len = 0; + uint16_t wCrc = 0; + uint16_t writeOffset = 0; + pr_debug(" %s Entry", __func__); + if(gphDnldNfc_DlSeqSz == 0) { + pr_err(" %s invalid params", __func__); + return STATUS_FAILED; + } + memset(g_recovery_frame.p_buffer, 0x00, MAX_FRAME_SIZE); + g_recovery_frame.len = 0; + if(g_recovery_info.bFrameSegmented == false) { + len = gphDnldNfc_DlSequence[g_recovery_info.currentReadOffset]; + len <<= MSB_POS; + len |= gphDnldNfc_DlSequence[g_recovery_info.currentReadOffset + 1]; + } else { + /* last frame was segmented frame + * read length reamaining length */ + len = g_recovery_info.wRemChunkBytes; + } + if(len > MAX_DATA_SIZE) { + /* set remaining chunk */ + g_recovery_info.wRemChunkBytes = (len - MAX_DATA_SIZE); + len = MAX_DATA_SIZE; + /* set chunk bit to write in header */ + len = DL_SET_HDR_FRAGBIT(len); + g_recovery_frame.p_buffer[writeOffset++] = (len >> MSB_POS) & SHIFT_MASK; + g_recovery_frame.p_buffer[writeOffset++] = len & SHIFT_MASK; + /* clear chunk bit for length variable */ + len = DL_CLR_HDR_FRAGBIT(len); + /* first chunk of segmented frame*/ + if(!g_recovery_info.bFrameSegmented) { + /* ignore header from user buffer */ + g_recovery_info.currentReadOffset += FW_HDR_LEN; + g_recovery_info.remBytes -= FW_HDR_LEN; + } + g_recovery_frame.len += FW_HDR_LEN; + g_recovery_info.bFrameSegmented = true; + } else { + /* last chunk of segmented frame */ + if(g_recovery_info.bFrameSegmented) { + /* write header with user chunk length */ + g_recovery_frame.p_buffer[writeOffset++] = (len >> MSB_POS) & SHIFT_MASK; + g_recovery_frame.p_buffer[writeOffset++] = len & SHIFT_MASK; + g_recovery_frame.len += FW_HDR_LEN; + } else { + /* normal Frame with in supported size increase + * len to read header from user data */ + len += FW_HDR_LEN; + } + g_recovery_info.wRemChunkBytes = 0; + g_recovery_info.bFrameSegmented = false; + } + if(((writeOffset + len) > MAX_FRAME_SIZE) || + ((g_recovery_info.currentReadOffset + len) > gphDnldNfc_DlSeqSz)) { + pr_err("%s frame offsets out of bound",__func__); + return STATUS_FAILED; + } + memcpy(&g_recovery_frame.p_buffer[writeOffset], + &gphDnldNfc_DlSequence[g_recovery_info.currentReadOffset], len); + g_recovery_info.currentReadOffset += len; + g_recovery_frame.len += len; + writeOffset += len; + g_recovery_info.remBytes -= len; + wCrc = calcCrc16(g_recovery_frame.p_buffer, + g_recovery_frame.len); + g_recovery_frame.p_buffer[writeOffset++] = (wCrc >> MSB_POS) & SHIFT_MASK; + g_recovery_frame.p_buffer[writeOffset++] = wCrc & SHIFT_MASK; + g_recovery_frame.len += FW_CRC_LEN; + return STATUS_SUCCESS; +} + +/** @brief Function to tramsmit recovery frame. + * @param nfc_dev nfc driver object. + * @return status code of recovery_status_t type. + */ +static recovery_status_t transmit(nfc_dev_t* nfc_dev) { + char rsp_buf[MAX_BUFFER_SIZE]; + int ret = 0; + int frame_resp_len = 0; + uint16_t respCRC = 0; + uint16_t respCRCOffset = 0; + + pr_debug("%s Entry", __func__); + if(NULL == nfc_dev || g_recovery_frame.len <= 0) { + pr_err("%s invalid Params ", __func__); + return STATUS_FAILED; + } + ret = nfc_dev->nfc_write(nfc_dev, g_recovery_frame.p_buffer, + g_recovery_frame.len, MAX_RETRY_COUNT); + if (ret <= 0) { + pr_err(" %s: Write recovery frame error %d\n", __func__, ret); + return STATUS_FAILED; + } + pr_debug(" %s Reading response \n", __func__); + memset(rsp_buf, 0x00, MAX_BUFFER_SIZE); + ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, FW_HDR_LEN, NCI_CMD_RSP_TIMEOUT); + if (ret < FW_HDR_LEN) { + pr_err(" %s - Read recovery frame response error ret %d\n", __func__, ret); + return STATUS_FAILED; + } + if( rsp_buf[0] != FW_MSG_CMD_RSP || + rsp_buf[DL_FRAME_RESP_LEN_OFFSET] != DL_FRAME_RESP_LEN) { + pr_err("%s, invalid response", __func__); + return STATUS_FAILED; + } + frame_resp_len = rsp_buf[DL_FRAME_RESP_LEN_OFFSET] + FW_CRC_LEN; + ret = nfc_dev->nfc_read(nfc_dev, rsp_buf + FW_HDR_LEN, frame_resp_len, NCI_CMD_RSP_TIMEOUT); + if (ret < frame_resp_len) { + pr_err(" %s - Read recovery frame response error ret %d\n", __func__, ret); + return STATUS_FAILED; + } + pr_debug(" %s: recovery frame Response 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", + __func__, rsp_buf[0], rsp_buf[1],rsp_buf[2], rsp_buf[3], rsp_buf[4], rsp_buf[5]); + respCRCOffset = FW_HDR_LEN + rsp_buf[DL_FRAME_RESP_LEN_OFFSET]; + respCRC = rsp_buf[respCRCOffset++]; + respCRC <<= MSB_POS; + respCRC |= rsp_buf[respCRCOffset]; + if(respCRC != calcCrc16(rsp_buf, DL_FRAME_RESP_LEN + FW_HDR_LEN)) { + pr_err("%s, invalid response crc", __func__); + return STATUS_FAILED; + } + if(g_recovery_info.bFrameSegmented && + (rsp_buf[DL_FRAME_RESP_STAT_OFFSET] != DL_SEGMENTED_FRAME_RESP_STAT1 + && rsp_buf[DL_FRAME_RESP_STAT_OFFSET] != DL_SEGMENTED_FRAME_RESP_STAT2)) { + pr_err("%s, invalid stat flag in chunk response", __func__); + return STATUS_FAILED; + } + if(!g_recovery_info.bFrameSegmented && + rsp_buf[DL_FRAME_RESP_STAT_OFFSET] != DL_NON_SEGMENTED_FRAME_RESP_STAT) { + pr_err("%s, invalid stat flag in response", __func__); + return STATUS_FAILED; + } + return STATUS_SUCCESS; +} + +/** @brief Function to detect the fw state and print. + * @param nfc_dev nfc driver object. + * @return no return. + */ +static void detect_fw_state(nfc_dev_t* nfc_dev) { + const char get_session_state_cmd[] = { 0x00, 0x04, 0xF2, 0x00, 0x00, 0x00, 0xF5, 0x33 }; + char rsp_buf[MAX_BUFFER_SIZE]; + int ret = 0; + pr_debug("%s:Sending GET_SESSION_STATE cmd \n", __func__); + ret = nfc_dev->nfc_write(nfc_dev, get_session_state_cmd, + sizeof(get_session_state_cmd), MAX_RETRY_COUNT); + if (ret <= 0) { + pr_err("%s: - nfc get session state cmd err ret %d\n", __func__, ret); + return; + } + memset(rsp_buf, 0x00, DL_GET_SESSION_STATE_RSP_LEN); + pr_debug("%s: Reading response of GET_SESSION_STATE cmd\n", __func__); + ret = nfc_dev->nfc_read(nfc_dev, rsp_buf, DL_GET_SESSION_STATE_RSP_LEN, NCI_CMD_RSP_TIMEOUT); + if (ret <= 0) { + pr_err("%s: - nfc get session state rsp err %d\n", __func__, ret); + return; + } + pr_debug("Response bytes are %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x", + rsp_buf[0], rsp_buf[1], rsp_buf[2], rsp_buf[3], rsp_buf[4], rsp_buf[5], + rsp_buf[6], rsp_buf[7]); + /*verify fw in non-teared state */ + if (rsp_buf[GET_SESSION_STS_OFF] != NFCC_SESSION_STS_CLOSED) { + pr_err("%s NFCC is in teared state %d\n", __func__, __LINE__); + } else { + pr_info("%s NFCC is in recoverd state %d\n", __func__, __LINE__); + } +} + +/** @brief Function to check input version with recovery fw version. + * @param fw_major_version: input major_version to check. + * @return true if input major_version matches with recovery fw major version + * otherwise returns false. + */ +static bool check_major_version(uint8_t fw_major_version) { + if(gphDnldNfc_DlSeqSz < RECOVERY_FW_MJ_VER_OFFSET) { + /* Recovery data corrupted */ + pr_err("%s Not able to extract major version from recovery fw\n", __func__); + return false; + } + return (fw_major_version == gphDnldNfc_DlSequence[RECOVERY_FW_MJ_VER_OFFSET]); +} + +/** @brief Function to recover the nfcc. + * @param nfc_dev nfc driver object. + * @return status code of type recovery_status_t. + */ +recovery_status_t do_recovery(nfc_dev_t *nfc_dev) { + recovery_status_t status = STATUS_SUCCESS; + g_recovery_info.remBytes = gphDnldNfc_DlSeqSz; + g_recovery_info.currentReadOffset = 0; + g_recovery_info.bFrameSegmented = false; + g_recovery_info.wRemChunkBytes = 0; + + pr_debug("%s Entry", __func__); + if(NULL == nfc_dev) { + pr_err("%s invalid params ", __func__); + return STATUS_FAILED; + } + if(!nfc_dev->recovery_required + || !(check_major_version(nfc_dev->fw_major_version))) { + pr_err("%s recovery not required or unsupported version", __func__); + status = STATUS_FAILED; + goto EXIT_RECOVERY; + } + while(g_recovery_info.remBytes > 0) { + status = build_cmd_frame(); + if(status != STATUS_SUCCESS) { + pr_err(" %s Unable to create recovery frame"); + break; + } + status = transmit(nfc_dev); + if(status != STATUS_SUCCESS) { + pr_err(" %s Unable to send recovery frame"); + break; + } + } +EXIT_RECOVERY: + detect_fw_state(nfc_dev); + /*set NCI mode for i2c products with dwl pin */ + enable_dwnld_mode(nfc_dev, false); + pr_info("%s Recovery done status %d", __func__, status); + return status; +} +#endif diff --git a/nfc/recovery_seq.h b/nfc/recovery_seq.h new file mode 100644 index 0000000000..86671de262 --- /dev/null +++ b/nfc/recovery_seq.h @@ -0,0 +1,80 @@ +/****************************************************************************** + * Copyright (C) 2021 NXP + * * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + ******************************************************************************/ +#if defined(RECOVERY_ENABLE) + +#ifndef __RECOVERY_SEQ_H_ +#define __RECOVERY_SEQ_H_ + +#include "common.h" + +#define MAX_FRAME_SIZE 0x22A /* support for 256(0x100) & 554(0x22A) frame size*/ + +#define MAX_DATA_SIZE \ + (MAX_FRAME_SIZE - FW_CRC_LEN - FW_HDR_LEN) + +#define FW_ROM_CODE_VER_OFFSET 4 +#define FW_MAJOR_VER_OFFSET 7 +#define RECOVERY_FW_SUPPORTED_ROM_VER 0x01 +#define RECOVERY_FW_SUPPORTED_MAJOR_VER 0x10 +#define RECOVERY_FW_MJ_VER_OFFSET 5 + +#define DL_SET_HDR_FRAGBIT(n) \ + ((n) | (1 << 10)) /* Header chunk bit set macro */ +#define DL_CLR_HDR_FRAGBIT(n) \ + ((n) & ~(1U << 10)) /* Header chunk bit clear macro */ + +#define DL_FRAME_RESP_LEN 0x04 +#define DL_FRAME_RESP_LEN_OFFSET 1 +#define DL_FRAME_RESP_STAT_OFFSET 2 +#define DL_SEGMENTED_FRAME_RESP_STAT1 0x2D +#define DL_SEGMENTED_FRAME_RESP_STAT2 0x2E +#define DL_NON_SEGMENTED_FRAME_RESP_STAT 0x00 +#define DL_INVALID_CRC_VALUE 0xffffU +#define DL_CRC_MASK 0xff + +#define SHIFT_MASK 0x00FF +#define MSB_POS 8 + +/* Data buffer for frame to write */ +typedef struct recovery_frame { + uint32_t len; + uint8_t p_buffer[MAX_FRAME_SIZE]; +} recovery_frame_t; + +/* Contains Info about user buffer and last data frame */ +typedef struct recovery_info { + uint32_t currentReadOffset; /* current offset within the user buffer to read/write */ + uint32_t remBytes; /* Remaining bytes to write */ + uint16_t wRemChunkBytes; /* Remaining bytes within the chunked frame */ + bool bFrameSegmented; /* Indicates the current frame is segmented */ +} recovery_info_t; + +/* indicates the error codes for nfc recovery module */ +typedef enum recovery_status { + STATUS_SUCCESS = 0x00, + STATUS_FAILED = 0x01, +} recovery_status_t; + +/** @brief Function to recover the nfcc. + * @param nfc_dev nfc driver object. + * @return status code of type recovery_status_t. + */ +recovery_status_t do_recovery(nfc_dev_t *nfc_dev); +#endif// end __RECOVERY_SEQ_H_ +#endif