diff options
Diffstat (limited to 'drivers')
64 files changed, 45646 insertions, 237 deletions
diff --git a/drivers/battery/Kconfig b/drivers/battery/Kconfig index acfbdb3..489bca1 100644 --- a/drivers/battery/Kconfig +++ b/drivers/battery/Kconfig @@ -45,6 +45,15 @@ config BATTERY_MAX17047_FUELGAUGE in handheld and portable equipment. The MAX17047 is configured to operate with a single lithium cell +config BATTERY_MAX17047_C_FUELGAUGE + tristate "Maxim MAX17047 Fuel Gauge - COULOMB_COUNTING" + depends on I2C + help + MAX17047 is fuel-gauge systems for lithium-ion (Li+) batteries + in handheld and portable equipment. The MAX17047 is configured + to operate with a single lithium cell + + config BATTERY_SMB136_CHARGER tristate "SMB136 battery charger support" depends on I2C diff --git a/drivers/battery/Makefile b/drivers/battery/Makefile index bb1af5e..af56fec 100644 --- a/drivers/battery/Makefile +++ b/drivers/battery/Makefile @@ -7,6 +7,7 @@ obj-$(CONFIG_MAX8997_CHARGER) += max8997-charger.o obj-$(CONFIG_BATTERY_MAX17043_FUELGAUGE) += max17043_fuelgauge.o obj-$(CONFIG_BATTERY_MAX17042_FUELGAUGE) += max17042_fuelgauge.o obj-$(CONFIG_BATTERY_MAX17047_FUELGAUGE) += max17047_fuelgauge.o +obj-$(CONFIG_BATTERY_MAX17047_C_FUELGAUGE) += max17047_fuelgauge_c.o obj-$(CONFIG_BATTERY_SMB136_CHARGER) += smb136_charger.o obj-$(CONFIG_BATTERY_MAX77693_CHARGER) += max77693_charger.o diff --git a/drivers/battery/battery-factory.c b/drivers/battery/battery-factory.c index c1cd9b1..0f20fed 100644 --- a/drivers/battery/battery-factory.c +++ b/drivers/battery/battery-factory.c @@ -121,6 +121,9 @@ static ssize_t factory_show_property(struct device *dev, int i; int cnt, dat, d_max, d_min, d_total; int val; +#if defined(CONFIG_MACH_KONA) + int comp1, comp3; +#endif const ptrdiff_t off = attr - factory_attrs; pr_debug("%s: %s\n", __func__, factory_attrs[off].attr.name); @@ -149,10 +152,16 @@ static ssize_t factory_show_property(struct device *dev, val = 0; for (cnt = 0; cnt < CNT_TEMPER_AVG; cnt++) { msleep(100); +#if defined(CONFIG_MACH_KONA) + info->battery_temper_adc = battery_get_info(info, + POWER_SUPPLY_PROP_TEMP); +#else battery_get_info(info, POWER_SUPPLY_PROP_TEMP); +#endif val += info->battery_temper_adc; info->battery_temper_adc_avg = val / (cnt + 1); } +#if !defined(CONFIG_MACH_KONA) #ifdef CONFIG_S3C_ADC info->battery_temper_avg = info->pdata->covert_adc( info->battery_temper_adc_avg, @@ -160,6 +169,10 @@ static ssize_t factory_show_property(struct device *dev, #else info->battery_temper_avg = info->battery_temper; #endif +#else + info->battery_temper_avg = info->battery_temper_adc_avg; +#endif + val = info->battery_temper_avg; pr_info("%s: temper avg(%d)\n", __func__, val); i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", val); @@ -185,6 +198,9 @@ static ssize_t factory_show_property(struct device *dev, d_total += dat; } val = (d_total - d_max - d_min) / (CNT_VOLTAGE_AVG - 2); +#if defined(CONFIG_MACH_KONA) + val /= 1000; +#endif pr_info("%s: voltage avg(%d)\n", __func__, val); i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", val); break; @@ -242,8 +258,28 @@ static ssize_t factory_show_property(struct device *dev, i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", val); break; case BATT_VOL_ADC: + i += scnprintf(buf + i, PAGE_SIZE - i, "N/A\n"); + break; case BATT_VOL_ADC_CAL: +#if defined(CONFIG_MACH_KONA) + /* For using compensation 1% value */ + comp1 = info->is_comp_1; + i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", comp1); + break; +#else + i += scnprintf(buf + i, PAGE_SIZE - i, "N/A\n"); + break; +#endif case BATT_VOL_ADC_AVER: +#if defined(CONFIG_MACH_KONA) + /* For using compensation 3% value */ + comp3 = info->is_comp_3; + i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", comp3); + break; +#else + i += scnprintf(buf + i, PAGE_SIZE - i, "N/A\n"); + break; +#endif case BATT_TEMP_ADC_CAL: case AUTH_BATTERY: i += scnprintf(buf + i, PAGE_SIZE - i, "N/A\n"); diff --git a/drivers/battery/max17047_fuelgauge_c.c b/drivers/battery/max17047_fuelgauge_c.c new file mode 100755 index 0000000..4b26cb0 --- /dev/null +++ b/drivers/battery/max17047_fuelgauge_c.c @@ -0,0 +1,2217 @@ +/* + * max17047_fuelgauge.c + * + * Copyright (C) 2011 Samsung Electronics + * SangYoung Son <hello.son@samsung.com> + * + * based on max17040_battery.c + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 and + * only version 2 as published by the Free Software Foundation. + * + * 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. + * + */ + +#include <linux/module.h> +#include <linux/init.h> +#include <linux/platform_device.h> +#include <linux/mutex.h> +#include <linux/err.h> +#include <linux/i2c.h> +#include <linux/delay.h> +#include <linux/power_supply.h> +#include <linux/battery/samsung_battery.h> +#include <linux/battery/max17047_fuelgauge_c.h> +#include <linux/slab.h> +#include <linux/interrupt.h> +#include <linux/irq.h> +#include <linux/gpio.h> +#include <plat/gpio-cfg.h> +#include <linux/rtc.h> +#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_MACH_M0_CTC)\ + || defined(CONFIG_MACH_T0_CHN_CTC) +#ifdef CONFIG_DEBUG_FS +#include <linux/debugfs.h> +#endif +#endif + +/* TRIM ERROR DETECTION */ +#define USE_TRIM_ERROR_DETECTION + +#define CONFIG_FUELGAUGE_MAX17047_COULOMB_COUNTING + +/* MAX17047 Registers. */ +#define MAX17047_REG_STATUS 0x00 +#define MAX17047_REG_VALRT_TH 0x01 +#define MAX17047_REG_TALRT_TH 0x02 +#define MAX17047_REG_SALRT_TH 0x03 +#define MAX17047_REG_REMCAP_REP 0x05 +#define MAX17047_SOCREP 0x06 +#define MAX17047_REG_VCELL 0x09 +#define MAX17047_REG_FULLCAP 0x10 +#define MAX17047_REG_TEMPERATURE 0x08 +#define MAX17047_REG_CYCLES 0x17 +#define MAX17047_REG_DESIGNCAP_REG 0x18 +#define MAX17047_REG_AVGVCELL 0x19 +#define MAX17047_REG_CONFIG 0x1D +#define MAX17047_REG_VERSION 0x21 +#define MAX17047_REG_FULLCAP_NOM 0x23 +#define MAX17047_REG_LEARNCFG 0x28 +#define MAX17047_REG_FILTERCFG 0x29 +#define MAX17047_REG_MISCCFG 0x2B +#define MAX17047_REG_CGAIN 0x2E +#define MAX17047_REG_RCOMP 0x38 +#define MAX17047_REG_VFOCV 0xFB +#define MAX17047_REG_SOC_VF 0xFF +#define MAX17047_REG_FULLCAP 0x10 +#define MAX17047_REG_FULLCAPNOM 0x23 +#define MAX17047_REG_CURRENT 0x0A +#define MAX17047_REG_AVG_CURRENT 0x0B +#define MAX17047_REG_DQACC 0x45 +#define MAX17047_REG_DPACC 0x46 +#define MAX17047_REG_VFSOC 0xFF + + + + +/* Polling work */ +#undef DEBUG_FUELGAUGE_POLLING +#define MAX17047_POLLING_INTERVAL 10000 + +/* rcomp update */ +#if defined(CONFIG_MACH_C1_KOR_SKT) || \ + defined(CONFIG_MACH_C1_KOR_KT) || \ + defined(CONFIG_MACH_C1_KOR_LGT) +#define CHECK_RCOMP_UPDATE +#define MAX17047_NEW_RCOMP 0x0070 +#endif + +/* adjust full soc */ +#if defined(CONFIG_MACH_T0) +#if defined(CONFIG_TARGET_LOCALE_KOR) +#define FULL_SOC_DEFAULT 9700 +#define FULL_SOC_LOW 9600 +#define FULL_SOC_HIGH 10050 +#define KEEP_FULL_SOC 100 /* 1.0% */ +#else +#define FULL_SOC_DEFAULT 9650 +#define FULL_SOC_LOW 9500 +#define FULL_SOC_HIGH 10050 +#define KEEP_FULL_SOC 100 /* 1.0% */ +#endif +#elif defined(CONFIG_MACH_GC1) +#define FULL_SOC_DEFAULT 9700 +#define FULL_SOC_LOW 9650 +#define FULL_SOC_HIGH 10000 +#define KEEP_FULL_SOC 110 /* 1.1% */ +#elif defined(CONFIG_MACH_KONA) +#define FULL_SOC_DEFAULT 9900 +#define FULL_SOC_LOW 9700 +#define FULL_SOC_HIGH 10000 +#define KEEP_FULL_SOC 100 // /* 1.0% */ +#else /* M0, C1,,, */ +#define FULL_SOC_DEFAULT 9850 +#define FULL_SOC_LOW 9700 +#define FULL_SOC_HIGH 10000 +#define KEEP_FULL_SOC 100 /* 1.0% */ +#endif +#define KEEP_SOC_DEFAULT 50 /* 0.5% */ + +struct max17047_fuelgauge_data { + struct i2c_client *client; + struct max17047_platform_data *pdata; + + struct power_supply fuelgauge; + + /* workqueue */ + struct delayed_work update_work; +#ifdef DEBUG_FUELGAUGE_POLLING + struct delayed_work polling_work; +#endif + + /* mutex */ + struct mutex irq_lock; + + /* wakelock */ + struct wake_lock update_wake_lock; + + unsigned int irq; + + unsigned int vcell; + unsigned int avgvcell; + unsigned int vfocv; + unsigned int soc; + unsigned int rawsoc; + unsigned int temperature; + +/*#if defined(CONFIG_FUELGAUGE_MAX17047_COULOMB_COUNTING)*/ + u32 previous_fullcap; + u32 previous_vffullcap; + + /* low battery comp */ + int low_batt_comp_cnt[LOW_BATT_COMP_RANGE_NUM][LOW_BATT_COMP_LEVEL_NUM]; + + /* low battery boot */ + int low_batt_boot_flag; + bool is_low_batt_alarm; + + /* miscellaneous */ + unsigned long fullcap_check_interval; + int full_check_flag; + bool is_first_check; +/*#endif*/ + + /* adjust full soc */ + int full_soc; + +#if defined(CONFIG_MACH_GC1) + int prev_status; +#endif + +#ifdef USE_TRIM_ERROR_DETECTION + /* trim error state */ + bool trim_err; +#endif + +#ifdef CONFIG_DEBUG_FS + struct dentry *fg_debugfs_dir; +#endif + +#ifdef CONFIG_HIBERNATION + u8 *reg_dump; +#endif + +}; + +static struct battery_data_t fg_battery_data[] = { + /* SDI battery data */ + { + .Capacity = 0x2530, + .low_battery_comp_voltage = 3500, + .low_battery_table = { + /* range, slope, offset */ + {-5000, 0, 0}, /* dummy for top limit */ + {-1250, 0, 3320}, + {-750, 97, 3451}, + {-100, 96, 3461}, + {0, 0, 3456}, + }, + .temp_adjust_table = { + /* range, slope, offset */ + {47000, 122, 8950}, + {60000, 200, 51000}, + {100000, 0, 0}, /* dummy for top limit */ + }, + .type_str = "SDI", + } +}; + + +#define MAX17047_CAPACITY 0x2530 + +static int max17047_i2c_read(struct i2c_client *client, int reg, u8 *buf) +{ + int ret; + + ret = i2c_smbus_read_i2c_block_data(client, reg, 2, buf); + if (ret < 0) + pr_err("%s: err %d, reg: 0x%02x\n", __func__, ret, reg); + + return ret; +} + +static int max17047_i2c_write(struct i2c_client *client, int reg, u8 *buf) +{ + int ret; + + ret = i2c_smbus_write_i2c_block_data(client, reg, 2, buf); + if (ret < 0) + pr_err("%s: err %d, reg: 0x%02x, data: 0x%x%x\n", __func__, + ret, reg, buf[0], buf[1]); + + return ret; +} + +static int fg_read_register(struct i2c_client *client, + u8 addr) +{ + u8 data[2]; + + if (max17047_i2c_read(client, addr, data) < 0) { + dev_err(&client->dev, "%s: Failed to read addr(0x%x)\n", + __func__, addr); + return -1; + } + + return (data[1] << 8) | data[0]; +} + +static int fg_write_register(struct i2c_client *client, + u8 addr, u16 w_data) +{ + u8 data[2]; + + data[0] = w_data & 0xFF; + data[1] = w_data >> 8; + + if (max17047_i2c_write(client, addr, data) < 0) { + dev_err(&client->dev, "%s: Failed to write addr(0x%x)\n", + __func__, addr); + return -1; + } + + return 0; +} + +static void max17047_test_read(struct max17047_fuelgauge_data *fg_data) +{ + int reg; + u8 data[2]; + int i; + u8 buf[673]; + + struct timespec ts; + struct rtc_time tm; + pr_info("%s\n", __func__); + + getnstimeofday(&ts); + rtc_time_to_tm(ts.tv_sec, &tm); + + pr_info("%s: %d/%d/%d %02d:%02d\n", __func__, + tm.tm_mday, + tm.tm_mon + 1, + tm.tm_year + 1900, + tm.tm_hour, + tm.tm_min); + + i = 0; + for (reg = 0; reg < 0x50; reg++) { + if (!(reg & 0xf)) + i += sprintf(buf + i, "\n%02x| ", reg); + max17047_i2c_read(fg_data->client, reg, data); + i += sprintf(buf + i, "%02x%02x ", data[1], data[0]); + } + for (reg = 0xe0; reg < 0x100; reg++) { + if (!(reg & 0xf)) + i += sprintf(buf + i, "\n%02x| ", reg); + max17047_i2c_read(fg_data->client, reg, data); + i += sprintf(buf + i, "%02x%02x ", data[1], data[0]); + } + + pr_info(" 0 1 2 3 4 5 6 7"); + pr_cont(" 8 9 a b c d e f"); + pr_cont("%s\n", buf); +} + +static int fg_check_battery_present(struct i2c_client *client) +{ + u8 status_data[2]; + int ret = 1; + + /* 1. Check Bst bit */ + if (max17047_i2c_read(client, MAX17047_REG_STATUS, status_data) < 0) { + dev_err(&client->dev, + "%s: Failed to read STATUS_REG\n", __func__); + return 0; + } + + if (status_data[0] & (0x1 << 3)) { + dev_info(&client->dev, + "%s: addr(0x01), data(0x%04x)\n", __func__, + (status_data[1]<<8) | status_data[0]); + dev_info(&client->dev, "%s: battery is absent!!\n", __func__); + ret = 0; + } + + return ret; +} + +static int max17047_get_temperature(struct i2c_client *client) +{ +#if defined(CONFIG_MACH_KONA) + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2] = {0x00, 0x00}; + int temper = 0; + + if (fg_check_battery_present(client)) { + if (max17047_i2c_read(client, MAX17047_REG_TEMPERATURE, data) < 0) { + dev_err(&client->dev, + "%s: Failed to read TEMPERATURE_REG\n", + __func__); + return -1; + } + + if (data[1]&(0x1 << 7)) { + temper = ((~(data[1]))&0xFF)+1; + temper *= (-1000); + temper -= ((~((int)data[0]))+1) * 39 / 10; + } else { + temper = data[1] & 0x7f; + temper *= 1000; + temper += data[0] * 39 / 10; + } + } else + temper = 20000; + + dev_info(&client->dev, "%s: TEMPERATURE(%d), data(0x%04x)\n", + __func__, temper/100, (data[1]<<8) | data[0]); + + return temper/100; +#else + return 300; +#endif +} + +/* max17047_get_XXX(); Return current value and update data value */ +static int max17047_get_vfocv(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + int ret; + u32 vfocv; + pr_debug("%s\n", __func__); + + ret = max17047_i2c_read(client, MAX17047_REG_VFOCV, data); + if (ret < 0) + return ret; + + vfocv = fg_data->vfocv = ((data[0] >> 3) + (data[1] << 5)) * 625 / 1000; + + pr_debug("%s: VFOCV(0x%02x%02x, %d)\n", __func__, + data[1], data[0], vfocv); + return vfocv * 1000; +} + +static int fg_read_vcell(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + u32 vcell; + u16 w_data; + u32 temp; + u32 temp2; + + if (max17047_i2c_read(client, MAX17047_REG_VCELL, data) < 0) { + dev_err(&client->dev, "%s: Failed to read VCELL\n", __func__); + return -1; + } + + w_data = (data[1]<<8) | data[0]; + + temp = (w_data & 0xFFF) * 78125; + vcell = temp / 1000000; + + temp = ((w_data & 0xF000) >> 4) * 78125; + temp2 = temp / 1000000; + vcell += (temp2 << 4); + + dev_info(&client->dev, "%s: VCELL(%d), data(0x%04x)\n", + __func__, vcell, (data[1]<<8) | data[0]); + + return vcell; +} + + +static int max17047_get_vcell(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + int ret; + u32 vcell; + pr_debug("%s\n", __func__); + + ret = max17047_i2c_read(client, MAX17047_REG_VCELL, data); + if (ret < 0) + return ret; + + vcell = fg_data->vcell = ((data[0] >> 3) + (data[1] << 5)) * 625; + + pr_debug("%s: VCELL(0x%02x%02x, %d)\n", __func__, + data[1], data[0], vcell); + return vcell; +} + +static int max17047_get_avgvcell(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + int ret; + u32 avgvcell; + pr_debug("%s\n", __func__); + + ret = max17047_i2c_read(client, MAX17047_REG_AVGVCELL, data); + if (ret < 0) + return ret; + + avgvcell = fg_data->avgvcell = ((data[0] >> 3) + (data[1] << 5)) * 625; + + pr_debug("%s: AVGVCELL(0x%02x%02x, %d)\n", __func__, + data[1], data[0], avgvcell); + return avgvcell; +} + +static int max17047_get_rawsoc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + int soc; + + if (max17047_i2c_read(client, MAX17047_SOCREP, data) < 0) { + dev_err(&client->dev, "%s: Failed to read SOCREP\n", __func__); + return -1; + } + + soc = (data[1] * 100) + (data[0] * 100 / 256); + + dev_dbg(&client->dev, "%s: raw capacity (0.01%%) (%d)\n", + __func__, soc); + + dev_dbg(&client->dev, "%s: raw capacity (%d), data(0x%04x)\n", + __func__, soc, (data[1]<<8) | data[0]); + + return min(soc, 10000); +} + +#if 0 +static int max17047_get_soc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + int rawsoc, soc, fullsoc, empty; + pr_debug("%s\n", __func__); + + rawsoc = max17047_get_rawsoc(fg_data->client); + +#if defined(CONFIG_MACH_C1) + empty = 0; +#else /* M0, T0,,, */ + empty = 29; +#endif + + if (fg_data->full_soc <= 0) + fg_data->full_soc = FULL_SOC_DEFAULT; + fullsoc = fg_data->full_soc - empty; + rawsoc -= empty; + + soc = fg_data->soc = + ((rawsoc < empty) ? 0 : (min((rawsoc * 100 / fullsoc), 100))); + + pr_info("%s: SOC(%d, %d / %d)\n", __func__, soc, rawsoc, fullsoc); + return soc; +} + +#else +/* soc should be 0.1% unit */ +static int max17047_get_soc(struct i2c_client *client) +{ + u8 data[2]; + int soc; + + if (max17047_i2c_read(client, MAX17047_SOCREP, data) < 0) { + pr_err("%s: Failed to read SOCREP\n", __func__); + return -1; + } + + soc = ((data[1] * 100) + (data[0] * 100 / 256)) / 10; + + pr_info("%s: raw capacity (%d), data(0x%04x)\n", __func__, soc, (data[1]<<8) | data[0]); + + return min(soc, 1000); +} +#endif + +static int fg_reset_capacity_by_jig_connection(struct i2c_client *client) +{ + pr_info("%s: DesignCap = Capacity - 1 (Jig Connection)\n", __func__); + + return fg_write_register(client, MAX17047_REG_DESIGNCAP_REG, + fg_battery_data[SDI].Capacity - 1); +} + +#if defined(CONFIG_MACH_KONA) +/* For using JIG detach */ +struct i2c_client *fg_client; + +void fg_reset_capacity_by_jig_connection_ex(void) +{ + + pr_info("%s: DesignCap = Capacity - 1 (Jig Connection)\n", __func__); + printk("[BAT] %s call!!\n", __func__); + + + fg_write_register(fg_client, MAX17047_REG_DESIGNCAP_REG, + fg_battery_data[SDI].Capacity - 1); +} +EXPORT_SYMBOL(fg_reset_capacity_by_jig_connection_ex); +#endif + +static void fg_periodic_read(struct i2c_client *client) +{ + u8 reg; + int i; + int data[0x10]; + char *str = NULL; + + str = kzalloc(sizeof(char)*1024, GFP_KERNEL); + if (!str) + return; + + for (i = 0; i < 16; i++) { + for (reg = 0; reg < 0x10; reg++) + data[reg] = fg_read_register(client, reg + i * 0x10); + + sprintf(str+strlen(str), + "%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,", + data[0x00], data[0x01], data[0x02], data[0x03], + data[0x04], data[0x05], data[0x06], data[0x07]); + sprintf(str+strlen(str), + "%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,%04xh,", + data[0x08], data[0x09], data[0x0a], data[0x0b], + data[0x0c], data[0x0d], data[0x0e], data[0x0f]); + if (i == 4) + i = 13; + } + + dev_info(&client->dev, "maxim check %s", str); + + kfree(str); +} + +static int fg_read_current(struct i2c_client *client) +{ + u8 data1[2], data2[2]; + u32 temp, sign; + s32 i_current; + s32 avg_current; + + if (max17047_i2c_read(client, MAX17047_REG_CURRENT, data1) < 0) { + pr_err("%s: Failed to read CURRENT\n", + __func__); + return -1; + } + + if (max17047_i2c_read(client, MAX17047_REG_AVG_CURRENT, data2) < 0) { + pr_err("%s: Failed to read AVERAGE CURRENT\n", + __func__); + return -1; + } + + temp = ((data1[1]<<8) | data1[0]) & 0xFFFF; + if (temp & (0x1 << 15)) { + sign = NEGATIVE; + temp = (~temp & 0xFFFF) + 1; + } else + sign = POSITIVE; + + /* 1.5625uV/0.01Ohm(Rsense) = 156.25uA */ + i_current = temp * 15625 / 100000; + if (sign) + i_current *= -1; + + temp = ((data2[1]<<8) | data2[0]) & 0xFFFF; + if (temp & (0x1 << 15)) { + sign = NEGATIVE; + temp = (~temp & 0xFFFF) + 1; + } else + sign = POSITIVE; + + /* 1.5625uV/0.01Ohm(Rsense) = 156.25uA */ + avg_current = temp * 15625 / 100000; + if (sign) + avg_current *= -1; + + pr_info("%s: CURRENT(%dmA), AVG_CURRENT(%dmA)\n", + __func__, i_current, avg_current); + + fg_periodic_read(client); + + return i_current; +} + +static int fg_read_avg_current(struct i2c_client *client) +{ + u8 data2[2]; + u32 temp, sign; + s32 avg_current; + + if (max17047_i2c_read(client, MAX17047_REG_AVG_CURRENT, data2) < 0) { + pr_err("%s: Failed to read AVERAGE CURRENT\n", + __func__); + return -1; + } + + temp = ((data2[1]<<8) | data2[0]) & 0xFFFF; + if (temp & (0x1 << 15)) { + sign = NEGATIVE; + temp = (~temp & 0xFFFF) + 1; + } else + sign = POSITIVE; + + /* 1.5625uV/0.01Ohm(Rsense) = 156.25uA */ + avg_current = temp * 15625 / 100000; + + if (sign) + avg_current *= -1; + + return avg_current; +} + +/* soc should be 0.1% unit */ +static int fg_read_vfsoc(struct i2c_client *client) +{ + u8 data[2]; + int soc; + + if (max17047_i2c_read(client, MAX17047_REG_VFSOC, data) < 0) { + pr_err("%s: Failed to read VFSOC\n", __func__); + return -1; + } + + soc = ((data[1] * 100) + (data[0] * 100 / 256)) / 10; + + return min(soc, 1000); +} + + +int get_fuelgauge_value(struct i2c_client *client, int data) +{ + int ret = 0; + + switch (data) { + case FG_LEVEL: + /*ret = fg_read_soc(client);*/ + ret = max17047_get_soc(client); + + break; + + case FG_TEMPERATURE: + /*ret = fg_read_temp(client);*/ + break; + + case FG_VOLTAGE: + ret = fg_read_vcell(client); + break; + + case FG_CURRENT: + ret = fg_read_current(client); + break; + + case FG_CURRENT_AVG: + ret = fg_read_avg_current(client); + break; + + case FG_CHECK_STATUS: + /*ret = fg_check_status_reg(client);*/ + break; + + case FG_RAW_SOC: + /*ret = fg_read_rawsoc(client);*/ + break; + + case FG_VF_SOC: + ret = fg_read_vfsoc(client); + break; + + case FG_AV_SOC: + /*ret = fg_read_avsoc(client);*/ + break; + + case FG_FULLCAP: + /*ret = fg_read_fullcap(client);*/ + break; + + case FG_MIXCAP: + /*ret = fg_read_mixcap(client);*/ + break; + + case FG_AVCAP: + /*ret = fg_read_avcap(client);*/ + break; + + case FG_REPCAP: + /*ret = fg_read_repcap(client);*/ + break; + + default: + ret = -1; + break; + } + + return ret; +} + + +void fg_check_vf_fullcap_range(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + + static int new_vffullcap; + bool is_vffullcap_changed = true; + + if (is_jig_attached == JIG_ON) + fg_reset_capacity_by_jig_connection(client); + + new_vffullcap = fg_read_register(client, MAX17047_REG_FULLCAP_NOM); + if (new_vffullcap < 0) + new_vffullcap = fg_battery_data[SDI].Capacity; + + /* compare with initial capacity */ + if (new_vffullcap > + (fg_battery_data[SDI].Capacity * 110 / 100)) { + pr_info("%s: [Case 1] capacity = 0x%04x, NewVfFullCap = 0x%04x\n", + __func__, fg_battery_data[SDI].Capacity, + new_vffullcap); + + new_vffullcap = + (fg_battery_data[SDI].Capacity * 110) / 100; + + fg_write_register(client, MAX17047_REG_DQACC, + (u16)(new_vffullcap / 4)); + fg_write_register(client, MAX17047_REG_DPACC, (u16)0x3200); + } else if (new_vffullcap < + (fg_battery_data[SDI].Capacity * 50 / 100)) { + pr_info("%s: [Case 5] capacity = 0x%04x, NewVfFullCap = 0x%04x\n", + __func__, fg_battery_data[SDI].Capacity, new_vffullcap); + + new_vffullcap = + (fg_battery_data[SDI].Capacity * 50) / 100; + + fg_write_register(client, MAX17047_REG_DQACC, + (u16)(new_vffullcap / 4)); + fg_write_register(client, MAX17047_REG_DPACC, (u16)0x3200); + } else { + /* compare with previous capacity */ + if (new_vffullcap > + (fg_data->previous_vffullcap * 110 / 100)) { + pr_info("%s: [Case 2] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x\n", + __func__, fg_data->previous_vffullcap, + new_vffullcap); + + new_vffullcap = + (fg_data->previous_vffullcap * 110) / + 100; + + fg_write_register(client, MAX17047_REG_DQACC, + (u16)(new_vffullcap / 4)); + fg_write_register(client, MAX17047_REG_DPACC, (u16)0x3200); + } else if (new_vffullcap < + (fg_data->previous_vffullcap * 90 / 100)) { + pr_info("%s: [Case 3] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x\n", + __func__, fg_data->previous_vffullcap, new_vffullcap); + + new_vffullcap = + (fg_data->previous_vffullcap * 90) / 100; + + fg_write_register(client, MAX17047_REG_DQACC, + (u16)(new_vffullcap / 4)); + fg_write_register(client, MAX17047_REG_DPACC, (u16)0x3200); + } else { + pr_info("%s: [Case 4] previous_vffullcap = 0x%04x, NewVfFullCap = 0x%04x\n", + __func__, fg_data->previous_vffullcap, + new_vffullcap); + is_vffullcap_changed = false; + } + } + + /* delay for register setting (dQacc, dPacc) */ + if (is_vffullcap_changed) + msleep(300); + + fg_data->previous_vffullcap = + fg_read_register(client, MAX17047_REG_FULLCAP_NOM); + + if (is_vffullcap_changed) + pr_info("%s : VfFullCap(0x%04x), dQacc(0x%04x), dPacc(0x%04x)\n", + __func__, + fg_read_register(client, MAX17047_REG_FULLCAP_NOM), + fg_read_register(client, MAX17047_REG_DQACC), + fg_read_register(client, MAX17047_REG_DPACC)); + +} + +void fg_set_full_charged(struct i2c_client *client) +{ + pr_info("[FG_Set_Full] (B) FullCAP(%d), RemCAP(%d)\n", + (fg_read_register(client, MAX17047_REG_FULLCAP)/2), + (fg_read_register(client, MAX17047_REG_REMCAP_REP)/2)); + + fg_write_register(client, MAX17047_REG_FULLCAP, + (u16)fg_read_register(client, MAX17047_REG_REMCAP_REP)); + + pr_info("[FG_Set_Full] (A) FullCAP(%d), RemCAP(%d)\n", + (fg_read_register(client, MAX17047_REG_FULLCAP)/2), + (fg_read_register(client, MAX17047_REG_REMCAP_REP)/2)); +} + +static void add_low_batt_comp_cnt(struct i2c_client *client, + int range, int level) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int i; + int j; + + /* Increase the requested count value, and reset others. */ + fg_data->low_batt_comp_cnt[range-1][level/2]++; + + for (i = 0; i < LOW_BATT_COMP_RANGE_NUM; i++) { + for (j = 0; j < LOW_BATT_COMP_LEVEL_NUM; j++) { + if (i == range-1 && j == level/2) + continue; + else + fg_data->low_batt_comp_cnt[i][j] = 0; + } + } +} + + +static int get_low_batt_threshold(struct i2c_client *client, + int range, int nCurrent, int level) +{ + int ret = 0; + + ret = fg_battery_data[SDI].low_battery_table[range][OFFSET] + + ((nCurrent * + fg_battery_data[SDI].low_battery_table[range][SLOPE]) / + 1000); + + return ret; +} + +void reset_low_batt_comp_cnt(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + + memset(fg_data->low_batt_comp_cnt, 0, + sizeof(fg_data->low_batt_comp_cnt)); +} + +static void display_low_batt_comp_cnt(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + + pr_info("Check Array(%s): [%d, %d], [%d, %d], ", + fg_battery_data[SDI].type_str, + fg_data->low_batt_comp_cnt[0][0], + fg_data->low_batt_comp_cnt[0][1], + fg_data->low_batt_comp_cnt[1][0], + fg_data->low_batt_comp_cnt[1][1]); + pr_info("[%d, %d], [%d, %d], [%d, %d]\n", + fg_data->low_batt_comp_cnt[2][0], + fg_data->low_batt_comp_cnt[2][1], + fg_data->low_batt_comp_cnt[3][0], + fg_data->low_batt_comp_cnt[3][1], + fg_data->low_batt_comp_cnt[4][0], + fg_data->low_batt_comp_cnt[4][1]); +} + + +static int check_low_batt_comp_condition( + struct i2c_client *client, int *nLevel) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int i; + int j; + int ret = 0; + + for (i = 0; i < LOW_BATT_COMP_RANGE_NUM; i++) { + for (j = 0; j < LOW_BATT_COMP_LEVEL_NUM; j++) { + if (fg_data->low_batt_comp_cnt[i][j] >= + MAX_LOW_BATT_CHECK_CNT) { + display_low_batt_comp_cnt(client); + ret = 1; + *nLevel = j*2 + 1; + break; + } + } + } + + return ret; +} + +void fg_low_batt_compensation(struct i2c_client *client, u32 level) +{ +#if defined(CONFIG_MACH_KONA) + struct power_supply *battery_psy = power_supply_get_by_name("battery"); + union power_supply_propval value; +#endif + int read_val; + u32 temp; + + pr_info("%s: Adjust SOCrep to %d!!\n", + __func__, level); + + read_val = fg_read_register(client, MAX17047_REG_FULLCAP); + if (read_val < 0) + return; + +#if defined(CONFIG_MACH_KONA) + if (read_val > 2) { /* 3% compensation */ + /* RemCapREP (05h) = FullCap(10h) x 0.0301 */ + temp = read_val * (level*100 + 1) / 10000; + + /* Display conpensation 3% value for debug screen */ + value.intval = 1; + battery_psy->set_property(battery_psy, + POWER_SUPPLY_PROP_COMPENSATION_3, + &value); + } else { /* 1% compensation */ + /* RemCapREP (05h) = FullCap(10h) x 0.0090 */ + temp = read_val * (level*90) / 10000; + + /* Display conpensation 1% value for debug screen */ + value.intval = 1; + battery_psy->set_property(battery_psy, + POWER_SUPPLY_PROP_COMPENSATION_1, + &value); + } +#else + if (read_val > 2) /* 3% compensation */ + /* RemCapREP (05h) = FullCap(10h) x 0.0301 */ + temp = read_val * (level*100 + 1) / 10000; + else /* 1% compensation */ + /* RemCapREP (05h) = FullCap(10h) x 0.0090 */ + temp = read_val * (level*90) / 10000; +#endif + + fg_write_register(client, MAX17047_REG_REMCAP_REP, (u16)temp); +} + +void prevent_early_poweroff(struct i2c_client *client, + int vcell, int *fg_soc) +{ + int soc = 0; + int read_val; + + soc = get_fuelgauge_value(client, FG_LEVEL); + + if (soc > POWER_OFF_SOC_HIGH_MARGIN) + return; + + pr_info("%s: soc=%d%%, vcell=%d\n", __func__, + soc, vcell); + + if (vcell > POWER_OFF_VOLTAGE_HIGH_MARGIN) { + read_val = fg_read_register(client, MAX17047_REG_FULLCAP); + /* FullCAP * 0.013 */ + fg_write_register(client, MAX17047_REG_REMCAP_REP, + (u16)(read_val * 13 / 1000)); + msleep(200); + *fg_soc = max17047_get_soc(client); + dev_info(&client->dev, "%s : new soc=%d, vcell=%d\n", + __func__, *fg_soc, vcell); + } +} + +int low_batt_compensation(struct i2c_client *client, + int fg_soc, int fg_vcell, int fg_current) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int fg_avg_current = 0; + int fg_min_current = 0; + int new_level = 0; + int i, table_size; + + /* Not charging, Under low battery comp voltage */ + if (fg_vcell <= fg_battery_data[SDI].low_battery_comp_voltage) { + fg_avg_current = fg_read_avg_current(client); + fg_min_current = min(fg_avg_current, fg_current); + + table_size = + sizeof(fg_battery_data[SDI].low_battery_table) / + (sizeof(s16)*TABLE_MAX); + + for (i = 1; i < CURRENT_RANGE_MAX_NUM; i++) { + if ((fg_min_current >= fg_battery_data[SDI].low_battery_table[i-1][RANGE]) && + (fg_min_current < fg_battery_data[SDI].low_battery_table[i][RANGE])) { + if (fg_soc >= 2 && fg_vcell < + get_low_batt_threshold(client, + i, fg_min_current, 1)) { + add_low_batt_comp_cnt( + client, i, 1); + } else { + reset_low_batt_comp_cnt(client); + } + } + } + + if (check_low_batt_comp_condition(client, &new_level)) { + fg_low_batt_compensation(client, new_level); + reset_low_batt_comp_cnt(client); + + /* Do not update soc right after + * low battery compensation + * to prevent from powering-off suddenly + */ + pr_info("%s: SOC is set to %d by low compensation!!\n", + __func__, max17047_get_soc(client)); + } + } + + /* Prevent power off over 3500mV */ + prevent_early_poweroff(client, fg_vcell, &fg_soc); + + return fg_soc; +} + +int fg_adjust_capacity(struct i2c_client *client) +{ + u8 data[2]; + + data[0] = 0; + data[1] = 0; + + /* 1. Write RemCapREP(05h)=0; */ + if (max17047_i2c_write(client, MAX17047_REG_REMCAP_REP, data) < 0) { + pr_err("%s: Failed to write RemCap_REP\n", __func__); + return -1; + } + msleep(200); + + pr_info("%s: After adjust - RepSOC(%d)\n", __func__, max17047_get_soc(client)); + + return 0; +} + +static bool is_booted_in_low_battery(struct i2c_client *client) +{ + int fg_vcell = get_fuelgauge_value(client, FG_VOLTAGE); + int fg_current = get_fuelgauge_value(client, FG_CURRENT); + int threshold = 0; + + threshold = 3300 + ((fg_current * 17) / 100); + + if (fg_vcell <= threshold) + return true; + else + return false; +} + +static bool fuelgauge_recovery_handler(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int current_soc; + int avsoc; + int temperature; + + if (fg_data->soc > LOW_BATTERY_SOC_REDUCE_UNIT) { + pr_err("%s: Reduce the Reported SOC by 1%%\n", + __func__); + current_soc = + get_fuelgauge_value(client, FG_LEVEL); + + if (current_soc) { + pr_info("%s: Returning to Normal discharge path\n", + __func__); + pr_info("%s: Actual SOC(%d) non-zero\n", + __func__, current_soc); + fg_data->is_low_batt_alarm = false; + } else { + temperature = + get_fuelgauge_value(client, FG_TEMPERATURE); + avsoc = + get_fuelgauge_value(client, FG_AV_SOC); + + if ((fg_data->soc > avsoc) || + (temperature < 0)) { + fg_data->soc -= + LOW_BATTERY_SOC_REDUCE_UNIT; + pr_err("%s: New Reduced RepSOC (%d)\n", + __func__, fg_data->soc); + } else + pr_info("%s: Waiting for recovery (AvSOC:%d)\n", + __func__, avsoc); + } + } + + return fg_data->is_low_batt_alarm; +} + + +static int get_fuelgauge_soc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + struct power_supply *battery_psy = power_supply_get_by_name("battery"); + union power_supply_propval value; + int fg_soc; + int fg_vfsoc; + int fg_vcell; + int fg_current; + int avg_current; + ktime_t current_time; + struct timespec ts; + int fullcap_check_interval; + int cable_type; + + if (fg_data->is_low_batt_alarm) { + if (fuelgauge_recovery_handler(client)) { + fg_soc = fg_data->soc; + goto return_soc; + } + } + + current_time = alarm_get_elapsed_realtime(); + ts = ktime_to_timespec(current_time); + + /* check fullcap range */ + fullcap_check_interval = + (ts.tv_sec - fg_data->fullcap_check_interval); + if (fullcap_check_interval > + VFFULLCAP_CHECK_INTERVAL) { + dev_info(&client->dev, + "%s: check fullcap range (interval:%d)\n", + __func__, fullcap_check_interval); + fg_check_vf_fullcap_range(client); + fg_data->fullcap_check_interval = ts.tv_sec; + } + + fg_soc = get_fuelgauge_value(client, FG_LEVEL); + if (fg_soc < 0) { + pr_info("Can't read soc!!!"); + fg_soc = fg_data->soc; + } + + if (!battery_psy) { + pr_info("%s : battery driver didn't load yet.\n", __func__); + return fg_soc; + } + + battery_psy->get_property(battery_psy, + POWER_SUPPLY_PROP_ONLINE, + &value); + + cable_type = value.intval; + + if (fg_data->low_batt_boot_flag) { + fg_soc = 0; + + if (cable_type != POWER_SUPPLY_TYPE_BATTERY && + !is_booted_in_low_battery(client)) { + fg_adjust_capacity(client); + fg_data->low_batt_boot_flag = 0; + } + + if (cable_type == POWER_SUPPLY_TYPE_BATTERY) + fg_data->low_batt_boot_flag = 0; + } + + fg_vcell = get_fuelgauge_value(client, FG_VOLTAGE); + fg_current = get_fuelgauge_value(client, FG_CURRENT); + avg_current = get_fuelgauge_value(client, FG_CURRENT_AVG); + fg_vfsoc = get_fuelgauge_value(client, FG_VF_SOC); + + + battery_psy->get_property(battery_psy, + POWER_SUPPLY_PROP_STATUS, + &value); + + /* Algorithm for reducing time to fully charged (from MAXIM) */ + if (value.intval != POWER_SUPPLY_STATUS_DISCHARGING && + value.intval != POWER_SUPPLY_STATUS_FULL && + cable_type != POWER_SUPPLY_TYPE_USB && + /* Skip when first check after boot up */ + !fg_data->is_first_check && + (fg_vfsoc > VFSOC_FOR_FULLCAP_LEARNING && + (fg_current > LOW_CURRENT_FOR_FULLCAP_LEARNING && + fg_current < HIGH_CURRENT_FOR_FULLCAP_LEARNING) && + (avg_current > LOW_AVGCURRENT_FOR_FULLCAP_LEARNING && + avg_current < HIGH_AVGCURRENT_FOR_FULLCAP_LEARNING))) { + + if (fg_data->full_check_flag == 2) { + pr_info("%s: force fully charged SOC !! (%d)", + __func__, fg_data->full_check_flag); + fg_set_full_charged(client); + fg_soc = get_fuelgauge_value(client, FG_LEVEL); + } else if (fg_data->full_check_flag < 2) + pr_info("%s: full_check_flag (%d)", + __func__, fg_data->full_check_flag); + + /* prevent overflow */ + if (fg_data->full_check_flag++ > 10000) + fg_data->full_check_flag = 3; + } else + fg_data->full_check_flag = 0; + + /* Checks vcell level and tries to compensate SOC if needed.*/ + /* If jig cable is connected, then skip low batt compensation check. */ + if (is_jig_attached != JIG_ON && + value.intval == POWER_SUPPLY_STATUS_DISCHARGING) + fg_soc = low_batt_compensation( + client, fg_soc, fg_vcell, fg_current); + + if (fg_data->is_first_check) + fg_data->is_first_check = false; + fg_data->soc = fg_soc; + +return_soc: + +#if defined(CONFIG_MACH_KONA) + if (fg_data->full_soc <= 0) + fg_data->full_soc = FULL_SOC_DEFAULT; + + fg_soc =(min((fg_soc * 10000 / (fg_data->full_soc)), 1000)); +#endif + + pr_info("%s: soc(%d), low_batt_alarm(%d)\n", + __func__, fg_data->soc, + fg_data->is_low_batt_alarm); + + return fg_soc; +} + +static void max17047_adjust_fullsoc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = + i2c_get_clientdata(client); + int prev_full_soc = fg_data->full_soc; + int raw_soc = max17047_get_rawsoc(fg_data->client); + int keep_soc = 0; + + if (raw_soc < 0) { + pr_err("%s : fg data error!(%d)\n", __func__, raw_soc); + fg_data->full_soc = FULL_SOC_DEFAULT; + return; + } + + if (raw_soc < FULL_SOC_LOW) + fg_data->full_soc = FULL_SOC_LOW; + else if (raw_soc > FULL_SOC_HIGH) { + keep_soc = FULL_SOC_HIGH / 100; + fg_data->full_soc = (FULL_SOC_HIGH - keep_soc); + } else { + keep_soc = ((raw_soc * KEEP_FULL_SOC) / 10000); + if (raw_soc > (FULL_SOC_LOW + keep_soc)) + fg_data->full_soc = raw_soc - keep_soc; + else + fg_data->full_soc = FULL_SOC_LOW; + } + + if (prev_full_soc != fg_data->full_soc) + pr_info("%s : full_soc(%d->%d), rsoc(%d), keep(%d)\n", __func__, + prev_full_soc, fg_data->full_soc, raw_soc, keep_soc); +} + +/* SOC% alert, disabled(0xFF00) */ +static void max17047_set_salrt(struct max17047_fuelgauge_data *fg_data, + u8 min, u8 max) +{ + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_info("%s: min(%d%%), max(%d%%)\n", __func__, min, max); + + i2c_data[1] = max; + i2c_data[0] = min; + max17047_i2c_write(client, MAX17047_REG_SALRT_TH, i2c_data); + + max17047_i2c_read(client, MAX17047_REG_SALRT_TH, i2c_data); + if ((i2c_data[0] != min) || (i2c_data[1] != max)) + pr_err("%s: SALRT_TH is not valid (0x%02d%02d ? 0x%02d%02d)\n", + __func__, i2c_data[1], i2c_data[0], max, min); +} + +/* Temperature alert, disabled(0x7F80) */ +static void max17047_set_talrt(struct max17047_fuelgauge_data *fg_data, + u8 min, u8 max) +{ + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_info("%s: min(0x%02x), max(0x%02x)\n", __func__, min, max); + + i2c_data[1] = max; + i2c_data[0] = min; + max17047_i2c_write(client, MAX17047_REG_TALRT_TH, i2c_data); + + max17047_i2c_read(client, MAX17047_REG_TALRT_TH, i2c_data); + if ((i2c_data[0] != min) || (i2c_data[1] != max)) + pr_err("%s: TALRT_TH is not valid (0x%02d%02d ? 0x%02d%02d)\n", + __func__, i2c_data[1], i2c_data[0], max, min); +} + +/* Voltage alert, disabled(0xFF00) */ +static void max17047_set_valrt(struct max17047_fuelgauge_data *fg_data, + u8 min, u8 max) +{ + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_info("%s: min(%dmV), max(%dmV)\n", __func__, min * 20, max * 20); + + i2c_data[1] = max; + i2c_data[0] = min; + max17047_i2c_write(client, MAX17047_REG_VALRT_TH, i2c_data); + + max17047_i2c_read(client, MAX17047_REG_VALRT_TH, i2c_data); + if ((i2c_data[0] != min) || (i2c_data[1] != max)) + pr_err("%s: VALRT_TH is not valid (0x%02d%02d ? 0x%02d%02d)\n", + __func__, i2c_data[1], i2c_data[0], max, min); +} + +static void max17047_alert_init(struct max17047_fuelgauge_data *fg_data) +{ + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_debug("%s\n", __func__); + + /* SALRT Threshold setting */ + /* min 1%, max disable */ + max17047_set_salrt(fg_data, 0x01, 0xFF); + + /* TALRT Threshold setting */ + /* min disable, max disable */ + max17047_set_talrt(fg_data, 0x80, 0x7F); + + /* VALRT Threshold setting */ + /* min disable, max disable */ + max17047_set_valrt(fg_data, 0x00, 0xFF); + + /* Enable SOC alerts */ + max17047_i2c_read(client, MAX17047_REG_CONFIG, i2c_data); + i2c_data[0] |= (0x1 << 2); + max17047_i2c_write(client, MAX17047_REG_CONFIG, i2c_data); +} + +static void max17047_reg_init(struct max17047_fuelgauge_data *fg_data) +{ + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_debug("%s\n", __func__); + + if (max17047_i2c_read(client, MAX17047_REG_FILTERCFG, i2c_data) < 0) + return; + + /* Clear average vcell (12 sec) */ + i2c_data[0] &= 0x8f; + + max17047_i2c_write(client, MAX17047_REG_FILTERCFG, i2c_data); + + i2c_data[0] = 0xd9; + i2c_data[1] = 0x35; + max17047_i2c_write(client, MAX17047_REG_CGAIN, i2c_data); +} + +static void max17047_update_work(struct work_struct *work) +{ + struct max17047_fuelgauge_data *fg_data = container_of(work, + struct max17047_fuelgauge_data, + update_work.work); + struct power_supply *battery_psy; + struct i2c_client *client = fg_data->client; + union power_supply_propval value; + pr_debug("%s\n", __func__); + +#ifdef CONFIG_SLP + battery_psy = &fg_data->fuelgauge; +#else + battery_psy = power_supply_get_by_name("battery"); +#endif + + max17047_get_vcell(client); + max17047_get_vfocv(client); + max17047_get_avgvcell(client); + max17047_get_rawsoc(client); + max17047_get_soc(client); + + pr_info("%s: VCELL(%d), VFOCV(%d), AVGVCELL(%d), RAWSOC(%d), SOC(%d)\n", + __func__, fg_data->vcell, + fg_data->vfocv, fg_data->avgvcell, + fg_data->rawsoc, fg_data->soc); + + max17047_test_read(fg_data); + + if (!battery_psy || !battery_psy->set_property) { + pr_err("%s: fail to get battery power supply\n", __func__); + return; + } + + battery_psy->set_property(battery_psy, + POWER_SUPPLY_PROP_STATUS, + &value); + + wake_lock_timeout(&fg_data->update_wake_lock, HZ); +} + +#ifdef DEBUG_FUELGAUGE_POLLING +static void max17047_polling_work(struct work_struct *work) +{ + struct max17047_fuelgauge_data *fg_data = container_of(work, + struct max17047_fuelgauge_data, + polling_work.work); + int reg; + int i; + u8 data[2]; + u8 buf[512]; + + max17047_get_vcell(fg_data->client); + max17047_get_vfocv(fg_data->client); + max17047_get_avgvcell(fg_data->client); + max17047_get_rawsoc(fg_data->client); + max17047_get_soc(fg_data->client); + + pr_info("%s: VCELL(%d), VFOCV(%d), AVGVCELL(%d), RAWSOC(%d), SOC(%d)\n", + __func__, fg_data->vcell, + fg_data->vfocv, fg_data->avgvcell, + fg_data->rawsoc, fg_data->soc); + + max17047_test_read(fg_data); + + schedule_delayed_work(&fg_data->polling_work, + msecs_to_jiffies(MAX17047_POLLING_INTERVAL)); +} +#endif + +static enum power_supply_property max17047_fuelgauge_props[] = { + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_AVG, + POWER_SUPPLY_PROP_CAPACITY, + POWER_SUPPLY_PROP_TEMP, +}; + +static int max17047_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + struct max17047_fuelgauge_data *fg_data = container_of(psy, + struct max17047_fuelgauge_data, + fuelgauge); + switch (psp) { + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + switch (val->intval) { + case VOLTAGE_TYPE_VCELL: + val->intval = max17047_get_vcell(fg_data->client); + break; + case VOLTAGE_TYPE_VFOCV: + val->intval = max17047_get_vfocv(fg_data->client); + break; + default: + val->intval = max17047_get_vcell(fg_data->client); + break; + } + break; + case POWER_SUPPLY_PROP_VOLTAGE_AVG: + val->intval = max17047_get_avgvcell(fg_data->client); + break; + /* Current (mA) */ + case POWER_SUPPLY_PROP_CURRENT_NOW: + val->intval = get_fuelgauge_value(fg_data->client, FG_CURRENT); + break; + /* Average Current (mA) */ + case POWER_SUPPLY_PROP_CURRENT_AVG: + val->intval = get_fuelgauge_value(fg_data->client, FG_CURRENT_AVG); + break; + case POWER_SUPPLY_PROP_CAPACITY: + switch (val->intval) { + case SOC_TYPE_ADJUSTED: + /*val->intval = max17047_get_soc(fg_data->client);*/ + val->intval = get_fuelgauge_soc(fg_data->client) / 10; + break; + case SOC_TYPE_RAW: + val->intval = max17047_get_rawsoc(fg_data->client); + break; + case SOC_TYPE_FULL: + val->intval = fg_data->full_soc; + break; + default: + val->intval = get_fuelgauge_soc(fg_data->client) / 10; + break; + } + break; + case POWER_SUPPLY_PROP_TEMP: + val->intval = max17047_get_temperature(fg_data->client); + break; + default: + return -EINVAL; + } + + return 0; +} + +static int max17047_reset_soc(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + u8 data[2]; + int vfocv, fullcap; + + /* delay for current stablization */ + msleep(500); + + dev_info(&client->dev, + "%s: Before quick-start - VCELL(%d), VFOCV(%d), VfSOC(%d), RepSOC(%d)\n", + __func__, max17047_get_vcell(client), max17047_get_vfocv(client), + fg_read_vfsoc(client), max17047_get_soc(client)); + dev_info(&client->dev, + "%s: Before quick-start - current(%d), avg current(%d)\n", + __func__, fg_read_current(client), + fg_read_avg_current(client)); + + if (is_jig_attached == JIG_OFF) { + dev_info(&client->dev, + "%s : Return by No JIG_ON signal\n", __func__); + return 0; + } + + fg_write_register(client, MAX17047_REG_CYCLES, 0); + + if (max17047_i2c_read(client, MAX17047_REG_MISCCFG, data) < 0) { + dev_err(&client->dev, "%s: Failed to read MiscCFG\n", __func__); + return -1; + } + + data[1] |= (0x1 << 2); + if (max17047_i2c_write(client, MAX17047_REG_MISCCFG, data) < 0) { + dev_err(&client->dev, + "%s: Failed to write MiscCFG\n", __func__); + return -1; + } + + msleep(250); + fg_write_register(client, MAX17047_REG_FULLCAP, + fg_battery_data[SDI].Capacity); + msleep(500); + + dev_info(&client->dev, + "%s: After quick-start - VCELL(%d), VFOCV(%d), VfSOC(%d), RepSOC(%d)\n", + __func__, max17047_get_vcell(client), max17047_get_vfocv(client), + fg_read_vfsoc(client), max17047_get_soc(client)); + dev_info(&client->dev, + "%s: After quick-start - current(%d), avg current(%d)\n", + __func__, fg_read_current(client), + fg_read_avg_current(client)); + fg_write_register(client, MAX17047_REG_CYCLES, 0x00a0); + +/* P8 is not turned off by Quickstart @3.4V + * (It's not a problem, depend on mode data) + * Power off for factory test(File system, etc..) */ + vfocv = max17047_get_vfocv(client); + if (vfocv < POWER_OFF_VOLTAGE_LOW_MARGIN) { + dev_info(&client->dev, "%s: Power off condition(%d)\n", + __func__, vfocv); + + fullcap = fg_read_register(client, MAX17047_REG_FULLCAP); + /* FullCAP * 0.009 */ + fg_write_register(client, MAX17047_REG_REMCAP_REP, + (u16)(fullcap * 9 / 1000)); + msleep(200); + dev_info(&client->dev, "%s: new soc=%d, vfocv=%d\n", __func__, + max17047_get_soc(client), vfocv); + } + + dev_info(&client->dev, + "%s: Additional step - VfOCV(%d), VfSOC(%d), RepSOC(%d)\n", + __func__, max17047_get_vfocv(client), + fg_read_vfsoc(client), max17047_get_soc(client)); + + return 0; +} + + +static int max17047_set_property(struct power_supply *psy, + enum power_supply_property psp, + const union power_supply_propval *val) +{ + struct max17047_fuelgauge_data *fg_data = container_of(psy, + struct max17047_fuelgauge_data, + fuelgauge); + + switch (psp) { + case POWER_SUPPLY_PROP_CAPACITY: + max17047_reset_soc(fg_data->client); + break; + case POWER_SUPPLY_PROP_STATUS: + if (val->intval != POWER_SUPPLY_STATUS_FULL) + return -EINVAL; + pr_info("%s: charger full state!\n", __func__); + /* adjust full soc */ + max17047_adjust_fullsoc(fg_data->client); + break; +#if defined(CONFIG_MACH_GC1) + case POWER_SUPPLY_PROP_RCOMP: + if (fg_data->prev_status == val->intval) { + pr_debug("%s: No rcomp change, prev(%d) = cur(%d)\n", + __func__, fg_data->prev_status, val->intval); + } else { + if (val->intval == POWER_SUPPLY_STATUS_CHARGING) + max17047_set_rcomp(fg_data->client, 1); + else + max17047_set_rcomp(fg_data->client, 0); + max17047_get_rcomp(fg_data->client, val->intval); + fg_data->prev_status = val->intval; + } + break; +#endif + default: + return -EINVAL; + } + + return 0; +} + +static irqreturn_t max17047_fuelgauge_isr(int irq, void *data) +{ + struct max17047_fuelgauge_data *fg_data = data; + struct i2c_client *client = fg_data->client; + u8 i2c_data[2]; + pr_info("%s: irq(%d)\n", __func__, irq); + mutex_lock(&fg_data->irq_lock); + + max17047_i2c_read(client, MAX17047_REG_STATUS, i2c_data); + pr_info("%s: MAX17047_REG_STATUS(0x%02x%02x)\n", __func__, + i2c_data[1], i2c_data[0]); + + cancel_delayed_work(&fg_data->update_work); + wake_lock(&fg_data->update_wake_lock); + schedule_delayed_work(&fg_data->update_work, msecs_to_jiffies(1000)); + + mutex_unlock(&fg_data->irq_lock); + return IRQ_HANDLED; +} + +#if defined(CONFIG_TARGET_LOCALE_KOR) +#ifdef CONFIG_DEBUG_FS +static int max17047_debugfs_open(struct inode *inode, struct file *filp) +{ + filp->private_data = inode->i_private; + return 0; +} + +static ssize_t max17047_debugfs_read_registers(struct file *filp, + char __user *buffer, size_t count, loff_t *ppos) +{ + struct max17047_fuelgauge_data *fg_data = filp->private_data; + struct i2c_client *client = NULL; + u8 i2c_data[2]; + int reg = 0; + char *buf; + size_t len = 0; + ssize_t ret; + + if (!fg_data) { + pr_err("%s : fg_data is null\n", __func__); + return 0; + } + + client = fg_data->client; + + if (*ppos != 0) + return 0; + + if (count < sizeof(buf)) + return -ENOSPC; + + buf = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + reg = MAX17047_REG_STATUS; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "status(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = MAX17047_REG_CONFIG; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "config(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = MAX17047_REG_RCOMP; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "rcomp(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = MAX17047_REG_CGAIN; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "cgain(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = MAX17047_REG_SALRT_TH; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "salrt(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = MAX17047_REG_MISCCFG; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "misc(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = 0x39; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "tempc0(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = 0x0F; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "remCap(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + reg = 0x10; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "fullCap(0x%x)=%02x%02x ", reg, i2c_data[1], i2c_data[0]); + + len += snprintf(buf + len, PAGE_SIZE - len, "\n"); + + ret = simple_read_from_buffer(buffer, len, ppos, buf, PAGE_SIZE); + kfree(buf); + + return ret; +} + +static const struct file_operations max17047_debugfs_fops = { + .owner = THIS_MODULE, + .open = max17047_debugfs_open, + .read = max17047_debugfs_read_registers, +}; + +static ssize_t max17047_debugfs_read_defaultdata(struct file *filp, + char __user *buffer, size_t count, loff_t *ppos) +{ + struct max17047_fuelgauge_data *fg_data = filp->private_data; + struct i2c_client *client = NULL; + u8 i2c_data[2]; + int reg = 0; + char *buf; + size_t len = 0; + ssize_t ret; + + if (!fg_data) { + pr_err("%s : fg_data is null\n", __func__); + return 0; + } + + client = fg_data->client; + + if (*ppos != 0) + return 0; + + if (count < sizeof(buf)) + return -ENOSPC; + + buf = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + reg = MAX17047_REG_RCOMP; + max17047_i2c_read(client, reg, i2c_data); + len += snprintf(buf + len, PAGE_SIZE - len, + "rcomp=%02x%02x ", i2c_data[1], i2c_data[0]); + + len += snprintf(buf + len, PAGE_SIZE - len, + "fsoc=%d", fg_data->full_soc); + + len += snprintf(buf + len, PAGE_SIZE - len, "\n"); + + ret = simple_read_from_buffer(buffer, len, ppos, buf, PAGE_SIZE); + kfree(buf); + + return ret; +} + +static const struct file_operations max17047_debugfs_fops2 = { + .owner = THIS_MODULE, + .open = max17047_debugfs_open, + .read = max17047_debugfs_read_defaultdata, +}; +#endif +#endif + +#ifdef CHECK_RCOMP_UPDATE +static void max17047_check_rcomp_update(struct i2c_client *client) +{ + u8 data[2]; + int ret, rcomp; + + /* read rcomp */ + ret = max17047_i2c_read(client, MAX17047_REG_RCOMP, data); + if (ret < 0) + return; + + rcomp = (data[1] << 8) | data[0]; + pr_info("%s: rcomp = 0x%04x\n", __func__, rcomp); + + /* check rcomp update */ + if (rcomp != MAX17047_NEW_RCOMP) { + data[0] = MAX17047_NEW_RCOMP & 0xff; + data[1] = MAX17047_NEW_RCOMP >> 8; + max17047_i2c_write(client, MAX17047_REG_RCOMP, data); + pr_info("%s: set new rcomp = 0x%04x\n", + __func__, MAX17047_NEW_RCOMP); + max17047_i2c_read(client, MAX17047_REG_RCOMP, data); + rcomp = (data[1] << 8) | data[0]; + pr_info("%s: verify rcomp = 0x%04x\n", __func__, rcomp); + } +} +#endif + +static int __devinit max17047_fuelgauge_i2c_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); + struct max17047_fuelgauge_data *fg_data; + struct max17047_platform_data *pdata = client->dev.platform_data; + int ret = -ENODEV; + int rawsoc, firstsoc; + ktime_t current_time; + struct timespec ts; + + pr_info("%s: fuelgauge init\n", __func__); + + if (!pdata) { + pr_err("%s: no platform data\n", __func__); + return -ENODEV; + } + + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) + return -EIO; + + fg_data = kzalloc(sizeof(struct max17047_fuelgauge_data), GFP_KERNEL); + if (!fg_data) + return -ENOMEM; + + fg_data->client = client; + fg_data->pdata = pdata; + fg_client = client; + + i2c_set_clientdata(client, fg_data); + + mutex_init(&fg_data->irq_lock); + + wake_lock_init(&fg_data->update_wake_lock, WAKE_LOCK_SUSPEND, + "fuel-update"); + + /* Initialize full_soc, set this before fisrt SOC reading */ + fg_data->full_soc = FULL_SOC_DEFAULT; + /* first full_soc update */ + rawsoc = max17047_get_rawsoc(fg_data->client); + if (rawsoc > FULL_SOC_DEFAULT) + max17047_adjust_fullsoc(client); + firstsoc = max17047_get_soc(client); + pr_info("%s: rsoc=%d, fsoc=%d, soc=%d\n", __func__, + rawsoc, fg_data->full_soc, firstsoc); + + if (fg_data->pdata->psy_name) + fg_data->fuelgauge.name = + fg_data->pdata->psy_name; + else + fg_data->fuelgauge.name = "max17047-fuelgauge"; + + fg_data->fuelgauge.type = POWER_SUPPLY_TYPE_BATTERY; + fg_data->fuelgauge.properties = max17047_fuelgauge_props; + fg_data->fuelgauge.num_properties = + ARRAY_SIZE(max17047_fuelgauge_props); + fg_data->fuelgauge.get_property = max17047_get_property; + fg_data->fuelgauge.set_property = max17047_set_property; + + ret = power_supply_register(&client->dev, &fg_data->fuelgauge); + if (ret) { + pr_err("%s: failed power supply register\n", __func__); + goto err_psy_reg_fg; + } + + current_time = alarm_get_elapsed_realtime(); + ts = ktime_to_timespec(current_time); + + fg_data->fullcap_check_interval = ts.tv_sec; + + /* Init parameters to prevent wrong compensation */ + fg_data->previous_fullcap = + fg_read_register(fg_data->client, MAX17047_REG_FULLCAP); + + fg_data->previous_vffullcap = + fg_read_register(fg_data->client, MAX17047_REG_FULLCAPNOM); + + max17047_test_read(fg_data); + + if (is_jig_attached == JIG_ON) + fg_reset_capacity_by_jig_connection(fg_data->client); + + /* Initialize fuelgauge alert */ + max17047_alert_init(fg_data); + + INIT_DELAYED_WORK_DEFERRABLE(&fg_data->update_work, + max17047_update_work); + + /* Request IRQ */ + fg_data->irq = gpio_to_irq(fg_data->pdata->irq_gpio); + ret = gpio_request(fg_data->pdata->irq_gpio, "fuelgauge-irq"); + if (ret) { + pr_err("%s: failed requesting gpio %d\n", __func__, + fg_data->pdata->irq_gpio); + goto err_irq; + } + gpio_direction_input(fg_data->pdata->irq_gpio); + gpio_free(fg_data->pdata->irq_gpio); + + ret = request_threaded_irq(fg_data->irq, NULL, + max17047_fuelgauge_isr, IRQF_TRIGGER_FALLING, + "max17047-alert", fg_data); + if (ret < 0) { + pr_err("%s: fail to request max17047 irq: %d: %d\n", + __func__, fg_data->irq, ret); + goto err_irq; + } + + ret = enable_irq_wake(fg_data->irq); + if (ret < 0) { + pr_err("%s: failed enable irq wake %d\n", __func__, + fg_data->irq); + goto err_enable_irq; + } + +#ifdef DEBUG_FUELGAUGE_POLLING + INIT_DELAYED_WORK_DEFERRABLE(&fg_data->polling_work, + max17047_polling_work); + schedule_delayed_work(&fg_data->polling_work, 0); +#else + max17047_test_read(fg_data); +#endif + + pr_info("%s: probe complete\n", __func__); + +#if defined(CONFIG_TARGET_LOCALE_KOR) +#ifdef CONFIG_DEBUG_FS + fg_data->fg_debugfs_dir = + debugfs_create_dir("fg_debug", NULL); + if (fg_data->fg_debugfs_dir) { + if (!debugfs_create_file("max17047_regs", 0644, + fg_data->fg_debugfs_dir, + fg_data, &max17047_debugfs_fops)) + pr_err("%s : debugfs_create_file, error\n", __func__); + if (!debugfs_create_file("default_data", 0644, + fg_data->fg_debugfs_dir, + fg_data, &max17047_debugfs_fops2)) + pr_err("%s : debugfs_create_file2, error\n", __func__); + } else + pr_err("%s : debugfs_create_dir, error\n", __func__); +#endif +#endif + + return 0; + +err_enable_irq: + free_irq(fg_data->irq, fg_data); +err_irq: + power_supply_unregister(&fg_data->fuelgauge); +err_psy_reg_fg: + wake_lock_destroy(&fg_data->update_wake_lock); + mutex_destroy(&fg_data->irq_lock); + kfree(fg_data); + return ret; +} + +static int __devexit max17047_fuelgauge_remove(struct i2c_client *client) +{ + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + + wake_lock_destroy(&fg_data->update_wake_lock); + free_irq(fg_data->irq, fg_data); + power_supply_unregister(&fg_data->fuelgauge); +#ifdef DEBUG_FUELGAUGE_POLLING + cancel_delayed_work(&fg_data->polling_work); +#endif + cancel_delayed_work(&fg_data->update_work); + mutex_destroy(&fg_data->irq_lock); + kfree(fg_data); + + return 0; +} + +#ifdef CONFIG_PM +static int max17047_fuelgauge_suspend(struct device *dev) +{ + struct i2c_client *client = container_of(dev, struct i2c_client, dev); + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + struct power_supply *psy = power_supply_get_by_name("battery"); + union power_supply_propval value; + int charge_state, voltage_max, voltage_min; + int valrt_vol; + pr_info("%s\n", __func__); + +#ifdef DEBUG_FUELGAUGE_POLLING + cancel_delayed_work(&fg_data->polling_work); +#endif + +#if !defined(CONFIG_SLP) + /* default disable */ + valrt_vol = 0; + + /* voltage alert recharge voltage */ + if (!psy) { + pr_err("%s: fail to get battery psy\n", __func__); + return 0; + } + psy->get_property(psy, POWER_SUPPLY_PROP_STATUS, &value); + charge_state = value.intval; + + if (charge_state == POWER_SUPPLY_STATUS_FULL) { + psy->get_property(psy, POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + &value); + voltage_max = value.intval; + + /* valrt voltage set as recharge voltage */ + valrt_vol = voltage_max - RECHG_DROP_VALUE; + } else { + psy->get_property(psy, POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + &value); + voltage_min = value.intval; + + /* valrt voltage set as min voltage - 50mV */ + valrt_vol = voltage_min - 50000; + } + + pr_info("%s: charge state(%d), vcell(%d), valrt(%d)\n", __func__, + charge_state, fg_data->vcell, valrt_vol); + + /* set voltage alert */ + max17047_set_valrt(fg_data, (valrt_vol / 1000 / 20), 0xFF); +#endif + + return 0; +} + +static int max17047_fuelgauge_resume(struct device *dev) +{ + struct i2c_client *client = container_of(dev, struct i2c_client, dev); + struct max17047_fuelgauge_data *fg_data = i2c_get_clientdata(client); + pr_info("%s\n", __func__); + +#if !defined(CONFIG_SLP) + /* min disable, max disable */ + max17047_set_valrt(fg_data, 0x00, 0xFF); +#endif + +#ifdef DEBUG_FUELGAUGE_POLLING + schedule_delayed_work(&fg_data->polling_work, 0); +#endif + + return 0; +} +#else +#define max17047_fuelgauge_suspend NULL +#define max17047_fuelgauge_resume NULL +#endif /* CONFIG_PM */ + +static const struct i2c_device_id max17047_fuelgauge_id[] = { + {"max17047-fuelgauge", 0}, + {} +}; + +#ifdef CONFIG_HIBERNATION +static const u16 save_addr[] = { + MAX17047_REG_VALRT_TH, + MAX17047_REG_TALRT_TH, + MAX17047_REG_SALRT_TH, + + MAX17047_REG_TEMPERATURE, + MAX17047_REG_CONFIG, + + MAX17047_REG_LEARNCFG, + MAX17047_REG_FILTERCFG, + MAX17047_REG_MISCCFG, + MAX17047_REG_CGAIN, + MAX17047_REG_RCOMP, + MAX17047_REG_SOC_VF, +}; + + +static int max17047_freeze(struct device *dev) +{ + struct i2c_client *client = container_of(dev, struct i2c_client, dev); + struct max17047_fuelgauge_data *fg_data + = i2c_get_clientdata(client); + int i, j; + + if (fg_data->reg_dump) { + dev_err(dev, "Register dump is not clean.\n"); + return -EINVAL; + } + + fg_data->reg_dump = kzalloc(sizeof(u16) * ARRAY_SIZE(save_addr), + GFP_KERNEL); + if (!fg_data->reg_dump) { + dev_err(dev, "Cannot allocate memory for hibernation dump.\n"); + return -ENOMEM; + } + + for (i = 0, j = 0; i < ARRAY_SIZE(save_addr); i++, j += 2) + max17047_i2c_read(client, save_addr[i] + , &(fg_data->reg_dump[j])); + + return 0; +} + +static int max17047_restore(struct device *dev) +{ + struct i2c_client *client = container_of(dev, struct i2c_client, dev); + struct max17047_fuelgauge_data *fg_data + = i2c_get_clientdata(client); + int i, j; + + if (!fg_data->reg_dump) { + dev_err(dev, "Cannot allocate memory for hibernation dump.\n"); + return -ENOMEM; + } + + for (i = 0, j = 0; i < ARRAY_SIZE(save_addr); i++, j += 2) + max17047_i2c_write(client, save_addr[i] + , &(fg_data->reg_dump[j])); + + kfree(fg_data->reg_dump); + fg_data->reg_dump = NULL; + + return 0; +} +#endif + + + +#ifdef CONFIG_PM +const struct dev_pm_ops max17047_pm = { + .suspend = max17047_fuelgauge_suspend, + .resume = max17047_fuelgauge_resume, +#ifdef CONFIG_HIBERNATION + .freeze = max17047_freeze, + .thaw = max17047_restore, + .restore = max17047_restore, +#endif +}; +#endif + + +MODULE_DEVICE_TABLE(i2c, max17047_fuelgauge_id); + +static struct i2c_driver max17047_i2c_driver = { + .driver = { + .owner = THIS_MODULE, + .name = "max17047-fuelgauge", + .pm = &max17047_pm, + + }, + .probe = max17047_fuelgauge_i2c_probe, + .remove = __devexit_p(max17047_fuelgauge_remove), + .id_table = max17047_fuelgauge_id, +}; + +static int __init max17047_fuelgauge_init(void) +{ + return i2c_add_driver(&max17047_i2c_driver); +} + +static void __exit max17047_fuelgauge_exit(void) +{ + i2c_del_driver(&max17047_i2c_driver); +} + +module_init(max17047_fuelgauge_init); +module_exit(max17047_fuelgauge_exit); + +MODULE_AUTHOR("SangYoung Son <hello.son@samsung.com>"); +MODULE_DESCRIPTION("max17047 Fuel gauge driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/battery/samsung_battery.c b/drivers/battery/samsung_battery.c index ffe10e9..8bc5c7f 100644 --- a/drivers/battery/samsung_battery.c +++ b/drivers/battery/samsung_battery.c @@ -2007,6 +2007,14 @@ static int samsung_battery_set_property(struct power_supply *ps, case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: info->pdata->voltage_min = val->intval; break; +#if defined(CONFIG_MACH_KONA) + case POWER_SUPPLY_PROP_COMPENSATION_3: + info->is_comp_3 = val->intval; + break; + case POWER_SUPPLY_PROP_COMPENSATION_1: + info->is_comp_1 = val->intval; + break; +#endif default: return -EINVAL; } @@ -2037,12 +2045,19 @@ static int samsung_usb_get_property(struct power_supply *ps, return -EINVAL; /* Set enable=1 only if the USB charger is connected */ - val->intval = ((info->charge_virt_state != - POWER_SUPPLY_STATUS_DISCHARGING) && - ((info->cable_type == POWER_SUPPLY_TYPE_USB) || +#if defined(CONFIG_MACH_KONA) + val->intval = (((info->cable_type == POWER_SUPPLY_TYPE_USB) || (info->cable_type == POWER_SUPPLY_TYPE_USB_CDP) || ((info->cable_type == POWER_SUPPLY_TYPE_DOCK) && (info->online_prop == ONLINE_PROP_USB)))); +#else + val->intval = ((info->charge_virt_state != + POWER_SUPPLY_STATUS_DISCHARGING) && + ((info->cable_type == POWER_SUPPLY_TYPE_USB) || + (info->cable_type == POWER_SUPPLY_TYPE_USB_CDP) || + ((info->cable_type == POWER_SUPPLY_TYPE_DOCK) && + (info->online_prop == ONLINE_PROP_USB)))); +#endif return 0; } @@ -2161,9 +2176,11 @@ static __devinit int samsung_battery_probe(struct platform_device *pdev) pr_info("%s: VF detect source: %s\n", __func__, vf_src_name[info->pdata->vf_det_src]); +#if !defined(CONFIG_MACH_KONA) /* recalculate recharge voltage, it depends on max voltage value */ info->pdata->recharge_voltage = info->pdata->voltage_max - RECHG_DROP_VALUE; +#endif pr_info("%s: Recharge voltage: %d\n", __func__, info->pdata->recharge_voltage); diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig index 6c03331..61e680e 100644 --- a/drivers/input/keyboard/Kconfig +++ b/drivers/input/keyboard/Kconfig @@ -563,6 +563,11 @@ config KEYBOARD_W90P910 To compile this driver as a module, choose M here: the module will be called w90p910_keypad. +config SENSORS_HALL + tristate "HALL" + help + Say Y here to enable the HALL. + source "drivers/input/keyboard/cypress/Kconfig" endif diff --git a/drivers/input/keyboard/gpio_keys.c b/drivers/input/keyboard/gpio_keys.c index bf75ef5..b1fddc8 100644 --- a/drivers/input/keyboard/gpio_keys.c +++ b/drivers/input/keyboard/gpio_keys.c @@ -47,10 +47,20 @@ struct gpio_keys_drvdata { unsigned int n_buttons; int (*enable)(struct device *dev); void (*disable)(struct device *dev); +#ifdef CONFIG_SENSORS_HALL + int gpio_flip_cover; + bool flip_cover; + struct delayed_work flip_cover_dwork; +#endif struct gpio_button_data data[0]; /* WARNING: this area can be expanded. Do NOT add any member! */ }; +#ifdef CONFIG_SENSORS_HALL +int flip_cover_open; +extern ts_powered_on; +#endif + /* * SYSFS interface for enabling/disabling keys and switches: * @@ -376,12 +386,36 @@ out: return count; } +#ifdef CONFIG_SENSORS_HALL +static ssize_t hall_detect_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct gpio_keys_drvdata *ddata = dev_get_drvdata(dev); + + if (ddata->flip_cover){ + printk("%s: OPEN",__func__); + sprintf(buf, "OPEN"); + }else{ + printk("%s: CLOSE",__func__); + sprintf(buf, "CLOSE"); + } + + return strlen(buf); +} +#endif + static DEVICE_ATTR(sec_key_pressed, 0664, key_pressed_show, NULL); static DEVICE_ATTR(wakeup_keys, 0664, NULL, wakeup_enable); +#ifdef CONFIG_SENSORS_HALL +static DEVICE_ATTR(hall_detect, 0664, hall_detect_show, NULL); +#endif static struct attribute *sec_key_attrs[] = { &dev_attr_sec_key_pressed.attr, &dev_attr_wakeup_keys.attr, +#ifdef CONFIG_SENSORS_HALL + &dev_attr_hall_detect.attr, +#endif NULL, }; @@ -531,9 +565,16 @@ static void gpio_keys_report_event(struct gpio_button_data *bdata) } } #endif +#ifdef CONFIG_SENSORS_HALL + if(!flip_cover_open && button->code == KEY_POWER){ + printk(KERN_DEBUG" cover closed...ignoring PWR button"); + }else{ +#endif input_event(input, type, button->code, !!state); input_sync(input); - +#ifdef CONFIG_SENSORS_HALL + } +#endif if (button->code == KEY_POWER) printk(KERN_DEBUG"[keys]PWR %d\n", !!state); } @@ -652,11 +693,83 @@ fail2: return error; } +#ifdef CONFIG_SENSORS_HALL +static void flip_cover_work(struct work_struct *work) +{ + struct gpio_keys_drvdata *ddata = + container_of(work, struct gpio_keys_drvdata, + flip_cover_dwork.work); + + ddata->flip_cover = gpio_get_value(ddata->gpio_flip_cover); + + printk(KERN_DEBUG "[keys] %s : %d\n", + __func__, ddata->flip_cover); + + /* input_report_switch(ddata->input, SW_FLIP, ddata->flip_cover); + input_sync(ddata->input);*/ + + flip_cover_open = ddata->flip_cover; + + if(!ts_powered_on && !ddata->flip_cover){ + printk("screen already off\n"); + }else{ + input_report_key(ddata->input, KEY_POWER, 1); + input_sync(ddata->input); + input_report_key(ddata->input, KEY_POWER, 0); + input_sync(ddata->input); + } +} + +static irqreturn_t flip_cover_detect(int irq, void *dev_id) +{ + struct gpio_keys_drvdata *ddata = dev_id; + + cancel_delayed_work_sync(&ddata->flip_cover_dwork); + schedule_delayed_work(&ddata->flip_cover_dwork, HZ / 20); + return IRQ_HANDLED; +} +#endif + static int gpio_keys_open(struct input_dev *input) { struct gpio_keys_drvdata *ddata = input_get_drvdata(input); + +#ifdef CONFIG_SENSORS_HALL + int ret = 0; + int irq = gpio_to_irq(ddata->gpio_flip_cover); + + INIT_DELAYED_WORK(&ddata->flip_cover_dwork, flip_cover_work); + + ret = request_threaded_irq( + irq, NULL, + flip_cover_detect, + IRQF_DISABLED | IRQF_TRIGGER_RISING | + IRQF_TRIGGER_FALLING | IRQF_ONESHOT, + "flip_cover", ddata); + + if (ret) { + printk(KERN_ERR + "keys: failed to request flip cover irq %d gpio %d\n", + irq, ddata->gpio_flip_cover); + goto hall_sensor_error; + } + + ret = enable_irq_wake(irq); + if (ret < 0) { + printk(KERN_ERR + "keys: Failed to Enable Wakeup Source(%d) \n", + ret); + goto hall_sensor_error; + } + + /* update the current status */ + schedule_delayed_work(&ddata->flip_cover_dwork, HZ / 2); - return ddata->enable ? ddata->enable(input->dev.parent) : 0; +hall_sensor_error: + +#endif + + return ddata->enable ? ddata->enable(input->dev.parent) : 0; } static void gpio_keys_close(struct input_dev *input) @@ -690,6 +803,9 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev) ddata->n_buttons = pdata->nbuttons; ddata->enable = pdata->enable; ddata->disable = pdata->disable; +#ifdef CONFIG_SENSORS_HALL + ddata->gpio_flip_cover = pdata->gpio_flip_cover; +#endif mutex_init(&ddata->disable_lock); platform_set_drvdata(pdev, ddata); @@ -698,6 +814,10 @@ static int __devinit gpio_keys_probe(struct platform_device *pdev) input->name = pdata->name ? : pdev->name; input->phys = "gpio-keys/input0"; input->dev.parent = &pdev->dev; +/*#ifdef CONFIG_SENSORS_HALL + input->evbit[0] |= BIT_MASK(EV_SW); + input_set_capability(input, EV_SW, SW_FLIP); +#endif*/ input->open = gpio_keys_open; input->close = gpio_keys_close; diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 8c4ba2a..ec4d775 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -958,6 +958,27 @@ config TOUCHSCREEN_SYNAPTICS_S7301 To compile this driver as a module, choose M here: the module will be called melfas_ts. +config TOUCHSCREEN_SYNAPTICS_S7301_KEYS + bool "S7301 touch key support" + default n + help + Say Y here if you want support for SYNAPTICS S7301 + touchscreen controller Keys. + +config TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND + bool "S7301 touch key workaround" + default n + help + Say Y here if you want support for SYNAPTICS S7301 + touchscreen controller reset control + +config TOUCHSCREEN_SYNAPTICS_S7301_KEYLED + bool "S7301 touch keyled support" + default n + help + Say Y here if you want support for SYNAPTICS S7301 + with GPIO led control + config TOUCHSCREEN_CYTTSP4 tristate "Cypress GEN4 Touchscreen Interface" depends on I2C @@ -974,6 +995,11 @@ config SEC_TOUCHSCREEN_DVFS_LOCK help Say Y here if you want support for lock the cpu frequency. +config SEC_TOUCHSCREEN_SURFACE_TOUCH + tristate "SEC surface touch" + help + Say Y here if you want support for surface touch. + config KEYPAD_MELFAS_TOUCH tristate "Melfas touch keypad support" default n diff --git a/drivers/input/touchscreen/synaptics_fw.h b/drivers/input/touchscreen/synaptics_fw.h index 2cc5314..a5da7325 100644 --- a/drivers/input/touchscreen/synaptics_fw.h +++ b/drivers/input/touchscreen/synaptics_fw.h @@ -1,6 +1,8854 @@ #ifndef __RMI_FW_H #define __RMI_FW_H +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) +const char *rmi_config_ver_button = "00"; + +#if defined(CONFIG_KONA_01_BD) +const u8 rmi_fw_button[] = { + /*0000:*/ 0x82, 0x78, 0x14, 0xfe, 0x00, 0x00, 0x00, 0x05, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, + /*0010:*/ 0x53, 0x37, 0x33, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0020:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0030:*/ 0x44, 0x53, 0x34, 0x20, 0x52, 0x33, 0x2e, 0x35, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0040:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0050:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0060:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0070:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0080:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0090:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00a0:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00b0:*/ 0x69, 0x96, 0x7e, 0xd0, 0x20, 0x5a, 0x00, 0x20, 0xc5, 0xc0, 0x2a, 0x79, 0xac, 0x74, 0x2e, 0x45, + /*00c0:*/ 0x57, 0x05, 0x48, 0x7c, 0xd7, 0x03, 0xb0, 0x50, 0xe0, 0x77, 0x3c, 0x8b, 0x79, 0xf6, 0x71, 0x75, + /*00d0:*/ 0xca, 0xec, 0xb0, 0x31, 0x53, 0xaa, 0x37, 0xe9, 0x19, 0x47, 0x46, 0x84, 0xba, 0x28, 0x18, 0xe9, + /*00e0:*/ 0x51, 0x89, 0xe7, 0xce, 0x3e, 0x64, 0x26, 0xa6, 0x25, 0x31, 0xc5, 0x0d, 0x9a, 0xa9, 0x93, 0xfa, + /*00f0:*/ 0x7c, 0x9a, 0x20, 0x17, 0x1a, 0x92, 0x35, 0xa6, 0x9a, 0x75, 0xa0, 0x23, 0x4f, 0xb1, 0xec, 0x1e, + /*0100:*/ 0x64, 0xce, 0x5c, 0x97, 0x6f, 0xf6, 0x36, 0x81, 0xf8, 0x90, 0x17, 0xb0, 0x0d, 0x0c, 0xd3, 0x50, + /*0110:*/ 0x2b, 0xb3, 0x37, 0x31, 0xe9, 0x03, 0x0c, 0x63, 0xf1, 0x9e, 0x52, 0x2d, 0xf5, 0xd3, 0x44, 0x87, + /*0120:*/ 0xa3, 0xef, 0xc0, 0x55, 0xf3, 0xca, 0x62, 0x4f, 0xc8, 0x13, 0xbd, 0x20, 0xe6, 0x3a, 0xac, 0xcd, + /*0130:*/ 0x2b, 0x4b, 0x2c, 0x18, 0x21, 0x16, 0xf3, 0xb6, 0xaa, 0x41, 0xe2, 0x66, 0xfc, 0x6f, 0x1f, 0xce, + /*0140:*/ 0x7f, 0x17, 0xdd, 0xfd, 0x49, 0xde, 0x8b, 0x2b, 0xec, 0xf9, 0xe4, 0xed, 0xaf, 0x8c, 0x26, 0xe0, + /*0150:*/ 0xb5, 0x30, 0xde, 0x4b, 0xb9, 0x9e, 0x4d, 0xfe, 0x43, 0x86, 0xce, 0x9e, 0x0b, 0x6f, 0xb9, 0xc8, + /*0160:*/ 0x1e, 0xcb, 0x83, 0xee, 0xdb, 0xf3, 0xcb, 0x5f, 0xa2, 0x9b, 0xba, 0x53, 0x3d, 0xde, 0x85, 0xce, + /*0170:*/ 0xda, 0xdc, 0xfd, 0x86, 0xe6, 0xdc, 0xb0, 0x14, 0xc0, 0x87, 0x68, 0x6d, 0x15, 0x39, 0x99, 0x81, + /*0180:*/ 0xf4, 0x8f, 0xfa, 0x4b, 0x47, 0x53, 0x99, 0x05, 0xe8, 0x9f, 0xd7, 0x8c, 0x0a, 0xdd, 0x12, 0x95, + /*0190:*/ 0xc6, 0xd0, 0xe3, 0xf9, 0x2c, 0xb0, 0xee, 0x4f, 0x50, 0x51, 0x9e, 0x2c, 0x7f, 0x07, 0xd7, 0xd7, + /*01a0:*/ 0xa6, 0xfc, 0x58, 0x56, 0x65, 0x04, 0x49, 0x73, 0x05, 0x3e, 0xd2, 0xe9, 0x37, 0xb8, 0xd7, 0xbc, + /*01b0:*/ 0x79, 0x5f, 0x8c, 0xc7, 0x28, 0xe6, 0x39, 0xef, 0x29, 0x7f, 0x26, 0x52, 0xd8, 0xda, 0x99, 0x4c, + /*01c0:*/ 0x6b, 0x6e, 0x7a, 0xd3, 0x9e, 0x75, 0xca, 0x55, 0xb2, 0x29, 0x88, 0xb8, 0x0b, 0x1d, 0x1c, 0x81, + /*01d0:*/ 0x98, 0x15, 0xf7, 0x59, 0x1d, 0x73, 0xc3, 0x8d, 0x42, 0x5e, 0xce, 0x78, 0x9b, 0x36, 0x49, 0xbe, + /*01e0:*/ 0xad, 0xc9, 0x81, 0xa4, 0x7e, 0x4c, 0xcb, 0x35, 0x52, 0x17, 0xd7, 0x73, 0x29, 0x4e, 0x81, 0xdf, + /*01f0:*/ 0x66, 0x04, 0x1d, 0x49, 0x3f, 0xa0, 0xf2, 0x2f, 0x42, 0xd0, 0xf4, 0xe9, 0x49, 0xae, 0x52, 0xf7, + /*0200:*/ 0xce, 0x67, 0x45, 0x5c, 0x59, 0x91, 0xb0, 0x83, 0xc0, 0x2e, 0xf4, 0x77, 0xcb, 0x65, 0xb5, 0xd3, + /*0210:*/ 0x18, 0x15, 0x9e, 0x05, 0x30, 0x8f, 0xb7, 0xb8, 0x40, 0x1f, 0x71, 0xb1, 0x0f, 0x81, 0x03, 0x89, + /*0220:*/ 0xb7, 0x6d, 0xef, 0x46, 0x6e, 0x45, 0x46, 0xc5, 0xd3, 0x94, 0x92, 0x41, 0xca, 0xc5, 0x32, 0xac, + /*0230:*/ 0x34, 0x10, 0x2b, 0x1a, 0x4f, 0xec, 0x94, 0xcf, 0x91, 0xd9, 0x80, 0xf1, 0x60, 0x9d, 0xe7, 0x63, + /*0240:*/ 0x51, 0xa7, 0xec, 0xe6, 0x1d, 0xf8, 0x38, 0xc7, 0xec, 0xe7, 0x69, 0x08, 0x02, 0x7b, 0x09, 0x89, + /*0250:*/ 0x84, 0x9a, 0xbd, 0x1f, 0x04, 0x9f, 0xf3, 0x20, 0xc8, 0x23, 0x4c, 0xd7, 0x0a, 0x64, 0x47, 0x43, + /*0260:*/ 0xb6, 0xc8, 0xad, 0xb7, 0xd5, 0xa4, 0xb0, 0xea, 0x57, 0x8d, 0xe9, 0x4e, 0x18, 0x81, 0x08, 0x26, + /*0270:*/ 0x68, 0x66, 0xe6, 0x0b, 0xb2, 0x5d, 0xf5, 0xc3, 0xc1, 0xc1, 0x25, 0x84, 0xdd, 0x00, 0x34, 0x10, + /*0280:*/ 0x94, 0xb6, 0xaf, 0x9f, 0x6a, 0xd5, 0x34, 0x1e, 0x9a, 0x42, 0xd0, 0xa7, 0xc9, 0xd7, 0x3f, 0xc3, + /*0290:*/ 0x43, 0xf2, 0x80, 0x94, 0x2e, 0xb9, 0xdb, 0x60, 0x76, 0xc5, 0xf5, 0x6f, 0xe8, 0x83, 0x96, 0x1b, + /*02a0:*/ 0x96, 0x80, 0xed, 0xb4, 0x0b, 0xc3, 0x34, 0x92, 0xa3, 0xe7, 0xb8, 0x07, 0x23, 0x1b, 0x1b, 0x44, + /*02b0:*/ 0x4a, 0x09, 0xf5, 0xb9, 0x50, 0x75, 0xf2, 0xd6, 0x75, 0xae, 0xef, 0xfa, 0x29, 0x4f, 0x7a, 0xf0, + /*02c0:*/ 0xfa, 0x01, 0xf4, 0x0c, 0x67, 0x2c, 0x2d, 0x36, 0x75, 0xfb, 0xe9, 0xaa, 0xf5, 0x4b, 0x87, 0xbb, + /*02d0:*/ 0xb8, 0xe7, 0x62, 0x4f, 0xbb, 0xc1, 0xc7, 0xd6, 0xa4, 0x10, 0xa3, 0xca, 0xb9, 0x80, 0x7a, 0x1e, + /*02e0:*/ 0xb0, 0xc5, 0xaa, 0x84, 0x0e, 0xe8, 0x10, 0x25, 0xa4, 0xd5, 0x1d, 0xc3, 0x2f, 0x11, 0x8e, 0xdc, + /*02f0:*/ 0xae, 0x9d, 0x51, 0x75, 0x40, 0x9e, 0x92, 0xec, 0x94, 0xff, 0x24, 0xbd, 0x00, 0x51, 0x43, 0x15, + /*0300:*/ 0x22, 0x7f, 0x7e, 0x22, 0xfa, 0x57, 0x2b, 0x1c, 0xf3, 0xb1, 0x11, 0x62, 0x0d, 0xb3, 0x68, 0x1a, + /*0310:*/ 0x6f, 0x2c, 0xb1, 0x6a, 0x0a, 0xb6, 0xc0, 0x8e, 0x14, 0x2f, 0x49, 0xd6, 0x65, 0x77, 0xb9, 0xfb, + /*0320:*/ 0x62, 0x78, 0xbf, 0x05, 0x1d, 0x37, 0xc7, 0x59, 0xa0, 0x1a, 0x8e, 0xb3, 0x08, 0x07, 0x69, 0x12, + /*0330:*/ 0x8b, 0xa1, 0x36, 0xd2, 0x42, 0xfe, 0x5a, 0xf7, 0xa6, 0xfd, 0x8b, 0x27, 0x6d, 0x1d, 0x3b, 0x8b, + /*0340:*/ 0xcb, 0xe9, 0x2b, 0x3f, 0xdd, 0xe0, 0xa4, 0x4e, 0x97, 0x41, 0x72, 0x15, 0xfc, 0x7a, 0x40, 0x84, + /*0350:*/ 0x24, 0x56, 0x76, 0xdd, 0x7b, 0xb8, 0xf6, 0xdc, 0x15, 0x01, 0x4a, 0x5f, 0x21, 0xae, 0xc0, 0xbd, + /*0360:*/ 0x14, 0x83, 0x35, 0x64, 0x54, 0x7d, 0xb5, 0x8b, 0xc6, 0x8d, 0xe0, 0x6a, 0xe4, 0x2b, 0x69, 0x49, + /*0370:*/ 0xd1, 0x0b, 0x17, 0x27, 0x09, 0x9a, 0x52, 0x82, 0x57, 0x90, 0x2f, 0x24, 0x43, 0xc3, 0x9d, 0x7d, + /*0380:*/ 0x31, 0x26, 0x6f, 0x54, 0x7d, 0xb6, 0x51, 0x15, 0x47, 0x4e, 0x9e, 0x96, 0x81, 0x29, 0xcb, 0xaa, + /*0390:*/ 0x01, 0xee, 0x77, 0x57, 0xc0, 0xf6, 0xb4, 0xe0, 0xd7, 0x90, 0xa9, 0x44, 0x2c, 0xe3, 0xa9, 0x32, + /*03a0:*/ 0x17, 0x3d, 0x5c, 0xe3, 0xc9, 0x82, 0xb2, 0x56, 0xb3, 0x9b, 0xda, 0xd6, 0x7c, 0x7d, 0x64, 0xd4, + /*03b0:*/ 0xe4, 0x39, 0x0d, 0xcc, 0xf3, 0x02, 0x59, 0xbe, 0x4b, 0x58, 0x4e, 0x1f, 0x47, 0x46, 0x55, 0x97, + /*03c0:*/ 0x67, 0xe7, 0xdc, 0x2f, 0xb1, 0x91, 0x81, 0x0b, 0x46, 0x97, 0x78, 0x25, 0x29, 0xb0, 0x7f, 0xa2, + /*03d0:*/ 0xb9, 0xfa, 0xf4, 0x20, 0x19, 0xab, 0xae, 0xf4, 0x7e, 0x74, 0x92, 0xf3, 0x63, 0x97, 0x05, 0xf4, + /*03e0:*/ 0x8c, 0xc8, 0xfb, 0xa7, 0x6f, 0xdf, 0x2d, 0xa8, 0x80, 0x17, 0x0c, 0x37, 0x6d, 0xe4, 0x97, 0x5b, + /*03f0:*/ 0xa4, 0x1d, 0xda, 0xb7, 0x45, 0xf0, 0xce, 0x7d, 0x31, 0xcc, 0xc2, 0x29, 0x37, 0xd1, 0x8c, 0x3d, + /*0400:*/ 0xcc, 0xa2, 0xf0, 0x70, 0x16, 0x9b, 0x87, 0xc6, 0x97, 0x20, 0x99, 0x8b, 0xb4, 0xb5, 0x39, 0xf7, + /*0410:*/ 0x7c, 0x7f, 0x86, 0x37, 0x79, 0x6e, 0x8b, 0x1b, 0xbf, 0xfb, 0x68, 0xd3, 0xf4, 0x61, 0x58, 0xe5, + /*0420:*/ 0x8a, 0xb0, 0xee, 0x70, 0x06, 0x18, 0x0c, 0x6b, 0x64, 0xf3, 0xb0, 0x64, 0x30, 0xee, 0xd3, 0xd1, + /*0430:*/ 0xa8, 0xe1, 0x30, 0xfc, 0x82, 0x36, 0x67, 0x93, 0x05, 0x6b, 0x4a, 0x33, 0x93, 0x5b, 0x8d, 0xdf, + /*0440:*/ 0xf4, 0x19, 0x3b, 0x85, 0xf0, 0x36, 0xf7, 0x50, 0xaa, 0x5e, 0xf7, 0x83, 0x93, 0x67, 0x78, 0x33, + /*0450:*/ 0x77, 0x3f, 0x9e, 0x34, 0x06, 0x6c, 0xcb, 0xc3, 0x00, 0x7f, 0xea, 0x39, 0x6d, 0xc5, 0x5e, 0x91, + /*0460:*/ 0xb1, 0x00, 0xbe, 0x6f, 0x08, 0x96, 0x01, 0xe4, 0xcb, 0x9f, 0x92, 0x79, 0x50, 0xaa, 0xda, 0x1e, + /*0470:*/ 0xec, 0x12, 0x2b, 0x4b, 0x0a, 0xa3, 0xcf, 0x8c, 0x1f, 0x4b, 0x15, 0xee, 0xec, 0x18, 0xa6, 0xfe, + /*0480:*/ 0xd5, 0x73, 0x82, 0x1d, 0x6e, 0x21, 0x8c, 0xe5, 0xf4, 0x36, 0x83, 0x9e, 0x00, 0x7b, 0x60, 0x9f, + /*0490:*/ 0x0d, 0xb4, 0x60, 0x70, 0xe0, 0x99, 0xc6, 0x55, 0xb9, 0xee, 0x3e, 0x24, 0x06, 0x15, 0x79, 0x0d, + /*04a0:*/ 0xa6, 0xc7, 0x79, 0x97, 0x01, 0x5c, 0x52, 0x38, 0xfa, 0x5b, 0x71, 0x38, 0xfa, 0xbf, 0xa0, 0x2c, + /*04b0:*/ 0x2c, 0x9d, 0x25, 0xfa, 0x70, 0xd7, 0x32, 0xb1, 0x33, 0xb6, 0xcd, 0xcd, 0xcd, 0xf6, 0x97, 0x3b, + /*04c0:*/ 0x3b, 0x0a, 0x33, 0xbb, 0x7a, 0xa5, 0x89, 0x14, 0xa6, 0x15, 0x44, 0xdb, 0x91, 0x07, 0x75, 0x48, + /*04d0:*/ 0xd5, 0x45, 0x46, 0x71, 0x1c, 0xf2, 0x12, 0xbc, 0x61, 0x70, 0x50, 0x56, 0xd3, 0x21, 0x5d, 0xc4, + /*04e0:*/ 0x29, 0x9f, 0x04, 0xfe, 0xe8, 0xdb, 0x77, 0x42, 0xde, 0xf3, 0xef, 0x2b, 0xfb, 0x34, 0xe7, 0x00, + /*04f0:*/ 0x8a, 0x50, 0x40, 0x3f, 0x62, 0x3d, 0x94, 0x49, 0xd2, 0x95, 0x27, 0xec, 0x86, 0xcd, 0xa2, 0x05, + /*0500:*/ 0xac, 0xfe, 0xb0, 0x83, 0xee, 0x52, 0x05, 0x7c, 0x40, 0x27, 0x4b, 0xc7, 0x93, 0xaa, 0x92, 0xce, + /*0510:*/ 0x72, 0x70, 0x8d, 0x9a, 0x5b, 0x88, 0x6b, 0x59, 0xa7, 0x61, 0xf7, 0x12, 0xe8, 0x61, 0xb6, 0x23, + /*0520:*/ 0xe8, 0xd3, 0xfc, 0x6a, 0xec, 0x4a, 0x05, 0xcd, 0x49, 0x74, 0xf4, 0xcb, 0x0e, 0xe3, 0x95, 0x95, + /*0530:*/ 0x0e, 0xc3, 0xd7, 0x9e, 0xb6, 0x6e, 0xcb, 0x4f, 0xdc, 0xe3, 0x3d, 0x87, 0x23, 0x3a, 0xc8, 0x8d, + /*0540:*/ 0x4f, 0x7b, 0xd8, 0xe9, 0x12, 0x46, 0x92, 0x0c, 0x75, 0xe0, 0x6b, 0x35, 0xf1, 0x82, 0xbc, 0xbb, + /*0550:*/ 0x09, 0x3f, 0xf9, 0xa7, 0xb6, 0x29, 0x62, 0x64, 0x09, 0x02, 0x5b, 0xf7, 0x47, 0xac, 0x69, 0xe5, + /*0560:*/ 0xb9, 0x7a, 0x6a, 0x7b, 0xb1, 0xad, 0xf4, 0x5f, 0xa4, 0x2c, 0x31, 0x06, 0x69, 0x63, 0x25, 0x32, + /*0570:*/ 0x75, 0x35, 0x95, 0x06, 0x41, 0xf8, 0x40, 0xce, 0x35, 0x2c, 0xad, 0x9b, 0xfb, 0xc0, 0x87, 0xed, + /*0580:*/ 0xe9, 0xd9, 0xe1, 0x65, 0x45, 0xc1, 0x98, 0x87, 0x0f, 0x2d, 0xc9, 0x38, 0xbc, 0x24, 0xdb, 0xa7, + /*0590:*/ 0x51, 0xae, 0x04, 0xa8, 0x3e, 0x1f, 0xab, 0xd4, 0xbb, 0x00, 0x08, 0x93, 0xc3, 0xcf, 0x15, 0x94, + /*05a0:*/ 0x2c, 0xd9, 0xa4, 0x0f, 0xb1, 0xc4, 0xda, 0xc6, 0xac, 0x24, 0x17, 0x8a, 0xda, 0xab, 0x4e, 0xa7, + /*05b0:*/ 0xeb, 0xeb, 0xc2, 0xdd, 0x01, 0x51, 0xfd, 0xc2, 0xf9, 0x3a, 0x2b, 0x97, 0x19, 0x3f, 0x1a, 0x84, + /*05c0:*/ 0x65, 0x14, 0xd6, 0xac, 0xf8, 0xbd, 0xe5, 0xa3, 0xb4, 0x19, 0x4b, 0xbe, 0x02, 0xe7, 0x71, 0xff, + /*05d0:*/ 0x14, 0xbe, 0xfa, 0x49, 0x20, 0x50, 0x74, 0x43, 0x68, 0x23, 0x86, 0x4b, 0xe3, 0xbe, 0x4d, 0x16, + /*05e0:*/ 0x93, 0xd0, 0xcf, 0xa5, 0x5a, 0x56, 0x0a, 0x4e, 0x05, 0xf0, 0x24, 0xf0, 0xe9, 0xbb, 0xf3, 0xd2, + /*05f0:*/ 0xcf, 0xaa, 0x1d, 0x6b, 0x99, 0x31, 0x79, 0xd8, 0x26, 0xc8, 0x0a, 0xa4, 0x32, 0xb1, 0xe2, 0x0c, + /*0600:*/ 0xaa, 0xb4, 0xe0, 0x05, 0xc4, 0x60, 0xb9, 0xdf, 0xad, 0x95, 0x51, 0x29, 0xbc, 0xa8, 0xcb, 0xae, + /*0610:*/ 0xc3, 0x75, 0xbf, 0x42, 0x8f, 0x02, 0xe8, 0xf1, 0x74, 0x2a, 0x93, 0x98, 0xce, 0x7e, 0x13, 0xd5, + /*0620:*/ 0xd6, 0x2c, 0xd5, 0x08, 0x45, 0xe2, 0x6d, 0xe1, 0x2a, 0x63, 0x8d, 0xa4, 0x3e, 0xab, 0x73, 0x6d, + /*0630:*/ 0x4c, 0x06, 0xf8, 0x44, 0x5a, 0xb1, 0x65, 0x0f, 0x1d, 0xf3, 0xcd, 0xf2, 0x3e, 0xde, 0xa2, 0x12, + /*0640:*/ 0xe6, 0x1c, 0xbd, 0x84, 0x65, 0x13, 0xb5, 0x3c, 0x9a, 0xa8, 0x17, 0xc3, 0x9e, 0xb4, 0xab, 0x52, + /*0650:*/ 0x30, 0x4c, 0x0a, 0xc2, 0xff, 0x20, 0x4b, 0xb4, 0x8e, 0xf9, 0x4a, 0xb6, 0x21, 0xaa, 0x47, 0x68, + /*0660:*/ 0x61, 0x6f, 0x81, 0x0e, 0x36, 0xe7, 0x19, 0x2f, 0x68, 0xbb, 0x18, 0x29, 0xdd, 0xf1, 0xc3, 0x57, + /*0670:*/ 0x9a, 0xe0, 0x66, 0x47, 0xda, 0xe2, 0x24, 0x27, 0xb7, 0x75, 0x6d, 0x99, 0x5f, 0x94, 0x5b, 0xae, + /*0680:*/ 0x60, 0xde, 0xc2, 0x2a, 0xd5, 0x36, 0x24, 0x61, 0x6a, 0x39, 0x08, 0x32, 0x18, 0x04, 0x41, 0x0f, + /*0690:*/ 0x24, 0xc2, 0x4a, 0x5f, 0xa2, 0x32, 0xf6, 0x8a, 0xe4, 0x03, 0x9e, 0x85, 0xb0, 0xe6, 0x5b, 0xeb, + /*06a0:*/ 0x15, 0x21, 0xce, 0xc7, 0xdc, 0x90, 0xfb, 0x22, 0x94, 0xf1, 0x77, 0x1b, 0x60, 0x17, 0x97, 0x6e, + /*06b0:*/ 0x19, 0x51, 0xde, 0xf6, 0x73, 0xa5, 0xf1, 0xf5, 0x71, 0xc5, 0xa2, 0x44, 0x61, 0x20, 0xe3, 0x08, + /*06c0:*/ 0x82, 0xd6, 0x9f, 0xfe, 0xdb, 0x11, 0x10, 0xfb, 0x38, 0x72, 0x9e, 0x3a, 0x1b, 0xa2, 0x28, 0xdb, + /*06d0:*/ 0x37, 0xef, 0xaf, 0x13, 0x6b, 0xde, 0x35, 0xa3, 0xc0, 0x42, 0x2c, 0xd3, 0xe0, 0x11, 0xe9, 0xe4, + /*06e0:*/ 0x94, 0x9c, 0x1e, 0xe4, 0x01, 0x02, 0x22, 0x8c, 0x13, 0x27, 0xda, 0xe6, 0x30, 0x61, 0x67, 0xca, + /*06f0:*/ 0x40, 0x87, 0x06, 0xce, 0x72, 0xa7, 0x14, 0x15, 0xa7, 0xe6, 0xa3, 0x7c, 0x51, 0xb7, 0xdd, 0x3e, + /*0700:*/ 0x2b, 0x8c, 0x7d, 0x56, 0x86, 0xb8, 0x3e, 0x17, 0xe8, 0x73, 0xce, 0xe8, 0x4a, 0xd9, 0xac, 0x9b, + /*0710:*/ 0x2b, 0x09, 0x3a, 0xb0, 0xb3, 0x96, 0xad, 0x98, 0xfd, 0x55, 0xdc, 0x0f, 0xf0, 0x1c, 0xaa, 0x8a, + /*0720:*/ 0xba, 0x6a, 0xfb, 0xf1, 0xac, 0x36, 0x35, 0x02, 0x42, 0x85, 0x6a, 0x81, 0x41, 0x78, 0xe1, 0x75, + /*0730:*/ 0xc2, 0x55, 0x5e, 0x15, 0x4c, 0x99, 0x22, 0xcc, 0x19, 0xc4, 0x91, 0x32, 0x80, 0x70, 0xa6, 0x7a, + /*0740:*/ 0x76, 0xa4, 0xfb, 0xfb, 0xa3, 0x94, 0x5d, 0xc7, 0x01, 0x92, 0x9a, 0xc7, 0xc1, 0x6f, 0x0e, 0x20, + /*0750:*/ 0xbc, 0x3d, 0x84, 0xf7, 0xa9, 0xe5, 0x6d, 0x72, 0x8c, 0x8a, 0x82, 0xfc, 0x53, 0x80, 0xdf, 0x34, + /*0760:*/ 0x82, 0xff, 0x69, 0xcb, 0x33, 0xbc, 0xeb, 0x6c, 0xe4, 0xbd, 0x9d, 0xc4, 0x67, 0xdc, 0x25, 0x55, + /*0770:*/ 0x51, 0xb5, 0x5f, 0xf5, 0x5c, 0xe4, 0x35, 0xfc, 0x55, 0xe5, 0x2d, 0xdf, 0x51, 0x2c, 0xcc, 0x28, + /*0780:*/ 0xaa, 0xe4, 0x7b, 0x5f, 0x87, 0x2a, 0x79, 0x48, 0xf3, 0xf6, 0xaf, 0x22, 0xf1, 0xe3, 0x62, 0x29, + /*0790:*/ 0x31, 0x65, 0x87, 0xef, 0x97, 0xa7, 0x18, 0xf6, 0xf4, 0xc7, 0x71, 0x5d, 0x53, 0xd5, 0x1b, 0x20, + /*07a0:*/ 0x4f, 0x15, 0x4b, 0x20, 0x3a, 0x5d, 0x37, 0xbb, 0x90, 0x80, 0xf3, 0xc2, 0xd0, 0x37, 0xb0, 0xe9, + /*07b0:*/ 0xad, 0xab, 0x28, 0xf4, 0x20, 0x23, 0x3d, 0x53, 0x68, 0xff, 0x00, 0x39, 0x99, 0x17, 0xde, 0xd1, + /*07c0:*/ 0x0d, 0x8d, 0xd9, 0x84, 0x03, 0xb9, 0x2b, 0x20, 0x8c, 0x98, 0x00, 0xbf, 0x59, 0x9c, 0xe8, 0xba, + /*07d0:*/ 0x29, 0x3f, 0xf8, 0x5c, 0x5b, 0xd2, 0xf3, 0x76, 0xf6, 0xac, 0x0b, 0x9e, 0x8d, 0xf4, 0x2a, 0xb2, + /*07e0:*/ 0x4e, 0xaf, 0xb9, 0xe9, 0xd1, 0xb3, 0x40, 0xa6, 0x08, 0xc5, 0x1a, 0x31, 0xb4, 0xd8, 0x05, 0x24, + /*07f0:*/ 0xdf, 0x29, 0xf0, 0xc0, 0xf6, 0x90, 0x0f, 0x0c, 0x72, 0xdb, 0x4d, 0x32, 0xbe, 0xd6, 0x72, 0x57, + /*0800:*/ 0xe3, 0xc3, 0xaa, 0x3c, 0x4b, 0x12, 0xea, 0xc8, 0xf6, 0xb8, 0x0f, 0xdf, 0xa9, 0x21, 0x8a, 0x20, + /*0810:*/ 0xfc, 0x2a, 0x14, 0xa0, 0x9d, 0xb4, 0xea, 0xbf, 0x09, 0xbe, 0xca, 0x32, 0xff, 0xd8, 0xfc, 0x91, + /*0820:*/ 0x2c, 0xf4, 0x58, 0x67, 0x79, 0x4a, 0xb7, 0x0f, 0x9d, 0x30, 0xf9, 0x8d, 0xbd, 0xaf, 0x28, 0x3b, + /*0830:*/ 0xdf, 0x8b, 0xa2, 0x83, 0xb1, 0xef, 0x3a, 0x1a, 0x8e, 0xff, 0x59, 0x1b, 0x25, 0xf7, 0x0f, 0x30, + /*0840:*/ 0x34, 0xc4, 0xbe, 0x4a, 0x41, 0xc4, 0x37, 0xf9, 0x59, 0x07, 0x42, 0x20, 0x28, 0xac, 0xca, 0x32, + /*0850:*/ 0xed, 0xd2, 0x03, 0x06, 0xa7, 0x96, 0x69, 0xb7, 0xe9, 0xde, 0xc8, 0x28, 0x06, 0xd8, 0x4d, 0xe7, + /*0860:*/ 0xab, 0xd5, 0xef, 0x00, 0x0f, 0x45, 0x50, 0xfb, 0x50, 0xbf, 0x79, 0x7d, 0xdc, 0x50, 0xa9, 0xec, + /*0870:*/ 0xbb, 0x92, 0x31, 0xce, 0x44, 0x9c, 0x06, 0x33, 0x8f, 0x39, 0x74, 0x74, 0xf4, 0x6c, 0xd6, 0xa6, + /*0880:*/ 0x8f, 0x50, 0x2b, 0x09, 0x1e, 0xeb, 0x31, 0x98, 0xc6, 0xfc, 0xfc, 0x40, 0x45, 0x45, 0x85, 0x82, + /*0890:*/ 0xa9, 0x4d, 0xd0, 0xfa, 0xd1, 0xe6, 0x0c, 0xda, 0x0a, 0x59, 0x2b, 0x7d, 0x9e, 0x93, 0x4e, 0x41, + /*08a0:*/ 0xce, 0x96, 0xc9, 0x9a, 0x7b, 0xd4, 0x83, 0xe8, 0x43, 0xdb, 0xb5, 0x6d, 0xe8, 0x1a, 0xa6, 0xe8, + /*08b0:*/ 0xf0, 0x5f, 0x7f, 0xf3, 0x40, 0x2c, 0x86, 0xbb, 0x7e, 0xfc, 0xa2, 0x64, 0xef, 0x99, 0xc8, 0xb7, + /*08c0:*/ 0x71, 0x9a, 0x4e, 0xd8, 0xe8, 0x16, 0x5d, 0x29, 0x7d, 0x76, 0x08, 0xdf, 0x0d, 0xde, 0x6b, 0x16, + /*08d0:*/ 0x29, 0xbd, 0xce, 0x46, 0x65, 0x85, 0xc8, 0xcd, 0xf4, 0x39, 0xa5, 0xa6, 0x87, 0xa8, 0x18, 0x85, + /*08e0:*/ 0x6b, 0x60, 0xd7, 0x94, 0xcd, 0x21, 0x04, 0x18, 0x73, 0x58, 0xb3, 0xd4, 0x88, 0x0a, 0xd0, 0x33, + /*08f0:*/ 0x70, 0xe7, 0x80, 0x18, 0x22, 0x48, 0xc4, 0xce, 0x53, 0xac, 0x96, 0x2d, 0xb3, 0x65, 0xd3, 0x6b, + /*0900:*/ 0x1f, 0xb9, 0xb4, 0xd9, 0x24, 0xf0, 0x13, 0x4d, 0xcc, 0x5e, 0x6d, 0xe8, 0x80, 0xce, 0xc8, 0xe4, + /*0910:*/ 0xb3, 0x56, 0x91, 0x7a, 0x27, 0xb0, 0x1a, 0x32, 0x55, 0x49, 0xa0, 0xc4, 0xa5, 0x44, 0xf0, 0xb4, + /*0920:*/ 0x8a, 0x35, 0x0b, 0x45, 0x37, 0xf5, 0x3c, 0xe4, 0x89, 0x46, 0x1a, 0x56, 0xea, 0xc0, 0xd3, 0x8e, + /*0930:*/ 0x65, 0x90, 0x7b, 0x8d, 0x32, 0x65, 0x51, 0x89, 0x8d, 0x96, 0xab, 0x98, 0xb1, 0xd6, 0x71, 0x6e, + /*0940:*/ 0x46, 0xf2, 0x33, 0xe9, 0x37, 0x14, 0xf7, 0x11, 0xd4, 0xa8, 0xbf, 0x2a, 0x22, 0xe9, 0xc7, 0xbd, + /*0950:*/ 0xad, 0x08, 0x95, 0x73, 0xb4, 0x5e, 0x1f, 0x92, 0xfa, 0x9a, 0x1a, 0xe9, 0x77, 0x22, 0xce, 0xa6, + /*0960:*/ 0xd2, 0xc5, 0xa3, 0xf9, 0x41, 0xd8, 0x88, 0x0b, 0xe2, 0x28, 0xf1, 0x7c, 0xda, 0x84, 0x71, 0xd1, + /*0970:*/ 0x00, 0x30, 0x6d, 0x6e, 0x6c, 0xba, 0x38, 0xcd, 0x51, 0x20, 0xe2, 0x85, 0x30, 0xc1, 0x4f, 0xba, + /*0980:*/ 0x8a, 0x89, 0xf2, 0x50, 0x43, 0xf6, 0x1b, 0x4a, 0xa7, 0x2e, 0x8b, 0x67, 0xc4, 0x6d, 0x32, 0x9a, + /*0990:*/ 0xba, 0xfb, 0xa7, 0xb2, 0x3f, 0xa3, 0x2d, 0xc6, 0x7c, 0x64, 0x94, 0xde, 0xcf, 0x27, 0x86, 0x90, + /*09a0:*/ 0xc7, 0xd5, 0xa3, 0x36, 0xa6, 0x10, 0xcb, 0xcd, 0x58, 0x53, 0x0b, 0xa6, 0xb4, 0x46, 0x2a, 0xf7, + /*09b0:*/ 0x28, 0x63, 0x6a, 0x4f, 0x0e, 0xd6, 0x48, 0x3f, 0x93, 0x09, 0x12, 0xb6, 0xd7, 0x4f, 0x59, 0x96, + /*09c0:*/ 0xf9, 0xa7, 0x31, 0x0f, 0x59, 0xe1, 0x27, 0xf1, 0x66, 0x99, 0xe7, 0xb4, 0x04, 0xdb, 0xb0, 0xa0, + /*09d0:*/ 0x41, 0x1c, 0x98, 0x4c, 0xed, 0x04, 0x19, 0x06, 0xd0, 0x4a, 0x94, 0xef, 0x17, 0xf0, 0x65, 0x5b, + /*09e0:*/ 0x47, 0x2e, 0x64, 0x59, 0xb4, 0x45, 0x26, 0x37, 0x21, 0x5a, 0x8a, 0x11, 0xda, 0x41, 0x71, 0x87, + /*09f0:*/ 0x43, 0x3d, 0xe7, 0xb9, 0xaf, 0x7e, 0x81, 0x81, 0xc9, 0xd1, 0xf1, 0x0f, 0x62, 0xcc, 0x35, 0xef, + /*0a00:*/ 0x8d, 0xee, 0x9d, 0x7a, 0x57, 0xa0, 0xad, 0x9b, 0x40, 0xc8, 0x28, 0xbf, 0xa8, 0xf4, 0xf5, 0x37, + /*0a10:*/ 0x60, 0xdb, 0xdb, 0xc8, 0xe5, 0xd1, 0x7b, 0xbc, 0x53, 0x43, 0x8b, 0xf8, 0x10, 0xbe, 0x9d, 0x56, + /*0a20:*/ 0x14, 0x75, 0xcc, 0x66, 0x5b, 0x8c, 0x2b, 0x33, 0xaf, 0xa6, 0xe4, 0x08, 0x29, 0xf6, 0x50, 0x7a, + /*0a30:*/ 0x0d, 0x11, 0xa1, 0xea, 0x30, 0x49, 0x98, 0x8b, 0xa6, 0x4d, 0x29, 0x73, 0x7d, 0xfa, 0x87, 0xc9, + /*0a40:*/ 0x6a, 0x13, 0xfa, 0x75, 0xa0, 0x5a, 0x89, 0xc0, 0xb4, 0x64, 0x96, 0x79, 0x42, 0x6f, 0x30, 0xef, + /*0a50:*/ 0x13, 0x1b, 0xe7, 0x44, 0xec, 0x55, 0xb1, 0x77, 0xa6, 0xd9, 0x63, 0x09, 0xc3, 0x29, 0x95, 0x5f, + /*0a60:*/ 0xee, 0x92, 0xb6, 0x6e, 0xb4, 0xfd, 0xf2, 0x48, 0x35, 0x13, 0x2c, 0xb7, 0x34, 0xd8, 0x2d, 0x6e, + /*0a70:*/ 0xce, 0x21, 0xda, 0xe8, 0x71, 0x86, 0x3a, 0x34, 0x80, 0x5d, 0x59, 0xd5, 0x32, 0x99, 0x95, 0x52, + /*0a80:*/ 0x83, 0xd5, 0x7b, 0xd5, 0xa7, 0xa3, 0x52, 0x48, 0x92, 0xdc, 0x1f, 0x34, 0x84, 0x72, 0x08, 0x5a, + /*0a90:*/ 0xce, 0xb7, 0x02, 0xea, 0xd1, 0x75, 0x39, 0xe2, 0xa5, 0xae, 0x72, 0x56, 0x2b, 0xcc, 0xd1, 0xc8, + /*0aa0:*/ 0x95, 0x54, 0x34, 0x35, 0x94, 0x80, 0xdb, 0x62, 0xbf, 0x1f, 0xe0, 0xbc, 0x0f, 0x43, 0xce, 0xce, + /*0ab0:*/ 0x64, 0xfe, 0xbe, 0x7d, 0xe1, 0xc6, 0x81, 0xfe, 0xa6, 0x2b, 0xd7, 0x02, 0x10, 0x83, 0x03, 0xb6, + /*0ac0:*/ 0x4d, 0x59, 0x5f, 0x12, 0x39, 0x90, 0x2d, 0x0c, 0xd8, 0x29, 0xbc, 0xae, 0xed, 0x41, 0x66, 0x37, + /*0ad0:*/ 0x2c, 0x90, 0xf7, 0xba, 0xf8, 0x09, 0x20, 0x3f, 0x38, 0xd4, 0x7a, 0x24, 0x7b, 0x1a, 0x8b, 0xc6, + /*0ae0:*/ 0x69, 0x2b, 0x4d, 0x15, 0xb3, 0xd7, 0x79, 0x5f, 0x87, 0xe5, 0x48, 0x5d, 0x2a, 0x89, 0x85, 0xd7, + /*0af0:*/ 0x96, 0xf9, 0x39, 0x91, 0xdb, 0x3d, 0x9e, 0x5b, 0x39, 0xe8, 0x3a, 0x29, 0x4c, 0xd1, 0x22, 0xce, + /*0b00:*/ 0x3f, 0xa4, 0xf3, 0xad, 0x28, 0xc2, 0xee, 0xa3, 0x27, 0x19, 0x0a, 0x86, 0x13, 0xeb, 0xcc, 0xc8, + /*0b10:*/ 0x69, 0xbf, 0x46, 0xf7, 0xe4, 0x6d, 0xf8, 0x31, 0xbb, 0xd7, 0x45, 0xfd, 0x0a, 0x68, 0xee, 0x2b, + /*0b20:*/ 0xb5, 0x71, 0xb2, 0xad, 0x5b, 0x80, 0x5e, 0x69, 0x58, 0x11, 0x6a, 0xea, 0x30, 0x88, 0x33, 0xec, + /*0b30:*/ 0xa9, 0xed, 0x2f, 0x8c, 0x95, 0x30, 0xec, 0x4a, 0xc1, 0x47, 0xbd, 0xd0, 0x60, 0x8c, 0x23, 0x0f, + /*0b40:*/ 0x9e, 0x11, 0x62, 0xc6, 0xc2, 0xb4, 0xc6, 0x43, 0x4c, 0xa6, 0x66, 0xe8, 0xbc, 0xed, 0x57, 0xfb, + /*0b50:*/ 0x6d, 0x73, 0x80, 0xd3, 0x5f, 0xe1, 0x90, 0x27, 0xd5, 0x32, 0x20, 0x9d, 0x1f, 0x72, 0x5d, 0xad, + /*0b60:*/ 0xdc, 0xb3, 0x3d, 0x86, 0x75, 0x95, 0x1b, 0x34, 0x52, 0x46, 0x66, 0x58, 0xf6, 0x9a, 0xd7, 0x06, + /*0b70:*/ 0xf0, 0x40, 0x64, 0x55, 0x74, 0xa5, 0x70, 0x56, 0x17, 0x71, 0xe7, 0xee, 0xf8, 0x18, 0x77, 0xdd, + /*0b80:*/ 0x23, 0x78, 0x01, 0xde, 0x3d, 0x5b, 0x97, 0xd1, 0x35, 0x00, 0x94, 0xd9, 0x12, 0xe3, 0x7b, 0x66, + /*0b90:*/ 0xac, 0x58, 0xdb, 0xe8, 0xb0, 0x41, 0x83, 0x3e, 0x7c, 0xdc, 0x04, 0x41, 0x2f, 0xf5, 0x89, 0xce, + /*0ba0:*/ 0xbd, 0xf6, 0xa9, 0x95, 0x20, 0x62, 0x66, 0x5d, 0x6a, 0x1d, 0x08, 0xca, 0x44, 0x80, 0x7e, 0xb0, + /*0bb0:*/ 0xfd, 0x45, 0x82, 0x92, 0x80, 0x52, 0x99, 0x90, 0x16, 0x59, 0xd1, 0x29, 0xa1, 0xf2, 0x56, 0x84, + /*0bc0:*/ 0xa4, 0x5d, 0xdd, 0x82, 0x27, 0x80, 0x17, 0x84, 0x1f, 0x6e, 0x71, 0xb0, 0x7c, 0xb8, 0x39, 0xf6, + /*0bd0:*/ 0x9e, 0x55, 0xe6, 0x85, 0xa6, 0x20, 0x56, 0x6b, 0x8e, 0x4e, 0xd5, 0xd1, 0x93, 0xa3, 0xf8, 0x01, + /*0be0:*/ 0xc5, 0x04, 0x73, 0x76, 0xdd, 0x79, 0x03, 0x50, 0xc3, 0x6f, 0x89, 0x53, 0x97, 0x3e, 0xf9, 0xa4, + /*0bf0:*/ 0xfa, 0xf8, 0xd6, 0x43, 0xcd, 0x98, 0x0d, 0x69, 0xf0, 0xff, 0xa3, 0xd6, 0xb9, 0xa6, 0x0a, 0x59, + /*0c00:*/ 0x87, 0x45, 0x5e, 0x1c, 0x0d, 0x5c, 0xc3, 0x30, 0x1c, 0x69, 0xd0, 0x26, 0xc4, 0x64, 0x9f, 0xd9, + /*0c10:*/ 0xd3, 0xad, 0xbe, 0x19, 0xfd, 0x77, 0x71, 0xdb, 0xa4, 0x60, 0x93, 0x6c, 0x7e, 0xc5, 0x11, 0x41, + /*0c20:*/ 0xab, 0x40, 0xa7, 0x57, 0x70, 0x4b, 0xac, 0x56, 0x21, 0x3e, 0xb7, 0xc3, 0x1e, 0x25, 0xf9, 0xab, + /*0c30:*/ 0x86, 0x8b, 0x56, 0xf1, 0x62, 0x37, 0x24, 0xe3, 0x38, 0xb3, 0x51, 0xa8, 0xcb, 0xaa, 0x09, 0xe8, + /*0c40:*/ 0x81, 0xa2, 0x9e, 0xc6, 0x4e, 0xbe, 0x7b, 0xfd, 0x96, 0x13, 0xb5, 0x2d, 0x7c, 0xf1, 0xa8, 0xf6, + /*0c50:*/ 0x3d, 0x01, 0x2d, 0x8a, 0x8d, 0xf7, 0x8c, 0x0e, 0x6a, 0xf0, 0x00, 0x32, 0xe0, 0x8a, 0xe8, 0xa6, + /*0c60:*/ 0x7a, 0x78, 0xad, 0xcb, 0xef, 0xc8, 0xfe, 0x06, 0x74, 0x04, 0x00, 0xf5, 0xc7, 0xf5, 0x00, 0xca, + /*0c70:*/ 0x9d, 0x50, 0x57, 0x95, 0x29, 0x13, 0x34, 0xe0, 0xa6, 0xad, 0x81, 0x09, 0x9f, 0x76, 0xc1, 0xde, + /*0c80:*/ 0x1b, 0x17, 0xd4, 0x9d, 0xa0, 0x68, 0x1e, 0x6d, 0xd8, 0x3a, 0xe3, 0xa8, 0x9b, 0xfd, 0x55, 0x37, + /*0c90:*/ 0xb9, 0xfb, 0x04, 0x17, 0x8c, 0x91, 0xcc, 0x51, 0xdf, 0x96, 0x51, 0x8d, 0x26, 0x1c, 0x38, 0x0c, + /*0ca0:*/ 0x74, 0x42, 0x6a, 0x48, 0xdb, 0xb0, 0xed, 0xca, 0x95, 0xa5, 0x07, 0x76, 0x39, 0xaa, 0x9d, 0xc1, + /*0cb0:*/ 0xf0, 0xe3, 0x71, 0xce, 0x8c, 0x09, 0x88, 0x63, 0x15, 0x6d, 0x15, 0x3a, 0xdb, 0xaf, 0xad, 0x8f, + /*0cc0:*/ 0x63, 0x64, 0x37, 0x65, 0x63, 0x19, 0x7f, 0x63, 0x8a, 0xb6, 0x21, 0xc9, 0x0b, 0xd3, 0x78, 0x0d, + /*0cd0:*/ 0x21, 0x08, 0x6e, 0x66, 0xf7, 0xd8, 0xfa, 0xdf, 0x1e, 0x67, 0xae, 0xa3, 0x0b, 0xa8, 0xfb, 0xab, + /*0ce0:*/ 0xa6, 0xcb, 0x28, 0x74, 0x47, 0x8e, 0x76, 0xb7, 0xf5, 0xe5, 0x8b, 0xe9, 0x90, 0x26, 0x78, 0xe8, + /*0cf0:*/ 0x88, 0x1a, 0x9b, 0xd6, 0x07, 0xe1, 0x4d, 0xe9, 0xc6, 0xc2, 0x3c, 0x42, 0xa5, 0x7c, 0x03, 0xb1, + /*0d00:*/ 0x40, 0xd8, 0xec, 0xdf, 0x63, 0x90, 0x38, 0x13, 0x17, 0x9a, 0x34, 0x93, 0x93, 0x7d, 0x17, 0x82, + /*0d10:*/ 0xac, 0x78, 0x36, 0x21, 0x8b, 0x13, 0x33, 0xe0, 0xb7, 0xc7, 0xf3, 0x35, 0xff, 0xd7, 0xf5, 0x18, + /*0d20:*/ 0xdc, 0x8f, 0xe9, 0xd3, 0x63, 0xf4, 0x69, 0x5a, 0xc2, 0xf7, 0x70, 0x1d, 0xd6, 0x2e, 0x24, 0x31, + /*0d30:*/ 0x03, 0x3f, 0x71, 0xc5, 0x1b, 0xa1, 0x0a, 0xa0, 0xaa, 0xfb, 0xd3, 0xc4, 0x2d, 0x0c, 0x5d, 0xb4, + /*0d40:*/ 0xf4, 0x69, 0xa2, 0x82, 0xe5, 0xd7, 0x2b, 0x2c, 0xf6, 0x08, 0x1d, 0xb2, 0x14, 0x98, 0x66, 0xc1, + /*0d50:*/ 0x15, 0x0d, 0xc9, 0xcc, 0x1d, 0xc2, 0x54, 0x9b, 0x80, 0x27, 0xec, 0x27, 0x70, 0x4b, 0x5c, 0xee, + /*0d60:*/ 0xc0, 0xd3, 0x3c, 0x68, 0x50, 0x00, 0xf5, 0x80, 0x56, 0x46, 0xc3, 0x30, 0x97, 0xca, 0x5e, 0x72, + /*0d70:*/ 0x50, 0x1d, 0xb2, 0x82, 0x22, 0x73, 0x6f, 0x01, 0xf9, 0xcc, 0x98, 0xf6, 0xc5, 0xdc, 0x75, 0x2e, + /*0d80:*/ 0xa6, 0x96, 0x75, 0x75, 0xf1, 0x61, 0x58, 0x2c, 0x9f, 0x7e, 0x5f, 0xba, 0x7b, 0xe3, 0xfa, 0x47, + /*0d90:*/ 0xf7, 0x8e, 0xc1, 0x0f, 0xeb, 0xf2, 0x7a, 0x4e, 0x35, 0x09, 0x60, 0xf0, 0x38, 0xeb, 0x57, 0x5e, + /*0da0:*/ 0xa3, 0x3f, 0x77, 0x3f, 0xc4, 0xcc, 0xf4, 0xf8, 0xc5, 0x33, 0x19, 0x8e, 0xc8, 0x4a, 0xd1, 0xe5, + /*0db0:*/ 0x17, 0x70, 0xdb, 0xf7, 0x7d, 0xbc, 0x7d, 0xe0, 0x2b, 0x7e, 0x10, 0x66, 0x51, 0x47, 0x64, 0xf9, + /*0dc0:*/ 0x62, 0xcf, 0x37, 0xbb, 0x92, 0xf5, 0xb3, 0xdf, 0x11, 0x37, 0x93, 0x81, 0x6f, 0xd8, 0xb4, 0x74, + /*0dd0:*/ 0x09, 0xcb, 0x36, 0x9e, 0x44, 0xe5, 0xce, 0x3e, 0xfb, 0x3b, 0xaa, 0x1b, 0xfc, 0x46, 0x7b, 0xe6, + /*0de0:*/ 0xb0, 0x86, 0x46, 0xbf, 0xf5, 0xc2, 0xa2, 0xdc, 0x5c, 0x91, 0xa7, 0x9f, 0x1b, 0xdd, 0x9f, 0x58, + /*0df0:*/ 0x12, 0x44, 0xfe, 0x55, 0x85, 0xc3, 0xfc, 0x12, 0x13, 0x3e, 0xf3, 0x7b, 0xd7, 0x47, 0x4d, 0x26, + /*0e00:*/ 0x93, 0x32, 0x45, 0x16, 0xd0, 0x03, 0x66, 0x23, 0xe2, 0x4f, 0x92, 0x21, 0x3c, 0x18, 0x9f, 0x2e, + /*0e10:*/ 0xdd, 0xec, 0x8f, 0xeb, 0x3b, 0xef, 0x26, 0xef, 0x35, 0x98, 0xf3, 0x26, 0x90, 0x3d, 0x01, 0x46, + /*0e20:*/ 0xc4, 0x3d, 0x49, 0x19, 0xc2, 0xc7, 0xc5, 0x57, 0xf1, 0xd4, 0x1d, 0x63, 0xb3, 0xe3, 0xec, 0x29, + /*0e30:*/ 0xb7, 0x8c, 0xa6, 0xb7, 0xae, 0x63, 0x79, 0x5e, 0xc8, 0x02, 0xde, 0x38, 0x4d, 0xee, 0x6e, 0x7e, + /*0e40:*/ 0x0f, 0x70, 0xe2, 0xc0, 0x23, 0x83, 0xf6, 0xd7, 0x9e, 0x53, 0xd5, 0x44, 0x96, 0xb1, 0xfe, 0x0c, + /*0e50:*/ 0xbb, 0x00, 0x6a, 0xb3, 0xab, 0xeb, 0x31, 0xae, 0x6e, 0x63, 0xed, 0x91, 0x16, 0x44, 0x43, 0xd4, + /*0e60:*/ 0x2d, 0xf3, 0x7a, 0x95, 0x5c, 0x93, 0xa9, 0x44, 0x91, 0x7c, 0xb0, 0xc7, 0xdd, 0x92, 0x1c, 0xde, + /*0e70:*/ 0xa6, 0xc3, 0xf1, 0x58, 0x4d, 0x25, 0xcd, 0x88, 0x1a, 0x54, 0xbe, 0x50, 0x2b, 0x9a, 0xfb, 0xbc, + /*0e80:*/ 0xd6, 0x4d, 0x59, 0x2d, 0xcd, 0x76, 0x16, 0x3c, 0x1c, 0xfd, 0x7a, 0xae, 0x41, 0xae, 0xfa, 0x95, + /*0e90:*/ 0xd6, 0xb8, 0x8b, 0xac, 0xa9, 0xee, 0x93, 0x2a, 0x55, 0x21, 0x4b, 0x6c, 0x1a, 0x28, 0x2f, 0x8d, + /*0ea0:*/ 0x9c, 0x42, 0xd0, 0xb0, 0x21, 0x90, 0x0a, 0xce, 0xa5, 0x55, 0x6d, 0x52, 0x8e, 0xb7, 0x98, 0xad, + /*0eb0:*/ 0xd4, 0xdf, 0x48, 0x48, 0x71, 0x7a, 0x66, 0x4a, 0xb2, 0x45, 0x17, 0xab, 0x5b, 0x91, 0x05, 0x7f, + /*0ec0:*/ 0x72, 0xf3, 0xd3, 0x89, 0x1f, 0x81, 0x1f, 0xd4, 0xe8, 0x38, 0x5d, 0x68, 0x24, 0xca, 0x5e, 0xe1, + /*0ed0:*/ 0xd4, 0x9e, 0xac, 0x17, 0x09, 0x0e, 0x88, 0x70, 0x7a, 0xae, 0xc1, 0xc8, 0x94, 0xf5, 0x6b, 0x21, + /*0ee0:*/ 0x69, 0xc5, 0xd2, 0xb6, 0x0b, 0xc7, 0x2e, 0x27, 0x0b, 0xf2, 0xfd, 0x74, 0x8b, 0xd6, 0xd9, 0x7d, + /*0ef0:*/ 0xcd, 0x58, 0x38, 0x20, 0xc8, 0x68, 0x48, 0x08, 0xbd, 0x18, 0x69, 0x0a, 0x4f, 0x04, 0x4e, 0xcf, + /*0f00:*/ 0x43, 0x7c, 0x6f, 0x11, 0x86, 0x5b, 0xbb, 0x5b, 0x25, 0x76, 0x77, 0xf0, 0x7b, 0xbd, 0xc7, 0xd2, + /*0f10:*/ 0x2c, 0x47, 0xf3, 0x13, 0x3c, 0xfd, 0xbc, 0xa3, 0x80, 0x22, 0xcf, 0x18, 0x92, 0x36, 0x09, 0x9a, + /*0f20:*/ 0x96, 0x72, 0x05, 0xb3, 0x67, 0xa2, 0x2a, 0xee, 0x1c, 0x7c, 0x84, 0x37, 0x1c, 0x0d, 0xaa, 0x02, + /*0f30:*/ 0xcd, 0xf6, 0xc6, 0x65, 0x14, 0x2d, 0xcd, 0x18, 0x42, 0xc2, 0x3f, 0xee, 0x09, 0xcd, 0x57, 0xf9, + /*0f40:*/ 0xdd, 0xa9, 0xd4, 0xf1, 0xb3, 0x97, 0x9f, 0xf7, 0xb7, 0x4a, 0x39, 0x9c, 0xb5, 0x64, 0xd2, 0x66, + /*0f50:*/ 0x58, 0x78, 0x69, 0x65, 0xfa, 0x21, 0xfd, 0x1e, 0x0f, 0xe2, 0x37, 0x57, 0xf9, 0x8d, 0x56, 0x34, + /*0f60:*/ 0x76, 0xb4, 0x07, 0xa4, 0x9b, 0xf4, 0x27, 0xf0, 0x26, 0x95, 0x23, 0xf5, 0x6a, 0x35, 0x99, 0x52, + /*0f70:*/ 0xac, 0x40, 0x51, 0xd2, 0xf2, 0x2b, 0x22, 0x54, 0xff, 0x45, 0xda, 0x84, 0x1e, 0x72, 0x53, 0xa3, + /*0f80:*/ 0xb2, 0x9e, 0xc0, 0x6e, 0x68, 0x62, 0xa1, 0x8a, 0x74, 0xa9, 0x90, 0xfa, 0x19, 0xd0, 0x25, 0x13, + /*0f90:*/ 0xd0, 0x3b, 0x59, 0xcd, 0x85, 0x5e, 0xc4, 0x4b, 0x7b, 0x3c, 0xd4, 0xc1, 0x91, 0xa9, 0xc0, 0xce, + /*0fa0:*/ 0x5a, 0xa6, 0xc0, 0x84, 0x0c, 0xea, 0xd5, 0xeb, 0xad, 0x6c, 0x81, 0x12, 0xb4, 0x3d, 0xac, 0x20, + /*0fb0:*/ 0xcc, 0x4c, 0x82, 0xa0, 0xc3, 0x77, 0x01, 0x20, 0xeb, 0xc0, 0xd5, 0x86, 0xa0, 0x79, 0x1f, 0x75, + /*0fc0:*/ 0x27, 0xf6, 0xd4, 0xae, 0x45, 0x0f, 0x42, 0x36, 0x7f, 0x96, 0x8a, 0x9a, 0x6d, 0x65, 0xa7, 0xa3, + /*0fd0:*/ 0x8b, 0x6a, 0xea, 0xb6, 0x72, 0xb8, 0x37, 0x3f, 0x3f, 0x64, 0x64, 0x84, 0xa3, 0x68, 0x44, 0x7a, + /*0fe0:*/ 0x10, 0xe6, 0x9c, 0x54, 0x54, 0x6b, 0xc9, 0x83, 0x88, 0x49, 0x71, 0x25, 0x7a, 0x01, 0x36, 0x15, + /*0ff0:*/ 0x8e, 0x84, 0x8c, 0x41, 0x8a, 0x07, 0xc3, 0x9a, 0x87, 0x16, 0x52, 0xe8, 0xe7, 0x49, 0xd3, 0xc8, + /*1000:*/ 0x8c, 0x4a, 0xfe, 0xd9, 0xd2, 0x8c, 0xac, 0x45, 0xf2, 0xc5, 0x57, 0x73, 0xf7, 0x47, 0x1c, 0x1d, + /*1010:*/ 0x33, 0x2a, 0x16, 0x87, 0xf2, 0xfc, 0xec, 0xcd, 0x41, 0x8f, 0x5e, 0xa4, 0x40, 0x75, 0x75, 0x33, + /*1020:*/ 0xcd, 0x40, 0x13, 0x77, 0xa6, 0xb7, 0x3a, 0xf4, 0xd5, 0x5c, 0x3d, 0x9e, 0xdc, 0xd2, 0x31, 0x4f, + /*1030:*/ 0x6a, 0x4f, 0xae, 0x9b, 0xa4, 0xe7, 0xb6, 0xb9, 0x3c, 0x87, 0x02, 0x5f, 0x48, 0xbe, 0x87, 0xa7, + /*1040:*/ 0x92, 0x52, 0x8f, 0x72, 0x15, 0xbe, 0xce, 0x65, 0xfe, 0x1d, 0x9e, 0xf8, 0x9f, 0xc3, 0x8e, 0x57, + /*1050:*/ 0xbf, 0xa7, 0xe6, 0x8f, 0xb1, 0x50, 0x8c, 0x19, 0x42, 0x8a, 0x4b, 0x6f, 0x4f, 0xcf, 0xe6, 0xd5, + /*1060:*/ 0x0d, 0xa3, 0xe7, 0x02, 0x2a, 0x35, 0x17, 0xc5, 0x74, 0xab, 0xa0, 0x6d, 0xee, 0x58, 0x35, 0x10, + /*1070:*/ 0xc6, 0xb6, 0xf1, 0x9b, 0xe2, 0x1e, 0xfc, 0xb8, 0x95, 0xcb, 0xbb, 0xb2, 0x0a, 0xc2, 0x1c, 0x67, + /*1080:*/ 0xa3, 0x1d, 0x62, 0x44, 0x96, 0xdb, 0x36, 0xf0, 0xfd, 0xd2, 0x48, 0x98, 0x92, 0xdc, 0xec, 0xf4, + /*1090:*/ 0x44, 0x81, 0xf8, 0x3a, 0x6f, 0x1e, 0x24, 0x14, 0x26, 0x0c, 0x15, 0x74, 0xf1, 0x45, 0x8d, 0xfb, + /*10a0:*/ 0xee, 0x32, 0x61, 0x72, 0x28, 0x41, 0xc4, 0x12, 0xc0, 0x37, 0xca, 0x7f, 0x70, 0x86, 0xce, 0xf5, + /*10b0:*/ 0x34, 0xcf, 0xc6, 0x99, 0x5a, 0x74, 0xc9, 0xad, 0xce, 0x7d, 0x35, 0x80, 0x00, 0x47, 0xbf, 0xdd, + /*10c0:*/ 0x49, 0x42, 0xde, 0x17, 0xf1, 0xf2, 0x77, 0x1f, 0x3e, 0x47, 0x7e, 0x18, 0x2a, 0xb5, 0xae, 0x43, + /*10d0:*/ 0x46, 0x7d, 0xa9, 0x10, 0xfa, 0x0a, 0xca, 0x54, 0xf6, 0x03, 0xe0, 0xa2, 0xd3, 0xe5, 0x2b, 0xca, + /*10e0:*/ 0xe5, 0x3b, 0x46, 0xb6, 0xe2, 0x0e, 0x36, 0x71, 0x68, 0xaf, 0x51, 0xc3, 0xd9, 0xeb, 0x64, 0x60, + /*10f0:*/ 0x78, 0x2c, 0xfc, 0x5f, 0x73, 0x1f, 0xa0, 0x8a, 0xa5, 0xe5, 0xc3, 0x90, 0x3e, 0xc8, 0x83, 0x56, + /*1100:*/ 0xda, 0x17, 0xee, 0x23, 0x3b, 0x7a, 0x6d, 0xfe, 0xef, 0xa9, 0xe8, 0x92, 0xc5, 0xa5, 0xd7, 0x5e, + /*1110:*/ 0x11, 0x18, 0xd8, 0xf5, 0x1c, 0xd8, 0x1d, 0x9b, 0x0b, 0x79, 0x91, 0xa3, 0x02, 0x7d, 0xa3, 0x0f, + /*1120:*/ 0xc2, 0xcc, 0xb0, 0x0d, 0xfc, 0x7e, 0xbd, 0x1b, 0xee, 0x42, 0x90, 0x65, 0x20, 0xd8, 0xad, 0x41, + /*1130:*/ 0x6b, 0xba, 0xb0, 0xeb, 0xaa, 0xa4, 0x1b, 0x80, 0x97, 0xa7, 0x88, 0x2e, 0xdc, 0xfd, 0x55, 0x65, + /*1140:*/ 0xe9, 0xf1, 0xb6, 0x9a, 0x27, 0xca, 0x23, 0x30, 0x46, 0x3e, 0x6f, 0x0c, 0x57, 0xc3, 0xd7, 0xca, + /*1150:*/ 0xe3, 0x99, 0xe6, 0x09, 0xa1, 0x5c, 0x72, 0xd8, 0x65, 0x08, 0x21, 0xfe, 0xb0, 0x48, 0xc9, 0xf9, + /*1160:*/ 0x42, 0xad, 0xda, 0x11, 0x70, 0x56, 0x0a, 0xa5, 0x3b, 0xd9, 0xee, 0xc7, 0x30, 0x9b, 0x23, 0xd9, + /*1170:*/ 0xa0, 0x82, 0x8d, 0xe0, 0x77, 0x67, 0x4a, 0x85, 0x8b, 0x52, 0x9a, 0x16, 0xf1, 0x6a, 0x74, 0x96, + /*1180:*/ 0xf7, 0xfe, 0xa6, 0x83, 0x72, 0xb6, 0x82, 0x78, 0x44, 0xd7, 0x51, 0x70, 0x92, 0x8e, 0x64, 0xc3, + /*1190:*/ 0x8c, 0x92, 0x18, 0xc9, 0x7a, 0x4d, 0x7e, 0xd1, 0x11, 0x53, 0xa6, 0x14, 0xed, 0x9c, 0x04, 0x01, + /*11a0:*/ 0xdb, 0x9f, 0xfd, 0x38, 0xc7, 0xf0, 0xb0, 0x70, 0x96, 0x7a, 0x67, 0xdc, 0x19, 0xeb, 0xaf, 0xf9, + /*11b0:*/ 0x25, 0x1f, 0xbc, 0xc0, 0xa4, 0xa8, 0x05, 0x7b, 0x9e, 0xd5, 0xe8, 0x1c, 0xe3, 0x71, 0xab, 0x92, + /*11c0:*/ 0xc9, 0xb4, 0xac, 0xb0, 0xe0, 0xf1, 0x59, 0x0b, 0x58, 0x3e, 0xca, 0x9d, 0x3e, 0xd0, 0xae, 0xeb, + /*11d0:*/ 0x51, 0xf0, 0x3c, 0xc0, 0xb9, 0x0b, 0xda, 0xba, 0x6b, 0xd8, 0x1f, 0x97, 0x68, 0x75, 0xbc, 0x88, + /*11e0:*/ 0x44, 0x5c, 0x37, 0xc7, 0x0c, 0xd7, 0xf1, 0x1d, 0x03, 0xe8, 0x0e, 0xa6, 0xae, 0xd0, 0x66, 0xa4, + /*11f0:*/ 0xd1, 0xf5, 0x52, 0xc8, 0x7b, 0x1e, 0xfe, 0x4b, 0x5d, 0xdd, 0xca, 0xad, 0x21, 0xde, 0x28, 0xf4, + /*1200:*/ 0x98, 0x98, 0x9c, 0xd2, 0x62, 0xd7, 0x00, 0xde, 0x6a, 0xf1, 0xa1, 0xe4, 0x1c, 0xaf, 0x1f, 0x9b, + /*1210:*/ 0x90, 0x8a, 0x40, 0x9d, 0x78, 0x64, 0x75, 0x60, 0xaa, 0xc7, 0xce, 0x63, 0x65, 0x1e, 0x65, 0x74, + /*1220:*/ 0x9b, 0x37, 0xb2, 0xb7, 0x54, 0xc5, 0x6d, 0xce, 0x1d, 0x08, 0x3a, 0x01, 0x07, 0xc1, 0x80, 0x21, + /*1230:*/ 0x1e, 0x25, 0xbe, 0x97, 0xbb, 0x53, 0x3f, 0x8a, 0xcf, 0x1c, 0xfe, 0x7f, 0x93, 0xfb, 0x0c, 0x5a, + /*1240:*/ 0x52, 0xf2, 0x63, 0xba, 0xd0, 0xa5, 0x5b, 0xd8, 0x98, 0xb8, 0x95, 0xd4, 0xc8, 0xb1, 0x04, 0x99, + /*1250:*/ 0x83, 0xb4, 0xcb, 0xe4, 0x3a, 0xea, 0x02, 0x5e, 0x88, 0x6e, 0xfd, 0xf8, 0x79, 0x5f, 0x03, 0x99, + /*1260:*/ 0x56, 0xea, 0x25, 0xc8, 0x08, 0x1b, 0x6a, 0x8d, 0x28, 0xe6, 0x08, 0x47, 0x67, 0xf5, 0xc7, 0x52, + /*1270:*/ 0x60, 0x08, 0x42, 0x5f, 0x58, 0x01, 0x0a, 0xf2, 0xa3, 0xa3, 0x1e, 0x91, 0x17, 0x5d, 0xe8, 0xe4, + /*1280:*/ 0x14, 0x10, 0x67, 0xc3, 0x1c, 0x3e, 0x71, 0x23, 0x45, 0xf3, 0xc9, 0x73, 0xc9, 0xc5, 0x94, 0x67, + /*1290:*/ 0x51, 0x22, 0xa5, 0xf9, 0x45, 0xce, 0x35, 0x20, 0xf7, 0xf7, 0x1a, 0xea, 0x52, 0x25, 0x17, 0xb1, + /*12a0:*/ 0xec, 0xc5, 0x4e, 0xe9, 0x03, 0x8f, 0xc2, 0x0c, 0xa3, 0x00, 0xd9, 0xe8, 0xe8, 0xb2, 0xbe, 0xaf, + /*12b0:*/ 0xcb, 0xda, 0xf8, 0xbe, 0x2d, 0x2e, 0x92, 0x23, 0x3b, 0x9b, 0x27, 0x65, 0x7f, 0x03, 0xc7, 0x8e, + /*12c0:*/ 0x9c, 0x86, 0x66, 0xf4, 0x67, 0xb4, 0x7b, 0x7d, 0x44, 0x73, 0x8e, 0x7e, 0x32, 0x87, 0x58, 0xa9, + /*12d0:*/ 0xcf, 0x92, 0xc8, 0x07, 0x41, 0xc5, 0x41, 0x17, 0x34, 0xed, 0x3b, 0xd6, 0x30, 0xca, 0x66, 0x50, + /*12e0:*/ 0x4a, 0x1e, 0x68, 0xcc, 0x91, 0xe2, 0x78, 0x38, 0xfc, 0x04, 0x72, 0xfb, 0xbb, 0x63, 0x4f, 0x30, + /*12f0:*/ 0xc2, 0xbb, 0x4a, 0xd5, 0xc9, 0x0e, 0x53, 0xc7, 0x5c, 0x83, 0x1d, 0xc0, 0x42, 0x22, 0xfa, 0xba, + /*1300:*/ 0x31, 0xfa, 0x85, 0x75, 0x8e, 0x7b, 0x1b, 0x63, 0x2a, 0x13, 0x2a, 0x33, 0x01, 0x86, 0xc0, 0xdd, + /*1310:*/ 0xfd, 0x14, 0xc5, 0x84, 0x9b, 0xcc, 0xa5, 0x89, 0x31, 0x27, 0x6e, 0x3b, 0xc6, 0xb0, 0xf2, 0x23, + /*1320:*/ 0x61, 0x52, 0x5b, 0x3a, 0xf2, 0x63, 0x3a, 0xc2, 0x6e, 0xaf, 0x98, 0x97, 0x5c, 0xbc, 0xd4, 0xf3, + /*1330:*/ 0xd4, 0x98, 0x25, 0x73, 0xc6, 0xbb, 0x64, 0x85, 0x88, 0x95, 0x0d, 0xcb, 0xaa, 0xfd, 0x57, 0x9c, + /*1340:*/ 0xa8, 0x4f, 0x32, 0xa4, 0xce, 0xf0, 0x0d, 0x1c, 0xac, 0x9a, 0x53, 0x84, 0xb8, 0x4e, 0x48, 0xc0, + /*1350:*/ 0xfb, 0xc2, 0x48, 0x1e, 0x76, 0xb4, 0xf2, 0x7c, 0xde, 0xe1, 0xc4, 0xf4, 0xb7, 0x09, 0x19, 0x7e, + /*1360:*/ 0x0d, 0x40, 0x92, 0xa3, 0x4e, 0x14, 0xcf, 0x15, 0x17, 0x6c, 0x81, 0x55, 0xaa, 0xce, 0xa6, 0x8b, + /*1370:*/ 0xbf, 0xd6, 0x30, 0x06, 0xa0, 0x1b, 0x18, 0x40, 0xca, 0x69, 0xab, 0xe2, 0x3e, 0xa5, 0xf2, 0x85, + /*1380:*/ 0x43, 0x54, 0x76, 0x5d, 0xe3, 0x96, 0xd4, 0x39, 0x47, 0x70, 0x1a, 0x71, 0x94, 0xcd, 0x9d, 0xfa, + /*1390:*/ 0xb0, 0x89, 0xab, 0x7a, 0x2e, 0x49, 0xb5, 0x34, 0x66, 0xbb, 0xdc, 0x6e, 0x5a, 0x1d, 0x65, 0x20, + /*13a0:*/ 0xce, 0x49, 0x1d, 0xeb, 0x73, 0x83, 0x00, 0x05, 0xb0, 0x5a, 0x56, 0xc3, 0xa5, 0x0f, 0x03, 0xb0, + /*13b0:*/ 0xdb, 0xb5, 0xf0, 0x61, 0x2c, 0xfd, 0x37, 0x38, 0x7d, 0xf8, 0xc4, 0x09, 0xd0, 0xf3, 0xdc, 0x62, + /*13c0:*/ 0xca, 0x29, 0x71, 0xb9, 0x44, 0xc4, 0x24, 0x21, 0xc5, 0xfe, 0x9c, 0xd9, 0xd4, 0x89, 0x44, 0x00, + /*13d0:*/ 0x20, 0xae, 0xd9, 0xae, 0xd6, 0xea, 0x5d, 0x04, 0x35, 0x4c, 0x09, 0x47, 0xfa, 0x85, 0x7f, 0x1e, + /*13e0:*/ 0x52, 0x62, 0xb7, 0x8a, 0x05, 0xc5, 0x47, 0x39, 0x2d, 0xe8, 0xf0, 0xf7, 0x57, 0x67, 0xf5, 0xda, + /*13f0:*/ 0x47, 0xe9, 0x10, 0x84, 0xb4, 0xf9, 0x3f, 0x8d, 0xae, 0xdd, 0xce, 0x76, 0xc9, 0xfe, 0x0b, 0x52, + /*1400:*/ 0x63, 0x1d, 0xde, 0x2a, 0x25, 0x54, 0x9c, 0xab, 0x2b, 0x52, 0x30, 0x8c, 0x80, 0xe8, 0x50, 0xe0, + /*1410:*/ 0x2b, 0x6b, 0xf5, 0x42, 0xbc, 0x26, 0x85, 0x9f, 0xd3, 0x9a, 0xbe, 0x41, 0xd2, 0xf1, 0xa6, 0xd7, + /*1420:*/ 0xf2, 0xcd, 0x72, 0xab, 0x8d, 0x4c, 0x46, 0x7b, 0xaf, 0x82, 0x58, 0xd7, 0x2f, 0x16, 0x07, 0x28, + /*1430:*/ 0xf0, 0x3a, 0x7e, 0x85, 0xc3, 0xf3, 0xe8, 0xe5, 0x00, 0x06, 0x00, 0xb5, 0x97, 0x19, 0x9f, 0xde, + /*1440:*/ 0x99, 0x1f, 0xf5, 0x08, 0x97, 0x02, 0x6e, 0x60, 0xc5, 0xa7, 0x77, 0x99, 0xcf, 0x04, 0xa6, 0x2f, + /*1450:*/ 0xb5, 0xca, 0xff, 0x4b, 0xd7, 0xee, 0xcc, 0x90, 0x6c, 0x77, 0xac, 0x95, 0x3f, 0x24, 0xa5, 0x50, + /*1460:*/ 0x00, 0x9d, 0xf5, 0x7e, 0xed, 0x37, 0xa8, 0xd6, 0xd7, 0xf2, 0xf7, 0x14, 0xb8, 0x2e, 0x7e, 0x1f, + /*1470:*/ 0xa3, 0x02, 0xec, 0x4c, 0xf5, 0xc6, 0x7b, 0x03, 0x99, 0x3b, 0x9d, 0xaf, 0xad, 0xe2, 0x44, 0x7c, + /*1480:*/ 0x89, 0xd6, 0xd3, 0x09, 0x0c, 0xed, 0x48, 0x17, 0x3e, 0xcc, 0xce, 0x08, 0x1d, 0x2d, 0x47, 0x36, + /*1490:*/ 0xf8, 0x6c, 0x37, 0xcd, 0x7c, 0xc7, 0xf3, 0x06, 0x17, 0x8c, 0xca, 0xfe, 0x36, 0x4c, 0xb8, 0x10, + /*14a0:*/ 0x08, 0xe6, 0xd5, 0xa8, 0x99, 0x56, 0x48, 0xe0, 0x18, 0x44, 0x72, 0x63, 0x3d, 0x09, 0xd5, 0xd9, + /*14b0:*/ 0x5a, 0xe1, 0x4c, 0x38, 0xd1, 0xdc, 0x0b, 0x47, 0xd3, 0x8a, 0x1a, 0xf8, 0xe8, 0x75, 0x3b, 0x1a, + /*14c0:*/ 0x9c, 0xcb, 0x89, 0x37, 0xc4, 0xa6, 0xa3, 0xbe, 0xf6, 0xe5, 0x40, 0xd3, 0x44, 0x1d, 0xea, 0x92, + /*14d0:*/ 0xfa, 0xf2, 0xd6, 0x0d, 0x52, 0xf0, 0x8c, 0x0b, 0x3a, 0x55, 0x75, 0x7a, 0xfc, 0xef, 0x81, 0xdb, + /*14e0:*/ 0xc5, 0x97, 0x81, 0xe3, 0x32, 0xd8, 0x8a, 0x49, 0xf0, 0x14, 0x28, 0x14, 0xac, 0x7a, 0xc6, 0x21, + /*14f0:*/ 0xe2, 0xa9, 0x61, 0xc4, 0xa5, 0xd2, 0x8d, 0xd6, 0x36, 0xba, 0x4f, 0x20, 0x43, 0xeb, 0xac, 0xef, + /*1500:*/ 0x6a, 0x81, 0x0a, 0x54, 0x37, 0x35, 0x34, 0x09, 0xce, 0xdc, 0x78, 0x43, 0x00, 0xc5, 0x46, 0x0e, + /*1510:*/ 0x17, 0xb1, 0x7a, 0x51, 0x96, 0x54, 0xee, 0x24, 0x32, 0xf9, 0x09, 0x66, 0xff, 0xf6, 0xb9, 0x9f, + /*1520:*/ 0x06, 0xa4, 0x55, 0x8c, 0x3b, 0x9d, 0xcd, 0x31, 0x01, 0x33, 0x61, 0xeb, 0xd3, 0x45, 0x49, 0x34, + /*1530:*/ 0x2e, 0xff, 0xa3, 0x7f, 0xf5, 0xb0, 0x37, 0x00, 0x31, 0x84, 0xb1, 0xa1, 0x9f, 0xa4, 0xdb, 0xc7, + /*1540:*/ 0xa2, 0xd9, 0x23, 0x4c, 0xf0, 0x09, 0x57, 0x9b, 0x4b, 0xbc, 0x6b, 0xe4, 0x15, 0x55, 0x9f, 0x3d, + /*1550:*/ 0x97, 0xa6, 0xab, 0x0a, 0x86, 0xde, 0xd3, 0x83, 0xd2, 0x81, 0x21, 0x75, 0x60, 0x66, 0xd8, 0xa1, + /*1560:*/ 0xd0, 0xdb, 0x08, 0x42, 0xe6, 0xf1, 0xeb, 0x6f, 0x59, 0xe2, 0x0f, 0xd1, 0x00, 0x3a, 0x09, 0x86, + /*1570:*/ 0x61, 0x8f, 0x3c, 0x6d, 0x02, 0x48, 0x41, 0x1a, 0x9b, 0xcd, 0x33, 0xd6, 0xbe, 0x15, 0x88, 0x2a, + /*1580:*/ 0x94, 0xf9, 0xc9, 0xda, 0x03, 0xb3, 0x1c, 0xaa, 0x22, 0x19, 0xa9, 0x9e, 0xdd, 0xe7, 0x7e, 0x92, + /*1590:*/ 0xdf, 0x06, 0xd7, 0x0c, 0xe0, 0x19, 0xa8, 0xec, 0x9a, 0x33, 0xfa, 0x30, 0xa7, 0xe9, 0xc9, 0x3d, + /*15a0:*/ 0x6a, 0x14, 0x89, 0x5b, 0xe9, 0x19, 0xfd, 0xf5, 0xdb, 0xfe, 0x70, 0x4a, 0x09, 0x18, 0x9a, 0x90, + /*15b0:*/ 0x16, 0x88, 0xb2, 0x60, 0x6e, 0x34, 0xa5, 0x22, 0x7e, 0x2d, 0x5a, 0x37, 0x0e, 0xbe, 0x71, 0x7e, + /*15c0:*/ 0x5a, 0xd4, 0x38, 0x0b, 0x25, 0x49, 0x4d, 0x07, 0x47, 0xee, 0x3d, 0xfe, 0x8f, 0x81, 0xdb, 0xb2, + /*15d0:*/ 0xda, 0x0d, 0x71, 0xbc, 0x10, 0x36, 0x69, 0xd5, 0xec, 0xdd, 0x57, 0xc4, 0xeb, 0x52, 0xd6, 0x2c, + /*15e0:*/ 0xce, 0xaf, 0xe7, 0xae, 0xfa, 0xf6, 0x22, 0x8e, 0x72, 0x39, 0xcb, 0x48, 0x0f, 0x76, 0x9c, 0x51, + /*15f0:*/ 0x54, 0x7b, 0x7c, 0x2d, 0x5d, 0x4e, 0x54, 0x82, 0xf4, 0xfd, 0x6b, 0xdf, 0x97, 0xed, 0xec, 0x68, + /*1600:*/ 0xb7, 0x03, 0x26, 0x74, 0x46, 0xcc, 0x3f, 0x6d, 0x49, 0x52, 0xce, 0xe2, 0x82, 0x12, 0x79, 0x85, + /*1610:*/ 0x95, 0xb6, 0x4c, 0x9e, 0x61, 0xd9, 0xc4, 0xaa, 0xd6, 0xcd, 0x0b, 0xad, 0x78, 0xd8, 0xed, 0x07, + /*1620:*/ 0x5c, 0x8b, 0xe4, 0x1c, 0x86, 0x85, 0xf2, 0xee, 0x98, 0x81, 0x4f, 0xa9, 0x74, 0x22, 0xd5, 0x7f, + /*1630:*/ 0xf3, 0x48, 0xec, 0x30, 0xde, 0x23, 0x10, 0xa8, 0x6e, 0x1e, 0xbb, 0x6b, 0x31, 0xd1, 0x26, 0x48, + /*1640:*/ 0xac, 0x4a, 0x19, 0x66, 0xef, 0x2e, 0x5f, 0xd9, 0x7a, 0xc6, 0xfa, 0xc3, 0x06, 0xf0, 0xfe, 0x6c, + /*1650:*/ 0xd3, 0xf5, 0xdd, 0x6b, 0x09, 0x39, 0x17, 0x99, 0x29, 0xff, 0x24, 0x51, 0x3b, 0x06, 0x35, 0x92, + /*1660:*/ 0xda, 0x9f, 0x9f, 0x32, 0x40, 0x5c, 0x05, 0x60, 0x18, 0xd5, 0xb4, 0xd7, 0x9d, 0x7f, 0xd8, 0x5b, + /*1670:*/ 0x3e, 0x67, 0xee, 0xaa, 0x12, 0xd0, 0xd1, 0x61, 0x78, 0x60, 0x28, 0x63, 0xd8, 0x91, 0xe1, 0x86, + /*1680:*/ 0x78, 0x01, 0x62, 0x55, 0xa8, 0x5c, 0x7d, 0xf5, 0x80, 0x97, 0x16, 0xaa, 0xcc, 0x62, 0xec, 0x35, + /*1690:*/ 0x18, 0x53, 0xda, 0xfc, 0x3b, 0x5b, 0x2f, 0xe5, 0xd0, 0xb9, 0xba, 0x31, 0xed, 0xbe, 0xe0, 0xf1, + /*16a0:*/ 0xfa, 0x54, 0x8f, 0x1d, 0x1a, 0xfc, 0xfb, 0xe0, 0xbb, 0x30, 0x0c, 0x6a, 0xf7, 0x80, 0x27, 0xbb, + /*16b0:*/ 0xb2, 0xc3, 0x38, 0xb9, 0x01, 0x2c, 0x93, 0x00, 0xac, 0xb0, 0xef, 0x9a, 0x44, 0x7d, 0xfb, 0x0b, + /*16c0:*/ 0x91, 0x36, 0xac, 0xb7, 0x0a, 0xe9, 0x29, 0xdc, 0x82, 0x8a, 0x76, 0x75, 0x12, 0xec, 0x81, 0x20, + /*16d0:*/ 0x55, 0x2b, 0x67, 0x28, 0xa6, 0x1a, 0x73, 0xde, 0x82, 0xac, 0x0f, 0xa6, 0xd8, 0xa6, 0x96, 0xf7, + /*16e0:*/ 0xe6, 0x27, 0x33, 0xa3, 0x4d, 0x37, 0x66, 0xbd, 0xcf, 0xa3, 0x70, 0x4f, 0xae, 0xb3, 0x55, 0x92, + /*16f0:*/ 0x8b, 0x7c, 0x5f, 0xd3, 0x5e, 0x8a, 0x84, 0xf8, 0x30, 0x95, 0x16, 0xb5, 0xfc, 0xc2, 0x23, 0x25, + /*1700:*/ 0x65, 0xdb, 0x48, 0xcd, 0xfc, 0xc4, 0xbf, 0xca, 0xa3, 0xd3, 0x8b, 0xe4, 0x5c, 0x7a, 0x97, 0x5d, + /*1710:*/ 0xa8, 0xc5, 0xf9, 0x1a, 0x91, 0x60, 0x3b, 0x20, 0x77, 0xe7, 0x35, 0x99, 0x43, 0x47, 0x1c, 0x96, + /*1720:*/ 0x54, 0xeb, 0x9f, 0xc0, 0x7e, 0xb0, 0xcd, 0x9f, 0x62, 0xec, 0x5c, 0xd9, 0x37, 0xc8, 0x4d, 0x92, + /*1730:*/ 0xc0, 0x76, 0xfa, 0x3b, 0xbd, 0x4b, 0xd1, 0x1f, 0x43, 0xd9, 0x55, 0x7a, 0xb8, 0x7c, 0x7b, 0xa3, + /*1740:*/ 0x0c, 0x26, 0x5f, 0x6b, 0x7c, 0x38, 0xc2, 0x72, 0x36, 0xd7, 0xc0, 0x5c, 0x57, 0x69, 0xd1, 0x1a, + /*1750:*/ 0xc6, 0xda, 0x20, 0x3a, 0x2a, 0x43, 0x2b, 0x32, 0x86, 0x37, 0x8d, 0x44, 0x20, 0x0c, 0xcf, 0xb4, + /*1760:*/ 0xe8, 0x7b, 0x38, 0xc2, 0xea, 0x4f, 0xd2, 0xf3, 0xe0, 0x44, 0x11, 0xa4, 0x60, 0x11, 0xea, 0x09, + /*1770:*/ 0x3a, 0x04, 0x0b, 0xe8, 0xcc, 0x55, 0xbf, 0xa2, 0xe7, 0xee, 0x4e, 0xbf, 0xc6, 0x10, 0xbf, 0x0c, + /*1780:*/ 0xb9, 0x24, 0xa9, 0x8c, 0x46, 0x81, 0xc7, 0x44, 0x3e, 0x63, 0x50, 0xce, 0x4c, 0x91, 0xfc, 0xe8, + /*1790:*/ 0x2e, 0x97, 0x76, 0xc5, 0xf4, 0xd0, 0x36, 0x5a, 0x6c, 0x30, 0xfe, 0xc1, 0x02, 0x86, 0x07, 0xd3, + /*17a0:*/ 0xeb, 0x57, 0x6d, 0x43, 0xf9, 0xfa, 0xc7, 0x39, 0xd5, 0xfa, 0x70, 0xa4, 0x55, 0x7c, 0x4e, 0x93, + /*17b0:*/ 0xca, 0xd9, 0x78, 0xcb, 0xa2, 0x1d, 0x79, 0x96, 0x55, 0x16, 0x94, 0x8d, 0x74, 0xda, 0xa5, 0x1c, + /*17c0:*/ 0xf6, 0xa3, 0xcc, 0x33, 0x0e, 0x3a, 0x29, 0xa0, 0xf9, 0x7d, 0x8b, 0x13, 0x6e, 0x7f, 0x02, 0x4a, + /*17d0:*/ 0x50, 0xd3, 0x7c, 0x1e, 0x09, 0x3c, 0xd0, 0x03, 0xad, 0x0d, 0xb2, 0xfa, 0xa1, 0x8b, 0xd3, 0x69, + /*17e0:*/ 0x91, 0x7a, 0x6a, 0xe2, 0x66, 0x1a, 0xe4, 0x3d, 0xdf, 0xab, 0x3f, 0xfa, 0x39, 0xb3, 0x66, 0x0a, + /*17f0:*/ 0x80, 0x1a, 0x07, 0x75, 0xe6, 0xfd, 0x9b, 0x9b, 0xfe, 0xf0, 0x9c, 0x3f, 0x9e, 0x43, 0xc8, 0xe3, + /*1800:*/ 0xbd, 0xb4, 0x32, 0x25, 0x4f, 0x96, 0x8f, 0xba, 0x46, 0x34, 0xdc, 0x9e, 0x18, 0xe8, 0x16, 0x9a, + /*1810:*/ 0xc1, 0x8c, 0x41, 0x16, 0x2d, 0x88, 0x0b, 0x1d, 0x6f, 0x2a, 0xbf, 0x99, 0x85, 0x14, 0xa3, 0x89, + /*1820:*/ 0x86, 0xac, 0xf6, 0xe3, 0x7b, 0xcf, 0x48, 0xec, 0xe0, 0x74, 0xbc, 0x96, 0x95, 0x4d, 0x76, 0x1d, + /*1830:*/ 0x5e, 0x76, 0x49, 0x63, 0x62, 0x75, 0x21, 0x87, 0x4d, 0x62, 0xb3, 0xfe, 0x0b, 0xf5, 0xed, 0x8c, + /*1840:*/ 0x95, 0x9c, 0xd3, 0xc5, 0x5f, 0x14, 0xd8, 0x4e, 0x41, 0xaa, 0xd9, 0x1f, 0xb3, 0x67, 0x35, 0xaf, + /*1850:*/ 0x0d, 0x3a, 0xcb, 0xe5, 0xcc, 0x84, 0xc4, 0xab, 0x45, 0x38, 0xa9, 0x45, 0x66, 0x12, 0x75, 0x93, + /*1860:*/ 0xc0, 0x36, 0x42, 0x88, 0xb6, 0x5e, 0x3f, 0xae, 0x67, 0xe5, 0x5f, 0xe2, 0xc1, 0x93, 0xca, 0x84, + /*1870:*/ 0x55, 0xa1, 0xda, 0xec, 0x53, 0xe8, 0x74, 0xc2, 0xdb, 0x25, 0xdf, 0x8a, 0xfb, 0xfa, 0xf0, 0x14, + /*1880:*/ 0xf7, 0x92, 0x67, 0xbb, 0x0a, 0x5e, 0xfa, 0x53, 0x4f, 0x5f, 0xf9, 0x05, 0x7b, 0xbd, 0x02, 0x3e, + /*1890:*/ 0x30, 0xdf, 0x90, 0xef, 0x3d, 0x84, 0x0b, 0x71, 0x8b, 0x08, 0xc3, 0xae, 0xb7, 0xdb, 0xe1, 0x19, + /*18a0:*/ 0x56, 0x85, 0x65, 0x98, 0x53, 0x32, 0x4b, 0xe7, 0xd5, 0x01, 0x4f, 0x02, 0xf2, 0xa1, 0xb6, 0x61, + /*18b0:*/ 0xf9, 0xa2, 0xd1, 0xb0, 0xb7, 0x87, 0x21, 0x62, 0x60, 0x7a, 0x91, 0x14, 0x7a, 0x11, 0x6d, 0xb4, + /*18c0:*/ 0x79, 0x40, 0xa4, 0x9a, 0x6d, 0xcf, 0xe2, 0x6d, 0x8a, 0xd2, 0x7d, 0xfb, 0x2b, 0x11, 0xfa, 0x92, + /*18d0:*/ 0xe3, 0x6f, 0x47, 0x7f, 0xa2, 0x41, 0x3b, 0x90, 0x36, 0x68, 0x90, 0x96, 0xf3, 0xf5, 0x27, 0xeb, + /*18e0:*/ 0x99, 0x6b, 0x31, 0x5b, 0x94, 0x7d, 0xa6, 0x2d, 0xdf, 0xfd, 0xee, 0x2c, 0x54, 0x59, 0x1c, 0xb7, + /*18f0:*/ 0xa9, 0xd0, 0x9a, 0x43, 0x82, 0x05, 0x47, 0xba, 0x26, 0xe3, 0x7d, 0x98, 0xd9, 0x4e, 0xe9, 0xed, + /*1900:*/ 0xbb, 0x30, 0x27, 0xb0, 0xed, 0xc4, 0x95, 0xb5, 0x64, 0x98, 0x66, 0xe6, 0x44, 0x9d, 0x63, 0x3f, + /*1910:*/ 0xb8, 0xdd, 0x35, 0xed, 0x79, 0x9c, 0x30, 0xd0, 0x5a, 0xfc, 0x14, 0xcf, 0x6b, 0x05, 0x48, 0x5d, + /*1920:*/ 0x35, 0xd7, 0xd6, 0x8c, 0xce, 0xee, 0x21, 0x73, 0x01, 0xeb, 0x8a, 0x14, 0x01, 0x1c, 0xee, 0x8a, + /*1930:*/ 0xbc, 0x7a, 0xbb, 0xbb, 0x7b, 0x89, 0x8a, 0xfa, 0x6a, 0xf8, 0x90, 0x6f, 0x07, 0xba, 0x77, 0x7b, + /*1940:*/ 0x27, 0x01, 0xfd, 0x67, 0x52, 0xcf, 0xf5, 0xc2, 0xa7, 0x2d, 0x79, 0xbf, 0x50, 0x7a, 0xc9, 0x1c, + /*1950:*/ 0x6a, 0x6f, 0x38, 0xa1, 0x76, 0x80, 0x22, 0x01, 0xa8, 0x4e, 0x6c, 0x8d, 0x64, 0x55, 0x63, 0x89, + /*1960:*/ 0xf8, 0xe4, 0x59, 0x37, 0xf7, 0xae, 0x6b, 0x61, 0x98, 0x7e, 0x43, 0xdd, 0xba, 0xf0, 0x07, 0x28, + /*1970:*/ 0x91, 0xe7, 0x8a, 0xf7, 0xe4, 0xaa, 0x86, 0x0b, 0x26, 0x1e, 0x3c, 0x45, 0x9b, 0x84, 0xd0, 0xe0, + /*1980:*/ 0xcf, 0x81, 0x1b, 0x61, 0x9b, 0xef, 0xde, 0x8c, 0xc0, 0xa4, 0x83, 0xe7, 0x31, 0x18, 0xf1, 0x66, + /*1990:*/ 0x2d, 0x65, 0x6f, 0x2e, 0xfb, 0x60, 0x99, 0xa4, 0xbd, 0x20, 0x6b, 0x83, 0xe6, 0x2d, 0x93, 0xbc, + /*19a0:*/ 0x9b, 0xce, 0xa5, 0x1e, 0x9b, 0xda, 0xb4, 0x69, 0x89, 0xb9, 0x42, 0x3a, 0x1a, 0xcc, 0x13, 0x7f, + /*19b0:*/ 0x5e, 0xc6, 0xa2, 0x4c, 0x8a, 0x82, 0xc0, 0x19, 0x2f, 0xe0, 0xac, 0x58, 0xb4, 0xbc, 0x69, 0x2f, + /*19c0:*/ 0x11, 0xa2, 0x85, 0x0b, 0x72, 0x32, 0x74, 0x83, 0x11, 0x58, 0xe0, 0x7a, 0xce, 0x55, 0xda, 0x6e, + /*19d0:*/ 0x2f, 0xe9, 0x6c, 0x62, 0xdc, 0xbd, 0x89, 0x0d, 0xfd, 0x7a, 0x32, 0xb9, 0x28, 0x7a, 0xc2, 0xb6, + /*19e0:*/ 0x10, 0x67, 0xf1, 0x6a, 0xe2, 0x04, 0x17, 0x9d, 0x2d, 0xe0, 0xde, 0xc3, 0xad, 0xff, 0xb6, 0x4b, + /*19f0:*/ 0x11, 0x3d, 0x53, 0x21, 0x6a, 0xe6, 0x30, 0xad, 0x15, 0x7d, 0x13, 0x28, 0x3c, 0xea, 0x29, 0x32, + /*1a00:*/ 0xa7, 0xb6, 0x67, 0x07, 0x1f, 0x0e, 0x72, 0xe8, 0xd7, 0xcf, 0x59, 0xb5, 0x68, 0xf4, 0xb6, 0x81, + /*1a10:*/ 0xed, 0xf5, 0xb8, 0xab, 0xfb, 0xee, 0x6c, 0x94, 0xff, 0x03, 0xa9, 0xc8, 0x1a, 0x30, 0x9b, 0x16, + /*1a20:*/ 0xff, 0x9b, 0x40, 0x57, 0x70, 0x9f, 0xb9, 0xcb, 0xf6, 0x79, 0x88, 0xee, 0x3f, 0xf1, 0xa0, 0x8d, + /*1a30:*/ 0x67, 0x26, 0x90, 0x71, 0x84, 0x34, 0xce, 0x7b, 0xaa, 0x83, 0xd1, 0x00, 0x33, 0xfd, 0x4d, 0x86, + /*1a40:*/ 0x55, 0x53, 0xc0, 0x6b, 0x3a, 0x44, 0xd8, 0xdb, 0x40, 0x24, 0xb8, 0xef, 0x7d, 0x2b, 0x7d, 0x03, + /*1a50:*/ 0x79, 0xaf, 0x0f, 0x86, 0x21, 0x4e, 0x41, 0xc6, 0x60, 0x21, 0x8e, 0x58, 0x26, 0x1b, 0x72, 0xfe, + /*1a60:*/ 0x71, 0x21, 0x0e, 0xa1, 0xd6, 0xf7, 0x41, 0x50, 0x68, 0xca, 0x3f, 0x62, 0xdf, 0xd1, 0x41, 0xe1, + /*1a70:*/ 0xdc, 0xc2, 0x7f, 0x82, 0xd8, 0x6e, 0x3e, 0xf9, 0x30, 0xee, 0x71, 0xcd, 0x1f, 0x0f, 0x4f, 0xb3, + /*1a80:*/ 0x03, 0xfb, 0x20, 0x75, 0x91, 0x1a, 0xbf, 0xb0, 0xc1, 0xc4, 0x65, 0x4b, 0x65, 0x52, 0x2a, 0x13, + /*1a90:*/ 0xb1, 0xb1, 0xc8, 0xe1, 0x9e, 0xc5, 0x78, 0x40, 0xae, 0xf6, 0x57, 0x12, 0xc9, 0x49, 0x24, 0xee, + /*1aa0:*/ 0x87, 0x6b, 0xa0, 0x0c, 0x0f, 0xb1, 0xbe, 0xac, 0xcb, 0x8b, 0xe9, 0x3f, 0x1b, 0xaa, 0x79, 0x9f, + /*1ab0:*/ 0xc4, 0xff, 0xac, 0xf9, 0xf7, 0x53, 0xab, 0xa8, 0xf2, 0x00, 0xc0, 0xa4, 0x24, 0x22, 0x97, 0x58, + /*1ac0:*/ 0x0c, 0x39, 0x96, 0xe2, 0xe9, 0xcf, 0x62, 0xcb, 0x8f, 0xdb, 0xa8, 0xdd, 0x5a, 0x5c, 0xb2, 0xce, + /*1ad0:*/ 0xae, 0x84, 0x2a, 0x68, 0x7c, 0x38, 0x56, 0x78, 0xe1, 0xa6, 0x7c, 0x6b, 0x8b, 0x47, 0x07, 0xe4, + /*1ae0:*/ 0xc7, 0x54, 0x9a, 0x76, 0x34, 0xe5, 0xf5, 0x23, 0x49, 0x15, 0x90, 0x73, 0xa3, 0x0a, 0x5c, 0x4b, + /*1af0:*/ 0x99, 0x6f, 0x7b, 0x0f, 0x61, 0x9e, 0xf9, 0xa5, 0x95, 0x42, 0xbd, 0x19, 0xa5, 0x31, 0x08, 0xdd, + /*1b00:*/ 0x9a, 0x23, 0xdb, 0x2c, 0x19, 0x50, 0xbb, 0xc3, 0x3b, 0x51, 0xec, 0xd9, 0x38, 0x5b, 0x1b, 0x58, + /*1b10:*/ 0x79, 0xfb, 0xa2, 0x94, 0x6a, 0xe1, 0xd9, 0x03, 0x58, 0xd2, 0xb7, 0xfe, 0xc2, 0x99, 0xf4, 0x45, + /*1b20:*/ 0x28, 0x00, 0x11, 0x41, 0x67, 0x09, 0x1a, 0x82, 0x48, 0x11, 0x25, 0x82, 0x66, 0xd9, 0x08, 0xe4, + /*1b30:*/ 0xf3, 0x4f, 0xf1, 0x4c, 0x40, 0x78, 0xb7, 0x40, 0x5f, 0x16, 0xd6, 0x4d, 0x9d, 0x25, 0xcb, 0xff, + /*1b40:*/ 0xe1, 0xe7, 0xaf, 0x0c, 0x5b, 0x9a, 0x57, 0xf6, 0xc1, 0xd0, 0x1c, 0x20, 0x68, 0x9a, 0x51, 0x7a, + /*1b50:*/ 0xbd, 0xcb, 0x96, 0x21, 0x57, 0xe4, 0x70, 0x9d, 0x9c, 0xda, 0xaa, 0x89, 0x0d, 0xc2, 0x53, 0xa9, + /*1b60:*/ 0x6b, 0x78, 0x12, 0xeb, 0x77, 0x4d, 0x5c, 0xe4, 0x5e, 0x2b, 0x30, 0x0f, 0xb3, 0x08, 0x9f, 0x68, + /*1b70:*/ 0xf1, 0xb4, 0x37, 0xac, 0xed, 0x39, 0x0e, 0x59, 0xfa, 0xc4, 0xa8, 0xfa, 0xcc, 0x76, 0x77, 0xba, + /*1b80:*/ 0x15, 0xae, 0xbe, 0x0f, 0x89, 0xb7, 0x3c, 0xf5, 0x27, 0x2c, 0xfc, 0x05, 0xb2, 0x32, 0x40, 0x61, + /*1b90:*/ 0x0d, 0xdd, 0x0a, 0x8a, 0x0c, 0xa5, 0x7e, 0x2c, 0x5e, 0x50, 0x6b, 0xa1, 0x3b, 0x87, 0x23, 0xa0, + /*1ba0:*/ 0xa9, 0x4c, 0x46, 0x4c, 0xfb, 0xe2, 0x39, 0x3a, 0x3b, 0x43, 0x9b, 0x24, 0x8b, 0x4c, 0xae, 0x25, + /*1bb0:*/ 0x81, 0x72, 0x5e, 0xaf, 0xe3, 0x3f, 0x8c, 0x5b, 0x2f, 0xfd, 0x48, 0x61, 0x29, 0x9e, 0xba, 0x76, + /*1bc0:*/ 0x73, 0x3c, 0xeb, 0xeb, 0x30, 0x18, 0xa9, 0x89, 0x4c, 0xbc, 0x09, 0xb6, 0xd7, 0x46, 0x27, 0x76, + /*1bd0:*/ 0x51, 0x41, 0x52, 0x29, 0x2a, 0x73, 0x2d, 0xf0, 0x13, 0x9c, 0x00, 0x38, 0xe1, 0xe6, 0xc7, 0x9c, + /*1be0:*/ 0x7b, 0x07, 0xab, 0xf0, 0xf9, 0x0f, 0xc0, 0xce, 0x6a, 0xba, 0x10, 0x03, 0xfa, 0x55, 0x8b, 0x1a, + /*1bf0:*/ 0xfc, 0xd4, 0xdf, 0x8d, 0xf5, 0x98, 0x7e, 0xf1, 0x70, 0xff, 0x41, 0x9d, 0x66, 0xa3, 0x3a, 0x99, + /*1c00:*/ 0x5e, 0xe2, 0x9f, 0x29, 0x3b, 0xc8, 0xe9, 0x32, 0xb7, 0x1a, 0xb3, 0x47, 0xde, 0x42, 0x2d, 0x37, + /*1c10:*/ 0x2f, 0x13, 0xe6, 0x4a, 0xd8, 0x4d, 0xfc, 0x65, 0x6b, 0xaa, 0xd7, 0x58, 0xab, 0x86, 0x95, 0x88, + /*1c20:*/ 0x36, 0xf8, 0xf9, 0xa6, 0xd6, 0x66, 0xf3, 0xa7, 0x18, 0x62, 0x7d, 0xa3, 0x5f, 0xbe, 0xac, 0xba, + /*1c30:*/ 0x9f, 0x02, 0x3b, 0xa7, 0x43, 0x2a, 0xb5, 0x48, 0x70, 0x76, 0xda, 0xa2, 0x06, 0xb4, 0x67, 0x48, + /*1c40:*/ 0x33, 0xd9, 0x2d, 0xce, 0xd2, 0xe0, 0xd5, 0x3b, 0x81, 0xbb, 0x7a, 0x6a, 0xa9, 0xe5, 0xac, 0x82, + /*1c50:*/ 0x7c, 0x05, 0x7d, 0x93, 0x03, 0x15, 0xc2, 0x8f, 0x14, 0x44, 0xf9, 0xe2, 0xb2, 0x85, 0xfd, 0xe4, + /*1c60:*/ 0x7f, 0xaf, 0x3f, 0x36, 0x1e, 0xdc, 0x0f, 0x81, 0x29, 0x22, 0xfd, 0xb6, 0xf4, 0xa1, 0xef, 0xe2, + /*1c70:*/ 0x28, 0x82, 0xcb, 0x1c, 0x50, 0x4b, 0x68, 0x92, 0xc5, 0x40, 0xba, 0x8f, 0xb0, 0x13, 0x1e, 0xb7, + /*1c80:*/ 0xc4, 0x89, 0x78, 0x90, 0x52, 0x4a, 0x0d, 0xa9, 0x21, 0x25, 0x46, 0x65, 0x6c, 0x3f, 0x44, 0xb6, + /*1c90:*/ 0x6c, 0x6b, 0x91, 0xe2, 0x84, 0x75, 0x33, 0x58, 0x67, 0xf1, 0x19, 0x91, 0xd2, 0x18, 0xdb, 0x6c, + /*1ca0:*/ 0x80, 0x06, 0x8f, 0xb4, 0x13, 0xde, 0x16, 0x1b, 0x70, 0x8e, 0x11, 0x92, 0xfd, 0xa5, 0x38, 0xbf, + /*1cb0:*/ 0x3b, 0x88, 0x8a, 0xec, 0x26, 0xe7, 0x04, 0x47, 0x34, 0x63, 0xcc, 0xcb, 0x57, 0x35, 0x2d, 0xe7, + /*1cc0:*/ 0x77, 0x7c, 0xe3, 0x84, 0xfc, 0xdd, 0x45, 0x3b, 0x45, 0x9e, 0x7c, 0xf8, 0x78, 0x5d, 0x42, 0x09, + /*1cd0:*/ 0x23, 0x9c, 0xf5, 0x8e, 0x95, 0x0a, 0xac, 0x64, 0x35, 0x20, 0x78, 0xca, 0x3e, 0x2b, 0x5f, 0xd5, + /*1ce0:*/ 0xb0, 0x22, 0xc6, 0x3a, 0x9a, 0x6f, 0xa7, 0x57, 0xf6, 0x83, 0xb4, 0xad, 0xe9, 0xd7, 0x0f, 0xaa, + /*1cf0:*/ 0x93, 0x49, 0x6b, 0x04, 0xf9, 0x35, 0x16, 0x37, 0x7f, 0x82, 0xac, 0x7e, 0x87, 0x32, 0x84, 0xef, + /*1d00:*/ 0x1c, 0x06, 0x6a, 0xdc, 0x26, 0x23, 0xcd, 0x39, 0x3c, 0x71, 0xae, 0x7d, 0x08, 0x6d, 0x76, 0xa4, + /*1d10:*/ 0xf0, 0x68, 0xd6, 0x6c, 0xec, 0xc4, 0x10, 0x6c, 0xaf, 0x8e, 0x50, 0x2c, 0xd8, 0x06, 0xcd, 0x19, + /*1d20:*/ 0x05, 0xf8, 0x16, 0x3a, 0x28, 0xb9, 0x2e, 0x00, 0x0b, 0xf9, 0xa9, 0x1b, 0x5a, 0xa5, 0x34, 0x9c, + /*1d30:*/ 0xbe, 0x65, 0xb5, 0xe6, 0xb4, 0xc1, 0x8a, 0xfe, 0x1c, 0x24, 0x0f, 0x7e, 0x91, 0x8c, 0x65, 0x3d, + /*1d40:*/ 0xaa, 0x26, 0x13, 0x91, 0x8b, 0xee, 0xd9, 0x0c, 0xdc, 0xc7, 0x08, 0x21, 0x8c, 0xc4, 0xb7, 0x86, + /*1d50:*/ 0x45, 0xf7, 0x11, 0x35, 0x9d, 0x76, 0x38, 0x81, 0x6c, 0xc5, 0x49, 0x87, 0xe2, 0xe9, 0x48, 0x5c, + /*1d60:*/ 0xf9, 0x15, 0x30, 0x10, 0x2e, 0xee, 0x6e, 0x4d, 0x9b, 0xd3, 0xb8, 0x10, 0xff, 0xdd, 0x5d, 0xe1, + /*1d70:*/ 0x2c, 0x38, 0xfe, 0x0f, 0xae, 0x14, 0xb9, 0x21, 0x74, 0x6a, 0xc0, 0xf8, 0x29, 0x2e, 0xa1, 0xb0, + /*1d80:*/ 0xf9, 0x3c, 0x72, 0x46, 0x1b, 0xe7, 0xa2, 0xef, 0x18, 0x0b, 0xe3, 0xc7, 0x6b, 0x60, 0x6a, 0x7f, + /*1d90:*/ 0x60, 0x36, 0xa5, 0xa9, 0x3b, 0x13, 0x97, 0xd4, 0xee, 0x5a, 0x23, 0xd0, 0xc9, 0x2d, 0x3a, 0x1f, + /*1da0:*/ 0x84, 0x86, 0x42, 0xc5, 0x94, 0xf0, 0x6f, 0x9e, 0xd7, 0xa9, 0xa0, 0x63, 0xd0, 0xc2, 0xa2, 0x57, + /*1db0:*/ 0x3a, 0xe5, 0x14, 0xc9, 0xce, 0x7a, 0x77, 0xfc, 0x72, 0x99, 0xf7, 0x02, 0x92, 0xdb, 0x95, 0xf3, + /*1dc0:*/ 0x66, 0x17, 0xb0, 0xe1, 0x83, 0xe3, 0x13, 0x55, 0xe4, 0xf2, 0xb7, 0x45, 0x35, 0x34, 0x5e, 0x3b, + /*1dd0:*/ 0x1d, 0x68, 0x0a, 0x38, 0x94, 0x43, 0x7b, 0xc0, 0x21, 0x77, 0x3e, 0x11, 0x51, 0xba, 0x1b, 0x0c, + /*1de0:*/ 0x1f, 0x0b, 0x28, 0x23, 0xca, 0x79, 0x5b, 0x3c, 0xc8, 0x4b, 0x84, 0xd8, 0xa0, 0xfc, 0x9d, 0x7f, + /*1df0:*/ 0xad, 0xce, 0x6a, 0xe4, 0x7b, 0xbd, 0xbc, 0xbe, 0x9c, 0xef, 0x2c, 0x5e, 0x5c, 0x64, 0x1e, 0x5d, + /*1e00:*/ 0x97, 0x83, 0x20, 0x63, 0x5b, 0x4d, 0x18, 0xdd, 0xe3, 0x08, 0x7a, 0xfd, 0x7a, 0xb0, 0xb4, 0x89, + /*1e10:*/ 0xfe, 0x5d, 0x59, 0x5a, 0x50, 0x91, 0x6a, 0xe3, 0xd8, 0xe4, 0x4c, 0x74, 0x06, 0x1e, 0xb8, 0xcb, + /*1e20:*/ 0x27, 0x0e, 0x57, 0x76, 0x4c, 0x31, 0x76, 0x86, 0xd4, 0x37, 0x93, 0x6c, 0x13, 0x45, 0x6d, 0x79, + /*1e30:*/ 0xef, 0xab, 0xb6, 0x07, 0x7b, 0x07, 0xc0, 0x26, 0xa1, 0x61, 0x40, 0xa0, 0x67, 0x36, 0xfc, 0xb5, + /*1e40:*/ 0x8b, 0x75, 0x02, 0xd8, 0x4d, 0x60, 0x40, 0xeb, 0xf4, 0x02, 0xb2, 0xe3, 0x5e, 0x22, 0x13, 0xf5, + /*1e50:*/ 0xb4, 0x71, 0xb9, 0x64, 0x3a, 0x71, 0xba, 0xdb, 0x4e, 0xbe, 0x8e, 0x35, 0x18, 0xe1, 0xf3, 0xf1, + /*1e60:*/ 0xde, 0xd9, 0xba, 0x88, 0x1e, 0x08, 0xd7, 0x79, 0x54, 0xdd, 0x1c, 0xda, 0xa3, 0xcd, 0x18, 0x7b, + /*1e70:*/ 0x84, 0x17, 0xc7, 0x0a, 0x17, 0x9f, 0x14, 0x58, 0x6c, 0xce, 0x7f, 0x1b, 0x7c, 0x0b, 0xcd, 0x82, + /*1e80:*/ 0xee, 0x1a, 0x9f, 0x24, 0x94, 0x01, 0x76, 0xbe, 0x68, 0xb5, 0xc5, 0x9e, 0x6f, 0x3c, 0x90, 0x02, + /*1e90:*/ 0x2b, 0x58, 0xc3, 0x2e, 0x9d, 0xc0, 0x4e, 0xa2, 0x78, 0xf2, 0x2d, 0x8a, 0x07, 0x82, 0xbe, 0xd4, + /*1ea0:*/ 0xbf, 0x4a, 0x08, 0xa3, 0xa5, 0x89, 0xe0, 0x3f, 0x28, 0x0b, 0xec, 0xac, 0x77, 0xdd, 0xac, 0x52, + /*1eb0:*/ 0x7a, 0x58, 0x65, 0x59, 0x48, 0x03, 0xf9, 0x27, 0xd1, 0xa9, 0x7b, 0x37, 0xbe, 0x4c, 0x6c, 0x6b, + /*1ec0:*/ 0x73, 0x15, 0x74, 0xfc, 0x83, 0x1e, 0xbd, 0x67, 0x20, 0x14, 0xe9, 0xad, 0x93, 0x13, 0xd5, 0x45, + /*1ed0:*/ 0x2a, 0xdc, 0x6c, 0xa3, 0x04, 0xe7, 0x5f, 0x58, 0xea, 0x95, 0x25, 0x25, 0xe8, 0xb5, 0x32, 0x26, + /*1ee0:*/ 0xd8, 0xa1, 0x16, 0x0c, 0xbe, 0x63, 0xee, 0xc3, 0x52, 0xba, 0x01, 0xbe, 0xfd, 0xc1, 0x9b, 0x5c, + /*1ef0:*/ 0xf4, 0x6d, 0x1c, 0x08, 0x0a, 0xd9, 0xd9, 0xa6, 0xd2, 0x24, 0x05, 0x7c, 0x05, 0x8c, 0x4a, 0x7a, + /*1f00:*/ 0xfe, 0x35, 0x11, 0x82, 0xb6, 0x94, 0xe1, 0x3e, 0xc3, 0xd1, 0xad, 0x88, 0x3c, 0x2f, 0xb2, 0x2c, + /*1f10:*/ 0x75, 0xef, 0x37, 0xd8, 0x33, 0x9a, 0xf6, 0x65, 0x8f, 0x58, 0xa7, 0x64, 0x52, 0xb8, 0x95, 0x19, + /*1f20:*/ 0xe6, 0xee, 0x39, 0x03, 0xdd, 0x8d, 0x33, 0x47, 0xb5, 0xb7, 0x4b, 0x6f, 0x55, 0xb6, 0x8e, 0xca, + /*1f30:*/ 0x3d, 0x6f, 0xc7, 0x39, 0x1f, 0x56, 0xa1, 0xa8, 0xef, 0x0b, 0xcb, 0x52, 0xea, 0x2d, 0x1f, 0x11, + /*1f40:*/ 0xee, 0x6b, 0x6a, 0x26, 0x84, 0xce, 0x02, 0x5a, 0x10, 0x2d, 0x6f, 0xd6, 0x8f, 0xf9, 0x68, 0xd8, + /*1f50:*/ 0x0a, 0x67, 0xeb, 0x09, 0x7c, 0xd0, 0xa8, 0xfd, 0x47, 0x40, 0x49, 0x6f, 0xb1, 0xcd, 0x01, 0xaa, + /*1f60:*/ 0x2d, 0x85, 0xb8, 0xc7, 0x81, 0x3e, 0xc7, 0xa9, 0xbe, 0xc5, 0xc6, 0x20, 0xf2, 0x4d, 0x61, 0xff, + /*1f70:*/ 0x64, 0x45, 0xed, 0xa0, 0xa0, 0xa8, 0xbb, 0xb4, 0x78, 0x44, 0x1c, 0x7f, 0xe8, 0x87, 0x7b, 0xc1, + /*1f80:*/ 0x29, 0xc2, 0x71, 0x0d, 0x9a, 0xa7, 0x9c, 0xc4, 0x03, 0x1b, 0x6c, 0x25, 0x2f, 0x9f, 0xc4, 0xd1, + /*1f90:*/ 0x67, 0x19, 0x81, 0x3f, 0x71, 0x94, 0xcd, 0xed, 0x84, 0x9d, 0x0f, 0x42, 0xae, 0x38, 0xdf, 0xbd, + /*1fa0:*/ 0xc3, 0x92, 0x6b, 0xa8, 0x8b, 0x18, 0x45, 0xe2, 0xf3, 0x1c, 0x7c, 0xe6, 0x06, 0xeb, 0x41, 0x48, + /*1fb0:*/ 0xe1, 0x44, 0x79, 0x28, 0xa2, 0xfe, 0x46, 0x85, 0x9d, 0x1a, 0x83, 0x1d, 0x9c, 0xe3, 0xe2, 0xc9, + /*1fc0:*/ 0x33, 0x68, 0xa8, 0xa9, 0x07, 0x9c, 0x7f, 0x71, 0xe7, 0xf0, 0x4e, 0x21, 0x90, 0x80, 0xc1, 0x3e, + /*1fd0:*/ 0x1f, 0xae, 0xdd, 0xb8, 0x5a, 0x17, 0x86, 0x9a, 0xdf, 0xec, 0xde, 0xaa, 0x48, 0x99, 0x4b, 0xd9, + /*1fe0:*/ 0xa8, 0x9b, 0xbc, 0x34, 0x65, 0x30, 0x1a, 0x72, 0xf4, 0x69, 0xee, 0x81, 0x06, 0x86, 0xbe, 0x65, + /*1ff0:*/ 0x74, 0x22, 0xdc, 0x45, 0x61, 0x4d, 0x11, 0x16, 0x94, 0xc3, 0xaf, 0x31, 0xf2, 0x2e, 0x7e, 0x0a, + /*2000:*/ 0xe9, 0xcc, 0x15, 0x55, 0xdd, 0x5c, 0x4b, 0xc8, 0xe6, 0x54, 0x65, 0x71, 0x96, 0xb6, 0x05, 0xa1, + /*2010:*/ 0xf6, 0x12, 0xf5, 0x2e, 0xbd, 0x04, 0x7d, 0xc9, 0xb6, 0xe1, 0x40, 0x64, 0x35, 0x33, 0x2e, 0x1e, + /*2020:*/ 0xfd, 0xcb, 0x48, 0x03, 0xc1, 0x90, 0x27, 0x65, 0x2c, 0xa5, 0x3b, 0xba, 0x99, 0x89, 0x1d, 0x63, + /*2030:*/ 0x27, 0x31, 0xa4, 0x45, 0x7a, 0x5d, 0xbb, 0x67, 0xea, 0x3e, 0x3d, 0x03, 0x71, 0x8b, 0xda, 0x94, + /*2040:*/ 0xc6, 0x09, 0xb6, 0xfb, 0x87, 0x2e, 0x50, 0x67, 0x04, 0x3d, 0xf0, 0x54, 0xd8, 0xcb, 0xee, 0x74, + /*2050:*/ 0x59, 0x15, 0x9a, 0x40, 0xb2, 0xf1, 0xae, 0xa2, 0x9c, 0x76, 0x6b, 0x2b, 0x70, 0xc8, 0xe9, 0x20, + /*2060:*/ 0x95, 0x16, 0xb8, 0xb2, 0x7e, 0x43, 0xd7, 0x5b, 0x3d, 0xce, 0x82, 0x22, 0x61, 0xff, 0x64, 0x14, + /*2070:*/ 0xcc, 0x7e, 0xf8, 0x73, 0x5e, 0x72, 0xf3, 0xfc, 0xea, 0xbf, 0x44, 0xc4, 0x1b, 0x25, 0xd1, 0xbd, + /*2080:*/ 0x95, 0x3a, 0xb0, 0x1b, 0x1f, 0xfa, 0x7b, 0xbe, 0x52, 0x80, 0x21, 0xb6, 0x22, 0x0b, 0x9c, 0x38, + /*2090:*/ 0x3d, 0xbb, 0xae, 0x2f, 0xd8, 0xaf, 0x45, 0x00, 0x47, 0x44, 0xcd, 0x6a, 0x66, 0x8c, 0xc5, 0x35, + /*20a0:*/ 0xfd, 0x6d, 0xe4, 0xf5, 0xfa, 0xfa, 0x00, 0xff, 0x96, 0xdb, 0x91, 0xad, 0x00, 0x05, 0xbe, 0x99, + /*20b0:*/ 0xa0, 0x15, 0x4d, 0xb6, 0xb5, 0x26, 0xc4, 0x82, 0xa9, 0xd4, 0xbc, 0x2f, 0xe1, 0x85, 0x18, 0xd0, + /*20c0:*/ 0xa7, 0xdc, 0xbe, 0x53, 0x84, 0xac, 0x2a, 0xc3, 0xf9, 0x8c, 0x01, 0x6e, 0xdb, 0x3e, 0x7a, 0xf4, + /*20d0:*/ 0x0b, 0xf3, 0x82, 0x34, 0x4d, 0x8a, 0x67, 0x0a, 0x68, 0x5c, 0x87, 0xd5, 0x12, 0x11, 0xf7, 0xd0, + /*20e0:*/ 0xf2, 0xd7, 0x3c, 0x2c, 0x7a, 0xf6, 0xee, 0x3a, 0x7f, 0xa3, 0x66, 0xb4, 0x76, 0x5e, 0x2b, 0x14, + /*20f0:*/ 0x17, 0xdc, 0x28, 0x89, 0xa4, 0xba, 0x8e, 0x66, 0x82, 0x18, 0xfe, 0x04, 0xcc, 0x44, 0xf8, 0xd9, + /*2100:*/ 0x76, 0x30, 0x30, 0xad, 0x4c, 0xa0, 0x5f, 0x8a, 0x7b, 0x59, 0x07, 0xb9, 0x1f, 0xdc, 0x88, 0xac, + /*2110:*/ 0xbf, 0xcb, 0x8d, 0x64, 0x34, 0x01, 0xd6, 0xb1, 0x03, 0xd7, 0xa8, 0x0b, 0x2f, 0xee, 0x98, 0x8d, + /*2120:*/ 0x18, 0x9f, 0x19, 0xf4, 0xc3, 0x9c, 0x44, 0x9a, 0x2b, 0xdf, 0x88, 0x79, 0xad, 0x0f, 0x13, 0x3e, + /*2130:*/ 0xd7, 0xb9, 0x5c, 0x50, 0xed, 0x0c, 0xda, 0xb0, 0xb6, 0x6e, 0xdb, 0x6d, 0x03, 0x31, 0xc6, 0x97, + /*2140:*/ 0xac, 0x8f, 0x9c, 0x2d, 0x16, 0x88, 0x72, 0x49, 0x82, 0x99, 0xc0, 0x71, 0x59, 0x27, 0xb6, 0x39, + /*2150:*/ 0xc8, 0x30, 0x56, 0x8e, 0x8f, 0xa2, 0xa5, 0xbe, 0xc4, 0x01, 0x1e, 0x12, 0x42, 0xab, 0xd1, 0x9c, + /*2160:*/ 0x4c, 0x34, 0xef, 0x87, 0x36, 0xf2, 0xce, 0xde, 0xf5, 0x23, 0x71, 0x12, 0x7e, 0xb6, 0x8e, 0x25, + /*2170:*/ 0x82, 0x7d, 0xd6, 0xac, 0x07, 0xbb, 0x01, 0xfc, 0x9d, 0x14, 0xdf, 0x24, 0x38, 0x7c, 0xd8, 0x42, + /*2180:*/ 0x3a, 0xf9, 0xb1, 0xfd, 0x66, 0x9f, 0x7c, 0x47, 0x9d, 0x57, 0x3b, 0x75, 0x44, 0x63, 0xe8, 0x4c, + /*2190:*/ 0x7c, 0xf2, 0xfc, 0xec, 0x43, 0x83, 0x87, 0xd3, 0x13, 0x73, 0x33, 0x98, 0x7d, 0x33, 0x0b, 0x4b, + /*21a0:*/ 0x44, 0xb2, 0xc1, 0x9c, 0xb3, 0x03, 0x67, 0x80, 0xef, 0x95, 0x06, 0xe0, 0xbb, 0xe1, 0xe5, 0x33, + /*21b0:*/ 0x21, 0x73, 0x1f, 0x91, 0xf1, 0x14, 0xdc, 0x9e, 0x53, 0xe3, 0x14, 0x85, 0x43, 0x1e, 0xaa, 0x5d, + /*21c0:*/ 0x08, 0x7b, 0x28, 0x8d, 0x43, 0x27, 0xec, 0x2d, 0xab, 0xe7, 0xe2, 0x09, 0xc9, 0x15, 0x1a, 0x87, + /*21d0:*/ 0x58, 0xa6, 0xfe, 0x35, 0xd0, 0xd9, 0x87, 0x39, 0x7e, 0xae, 0xc2, 0x91, 0x0a, 0x0f, 0xf3, 0x48, + /*21e0:*/ 0xe2, 0x5d, 0x4c, 0x1a, 0x56, 0xbb, 0x74, 0x8e, 0x9f, 0x25, 0xf0, 0x90, 0x46, 0xcf, 0x50, 0x35, + /*21f0:*/ 0x7a, 0x59, 0xe1, 0x6a, 0xd4, 0x24, 0x97, 0x4a, 0xca, 0xdb, 0xbd, 0x83, 0xd9, 0xa9, 0x6a, 0xae, + /*2200:*/ 0xea, 0x46, 0x97, 0x14, 0xdd, 0xaf, 0x46, 0x79, 0x98, 0xb7, 0x20, 0xf2, 0x3e, 0x98, 0xd8, 0x6c, + /*2210:*/ 0xc5, 0x57, 0x5d, 0xed, 0x08, 0xda, 0x0f, 0x98, 0x06, 0xd8, 0xdc, 0x2c, 0x28, 0x8d, 0xc5, 0x21, + /*2220:*/ 0x33, 0xc1, 0xc4, 0x2d, 0x1e, 0x85, 0x7b, 0x82, 0x12, 0x74, 0x78, 0x2b, 0xf5, 0x0b, 0x77, 0xeb, + /*2230:*/ 0xc8, 0x6f, 0x42, 0x83, 0xe2, 0x19, 0x25, 0x6b, 0xff, 0x92, 0xb7, 0x63, 0x82, 0xae, 0xc9, 0x0d, + /*2240:*/ 0xa0, 0xc3, 0x64, 0x6f, 0x13, 0x8c, 0xf2, 0x8a, 0xa2, 0xb6, 0x57, 0x99, 0x2e, 0x92, 0xa6, 0x3c, + /*2250:*/ 0xa1, 0x86, 0x05, 0x76, 0x4f, 0x55, 0x5d, 0x2b, 0x3c, 0x28, 0x30, 0x00, 0x51, 0x5e, 0xa1, 0x90, + /*2260:*/ 0x35, 0x0b, 0x78, 0xb6, 0x04, 0x82, 0xca, 0xe0, 0x3e, 0xb9, 0xe0, 0x12, 0x19, 0x62, 0xfd, 0x05, + /*2270:*/ 0x81, 0xd7, 0x78, 0xb9, 0x23, 0x14, 0xe3, 0xb3, 0x4d, 0xac, 0x97, 0x80, 0xac, 0x4c, 0x98, 0xea, + /*2280:*/ 0x60, 0x89, 0x62, 0x8b, 0xc0, 0xd2, 0x37, 0x5c, 0x5a, 0x63, 0xcf, 0x7a, 0x55, 0x3a, 0x67, 0xeb, + /*2290:*/ 0xec, 0xcb, 0xd6, 0xf7, 0x39, 0x33, 0xf0, 0x6e, 0x4c, 0x8c, 0x0f, 0x75, 0x60, 0x5a, 0x5f, 0x08, + /*22a0:*/ 0x52, 0x93, 0x86, 0x50, 0xf3, 0xf1, 0x99, 0x9f, 0x3a, 0x02, 0x9e, 0xe8, 0xca, 0xe7, 0x95, 0x47, + /*22b0:*/ 0xb0, 0x37, 0x4e, 0xa1, 0x53, 0xc8, 0xaf, 0xb6, 0x6e, 0x55, 0xdf, 0xf8, 0x7d, 0xf2, 0xe7, 0x36, + /*22c0:*/ 0xc2, 0xf8, 0xbc, 0x54, 0xe7, 0x01, 0x13, 0x6b, 0x3f, 0xcc, 0xd0, 0x84, 0xe4, 0xac, 0xd8, 0x0a, + /*22d0:*/ 0x26, 0x2f, 0x82, 0xe1, 0xce, 0x3d, 0x60, 0xe4, 0xb9, 0xb2, 0xad, 0xd9, 0x9c, 0x4c, 0x2f, 0xa3, + /*22e0:*/ 0x2b, 0x37, 0x8f, 0x0d, 0x65, 0x38, 0xc5, 0x76, 0xca, 0x97, 0xa1, 0x64, 0xca, 0x3c, 0x14, 0xb6, + /*22f0:*/ 0xb3, 0x68, 0xaf, 0xb2, 0x47, 0x66, 0x4b, 0x85, 0x21, 0x1e, 0xa2, 0x60, 0xd7, 0x85, 0x8a, 0x9b, + /*2300:*/ 0x35, 0x0e, 0xd8, 0x20, 0x12, 0x8b, 0xca, 0x25, 0x17, 0xc4, 0x57, 0xb8, 0x6a, 0x6f, 0xac, 0xa9, + /*2310:*/ 0xf4, 0xe9, 0x3c, 0xc1, 0x05, 0x4a, 0x8c, 0x5c, 0xba, 0xbb, 0x82, 0xe7, 0xa7, 0xd0, 0x58, 0x44, + /*2320:*/ 0x13, 0x86, 0xac, 0x3c, 0x63, 0x9b, 0xa8, 0xb5, 0x56, 0x13, 0x55, 0xce, 0xc3, 0xd3, 0x29, 0xec, + /*2330:*/ 0x96, 0x27, 0x17, 0xde, 0x8a, 0xec, 0x31, 0x56, 0x6e, 0x3b, 0xfa, 0x4e, 0xa9, 0x51, 0x9c, 0x1c, + /*2340:*/ 0x67, 0x70, 0xbb, 0xc7, 0x50, 0x2d, 0xfb, 0xc9, 0x21, 0x64, 0x4c, 0xdd, 0xe7, 0xd2, 0x57, 0xfe, + /*2350:*/ 0x09, 0x12, 0x0d, 0xe7, 0x5b, 0x0f, 0x81, 0x21, 0x13, 0x44, 0x2f, 0x57, 0xab, 0xe8, 0xac, 0xf6, + /*2360:*/ 0x02, 0x23, 0x3d, 0xa1, 0x4f, 0xf5, 0x54, 0x20, 0xe2, 0x82, 0x4d, 0xf4, 0x22, 0x15, 0xc5, 0x70, + /*2370:*/ 0xf7, 0x9d, 0xd7, 0x3b, 0xb5, 0x30, 0x82, 0x94, 0x47, 0x26, 0xba, 0xb1, 0x15, 0xe6, 0x7c, 0xba, + /*2380:*/ 0xb0, 0xcd, 0xd2, 0xe6, 0x69, 0x52, 0x35, 0x0b, 0x77, 0x78, 0xd2, 0x65, 0x7c, 0xa3, 0xba, 0x56, + /*2390:*/ 0x61, 0xa0, 0xb1, 0x93, 0x83, 0xa1, 0x28, 0x23, 0x37, 0xb5, 0x1f, 0x56, 0x64, 0xdc, 0x66, 0x02, + /*23a0:*/ 0x22, 0x2d, 0xa7, 0x14, 0x77, 0x3e, 0xc0, 0xdb, 0x5c, 0x84, 0x63, 0x0f, 0xea, 0x37, 0x36, 0x34, + /*23b0:*/ 0xab, 0xab, 0x99, 0x5b, 0x81, 0x37, 0x22, 0xa5, 0x94, 0xe5, 0xf2, 0x79, 0x2f, 0x45, 0xc7, 0xc9, + /*23c0:*/ 0xa7, 0xfa, 0x6d, 0xbe, 0x02, 0x99, 0x2e, 0xeb, 0x6c, 0xc8, 0xc3, 0x24, 0x48, 0xbc, 0x9b, 0x4e, + /*23d0:*/ 0x13, 0x05, 0xfe, 0x9f, 0x67, 0xe7, 0x62, 0xc3, 0x74, 0x6d, 0x24, 0xf9, 0x42, 0x71, 0x77, 0x85, + /*23e0:*/ 0x4f, 0xb4, 0xba, 0x77, 0xbc, 0xdc, 0x49, 0x94, 0x73, 0x24, 0xe1, 0x62, 0xe1, 0xee, 0x8f, 0xd1, + /*23f0:*/ 0xa1, 0x7a, 0x72, 0x40, 0xba, 0x5e, 0x8c, 0x60, 0x31, 0x6e, 0x5d, 0x71, 0x15, 0x42, 0xf9, 0x70, + /*2400:*/ 0x61, 0x88, 0x08, 0x72, 0xa7, 0x03, 0x92, 0x3d, 0xc0, 0x0f, 0xed, 0x11, 0xf9, 0x32, 0xbe, 0x42, + /*2410:*/ 0x03, 0xb3, 0xb9, 0x15, 0xe1, 0x50, 0x00, 0xcf, 0xcd, 0x19, 0x19, 0x82, 0x32, 0x39, 0x43, 0x1a, + /*2420:*/ 0x54, 0xbd, 0xf4, 0xd8, 0x47, 0xe1, 0x01, 0x7a, 0xf5, 0xdb, 0x6f, 0xae, 0xad, 0xd4, 0x52, 0x6a, + /*2430:*/ 0xe0, 0x98, 0xa8, 0x8e, 0x1b, 0x1c, 0x54, 0x75, 0x6f, 0x71, 0x53, 0xbd, 0xea, 0x26, 0x78, 0x50, + /*2440:*/ 0x7b, 0x10, 0xe5, 0x5b, 0x56, 0xe4, 0xd8, 0x47, 0x20, 0xf8, 0x39, 0xb5, 0x29, 0xab, 0x99, 0x66, + /*2450:*/ 0xe9, 0xc9, 0xa2, 0x30, 0x8e, 0x14, 0xfc, 0x2c, 0x14, 0xdc, 0xba, 0xc9, 0x8a, 0xa1, 0x06, 0xab, + /*2460:*/ 0xfd, 0xc8, 0x93, 0x52, 0x26, 0x44, 0xf6, 0x0d, 0xc9, 0x46, 0x8a, 0x4e, 0x0b, 0x96, 0x98, 0x4d, + /*2470:*/ 0xf3, 0x71, 0x8f, 0xdf, 0x02, 0x2a, 0xa6, 0x8b, 0xe7, 0x6d, 0x6c, 0x80, 0x18, 0x21, 0x3c, 0x7c, + /*2480:*/ 0x6f, 0xc0, 0xb6, 0xea, 0x5d, 0x78, 0xb5, 0x46, 0xf9, 0x27, 0xfa, 0x4f, 0xd3, 0xbe, 0x83, 0xe2, + /*2490:*/ 0xaa, 0x26, 0xee, 0x71, 0x86, 0x5d, 0xf1, 0x05, 0x15, 0x97, 0x98, 0x0a, 0xdd, 0xa3, 0x67, 0x93, + /*24a0:*/ 0x50, 0xc1, 0x1a, 0xa7, 0xd1, 0xa0, 0xcd, 0xa4, 0xfe, 0xfa, 0x5a, 0x0e, 0x34, 0x64, 0x4c, 0x00, + /*24b0:*/ 0x41, 0xfc, 0x6e, 0x8c, 0x65, 0x60, 0xa5, 0xe9, 0xea, 0xc1, 0xd2, 0xed, 0x27, 0xd1, 0x3c, 0x87, + /*24c0:*/ 0xbb, 0xdd, 0xc8, 0xfa, 0x10, 0xa4, 0x90, 0x68, 0x4d, 0x8c, 0x9f, 0x3d, 0x47, 0x41, 0x1e, 0x38, + /*24d0:*/ 0x55, 0x7a, 0x02, 0xb5, 0xfc, 0xea, 0xcc, 0x33, 0x15, 0x62, 0xa3, 0x0c, 0x16, 0x39, 0x3a, 0x1d, + /*24e0:*/ 0xfd, 0x6d, 0x89, 0xb2, 0x93, 0x18, 0xb1, 0xfb, 0x74, 0x2b, 0x58, 0x6e, 0x2e, 0xa3, 0x0a, 0xfc, + /*24f0:*/ 0xed, 0x5e, 0xc9, 0xfc, 0xda, 0xdc, 0x61, 0xf1, 0x1b, 0xdc, 0x8b, 0xd6, 0x19, 0x3d, 0x3f, 0x68, + /*2500:*/ 0x90, 0x83, 0x19, 0x79, 0xe7, 0xfe, 0x11, 0x14, 0xf7, 0xe7, 0x3d, 0x94, 0x08, 0x60, 0xbd, 0xaa, + /*2510:*/ 0xdd, 0x87, 0xd0, 0xf4, 0xd2, 0xf5, 0xe4, 0x90, 0xa8, 0x73, 0xae, 0xb6, 0xb3, 0x8a, 0xc1, 0x36, + /*2520:*/ 0xa1, 0x1a, 0x03, 0x7c, 0xbe, 0x9d, 0xcb, 0xbc, 0x3a, 0x0f, 0x16, 0x54, 0xdb, 0xd6, 0xb4, 0x84, + /*2530:*/ 0x79, 0xe3, 0x95, 0xee, 0x5a, 0x65, 0x88, 0x1a, 0x68, 0x82, 0xc1, 0x32, 0x47, 0x94, 0x4a, 0x8b, + /*2540:*/ 0xb8, 0x1b, 0xa4, 0x77, 0x49, 0x65, 0x51, 0xbb, 0xbd, 0x0c, 0xd2, 0x7b, 0xbd, 0xff, 0xd9, 0x72, + /*2550:*/ 0x2e, 0x37, 0xc2, 0xc0, 0xf0, 0x03, 0xc7, 0x13, 0x46, 0xef, 0x7b, 0xa1, 0xf1, 0xa5, 0xbd, 0x1f, + /*2560:*/ 0x0e, 0x2f, 0x4e, 0x20, 0x51, 0xc7, 0x54, 0x57, 0x84, 0x78, 0xac, 0x7b, 0xc9, 0xe1, 0x8d, 0x66, + /*2570:*/ 0x51, 0x12, 0x79, 0x7c, 0x9c, 0x3d, 0xe2, 0xf3, 0x8e, 0x6b, 0x77, 0x84, 0x47, 0x14, 0x4d, 0x87, + /*2580:*/ 0xac, 0xa0, 0x9a, 0x5f, 0xd7, 0x4f, 0x18, 0x44, 0x8e, 0x96, 0x6f, 0xf4, 0xf0, 0x45, 0x73, 0x36, + /*2590:*/ 0x34, 0xa5, 0xaa, 0x24, 0xec, 0xde, 0x68, 0xa3, 0xda, 0x9e, 0xfc, 0x19, 0xba, 0x0e, 0x31, 0x80, + /*25a0:*/ 0x20, 0xad, 0x73, 0x0c, 0x35, 0x2d, 0x5f, 0x50, 0x41, 0x58, 0x02, 0xb6, 0x4c, 0xeb, 0xcf, 0xa1, + /*25b0:*/ 0x6e, 0x54, 0x66, 0xf9, 0xfb, 0xfa, 0x73, 0x48, 0x53, 0x9d, 0xbc, 0x7b, 0xe4, 0x6e, 0xad, 0xa7, + /*25c0:*/ 0x68, 0x6c, 0x3a, 0xed, 0xd9, 0x01, 0x49, 0xbe, 0xe8, 0x03, 0x36, 0xb6, 0x06, 0x2f, 0xfc, 0xfa, + /*25d0:*/ 0x5c, 0xd1, 0xe2, 0x4d, 0x62, 0xdc, 0x1c, 0xb8, 0x9b, 0xfc, 0x6e, 0x26, 0x3c, 0x38, 0xc3, 0x3d, + /*25e0:*/ 0xe0, 0x52, 0x61, 0x10, 0x34, 0x97, 0x15, 0x3f, 0xa9, 0xdc, 0xc2, 0xad, 0x32, 0xf7, 0x3d, 0x70, + /*25f0:*/ 0xe7, 0xf1, 0x2e, 0xe8, 0x1e, 0xbd, 0x8e, 0x90, 0xfb, 0x22, 0x73, 0xde, 0xe7, 0xb8, 0x9c, 0xce, + /*2600:*/ 0x9b, 0x89, 0xd3, 0x51, 0xfd, 0xe9, 0x07, 0xbe, 0x32, 0x14, 0x04, 0x22, 0xf8, 0x73, 0x75, 0x39, + /*2610:*/ 0x6d, 0x77, 0x21, 0x58, 0x5e, 0x64, 0x98, 0x36, 0x67, 0xc4, 0xed, 0x70, 0x25, 0xf7, 0x79, 0x12, + /*2620:*/ 0x53, 0xa8, 0xff, 0x59, 0x0b, 0xb7, 0xe0, 0x78, 0x35, 0xe5, 0x47, 0x70, 0xd9, 0xc5, 0x13, 0xe7, + /*2630:*/ 0xda, 0xa9, 0x09, 0xc9, 0x17, 0x68, 0x58, 0xb8, 0xbc, 0xa3, 0xf3, 0xf6, 0x02, 0xda, 0x35, 0x93, + /*2640:*/ 0x7f, 0xf2, 0x4e, 0x5f, 0x2f, 0xf2, 0x30, 0xca, 0xce, 0x23, 0xb3, 0x13, 0xff, 0xa3, 0xd6, 0x76, + /*2650:*/ 0xf8, 0xd5, 0xb8, 0xad, 0x52, 0xe3, 0x55, 0x15, 0x6e, 0x3b, 0x61, 0x5e, 0x25, 0x97, 0xda, 0x62, + /*2660:*/ 0xe6, 0x5a, 0x1a, 0xc3, 0x2e, 0x5d, 0xcd, 0xb9, 0x41, 0xe3, 0x72, 0x0b, 0x12, 0x94, 0x95, 0x08, + /*2670:*/ 0x06, 0x86, 0x45, 0xf9, 0x38, 0x8d, 0x41, 0xf6, 0x3e, 0x84, 0x6d, 0x06, 0xfb, 0x41, 0x55, 0x0d, + /*2680:*/ 0x8e, 0x31, 0x8d, 0x8d, 0x7c, 0x9b, 0x1e, 0x54, 0x5a, 0xac, 0xe1, 0x3e, 0xc0, 0x03, 0x36, 0x23, + /*2690:*/ 0x81, 0x13, 0xe7, 0xcc, 0x1b, 0xc3, 0x9c, 0x6a, 0xc1, 0xfc, 0xe9, 0x9c, 0x20, 0xa0, 0x4a, 0x84, + /*26a0:*/ 0x0f, 0x17, 0xcc, 0xf1, 0xb6, 0xcc, 0xf9, 0x5e, 0x52, 0x0a, 0x70, 0x03, 0x24, 0x73, 0x65, 0x5b, + /*26b0:*/ 0x28, 0x8d, 0xe5, 0x99, 0x8e, 0x47, 0xfd, 0x75, 0x63, 0xd6, 0x6a, 0x16, 0xe7, 0xa8, 0x27, 0x44, + /*26c0:*/ 0x76, 0xf6, 0x81, 0xf9, 0xec, 0x37, 0x49, 0x5b, 0x50, 0x19, 0x11, 0x8e, 0xe4, 0x21, 0x6f, 0xca, + /*26d0:*/ 0xd3, 0x91, 0xb7, 0x2d, 0x91, 0x1b, 0x99, 0x19, 0xb6, 0xfb, 0xcd, 0xb6, 0xe4, 0x11, 0xd3, 0x26, + /*26e0:*/ 0x70, 0xa9, 0x3f, 0x3e, 0x81, 0x66, 0x8c, 0x97, 0xce, 0xe8, 0x98, 0x0a, 0x55, 0x57, 0x7f, 0x14, + /*26f0:*/ 0x8b, 0x9d, 0xb5, 0x81, 0x3b, 0x61, 0x25, 0x5e, 0xa0, 0xda, 0xcc, 0x64, 0xf1, 0xe2, 0xe4, 0xa0, + /*2700:*/ 0x86, 0xdb, 0xec, 0x17, 0x94, 0x06, 0xe8, 0xa3, 0x6d, 0x65, 0xd7, 0x0e, 0xda, 0x42, 0xfa, 0x65, + /*2710:*/ 0x2f, 0x86, 0xde, 0xb3, 0x0c, 0x85, 0x46, 0xb2, 0x5f, 0x43, 0x40, 0xc7, 0x06, 0xfc, 0xd7, 0xbc, + /*2720:*/ 0x13, 0x3d, 0x1e, 0x7c, 0xfe, 0x21, 0x92, 0x51, 0xcd, 0xb6, 0xf2, 0xdd, 0xf2, 0xf1, 0x63, 0x3d, + /*2730:*/ 0x23, 0x81, 0xd4, 0x82, 0x2e, 0x7b, 0x7d, 0x9b, 0xa4, 0x45, 0x30, 0xf5, 0xbf, 0x32, 0x01, 0xbd, + /*2740:*/ 0xda, 0x6e, 0xb6, 0x43, 0xbc, 0xb3, 0xf2, 0xbb, 0x7c, 0x99, 0xcc, 0x84, 0xc2, 0x32, 0x89, 0xe9, + /*2750:*/ 0xfa, 0xeb, 0x75, 0x52, 0x77, 0xc2, 0xf4, 0x18, 0x1f, 0x16, 0xef, 0x3a, 0xcd, 0xef, 0xce, 0x7f, + /*2760:*/ 0x69, 0xcf, 0x0d, 0x50, 0xa4, 0xc6, 0x17, 0xf8, 0x00, 0x28, 0xed, 0xa6, 0x98, 0x97, 0xb8, 0x42, + /*2770:*/ 0xae, 0xc1, 0x43, 0x4d, 0x00, 0x0c, 0x41, 0x67, 0xf1, 0xe5, 0xed, 0x28, 0x75, 0x64, 0x27, 0x57, + /*2780:*/ 0x0a, 0x42, 0xa0, 0x9f, 0x81, 0x6b, 0xf4, 0xa8, 0x4a, 0x92, 0xe4, 0xf4, 0xe2, 0x02, 0x5d, 0xf1, + /*2790:*/ 0x2c, 0xe6, 0x61, 0x2d, 0xc8, 0x73, 0x24, 0x58, 0xb9, 0x52, 0x8c, 0x3d, 0x69, 0x5f, 0xc4, 0xc5, + /*27a0:*/ 0x7c, 0x76, 0x40, 0x0f, 0x27, 0x98, 0x30, 0x34, 0xc7, 0xb3, 0x9f, 0x8c, 0xa2, 0x59, 0x90, 0x60, + /*27b0:*/ 0xe5, 0xbe, 0x1c, 0x06, 0xc5, 0x7e, 0x3b, 0xce, 0x8c, 0x18, 0x19, 0x52, 0xe5, 0x20, 0xc9, 0x58, + /*27c0:*/ 0xea, 0x6b, 0x24, 0x44, 0x8f, 0x8d, 0x41, 0xbc, 0xb7, 0xd9, 0x7d, 0x38, 0xc5, 0xf9, 0xe4, 0x8d, + /*27d0:*/ 0xf6, 0x7a, 0x01, 0x3d, 0x0f, 0x9c, 0xf3, 0x55, 0x54, 0x78, 0xa8, 0xb8, 0x2e, 0x4f, 0xfd, 0x4e, + /*27e0:*/ 0xc7, 0xea, 0x78, 0xbc, 0xa3, 0x35, 0xa6, 0x8a, 0x70, 0xfb, 0xef, 0xb0, 0x5e, 0x72, 0x91, 0x3e, + /*27f0:*/ 0x43, 0xc0, 0xb0, 0x1e, 0x7a, 0x3a, 0xcd, 0xa1, 0xfd, 0x02, 0x6b, 0x55, 0xc1, 0xd2, 0x3a, 0xd1, + /*2800:*/ 0x65, 0x71, 0x5d, 0x2c, 0x57, 0xce, 0x15, 0xec, 0x08, 0xb0, 0x83, 0xf0, 0xac, 0x4f, 0x10, 0xa0, + /*2810:*/ 0x80, 0xc3, 0x64, 0x82, 0x87, 0xb4, 0x99, 0x83, 0xd3, 0x3b, 0x21, 0x03, 0xbc, 0xa3, 0x8a, 0x4f, + /*2820:*/ 0xcb, 0x72, 0x0f, 0x13, 0x55, 0xb8, 0x50, 0x30, 0x8a, 0xc7, 0x3e, 0xc8, 0x1b, 0xd2, 0x80, 0xec, + /*2830:*/ 0x87, 0x25, 0x4f, 0x9f, 0x19, 0xd6, 0x3f, 0xfc, 0x7b, 0xed, 0x1b, 0x8b, 0xa8, 0x27, 0x82, 0xa2, + /*2840:*/ 0x67, 0xae, 0xed, 0xd9, 0x1d, 0xba, 0x29, 0x2c, 0xd2, 0x11, 0x6a, 0xbd, 0x98, 0x0a, 0xca, 0x16, + /*2850:*/ 0xaf, 0xe6, 0x80, 0x10, 0xe4, 0x3c, 0x0e, 0xd2, 0xd2, 0xfe, 0x4a, 0x71, 0x1f, 0x6e, 0x6e, 0xf4, + /*2860:*/ 0xf5, 0x4a, 0x27, 0xf8, 0xb8, 0x6a, 0xf1, 0x47, 0xbe, 0xfe, 0x48, 0x31, 0x87, 0xd1, 0x31, 0x1d, + /*2870:*/ 0x6e, 0x64, 0xde, 0x2a, 0x50, 0xb6, 0x47, 0xf2, 0x35, 0xd7, 0x97, 0x70, 0x2a, 0xf7, 0xf1, 0xa7, + /*2880:*/ 0x14, 0x57, 0x09, 0x45, 0xa9, 0x64, 0x6b, 0x3f, 0x98, 0xc7, 0xe9, 0xf4, 0x5f, 0x74, 0xe4, 0x44, + /*2890:*/ 0x34, 0xce, 0x4a, 0x60, 0x80, 0x6c, 0xe7, 0x88, 0xc9, 0xab, 0x26, 0x5a, 0xc4, 0x5f, 0xe3, 0x09, + /*28a0:*/ 0x2d, 0xc8, 0x95, 0xae, 0xfc, 0x8e, 0xdf, 0xc9, 0x3c, 0x65, 0x5c, 0xf5, 0x7c, 0x04, 0x20, 0xcb, + /*28b0:*/ 0x22, 0xb7, 0x6b, 0x91, 0xc3, 0x2d, 0xa0, 0x25, 0xc2, 0x69, 0x7b, 0x3d, 0x86, 0x1a, 0x20, 0x49, + /*28c0:*/ 0x8d, 0x42, 0xc1, 0xc4, 0x9a, 0x1f, 0xf3, 0x3f, 0x52, 0xf0, 0xf1, 0xe2, 0x5c, 0xf0, 0x37, 0x12, + /*28d0:*/ 0x99, 0x13, 0x21, 0x70, 0x39, 0x7c, 0x74, 0x22, 0xff, 0xc6, 0xc6, 0x0c, 0xbc, 0xf6, 0x8d, 0x72, + /*28e0:*/ 0xeb, 0xa4, 0x13, 0x79, 0xd7, 0x23, 0xa8, 0xdb, 0x59, 0x7b, 0x70, 0xfd, 0x06, 0xf5, 0x6c, 0x53, + /*28f0:*/ 0xe5, 0x04, 0x74, 0xa7, 0xc8, 0xb6, 0xe6, 0x95, 0x99, 0x95, 0x89, 0x55, 0xc7, 0xdd, 0xc9, 0x45, + /*2900:*/ 0xb5, 0x88, 0xc7, 0xbd, 0x0d, 0x52, 0xf0, 0x08, 0x03, 0x87, 0x9e, 0x8b, 0xe6, 0x68, 0x57, 0xde, + /*2910:*/ 0x81, 0x77, 0x92, 0x91, 0x45, 0x41, 0x3a, 0xfe, 0x2f, 0xf0, 0x2c, 0x3b, 0xed, 0x9d, 0x3e, 0xbf, + /*2920:*/ 0x4a, 0x8e, 0x7f, 0x54, 0xaa, 0x5c, 0x08, 0x84, 0x86, 0xf3, 0xc3, 0x04, 0x86, 0x2a, 0xab, 0xaf, + /*2930:*/ 0xcc, 0xac, 0xd8, 0x59, 0x7d, 0xa1, 0xd3, 0x70, 0x4f, 0xb1, 0x1b, 0x05, 0xbb, 0x61, 0x85, 0xd7, + /*2940:*/ 0x3b, 0xaf, 0x3c, 0x80, 0x2a, 0xae, 0x1b, 0xfe, 0x24, 0xb6, 0x1d, 0x23, 0x3d, 0xae, 0x39, 0x5a, + /*2950:*/ 0xe5, 0xc4, 0x23, 0x39, 0x4f, 0x4c, 0x7e, 0x83, 0x4e, 0x8a, 0x8a, 0x89, 0x5f, 0x9e, 0x28, 0x1b, + /*2960:*/ 0xd8, 0xdf, 0xb8, 0xf7, 0x0e, 0x9d, 0x83, 0x23, 0x33, 0x77, 0x09, 0x96, 0x4b, 0x3c, 0xd3, 0x34, + /*2970:*/ 0x32, 0x75, 0x8b, 0x57, 0xd0, 0x75, 0xa1, 0xbe, 0xbf, 0xaa, 0x47, 0xfd, 0x34, 0xe1, 0x8d, 0xb2, + /*2980:*/ 0x15, 0x23, 0xdb, 0x9e, 0x68, 0x87, 0x98, 0xf4, 0x50, 0xc2, 0x43, 0xaf, 0x3a, 0x76, 0xcb, 0xb8, + /*2990:*/ 0x3f, 0x8f, 0x5c, 0x0d, 0x82, 0x4d, 0x86, 0xfe, 0x53, 0x51, 0xea, 0xba, 0xf7, 0x47, 0x9f, 0xbd, + /*29a0:*/ 0xb9, 0xf3, 0xe7, 0x5c, 0x21, 0x05, 0x9f, 0xa0, 0x51, 0x53, 0xec, 0xda, 0xce, 0x5d, 0xd7, 0x54, + /*29b0:*/ 0xbb, 0x95, 0xb8, 0xf0, 0x81, 0xf5, 0x80, 0x72, 0x6c, 0x11, 0xf6, 0x50, 0x7e, 0xb6, 0x7b, 0x17, + /*29c0:*/ 0xd4, 0xd9, 0xca, 0x9f, 0x2a, 0x42, 0xef, 0x81, 0x72, 0x68, 0x21, 0x4a, 0x32, 0x41, 0xa8, 0x2b, + /*29d0:*/ 0x6b, 0xf7, 0xc2, 0x9d, 0xdc, 0x14, 0x0e, 0xfa, 0x35, 0x95, 0x7d, 0x9c, 0xb5, 0x2c, 0x52, 0xac, + /*29e0:*/ 0xf3, 0x4a, 0x82, 0x9a, 0x6b, 0xa6, 0x5a, 0x53, 0xbe, 0x75, 0x7e, 0xd7, 0x62, 0x28, 0xe1, 0x42, + /*29f0:*/ 0x1b, 0x44, 0x8c, 0xb3, 0xf7, 0x59, 0x60, 0xb4, 0x6d, 0x87, 0x89, 0xf3, 0x5b, 0xe9, 0x02, 0xee, + /*2a00:*/ 0x38, 0xdb, 0xcb, 0x3f, 0x5a, 0x99, 0x68, 0x43, 0x13, 0x62, 0x6b, 0x05, 0xd7, 0xc0, 0x81, 0x10, + /*2a10:*/ 0xbf, 0x56, 0x4e, 0x2a, 0x21, 0xe2, 0x17, 0x64, 0xfa, 0x2c, 0xc1, 0xee, 0xa0, 0xee, 0x91, 0xcb, + /*2a20:*/ 0x12, 0xaa, 0x14, 0x08, 0xc1, 0x29, 0x23, 0xb4, 0xc6, 0xaf, 0xff, 0xf8, 0x4d, 0x05, 0x6c, 0xe8, + /*2a30:*/ 0x20, 0x11, 0xdf, 0xc4, 0x0f, 0x2c, 0x49, 0xc9, 0xd3, 0xf2, 0x7d, 0x37, 0x9c, 0xc0, 0xc1, 0x99, + /*2a40:*/ 0xf5, 0xa1, 0x91, 0x10, 0x45, 0x6a, 0xf4, 0x61, 0x3e, 0x0f, 0x08, 0x4f, 0x84, 0xe9, 0x22, 0x0d, + /*2a50:*/ 0x1e, 0x78, 0x44, 0xd8, 0x31, 0x49, 0x6a, 0x31, 0x2a, 0x43, 0x5c, 0x64, 0x66, 0x43, 0x10, 0x9d, + /*2a60:*/ 0xa2, 0x74, 0x84, 0x28, 0xbf, 0x78, 0x5a, 0xfd, 0xbe, 0x2d, 0x01, 0xeb, 0x55, 0xa9, 0x41, 0x94, + /*2a70:*/ 0xd1, 0x7b, 0x72, 0x62, 0x82, 0x92, 0x64, 0xef, 0x05, 0xe9, 0xd0, 0x35, 0x3d, 0x46, 0x4d, 0xb4, + /*2a80:*/ 0x9f, 0x1e, 0x09, 0x38, 0x8c, 0x37, 0x70, 0x9e, 0xfb, 0x04, 0xa0, 0xd1, 0x49, 0x92, 0x85, 0x74, + /*2a90:*/ 0x23, 0x19, 0x41, 0xc3, 0x56, 0xf0, 0x89, 0xdf, 0x00, 0x83, 0x4b, 0xcb, 0xf1, 0x66, 0x9b, 0x8d, + /*2aa0:*/ 0x61, 0xf0, 0x6d, 0xee, 0x6b, 0x34, 0xc3, 0x88, 0x7e, 0xbf, 0x62, 0x3f, 0xe7, 0x4d, 0x85, 0x70, + /*2ab0:*/ 0xba, 0x7c, 0xe4, 0x78, 0x8f, 0xa1, 0x01, 0x58, 0x68, 0x67, 0x05, 0x36, 0x17, 0x0c, 0x4f, 0xe3, + /*2ac0:*/ 0xd4, 0x85, 0x39, 0x93, 0x8f, 0xf6, 0xd6, 0x93, 0x16, 0xd9, 0x19, 0x7c, 0xa6, 0x94, 0x76, 0xad, + /*2ad0:*/ 0xf4, 0xec, 0x5b, 0x63, 0x3d, 0x3e, 0x65, 0x29, 0x39, 0x6c, 0xa7, 0xe0, 0xbf, 0xe5, 0x64, 0x17, + /*2ae0:*/ 0xa9, 0xcb, 0xb9, 0x96, 0x58, 0x85, 0xdb, 0x55, 0x33, 0x31, 0x70, 0xac, 0x89, 0x01, 0x54, 0x83, + /*2af0:*/ 0x8d, 0x52, 0xa6, 0x6d, 0x71, 0x5f, 0x7b, 0xb6, 0x43, 0x8b, 0x44, 0x4e, 0xe4, 0x38, 0x67, 0x32, + /*2b00:*/ 0x4b, 0x5b, 0xea, 0xfd, 0xe5, 0x4c, 0x44, 0x15, 0x80, 0xde, 0x1c, 0x5d, 0x8c, 0xa5, 0xa1, 0x03, + /*2b10:*/ 0x56, 0x81, 0x78, 0x9b, 0xcc, 0x2f, 0xbb, 0x98, 0x55, 0xc8, 0x2b, 0x2c, 0x3d, 0x5a, 0x9c, 0x01, + /*2b20:*/ 0x73, 0x9f, 0x25, 0x24, 0x2a, 0xf9, 0xf0, 0x69, 0x59, 0x11, 0x7f, 0x0e, 0xa9, 0xfc, 0x14, 0x2d, + /*2b30:*/ 0x75, 0xa1, 0x24, 0xa0, 0x02, 0x29, 0x81, 0x04, 0x79, 0xfe, 0x7e, 0x99, 0x45, 0x01, 0xc0, 0xd4, + /*2b40:*/ 0x38, 0x9c, 0x9c, 0x24, 0xe8, 0x02, 0x26, 0xae, 0x10, 0x3d, 0x37, 0x33, 0xe3, 0x74, 0xd4, 0xfc, + /*2b50:*/ 0xe3, 0x82, 0x8e, 0xa2, 0x1c, 0x22, 0x8d, 0xd7, 0x94, 0xb3, 0xb3, 0x3c, 0xfc, 0xeb, 0xa9, 0x9c, + /*2b60:*/ 0xc6, 0x1c, 0x9e, 0x39, 0xaf, 0xb9, 0xfb, 0x65, 0x9a, 0xc7, 0xa3, 0xaa, 0x65, 0x23, 0x14, 0xb3, + /*2b70:*/ 0x30, 0x9f, 0x26, 0x3d, 0x44, 0x94, 0xe8, 0x44, 0xe1, 0xa8, 0x48, 0xb2, 0x6a, 0x1d, 0x2c, 0x49, + /*2b80:*/ 0xff, 0x90, 0x82, 0x9b, 0x21, 0xa9, 0xee, 0x51, 0x32, 0xfc, 0xa3, 0x77, 0x87, 0xf5, 0x1d, 0xc5, + /*2b90:*/ 0xd3, 0xb3, 0x1c, 0x25, 0x36, 0xa7, 0x23, 0xaf, 0xbf, 0x16, 0x25, 0x73, 0x91, 0x02, 0x04, 0xf7, + /*2ba0:*/ 0x4d, 0xe0, 0xa1, 0x12, 0x68, 0xa8, 0x89, 0xbe, 0x16, 0xed, 0x84, 0x18, 0x68, 0x17, 0x7b, 0x27, + /*2bb0:*/ 0x73, 0xc2, 0x07, 0xcf, 0x89, 0xdd, 0x18, 0x3c, 0x0f, 0x0c, 0x94, 0x2e, 0x9c, 0x44, 0xba, 0xf5, + /*2bc0:*/ 0x4f, 0x3b, 0xd4, 0xb7, 0x3a, 0x61, 0xd3, 0x4c, 0x1a, 0x09, 0x3c, 0x37, 0x29, 0x49, 0x8a, 0x38, + /*2bd0:*/ 0x91, 0xda, 0xb9, 0x64, 0x3c, 0xdd, 0xfe, 0x2a, 0x84, 0xb3, 0x56, 0x8c, 0xdb, 0x27, 0x73, 0x96, + /*2be0:*/ 0x5b, 0xfa, 0x89, 0x4d, 0xda, 0xd8, 0x0e, 0x72, 0x44, 0x6c, 0x66, 0x4f, 0x1a, 0x18, 0xa3, 0xf3, + /*2bf0:*/ 0xdc, 0xc0, 0x55, 0xa5, 0x25, 0x61, 0xd6, 0xf7, 0x09, 0xe1, 0xb6, 0x43, 0x4e, 0x1c, 0x6c, 0xd4, + /*2c00:*/ 0x49, 0xfe, 0x6c, 0xd1, 0xda, 0x1d, 0x53, 0xf7, 0x4e, 0x4d, 0xb2, 0x43, 0x0d, 0x98, 0x2e, 0x29, + /*2c10:*/ 0x9f, 0xd5, 0xfc, 0x21, 0x31, 0xd8, 0x74, 0x1a, 0x3b, 0xf7, 0x50, 0x06, 0x57, 0x6c, 0xbe, 0x5e, + /*2c20:*/ 0x5a, 0x29, 0xef, 0xac, 0xde, 0xf2, 0xe3, 0xad, 0x69, 0x6f, 0x67, 0x78, 0xce, 0x9f, 0xc4, 0x42, + /*2c30:*/ 0xb0, 0xac, 0xeb, 0x30, 0x7f, 0x23, 0x93, 0x86, 0xe7, 0x7d, 0x35, 0x32, 0xe3, 0x6b, 0x0e, 0x8b, + /*2c40:*/ 0x58, 0x83, 0x50, 0xe3, 0x5f, 0x12, 0xd4, 0xa7, 0xf2, 0x1b, 0xfb, 0xb1, 0xf9, 0x7e, 0x1e, 0x05, + /*2c50:*/ 0x7f, 0xec, 0x88, 0x2e, 0xd3, 0xda, 0x49, 0x3f, 0x3a, 0xc9, 0xb7, 0x3f, 0x44, 0xc5, 0xb6, 0x01, + /*2c60:*/ 0xb0, 0x6f, 0xa1, 0x3c, 0x9e, 0x44, 0x02, 0xf1, 0x11, 0x92, 0xf1, 0xd1, 0x7d, 0x2a, 0xa7, 0xc2, + /*2c70:*/ 0x7f, 0x5b, 0xc3, 0x0e, 0x03, 0xe1, 0x86, 0xf4, 0x63, 0x19, 0x15, 0xad, 0x1b, 0x0d, 0x9b, 0x04, + /*2c80:*/ 0x55, 0x49, 0xcb, 0x89, 0x85, 0x98, 0x6a, 0xd0, 0x18, 0x4d, 0xa2, 0x3e, 0x8c, 0x8b, 0x6c, 0x5b, + /*2c90:*/ 0xcf, 0xd1, 0xcb, 0xf3, 0x1a, 0x7b, 0x7b, 0x97, 0xe1, 0xa9, 0xd3, 0xcd, 0xc1, 0xbd, 0x25, 0x99, + /*2ca0:*/ 0x51, 0xde, 0x67, 0x08, 0x13, 0xa2, 0x91, 0x52, 0x4e, 0xf3, 0xca, 0xe7, 0xf3, 0xdc, 0x94, 0x1e, + /*2cb0:*/ 0x00, 0x60, 0x69, 0xfe, 0x98, 0xe9, 0x06, 0xc4, 0xf9, 0x9f, 0xdd, 0x2b, 0x25, 0x11, 0x41, 0x4f, + /*2cc0:*/ 0x7a, 0x75, 0x62, 0x4e, 0xbe, 0x00, 0x7b, 0xee, 0x38, 0x57, 0xd3, 0x5a, 0xf7, 0xc2, 0x33, 0x37, + /*2cd0:*/ 0x59, 0xe3, 0xd5, 0x20, 0x4e, 0xb1, 0x8d, 0xcf, 0x43, 0x03, 0xf3, 0x65, 0xca, 0xb6, 0xd1, 0x52, + /*2ce0:*/ 0x36, 0x8e, 0xdd, 0xb0, 0x30, 0x6c, 0xcf, 0xec, 0xe1, 0x04, 0xc1, 0x5b, 0x40, 0x7b, 0x4d, 0x02, + /*2cf0:*/ 0x91, 0x46, 0x3c, 0x90, 0x87, 0x60, 0xe4, 0x1b, 0xe0, 0xe1, 0x2c, 0xeb, 0x16, 0x6f, 0x6c, 0x72, + /*2d00:*/ 0xda, 0x71, 0x1f, 0x55, 0x3a, 0xe7, 0x52, 0x15, 0xff, 0x09, 0x4a, 0x84, 0x0c, 0xc5, 0x92, 0x69, + /*2d10:*/ 0x94, 0x5c, 0xb2, 0x15, 0x7f, 0x00, 0xe3, 0xf1, 0x43, 0x8b, 0x06, 0xa3, 0x51, 0xdf, 0xd1, 0x3c, + /*2d20:*/ 0x14, 0xe0, 0xe4, 0x18, 0xae, 0xe2, 0x56, 0x00, 0x6d, 0x04, 0xa0, 0xef, 0x21, 0xfe, 0x0e, 0xd6, + /*2d30:*/ 0x19, 0x78, 0x19, 0x98, 0xa4, 0x86, 0x6c, 0xc2, 0x39, 0x3b, 0x61, 0x33, 0xf9, 0xd9, 0xed, 0xcb, + /*2d40:*/ 0x8b, 0x14, 0x4e, 0xc2, 0x0f, 0x5d, 0xf0, 0x19, 0x0b, 0x21, 0x25, 0x61, 0x79, 0x93, 0x3d, 0x0d, + /*2d50:*/ 0xed, 0x6f, 0x1a, 0xa0, 0x19, 0xab, 0xb6, 0x56, 0xce, 0xa5, 0x51, 0xa4, 0x09, 0xf6, 0xc5, 0x95, + /*2d60:*/ 0x63, 0x85, 0x5f, 0x24, 0xd7, 0xd4, 0xba, 0x07, 0xa3, 0x62, 0x55, 0xe7, 0x3f, 0x7c, 0x3a, 0x8b, + /*2d70:*/ 0xc3, 0xc8, 0xe9, 0x94, 0x59, 0x59, 0xc9, 0x87, 0xc9, 0xc1, 0xdb, 0xb9, 0xc0, 0x13, 0xa1, 0x1e, + /*2d80:*/ 0xd4, 0x49, 0x32, 0xa3, 0x31, 0x42, 0xb4, 0x32, 0xed, 0x0a, 0xfd, 0xf4, 0xf8, 0x76, 0x01, 0x28, + /*2d90:*/ 0xaf, 0x1e, 0x7b, 0xd6, 0x7e, 0xf7, 0x05, 0x4c, 0x15, 0xee, 0x50, 0x74, 0x15, 0xbf, 0x19, 0xc7, + /*2da0:*/ 0x5e, 0xa6, 0x8d, 0xb9, 0x0d, 0xfc, 0x4a, 0xf1, 0x55, 0x4f, 0x2a, 0xea, 0x1c, 0x91, 0xdf, 0x47, + /*2db0:*/ 0xf2, 0x3a, 0xab, 0x09, 0x3a, 0x96, 0x92, 0x4b, 0xdd, 0xf7, 0x13, 0x82, 0xa1, 0x77, 0x44, 0x96, + /*2dc0:*/ 0xe2, 0x7b, 0x9d, 0xcb, 0xdd, 0x3b, 0x10, 0xf6, 0x45, 0x5b, 0xd0, 0x9e, 0xfb, 0x50, 0x10, 0x86, + /*2dd0:*/ 0x31, 0x05, 0x5c, 0x8e, 0x77, 0xb2, 0x49, 0x86, 0xe1, 0x35, 0x45, 0x65, 0x28, 0x5b, 0x05, 0xce, + /*2de0:*/ 0x4b, 0xef, 0xf2, 0x62, 0xde, 0xa3, 0x89, 0xf9, 0x8f, 0x68, 0x2a, 0x2c, 0xcd, 0x06, 0xd0, 0xb5, + /*2df0:*/ 0xb4, 0x4d, 0xa2, 0x38, 0xd1, 0x3c, 0x01, 0x13, 0x3c, 0x98, 0x8b, 0x72, 0x80, 0x4a, 0x22, 0x73, + /*2e00:*/ 0x45, 0x15, 0x5a, 0xaf, 0x27, 0x76, 0x7e, 0xd0, 0x5e, 0xad, 0x37, 0xdb, 0x59, 0xac, 0xd1, 0x11, + /*2e10:*/ 0x9e, 0xca, 0x10, 0x59, 0x29, 0x7d, 0x2f, 0xc4, 0xcb, 0x83, 0xdb, 0x96, 0x54, 0x7d, 0xa7, 0x4c, + /*2e20:*/ 0x61, 0x0b, 0x0e, 0xa1, 0xcd, 0xa5, 0x5d, 0x9c, 0x5d, 0xc7, 0x5a, 0x5d, 0x10, 0xfc, 0x43, 0x7b, + /*2e30:*/ 0x91, 0xd0, 0x2a, 0xdc, 0x9f, 0x4b, 0xeb, 0xaa, 0x53, 0xf3, 0x5a, 0x54, 0x16, 0x78, 0xd2, 0x67, + /*2e40:*/ 0x28, 0x1a, 0x39, 0x2e, 0x9a, 0x5b, 0xae, 0x7e, 0x2f, 0xc2, 0xf6, 0xa7, 0xaf, 0x8a, 0x84, 0xdf, + /*2e50:*/ 0x6b, 0xdb, 0xbc, 0xdf, 0xd7, 0x2e, 0xd5, 0x27, 0xbb, 0x31, 0x40, 0xb9, 0x54, 0xb1, 0xf9, 0x08, + /*2e60:*/ 0xdb, 0x69, 0xff, 0x2e, 0x40, 0xa9, 0x98, 0x36, 0x02, 0x24, 0x52, 0x27, 0x48, 0x5b, 0x16, 0x56, + /*2e70:*/ 0x8a, 0x2c, 0x7d, 0x15, 0xd1, 0xd8, 0xb2, 0x74, 0xbf, 0x2e, 0x65, 0x61, 0xe8, 0x1c, 0x53, 0x99, + /*2e80:*/ 0x54, 0x0a, 0xc0, 0x53, 0xc4, 0xdd, 0x62, 0x38, 0x49, 0x1a, 0xb7, 0xf1, 0xc0, 0xee, 0xf7, 0x58, + /*2e90:*/ 0xa9, 0xcd, 0xd2, 0x49, 0xcc, 0x6d, 0xee, 0x43, 0xd0, 0x0c, 0xd4, 0x4b, 0x15, 0x3d, 0x00, 0x7f, + /*2ea0:*/ 0x08, 0x29, 0x25, 0x1e, 0x13, 0xc4, 0xfa, 0x84, 0x9a, 0xbd, 0x22, 0xd9, 0xf8, 0x0f, 0xa9, 0xb6, + /*2eb0:*/ 0x13, 0x6f, 0x03, 0xd1, 0x91, 0xf7, 0x88, 0x36, 0xbd, 0xb3, 0xb1, 0x67, 0xca, 0x39, 0x4e, 0x1d, + /*2ec0:*/ 0xc7, 0xbc, 0xdf, 0xbb, 0x25, 0x1c, 0xcc, 0x59, 0xd1, 0x69, 0x9e, 0x56, 0xe3, 0x93, 0x63, 0xd5, + /*2ed0:*/ 0x44, 0xdd, 0x6b, 0x69, 0x1e, 0x51, 0xd0, 0x22, 0x69, 0x3f, 0x04, 0x43, 0xa5, 0xd6, 0x8f, 0x2f, + /*2ee0:*/ 0x6d, 0xe8, 0xd6, 0x0e, 0x3d, 0x58, 0x2a, 0x83, 0xd2, 0xee, 0x0e, 0x9d, 0x2c, 0xa8, 0xb5, 0xfa, + /*2ef0:*/ 0x65, 0x19, 0x04, 0x2d, 0x19, 0x8c, 0x07, 0xf5, 0x2f, 0x01, 0xf8, 0xc5, 0x38, 0x24, 0xd4, 0x6e, + /*2f00:*/ 0xfd, 0xd6, 0xad, 0xf6, 0xac, 0xcd, 0x92, 0x27, 0x93, 0x0b, 0xf9, 0x60, 0x22, 0x2b, 0xa2, 0xae, + /*2f10:*/ 0x86, 0x79, 0xd7, 0xd6, 0xb6, 0xad, 0x64, 0x59, 0x69, 0xe0, 0x83, 0xf3, 0xf9, 0x49, 0x19, 0x08, + /*2f20:*/ 0x9a, 0xa3, 0xfd, 0xf5, 0x92, 0x2d, 0x35, 0x06, 0x44, 0x32, 0xe7, 0xdf, 0x5e, 0x83, 0x93, 0x42, + /*2f30:*/ 0xe4, 0xf8, 0x24, 0xad, 0x65, 0x6d, 0x37, 0x58, 0x87, 0x80, 0x2b, 0xac, 0xc7, 0x27, 0xce, 0x2d, + /*2f40:*/ 0x07, 0x10, 0x7e, 0x1d, 0xa4, 0x80, 0x2c, 0x16, 0xf0, 0x3b, 0x66, 0x3d, 0x74, 0x15, 0x25, 0xe0, + /*2f50:*/ 0x46, 0xf3, 0x08, 0xbd, 0x0b, 0x6e, 0x44, 0x5a, 0xc5, 0x0e, 0x53, 0x01, 0x4b, 0x80, 0x16, 0x91, + /*2f60:*/ 0x07, 0x94, 0x8f, 0x66, 0xb9, 0x38, 0xa1, 0x44, 0xed, 0xd4, 0x44, 0x58, 0x36, 0xd2, 0x12, 0xf3, + /*2f70:*/ 0xb0, 0x41, 0x7a, 0xfa, 0xaa, 0xca, 0x35, 0xf2, 0xd6, 0x4e, 0xf7, 0x8b, 0xce, 0x9b, 0x7d, 0x67, + /*2f80:*/ 0xdc, 0xbb, 0x46, 0xc8, 0x19, 0xbf, 0x0d, 0xd0, 0x7a, 0xee, 0x10, 0xb7, 0x9c, 0x85, 0x94, 0xb4, + /*2f90:*/ 0xfd, 0x49, 0x0d, 0x77, 0x9e, 0x95, 0x0b, 0xe2, 0xd5, 0xef, 0x28, 0x08, 0xee, 0xbf, 0xf9, 0x4b, + /*2fa0:*/ 0x39, 0x74, 0x02, 0x96, 0x1a, 0x8f, 0x34, 0x8b, 0x3a, 0xd9, 0x3f, 0x63, 0xa4, 0xfd, 0x63, 0xbd, + /*2fb0:*/ 0xc6, 0xfd, 0x8f, 0x02, 0x97, 0x44, 0xbc, 0xb1, 0xe5, 0x95, 0xd0, 0x5b, 0xa8, 0x3c, 0x11, 0xd9, + /*2fc0:*/ 0x93, 0xbf, 0x66, 0x82, 0xdc, 0xdd, 0xd5, 0x99, 0xee, 0x92, 0x09, 0x8e, 0x06, 0x0e, 0x7e, 0x67, + /*2fd0:*/ 0x00, 0xb5, 0x93, 0xb3, 0x39, 0x00, 0xe2, 0xe2, 0xb7, 0xe3, 0xe0, 0x1f, 0x3e, 0xd7, 0x8a, 0xc7, + /*2fe0:*/ 0x7e, 0xa6, 0xce, 0x8b, 0x08, 0xaa, 0x9a, 0xde, 0x27, 0xd2, 0xaf, 0xca, 0x72, 0x41, 0xb0, 0x4f, + /*2ff0:*/ 0xea, 0xf5, 0x7b, 0x85, 0x46, 0x03, 0xa6, 0x1f, 0x50, 0x7f, 0x74, 0xba, 0x01, 0xae, 0x88, 0x1e, + /*3000:*/ 0x0a, 0x50, 0x71, 0xb9, 0xcc, 0x78, 0x5a, 0xdd, 0x4c, 0xad, 0x30, 0xbd, 0xe8, 0x34, 0x8a, 0xe1, + /*3010:*/ 0xaf, 0xa9, 0xeb, 0xb9, 0x22, 0x69, 0xd7, 0x30, 0x45, 0xa6, 0x06, 0xf3, 0xd6, 0x4e, 0xac, 0x19, + /*3020:*/ 0xcf, 0x12, 0x66, 0x1d, 0xd2, 0x11, 0xe1, 0xcf, 0x3c, 0x12, 0x21, 0xcd, 0x74, 0xd2, 0xba, 0x62, + /*3030:*/ 0xcc, 0x6c, 0xb9, 0x67, 0xfd, 0xc4, 0x5a, 0x94, 0xc5, 0x6f, 0x1e, 0xb7, 0x49, 0x8c, 0x24, 0x96, + /*3040:*/ 0xf1, 0x8c, 0x30, 0xb9, 0xfc, 0x2f, 0xdf, 0x9d, 0xb7, 0x6c, 0x81, 0x63, 0xf5, 0x0f, 0x1c, 0xfd, + /*3050:*/ 0x15, 0xbe, 0x0b, 0x36, 0xff, 0xa2, 0xc9, 0x07, 0x40, 0x85, 0x70, 0xe4, 0x4f, 0xb0, 0xa9, 0x11, + /*3060:*/ 0x8b, 0x8d, 0x6f, 0x74, 0x17, 0x7d, 0x4c, 0xf9, 0xc6, 0x23, 0x81, 0x56, 0x21, 0xcb, 0x99, 0x1c, + /*3070:*/ 0x31, 0x03, 0xa1, 0x05, 0x5a, 0x29, 0x9a, 0xf1, 0x2e, 0xf5, 0x07, 0xb1, 0x8b, 0x6b, 0xea, 0xb6, + /*3080:*/ 0xd0, 0xe8, 0x78, 0x93, 0xb3, 0x2d, 0xcf, 0xa6, 0xb8, 0x7e, 0xfe, 0x7c, 0x91, 0x25, 0xa6, 0xf1, + /*3090:*/ 0xc8, 0xaa, 0xff, 0xcd, 0x4a, 0xf3, 0x22, 0x62, 0x98, 0xbb, 0x95, 0xa7, 0x9e, 0xff, 0x23, 0x37, + /*30a0:*/ 0x88, 0x79, 0xbe, 0x02, 0x8e, 0x85, 0xd3, 0x8e, 0x38, 0x50, 0xab, 0x9a, 0x47, 0xa8, 0xa7, 0x1a, + /*30b0:*/ 0x22, 0x06, 0xd2, 0xcb, 0xa9, 0x49, 0xd0, 0xfc, 0xa2, 0x3f, 0xb5, 0x8c, 0x80, 0xa4, 0x65, 0xf0, + /*30c0:*/ 0x7a, 0xe0, 0xf5, 0x05, 0xf8, 0x1f, 0x75, 0x8b, 0x03, 0xa8, 0xd7, 0x45, 0xd1, 0x17, 0xf4, 0x85, + /*30d0:*/ 0x94, 0x85, 0x5a, 0xb3, 0x26, 0x52, 0x4d, 0x24, 0x45, 0x93, 0xd2, 0x19, 0x04, 0x3d, 0xb9, 0x4e, + /*30e0:*/ 0xe7, 0xac, 0x7c, 0xd3, 0x38, 0x2e, 0x13, 0xce, 0x72, 0xf7, 0x26, 0x49, 0x04, 0xd0, 0xe4, 0x9b, + /*30f0:*/ 0x0f, 0x4c, 0x91, 0x27, 0x37, 0x89, 0x20, 0x54, 0x8b, 0xf9, 0xbc, 0x46, 0xab, 0x97, 0x5d, 0xf3, + /*3100:*/ 0x8c, 0xf4, 0xdf, 0x79, 0x3d, 0x13, 0x84, 0xb1, 0x12, 0x33, 0x2d, 0x83, 0xc0, 0xb0, 0xc8, 0x77, + /*3110:*/ 0xb7, 0x2e, 0x24, 0x9d, 0xdd, 0x10, 0x31, 0x6f, 0x1b, 0xef, 0x9c, 0x20, 0xcd, 0x8d, 0x90, 0x07, + /*3120:*/ 0xbf, 0x1c, 0x6f, 0x46, 0xb6, 0x6e, 0xdd, 0x90, 0x8a, 0xf8, 0xf7, 0x14, 0xc0, 0xbe, 0xd4, 0x9b, + /*3130:*/ 0x6f, 0x2a, 0xf5, 0x37, 0xf5, 0xc9, 0x5a, 0x80, 0x5d, 0xef, 0x76, 0x99, 0x7c, 0xfd, 0xd7, 0x04, + /*3140:*/ 0xa5, 0x7b, 0xe5, 0x1e, 0x45, 0x20, 0x82, 0xaa, 0xf6, 0x4f, 0x6a, 0x34, 0xfd, 0xbe, 0x61, 0xc2, + /*3150:*/ 0x2d, 0xbc, 0x5f, 0xcc, 0x56, 0xc4, 0x4d, 0x62, 0x08, 0xcb, 0xf2, 0x2b, 0x1b, 0x79, 0xd6, 0xe3, + /*3160:*/ 0xb6, 0xc2, 0xb0, 0x98, 0xaa, 0xde, 0xb9, 0xf8, 0xf8, 0x26, 0x5e, 0xf1, 0x74, 0x61, 0x5e, 0x10, + /*3170:*/ 0xa6, 0xa7, 0x45, 0x50, 0x2b, 0x94, 0x6d, 0x0d, 0x03, 0x66, 0x81, 0xed, 0x6c, 0x30, 0x48, 0x96, + /*3180:*/ 0x56, 0xda, 0x29, 0x3d, 0x9a, 0xb1, 0xa3, 0x64, 0x1f, 0xcd, 0xc9, 0x63, 0x42, 0x01, 0x08, 0x34, + /*3190:*/ 0x1d, 0x0e, 0x92, 0xca, 0xec, 0x3f, 0x9f, 0x87, 0xda, 0x68, 0xbb, 0xf1, 0x7c, 0x47, 0xc5, 0x26, + /*31a0:*/ 0x72, 0xee, 0x46, 0x90, 0x5c, 0xa7, 0x49, 0xd8, 0xd8, 0xba, 0xd6, 0xc9, 0x52, 0x9f, 0x48, 0x38, + /*31b0:*/ 0x16, 0xd9, 0xe2, 0x99, 0x88, 0xab, 0x1f, 0xca, 0xd9, 0x63, 0xd4, 0xf2, 0x48, 0x07, 0x92, 0x45, + /*31c0:*/ 0xc9, 0xe7, 0x97, 0xdf, 0x7b, 0xf7, 0x4b, 0x69, 0x5b, 0x19, 0x3b, 0x3f, 0x79, 0xc2, 0x23, 0x90, + /*31d0:*/ 0xff, 0x84, 0x5a, 0x8a, 0xe8, 0xdf, 0xcb, 0xaf, 0x3d, 0xa0, 0x15, 0x81, 0x43, 0xc6, 0xb5, 0xd9, + /*31e0:*/ 0x68, 0xc7, 0x83, 0x0b, 0x8a, 0x77, 0x16, 0xb6, 0x75, 0x23, 0x98, 0x9d, 0x0a, 0x08, 0x47, 0x4f, + /*31f0:*/ 0x0b, 0x84, 0x21, 0xdf, 0x61, 0xd5, 0x75, 0x6a, 0x2e, 0x3d, 0x82, 0x58, 0xc6, 0xa8, 0x21, 0xa1, + /*3200:*/ 0xa6, 0x39, 0x33, 0x68, 0x31, 0x70, 0x73, 0x84, 0x15, 0x0e, 0xb5, 0x4f, 0xc4, 0x80, 0x9f, 0x10, + /*3210:*/ 0x34, 0xf5, 0x6d, 0xa6, 0x49, 0x8f, 0x85, 0x36, 0xb4, 0x4c, 0x2f, 0x1e, 0x60, 0xa6, 0xfc, 0xd6, + /*3220:*/ 0xb2, 0x48, 0x2c, 0x7b, 0xdc, 0x02, 0xc7, 0x21, 0x24, 0x47, 0x20, 0x45, 0xd6, 0xbb, 0x29, 0xf6, + /*3230:*/ 0x0d, 0x25, 0x12, 0x58, 0xfe, 0xec, 0x88, 0x29, 0x9d, 0x83, 0xe5, 0x24, 0xac, 0xa3, 0x9b, 0x1f, + /*3240:*/ 0x35, 0x58, 0xe2, 0x3a, 0xf0, 0x85, 0xe1, 0x37, 0xd4, 0x91, 0xe2, 0xbf, 0xd7, 0xf4, 0x03, 0xf2, + /*3250:*/ 0xe4, 0x9d, 0x09, 0x27, 0x95, 0x3f, 0x0e, 0x3d, 0xfd, 0xf7, 0x41, 0xee, 0xb1, 0x76, 0xe1, 0xaf, + /*3260:*/ 0xed, 0x68, 0x37, 0xd5, 0xea, 0xe8, 0x6e, 0xc6, 0x11, 0xe6, 0xd7, 0xb0, 0x59, 0x19, 0x4a, 0x83, + /*3270:*/ 0x3d, 0xec, 0x38, 0xc9, 0x5b, 0xed, 0xe8, 0xe3, 0x76, 0x03, 0xcd, 0x4a, 0x90, 0xa9, 0x21, 0xd5, + /*3280:*/ 0xf4, 0x89, 0xc2, 0x7a, 0xb7, 0xa6, 0x02, 0x40, 0x5c, 0xb7, 0xe7, 0xea, 0x3e, 0xb4, 0x3e, 0x42, + /*3290:*/ 0x81, 0x6e, 0x88, 0x87, 0x7c, 0xa1, 0x71, 0xd5, 0x08, 0x7f, 0x87, 0xa0, 0x34, 0x74, 0x4a, 0x73, + /*32a0:*/ 0x8b, 0xf6, 0xfe, 0x41, 0xc8, 0xd4, 0x1d, 0x3a, 0x1e, 0xae, 0xff, 0xf4, 0x7e, 0xfe, 0xdd, 0x44, + /*32b0:*/ 0x9a, 0x3e, 0x8f, 0x5e, 0xf1, 0xdd, 0xd2, 0x38, 0x61, 0x58, 0x1e, 0xf7, 0xcd, 0x30, 0x3d, 0x88, + /*32c0:*/ 0xc4, 0x14, 0x56, 0xb3, 0x1b, 0x68, 0x0a, 0x02, 0x58, 0x47, 0x42, 0xc6, 0xf0, 0x0c, 0x6a, 0xe9, + /*32d0:*/ 0xa4, 0x20, 0x32, 0x74, 0x5a, 0xf5, 0x54, 0xa4, 0x48, 0x61, 0x6a, 0xa8, 0x12, 0x6b, 0xd9, 0xa7, + /*32e0:*/ 0x0c, 0x6c, 0xcf, 0x74, 0x1c, 0x22, 0xe4, 0x7e, 0x94, 0xe6, 0xf6, 0x9f, 0x0f, 0x17, 0x2b, 0xb1, + /*32f0:*/ 0xf0, 0xb4, 0x3b, 0x6a, 0x98, 0xfd, 0x33, 0x56, 0x6b, 0x10, 0x3e, 0x75, 0xa8, 0x0e, 0x4a, 0x99, + /*3300:*/ 0x1c, 0xfb, 0xe4, 0x70, 0x94, 0x6f, 0xbd, 0xd9, 0x40, 0x68, 0x46, 0x1f, 0x42, 0xac, 0x6c, 0x2d, + /*3310:*/ 0x0d, 0x45, 0xb0, 0x63, 0x81, 0x15, 0xdc, 0x59, 0x54, 0x73, 0xd7, 0xcd, 0xf5, 0x39, 0x93, 0x0a, + /*3320:*/ 0x09, 0xc1, 0x6f, 0x26, 0xc2, 0x33, 0xdd, 0x31, 0x87, 0xab, 0xff, 0x93, 0x96, 0xa4, 0x27, 0xda, + /*3330:*/ 0xd3, 0x5e, 0x30, 0xb4, 0x04, 0x93, 0xd5, 0xdd, 0x83, 0x4b, 0x19, 0x36, 0xb4, 0xdd, 0xeb, 0x45, + /*3340:*/ 0x70, 0x7c, 0xe7, 0x0b, 0x53, 0xda, 0x85, 0x6f, 0x66, 0xcc, 0x88, 0x3d, 0xfe, 0x7f, 0x54, 0xe2, + /*3350:*/ 0x12, 0x18, 0xc8, 0xed, 0x0b, 0x49, 0xc3, 0x4e, 0x88, 0x24, 0xae, 0x50, 0x38, 0xed, 0x78, 0x69, + /*3360:*/ 0x0d, 0x2d, 0x31, 0x46, 0xce, 0x89, 0xcc, 0x3b, 0x34, 0x8e, 0x12, 0xf4, 0xa4, 0x84, 0x6b, 0xc1, + /*3370:*/ 0x2f, 0x69, 0x3a, 0x35, 0x67, 0xb7, 0x13, 0x9d, 0x14, 0x59, 0x2c, 0x73, 0xac, 0x97, 0x1c, 0xc9, + /*3380:*/ 0x23, 0xe0, 0xec, 0xf5, 0x84, 0xb6, 0x30, 0x8a, 0x7f, 0xe6, 0x9b, 0x0d, 0xad, 0xdc, 0xa4, 0x9e, + /*3390:*/ 0xe4, 0x9f, 0x92, 0xae, 0x05, 0xd7, 0xf3, 0x74, 0x54, 0x24, 0xf8, 0x9f, 0x09, 0xa4, 0xc9, 0x3c, + /*33a0:*/ 0x6d, 0xda, 0x01, 0xeb, 0x25, 0x06, 0x66, 0xdd, 0xc0, 0x2d, 0x73, 0xfd, 0x45, 0xd1, 0xe4, 0x34, + /*33b0:*/ 0x73, 0xb4, 0x62, 0x11, 0xaf, 0x82, 0x2d, 0xcb, 0xaa, 0xb7, 0x9c, 0x83, 0xc5, 0x57, 0x86, 0xc3, + /*33c0:*/ 0xdd, 0xa0, 0xf1, 0x6d, 0xf3, 0x5a, 0xbe, 0xa8, 0xb6, 0x9f, 0x66, 0x9c, 0x7b, 0x48, 0xf1, 0x71, + /*33d0:*/ 0x83, 0x94, 0x54, 0x8d, 0x85, 0xb5, 0x03, 0xd1, 0x88, 0xb9, 0xe6, 0xcb, 0x78, 0xab, 0xea, 0x24, + /*33e0:*/ 0x54, 0x7e, 0x3f, 0x66, 0xa0, 0x3e, 0x63, 0x9b, 0x8c, 0x57, 0x2c, 0xa9, 0x97, 0xba, 0xfd, 0x6e, + /*33f0:*/ 0x05, 0xbb, 0xda, 0x9f, 0x1c, 0x9d, 0x6d, 0xea, 0x04, 0x84, 0x8c, 0x07, 0x78, 0xa2, 0x80, 0x1e, + /*3400:*/ 0x1e, 0xe0, 0x0b, 0x8f, 0x89, 0xf3, 0x84, 0x23, 0x17, 0x71, 0xff, 0x15, 0x64, 0x49, 0x2e, 0x90, + /*3410:*/ 0x0e, 0x50, 0x20, 0x2f, 0xf1, 0x9b, 0xb9, 0xb3, 0xe6, 0xf0, 0xee, 0xbb, 0x5f, 0x6d, 0xa6, 0xa2, + /*3420:*/ 0x10, 0x8f, 0xaf, 0x2f, 0x4e, 0xe9, 0x27, 0xa0, 0x04, 0x48, 0xda, 0x9a, 0x03, 0x64, 0x33, 0x42, + /*3430:*/ 0x0e, 0x02, 0x2e, 0x1f, 0x0e, 0x87, 0x0c, 0xd7, 0xe7, 0x09, 0xac, 0x79, 0x42, 0x93, 0xd7, 0x4a, + /*3440:*/ 0xaa, 0x5f, 0x07, 0xed, 0xb1, 0xaf, 0x0c, 0x22, 0x63, 0x2a, 0x9c, 0x9d, 0x4b, 0x6c, 0xf6, 0x80, + /*3450:*/ 0x0a, 0x1e, 0x4a, 0x50, 0x07, 0x64, 0xc6, 0xcc, 0x3a, 0x2a, 0x64, 0x9e, 0xde, 0x5b, 0x2d, 0x6c, + /*3460:*/ 0xe3, 0x48, 0xb5, 0x11, 0x9d, 0x3c, 0xf0, 0x8f, 0x5c, 0x0d, 0xd7, 0x02, 0xf5, 0xce, 0xff, 0x71, + /*3470:*/ 0x06, 0xc4, 0x4b, 0x7d, 0x67, 0x7e, 0xef, 0xc4, 0x78, 0x60, 0xba, 0x58, 0x0f, 0xbc, 0x84, 0x7b, + /*3480:*/ 0xc5, 0xba, 0xde, 0x8b, 0xdc, 0x60, 0x78, 0xab, 0xf2, 0xde, 0xd4, 0xed, 0x00, 0x22, 0x6b, 0xa4, + /*3490:*/ 0x4a, 0x79, 0x43, 0x79, 0xba, 0x03, 0x84, 0x25, 0x0c, 0x41, 0x1d, 0x1f, 0x19, 0x23, 0x7c, 0xf7, + /*34a0:*/ 0x20, 0xa3, 0xfd, 0xa1, 0x4f, 0xff, 0xfe, 0x8c, 0x7e, 0xb9, 0x07, 0x7d, 0xbe, 0x79, 0x18, 0xa8, + /*34b0:*/ 0x24, 0x2a, 0x95, 0x01, 0xf3, 0x3f, 0xb1, 0xa6, 0xe4, 0xda, 0xcf, 0x68, 0x42, 0x08, 0x2c, 0x4d, + /*34c0:*/ 0x2a, 0xd7, 0xb3, 0x6f, 0x4a, 0xb4, 0x6b, 0xe9, 0x0b, 0xfb, 0x73, 0xb1, 0x21, 0x0a, 0x44, 0xab, + /*34d0:*/ 0x47, 0x02, 0xdb, 0xb5, 0x0b, 0x13, 0x6f, 0x0c, 0x78, 0x40, 0xbd, 0x73, 0x04, 0xf2, 0x7e, 0x54, + /*34e0:*/ 0x85, 0x35, 0x78, 0x52, 0x6d, 0xf4, 0x05, 0x70, 0x51, 0xa2, 0xb9, 0x6f, 0x34, 0x8c, 0x4b, 0x7b, + /*34f0:*/ 0xb8, 0x6c, 0x3b, 0xa5, 0xe7, 0x22, 0xc6, 0x46, 0xa8, 0x09, 0xc3, 0x6b, 0x19, 0x01, 0x50, 0xa5, + /*3500:*/ 0x58, 0xef, 0x4d, 0xfa, 0xee, 0x20, 0xbd, 0xcb, 0xd1, 0x56, 0xae, 0x7e, 0xc3, 0x6f, 0x61, 0x52, + /*3510:*/ 0xde, 0x9e, 0x59, 0xc4, 0x41, 0x52, 0x78, 0x39, 0x97, 0x30, 0x24, 0x9e, 0x92, 0xea, 0xbc, 0x69, + /*3520:*/ 0xf9, 0x8d, 0x1d, 0x1a, 0xce, 0x74, 0x52, 0x4f, 0x04, 0x5f, 0x0e, 0xd8, 0xb7, 0xb4, 0xf5, 0x5b, + /*3530:*/ 0xa9, 0x1c, 0xc0, 0x0d, 0xf3, 0xbc, 0x27, 0xde, 0x37, 0xe6, 0x26, 0x11, 0xd4, 0x9b, 0x25, 0x42, + /*3540:*/ 0xd7, 0xc1, 0xf6, 0xde, 0xb5, 0xae, 0x24, 0x59, 0x2a, 0x83, 0xb5, 0xa6, 0x8f, 0x03, 0xd3, 0xbf, + /*3550:*/ 0xcb, 0x58, 0x76, 0xe0, 0xf7, 0xdb, 0x63, 0xa4, 0x18, 0xbc, 0xfb, 0x0c, 0x76, 0x3e, 0x73, 0x71, + /*3560:*/ 0x4a, 0xdc, 0x5a, 0x0e, 0xf8, 0x59, 0x88, 0xc1, 0xc9, 0x55, 0x13, 0xc7, 0xab, 0x57, 0x85, 0x5b, + /*3570:*/ 0x46, 0x4d, 0x19, 0x14, 0x0c, 0xb0, 0x43, 0xd2, 0x92, 0xef, 0x6f, 0x8b, 0xd9, 0x06, 0xd3, 0x2f, + /*3580:*/ 0xaf, 0xf3, 0xa5, 0x09, 0x71, 0x96, 0x97, 0x5a, 0xfd, 0x03, 0x65, 0xad, 0x8e, 0x62, 0xce, 0x91, + /*3590:*/ 0x96, 0xd3, 0x91, 0x11, 0xb2, 0x85, 0xc7, 0xcb, 0x29, 0x79, 0x8d, 0x37, 0xd7, 0xec, 0x13, 0x43, + /*35a0:*/ 0x20, 0x08, 0x40, 0x8f, 0xa2, 0xee, 0xa5, 0x1f, 0xed, 0xa5, 0x78, 0x4b, 0x59, 0x50, 0x60, 0x09, + /*35b0:*/ 0x66, 0x0b, 0x0a, 0x5a, 0xc1, 0xd6, 0xe3, 0x96, 0xcd, 0xa2, 0x61, 0x26, 0x57, 0xa0, 0x51, 0x7e, + /*35c0:*/ 0x11, 0x21, 0xad, 0xce, 0xf5, 0x26, 0xdc, 0x8c, 0x3e, 0xd0, 0x61, 0xd8, 0x11, 0x2c, 0x7a, 0x68, + /*35d0:*/ 0xca, 0x95, 0x26, 0xde, 0x3c, 0xb4, 0xf1, 0x4b, 0x1e, 0xb8, 0x21, 0x83, 0x1e, 0xdb, 0xd9, 0x9d, + /*35e0:*/ 0x73, 0x60, 0xfa, 0x26, 0x2b, 0x41, 0xd1, 0x55, 0x16, 0x7b, 0x9f, 0xa8, 0xa4, 0x1f, 0x18, 0x5b, + /*35f0:*/ 0x6d, 0x22, 0xab, 0x73, 0x71, 0x7c, 0x04, 0xa8, 0xef, 0x3f, 0x1d, 0x2c, 0x9a, 0x98, 0x4e, 0xff, + /*3600:*/ 0xc7, 0xef, 0x7b, 0x63, 0x4d, 0x79, 0xe2, 0x33, 0x0a, 0xd8, 0x26, 0x30, 0xfc, 0xa3, 0x24, 0x5e, + /*3610:*/ 0x2f, 0xd7, 0xb3, 0x90, 0x1e, 0x45, 0x30, 0x41, 0x00, 0x59, 0x92, 0x62, 0x20, 0xb3, 0xff, 0x5d, + /*3620:*/ 0x47, 0x31, 0x6e, 0x87, 0xe5, 0x7e, 0x9d, 0x73, 0x8d, 0x3d, 0x74, 0x9c, 0x4b, 0xf7, 0xc8, 0x86, + /*3630:*/ 0xe4, 0xa7, 0xac, 0x4c, 0xf9, 0x51, 0x2f, 0x4d, 0xd2, 0x02, 0x9b, 0xcf, 0xb7, 0x68, 0x7f, 0x25, + /*3640:*/ 0xc7, 0x22, 0xfa, 0x75, 0xe5, 0xdd, 0x7e, 0xd3, 0x28, 0x07, 0x87, 0x78, 0x62, 0x20, 0x0e, 0xa1, + /*3650:*/ 0xab, 0x3e, 0xfd, 0xd0, 0x04, 0xe6, 0xd8, 0xf0, 0xa3, 0x1e, 0x05, 0xf5, 0x7e, 0x5e, 0xd8, 0xee, + /*3660:*/ 0x62, 0xc2, 0x71, 0xf7, 0x4a, 0x05, 0x84, 0x90, 0x15, 0x0a, 0x4a, 0x25, 0x32, 0x3c, 0x1c, 0xfe, + /*3670:*/ 0x14, 0xe2, 0x19, 0x3b, 0x97, 0xe4, 0x38, 0x8b, 0x7d, 0x30, 0x4b, 0x00, 0x62, 0x01, 0x68, 0x0f, + /*3680:*/ 0x01, 0xe3, 0xbb, 0x7d, 0x1a, 0x74, 0x0d, 0x09, 0x8e, 0x7a, 0xfe, 0x00, 0xc3, 0xb8, 0x23, 0xe7, + /*3690:*/ 0x98, 0xf5, 0xd7, 0x2b, 0x32, 0x2a, 0x4a, 0xbf, 0xe2, 0x21, 0x5f, 0xd8, 0x7a, 0x7c, 0x65, 0x0a, + /*36a0:*/ 0xba, 0x46, 0xfb, 0x66, 0x27, 0xdb, 0xd2, 0xa6, 0x52, 0x49, 0x7a, 0xb2, 0xee, 0x58, 0xe0, 0xc2, + /*36b0:*/ 0x90, 0x76, 0x90, 0x4a, 0x6f, 0xa1, 0x04, 0x44, 0xba, 0x9e, 0x40, 0x33, 0x16, 0x27, 0xa3, 0x0e, + /*36c0:*/ 0x6b, 0xed, 0x26, 0x0a, 0xaa, 0xc2, 0x09, 0x6a, 0xd6, 0x7c, 0x86, 0x9d, 0x3c, 0x57, 0x66, 0x01, + /*36d0:*/ 0xf0, 0x59, 0xd1, 0x2a, 0xf4, 0x5e, 0xa8, 0x4f, 0xff, 0x1a, 0xb2, 0xc6, 0xc6, 0xaa, 0x1e, 0x0d, + /*36e0:*/ 0x8d, 0x32, 0x05, 0x6d, 0x97, 0x25, 0xea, 0x32, 0x14, 0x4b, 0x6b, 0x20, 0x2a, 0x8c, 0x2b, 0xc1, + /*36f0:*/ 0x58, 0xcb, 0xa6, 0x87, 0x50, 0x96, 0xdb, 0x48, 0x3b, 0xcf, 0x6a, 0x41, 0x30, 0x72, 0x2d, 0x00, + /*3700:*/ 0x54, 0x6c, 0x03, 0x86, 0x88, 0x1a, 0x67, 0x8f, 0xa1, 0x4c, 0xdc, 0xf5, 0x7c, 0x16, 0xcf, 0x6f, + /*3710:*/ 0xa1, 0x5c, 0x59, 0x83, 0xb2, 0xca, 0xc3, 0xa4, 0x86, 0xa3, 0x0b, 0xab, 0x45, 0xeb, 0xf0, 0x21, + /*3720:*/ 0x8d, 0x06, 0x7f, 0x44, 0xa2, 0x4f, 0xeb, 0x63, 0x6f, 0x41, 0x11, 0x45, 0x7d, 0x00, 0xe9, 0x80, + /*3730:*/ 0x98, 0x25, 0xe3, 0x9c, 0x5f, 0x21, 0x9e, 0x3c, 0xfa, 0x8f, 0x0c, 0x35, 0x29, 0xce, 0x6e, 0xd6, + /*3740:*/ 0x48, 0x2c, 0x30, 0x90, 0xce, 0x35, 0x9d, 0x23, 0x10, 0x7d, 0x21, 0x0e, 0xc2, 0x93, 0x93, 0x8c, + /*3750:*/ 0xc5, 0xfc, 0xc6, 0x33, 0x05, 0x56, 0xa3, 0x53, 0x28, 0xd5, 0x3f, 0xc2, 0x80, 0x22, 0x9d, 0x5f, + /*3760:*/ 0xaa, 0x97, 0x06, 0x0b, 0xa1, 0xa7, 0x7b, 0x12, 0x7f, 0xcc, 0xca, 0xbc, 0x3e, 0x72, 0xd2, 0x17, + /*3770:*/ 0xb0, 0xd0, 0xe2, 0x0e, 0x36, 0xe4, 0xeb, 0xd5, 0x25, 0xc7, 0x94, 0xc4, 0x36, 0xa5, 0x2f, 0xee, + /*3780:*/ 0x03, 0xe3, 0x99, 0x3b, 0x9a, 0x57, 0x81, 0x71, 0xc6, 0xdc, 0x18, 0xea, 0x88, 0x10, 0x59, 0xfd, + /*3790:*/ 0x9d, 0x31, 0x71, 0x79, 0x55, 0x5d, 0x65, 0xf1, 0x20, 0x81, 0x9e, 0x0e, 0x42, 0x91, 0x2a, 0xa7, + /*37a0:*/ 0x0a, 0x79, 0xa8, 0x33, 0xd5, 0x00, 0x1d, 0x55, 0xb2, 0x47, 0xc6, 0xda, 0x47, 0x1e, 0x55, 0x7a, + /*37b0:*/ 0xb5, 0x16, 0xe9, 0x16, 0x75, 0x1c, 0x1a, 0x6e, 0x57, 0x30, 0xf4, 0xe1, 0xf0, 0x92, 0x2d, 0x28, + /*37c0:*/ 0xfa, 0x30, 0xc5, 0xc2, 0x6e, 0x6b, 0x0b, 0x98, 0x64, 0xd7, 0x3f, 0x6e, 0x73, 0x20, 0xb1, 0xda, + /*37d0:*/ 0x9a, 0xc4, 0x04, 0xe9, 0xc8, 0x8c, 0x09, 0xb3, 0x0f, 0x06, 0xa8, 0x07, 0x11, 0xc2, 0x15, 0x27, + /*37e0:*/ 0x08, 0xeb, 0x42, 0x29, 0xfb, 0x7c, 0xb2, 0xd5, 0x2c, 0x25, 0x85, 0x6b, 0x07, 0x51, 0xdc, 0x0a, + /*37f0:*/ 0x6b, 0xd4, 0xdb, 0x1d, 0xf7, 0x21, 0x59, 0xa0, 0xb5, 0xd9, 0xdf, 0x62, 0x34, 0xd0, 0xce, 0xad, + /*3800:*/ 0xfc, 0xad, 0x16, 0xcc, 0x01, 0x9d, 0x55, 0x5e, 0x84, 0xdd, 0x5f, 0xad, 0x3a, 0x36, 0x81, 0x5c, + /*3810:*/ 0xaf, 0x48, 0xce, 0x4d, 0xb7, 0x39, 0x02, 0x47, 0x20, 0x55, 0xd6, 0xbd, 0x4e, 0xf8, 0xe8, 0x78, + /*3820:*/ 0x74, 0xb3, 0x8e, 0x76, 0xbf, 0x71, 0x1e, 0x46, 0x5b, 0x33, 0x74, 0x23, 0xe1, 0x8b, 0xee, 0x89, + /*3830:*/ 0x38, 0xdb, 0xde, 0xb7, 0xae, 0x06, 0x3c, 0x51, 0x1b, 0xaf, 0xf6, 0x32, 0x61, 0x5b, 0xe2, 0xf6, + /*3840:*/ 0x7e, 0x0e, 0x78, 0xe8, 0xcf, 0x1a, 0x4a, 0x39, 0xf8, 0xda, 0x4f, 0x1b, 0xb5, 0xe4, 0x25, 0x3e, + /*3850:*/ 0x41, 0xef, 0x28, 0xcb, 0x17, 0x2f, 0xa4, 0x55, 0xd6, 0xf9, 0x88, 0x48, 0x26, 0x66, 0x56, 0xfe, + /*3860:*/ 0x30, 0x4d, 0x7d, 0x6b, 0xf8, 0x61, 0x80, 0x0f, 0x3d, 0x36, 0xb3, 0x7d, 0x73, 0x40, 0x17, 0x92, + /*3870:*/ 0x51, 0x58, 0x05, 0x49, 0x4b, 0x83, 0x13, 0x2a, 0x24, 0xd5, 0x92, 0xac, 0x40, 0x67, 0xe3, 0xa8, + /*3880:*/ 0xe9, 0xa6, 0x85, 0x58, 0xd7, 0xf4, 0xfc, 0x1d, 0xb5, 0x68, 0x19, 0xa7, 0xf8, 0xd8, 0xa5, 0x75, + /*3890:*/ 0xe0, 0x6d, 0xc6, 0x5a, 0xa6, 0xa3, 0x1c, 0x16, 0xd3, 0xf3, 0x61, 0xbb, 0x3c, 0x61, 0xb1, 0x3d, + /*38a0:*/ 0x58, 0xb9, 0x3f, 0x8a, 0xb2, 0x61, 0x6d, 0x78, 0x92, 0x20, 0x6e, 0xff, 0x69, 0x5e, 0x3e, 0xe2, + /*38b0:*/ 0x16, 0xb2, 0xc4, 0x44, 0x8d, 0xb9, 0x86, 0xa5, 0xcf, 0xc7, 0x97, 0xc1, 0x10, 0xed, 0xe7, 0x76, + /*38c0:*/ 0xe3, 0xa6, 0x51, 0x8f, 0x01, 0xb5, 0xd0, 0x34, 0xe2, 0xab, 0x7d, 0x45, 0xb6, 0x1f, 0x7c, 0xde, + /*38d0:*/ 0x5a, 0xa7, 0x59, 0x9e, 0xd2, 0x4b, 0x6d, 0xc8, 0xf4, 0x29, 0xb4, 0x73, 0x20, 0x0a, 0xc5, 0x60, + /*38e0:*/ 0xd1, 0x6e, 0xad, 0x8f, 0xb7, 0x56, 0xd3, 0xaa, 0xf9, 0xff, 0x16, 0xcc, 0x7b, 0x87, 0x2c, 0x3a, + /*38f0:*/ 0xa1, 0x1c, 0x57, 0x24, 0x5f, 0xb5, 0xb0, 0x99, 0x9c, 0xdb, 0xef, 0xdc, 0x4f, 0x6c, 0xea, 0x39, + /*3900:*/ 0x6d, 0x3d, 0x75, 0x65, 0x90, 0x79, 0xb5, 0x4b, 0xa9, 0x86, 0x74, 0xc5, 0xe6, 0x60, 0x7c, 0x2e, + /*3910:*/ 0xa4, 0x64, 0x93, 0xc8, 0x24, 0x54, 0x9b, 0xbf, 0x08, 0x07, 0xd1, 0x94, 0x87, 0xea, 0x9d, 0x88, + /*3920:*/ 0x19, 0x52, 0x32, 0xa4, 0xb5, 0x09, 0xf1, 0xb8, 0xee, 0x33, 0xc9, 0xff, 0x17, 0x9e, 0xbc, 0xb9, + /*3930:*/ 0xb4, 0x53, 0x93, 0xf4, 0x76, 0xa2, 0xd0, 0x87, 0xce, 0x22, 0xea, 0xee, 0xe3, 0xeb, 0x88, 0x58, + /*3940:*/ 0xb5, 0xb2, 0xd8, 0xed, 0x4c, 0x01, 0x2a, 0x8c, 0x25, 0x6f, 0xbf, 0xb1, 0xe5, 0x23, 0xf1, 0x7a, + /*3950:*/ 0x78, 0x2b, 0x32, 0x37, 0x99, 0xc3, 0xb0, 0x23, 0xa2, 0x9f, 0x72, 0xb6, 0x71, 0x88, 0x92, 0x32, + /*3960:*/ 0x52, 0x77, 0xd1, 0xb6, 0x0d, 0xbe, 0x6e, 0xd4, 0xdc, 0xf9, 0xb2, 0x0f, 0xcc, 0x8d, 0x8a, 0x96, + /*3970:*/ 0xce, 0x7f, 0x8f, 0xa4, 0x0e, 0x8f, 0x5f, 0x4c, 0x35, 0x54, 0xcb, 0xe2, 0xfa, 0xad, 0x5d, 0xd5, + /*3980:*/ 0x5d, 0x70, 0xf2, 0x82, 0x78, 0x27, 0xb9, 0xf9, 0x02, 0x15, 0x53, 0x00, 0xae, 0x29, 0x85, 0xf4, + /*3990:*/ 0xba, 0xc6, 0x0e, 0x6c, 0xb6, 0xe9, 0xef, 0xe1, 0x88, 0x42, 0xc5, 0x1a, 0x23, 0x5f, 0x19, 0xaf, + /*39a0:*/ 0x15, 0x9e, 0x26, 0x48, 0x42, 0x91, 0xc5, 0xc0, 0xfe, 0xfb, 0x72, 0x0c, 0x98, 0x98, 0xfa, 0xed, + /*39b0:*/ 0x94, 0x12, 0x1f, 0xc5, 0x14, 0x00, 0x55, 0xa5, 0x10, 0xc6, 0xf6, 0x3e, 0x64, 0x8c, 0xa7, 0x4e, + /*39c0:*/ 0x11, 0x84, 0x16, 0xeb, 0x48, 0x90, 0x49, 0xc2, 0xbf, 0x3c, 0xab, 0x54, 0xe4, 0x28, 0x59, 0x43, + /*39d0:*/ 0x77, 0xad, 0x1a, 0x14, 0xd8, 0xc3, 0x3e, 0x88, 0x3f, 0x7f, 0x38, 0xbf, 0xe2, 0x65, 0x89, 0x6d, + /*39e0:*/ 0x9e, 0x4e, 0x91, 0x5f, 0x6a, 0x70, 0x48, 0x17, 0xa0, 0x87, 0x68, 0x0d, 0x4b, 0x7c, 0x56, 0x1f, + /*39f0:*/ 0x57, 0xb0, 0x4d, 0x54, 0x78, 0x3e, 0x2b, 0xdb, 0x12, 0xed, 0x1d, 0x69, 0x7a, 0x48, 0x03, 0x46, + /*3a00:*/ 0x3c, 0xa8, 0x45, 0xff, 0xc7, 0x23, 0x17, 0x2d, 0xdd, 0x6b, 0xad, 0x4a, 0xff, 0x9d, 0x8d, 0xa2, + /*3a10:*/ 0x9e, 0x3d, 0x5b, 0xe6, 0x7a, 0x0f, 0x31, 0x6e, 0x0a, 0xca, 0xc4, 0x48, 0x91, 0xe5, 0xd2, 0x38, + /*3a20:*/ 0xfe, 0x87, 0x1b, 0x4a, 0xa1, 0xca, 0xd6, 0xad, 0x4d, 0x90, 0xff, 0x65, 0x93, 0xc1, 0x22, 0xdd, + /*3a30:*/ 0x46, 0x16, 0x89, 0x08, 0x6e, 0x6d, 0x35, 0x5e, 0x13, 0x95, 0x6d, 0x0e, 0xce, 0xd1, 0x3c, 0x98, + /*3a40:*/ 0x15, 0x0a, 0xee, 0xaa, 0xbb, 0x7e, 0xba, 0x21, 0x1c, 0x1d, 0x52, 0x6d, 0xaa, 0x86, 0xcd, 0x42, + /*3a50:*/ 0x52, 0xf4, 0xdf, 0xca, 0x57, 0xf8, 0x26, 0x7b, 0xc7, 0x31, 0x37, 0xec, 0xbb, 0x5b, 0x61, 0xe5, + /*3a60:*/ 0xda, 0xa9, 0x93, 0xd6, 0xe1, 0xd7, 0xcf, 0xdc, 0xeb, 0x3a, 0xcb, 0x19, 0x73, 0x40, 0xf3, 0xde, + /*3a70:*/ 0x5d, 0x4a, 0xaf, 0x46, 0x62, 0xbb, 0xf7, 0x4b, 0x4c, 0xe1, 0x50, 0xa7, 0xc5, 0x14, 0x71, 0xbf, + /*3a80:*/ 0x3a, 0x03, 0x8a, 0xd2, 0xaa, 0x9a, 0x44, 0x91, 0xaf, 0xd1, 0x44, 0x24, 0xa4, 0x0e, 0x47, 0x32, + /*3a90:*/ 0x51, 0x62, 0x14, 0x10, 0x8d, 0x21, 0x2d, 0x7e, 0x62, 0x12, 0x5d, 0xc1, 0x46, 0xcc, 0x9d, 0xd0, + /*3aa0:*/ 0xa0, 0xa2, 0x35, 0x33, 0xcb, 0x4c, 0xc0, 0x5a, 0x20, 0x2e, 0xc8, 0x49, 0x03, 0x12, 0x00, 0xc9, + /*3ab0:*/ 0x5c, 0xc8, 0xc3, 0xff, 0xfa, 0x1f, 0x85, 0x18, 0x78, 0xe4, 0x7f, 0x95, 0x07, 0xce, 0xb3, 0xf3, + /*3ac0:*/ 0xb1, 0x75, 0x76, 0xf3, 0xd8, 0x82, 0xc8, 0xc9, 0x5e, 0xb5, 0x30, 0xa6, 0xbf, 0xcb, 0x0a, 0x21, + /*3ad0:*/ 0x1e, 0x98, 0x06, 0x8e, 0x4c, 0x7a, 0xb4, 0x72, 0x36, 0xf5, 0xca, 0x07, 0xce, 0x90, 0xf2, 0x1f, + /*3ae0:*/ 0xcd, 0x68, 0xac, 0x7f, 0x12, 0x8a, 0x19, 0x2c, 0x60, 0x3a, 0x9a, 0x65, 0x79, 0x48, 0x01, 0x89, + /*3af0:*/ 0x9e, 0x61, 0xff, 0xe4, 0x36, 0x4f, 0x0d, 0x9b, 0x69, 0xaa, 0x9f, 0x01, 0x87, 0x53, 0x13, 0x0c, + /*3b00:*/ 0x93, 0x20, 0x21, 0x87, 0x41, 0x48, 0xfc, 0x82, 0xe9, 0x12, 0x4c, 0x17, 0xd0, 0xee, 0xdc, 0x68, + /*3b10:*/ 0xf9, 0xdd, 0x28, 0x13, 0xa4, 0x28, 0x12, 0x97, 0x38, 0xe9, 0xb9, 0x7c, 0x0e, 0xfe, 0xc3, 0xd3, + /*3b20:*/ 0x86, 0x7d, 0xb3, 0x82, 0x66, 0xb8, 0x98, 0xeb, 0xdd, 0x24, 0x82, 0xa6, 0x26, 0x82, 0xd0, 0xf0, + /*3b30:*/ 0x44, 0xd1, 0x1e, 0x49, 0xee, 0xf5, 0x48, 0x75, 0x87, 0xca, 0xe2, 0xdf, 0x81, 0x9a, 0x5b, 0x83, + /*3b40:*/ 0xfd, 0xa1, 0xef, 0x87, 0x83, 0x95, 0xe5, 0x8c, 0x74, 0x35, 0x38, 0xd9, 0x7c, 0x56, 0x5f, 0xf0, + /*3b50:*/ 0xd4, 0x60, 0xb8, 0x97, 0xe2, 0x96, 0x06, 0xd3, 0xc9, 0xc9, 0x88, 0x31, 0x02, 0x2a, 0xb2, 0x28, + /*3b60:*/ 0xb2, 0xcc, 0x91, 0xcb, 0x01, 0xec, 0xb5, 0x9d, 0x09, 0x6e, 0xd0, 0xde, 0xf0, 0xce, 0x72, 0x93, + /*3b70:*/ 0x6c, 0xcb, 0xaa, 0x2b, 0x29, 0x84, 0xbe, 0xab, 0xff, 0x42, 0x2e, 0x4f, 0xc1, 0x65, 0x22, 0x91, + /*3b80:*/ 0xac, 0xb3, 0xfb, 0x53, 0x98, 0x56, 0x8f, 0x16, 0xbe, 0x1d, 0x7f, 0x29, 0x17, 0xdc, 0x9d, 0xf8, + /*3b90:*/ 0x59, 0x8b, 0xa9, 0x76, 0x01, 0xa8, 0x24, 0xa7, 0x00, 0xdd, 0xa3, 0xe5, 0x6e, 0x27, 0x66, 0x2f, + /*3ba0:*/ 0xe7, 0x1d, 0x0d, 0x2a, 0x75, 0x80, 0x10, 0x38, 0xf6, 0x3d, 0x45, 0x18, 0xb0, 0x31, 0xcb, 0xe0, + /*3bb0:*/ 0x8e, 0x73, 0x14, 0xbc, 0x36, 0x16, 0xf3, 0xa8, 0xd5, 0x3e, 0xf6, 0xdc, 0xa7, 0x33, 0xcb, 0x49, + /*3bc0:*/ 0xb6, 0x45, 0x00, 0xb6, 0xcc, 0x9d, 0x40, 0xbc, 0x1d, 0x12, 0xbb, 0xe4, 0xd0, 0x3f, 0xa6, 0x28, + /*3bd0:*/ 0x5d, 0x0f, 0xa2, 0x90, 0xbe, 0x1f, 0x90, 0x6a, 0xb8, 0x22, 0x89, 0xf9, 0x3a, 0xdd, 0x7a, 0xe8, + /*3be0:*/ 0x63, 0x1f, 0x1f, 0x15, 0xa1, 0xbd, 0x72, 0x6d, 0x83, 0x02, 0x5e, 0x95, 0x5c, 0x33, 0x20, 0xb4, + /*3bf0:*/ 0xe5, 0x39, 0x87, 0xd9, 0x57, 0xd7, 0xb6, 0x86, 0x21, 0xff, 0xfa, 0x67, 0x7e, 0x94, 0xac, 0xda, + /*3c00:*/ 0xf0, 0xe0, 0x4e, 0xc4, 0x88, 0x84, 0x01, 0xcc, 0xfa, 0x37, 0x27, 0xbe, 0x63, 0x8f, 0x41, 0x94, + /*3c10:*/ 0x75, 0x06, 0x8c, 0x10, 0xd5, 0xf7, 0xe1, 0x2c, 0x92, 0xe1, 0x4f, 0xda, 0xdf, 0xac, 0x64, 0xe8, + /*3c20:*/ 0x8e, 0xbb, 0x8b, 0x9a, 0x70, 0x57, 0x50, 0xb3, 0x63, 0x77, 0xcf, 0xa6, 0xb0, 0x91, 0x13, 0xa4, + /*3c30:*/ 0x29, 0xf1, 0x27, 0x1d, 0x4e, 0x37, 0x6b, 0x81, 0xd3, 0x0d, 0x3c, 0xb6, 0x91, 0x42, 0xf4, 0x70, + /*3c40:*/ 0x64, 0x86, 0x2f, 0xee, 0xec, 0xc2, 0x97, 0xb7, 0xb6, 0xf2, 0x86, 0x8a, 0x7a, 0x2d, 0x6c, 0x06, + /*3c50:*/ 0x5d, 0x24, 0xd9, 0xf9, 0xc8, 0xd2, 0xd6, 0xb5, 0xb8, 0xd7, 0x0a, 0x1e, 0x31, 0x4f, 0x04, 0x9c, + /*3c60:*/ 0x4b, 0xe0, 0x21, 0xdf, 0xb3, 0x8d, 0xdf, 0xc7, 0x9d, 0x57, 0x62, 0xa4, 0xff, 0x88, 0x07, 0x0e, + /*3c70:*/ 0xad, 0x7f, 0x39, 0xe8, 0x8a, 0x04, 0x64, 0xde, 0x94, 0xc3, 0xa3, 0xd0, 0xc8, 0x40, 0x27, 0x63, + /*3c80:*/ 0x76, 0x4b, 0xa0, 0xe1, 0xdc, 0xf1, 0xec, 0x93, 0xd3, 0xa2, 0x69, 0x8a, 0xa7, 0xe2, 0x33, 0x97, + /*3c90:*/ 0x58, 0xff, 0x7e, 0x66, 0x24, 0x2c, 0x61, 0x7f, 0x3a, 0xdf, 0x92, 0x31, 0x4b, 0x66, 0x52, 0x7e, + /*3ca0:*/ 0xa3, 0x88, 0x7e, 0x57, 0xe6, 0x51, 0xf6, 0x7f, 0x98, 0x93, 0x6b, 0xd7, 0x7d, 0x7d, 0xee, 0x72, + /*3cb0:*/ 0xc6, 0x15, 0xe1, 0x30, 0x2a, 0xeb, 0x48, 0x8f, 0x8d, 0xed, 0x62, 0x0c, 0x53, 0x93, 0x62, 0x1e, + /*3cc0:*/ 0x61, 0x1a, 0x2e, 0x34, 0xad, 0xd2, 0x47, 0x0d, 0x08, 0x8e, 0xae, 0x35, 0x77, 0x25, 0x67, 0x00, + /*3cd0:*/ 0x9a, 0xf0, 0x51, 0x5e, 0x16, 0x94, 0x31, 0xd7, 0x24, 0x17, 0xa5, 0xe5, 0x2e, 0x92, 0x36, 0xcb, + /*3ce0:*/ 0x36, 0xf8, 0x16, 0xb7, 0x7b, 0xff, 0x2d, 0x25, 0x02, 0x00, 0xb3, 0x75, 0x78, 0xd5, 0xb2, 0x69, + /*3cf0:*/ 0xae, 0x95, 0xd8, 0xc4, 0x4e, 0xa1, 0x6f, 0x93, 0x20, 0xae, 0x74, 0x56, 0x7a, 0xed, 0x24, 0xbb, + /*3d00:*/ 0xc7, 0x8d, 0x0a, 0xbe, 0x9f, 0x5c, 0xd4, 0xa2, 0x20, 0xe9, 0x5e, 0x01, 0x6d, 0x16, 0xe1, 0x59, + /*3d10:*/ 0x05, 0x65, 0xa7, 0x5b, 0xdc, 0x3f, 0x15, 0xf0, 0x43, 0x97, 0x0f, 0x72, 0x60, 0x47, 0xf8, 0x1c, + /*3d20:*/ 0xff, 0xdc, 0xcf, 0xb1, 0xc3, 0x2a, 0x44, 0x9d, 0x37, 0xec, 0x8b, 0x0d, 0x7d, 0x37, 0xa5, 0x2f, + /*3d30:*/ 0x3c, 0x74, 0xca, 0x90, 0x2c, 0x0c, 0x8f, 0x88, 0x01, 0x48, 0x81, 0x0b, 0x8b, 0xf8, 0xc7, 0xb8, + /*3d40:*/ 0x96, 0x45, 0x06, 0x4e, 0x60, 0x04, 0xd8, 0xae, 0x30, 0xcb, 0x6b, 0xf9, 0xdd, 0x0a, 0x31, 0x8d, + /*3d50:*/ 0xde, 0x60, 0x42, 0xf3, 0xf1, 0x87, 0x31, 0x85, 0x25, 0x62, 0xcc, 0x92, 0x54, 0x49, 0x96, 0xd5, + /*3d60:*/ 0x72, 0xc7, 0xb7, 0xf1, 0x01, 0x0b, 0x30, 0xe5, 0x8b, 0xba, 0x49, 0x05, 0xe0, 0xa2, 0x54, 0xee, + /*3d70:*/ 0x45, 0xae, 0xd3, 0x75, 0x35, 0x61, 0x9a, 0x10, 0xee, 0x1f, 0x2a, 0x83, 0xfe, 0x81, 0x0d, 0xc4, + /*3d80:*/ 0xc2, 0x35, 0xc9, 0xf0, 0xed, 0x01, 0xf3, 0x5f, 0x9b, 0x66, 0x41, 0xc1, 0x10, 0x04, 0xc3, 0x57, + /*3d90:*/ 0x04, 0x74, 0x31, 0x72, 0xd9, 0x15, 0x9d, 0xe6, 0xc9, 0x2e, 0xb9, 0xd0, 0x2c, 0xe5, 0x27, 0x85, + /*3da0:*/ 0xa8, 0xe8, 0x8b, 0x44, 0x20, 0x99, 0x1e, 0x12, 0x33, 0xff, 0x4c, 0xa1, 0x59, 0x2c, 0x44, 0xd2, + /*3db0:*/ 0x51, 0x94, 0xa1, 0xc1, 0x65, 0xe8, 0x77, 0xad, 0xf7, 0x2c, 0x3c, 0x1b, 0xeb, 0x85, 0x31, 0x7e, + /*3dc0:*/ 0x7a, 0x3d, 0xe3, 0x49, 0xc3, 0xe7, 0x8f, 0xe1, 0x39, 0x88, 0x33, 0xd1, 0x8d, 0xf5, 0xec, 0x2c, + /*3dd0:*/ 0x43, 0x6a, 0x63, 0x8a, 0xad, 0x7b, 0x61, 0x8c, 0x55, 0x10, 0x89, 0x2e, 0x50, 0x0c, 0x72, 0x49, + /*3de0:*/ 0xad, 0xaf, 0xc4, 0x3f, 0x34, 0xdb, 0xc9, 0x23, 0x90, 0x18, 0xd6, 0x8c, 0xe9, 0xab, 0x5b, 0x01, + /*3df0:*/ 0x9c, 0x5d, 0x05, 0x65, 0x5c, 0x14, 0x27, 0x28, 0xa7, 0x42, 0x93, 0xbe, 0xde, 0xd2, 0x3a, 0x1f, + /*3e00:*/ 0x3f, 0x32, 0xaf, 0x89, 0x34, 0xfa, 0x7a, 0x0d, 0xdd, 0x66, 0xdc, 0x16, 0x60, 0x69, 0x24, 0x04, + /*3e10:*/ 0x1e, 0x9e, 0x55, 0x09, 0x3c, 0x98, 0xb3, 0x95, 0xcc, 0xa4, 0x51, 0xb4, 0x17, 0x80, 0x3a, 0x74, + /*3e20:*/ 0x2c, 0x2f, 0x54, 0x28, 0x83, 0xf9, 0xc4, 0x8a, 0x6b, 0x42, 0x57, 0x6c, 0x14, 0xba, 0xca, 0x51, + /*3e30:*/ 0x27, 0xeb, 0x90, 0x98, 0x59, 0x84, 0x0c, 0xea, 0x90, 0x6e, 0xf3, 0xb2, 0xc3, 0x50, 0xd2, 0x4e, + /*3e40:*/ 0xa0, 0xb3, 0xc0, 0x09, 0x41, 0x59, 0xb5, 0x18, 0x0e, 0x14, 0x27, 0xb1, 0x95, 0x21, 0x0c, 0xe7, + /*3e50:*/ 0x24, 0x79, 0x62, 0x9c, 0x90, 0xe5, 0x44, 0x98, 0x7b, 0x5f, 0xba, 0x46, 0x5f, 0x61, 0xbb, 0x25, + /*3e60:*/ 0xd3, 0x3b, 0x63, 0xdf, 0xc4, 0x76, 0xce, 0x55, 0x4d, 0xaf, 0x69, 0xfd, 0xab, 0xaa, 0x2c, 0x52, + /*3e70:*/ 0xaa, 0x20, 0x38, 0x7e, 0x29, 0x4a, 0x7d, 0x09, 0xee, 0xa8, 0x77, 0xe0, 0xed, 0x54, 0x64, 0x50, + /*3e80:*/ 0x19, 0x1f, 0xc7, 0x34, 0x79, 0xbf, 0x06, 0xf9, 0xac, 0x61, 0x6a, 0xd7, 0x8e, 0xb0, 0x65, 0x4d, + /*3e90:*/ 0xa0, 0xc1, 0x9a, 0xbb, 0x44, 0xbd, 0x30, 0xa0, 0xfb, 0xf5, 0x35, 0x91, 0xa7, 0x09, 0xbb, 0x48, + /*3ea0:*/ 0x4f, 0x94, 0x33, 0xe2, 0x3d, 0x79, 0xc0, 0x0b, 0x27, 0x42, 0x9f, 0x7c, 0x4c, 0x1a, 0xe5, 0x17, + /*3eb0:*/ 0xb2, 0xdf, 0xa3, 0x87, 0x4b, 0x76, 0xd3, 0x78, 0x24, 0x6b, 0xd4, 0x54, 0x7e, 0x73, 0x37, 0x2b, + /*3ec0:*/ 0xe1, 0xbe, 0xba, 0xbd, 0x6b, 0xb4, 0x5c, 0x7b, 0xba, 0xbc, 0x98, 0x65, 0xcb, 0xdf, 0xb9, 0x99, + /*3ed0:*/ 0x25, 0xeb, 0xe5, 0x93, 0xff, 0x8f, 0x82, 0x6c, 0x5f, 0x6b, 0xde, 0x47, 0xb7, 0x16, 0x92, 0x81, + /*3ee0:*/ 0x7c, 0x77, 0xe3, 0x0b, 0x6f, 0xf2, 0x9a, 0xa0, 0x98, 0xf4, 0xf5, 0xcd, 0x6e, 0xf4, 0x64, 0x65, + /*3ef0:*/ 0xc2, 0x87, 0x85, 0x54, 0x32, 0x11, 0x37, 0xde, 0xfb, 0x7e, 0x51, 0x64, 0x4b, 0x7f, 0x57, 0x34, + /*3f00:*/ 0x1c, 0xa3, 0x37, 0x11, 0x1e, 0x66, 0x43, 0xf5, 0x6d, 0x4d, 0x08, 0x94, 0x7c, 0x79, 0xb7, 0xfe, + /*3f10:*/ 0x20, 0x78, 0x2e, 0x19, 0x49, 0xf6, 0x3b, 0x86, 0xe4, 0xa1, 0xc5, 0x65, 0xef, 0xa9, 0x97, 0x55, + /*3f20:*/ 0x37, 0xed, 0x23, 0xd2, 0x5a, 0x14, 0x5a, 0xde, 0x6c, 0xda, 0x50, 0xfb, 0xcb, 0x56, 0x56, 0x8e, + /*3f30:*/ 0xf1, 0xd1, 0x18, 0x0d, 0x17, 0x7f, 0x3a, 0xb3, 0x07, 0x25, 0x1a, 0x76, 0x1f, 0xd8, 0x67, 0x97, + /*3f40:*/ 0x43, 0xfa, 0x02, 0xa8, 0x7c, 0x6d, 0x56, 0xb1, 0xd4, 0xba, 0x1d, 0x06, 0x60, 0x86, 0x66, 0xd6, + /*3f50:*/ 0xd5, 0x1b, 0x5e, 0x64, 0xf5, 0x02, 0x44, 0xa4, 0x8d, 0x21, 0x27, 0xd2, 0x16, 0xe4, 0xd9, 0xad, + /*3f60:*/ 0xac, 0x08, 0x12, 0x81, 0xd6, 0xe4, 0x4e, 0x68, 0xe4, 0xaf, 0x62, 0x8c, 0x7e, 0xef, 0x42, 0xa9, + /*3f70:*/ 0xff, 0x3f, 0x3b, 0x6c, 0x9f, 0xec, 0xa5, 0x9c, 0xf5, 0xf8, 0x4f, 0xa9, 0x37, 0x79, 0x86, 0x92, + /*3f80:*/ 0x2b, 0x6d, 0x75, 0xbc, 0x50, 0x5e, 0x78, 0x1c, 0xbe, 0x03, 0xcf, 0x7d, 0x37, 0x21, 0xcf, 0x43, + /*3f90:*/ 0x4e, 0x2b, 0x68, 0x7b, 0x77, 0x44, 0x39, 0x85, 0x1b, 0x1c, 0x4a, 0x1f, 0x75, 0x68, 0xa6, 0x9c, + /*3fa0:*/ 0x8c, 0x0f, 0x35, 0x78, 0x20, 0x1a, 0xe5, 0xa6, 0x2b, 0xbf, 0x4a, 0x08, 0x04, 0xe5, 0x9d, 0x08, + /*3fb0:*/ 0x4f, 0x03, 0x11, 0xc9, 0x08, 0x1a, 0xde, 0xd1, 0x9d, 0x7c, 0x74, 0x49, 0x5d, 0x09, 0xff, 0x38, + /*3fc0:*/ 0x29, 0x76, 0xa6, 0xf8, 0x9a, 0xda, 0xda, 0x9a, 0xb6, 0xc9, 0x39, 0x59, 0x62, 0xe1, 0x4b, 0x7f, + /*3fd0:*/ 0x11, 0xac, 0xa6, 0x21, 0x85, 0x0b, 0x2a, 0x0e, 0xa6, 0x89, 0x61, 0x00, 0xdc, 0xb0, 0x5a, 0x9b, + /*3fe0:*/ 0x1b, 0xbd, 0x44, 0x74, 0x01, 0xbc, 0x31, 0x7f, 0xbb, 0x2f, 0x4c, 0x83, 0x8d, 0xe2, 0x99, 0xea, + /*3ff0:*/ 0xad, 0xbb, 0xb4, 0xe5, 0xb6, 0x4d, 0xa8, 0xf6, 0x99, 0xe2, 0x85, 0x27, 0x08, 0x70, 0x84, 0x05, + /*4000:*/ 0xed, 0x8d, 0x0e, 0x89, 0x9a, 0x03, 0xc3, 0xe6, 0xa6, 0xe1, 0x8d, 0xc3, 0x2e, 0xdd, 0xc8, 0x53, + /*4010:*/ 0xb8, 0xd7, 0x88, 0xf6, 0x88, 0xb2, 0xb4, 0x38, 0xa6, 0xc4, 0xc1, 0x2c, 0x71, 0x41, 0x8f, 0xc3, + /*4020:*/ 0x51, 0x77, 0x20, 0x0c, 0xa6, 0x4c, 0xac, 0xcd, 0xf5, 0xae, 0x4c, 0x37, 0x57, 0xf5, 0x1c, 0x09, + /*4030:*/ 0xe3, 0xcf, 0x5c, 0x69, 0xed, 0x92, 0x5e, 0xce, 0xf1, 0x83, 0x41, 0xf7, 0xa1, 0x05, 0x3f, 0x56, + /*4040:*/ 0x5e, 0x76, 0x06, 0x63, 0xb7, 0x73, 0x2a, 0xe4, 0x83, 0x10, 0xe6, 0x30, 0x7e, 0x9a, 0xd6, 0xc5, + /*4050:*/ 0x8d, 0x7f, 0xf8, 0xeb, 0xf6, 0x05, 0x32, 0x24, 0xf1, 0x70, 0xa9, 0x85, 0x69, 0x5c, 0x37, 0x02, + /*4060:*/ 0x4a, 0x7e, 0x23, 0xee, 0x91, 0xa2, 0xdd, 0xaa, 0x51, 0x6b, 0x1b, 0x39, 0x76, 0x28, 0x9e, 0xbf, + /*4070:*/ 0xe5, 0xd9, 0xfe, 0x0b, 0x89, 0x63, 0xff, 0x47, 0x50, 0x8f, 0x66, 0x0e, 0x96, 0x0f, 0x3d, 0x8c, + /*4080:*/ 0xdd, 0x55, 0xfd, 0xae, 0x37, 0x18, 0x71, 0x0e, 0x08, 0x48, 0x65, 0x53, 0xb8, 0x1b, 0x9d, 0xc5, + /*4090:*/ 0x1f, 0x0f, 0x9e, 0x9a, 0xcf, 0xfb, 0x37, 0xf0, 0x6e, 0x5c, 0x8b, 0xec, 0x3b, 0x3a, 0xd3, 0xce, + /*40a0:*/ 0xc5, 0x94, 0x24, 0x88, 0x0b, 0x6a, 0x03, 0x4c, 0x52, 0xf7, 0xb2, 0x1d, 0x07, 0xae, 0x81, 0x3d, + /*40b0:*/ 0xf1, 0xfd, 0x8e, 0xcc, 0x3a, 0x47, 0x6e, 0xa9, 0x19, 0xf7, 0x16, 0x8e, 0x15, 0x93, 0x56, 0x20, + /*40c0:*/ 0x7e, 0x67, 0xd3, 0x17, 0xcb, 0xfa, 0x4b, 0xf1, 0x63, 0x02, 0x81, 0x14, 0x1e, 0xbd, 0x73, 0x95, + /*40d0:*/ 0xcc, 0xfd, 0x70, 0xa6, 0x30, 0x3e, 0x41, 0x64, 0x5a, 0x12, 0xc6, 0x50, 0x28, 0xf0, 0x83, 0x60, + /*40e0:*/ 0xd7, 0xb9, 0x72, 0x1d, 0x87, 0xab, 0x74, 0xf5, 0xb7, 0x30, 0xa1, 0xae, 0x89, 0x76, 0xfe, 0x92, + /*40f0:*/ 0x07, 0x34, 0x78, 0x8e, 0x8b, 0xb1, 0x44, 0x85, 0x37, 0xcf, 0xe8, 0x56, 0xe7, 0xaa, 0xa9, 0x70, + /*4100:*/ 0xe9, 0x79, 0x59, 0xa6, 0x3c, 0x9d, 0xad, 0xc5, 0x0f, 0x7d, 0x3c, 0x8e, 0xb9, 0xdc, 0xd4, 0xf7, + /*4110:*/ 0xe4, 0xcd, 0xa7, 0x27, 0xfd, 0x20, 0x33, 0x9d, 0x64, 0xcd, 0xcc, 0xaf, 0xb9, 0x43, 0xc6, 0x6b, + /*4120:*/ 0xcd, 0xaa, 0xf8, 0x8a, 0x97, 0x30, 0x95, 0xcc, 0xf2, 0x9f, 0x70, 0x25, 0x3f, 0x7b, 0x27, 0x0f, + /*4130:*/ 0xc2, 0x0f, 0xd7, 0x33, 0xde, 0x08, 0x90, 0xc2, 0x5d, 0xb5, 0xc0, 0x1a, 0x39, 0x86, 0xb3, 0x62, + /*4140:*/ 0xeb, 0x19, 0xee, 0x4c, 0x10, 0xe6, 0x75, 0x40, 0x7a, 0x9d, 0x8f, 0x80, 0x39, 0x75, 0x77, 0x37, + /*4150:*/ 0x27, 0x4e, 0x36, 0xa6, 0xc6, 0x7a, 0xb9, 0x0d, 0x7c, 0x5c, 0x7f, 0xbc, 0xe5, 0x9c, 0xe2, 0x13, + /*4160:*/ 0xfe, 0x3f, 0xc6, 0x30, 0xf8, 0xbb, 0xe6, 0x19, 0xcf, 0x2e, 0xfb, 0x6c, 0x10, 0x38, 0x61, 0x72, + /*4170:*/ 0xe3, 0x32, 0xfc, 0xcb, 0x72, 0x88, 0x6b, 0x62, 0x20, 0x32, 0x0b, 0xbc, 0xc3, 0xfd, 0x23, 0x9c, + /*4180:*/ 0xad, 0x96, 0xa7, 0xa4, 0x4e, 0x40, 0xfc, 0xac, 0x04, 0xbc, 0x8e, 0x17, 0x43, 0xba, 0x2b, 0xbf, + /*4190:*/ 0x0a, 0x5f, 0x2b, 0xaa, 0x74, 0x06, 0x1f, 0x75, 0x8e, 0xa4, 0x57, 0xdf, 0x1e, 0x4c, 0xfa, 0xb9, + /*41a0:*/ 0xb4, 0x33, 0x72, 0xd7, 0x88, 0x6b, 0x19, 0xb0, 0x36, 0x76, 0x07, 0xb2, 0x79, 0x77, 0x50, 0xc1, + /*41b0:*/ 0xb9, 0xa5, 0x28, 0x8d, 0xc8, 0x70, 0x3d, 0xdf, 0xe9, 0x96, 0x49, 0xf4, 0xbd, 0xed, 0x62, 0x3c, + /*41c0:*/ 0xe0, 0x63, 0x41, 0x84, 0x55, 0xef, 0x54, 0x2f, 0xb4, 0x94, 0x7d, 0x32, 0x56, 0x01, 0x04, 0x40, + /*41d0:*/ 0x73, 0x43, 0xdd, 0x84, 0xbe, 0xe6, 0x2f, 0xa1, 0xa7, 0xec, 0xed, 0x6f, 0x45, 0xd3, 0x74, 0x58, + /*41e0:*/ 0x5f, 0xae, 0x10, 0x4a, 0xe3, 0x7e, 0xc9, 0xca, 0xee, 0xe0, 0x05, 0xc5, 0x95, 0x34, 0xff, 0x5e, + /*41f0:*/ 0xda, 0x21, 0xf3, 0x49, 0x80, 0xf8, 0xd8, 0x33, 0x3a, 0x93, 0xab, 0xdd, 0x76, 0xdc, 0x77, 0x06, + /*4200:*/ 0x83, 0x9b, 0x67, 0x8a, 0xa0, 0x72, 0x2a, 0x32, 0x24, 0x00, 0x85, 0x1e, 0x27, 0x22, 0x91, 0x85, + /*4210:*/ 0xde, 0xb0, 0x9b, 0xc0, 0xa8, 0x03, 0x90, 0x9e, 0xe3, 0x18, 0x64, 0x91, 0x2c, 0xaa, 0x21, 0xbb, + /*4220:*/ 0xca, 0x34, 0x42, 0x9c, 0xcd, 0x73, 0x5e, 0xff, 0x7a, 0x9a, 0xc0, 0x1c, 0x6e, 0xb2, 0x45, 0xec, + /*4230:*/ 0x09, 0xe4, 0xed, 0x3f, 0xa2, 0xf2, 0x82, 0xa8, 0xa3, 0xc0, 0xd3, 0x4e, 0xbc, 0xe5, 0x11, 0x9b, + /*4240:*/ 0x5e, 0x3d, 0x0e, 0x1e, 0xcc, 0x85, 0x4c, 0x5d, 0x97, 0xa6, 0xa2, 0xe7, 0x90, 0xad, 0x0a, 0xf5, + /*4250:*/ 0x83, 0x65, 0xc6, 0xcc, 0x4f, 0x52, 0xe0, 0x38, 0xe9, 0x25, 0xa7, 0x83, 0x03, 0x4a, 0x0f, 0x72, + /*4260:*/ 0xe5, 0xc9, 0x36, 0x32, 0xb9, 0x7d, 0x58, 0xa2, 0x05, 0x0e, 0x30, 0x13, 0xd3, 0xfc, 0x30, 0x86, + /*4270:*/ 0xbd, 0xab, 0x67, 0xcf, 0x86, 0x4d, 0xa5, 0xfe, 0x6d, 0xb5, 0x91, 0x1e, 0xcf, 0x44, 0xc8, 0x40, + /*4280:*/ 0x2b, 0xaa, 0x96, 0x33, 0xb5, 0x8e, 0x32, 0x59, 0x0d, 0x0c, 0x6d, 0x91, 0x24, 0x7a, 0x49, 0x1a, + /*4290:*/ 0x8d, 0x8f, 0x14, 0xa6, 0x25, 0x35, 0xef, 0x8f, 0xb6, 0x53, 0xaf, 0xe2, 0xa5, 0xa4, 0x3d, 0x19, + /*42a0:*/ 0x9e, 0x61, 0x5c, 0x38, 0x60, 0xdc, 0x7a, 0x90, 0xda, 0xb0, 0xc7, 0x78, 0x2d, 0xc9, 0x8e, 0xc4, + /*42b0:*/ 0x2a, 0xe5, 0x9d, 0x10, 0x26, 0xef, 0x4f, 0x79, 0xf2, 0xf7, 0x89, 0x79, 0xdb, 0xc1, 0xf3, 0xc3, + /*42c0:*/ 0x38, 0x6a, 0xd3, 0x59, 0x31, 0x69, 0xfd, 0xd6, 0x9d, 0x26, 0x54, 0x44, 0x0e, 0x2b, 0xc5, 0x9a, + /*42d0:*/ 0x9f, 0x77, 0xb7, 0x73, 0x40, 0xc5, 0xa2, 0x46, 0x3b, 0xb9, 0xb6, 0xab, 0x58, 0x93, 0x88, 0x9c, + /*42e0:*/ 0xe5, 0xae, 0x1b, 0x90, 0xf8, 0xdf, 0xdf, 0xd6, 0x4d, 0x2e, 0x3b, 0xeb, 0x3a, 0x6f, 0xe3, 0x28, + /*42f0:*/ 0x73, 0x32, 0x71, 0xb3, 0x7c, 0xd8, 0x7a, 0xa2, 0xfc, 0x61, 0x56, 0x2c, 0x89, 0x63, 0x16, 0xbd, + /*4300:*/ 0xea, 0xd2, 0x49, 0x1b, 0x43, 0xcf, 0x2a, 0xce, 0xd2, 0x00, 0xe8, 0xef, 0x60, 0xf9, 0x9e, 0x41, + /*4310:*/ 0x23, 0xde, 0x64, 0xa1, 0x05, 0x64, 0x55, 0xdb, 0xb0, 0xac, 0x37, 0xd1, 0x41, 0xd4, 0xfa, 0xde, + /*4320:*/ 0x9c, 0x18, 0x46, 0x59, 0xac, 0x51, 0xc4, 0xd4, 0xb9, 0x4c, 0x35, 0xfa, 0xcd, 0xfd, 0x23, 0xde, + /*4330:*/ 0xa8, 0x5d, 0x7c, 0xdb, 0xa1, 0x1a, 0x99, 0x9d, 0x21, 0x12, 0x81, 0xa8, 0xd1, 0x20, 0xc2, 0xd4, + /*4340:*/ 0x6c, 0xe9, 0x8b, 0x16, 0x22, 0x55, 0x5b, 0x0e, 0x1d, 0xde, 0x36, 0x54, 0x96, 0x76, 0x51, 0x36, + /*4350:*/ 0x13, 0x4a, 0x9f, 0x0f, 0x42, 0x11, 0xb2, 0x8a, 0x69, 0xec, 0x5b, 0xbd, 0xbd, 0xe6, 0x90, 0x1d, + /*4360:*/ 0x6f, 0x36, 0x18, 0x6d, 0x71, 0x18, 0x6b, 0xa0, 0x08, 0x0c, 0x6a, 0xbd, 0xc9, 0xc9, 0x03, 0xbb, + /*4370:*/ 0x2b, 0x13, 0xc4, 0x81, 0xd4, 0x98, 0xaa, 0x33, 0xa7, 0x7c, 0x9d, 0x2a, 0xcf, 0xf4, 0xc8, 0x33, + /*4380:*/ 0xc8, 0x54, 0x80, 0x2e, 0x85, 0x05, 0xf3, 0x67, 0x34, 0x07, 0xe1, 0x5c, 0x49, 0x4a, 0x72, 0x7e, + /*4390:*/ 0x1b, 0x64, 0xc1, 0x66, 0xe8, 0x3d, 0x30, 0x38, 0x8c, 0x58, 0x3c, 0x0f, 0x64, 0x54, 0x9b, 0x1b, + /*43a0:*/ 0x5e, 0xb7, 0x87, 0x95, 0xf7, 0x92, 0xbe, 0x4c, 0x42, 0x03, 0x77, 0x74, 0xea, 0x9e, 0xf3, 0x92, + /*43b0:*/ 0x94, 0x0d, 0x47, 0x33, 0x23, 0x88, 0x74, 0x71, 0x47, 0xab, 0x1d, 0xd5, 0x92, 0x81, 0x73, 0x66, + /*43c0:*/ 0x62, 0xc3, 0x27, 0xe5, 0xe0, 0x84, 0xfa, 0xe4, 0x6a, 0x2e, 0x07, 0xea, 0xdb, 0x44, 0x24, 0xef, + /*43d0:*/ 0x8a, 0xb0, 0x5e, 0xb0, 0x61, 0x03, 0x9c, 0xf8, 0xc7, 0xc8, 0x34, 0x1b, 0x87, 0xc7, 0xf1, 0x3b, + /*43e0:*/ 0xb5, 0x7e, 0xb7, 0x37, 0x4d, 0x3a, 0xb7, 0x4b, 0x2e, 0x21, 0xe2, 0x3e, 0x0d, 0xe7, 0x07, 0x3c, + /*43f0:*/ 0x43, 0xb2, 0x6d, 0x87, 0xa9, 0x79, 0x96, 0x86, 0x0c, 0x0e, 0xbc, 0x0d, 0x5e, 0x5b, 0x9f, 0xbf, + /*4400:*/ 0xc0, 0xfe, 0x4b, 0x81, 0xa2, 0x91, 0x39, 0xf9, 0x59, 0xfa, 0x96, 0x80, 0x2a, 0x90, 0x13, 0x4c, + /*4410:*/ 0x4e, 0x08, 0x1e, 0xcc, 0xfe, 0x1f, 0x94, 0x2b, 0x1b, 0x3f, 0x80, 0xa2, 0x03, 0xc2, 0xee, 0x37, + /*4420:*/ 0x52, 0xa2, 0xb7, 0xfb, 0x2c, 0x42, 0xe6, 0xd9, 0x57, 0xa4, 0xdd, 0x41, 0x02, 0xfc, 0x9f, 0x40, + /*4430:*/ 0x62, 0xb8, 0xc6, 0x4b, 0x42, 0xe4, 0xd8, 0x50, 0x47, 0xad, 0xea, 0x55, 0x21, 0xe7, 0xbb, 0xa4, + /*4440:*/ 0xf5, 0x07, 0x70, 0x6f, 0xba, 0x7e, 0x30, 0x31, 0x03, 0x15, 0x9d, 0x44, 0x29, 0x16, 0xe0, 0x95, + /*4450:*/ 0x67, 0xf0, 0x4b, 0x27, 0x94, 0xaf, 0x48, 0x2f, 0x3d, 0xe8, 0x8c, 0x64, 0x47, 0x32, 0xa0, 0xb7, + /*4460:*/ 0x23, 0x27, 0xbf, 0xca, 0xdf, 0x6a, 0xc1, 0x41, 0x19, 0x82, 0xd4, 0x97, 0xee, 0x24, 0xbc, 0x65, + /*4470:*/ 0xd3, 0x8b, 0x10, 0xf8, 0x1b, 0x70, 0xe1, 0x5c, 0xeb, 0xa2, 0xa9, 0x89, 0x62, 0xec, 0xaa, 0xf6, + /*4480:*/ 0xb1, 0xda, 0xf9, 0xe5, 0x0c, 0x47, 0xa0, 0x06, 0x93, 0x6c, 0x54, 0xea, 0x48, 0x9d, 0x57, 0x90, + /*4490:*/ 0x8f, 0x5f, 0xd0, 0x6f, 0x97, 0x2a, 0x64, 0x46, 0x05, 0x22, 0x5a, 0xda, 0xbd, 0xb0, 0x47, 0x73, + /*44a0:*/ 0x62, 0x2c, 0x75, 0xcb, 0xed, 0x7d, 0x0b, 0x14, 0x30, 0xb3, 0x78, 0x4c, 0xe7, 0x9c, 0xaf, 0x9b, + /*44b0:*/ 0x7a, 0x97, 0xde, 0x12, 0xac, 0x5e, 0x6a, 0x96, 0xd7, 0xfd, 0x8c, 0x3f, 0xe8, 0xed, 0x61, 0x1d, + /*44c0:*/ 0x5e, 0xcf, 0xfb, 0xb9, 0x49, 0x80, 0xde, 0x1b, 0xb8, 0x12, 0x81, 0x5a, 0xdb, 0xd6, 0xb7, 0x0f, + /*44d0:*/ 0x50, 0xf5, 0x7e, 0xf8, 0xa6, 0xcc, 0xfa, 0x86, 0x25, 0xdb, 0xd1, 0xd1, 0xfb, 0x99, 0xbe, 0x28, + /*44e0:*/ 0x60, 0xc9, 0x83, 0xe6, 0x64, 0x56, 0xf6, 0x15, 0x8d, 0xf0, 0xad, 0xd2, 0x3f, 0x6f, 0x18, 0xe8, + /*44f0:*/ 0xee, 0x3c, 0x25, 0x52, 0x3f, 0x32, 0x29, 0x99, 0x36, 0xc2, 0x18, 0xb0, 0xea, 0xc5, 0x87, 0x60, + /*4500:*/ 0xda, 0xe4, 0x78, 0x89, 0xee, 0xaa, 0x9d, 0x4e, 0xfa, 0xca, 0xe1, 0xbe, 0xda, 0x46, 0x22, 0x28, + /*4510:*/ 0x13, 0x0e, 0xf1, 0x8e, 0x15, 0x6d, 0x68, 0x07, 0xc5, 0x0a, 0x41, 0x4f, 0x2d, 0xd6, 0x0c, 0x89, + /*4520:*/ 0x13, 0x5b, 0x79, 0x46, 0x0e, 0x14, 0x4d, 0x8a, 0xb1, 0xe0, 0x6e, 0xcc, 0x46, 0xa2, 0x35, 0xa6, + /*4530:*/ 0xf0, 0x61, 0x80, 0xe8, 0xd0, 0x24, 0xab, 0x1d, 0xa4, 0x28, 0x93, 0xb8, 0x87, 0xa5, 0xd0, 0xe4, + /*4540:*/ 0x9c, 0xfd, 0x29, 0x75, 0x8e, 0x85, 0x20, 0x25, 0xcb, 0xbb, 0x21, 0x20, 0xf9, 0x31, 0x07, 0xaf, + /*4550:*/ 0x5d, 0xf7, 0xc1, 0x7f, 0x89, 0xad, 0xab, 0xbf, 0x65, 0xf8, 0x71, 0xb0, 0x7f, 0xd2, 0xad, 0xd1, + /*4560:*/ 0x51, 0x48, 0x9f, 0xf0, 0xaa, 0xc0, 0xde, 0x60, 0x40, 0xe4, 0x2b, 0xb5, 0x0e, 0x24, 0xdd, 0xfa, + /*4570:*/ 0x0f, 0x52, 0xc3, 0x6e, 0xcc, 0xa2, 0xb9, 0x32, 0x30, 0x92, 0x24, 0x51, 0xb9, 0xff, 0x7d, 0xef, + /*4580:*/ 0x5b, 0x6c, 0xf2, 0xde, 0x08, 0x11, 0x94, 0x52, 0xac, 0x53, 0xd3, 0xc5, 0x97, 0xd6, 0xd2, 0x78, + /*4590:*/ 0x1c, 0x70, 0xea, 0xd8, 0x81, 0x7f, 0xd6, 0x3b, 0x27, 0x6f, 0x94, 0x59, 0x98, 0xcf, 0x5d, 0x06, + /*45a0:*/ 0x9b, 0x97, 0x47, 0xf9, 0x4f, 0x50, 0xb9, 0x56, 0x36, 0xb5, 0xb6, 0xb9, 0xe3, 0xe2, 0xce, 0x63, + /*45b0:*/ 0x0c, 0x3f, 0xc5, 0xe1, 0xde, 0x8f, 0xcb, 0x8b, 0x36, 0x8d, 0x8d, 0xb9, 0xa6, 0xfb, 0x1b, 0xe4, + /*45c0:*/ 0xe9, 0xea, 0xd0, 0xf0, 0x75, 0x2e, 0x75, 0x58, 0xfc, 0x48, 0x49, 0xad, 0x97, 0x3e, 0xc8, 0xdd, + /*45d0:*/ 0x12, 0x78, 0x79, 0xd1, 0xdc, 0xd7, 0x49, 0x05, 0x65, 0x64, 0x26, 0x9e, 0x00, 0xf5, 0x2b, 0xc2, + /*45e0:*/ 0x03, 0x74, 0xb3, 0x23, 0x74, 0xd5, 0xb4, 0x4b, 0xb4, 0x6e, 0x0e, 0x1e, 0xb3, 0xae, 0x14, 0xe2, + /*45f0:*/ 0xe8, 0xfb, 0xc2, 0xf6, 0xd5, 0x99, 0xd2, 0x90, 0x27, 0x13, 0xf9, 0x20, 0x7b, 0xd0, 0x76, 0x95, + /*4600:*/ 0x67, 0x45, 0x7a, 0x9b, 0x3c, 0x41, 0xc0, 0x6e, 0x6c, 0x2f, 0x0a, 0xe9, 0xcc, 0xa5, 0x8b, 0x41, + /*4610:*/ 0x8c, 0x27, 0xd6, 0xce, 0xde, 0x8f, 0x02, 0xd3, 0xad, 0xd5, 0x88, 0x19, 0xbb, 0xeb, 0xb8, 0x3c, + /*4620:*/ 0x45, 0xea, 0xff, 0xe8, 0x10, 0x93, 0xaf, 0xab, 0x24, 0xff, 0x10, 0x8e, 0x60, 0x92, 0x88, 0x0c, + /*4630:*/ 0x42, 0x17, 0xf4, 0x42, 0xbc, 0x7e, 0xfe, 0xbf, 0x14, 0x09, 0x6f, 0xff, 0xa2, 0x42, 0x43, 0x97, + /*4640:*/ 0x5f, 0x24, 0xae, 0xa1, 0xcf, 0x48, 0xe6, 0x35, 0x3f, 0x12, 0x55, 0x38, 0x0a, 0x91, 0x05, 0x46, + /*4650:*/ 0x9d, 0x80, 0xb3, 0x75, 0x24, 0x64, 0x19, 0x8e, 0xea, 0x65, 0x94, 0x22, 0xfe, 0x6c, 0xa4, 0x82, + /*4660:*/ 0x16, 0x96, 0x7f, 0x57, 0x4b, 0x72, 0x54, 0x9e, 0x84, 0x22, 0x06, 0x64, 0x24, 0xe1, 0x50, 0xc7, + /*4670:*/ 0x78, 0xb8, 0xa4, 0xb4, 0xfe, 0x60, 0xa1, 0x0c, 0xf6, 0xba, 0xdd, 0x93, 0x0f, 0xf5, 0x36, 0xe2, + /*4680:*/ 0xb6, 0x9c, 0xd3, 0xc8, 0x96, 0xb4, 0xd2, 0x02, 0x38, 0x42, 0x9a, 0x2f, 0x1b, 0x46, 0xd2, 0x20, + /*4690:*/ 0xc6, 0x90, 0xd5, 0xd4, 0x42, 0xf0, 0xd5, 0x14, 0xd1, 0xb1, 0xec, 0x02, 0x41, 0x25, 0xbb, 0x35, + /*46a0:*/ 0x0b, 0x9a, 0x66, 0x1d, 0xc8, 0xf9, 0xc1, 0x6a, 0x59, 0xfc, 0xc5, 0x57, 0xda, 0xdf, 0xe2, 0x8a, + /*46b0:*/ 0x8b, 0x1b, 0x21, 0x1d, 0x45, 0x76, 0x57, 0x8a, 0x0c, 0xd8, 0x21, 0xa0, 0x34, 0x42, 0xeb, 0xa7, + /*46c0:*/ 0x01, 0x62, 0x5f, 0x5d, 0xf5, 0x12, 0x44, 0x42, 0x4a, 0xb1, 0x2c, 0x9a, 0x44, 0x79, 0x9e, 0x6b, + /*46d0:*/ 0xde, 0xbf, 0x13, 0x8c, 0x22, 0x4f, 0xe7, 0x50, 0xd4, 0x0a, 0x18, 0x4f, 0x50, 0xf0, 0xbb, 0x16, + /*46e0:*/ 0xf5, 0x57, 0x2c, 0xd8, 0x66, 0x3f, 0x83, 0x62, 0xe8, 0x5a, 0xd4, 0x05, 0x67, 0xe0, 0xa7, 0x40, + /*46f0:*/ 0x08, 0xc3, 0x9e, 0x5b, 0xbb, 0x3a, 0xd3, 0x44, 0x15, 0xa6, 0xb3, 0x12, 0xea, 0x89, 0xd9, 0xbc, + /*4700:*/ 0xc1, 0xc8, 0x01, 0x39, 0x1c, 0xc7, 0xc0, 0xfa, 0xea, 0x85, 0xf9, 0x27, 0xe9, 0x10, 0x93, 0x49, + /*4710:*/ 0x5e, 0xa2, 0xb2, 0x40, 0xf3, 0x6f, 0xd1, 0xfb, 0x67, 0xfa, 0x1e, 0x44, 0xc5, 0x7d, 0x49, 0xbe, + /*4720:*/ 0xeb, 0xff, 0x2b, 0x0d, 0xcd, 0x82, 0xd5, 0x42, 0xd1, 0xf2, 0x26, 0x78, 0x8e, 0xec, 0x67, 0x01, + /*4730:*/ 0xb0, 0x5f, 0x0b, 0x28, 0x59, 0x49, 0x8d, 0x2d, 0x77, 0x30, 0x77, 0xfb, 0xf0, 0x1b, 0x1a, 0x83, + /*4740:*/ 0x93, 0x22, 0x0c, 0x92, 0xa5, 0x74, 0xbb, 0xe2, 0xa6, 0xe5, 0x9e, 0x86, 0x6c, 0x34, 0xee, 0x28, + /*4750:*/ 0xec, 0x81, 0xdc, 0x1f, 0x78, 0x54, 0x2c, 0x5a, 0xe6, 0xdf, 0x37, 0x61, 0xd1, 0x9b, 0x75, 0x87, + /*4760:*/ 0xc8, 0xe7, 0x9e, 0x1a, 0x26, 0x82, 0x16, 0xaa, 0x4e, 0x0a, 0xfc, 0xc1, 0xa6, 0xf3, 0xb6, 0xaf, + /*4770:*/ 0x1f, 0xff, 0xc2, 0xb4, 0xb7, 0x33, 0x13, 0xb3, 0xc4, 0xc7, 0x7d, 0xb1, 0xd3, 0x69, 0x5c, 0x8e, + /*4780:*/ 0xe7, 0x49, 0x52, 0x47, 0x16, 0x28, 0x14, 0x4a, 0x54, 0xb5, 0xe3, 0xa8, 0x62, 0x2d, 0x22, 0xb1, + /*4790:*/ 0x78, 0xe2, 0x15, 0x63, 0x6f, 0x0f, 0x7e, 0x5c, 0x3b, 0xc3, 0x12, 0xfd, 0x67, 0x62, 0x24, 0x12, + /*47a0:*/ 0x96, 0x75, 0x30, 0x87, 0x77, 0x81, 0x49, 0xa8, 0x95, 0x3b, 0x94, 0xb8, 0x32, 0x24, 0x65, 0xe5, + /*47b0:*/ 0xd7, 0x05, 0x07, 0xf4, 0xa2, 0xc7, 0x67, 0x1d, 0x0a, 0xc4, 0xee, 0x25, 0xf9, 0x6a, 0xc2, 0xf3, + /*47c0:*/ 0x06, 0xd9, 0xcc, 0x48, 0x0f, 0x85, 0xb0, 0x93, 0xdb, 0x27, 0x46, 0xfe, 0xc7, 0x8d, 0xcb, 0x02, + /*47d0:*/ 0xd5, 0xad, 0x0c, 0x18, 0xc1, 0x19, 0xab, 0xd5, 0xd9, 0xbf, 0x7a, 0xfe, 0xc1, 0x27, 0x80, 0xca, + /*47e0:*/ 0xca, 0x14, 0x1f, 0x4f, 0x64, 0xfb, 0xe5, 0x03, 0x28, 0x16, 0xa2, 0xc9, 0x09, 0x93, 0xdd, 0x40, + /*47f0:*/ 0xc3, 0x2f, 0x46, 0xd5, 0xcf, 0x29, 0xe0, 0x9c, 0xab, 0x0a, 0x5b, 0xab, 0xbd, 0x0e, 0x28, 0x16, + /*4800:*/ 0xc6, 0x5d, 0x3f, 0x5e, 0x41, 0x5a, 0x35, 0xd0, 0x3b, 0x9f, 0x49, 0x25, 0x00, 0x4b, 0x81, 0xda, + /*4810:*/ 0x04, 0xd4, 0x03, 0xe3, 0xd8, 0xb3, 0x51, 0xba, 0x4c, 0xe2, 0x1c, 0xb8, 0x9a, 0xaa, 0x0d, 0x00, + /*4820:*/ 0x21, 0x93, 0x0a, 0xcb, 0xa4, 0x1e, 0xf9, 0x50, 0x9f, 0xf0, 0xa3, 0x01, 0x84, 0xf1, 0xcf, 0x7f, + /*4830:*/ 0x93, 0x19, 0xbd, 0x53, 0x0c, 0xd1, 0x89, 0xe6, 0x2f, 0x10, 0x80, 0x91, 0x33, 0xb7, 0x99, 0xaa, + /*4840:*/ 0xe1, 0x26, 0xf7, 0xde, 0x76, 0x09, 0xf6, 0x45, 0x89, 0x33, 0xd0, 0xf0, 0xf8, 0xf6, 0xd4, 0x59, + /*4850:*/ 0x94, 0xf9, 0x06, 0xe5, 0x7c, 0xb4, 0x61, 0xac, 0x2f, 0x9a, 0x8e, 0x2d, 0x28, 0x37, 0x11, 0x3a, + /*4860:*/ 0x1d, 0xf7, 0x06, 0x79, 0x52, 0x8b, 0xa9, 0xd9, 0xa8, 0x89, 0xfc, 0xb4, 0xbf, 0xbe, 0x56, 0xfd, + /*4870:*/ 0x8a, 0x62, 0x89, 0x21, 0x6a, 0x58, 0x03, 0x22, 0x43, 0x56, 0x33, 0xca, 0x3e, 0x2a, 0x87, 0x66, + /*4880:*/ 0x16, 0xda, 0xb5, 0x96, 0x51, 0x86, 0xb9, 0x7e, 0x6d, 0xb5, 0xb5, 0xb2, 0x57, 0x5b, 0x75, 0xd5, + /*4890:*/ 0xd5, 0xc2, 0x72, 0x7b, 0x9e, 0xa5, 0xab, 0x45, 0x71, 0x77, 0x87, 0xc8, 0xb7, 0x0d, 0xbd, 0xea, + /*48a0:*/ 0x29, 0xd1, 0xc3, 0x15, 0x55, 0xa5, 0x16, 0x4c, 0x38, 0xa8, 0x86, 0x66, 0xd5, 0x7a, 0xf4, 0x47, + /*48b0:*/ 0x63, 0xb5, 0x01, 0x99, 0xec, 0xbb, 0x7e, 0x72, 0x4d, 0x6c, 0x49, 0x55, 0xde, 0xc1, 0xfa, 0xd9, + /*48c0:*/ 0x34, 0x60, 0x48, 0x48, 0x14, 0x9d, 0xb9, 0x9e, 0x5f, 0x2b, 0x7b, 0xbd, 0x68, 0x6a, 0xb2, 0x6d, + /*48d0:*/ 0xc6, 0x0b, 0x89, 0xbb, 0x84, 0xdd, 0x33, 0x5c, 0xc1, 0x36, 0x5e, 0xeb, 0x71, 0x39, 0x32, 0xd3, + /*48e0:*/ 0xdf, 0xdd, 0xd4, 0x46, 0x8d, 0x63, 0xaa, 0xea, 0x47, 0xc4, 0x15, 0x01, 0xe3, 0x37, 0xfc, 0x91, + /*48f0:*/ 0x92, 0xca, 0x90, 0xb5, 0xa0, 0x8d, 0xd7, 0xdb, 0x7a, 0xe2, 0x9d, 0x82, 0x7f, 0xb7, 0x40, 0x72, + /*4900:*/ 0xfb, 0x5e, 0xc9, 0x5a, 0xf9, 0xcf, 0xa8, 0x9f, 0x42, 0xa6, 0x66, 0xa6, 0x91, 0x41, 0x6c, 0xf8, + /*4910:*/ 0x59, 0xbf, 0x9e, 0xbb, 0x62, 0xab, 0x05, 0x1f, 0x19, 0x6e, 0x5f, 0x23, 0x48, 0x85, 0xa7, 0xaf, + /*4920:*/ 0xeb, 0x26, 0x7f, 0xb3, 0x42, 0xfe, 0x37, 0xd6, 0xa0, 0x9f, 0x47, 0xb3, 0x3a, 0x05, 0x6c, 0x78, + /*4930:*/ 0x08, 0x5d, 0xaa, 0x19, 0x37, 0xff, 0x69, 0x0d, 0x96, 0x2a, 0xd2, 0x8a, 0x0d, 0x7f, 0xbf, 0x5b, + /*4940:*/ 0x26, 0x40, 0x3e, 0x47, 0x30, 0xb5, 0xc1, 0x48, 0xa5, 0x4e, 0x76, 0xae, 0x8d, 0xba, 0x5b, 0x0b, + /*4950:*/ 0x22, 0xef, 0xdf, 0xa5, 0x33, 0xc6, 0xe9, 0x79, 0x5d, 0x1e, 0x6a, 0xec, 0xa2, 0xa6, 0xfa, 0x5f, + /*4960:*/ 0xac, 0x42, 0x67, 0x60, 0x06, 0x65, 0x6b, 0xf2, 0x3d, 0xbf, 0x92, 0x54, 0xfb, 0xe8, 0x7e, 0x1a, + /*4970:*/ 0xb5, 0x9b, 0x57, 0x86, 0x21, 0xc4, 0x80, 0x50, 0x54, 0xe7, 0xfc, 0x10, 0x9c, 0xb5, 0xde, 0x50, + /*4980:*/ 0x13, 0x92, 0x3a, 0x85, 0x09, 0xd3, 0x02, 0xa2, 0xf0, 0x38, 0xf0, 0x6d, 0x98, 0x9a, 0x59, 0x92, + /*4990:*/ 0xad, 0x89, 0x0d, 0xfd, 0xdf, 0x84, 0xbb, 0x77, 0x2d, 0x4c, 0xbb, 0x8c, 0xa5, 0xe2, 0xea, 0x45, + /*49a0:*/ 0xfd, 0x40, 0x07, 0xbc, 0xa0, 0xf0, 0x84, 0x48, 0x17, 0xd2, 0x58, 0x94, 0xbf, 0x89, 0x04, 0x7e, + /*49b0:*/ 0x6e, 0xc9, 0x7a, 0xcc, 0x4a, 0x65, 0xf7, 0xb4, 0xf4, 0x2f, 0xae, 0x6e, 0xae, 0x7f, 0x1c, 0xa7, + /*49c0:*/ 0xda, 0xce, 0x73, 0xda, 0x7c, 0x9c, 0xed, 0x7c, 0x5c, 0xc6, 0x56, 0x8b, 0xc7, 0xc1, 0x53, 0xb4, + /*49d0:*/ 0x5a, 0x30, 0x70, 0x09, 0xd7, 0xdd, 0x20, 0xd0, 0x2a, 0x47, 0x82, 0xb2, 0xa1, 0xd5, 0x69, 0x0a, + /*49e0:*/ 0xc1, 0xf8, 0xe9, 0x69, 0x60, 0x17, 0x3f, 0x4c, 0x79, 0x92, 0x33, 0x16, 0x92, 0xbf, 0x4a, 0x73, + /*49f0:*/ 0x7f, 0x0a, 0xd1, 0x96, 0x83, 0x53, 0x1c, 0x01, 0x01, 0x5d, 0xe4, 0xf1, 0xe3, 0xa1, 0xc4, 0x91, + /*4a00:*/ 0x71, 0x14, 0xbf, 0x60, 0x5a, 0xf5, 0x95, 0x0a, 0x45, 0x35, 0x39, 0x81, 0xea, 0xd4, 0x66, 0x69, + /*4a10:*/ 0xa6, 0x12, 0x6d, 0xa8, 0xb8, 0x32, 0x92, 0x1b, 0xa4, 0x59, 0x46, 0x6c, 0x8c, 0xed, 0xc0, 0x4c, + /*4a20:*/ 0x55, 0x99, 0xb3, 0xc1, 0x51, 0xfa, 0x30, 0xf0, 0x54, 0x2f, 0x6e, 0x7d, 0xbc, 0xb3, 0x9a, 0x9d, + /*4a30:*/ 0x27, 0x42, 0x30, 0xbf, 0x0e, 0x41, 0x87, 0x65, 0x70, 0x10, 0xbc, 0xf1, 0x4b, 0x3e, 0x64, 0x48, + /*4a40:*/ 0x88, 0xfb, 0xfa, 0x1b, 0x9a, 0xcb, 0xf5, 0xf7, 0x5c, 0xf8, 0xcc, 0xb2, 0xad, 0xc7, 0x96, 0x16, + /*4a50:*/ 0x36, 0xe4, 0x8c, 0x23, 0x21, 0x38, 0x60, 0x6c, 0x6d, 0xaa, 0xef, 0xc9, 0x26, 0xde, 0x1f, 0x17, + /*4a60:*/ 0xad, 0x4a, 0xa6, 0xbb, 0xcb, 0xce, 0x76, 0x40, 0x5e, 0x86, 0xdb, 0x97, 0x1f, 0x70, 0x86, 0xf7, + /*4a70:*/ 0x8f, 0xf8, 0x11, 0x39, 0x03, 0xc7, 0x0c, 0xcc, 0x71, 0x29, 0x00, 0x2a, 0x4e, 0x62, 0x49, 0xad, + /*4a80:*/ 0xb0, 0xfa, 0xfb, 0x80, 0x2e, 0xe8, 0x70, 0x73, 0x57, 0x42, 0xd3, 0xc0, 0x68, 0x7e, 0xaa, 0x0a, + /*4a90:*/ 0xdb, 0x99, 0x89, 0x07, 0x8a, 0x6d, 0x4c, 0x9c, 0xbc, 0x33, 0x4f, 0xee, 0x7f, 0x27, 0x45, 0x0f, + /*4aa0:*/ 0x7f, 0x16, 0xcb, 0x5b, 0xd7, 0x88, 0x9a, 0xbf, 0x4b, 0x98, 0x01, 0x1c, 0xaf, 0x06, 0x7f, 0x1e, + /*4ab0:*/ 0x4d, 0x07, 0x70, 0xb8, 0x7f, 0xac, 0xbb, 0x79, 0xc3, 0x10, 0x01, 0xbc, 0x43, 0x97, 0x46, 0x38, + /*4ac0:*/ 0x6e, 0x96, 0x82, 0x31, 0xe6, 0x2e, 0xa0, 0x56, 0xd6, 0xfa, 0xce, 0x3c, 0x43, 0xcd, 0xfe, 0x63, + /*4ad0:*/ 0x3d, 0xd8, 0x48, 0x28, 0x8d, 0x80, 0xb8, 0xe3, 0xfd, 0x3b, 0x74, 0x90, 0xbd, 0x64, 0x2d, 0x3f, + /*4ae0:*/ 0x18, 0x94, 0x39, 0x9c, 0x52, 0x8a, 0x6b, 0x88, 0x7b, 0xd2, 0xa7, 0x89, 0x16, 0x7b, 0x89, 0x45, + /*4af0:*/ 0xdd, 0x0e, 0xf1, 0xc7, 0xc4, 0x9b, 0xb8, 0x90, 0xb8, 0x97, 0x93, 0x4f, 0x98, 0x49, 0xef, 0xef, + /*4b00:*/ 0x0a, 0x78, 0xc9, 0xaf, 0xc3, 0xe2, 0xb6, 0x9c, 0x22, 0x69, 0x8b, 0x86, 0xff, 0x76, 0x04, 0x60, + /*4b10:*/ 0xab, 0x35, 0x92, 0x1c, 0xa8, 0xac, 0xdd, 0x99, 0x09, 0xdf, 0x97, 0xfe, 0x25, 0x86, 0x0a, 0x43, + /*4b20:*/ 0xdd, 0x5c, 0xee, 0x40, 0xdf, 0x68, 0x7b, 0x87, 0x70, 0xd0, 0x45, 0xa9, 0x9c, 0xd8, 0x19, 0xca, + /*4b30:*/ 0xfd, 0x08, 0x4a, 0xfc, 0x26, 0xfb, 0xb0, 0x3d, 0xab, 0xf9, 0x04, 0x77, 0x26, 0xc9, 0x18, 0x45, + /*4b40:*/ 0xdf, 0xf5, 0xed, 0x8a, 0xb6, 0x9a, 0x08, 0x2d, 0xa9, 0xb3, 0xd1, 0xea, 0x82, 0xfd, 0x5c, 0xbf, + /*4b50:*/ 0x32, 0x90, 0xc7, 0x2d, 0x01, 0xf9, 0x56, 0xb0, 0x6b, 0xfe, 0x7a, 0xe2, 0x03, 0x90, 0x48, 0x60, + /*4b60:*/ 0xdc, 0x0b, 0xc9, 0x2f, 0x95, 0xe6, 0x0b, 0x73, 0xb5, 0xeb, 0x3d, 0xfe, 0xbe, 0x7e, 0x89, 0x24, + /*4b70:*/ 0x15, 0x68, 0x08, 0x86, 0x38, 0xad, 0x27, 0x55, 0x9a, 0x56, 0x58, 0x06, 0x0a, 0x4b, 0x78, 0xde, + /*4b80:*/ 0x94, 0xb0, 0xa5, 0x95, 0x10, 0x85, 0x63, 0x8e, 0xcb, 0xd2, 0x26, 0x35, 0x14, 0xa3, 0x1d, 0xd8, + /*4b90:*/ 0x62, 0xc0, 0x42, 0x4c, 0xa4, 0xad, 0x9e, 0x59, 0x50, 0xf8, 0xcf, 0x55, 0xb8, 0x01, 0xfe, 0x68, + /*4ba0:*/ 0x92, 0x08, 0x8b, 0x8d, 0xd8, 0xab, 0x1d, 0xed, 0xec, 0x01, 0xbc, 0xf5, 0xe3, 0x7c, 0x5c, 0x13, + /*4bb0:*/ 0xef, 0x7d, 0x14, 0x21, 0xd1, 0x8e, 0x9b, 0xe4, 0x34, 0x78, 0x59, 0x45, 0x9c, 0x86, 0x37, 0xc2, + /*4bc0:*/ 0x24, 0xd1, 0xeb, 0x14, 0x83, 0x0a, 0x80, 0xde, 0x45, 0xa1, 0x17, 0x41, 0xd1, 0x36, 0x1e, 0x95, + /*4bd0:*/ 0x4d, 0x00, 0x13, 0x2d, 0x15, 0x7d, 0x4b, 0x52, 0x90, 0x32, 0x12, 0xc2, 0x7d, 0x72, 0xaa, 0x2a, + /*4be0:*/ 0x16, 0x54, 0x08, 0xb7, 0x2b, 0x86, 0xa5, 0xa6, 0x62, 0x2c, 0x8a, 0x0d, 0xd8, 0x50, 0x89, 0xf9, + /*4bf0:*/ 0xb2, 0x52, 0xd2, 0xd9, 0xa2, 0xa3, 0x21, 0x14, 0x87, 0x89, 0xe1, 0xe7, 0xce, 0xf0, 0x5f, 0xd8, + /*4c00:*/ 0x75, 0x61, 0xd6, 0x66, 0xcf, 0xda, 0x00, 0x21, 0xa6, 0xf0, 0xb4, 0x41, 0xcf, 0xf4, 0x71, 0x51, + /*4c10:*/ 0xba, 0x27, 0x32, 0x7c, 0x3c, 0xb6, 0xc8, 0x29, 0x53, 0x1f, 0xc5, 0xc1, 0xfd, 0x9f, 0xa8, 0x08, + /*4c20:*/ 0x30, 0x51, 0x7f, 0xf6, 0x8b, 0x6a, 0xa2, 0xbe, 0xd4, 0xf5, 0x15, 0xaf, 0x49, 0x19, 0xb9, 0x8e, + /*4c30:*/ 0x19, 0xfc, 0x70, 0x0c, 0x28, 0xdc, 0xee, 0x85, 0xb7, 0x5b, 0xde, 0x02, 0xdd, 0x85, 0x8c, 0x9b, + /*4c40:*/ 0x78, 0x13, 0x35, 0x1b, 0xd2, 0xe8, 0xcf, 0x9a, 0xc1, 0x3d, 0x21, 0xa2, 0xc5, 0x34, 0xdd, 0x9e, + /*4c50:*/ 0x6f, 0xeb, 0xc4, 0x82, 0x18, 0xd8, 0x5a, 0x31, 0x4a, 0x75, 0x45, 0xc9, 0x6f, 0x56, 0x63, 0x1f, + /*4c60:*/ 0xc9, 0x4d, 0x35, 0x74, 0x58, 0x31, 0xf1, 0x3e, 0xd7, 0xc5, 0x95, 0xf7, 0x29, 0x4f, 0x24, 0xf7, + /*4c70:*/ 0xd9, 0xba, 0xb6, 0x43, 0x34, 0x69, 0x34, 0x04, 0xf0, 0xac, 0x4c, 0x08, 0xed, 0xf9, 0xf4, 0xe3, + /*4c80:*/ 0xdc, 0xc5, 0x3e, 0x4f, 0x65, 0xde, 0xba, 0xb3, 0xaf, 0x6f, 0x1a, 0x1f, 0x21, 0x00, 0x80, 0xc2, + /*4c90:*/ 0x7c, 0x54, 0x55, 0x35, 0x05, 0x23, 0x65, 0x8c, 0x1a, 0x19, 0x2e, 0xd8, 0x4f, 0xfb, 0xb9, 0xfa, + /*4ca0:*/ 0x73, 0x5f, 0x33, 0x0e, 0xfb, 0x32, 0xf5, 0x84, 0x5e, 0xd1, 0x5d, 0x0c, 0x6d, 0x6b, 0x06, 0xc6, + /*4cb0:*/ 0x09, 0x5b, 0x14, 0x40, 0x84, 0x68, 0xca, 0x4e, 0xf3, 0xd0, 0xe0, 0x98, 0x86, 0xbe, 0xb8, 0x60, + /*4cc0:*/ 0x8c, 0xf6, 0xf3, 0x0e, 0xec, 0x70, 0xea, 0x53, 0x19, 0x2c, 0xfb, 0x69, 0x00, 0x37, 0x06, 0x36, + /*4cd0:*/ 0x3b, 0xee, 0xf1, 0x9e, 0xcb, 0xdb, 0x03, 0x00, 0x25, 0x35, 0xa1, 0x7b, 0xb2, 0x79, 0xce, 0x53, + /*4ce0:*/ 0xfe, 0xcb, 0x3c, 0x99, 0xde, 0x50, 0x5a, 0x26, 0xa0, 0xe4, 0x28, 0x96, 0xf6, 0x8d, 0x30, 0x97, + /*4cf0:*/ 0xcd, 0x6e, 0xbb, 0xb0, 0x70, 0x29, 0x60, 0xe8, 0x48, 0x1b, 0xe9, 0xfb, 0xa4, 0x29, 0xea, 0x52, + /*4d00:*/ 0x8f, 0x76, 0x77, 0x1a, 0xdb, 0xcd, 0x39, 0x7a, 0xcf, 0x9d, 0x66, 0xf3, 0x06, 0x9a, 0xb9, 0x80, + /*4d10:*/ 0xb7, 0xe7, 0xab, 0xbd, 0xe3, 0xbe, 0x33, 0xb2, 0x3a, 0x4b, 0x43, 0xc5, 0xa8, 0x91, 0x1c, 0xba, + /*4d20:*/ 0x89, 0xd4, 0x2b, 0xba, 0xfb, 0x91, 0xe0, 0x27, 0xf5, 0x57, 0xd8, 0x2d, 0x7b, 0xad, 0x3d, 0x0d, + /*4d30:*/ 0x2c, 0x21, 0xf8, 0x3a, 0x6a, 0x86, 0xbf, 0x66, 0x35, 0xb2, 0x3a, 0x55, 0xb7, 0x41, 0xf2, 0x8c, + /*4d40:*/ 0x82, 0x2f, 0xf9, 0x36, 0x5e, 0x63, 0xfe, 0x15, 0x23, 0x61, 0xa4, 0xee, 0x53, 0x45, 0xd3, 0xdc, + /*4d50:*/ 0xc5, 0x1b, 0xce, 0xb7, 0x3c, 0x23, 0x6d, 0x40, 0xa1, 0x28, 0x05, 0x0f, 0xd0, 0xb8, 0x9b, 0x48, + /*4d60:*/ 0xb3, 0xe1, 0x91, 0xe1, 0x0e, 0xe5, 0xd3, 0x7e, 0xaa, 0x7a, 0xad, 0xa1, 0xcb, 0xa9, 0x06, 0x4a, + /*4d70:*/ 0x22, 0x57, 0xa1, 0x7b, 0xd9, 0xf5, 0x09, 0x48, 0x09, 0x34, 0x88, 0xcf, 0xfd, 0xf8, 0xdd, 0x3d, + /*4d80:*/ 0xc2, 0x7c, 0x5b, 0x36, 0xb0, 0x53, 0x2f, 0x5f, 0x41, 0x3e, 0x15, 0x71, 0xb0, 0x06, 0x18, 0x68, + /*4d90:*/ 0x64, 0xc8, 0xdb, 0xab, 0x4a, 0x1f, 0xc0, 0x24, 0xd1, 0x4c, 0x59, 0xe8, 0x9e, 0xce, 0x10, 0x16, + /*4da0:*/ 0x68, 0x1f, 0x70, 0x1f, 0x31, 0xde, 0xa3, 0xe2, 0x20, 0xbb, 0xfc, 0x93, 0xa6, 0x43, 0x23, 0xea, + /*4db0:*/ 0x3a, 0x45, 0xe5, 0x93, 0x80, 0x92, 0x43, 0x5b, 0x05, 0x3d, 0x65, 0xe2, 0xbf, 0x56, 0x3f, 0x26, + /*4dc0:*/ 0x82, 0x0b, 0x1e, 0xd4, 0x46, 0x3a, 0x7a, 0x5a, 0x44, 0x91, 0x7e, 0x38, 0x3b, 0x6a, 0x17, 0xaf, + /*4dd0:*/ 0xc5, 0x5a, 0xb2, 0x68, 0xce, 0x68, 0x9c, 0x3c, 0x71, 0xc9, 0xde, 0xaa, 0x9b, 0xee, 0xd3, 0x50, + /*4de0:*/ 0x3c, 0xfd, 0xd8, 0x82, 0xc2, 0x6b, 0x92, 0x1a, 0xf9, 0x0c, 0x65, 0x20, 0x96, 0xc2, 0xd4, 0x2c, + /*4df0:*/ 0x0e, 0x89, 0x9d, 0xc7, 0xe0, 0xb9, 0x9b, 0x12, 0xad, 0xea, 0x0d, 0x97, 0x24, 0x99, 0xbe, 0x81, + /*4e00:*/ 0x08, 0x1f, 0x19, 0x70, 0x7f, 0x12, 0x9b, 0x46, 0x6b, 0xe3, 0xaf, 0x0b, 0xbb, 0xdd, 0xf9, 0xee, + /*4e10:*/ 0xfc, 0x40, 0x5b, 0x60, 0xb7, 0x9e, 0x00, 0xfe, 0x83, 0xca, 0x02, 0x31, 0xdb, 0x0a, 0x1a, 0xbe, + /*4e20:*/ 0xf1, 0x5f, 0xf9, 0x4f, 0xce, 0x03, 0x8c, 0xed, 0x31, 0x22, 0xaa, 0xcd, 0xa5, 0x34, 0xf5, 0xb2, + /*4e30:*/ 0x68, 0xad, 0x3e, 0xb4, 0x80, 0xa9, 0x11, 0x32, 0x56, 0x4d, 0xd6, 0x34, 0xe0, 0x3c, 0xf3, 0x49, + /*4e40:*/ 0x67, 0x5c, 0x8a, 0xf2, 0x08, 0xbf, 0x48, 0xac, 0xc1, 0x85, 0xa7, 0xfe, 0xcd, 0x8f, 0x46, 0x3c, + /*4e50:*/ 0xd5, 0x49, 0xfe, 0xf3, 0x9c, 0x61, 0x20, 0xd6, 0x16, 0x53, 0xfe, 0x67, 0x1d, 0x74, 0x44, 0x43, + /*4e60:*/ 0xab, 0x01, 0x7a, 0x1f, 0xdf, 0x83, 0x51, 0xbb, 0x25, 0xfc, 0xd7, 0x22, 0x94, 0x22, 0x03, 0x6c, + /*4e70:*/ 0x66, 0xa3, 0xa4, 0x0e, 0x19, 0x39, 0xd4, 0x9b, 0xfb, 0x4e, 0x37, 0x9d, 0x0d, 0xef, 0x7f, 0x7c, + /*4e80:*/ 0x08, 0x6b, 0xff, 0xbc, 0xab, 0xd9, 0xfe, 0xd9, 0x37, 0xd5, 0x8e, 0x5f, 0x33, 0xa3, 0xf1, 0xa4, + /*4e90:*/ 0x14, 0x77, 0xdb, 0x2b, 0xda, 0x8e, 0x5f, 0xb0, 0x33, 0x70, 0x6d, 0xd7, 0x84, 0xbf, 0xe5, 0x76, + /*4ea0:*/ 0xc3, 0xed, 0x1b, 0x34, 0xaa, 0xc1, 0x8d, 0x91, 0xf9, 0x44, 0x9b, 0xb7, 0x40, 0x92, 0x5d, 0xf3, + /*4eb0:*/ 0x3f, 0xe0, 0xb2, 0x34, 0x6b, 0x43, 0xc2, 0x04, 0xf5, 0x22, 0x95, 0xf5, 0xf6, 0x0a, 0x0d, 0x3c, + /*4ec0:*/ 0x51, 0xde, 0xa5, 0x32, 0x85, 0x29, 0x49, 0xd2, 0x37, 0x97, 0x44, 0x8f, 0x09, 0x49, 0xb7, 0xcb, + /*4ed0:*/ 0x76, 0xb5, 0x5d, 0x27, 0x24, 0x08, 0xb0, 0x73, 0x6d, 0xd5, 0xce, 0x44, 0xe2, 0xbf, 0x5a, 0xa1, + /*4ee0:*/ 0x52, 0x19, 0xdd, 0x09, 0xc1, 0x8c, 0x04, 0x0c, 0x5c, 0x4d, 0x80, 0xeb, 0x28, 0xb2, 0xf6, 0x74, + /*4ef0:*/ 0x98, 0xef, 0xe9, 0xfc, 0x67, 0xb1, 0x6a, 0x4d, 0x99, 0x50, 0xcc, 0x5e, 0x4e, 0x48, 0xaf, 0x3a, + /*4f00:*/ 0x2b, 0xf9, 0xd5, 0x8a, 0xf5, 0x2c, 0xb1, 0x48, 0x24, 0x3c, 0x93, 0xd8, 0xd0, 0x0a, 0x7a, 0x72, + /*4f10:*/ 0x20, 0xe6, 0xe1, 0x38, 0x6b, 0xa5, 0x30, 0x03, 0xaf, 0x3c, 0x52, 0x34, 0xdf, 0x42, 0x0c, 0x62, + /*4f20:*/ 0xfd, 0x7e, 0x11, 0x3a, 0x8b, 0x89, 0x36, 0x34, 0xf4, 0xdb, 0x88, 0xe4, 0xb9, 0x0a, 0xb8, 0x72, + /*4f30:*/ 0x3f, 0x42, 0x13, 0x7e, 0x4b, 0x4e, 0x6d, 0xae, 0x3c, 0x49, 0x26, 0x12, 0x75, 0x70, 0x8f, 0x43, + /*4f40:*/ 0xaa, 0xb3, 0x1a, 0x87, 0x12, 0x99, 0x43, 0x7c, 0x37, 0x52, 0xc6, 0xb1, 0x72, 0x5a, 0xab, 0xc8, + /*4f50:*/ 0x49, 0xd5, 0x30, 0x49, 0x8f, 0xf0, 0x06, 0xae, 0x97, 0x7d, 0x97, 0x57, 0x5e, 0x2b, 0x6a, 0x43, + /*4f60:*/ 0xa2, 0x8d, 0xa8, 0x4e, 0xcf, 0xa3, 0xbb, 0x1a, 0x28, 0x23, 0x06, 0x3d, 0x61, 0x2a, 0x4c, 0x97, + /*4f70:*/ 0x9a, 0xd2, 0x3e, 0xc1, 0x68, 0xc5, 0x3c, 0x81, 0x61, 0x7f, 0x8b, 0xea, 0x0f, 0x42, 0x9c, 0x89, + /*4f80:*/ 0xb8, 0xb1, 0x8a, 0xd1, 0x74, 0x09, 0x6c, 0x13, 0xee, 0x22, 0x8a, 0x3c, 0x59, 0xf6, 0x6c, 0xdb, + /*4f90:*/ 0xfd, 0xe9, 0x12, 0x29, 0xd9, 0x56, 0xdf, 0xe9, 0x9b, 0x4f, 0x30, 0x0e, 0x1c, 0x4c, 0x3f, 0x57, + /*4fa0:*/ 0xea, 0xd2, 0x9a, 0x00, 0x2d, 0x05, 0xfa, 0x0d, 0xcd, 0x2a, 0x6b, 0x7b, 0x12, 0xae, 0xe5, 0xe2, + /*4fb0:*/ 0xb0, 0xa1, 0x3c, 0xfc, 0xcb, 0x41, 0x00, 0x4c, 0x79, 0xbd, 0x02, 0x47, 0x36, 0x1b, 0x2a, 0xbc, + /*4fc0:*/ 0x46, 0x3a, 0x29, 0x68, 0x4b, 0x41, 0x5f, 0x47, 0x2b, 0xdb, 0x4c, 0x0d, 0xba, 0x7d, 0x3e, 0xd8, + /*4fd0:*/ 0x9a, 0x74, 0x62, 0x3d, 0x5d, 0x29, 0xec, 0x52, 0x65, 0x65, 0xdb, 0x95, 0xa5, 0x52, 0xff, 0xbb, + /*4fe0:*/ 0xef, 0xdb, 0xe9, 0xe4, 0xef, 0xb8, 0x0f, 0x94, 0x84, 0xab, 0xcb, 0x2e, 0x3c, 0x07, 0xee, 0xc1, + /*4ff0:*/ 0x26, 0xa5, 0xcd, 0xc4, 0x8f, 0xd7, 0x4c, 0xb5, 0x8c, 0xa8, 0x82, 0xbb, 0xda, 0xfe, 0x18, 0x25, + /*5000:*/ 0x0a, 0x5a, 0x1c, 0x02, 0x5a, 0x84, 0xa7, 0x1e, 0xdb, 0x8a, 0xc3, 0x97, 0xf0, 0x3a, 0x82, 0x06, + /*5010:*/ 0x08, 0x55, 0x93, 0x72, 0x66, 0xec, 0xac, 0x86, 0x3a, 0xb4, 0x27, 0xf4, 0x9d, 0x91, 0x96, 0xe8, + /*5020:*/ 0x6c, 0x06, 0x6c, 0xc0, 0xe4, 0x18, 0x1c, 0x54, 0x72, 0x2e, 0x4c, 0x56, 0xb6, 0x15, 0xe0, 0x72, + /*5030:*/ 0x66, 0xf0, 0xb0, 0xde, 0x53, 0x32, 0x30, 0x6c, 0xe4, 0x3f, 0x6e, 0x6e, 0x6a, 0xa3, 0xc5, 0x30, + /*5040:*/ 0xc8, 0xba, 0x71, 0x11, 0x9c, 0x57, 0x34, 0xb4, 0x92, 0x7d, 0x19, 0x3c, 0xcd, 0x9d, 0x22, 0xa2, + /*5050:*/ 0xf9, 0xdb, 0x99, 0x73, 0xfe, 0xcc, 0x10, 0x2d, 0xdf, 0x96, 0xf6, 0x8b, 0xce, 0x74, 0x91, 0xcb, + /*5060:*/ 0xd8, 0x50, 0x6b, 0x9d, 0x56, 0xec, 0x53, 0x7e, 0x5b, 0xaa, 0x7b, 0xa3, 0x9b, 0xaf, 0xa5, 0x7e, + /*5070:*/ 0xa4, 0xfa, 0x10, 0xdb, 0x73, 0x6e, 0xba, 0x66, 0x66, 0x17, 0xd5, 0x60, 0xa7, 0x9c, 0x4b, 0xdf, + /*5080:*/ 0xa7, 0x5e, 0x45, 0xfe, 0x5f, 0xbe, 0xf1, 0xd2, 0x63, 0x1a, 0x4d, 0x26, 0x22, 0x6e, 0x03, 0xe0, + /*5090:*/ 0x45, 0x89, 0x30, 0x41, 0x43, 0xad, 0x2b, 0xad, 0xf4, 0x0e, 0x0f, 0xa5, 0x33, 0xfc, 0x49, 0x30, + /*50a0:*/ 0x44, 0xf5, 0xc5, 0x8e, 0xe2, 0xa6, 0x32, 0x4b, 0x0c, 0xd5, 0x4d, 0x91, 0xe3, 0x48, 0xe2, 0xb7, + /*50b0:*/ 0xad, 0x24, 0xfb, 0xf9, 0x13, 0xe0, 0x3c, 0x8a, 0x03, 0xc6, 0x35, 0xbc, 0xd6, 0x6e, 0x03, 0x20, + /*50c0:*/ 0xda, 0x2b, 0x95, 0x22, 0x23, 0x55, 0xab, 0x79, 0x58, 0xd0, 0x55, 0x1a, 0x4d, 0xa4, 0xfd, 0x6e, + /*50d0:*/ 0x6b, 0x99, 0xc1, 0xf0, 0xba, 0x5d, 0x51, 0xfe, 0x59, 0xc3, 0x52, 0x19, 0x1b, 0x33, 0x89, 0x60, + /*50e0:*/ 0x07, 0xaf, 0x23, 0xd1, 0x01, 0xcd, 0xc9, 0xfa, 0x58, 0xa6, 0x7d, 0xec, 0x3e, 0x19, 0xc6, 0xc0, + /*50f0:*/ 0xa9, 0x5e, 0x9a, 0xb1, 0xe8, 0x58, 0xcb, 0x05, 0x36, 0x11, 0x98, 0xa3, 0x35, 0x32, 0x87, 0x44, + /*5100:*/ 0x5f, 0x6b, 0xdf, 0x09, 0x15, 0x42, 0xd7, 0xe9, 0x72, 0x56, 0x3f, 0x6b, 0x19, 0x08, 0x46, 0xf0, + /*5110:*/ 0x25, 0x77, 0x96, 0x04, 0x0f, 0x99, 0x4e, 0xa9, 0xbb, 0x7d, 0xad, 0x19, 0x6b, 0x2e, 0x42, 0x41, + /*5120:*/ 0xbc, 0xd2, 0xf0, 0x4b, 0xc6, 0xc5, 0x72, 0xa1, 0x39, 0x22, 0x56, 0x9b, 0x72, 0x34, 0x01, 0x3b, + /*5130:*/ 0x70, 0x33, 0x0f, 0xa3, 0x80, 0xf3, 0x9b, 0xcf, 0x4c, 0x22, 0xb5, 0xce, 0xd7, 0xe1, 0xdd, 0xa9, + /*5140:*/ 0xa0, 0x04, 0x87, 0xd0, 0xe2, 0x76, 0xed, 0xb6, 0x17, 0xb5, 0xf8, 0x20, 0x4c, 0xb2, 0x1c, 0x25, + /*5150:*/ 0x8b, 0x7e, 0x10, 0x65, 0xe3, 0xaa, 0x9b, 0x58, 0xfe, 0x41, 0x68, 0x9b, 0x2e, 0x02, 0x93, 0x86, + /*5160:*/ 0xab, 0xba, 0xb2, 0x70, 0xed, 0x13, 0x21, 0x94, 0xc7, 0x4f, 0xac, 0xb3, 0x77, 0xbb, 0xf1, 0x62, + /*5170:*/ 0x08, 0xfd, 0xe6, 0x53, 0xa0, 0x03, 0xc7, 0xbb, 0xcc, 0xf8, 0x90, 0x93, 0x2d, 0xc7, 0xee, 0xf8, + /*5180:*/ 0xf5, 0x08, 0xf8, 0x70, 0x2b, 0xc7, 0x29, 0x49, 0xc6, 0xc1, 0xbe, 0xc9, 0x48, 0x4b, 0xb4, 0x87, + /*5190:*/ 0xa3, 0xcb, 0x24, 0x88, 0x5f, 0xd7, 0xc0, 0x28, 0x2e, 0x13, 0x12, 0x6c, 0xf5, 0x00, 0x09, 0x12, + /*51a0:*/ 0x59, 0x8d, 0x38, 0x6c, 0xb7, 0x33, 0xda, 0x11, 0x66, 0x06, 0xd5, 0x11, 0x99, 0x1f, 0x3f, 0x44, + /*51b0:*/ 0xf1, 0x5e, 0x58, 0x7f, 0x30, 0xaf, 0x73, 0x8d, 0x24, 0x01, 0x5c, 0x1d, 0x02, 0x4a, 0x15, 0xd9, + /*51c0:*/ 0x8c, 0x6e, 0x12, 0xe6, 0x54, 0x73, 0xe9, 0x62, 0x31, 0xf9, 0x8e, 0x3c, 0x00, 0xff, 0x80, 0x48, + /*51d0:*/ 0xb9, 0x24, 0x18, 0x2f, 0xa7, 0xd8, 0x07, 0xd0, 0x84, 0x64, 0xe6, 0xad, 0x9d, 0xe9, 0xa7, 0xd8, + /*51e0:*/ 0x3c, 0xaa, 0x59, 0x19, 0x5a, 0x29, 0x61, 0xf8, 0x39, 0xcb, 0x16, 0x63, 0x9e, 0x6a, 0xc8, 0xcd, + /*51f0:*/ 0x5d, 0x4f, 0x97, 0x8c, 0xe3, 0xf1, 0x9a, 0xa0, 0x33, 0x24, 0x7c, 0x15, 0x65, 0x95, 0xb3, 0x09, + /*5200:*/ 0xaf, 0x2f, 0x11, 0x6c, 0xac, 0xea, 0x75, 0x33, 0x4b, 0x5a, 0xf3, 0x9f, 0x38, 0xa4, 0x60, 0xd8, + /*5210:*/ 0x0c, 0xff, 0x92, 0x97, 0x35, 0x63, 0xbe, 0x2f, 0x44, 0xa5, 0xc6, 0x4d, 0x61, 0x3e, 0xc5, 0xad, + /*5220:*/ 0xc6, 0x9b, 0x41, 0x02, 0x0c, 0x9d, 0x1e, 0xc5, 0xb1, 0x21, 0x0e, 0xd3, 0x44, 0xd8, 0x36, 0x49, + /*5230:*/ 0x73, 0x20, 0x23, 0xbc, 0x97, 0x99, 0xf0, 0xc2, 0x6f, 0x2c, 0x10, 0x69, 0x9d, 0xfe, 0x4d, 0x85, + /*5240:*/ 0xf7, 0xd6, 0x86, 0x87, 0x05, 0x42, 0x8d, 0xcb, 0xc7, 0x9f, 0xbd, 0x28, 0x0b, 0xdd, 0x8c, 0xe0, + /*5250:*/ 0x60, 0x61, 0x77, 0xb5, 0xca, 0x50, 0x33, 0x3d, 0xd4, 0x82, 0x51, 0x8d, 0x5b, 0x14, 0x28, 0x98, + /*5260:*/ 0x88, 0x90, 0x34, 0x1e, 0x77, 0xf6, 0x7f, 0xc2, 0x00, 0xf8, 0x55, 0x6d, 0xf9, 0xce, 0xb0, 0x3a, + /*5270:*/ 0xec, 0xe5, 0x5f, 0x8b, 0x2b, 0x12, 0x5c, 0x9b, 0x01, 0x33, 0xa6, 0x9b, 0x8b, 0xb1, 0x6a, 0x8d, + /*5280:*/ 0x70, 0xb2, 0x9e, 0x07, 0x27, 0x5a, 0x40, 0x5d, 0xba, 0x7f, 0x8b, 0x4c, 0x99, 0x49, 0x6e, 0x31, + /*5290:*/ 0x1e, 0xe4, 0x7e, 0x4a, 0x5d, 0xc3, 0xd1, 0x04, 0x0a, 0x7a, 0xab, 0x6a, 0x3c, 0x38, 0xa7, 0x7f, + /*52a0:*/ 0xd0, 0xcd, 0x06, 0x6a, 0x81, 0x37, 0x28, 0x25, 0xe9, 0xd2, 0xe6, 0x79, 0x1c, 0x43, 0x36, 0x80, + /*52b0:*/ 0x2b, 0x1d, 0xee, 0xd4, 0x4b, 0x7a, 0x5f, 0x9a, 0x7c, 0x38, 0xc1, 0x08, 0xa9, 0x17, 0x18, 0xd2, + /*52c0:*/ 0x6c, 0x78, 0xf0, 0xaa, 0xb4, 0x62, 0x38, 0x96, 0x6e, 0x96, 0x7b, 0x21, 0xc3, 0x21, 0x9b, 0xb2, + /*52d0:*/ 0x70, 0x5d, 0x7b, 0x2f, 0xb1, 0xc6, 0x96, 0x1a, 0xe0, 0xd7, 0x76, 0x6a, 0x6f, 0x4b, 0x23, 0x38, + /*52e0:*/ 0x9b, 0xc7, 0xac, 0xbf, 0x44, 0x01, 0x0f, 0xb6, 0x66, 0x97, 0xa5, 0xc6, 0xf8, 0xc2, 0xfa, 0x3b, + /*52f0:*/ 0x78, 0x48, 0xd1, 0xac, 0xe8, 0x47, 0xd0, 0x0e, 0x80, 0x0c, 0x52, 0xf0, 0xd4, 0x04, 0x4a, 0xd7, + /*5300:*/ 0x60, 0x49, 0xe5, 0x78, 0xe6, 0xc6, 0x91, 0xbc, 0x67, 0x12, 0x9a, 0x14, 0x39, 0x3a, 0xd5, 0x3a, + /*5310:*/ 0xa4, 0x2c, 0xfc, 0x1c, 0x30, 0x99, 0xdd, 0xf2, 0xba, 0xe6, 0xfa, 0xe3, 0x1d, 0xd9, 0xae, 0x64, + /*5320:*/ 0x11, 0x87, 0x92, 0x51, 0xc9, 0x61, 0x50, 0xb0, 0x82, 0x6d, 0x0b, 0x43, 0x8b, 0xf6, 0xae, 0x8e, + /*5330:*/ 0x83, 0x7d, 0x00, 0xfc, 0xd9, 0xf5, 0x4b, 0x14, 0x36, 0xf1, 0x4a, 0xea, 0x33, 0x92, 0x8c, 0x16, + /*5340:*/ 0x91, 0xb9, 0xf0, 0x44, 0xa2, 0x31, 0xed, 0x0e, 0x6b, 0x45, 0xb3, 0xe2, 0x47, 0xab, 0xc6, 0x70, + /*5350:*/ 0xf8, 0x84, 0xe8, 0xa4, 0x41, 0x9f, 0x32, 0xd5, 0x61, 0x6b, 0x81, 0x38, 0x34, 0x5b, 0x88, 0xf2, + /*5360:*/ 0x82, 0xae, 0x6c, 0x5e, 0xa0, 0x6f, 0xb1, 0x93, 0xaf, 0x6b, 0x04, 0xbe, 0xd5, 0xcb, 0xae, 0xac, + /*5370:*/ 0xd0, 0x09, 0x2a, 0x7d, 0x9f, 0xa6, 0xa9, 0xa2, 0x46, 0x61, 0x82, 0xaa, 0x95, 0x9c, 0xf1, 0x36, + /*5380:*/ 0x57, 0xb5, 0xcf, 0x5a, 0x00, 0x43, 0xac, 0x5c, 0xb4, 0xd9, 0xe2, 0x08, 0x03, 0x5c, 0x88, 0xc4, + /*5390:*/ 0xab, 0x50, 0xa6, 0x72, 0xae, 0xe0, 0x56, 0xba, 0x93, 0x9a, 0x87, 0x20, 0xe1, 0x08, 0x55, 0x2c, + /*53a0:*/ 0xeb, 0xff, 0xfd, 0xc6, 0x31, 0xc0, 0xb2, 0xce, 0x62, 0xe4, 0x8b, 0x31, 0xc3, 0xa9, 0x70, 0xed, + /*53b0:*/ 0x0f, 0x98, 0x04, 0x70, 0x07, 0xa3, 0x17, 0xc5, 0xb6, 0x15, 0x02, 0x2b, 0x62, 0x68, 0xb9, 0x18, + /*53c0:*/ 0xa4, 0x88, 0xf8, 0xad, 0x61, 0x63, 0x9d, 0x4f, 0x71, 0xd5, 0xbc, 0x32, 0x86, 0xa9, 0x2b, 0x6b, + /*53d0:*/ 0xdf, 0x2d, 0x0d, 0x4b, 0x6f, 0x65, 0xe4, 0x57, 0xae, 0x76, 0xac, 0x48, 0xeb, 0xa8, 0x12, 0xc5, + /*53e0:*/ 0x30, 0x93, 0x12, 0xfb, 0x85, 0xa9, 0x76, 0xe4, 0xca, 0x36, 0xbc, 0xb4, 0xd4, 0xa5, 0x6f, 0x3c, + /*53f0:*/ 0x77, 0x16, 0x05, 0x00, 0x3f, 0xd3, 0x0b, 0x93, 0x3e, 0xf0, 0xdd, 0xa3, 0xd9, 0xba, 0xfd, 0x6d, + /*5400:*/ 0x6e, 0x91, 0x64, 0x41, 0xa0, 0x40, 0xd7, 0x1a, 0x25, 0x33, 0xb8, 0x35, 0x50, 0x56, 0xa6, 0xf1, + /*5410:*/ 0x18, 0x19, 0x98, 0x5e, 0x74, 0x4b, 0xb0, 0xc0, 0xf2, 0xbb, 0x5b, 0x06, 0x1c, 0xc7, 0x35, 0x3b, + /*5420:*/ 0x3f, 0x00, 0x58, 0x20, 0x4a, 0x52, 0x25, 0xd2, 0x10, 0x79, 0x3b, 0x78, 0xd3, 0x6b, 0x39, 0x5c, + /*5430:*/ 0xf3, 0x22, 0xde, 0xb8, 0xd6, 0x8b, 0xe9, 0x2c, 0x03, 0x55, 0xd4, 0x82, 0x66, 0x33, 0x6e, 0xa1, + /*5440:*/ 0x68, 0xd8, 0x63, 0x1f, 0xda, 0xf8, 0x14, 0x4c, 0xfd, 0x78, 0x70, 0x3e, 0xdf, 0xdb, 0x83, 0x99, + /*5450:*/ 0x94, 0x61, 0xa5, 0x86, 0x64, 0xae, 0x9c, 0xfe, 0x33, 0xc7, 0x20, 0x04, 0x5a, 0xbe, 0xd4, 0x74, + /*5460:*/ 0xef, 0x19, 0x39, 0xf8, 0xf9, 0xff, 0xcc, 0x96, 0x3a, 0xb6, 0x1c, 0x54, 0xd8, 0xd7, 0xcb, 0xf6, + /*5470:*/ 0xd7, 0x97, 0x51, 0xd2, 0xd8, 0x86, 0x8e, 0x04, 0x5f, 0xc6, 0x5c, 0x3e, 0x71, 0x87, 0xa6, 0x50, + /*5480:*/ 0xeb, 0x41, 0x45, 0x45, 0xba, 0x0f, 0x67, 0x32, 0x44, 0x64, 0xbf, 0xde, 0xbc, 0x4c, 0x11, 0xfe, + /*5490:*/ 0xc2, 0x24, 0xe2, 0xf3, 0x30, 0xb2, 0x87, 0xa1, 0x62, 0xf6, 0xa0, 0x7d, 0xf7, 0xd9, 0x68, 0x83, + /*54a0:*/ 0x7a, 0x1b, 0x00, 0x0d, 0x01, 0xd8, 0xc0, 0xa6, 0x99, 0x2a, 0x95, 0x44, 0x5f, 0xda, 0xf6, 0xc3, + /*54b0:*/ 0xa0, 0x30, 0x0b, 0x1d, 0x88, 0xb4, 0xae, 0xc7, 0x2b, 0xae, 0x06, 0x2a, 0xb1, 0x72, 0x64, 0xec, + /*54c0:*/ 0x0b, 0xdc, 0xc6, 0xba, 0x92, 0xa6, 0xb9, 0x6e, 0x4f, 0x69, 0x12, 0x99, 0xb5, 0x00, 0xcf, 0x8d, + /*54d0:*/ 0x8e, 0x0b, 0x94, 0x75, 0xf2, 0x89, 0xb4, 0x35, 0x48, 0x9d, 0x7f, 0x76, 0x15, 0xb9, 0x92, 0x0b, + /*54e0:*/ 0x82, 0xba, 0x88, 0x8a, 0xff, 0x21, 0x3b, 0xd8, 0x53, 0x02, 0x78, 0x6a, 0x2a, 0x7c, 0x34, 0xb5, + /*54f0:*/ 0xfc, 0xc7, 0xb8, 0x99, 0xe0, 0xed, 0xb8, 0x52, 0xce, 0xc8, 0x68, 0x5e, 0x67, 0x2a, 0x7a, 0x4b, + /*5500:*/ 0x75, 0x78, 0x0f, 0x9d, 0xbe, 0x0e, 0x4c, 0xde, 0x5a, 0x1b, 0xc2, 0x36, 0xf3, 0xe4, 0x8a, 0xfd, + /*5510:*/ 0xf3, 0x72, 0x42, 0x38, 0xac, 0xd3, 0xc4, 0xaa, 0x16, 0xfa, 0x60, 0x8b, 0x4e, 0xd5, 0x87, 0x34, + /*5520:*/ 0x78, 0x01, 0x8b, 0x3b, 0x48, 0x1e, 0x57, 0x46, 0x59, 0x2d, 0x6c, 0xda, 0x80, 0xb2, 0x4b, 0x9c, + /*5530:*/ 0x77, 0xa2, 0x1c, 0xc0, 0x70, 0x63, 0xc1, 0x0e, 0x30, 0xf1, 0x26, 0xd1, 0xdd, 0x75, 0xf8, 0x3f, + /*5540:*/ 0x2c, 0xeb, 0x9d, 0xdf, 0xbc, 0x74, 0xff, 0x46, 0x6e, 0xbc, 0x7f, 0x9b, 0x41, 0xce, 0x20, 0xb0, + /*5550:*/ 0xb7, 0xff, 0x99, 0xc3, 0x13, 0x7c, 0xf6, 0x4b, 0xb3, 0x35, 0x37, 0xaa, 0xf2, 0x9a, 0xad, 0x67, + /*5560:*/ 0x81, 0xe0, 0x9d, 0xa6, 0x4f, 0x48, 0x68, 0xc2, 0x22, 0xaf, 0xf8, 0xdf, 0xf9, 0x2f, 0x08, 0x84, + /*5570:*/ 0x2c, 0xcb, 0xc4, 0x86, 0xe2, 0x5a, 0x38, 0x94, 0x45, 0x4d, 0xd7, 0x30, 0x97, 0x5a, 0xd4, 0x60, + /*5580:*/ 0x3b, 0x20, 0xb5, 0xf8, 0x39, 0x8c, 0x1a, 0x60, 0x05, 0xbb, 0x9e, 0x61, 0x8c, 0x56, 0x96, 0x39, + /*5590:*/ 0xe4, 0x78, 0x10, 0x07, 0x14, 0xb3, 0xbe, 0x0d, 0x24, 0x58, 0x78, 0xa8, 0x79, 0x29, 0xf0, 0xcc, + /*55a0:*/ 0x12, 0x4b, 0x5a, 0x9a, 0xa4, 0x4b, 0xa8, 0x37, 0x5e, 0xc3, 0x1b, 0x13, 0x77, 0x24, 0x09, 0x29, + /*55b0:*/ 0xcc, 0xf9, 0x05, 0xd7, 0x20, 0xe9, 0x16, 0xd5, 0xb0, 0x4d, 0x61, 0x44, 0xd7, 0x29, 0x9b, 0xd7, + /*55c0:*/ 0x6c, 0xaa, 0x82, 0xc9, 0x6e, 0x3a, 0x07, 0x8b, 0x9c, 0xef, 0x6a, 0xc0, 0x91, 0x11, 0x4b, 0x2d, + /*55d0:*/ 0x26, 0xd7, 0x3b, 0x11, 0x88, 0x4d, 0x6f, 0xf4, 0xad, 0xf3, 0xde, 0xdb, 0xa5, 0xb9, 0x7b, 0x64, + /*55e0:*/ 0x60, 0x7b, 0xd8, 0xf2, 0xd3, 0xa3, 0x64, 0x1a, 0x56, 0xc9, 0x5e, 0x6a, 0x86, 0xbd, 0x28, 0xea, + /*55f0:*/ 0x31, 0x28, 0x15, 0x84, 0x5c, 0xe5, 0x0a, 0x89, 0x54, 0x69, 0x14, 0x5b, 0xca, 0x24, 0x56, 0xc2, + /*5600:*/ 0x71, 0x96, 0xdf, 0x31, 0x9b, 0x72, 0x9f, 0xb3, 0xce, 0xd4, 0x87, 0xf6, 0x6f, 0x32, 0x89, 0x72, + /*5610:*/ 0x82, 0x7c, 0x59, 0x5c, 0x57, 0xfa, 0x01, 0x89, 0xd2, 0x2d, 0x45, 0xe3, 0x53, 0x62, 0xc9, 0x40, + /*5620:*/ 0x73, 0xa0, 0xcd, 0x96, 0xe1, 0xe5, 0x42, 0xed, 0x1a, 0x51, 0xb2, 0xb6, 0xc3, 0x18, 0xed, 0xd1, + /*5630:*/ 0x1f, 0x07, 0x69, 0x66, 0xbd, 0x27, 0x78, 0x6e, 0xd9, 0xf0, 0xe5, 0x37, 0x75, 0xbd, 0x67, 0xcf, + /*5640:*/ 0x62, 0x4e, 0xd2, 0xb1, 0xfa, 0xa9, 0x0c, 0x4a, 0xd3, 0x96, 0x96, 0x0f, 0xcd, 0x9b, 0x80, 0x1a, + /*5650:*/ 0x3b, 0x4a, 0x99, 0xdb, 0xd4, 0x16, 0x02, 0x62, 0x15, 0x97, 0xfa, 0xac, 0xd2, 0x04, 0x0b, 0xd5, + /*5660:*/ 0x7b, 0x20, 0x1d, 0xf3, 0x9c, 0xed, 0x32, 0x9b, 0x90, 0x2d, 0x95, 0xb1, 0x7e, 0x2c, 0xf8, 0x27, + /*5670:*/ 0x2c, 0x06, 0x8b, 0x23, 0x93, 0xc5, 0xa2, 0x0d, 0x94, 0xfc, 0xfd, 0x56, 0xe1, 0xe6, 0xa9, 0x81, + /*5680:*/ 0xe2, 0x48, 0x53, 0xee, 0x6d, 0xe9, 0x44, 0x92, 0x1b, 0x73, 0x16, 0xd6, 0x99, 0x12, 0xa4, 0x6a, + /*5690:*/ 0xa1, 0xfc, 0x8b, 0x1a, 0xf0, 0xb4, 0x1c, 0x67, 0xd4, 0x83, 0x65, 0x69, 0x9c, 0x64, 0xb1, 0x9e, + /*56a0:*/ 0x0b, 0x74, 0xbb, 0x0f, 0xa8, 0x7d, 0xb9, 0x39, 0x3b, 0x2c, 0x89, 0xcf, 0x70, 0x74, 0x27, 0xcf, + /*56b0:*/ 0x4a, 0xdd, 0x8a, 0xe5, 0x05, 0x46, 0x6d, 0x84, 0xba, 0x1d, 0x70, 0x78, 0x5a, 0x6f, 0x9a, 0xf1, + /*56c0:*/ 0xb4, 0xf8, 0x11, 0x7b, 0x39, 0xe7, 0x03, 0x67, 0x58, 0x6b, 0x64, 0x8c, 0x8d, 0xa3, 0xd2, 0x7d, + /*56d0:*/ 0xf4, 0x35, 0x4e, 0x48, 0x61, 0xc8, 0xaa, 0x57, 0xb9, 0xf5, 0xcd, 0x9c, 0xaa, 0x38, 0x78, 0x17, + /*56e0:*/ 0xaf, 0x59, 0x11, 0x2b, 0xfa, 0x49, 0x6c, 0xf3, 0xdf, 0x53, 0xb0, 0xb5, 0x3d, 0x1e, 0x37, 0x7e, + /*56f0:*/ 0x11, 0x2c, 0x56, 0xfa, 0xc7, 0x77, 0x6d, 0x6c, 0xd8, 0xd6, 0x12, 0x41, 0x12, 0xa2, 0x02, 0x06, + /*5700:*/ 0xcd, 0x5d, 0x75, 0xba, 0x86, 0xe5, 0xe5, 0x27, 0xdf, 0x8c, 0xd0, 0x06, 0xeb, 0x41, 0xbe, 0x8d, + /*5710:*/ 0xe1, 0xa2, 0x90, 0x8f, 0x4b, 0xbf, 0x76, 0x03, 0x75, 0x33, 0x29, 0x1a, 0x80, 0x57, 0xd6, 0x67, + /*5720:*/ 0x01, 0x72, 0xc1, 0x5a, 0xea, 0xd3, 0xbe, 0xb1, 0xac, 0x6c, 0x13, 0xc5, 0xc2, 0x72, 0x7d, 0x22, + /*5730:*/ 0xb0, 0xa2, 0xab, 0xf6, 0x52, 0x78, 0x37, 0xcf, 0x38, 0x1e, 0x13, 0xb9, 0xee, 0x71, 0x5a, 0xc4, + /*5740:*/ 0xfc, 0x6a, 0x11, 0xe1, 0xd6, 0x6e, 0x01, 0x32, 0x5a, 0x51, 0x35, 0x39, 0x59, 0x30, 0xc5, 0x15, + /*5750:*/ 0x87, 0x52, 0x63, 0xe8, 0x07, 0x39, 0xd8, 0xf0, 0x85, 0xf5, 0x7c, 0x31, 0x6d, 0xbf, 0x24, 0x27, + /*5760:*/ 0xf7, 0x66, 0xca, 0x6a, 0x81, 0xc8, 0x38, 0x02, 0x07, 0x20, 0x49, 0x2e, 0x9e, 0xe6, 0xe9, 0x5e, + /*5770:*/ 0x64, 0x81, 0xed, 0xea, 0xf9, 0x87, 0x53, 0xed, 0x06, 0xe0, 0x27, 0xba, 0x29, 0x0b, 0x00, 0xa0, + /*5780:*/ 0x2c, 0xbf, 0xee, 0x37, 0x44, 0x63, 0xa0, 0xf4, 0xe3, 0x9a, 0xc5, 0xba, 0x6f, 0x50, 0x1c, 0x72, + /*5790:*/ 0x14, 0x89, 0x3c, 0x14, 0xc4, 0xf7, 0x8c, 0x4d, 0x7d, 0x2a, 0xa2, 0xb4, 0x94, 0xfe, 0xfd, 0xce, + /*57a0:*/ 0xcf, 0x07, 0x71, 0x33, 0xe0, 0x46, 0xe0, 0x03, 0x94, 0x42, 0x9d, 0x55, 0x69, 0x2c, 0x3d, 0x74, + /*57b0:*/ 0x6b, 0x74, 0x52, 0x49, 0x34, 0x9c, 0x51, 0xc0, 0x19, 0x0c, 0x5e, 0x74, 0x76, 0xc2, 0x4a, 0x0a, + /*57c0:*/ 0x14, 0x88, 0x4e, 0x2a, 0xa5, 0x9a, 0x9e, 0xc3, 0x99, 0x72, 0x5e, 0xef, 0x9c, 0x94, 0xac, 0xa7, + /*57d0:*/ 0x61, 0x78, 0xc2, 0x36, 0x17, 0x82, 0x2d, 0xce, 0x7d, 0x92, 0xd0, 0x8a, 0x3b, 0x3e, 0x1f, 0x1d, + /*57e0:*/ 0x83, 0xf9, 0xa8, 0x44, 0xdf, 0xce, 0x84, 0x31, 0xdc, 0xf2, 0xd6, 0x0d, 0xb9, 0x0b, 0x89, 0xc5, + /*57f0:*/ 0x77, 0xae, 0xa1, 0x9a, 0x75, 0xc6, 0x93, 0x6e, 0xdb, 0x61, 0xdd, 0x3d, 0x8e, 0x7c, 0x4b, 0x53, + /*5800:*/ 0x14, 0x1d, 0x3c, 0x51, 0x5f, 0x60, 0xfe, 0x6a, 0x1d, 0xef, 0x49, 0x30, 0x03, 0xf3, 0xb2, 0x7c, + /*5810:*/ 0xf5, 0x1c, 0x88, 0x68, 0xf4, 0xb8, 0xf5, 0x36, 0x4f, 0x17, 0x11, 0x39, 0x44, 0xfc, 0xaa, 0xe2, + /*5820:*/ 0x51, 0x20, 0x77, 0xc7, 0xe0, 0xf4, 0x6e, 0x8c, 0xa5, 0x77, 0xc7, 0x66, 0x2c, 0x24, 0xb1, 0xae, + /*5830:*/ 0xc1, 0xbd, 0x1a, 0x64, 0x1c, 0x1e, 0xa3, 0xbb, 0x52, 0xb3, 0x53, 0x1a, 0x5e, 0x94, 0xd6, 0x10, + /*5840:*/ 0xd4, 0x17, 0x6e, 0x36, 0xe8, 0x09, 0x6a, 0x0f, 0x67, 0x73, 0x40, 0xb8, 0xcf, 0xdd, 0xc0, 0xac, + /*5850:*/ 0x3a, 0xfd, 0x08, 0xcd, 0xd2, 0x42, 0xc0, 0xb0, 0x4e, 0xc3, 0xca, 0x66, 0x2b, 0x84, 0x19, 0x6f, + /*5860:*/ 0x2e, 0xf2, 0x22, 0x21, 0x56, 0xb7, 0x17, 0xbe, 0x47, 0xc2, 0x96, 0x6e, 0x60, 0xf2, 0xc7, 0x1f, + /*5870:*/ 0x9b, 0xb5, 0x82, 0xea, 0x02, 0x46, 0x4e, 0x04, 0xca, 0x64, 0xa1, 0x70, 0xd6, 0xd0, 0xd7, 0x3d, + /*5880:*/ 0x15, 0x42, 0x68, 0x17, 0xfd, 0x7f, 0x7f, 0x9a, 0x12, 0x1b, 0xcc, 0x7a, 0x59, 0x85, 0x5e, 0xfd, + /*5890:*/ 0x74, 0x55, 0x8b, 0xc9, 0x55, 0xf7, 0x44, 0x64, 0xa8, 0xff, 0xd3, 0xb5, 0x32, 0x2e, 0xb1, 0x3a, + /*58a0:*/ 0x36, 0xe2, 0x4d, 0x18, 0x35, 0x37, 0x5c, 0x5b, 0x8d, 0x9b, 0x51, 0x51, 0x39, 0xb2, 0xbe, 0x5a, + /*58b0:*/ 0xaf, 0xf6, 0xa4, 0x35, 0xc5, 0x62, 0x26, 0x9e, 0x60, 0xa8, 0xad, 0x12, 0x89, 0xef, 0x23, 0x9a, + /*58c0:*/ 0x54, 0x74, 0xa6, 0x07, 0x40, 0xab, 0x97, 0xf4, 0xcc, 0xa9, 0x37, 0xd2, 0x43, 0xda, 0x9b, 0xdb, + /*58d0:*/ 0x07, 0x3c, 0x6f, 0x33, 0x64, 0x6b, 0xfd, 0xa7, 0x72, 0x5c, 0x61, 0xce, 0xe7, 0x2a, 0x21, 0x96, + /*58e0:*/ 0xac, 0xb4, 0x04, 0x2d, 0x0b, 0x8b, 0x6d, 0xa8, 0xbd, 0x48, 0xab, 0xcd, 0xc9, 0x1f, 0x12, 0xf3, + /*58f0:*/ 0xb6, 0x83, 0xec, 0xa2, 0x89, 0x8b, 0x89, 0x35, 0x62, 0x10, 0x5e, 0xc8, 0x28, 0xcc, 0x2f, 0xfb, + /*5900:*/ 0x85, 0xb4, 0x9a, 0xab, 0x51, 0x1a, 0x78, 0x84, 0x42, 0xec, 0x99, 0xad, 0x5b, 0x53, 0x24, 0x39, + /*5910:*/ 0x68, 0x4c, 0xdb, 0xef, 0xab, 0x5c, 0x89, 0xfa, 0x6f, 0xf7, 0x23, 0x6c, 0x42, 0x7d, 0xbf, 0xe9, + /*5920:*/ 0x29, 0x96, 0x1f, 0x47, 0x39, 0x86, 0x02, 0x36, 0x5a, 0x1a, 0x98, 0xe4, 0x1a, 0x7b, 0x03, 0x3b, + /*5930:*/ 0x6c, 0x5f, 0x41, 0x61, 0x20, 0x26, 0xe2, 0xf2, 0x26, 0x8a, 0xf7, 0x50, 0xe4, 0x50, 0xd2, 0x64, + /*5940:*/ 0xea, 0xec, 0xf5, 0x37, 0xea, 0xf7, 0x68, 0x8b, 0x31, 0x24, 0xc8, 0x78, 0x96, 0x2d, 0xc6, 0x9b, + /*5950:*/ 0x46, 0xa1, 0x9a, 0xe2, 0xdc, 0xbb, 0x26, 0x14, 0xd8, 0x7e, 0x78, 0xb9, 0x60, 0x1d, 0xc4, 0x4b, + /*5960:*/ 0x66, 0xad, 0x2d, 0x11, 0x40, 0x70, 0xcd, 0x41, 0xb5, 0xb5, 0x8d, 0xe1, 0xc2, 0x44, 0x6a, 0xcf, + /*5970:*/ 0x87, 0x28, 0xa8, 0x8a, 0xc6, 0x9b, 0xb4, 0xd8, 0x14, 0xae, 0x0e, 0xae, 0x4e, 0xde, 0x7f, 0xf1, + /*5980:*/ 0x79, 0xec, 0x9c, 0xed, 0x96, 0x33, 0xfd, 0x40, 0xae, 0xbf, 0x34, 0xa2, 0x9c, 0x5a, 0xf7, 0xcd, + /*5990:*/ 0x4b, 0xab, 0xaa, 0xd2, 0xd5, 0xb2, 0x39, 0xcd, 0x4a, 0x23, 0xc7, 0xb9, 0x82, 0x55, 0xa9, 0x00, + /*59a0:*/ 0xf1, 0x6d, 0x29, 0x99, 0x0d, 0xc6, 0x83, 0x5a, 0x21, 0xaa, 0x09, 0xb6, 0x24, 0x17, 0xd9, 0xbe, + /*59b0:*/ 0x56, 0xd8, 0x23, 0x56, 0x94, 0xe5, 0x72, 0xdd, 0xb3, 0xc7, 0x30, 0x76, 0x66, 0xc8, 0x79, 0xd6, + /*59c0:*/ 0xda, 0xa0, 0x85, 0x20, 0x75, 0xd4, 0x17, 0x65, 0x68, 0xb2, 0x47, 0xe7, 0xae, 0xfc, 0xe8, 0x40, + /*59d0:*/ 0xf0, 0x10, 0x64, 0xa8, 0x56, 0x29, 0x92, 0x4c, 0xe1, 0x8d, 0x80, 0x60, 0x3e, 0x05, 0x3d, 0xaa, + /*59e0:*/ 0x46, 0x9b, 0x4b, 0xa8, 0x80, 0xd7, 0xb0, 0x81, 0xa4, 0x5c, 0xc6, 0x12, 0xef, 0x4b, 0xda, 0x3f, + /*59f0:*/ 0x4b, 0x78, 0xf4, 0x64, 0x17, 0x52, 0xc2, 0xec, 0x4a, 0xc6, 0x44, 0x3b, 0x80, 0xcf, 0xd6, 0xa5, + /*5a00:*/ 0x44, 0xa5, 0x02, 0x3b, 0x05, 0x10, 0xd0, 0x69, 0xdf, 0x7e, 0x27, 0xf0, 0x25, 0x26, 0x09, 0xa8, + /*5a10:*/ 0xa7, 0x38, 0x72, 0xe5, 0x96, 0x62, 0x8a, 0xc7, 0x5e, 0xb1, 0x6a, 0xf6, 0x5a, 0x1a, 0x08, 0x88, + /*5a20:*/ 0xe4, 0x18, 0x42, 0xff, 0x53, 0xbb, 0x93, 0x7c, 0xc5, 0x34, 0x65, 0x29, 0xcc, 0xbe, 0xfa, 0xb2, + /*5a30:*/ 0xec, 0x59, 0x23, 0xd8, 0xb2, 0x31, 0xe4, 0xe1, 0xe1, 0xb7, 0xd9, 0x40, 0xbd, 0xb6, 0x1b, 0x29, + /*5a40:*/ 0xba, 0x10, 0x60, 0x3d, 0x93, 0x68, 0x2f, 0x08, 0x17, 0xf3, 0x43, 0xa8, 0x0c, 0x1e, 0xda, 0x76, + /*5a50:*/ 0x60, 0x8a, 0xb0, 0x2d, 0x44, 0x09, 0x24, 0xf2, 0xca, 0xa8, 0xf5, 0xd4, 0x4e, 0x2a, 0xbd, 0xd7, + /*5a60:*/ 0xed, 0x37, 0x24, 0x20, 0xfa, 0x00, 0x0a, 0x01, 0x4d, 0xc1, 0xfe, 0x71, 0x26, 0x76, 0xf0, 0x2f, + /*5a70:*/ 0x2b, 0xe9, 0xb5, 0xfe, 0xd9, 0x18, 0x96, 0x84, 0x51, 0xc1, 0x39, 0xf3, 0x1a, 0x87, 0x1c, 0xf6, + /*5a80:*/ 0x62, 0xed, 0xcd, 0xa7, 0x7e, 0x57, 0x6d, 0x08, 0xc6, 0x90, 0x6d, 0xe5, 0x6e, 0xee, 0x8f, 0x88, + /*5a90:*/ 0x07, 0x71, 0xab, 0x55, 0x66, 0xfc, 0xf7, 0x0b, 0x90, 0x97, 0xc9, 0xe9, 0xf0, 0xe5, 0x30, 0x9a, + /*5aa0:*/ 0xd0, 0x5a, 0x00, 0x9c, 0x1c, 0x3c, 0x49, 0x2a, 0x3e, 0x72, 0xb8, 0xfe, 0xab, 0x20, 0xc8, 0xf5, + /*5ab0:*/ 0xd7, 0xf9, 0x76, 0xbe, 0x33, 0x45, 0xac, 0x6b, 0x81, 0x50, 0x66, 0x9c, 0x24, 0xa0, 0x47, 0xe0, + /*5ac0:*/ 0xbe, 0x7f, 0xa2, 0x85, 0xb0, 0x8a, 0xfb, 0x42, 0x04, 0xe0, 0xed, 0xd6, 0xfd, 0xcc, 0x59, 0x6f, + /*5ad0:*/ 0xe7, 0x57, 0x63, 0x52, 0x03, 0x75, 0x28, 0x2d, 0x07, 0x7b, 0xe3, 0xf9, 0xfb, 0xa1, 0xef, 0x85, + /*5ae0:*/ 0x51, 0xf0, 0xf8, 0x76, 0x11, 0xa6, 0x80, 0xe4, 0x4b, 0x24, 0xfd, 0x1f, 0xc7, 0x68, 0x05, 0x8f, + /*5af0:*/ 0xd8, 0xdb, 0x52, 0xbd, 0x09, 0x85, 0x75, 0x5e, 0xe1, 0x61, 0x14, 0x60, 0xaf, 0xfd, 0xd2, 0xdf, + /*5b00:*/ 0xa3, 0x80, 0xc9, 0xa2, 0x80, 0x69, 0x47, 0xe9, 0xb7, 0xcd, 0xbb, 0xae, 0x53, 0xbd, 0xa8, 0xf6, + /*5b10:*/ 0x86, 0x88, 0x4c, 0xdb, 0xfc, 0xa7, 0xd1, 0x42, 0xfc, 0xb8, 0x9f, 0xe9, 0xf3, 0x7e, 0xeb, 0x13, + /*5b20:*/ 0x4f, 0xb0, 0xfa, 0xe0, 0x40, 0x42, 0xa6, 0x3b, 0x35, 0xf9, 0x72, 0x2f, 0x21, 0x17, 0x2d, 0xdd, + /*5b30:*/ 0xa2, 0x39, 0xa5, 0x88, 0xb2, 0x9b, 0xdb, 0x65, 0x3b, 0x70, 0x97, 0xb1, 0xe4, 0x4c, 0xda, 0x69, + /*5b40:*/ 0x88, 0x5c, 0xde, 0x5b, 0x89, 0x42, 0xe5, 0x13, 0x29, 0x73, 0x71, 0xe6, 0x37, 0x8a, 0x3e, 0x69, + /*5b50:*/ 0x66, 0xfd, 0xb2, 0x4b, 0x85, 0xa9, 0x29, 0x11, 0xce, 0x9b, 0x5a, 0x77, 0x48, 0xc8, 0x45, 0x19, + /*5b60:*/ 0x22, 0x07, 0x84, 0x91, 0xa0, 0x91, 0x5d, 0x7b, 0xde, 0x37, 0xd5, 0xcf, 0x62, 0x4e, 0x01, 0xd1, + /*5b70:*/ 0x87, 0x1f, 0xf9, 0x2d, 0xe6, 0x35, 0x67, 0x45, 0x69, 0x5a, 0x50, 0xaf, 0xae, 0xa8, 0x5b, 0x62, + /*5b80:*/ 0xbb, 0x03, 0x86, 0x97, 0x7f, 0x84, 0xe2, 0xbf, 0xc3, 0x04, 0x06, 0x1d, 0x08, 0xbc, 0x6d, 0x8e, + /*5b90:*/ 0xb9, 0x7a, 0x0d, 0xf1, 0x6c, 0xc6, 0x25, 0xd2, 0x17, 0x26, 0x05, 0x4c, 0xe3, 0xd6, 0x52, 0x19, + /*5ba0:*/ 0xf3, 0xd0, 0xb1, 0x0b, 0x62, 0x4d, 0x6c, 0x8e, 0xb8, 0x34, 0x1e, 0xd8, 0x0e, 0x88, 0xe2, 0x91, + /*5bb0:*/ 0xa8, 0xf0, 0xdf, 0x13, 0xb7, 0x5e, 0x12, 0xae, 0x21, 0x6b, 0x0c, 0x60, 0xa4, 0x40, 0xee, 0x1d, + /*5bc0:*/ 0x75, 0xfa, 0xd2, 0x0e, 0x21, 0x57, 0x15, 0x87, 0x0c, 0x30, 0x9f, 0x8a, 0x1c, 0xc6, 0xde, 0x93, + /*5bd0:*/ 0xb9, 0xc5, 0x3f, 0x48, 0x81, 0x07, 0xc0, 0xcb, 0x2f, 0xd3, 0x79, 0x60, 0x99, 0xab, 0x22, 0xa2, + /*5be0:*/ 0xcd, 0xc1, 0x6a, 0x6e, 0x87, 0xdf, 0xf9, 0x32, 0xba, 0x53, 0x25, 0xab, 0x0d, 0x3a, 0xcc, 0x31, + /*5bf0:*/ 0x61, 0x0e, 0xa7, 0x16, 0x4b, 0x2e, 0x1d, 0x94, 0xc5, 0x45, 0x80, 0x0c, 0x16, 0x93, 0x7c, 0xfd, + /*5c00:*/ 0x1f, 0xa1, 0x01, 0x20, 0xfb, 0xe3, 0x93, 0x92, 0x81, 0x38, 0x78, 0xd2, 0xda, 0xbd, 0xcd, 0xf0, + /*5c10:*/ 0xe6, 0x55, 0x6e, 0x33, 0x24, 0x06, 0xcb, 0xf1, 0xb3, 0x14, 0x90, 0x28, 0xe4, 0x33, 0xd7, 0xc8, + /*5c20:*/ 0x0d, 0xbb, 0x79, 0xcc, 0xe5, 0x9f, 0xcd, 0x78, 0x99, 0xb4, 0xab, 0xe1, 0x97, 0x30, 0x26, 0x62, + /*5c30:*/ 0xbe, 0x36, 0xfe, 0x00, 0x4d, 0xdf, 0x68, 0x50, 0x67, 0x63, 0xb6, 0xe2, 0x3b, 0xef, 0xbe, 0x2f, + /*5c40:*/ 0xca, 0xa2, 0xec, 0xc8, 0x79, 0x51, 0x56, 0x8c, 0xae, 0x14, 0xf8, 0xfc, 0x3f, 0x5f, 0x94, 0xdd, + /*5c50:*/ 0xb7, 0x0a, 0x1c, 0x79, 0xea, 0x22, 0x73, 0x33, 0x66, 0x7f, 0x4b, 0x0a, 0xb4, 0x51, 0xbd, 0xa7, + /*5c60:*/ 0xed, 0x46, 0x8f, 0xf9, 0x86, 0x65, 0x31, 0xfd, 0xf0, 0xdc, 0x2e, 0xee, 0xcf, 0xa7, 0x13, 0x9f, + /*5c70:*/ 0x07, 0x78, 0xc6, 0xc6, 0x07, 0x7b, 0x51, 0xda, 0x8f, 0x0b, 0xdb, 0xba, 0xd2, 0xde, 0xc6, 0x63, + /*5c80:*/ 0xbe, 0xd5, 0x92, 0xc6, 0xcb, 0xd3, 0xb3, 0xbb, 0x26, 0xe6, 0x10, 0x1f, 0x83, 0x69, 0x0e, 0x0a, + /*5c90:*/ 0xeb, 0xd5, 0x35, 0x71, 0xed, 0xa8, 0x77, 0x7a, 0x5a, 0x07, 0xaf, 0xd1, 0x3a, 0x00, 0xf6, 0x83, + /*5ca0:*/ 0x7e, 0x0d, 0x6c, 0xed, 0xd8, 0xc6, 0x3c, 0x15, 0x9d, 0xad, 0x5b, 0x1c, 0xb6, 0xfb, 0x4d, 0x89, + /*5cb0:*/ 0x0f, 0xa2, 0x8f, 0xf9, 0x3e, 0x48, 0x77, 0xeb, 0xd0, 0x8a, 0x0e, 0xfe, 0xd2, 0x15, 0x38, 0x1e, + /*5cc0:*/ 0x9c, 0x08, 0x60, 0xd8, 0xbf, 0x95, 0xb9, 0xe9, 0x5d, 0x6d, 0x7b, 0x8c, 0x86, 0x33, 0xe4, 0xb1, + /*5cd0:*/ 0x10, 0xf6, 0x0b, 0x1c, 0x2a, 0xcc, 0xe7, 0x3b, 0xc1, 0x18, 0x14, 0xf5, 0x8b, 0xf4, 0x50, 0x5b, + /*5ce0:*/ 0x64, 0x46, 0x8f, 0xc3, 0x70, 0xfb, 0x68, 0xe6, 0x9a, 0x73, 0x4e, 0x23, 0xc6, 0x21, 0x96, 0xf1, + /*5cf0:*/ 0x9f, 0xca, 0x75, 0xc4, 0xaf, 0xb2, 0xde, 0xd6, 0xa9, 0x5c, 0xa5, 0x18, 0x5d, 0x84, 0x79, 0xe3, + /*5d00:*/ 0xc5, 0xf5, 0x44, 0x5e, 0x63, 0xf0, 0xc8, 0x35, 0x15, 0xe3, 0xff, 0x04, 0x8a, 0x31, 0xd0, 0xee, + /*5d10:*/ 0xc6, 0xe4, 0x77, 0x30, 0xb8, 0x77, 0x49, 0x68, 0x1c, 0x33, 0x99, 0x2d, 0x7e, 0xf5, 0x45, 0xa9, + /*5d20:*/ 0x13, 0x69, 0xc2, 0xab, 0x3f, 0xea, 0x49, 0x07, 0x4b, 0xc9, 0x9d, 0x8a, 0x1f, 0x41, 0x7f, 0xf7, + /*5d30:*/ 0x98, 0x2d, 0x75, 0x11, 0x10, 0x23, 0xb7, 0xab, 0x26, 0x79, 0x04, 0x9c, 0x10, 0x2a, 0x75, 0xef, + /*5d40:*/ 0x54, 0xe6, 0xc7, 0xab, 0x2d, 0xe7, 0xb3, 0xf4, 0xdd, 0x9e, 0xb5, 0xda, 0xbd, 0x7b, 0xe9, 0xbd, + /*5d50:*/ 0x6b, 0xd8, 0xf3, 0x4b, 0x05, 0x76, 0xdb, 0x03, 0xa4, 0x2b, 0x37, 0x20, 0x8b, 0x3e, 0x2b, 0xa2, + /*5d60:*/ 0x18, 0x01, 0x8e, 0xcf, 0xf9, 0x3e, 0x8b, 0xf1, 0x80, 0x24, 0xde, 0x31, 0xd1, 0x81, 0x70, 0xaf, + /*5d70:*/ 0x82, 0xd7, 0x58, 0xa8, 0xdc, 0xce, 0x2b, 0x55, 0x44, 0x21, 0x2b, 0xe1, 0xac, 0x0e, 0x23, 0xe7, + /*5d80:*/ 0xb2, 0x0b, 0x5e, 0x12, 0x3c, 0x4e, 0x6e, 0x3b, 0xf7, 0xbb, 0xce, 0x72, 0x5a, 0x5d, 0x54, 0xa0, + /*5d90:*/ 0xf5, 0x2e, 0xce, 0x9f, 0x76, 0xbf, 0x25, 0xb1, 0xeb, 0x5a, 0xa6, 0x61, 0x7d, 0x98, 0x33, 0x2f, + /*5da0:*/ 0x49, 0x3d, 0xec, 0xdf, 0xef, 0xed, 0xa1, 0x90, 0xeb, 0xde, 0xc3, 0x89, 0xd0, 0x04, 0xa7, 0xa0, + /*5db0:*/ 0xaa, 0xb3, 0xed, 0x54, 0x13, 0xc4, 0x70, 0x90, 0xfa, 0x2a, 0xfd, 0x24, 0x87, 0xf5, 0x12, 0x82, + /*5dc0:*/ 0xf0, 0x39, 0xfd, 0x1a, 0xd5, 0x0f, 0x26, 0x4a, 0xaf, 0x40, 0xb4, 0x2e, 0x3f, 0x9c, 0xa7, 0x35, + /*5dd0:*/ 0xcb, 0x5d, 0xf3, 0x21, 0xea, 0xbf, 0xb9, 0x14, 0x01, 0x06, 0x36, 0xcc, 0x06, 0xba, 0xa9, 0x8a, + /*5de0:*/ 0x32, 0x22, 0x12, 0x22, 0x19, 0xff, 0x64, 0xd2, 0x33, 0x98, 0x90, 0xb0, 0x57, 0xcb, 0xe7, 0x6a, + /*5df0:*/ 0x58, 0xc9, 0x1d, 0x85, 0x08, 0x4e, 0x18, 0x57, 0x4b, 0x20, 0xd6, 0xbe, 0xaa, 0x8c, 0x44, 0xad, + /*5e00:*/ 0x83, 0x78, 0xe5, 0x79, 0x72, 0xc6, 0xa8, 0xf1, 0xe5, 0x09, 0x9d, 0x4f, 0x54, 0xd5, 0xb9, 0x7d, + /*5e10:*/ 0x5b, 0xe8, 0x9f, 0xb1, 0x45, 0xc2, 0xe3, 0xe3, 0xe2, 0xbf, 0x4d, 0xb4, 0x5b, 0x88, 0x15, 0x70, + /*5e20:*/ 0x94, 0xf0, 0xe6, 0x2c, 0x3c, 0x66, 0x15, 0xf2, 0xab, 0xdf, 0x57, 0x74, 0x59, 0x8e, 0x30, 0x0a, + /*5e30:*/ 0x52, 0xe0, 0x96, 0x54, 0x84, 0xbd, 0x28, 0x94, 0x80, 0x4d, 0xac, 0x0a, 0xc1, 0xf6, 0x36, 0x8b, + /*5e40:*/ 0x7b, 0x11, 0xce, 0x6e, 0x43, 0x50, 0xbc, 0x94, 0x93, 0x96, 0x29, 0xe3, 0xf3, 0x28, 0x1b, 0x88, + /*5e50:*/ 0x23, 0xb8, 0x7d, 0x0e, 0xd0, 0xb9, 0x46, 0x81, 0xa1, 0xb3, 0xba, 0xb9, 0x67, 0x48, 0xe6, 0xc5, + /*5e60:*/ 0x11, 0x12, 0xa3, 0xaa, 0xf3, 0x1d, 0xe0, 0x64, 0x20, 0x09, 0x31, 0xe4, 0x21, 0xd1, 0xbb, 0x6c, + /*5e70:*/ 0x67, 0x83, 0x43, 0xd1, 0x9b, 0x91, 0x3d, 0xdf, 0xea, 0xf3, 0xaf, 0x77, 0x4d, 0x58, 0x16, 0xe8, + /*5e80:*/ 0xce, 0xd6, 0x60, 0xaa, 0xa9, 0x40, 0x6d, 0x44, 0xbc, 0xb2, 0x46, 0x27, 0xc3, 0xa3, 0x5c, 0x18, + /*5e90:*/ 0xcd, 0xd9, 0xe5, 0xef, 0x91, 0x14, 0x3b, 0xff, 0xb2, 0xbd, 0x65, 0x9a, 0xf8, 0x75, 0x76, 0x7b, + /*5ea0:*/ 0x0f, 0xf8, 0xad, 0x0b, 0xbf, 0x4b, 0xdf, 0x2e, 0xa8, 0x45, 0xac, 0x4c, 0x3b, 0xb0, 0x18, 0x8e, + /*5eb0:*/ 0xb5, 0x85, 0x23, 0x1b, 0x63, 0xed, 0xaa, 0x09, 0x52, 0xb6, 0x36, 0xe0, 0xb8, 0x15, 0xa8, 0x8b, + /*5ec0:*/ 0x51, 0x4c, 0xa3, 0xca, 0x09, 0x3c, 0xec, 0x83, 0x91, 0xfb, 0x4f, 0x3b, 0xc5, 0x35, 0x4c, 0x13, + /*5ed0:*/ 0x0a, 0x8f, 0x58, 0xb5, 0x19, 0x29, 0xdd, 0x46, 0x53, 0xbd, 0xf4, 0x15, 0xdf, 0x29, 0xf5, 0xa4, + /*5ee0:*/ 0x25, 0x45, 0x85, 0xa3, 0x00, 0x75, 0x4d, 0x38, 0xfb, 0xfe, 0x53, 0xed, 0x1f, 0x14, 0xf2, 0x0e, + /*5ef0:*/ 0xb7, 0x40, 0x62, 0x88, 0x92, 0x54, 0x6e, 0xd2, 0xa5, 0x8d, 0x7a, 0x9b, 0x2b, 0xee, 0x74, 0xb0, + /*5f00:*/ 0xb0, 0x17, 0x2b, 0xd3, 0x46, 0x6a, 0x3d, 0xcb, 0xdc, 0x93, 0x00, 0xfc, 0xf1, 0x3d, 0x4d, 0x25, + /*5f10:*/ 0xe9, 0x8d, 0xdf, 0x8d, 0x0d, 0x4a, 0x3e, 0xcb, 0x58, 0xc2, 0x33, 0x72, 0x0b, 0xd2, 0x8d, 0x55, + /*5f20:*/ 0x74, 0x63, 0x66, 0x3f, 0x9b, 0xeb, 0x77, 0x17, 0xb9, 0x18, 0x9c, 0xc8, 0xb7, 0x9b, 0x52, 0x1c, + /*5f30:*/ 0xbd, 0xa9, 0xa1, 0x3d, 0x51, 0x7e, 0x9a, 0xf8, 0x94, 0x14, 0xb8, 0x59, 0xec, 0xe2, 0x2f, 0xf6, + /*5f40:*/ 0xdd, 0x8a, 0x44, 0x55, 0x72, 0xc8, 0x7b, 0xaf, 0xce, 0xd2, 0x85, 0xb8, 0x71, 0x2d, 0x2e, 0x9e, + /*5f50:*/ 0xcb, 0x22, 0xbf, 0xdb, 0xd3, 0x85, 0x08, 0x7c, 0x48, 0x06, 0xd7, 0xbe, 0x5a, 0xa6, 0x5a, 0xe5, + /*5f60:*/ 0x83, 0x6f, 0xbc, 0xc2, 0xf0, 0xce, 0xc1, 0x8c, 0x54, 0x5e, 0x01, 0x93, 0xc4, 0x48, 0x62, 0x29, + /*5f70:*/ 0xef, 0x74, 0x0a, 0x80, 0xb8, 0x03, 0x61, 0x67, 0x13, 0x38, 0xd5, 0x55, 0x89, 0xc1, 0x51, 0x06, + /*5f80:*/ 0x2f, 0xb6, 0x24, 0x34, 0xbe, 0x92, 0xc9, 0x9b, 0xa4, 0xc8, 0x50, 0x50, 0xb4, 0xf3, 0xba, 0xd3, + /*5f90:*/ 0x77, 0x18, 0xd1, 0x8d, 0x95, 0x11, 0x48, 0x0d, 0xbc, 0x2b, 0x0f, 0xee, 0x04, 0x6a, 0xd8, 0xa0, + /*5fa0:*/ 0x6a, 0xfb, 0x6e, 0xae, 0xac, 0x6c, 0xad, 0x4b, 0x66, 0x61, 0x35, 0x00, 0x29, 0x19, 0x31, 0x7d, + /*5fb0:*/ 0x67, 0x58, 0xd0, 0x95, 0x81, 0xfe, 0x31, 0x46, 0x91, 0xd8, 0xac, 0xb4, 0x5e, 0xbf, 0xf3, 0xfc, + /*5fc0:*/ 0x4a, 0xcc, 0x67, 0xc6, 0xbf, 0x89, 0xb9, 0x9a, 0x83, 0x3a, 0x6a, 0x00, 0xe3, 0x8e, 0x7f, 0x03, + /*5fd0:*/ 0xa2, 0xc6, 0x6e, 0x81, 0x9a, 0xd3, 0xf9, 0x9e, 0xb9, 0xe1, 0x15, 0x01, 0xb3, 0x6d, 0xc4, 0xea, + /*5fe0:*/ 0xa1, 0x3a, 0x29, 0x38, 0x64, 0x07, 0xeb, 0x7c, 0x96, 0x3c, 0x05, 0xc9, 0xee, 0x2c, 0x13, 0x91, + /*5ff0:*/ 0x30, 0x33, 0x84, 0x01, 0x31, 0xe0, 0xef, 0xe9, 0x31, 0x07, 0x59, 0x9b, 0xca, 0xc2, 0x73, 0xc1, + /*6000:*/ 0xbc, 0x1c, 0xd8, 0xc0, 0xce, 0x1d, 0xf4, 0x25, 0x2e, 0x88, 0xa1, 0xc1, 0x48, 0x98, 0x0c, 0xae, + /*6010:*/ 0x01, 0x9f, 0xe0, 0x94, 0x38, 0x4f, 0xd0, 0x8c, 0x36, 0x6b, 0x4d, 0xd5, 0x0b, 0x03, 0x8a, 0x5d, + /*6020:*/ 0x15, 0x3c, 0x3a, 0x09, 0x32, 0x95, 0xd8, 0xdb, 0x9f, 0xcf, 0x71, 0x67, 0x9b, 0xc6, 0xab, 0x87, + /*6030:*/ 0xd4, 0xfe, 0xad, 0xc2, 0xde, 0x17, 0x9c, 0xba, 0x4b, 0x1c, 0x73, 0x69, 0xe4, 0xa5, 0xc1, 0x90, + /*6040:*/ 0x2c, 0x25, 0xec, 0x91, 0x2e, 0xd9, 0x18, 0xe5, 0xa4, 0xfb, 0x4d, 0x6b, 0x31, 0x5d, 0xbb, 0xb5, + /*6050:*/ 0xb9, 0xe1, 0xdc, 0xf6, 0xcd, 0x88, 0x15, 0xbe, 0x82, 0xf7, 0x7e, 0x74, 0x9f, 0x67, 0x84, 0x38, + /*6060:*/ 0x60, 0x25, 0xa6, 0x22, 0x8a, 0xfa, 0xd1, 0x54, 0x9d, 0x4a, 0xab, 0x80, 0x8e, 0xf3, 0x46, 0x92, + /*6070:*/ 0x93, 0xd3, 0x56, 0xdf, 0x3c, 0xed, 0xfe, 0x16, 0x90, 0x7f, 0x22, 0xe8, 0xda, 0x79, 0xe3, 0x4d, + /*6080:*/ 0x32, 0x34, 0x05, 0xa4, 0x1e, 0xf8, 0xa1, 0xa4, 0x73, 0xe8, 0x3b, 0x94, 0xcc, 0xc5, 0x56, 0x86, + /*6090:*/ 0xd5, 0xc5, 0x52, 0x23, 0xf1, 0x3e, 0xbb, 0x73, 0x5f, 0x2e, 0xa4, 0x53, 0x18, 0x1d, 0xeb, 0xbc, + /*60a0:*/ 0xab, 0x38, 0x61, 0x83, 0x15, 0xcf, 0xbc, 0xff, 0xb7, 0x3e, 0x43, 0xa7, 0x48, 0x10, 0x64, 0x52, + /*60b0:*/ 0x3c, 0xae, 0x7c, 0x8f, 0xf0, 0x21, 0x96, 0x99, 0xc4, 0xc5, 0xaa, 0xfe, 0x96, 0xc0, 0x13, 0xa9, + /*60c0:*/ 0x91, 0xe2, 0xb3, 0x6b, 0x52, 0xea, 0x5f, 0xfa, 0xcd, 0xe3, 0x48, 0xd8, 0x8e, 0x8a, 0x8d, 0x8f, + /*60d0:*/ 0x89, 0x45, 0xf0, 0xcb, 0xc8, 0xc7, 0x21, 0x44, 0x22, 0xb3, 0xad, 0x68, 0x55, 0xd1, 0x59, 0xa6, + /*60e0:*/ 0xd0, 0x7e, 0xb2, 0xd3, 0xf1, 0xd1, 0x0a, 0x25, 0xc2, 0x3f, 0x3b, 0x40, 0x34, 0x03, 0x1e, 0xc3, + /*60f0:*/ 0x3c, 0x71, 0x70, 0xf8, 0x3a, 0x6a, 0x9d, 0x7c, 0x46, 0xbb, 0xd7, 0x79, 0x66, 0x6a, 0x3d, 0xb6, + /*6100:*/ 0x6f, 0x57, 0xa8, 0x22, 0xf3, 0x1e, 0x8c, 0x91, 0x44, 0x86, 0xa5, 0x91, 0xce, 0x11, 0x14, 0xc0, + /*6110:*/ 0x13, 0xaa, 0xaa, 0xbe, 0xb0, 0x7f, 0x2b, 0x6b, 0x12, 0x53, 0x75, 0x82, 0xcb, 0x1b, 0x56, 0xf8, + /*6120:*/ 0xc6, 0x1b, 0x83, 0x8c, 0x94, 0xd4, 0xfa, 0x0b, 0x2f, 0x90, 0x0d, 0xf0, 0x05, 0x80, 0xac, 0x2d, + /*6130:*/ 0xf2, 0x1c, 0x7a, 0x53, 0xce, 0x2a, 0xd2, 0xc8, 0xd7, 0x0c, 0x84, 0x60, 0xe1, 0x4d, 0xb1, 0x75, + /*6140:*/ 0x56, 0xc8, 0xf8, 0xab, 0x4d, 0x49, 0x16, 0x87, 0x41, 0x71, 0x1b, 0x0f, 0xed, 0x3a, 0xa6, 0xe4, + /*6150:*/ 0x92, 0x9e, 0xe7, 0xad, 0xb5, 0xb3, 0x0c, 0xa1, 0x7d, 0x00, 0x3d, 0x54, 0x11, 0xc6, 0x34, 0xb8, + /*6160:*/ 0x87, 0x2a, 0xb7, 0xf7, 0x56, 0xd1, 0x3e, 0x18, 0xa1, 0xcc, 0xc0, 0x71, 0x5d, 0xe3, 0x66, 0xf0, + /*6170:*/ 0xea, 0x05, 0xa4, 0xe2, 0x55, 0x77, 0x8c, 0x5c, 0xa5, 0xca, 0xb1, 0xae, 0xf4, 0x0f, 0xb3, 0x9d, + /*6180:*/ 0xb8, 0x0f, 0x1e, 0x0f, 0x8e, 0x5e, 0xbb, 0x0e, 0x26, 0x5e, 0x3a, 0xdc, 0xca, 0xb5, 0xa2, 0xad, + /*6190:*/ 0x1d, 0xfe, 0x65, 0x89, 0x4e, 0x67, 0x8c, 0xe3, 0xc6, 0x61, 0x0f, 0x28, 0x8c, 0x7a, 0xf0, 0x18, + /*61a0:*/ 0x26, 0xbd, 0x05, 0x5f, 0x08, 0xba, 0x7b, 0x76, 0xb3, 0xc0, 0x76, 0x52, 0xfe, 0xda, 0x9b, 0x79, + /*61b0:*/ 0xb9, 0x2b, 0x12, 0x05, 0xdf, 0x3f, 0xa3, 0x92, 0xff, 0x2f, 0x82, 0x65, 0x0c, 0xe6, 0x10, 0x26, + /*61c0:*/ 0x20, 0x3a, 0xbf, 0x49, 0x70, 0x40, 0x94, 0xd3, 0xc2, 0xd9, 0xf1, 0x66, 0xc4, 0x79, 0x57, 0xe6, + /*61d0:*/ 0xcd, 0x93, 0xd8, 0xc7, 0x21, 0xd0, 0x4d, 0x71, 0x39, 0x4c, 0xaf, 0xdf, 0xb8, 0x34, 0xa7, 0xdc, + /*61e0:*/ 0x94, 0x78, 0x2e, 0x1a, 0x6c, 0x1b, 0xb6, 0xe7, 0x18, 0x45, 0xb7, 0x05, 0xe9, 0x12, 0x20, 0x95, + /*61f0:*/ 0xa2, 0x6c, 0x35, 0x27, 0xaf, 0xdf, 0xed, 0x1f, 0x70, 0xd5, 0x74, 0x44, 0x65, 0x54, 0x38, 0x12, + /*6200:*/ 0x9c, 0xe8, 0x59, 0x3f, 0x9a, 0x07, 0x44, 0x32, 0xa7, 0x4b, 0x0a, 0xe5, 0x1d, 0x08, 0x82, 0x86, + /*6210:*/ 0xcf, 0x99, 0x47, 0x8d, 0xb4, 0x29, 0xa4, 0x96, 0x3f, 0x65, 0x8e, 0xaf, 0xb4, 0x44, 0xe9, 0x69, + /*6220:*/ 0x1e, 0xe8, 0xc8, 0xcb, 0x67, 0xd9, 0x78, 0x2e, 0xbb, 0x11, 0x72, 0xed, 0x4f, 0xe5, 0x95, 0xad, + /*6230:*/ 0x13, 0xc9, 0x68, 0x0c, 0x0e, 0xe4, 0xde, 0xcf, 0xb1, 0x65, 0xc5, 0x36, 0xe9, 0xeb, 0x25, 0xe7, + /*6240:*/ 0xdf, 0xe5, 0x02, 0x09, 0x31, 0x37, 0x99, 0x7a, 0xe3, 0xe5, 0x34, 0xf6, 0xea, 0x6e, 0xcc, 0x39, + /*6250:*/ 0x64, 0xbe, 0xb3, 0xd3, 0x0f, 0xf2, 0x7e, 0x18, 0xba, 0x53, 0x35, 0x19, 0x3f, 0x9f, 0x5a, 0x80, + /*6260:*/ 0x2a, 0xbb, 0x7e, 0x92, 0x31, 0xfd, 0x2a, 0x66, 0xee, 0x54, 0xd0, 0x32, 0xa3, 0x53, 0x2d, 0xfc, + /*6270:*/ 0xf5, 0x59, 0x13, 0xe1, 0xb0, 0xe9, 0x31, 0x07, 0x19, 0xe5, 0x08, 0x8e, 0x24, 0x87, 0x39, 0x8b, + /*6280:*/ 0xb2, 0xa8, 0xde, 0x81, 0xaa, 0x47, 0x5b, 0x9a, 0x41, 0xd5, 0xda, 0xb9, 0x61, 0x59, 0x4f, 0x30, + /*6290:*/ 0x25, 0xa3, 0x56, 0x4f, 0x9b, 0x9e, 0x63, 0x96, 0x75, 0xba, 0xfd, 0xf0, 0x4b, 0x64, 0x73, 0xbb, + /*62a0:*/ 0xa2, 0x96, 0x5b, 0xbf, 0xce, 0xc3, 0xa1, 0xa8, 0x90, 0xc9, 0x19, 0xf7, 0xb1, 0x82, 0xb7, 0xcc, + /*62b0:*/ 0xb1, 0x57, 0xa0, 0x13, 0x7c, 0x60, 0x34, 0x32, 0x65, 0xba, 0xf2, 0x5f, 0x41, 0xdc, 0x00, 0xd1, + /*62c0:*/ 0x5a, 0x38, 0xb6, 0x4f, 0x4d, 0xec, 0x18, 0x31, 0xc3, 0x8b, 0xaa, 0x06, 0xda, 0x2f, 0x2e, 0x7c, + /*62d0:*/ 0x2b, 0x57, 0x29, 0x81, 0x43, 0xb2, 0xca, 0xb9, 0x61, 0x2c, 0x94, 0x5e, 0x8e, 0xa2, 0x33, 0x80, + /*62e0:*/ 0x0a, 0x4b, 0x58, 0xa7, 0x1c, 0xf7, 0x0d, 0xc0, 0x1a, 0x61, 0x14, 0xf8, 0x82, 0x57, 0x5b, 0x0d, + /*62f0:*/ 0x17, 0x71, 0x8d, 0xf9, 0x42, 0x9a, 0x41, 0x1f, 0x84, 0x98, 0xcb, 0x38, 0x25, 0x4a, 0xb9, 0x0a, + /*6300:*/ 0xf1, 0xfc, 0x94, 0x14, 0x21, 0x51, 0xe3, 0xe5, 0x1a, 0xd9, 0x70, 0x31, 0x1a, 0x84, 0xaf, 0x08, + /*6310:*/ 0x20, 0x9f, 0x96, 0x61, 0x84, 0xf5, 0xfb, 0xfc, 0x4f, 0xf0, 0xb7, 0xcc, 0xef, 0x99, 0xb9, 0x6d, + /*6320:*/ 0x95, 0x11, 0x57, 0x20, 0x62, 0x62, 0xa8, 0xfb, 0xec, 0xf1, 0x0f, 0xcc, 0xc9, 0xf0, 0x63, 0xb8, + /*6330:*/ 0x59, 0xa4, 0xf8, 0xb0, 0xfd, 0xf6, 0xe2, 0x61, 0x45, 0x9b, 0xb4, 0x18, 0xf5, 0xe5, 0x9f, 0x3e, + /*6340:*/ 0x97, 0xe7, 0x3f, 0x08, 0xf7, 0x63, 0x9b, 0x71, 0x4f, 0x06, 0x95, 0x66, 0xa7, 0x2e, 0xa1, 0xa3, + /*6350:*/ 0xef, 0x22, 0xf7, 0x82, 0x00, 0xf8, 0xc6, 0x04, 0x03, 0xf6, 0x90, 0x4d, 0xd2, 0xe7, 0xb2, 0xda, + /*6360:*/ 0xeb, 0x4b, 0xff, 0x40, 0x33, 0x28, 0xed, 0x33, 0x81, 0x9e, 0xfa, 0x18, 0x43, 0xac, 0x82, 0x99, + /*6370:*/ 0x09, 0xa5, 0x7c, 0xd7, 0xc0, 0xf2, 0x9a, 0xeb, 0xb4, 0xb6, 0x18, 0x9a, 0x9c, 0x8e, 0x5e, 0xed, + /*6380:*/ 0x49, 0x18, 0xb6, 0x14, 0x74, 0x3b, 0x19, 0x2d, 0xa0, 0xdf, 0xc0, 0xa3, 0x56, 0x6b, 0x17, 0x80, + /*6390:*/ 0x40, 0x36, 0x2f, 0x5b, 0xf8, 0xc0, 0x39, 0x0b, 0x64, 0x73, 0x31, 0x15, 0x0f, 0x54, 0x3d, 0x52, + /*63a0:*/ 0x39, 0x99, 0xe3, 0x37, 0xaf, 0xae, 0xaa, 0xf2, 0x1e, 0xc4, 0x53, 0x41, 0xa8, 0x41, 0x82, 0x5c, + /*63b0:*/ 0xde, 0x4a, 0xef, 0xa9, 0x4b, 0x31, 0xfe, 0xdb, 0x5a, 0x2d, 0x55, 0xa2, 0x5a, 0x84, 0xda, 0xfc, + /*63c0:*/ 0x47, 0xbc, 0x8c, 0x5f, 0x6c, 0x30, 0x6f, 0xb7, 0xb0, 0x57, 0xe2, 0xe3, 0x30, 0x75, 0xae, 0x9d, + /*63d0:*/ 0x78, 0xd5, 0x98, 0x44, 0xee, 0x86, 0x44, 0x3c, 0xfd, 0x18, 0x0d, 0x5c, 0x16, 0x86, 0x04, 0xdb, + /*63e0:*/ 0x8a, 0xda, 0x0c, 0x37, 0xef, 0xb1, 0xea, 0xe5, 0x7c, 0x10, 0x6a, 0x17, 0x01, 0xd4, 0x44, 0x4e, + /*63f0:*/ 0xf3, 0xb3, 0x47, 0xce, 0x10, 0x78, 0x6e, 0x69, 0x98, 0x3e, 0x61, 0x21, 0xde, 0x65, 0x50, 0xb4, + /*6400:*/ 0x2e, 0x08, 0x08, 0x6b, 0xef, 0x25, 0x1b, 0x9d, 0x68, 0xee, 0xd0, 0xce, 0xd5, 0x36, 0xb0, 0xcd, + /*6410:*/ 0x4e, 0x0c, 0x19, 0x59, 0x57, 0xd8, 0xa1, 0x69, 0xe5, 0x1f, 0xba, 0x8d, 0x28, 0xa4, 0xe0, 0x56, + /*6420:*/ 0xdf, 0xab, 0xd0, 0x2a, 0x27, 0x60, 0xd3, 0xa1, 0x69, 0xbb, 0x77, 0xe5, 0xef, 0xa8, 0x99, 0xb4, + /*6430:*/ 0x3f, 0xc1, 0x09, 0x72, 0x69, 0xe9, 0x73, 0x5b, 0x59, 0x48, 0x4c, 0x1d, 0x9d, 0x73, 0xb6, 0x8e, + /*6440:*/ 0x2a, 0x66, 0x7e, 0xf5, 0xaf, 0x12, 0x69, 0xcf, 0x61, 0xbd, 0xd3, 0x84, 0xd3, 0x3a, 0xe4, 0xbf, + /*6450:*/ 0x7f, 0xeb, 0x21, 0x59, 0x72, 0x7c, 0xa6, 0x89, 0x6b, 0x2e, 0xc9, 0x46, 0xa8, 0x05, 0xc9, 0xf9, + /*6460:*/ 0x7a, 0x25, 0x27, 0xb8, 0xda, 0x80, 0xf6, 0xa7, 0x69, 0x28, 0x06, 0x5d, 0x8e, 0xa6, 0x0d, 0x3c, + /*6470:*/ 0x7b, 0x2a, 0xce, 0x1a, 0x13, 0x53, 0x98, 0x85, 0x1f, 0xc9, 0xce, 0xd0, 0xd4, 0x76, 0x6d, 0x6e, + /*6480:*/ 0xa9, 0x4e, 0x5a, 0x44, 0xc2, 0xb4, 0x6f, 0x5e, 0xe8, 0x8c, 0x88, 0xfb, 0xe2, 0x1e, 0x4b, 0x1a, + /*6490:*/ 0xa9, 0x55, 0x09, 0x70, 0x73, 0xf9, 0x4f, 0xd4, 0x4a, 0x53, 0xaa, 0x7e, 0x67, 0xe5, 0x61, 0x13, + /*64a0:*/ 0x53, 0xfc, 0xef, 0xe6, 0x82, 0x6a, 0xdf, 0x82, 0x87, 0x93, 0x8f, 0x85, 0x7a, 0x8e, 0x7a, 0xb9, + /*64b0:*/ 0xd8, 0xf9, 0xac, 0x79, 0x2c, 0x87, 0x9f, 0x40, 0x9a, 0xe3, 0x8b, 0xbd, 0x15, 0xaf, 0x70, 0xfb, + /*64c0:*/ 0x7f, 0x80, 0x74, 0x6c, 0x94, 0x02, 0x0d, 0xd2, 0x41, 0x7f, 0xe2, 0x38, 0xcb, 0xfe, 0x99, 0xef, + /*64d0:*/ 0xd7, 0x0e, 0x74, 0x93, 0x66, 0xae, 0xa7, 0x10, 0x42, 0x10, 0xf6, 0x77, 0x5e, 0x16, 0xe7, 0x4c, + /*64e0:*/ 0x41, 0x51, 0xc8, 0x80, 0x6c, 0xaf, 0xb9, 0xb6, 0x91, 0x17, 0xb3, 0xba, 0x00, 0x07, 0xe4, 0xd1, + /*64f0:*/ 0x89, 0x05, 0x31, 0xc9, 0x6c, 0x5a, 0x8f, 0x4c, 0xd2, 0x03, 0xe7, 0x79, 0x65, 0xfb, 0x6a, 0x60, + /*6500:*/ 0x6c, 0x1d, 0x88, 0x94, 0xf3, 0xc0, 0x15, 0xd0, 0xc3, 0xad, 0x93, 0x81, 0xee, 0x3e, 0x48, 0x9b, + /*6510:*/ 0xa7, 0xe8, 0x9b, 0x26, 0x55, 0x97, 0xcd, 0x15, 0xc1, 0xf0, 0x97, 0xb0, 0x47, 0x42, 0xba, 0xea, + /*6520:*/ 0x04, 0x2e, 0x31, 0xf8, 0xb3, 0xf5, 0xcb, 0xa4, 0xec, 0xf5, 0x59, 0xe4, 0x8f, 0x03, 0x69, 0x85, + /*6530:*/ 0x94, 0x55, 0x00, 0xeb, 0xa5, 0x15, 0xca, 0xe2, 0xac, 0xc7, 0xfb, 0x79, 0x23, 0xbc, 0x60, 0x2b, + /*6540:*/ 0x87, 0xcc, 0x55, 0xc5, 0xe8, 0x79, 0xd0, 0x1e, 0x4b, 0xde, 0xf6, 0xf0, 0x26, 0x87, 0x88, 0x29, + /*6550:*/ 0xf4, 0x78, 0x77, 0x42, 0xaf, 0x38, 0x53, 0xc4, 0x91, 0x7b, 0xf0, 0x2d, 0x12, 0x2d, 0xa3, 0x15, + /*6560:*/ 0xaf, 0x2d, 0x0d, 0xd1, 0xc5, 0x07, 0x55, 0x03, 0x8c, 0x1a, 0x51, 0x5d, 0x1c, 0xcb, 0xd2, 0xd5, + /*6570:*/ 0x6a, 0x9b, 0x6e, 0x48, 0x35, 0x7d, 0xd0, 0xc0, 0x45, 0x8f, 0x14, 0xca, 0x74, 0x9f, 0x84, 0xf8, + /*6580:*/ 0xd3, 0xd3, 0xe6, 0x14, 0x66, 0xc6, 0x8c, 0xde, 0x3b, 0x54, 0x33, 0x69, 0x20, 0x23, 0x60, 0x3d, + /*6590:*/ 0xc4, 0xd5, 0x7c, 0xc6, 0xa9, 0xd9, 0xf0, 0xbd, 0x4b, 0xbd, 0x0d, 0x5c, 0xea, 0x74, 0x0a, 0x6a, + /*65a0:*/ 0x17, 0x0d, 0x71, 0xfd, 0x9b, 0xa9, 0x0a, 0x1c, 0x80, 0xf6, 0x2a, 0xd9, 0xf7, 0x2f, 0x1b, 0x41, + /*65b0:*/ 0x06, 0x09, 0x10, 0x95, 0xfc, 0xbd, 0xe4, 0x81, 0x54, 0x47, 0x0e, 0xfd, 0xca, 0xe5, 0x6f, 0x49, + /*65c0:*/ 0x39, 0xe7, 0xb4, 0xea, 0x75, 0x3c, 0x02, 0x76, 0xb5, 0xa8, 0x0e, 0x4b, 0x81, 0x2d, 0xbc, 0x9d, + /*65d0:*/ 0xc9, 0x88, 0xea, 0x8f, 0xde, 0x8d, 0xdb, 0x69, 0x91, 0x6b, 0x30, 0xbf, 0xdb, 0x43, 0x57, 0xa3, + /*65e0:*/ 0xd2, 0xde, 0x8b, 0x8e, 0xaa, 0xc0, 0x46, 0xb5, 0x09, 0x61, 0xfd, 0x92, 0x11, 0x78, 0x73, 0xed, + /*65f0:*/ 0x89, 0xa3, 0xf9, 0x33, 0xd8, 0x5f, 0xbe, 0x1c, 0x82, 0x6c, 0xd1, 0xd0, 0x58, 0xb5, 0x72, 0x43, + /*6600:*/ 0x37, 0xd6, 0xca, 0x98, 0x30, 0x9c, 0x29, 0xae, 0x11, 0x14, 0x73, 0x17, 0x6d, 0x10, 0xea, 0xa6, + /*6610:*/ 0x2d, 0xf3, 0x1b, 0xe4, 0xd2, 0xba, 0x01, 0x52, 0x4b, 0xe9, 0x54, 0xb5, 0x3f, 0x9c, 0xb4, 0x9e, + /*6620:*/ 0xac, 0xe0, 0x93, 0x6d, 0xdc, 0x1d, 0xfa, 0xf7, 0x04, 0x8f, 0x4a, 0x7e, 0x97, 0xf3, 0x01, 0x38, + /*6630:*/ 0x2f, 0xa2, 0x3d, 0xcf, 0xd1, 0x4c, 0x6c, 0x57, 0xb5, 0x8e, 0xb3, 0x59, 0xdd, 0x84, 0x8c, 0x1a, + /*6640:*/ 0xaa, 0xc4, 0x9a, 0x6d, 0x7d, 0xd2, 0xf3, 0x5f, 0x60, 0x2d, 0xd3, 0xc3, 0xdb, 0x3c, 0xef, 0xea, + /*6650:*/ 0x0c, 0x99, 0x3a, 0xd0, 0xb5, 0xbb, 0xda, 0xcc, 0x35, 0xce, 0x81, 0xc1, 0x15, 0x61, 0x2d, 0x7c, + /*6660:*/ 0x20, 0xb1, 0x2a, 0x4c, 0x19, 0x79, 0xff, 0xe7, 0xfd, 0xa2, 0x7c, 0xd4, 0x81, 0xef, 0xd6, 0xc7, + /*6670:*/ 0x89, 0xfd, 0x67, 0x8f, 0xa0, 0x64, 0xb9, 0x84, 0x68, 0x87, 0xa2, 0x7d, 0x21, 0xa9, 0xd4, 0x28, + /*6680:*/ 0x89, 0x0d, 0x62, 0x08, 0x25, 0xb6, 0x41, 0x9f, 0x0c, 0x3b, 0xdf, 0x0d, 0x86, 0x9c, 0xbd, 0x16, + /*6690:*/ 0x6f, 0x03, 0x1b, 0xd8, 0x1c, 0x00, 0x91, 0x14, 0xc1, 0x3a, 0x45, 0x96, 0xa4, 0x4c, 0xa3, 0x27, + /*66a0:*/ 0x31, 0x4d, 0xf7, 0x8b, 0x69, 0xdc, 0xab, 0x4e, 0x91, 0xb7, 0x68, 0x46, 0x52, 0x04, 0xb4, 0xf0, + /*66b0:*/ 0xa3, 0x7d, 0xf2, 0xa3, 0x14, 0xb4, 0x12, 0xda, 0xa1, 0xb4, 0xa9, 0x6b, 0x22, 0x49, 0x0c, 0xaa, + /*66c0:*/ 0x1a, 0x95, 0x57, 0x4c, 0x6c, 0x0b, 0x72, 0x36, 0xf9, 0x02, 0x41, 0x17, 0xc9, 0x70, 0x7e, 0x10, + /*66d0:*/ 0xce, 0x4c, 0xd2, 0xa0, 0x46, 0xac, 0x64, 0x5a, 0x53, 0x12, 0x5a, 0xd1, 0x4b, 0x5c, 0x87, 0xa0, + /*66e0:*/ 0xb6, 0xc9, 0xf5, 0x6e, 0xa2, 0xbb, 0x3b, 0x6c, 0x55, 0x67, 0x73, 0xe2, 0x01, 0x5d, 0xac, 0x26, + /*66f0:*/ 0xad, 0x79, 0xc4, 0x56, 0x2c, 0x33, 0x66, 0x7b, 0xb9, 0xdf, 0x4f, 0x9e, 0xe5, 0x13, 0xb8, 0xf0, + /*6700:*/ 0x70, 0x53, 0x59, 0xa0, 0xc2, 0x74, 0xc5, 0xeb, 0x76, 0x4e, 0x1c, 0x0d, 0xfe, 0x98, 0x05, 0x57, + /*6710:*/ 0xd5, 0xbe, 0x81, 0xb2, 0x67, 0x0a, 0xcc, 0xde, 0xc1, 0x4e, 0x07, 0x80, 0x34, 0xee, 0x20, 0x93, + /*6720:*/ 0xbd, 0xc1, 0xd6, 0x72, 0x47, 0x17, 0xe0, 0x27, 0x90, 0xca, 0x97, 0x0e, 0x0f, 0x6c, 0xcc, 0xe2, + /*6730:*/ 0x97, 0x47, 0x49, 0x0c, 0x73, 0xaf, 0x47, 0x8d, 0x8a, 0x2a, 0x6e, 0xfb, 0x79, 0x81, 0xe2, 0xc8, + /*6740:*/ 0x97, 0x9f, 0x7e, 0x9b, 0xf4, 0x9a, 0x8f, 0x10, 0x75, 0x23, 0x4a, 0xb9, 0xbd, 0x0d, 0x25, 0xa1, + /*6750:*/ 0x50, 0xdf, 0x40, 0x23, 0xbf, 0x1c, 0x83, 0xcd, 0x4c, 0xb7, 0xa3, 0x51, 0x7f, 0xca, 0x44, 0x23, + /*6760:*/ 0xbe, 0xd8, 0x74, 0x8a, 0x4c, 0xb3, 0x72, 0x93, 0xaa, 0x9a, 0x32, 0x11, 0xc1, 0x4b, 0x9b, 0x96, + /*6770:*/ 0x88, 0x61, 0xc7, 0x22, 0xa3, 0x6c, 0x28, 0xf1, 0x17, 0xa5, 0x02, 0x5e, 0x6d, 0x71, 0x44, 0xe7, + /*6780:*/ 0xa6, 0x63, 0x9e, 0xee, 0xc6, 0xef, 0xc0, 0x18, 0xf8, 0xea, 0xf8, 0x78, 0x73, 0x8f, 0xae, 0xed, + /*6790:*/ 0xb3, 0x5b, 0x80, 0x12, 0x5b, 0x47, 0x48, 0x54, 0x3a, 0xf3, 0xaf, 0x37, 0x14, 0xc3, 0x8c, 0x09, + /*67a0:*/ 0x1e, 0x11, 0xb5, 0xc2, 0x82, 0xef, 0x31, 0x36, 0xe6, 0x73, 0xbe, 0xea, 0x98, 0x4f, 0x14, 0x17, + /*67b0:*/ 0x1d, 0xbb, 0x89, 0xba, 0x95, 0xf6, 0x79, 0xa9, 0x71, 0xc0, 0x47, 0xf1, 0x86, 0x18, 0x7c, 0x74, + /*67c0:*/ 0x18, 0x27, 0xb7, 0x28, 0x27, 0xf6, 0x2a, 0x4a, 0xcc, 0x8e, 0x7a, 0x0f, 0x90, 0x65, 0x9a, 0xc0, + /*67d0:*/ 0xd1, 0xba, 0xf3, 0xd8, 0x49, 0x6a, 0x88, 0x68, 0x41, 0xaa, 0xb9, 0x28, 0xfe, 0x4f, 0xe4, 0x3e, + /*67e0:*/ 0x1b, 0xc8, 0xa2, 0x0f, 0x38, 0x8d, 0x7b, 0x63, 0xee, 0x46, 0xbd, 0xa2, 0x75, 0xb3, 0x27, 0x35, + /*67f0:*/ 0x72, 0xa7, 0xd4, 0xdd, 0xea, 0xdb, 0xb6, 0x1a, 0x65, 0x39, 0xce, 0xc3, 0x83, 0x65, 0x2d, 0x83, + /*6800:*/ 0xb0, 0xf1, 0xd9, 0xa1, 0xb0, 0x48, 0x0f, 0x55, 0x48, 0x3b, 0x78, 0x98, 0xc9, 0x3a, 0x93, 0xbc, + /*6810:*/ 0xdb, 0x43, 0x32, 0x27, 0xf6, 0xba, 0xb7, 0xb7, 0x99, 0x11, 0x04, 0xa9, 0x4f, 0x8f, 0x89, 0x30, + /*6820:*/ 0x19, 0xad, 0x0d, 0x30, 0xfd, 0x02, 0xfa, 0x87, 0x73, 0xc1, 0x18, 0x07, 0x51, 0x54, 0x1b, 0xdf, + /*6830:*/ 0xae, 0xfd, 0x6f, 0x62, 0x23, 0x0b, 0x7b, 0xfb, 0x8a, 0xf8, 0x2b, 0xcc, 0x69, 0x0e, 0x56, 0x6d, + /*6840:*/ 0x35, 0x9d, 0xbd, 0x71, 0x51, 0xa7, 0xd9, 0xeb, 0x34, 0x9a, 0x95, 0x9d, 0x52, 0x71, 0x3e, 0x04, + /*6850:*/ 0x9f, 0x20, 0xfb, 0xf8, 0x6a, 0xf7, 0x7d, 0x3e, 0x1f, 0xeb, 0x71, 0xe4, 0xf1, 0xbf, 0xb8, 0xb9, + /*6860:*/ 0x62, 0x70, 0x84, 0x87, 0xdc, 0x9e, 0xaf, 0x21, 0xd7, 0xa3, 0x58, 0x03, 0x90, 0x9e, 0xcb, 0x9f, + /*6870:*/ 0x5d, 0x48, 0xfb, 0xb7, 0xa6, 0x0e, 0x94, 0xb2, 0xaa, 0x4a, 0xb5, 0x7e, 0xfc, 0x6b, 0xd1, 0x59, + /*6880:*/ 0x80, 0xec, 0xb0, 0x91, 0x68, 0x62, 0xd1, 0x93, 0x25, 0x70, 0xf7, 0x47, 0x31, 0x69, 0xc9, 0x05, + /*6890:*/ 0x31, 0x5b, 0x97, 0x48, 0x28, 0xee, 0xb0, 0x77, 0xac, 0x56, 0xde, 0xb0, 0x5f, 0x14, 0x19, 0x58, + /*68a0:*/ 0x1f, 0xd1, 0x31, 0xf6, 0x02, 0xcb, 0x81, 0x6a, 0xac, 0x57, 0x62, 0xea, 0xb9, 0xf0, 0x8f, 0xfd, + /*68b0:*/ 0x78, 0xbf, 0xbc, 0x3b, 0xf2, 0x41, 0x2c, 0xff, 0x6e, 0x83, 0x5d, 0xde, 0x22, 0x7b, 0x48, 0x65, + /*68c0:*/ 0xac, 0x72, 0xce, 0x12, 0xcf, 0x0c, 0x27, 0x9b, 0xd5, 0x8d, 0xf3, 0x32, 0x1a, 0x4f, 0x67, 0xa6, + /*68d0:*/ 0xeb, 0x6a, 0x4c, 0xc8, 0x81, 0x35, 0xd0, 0x22, 0x75, 0xc9, 0xd1, 0x29, 0x8e, 0x42, 0x73, 0x99, + /*68e0:*/ 0xdd, 0x50, 0x7e, 0x3c, 0xcb, 0x5f, 0xca, 0xbf, 0x8d, 0x66, 0x13, 0x0e, 0x19, 0x01, 0x58, 0x2d, + /*68f0:*/ 0x16, 0x91, 0xb4, 0x40, 0xba, 0xed, 0x9a, 0x02, 0x04, 0xa3, 0x82, 0x14, 0x9d, 0x8b, 0xcc, 0xd5, + /*6900:*/ 0xf5, 0x6f, 0x78, 0x60, 0xe5, 0x8b, 0x06, 0xc7, 0xf0, 0xb0, 0x5d, 0xd7, 0x2e, 0x0f, 0xa0, 0x6b, + /*6910:*/ 0x39, 0xcd, 0xb4, 0x2a, 0x2d, 0x81, 0x97, 0xa1, 0xab, 0x07, 0x8c, 0x7e, 0xbc, 0x68, 0x13, 0x38, + /*6920:*/ 0x85, 0x0a, 0x88, 0x17, 0xf3, 0xba, 0xbf, 0x58, 0x9c, 0xbe, 0x43, 0x3d, 0x36, 0xc3, 0x92, 0x8c, + /*6930:*/ 0x31, 0x90, 0xe3, 0x05, 0x3f, 0x6a, 0x25, 0x6e, 0x65, 0xd7, 0x62, 0x60, 0x6e, 0x79, 0x02, 0x62, + /*6940:*/ 0xec, 0xd5, 0x9b, 0x99, 0xe4, 0x30, 0xd8, 0xf1, 0x99, 0x45, 0x9d, 0xfb, 0x62, 0x5a, 0x3f, 0x3e, + /*6950:*/ 0x2d, 0x75, 0x94, 0x5c, 0x04, 0x31, 0xc0, 0x56, 0xeb, 0x37, 0x29, 0x60, 0x3c, 0x29, 0x63, 0x54, + /*6960:*/ 0x24, 0x1f, 0x34, 0xd3, 0x81, 0x5c, 0x2b, 0x07, 0x78, 0x6a, 0xab, 0x85, 0x02, 0x50, 0xd3, 0x0f, + /*6970:*/ 0x0f, 0x94, 0x3b, 0x33, 0x9a, 0xcc, 0x99, 0xad, 0xcc, 0xfc, 0xa3, 0xdf, 0xc9, 0xe7, 0x90, 0xb7, + /*6980:*/ 0xc1, 0x76, 0xb5, 0x01, 0x66, 0xa1, 0x33, 0x38, 0x26, 0xa6, 0xbb, 0xff, 0xaf, 0x10, 0x27, 0x0a, + /*6990:*/ 0x96, 0x6b, 0x1d, 0x74, 0xb1, 0x7d, 0xa9, 0x17, 0x5c, 0x4f, 0x2d, 0x2e, 0x69, 0xaa, 0xb6, 0x4f, + /*69a0:*/ 0x95, 0xa7, 0x90, 0xcd, 0x1b, 0x60, 0xb0, 0x68, 0x93, 0x91, 0xba, 0x34, 0xa8, 0x2d, 0xe4, 0xfe, + /*69b0:*/ 0xa0, 0x8b, 0x9e, 0x82, 0x77, 0x7a, 0xe3, 0x32, 0xc1, 0x8c, 0x50, 0xdf, 0x49, 0x5f, 0x57, 0xd4, + /*69c0:*/ 0x55, 0xe4, 0x25, 0xf0, 0x07, 0x91, 0xaa, 0x77, 0x9b, 0xf9, 0x99, 0xfb, 0x98, 0xd0, 0x01, 0xf8, + /*69d0:*/ 0x6b, 0x14, 0xd3, 0xc1, 0x2d, 0xcb, 0x3e, 0xb7, 0xd5, 0xe8, 0x61, 0x20, 0xbd, 0xa5, 0xe3, 0xe0, + /*69e0:*/ 0x11, 0x6e, 0x3b, 0xe5, 0x6e, 0xe0, 0xdc, 0x2f, 0x4c, 0x8b, 0x14, 0xa7, 0x08, 0x93, 0xcd, 0xf3, + /*69f0:*/ 0x5c, 0x8e, 0x30, 0xab, 0x09, 0x36, 0x70, 0xe9, 0x0c, 0x09, 0x93, 0x45, 0xad, 0x2a, 0x6c, 0xdf, + /*6a00:*/ 0x30, 0xe9, 0x50, 0xae, 0x8b, 0x94, 0x5f, 0x20, 0x52, 0xf1, 0x91, 0x22, 0x07, 0xb6, 0x3a, 0x14, + /*6a10:*/ 0xa1, 0x33, 0x78, 0x80, 0xa6, 0x49, 0x08, 0xbf, 0xfc, 0xc2, 0x4c, 0x49, 0xee, 0x93, 0x33, 0x77, + /*6a20:*/ 0xfd, 0x7d, 0xb6, 0x3d, 0x23, 0x8f, 0x5a, 0x90, 0xa0, 0xe0, 0x3c, 0xc9, 0x93, 0x97, 0x00, 0x16, + /*6a30:*/ 0xc2, 0xeb, 0x9b, 0xfa, 0x24, 0x04, 0xc7, 0x9e, 0x46, 0xbf, 0x14, 0xa7, 0x97, 0x03, 0x5d, 0x25, + /*6a40:*/ 0x08, 0xb2, 0xf4, 0xa0, 0x1e, 0xe5, 0x47, 0x36, 0x64, 0x7e, 0xab, 0x5d, 0xa8, 0x04, 0x18, 0x84, + /*6a50:*/ 0x8e, 0x3d, 0x96, 0xa8, 0xc9, 0xfb, 0xe0, 0x1f, 0x8d, 0xa8, 0x77, 0x73, 0xe5, 0x6c, 0xcf, 0xbf, + /*6a60:*/ 0x65, 0x9c, 0x73, 0x73, 0xed, 0x36, 0x18, 0xbd, 0xcb, 0xd0, 0xb2, 0x87, 0xea, 0x0a, 0x18, 0xf5, + /*6a70:*/ 0x7c, 0x0f, 0xf7, 0x6b, 0x35, 0x4f, 0xd9, 0x07, 0x8a, 0xa1, 0xa4, 0x21, 0x40, 0x81, 0x75, 0xff, + /*6a80:*/ 0x73, 0xeb, 0xcb, 0xda, 0x30, 0x09, 0xd5, 0x2a, 0x30, 0x5c, 0xd7, 0x86, 0x72, 0xe5, 0xc9, 0x31, + /*6a90:*/ 0xca, 0x91, 0xc9, 0x90, 0x48, 0xae, 0x14, 0x59, 0xc3, 0x7e, 0x82, 0xb6, 0x9d, 0x56, 0x10, 0x59, + /*6aa0:*/ 0xd7, 0x14, 0xbb, 0x47, 0x61, 0xd8, 0x53, 0x2b, 0x56, 0x62, 0xf2, 0x8f, 0x84, 0x58, 0x1b, 0xfb, + /*6ab0:*/ 0x95, 0x8d, 0x29, 0x78, 0xf5, 0x35, 0xeb, 0xe0, 0xe1, 0x1e, 0x9b, 0x66, 0x5f, 0xbd, 0xf9, 0x8f, + /*6ac0:*/ 0x3d, 0x12, 0x95, 0xb2, 0xbb, 0x75, 0x84, 0x36, 0x51, 0x33, 0xfa, 0x5a, 0x32, 0x16, 0x93, 0x12, + /*6ad0:*/ 0x12, 0x31, 0xb5, 0x48, 0x14, 0xb4, 0xdc, 0xcb, 0xb3, 0x38, 0xa7, 0x0b, 0x60, 0x56, 0xfa, 0x73, + /*6ae0:*/ 0x28, 0x5d, 0xcf, 0x1b, 0x56, 0x4d, 0x6f, 0xea, 0xea, 0xbd, 0xfc, 0xe6, 0x3c, 0x5c, 0x41, 0x8a, + /*6af0:*/ 0x3f, 0x6c, 0xfc, 0x7d, 0x8b, 0x66, 0x4d, 0x51, 0x8d, 0x71, 0x0e, 0xbf, 0xdd, 0xa1, 0x1e, 0x92, + /*6b00:*/ 0x7c, 0x4e, 0xd4, 0x6e, 0x0c, 0xaa, 0x50, 0x96, 0xce, 0x90, 0x55, 0xcb, 0x86, 0x24, 0xf2, 0x33, + /*6b10:*/ 0xab, 0x9b, 0xc6, 0x60, 0x0d, 0x7f, 0x5b, 0x94, 0x16, 0xd3, 0x55, 0xb7, 0xb4, 0x9e, 0xfe, 0xf0, + /*6b20:*/ 0xdc, 0xae, 0x2c, 0xc5, 0x24, 0x0f, 0x7e, 0x99, 0xe4, 0x77, 0x0e, 0x96, 0x90, 0xe8, 0x39, 0xac, + /*6b30:*/ 0x8a, 0x53, 0xfb, 0xe8, 0x75, 0x24, 0x69, 0x6f, 0xb2, 0x11, 0x2a, 0x45, 0x2d, 0x2f, 0x87, 0xac, + /*6b40:*/ 0xfa, 0xea, 0xd5, 0x70, 0x98, 0x39, 0xdb, 0x81, 0xcd, 0x56, 0xdd, 0x4f, 0xdf, 0x78, 0xe1, 0x2c, + /*6b50:*/ 0xab, 0x35, 0x54, 0x37, 0x11, 0xf7, 0x23, 0x31, 0xda, 0xb1, 0xd8, 0x76, 0x2e, 0x86, 0xaa, 0xc7, + /*6b60:*/ 0x8e, 0x73, 0x6a, 0xba, 0x2a, 0x98, 0xd3, 0x6b, 0x8a, 0x1f, 0x1d, 0xd3, 0xe9, 0x04, 0x3f, 0xf0, + /*6b70:*/ 0xdb, 0xb8, 0x06, 0xd9, 0xae, 0x7e, 0xcb, 0xbf, 0x3d, 0x85, 0xa6, 0x10, 0x30, 0xbc, 0x04, 0x96, + /*6b80:*/ 0x2a, 0xc8, 0x89, 0xa9, 0xa6, 0x14, 0xdc, 0x75, 0x4d, 0x5a, 0xe5, 0x4a, 0x89, 0x49, 0x58, 0x1a, + /*6b90:*/ 0x4a, 0x07, 0x55, 0x28, 0xd8, 0x5a, 0x12, 0xa0, 0x97, 0x0e, 0xcb, 0x3b, 0x70, 0xb1, 0xa9, 0xaf, + /*6ba0:*/ 0x3a, 0xd3, 0x5b, 0xbb, 0x07, 0x4a, 0x3e, 0x04, 0xa7, 0x2f, 0x1e, 0xb7, 0xa3, 0x80, 0xa5, 0x5d, + /*6bb0:*/ 0x52, 0x1c, 0x45, 0xd4, 0x11, 0xdf, 0x1a, 0xc0, 0x8d, 0xf6, 0xe4, 0x87, 0x07, 0xa3, 0xb3, 0xa1, + /*6bc0:*/ 0xe0, 0x5d, 0x68, 0x0a, 0x2f, 0x94, 0xc3, 0xab, 0x98, 0x76, 0x5e, 0x71, 0xf3, 0x75, 0xb2, 0xcd, + /*6bd0:*/ 0x38, 0x38, 0x8e, 0xa3, 0x10, 0xb8, 0xc3, 0x83, 0x71, 0xde, 0x20, 0xa2, 0x62, 0xa9, 0x5f, 0x28, + /*6be0:*/ 0xbb, 0xfd, 0x14, 0x11, 0x6c, 0x9f, 0x90, 0x0e, 0x47, 0x0d, 0xf0, 0x28, 0x52, 0x55, 0x1c, 0x5e, + /*6bf0:*/ 0xf2, 0x8d, 0x70, 0x81, 0x73, 0x6b, 0x7a, 0x7d, 0x21, 0x3e, 0x8e, 0x4c, 0x80, 0x38, 0x8e, 0x4c, + /*6c00:*/ 0x7e, 0x29, 0x99, 0x07, 0x05, 0x25, 0x81, 0x66, 0x64, 0x34, 0x95, 0x45, 0x8c, 0xf3, 0x00, 0x81, + /*6c10:*/ 0x81, 0xb8, 0x91, 0xb4, 0xfc, 0x83, 0xc4, 0xac, 0x60, 0xfd, 0x01, 0x04, 0x7a, 0xff, 0x87, 0x04, + /*6c20:*/ 0x79, 0x40, 0xc0, 0x93, 0x72, 0x66, 0x32, 0xc6, 0xc1, 0x42, 0xe5, 0x5e, 0x74, 0xd5, 0x3b, 0xb8, + /*6c30:*/ 0xde, 0xca, 0xbd, 0x17, 0xc0, 0x5f, 0x93, 0xe5, 0xdc, 0xe7, 0xdb, 0xf8, 0x53, 0x70, 0x01, 0x4d, + /*6c40:*/ 0x7a, 0x78, 0x1f, 0xc9, 0xa8, 0x96, 0xbb, 0xde, 0x29, 0xf8, 0x0b, 0x32, 0xd2, 0x9b, 0x00, 0x33, + /*6c50:*/ 0x96, 0xa5, 0xd6, 0x7f, 0x88, 0x78, 0x3d, 0x03, 0x39, 0x8b, 0x82, 0x48, 0x88, 0xd6, 0x2d, 0x3d, + /*6c60:*/ 0xc5, 0x13, 0xee, 0x2b, 0x61, 0x54, 0xf2, 0x10, 0xec, 0xd2, 0x8d, 0x4a, 0xc4, 0xbe, 0xef, 0x36, + /*6c70:*/ 0x39, 0x4f, 0xdc, 0x63, 0xb7, 0x0c, 0x40, 0x38, 0x47, 0x85, 0x40, 0xc7, 0x8b, 0xfa, 0x1f, 0x69, + /*6c80:*/ 0x9f, 0xd9, 0xf7, 0x4f, 0x68, 0x7f, 0x34, 0x23, 0xfc, 0x95, 0xee, 0xb2, 0x1c, 0x18, 0xda, 0x2a, + /*6c90:*/ 0x2b, 0x78, 0x53, 0x53, 0xa4, 0x32, 0x01, 0x83, 0xf6, 0x3e, 0xf5, 0x40, 0xb2, 0xae, 0x0f, 0x1f, + /*6ca0:*/ 0xf7, 0x1f, 0x7f, 0x69, 0x4e, 0x44, 0x54, 0x24, 0x2d, 0x82, 0x32, 0xd3, 0x71, 0x8f, 0xf4, 0x68, + /*6cb0:*/ 0x79, 0xc0, 0xdc, 0x98, 0xa6, 0xfb, 0x9b, 0xde, 0xa5, 0xb3, 0xea, 0xbd, 0x02, 0x64, 0xcc, 0xd9, + /*6cc0:*/ 0xa2, 0x25, 0x1c, 0x42, 0x15, 0xa8, 0xf0, 0xe5, 0x43, 0x94, 0x39, 0xaf, 0x10, 0xc3, 0x20, 0xa9, + /*6cd0:*/ 0x49, 0x2d, 0x12, 0x9f, 0x8e, 0xe5, 0x10, 0x5f, 0x67, 0xb4, 0x55, 0x7a, 0x58, 0x7c, 0xfd, 0xf0, + /*6ce0:*/ 0x13, 0x8a, 0xfe, 0xff, 0x5e, 0xfc, 0xc1, 0x93, 0x57, 0xa8, 0x7f, 0xe0, 0x5e, 0xad, 0x63, 0xa8, + /*6cf0:*/ 0x38, 0x0c, 0xa3, 0xfa, 0xb3, 0xab, 0x67, 0x4a, 0x09, 0xb8, 0xe5, 0xb2, 0xbd, 0x52, 0xa6, 0xb2, + /*6d00:*/ 0x9f, 0x07, 0xe7, 0xce, 0x31, 0xe3, 0x14, 0x82, 0x99, 0xca, 0xad, 0x55, 0x9b, 0xb6, 0x9e, 0x2f, + /*6d10:*/ 0xa4, 0x4f, 0xc7, 0xaa, 0x84, 0xfb, 0x22, 0x0a, 0x45, 0x7d, 0xab, 0x24, 0xd5, 0xe3, 0xd2, 0xb1, + /*6d20:*/ 0x12, 0xc7, 0xda, 0x73, 0xe8, 0xd4, 0x43, 0x56, 0xaa, 0x9d, 0xc9, 0x0a, 0x9a, 0x19, 0x12, 0x08, + /*6d30:*/ 0x89, 0x6f, 0x37, 0x59, 0xfe, 0x67, 0x0f, 0x3c, 0x7b, 0xae, 0x30, 0xa7, 0x1b, 0x6e, 0x8d, 0xb9, + /*6d40:*/ 0xd1, 0x6f, 0x94, 0x03, 0x95, 0x22, 0x90, 0xdd, 0x2a, 0xb2, 0xc2, 0x7a, 0x12, 0xe6, 0xad, 0x41, + /*6d50:*/ 0xe6, 0xeb, 0x85, 0x8e, 0x98, 0xc0, 0xe1, 0xeb, 0x87, 0xaa, 0xf0, 0xd4, 0xde, 0x5e, 0x32, 0xdb, + /*6d60:*/ 0x73, 0xca, 0xc8, 0x5f, 0x87, 0xca, 0x00, 0x3b, 0xfe, 0x3d, 0x0f, 0x90, 0x75, 0xe1, 0x8b, 0xf6, + /*6d70:*/ 0x73, 0x46, 0x86, 0x87, 0x98, 0xbf, 0x7d, 0x6d, 0x21, 0xec, 0xa3, 0x8c, 0x5a, 0x53, 0x48, 0x06, + /*6d80:*/ 0x56, 0x9a, 0x3d, 0x2b, 0x0a, 0xd7, 0x85, 0x14, 0x0f, 0x12, 0x19, 0x91, 0xcb, 0xb1, 0x9e, 0x6d, + /*6d90:*/ 0x9c, 0x27, 0xb2, 0x4e, 0x36, 0xeb, 0xa6, 0x25, 0x22, 0x4a, 0x15, 0x21, 0xd6, 0x23, 0xcf, 0xf1, + /*6da0:*/ 0xdf, 0xba, 0x0a, 0xb0, 0x6b, 0xd9, 0xd1, 0x43, 0xfd, 0x0a, 0xa8, 0xf3, 0xf0, 0x34, 0x78, 0x41, + /*6db0:*/ 0x7e, 0x70, 0xf4, 0x40, 0xbf, 0x82, 0x37, 0x79, 0xef, 0xe5, 0x80, 0x48, 0x1f, 0x91, 0x47, 0xd6, + /*6dc0:*/ 0x7e, 0x41, 0x92, 0x1e, 0x59, 0x28, 0x05, 0xcc, 0xa6, 0xd2, 0xb8, 0xe0, 0x2c, 0xc0, 0x23, 0x58, + /*6dd0:*/ 0x50, 0x3a, 0x96, 0x83, 0xd5, 0xa8, 0xa1, 0x82, 0x88, 0x43, 0xab, 0x0b, 0x88, 0xbe, 0xb7, 0x2d, + /*6de0:*/ 0x6f, 0x19, 0x74, 0x41, 0x6f, 0xb9, 0xd4, 0xea, 0x25, 0xe1, 0xc5, 0x62, 0x87, 0xb6, 0x0c, 0x2a, + /*6df0:*/ 0x5b, 0x9b, 0xa4, 0xa2, 0xcf, 0x9c, 0xb7, 0x60, 0x3a, 0x99, 0x1a, 0x37, 0xf9, 0xf9, 0xce, 0x49, + /*6e00:*/ 0x64, 0x2f, 0x3a, 0xc2, 0x35, 0x1b, 0x48, 0x99, 0x64, 0xdb, 0x26, 0xb4, 0x96, 0x74, 0x48, 0x2a, + /*6e10:*/ 0x98, 0x39, 0x51, 0x6b, 0x95, 0xb8, 0xaa, 0x47, 0xaf, 0xba, 0xc9, 0x75, 0x3a, 0x83, 0xf4, 0x6b, + /*6e20:*/ 0xc2, 0xe2, 0x9d, 0x35, 0x04, 0x4a, 0x7c, 0x2c, 0xa4, 0xac, 0xaf, 0xd4, 0xb6, 0x9c, 0x8c, 0xb1, + /*6e30:*/ 0xf7, 0xff, 0xca, 0xab, 0xda, 0x74, 0x70, 0xaf, 0xfc, 0x79, 0x64, 0x0f, 0x24, 0xb6, 0xab, 0x66, + /*6e40:*/ 0x0c, 0x31, 0x15, 0xaa, 0x1e, 0xa8, 0x52, 0xc2, 0x19, 0x93, 0x8c, 0x46, 0xbb, 0x66, 0x66, 0xa0, + /*6e50:*/ 0xfb, 0xc8, 0x1d, 0x39, 0x89, 0xed, 0xcc, 0x6c, 0x16, 0x88, 0x4d, 0xc4, 0x28, 0x98, 0x1b, 0x6d, + /*6e60:*/ 0xa4, 0x42, 0x67, 0x00, 0x06, 0xf8, 0xd5, 0x2b, 0xc2, 0xe3, 0xc7, 0xa7, 0x19, 0x32, 0xcf, 0x79, + /*6e70:*/ 0xce, 0x4b, 0x5f, 0x7f, 0xfe, 0xd6, 0xb1, 0xc8, 0xec, 0xe6, 0x96, 0x8b, 0x6a, 0xf6, 0xa4, 0x2b, + /*6e80:*/ 0xa7, 0x8f, 0xd8, 0xb1, 0x1f, 0xc5, 0xce, 0x24, 0xfe, 0xd0, 0xd7, 0xd7, 0xd9, 0xfb, 0x8e, 0x19, + /*6e90:*/ 0xfd, 0x6f, 0x54, 0x3a, 0x73, 0xbe, 0x0a, 0x5c, 0xd0, 0x1e, 0xf2, 0x85, 0x7c, 0x1e, 0x18, 0xc9, + /*6ea0:*/ 0x4f, 0x86, 0x9b, 0x71, 0x1f, 0x0a, 0x75, 0xc4, 0x5d, 0x68, 0xac, 0x1a, 0xef, 0xce, 0xdf, 0xb0, + /*6eb0:*/ 0x23, 0x4b, 0x79, 0xa1, 0x64, 0x86, 0x07, 0xa2, 0x91, 0x0d, 0x00, 0x36, 0xf1, 0xbe, 0xe7, 0x4a, + /*6ec0:*/ 0x03, 0x13, 0xf2, 0xc0, 0x40, 0x8a, 0x82, 0x49, 0xa8, 0x80, 0x9c, 0xda, 0x0c, 0xe8, 0xf9, 0xb3, + /*6ed0:*/ 0x5c, 0xbb, 0x5c, 0x2b, 0x8b, 0xf7, 0xdd, 0x8f, 0x7a, 0x7a, 0xac, 0x29, 0x65, 0x36, 0xb5, 0xc9, + /*6ee0:*/ 0xac, 0x60, 0x77, 0x12, 0xe3, 0x2e, 0xbf, 0x7c, 0xdd, 0x3a, 0x99, 0xe9, 0x79, 0xed, 0x36, 0x85, + /*6ef0:*/ 0x0b, 0xc5, 0xe7, 0x0d, 0xdb, 0x4d, 0x5e, 0x8c, 0x3a, 0xb5, 0xc2, 0x09, 0x52, 0xf9, 0xf8, 0x90, + /*6f00:*/ 0xbd, 0x35, 0x94, 0x27, 0x21, 0xe1, 0xbf, 0xa7, 0xb6, 0x1d, 0x31, 0x23, 0x55, 0x5c, 0xec, 0x78, + /*6f10:*/ 0xe6, 0x86, 0xd0, 0x3a, 0x32, 0x14, 0x2a, 0x20, 0x20, 0x59, 0x78, 0x24, 0xab, 0x27, 0xb5, 0xa0, + /*6f20:*/ 0x13, 0xfc, 0xf5, 0x5b, 0x1e, 0xad, 0x3a, 0x36, 0x40, 0x18, 0x4a, 0x73, 0x5b, 0xdd, 0x8d, 0xb2, + /*6f30:*/ 0xc3, 0xb9, 0xe4, 0x15, 0xf0, 0xd6, 0xf6, 0xf3, 0x5c, 0x26, 0x00, 0x22, 0xde, 0x9a, 0xa4, 0xe1, + /*6f40:*/ 0x36, 0xa6, 0xd9, 0xe7, 0xc9, 0x9e, 0xd7, 0xb2, 0x64, 0xfb, 0x24, 0xe9, 0xb0, 0xba, 0xa1, 0xa6, + /*6f50:*/ 0xc5, 0xc6, 0x7f, 0xbe, 0x22, 0x28, 0x02, 0x62, 0xb5, 0xf4, 0x38, 0xaa, 0x2d, 0x85, 0x45, 0xac, + /*6f60:*/ 0xe8, 0xcc, 0xfc, 0x2f, 0x75, 0xec, 0x09, 0xd2, 0xf5, 0x63, 0x64, 0xd0, 0x1a, 0xec, 0xfc, 0xfb, + /*6f70:*/ 0x59, 0xea, 0x70, 0x42, 0x09, 0xae, 0xe9, 0xd0, 0x4f, 0xbb, 0x34, 0xa8, 0x9e, 0x76, 0x2b, 0x13, + /*6f80:*/ 0x00, 0xe0, 0xde, 0x26, 0x12, 0x49, 0x6c, 0x1c, 0x52, 0xc1, 0x8d, 0xb9, 0x47, 0xaa, 0xff, 0xb3, + /*6f90:*/ 0x06, 0x54, 0x5e, 0x5f, 0x77, 0x82, 0x93, 0x8f, 0xd0, 0x62, 0xd6, 0xde, 0xd2, 0x00, 0xb2, 0xc2, + /*6fa0:*/ 0x7e, 0x08, 0x34, 0x9b, 0xc5, 0x2e, 0x6d, 0x3d, 0xbf, 0x06, 0xc8, 0xce, 0x3c, 0x96, 0x9b, 0x9c, + /*6fb0:*/ 0xe5, 0x94, 0x0c, 0x56, 0x4e, 0x54, 0xcf, 0xee, 0xff, 0xb3, 0x61, 0x66, 0xf3, 0x4a, 0xe0, 0x6b, + /*6fc0:*/ 0x20, 0xda, 0xe3, 0x5f, 0x04, 0xf7, 0xef, 0xc6, 0x27, 0x85, 0xb0, 0xf8, 0xf0, 0xf5, 0x37, 0x50, + /*6fd0:*/ 0x34, 0x5d, 0xde, 0x5e, 0x20, 0x57, 0x95, 0xe4, 0x30, 0x0d, 0xa9, 0xe8, 0x05, 0xb8, 0x5e, 0xbe, + /*6fe0:*/ 0x2d, 0x74, 0x7b, 0x4b, 0xff, 0x5a, 0x88, 0x31, 0xe5, 0x11, 0xe3, 0x90, 0xef, 0xb3, 0xd1, 0x28, + /*6ff0:*/ 0x92, 0x24, 0x4d, 0x93, 0xd3, 0x9c, 0xbf, 0xfc, 0x9d, 0x1f, 0x80, 0x4c, 0xdb, 0xbc, 0x82, 0x3f, + /*7000:*/ 0x0d, 0xc9, 0xa6, 0xf5, 0x90, 0x95, 0x0c, 0x18, 0x9b, 0x5a, 0x08, 0xe4, 0x6d, 0xed, 0x36, 0x63, + /*7010:*/ 0x78, 0x36, 0x56, 0xfc, 0x40, 0xa9, 0xbb, 0x23, 0xbe, 0x39, 0x16, 0xae, 0xe9, 0x3d, 0x2c, 0xc8, + /*7020:*/ 0x3f, 0x70, 0xfc, 0x9d, 0x6d, 0x3b, 0xc8, 0x75, 0xb5, 0x62, 0x8a, 0x80, 0xea, 0x90, 0x25, 0x1b, + /*7030:*/ 0xc2, 0x6c, 0x24, 0xc8, 0xab, 0x99, 0x6e, 0x32, 0x59, 0x3e, 0x03, 0xd1, 0xab, 0x20, 0xab, 0x64, + /*7040:*/ 0x55, 0xf5, 0x98, 0x31, 0x92, 0xc5, 0xcd, 0x26, 0x97, 0xe0, 0x80, 0xc5, 0xfe, 0x65, 0xd4, 0x21, + /*7050:*/ 0x45, 0x9e, 0xee, 0xad, 0x59, 0xd5, 0x32, 0x61, 0x62, 0x6b, 0x86, 0x53, 0xeb, 0xed, 0x36, 0x4c, + /*7060:*/ 0x59, 0x1e, 0x0f, 0xc7, 0xcf, 0xf4, 0x9b, 0x8c, 0x43, 0x08, 0x2f, 0x9a, 0x5e, 0x2c, 0x1f, 0xdb, + /*7070:*/ 0x5e, 0xd7, 0x0b, 0xe8, 0x4e, 0xe5, 0x76, 0x67, 0x18, 0xdc, 0xd9, 0x6e, 0x64, 0xf4, 0x8f, 0x98, + /*7080:*/ 0x47, 0x2f, 0x8d, 0x85, 0xbe, 0x9c, 0xd7, 0xaf, 0x2e, 0x56, 0x82, 0x9d, 0x71, 0x91, 0xbd, 0x7d, + /*7090:*/ 0xdd, 0x40, 0x85, 0xd9, 0x40, 0x7b, 0x2d, 0x51, 0xd6, 0xf4, 0xc9, 0x49, 0x1d, 0x5f, 0x1a, 0x23, + /*70a0:*/ 0xdc, 0xa7, 0x67, 0x16, 0xe4, 0xde, 0x7b, 0xd9, 0xf0, 0xd6, 0x0d, 0x0f, 0x20, 0x06, 0x22, 0x70, + /*70b0:*/ 0xcb, 0x63, 0x94, 0xab, 0xdb, 0xc8, 0x3c, 0xa6, 0x20, 0x70, 0xf4, 0xf4, 0x01, 0xac, 0x8e, 0xc7, + /*70c0:*/ 0x5a, 0x3c, 0x38, 0x5f, 0x39, 0x06, 0x47, 0x35, 0x5c, 0x98, 0xbf, 0x9c, 0x59, 0xd0, 0x8d, 0x2f, + /*70d0:*/ 0x73, 0x13, 0x06, 0x14, 0x5c, 0x10, 0xc6, 0x17, 0x87, 0xc6, 0x4d, 0x1e, 0x54, 0x67, 0x94, 0x2c, + /*70e0:*/ 0xf2, 0xfc, 0x9f, 0x8a, 0x55, 0x8e, 0xd4, 0x16, 0x76, 0xe2, 0x4f, 0x94, 0x29, 0xc9, 0x27, 0xd4, + /*70f0:*/ 0x84, 0xd1, 0xc3, 0x33, 0xc7, 0xf3, 0x5c, 0x82, 0x11, 0x95, 0x4f, 0xfb, 0x7b, 0xa1, 0x4d, 0xb4, + /*7100:*/ 0x8c, 0x83, 0xec, 0xb6, 0xb2, 0x27, 0xaf, 0xeb, 0x31, 0x07, 0x52, 0x40, 0xd0, 0xc4, 0x75, 0x78, + /*7110:*/ 0xf5, 0xcf, 0x28, 0xce, 0x4d, 0xcb, 0x72, 0x87, 0x97, 0x48, 0x7c, 0xc2, 0x76, 0xc7, 0x43, 0x36, + /*7120:*/ 0xa5, 0x95, 0x0f, 0x90, 0x8b, 0x0a, 0x90, 0xf0, 0xb3, 0x37, 0x59, 0x9d, 0x0a, 0xde, 0x1a, 0x3a, + /*7130:*/ 0x6e, 0xcd, 0xff, 0x66, 0x15, 0xef, 0xcc, 0x5b, 0x83, 0x84, 0x76, 0x9d, 0x07, 0xb3, 0xe4, 0x1c, + /*7140:*/ 0x36, 0xb3, 0x99, 0xf6, 0x62, 0x6c, 0x96, 0x5d, 0x56, 0xa7, 0xd7, 0xf2, 0xe2, 0x39, 0x9e, 0x63, + /*7150:*/ 0x54, 0x2b, 0x45, 0xc4, 0x4e, 0x55, 0x92, 0x80, 0xd7, 0x24, 0x4d, 0x05, 0x3a, 0x86, 0x34, 0x17, + /*7160:*/ 0xb1, 0x09, 0xb4, 0xaf, 0x34, 0x35, 0x69, 0x4f, 0x74, 0x1e, 0x9e, 0x8f, 0x9f, 0x7d, 0x89, 0x7d, + /*7170:*/ 0x7e, 0x5a, 0x0a, 0x38, 0xe1, 0x53, 0x73, 0x9a, 0x80, 0xdc, 0xea, 0x3f, 0x79, 0xf0, 0xd8, 0x48, + /*7180:*/ 0x7f, 0xf7, 0xc8, 0x73, 0x20, 0x3f, 0xbe, 0x71, 0xec, 0xc5, 0x8a, 0x65, 0x17, 0x16, 0xd0, 0xf4, + /*7190:*/ 0x7f, 0x21, 0x33, 0x94, 0xe1, 0xa5, 0x93, 0x32, 0x02, 0x0f, 0x3b, 0x74, 0x97, 0x88, 0x59, 0xcb, + /*71a0:*/ 0x12, 0xc5, 0x80, 0xd8, 0x7a, 0xe5, 0x89, 0x0c, 0x09, 0x62, 0x2b, 0x58, 0x9b, 0xef, 0xb5, 0x21, + /*71b0:*/ 0xed, 0xb2, 0x70, 0x45, 0x9e, 0x17, 0x87, 0x3b, 0x1b, 0xef, 0xb1, 0xee, 0xea, 0x0f, 0x6f, 0x70, + /*71c0:*/ 0x7d, 0x4d, 0xf9, 0x40, 0x11, 0x81, 0x97, 0xe7, 0x08, 0x94, 0x64, 0xd3, 0xe1, 0xbe, 0x76, 0xec, + /*71d0:*/ 0x95, 0x29, 0x5a, 0x83, 0xb3, 0x75, 0xd7, 0x10, 0xb1, 0x55, 0x7f, 0xc5, 0xd2, 0x57, 0xe3, 0xf8, + /*71e0:*/ 0xf0, 0x78, 0xef, 0xd9, 0x9a, 0xa5, 0xa8, 0xf6, 0x3d, 0xc8, 0xf2, 0xce, 0x58, 0xf0, 0x4b, 0x5a, + /*71f0:*/ 0xf3, 0xb7, 0xb3, 0xc8, 0x94, 0xe8, 0x1f, 0xef, 0x4b, 0x1d, 0x03, 0x0b, 0xc2, 0x51, 0xbf, 0x48, + /*7200:*/ 0xa7, 0xcf, 0xbe, 0x93, 0x5d, 0x93, 0x21, 0xfc, 0x33, 0x45, 0x6d, 0x79, 0xee, 0xb1, 0x8a, 0x60, + /*7210:*/ 0x70, 0xce, 0x7c, 0xbc, 0x58, 0x0b, 0x34, 0xb3, 0x8c, 0xd6, 0x8f, 0x94, 0x50, 0xbf, 0x0b, 0x50, + /*7220:*/ 0xc4, 0xf9, 0x9a, 0xd7, 0x95, 0x1e, 0xb0, 0x53, 0xe8, 0xd8, 0x14, 0x9e, 0x13, 0x5b, 0x9c, 0x9f, + /*7230:*/ 0xb4, 0xf5, 0x0d, 0x65, 0xfa, 0xe2, 0xaf, 0x04, 0x94, 0xda, 0x9f, 0x8e, 0x31, 0x0e, 0x66, 0xb6, + /*7240:*/ 0x45, 0x8b, 0xa5, 0xb5, 0xbc, 0x10, 0x30, 0xcf, 0xf7, 0x77, 0x79, 0x87, 0xd4, 0xe4, 0x32, 0xe3, + /*7250:*/ 0xce, 0x97, 0x4d, 0x63, 0xe8, 0xe5, 0x06, 0xf1, 0x3b, 0x30, 0x29, 0x35, 0xab, 0xe4, 0x46, 0x68, + /*7260:*/ 0x77, 0x94, 0xf7, 0x0d, 0x82, 0xf7, 0x61, 0xcb, 0x84, 0x2f, 0x2f, 0xfe, 0x5d, 0xe1, 0x25, 0x93, + /*7270:*/ 0xe2, 0xb3, 0xd2, 0x35, 0xf0, 0x3d, 0x43, 0x20, 0x1d, 0x4e, 0x9f, 0x35, 0x8c, 0x44, 0x95, 0xc5, + /*7280:*/ 0x71, 0x12, 0xd2, 0xc7, 0x8b, 0xf1, 0x30, 0x4a, 0x49, 0x51, 0xe4, 0xe9, 0x03, 0x9b, 0x14, 0x51, + /*7290:*/ 0x90, 0xbd, 0xbb, 0x9c, 0x21, 0xb8, 0xe0, 0x51, 0xe3, 0xca, 0xf4, 0xb4, 0x10, 0xd5, 0xa4, 0x8d, + /*72a0:*/ 0x9d, 0x3f, 0x28, 0x73, 0x7e, 0x5b, 0x6c, 0xe7, 0xca, 0x57, 0x66, 0x8d, 0x5b, 0x34, 0xe9, 0xaa, + /*72b0:*/ 0xb4, 0x2f, 0x56, 0x49, 0x1e, 0xa9, 0x14, 0xed, 0x2b, 0xee, 0x43, 0xa1, 0x3e, 0x10, 0xa4, 0xed, + /*72c0:*/ 0x1a, 0x13, 0xad, 0x78, 0x7a, 0xf2, 0x6e, 0xad, 0xca, 0x30, 0x2a, 0xa1, 0xd8, 0xf8, 0xe1, 0xd1, + /*72d0:*/ 0x91, 0x68, 0x5f, 0x6e, 0xd9, 0x06, 0x91, 0xd2, 0x8b, 0x2a, 0x9e, 0x29, 0x8c, 0xca, 0x5f, 0x46, + /*72e0:*/ 0x77, 0x6c, 0x19, 0xdc, 0x92, 0xf9, 0x8f, 0xc9, 0x68, 0x21, 0xe7, 0x6b, 0x89, 0xf5, 0x83, 0xa8, + /*72f0:*/ 0x6b, 0x9d, 0xe0, 0x1d, 0x77, 0x20, 0x16, 0x66, 0xe6, 0x53, 0xda, 0x32, 0x02, 0x39, 0x09, 0xcf, + /*7300:*/ 0xed, 0x34, 0xec, 0x87, 0xf7, 0xc0, 0x8d, 0xc7, 0xfc, 0x05, 0x7f, 0xc0, 0x6c, 0x78, 0x7c, 0xd9, + /*7310:*/ 0xa3, 0x30, 0xe3, 0xa2, 0x14, 0x0f, 0x42, 0xd6, 0x16, 0x62, 0xcb, 0xb6, 0x4a, 0xf4, 0xab, 0xee, + /*7320:*/ 0x29, 0x7e, 0xf3, 0xc1, 0x8e, 0xb9, 0xdd, 0x61, 0x44, 0x82, 0x2f, 0x1f, 0xc0, 0x28, 0x36, 0xb8, + /*7330:*/ 0x2c, 0xec, 0x2a, 0x4c, 0xe7, 0x50, 0x37, 0x9b, 0x6f, 0xb3, 0xb3, 0xc2, 0x1b, 0xf4, 0x91, 0x88, + /*7340:*/ 0x46, 0xb8, 0x2a, 0xbe, 0xc9, 0x56, 0x4e, 0x74, 0x16, 0xd7, 0x1f, 0x49, 0x3b, 0x50, 0xf2, 0x60, + /*7350:*/ 0xbe, 0x0f, 0x3d, 0x79, 0x4b, 0xae, 0x5d, 0xe5, 0x8b, 0xea, 0xd9, 0xe6, 0xca, 0x84, 0x85, 0x93, + /*7360:*/ 0x84, 0x98, 0x10, 0x0b, 0xa6, 0xfb, 0xb2, 0xa5, 0x3c, 0xc2, 0x79, 0x75, 0x56, 0x69, 0x26, 0x55, + /*7370:*/ 0x61, 0x6e, 0xf3, 0x3d, 0xb3, 0xfa, 0xdc, 0xd1, 0xe4, 0x57, 0x8f, 0x8f, 0x04, 0x61, 0xec, 0x42, + /*7380:*/ 0x6b, 0xe2, 0x89, 0xe2, 0x22, 0xc4, 0xde, 0x2e, 0xae, 0x0f, 0x78, 0x73, 0x0a, 0x7f, 0x33, 0x4a, + /*7390:*/ 0x26, 0x13, 0x11, 0x73, 0x32, 0x7f, 0x30, 0x28, 0x02, 0x40, 0x19, 0xfc, 0xaf, 0xf0, 0x12, 0x0c, + /*73a0:*/ 0x64, 0xcd, 0x83, 0x47, 0x66, 0x7e, 0xa5, 0x45, 0x0c, 0x91, 0xd4, 0x13, 0x45, 0x83, 0xd2, 0xbe, + /*73b0:*/ 0x1e, 0x7b, 0x00, 0x43, 0xd8, 0x12, 0x6c, 0xfe, 0xc4, 0x15, 0x34, 0x6e, 0x17, 0xb0, 0x18, 0x72, + /*73c0:*/ 0xc1, 0x08, 0x8d, 0x8c, 0x25, 0x24, 0x1a, 0xce, 0x06, 0xdb, 0x34, 0x8d, 0xec, 0xcb, 0x95, 0xf0, + /*73d0:*/ 0x09, 0x72, 0xa5, 0x5a, 0x22, 0x99, 0x0a, 0x93, 0x88, 0xea, 0x6e, 0x50, 0x80, 0x35, 0x0a, 0x12, + /*73e0:*/ 0x3f, 0x88, 0x4e, 0xe9, 0x64, 0x70, 0xc9, 0xea, 0x5a, 0xe1, 0x43, 0xe7, 0xb3, 0xd0, 0x32, 0x16, + /*73f0:*/ 0x58, 0xbf, 0x4b, 0xa0, 0x40, 0x26, 0xad, 0x4f, 0x83, 0xbe, 0x44, 0xbd, 0x29, 0xb2, 0x11, 0xd7, + /*7400:*/ 0x7a, 0x23, 0xe5, 0xc5, 0xda, 0xfc, 0xa6, 0xf8, 0xa1, 0x26, 0x99, 0xb3, 0xbb, 0x3d, 0xe6, 0x37, + /*7410:*/ 0x24, 0x36, 0x89, 0xa3, 0x67, 0x9b, 0x16, 0x46, 0xdf, 0x9c, 0x09, 0x07, 0x00, 0xf7, 0x14, 0xac, + /*7420:*/ 0x6c, 0x88, 0x2f, 0xfe, 0x3a, 0x88, 0xf2, 0xbf, 0x88, 0x87, 0x4e, 0xe5, 0x1a, 0xad, 0x70, 0x79, + /*7430:*/ 0x85, 0x2c, 0xa4, 0x2c, 0xf7, 0x8c, 0x2c, 0x9c, 0x16, 0x07, 0x3b, 0x64, 0x62, 0x94, 0x6b, 0xca, + /*7440:*/ 0x30, 0x6f, 0xe6, 0x86, 0x71, 0x82, 0x32, 0xd5, 0x22, 0xb7, 0x69, 0x44, 0x82, 0xab, 0xaa, 0xe1, + /*7450:*/ 0x5e, 0xf3, 0xd6, 0xb3, 0xf9, 0xe0, 0x1a, 0xfa, 0xf5, 0x54, 0x11, 0x7d, 0xf7, 0x38, 0xdb, 0x31, + /*7460:*/ 0x38, 0xfb, 0xf4, 0x3b, 0x47, 0x90, 0x1c, 0x57, 0xbf, 0x66, 0x4e, 0x68, 0xd9, 0x67, 0x03, 0x5a, + /*7470:*/ 0xa8, 0xd9, 0xe9, 0x91, 0xee, 0x66, 0x9c, 0x5f, 0xeb, 0x18, 0x12, 0xaf, 0x90, 0xf7, 0x58, 0x13, + /*7480:*/ 0x41, 0x5e, 0xa9, 0x66, 0xd7, 0x8a, 0xe7, 0x0c, 0xe9, 0x47, 0xa8, 0x96, 0x25, 0x7c, 0x5c, 0x38, + /*7490:*/ 0x46, 0xbc, 0x5a, 0x3d, 0x7f, 0xed, 0x9e, 0xc2, 0xc0, 0xde, 0x93, 0xcb, 0xfc, 0x19, 0x47, 0x5c, + /*74a0:*/ 0x5a, 0xca, 0x38, 0xd1, 0x88, 0xac, 0x7f, 0xf9, 0xad, 0x6f, 0x90, 0x62, 0x80, 0x6a, 0xac, 0x5e, + /*74b0:*/ 0x5c, 0x58, 0xfd, 0xa2, 0x62, 0xf8, 0x05, 0xbb, 0x5d, 0x63, 0x32, 0x74, 0x74, 0xc9, 0x1e, 0x28, + /*74c0:*/ 0xb6, 0x0e, 0x16, 0xa7, 0x4e, 0xc1, 0x51, 0x8e, 0x0d, 0xad, 0x1c, 0x8d, 0x3e, 0x86, 0x2b, 0x99, + /*74d0:*/ 0x77, 0x7c, 0x97, 0x70, 0xe9, 0xdf, 0x15, 0x83, 0xa9, 0x9c, 0x92, 0x7a, 0xf5, 0x54, 0x98, 0x7b, + /*74e0:*/ 0x33, 0xdf, 0xfb, 0xac, 0xde, 0xe8, 0x89, 0xda, 0x49, 0x77, 0x99, 0x22, 0xac, 0x52, 0x21, 0xf6, + /*74f0:*/ 0x7c, 0xf5, 0xa1, 0x67, 0x21, 0xc1, 0x7f, 0x65, 0x96, 0xcb, 0x84, 0x67, 0x1e, 0x87, 0x0f, 0x19, + /*7500:*/ 0x92, 0x53, 0x19, 0xce, 0x4f, 0xc5, 0x26, 0xef, 0x5b, 0xe6, 0xee, 0x9e, 0xe0, 0x4e, 0x26, 0xbc, + /*7510:*/ 0xa7, 0xe7, 0x06, 0x2d, 0x20, 0xd6, 0x5b, 0xe9, 0x57, 0x05, 0x50, 0xc1, 0x53, 0x3d, 0x0c, 0x29, + /*7520:*/ 0xc3, 0xb3, 0xd1, 0xe4, 0x20, 0x0f, 0xe1, 0xad, 0x1d, 0x0d, 0xe8, 0xd9, 0x8f, 0x32, 0xf8, 0x85, + /*7530:*/ 0xf4, 0xac, 0x21, 0x01, 0x5a, 0x64, 0xc8, 0x8c, 0x40, 0x2f, 0xf8, 0x52, 0xc8, 0x4d, 0x41, 0x2e, + /*7540:*/ 0x6d, 0x97, 0x57, 0x37, 0xca, 0xef, 0xba, 0x0a, 0xb2, 0x15, 0x38, 0x4c, 0xa1, 0xe1, 0x94, 0x1e, + /*7550:*/ 0xc2, 0x8e, 0x58, 0xe4, 0x8b, 0x6d, 0x52, 0x1d, 0x15, 0x7b, 0x10, 0x4b, 0x50, 0x32, 0x7b, 0xff, + /*7560:*/ 0x7b, 0xd4, 0xd9, 0xc6, 0x26, 0x21, 0x76, 0xf7, 0x4f, 0x9d, 0x35, 0x56, 0x50, 0x5a, 0x0b, 0x94, + /*7570:*/ 0x8d, 0x60, 0x84, 0x4d, 0xb2, 0xb3, 0x75, 0x9d, 0x34, 0xf6, 0x8f, 0x2d, 0xc9, 0x48, 0xd9, 0x16, + /*7580:*/ 0x20, 0xb4, 0xfa, 0xd4, 0x03, 0x1c, 0x0b, 0x6f, 0x56, 0x4a, 0x7b, 0x5b, 0x00, 0x4d, 0x09, 0x98, + /*7590:*/ 0x73, 0xd2, 0x14, 0xe7, 0xef, 0xc6, 0xba, 0x03, 0xab, 0xf9, 0xc4, 0x49, 0xa1, 0xc2, 0x56, 0xa5, + /*75a0:*/ 0x6b, 0xbc, 0x91, 0x76, 0x80, 0xc8, 0x85, 0x39, 0xd1, 0x05, 0x81, 0x7a, 0x78, 0x91, 0x7c, 0x4e, + /*75b0:*/ 0x15, 0x5a, 0x67, 0x76, 0x08, 0xa5, 0x76, 0xf1, 0x6f, 0xc4, 0x6d, 0x36, 0x40, 0xc1, 0x0a, 0x2b, + /*75c0:*/ 0xa3, 0x03, 0x6a, 0xf3, 0x20, 0xcc, 0x39, 0x24, 0x15, 0x21, 0x0d, 0xff, 0x0d, 0x75, 0x38, 0x93, + /*75d0:*/ 0x5a, 0x5b, 0xb0, 0x95, 0x27, 0x16, 0x4a, 0xd2, 0xf2, 0x44, 0x76, 0x1d, 0x01, 0xef, 0xf2, 0x9e, + /*75e0:*/ 0x92, 0xad, 0xe9, 0x00, 0x96, 0x51, 0x59, 0x9e, 0x03, 0xf8, 0xc4, 0xe8, 0xbb, 0xec, 0xa8, 0xce, + /*75f0:*/ 0x38, 0xb2, 0xc6, 0x7d, 0x8f, 0x08, 0xc8, 0xb1, 0x94, 0x41, 0xa8, 0xa0, 0x33, 0xcd, 0x6e, 0x85, + /*7600:*/ 0x56, 0x54, 0xf8, 0x93, 0xec, 0x92, 0x43, 0xee, 0xed, 0xac, 0xa6, 0x1a, 0xa6, 0xcd, 0x2a, 0xe5, + /*7610:*/ 0x78, 0xf5, 0x2e, 0x44, 0xaf, 0x5b, 0x21, 0x55, 0x12, 0x75, 0xf3, 0xb6, 0x09, 0x9c, 0x1a, 0x79, + /*7620:*/ 0xc3, 0xf4, 0x5c, 0x5f, 0xb9, 0xb9, 0xf1, 0x0b, 0x90, 0xf1, 0xc9, 0x81, 0x2c, 0x1f, 0xea, 0x57, + /*7630:*/ 0xfb, 0xce, 0x80, 0x90, 0xbc, 0x2b, 0x6b, 0x19, 0xaa, 0x6e, 0xef, 0xc3, 0xff, 0x04, 0x5a, 0x46, + /*7640:*/ 0x1a, 0x31, 0x58, 0x59, 0x90, 0x51, 0x5b, 0x6e, 0x8d, 0x0e, 0x03, 0xd9, 0x1f, 0x97, 0xdd, 0xdf, + /*7650:*/ 0x8c, 0xc7, 0xf7, 0x9c, 0x35, 0xfb, 0x11, 0xb1, 0x46, 0x93, 0x50, 0x93, 0xa4, 0xab, 0x2a, 0x9c, + /*7660:*/ 0xc9, 0x05, 0x67, 0x82, 0x4c, 0xa9, 0x5f, 0x12, 0xf0, 0xb4, 0x09, 0xe5, 0x95, 0x16, 0xa4, 0xd2, + /*7670:*/ 0x49, 0x01, 0x37, 0xb8, 0x69, 0xdf, 0x89, 0xbc, 0xe5, 0x9a, 0x0c, 0x6a, 0xfd, 0xae, 0xd9, 0xa0, + /*7680:*/ 0x3c, 0xeb, 0xb6, 0x4c, 0xe9, 0xcb, 0xc2, 0x88, 0xc6, 0x67, 0x8e, 0xa7, 0x69, 0xf5, 0xfc, 0xb6, + /*7690:*/ 0xb7, 0x26, 0xf1, 0x13, 0x9f, 0x30, 0xd2, 0x0f, 0xb0, 0x45, 0x39, 0x32, 0xc7, 0x37, 0xb2, 0xc4, + /*76a0:*/ 0x0c, 0xbd, 0x8b, 0xff, 0x2f, 0x79, 0x0c, 0x2a, 0xbe, 0x7b, 0xf5, 0x8e, 0x23, 0xb9, 0x83, 0xe2, + /*76b0:*/ 0xbe, 0x90, 0xcd, 0xa3, 0x81, 0x81, 0x64, 0x24, 0xf4, 0x09, 0x27, 0x58, 0xf5, 0x9e, 0x96, 0x1a, + /*76c0:*/ 0xd6, 0x75, 0x92, 0x63, 0x18, 0xd8, 0xe6, 0x5e, 0x83, 0x9e, 0x1a, 0xaf, 0xcf, 0x68, 0x72, 0xdc, + /*76d0:*/ 0xc3, 0x7b, 0xcb, 0x32, 0x28, 0x84, 0xfd, 0x6c, 0x39, 0x1d, 0xc9, 0x9c, 0x17, 0x2d, 0x28, 0x75, + /*76e0:*/ 0xba, 0xa4, 0x00, 0xea, 0xe6, 0x04, 0x1e, 0x70, 0x27, 0x67, 0xff, 0x5b, 0xdd, 0xd1, 0x8f, 0xfc, + /*76f0:*/ 0x71, 0x27, 0xd1, 0x53, 0xf3, 0xc6, 0xb3, 0x52, 0x47, 0x43, 0x6a, 0x01, 0x07, 0xf6, 0x0a, 0x21, + /*7700:*/ 0x2a, 0xda, 0x4e, 0x03, 0x41, 0x2f, 0xee, 0x85, 0xae, 0x7f, 0x3b, 0xe6, 0x38, 0xf7, 0x97, 0xde, + /*7710:*/ 0xf5, 0x67, 0x10, 0x52, 0xd5, 0x20, 0x73, 0x1b, 0xd9, 0x6b, 0x5c, 0x9a, 0x00, 0x90, 0xbc, 0xd3, + /*7720:*/ 0x9c, 0x8d, 0x26, 0x87, 0x97, 0x94, 0x8f, 0x6f, 0x05, 0x64, 0x8d, 0x7b, 0x6f, 0x51, 0xf1, 0xf1, + /*7730:*/ 0x43, 0xd2, 0xa3, 0x5e, 0xd5, 0x93, 0x4a, 0xe1, 0x83, 0x84, 0x7c, 0xde, 0xcf, 0x65, 0x1f, 0x6a, + /*7740:*/ 0x45, 0xba, 0x07, 0xa6, 0x8e, 0xe4, 0x01, 0x4d, 0x22, 0xdf, 0x00, 0x22, 0x39, 0x75, 0x3e, 0x0d, + /*7750:*/ 0x8d, 0x3c, 0x68, 0x5b, 0x7c, 0x81, 0xd1, 0xc6, 0x79, 0x2b, 0x54, 0xb7, 0xc1, 0x86, 0x2e, 0x03, + /*7760:*/ 0x44, 0xa6, 0xc0, 0xe0, 0x17, 0x59, 0x3a, 0xed, 0x0b, 0x6b, 0x0c, 0x08, 0x0a, 0xce, 0x9a, 0x31, + /*7770:*/ 0xa5, 0x94, 0x3c, 0x96, 0x29, 0x8f, 0xc7, 0xb0, 0xa3, 0x54, 0x91, 0x0d, 0xd5, 0x5e, 0xb3, 0x73, + /*7780:*/ 0x1a, 0xf6, 0x69, 0xb4, 0xb0, 0x16, 0xc1, 0x28, 0xdc, 0xbd, 0x4e, 0x2f, 0x89, 0x9d, 0xd2, 0xfe, + /*7790:*/ 0x4f, 0xb9, 0x7b, 0x81, 0xcb, 0xf3, 0x67, 0x99, 0x85, 0x44, 0x62, 0xb0, 0x77, 0xd8, 0x3b, 0x2b, + /*77a0:*/ 0xda, 0x8d, 0xcd, 0xa2, 0xf5, 0x00, 0x35, 0x98, 0xc2, 0xb0, 0x1f, 0x8d, 0x24, 0xac, 0x42, 0x1b, + /*77b0:*/ 0x8b, 0xe7, 0xc0, 0x66, 0xa8, 0x91, 0xf0, 0x68, 0x0b, 0x21, 0xe2, 0x0d, 0x71, 0x7f, 0x10, 0x7f, + /*77c0:*/ 0x54, 0x0d, 0x77, 0x01, 0x21, 0x48, 0xde, 0x35, 0x7d, 0x3d, 0x7d, 0xde, 0xc1, 0x3a, 0x18, 0x27, + /*77d0:*/ 0x63, 0xb2, 0x81, 0x34, 0x6f, 0x6f, 0x61, 0x8f, 0xd4, 0xcb, 0x95, 0x14, 0x13, 0xc5, 0x62, 0xf2, + /*77e0:*/ 0x53, 0xed, 0xad, 0x38, 0x92, 0x7d, 0xd5, 0x1b, 0x10, 0x45, 0x42, 0x78, 0xd1, 0x85, 0x2c, 0x42, + /*77f0:*/ 0xcb, 0x72, 0x74, 0x0b, 0x8a, 0x08, 0x39, 0x7b, 0x7b, 0xdb, 0x97, 0x69, 0xcc, 0x22, 0xc7, 0x6e, + /*7800:*/ 0x13, 0x5a, 0x2b, 0x90, 0x4b, 0xd7, 0xb3, 0x54, 0x7b, 0x64, 0xf4, 0x4e, 0x3e, 0xd2, 0xd1, 0xf0, + /*7810:*/ 0xbb, 0xa5, 0xab, 0xd4, 0xd7, 0x5d, 0xb4, 0x4b, 0x43, 0x8b, 0xe4, 0x0b, 0x27, 0xcb, 0x4c, 0xf9, + /*7820:*/ 0xe8, 0x9c, 0x24, 0x68, 0x42, 0x57, 0x9f, 0xa6, 0xc9, 0xc7, 0x53, 0xfc, 0x94, 0x1b, 0x18, 0x97, + /*7830:*/ 0xd5, 0xeb, 0x24, 0xbc, 0xb9, 0xaa, 0xc8, 0xe0, 0x01, 0x30, 0xc5, 0x01, 0x49, 0xc3, 0x61, 0x8a, + /*7840:*/ 0x47, 0x7a, 0x8d, 0x5b, 0x74, 0x0d, 0x48, 0xbf, 0x0c, 0xb3, 0xec, 0xe9, 0xe0, 0x1f, 0x6c, 0x36, + /*7850:*/ 0x67, 0xb7, 0xa1, 0xec, 0x9d, 0x51, 0x00, 0x4e, 0x2f, 0x58, 0xae, 0x7f, 0x61, 0x2e, 0x79, 0x24, + /*7860:*/ 0x50, 0x38, 0xe2, 0x3e, 0xc4, 0x00, 0xbb, 0xf2, 0x25, 0x5b, 0xa8, 0xf6, 0x75, 0x58, 0x30, 0xd9, + /*7870:*/ 0x63, 0x46, 0x4a, 0x62, 0xfc, 0x47, 0x83, 0xb5, 0xb7, 0xb0, 0x21, 0xf1, 0xfb, 0xaa, 0x6b, 0x17, + /*7880:*/ 0xb9, 0xa9, 0xea, 0xd0, 0x98, 0xfc, 0xd5, 0x76, 0x4f, 0x7f, 0x04, 0x69, 0x70, 0x49, 0xcc, 0x34, + /*7890:*/ 0x1f, 0x88, 0x0f, 0x63, 0x29, 0x47, 0x15, 0x56, 0x30, 0xfc, 0x99, 0xa9, 0xb9, 0x1a, 0x42, 0xe3, + /*78a0:*/ 0x0f, 0x28, 0x7a, 0xed, 0xca, 0xad, 0x55, 0x0f, 0xd7, 0xca, 0x5a, 0xae, 0x61, 0x4b, 0x24, 0xd2, + /*78b0:*/ 0x77, 0x68, 0xcc, 0xd2, 0x4f, 0x97, 0xc2, 0xeb, 0x79, 0x5c, 0x0a, 0xfe, 0x90, 0x5a, 0x31, 0xcb, + /*78c0:*/ 0x26, 0xa4, 0x73, 0x1e, 0xea, 0x43, 0xd4, 0x64, 0x6e, 0x0c, 0x07, 0x9d, 0xea, 0x6c, 0x91, 0x3c, + /*78d0:*/ 0x86, 0x72, 0xa6, 0xf2, 0xcd, 0x87, 0xc8, 0xbb, 0xfd, 0xef, 0x05, 0xa1, 0xf7, 0xff, 0x5f, 0x08, + /*78e0:*/ 0xc3, 0xc6, 0x55, 0x92, 0xb6, 0xf3, 0x3a, 0x87, 0x2b, 0x40, 0x3e, 0xe0, 0x37, 0x1f, 0xe2, 0xd4, + /*78f0:*/ 0x1e, 0x67, 0xc3, 0x87, 0xb6, 0x93, 0x76, 0x99, 0x22, 0x79, 0xfd, 0x1d, 0xbc, 0xf8, 0x2c, 0x54, + /*7900:*/ 0x10, 0x03, 0x2f, 0x36, 0xdb, 0x8c, 0x63, 0xba, 0x91, 0xbc, 0xca, 0xe1, 0xd7, 0xc7, 0x8e, 0x32, + /*7910:*/ 0x02, 0xb1, 0x77, 0x4d, 0x1d, 0x70, 0x2b, 0x3a, 0x84, 0xea, 0x1f, 0x78, 0xcc, 0xe8, 0x85, 0x30, + /*7920:*/ 0xbc, 0xe5, 0xb6, 0x15, 0x31, 0x4f, 0x61, 0xb2, 0x18, 0x5e, 0x36, 0xad, 0x70, 0x75, 0xd8, 0xe4, + /*7930:*/ 0x65, 0xdf, 0xac, 0xa1, 0xcc, 0x51, 0x1a, 0x0e, 0x8d, 0x45, 0xc4, 0x46, 0x73, 0x69, 0x2c, 0xc9, + /*7940:*/ 0xb3, 0x96, 0x4e, 0x58, 0x5d, 0x57, 0x68, 0x4e, 0x60, 0x48, 0x16, 0x74, 0x5e, 0xc3, 0xd8, 0x61, + /*7950:*/ 0x22, 0x30, 0x3b, 0x63, 0x96, 0x02, 0x35, 0x2a, 0x15, 0x21, 0x62, 0x92, 0x66, 0x7b, 0xfa, 0x90, + /*7960:*/ 0xfd, 0x63, 0x3c, 0xa7, 0x5a, 0x72, 0xd4, 0x95, 0x63, 0xb8, 0x57, 0x2e, 0x3a, 0x71, 0xa7, 0xd4, + /*7970:*/ 0xff, 0xf9, 0x02, 0xd4, 0xc1, 0xfe, 0xeb, 0x3e, 0x8c, 0xbf, 0xab, 0x16, 0x42, 0x2c, 0x0c, 0x57, + /*7980:*/ 0x12, 0xf0, 0x5a, 0x64, 0xf5, 0x09, 0x1c, 0x46, 0x7c, 0xfb, 0xe0, 0x68, 0x94, 0x97, 0x2c, 0x70, + /*7990:*/ 0x57, 0x13, 0xed, 0xec, 0xdc, 0xd8, 0xab, 0xba, 0x8e, 0x49, 0x87, 0x7c, 0x03, 0x6a, 0x5e, 0xf5, + /*79a0:*/ 0xca, 0x09, 0x96, 0x2c, 0x4b, 0xfb, 0x55, 0xb6, 0x1a, 0x04, 0xf0, 0xb0, 0xbc, 0x71, 0x4f, 0x68, + /*79b0:*/ 0x7c, 0xd4, 0x04, 0xd8, 0x16, 0x6d, 0xae, 0xa9, 0x62, 0xa7, 0xc0, 0xdd, 0x6c, 0xf5, 0x6a, 0x81, + /*79c0:*/ 0x56, 0xb9, 0x09, 0xed, 0x6a, 0xe1, 0x86, 0x44, 0xf7, 0x94, 0xbf, 0xda, 0xcc, 0xf6, 0x9c, 0x7a, + /*79d0:*/ 0xe8, 0x11, 0x1f, 0xdc, 0x7d, 0x22, 0xf2, 0xf1, 0xd2, 0x29, 0x28, 0x02, 0x90, 0x08, 0xb3, 0xdc, + /*79e0:*/ 0x13, 0xe5, 0x57, 0x6b, 0xd1, 0xd5, 0x4c, 0xc6, 0xed, 0xf2, 0x7f, 0x45, 0x38, 0x74, 0xd2, 0xe5, + /*79f0:*/ 0xb3, 0x38, 0x15, 0xc8, 0x55, 0xbe, 0x3c, 0x3d, 0x4e, 0x0c, 0xdd, 0x52, 0x4f, 0xea, 0x31, 0x26, + /*7a00:*/ 0x66, 0x93, 0x37, 0x93, 0x2b, 0x0e, 0x3b, 0x36, 0xd7, 0xd5, 0xc4, 0x9b, 0x3d, 0x0a, 0x25, 0x34, + /*7a10:*/ 0xcd, 0x7f, 0xea, 0x96, 0x9c, 0x34, 0x8f, 0xb8, 0x4a, 0x22, 0x4d, 0x64, 0x33, 0xc8, 0x79, 0x2d, + /*7a20:*/ 0xed, 0xe0, 0x63, 0x19, 0xac, 0xed, 0xf4, 0x95, 0x9e, 0x82, 0x87, 0x6d, 0xdd, 0x13, 0x7f, 0x00, + /*7a30:*/ 0xfe, 0x0a, 0xf8, 0x23, 0x1c, 0x6f, 0x53, 0xa4, 0xcd, 0x64, 0xe2, 0xae, 0xb8, 0x27, 0xff, 0x9f, + /*7a40:*/ 0xe9, 0x1e, 0xd7, 0x3e, 0x62, 0xc2, 0x3b, 0xfb, 0x2c, 0x93, 0x06, 0xcf, 0x21, 0xdb, 0x65, 0x8c, + /*7a50:*/ 0xc5, 0xe0, 0xfa, 0x99, 0x71, 0xf6, 0x55, 0x17, 0x64, 0xc9, 0xd6, 0x79, 0x0f, 0x0d, 0x4b, 0xdc, + /*7a60:*/ 0xcf, 0x24, 0x5d, 0x52, 0xed, 0x41, 0xe8, 0x06, 0x31, 0x87, 0x76, 0xdc, 0x4f, 0x79, 0x8e, 0x10, + /*7a70:*/ 0xa5, 0x5c, 0x37, 0x8c, 0xd4, 0xf7, 0x72, 0x77, 0xd9, 0x69, 0x24, 0x54, 0xdc, 0xf6, 0x35, 0x97, + /*7a80:*/ 0x0d, 0xe4, 0x14, 0xdd, 0xc7, 0x1c, 0x75, 0x5f, 0x2c, 0x33, 0xbe, 0xaa, 0x62, 0xbc, 0x53, 0x04, + /*7a90:*/ 0x18, 0xe0, 0x56, 0x8b, 0xdb, 0xcd, 0xcf, 0x98, 0xb5, 0x1b, 0xb4, 0xa9, 0x84, 0xb3, 0x89, 0xcf, + /*7aa0:*/ 0x5c, 0x57, 0x2d, 0x3d, 0xea, 0x89, 0xd7, 0x14, 0x1e, 0x3b, 0x1e, 0xfb, 0x2e, 0xf6, 0xa7, 0x62, + /*7ab0:*/ 0xd5, 0x21, 0x6f, 0xd2, 0x73, 0xd8, 0x3e, 0xde, 0x1a, 0x65, 0x9f, 0xd0, 0xeb, 0x90, 0x0b, 0x9d, + /*7ac0:*/ 0x21, 0xe5, 0x62, 0x5f, 0x31, 0x8c, 0x8e, 0x55, 0x8b, 0x85, 0x38, 0xa3, 0x16, 0xe8, 0x85, 0x48, + /*7ad0:*/ 0xce, 0xc9, 0xf3, 0x6e, 0x1c, 0x36, 0xd4, 0x38, 0x44, 0x92, 0x9b, 0xf0, 0xc4, 0x6a, 0x44, 0x13, + /*7ae0:*/ 0xfa, 0xde, 0x91, 0x4e, 0x04, 0xeb, 0x70, 0x2d, 0xb4, 0x5f, 0xc5, 0xe0, 0x49, 0x1c, 0x42, 0x4c, + /*7af0:*/ 0xca, 0xa2, 0x70, 0xc3, 0x5f, 0x38, 0x9c, 0x3b, 0xed, 0x96, 0xdf, 0x8d, 0x7f, 0x8c, 0xf9, 0x29, + /*7b00:*/ 0xe6, 0x5d, 0x4e, 0x0e, 0x9d, 0x47, 0x12, 0x37, 0x0c, 0x59, 0xf7, 0x01, 0xa9, 0xab, 0x4a, 0x08, + /*7b10:*/ 0x31, 0x9e, 0x5d, 0x7a, 0xbb, 0xe3, 0x69, 0x03, 0x53, 0xaf, 0xca, 0x96, 0x2e, 0x98, 0x12, 0xfd, + /*7b20:*/ 0x30, 0xab, 0xed, 0x90, 0xa2, 0x08, 0xd5, 0x2d, 0xcc, 0xda, 0xc3, 0x1b, 0xf9, 0x4c, 0x83, 0x71, + /*7b30:*/ 0xb0, 0x40, 0xc9, 0xe6, 0x1f, 0x03, 0x38, 0xc7, 0x6a, 0x85, 0xe1, 0xae, 0x1f, 0xca, 0x12, 0xe4, + /*7b40:*/ 0x6e, 0x9c, 0x1d, 0x6f, 0x6d, 0xa8, 0x2b, 0x9b, 0x46, 0x47, 0x8c, 0xba, 0x32, 0x3d, 0x98, 0x5d, + /*7b50:*/ 0x1e, 0xea, 0x08, 0xa6, 0x6d, 0xd8, 0x8a, 0x1c, 0x1c, 0xeb, 0x61, 0x0d, 0xc2, 0x9a, 0x3f, 0x79, + /*7b60:*/ 0xf4, 0x73, 0x8f, 0x30, 0xb7, 0x73, 0x06, 0x0c, 0xfc, 0x74, 0xf9, 0x60, 0x05, 0x46, 0xe9, 0x10, + /*7b70:*/ 0x1f, 0x8d, 0x01, 0x46, 0xd7, 0xc3, 0x72, 0x19, 0x7f, 0x45, 0x09, 0xe7, 0xe2, 0x9f, 0x7e, 0x57, + /*7b80:*/ 0x65, 0x0a, 0x4b, 0x02, 0x51, 0x20, 0xda, 0x6d, 0x09, 0xbf, 0x10, 0x02, 0xbc, 0xb9, 0x57, 0x5a, + /*7b90:*/ 0x4d, 0x49, 0x51, 0x9d, 0xb5, 0x1d, 0xb1, 0xf0, 0x1d, 0x31, 0xe1, 0xac, 0x27, 0x28, 0x6f, 0xc2, + /*7ba0:*/ 0x2f, 0xd2, 0x2e, 0xb6, 0xe8, 0xa9, 0xaa, 0xfd, 0x48, 0x61, 0x1a, 0xcc, 0x06, 0x33, 0x43, 0x42, + /*7bb0:*/ 0x5b, 0x37, 0x63, 0x31, 0xbc, 0x08, 0x0b, 0xea, 0x64, 0x64, 0xbf, 0x64, 0x48, 0xd6, 0x67, 0x02, + /*7bc0:*/ 0xda, 0xb3, 0xd4, 0x7b, 0xac, 0x59, 0x47, 0xde, 0x5a, 0x69, 0xac, 0xf4, 0xbc, 0x92, 0x5f, 0x23, + /*7bd0:*/ 0x0c, 0xd8, 0x07, 0x48, 0xd4, 0x7a, 0x7e, 0x5b, 0x09, 0xff, 0xc6, 0xc8, 0x6d, 0x64, 0xcb, 0x36, + /*7be0:*/ 0x0f, 0x71, 0xe9, 0x8a, 0xa2, 0xbe, 0xee, 0xaa, 0x21, 0xf5, 0xfe, 0xe6, 0xdc, 0x05, 0x19, 0x26, + /*7bf0:*/ 0x58, 0x85, 0x09, 0x62, 0x18, 0x96, 0x37, 0x0d, 0xde, 0xf5, 0xbf, 0xe6, 0x96, 0x15, 0xea, 0x51, + /*7c00:*/ 0x88, 0x63, 0x2e, 0x1d, 0x08, 0xad, 0xa2, 0x48, 0x0b, 0x93, 0x89, 0xb0, 0xfc, 0x89, 0xa7, 0x64, + /*7c10:*/ 0x85, 0x42, 0x55, 0x64, 0x67, 0x76, 0xb9, 0x88, 0x94, 0xa0, 0x4a, 0x6a, 0xf2, 0x5e, 0x02, 0xa8, + /*7c20:*/ 0x06, 0xd1, 0x43, 0x8b, 0xfa, 0xe7, 0x99, 0x3b, 0xdc, 0x61, 0xbe, 0x3e, 0x9a, 0xd7, 0xea, 0x8f, + /*7c30:*/ 0x67, 0xd4, 0xdd, 0x46, 0x5a, 0x87, 0xed, 0x92, 0x25, 0xe7, 0x0e, 0x27, 0x08, 0x49, 0xfc, 0x5c, + /*7c40:*/ 0x22, 0x35, 0xa8, 0x2f, 0xcd, 0x9a, 0xa2, 0x2a, 0x54, 0xf5, 0xdb, 0x0e, 0x2c, 0x77, 0xf6, 0x5d, + /*7c50:*/ 0xa3, 0x1f, 0xf5, 0xa3, 0x9a, 0xa7, 0x74, 0xce, 0x58, 0xb0, 0xbd, 0x88, 0x8e, 0x4f, 0x97, 0xff, + /*7c60:*/ 0x78, 0x0c, 0x9c, 0x7d, 0x5c, 0x65, 0x6c, 0x24, 0x7c, 0xe3, 0x7f, 0xee, 0x2f, 0x50, 0xf3, 0x1f, + /*7c70:*/ 0x7d, 0x6b, 0xd4, 0xc3, 0xe3, 0x3a, 0x88, 0x81, 0x8d, 0x61, 0x7f, 0xdc, 0xa9, 0x4b, 0xac, 0x0e, + /*7c80:*/ 0x76, 0x1e, 0x4e, 0xd8, 0xf7, 0x5b, 0x2c, 0x03, 0x37, 0xa6, 0x93, 0x78, 0xb0, 0xad, 0x96, 0xff, + /*7c90:*/ 0xf1, 0xaf, 0x9a, 0x1c, 0xa4, 0x9d, 0x04, 0x5a, 0xbd, 0x85, 0x1b, 0xd9, 0xad, 0x92, 0x1a, 0x28, + /*7ca0:*/ 0xe7, 0x7e, 0x08, 0x25, 0x67, 0xb8, 0x0c, 0x83, 0x2f, 0x3d, 0x92, 0xd7, 0xfe, 0xcf, 0x18, 0xee, + /*7cb0:*/ 0xd8, 0xd3, 0x2d, 0xec, 0x6f, 0x56, 0x3c, 0x6a, 0x69, 0x4b, 0x31, 0x8b, 0x7e, 0x9d, 0x18, 0x26, + /*7cc0:*/ 0xdc, 0xdd, 0x89, 0xc2, 0x1d, 0x32, 0x49, 0x27, 0xf7, 0x78, 0x46, 0x8e, 0xbf, 0x47, 0x37, 0x9d, + /*7cd0:*/ 0x45, 0xad, 0x46, 0x63, 0x9e, 0x70, 0xd7, 0xd9, 0xdd, 0x0f, 0x2f, 0xe1, 0x11, 0xe9, 0x93, 0xa2, + /*7ce0:*/ 0x99, 0x6e, 0xc4, 0x98, 0x6a, 0xf3, 0x31, 0x33, 0xe9, 0x54, 0x84, 0x6e, 0xc7, 0xe5, 0x7b, 0x79, + /*7cf0:*/ 0x4f, 0x06, 0x69, 0x36, 0x64, 0x23, 0x7e, 0xc5, 0xdc, 0x95, 0x1c, 0x34, 0x86, 0x93, 0x9e, 0xa9, + /*7d00:*/ 0x5f, 0xab, 0x6c, 0xff, 0xee, 0x8e, 0x80, 0x0b, 0x66, 0x76, 0xc0, 0x12, 0x75, 0x6d, 0x96, 0xb1, + /*7d10:*/ 0xaf, 0xb2, 0xe9, 0x96, 0x34, 0xcc, 0x99, 0x89, 0x59, 0xbc, 0xe0, 0xd5, 0xde, 0x1e, 0x7b, 0x3b, + /*7d20:*/ 0x88, 0xd3, 0xe4, 0x27, 0x06, 0x93, 0x4c, 0xf4, 0x8b, 0xdb, 0xef, 0xd3, 0x23, 0x85, 0x30, 0x37, + /*7d30:*/ 0x47, 0x54, 0x7e, 0x7d, 0xe7, 0x21, 0xeb, 0xc5, 0x55, 0x93, 0x1f, 0xd4, 0xf1, 0x8c, 0x7d, 0xd4, + /*7d40:*/ 0x3b, 0xfe, 0x83, 0x4a, 0xc8, 0x9a, 0xd4, 0x2a, 0x69, 0x52, 0x73, 0x81, 0x77, 0x8f, 0x7c, 0x98, + /*7d50:*/ 0xa0, 0x01, 0x7e, 0x7e, 0x34, 0x91, 0xb1, 0xea, 0x5b, 0x05, 0xa4, 0x0d, 0x41, 0x8c, 0x38, 0x0c, + /*7d60:*/ 0xfe, 0x32, 0x81, 0xee, 0x1a, 0x54, 0xcf, 0x01, 0x8e, 0xb3, 0x6e, 0xa0, 0x41, 0xa1, 0xa5, 0xa3, + /*7d70:*/ 0xc0, 0x18, 0x5e, 0x06, 0x32, 0x04, 0x85, 0x72, 0x60, 0x07, 0xb5, 0x30, 0xce, 0xfc, 0x21, 0xb4, + /*7d80:*/ 0xaa, 0xaa, 0xd9, 0xaf, 0xb1, 0x7e, 0xbd, 0x03, 0x32, 0x56, 0x55, 0x5c, 0xdb, 0xe3, 0x05, 0x06, + /*7d90:*/ 0x6b, 0x39, 0x67, 0x81, 0xcd, 0xd0, 0xc8, 0x5d, 0xb8, 0xae, 0xb6, 0x13, 0x3b, 0x6e, 0x4c, 0x4b, + /*7da0:*/ 0x8f, 0x12, 0x5f, 0x21, 0x61, 0x6c, 0xfc, 0x3f, 0x96, 0x1b, 0x82, 0x57, 0xf9, 0xbe, 0x5a, 0x91, + /*7db0:*/ 0x19, 0xac, 0xdd, 0x54, 0x2a, 0xd6, 0x8b, 0xa6, 0x0b, 0xb8, 0x7e, 0xeb, 0xaa, 0x86, 0x3a, 0x44, + /*7dc0:*/ 0x96, 0x7a, 0xec, 0x6a, 0x3e, 0xa0, 0x94, 0x3e, 0xb3, 0xe0, 0xc1, 0xf9, 0xd4, 0xff, 0xa4, 0x10, + /*7dd0:*/ 0x79, 0x8e, 0x83, 0x65, 0x2e, 0xd9, 0x90, 0xec, 0x00, 0xca, 0x2a, 0x86, 0xb8, 0x85, 0xf1, 0xa1, + /*7de0:*/ 0xdc, 0xfe, 0x54, 0x11, 0x67, 0xcf, 0x6d, 0x42, 0x6c, 0x2d, 0xf7, 0x8e, 0x9c, 0x5e, 0x0f, 0x62, + /*7df0:*/ 0x49, 0xf8, 0xb2, 0x4c, 0xc8, 0x7a, 0x47, 0x40, 0x59, 0xba, 0xa3, 0x8b, 0xad, 0x61, 0x8e, 0xd6, + /*7e00:*/ 0xbf, 0xd1, 0xf4, 0x3e, 0xb9, 0x80, 0x47, 0xd5, 0x94, 0xa9, 0xb9, 0xc1, 0x4d, 0xf4, 0x35, 0xa6, + /*7e10:*/ 0xa4, 0x13, 0x90, 0xcb, 0x7f, 0x9d, 0x08, 0xb7, 0x5a, 0x5e, 0x1f, 0x5a, 0x5c, 0x19, 0xc2, 0xce, + /*7e20:*/ 0xa2, 0xe4, 0xc1, 0x2c, 0xdb, 0xb9, 0x84, 0xb4, 0x7a, 0xa4, 0x0c, 0xaf, 0xf0, 0xdc, 0x7e, 0xe4, + /*7e30:*/ 0x27, 0x94, 0x69, 0x07, 0x6d, 0xc2, 0xaa, 0xc4, 0x95, 0x80, 0xb5, 0x94, 0xf8, 0x57, 0x0e, 0x97, + /*7e40:*/ 0x4d, 0x9a, 0x3e, 0x5c, 0x63, 0x44, 0x1b, 0x61, 0x22, 0xd8, 0x47, 0x4c, 0x35, 0x39, 0xa0, 0xfd, + /*7e50:*/ 0x52, 0x3c, 0x3f, 0x2f, 0x2d, 0x15, 0x19, 0x7b, 0xd9, 0x17, 0xa7, 0x90, 0x0f, 0xbe, 0x21, 0xf6, + /*7e60:*/ 0x7b, 0x58, 0x8f, 0x48, 0x77, 0x0e, 0xac, 0x66, 0xa3, 0x2f, 0x80, 0xee, 0xe6, 0x23, 0x72, 0x03, + /*7e70:*/ 0x8e, 0x56, 0x54, 0x13, 0x1e, 0x06, 0xbc, 0x5d, 0xdf, 0x78, 0xf5, 0x1f, 0x1e, 0x2f, 0xd6, 0x68, + /*7e80:*/ 0x50, 0x1d, 0xaf, 0x61, 0x5d, 0x4b, 0x38, 0x31, 0x2c, 0xef, 0x54, 0x3c, 0x5f, 0xfc, 0xb5, 0x5e, + /*7e90:*/ 0xd9, 0x96, 0x08, 0x31, 0x25, 0x20, 0x42, 0xfb, 0x19, 0xba, 0xc8, 0xf2, 0x0f, 0xe3, 0xfd, 0x5b, + /*7ea0:*/ 0xae, 0x65, 0xba, 0x26, 0xfa, 0x7a, 0xfd, 0x79, 0xfd, 0xda, 0x2b, 0xab, 0xb2, 0x0b, 0x40, 0x55, + /*7eb0:*/ 0x87, 0x81, 0x6d, 0xc1, 0x02, 0xa4, 0xbc, 0x94, 0x89, 0x81, 0x42, 0xe7, 0x40, 0xf0, 0xd0, 0xfe, + /*7ec0:*/ 0x54, 0x56, 0xf8, 0xfa, 0x0c, 0x53, 0xce, 0xac, 0x04, 0xe3, 0xfb, 0xc6, 0x2f, 0x87, 0x6b, 0xde, + /*7ed0:*/ 0x74, 0x0f, 0x7a, 0x5b, 0xb8, 0xf2, 0x0a, 0x66, 0xf0, 0xb2, 0x1e, 0xd8, 0x2f, 0x37, 0xe0, 0xc1, + /*7ee0:*/ 0x45, 0x62, 0x6b, 0x0b, 0xab, 0xe8, 0x1f, 0x31, 0x7a, 0x28, 0xca, 0x54, 0x6f, 0x36, 0x10, 0xd6, + /*7ef0:*/ 0x43, 0xc1, 0xe1, 0x0a, 0x2e, 0xb6, 0xce, 0xaf, 0x45, 0xdc, 0x18, 0x9e, 0xcf, 0x5a, 0xdd, 0xea, + /*7f00:*/ 0x2e, 0xd7, 0xe5, 0x55, 0x49, 0x3e, 0x08, 0x15, 0xf7, 0xe3, 0xf7, 0x78, 0x8e, 0x41, 0xd1, 0xf8, + /*7f10:*/ 0xf4, 0x7a, 0x59, 0x93, 0xc8, 0xdf, 0xdb, 0xe1, 0x88, 0x66, 0x21, 0x84, 0xb7, 0x4d, 0xd6, 0x4a, + /*7f20:*/ 0x61, 0x2c, 0x5b, 0x8b, 0xf4, 0xc3, 0x64, 0xcc, 0x73, 0x69, 0xca, 0x0b, 0x55, 0x38, 0xbd, 0x2a, + /*7f30:*/ 0x6d, 0x1f, 0xad, 0xe4, 0xfe, 0x3a, 0xbf, 0x4a, 0xff, 0x18, 0x5f, 0x9c, 0x5d, 0xa7, 0x2f, 0xbc, + /*7f40:*/ 0x71, 0x8a, 0xe0, 0x82, 0x4a, 0xd8, 0x92, 0xdb, 0xb6, 0x80, 0x29, 0xa4, 0xed, 0x65, 0x3f, 0x72, + /*7f50:*/ 0xc4, 0xbc, 0x05, 0x4f, 0x3a, 0x97, 0x5d, 0x3c, 0x24, 0x50, 0xa4, 0x5b, 0x4e, 0x75, 0xab, 0x20, + /*7f60:*/ 0x96, 0x42, 0xa3, 0x5b, 0x36, 0x74, 0x79, 0xb0, 0xd2, 0xce, 0x49, 0x23, 0xa2, 0x22, 0xd7, 0x21, + /*7f70:*/ 0x66, 0xbe, 0xc4, 0xa9, 0x0c, 0x9d, 0xb3, 0xfc, 0x18, 0x81, 0x48, 0x7e, 0x1b, 0xfa, 0xdf, 0xb8, + /*7f80:*/ 0xba, 0xae, 0x15, 0x16, 0xdf, 0xee, 0x6c, 0x53, 0xf9, 0x6a, 0x80, 0xbb, 0xe0, 0x5e, 0x98, 0x2d, + /*7f90:*/ 0x18, 0xf1, 0x45, 0x99, 0x2d, 0xb8, 0xc6, 0xff, 0x74, 0xf4, 0xaa, 0x0b, 0x94, 0x42, 0x09, 0xb8, + /*7fa0:*/ 0x26, 0x5f, 0x7c, 0x15, 0x17, 0xe0, 0x90, 0x04, 0x96, 0x1e, 0x8d, 0xa9, 0xc3, 0x59, 0xcb, 0x5a, + /*7fb0:*/ 0xc2, 0x22, 0x78, 0x9c, 0xbe, 0xb1, 0xc8, 0x5b, 0x84, 0xda, 0x24, 0x3f, 0x3b, 0xc9, 0x9b, 0x7a, + /*7fc0:*/ 0xbb, 0xfd, 0xe7, 0x4b, 0x23, 0x43, 0xd1, 0x04, 0x98, 0x14, 0x5e, 0x23, 0xdb, 0xb9, 0x18, 0x3c, + /*7fd0:*/ 0x4f, 0xdb, 0xe1, 0x14, 0x1e, 0x30, 0x19, 0xd6, 0xb6, 0x70, 0xd4, 0xe1, 0xe1, 0x40, 0xad, 0xff, + /*7fe0:*/ 0xe9, 0xcc, 0xd5, 0xfa, 0xc1, 0x2b, 0x66, 0x07, 0xde, 0x05, 0x6d, 0xe7, 0x97, 0x75, 0xb9, 0x3f, + /*7ff0:*/ 0x5f, 0xd2, 0xdf, 0xd2, 0xd1, 0x27, 0xfe, 0x29, 0xb7, 0xc5, 0xfa, 0x41, 0xfd, 0x39, 0x39, 0x45, + /*8000:*/ 0xc6, 0x96, 0xa2, 0xd5, 0x25, 0xab, 0x00, 0xe4, 0x4c, 0xc8, 0x48, 0xe5, 0x89, 0xa5, 0x0b, 0x13, + /*8010:*/ 0x82, 0xb5, 0x53, 0xd6, 0x4c, 0x47, 0x7d, 0x28, 0x39, 0xe5, 0xad, 0x94, 0xc4, 0x6d, 0x21, 0x1e, + /*8020:*/ 0xb0, 0x73, 0xd9, 0xcc, 0xa6, 0x2f, 0x0b, 0xf0, 0x9c, 0xd7, 0x5c, 0x5f, 0x99, 0xf6, 0x09, 0x6e, + /*8030:*/ 0x64, 0xb1, 0xce, 0xcc, 0xee, 0x55, 0xd9, 0xeb, 0x51, 0x5f, 0x03, 0x03, 0x6f, 0xc2, 0xea, 0x70, + /*8040:*/ 0xc3, 0x4c, 0xd1, 0x9e, 0x26, 0x06, 0x0f, 0x80, 0x2d, 0xf0, 0x43, 0x75, 0x09, 0x8c, 0x52, 0x6a, + /*8050:*/ 0xbb, 0x76, 0xda, 0x09, 0x2f, 0x00, 0x45, 0xad, 0x9a, 0x24, 0x12, 0x4c, 0x29, 0x58, 0x67, 0x4f, + /*8060:*/ 0xd8, 0xdd, 0xe9, 0x62, 0xd4, 0x95, 0x0d, 0x83, 0x62, 0xfe, 0x66, 0xad, 0x12, 0x06, 0xe1, 0x16, + /*8070:*/ 0xb8, 0x89, 0xb4, 0x9f, 0xa6, 0xb6, 0x4f, 0xa7, 0xfe, 0x72, 0xd5, 0xbc, 0x7c, 0x84, 0x62, 0xe2, + /*8080:*/ 0xb1, 0xfb, 0x0c, 0x54, 0xed, 0x69, 0x96, 0x68, 0x5c, 0x1b, 0xcf, 0xa3, 0x56, 0xdd, 0x0b, 0x78, + /*8090:*/ 0x9c, 0x5d, 0x7d, 0x9d, 0x05, 0x79, 0x72, 0xb9, 0xa9, 0x6e, 0xd1, 0xfb, 0x0c, 0x28, 0x2b, 0xa9, + /*80a0:*/ 0xf4, 0xb3, 0x41, 0xb1, 0x12, 0xe0, 0xe3, 0xf4, 0xf0, 0x6c, 0x86, 0x50, 0xf0, 0xaf, 0x23, 0x87, + /*80b0:*/ 0x67, 0x91, 0xe2, 0x07, 0x6c, 0x77, 0x16, 0xf9, 0x5f, 0x83, 0x8a, 0x46, 0xb6, 0xe3, 0x02, 0x59, + /*80c0:*/ 0x77, 0xaf, 0x3e, 0x98, 0x33, 0x3f, 0xb6, 0xf4, 0x02, 0x23, 0x50, 0xd8, 0x4b, 0xc9, 0x4e, 0xd9, + /*80d0:*/ 0x00, 0xe9, 0x68, 0x13, 0x44, 0xed, 0x2c, 0x4d, 0xd7, 0x60, 0xb4, 0x69, 0xc6, 0xd4, 0xe7, 0xc6, + /*80e0:*/ 0x57, 0xe4, 0xb0, 0x5d, 0x74, 0x51, 0xb5, 0x09, 0x54, 0x11, 0x58, 0x1b, 0xab, 0xf6, 0x54, 0xfb, + /*80f0:*/ 0xe4, 0xaa, 0x99, 0xb0, 0xc2, 0xa8, 0xc3, 0x2d, 0x52, 0x95, 0x39, 0x51, 0x4b, 0x18, 0x83, 0xe6, + /*8100:*/ 0xfc, 0x55, 0xd5, 0x0a, 0xae, 0x93, 0x70, 0x97, 0x60, 0x65, 0x63, 0x61, 0x72, 0x65, 0x9a, 0xe8, + /*8110:*/ 0x13, 0x86, 0x99, 0x14, 0x75, 0xca, 0xe2, 0x9b, 0x40, 0xaf, 0x63, 0x49, 0x50, 0xfc, 0x1d, 0x9b, + /*8120:*/ 0x2a, 0x26, 0xee, 0xbc, 0x88, 0x78, 0x1d, 0xd8, 0xd6, 0x51, 0x8b, 0x8f, 0x45, 0xf9, 0xe0, 0x4b, + /*8130:*/ 0x70, 0xb4, 0x6b, 0x84, 0x42, 0xe5, 0x7b, 0x26, 0xf0, 0xb4, 0xff, 0x15, 0x70, 0x23, 0xc7, 0xd6, + /*8140:*/ 0xd7, 0xa0, 0x22, 0x84, 0x8f, 0x3d, 0xd6, 0x25, 0x26, 0x22, 0x3e, 0xcf, 0x81, 0x67, 0x1e, 0xdc, + /*8150:*/ 0x23, 0xc7, 0x2a, 0xe7, 0x2e, 0x68, 0x65, 0x06, 0x2f, 0xe0, 0x57, 0xe0, 0x89, 0x27, 0x5f, 0xc6, + /*8160:*/ 0x81, 0x85, 0x04, 0xb0, 0xa3, 0xc9, 0xde, 0xe3, 0x4f, 0x68, 0x4d, 0xc7, 0xa2, 0xc9, 0xc2, 0x6c, + /*8170:*/ 0x42, 0x37, 0x7d, 0x94, 0xe4, 0x61, 0x26, 0x39, 0x26, 0xc7, 0x30, 0xd9, 0xfc, 0x5a, 0x82, 0x44, + /*8180:*/ 0xee, 0x2c, 0x82, 0x2f, 0xa3, 0x66, 0xfc, 0x7a, 0x6b, 0xde, 0x3a, 0xf8, 0xad, 0xc4, 0xcc, 0xdf, + /*8190:*/ 0x4f, 0x38, 0xf0, 0x1e, 0xd8, 0x0d, 0x7d, 0x98, 0x6b, 0x74, 0xa5, 0xd7, 0x10, 0xce, 0xa0, 0x53, + /*81a0:*/ 0x72, 0x51, 0xf1, 0x5a, 0xa0, 0x01, 0x2c, 0x33, 0xe5, 0xfe, 0x25, 0xeb, 0x6c, 0xe3, 0x79, 0x02, + /*81b0:*/ 0x87, 0x5a, 0x56, 0xe9, 0xb6, 0xd0, 0xd1, 0x41, 0xe4, 0x2f, 0x53, 0xed, 0xbd, 0x22, 0x14, 0xe0, + /*81c0:*/ 0x2d, 0x48, 0x8c, 0xb9, 0x67, 0xd8, 0x7b, 0x27, 0x58, 0x7a, 0x7c, 0xc8, 0xd6, 0x48, 0xec, 0xd9, + /*81d0:*/ 0xba, 0xcf, 0xd1, 0xc4, 0xbd, 0x7f, 0x38, 0xb7, 0xdf, 0x4a, 0xff, 0x99, 0xd8, 0xf4, 0xaa, 0xbf, + /*81e0:*/ 0x68, 0x9a, 0xcb, 0x63, 0xcd, 0x01, 0x05, 0x53, 0xfd, 0xae, 0xcd, 0xd7, 0xfe, 0xa7, 0x79, 0x42, + /*81f0:*/ 0x85, 0x63, 0x40, 0x44, 0x65, 0x1b, 0x83, 0x70, 0x16, 0x1f, 0xc0, 0xf1, 0xb2, 0x49, 0x0f, 0x99, + /*8200:*/ 0x40, 0xbe, 0x21, 0xfa, 0x8e, 0x85, 0xb7, 0x9d, 0xee, 0x28, 0xbc, 0xac, 0x2b, 0x85, 0x3b, 0xdf, + /*8210:*/ 0x4a, 0x72, 0x81, 0x6d, 0x0e, 0x75, 0x58, 0x34, 0x41, 0x5b, 0xa3, 0x0f, 0x00, 0x1b, 0x28, 0xcf, + /*8220:*/ 0xa7, 0x57, 0x4e, 0x78, 0x41, 0x7c, 0xf9, 0x4e, 0x44, 0xcb, 0x6f, 0x4b, 0x88, 0x84, 0x73, 0x4f, + /*8230:*/ 0xfa, 0x4a, 0xc4, 0xa9, 0xad, 0xd7, 0xeb, 0x1d, 0x52, 0xe4, 0xd7, 0xa3, 0xdc, 0x37, 0xae, 0x23, + /*8240:*/ 0xe3, 0xa6, 0x91, 0x02, 0x75, 0xf0, 0x16, 0xbb, 0x24, 0x09, 0x15, 0xa3, 0x79, 0xe2, 0xd9, 0x66, + /*8250:*/ 0x25, 0x27, 0xe8, 0x5e, 0x72, 0x7d, 0xc6, 0x38, 0xac, 0xfb, 0x62, 0x3b, 0x7d, 0x23, 0xe6, 0xbf, + /*8260:*/ 0x94, 0x12, 0x15, 0xcb, 0xd7, 0x73, 0xd7, 0xc9, 0x02, 0xff, 0xa5, 0xae, 0x15, 0x45, 0xc7, 0xfd, + /*8270:*/ 0x82, 0x77, 0x54, 0xd3, 0xc0, 0xcb, 0xc6, 0x1c, 0x8d, 0x58, 0x51, 0xd2, 0x82, 0x66, 0x03, 0x84, + /*8280:*/ 0x5a, 0x16, 0xad, 0x90, 0x0b, 0x29, 0x98, 0x6c, 0xa1, 0x53, 0xc3, 0x8e, 0x9e, 0x30, 0x61, 0x6f, + /*8290:*/ 0xc0, 0xc1, 0x8e, 0x61, 0x67, 0x82, 0x32, 0xb8, 0xa7, 0x4c, 0xa6, 0x78, 0x28, 0x72, 0xed, 0xc9, + /*82a0:*/ 0x17, 0x6d, 0xf4, 0xe1, 0x83, 0x9c, 0xa3, 0xc8, 0x57, 0x47, 0xf6, 0x0f, 0xa5, 0x43, 0x36, 0x78, + /*82b0:*/ 0x53, 0xd2, 0xf7, 0x75, 0xc2, 0x93, 0xb5, 0x4b, 0x5a, 0xbf, 0xa0, 0xfe, 0x09, 0xb3, 0xa4, 0x69, + /*82c0:*/ 0x3e, 0xee, 0x5e, 0xb1, 0xe6, 0x2b, 0xca, 0x21, 0x62, 0xed, 0xf5, 0x3a, 0xa6, 0x3c, 0x41, 0x44, + /*82d0:*/ 0x75, 0x03, 0xc8, 0x1e, 0x7f, 0x82, 0x5c, 0x9f, 0x77, 0x72, 0x73, 0xcf, 0xf4, 0x9e, 0x20, 0x63, + /*82e0:*/ 0x60, 0xe1, 0x4b, 0x42, 0xb4, 0xa1, 0xdf, 0xda, 0xdc, 0x2e, 0xda, 0x4f, 0xba, 0xf2, 0x2a, 0x44, + /*82f0:*/ 0x7a, 0x82, 0x40, 0xb9, 0x5d, 0xa2, 0x61, 0x1e, 0xea, 0xff, 0x9a, 0xd7, 0x85, 0x8b, 0x2a, 0x88, + /*8300:*/ 0x6a, 0xbc, 0xdb, 0x16, 0x1b, 0x43, 0x02, 0xbd, 0x36, 0xa1, 0x9e, 0x86, 0x45, 0x15, 0x4b, 0x07, + /*8310:*/ 0x05, 0xe0, 0x64, 0x85, 0xda, 0xc3, 0x61, 0xdd, 0xc6, 0xf7, 0xf1, 0x6b, 0xe0, 0xf0, 0x0b, 0xcd, + /*8320:*/ 0x6d, 0x6e, 0x33, 0x05, 0xdf, 0x4e, 0x18, 0x79, 0xfc, 0x85, 0x30, 0xf1, 0x04, 0xa8, 0x7a, 0x9a, + /*8330:*/ 0xbe, 0x72, 0x8f, 0x92, 0x30, 0xd8, 0x04, 0x19, 0xbc, 0x26, 0xc5, 0xe6, 0x71, 0xd3, 0x4d, 0xfc, + /*8340:*/ 0xe8, 0x44, 0xca, 0x60, 0xb6, 0x0a, 0x2f, 0x8a, 0x36, 0x83, 0x54, 0x6f, 0x68, 0xcd, 0xa6, 0x60, + /*8350:*/ 0x64, 0xdc, 0xcd, 0xde, 0xeb, 0x92, 0x47, 0x61, 0xce, 0xc7, 0xa9, 0x99, 0xd9, 0xad, 0x4e, 0x4d, + /*8360:*/ 0x11, 0xb5, 0x10, 0x46, 0x31, 0x91, 0x66, 0x42, 0xad, 0xe1, 0xb9, 0x79, 0x93, 0x62, 0xde, 0x40, + /*8370:*/ 0xd5, 0x1b, 0x74, 0x70, 0x73, 0xb1, 0xa7, 0xa3, 0x85, 0xcd, 0x55, 0x62, 0x8b, 0x2c, 0xf9, 0xcf, + /*8380:*/ 0xa5, 0x7f, 0x02, 0x3f, 0x58, 0x04, 0x7c, 0x02, 0x6f, 0x4d, 0xd4, 0x67, 0x95, 0x94, 0xf5, 0x42, + /*8390:*/ 0x57, 0xf9, 0xa1, 0x65, 0xc6, 0x2e, 0xb6, 0x7d, 0x1b, 0x93, 0x5b, 0xa3, 0x2d, 0x32, 0x77, 0x6b, + /*83a0:*/ 0xb0, 0xcd, 0xd6, 0x9b, 0xd6, 0x11, 0x7b, 0x5b, 0xc5, 0x10, 0x86, 0xc9, 0x74, 0x35, 0xfa, 0x67, + /*83b0:*/ 0xbc, 0xea, 0x5d, 0x46, 0x5c, 0xf6, 0x4f, 0xb7, 0x86, 0x58, 0xda, 0x5c, 0x38, 0xf5, 0x68, 0xb8, + /*83c0:*/ 0xcf, 0xbb, 0x7e, 0x76, 0x0d, 0xdd, 0x1b, 0x28, 0xcd, 0x4f, 0xb3, 0x99, 0x8c, 0x11, 0xef, 0x6e, + /*83d0:*/ 0x1b, 0xf0, 0x81, 0xb4, 0x6b, 0xb9, 0x34, 0xa4, 0x93, 0x5d, 0xf1, 0xca, 0xef, 0x45, 0x60, 0xc2, + /*83e0:*/ 0x35, 0xdf, 0x01, 0xcf, 0x2b, 0x3a, 0xb6, 0x1f, 0xd1, 0x8d, 0x3d, 0xe7, 0x12, 0x60, 0xed, 0xc4, + /*83f0:*/ 0x0b, 0x36, 0x84, 0xe3, 0x6b, 0x75, 0x09, 0x2a, 0x95, 0xad, 0xa5, 0x37, 0x4f, 0x75, 0xc5, 0x13, + /*8400:*/ 0x61, 0x74, 0x17, 0x83, 0x86, 0x94, 0x94, 0xfe, 0x0e, 0x7d, 0xc1, 0x54, 0x6b, 0x13, 0x3b, 0xd9, + /*8410:*/ 0x7c, 0xf7, 0x90, 0x56, 0x7d, 0x30, 0x42, 0xd0, 0x82, 0x42, 0xc3, 0x3a, 0x52, 0xdf, 0x70, 0x24, + /*8420:*/ 0xb3, 0xcb, 0x25, 0x15, 0x2d, 0x4e, 0xa9, 0xd4, 0x56, 0x33, 0xb9, 0x79, 0xca, 0xbd, 0xcc, 0x56, + /*8430:*/ 0x9f, 0x13, 0xc0, 0x44, 0xe4, 0x71, 0xdf, 0x2d, 0xf2, 0x55, 0x49, 0xae, 0x0f, 0x10, 0x4d, 0x03, + /*8440:*/ 0x08, 0x59, 0x6d, 0xf9, 0xb1, 0xd8, 0x14, 0x88, 0xdd, 0x0e, 0x0f, 0xa9, 0xbc, 0x5d, 0x74, 0xff, + /*8450:*/ 0x9b, 0xf8, 0x8c, 0xbb, 0xdf, 0xb4, 0x60, 0x64, 0x2f, 0x7b, 0x5e, 0x83, 0x52, 0xf5, 0x7a, 0xf7, + /*8460:*/ 0x33, 0x50, 0x08, 0x07, 0xb0, 0x2e, 0x7e, 0x88, 0xa8, 0x4b, 0xd2, 0xe5, 0xbc, 0x9c, 0xf2, 0x1b, + /*8470:*/ 0x64, 0xe9, 0x1c, 0x65, 0xb4, 0xec, 0x97, 0x0d, 0xd3, 0xa0, 0x8e, 0x02, 0xe9, 0x2b, 0xb1, 0x05, + /*8480:*/ 0x74, 0xe9, 0x8c, 0x18, 0x27, 0xcd, 0x6c, 0x59, 0x5d, 0xfd, 0xf3, 0x56, 0x5e, 0x56, 0xd7, 0xf0, + /*8490:*/ 0xa4, 0x0a, 0xc0, 0x16, 0x81, 0x07, 0x41, 0xc7, 0xf0, 0xe1, 0x08, 0x1a, 0xf8, 0xa8, 0x0f, 0xa7, + /*84a0:*/ 0x23, 0x95, 0xaa, 0x49, 0x3c, 0x5e, 0xb2, 0x7f, 0x69, 0xf3, 0x3d, 0xdd, 0xb4, 0x56, 0x96, 0xdb, + /*84b0:*/ 0xea, 0xf2, 0x34, 0xa8, 0xd0, 0xb7, 0x72, 0x98, 0x47, 0x15, 0x93, 0xf6, 0x57, 0x9c, 0xb1, 0x26, + /*84c0:*/ 0xf1, 0x00, 0xdf, 0xe8, 0xfb, 0x81, 0x15, 0x0f, 0x8d, 0x33, 0x9e, 0x79, 0x0e, 0x41, 0xf4, 0x16, + /*84d0:*/ 0x31, 0xdd, 0xfd, 0xec, 0x7d, 0x4b, 0x7e, 0x3b, 0xd7, 0x71, 0xf1, 0x1c, 0xb2, 0x53, 0x2b, 0x6f, + /*84e0:*/ 0xc5, 0x58, 0xf1, 0x50, 0xfe, 0xc3, 0x29, 0x82, 0xd2, 0xf4, 0x7c, 0xd7, 0x42, 0x8a, 0x7a, 0x83, + /*84f0:*/ 0x79, 0x42, 0x62, 0xde, 0x92, 0x64, 0x58, 0x6e, 0x9b, 0x24, 0x8d, 0x16, 0xb8, 0xf9, 0x83, 0xf9, + /*8500:*/ 0x8a, 0x35, 0x67, 0xf7, 0x07, 0xd5, 0x43, 0xd0, 0xc6, 0x71, 0x35, 0xfb, 0xb5, 0x9f, 0x0d, 0x84, + /*8510:*/ 0x9e, 0xa9, 0x69, 0x3b, 0x4e, 0x3c, 0xa3, 0x72, 0xd7, 0x48, 0xaf, 0xae, 0xba, 0xae, 0x4a, 0xf7, + /*8520:*/ 0x06, 0xce, 0xf6, 0xc8, 0x41, 0x0a, 0x7e, 0xfb, 0x76, 0xc6, 0xb0, 0xcc, 0xa9, 0xd9, 0xd3, 0xb6, + /*8530:*/ 0xfe, 0xc5, 0x62, 0x99, 0x28, 0x03, 0xdb, 0xa8, 0x10, 0xe9, 0xd2, 0x3b, 0x1b, 0xe2, 0xf5, 0x1b, + /*8540:*/ 0x81, 0xea, 0xfd, 0xd2, 0x9f, 0x34, 0xc8, 0xca, 0x58, 0x6d, 0x74, 0xbf, 0x2b, 0x53, 0x17, 0xf2, + /*8550:*/ 0x64, 0x15, 0xc0, 0x31, 0x77, 0x7a, 0x00, 0xcd, 0x28, 0x72, 0x56, 0x82, 0x81, 0xb8, 0xd8, 0x56, + /*8560:*/ 0x0f, 0xe1, 0xa3, 0xc2, 0xf8, 0x78, 0x01, 0x9f, 0x76, 0xd8, 0x77, 0xf6, 0x06, 0x78, 0x4c, 0xf4, + /*8570:*/ 0xf8, 0xab, 0x09, 0x9f, 0x81, 0x7c, 0xdf, 0x6c, 0x79, 0x0f, 0xb8, 0xed, 0xec, 0x92, 0x68, 0xb1, + /*8580:*/ 0x0d, 0xed, 0x5c, 0x62, 0xe1, 0x94, 0x91, 0xfd, 0x39, 0xbe, 0x65, 0x59, 0x45, 0xfb, 0x59, 0xe1, + /*8590:*/ 0xbd, 0xad, 0xbc, 0x41, 0xa0, 0x94, 0x49, 0xec, 0x29, 0x06, 0xe9, 0xd8, 0x64, 0x04, 0xe1, 0x70, + /*85a0:*/ 0x31, 0xb9, 0xe4, 0xdf, 0x23, 0xf9, 0x7d, 0x0f, 0x5d, 0x9a, 0xa6, 0x67, 0x4c, 0xde, 0xdd, 0xb6, + /*85b0:*/ 0xb2, 0xc5, 0x33, 0x87, 0xee, 0xb8, 0x36, 0xaa, 0x32, 0xdb, 0xc4, 0x90, 0x9b, 0xe0, 0xc2, 0x6c, + /*85c0:*/ 0xcd, 0xae, 0xff, 0x7e, 0x9a, 0x35, 0xa7, 0x4e, 0x48, 0xe2, 0x62, 0x1b, 0x0e, 0x7d, 0x9b, 0x44, + /*85d0:*/ 0x43, 0xbd, 0x55, 0x82, 0x88, 0x1a, 0x9c, 0x83, 0xfc, 0x1e, 0x3d, 0x8b, 0x6b, 0x29, 0x23, 0xf8, + /*85e0:*/ 0x1e, 0xba, 0xb4, 0x5b, 0xc5, 0x80, 0x12, 0x70, 0x48, 0x9b, 0x41, 0xfb, 0xe6, 0xc8, 0xf3, 0x19, + /*85f0:*/ 0x15, 0x7b, 0xc0, 0x8d, 0xb0, 0x49, 0x67, 0xcc, 0xf4, 0xe0, 0x12, 0x41, 0xf9, 0xfb, 0xd4, 0x1a, + /*8600:*/ 0xe8, 0x72, 0x1b, 0xfc, 0x02, 0xbe, 0x6d, 0x34, 0x96, 0xaf, 0xba, 0x96, 0x44, 0x7d, 0xce, 0x3f, + /*8610:*/ 0x0e, 0x58, 0x7b, 0xb1, 0x0d, 0xb7, 0x00, 0x43, 0x6d, 0x81, 0xaa, 0xa6, 0xe4, 0x5c, 0xf1, 0xa4, + /*8620:*/ 0x1f, 0xe4, 0xa8, 0x30, 0x2b, 0x0c, 0xbf, 0xdd, 0x69, 0xfa, 0xe7, 0xf7, 0x44, 0xff, 0x50, 0x2b, + /*8630:*/ 0x39, 0x73, 0xbd, 0x03, 0x22, 0x84, 0xef, 0x14, 0x08, 0x74, 0xa8, 0x85, 0x05, 0x64, 0xd4, 0xc7, + /*8640:*/ 0x30, 0xa4, 0x84, 0x2e, 0xbd, 0x8d, 0x0c, 0xee, 0xfc, 0x11, 0x0f, 0x0c, 0x3f, 0xb1, 0x48, 0x6e, + /*8650:*/ 0xb6, 0x09, 0x01, 0xc8, 0x54, 0x6a, 0xe7, 0x1b, 0x46, 0x90, 0x5b, 0x79, 0x64, 0x08, 0xa8, 0xda, + /*8660:*/ 0xb0, 0x7e, 0x1f, 0xc3, 0x8c, 0xee, 0x9e, 0x9f, 0x8b, 0x9b, 0xc2, 0x80, 0x2f, 0x4f, 0x0d, 0x3a, + /*8670:*/ 0x97, 0x3b, 0xcd, 0xfa, 0xde, 0xa0, 0xaf, 0x6d, 0x1e, 0xd2, 0x47, 0x31, 0xe0, 0xf3, 0xcf, 0x15, + /*8680:*/ 0x12, 0xae, 0x45, 0xbb, 0x28, 0x04, 0x5e, 0xf6, 0x2e, 0xab, 0xa5, 0x8f, 0xea, 0xd0, 0xa4, 0xbf, + /*8690:*/ 0xbe, 0xa7, 0x77, 0x5d, 0x7b, 0xab, 0x48, 0x5f, 0x1a, 0xe4, 0xc6, 0xb3, 0x62, 0x70, 0xdf, 0x82, + /*86a0:*/ 0x24, 0x59, 0xd6, 0x88, 0x5c, 0x36, 0xd6, 0x0c, 0xbe, 0xbc, 0xbd, 0xc6, 0x1a, 0xcb, 0x93, 0xfa, + /*86b0:*/ 0xff, 0x16, 0x26, 0xea, 0xd2, 0xd3, 0x41, 0x5a, 0x49, 0x00, 0x99, 0x12, 0x48, 0xbe, 0xa8, 0xc7, + /*86c0:*/ 0xe3, 0x5d, 0x3b, 0xb1, 0x40, 0x35, 0xee, 0xfe, 0xc3, 0x78, 0x2b, 0xfe, 0x10, 0x20, 0xc9, 0x96, + /*86d0:*/ 0x28, 0xc2, 0xb2, 0x17, 0x03, 0x69, 0x85, 0x74, 0xf5, 0xac, 0x28, 0x02, 0xd0, 0x97, 0x74, 0xf2, + /*86e0:*/ 0x22, 0x12, 0x80, 0xf1, 0x1b, 0xd8, 0x49, 0x1d, 0x70, 0x79, 0x56, 0x7a, 0xbb, 0x2e, 0x5b, 0x35, + /*86f0:*/ 0x17, 0x34, 0x9b, 0xef, 0xf8, 0x58, 0x8d, 0x4b, 0xf3, 0x9a, 0x7a, 0xb3, 0xf7, 0x8c, 0x08, 0x4c, + /*8700:*/ 0x1f, 0xe4, 0x47, 0x30, 0xa2, 0x16, 0x9e, 0xe3, 0x5f, 0xb6, 0x57, 0xb3, 0x93, 0x8f, 0xd0, 0x5e, + /*8710:*/ 0x3b, 0x8d, 0x64, 0x70, 0x7c, 0xbc, 0x6e, 0xc0, 0x12, 0x4b, 0x1e, 0xcd, 0x0b, 0x58, 0x5c, 0xed, + /*8720:*/ 0x19, 0x2f, 0x72, 0x39, 0xaf, 0x03, 0xaf, 0x8f, 0xe0, 0xc1, 0x3f, 0xcc, 0x8a, 0x9a, 0x95, 0x12, + /*8730:*/ 0x7c, 0x88, 0x38, 0x7d, 0x82, 0xdb, 0xbe, 0x58, 0xbb, 0xa8, 0x9b, 0x05, 0x5f, 0x81, 0xe4, 0xaa, + /*8740:*/ 0x58, 0x81, 0xdc, 0x5f, 0x8a, 0x7c, 0xc0, 0xbc, 0x57, 0xa8, 0x48, 0xa4, 0x7e, 0xd5, 0x6d, 0xc4, + /*8750:*/ 0x04, 0x62, 0xbd, 0x28, 0x0e, 0x5c, 0x97, 0x3b, 0xf2, 0x6f, 0xee, 0xe9, 0x0d, 0x5a, 0x9c, 0x79, + /*8760:*/ 0x17, 0xfe, 0xac, 0x66, 0xb0, 0xa6, 0x6e, 0x11, 0x9b, 0xbe, 0x0b, 0xb4, 0x32, 0x67, 0x47, 0x14, + /*8770:*/ 0x70, 0xd6, 0x1c, 0x8c, 0x8f, 0x95, 0x96, 0xa8, 0x46, 0x10, 0x82, 0x49, 0xb7, 0x69, 0xb7, 0x40, + /*8780:*/ 0x83, 0xad, 0xfa, 0x1f, 0x89, 0x05, 0x8a, 0x16, 0x58, 0xee, 0x9c, 0xfd, 0x9f, 0x0c, 0xc6, 0xca, + /*8790:*/ 0xaf, 0x47, 0x5a, 0x00, 0xcd, 0xd6, 0x83, 0x8d, 0x04, 0xf6, 0x18, 0xc7, 0xf3, 0xd2, 0x4c, 0x7c, + /*87a0:*/ 0xdf, 0xc8, 0x61, 0xa9, 0x82, 0x96, 0xf3, 0x18, 0x77, 0xe2, 0x0a, 0x2c, 0x77, 0x67, 0x3c, 0x65, + /*87b0:*/ 0xd4, 0x56, 0xb0, 0xa6, 0x57, 0x0e, 0x74, 0xc9, 0xb5, 0x5e, 0xde, 0xe3, 0x09, 0x69, 0x53, 0x77, + /*87c0:*/ 0xdf, 0xd6, 0x20, 0xba, 0x19, 0xd6, 0x16, 0xbd, 0x4c, 0x95, 0x94, 0x00, 0x4a, 0xf8, 0x72, 0x83, + /*87d0:*/ 0x4c, 0xf2, 0x96, 0xa7, 0x1e, 0xf9, 0x62, 0x98, 0x64, 0x1a, 0xa5, 0x40, 0xb1, 0xbe, 0xd5, 0xb6, + /*87e0:*/ 0x53, 0x5f, 0xb9, 0xce, 0xa3, 0xcf, 0x03, 0x46, 0x94, 0x85, 0xd8, 0xc4, 0x86, 0x23, 0x85, 0x08, + /*87f0:*/ 0x1a, 0x13, 0xa2, 0x41, 0xf6, 0x9d, 0x52, 0xc6, 0xb2, 0x67, 0xe3, 0x30, 0x23, 0xcb, 0x3a, 0x4b, + /*8800:*/ 0x41, 0x57, 0x5f, 0xd2, 0x75, 0x8b, 0x5f, 0x44, 0x39, 0x40, 0x34, 0x25, 0xf1, 0xda, 0x0a, 0xb0, + /*8810:*/ 0xf0, 0xac, 0x15, 0x8d, 0xee, 0x68, 0x5c, 0x39, 0xbf, 0x48, 0x9a, 0x82, 0xfd, 0x81, 0x45, 0x7e, + /*8820:*/ 0xce, 0x81, 0xe6, 0x97, 0x3d, 0xf4, 0x21, 0x8c, 0x9b, 0x36, 0xe6, 0xd0, 0xbf, 0xcc, 0xf2, 0x33, + /*8830:*/ 0x4e, 0x98, 0x70, 0x3f, 0x08, 0x52, 0x9f, 0xd4, 0x48, 0xf3, 0x0a, 0xd8, 0x51, 0xfb, 0x39, 0x9b, + /*8840:*/ 0x8a, 0xf1, 0x32, 0x55, 0xf0, 0x59, 0x68, 0x17, 0xc8, 0x35, 0xe3, 0x38, 0x8c, 0x40, 0xd4, 0xf7, + /*8850:*/ 0xd3, 0xe7, 0x20, 0x07, 0x84, 0xf8, 0xc0, 0x9a, 0x2c, 0x56, 0x6d, 0xaa, 0xae, 0xca, 0x16, 0x82, + /*8860:*/ 0x9a, 0xd1, 0x72, 0x2e, 0xd4, 0x12, 0xda, 0x65, 0xe6, 0x78, 0x01, 0x79, 0x16, 0xa2, 0x05, 0x45, + /*8870:*/ 0x0b, 0xbc, 0x65, 0xd4, 0xf5, 0x19, 0x9d, 0x1f, 0xa4, 0x49, 0x02, 0xe3, 0x0f, 0x1a, 0x82, 0x49, + /*8880:*/ 0x2c, 0xd2, 0x22, 0xdf, 0x97, 0x7d, 0xe6, 0xaf, 0x14, 0x03, 0xdf, 0x69, 0xe6, 0xf3, 0x07, 0x50, + /*8890:*/ 0x48, 0xe5, 0x42, 0xfe, 0xe3, 0x59, 0x91, 0x6d, 0xbc, 0xf6, 0xd1, 0xf0, 0x2a, 0xbd, 0x0a, 0x4d, + /*88a0:*/ 0x4f, 0x51, 0x6e, 0x0f, 0x76, 0xef, 0xa8, 0xb5, 0xa7, 0x8b, 0x49, 0xf3, 0xd5, 0x8e, 0xf4, 0x41, + /*88b0:*/ 0xf9, 0x57, 0x26, 0x2f, 0xcf, 0xa8, 0xd7, 0x76, 0x36, 0xd1, 0xf1, 0xb9, 0x26, 0x79, 0x92, 0xaf, + /*88c0:*/ 0xcc, 0xf6, 0xe9, 0xab, 0xf2, 0x96, 0xec, 0x5e, 0xbb, 0xcc, 0xf0, 0x89, 0x39, 0xc1, 0x83, 0x8f, + /*88d0:*/ 0xf5, 0x07, 0xb6, 0x17, 0x61, 0x17, 0x1c, 0xcd, 0xb6, 0x3b, 0xcc, 0x68, 0x8d, 0x52, 0x96, 0x18, + /*88e0:*/ 0xbf, 0x18, 0x00, 0xcf, 0xf5, 0x9c, 0x81, 0x20, 0xb0, 0xed, 0x63, 0xef, 0x1e, 0xa2, 0xac, 0x84, + /*88f0:*/ 0x19, 0xd8, 0x9a, 0x28, 0x68, 0x27, 0xb1, 0x99, 0x54, 0x4b, 0xe4, 0x0b, 0xcc, 0x55, 0x9e, 0x49, + /*8900:*/ 0xdb, 0xbc, 0x4d, 0x85, 0x1d, 0x83, 0x83, 0x46, 0x64, 0x27, 0xe1, 0x6d, 0x25, 0x24, 0x72, 0xfe, + /*8910:*/ 0xfb, 0x37, 0x67, 0x48, 0xf0, 0x7f, 0x7a, 0xbc, 0x9c, 0x9b, 0xa6, 0xe0, 0x55, 0xa4, 0x98, 0x3b, + /*8920:*/ 0x8e, 0xbe, 0x5b, 0x92, 0x29, 0x5e, 0xcd, 0x46, 0xcd, 0x83, 0x43, 0xfb, 0x8a, 0xaf, 0x68, 0x89, + /*8930:*/ 0xc6, 0x68, 0x32, 0x83, 0x7c, 0x33, 0x6e, 0xf9, 0x8f, 0x53, 0x40, 0xda, 0x2c, 0x6f, 0xcc, 0x7a, + /*8940:*/ 0xd7, 0x90, 0xd7, 0xc0, 0x29, 0x9d, 0xb7, 0x08, 0xe0, 0xa4, 0x41, 0x25, 0x7e, 0x39, 0x04, 0xf3, + /*8950:*/ 0x02, 0xb8, 0x4e, 0x3e, 0xee, 0x80, 0x07, 0x20, 0xdc, 0x49, 0x16, 0x9e, 0xab, 0xb0, 0x81, 0xd3, + /*8960:*/ 0x33, 0x00, 0xfe, 0xf6, 0x85, 0xcd, 0xf8, 0xe6, 0x79, 0x87, 0x1a, 0x5b, 0x1e, 0x11, 0x1b, 0xca, + /*8970:*/ 0x89, 0x35, 0xa5, 0x3a, 0x98, 0x0f, 0x4d, 0x20, 0x25, 0xe4, 0xbf, 0x48, 0x6d, 0x2c, 0x03, 0x97, + /*8980:*/ 0xff, 0xbb, 0x85, 0x3b, 0x1f, 0x17, 0x4f, 0xd6, 0xf4, 0xd4, 0xb8, 0x80, 0x49, 0x1a, 0x52, 0x26, + /*8990:*/ 0xbd, 0x81, 0x41, 0xe8, 0xc3, 0x63, 0x67, 0xf3, 0xe5, 0xeb, 0x57, 0xbe, 0x28, 0x83, 0xef, 0x3f, + /*89a0:*/ 0xcc, 0xff, 0x4f, 0xed, 0x19, 0xce, 0xe9, 0xe5, 0x0d, 0x1e, 0x0c, 0xd3, 0x8d, 0xed, 0xa3, 0x47, + /*89b0:*/ 0xb7, 0x1d, 0x63, 0x61, 0xc7, 0xfe, 0x36, 0xfa, 0x05, 0x30, 0xd9, 0x36, 0x04, 0xb8, 0x05, 0x1b, + /*89c0:*/ 0x89, 0xf3, 0xc0, 0x81, 0x07, 0xd5, 0xdf, 0x7f, 0x17, 0x5c, 0xaf, 0x75, 0x35, 0xeb, 0x2b, 0xac, + /*89d0:*/ 0x48, 0xd6, 0x07, 0xe7, 0x72, 0x3e, 0xa6, 0x30, 0x75, 0x77, 0x03, 0x74, 0x31, 0xe5, 0x8b, 0x10, + /*89e0:*/ 0xd0, 0x2a, 0x3c, 0xc7, 0x7d, 0xd4, 0x4e, 0xa5, 0xc9, 0xc7, 0xd1, 0xb8, 0xdb, 0x9d, 0x34, 0xbb, + /*89f0:*/ 0xce, 0x26, 0x16, 0x60, 0x38, 0x95, 0x28, 0x78, 0x60, 0xcb, 0x3f, 0xbd, 0xaa, 0x93, 0xed, 0xb3, + /*8a00:*/ 0x0d, 0xd0, 0x8c, 0xf4, 0x69, 0x24, 0x35, 0x84, 0x60, 0x2b, 0x48, 0x5b, 0x9a, 0x7e, 0xb8, 0xe1, + /*8a10:*/ 0xec, 0x6a, 0x17, 0x17, 0xb9, 0xdc, 0x5d, 0xa9, 0xf2, 0x95, 0x7f, 0xf5, 0xe7, 0x6c, 0x79, 0x93, + /*8a20:*/ 0xab, 0xb2, 0x52, 0x1a, 0x39, 0x5b, 0x3e, 0x49, 0x18, 0x19, 0x3c, 0xe7, 0x7e, 0xf4, 0x95, 0x96, + /*8a30:*/ 0x79, 0x30, 0xc0, 0x3f, 0x7a, 0xde, 0x28, 0xd9, 0x95, 0xe3, 0x69, 0x5b, 0xa5, 0x10, 0xb3, 0xe6, + /*8a40:*/ 0x1c, 0x01, 0xcc, 0xd4, 0xf2, 0x58, 0x76, 0x52, 0x9b, 0x1e, 0xa1, 0x90, 0xb0, 0xa4, 0x8e, 0x3e, + /*8a50:*/ 0x9f, 0x46, 0x9e, 0xa8, 0x75, 0x15, 0xe7, 0xfb, 0xf8, 0x5b, 0xb4, 0x55, 0x92, 0x12, 0x1b, 0x07, + /*8a60:*/ 0xb0, 0xe9, 0x0e, 0xf7, 0xf6, 0x1c, 0x7b, 0x31, 0x35, 0x2c, 0x3f, 0x12, 0x08, 0x1f, 0xe5, 0xf7, + /*8a70:*/ 0x7c, 0x9a, 0x32, 0xa2, 0xa5, 0x5c, 0x49, 0x54, 0x52, 0x0d, 0xca, 0xeb, 0x2c, 0x5e, 0x0d, 0xf2, + /*8a80:*/ 0x54, 0x10, 0x6b, 0x8f, 0x81, 0x1d, 0x56, 0x6e, 0x62, 0x7b, 0xfa, 0xe5, 0x65, 0x85, 0x71, 0xde, + /*8a90:*/ 0x53, 0x5e, 0x8a, 0x39, 0xed, 0x01, 0x3d, 0xe0, 0x37, 0x22, 0x1d, 0xd5, 0x6d, 0x94, 0xee, 0x8b, + /*8aa0:*/ 0x26, 0x8b, 0xe4, 0xf9, 0x2e, 0x14, 0xe8, 0x33, 0x59, 0xd1, 0x91, 0x32, 0x4a, 0x57, 0x4b, 0x8a, + /*8ab0:*/ 0x81, 0xbc, 0x57, 0x87, 0xe4, 0xa2, 0x73, 0x27, 0xd5, 0x25, 0x7b, 0x25, 0x09, 0x58, 0x29, 0xd5, + /*8ac0:*/ 0xb2, 0x7a, 0x3b, 0x59, 0x00, 0xf3, 0xba, 0x38, 0x72, 0xa2, 0xd3, 0x0e, 0x92, 0x0f, 0xbd, 0x9d, + /*8ad0:*/ 0x08, 0xbb, 0xe1, 0xdd, 0x55, 0x7c, 0xd7, 0xaa, 0xf6, 0x23, 0x2f, 0x21, 0xba, 0x7a, 0x4c, 0xe6, + /*8ae0:*/ 0xf6, 0x21, 0x8a, 0x3f, 0x28, 0xfa, 0x5d, 0x78, 0x4a, 0xba, 0x36, 0x1f, 0xdc, 0xeb, 0xa4, 0x25, + /*8af0:*/ 0x4a, 0x5c, 0x19, 0xab, 0xaf, 0x78, 0x25, 0x85, 0x5d, 0x2c, 0x56, 0x91, 0xb2, 0xc2, 0x4c, 0xd1, + /*8b00:*/ 0x12, 0x1b, 0x0f, 0xcf, 0x71, 0x79, 0x3f, 0x39, 0xd4, 0x0c, 0x02, 0xef, 0x4c, 0x77, 0x61, 0xb2, + /*8b10:*/ 0x3e, 0x7e, 0x2e, 0x89, 0x23, 0x88, 0x61, 0xd2, 0xb7, 0x7b, 0xe0, 0xfa, 0x91, 0xa6, 0x7b, 0x20, + /*8b20:*/ 0x26, 0x37, 0xbd, 0xd0, 0xaa, 0x0c, 0x6b, 0x9a, 0x12, 0x3a, 0xf6, 0xff, 0x39, 0x7f, 0x41, 0xee, + /*8b30:*/ 0x8b, 0xd3, 0xc6, 0x0e, 0x0e, 0xc1, 0x73, 0x60, 0x7e, 0xd0, 0x65, 0x4b, 0x47, 0x16, 0x17, 0xcd, + /*8b40:*/ 0x6d, 0x4d, 0x6e, 0x24, 0xdd, 0x1f, 0x24, 0x4c, 0x2a, 0xb1, 0x09, 0xf7, 0x77, 0xb6, 0x18, 0xe2, + /*8b50:*/ 0xa6, 0xd7, 0x2f, 0x41, 0xf8, 0x87, 0xb2, 0x89, 0x86, 0x60, 0xdc, 0x55, 0x0f, 0xbe, 0x68, 0xa9, + /*8b60:*/ 0x3c, 0x3e, 0xc1, 0xd9, 0x2b, 0x92, 0x1e, 0xb1, 0xe9, 0x97, 0xfc, 0xc8, 0xe9, 0x0a, 0xdc, 0xa6, + /*8b70:*/ 0x43, 0xe8, 0xc1, 0xeb, 0x02, 0x54, 0x9f, 0x94, 0xaa, 0xf2, 0xef, 0x72, 0xa3, 0x5b, 0x96, 0xfe, + /*8b80:*/ 0x33, 0xc5, 0x04, 0x0f, 0x37, 0x1c, 0x77, 0x5d, 0x53, 0x7c, 0xa3, 0x42, 0x0c, 0x40, 0x4a, 0x50, + /*8b90:*/ 0xc6, 0x44, 0x1e, 0xdd, 0x1c, 0x27, 0x87, 0x8f, 0x79, 0x8f, 0x2b, 0x7e, 0x2c, 0x2c, 0x08, 0xaf, + /*8ba0:*/ 0xc6, 0xcb, 0x68, 0xbe, 0xc7, 0x41, 0x9e, 0x01, 0xf5, 0x51, 0x04, 0xa2, 0x52, 0xb0, 0x58, 0xa6, + /*8bb0:*/ 0xc3, 0xd9, 0xf8, 0xe5, 0xe5, 0x60, 0x5a, 0x42, 0x1c, 0x92, 0x71, 0x27, 0x2b, 0x1b, 0x7b, 0xad, + /*8bc0:*/ 0x32, 0x24, 0x3e, 0x75, 0xa2, 0x64, 0xaa, 0x8e, 0xe1, 0x96, 0x6e, 0x80, 0xf7, 0x6f, 0xdb, 0xce, + /*8bd0:*/ 0xa8, 0xd5, 0x4a, 0x8b, 0xd4, 0x29, 0x10, 0x03, 0x17, 0x38, 0x5f, 0xdc, 0xca, 0xd7, 0xeb, 0xac, + /*8be0:*/ 0x45, 0x3d, 0xb8, 0x1b, 0x20, 0xae, 0x91, 0x6b, 0x63, 0xc7, 0xe4, 0x69, 0x94, 0xb9, 0x41, 0xe8, + /*8bf0:*/ 0xdc, 0x67, 0xb8, 0x0a, 0xfa, 0x72, 0x4e, 0x23, 0x12, 0xd9, 0xb1, 0x13, 0xf7, 0x53, 0xf6, 0x2b, + /*8c00:*/ 0x89, 0x06, 0x80, 0x67, 0x02, 0xc5, 0x4b, 0xbd, 0xaf, 0x60, 0x73, 0x90, 0x00, 0xd3, 0xfc, 0x9e, + /*8c10:*/ 0x59, 0x76, 0xaf, 0x70, 0x44, 0xd9, 0xae, 0x1a, 0x6b, 0xa7, 0x56, 0xad, 0x1b, 0xc2, 0xe6, 0xd5, + /*8c20:*/ 0xbc, 0x6f, 0x4a, 0xd9, 0x59, 0x11, 0xc1, 0xc5, 0xaf, 0x36, 0x26, 0x93, 0xd6, 0x20, 0x72, 0x61, + /*8c30:*/ 0x8e, 0xb6, 0x84, 0xab, 0x54, 0xcb, 0x7c, 0xf6, 0x84, 0x3b, 0x09, 0x3a, 0x46, 0x2f, 0xc6, 0x95, + /*8c40:*/ 0x07, 0x5f, 0xda, 0xf6, 0x8b, 0x30, 0x6d, 0xd9, 0xbb, 0x6f, 0x13, 0xea, 0x81, 0xa3, 0xd5, 0x72, + /*8c50:*/ 0x46, 0x43, 0x53, 0xe5, 0xbd, 0x02, 0x9c, 0x1d, 0x29, 0x94, 0x97, 0x01, 0xce, 0x6a, 0x76, 0x7b, + /*8c60:*/ 0xc3, 0xa5, 0x2f, 0xcf, 0xe4, 0x81, 0x32, 0xb5, 0x9f, 0xa1, 0x98, 0xea, 0xab, 0xe9, 0x6c, 0x8a, + /*8c70:*/ 0x37, 0x4e, 0x9e, 0x10, 0x1b, 0x87, 0xbd, 0x06, 0x77, 0xd5, 0x79, 0x79, 0xe3, 0x6d, 0x4e, 0x96, + /*8c80:*/ 0x51, 0x56, 0xd6, 0x18, 0x93, 0xe8, 0x69, 0xb4, 0x50, 0xf6, 0x61, 0xfc, 0x67, 0xdf, 0x82, 0xd4, + /*8c90:*/ 0x99, 0x06, 0x16, 0x97, 0x95, 0xd6, 0x43, 0xd6, 0x31, 0x4f, 0xb7, 0xeb, 0x2f, 0x3a, 0x3b, 0x1a, + /*8ca0:*/ 0xd9, 0xe2, 0xa1, 0xca, 0xbb, 0x76, 0x48, 0xe3, 0x47, 0xcc, 0xbe, 0x67, 0x24, 0xa2, 0xd0, 0x9a, + /*8cb0:*/ 0x7c, 0x30, 0x4f, 0x1b, 0x85, 0x08, 0xc9, 0xec, 0x98, 0x65, 0xb0, 0x93, 0x10, 0x1c, 0xca, 0x83, + /*8cc0:*/ 0x2d, 0x00, 0x68, 0x96, 0x39, 0x3f, 0x3f, 0x7c, 0x42, 0x6b, 0x6f, 0x41, 0x3f, 0xf3, 0x29, 0x66, + /*8cd0:*/ 0x98, 0xfb, 0x14, 0x3c, 0x8b, 0xd9, 0x5f, 0xdd, 0xe7, 0x8d, 0xbd, 0x40, 0x5a, 0x12, 0x41, 0x0c, + /*8ce0:*/ 0xd8, 0x02, 0x89, 0xc1, 0x65, 0x1b, 0xb2, 0x79, 0x6b, 0x98, 0x50, 0xff, 0xc8, 0xf0, 0x67, 0x66, + /*8cf0:*/ 0x51, 0xb8, 0x05, 0xc9, 0x1a, 0xcc, 0x7e, 0x28, 0x22, 0xc7, 0x11, 0xf6, 0xfc, 0x71, 0xeb, 0x97, + /*8d00:*/ 0x4b, 0x51, 0x53, 0x25, 0x88, 0xc9, 0x5e, 0x11, 0x84, 0x79, 0x4e, 0xf2, 0x02, 0x2f, 0xa6, 0x7e, + /*8d10:*/ 0x82, 0x65, 0x34, 0xfa, 0xd6, 0x33, 0xfe, 0xaa, 0x95, 0xe5, 0xb3, 0xd1, 0x5e, 0xf6, 0xdf, 0x96, + /*8d20:*/ 0x20, 0x29, 0xd6, 0xd4, 0xc1, 0x5c, 0x53, 0x2b, 0x4c, 0x32, 0xf4, 0xae, 0xfc, 0x69, 0x53, 0xfc, + /*8d30:*/ 0x2a, 0x7e, 0x83, 0xfb, 0x8f, 0x35, 0xe2, 0xd9, 0x5c, 0x12, 0x22, 0x5c, 0xc0, 0x75, 0x8a, 0x23, + /*8d40:*/ 0x8d, 0x63, 0xc8, 0xa9, 0x69, 0x40, 0x9c, 0x29, 0x22, 0xe9, 0x6a, 0x2b, 0x0c, 0xb7, 0xc8, 0x79, + /*8d50:*/ 0xb6, 0xcd, 0xaf, 0xac, 0x91, 0x96, 0x78, 0xb6, 0x29, 0x0b, 0xbd, 0x76, 0xd5, 0x2e, 0xcc, 0x39, + /*8d60:*/ 0x3b, 0xcc, 0xb1, 0xff, 0x91, 0xb9, 0xab, 0xcb, 0x34, 0xfb, 0xcf, 0xaf, 0xe3, 0xde, 0xb2, 0x37, + /*8d70:*/ 0xb5, 0x79, 0x47, 0xb3, 0xac, 0x9b, 0x20, 0xc4, 0xda, 0x7d, 0x6f, 0x49, 0x6f, 0x8b, 0xe3, 0x4b, + /*8d80:*/ 0x31, 0x23, 0x28, 0x63, 0x08, 0x59, 0x23, 0xf1, 0xa5, 0xea, 0x64, 0x08, 0x88, 0x34, 0xf3, 0x39, + /*8d90:*/ 0x62, 0xe8, 0x7a, 0x18, 0xed, 0x25, 0xa4, 0x68, 0x3d, 0xa6, 0x64, 0x0d, 0xdc, 0x99, 0x05, 0xc9, + /*8da0:*/ 0xb0, 0x9e, 0xc3, 0xe3, 0xa2, 0x9e, 0xc7, 0x92, 0x7a, 0xe1, 0xdd, 0x0e, 0x9d, 0x71, 0x6c, 0xf5, + /*8db0:*/ 0x73, 0xa5, 0xf9, 0xdf, 0x94, 0x49, 0xa3, 0x23, 0x73, 0xe0, 0x51, 0x6d, 0x0f, 0x9e, 0x1a, 0x87, + /*8dc0:*/ 0x3a, 0xef, 0xa4, 0x63, 0x13, 0x79, 0x7a, 0x2d, 0x0f, 0x7c, 0x88, 0x8b, 0xb1, 0x65, 0xbf, 0x0a, + /*8dd0:*/ 0xb5, 0x21, 0xc4, 0x7c, 0x65, 0xe3, 0x52, 0x1d, 0xa2, 0xf6, 0x1d, 0x93, 0x84, 0x86, 0x7a, 0xe8, + /*8de0:*/ 0x5f, 0x72, 0x4b, 0x85, 0x48, 0x8f, 0x23, 0x93, 0x7f, 0xdd, 0xef, 0x17, 0x46, 0x5d, 0xbe, 0xc0, + /*8df0:*/ 0x67, 0xbd, 0xe4, 0xd7, 0xc9, 0xca, 0x2e, 0xc6, 0x8b, 0xc3, 0x82, 0x28, 0x0f, 0xa6, 0x22, 0x9c, + /*8e00:*/ 0xaf, 0x0c, 0xa2, 0x5f, 0xe6, 0x91, 0x72, 0x6b, 0x43, 0x44, 0xd5, 0x8c, 0xd5, 0x55, 0xc2, 0x6a, + /*8e10:*/ 0x95, 0xe0, 0x42, 0x22, 0x41, 0xe7, 0xd5, 0x2a, 0xfa, 0xf7, 0xaa, 0x74, 0x29, 0x4f, 0x87, 0x2c, + /*8e20:*/ 0x38, 0x6a, 0x4a, 0x07, 0x38, 0xfd, 0x8c, 0xe2, 0x8d, 0xd8, 0x2b, 0x2e, 0xe7, 0x2b, 0xbc, 0x02, + /*8e30:*/ 0x22, 0xa1, 0x26, 0xce, 0x57, 0xab, 0x9b, 0x20, 0x02, 0x43, 0xaf, 0xb5, 0x73, 0x95, 0xc1, 0x5a, + /*8e40:*/ 0xe2, 0xe3, 0x7f, 0x60, 0x04, 0xab, 0xa3, 0x21, 0xf8, 0x18, 0xdb, 0x6b, 0x01, 0xdf, 0x6a, 0xac, + /*8e50:*/ 0xdb, 0x37, 0xa4, 0xdd, 0x4b, 0x0e, 0xfa, 0x39, 0xed, 0x64, 0xfb, 0xfc, 0x98, 0xe7, 0x71, 0x02, + /*8e60:*/ 0xdd, 0xbb, 0xa5, 0x62, 0x7e, 0x18, 0x16, 0xe1, 0x6e, 0xbd, 0x1d, 0xb3, 0xc5, 0x11, 0xd2, 0xdb, + /*8e70:*/ 0x20, 0x1f, 0x3a, 0x84, 0xda, 0x08, 0x7d, 0x58, 0x50, 0xc3, 0x3c, 0x5c, 0x7c, 0xc9, 0xb8, 0x78, + /*8e80:*/ 0x03, 0x57, 0x93, 0x71, 0x71, 0x28, 0xaf, 0x84, 0xd6, 0x89, 0xa2, 0xd4, 0x01, 0xcb, 0x26, 0x1b, + /*8e90:*/ 0x0a, 0x35, 0x38, 0xf8, 0x77, 0xb1, 0x09, 0x03, 0xb7, 0x1a, 0x0d, 0xb2, 0x82, 0x90, 0x22, 0x05, + /*8ea0:*/ 0x19, 0x63, 0x66, 0x58, 0x4a, 0xf9, 0x2f, 0x2f, 0xe2, 0xbb, 0x2b, 0x31, 0xca, 0xdc, 0x96, 0x47, + /*8eb0:*/ 0x88, 0x7d, 0x62, 0x75, 0xe6, 0x96, 0xf3, 0xa2, 0x1e, 0x62, 0x59, 0xff, 0x24, 0xbe, 0x2f, 0x8f, + /*8ec0:*/ 0xdf, 0xd5, 0x72, 0xfc, 0x0f, 0xc8, 0x10, 0x48, 0xa2, 0x90, 0xe0, 0x1a, 0xa2, 0x0c, 0x80, 0x80, + /*8ed0:*/ 0xda, 0xb8, 0x2f, 0x8c, 0xc4, 0x07, 0x49, 0x7a, 0x29, 0xf5, 0xbb, 0x02, 0x49, 0xc0, 0xa5, 0x5c, + /*8ee0:*/ 0x54, 0x6f, 0x05, 0xb6, 0x48, 0x1c, 0x41, 0xc9, 0xa2, 0x19, 0xab, 0xc4, 0x39, 0x6d, 0xf7, 0x7b, + /*8ef0:*/ 0x22, 0xc0, 0xbd, 0xbf, 0xd7, 0x88, 0x46, 0xe4, 0x18, 0x42, 0x06, 0xea, 0x45, 0xcb, 0x6a, 0xe1, + /*8f00:*/ 0x23, 0xe6, 0x93, 0x32, 0x7a, 0x56, 0x90, 0x80, 0xa9, 0xb1, 0xe3, 0x47, 0x6f, 0x71, 0x17, 0xb2, + /*8f10:*/ 0x6f, 0x5b, 0x23, 0x7a, 0x22, 0xea, 0xeb, 0xd1, 0x52, 0xed, 0x41, 0x71, 0xf5, 0x16, 0x98, 0x3a, + /*8f20:*/ 0x57, 0x79, 0x86, 0x99, 0xbf, 0xbe, 0xd2, 0x6b, 0x9d, 0x2a, 0x14, 0x61, 0x03, 0x5e, 0x4b, 0x5f, + /*8f30:*/ 0x02, 0x59, 0x22, 0x37, 0x13, 0x79, 0x7d, 0x47, 0xca, 0xc4, 0xe9, 0xa9, 0x0f, 0x33, 0x89, 0x72, + /*8f40:*/ 0x86, 0x3a, 0x79, 0x68, 0x17, 0x63, 0x6a, 0x0d, 0x50, 0x59, 0xd3, 0xb8, 0x3f, 0x32, 0x84, 0x6a, + /*8f50:*/ 0x7c, 0x11, 0x65, 0xb1, 0x34, 0xb6, 0x6a, 0x9f, 0x59, 0x28, 0xdd, 0xe8, 0xef, 0x10, 0x2a, 0x65, + /*8f60:*/ 0xde, 0x73, 0x8e, 0x15, 0x64, 0xcf, 0x99, 0xa9, 0x01, 0xdb, 0x79, 0x12, 0x99, 0x9b, 0x66, 0x0c, + /*8f70:*/ 0x5b, 0x2f, 0x31, 0xd4, 0xdd, 0x74, 0x8b, 0x64, 0x3e, 0x7e, 0xee, 0x85, 0xac, 0xcb, 0x94, 0x8a, + /*8f80:*/ 0xfb, 0xc8, 0x87, 0xce, 0xeb, 0x18, 0x23, 0xd4, 0x13, 0x4c, 0x22, 0xeb, 0x2d, 0x71, 0x7e, 0xd6, + /*8f90:*/ 0x4f, 0x06, 0x85, 0xf2, 0xf7, 0x4d, 0x39, 0xc3, 0x11, 0x33, 0x2a, 0x9e, 0xf8, 0x3c, 0xde, 0xef, + /*8fa0:*/ 0x06, 0xbe, 0xcd, 0x77, 0x21, 0xeb, 0xb0, 0xd6, 0xcf, 0x41, 0xd2, 0xd9, 0xb5, 0x8c, 0xa9, 0x51, + /*8fb0:*/ 0xae, 0x17, 0xe0, 0xb0, 0x60, 0x3f, 0x62, 0x82, 0x71, 0x28, 0x7e, 0xb9, 0x6d, 0x17, 0x26, 0xde, + /*8fc0:*/ 0xb0, 0x98, 0xeb, 0x35, 0x28, 0xb9, 0x1e, 0xd5, 0x82, 0xf7, 0xaf, 0xa2, 0x3b, 0xb7, 0xbe, 0xfd, + /*8fd0:*/ 0x4d, 0x68, 0x6a, 0x20, 0x61, 0x50, 0x47, 0xb2, 0x4a, 0x42, 0x7a, 0xfa, 0x29, 0xcc, 0x9e, 0x2f, + /*8fe0:*/ 0xd9, 0x50, 0x5b, 0xac, 0x1d, 0x02, 0x90, 0xd9, 0xe5, 0xe8, 0x51, 0x12, 0xe8, 0x3b, 0xb9, 0x06, + /*8ff0:*/ 0x93, 0xb5, 0x3c, 0xa3, 0xdf, 0x96, 0xd1, 0x07, 0xb5, 0xf7, 0x6d, 0xcd, 0x6e, 0x2c, 0xd3, 0x89, + /*9000:*/ 0xcd, 0x97, 0xfb, 0x6a, 0x85, 0xcf, 0x10, 0x46, 0xdc, 0xc6, 0xde, 0x2d, 0x28, 0x1a, 0xe7, 0x1a, + /*9010:*/ 0x6a, 0x19, 0x84, 0x67, 0x2d, 0x47, 0xb2, 0x05, 0xca, 0xe2, 0x74, 0xf6, 0xbc, 0x62, 0x15, 0x74, + /*9020:*/ 0x19, 0x15, 0x04, 0x73, 0xd1, 0x52, 0xe6, 0x57, 0xbf, 0x05, 0x0b, 0xe4, 0x38, 0x0c, 0x7c, 0x7b, + /*9030:*/ 0x87, 0x7c, 0xa0, 0xd3, 0x14, 0x94, 0xcc, 0x4d, 0x73, 0x12, 0xac, 0x5e, 0x7d, 0x74, 0xb3, 0x43, + /*9040:*/ 0xe1, 0x88, 0xca, 0x1d, 0x3d, 0x1c, 0xa1, 0x11, 0x83, 0xea, 0xf0, 0x72, 0x29, 0xda, 0xbe, 0xd3, + /*9050:*/ 0x98, 0xd2, 0xd8, 0xd6, 0x71, 0x9c, 0x7b, 0x44, 0xb8, 0x3c, 0xf6, 0x04, 0xc5, 0x32, 0xb8, 0x4e, + /*9060:*/ 0xb9, 0xcd, 0x59, 0x36, 0xe8, 0xd1, 0x63, 0x70, 0xd6, 0x5d, 0x0d, 0x49, 0xc8, 0x0e, 0xb6, 0x28, + /*9070:*/ 0x68, 0x67, 0xe8, 0x0c, 0x8c, 0x2f, 0x74, 0xfd, 0x56, 0x1d, 0x65, 0xaf, 0x33, 0xba, 0xf4, 0xe0, + /*9080:*/ 0x8c, 0xff, 0x5e, 0x96, 0x4c, 0xa9, 0x25, 0xde, 0x03, 0x8d, 0x38, 0xc6, 0xba, 0x40, 0xf8, 0xdf, + /*9090:*/ 0x93, 0xb4, 0x50, 0x58, 0x42, 0x73, 0x91, 0xad, 0xb4, 0x6f, 0x25, 0x0b, 0x7f, 0x5a, 0xd0, 0x69, + /*90a0:*/ 0x0e, 0x44, 0xbc, 0x27, 0xcc, 0x14, 0x07, 0xeb, 0x11, 0x20, 0x05, 0x3b, 0xf0, 0x73, 0x51, 0xc2, + /*90b0:*/ 0x3e, 0xbb, 0x85, 0xc9, 0xd7, 0xea, 0xd0, 0x0e, 0x25, 0xa1, 0x41, 0xe1, 0x70, 0xbd, 0xae, 0x81, + /*90c0:*/ 0xcc, 0x2b, 0x19, 0x39, 0x3b, 0xb3, 0x65, 0x2b, 0xd7, 0x9d, 0x94, 0xb3, 0xe1, 0xe7, 0xa5, 0xde, + /*90d0:*/ 0xd5, 0xe8, 0xb7, 0xc3, 0x4d, 0xbb, 0x32, 0x71, 0xa3, 0xfc, 0xb0, 0x6c, 0x8e, 0x20, 0xe7, 0xeb, + /*90e0:*/ 0x88, 0xc8, 0xa4, 0x76, 0xe8, 0xd5, 0xb1, 0x24, 0xbb, 0xa4, 0x35, 0xc8, 0x74, 0xb5, 0x3b, 0xba, + /*90f0:*/ 0x08, 0xbc, 0xbd, 0xcd, 0xe6, 0x0e, 0x71, 0x32, 0x0e, 0x88, 0x52, 0xfa, 0x45, 0xe7, 0x02, 0x3b, + /*9100:*/ 0x11, 0x5d, 0x8c, 0x07, 0x14, 0xc1, 0x68, 0x05, 0xc2, 0x4f, 0x03, 0x1c, 0x17, 0xa6, 0x38, 0xa1, + /*9110:*/ 0x9d, 0x07, 0xb0, 0xb3, 0x00, 0xab, 0x98, 0x89, 0x79, 0xd3, 0x8b, 0xb2, 0x93, 0x6b, 0x30, 0xf4, + /*9120:*/ 0x0c, 0xbd, 0xe3, 0x79, 0x3d, 0x1e, 0x3a, 0x75, 0xf8, 0x67, 0x3f, 0xd9, 0x20, 0x07, 0x22, 0xe6, + /*9130:*/ 0xc1, 0x4f, 0x85, 0x56, 0x68, 0xaa, 0xd1, 0x70, 0xd9, 0x3c, 0x24, 0xee, 0xdf, 0xcc, 0x1c, 0xda, + /*9140:*/ 0x76, 0xf5, 0x18, 0xd1, 0x53, 0x43, 0x3c, 0x1a, 0x51, 0xa4, 0x34, 0xce, 0xde, 0x4d, 0xfb, 0xee, + /*9150:*/ 0x8e, 0xca, 0xb7, 0x36, 0xae, 0x68, 0xcc, 0x22, 0x8b, 0xec, 0x66, 0xba, 0xcd, 0x93, 0x41, 0x75, + /*9160:*/ 0xc5, 0xba, 0x92, 0x23, 0xde, 0x1b, 0xc4, 0xc8, 0x75, 0xcb, 0xcc, 0x14, 0x2b, 0x99, 0x06, 0x43, + /*9170:*/ 0xd1, 0x9d, 0xae, 0xd5, 0x54, 0xda, 0x5f, 0x6f, 0x9c, 0x96, 0x52, 0x1c, 0xca, 0xf6, 0xab, 0x58, + /*9180:*/ 0xe4, 0xbd, 0x83, 0x35, 0xc6, 0x32, 0xae, 0xd7, 0x54, 0x59, 0x53, 0xb3, 0x33, 0xe6, 0xd9, 0x7c, + /*9190:*/ 0x72, 0xb5, 0xcb, 0x02, 0x92, 0xd8, 0xf2, 0x68, 0xd1, 0xdb, 0x93, 0xd8, 0x2e, 0xc9, 0xda, 0x87, + /*91a0:*/ 0x50, 0xf2, 0x6c, 0xf9, 0x58, 0x2e, 0x6a, 0x6a, 0xfc, 0x08, 0x56, 0x9c, 0x6e, 0xe1, 0xdf, 0xe2, + /*91b0:*/ 0x90, 0x38, 0xbe, 0xb9, 0xbc, 0x2e, 0xb9, 0x2c, 0xcc, 0xd9, 0x0d, 0x25, 0xe2, 0x37, 0xf4, 0x28, + /*91c0:*/ 0xe1, 0xc1, 0xf2, 0xc9, 0x68, 0xd3, 0xff, 0xa3, 0xf0, 0x28, 0x67, 0x48, 0xfb, 0x91, 0xfe, 0x46, + /*91d0:*/ 0xc4, 0xbf, 0x60, 0xe7, 0x97, 0x37, 0x3f, 0xd2, 0x7e, 0xdf, 0x3d, 0x27, 0x6d, 0x3e, 0x69, 0xa5, + /*91e0:*/ 0x7f, 0x2f, 0x57, 0xeb, 0x82, 0x7e, 0x94, 0x85, 0x69, 0xb2, 0x9d, 0xa6, 0x66, 0x16, 0xa7, 0xc2, + /*91f0:*/ 0x87, 0xe8, 0x72, 0x7c, 0x99, 0xd4, 0xb1, 0x43, 0xa8, 0x06, 0x32, 0x32, 0x1e, 0xb2, 0x6e, 0x2f, + /*9200:*/ 0xd0, 0xca, 0xe7, 0x10, 0xd5, 0xc2, 0xe5, 0x6b, 0x91, 0xac, 0xb4, 0x79, 0x6f, 0x23, 0xcc, 0xfc, + /*9210:*/ 0x09, 0xe4, 0x62, 0x5e, 0xb6, 0x58, 0xd1, 0x53, 0xd4, 0x10, 0x0b, 0x01, 0xf5, 0x26, 0x5f, 0x5a, + /*9220:*/ 0xcf, 0xf6, 0x44, 0x93, 0xad, 0xed, 0x64, 0xd2, 0xfd, 0x2c, 0x6a, 0xfe, 0x3c, 0x37, 0x44, 0xf0, + /*9230:*/ 0x0d, 0x21, 0xd3, 0x7b, 0x8d, 0x8a, 0xfe, 0x0c, 0xf9, 0x5a, 0x0a, 0x86, 0xed, 0xfb, 0x5b, 0x6b, + /*9240:*/ 0xbe, 0x39, 0xb9, 0x85, 0xf8, 0x76, 0xde, 0x5f, 0xd8, 0x6e, 0x95, 0xb6, 0xd5, 0x4b, 0x40, 0x32, + /*9250:*/ 0x4a, 0xf1, 0x1c, 0xa8, 0x48, 0xe2, 0xf3, 0x10, 0xa6, 0x51, 0xee, 0x2a, 0xbb, 0x65, 0xaa, 0xe6, + /*9260:*/ 0x4b, 0x9c, 0x5f, 0x30, 0xcc, 0xbe, 0xae, 0xe3, 0x0f, 0xbe, 0x34, 0x44, 0xf5, 0x3c, 0xb2, 0x6d, + /*9270:*/ 0xd5, 0x2f, 0x3b, 0x59, 0xc8, 0x7f, 0x48, 0xfa, 0x53, 0x6f, 0x85, 0x7b, 0xaa, 0x6d, 0xf5, 0x2c, + /*9280:*/ 0x0f, 0x23, 0x8a, 0x25, 0xee, 0x4f, 0x08, 0x00, 0xc9, 0x1d, 0x53, 0xdb, 0xad, 0x37, 0x35, 0x41, + /*9290:*/ 0x6c, 0x9f, 0xe2, 0x79, 0x6a, 0x21, 0x04, 0x05, 0xe6, 0x6f, 0x74, 0x9e, 0x9a, 0x1c, 0x33, 0xd6, + /*92a0:*/ 0x44, 0x5c, 0x09, 0x40, 0xcb, 0x0e, 0xe4, 0x27, 0xa3, 0xf8, 0xf7, 0xd4, 0xed, 0x09, 0x33, 0x71, + /*92b0:*/ 0x5d, 0x5c, 0x95, 0x25, 0x67, 0x0a, 0x5c, 0x2e, 0xb6, 0xe7, 0xb0, 0x10, 0x9c, 0x19, 0xb4, 0x39, + /*92c0:*/ 0x99, 0x11, 0xbd, 0x82, 0x87, 0x28, 0x6d, 0x75, 0x9d, 0x4e, 0x66, 0xbb, 0x1f, 0x01, 0x6b, 0x33, + /*92d0:*/ 0xf5, 0x01, 0x20, 0x9f, 0x69, 0x09, 0x99, 0x29, 0xda, 0x12, 0x5a, 0xa5, 0x47, 0xe2, 0x4d, 0x3c, + /*92e0:*/ 0x39, 0x54, 0x5e, 0x69, 0xa4, 0x54, 0x14, 0x1f, 0x3f, 0x75, 0xfc, 0x25, 0xa3, 0x3d, 0xc1, 0x65, + /*92f0:*/ 0xc6, 0xd0, 0xdb, 0x44, 0xbe, 0xe9, 0x6d, 0x3d, 0x00, 0x81, 0x3b, 0xed, 0xb5, 0xfd, 0xa6, 0x19, + /*9300:*/ 0x63, 0xa2, 0xf0, 0xd8, 0x86, 0xeb, 0x86, 0x20, 0xe2, 0xaa, 0x98, 0xf9, 0x21, 0x51, 0x40, 0x63, + /*9310:*/ 0x84, 0x80, 0x6d, 0x18, 0x84, 0x3c, 0x91, 0x6a, 0x93, 0x85, 0x25, 0x5b, 0x5a, 0x12, 0x61, 0xf3, + /*9320:*/ 0x20, 0x02, 0x6e, 0x52, 0x08, 0xcf, 0x9a, 0xda, 0xd0, 0xbc, 0xd5, 0x70, 0xca, 0x73, 0x28, 0xcb, + /*9330:*/ 0x6c, 0x97, 0xc1, 0xb0, 0x0e, 0xb7, 0xa2, 0xd7, 0xb8, 0xb2, 0xe3, 0x98, 0xf7, 0x9e, 0x60, 0xc6, + /*9340:*/ 0x54, 0x2d, 0x04, 0x98, 0x6f, 0x29, 0xbe, 0xdc, 0x67, 0xad, 0xfd, 0x2d, 0xf5, 0x0e, 0x11, 0xfb, + /*9350:*/ 0x00, 0xac, 0xef, 0x9d, 0x6c, 0x12, 0x26, 0xf4, 0xf0, 0xaf, 0x05, 0xe4, 0xbf, 0x07, 0x50, 0x17, + /*9360:*/ 0x9e, 0xf9, 0xfe, 0x37, 0x35, 0xa2, 0xb5, 0xff, 0x98, 0xd7, 0x05, 0xa2, 0xb2, 0xa7, 0x5c, 0x2a, + /*9370:*/ 0x3f, 0x67, 0x01, 0x06, 0xa9, 0x3e, 0xdc, 0x76, 0x97, 0xfb, 0x36, 0x72, 0x30, 0xb7, 0xe4, 0x30, + /*9380:*/ 0x51, 0xe3, 0xe7, 0xeb, 0xcc, 0xd3, 0x3d, 0x6f, 0x9e, 0x7e, 0x00, 0xc6, 0x7c, 0x14, 0xb0, 0xae, + /*9390:*/ 0x79, 0x1c, 0x0b, 0x55, 0xcc, 0x61, 0xaf, 0xfc, 0x96, 0xcf, 0xcc, 0xe1, 0x99, 0x4b, 0x85, 0xe7, + /*93a0:*/ 0xa8, 0x9b, 0x40, 0xa9, 0xf8, 0xe8, 0x68, 0xe7, 0x9d, 0xde, 0xf4, 0xdc, 0x93, 0x57, 0x0a, 0x54, + /*93b0:*/ 0x5e, 0x4a, 0x1c, 0xd7, 0x2f, 0xc4, 0x5d, 0x37, 0x98, 0xbc, 0x63, 0xf6, 0x5c, 0x9a, 0xc0, 0xf4, + /*93c0:*/ 0x5e, 0x07, 0xc5, 0xab, 0xe5, 0x51, 0xf1, 0xe9, 0x8d, 0xcd, 0x48, 0x54, 0xce, 0x87, 0x69, 0x51, + /*93d0:*/ 0x10, 0xb9, 0xe6, 0x47, 0x8c, 0x2f, 0x2f, 0xe1, 0x9b, 0xcd, 0x05, 0x55, 0x9c, 0xa7, 0x0f, 0x18, + /*93e0:*/ 0x76, 0xee, 0xc3, 0x7e, 0xfa, 0x69, 0xa3, 0x7f, 0xc2, 0xa9, 0xff, 0xaa, 0x7a, 0x2d, 0x13, 0xd1, + /*93f0:*/ 0xde, 0x8b, 0x1c, 0xd8, 0xe6, 0x6f, 0x12, 0xfc, 0x4c, 0xec, 0x79, 0x02, 0x17, 0x6f, 0xc3, 0xd1, + /*9400:*/ 0xb5, 0x6e, 0xff, 0x06, 0xf1, 0x06, 0xd6, 0xbe, 0xbf, 0x02, 0x04, 0x72, 0x48, 0xed, 0x80, 0x58, + /*9410:*/ 0xf0, 0x5f, 0x31, 0xcf, 0x4d, 0xec, 0xe0, 0x1b, 0x6d, 0x33, 0x69, 0xfd, 0x2f, 0x62, 0xb8, 0x93, + /*9420:*/ 0xac, 0x31, 0x56, 0x8e, 0x61, 0xde, 0x88, 0xea, 0x3f, 0xc4, 0x6b, 0xff, 0xcc, 0x6f, 0x10, 0x26, + /*9430:*/ 0x85, 0x04, 0x98, 0xe4, 0x3a, 0xda, 0x18, 0xa2, 0x99, 0x59, 0x73, 0x58, 0x91, 0x7c, 0x22, 0x7e, + /*9440:*/ 0x16, 0xd4, 0xd3, 0x20, 0x4c, 0x82, 0x21, 0x81, 0x43, 0x83, 0x36, 0x73, 0x04, 0x0e, 0x07, 0x79, + /*9450:*/ 0x81, 0xd7, 0x8e, 0x44, 0x50, 0x9f, 0x33, 0x68, 0x0c, 0x67, 0x18, 0xd3, 0xba, 0xbe, 0xc9, 0xb7, + /*9460:*/ 0xed, 0x8f, 0xb0, 0xdc, 0xc6, 0xab, 0x17, 0x84, 0xa0, 0x79, 0x78, 0xf9, 0x87, 0x8a, 0x21, 0xdf, + /*9470:*/ 0xe7, 0x4d, 0xfa, 0x3b, 0xd8, 0xf4, 0x00, 0x85, 0x00, 0x0d, 0x8e, 0x68, 0x7a, 0x5a, 0x1a, 0x6a, + /*9480:*/ 0x3a, 0x6d, 0x36, 0x12, 0xf4, 0xd4, 0x09, 0xf9, 0xc5, 0x50, 0x1c, 0xe6, 0xe0, 0x58, 0x25, 0xfa, + /*9490:*/ 0xbc, 0xea, 0xfe, 0x6e, 0x1f, 0x1a, 0x16, 0x8f, 0x2f, 0x0f, 0xb2, 0xf3, 0x85, 0xe0, 0x11, 0x9e, + /*94a0:*/ 0x90, 0xf1, 0xab, 0x01, 0xea, 0x9e, 0x03, 0xbe, 0xaa, 0x73, 0x8c, 0x96, 0xf2, 0x1c, 0x74, 0x46, + /*94b0:*/ 0xdd, 0x4c, 0xff, 0x63, 0x18, 0x4b, 0xee, 0x7d, 0xed, 0xff, 0x16, 0xc8, 0x8d, 0xac, 0x0e, 0xe1, + /*94c0:*/ 0x3b, 0x21, 0x1a, 0x5b, 0x69, 0x16, 0xb9, 0xb7, 0xbd, 0x97, 0x02, 0xb6, 0x29, 0xba, 0xd7, 0x0c, + /*94d0:*/ 0xb0, 0x33, 0xba, 0x5a, 0x0d, 0xd2, 0xe6, 0x32, 0x70, 0xd9, 0x71, 0xa3, 0x59, 0xce, 0xe0, 0xac, + /*94e0:*/ 0x9f, 0x3d, 0xd3, 0xba, 0x2e, 0x3d, 0x70, 0x1c, 0x19, 0x9e, 0xa5, 0x34, 0xef, 0xf7, 0x93, 0xcd, + /*94f0:*/ 0x6f, 0xd1, 0xfd, 0x72, 0x76, 0x3a, 0x33, 0x5c, 0x54, 0xd9, 0x85, 0xbf, 0x72, 0xfd, 0x13, 0xf0, + /*9500:*/ 0x5d, 0x37, 0x35, 0x42, 0x1c, 0xd2, 0x41, 0x66, 0x1d, 0xcb, 0xf9, 0x76, 0xd9, 0x26, 0x3b, 0xb7, + /*9510:*/ 0xe7, 0xf6, 0x32, 0xa9, 0x26, 0xba, 0x25, 0x9c, 0x35, 0xa5, 0x80, 0x11, 0x3d, 0x0d, 0x43, 0x80, + /*9520:*/ 0xd1, 0x90, 0xba, 0xe1, 0xc8, 0x1c, 0xe4, 0x83, 0x08, 0xaa, 0xaf, 0x66, 0x8e, 0x33, 0x9a, 0x4a, + /*9530:*/ 0xdd, 0x79, 0xf6, 0xa7, 0xfa, 0x15, 0x59, 0x61, 0xf6, 0x35, 0xd8, 0x0b, 0xe4, 0x86, 0xbb, 0x74, + /*9540:*/ 0xfa, 0x6b, 0xa5, 0x4e, 0xf8, 0x41, 0xa7, 0xb4, 0x37, 0x82, 0x8e, 0x5b, 0x1c, 0x71, 0xe2, 0xe1, + /*9550:*/ 0x57, 0xa8, 0xa1, 0xc3, 0x18, 0x6f, 0xcb, 0x31, 0x2e, 0x28, 0x9d, 0x09, 0x33, 0x67, 0x9b, 0xaf, + /*9560:*/ 0x6f, 0x07, 0x18, 0x49, 0xd1, 0x78, 0x5d, 0x87, 0xdf, 0xb7, 0x62, 0x14, 0x00, 0x7e, 0xc7, 0xe8, + /*9570:*/ 0x7f, 0xbc, 0x6a, 0xd4, 0x4c, 0x91, 0xc6, 0xde, 0xd3, 0x89, 0xc8, 0xbf, 0x90, 0xda, 0x84, 0x0f, + /*9580:*/ 0x56, 0xdd, 0x95, 0xae, 0x92, 0x78, 0xf3, 0x93, 0xf0, 0x6c, 0x9e, 0xab, 0xf5, 0xb7, 0xb5, 0x99, + /*9590:*/ 0xf6, 0xb3, 0x94, 0x57, 0xd1, 0x96, 0x91, 0x60, 0x31, 0x0d, 0xa9, 0xf4, 0x67, 0x62, 0xa4, 0xd5, + /*95a0:*/ 0xf1, 0x5e, 0x15, 0xd8, 0xba, 0x27, 0x4c, 0x2d, 0x1f, 0x92, 0x0e, 0x8a, 0x51, 0x74, 0xdd, 0x8f, + /*95b0:*/ 0x27, 0x89, 0x9b, 0xba, 0x1b, 0x1a, 0x01, 0x1e, 0x9a, 0xb5, 0x77, 0x72, 0x8e, 0xde, 0x73, 0xbb, + /*95c0:*/ 0xe9, 0x6a, 0xa1, 0xeb, 0xa2, 0xab, 0x70, 0x7a, 0x34, 0x34, 0x4f, 0x86, 0x2f, 0x26, 0x4f, 0x39, + /*95d0:*/ 0xab, 0x57, 0x4f, 0x76, 0xed, 0xf8, 0x30, 0xc0, 0x21, 0xb5, 0x17, 0x03, 0x8e, 0xf1, 0x4c, 0xe2, + /*95e0:*/ 0x50, 0x6e, 0xf8, 0x95, 0xee, 0x19, 0xc9, 0xf0, 0x7c, 0x06, 0x9e, 0x3d, 0x69, 0xdf, 0x90, 0x03, + /*95f0:*/ 0xae, 0xfb, 0xc4, 0x34, 0x9e, 0x0a, 0x7d, 0x2e, 0x4d, 0xc5, 0x97, 0x18, 0x01, 0xb7, 0xfb, 0xd7, + /*9600:*/ 0x89, 0x81, 0xd8, 0xd7, 0x2c, 0x12, 0x29, 0xd4, 0x3f, 0xa7, 0xcc, 0x67, 0x9a, 0xed, 0x17, 0xb9, + /*9610:*/ 0xd8, 0x74, 0x27, 0x54, 0xa0, 0x11, 0x44, 0xe0, 0x64, 0xfe, 0xa2, 0x57, 0xf5, 0x63, 0x55, 0xdd, + /*9620:*/ 0x7b, 0x45, 0xea, 0xc2, 0x19, 0xad, 0x3d, 0x68, 0xb7, 0x94, 0x89, 0xa6, 0x6e, 0x28, 0xd2, 0xbc, + /*9630:*/ 0x09, 0xe4, 0x75, 0x37, 0xd4, 0x26, 0x4e, 0xf1, 0x6c, 0x8b, 0x5d, 0x16, 0x12, 0xfc, 0x10, 0xff, + /*9640:*/ 0x12, 0x33, 0xdb, 0xd9, 0x7b, 0x22, 0x55, 0x7b, 0xe7, 0xc4, 0x9c, 0xd7, 0x50, 0x87, 0xc5, 0xde, + /*9650:*/ 0x8d, 0xe0, 0x74, 0xc7, 0x03, 0x9f, 0x64, 0x7f, 0xf4, 0xfd, 0xbd, 0xed, 0x0c, 0x14, 0x8c, 0x2a, + /*9660:*/ 0xf9, 0x2e, 0x06, 0x6e, 0xb7, 0x2a, 0x3e, 0x61, 0x02, 0xce, 0x84, 0xd4, 0xb6, 0x02, 0xee, 0x47, + /*9670:*/ 0x13, 0x01, 0x8c, 0x78, 0x6d, 0x2b, 0xea, 0xa2, 0x74, 0x3f, 0x87, 0x2d, 0x42, 0xa1, 0x7a, 0x63, + /*9680:*/ 0x25, 0x81, 0x88, 0x65, 0x0a, 0x42, 0x52, 0xa1, 0x8f, 0xba, 0xf5, 0x32, 0x27, 0xdd, 0x87, 0x68, + /*9690:*/ 0x95, 0x0e, 0x6e, 0xb3, 0x04, 0xbb, 0x40, 0x5e, 0x65, 0x0e, 0x51, 0x4c, 0x2a, 0x9c, 0x5a, 0x2e, + /*96a0:*/ 0xc9, 0xed, 0xc0, 0xe1, 0xb5, 0x7e, 0x69, 0xcf, 0x4e, 0x16, 0xe3, 0x11, 0x8e, 0xef, 0xb9, 0x44, + /*96b0:*/ 0x6b, 0x79, 0x1a, 0xf2, 0x7a, 0x58, 0xe7, 0xd3, 0xbb, 0x95, 0x9e, 0x9a, 0x63, 0xa2, 0x3c, 0x8c, + /*96c0:*/ 0xd3, 0x4f, 0x7e, 0x08, 0xd5, 0x48, 0x8f, 0x6f, 0x6d, 0x14, 0x44, 0x9d, 0x82, 0x1e, 0x27, 0x1c, + /*96d0:*/ 0xb7, 0x0d, 0xb5, 0xc8, 0x4a, 0x9e, 0x1d, 0x45, 0x6c, 0x69, 0x8d, 0x8b, 0x46, 0x21, 0x36, 0x51, + /*96e0:*/ 0xb8, 0x41, 0x18, 0x2f, 0x3c, 0x1f, 0xe1, 0xeb, 0x34, 0xc3, 0x09, 0xb5, 0xe8, 0xd7, 0x78, 0x60, + /*96f0:*/ 0xd5, 0x6f, 0xe4, 0xb1, 0x01, 0x3e, 0xac, 0xbf, 0xaa, 0xfd, 0x1a, 0x33, 0x75, 0xc7, 0x11, 0x66, + /*9700:*/ 0xed, 0x08, 0x5e, 0xbc, 0xa4, 0xc2, 0x12, 0x3e, 0x9f, 0xac, 0xc4, 0xee, 0xfe, 0xb2, 0xdb, 0x0f, + /*9710:*/ 0x0d, 0x6a, 0x03, 0x63, 0xe8, 0x9a, 0xfe, 0xde, 0xe1, 0x30, 0xba, 0x98, 0x1d, 0x33, 0x5c, 0x94, + /*9720:*/ 0x07, 0x88, 0x25, 0x84, 0xbe, 0x9c, 0x01, 0x21, 0xc3, 0x27, 0x98, 0xdb, 0x69, 0xb4, 0xec, 0x17, + /*9730:*/ 0x21, 0x15, 0x40, 0xbc, 0x54, 0xb3, 0xda, 0x62, 0x73, 0x09, 0x64, 0x6a, 0x41, 0x23, 0x8d, 0x47, + /*9740:*/ 0x19, 0xf7, 0x30, 0xe7, 0xb4, 0x2c, 0x60, 0xcb, 0x8c, 0xf3, 0xc4, 0xd8, 0xc5, 0x38, 0xba, 0xf7, + /*9750:*/ 0xf7, 0xe8, 0x1a, 0x07, 0x9c, 0xde, 0x82, 0x1c, 0x0f, 0xf9, 0x38, 0x4f, 0x32, 0xc0, 0x6c, 0x3d, + /*9760:*/ 0x4d, 0x90, 0x04, 0x0a, 0xe6, 0x34, 0xa9, 0x1d, 0xf6, 0x00, 0x97, 0xd8, 0x07, 0x8b, 0xfa, 0x3d, + /*9770:*/ 0x65, 0x0f, 0x31, 0x24, 0xd9, 0xf9, 0xdb, 0xc4, 0xbd, 0x6d, 0x14, 0xc5, 0x97, 0xdf, 0x6d, 0x22, + /*9780:*/ 0x82, 0x7b, 0x9d, 0x2e, 0x40, 0x53, 0x71, 0x0c, 0xde, 0x63, 0xe3, 0xf0, 0x50, 0xb9, 0x00, 0x99, + /*9790:*/ 0x76, 0x75, 0x3c, 0x90, 0x2d, 0x17, 0xb9, 0xed, 0x04, 0xcf, 0x14, 0x78, 0x8b, 0xe2, 0xcc, 0x7f, + /*97a0:*/ 0xa9, 0x49, 0xb0, 0x5d, 0x04, 0x64, 0xe4, 0x72, 0x55, 0x39, 0x1a, 0x9e, 0x88, 0xd4, 0x23, 0x9c, + /*97b0:*/ 0x04, 0xbf, 0xe0, 0x9b, 0xdf, 0xeb, 0x68, 0x6c, 0xc7, 0x04, 0xef, 0x6c, 0xb7, 0x6f, 0xd6, 0xff, + /*97c0:*/ 0xfe, 0x63, 0xeb, 0x9c, 0xc9, 0x7b, 0xfe, 0x30, 0x15, 0xce, 0x6c, 0xd2, 0x6f, 0xcc, 0x64, 0x5c, + /*97d0:*/ 0x76, 0x65, 0x45, 0xa6, 0x17, 0x85, 0x6c, 0xc5, 0x27, 0x2f, 0xd7, 0x16, 0x9e, 0xb7, 0x56, 0xb2, + /*97e0:*/ 0xb0, 0x72, 0x83, 0x5e, 0xde, 0xba, 0x80, 0xf1, 0x06, 0xe3, 0xaf, 0xcb, 0xad, 0xd8, 0x6b, 0xdd, + /*97f0:*/ 0x4a, 0xa9, 0xb6, 0x19, 0x48, 0x10, 0x50, 0xb7, 0xeb, 0x0a, 0x85, 0xa8, 0x9e, 0xbd, 0x10, 0x63, + /*9800:*/ 0x6c, 0x14, 0x33, 0x0a, 0x90, 0x63, 0x1f, 0xda, 0x0b, 0x1d, 0x19, 0xee, 0xf6, 0x20, 0xc5, 0x0c, + /*9810:*/ 0x79, 0x2d, 0x38, 0xbb, 0xdc, 0x38, 0x86, 0x4e, 0xce, 0x64, 0x1e, 0xfb, 0xfd, 0xbf, 0x8e, 0xa6, + /*9820:*/ 0x16, 0xec, 0xd9, 0x7b, 0x69, 0xb9, 0xc3, 0x96, 0x4a, 0x86, 0x43, 0x02, 0xf6, 0x74, 0xb5, 0x5f, + /*9830:*/ 0xb8, 0x39, 0xb1, 0x83, 0x40, 0x45, 0x72, 0xd8, 0xe9, 0x64, 0x81, 0x6a, 0xeb, 0x19, 0xbb, 0x42, + /*9840:*/ 0x61, 0xba, 0x45, 0x42, 0x47, 0x81, 0xe9, 0x19, 0x34, 0xdd, 0x80, 0x3e, 0xb9, 0x2c, 0x00, 0xad, + /*9850:*/ 0x0e, 0x3c, 0x71, 0x0b, 0xea, 0x1f, 0xf8, 0xa5, 0x38, 0x68, 0x66, 0x01, 0xa0, 0x70, 0xf4, 0x41, + /*9860:*/ 0x96, 0xa7, 0xb1, 0xae, 0x3c, 0xd9, 0xfd, 0x10, 0xb8, 0x4a, 0x70, 0x7b, 0x94, 0x00, 0xe8, 0xb6, + /*9870:*/ 0xa5, 0x24, 0xac, 0xa3, 0x5a, 0xd8, 0x6f, 0xa5, 0x48, 0x26, 0xd8, 0x7b, 0x4c, 0x5c, 0x30, 0x8b, + /*9880:*/ 0x6b, 0x55, 0x8a, 0x7b, 0x1b, 0xc8, 0xce, 0x9b, 0x7a, 0xc1, 0x36, 0xe7, 0x9a, 0x58, 0xe8, 0xc7, + /*9890:*/ 0x14, 0x8b, 0x01, 0x5f, 0x13, 0x04, 0x4c, 0x10, 0x43, 0x44, 0x33, 0x44, 0xe2, 0x60, 0xb6, 0x47, + /*98a0:*/ 0xca, 0x0a, 0x2e, 0x90, 0xa7, 0x49, 0xfc, 0x06, 0x3d, 0xf2, 0x4f, 0xd2, 0x69, 0x69, 0x6c, 0x0b, + /*98b0:*/ 0xe4, 0x37, 0x2a, 0x60, 0x8a, 0x8c, 0x0f, 0x33, 0xa9, 0xb1, 0xb3, 0xc8, 0xe6, 0x82, 0xa8, 0xaf, + /*98c0:*/ 0x56, 0x17, 0xc7, 0x77, 0xf6, 0xc9, 0xb2, 0x27, 0x79, 0x7e, 0xec, 0x3c, 0xba, 0xc4, 0x3b, 0x0f, + /*98d0:*/ 0x4f, 0xf4, 0x22, 0x13, 0x4c, 0x20, 0xda, 0xfb, 0xaf, 0x56, 0xae, 0x51, 0x27, 0x54, 0x15, 0x80, + /*98e0:*/ 0x85, 0x94, 0xb7, 0x97, 0x82, 0x8b, 0xef, 0xcf, 0x4a, 0xbf, 0xb8, 0x18, 0x2c, 0x37, 0x59, 0x8d, + /*98f0:*/ 0x32, 0xed, 0x94, 0x78, 0x56, 0x01, 0x05, 0xc0, 0xfe, 0x6f, 0x8c, 0x60, 0x7e, 0x77, 0xee, 0xc0, + /*9900:*/ 0xa8, 0x3f, 0x8d, 0xb9, 0x7d, 0x19, 0x8e, 0x95, 0xf8, 0xbe, 0xc5, 0xe8, 0x57, 0xbd, 0x3c, 0xfc, + /*9910:*/ 0x9b, 0xfd, 0x72, 0x44, 0xf4, 0x42, 0x2d, 0xcb, 0x8c, 0x81, 0x8c, 0x3b, 0x0c, 0xfe, 0x05, 0x42, + /*9920:*/ 0x55, 0xeb, 0xb9, 0x30, 0x27, 0xc5, 0x4c, 0x1b, 0x79, 0xd5, 0x9e, 0x2e, 0x50, 0x25, 0x08, 0x62, + /*9930:*/ 0xcc, 0x75, 0x72, 0x33, 0x26, 0xc3, 0xcd, 0x86, 0xb0, 0xe4, 0xee, 0xea, 0xd6, 0x2d, 0x57, 0xd3, + /*9940:*/ 0x80, 0x9c, 0xef, 0x9d, 0x78, 0x6d, 0x96, 0x28, 0xac, 0xed, 0x27, 0xea, 0x62, 0xbd, 0x8d, 0x9e, + /*9950:*/ 0x20, 0x2b, 0xc4, 0xe4, 0x3d, 0x61, 0x68, 0xff, 0x5c, 0x5d, 0x47, 0x44, 0x40, 0x4c, 0x9a, 0x47, + /*9960:*/ 0xa0, 0x24, 0x16, 0x1e, 0x88, 0xd5, 0x86, 0x29, 0x96, 0x0c, 0x4f, 0x13, 0x1f, 0x2c, 0x03, 0x98, + /*9970:*/ 0x56, 0xd9, 0x46, 0xe5, 0x18, 0x83, 0xed, 0x85, 0xd9, 0x8a, 0x8a, 0x88, 0xe6, 0x19, 0xf2, 0x7b, + /*9980:*/ 0xe4, 0x68, 0x3d, 0xfc, 0xbd, 0x71, 0x27, 0x22, 0xf4, 0x60, 0x51, 0x30, 0x52, 0x99, 0x43, 0x88, + /*9990:*/ 0x42, 0xa4, 0xe8, 0x16, 0xf2, 0x17, 0x3a, 0xd7, 0x2b, 0x85, 0x49, 0x53, 0x50, 0x14, 0x51, 0xd3, + /*99a0:*/ 0x4c, 0x85, 0xcc, 0x80, 0x1e, 0x49, 0x18, 0xb8, 0x3c, 0x3e, 0x1c, 0xbe, 0x56, 0x07, 0xf7, 0xc7, + /*99b0:*/ 0x9f, 0xda, 0xce, 0x00, 0x93, 0xe6, 0xa1, 0xda, 0xf1, 0x45, 0x7b, 0x3f, 0x26, 0x9c, 0xb6, 0xe8, + /*99c0:*/ 0xfb, 0xce, 0x3b, 0x85, 0x64, 0xf5, 0x85, 0x9c, 0x34, 0x4f, 0x89, 0x44, 0x52, 0x69, 0x99, 0xc9, + /*99d0:*/ 0x5d, 0x87, 0x52, 0x2c, 0xd3, 0x3a, 0x6e, 0x5c, 0x02, 0x41, 0x5c, 0x03, 0xa8, 0xfb, 0xcd, 0x82, + /*99e0:*/ 0xe6, 0xd7, 0xe2, 0x90, 0x06, 0x9e, 0x4f, 0xbc, 0x53, 0x79, 0x24, 0xd9, 0x20, 0xb6, 0x5f, 0xa6, + /*99f0:*/ 0x0d, 0x88, 0x85, 0xbe, 0x19, 0xe4, 0x1f, 0x95, 0xf8, 0x94, 0x6e, 0x01, 0x9d, 0xc0, 0xef, 0x18, + /*9a00:*/ 0xaf, 0xda, 0xac, 0x64, 0x8c, 0x7a, 0x84, 0x6d, 0x45, 0xa4, 0x34, 0x66, 0x9b, 0x81, 0xab, 0x69, + /*9a10:*/ 0x19, 0x49, 0x6c, 0xa8, 0xc6, 0x8b, 0x3b, 0xbd, 0xff, 0x27, 0x23, 0x48, 0xa6, 0x6b, 0xa9, 0x30, + /*9a20:*/ 0xf0, 0xbb, 0xe4, 0x08, 0x3d, 0x52, 0x21, 0x70, 0xbc, 0x42, 0x45, 0x92, 0xf7, 0x0c, 0x83, 0x33, + /*9a30:*/ 0x9f, 0x38, 0x28, 0x1b, 0xb3, 0xf2, 0xc4, 0x38, 0x24, 0x03, 0xfd, 0xa9, 0x18, 0x60, 0x54, 0xcc, + /*9a40:*/ 0xc1, 0xb0, 0x78, 0x8e, 0x99, 0x64, 0x9c, 0xeb, 0x02, 0xbc, 0x63, 0x7b, 0xd6, 0x03, 0x6d, 0xcb, + /*9a50:*/ 0x1f, 0x6f, 0x34, 0x59, 0xe6, 0x7e, 0xb0, 0x10, 0xbb, 0x5d, 0xe6, 0xfa, 0x66, 0xbe, 0x14, 0x10, + /*9a60:*/ 0xca, 0xd1, 0x3f, 0x99, 0x4c, 0x04, 0xfb, 0x56, 0x64, 0xec, 0x2e, 0x07, 0x61, 0x05, 0x9c, 0x8c, + /*9a70:*/ 0x1a, 0xc4, 0x34, 0x1d, 0xbf, 0x33, 0x69, 0x38, 0x9f, 0xa4, 0x9e, 0xbd, 0xc6, 0x4d, 0x49, 0xe4, + /*9a80:*/ 0xf3, 0xc5, 0x38, 0xb4, 0xb7, 0xa3, 0x0a, 0x49, 0x67, 0x9e, 0x79, 0xf0, 0xa7, 0x4c, 0x91, 0xf7, + /*9a90:*/ 0x42, 0x88, 0xc1, 0x4f, 0x01, 0xa0, 0x43, 0x6e, 0x39, 0xbd, 0x96, 0x07, 0x3e, 0xab, 0x70, 0x56, + /*9aa0:*/ 0x54, 0xe1, 0xc9, 0xa2, 0x9a, 0x98, 0xb9, 0xd6, 0x3c, 0x17, 0xa9, 0xbe, 0xc5, 0xe2, 0x36, 0x18, + /*9ab0:*/ 0xf4, 0x15, 0x9d, 0x0b, 0xa2, 0x66, 0x87, 0x79, 0x45, 0x6d, 0x24, 0x09, 0xa0, 0xcd, 0x87, 0xdc, + /*9ac0:*/ 0x3d, 0x69, 0x16, 0x6b, 0xef, 0xf4, 0x3b, 0x04, 0x34, 0x84, 0xf1, 0x19, 0x8c, 0x73, 0x90, 0xf0, + /*9ad0:*/ 0xde, 0xfb, 0xcf, 0x48, 0x44, 0x41, 0xf9, 0x81, 0xb3, 0xa7, 0x0a, 0xc2, 0xd4, 0x8c, 0x84, 0x9a, + /*9ae0:*/ 0x6a, 0x1c, 0x34, 0x63, 0x96, 0x0a, 0xe0, 0xc6, 0x10, 0x88, 0x8f, 0x8e, 0xac, 0x96, 0xee, 0xc0, + /*9af0:*/ 0x86, 0x16, 0x61, 0x8f, 0x35, 0xec, 0x47, 0x4e, 0x75, 0x17, 0x49, 0x0e, 0x3f, 0x34, 0x68, 0x7e, + /*9b00:*/ 0xae, 0x61, 0x0e, 0x7e, 0xd2, 0x81, 0x53, 0xd1, 0x53, 0x7a, 0x20, 0x7a, 0x40, 0x7a, 0x2e, 0xbc, + /*9b10:*/ 0x43, 0x3a, 0x66, 0x39, 0x0f, 0xc1, 0x85, 0xc0, 0x71, 0xe0, 0x15, 0x28, 0x47, 0xb5, 0xd1, 0x99, + /*9b20:*/ 0x6e, 0xd3, 0x48, 0xe0, 0x41, 0xa7, 0xf3, 0x27, 0x8f, 0xda, 0x55, 0x5f, 0x89, 0x0f, 0x9b, 0x91, + /*9b30:*/ 0xe9, 0x1f, 0x9b, 0x5e, 0x32, 0x53, 0x3e, 0x8c, 0x65, 0xd5, 0x92, 0x0b, 0x8c, 0x5f, 0x73, 0xcc, + /*9b40:*/ 0x0d, 0xc5, 0xa7, 0x1c, 0x80, 0x85, 0xca, 0xbc, 0x00, 0xf6, 0x73, 0x07, 0x9b, 0xb4, 0x93, 0x48, + /*9b50:*/ 0x22, 0xe3, 0xf9, 0x63, 0x9d, 0xe5, 0x82, 0x17, 0x3e, 0x65, 0x2b, 0x4f, 0x68, 0xc3, 0xc3, 0x6d, + /*9b60:*/ 0x8d, 0x9a, 0x5e, 0x47, 0xe6, 0x1f, 0x99, 0x94, 0xab, 0xd6, 0xc2, 0xeb, 0x05, 0x70, 0x23, 0x7a, + /*9b70:*/ 0x6b, 0xbd, 0xc0, 0x1d, 0xe2, 0x22, 0xa9, 0xb5, 0x56, 0xcb, 0x93, 0x2c, 0x88, 0xed, 0xd9, 0xbf, + /*9b80:*/ 0x14, 0x44, 0xb3, 0x99, 0xe2, 0x58, 0x2d, 0x78, 0x53, 0xc3, 0xbf, 0x94, 0xd0, 0x57, 0x95, 0xec, + /*9b90:*/ 0x25, 0xe2, 0x51, 0xb4, 0x6f, 0x2d, 0xf9, 0xb4, 0x15, 0x32, 0xa4, 0x20, 0xf8, 0x7e, 0x47, 0x65, + /*9ba0:*/ 0xc8, 0xb2, 0x95, 0xad, 0x41, 0xd5, 0x91, 0xbb, 0xd7, 0x66, 0x2c, 0x96, 0x7d, 0x78, 0x85, 0x3c, + /*9bb0:*/ 0x72, 0x21, 0x9d, 0xe4, 0x4a, 0x4a, 0x4f, 0x29, 0x76, 0x24, 0x82, 0x83, 0xb8, 0x19, 0x1b, 0x5a, + /*9bc0:*/ 0x1f, 0x13, 0x76, 0xc2, 0xe3, 0x69, 0x75, 0xea, 0x4a, 0xb0, 0xbd, 0x34, 0x87, 0x0c, 0xe3, 0xda, + /*9bd0:*/ 0x14, 0xce, 0x42, 0x65, 0x42, 0xed, 0x9a, 0x7f, 0x69, 0x83, 0x55, 0xa4, 0xbf, 0xd5, 0x91, 0xa9, + /*9be0:*/ 0x00, 0x57, 0xa1, 0x24, 0x8d, 0xd8, 0x01, 0xf7, 0x5a, 0x76, 0xf8, 0x15, 0x14, 0x80, 0xd0, 0x8e, + /*9bf0:*/ 0x26, 0xbb, 0x5c, 0x5b, 0x6b, 0x62, 0x5c, 0xa4, 0x75, 0xe2, 0x01, 0xd1, 0x46, 0x9b, 0x7f, 0x7f, + /*9c00:*/ 0x16, 0xd1, 0xa0, 0xfa, 0x4f, 0x8e, 0x3d, 0xe4, 0xe0, 0xab, 0xc4, 0x25, 0x7f, 0x3a, 0x1b, 0x17, + /*9c10:*/ 0x3a, 0x99, 0xff, 0xa6, 0x54, 0xce, 0x8d, 0x7c, 0xa6, 0x4a, 0xce, 0x6f, 0x98, 0xe3, 0x1d, 0x84, + /*9c20:*/ 0x8b, 0x74, 0xf7, 0x01, 0x99, 0x05, 0x21, 0xce, 0x4d, 0x0f, 0x4c, 0x91, 0x40, 0x24, 0xf4, 0x78, + /*9c30:*/ 0xec, 0x90, 0xc9, 0xca, 0xc2, 0x63, 0x97, 0x84, 0x56, 0x21, 0x88, 0x57, 0xc2, 0xc0, 0x9d, 0xbd, + /*9c40:*/ 0x78, 0xc8, 0x69, 0x9a, 0x00, 0xd0, 0xaa, 0x65, 0x9a, 0x74, 0x06, 0xf1, 0x66, 0x15, 0xcc, 0xf2, + /*9c50:*/ 0x2a, 0x6a, 0xc1, 0xf3, 0x02, 0x6e, 0x08, 0xc4, 0xea, 0x54, 0x55, 0x05, 0x86, 0xeb, 0x19, 0x4a, + /*9c60:*/ 0xa3, 0xee, 0xa7, 0x1a, 0x3c, 0x93, 0x34, 0x07, 0x91, 0x72, 0x36, 0xbd, 0xb7, 0x54, 0xc5, 0x05, + /*9c70:*/ 0xdb, 0xe3, 0xe6, 0x5d, 0x48, 0x58, 0x16, 0x23, 0xed, 0x21, 0x9e, 0xe6, 0xed, 0xb4, 0x8f, 0x75, + /*9c80:*/ 0x8d, 0x5b, 0x9a, 0x16, 0x65, 0x9e, 0x5f, 0xb9, 0xff, 0xc9, 0xcd, 0xd0, 0xa8, 0xd3, 0x36, 0x3e, + /*9c90:*/ 0x36, 0x67, 0x30, 0xf5, 0xd8, 0xbe, 0x1c, 0xe3, 0x30, 0x9e, 0x0c, 0x1b, 0x06, 0x6d, 0x34, 0x07, + /*9ca0:*/ 0x73, 0x56, 0x08, 0xff, 0xaa, 0x12, 0x5b, 0x46, 0x54, 0x57, 0xb5, 0x3d, 0x56, 0x95, 0x09, 0x9f, + /*9cb0:*/ 0x40, 0x99, 0x96, 0x83, 0x58, 0xbb, 0xcc, 0x88, 0x1a, 0x62, 0xbd, 0xb7, 0xaa, 0x27, 0x9a, 0xf7, + /*9cc0:*/ 0xd1, 0x23, 0x3c, 0xa7, 0x5f, 0x82, 0x20, 0x91, 0x0c, 0xa5, 0x4c, 0xda, 0x74, 0xf8, 0x0e, 0x59, + /*9cd0:*/ 0x68, 0x13, 0xd6, 0x07, 0xe2, 0x4e, 0x57, 0x5c, 0xd3, 0xb5, 0xb9, 0x11, 0xaa, 0x45, 0x74, 0xf2, + /*9ce0:*/ 0xf4, 0x37, 0x37, 0xff, 0x45, 0x6c, 0x51, 0x1d, 0xfe, 0xf0, 0x12, 0x40, 0x57, 0x6f, 0x41, 0x93, + /*9cf0:*/ 0xb0, 0x7c, 0xd3, 0x5d, 0xe4, 0x10, 0x0c, 0xe2, 0xfa, 0x90, 0xa9, 0x68, 0xf9, 0x41, 0xd4, 0x71, + /*9d00:*/ 0x2e, 0x46, 0xfb, 0x78, 0xca, 0xa6, 0x44, 0xec, 0xbf, 0xfb, 0x33, 0xea, 0xcd, 0x46, 0x64, 0xf0, + /*9d10:*/ 0x1e, 0x5a, 0x3a, 0x3a, 0xbe, 0x7f, 0x83, 0x94, 0xb2, 0x11, 0xb1, 0x32, 0x14, 0x05, 0xc0, 0xa0, + /*9d20:*/ 0x87, 0x7f, 0xb7, 0xf2, 0xe9, 0x08, 0xcb, 0x1f, 0x5d, 0x87, 0x30, 0xec, 0x05, 0xcf, 0xaa, 0x01, + /*9d30:*/ 0x2f, 0x23, 0x0d, 0x81, 0xde, 0x30, 0x8e, 0x03, 0x0e, 0x44, 0x6e, 0x62, 0xb9, 0x6e, 0x7c, 0x0e, + /*9d40:*/ 0x0a, 0x00, 0x63, 0xea, 0xb9, 0xbd, 0x9b, 0x8e, 0x1a, 0x3c, 0xb4, 0xff, 0xae, 0xd4, 0x15, 0x18, + /*9d50:*/ 0xe6, 0x0f, 0xfe, 0x28, 0x6e, 0xdc, 0x76, 0x2a, 0xf5, 0xd4, 0x14, 0xd8, 0x8c, 0x76, 0x35, 0xa8, + /*9d60:*/ 0x85, 0x38, 0x55, 0xfe, 0xc3, 0x83, 0xd5, 0xaa, 0x58, 0x92, 0xb8, 0x82, 0x45, 0x9c, 0xe5, 0x92, + /*9d70:*/ 0xd4, 0x11, 0xc9, 0xf9, 0xab, 0x5b, 0x9c, 0x77, 0xb3, 0xbe, 0x3f, 0x65, 0x89, 0xbd, 0x1d, 0xdf, + /*9d80:*/ 0x89, 0x64, 0xe3, 0x0b, 0xf4, 0xc8, 0xf2, 0xe1, 0x23, 0xbf, 0x13, 0x81, 0x33, 0x92, 0x94, 0x75, + /*9d90:*/ 0x1b, 0xd1, 0xfc, 0x34, 0xee, 0x54, 0xdc, 0x3c, 0x40, 0xf4, 0x5d, 0xdd, 0x64, 0xd5, 0xb0, 0xdf, + /*9da0:*/ 0x6a, 0xb6, 0x3b, 0x92, 0x71, 0x06, 0x33, 0xf7, 0xba, 0x9b, 0x4a, 0x79, 0x91, 0x31, 0x17, 0x86, + /*9db0:*/ 0x35, 0x37, 0x8f, 0x62, 0x57, 0x43, 0xe7, 0x72, 0x32, 0x56, 0x91, 0x41, 0xd5, 0xc9, 0x27, 0x54, + /*9dc0:*/ 0x7e, 0x61, 0x7b, 0x36, 0x15, 0x2d, 0xbd, 0x4d, 0x9f, 0x51, 0xfd, 0x85, 0x8d, 0x00, 0x91, 0xe3, + /*9dd0:*/ 0x64, 0xb1, 0x8b, 0x51, 0xbe, 0x0e, 0x5d, 0xdb, 0x41, 0x79, 0xec, 0x11, 0x95, 0xa7, 0xfa, 0x4b, + /*9de0:*/ 0xd3, 0x55, 0x98, 0xb2, 0xd2, 0x51, 0xfe, 0x51, 0x35, 0x9c, 0x22, 0x3e, 0x25, 0x91, 0x42, 0xc3, + /*9df0:*/ 0xb0, 0x75, 0x05, 0xeb, 0xf2, 0xcb, 0x7d, 0xaa, 0xb6, 0x4b, 0x82, 0x12, 0xc2, 0x88, 0xf9, 0x78, + /*9e00:*/ 0xf6, 0x01, 0x30, 0x50, 0x38, 0x6a, 0xcb, 0xb1, 0xf1, 0x27, 0xcb, 0xf7, 0xd3, 0xe1, 0x43, 0xf3, + /*9e10:*/ 0x9e, 0x8c, 0x92, 0xab, 0xcd, 0xa7, 0x03, 0xc3, 0xd0, 0x9c, 0x91, 0x8b, 0x2d, 0xde, 0xbc, 0x50, + /*9e20:*/ 0x63, 0x95, 0x4b, 0x7e, 0xda, 0xf4, 0x72, 0xe3, 0xcc, 0x2c, 0x35, 0x5d, 0x2c, 0xd0, 0x4b, 0x54, + /*9e30:*/ 0xaf, 0xf4, 0x42, 0x0e, 0xd4, 0x8a, 0x66, 0x56, 0x83, 0xd9, 0x5e, 0x1d, 0x81, 0xd3, 0xce, 0xad, + /*9e40:*/ 0x61, 0xca, 0x20, 0xe6, 0xc3, 0x17, 0xef, 0x4b, 0xbe, 0xf0, 0xbc, 0xda, 0xb3, 0x79, 0xb5, 0xcb, + /*9e50:*/ 0x38, 0x67, 0x2a, 0x17, 0x4f, 0xda, 0xfc, 0x1a, 0x87, 0x8d, 0xc3, 0x73, 0x87, 0x65, 0xf6, 0x03, + /*9e60:*/ 0xc9, 0xf0, 0xab, 0x2c, 0x6f, 0xae, 0x90, 0x15, 0x10, 0xf1, 0x8d, 0x90, 0x05, 0x1a, 0x27, 0x72, + /*9e70:*/ 0x2d, 0x2d, 0xfb, 0x1b, 0xec, 0x9a, 0x90, 0x21, 0x08, 0xb6, 0x58, 0x57, 0xb3, 0x3d, 0xb1, 0x29, + /*9e80:*/ 0x00, 0x62, 0x95, 0x68, 0x6b, 0x5b, 0xfb, 0x98, 0x6e, 0xbb, 0x9c, 0x53, 0x03, 0xd3, 0xda, 0x91, + /*9e90:*/ 0xac, 0xec, 0x1c, 0x4e, 0x56, 0xbb, 0x50, 0xe3, 0x23, 0xc0, 0x01, 0x63, 0x45, 0x01, 0xff, 0x30, + /*9ea0:*/ 0x6e, 0x6f, 0xe9, 0x60, 0xed, 0xab, 0x89, 0x5c, 0xcf, 0x0a, 0x89, 0x13, 0x39, 0x2a, 0xa6, 0x93, + /*9eb0:*/ 0x18, 0xc8, 0x26, 0xd3, 0x23, 0x8c, 0x22, 0xa4, 0x3c, 0xde, 0xe7, 0x7d, 0x9c, 0x5c, 0x35, 0x4c, + /*9ec0:*/ 0xb1, 0x6e, 0xfc, 0x19, 0xaa, 0x5a, 0x17, 0xad, 0x22, 0x75, 0x3e, 0x83, 0xa7, 0x7e, 0x72, 0xe0, + /*9ed0:*/ 0xaa, 0x75, 0x37, 0x2a, 0xd0, 0xd3, 0x8f, 0xbf, 0x20, 0x0b, 0x3e, 0xff, 0xea, 0x0b, 0x3c, 0x20, + /*9ee0:*/ 0x33, 0x6b, 0x28, 0xc8, 0x67, 0x85, 0x97, 0x61, 0x5f, 0x48, 0xaf, 0x38, 0x38, 0x07, 0x41, 0x6a, + /*9ef0:*/ 0x5e, 0x5a, 0x39, 0x4e, 0x45, 0xc6, 0xb5, 0x8f, 0xea, 0x78, 0x47, 0x51, 0x83, 0xb2, 0x98, 0xd1, + /*9f00:*/ 0x43, 0x0f, 0xc4, 0xaf, 0xad, 0xf4, 0x95, 0xe5, 0xc8, 0x6f, 0x48, 0x50, 0x83, 0x7c, 0xd4, 0xb9, + /*9f10:*/ 0x13, 0x7b, 0x60, 0x41, 0xf9, 0x2f, 0xe0, 0x31, 0x5f, 0x3f, 0x20, 0xce, 0x6f, 0xcd, 0x94, 0x0a, + /*9f20:*/ 0xd5, 0x0b, 0x01, 0x09, 0x5f, 0x1d, 0x43, 0x0a, 0x35, 0x05, 0x6b, 0xe6, 0x0a, 0x48, 0xb1, 0xa7, + /*9f30:*/ 0xe5, 0x03, 0x7f, 0x6b, 0xfe, 0xcc, 0xdf, 0x88, 0xbc, 0xde, 0x8f, 0x1f, 0xad, 0x77, 0xb0, 0xe9, + /*9f40:*/ 0x53, 0x1f, 0xad, 0xb0, 0x81, 0x9f, 0xa6, 0x9f, 0x7e, 0x36, 0x8e, 0xed, 0xba, 0xa9, 0x07, 0x78, + /*9f50:*/ 0x2f, 0xea, 0xdb, 0x66, 0x63, 0x32, 0x47, 0xbf, 0x38, 0xfe, 0x6b, 0xa8, 0x29, 0x27, 0x0a, 0x41, + /*9f60:*/ 0x0b, 0x84, 0x11, 0xcf, 0x5c, 0x57, 0x0f, 0x2a, 0xbc, 0x6f, 0xc8, 0xa8, 0x55, 0x19, 0xd8, 0xd0, + /*9f70:*/ 0x7c, 0xec, 0x19, 0x72, 0x50, 0xfa, 0x86, 0xf8, 0xa9, 0x1e, 0xb7, 0xa3, 0x96, 0xe2, 0x58, 0x17, + /*9f80:*/ 0x1c, 0xc9, 0x95, 0x38, 0x9e, 0x94, 0x9e, 0x16, 0xe1, 0x69, 0xe7, 0xea, 0xf2, 0x49, 0x5f, 0x9a, + /*9f90:*/ 0x64, 0x42, 0x5e, 0x7b, 0xb5, 0x4b, 0x5c, 0x29, 0x23, 0x84, 0xaf, 0xa3, 0x41, 0x54, 0xd2, 0x9e, + /*9fa0:*/ 0x25, 0x1d, 0x19, 0x1a, 0x86, 0x1d, 0xa5, 0xb4, 0xc6, 0x8f, 0x81, 0x1f, 0x06, 0xed, 0xb8, 0xee, + /*9fb0:*/ 0x1b, 0xf0, 0xb6, 0x78, 0xd1, 0x00, 0x85, 0x81, 0xff, 0xde, 0xdb, 0xc1, 0x6c, 0xb9, 0xdc, 0xb3, + /*9fc0:*/ 0x45, 0x16, 0x5f, 0xaf, 0x54, 0x17, 0xef, 0x0b, 0x98, 0x33, 0x29, 0xb5, 0x4a, 0xfb, 0x3d, 0x19, + /*9fd0:*/ 0x0d, 0x74, 0x8b, 0xee, 0x20, 0x94, 0x80, 0x59, 0xac, 0x93, 0xba, 0x50, 0x8a, 0x7b, 0xff, 0xd1, + /*9fe0:*/ 0xad, 0x7e, 0x91, 0x79, 0xcb, 0xb1, 0x64, 0x58, 0x55, 0x2a, 0xf8, 0xc4, 0xcd, 0x9b, 0xdc, 0x4c, + /*9ff0:*/ 0x17, 0x61, 0x19, 0x99, 0x54, 0x30, 0x20, 0x6b, 0xe9, 0xc8, 0xad, 0x1f, 0xcf, 0x61, 0x18, 0x5f, + /*a000:*/ 0x1d, 0x2d, 0xb1, 0xb6, 0xbf, 0xd9, 0xee, 0x38, 0x22, 0xd1, 0xd4, 0xad, 0xe7, 0xe4, 0xb3, 0xcd, + /*a010:*/ 0x65, 0x9c, 0x45, 0xcf, 0x2b, 0xe0, 0xde, 0x2c, 0x3a, 0x53, 0x1f, 0x98, 0x10, 0xf5, 0x15, 0xd8, + /*a020:*/ 0x53, 0xa4, 0x3c, 0x46, 0x00, 0x53, 0xab, 0x9b, 0x4f, 0x92, 0xb8, 0x70, 0x84, 0x24, 0xa7, 0xaf, + /*a030:*/ 0xe3, 0x0a, 0x5f, 0x89, 0x10, 0xa1, 0x72, 0x3d, 0x68, 0x14, 0x1d, 0xb9, 0x16, 0x4e, 0x6c, 0x19, + /*a040:*/ 0x43, 0x95, 0x83, 0xb8, 0x18, 0x61, 0x4d, 0x20, 0x6d, 0xb9, 0x97, 0x6b, 0x44, 0xe4, 0x9b, 0x2c, + /*a050:*/ 0xb5, 0x5a, 0xdd, 0xd5, 0xd1, 0x6a, 0xdf, 0x19, 0xf7, 0xb0, 0x5a, 0x09, 0xc1, 0x55, 0x3e, 0x88, + /*a060:*/ 0xbe, 0xa5, 0x49, 0x20, 0x95, 0x7f, 0xcb, 0x97, 0x5b, 0x51, 0x4d, 0xb0, 0x77, 0x89, 0xab, 0x4d, + /*a070:*/ 0xfc, 0x88, 0x20, 0x25, 0x68, 0x38, 0x6a, 0xb9, 0x5d, 0x0b, 0x9a, 0xe6, 0x96, 0xeb, 0x64, 0x66, + /*a080:*/ 0x1f, 0x7b, 0xb0, 0x2f, 0x35, 0xb6, 0x45, 0x25, 0x46, 0x09, 0x70, 0x98, 0xf8, 0xdc, 0x47, 0x14, + /*a090:*/ 0x7d, 0x61, 0xfa, 0x6e, 0x4e, 0x7c, 0x4f, 0x42, 0xe3, 0xaa, 0x1a, 0xf7, 0x44, 0xa8, 0x4a, 0x85, + /*a0a0:*/ 0xa5, 0xcc, 0x07, 0x7c, 0x2a, 0x23, 0xab, 0x1d, 0xf7, 0xa0, 0xd5, 0xd9, 0x9b, 0xfc, 0xf9, 0x9b, + /*a0b0:*/ 0xec, 0x93, 0xd4, 0x03, 0x86, 0x1d, 0x0b, 0x02, 0x82, 0xde, 0x06, 0xb3, 0xd1, 0x58, 0x03, 0xf1, + /*a0c0:*/ 0xbd, 0x8f, 0xf8, 0xc9, 0x39, 0x9d, 0xce, 0x16, 0x54, 0xb0, 0x42, 0x8b, 0xac, 0x08, 0x5c, 0xfb, + /*a0d0:*/ 0x0c, 0xcb, 0x79, 0xfc, 0x65, 0xe0, 0xe6, 0x54, 0xcd, 0x39, 0x6d, 0x3d, 0x67, 0x69, 0xf4, 0xb6, + /*a0e0:*/ 0x0d, 0x51, 0xb2, 0x3b, 0xc0, 0x61, 0x97, 0xde, 0xbd, 0x7f, 0x0a, 0xe0, 0xb0, 0xd7, 0x46, 0x21, + /*a0f0:*/ 0xb4, 0xa5, 0x9b, 0x96, 0x3c, 0xf5, 0x75, 0x39, 0x44, 0xb9, 0x06, 0xf2, 0xf7, 0x51, 0xc8, 0xfa, + /*a100:*/ 0x6f, 0x1c, 0x06, 0x3c, 0x90, 0xf0, 0xf6, 0x67, 0x17, 0xe8, 0xb2, 0x0c, 0x75, 0x40, 0x92, 0x4d, + /*a110:*/ 0x41, 0x08, 0x39, 0xf9, 0x71, 0xb8, 0xe5, 0xbf, 0x8f, 0xad, 0x90, 0x84, 0x29, 0x48, 0x8e, 0x75, + /*a120:*/ 0x4f, 0xb3, 0xf3, 0xe3, 0xc3, 0xf5, 0x3d, 0xe6, 0x95, 0xfb, 0x14, 0x5b, 0x89, 0xe4, 0xd8, 0xf3, + /*a130:*/ 0x16, 0x26, 0x76, 0xf5, 0x76, 0x43, 0x1f, 0xe3, 0x0b, 0xe4, 0xb7, 0x5a, 0x1a, 0x2c, 0x71, 0xb0, + /*a140:*/ 0xd4, 0xd0, 0x09, 0x8c, 0x64, 0x70, 0x57, 0x98, 0xe6, 0xa6, 0x10, 0x6f, 0xde, 0xe1, 0xa5, 0x45, + /*a150:*/ 0x9e, 0x41, 0x35, 0x3f, 0x78, 0x8e, 0xf1, 0x3c, 0x30, 0x32, 0xe2, 0xe1, 0xa6, 0xd8, 0x58, 0xc0, + /*a160:*/ 0xa4, 0x69, 0x1a, 0x5a, 0xb2, 0x56, 0x7f, 0x33, 0x3f, 0x10, 0x77, 0x92, 0xa7, 0xc0, 0xb2, 0xc0, + /*a170:*/ 0xf8, 0x27, 0xa5, 0xcd, 0xfa, 0x27, 0x9f, 0xe3, 0x28, 0x59, 0x54, 0xb3, 0x43, 0xf8, 0xd7, 0x20, + /*a180:*/ 0x25, 0xee, 0x34, 0x3d, 0x66, 0xa1, 0x48, 0x83, 0x61, 0x03, 0x29, 0xcb, 0xbb, 0x72, 0x56, 0x1d, + /*a190:*/ 0x66, 0xfc, 0xcf, 0x6e, 0x28, 0x22, 0xed, 0x3a, 0x2f, 0xdb, 0x4a, 0x0b, 0xa6, 0xbe, 0xb2, 0xe4, + /*a1a0:*/ 0x26, 0x40, 0x82, 0xd0, 0xab, 0xfa, 0x95, 0x03, 0x4d, 0xdb, 0x5b, 0x97, 0x65, 0x36, 0x4a, 0x5e, + /*a1b0:*/ 0xd9, 0x63, 0xc8, 0x9c, 0xbe, 0x70, 0x76, 0xee, 0xa0, 0xcf, 0x34, 0xad, 0xcd, 0xa1, 0x81, 0x19, + /*a1c0:*/ 0x71, 0x49, 0xb7, 0xc9, 0x47, 0xec, 0x92, 0x32, 0xc8, 0xf0, 0xe0, 0x30, 0xee, 0x9a, 0xbb, 0x11, + /*a1d0:*/ 0x8e, 0xe4, 0xa8, 0xdb, 0x1f, 0x29, 0xf5, 0xcf, 0x16, 0x82, 0x7b, 0xcf, 0x10, 0x48, 0xaa, 0x55, + /*a1e0:*/ 0x75, 0x9e, 0x8b, 0xc1, 0x34, 0xd2, 0x91, 0xd1, 0x56, 0x51, 0xee, 0xcb, 0xc5, 0x8b, 0xeb, 0x30, + /*a1f0:*/ 0xa9, 0x0c, 0xcd, 0x05, 0x7c, 0xd0, 0x64, 0x8b, 0x66, 0xba, 0x59, 0xd2, 0x0d, 0x87, 0x8f, 0xf6, + /*a200:*/ 0x67, 0x8b, 0x85, 0x44, 0x7f, 0xd9, 0x02, 0xfd, 0x75, 0x0b, 0x11, 0x45, 0xa5, 0x1d, 0x2a, 0x37, + /*a210:*/ 0xd8, 0xe7, 0xde, 0x33, 0xcf, 0xdb, 0xdb, 0x31, 0xe4, 0xf5, 0x41, 0xae, 0x33, 0x6e, 0x0e, 0x02, + /*a220:*/ 0x02, 0x38, 0xd7, 0x67, 0xb5, 0x24, 0xe9, 0x31, 0x91, 0x0f, 0x5f, 0x24, 0xd3, 0x2f, 0x41, 0xe7, + /*a230:*/ 0x8a, 0xb0, 0x5c, 0x88, 0x32, 0x4e, 0xff, 0xf1, 0xa4, 0xaf, 0xa8, 0x6b, 0x04, 0x5d, 0x0e, 0xb2, + /*a240:*/ 0xd8, 0x69, 0x74, 0x5b, 0xbc, 0x91, 0xf3, 0x59, 0x98, 0xf5, 0x13, 0xdd, 0x10, 0x45, 0x02, 0x6d, + /*a250:*/ 0xcb, 0x3e, 0x01, 0x31, 0xa0, 0x29, 0x07, 0x67, 0x3b, 0x04, 0x4a, 0xc3, 0x9c, 0x9e, 0x90, 0xa0, + /*a260:*/ 0x1d, 0xc1, 0x6a, 0x9e, 0xef, 0xd5, 0xf2, 0x1f, 0x91, 0xd0, 0xe7, 0xe2, 0x76, 0x83, 0xaa, 0x85, + /*a270:*/ 0xd6, 0x29, 0x8a, 0x74, 0x09, 0x94, 0xed, 0x4e, 0x2b, 0xd9, 0x6a, 0x55, 0x70, 0x3d, 0x16, 0x57, + /*a280:*/ 0xd4, 0x9e, 0x31, 0x66, 0x8b, 0xf4, 0x6a, 0x70, 0xce, 0xe5, 0x33, 0xc0, 0xb4, 0xcf, 0x41, 0xf7, + /*a290:*/ 0xb2, 0xbf, 0x95, 0xa1, 0xe3, 0x8b, 0x2e, 0x46, 0x1f, 0x44, 0xe5, 0xd0, 0x5e, 0x99, 0x4a, 0xb6, + /*a2a0:*/ 0x65, 0x90, 0x74, 0x2a, 0x8e, 0xbc, 0x1f, 0x17, 0x6a, 0x01, 0x05, 0xb7, 0xb5, 0xd2, 0xab, 0xf6, + /*a2b0:*/ 0xe6, 0x90, 0x5a, 0x07, 0xa1, 0x7c, 0x68, 0x9d, 0x7a, 0x88, 0x1c, 0x10, 0xa4, 0xe3, 0x7b, 0xbb, + /*a2c0:*/ 0xf4, 0xb0, 0x1f, 0x59, 0x96, 0x31, 0xea, 0xc5, 0xf2, 0x7e, 0x1e, 0x31, 0xa2, 0x94, 0x84, 0x3a, + /*a2d0:*/ 0xbd, 0x08, 0x8a, 0x3a, 0xa5, 0x6d, 0x0e, 0x45, 0x63, 0xd8, 0xe5, 0xf4, 0x53, 0xd5, 0x04, 0x64, + /*a2e0:*/ 0x43, 0x14, 0xed, 0x45, 0x96, 0x31, 0xdd, 0x73, 0xf8, 0xe5, 0x1f, 0x4f, 0xd7, 0x41, 0x9e, 0xed, + /*a2f0:*/ 0x87, 0xb0, 0x20, 0x8a, 0x51, 0xcf, 0x9e, 0x42, 0xe4, 0xb8, 0xce, 0x61, 0xbe, 0x3f, 0x03, 0xf6, + /*a300:*/ 0xdd, 0x55, 0x57, 0x17, 0x89, 0xe3, 0x11, 0x2f, 0x75, 0x54, 0x8f, 0xcc, 0x69, 0xc8, 0xd9, 0xd0, + /*a310:*/ 0x17, 0xfc, 0x6a, 0x4f, 0x11, 0x08, 0xc5, 0x67, 0xd4, 0xdd, 0x6e, 0x9c, 0xae, 0x18, 0x05, 0x50, + /*a320:*/ 0xd9, 0xb0, 0x75, 0x8c, 0x4a, 0x0a, 0xb9, 0x37, 0x91, 0x38, 0xab, 0x5e, 0xbc, 0xe0, 0x15, 0x07, + /*a330:*/ 0x10, 0xdd, 0x4c, 0xb2, 0xc7, 0x62, 0x57, 0x51, 0x72, 0xe9, 0x23, 0x50, 0x47, 0xf9, 0xc2, 0x31, + /*a340:*/ 0x40, 0x47, 0xfd, 0xe3, 0xf6, 0x45, 0xc4, 0xd8, 0x3b, 0x42, 0x47, 0xed, 0xd6, 0x36, 0x0a, 0x66, + /*a350:*/ 0x96, 0x1d, 0x3a, 0x27, 0x59, 0xa3, 0x51, 0xa6, 0xc0, 0x6c, 0xdb, 0x43, 0x0f, 0x86, 0xcb, 0xe6, + /*a360:*/ 0x01, 0x2d, 0x42, 0xcd, 0xa7, 0x63, 0x27, 0x0e, 0xd0, 0xdb, 0xa9, 0x39, 0xbe, 0x43, 0x78, 0x16, + /*a370:*/ 0x54, 0xcc, 0xff, 0x0d, 0x4c, 0x44, 0x22, 0x9e, 0xbf, 0x33, 0xbb, 0xb6, 0xd5, 0x9b, 0xe1, 0x80, + /*a380:*/ 0x26, 0x54, 0x76, 0xe7, 0xcb, 0x8b, 0x36, 0x9c, 0x85, 0xb7, 0xee, 0x62, 0x26, 0xa0, 0xd9, 0x99, + /*a390:*/ 0x1d, 0x8e, 0xfc, 0x66, 0xb8, 0x80, 0x64, 0x74, 0xc7, 0x5a, 0x51, 0x4e, 0x27, 0xac, 0x53, 0xb5, + /*a3a0:*/ 0x94, 0xf8, 0xab, 0xd9, 0xf9, 0x7b, 0xdd, 0xda, 0xac, 0xd6, 0xf8, 0x81, 0x8b, 0x1e, 0xd2, 0x11, + /*a3b0:*/ 0xc3, 0x2a, 0xc2, 0x32, 0xb5, 0x96, 0x11, 0xae, 0xa5, 0x44, 0xe8, 0xe3, 0x37, 0x2e, 0xe5, 0x46, + /*a3c0:*/ 0x89, 0xc1, 0x4a, 0x18, 0xdd, 0x0d, 0x08, 0x7c, 0x54, 0x4e, 0xe6, 0x48, 0x76, 0x74, 0x19, 0x7e, + /*a3d0:*/ 0x40, 0xf4, 0xf4, 0xe6, 0x04, 0x1c, 0xe2, 0x19, 0x2a, 0x87, 0x1d, 0x07, 0x3b, 0xf9, 0xf5, 0x72, + /*a3e0:*/ 0x67, 0xc5, 0xd5, 0x53, 0x5d, 0xa2, 0x6f, 0x87, 0x38, 0xe6, 0x3d, 0x7c, 0xf5, 0xcd, 0x02, 0xfc, + /*a3f0:*/ 0xf2, 0x74, 0x27, 0x62, 0x62, 0x71, 0x45, 0xaa, 0x1f, 0xbd, 0x49, 0x8c, 0xa3, 0xb8, 0xf7, 0x14, + /*a400:*/ 0xac, 0x49, 0xeb, 0xb3, 0x8f, 0x5f, 0x12, 0x46, 0x07, 0x28, 0x32, 0x4a, 0x50, 0x0e, 0x98, 0xb3, + /*a410:*/ 0x8f, 0x63, 0x38, 0x45, 0x76, 0xf1, 0xcf, 0x04, 0x86, 0x16, 0x2f, 0x10, 0xbd, 0xa0, 0xb1, 0xd1, + /*a420:*/ 0xe4, 0x32, 0x09, 0xa3, 0x0c, 0x4c, 0xf3, 0xb0, 0x3b, 0x7d, 0xa8, 0x9b, 0xf7, 0x6c, 0x11, 0xce, + /*a430:*/ 0xe4, 0x19, 0x8c, 0xbb, 0x27, 0x12, 0x73, 0x9f, 0xe9, 0x46, 0x4a, 0x82, 0xf9, 0x26, 0x30, 0x4e, + /*a440:*/ 0xef, 0x11, 0x55, 0x98, 0x2c, 0xa4, 0xf4, 0xa9, 0x42, 0x56, 0x67, 0x36, 0xbf, 0x8c, 0xe4, 0x8c, + /*a450:*/ 0xf8, 0x47, 0x8f, 0x73, 0x3a, 0x0c, 0xdd, 0xe6, 0x49, 0x29, 0x12, 0xf4, 0xc2, 0x7d, 0x72, 0x0f, + /*a460:*/ 0xa5, 0x5b, 0xb9, 0x19, 0xfe, 0x24, 0x65, 0xfd, 0x5a, 0xe6, 0x3f, 0xb0, 0x2c, 0x78, 0xec, 0x3f, + /*a470:*/ 0x1f, 0xc2, 0xa8, 0xd0, 0xdf, 0x1b, 0xa1, 0x9b, 0x47, 0x0b, 0x16, 0xb2, 0x1d, 0x75, 0xba, 0x23, + /*a480:*/ 0x20, 0x5a, 0x88, 0xca, 0x99, 0x54, 0x00, 0x8e, 0xd4, 0x9e, 0x31, 0x71, 0xdf, 0xb8, 0xf9, 0x23, + /*a490:*/ 0xc7, 0x88, 0x2a, 0x40, 0xc5, 0x5f, 0x17, 0x07, 0xe5, 0xab, 0x70, 0xff, 0xac, 0x79, 0xe8, 0x51, + /*a4a0:*/ 0x9c, 0x9f, 0x06, 0x43, 0x31, 0x7a, 0x0f, 0xa1, 0x12, 0x5a, 0x50, 0x86, 0x7a, 0x0f, 0xf9, 0xf2, + /*a4b0:*/ 0x13, 0x7d, 0x11, 0x72, 0x56, 0xa5, 0x54, 0x52, 0xb4, 0xcf, 0xb0, 0xdb, 0xce, 0xe1, 0x02, 0x8e, + /*a4c0:*/ 0xeb, 0xf8, 0xc6, 0xdd, 0xcf, 0x7f, 0x48, 0xa6, 0x18, 0xc1, 0x8e, 0xeb, 0xf7, 0xf0, 0x59, 0x2e, + /*a4d0:*/ 0xb5, 0xb0, 0x29, 0x7c, 0x46, 0x88, 0xfb, 0xf8, 0x5e, 0xb8, 0xd1, 0x96, 0x23, 0x8e, 0xaf, 0x06, + /*a4e0:*/ 0x44, 0x1b, 0xe0, 0xac, 0xf9, 0x5c, 0xa0, 0x2a, 0x05, 0xfc, 0x8f, 0x74, 0x4d, 0x42, 0x4c, 0xca, + /*a4f0:*/ 0xe8, 0x98, 0x96, 0x8c, 0x9b, 0x59, 0x92, 0xb1, 0x9a, 0x19, 0xed, 0x41, 0xc7, 0xe7, 0x61, 0x9b, + /*a500:*/ 0x30, 0x3c, 0x5b, 0x45, 0xcf, 0x90, 0xfb, 0xf4, 0x9f, 0xce, 0xc3, 0x83, 0x82, 0x70, 0xc2, 0xfd, + /*a510:*/ 0xb6, 0xcd, 0x94, 0x6a, 0x15, 0xa5, 0x30, 0x39, 0xa3, 0xbb, 0x0a, 0x70, 0x18, 0x69, 0x93, 0x7b, + /*a520:*/ 0x21, 0x1f, 0x7f, 0x71, 0x61, 0xb7, 0xa3, 0x21, 0xb1, 0xba, 0x65, 0x1d, 0x84, 0x39, 0xc7, 0x4e, + /*a530:*/ 0x21, 0x2f, 0xfe, 0x8a, 0x0f, 0xdf, 0x81, 0xbb, 0xb2, 0x72, 0x71, 0x25, 0xfa, 0xc2, 0xc5, 0xff, + /*a540:*/ 0x99, 0x6d, 0x1f, 0xa3, 0xfc, 0xf3, 0xec, 0x32, 0x92, 0xd3, 0x28, 0xf2, 0xc6, 0x26, 0x1f, 0xa0, + /*a550:*/ 0xe6, 0xdf, 0xc5, 0xb2, 0x6b, 0x17, 0x69, 0x64, 0xe1, 0xda, 0x68, 0x38, 0x14, 0xf5, 0x2e, 0xf5, + /*a560:*/ 0xaf, 0x57, 0x74, 0x44, 0xe1, 0x28, 0x6e, 0x2e, 0x28, 0x7f, 0x99, 0x1c, 0x23, 0x26, 0x96, 0x38, + /*a570:*/ 0xcb, 0x70, 0x62, 0x53, 0x1b, 0x70, 0xb3, 0x1b, 0xbb, 0x9a, 0x9e, 0x31, 0xfd, 0x6f, 0x74, 0x84, + /*a580:*/ 0x5c, 0xd5, 0xf7, 0x10, 0xf7, 0x76, 0xd4, 0x22, 0xe6, 0x5e, 0x4b, 0xad, 0x41, 0xe6, 0x23, 0xe5, + /*a590:*/ 0x36, 0xf1, 0x2b, 0x57, 0x87, 0x97, 0x60, 0x46, 0x9d, 0xea, 0x18, 0x25, 0xcf, 0x33, 0x4f, 0x68, + /*a5a0:*/ 0x4d, 0x9f, 0x61, 0x59, 0x09, 0xf4, 0x45, 0xa3, 0x03, 0x76, 0x68, 0x24, 0x18, 0x36, 0xbe, 0xb7, + /*a5b0:*/ 0x78, 0xf7, 0xdc, 0x21, 0xce, 0x36, 0x28, 0xd2, 0x79, 0xb9, 0xda, 0xf3, 0x7f, 0xc0, 0x74, 0x55, + /*a5c0:*/ 0x00, 0x38, 0x57, 0x73, 0x9b, 0x1e, 0x80, 0x84, 0x55, 0xfc, 0x35, 0x1c, 0xbd, 0x8c, 0x27, 0xf0, + /*a5d0:*/ 0x6d, 0xef, 0x8a, 0x6a, 0x3a, 0x76, 0x77, 0xd1, 0xf3, 0xf7, 0xbc, 0xdd, 0x97, 0x0b, 0x68, 0xcc, + /*a5e0:*/ 0x2b, 0xdc, 0x1f, 0xde, 0x52, 0x66, 0x67, 0x7d, 0x72, 0x4c, 0x2c, 0xa8, 0xf1, 0x8d, 0x6d, 0xa3, + /*a5f0:*/ 0x4c, 0x33, 0xcf, 0xa9, 0x25, 0x6b, 0x6e, 0xe0, 0x48, 0x81, 0x51, 0x85, 0xf4, 0x33, 0xda, 0x32, + /*a600:*/ 0x7b, 0xdd, 0xa8, 0x0e, 0x94, 0x08, 0xc2, 0x16, 0xd0, 0xdd, 0x93, 0x22, 0xdc, 0x90, 0x04, 0xc9, + /*a610:*/ 0xee, 0x2a, 0xcd, 0x58, 0xac, 0xf7, 0x9a, 0xe2, 0xd9, 0x0a, 0x7b, 0x18, 0x9f, 0x85, 0xfc, 0x8e, + /*a620:*/ 0xb6, 0x5c, 0x05, 0x46, 0x94, 0x55, 0xd5, 0x28, 0x84, 0x0a, 0xb1, 0x35, 0x8d, 0x38, 0x34, 0xd5, + /*a630:*/ 0xd6, 0x2b, 0x66, 0xd6, 0xc1, 0x19, 0x5d, 0x99, 0x2f, 0xbe, 0x7f, 0xd9, 0x53, 0xa5, 0x6f, 0xa0, + /*a640:*/ 0x18, 0xb5, 0x77, 0x12, 0x56, 0xdd, 0x64, 0x4c, 0x84, 0x43, 0xa6, 0x05, 0x29, 0xf2, 0x70, 0x88, + /*a650:*/ 0x64, 0x1e, 0x28, 0x35, 0x31, 0x2d, 0x9a, 0xa0, 0x1e, 0x05, 0x53, 0xa2, 0xf1, 0xa9, 0xa8, 0xae, + /*a660:*/ 0x6d, 0x93, 0x13, 0x2d, 0xeb, 0x94, 0xe9, 0x7f, 0x9e, 0x05, 0x52, 0x18, 0xa0, 0xaa, 0x4d, 0x25, + /*a670:*/ 0xf2, 0x1c, 0xa6, 0xf4, 0x38, 0x14, 0x36, 0xb6, 0x0c, 0x5f, 0xb3, 0x26, 0x1f, 0x35, 0x3d, 0x6d, + /*a680:*/ 0xa2, 0xa1, 0x06, 0x41, 0x44, 0xf2, 0xc2, 0xee, 0x8a, 0xf0, 0x5b, 0x4c, 0x15, 0xa2, 0x1d, 0xd1, + /*a690:*/ 0xd3, 0x44, 0x89, 0x49, 0x92, 0xe3, 0x1c, 0x15, 0x69, 0x43, 0xab, 0x10, 0xce, 0x16, 0xcf, 0x82, + /*a6a0:*/ 0x5b, 0x81, 0x1b, 0x86, 0x8b, 0x71, 0x79, 0x47, 0x49, 0x87, 0x8f, 0x73, 0x7a, 0xc2, 0xda, 0xb6, + /*a6b0:*/ 0x68, 0x45, 0x4d, 0x41, 0xbc, 0xec, 0x5c, 0x4a, 0xb1, 0x8b, 0x2d, 0xc2, 0x1f, 0x62, 0xd8, 0x8c, + /*a6c0:*/ 0x9e, 0x0d, 0x00, 0x5b, 0x20, 0x23, 0x39, 0xfe, 0x8c, 0x1c, 0x1d, 0xf6, 0xb8, 0x86, 0xb4, 0x2b, + /*a6d0:*/ 0xe2, 0xe9, 0x79, 0xc4, 0x30, 0xcf, 0xd8, 0xc4, 0x9d, 0xcf, 0x9d, 0xb2, 0xd3, 0x50, 0x2b, 0xdc, + /*a6e0:*/ 0xae, 0xfb, 0x67, 0x50, 0x73, 0x86, 0x0c, 0x01, 0x31, 0x8e, 0xb0, 0x98, 0x96, 0xe9, 0x3c, 0x58, + /*a6f0:*/ 0x08, 0x68, 0x0a, 0x63, 0xd2, 0xdf, 0xc7, 0x2e, 0xd5, 0xed, 0x14, 0xeb, 0x61, 0x56, 0x63, 0xa1, + /*a700:*/ 0xc1, 0xa9, 0x26, 0x25, 0xe8, 0x6c, 0xea, 0xa0, 0x5a, 0x8e, 0xaf, 0x5d, 0xca, 0x06, 0xa4, 0x64, + /*a710:*/ 0xad, 0xf8, 0xbd, 0x90, 0xbb, 0xbf, 0xb7, 0xb6, 0x25, 0x5d, 0x09, 0x39, 0x82, 0x01, 0x7d, 0xfb, + /*a720:*/ 0x31, 0x3c, 0x82, 0x2b, 0x40, 0x63, 0x01, 0x80, 0x4e, 0x7c, 0xe8, 0x6c, 0x9b, 0xef, 0x12, 0x2c, + /*a730:*/ 0x8d, 0x63, 0xff, 0xf5, 0xad, 0x77, 0x59, 0x39, 0x20, 0x99, 0x85, 0x51, 0xe7, 0x75, 0x07, 0xac, + /*a740:*/ 0xe8, 0x30, 0xa4, 0xc9, 0xbf, 0x9f, 0xa4, 0x1f, 0x11, 0x98, 0x01, 0x9b, 0xfb, 0x96, 0x7d, 0xa3, + /*a750:*/ 0xaf, 0x73, 0x15, 0x7b, 0xce, 0x7a, 0xce, 0x2c, 0x00, 0xa1, 0x0f, 0x3c, 0x49, 0x6c, 0x62, 0x4c, + /*a760:*/ 0x7c, 0xec, 0xbb, 0x44, 0xb5, 0xed, 0x16, 0x9d, 0x57, 0x2b, 0x76, 0x56, 0x57, 0x54, 0x8d, 0xd7, + /*a770:*/ 0xa1, 0x6c, 0xd8, 0x0f, 0xb5, 0x13, 0xe0, 0x56, 0xb6, 0xea, 0xaf, 0x60, 0x13, 0xd1, 0xf8, 0xbc, + /*a780:*/ 0x58, 0xa8, 0x52, 0x5e, 0x42, 0x1b, 0x70, 0x7d, 0x63, 0x7d, 0x8b, 0x69, 0x82, 0xc3, 0xab, 0x38, + /*a790:*/ 0x64, 0x82, 0xef, 0x3f, 0xa9, 0xd9, 0x51, 0x5c, 0x4b, 0x88, 0x35, 0x17, 0xc4, 0xd2, 0x2d, 0xa5, + /*a7a0:*/ 0x46, 0xb0, 0x11, 0xcf, 0x6d, 0x94, 0xa3, 0x93, 0x93, 0xb7, 0xa7, 0xf8, 0x09, 0x39, 0x03, 0x1c, + /*a7b0:*/ 0x15, 0xba, 0x34, 0x3e, 0xe0, 0x08, 0xda, 0x0a, 0x93, 0xa2, 0x35, 0x23, 0x9b, 0xa0, 0x49, 0x7e, + /*a7c0:*/ 0x58, 0xe4, 0x6d, 0xef, 0x21, 0xbd, 0xfb, 0x15, 0xe5, 0xb2, 0x26, 0xb9, 0xd9, 0xab, 0xef, 0x0e, + /*a7d0:*/ 0x12, 0xfc, 0x24, 0xd6, 0x5c, 0xfd, 0x0e, 0xf2, 0x00, 0x12, 0x0f, 0x22, 0x0c, 0x53, 0x54, 0xdd, + /*a7e0:*/ 0xe6, 0x04, 0x61, 0xcb, 0xf5, 0x4b, 0xd0, 0x91, 0x24, 0x7e, 0x91, 0x95, 0x07, 0x41, 0x4c, 0x32, + /*a7f0:*/ 0x64, 0x44, 0x4e, 0xdc, 0x0b, 0xf4, 0x8a, 0xb5, 0x75, 0xc8, 0x73, 0xee, 0xc3, 0x7d, 0xb0, 0xbf, + /*a800:*/ 0x63, 0x7d, 0x69, 0x96, 0x58, 0x9c, 0x10, 0xed, 0xe6, 0x5a, 0x55, 0xf7, 0x20, 0xda, 0xbd, 0x1b, + /*a810:*/ 0xba, 0x0a, 0xab, 0x36, 0x1f, 0xe3, 0xe0, 0x3c, 0x20, 0xae, 0x90, 0x60, 0xcd, 0xe0, 0x29, 0xe7, + /*a820:*/ 0x41, 0x27, 0x68, 0x1c, 0xf3, 0xcc, 0xb7, 0x79, 0xfb, 0x06, 0x48, 0x89, 0x61, 0xb2, 0x02, 0xb2, + /*a830:*/ 0xcf, 0x61, 0xe9, 0x77, 0x9f, 0x8d, 0x7e, 0x19, 0x2b, 0xd0, 0x2d, 0xf9, 0x61, 0x29, 0xc9, 0x46, + /*a840:*/ 0x84, 0xd1, 0x54, 0x4d, 0x83, 0xb0, 0x8c, 0x33, 0x4f, 0xa5, 0xeb, 0x98, 0xa0, 0x41, 0x5b, 0xa0, + /*a850:*/ 0x04, 0x09, 0x37, 0xc2, 0xa7, 0x5f, 0xdf, 0x63, 0xa8, 0x82, 0x78, 0xf9, 0xea, 0xfc, 0xde, 0xa5, + /*a860:*/ 0x5c, 0xe4, 0xd9, 0x80, 0x54, 0x78, 0x34, 0x77, 0x59, 0x2b, 0xbb, 0x38, 0x6e, 0xdd, 0x57, 0x9e, + /*a870:*/ 0xd7, 0xe3, 0x9c, 0x67, 0x2e, 0xc1, 0xa1, 0x9d, 0xf2, 0xa1, 0xb8, 0x99, 0xc0, 0x89, 0x83, 0x2c, + /*a880:*/ 0x03, 0xfc, 0xc0, 0x03, 0x77, 0x06, 0xc9, 0xbe, 0x8a, 0xe6, 0xaa, 0x42, 0x95, 0x43, 0x57, 0x30, + /*a890:*/ 0xdf, 0xc0, 0x71, 0x9b, 0x42, 0x39, 0x67, 0x35, 0xc1, 0xa8, 0xb0, 0x16, 0xe3, 0xc3, 0xa8, 0x20, + /*a8a0:*/ 0xd6, 0x11, 0xed, 0x12, 0x42, 0x62, 0x2e, 0x2b, 0x17, 0x43, 0x3a, 0x27, 0x0d, 0x83, 0xd6, 0x87, + /*a8b0:*/ 0x70, 0x0e, 0x84, 0x01, 0xfd, 0xa1, 0xd9, 0x2b, 0x5c, 0xdb, 0xf9, 0xbe, 0x27, 0xd3, 0x05, 0x7a, + /*a8c0:*/ 0x89, 0x77, 0x23, 0x7a, 0x0c, 0x4c, 0x3f, 0xb3, 0xbc, 0xc1, 0x80, 0xde, 0x88, 0x68, 0x6c, 0xbe, + /*a8d0:*/ 0x6b, 0xa0, 0xf4, 0xfe, 0x9d, 0xde, 0xa4, 0x8d, 0xc8, 0xfe, 0x8f, 0x0d, 0xf8, 0xfb, 0xe3, 0x33, + /*a8e0:*/ 0xd9, 0x9f, 0x38, 0x44, 0xf0, 0x1e, 0x13, 0x87, 0x4a, 0x35, 0x79, 0xbd, 0x56, 0x77, 0x4d, 0x2e, + /*a8f0:*/ 0xed, 0x44, 0x05, 0x70, 0xcb, 0xee, 0x56, 0xb8, 0x40, 0xc4, 0x29, 0x1a, 0xaf, 0x14, 0xd3, 0xd3, + /*a900:*/ 0x18, 0x34, 0x77, 0x79, 0x7c, 0x69, 0x36, 0xbc, 0x18, 0xea, 0xc8, 0x5e, 0xdf, 0x17, 0xfe, 0xf0, + /*a910:*/ 0x22, 0xd7, 0x5c, 0xa7, 0x24, 0xd8, 0xe9, 0x85, 0x2f, 0x08, 0xef, 0x68, 0x9a, 0xe9, 0x81, 0x80, + /*a920:*/ 0xe2, 0xb2, 0x5d, 0x11, 0x30, 0xf0, 0xa9, 0xab, 0x6b, 0xee, 0x2c, 0x62, 0x0a, 0xde, 0xec, 0x4e, + /*a930:*/ 0xd0, 0x25, 0xbb, 0xd5, 0xc5, 0x2d, 0xa8, 0xea, 0x1e, 0x7b, 0xfc, 0x84, 0x4b, 0x38, 0xb8, 0x90, + /*a940:*/ 0x8d, 0x4b, 0x3d, 0x7c, 0xa6, 0x8d, 0x1a, 0x73, 0x0f, 0x72, 0xb9, 0x2a, 0xc2, 0x31, 0x3c, 0xa5, + /*a950:*/ 0x18, 0xfe, 0x02, 0xb6, 0x2f, 0xfa, 0x3c, 0x23, 0x99, 0x73, 0x93, 0xcf, 0x14, 0x06, 0xb8, 0x76, + /*a960:*/ 0xf5, 0x66, 0xb2, 0xb8, 0x04, 0xd0, 0x10, 0x13, 0x38, 0x41, 0x17, 0x59, 0x20, 0x63, 0x09, 0xee, + /*a970:*/ 0x1b, 0xae, 0xc0, 0xea, 0xf3, 0xbf, 0xca, 0x9f, 0x25, 0x94, 0x0c, 0x96, 0x3f, 0x2d, 0x99, 0xc3, + /*a980:*/ 0x42, 0xe4, 0xe0, 0x92, 0x9c, 0x13, 0x0d, 0xb6, 0x87, 0xd6, 0x42, 0xbd, 0x35, 0xb2, 0x72, 0x57, + /*a990:*/ 0xb4, 0x52, 0x16, 0xa3, 0x86, 0x82, 0x21, 0x67, 0x5f, 0xff, 0x3d, 0x58, 0xcd, 0xb1, 0x9e, 0xbd, + /*a9a0:*/ 0x15, 0x87, 0x1e, 0x2f, 0x8d, 0x98, 0xcf, 0x4b, 0x93, 0x7b, 0x3f, 0xdd, 0x7c, 0x2b, 0xc5, 0x57, + /*a9b0:*/ 0x9b, 0x98, 0xfb, 0xc7, 0x53, 0xc3, 0x1f, 0xae, 0x9d, 0xd6, 0xed, 0xc8, 0xd0, 0xb6, 0x34, 0x21, + /*a9c0:*/ 0x94, 0xf3, 0x95, 0xfb, 0xf0, 0x80, 0x24, 0x98, 0x0f, 0xd1, 0xd3, 0xe0, 0xfd, 0xc5, 0xcd, 0xa6, + /*a9d0:*/ 0xda, 0xfb, 0x58, 0xb0, 0x1b, 0x9a, 0x24, 0x59, 0xaf, 0x55, 0xa6, 0x82, 0xab, 0x21, 0x40, 0x4a, + /*a9e0:*/ 0xaa, 0x4e, 0xcd, 0x23, 0x7d, 0x2b, 0xa3, 0x01, 0x18, 0x63, 0xfd, 0x2f, 0x12, 0xd3, 0x2b, 0x25, + /*a9f0:*/ 0xbd, 0xb0, 0x10, 0x59, 0x7c, 0x85, 0x5d, 0xdb, 0x28, 0x34, 0xd1, 0x1d, 0x9d, 0x50, 0x78, 0xef, + /*aa00:*/ 0x84, 0x97, 0x1a, 0x49, 0x1a, 0x8b, 0xd3, 0x88, 0xbe, 0x67, 0xac, 0x4a, 0x1f, 0x1b, 0x15, 0x21, + /*aa10:*/ 0x61, 0x85, 0xf3, 0x74, 0x48, 0x20, 0xe1, 0x55, 0x16, 0x2a, 0xf3, 0xdd, 0x5c, 0x9e, 0xc9, 0x13, + /*aa20:*/ 0x55, 0x70, 0xf7, 0xc1, 0x07, 0xcb, 0xa2, 0xa5, 0x7d, 0x7d, 0xcb, 0xbb, 0x56, 0x07, 0x7a, 0x5a, + /*aa30:*/ 0xa4, 0xf7, 0x1b, 0x28, 0x0a, 0x89, 0xef, 0x5a, 0x28, 0x01, 0xe0, 0xbb, 0x67, 0x9d, 0xab, 0x2f, + /*aa40:*/ 0xb8, 0x71, 0x48, 0x6c, 0x6e, 0x98, 0xc5, 0x7d, 0x81, 0xcd, 0xba, 0xc2, 0x70, 0x63, 0x9e, 0x87, + /*aa50:*/ 0x14, 0x54, 0xbb, 0xbb, 0xd6, 0x7b, 0xb1, 0xaa, 0xae, 0x22, 0xba, 0x87, 0x80, 0x59, 0x6f, 0x23, + /*aa60:*/ 0x06, 0x5c, 0x6c, 0x1d, 0x34, 0x70, 0xce, 0xfd, 0x37, 0x73, 0xff, 0x85, 0x92, 0xae, 0x13, 0xb7, + /*aa70:*/ 0x67, 0x5d, 0x32, 0xff, 0x39, 0x8e, 0x52, 0xaa, 0x3c, 0x99, 0xa7, 0xe9, 0x27, 0x4e, 0xbb, 0x58, + /*aa80:*/ 0x78, 0xa2, 0x85, 0x36, 0xad, 0xa5, 0xbe, 0xa9, 0x78, 0xc4, 0xae, 0x78, 0xef, 0xea, 0x18, 0x24, + /*aa90:*/ 0x50, 0x4a, 0x56, 0x85, 0x6c, 0xdc, 0x69, 0x14, 0xe2, 0xe0, 0xb3, 0x8d, 0x2e, 0xdf, 0x62, 0x47, + /*aaa0:*/ 0xcf, 0xf2, 0xee, 0xe2, 0x0b, 0xab, 0x08, 0xf0, 0x89, 0x29, 0x91, 0x12, 0xfc, 0x9f, 0x4c, 0xb9, + /*aab0:*/ 0x0c, 0x92, 0xd3, 0x0d, 0x41, 0x72, 0xce, 0x67, 0xbf, 0x72, 0x4a, 0xd5, 0x10, 0x3b, 0x7b, 0xa0, + /*aac0:*/ 0x6e, 0xf4, 0x51, 0x63, 0x47, 0x74, 0xd9, 0x5e, 0x0b, 0xb3, 0x3e, 0x56, 0xb9, 0x90, 0x30, 0xd8, + /*aad0:*/ 0xa6, 0x54, 0xf3, 0x87, 0x87, 0xf2, 0xca, 0xa8, 0x81, 0x72, 0xea, 0x07, 0x34, 0x2f, 0xb2, 0x11, + /*aae0:*/ 0x23, 0x49, 0xf5, 0x9d, 0x6c, 0x52, 0xd6, 0x41, 0x71, 0xe4, 0x2c, 0xc1, 0x4c, 0x30, 0x9e, 0xf3, + /*aaf0:*/ 0xb2, 0x21, 0x21, 0x3e, 0x1f, 0x12, 0x7b, 0x6b, 0xd1, 0xc7, 0xe8, 0xd0, 0x74, 0x1c, 0xf2, 0x46, + /*ab00:*/ 0xcc, 0x12, 0x89, 0x97, 0x9e, 0x92, 0x7f, 0x89, 0xdb, 0x82, 0x1c, 0xd4, 0xe8, 0xcd, 0x36, 0x76, + /*ab10:*/ 0x6c, 0x09, 0xe3, 0x15, 0x2e, 0x6a, 0xbf, 0x46, 0x28, 0x95, 0x2f, 0x01, 0x92, 0x00, 0x68, 0x6e, + /*ab20:*/ 0x5d, 0xbf, 0x3d, 0xc1, 0x29, 0xbf, 0x09, 0x4a, 0x08, 0x74, 0x79, 0x48, 0xb4, 0x5e, 0x5f, 0x52, + /*ab30:*/ 0x55, 0x0c, 0x41, 0x69, 0x3d, 0x48, 0xf6, 0xf0, 0x9b, 0x63, 0x1f, 0xaa, 0x6e, 0xfd, 0x7f, 0x0f, + /*ab40:*/ 0x83, 0x29, 0x68, 0xd7, 0xb5, 0xa6, 0x12, 0x05, 0x8f, 0x43, 0x07, 0xbc, 0x25, 0xd2, 0xec, 0xb3, + /*ab50:*/ 0xab, 0xc9, 0xf3, 0x1f, 0xbb, 0xc2, 0xe3, 0x78, 0x4e, 0xb6, 0x35, 0xfb, 0x94, 0xde, 0xf0, 0xd9, + /*ab60:*/ 0xe6, 0xec, 0xf8, 0xae, 0xf8, 0x46, 0x1a, 0x83, 0xd3, 0xdb, 0xfe, 0xbc, 0x80, 0x65, 0x4d, 0xc7, + /*ab70:*/ 0x83, 0x75, 0xb2, 0xdd, 0x77, 0xc3, 0x46, 0xd4, 0x32, 0xa4, 0x54, 0xef, 0x9b, 0xa3, 0x76, 0xb7, + /*ab80:*/ 0x9e, 0x60, 0x14, 0x6d, 0xd7, 0xb1, 0x47, 0x82, 0xef, 0x2c, 0xcf, 0x88, 0x17, 0x5c, 0xa1, 0xe6, + /*ab90:*/ 0x60, 0x22, 0xdb, 0x85, 0x18, 0x11, 0x08, 0xd0, 0x59, 0xc6, 0xe9, 0x19, 0x55, 0x3c, 0x81, 0xf4, + /*aba0:*/ 0x6d, 0xec, 0x1b, 0x88, 0xd6, 0xb6, 0x7a, 0x62, 0x5d, 0x7a, 0xc4, 0xf1, 0xf0, 0xa0, 0x09, 0x1a, + /*abb0:*/ 0xbc, 0xdf, 0x3c, 0xb0, 0x4f, 0x2b, 0xe1, 0x2e, 0x44, 0x3d, 0x9d, 0x0a, 0xb1, 0x1d, 0x66, 0x62, + /*abc0:*/ 0xbe, 0xbf, 0xe2, 0x2b, 0x66, 0xae, 0xa1, 0x35, 0x04, 0x63, 0x77, 0x97, 0xc9, 0x0b, 0xab, 0xeb, + /*abd0:*/ 0xf0, 0x61, 0xf2, 0x1f, 0xdb, 0x60, 0x51, 0x6f, 0xda, 0xd6, 0x19, 0xdf, 0x5b, 0xad, 0x6e, 0x02, + /*abe0:*/ 0x9c, 0xc8, 0xce, 0x0c, 0xa7, 0xcb, 0x93, 0x3d, 0x3c, 0xff, 0x9e, 0x88, 0xfa, 0xf9, 0x9c, 0x73, + /*abf0:*/ 0x9f, 0x3e, 0xbb, 0xa9, 0x40, 0x2c, 0x88, 0x4f, 0x19, 0x59, 0x1a, 0x42, 0x13, 0xca, 0x47, 0xb8, + /*ac00:*/ 0x46, 0x77, 0x49, 0xa0, 0xb7, 0xec, 0x73, 0x72, 0xb1, 0x9b, 0x61, 0x07, 0x8a, 0x61, 0x08, 0x1a, + /*ac10:*/ 0x4a, 0x59, 0x63, 0x60, 0x2a, 0x0f, 0x5a, 0xdf, 0x3c, 0x23, 0x83, 0x47, 0x32, 0x37, 0xde, 0x8a, + /*ac20:*/ 0x30, 0x10, 0x24, 0x3f, 0x31, 0x93, 0xcb, 0xca, 0xfa, 0x5c, 0xf0, 0xf9, 0x28, 0x50, 0x40, 0x2a, + /*ac30:*/ 0x62, 0xfd, 0x0b, 0x22, 0x52, 0x0b, 0xa4, 0x4d, 0xc4, 0xbc, 0x88, 0x32, 0x0f, 0x85, 0xab, 0xc9, + /*ac40:*/ 0x5c, 0x55, 0xc5, 0x63, 0xbb, 0x2f, 0xfb, 0x41, 0xf6, 0x52, 0xd7, 0x67, 0x35, 0x96, 0x0e, 0xf6, + /*ac50:*/ 0x46, 0x10, 0xaa, 0x92, 0x0a, 0xdf, 0xdf, 0xcb, 0x9b, 0xa7, 0xaa, 0x71, 0xe1, 0xd8, 0xfe, 0x03, + /*ac60:*/ 0xef, 0x25, 0x22, 0x72, 0x86, 0x42, 0x72, 0x00, 0xfc, 0xd2, 0x13, 0xbe, 0x03, 0x1c, 0x4c, 0x4d, + /*ac70:*/ 0x48, 0xb3, 0xaf, 0x7b, 0xb4, 0xa0, 0xe7, 0x0f, 0xc0, 0x40, 0x2b, 0x99, 0xfe, 0x6a, 0x8d, 0x82, + /*ac80:*/ 0x72, 0xef, 0x2b, 0x76, 0xdf, 0x82, 0x74, 0xd2, 0x17, 0xd0, 0xbc, 0xcf, 0x54, 0xb3, 0x6f, 0x34, + /*ac90:*/ 0xd7, 0x86, 0x90, 0x63, 0x1f, 0xdc, 0x54, 0xa6, 0xa7, 0x77, 0x4d, 0x84, 0x0d, 0x5a, 0x02, 0xc1, + /*aca0:*/ 0x3c, 0xd2, 0xc0, 0xc6, 0x1d, 0xa5, 0x60, 0x9b, 0x22, 0x08, 0x44, 0x01, 0xb8, 0x1a, 0xe4, 0x59, + /*acb0:*/ 0x63, 0x2b, 0x48, 0xed, 0xf1, 0x1f, 0x86, 0x18, 0x9c, 0x27, 0xe3, 0x11, 0xb8, 0x03, 0x1a, 0x28, + /*acc0:*/ 0xbb, 0x16, 0x90, 0x80, 0x8e, 0xc9, 0xd7, 0x57, 0x33, 0x82, 0x06, 0x44, 0x2b, 0x3f, 0xee, 0xbc, + /*acd0:*/ 0x4a, 0x19, 0x73, 0x96, 0x09, 0xb9, 0x26, 0x08, 0x57, 0xe9, 0x66, 0x86, 0x33, 0xfe, 0xf0, 0xad, + /*ace0:*/ 0xeb, 0x5f, 0x46, 0xd3, 0x8c, 0x6e, 0xa9, 0xeb, 0x0f, 0x58, 0x27, 0x1d, 0x37, 0x42, 0xd9, 0xbb, + /*acf0:*/ 0x65, 0x6d, 0xf0, 0x75, 0x89, 0xfb, 0x5e, 0x4d, 0xd7, 0x6d, 0x09, 0xb4, 0x42, 0x7e, 0x7c, 0x94, + /*ad00:*/ 0xa5, 0x34, 0x36, 0x13, 0x88, 0x1a, 0x12, 0x2b, 0x02, 0xd4, 0x38, 0x00, 0x25, 0xc4, 0x95, 0xe6, + /*ad10:*/ 0x3c, 0x9b, 0xbe, 0x55, 0x5d, 0x58, 0x6c, 0xef, 0x36, 0xbf, 0xeb, 0x90, 0x74, 0x93, 0x14, 0x07, + /*ad20:*/ 0xad, 0xfa, 0x42, 0x13, 0x7b, 0x13, 0x17, 0x1a, 0x9b, 0x0f, 0x36, 0xee, 0x61, 0x76, 0xe2, 0x85, + /*ad30:*/ 0x99, 0x42, 0x29, 0x50, 0x20, 0x7e, 0x3f, 0x09, 0xaf, 0x3a, 0xe5, 0x3f, 0x53, 0xf6, 0x76, 0x79, + /*ad40:*/ 0xfb, 0x8c, 0x73, 0xc9, 0x83, 0xf6, 0x1c, 0x21, 0xec, 0x05, 0x07, 0x10, 0xbc, 0x16, 0x8e, 0x65, + /*ad50:*/ 0x7f, 0xfe, 0x4a, 0x3e, 0xbe, 0xf7, 0x74, 0x47, 0x51, 0x89, 0x5f, 0xad, 0xc1, 0x9e, 0xa1, 0x6a, + /*ad60:*/ 0x69, 0x33, 0x5c, 0x10, 0x48, 0x10, 0xbb, 0x49, 0x98, 0x63, 0x04, 0xe4, 0x19, 0xfa, 0x45, 0x93, + /*ad70:*/ 0x09, 0x0d, 0xda, 0x37, 0x2e, 0xff, 0x4f, 0xaf, 0xdc, 0x3d, 0x71, 0x3e, 0x0c, 0x97, 0x3b, 0x8f, + /*ad80:*/ 0x80, 0xfc, 0x34, 0x24, 0x4e, 0x37, 0xaa, 0x11, 0xd0, 0x4a, 0x57, 0x9b, 0xa6, 0x6c, 0x4d, 0xc1, + /*ad90:*/ 0x65, 0x07, 0x6d, 0x1c, 0x9e, 0x06, 0xd9, 0xe3, 0x1a, 0x3f, 0xe0, 0xf1, 0x36, 0x9e, 0x74, 0x65, + /*ada0:*/ 0x5c, 0x75, 0xd2, 0xf5, 0xd9, 0xbc, 0x3c, 0x4f, 0x24, 0x4e, 0x04, 0x62, 0x04, 0x97, 0x3e, 0x6e, + /*adb0:*/ 0xc4, 0x01, 0x4c, 0x88, 0xfb, 0xb0, 0xdf, 0x7d, 0x45, 0xcd, 0xa0, 0xca, 0x91, 0x96, 0x11, 0x6e, + /*adc0:*/ 0x56, 0x5d, 0xe5, 0xd1, 0xf3, 0x2c, 0x4a, 0xf6, 0x07, 0xb3, 0x6d, 0xb6, 0x6b, 0x98, 0x7b, 0x9b, + /*add0:*/ 0x80, 0x7a, 0x02, 0x83, 0xc7, 0xef, 0x0e, 0x00, 0x81, 0xfc, 0x95, 0x64, 0xe4, 0xc0, 0xb3, 0xc1, + /*ade0:*/ 0x2f, 0xfe, 0x4a, 0x97, 0xa1, 0x1c, 0x68, 0xde, 0xee, 0xc6, 0xcc, 0x23, 0x33, 0x5c, 0x2b, 0xcd, + /*adf0:*/ 0xa1, 0x4b, 0xff, 0x97, 0x08, 0x01, 0x51, 0x5a, 0xc1, 0x69, 0x6a, 0xbc, 0xac, 0x3f, 0xc4, 0xf3, + /*ae00:*/ 0x5d, 0x75, 0x53, 0x23, 0x8d, 0xb5, 0x43, 0x8d, 0x2f, 0x41, 0x05, 0xd2, 0x7f, 0x88, 0xdd, 0x9e, + /*ae10:*/ 0xb8, 0x5b, 0x13, 0x34, 0x1a, 0x74, 0x5c, 0x6e, 0x81, 0xd3, 0x65, 0x6e, 0x02, 0xcf, 0xf1, 0xf2, + /*ae20:*/ 0xf2, 0x87, 0xca, 0xab, 0x11, 0x6e, 0xea, 0xf6, 0xa4, 0xa8, 0x82, 0xa8, 0x00, 0xbd, 0xc7, 0x80, + /*ae30:*/ 0x4f, 0xeb, 0x73, 0xbc, 0x9f, 0xbb, 0xc4, 0x17, 0x58, 0x68, 0x1f, 0x36, 0xfb, 0x3c, 0xda, 0xf4, + /*ae40:*/ 0xf4, 0xea, 0x6a, 0xce, 0x79, 0xe9, 0xb1, 0x83, 0x6d, 0x27, 0x22, 0xdc, 0x01, 0xf8, 0xec, 0x58, + /*ae50:*/ 0x6b, 0x58, 0x03, 0x24, 0x50, 0xeb, 0xed, 0xa9, 0x1c, 0x01, 0x1a, 0x7c, 0x50, 0xe3, 0x5e, 0x78, + /*ae60:*/ 0x90, 0xe8, 0x50, 0xfd, 0xe8, 0x34, 0xfc, 0x7c, 0x3e, 0x7b, 0x61, 0xd5, 0x93, 0x65, 0x47, 0xed, + /*ae70:*/ 0xfe, 0x63, 0xc1, 0xd1, 0x31, 0x86, 0x78, 0xa1, 0x68, 0xee, 0xfa, 0x4f, 0x5c, 0xf2, 0x45, 0x90, + /*ae80:*/ 0x7c, 0xb9, 0x6d, 0x98, 0x89, 0x3f, 0x3e, 0xc8, 0x0d, 0x02, 0xa2, 0x2e, 0xfd, 0x96, 0x3e, 0x16, + /*ae90:*/ 0xd6, 0xc8, 0x46, 0x89, 0xf5, 0x82, 0x71, 0xe7, 0x93, 0xcb, 0x57, 0x14, 0xce, 0xef, 0x51, 0x53, + /*aea0:*/ 0xaa, 0x3d, 0xe7, 0xdc, 0xbf, 0x14, 0xc1, 0x14, 0xdc, 0x24, 0xd1, 0xc9, 0x61, 0xb3, 0x0a, 0x9d, + /*aeb0:*/ 0xca, 0xcb, 0x00, 0x49, 0xc0, 0x9a, 0xbe, 0x59, 0x10, 0x9a, 0x0a, 0x75, 0x0a, 0x7a, 0x2d, 0xe2, + /*aec0:*/ 0x87, 0xe5, 0xb1, 0x32, 0x55, 0x8d, 0xd2, 0x3a, 0x0b, 0x3b, 0xd9, 0x16, 0xb1, 0x78, 0xa8, 0x83, + /*aed0:*/ 0x13, 0x30, 0x2f, 0xf8, 0xa0, 0x91, 0x55, 0xc5, 0x0b, 0x5e, 0x4a, 0x90, 0x1c, 0x10, 0x7c, 0x5a, + /*aee0:*/ 0x8e, 0x4b, 0x4b, 0xea, 0x12, 0xe2, 0x51, 0xfa, 0xc4, 0x5a, 0x52, 0x33, 0xff, 0xf9, 0x18, 0xc1, + /*aef0:*/ 0x5b, 0xa1, 0x29, 0xeb, 0x3f, 0xab, 0xf8, 0x1c, 0xa2, 0x7e, 0x97, 0xfd, 0x59, 0x04, 0x1a, 0x0c, + /*af00:*/ 0x60, 0x5e, 0x3d, 0x23, 0x5e, 0x0b, 0x8e, 0x2b, 0xf5, 0x57, 0xe7, 0x06, 0x71, 0x11, 0x68, 0xb6, + /*af10:*/ 0x5a, 0xc4, 0x49, 0xfa, 0x24, 0x17, 0xe7, 0xf7, 0xd2, 0xca, 0xc8, 0xbf, 0x5c, 0x5a, 0x98, 0xe5, + /*af20:*/ 0xb8, 0x72, 0x85, 0xb0, 0x8c, 0x4c, 0x49, 0xbc, 0x5f, 0xd5, 0xb3, 0x36, 0xa0, 0xc9, 0x59, 0xbc, + /*af30:*/ 0xc8, 0x5e, 0x00, 0xa4, 0x09, 0x95, 0x48, 0x31, 0x96, 0x76, 0x80, 0xee, 0x49, 0x9a, 0xac, 0xe4, + /*af40:*/ 0xbe, 0x94, 0xa5, 0xc6, 0x6c, 0xd0, 0xce, 0xcf, 0xa8, 0xdf, 0x61, 0xbb, 0xe5, 0x7a, 0x59, 0xe3, + /*af50:*/ 0x7d, 0xad, 0x3b, 0xa9, 0xcc, 0x26, 0xe7, 0x4e, 0x29, 0x5b, 0xed, 0x59, 0x43, 0x70, 0xdd, 0xb6, + /*af60:*/ 0xbf, 0x6c, 0xa6, 0x12, 0x87, 0xd0, 0xa2, 0x33, 0xf2, 0x9a, 0x8a, 0x39, 0xca, 0x63, 0x1e, 0x6a, + /*af70:*/ 0xf4, 0xf7, 0x4a, 0x97, 0xc6, 0x62, 0x85, 0xb1, 0x98, 0xf4, 0xbd, 0x2d, 0x2c, 0xf7, 0xe8, 0x47, + /*af80:*/ 0x73, 0x61, 0xda, 0x0b, 0xca, 0xc7, 0xa8, 0x37, 0x72, 0xdd, 0x08, 0xed, 0xfe, 0xb2, 0xc2, 0xa7, + /*af90:*/ 0x1f, 0x30, 0xce, 0x3a, 0x2e, 0xd8, 0x73, 0x77, 0xbf, 0xe1, 0x53, 0xab, 0xcf, 0xbf, 0x1d, 0xa2, + /*afa0:*/ 0x7b, 0xe6, 0x93, 0xa8, 0x0b, 0x1d, 0x7b, 0xdb, 0xaa, 0x83, 0x91, 0x76, 0x0b, 0xda, 0x09, 0x17, + /*afb0:*/ 0xe6, 0x8a, 0x25, 0x89, 0x1e, 0x9e, 0xe3, 0xec, 0xed, 0x9e, 0xfd, 0x5e, 0xb1, 0x47, 0x78, 0xd9, + /*afc0:*/ 0x1e, 0x2a, 0xfe, 0x92, 0x9b, 0x73, 0x70, 0x16, 0x2d, 0xdf, 0x76, 0x18, 0x35, 0x84, 0x40, 0xed, + /*afd0:*/ 0x42, 0xb5, 0xa6, 0x89, 0x52, 0x75, 0xf0, 0xbb, 0x20, 0xea, 0xea, 0xec, 0xa2, 0x40, 0xc8, 0x32, + /*afe0:*/ 0x82, 0xfb, 0x84, 0x0b, 0x99, 0x22, 0x39, 0x22, 0x0a, 0xde, 0x4f, 0x92, 0x96, 0xd1, 0xa5, 0xf1, + /*aff0:*/ 0x6b, 0xf4, 0x01, 0x04, 0x3d, 0x65, 0x70, 0x82, 0xe2, 0x2e, 0x76, 0xfc, 0x25, 0x81, 0x24, 0x59, + /*b000:*/ 0x7c, 0x77, 0x24, 0xab, 0x00, 0x06, 0x74, 0x9e, 0xa7, 0x6c, 0xaa, 0x04, 0x30, 0xed, 0x9d, 0xb3, + /*b010:*/ 0x56, 0xfc, 0x85, 0x8d, 0xa2, 0x90, 0xc3, 0xcd, 0x08, 0xd2, 0x71, 0xd7, 0xf2, 0x2e, 0x28, 0xfb, + /*b020:*/ 0x13, 0x28, 0xfc, 0x43, 0x40, 0x56, 0x80, 0xc4, 0x56, 0xd1, 0x39, 0x96, 0x1f, 0xdc, 0xa8, 0x70, + /*b030:*/ 0x32, 0x84, 0x40, 0xa1, 0x98, 0xb6, 0x1e, 0x7f, 0xbc, 0x05, 0xb8, 0x2c, 0x95, 0x26, 0xfd, 0x41, + /*b040:*/ 0x20, 0xbb, 0x88, 0x9f, 0x26, 0xf6, 0x4e, 0x99, 0x0e, 0x9c, 0xd9, 0xac, 0xc9, 0xcf, 0x71, 0x31, + /*b050:*/ 0xab, 0x6e, 0x05, 0xfd, 0x20, 0x69, 0x50, 0x93, 0x54, 0xe5, 0xc4, 0x0b, 0xc6, 0xa4, 0xd4, 0x00, + /*b060:*/ 0xcb, 0x58, 0x27, 0x33, 0x07, 0x01, 0xd6, 0xce, 0x25, 0xdf, 0xf9, 0x36, 0x54, 0x94, 0xf1, 0x40, + /*b070:*/ 0x61, 0x69, 0x12, 0x79, 0x5c, 0xb0, 0xf1, 0xba, 0xd2, 0x01, 0x9a, 0xd7, 0x96, 0xbe, 0x34, 0x95, + /*b080:*/ 0x06, 0xe7, 0x05, 0xc3, 0x13, 0x58, 0x4e, 0x85, 0xb6, 0xdb, 0x72, 0xba, 0x5e, 0x15, 0xc9, 0x0a, + /*b090:*/ 0x62, 0x60, 0x53, 0x3f, 0xad, 0x29, 0x3f, 0xe3, 0xe1, 0xbb, 0x23, 0xcc, 0x13, 0xb9, 0xbd, 0x85, + /*b0a0:*/ 0x5d, 0x84, 0x0b, 0x5f, 0x7c, 0x4d, 0x2e, 0x64, 0x41, 0x06, 0x39, 0x71, 0x2b, 0x30, 0x14, 0x59, + /*b0b0:*/ 0xfe, 0x18, 0x80, 0x37, 0x17, 0x9e, 0x40, 0xa8, 0x55, 0xf2, 0xf6, 0xcc, 0x4c, 0xad, 0x10, 0x88, + /*b0c0:*/ 0x70, 0x6d, 0xcc, 0x69, 0xc9, 0xfd, 0x11, 0xa3, 0xba, 0xd0, 0x6a, 0xe0, 0x65, 0xd1, 0xb8, 0x38, + /*b0d0:*/ 0x55, 0xec, 0x1a, 0x81, 0xd0, 0x51, 0x33, 0x31, 0x3b, 0x5a, 0xc9, 0x26, 0xc6, 0xf2, 0x78, 0x2d, + /*b0e0:*/ 0x8e, 0x4e, 0x22, 0x8b, 0x0d, 0x74, 0x4d, 0x36, 0x18, 0x45, 0xdc, 0x41, 0x44, 0x35, 0x6a, 0x3b, + /*b0f0:*/ 0x66, 0x2c, 0xd4, 0x61, 0x92, 0xb8, 0x48, 0xab, 0xa2, 0xb6, 0x09, 0x7f, 0xa7, 0x91, 0xe9, 0x97, + /*b100:*/ 0x53, 0x59, 0x04, 0x03, 0x00, 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x88, 0x00, 0x01, 0x01, 0xff, 0x0a, + /*b110:*/ 0x1f, 0x03, 0xff, 0x04, 0x1e, 0x06, 0x2d, 0x5c, 0x0f, 0x8d, 0x03, 0x01, 0x34, 0xfe, 0x33, 0xff, + /*b120:*/ 0x78, 0x43, 0xfd, 0x43, 0x50, 0xc3, 0x38, 0xc7, 0x00, 0x18, 0x20, 0x20, 0x20, 0x20, 0x14, 0x02, + /*b130:*/ 0x0c, 0x32, 0xe3, 0xbc, 0x00, 0x00, 0x05, 0x28, 0x0a, 0x2d, 0x00, 0x28, 0x0a, 0x32, 0x00, 0xc4, + /*b140:*/ 0x09, 0x3c, 0x00, 0xf0, 0x0a, 0x50, 0x00, 0x1e, 0x1e, 0x8c, 0x00, 0x96, 0x00, 0x14, 0x0a, 0x04, + /*b150:*/ 0x29, 0x1a, 0x64, 0x07, 0x66, 0x64, 0xc0, 0x20, 0x02, 0xaf, 0x00, 0x03, 0x0e, 0x1f, 0x08, 0x2a, + /*b160:*/ 0x00, 0x20, 0x04, 0x1b, 0x00, 0x80, 0x14, 0xc0, 0xc8, 0xc8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0x38, + /*b170:*/ 0x37, 0x35, 0x34, 0x32, 0x31, 0x2f, 0x2d, 0x01, 0x04, 0x07, 0x09, 0x0b, 0x0d, 0x0f, 0x13, 0x00, + /*b180:*/ 0x00, 0x00, 0x40, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x20, 0x20, 0x20, 0x20, + /*b190:*/ 0x20, 0x20, 0x20, 0x10, 0x5a, 0x5e, 0x61, 0x64, 0x67, 0x6a, 0x6d, 0x39, 0x00, 0x0a, 0x00, 0x10, + /*b1a0:*/ 0x27, 0x66, 0x12, 0xd4, 0x10, 0xff, 0x1a, 0x00, 0x28, 0x28, 0x1c, 0x26, 0x66, 0x66, 0x66, 0x66, + /*b1b0:*/ 0x66, 0x66, 0x66, 0xff, 0xc8, 0x11, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, + /*b1c0:*/ 0x04, 0x20, 0x40, 0x03, 0x00, 0x1f, 0x00, 0x1d, 0x2d, 0x1d, 0x2b, 0x1d, 0x28, 0x1d, 0x2c, 0x1d, + /*b1d0:*/ 0x20, 0xd9, 0x73, 0xca, 0x73, 0xd9, 0xcd, 0x0d, 0x04, 0x02, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + /*b1e0:*/ 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + /*b1f0:*/ 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, + /*b200:*/ 0x27, 0x29, 0x2a, 0x2d, 0x2b, 0x28, 0x2c, 0x20, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x14, + /*b210:*/ 0x12, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + /*b220:*/ 0x01, 0x00, 0x1d, 0x66, 0x66, 0x6d, 0x6d, 0x73, 0x73, 0x7a, 0x7a, 0x80, 0x80, 0x86, 0x86, 0x8d, + /*b230:*/ 0x8d, 0x93, 0x93, 0x9a, 0x9a, 0xa0, 0xa0, 0xa6, 0xa6, 0xad, 0xad, 0xb3, 0xb3, 0x80, 0x80, 0x80, + /*b240:*/ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + /*b250:*/ 0x80, 0x0a, 0x1c, 0x2b, 0x1e, 0x0a, 0x80, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b260:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b270:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b280:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b290:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xb8, 0x19, 0xcc, + /*b300:*/ 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b310:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b320:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b330:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b340:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b350:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b360:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b370:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b380:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b390:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b400:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b410:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b420:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b430:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b440:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + /*b450:*/ 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x08, 0x00, 0x19, 0x19, 0x00, 0x10, 0xe2, 0x04, 0xb6, 0x08, 0x1e, + /*b460:*/ 0x05, 0x28, 0xf5, 0x28, 0x1e, 0x05, 0x01, 0x30, 0x00, 0x30, 0x00, 0x00, 0x50, 0x00, 0x50, 0xf0, + /*b470:*/ 0xd2, 0xf0, 0xd2, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0xc0, 0x32, 0x70, 0x00, 0x00, + /*b480:*/ 0x00, 0x80, 0x04, 0x2e, 0x1b, 0x64, 0x07, 0x00, 0x00, 0x56, 0x35, 0x05, 0x10, 0x00, 0x00, 0x0b, + /*b490:*/ 0x20, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x37, 0x33, + /*b4a0:*/ 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x03, 0x0f, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf0, + /*b4b0:*/ 0x15, 0x1b, 0x2e, 0x49, 0x40, 0xff, 0x0b, 0x20, 0x0c, 0x18, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + /*b4c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b4d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x88, 0x55, + /*b4e0:*/ 0x15, 0x21, 0x11, 0x92, 0x87, 0x4f, 0x13, 0x01, 0x01, 0x89, 0x00, 0x4b, 0x00, 0x01, 0x34, 0x00, + /*b4f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b500:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b510:*/ 0x00, 0x02, 0x5e, 0x01, 0x03, 0x0e, 0x1f, 0x00, 0xde, 0x01, 0x19, 0x04, 0x1b, 0x00, 0x10, 0x0a, + /*b520:*/ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b530:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x05, 0x00, 0x00, + /*b540:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, + /*b550:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x28, 0x00, 0x77, 0x18, 0x80, 0x18, 0x80, 0x1a, + /*b560:*/ 0x01, 0x19, 0x3f, 0x4d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x10, 0x0a, 0x00, 0x00, + /*b570:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x04, 0x40, 0x40, 0x03, 0x00, 0x2e, 0x1b, + /*b580:*/ 0x44, 0x00, 0x19, 0x01, 0x00, 0xbe, 0x00, 0xde, 0x3f, 0xd0, 0x80, 0x08, 0x03, 0x00, 0x00, 0x00, + /*b590:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x7d, 0x10, 0x00, 0x01, 0x54, 0x00, + /*b5f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b600:*/ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x51, + /*b610:*/ 0x51, 0x51, 0x51, 0xcd, 0x0d, 0x04, 0x00, 0x00, 0x1c, 0x80, 0x00, 0x04, 0xff, 0x2e, 0x1b, 0x05, + /*b620:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b630:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b640:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b650:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b660:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b670:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b680:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b690:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6e0:*/ 0x00, 0x00, 0x00, 0x1d, 0x1a, 0x16, 0x00, 0x01, 0x55, 0x1b, 0x00, 0x01, 0x00, 0x01, 0x1a, 0x00, + /*b6f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b700:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b710:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b720:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x32, 0x00, 0x1e, 0x04, 0x80, 0xc0, 0x04, + /*b730:*/ 0x28, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b740:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b750:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b760:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b770:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b780:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b790:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x28, 0x00, 0x00, 0x51, 0x00, + /*b7f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b800:*/ 0xff}; +#else +const u8 rmi_fw_button[] = { + /*0000:*/ 0xaf, 0xee, 0x17, 0x5c, 0x00, 0x00, 0x00, 0x05, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, + /*0010:*/ 0x53, 0x37, 0x33, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0020:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0030:*/ 0x44, 0x53, 0x34, 0x20, 0x52, 0x33, 0x2e, 0x35, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0040:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0050:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0060:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0070:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0080:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0090:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00a0:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00b0:*/ 0x69, 0x96, 0x7e, 0xd0, 0x20, 0x5a, 0x00, 0x20, 0xc5, 0xc0, 0x2a, 0x79, 0xac, 0x74, 0x2e, 0x45, + /*00c0:*/ 0x57, 0x05, 0x48, 0x7c, 0xd7, 0x03, 0xb0, 0x50, 0xe0, 0x77, 0x3c, 0x8b, 0x79, 0xf6, 0x71, 0x75, + /*00d0:*/ 0xca, 0xec, 0xb0, 0x31, 0x53, 0xaa, 0x37, 0xe9, 0x19, 0x47, 0x46, 0x84, 0xba, 0x28, 0x18, 0xe9, + /*00e0:*/ 0x51, 0x89, 0xe7, 0xce, 0x3e, 0x64, 0x26, 0xa6, 0x25, 0x31, 0xc5, 0x0d, 0x9a, 0xa9, 0x93, 0xfa, + /*00f0:*/ 0x7c, 0x9a, 0x20, 0x17, 0x1a, 0x92, 0x35, 0xa6, 0x9a, 0x75, 0xa0, 0x23, 0x4f, 0xb1, 0xec, 0x1e, + /*0100:*/ 0x64, 0xce, 0x5c, 0x97, 0x6f, 0xf6, 0x36, 0x81, 0xf8, 0x90, 0x17, 0xb0, 0x0d, 0x0c, 0xd3, 0x50, + /*0110:*/ 0x2b, 0xb3, 0x37, 0x31, 0xe9, 0x03, 0x0c, 0x63, 0xf1, 0x9e, 0x52, 0x2d, 0xf5, 0xd3, 0x44, 0x87, + /*0120:*/ 0xa3, 0xef, 0xc0, 0x55, 0xf3, 0xca, 0x62, 0x4f, 0xc8, 0x13, 0xbd, 0x20, 0xe6, 0x3a, 0xac, 0xcd, + /*0130:*/ 0x2b, 0x4b, 0x2c, 0x18, 0x21, 0x16, 0xf3, 0xb6, 0xaa, 0x41, 0xe2, 0x66, 0xfc, 0x6f, 0x1f, 0xce, + /*0140:*/ 0x7f, 0x17, 0xdd, 0xfd, 0x49, 0xde, 0x8b, 0x2b, 0xec, 0xf9, 0xe4, 0xed, 0xaf, 0x8c, 0x26, 0xe0, + /*0150:*/ 0xb5, 0x30, 0xde, 0x4b, 0xb9, 0x9e, 0x4d, 0xfe, 0x43, 0x86, 0xce, 0x9e, 0x0b, 0x6f, 0xb9, 0xc8, + /*0160:*/ 0x1e, 0xcb, 0x83, 0xee, 0xdb, 0xf3, 0xcb, 0x5f, 0xa2, 0x9b, 0xba, 0x53, 0x3d, 0xde, 0x85, 0xce, + /*0170:*/ 0xda, 0xdc, 0xfd, 0x86, 0xe6, 0xdc, 0xb0, 0x14, 0xc0, 0x87, 0x68, 0x6d, 0x15, 0x39, 0x99, 0x81, + /*0180:*/ 0xf4, 0x8f, 0xfa, 0x4b, 0x47, 0x53, 0x99, 0x05, 0xe8, 0x9f, 0xd7, 0x8c, 0x0a, 0xdd, 0x12, 0x95, + /*0190:*/ 0xc6, 0xd0, 0xe3, 0xf9, 0x2c, 0xb0, 0xee, 0x4f, 0x50, 0x51, 0x9e, 0x2c, 0x7f, 0x07, 0xd7, 0xd7, + /*01a0:*/ 0xa6, 0xfc, 0x58, 0x56, 0x65, 0x04, 0x49, 0x73, 0x05, 0x3e, 0xd2, 0xe9, 0x37, 0xb8, 0xd7, 0xbc, + /*01b0:*/ 0x79, 0x5f, 0x8c, 0xc7, 0x28, 0xe6, 0x39, 0xef, 0x29, 0x7f, 0x26, 0x52, 0xd8, 0xda, 0x99, 0x4c, + /*01c0:*/ 0x6b, 0x6e, 0x7a, 0xd3, 0x9e, 0x75, 0xca, 0x55, 0xb2, 0x29, 0x88, 0xb8, 0x0b, 0x1d, 0x1c, 0x81, + /*01d0:*/ 0x98, 0x15, 0xf7, 0x59, 0x1d, 0x73, 0xc3, 0x8d, 0x42, 0x5e, 0xce, 0x78, 0x9b, 0x36, 0x49, 0xbe, + /*01e0:*/ 0xad, 0xc9, 0x81, 0xa4, 0x7e, 0x4c, 0xcb, 0x35, 0x52, 0x17, 0xd7, 0x73, 0x29, 0x4e, 0x81, 0xdf, + /*01f0:*/ 0x66, 0x04, 0x1d, 0x49, 0x3f, 0xa0, 0xf2, 0x2f, 0x42, 0xd0, 0xf4, 0xe9, 0x49, 0xae, 0x52, 0xf7, + /*0200:*/ 0xce, 0x67, 0x45, 0x5c, 0x59, 0x91, 0xb0, 0x83, 0xc0, 0x2e, 0xf4, 0x77, 0xcb, 0x65, 0xb5, 0xd3, + /*0210:*/ 0x18, 0x15, 0x9e, 0x05, 0x30, 0x8f, 0xb7, 0xb8, 0x40, 0x1f, 0x71, 0xb1, 0x0f, 0x81, 0x03, 0x89, + /*0220:*/ 0xb7, 0x6d, 0xef, 0x46, 0x6e, 0x45, 0x46, 0xc5, 0xd3, 0x94, 0x92, 0x41, 0xca, 0xc5, 0x32, 0xac, + /*0230:*/ 0x34, 0x10, 0x2b, 0x1a, 0x4f, 0xec, 0x94, 0xcf, 0x91, 0xd9, 0x80, 0xf1, 0x60, 0x9d, 0xe7, 0x63, + /*0240:*/ 0x51, 0xa7, 0xec, 0xe6, 0x1d, 0xf8, 0x38, 0xc7, 0xec, 0xe7, 0x69, 0x08, 0x02, 0x7b, 0x09, 0x89, + /*0250:*/ 0x84, 0x9a, 0xbd, 0x1f, 0x04, 0x9f, 0xf3, 0x20, 0xc8, 0x23, 0x4c, 0xd7, 0x0a, 0x64, 0x47, 0x43, + /*0260:*/ 0xb6, 0xc8, 0xad, 0xb7, 0xd5, 0xa4, 0xb0, 0xea, 0x57, 0x8d, 0xe9, 0x4e, 0x18, 0x81, 0x08, 0x26, + /*0270:*/ 0x68, 0x66, 0xe6, 0x0b, 0xb2, 0x5d, 0xf5, 0xc3, 0xc1, 0xc1, 0x25, 0x84, 0xdd, 0x00, 0x34, 0x10, + /*0280:*/ 0x94, 0xb6, 0xaf, 0x9f, 0x6a, 0xd5, 0x34, 0x1e, 0x9a, 0x42, 0xd0, 0xa7, 0xc9, 0xd7, 0x3f, 0xc3, + /*0290:*/ 0x43, 0xf2, 0x80, 0x94, 0x2e, 0xb9, 0xdb, 0x60, 0x76, 0xc5, 0xf5, 0x6f, 0xe8, 0x83, 0x96, 0x1b, + /*02a0:*/ 0x96, 0x80, 0xed, 0xb4, 0x0b, 0xc3, 0x34, 0x92, 0xa3, 0xe7, 0xb8, 0x07, 0x23, 0x1b, 0x1b, 0x44, + /*02b0:*/ 0x4a, 0x09, 0xf5, 0xb9, 0x50, 0x75, 0xf2, 0xd6, 0x75, 0xae, 0xef, 0xfa, 0x29, 0x4f, 0x7a, 0xf0, + /*02c0:*/ 0xfa, 0x01, 0xf4, 0x0c, 0x67, 0x2c, 0x2d, 0x36, 0x75, 0xfb, 0xe9, 0xaa, 0xf5, 0x4b, 0x87, 0xbb, + /*02d0:*/ 0xb8, 0xe7, 0x62, 0x4f, 0xbb, 0xc1, 0xc7, 0xd6, 0xa4, 0x10, 0xa3, 0xca, 0xb9, 0x80, 0x7a, 0x1e, + /*02e0:*/ 0xb0, 0xc5, 0xaa, 0x84, 0x0e, 0xe8, 0x10, 0x25, 0xa4, 0xd5, 0x1d, 0xc3, 0x2f, 0x11, 0x8e, 0xdc, + /*02f0:*/ 0xae, 0x9d, 0x51, 0x75, 0x40, 0x9e, 0x92, 0xec, 0x94, 0xff, 0x24, 0xbd, 0x00, 0x51, 0x43, 0x15, + /*0300:*/ 0x22, 0x7f, 0x7e, 0x22, 0xfa, 0x57, 0x2b, 0x1c, 0xf3, 0xb1, 0x11, 0x62, 0x0d, 0xb3, 0x68, 0x1a, + /*0310:*/ 0x6f, 0x2c, 0xb1, 0x6a, 0x0a, 0xb6, 0xc0, 0x8e, 0x14, 0x2f, 0x49, 0xd6, 0x65, 0x77, 0xb9, 0xfb, + /*0320:*/ 0x62, 0x78, 0xbf, 0x05, 0x1d, 0x37, 0xc7, 0x59, 0xa0, 0x1a, 0x8e, 0xb3, 0x08, 0x07, 0x69, 0x12, + /*0330:*/ 0x8b, 0xa1, 0x36, 0xd2, 0x42, 0xfe, 0x5a, 0xf7, 0xa6, 0xfd, 0x8b, 0x27, 0x6d, 0x1d, 0x3b, 0x8b, + /*0340:*/ 0xcb, 0xe9, 0x2b, 0x3f, 0xdd, 0xe0, 0xa4, 0x4e, 0x97, 0x41, 0x72, 0x15, 0xfc, 0x7a, 0x40, 0x84, + /*0350:*/ 0x24, 0x56, 0x76, 0xdd, 0x7b, 0xb8, 0xf6, 0xdc, 0x15, 0x01, 0x4a, 0x5f, 0x21, 0xae, 0xc0, 0xbd, + /*0360:*/ 0x14, 0x83, 0x35, 0x64, 0x54, 0x7d, 0xb5, 0x8b, 0xc6, 0x8d, 0xe0, 0x6a, 0xe4, 0x2b, 0x69, 0x49, + /*0370:*/ 0xd1, 0x0b, 0x17, 0x27, 0x09, 0x9a, 0x52, 0x82, 0x57, 0x90, 0x2f, 0x24, 0x43, 0xc3, 0x9d, 0x7d, + /*0380:*/ 0x31, 0x26, 0x6f, 0x54, 0x7d, 0xb6, 0x51, 0x15, 0x47, 0x4e, 0x9e, 0x96, 0x81, 0x29, 0xcb, 0xaa, + /*0390:*/ 0x01, 0xee, 0x77, 0x57, 0xc0, 0xf6, 0xb4, 0xe0, 0xd7, 0x90, 0xa9, 0x44, 0x2c, 0xe3, 0xa9, 0x32, + /*03a0:*/ 0x17, 0x3d, 0x5c, 0xe3, 0xc9, 0x82, 0xb2, 0x56, 0xb3, 0x9b, 0xda, 0xd6, 0x7c, 0x7d, 0x64, 0xd4, + /*03b0:*/ 0xe4, 0x39, 0x0d, 0xcc, 0xf3, 0x02, 0x59, 0xbe, 0x4b, 0x58, 0x4e, 0x1f, 0x47, 0x46, 0x55, 0x97, + /*03c0:*/ 0x67, 0xe7, 0xdc, 0x2f, 0xb1, 0x91, 0x81, 0x0b, 0x46, 0x97, 0x78, 0x25, 0x29, 0xb0, 0x7f, 0xa2, + /*03d0:*/ 0xb9, 0xfa, 0xf4, 0x20, 0x19, 0xab, 0xae, 0xf4, 0x7e, 0x74, 0x92, 0xf3, 0x63, 0x97, 0x05, 0xf4, + /*03e0:*/ 0x8c, 0xc8, 0xfb, 0xa7, 0x6f, 0xdf, 0x2d, 0xa8, 0x80, 0x17, 0x0c, 0x37, 0x6d, 0xe4, 0x97, 0x5b, + /*03f0:*/ 0xa4, 0x1d, 0xda, 0xb7, 0x45, 0xf0, 0xce, 0x7d, 0x31, 0xcc, 0xc2, 0x29, 0x37, 0xd1, 0x8c, 0x3d, + /*0400:*/ 0xcc, 0xa2, 0xf0, 0x70, 0x16, 0x9b, 0x87, 0xc6, 0x97, 0x20, 0x99, 0x8b, 0xb4, 0xb5, 0x39, 0xf7, + /*0410:*/ 0x7c, 0x7f, 0x86, 0x37, 0x79, 0x6e, 0x8b, 0x1b, 0xbf, 0xfb, 0x68, 0xd3, 0xf4, 0x61, 0x58, 0xe5, + /*0420:*/ 0x8a, 0xb0, 0xee, 0x70, 0x06, 0x18, 0x0c, 0x6b, 0x64, 0xf3, 0xb0, 0x64, 0x30, 0xee, 0xd3, 0xd1, + /*0430:*/ 0xa8, 0xe1, 0x30, 0xfc, 0x82, 0x36, 0x67, 0x93, 0x05, 0x6b, 0x4a, 0x33, 0x93, 0x5b, 0x8d, 0xdf, + /*0440:*/ 0xf4, 0x19, 0x3b, 0x85, 0xf0, 0x36, 0xf7, 0x50, 0xaa, 0x5e, 0xf7, 0x83, 0x93, 0x67, 0x78, 0x33, + /*0450:*/ 0x77, 0x3f, 0x9e, 0x34, 0x06, 0x6c, 0xcb, 0xc3, 0x00, 0x7f, 0xea, 0x39, 0x6d, 0xc5, 0x5e, 0x91, + /*0460:*/ 0xb1, 0x00, 0xbe, 0x6f, 0x08, 0x96, 0x01, 0xe4, 0xcb, 0x9f, 0x92, 0x79, 0x50, 0xaa, 0xda, 0x1e, + /*0470:*/ 0xec, 0x12, 0x2b, 0x4b, 0x0a, 0xa3, 0xcf, 0x8c, 0x1f, 0x4b, 0x15, 0xee, 0xec, 0x18, 0xa6, 0xfe, + /*0480:*/ 0xd5, 0x73, 0x82, 0x1d, 0x6e, 0x21, 0x8c, 0xe5, 0xf4, 0x36, 0x83, 0x9e, 0x00, 0x7b, 0x60, 0x9f, + /*0490:*/ 0x0d, 0xb4, 0x60, 0x70, 0xe0, 0x99, 0xc6, 0x55, 0xb9, 0xee, 0x3e, 0x24, 0x06, 0x15, 0x79, 0x0d, + /*04a0:*/ 0xa6, 0xc7, 0x79, 0x97, 0x01, 0x5c, 0x52, 0x38, 0xfa, 0x5b, 0x71, 0x38, 0xfa, 0xbf, 0xa0, 0x2c, + /*04b0:*/ 0x2c, 0x9d, 0x25, 0xfa, 0x70, 0xd7, 0x32, 0xb1, 0x33, 0xb6, 0xcd, 0xcd, 0xcd, 0xf6, 0x97, 0x3b, + /*04c0:*/ 0x3b, 0x0a, 0x33, 0xbb, 0x7a, 0xa5, 0x89, 0x14, 0xa6, 0x15, 0x44, 0xdb, 0x91, 0x07, 0x75, 0x48, + /*04d0:*/ 0xd5, 0x45, 0x46, 0x71, 0x1c, 0xf2, 0x12, 0xbc, 0x61, 0x70, 0x50, 0x56, 0xd3, 0x21, 0x5d, 0xc4, + /*04e0:*/ 0x29, 0x9f, 0x04, 0xfe, 0xe8, 0xdb, 0x77, 0x42, 0xde, 0xf3, 0xef, 0x2b, 0xfb, 0x34, 0xe7, 0x00, + /*04f0:*/ 0x8a, 0x50, 0x40, 0x3f, 0x62, 0x3d, 0x94, 0x49, 0xd2, 0x95, 0x27, 0xec, 0x86, 0xcd, 0xa2, 0x05, + /*0500:*/ 0xac, 0xfe, 0xb0, 0x83, 0xee, 0x52, 0x05, 0x7c, 0x40, 0x27, 0x4b, 0xc7, 0x93, 0xaa, 0x92, 0xce, + /*0510:*/ 0x72, 0x70, 0x8d, 0x9a, 0x5b, 0x88, 0x6b, 0x59, 0xa7, 0x61, 0xf7, 0x12, 0xe8, 0x61, 0xb6, 0x23, + /*0520:*/ 0xe8, 0xd3, 0xfc, 0x6a, 0xec, 0x4a, 0x05, 0xcd, 0x49, 0x74, 0xf4, 0xcb, 0x0e, 0xe3, 0x95, 0x95, + /*0530:*/ 0x0e, 0xc3, 0xd7, 0x9e, 0xb6, 0x6e, 0xcb, 0x4f, 0xdc, 0xe3, 0x3d, 0x87, 0x23, 0x3a, 0xc8, 0x8d, + /*0540:*/ 0x4f, 0x7b, 0xd8, 0xe9, 0x12, 0x46, 0x92, 0x0c, 0x75, 0xe0, 0x6b, 0x35, 0xf1, 0x82, 0xbc, 0xbb, + /*0550:*/ 0x09, 0x3f, 0xf9, 0xa7, 0xb6, 0x29, 0x62, 0x64, 0x09, 0x02, 0x5b, 0xf7, 0x47, 0xac, 0x69, 0xe5, + /*0560:*/ 0xb9, 0x7a, 0x6a, 0x7b, 0xb1, 0xad, 0xf4, 0x5f, 0xa4, 0x2c, 0x31, 0x06, 0x69, 0x63, 0x25, 0x32, + /*0570:*/ 0x75, 0x35, 0x95, 0x06, 0x41, 0xf8, 0x40, 0xce, 0x35, 0x2c, 0xad, 0x9b, 0xfb, 0xc0, 0x87, 0xed, + /*0580:*/ 0xe9, 0xd9, 0xe1, 0x65, 0x45, 0xc1, 0x98, 0x87, 0x0f, 0x2d, 0xc9, 0x38, 0xbc, 0x24, 0xdb, 0xa7, + /*0590:*/ 0x51, 0xae, 0x04, 0xa8, 0x3e, 0x1f, 0xab, 0xd4, 0xbb, 0x00, 0x08, 0x93, 0xc3, 0xcf, 0x15, 0x94, + /*05a0:*/ 0x2c, 0xd9, 0xa4, 0x0f, 0xb1, 0xc4, 0xda, 0xc6, 0xac, 0x24, 0x17, 0x8a, 0xda, 0xab, 0x4e, 0xa7, + /*05b0:*/ 0xeb, 0xeb, 0xc2, 0xdd, 0x01, 0x51, 0xfd, 0xc2, 0xf9, 0x3a, 0x2b, 0x97, 0x19, 0x3f, 0x1a, 0x84, + /*05c0:*/ 0x65, 0x14, 0xd6, 0xac, 0xf8, 0xbd, 0xe5, 0xa3, 0xb4, 0x19, 0x4b, 0xbe, 0x02, 0xe7, 0x71, 0xff, + /*05d0:*/ 0x14, 0xbe, 0xfa, 0x49, 0x20, 0x50, 0x74, 0x43, 0x68, 0x23, 0x86, 0x4b, 0xe3, 0xbe, 0x4d, 0x16, + /*05e0:*/ 0x93, 0xd0, 0xcf, 0xa5, 0x5a, 0x56, 0x0a, 0x4e, 0x05, 0xf0, 0x24, 0xf0, 0xe9, 0xbb, 0xf3, 0xd2, + /*05f0:*/ 0xcf, 0xaa, 0x1d, 0x6b, 0x99, 0x31, 0x79, 0xd8, 0x26, 0xc8, 0x0a, 0xa4, 0x32, 0xb1, 0xe2, 0x0c, + /*0600:*/ 0xaa, 0xb4, 0xe0, 0x05, 0xc4, 0x60, 0xb9, 0xdf, 0xad, 0x95, 0x51, 0x29, 0xbc, 0xa8, 0xcb, 0xae, + /*0610:*/ 0xc3, 0x75, 0xbf, 0x42, 0x8f, 0x02, 0xe8, 0xf1, 0x74, 0x2a, 0x93, 0x98, 0xce, 0x7e, 0x13, 0xd5, + /*0620:*/ 0xd6, 0x2c, 0xd5, 0x08, 0x45, 0xe2, 0x6d, 0xe1, 0x2a, 0x63, 0x8d, 0xa4, 0x3e, 0xab, 0x73, 0x6d, + /*0630:*/ 0x4c, 0x06, 0xf8, 0x44, 0x5a, 0xb1, 0x65, 0x0f, 0x1d, 0xf3, 0xcd, 0xf2, 0x3e, 0xde, 0xa2, 0x12, + /*0640:*/ 0xe6, 0x1c, 0xbd, 0x84, 0x65, 0x13, 0xb5, 0x3c, 0x9a, 0xa8, 0x17, 0xc3, 0x9e, 0xb4, 0xab, 0x52, + /*0650:*/ 0x30, 0x4c, 0x0a, 0xc2, 0xff, 0x20, 0x4b, 0xb4, 0x8e, 0xf9, 0x4a, 0xb6, 0x21, 0xaa, 0x47, 0x68, + /*0660:*/ 0x61, 0x6f, 0x81, 0x0e, 0x36, 0xe7, 0x19, 0x2f, 0x68, 0xbb, 0x18, 0x29, 0xdd, 0xf1, 0xc3, 0x57, + /*0670:*/ 0x9a, 0xe0, 0x66, 0x47, 0xda, 0xe2, 0x24, 0x27, 0xb7, 0x75, 0x6d, 0x99, 0x5f, 0x94, 0x5b, 0xae, + /*0680:*/ 0x60, 0xde, 0xc2, 0x2a, 0xd5, 0x36, 0x24, 0x61, 0x6a, 0x39, 0x08, 0x32, 0x18, 0x04, 0x41, 0x0f, + /*0690:*/ 0x24, 0xc2, 0x4a, 0x5f, 0xa2, 0x32, 0xf6, 0x8a, 0xe4, 0x03, 0x9e, 0x85, 0xb0, 0xe6, 0x5b, 0xeb, + /*06a0:*/ 0x15, 0x21, 0xce, 0xc7, 0xdc, 0x90, 0xfb, 0x22, 0x94, 0xf1, 0x77, 0x1b, 0x60, 0x17, 0x97, 0x6e, + /*06b0:*/ 0x19, 0x51, 0xde, 0xf6, 0x73, 0xa5, 0xf1, 0xf5, 0x71, 0xc5, 0xa2, 0x44, 0x61, 0x20, 0xe3, 0x08, + /*06c0:*/ 0x82, 0xd6, 0x9f, 0xfe, 0xdb, 0x11, 0x10, 0xfb, 0x38, 0x72, 0x9e, 0x3a, 0x1b, 0xa2, 0x28, 0xdb, + /*06d0:*/ 0x37, 0xef, 0xaf, 0x13, 0x6b, 0xde, 0x35, 0xa3, 0xc0, 0x42, 0x2c, 0xd3, 0xe0, 0x11, 0xe9, 0xe4, + /*06e0:*/ 0x94, 0x9c, 0x1e, 0xe4, 0x01, 0x02, 0x22, 0x8c, 0x13, 0x27, 0xda, 0xe6, 0x30, 0x61, 0x67, 0xca, + /*06f0:*/ 0x40, 0x87, 0x06, 0xce, 0x72, 0xa7, 0x14, 0x15, 0xa7, 0xe6, 0xa3, 0x7c, 0x51, 0xb7, 0xdd, 0x3e, + /*0700:*/ 0x2b, 0x8c, 0x7d, 0x56, 0x86, 0xb8, 0x3e, 0x17, 0xe8, 0x73, 0xce, 0xe8, 0x4a, 0xd9, 0xac, 0x9b, + /*0710:*/ 0x2b, 0x09, 0x3a, 0xb0, 0xb3, 0x96, 0xad, 0x98, 0xfd, 0x55, 0xdc, 0x0f, 0xf0, 0x1c, 0xaa, 0x8a, + /*0720:*/ 0xba, 0x6a, 0xfb, 0xf1, 0xac, 0x36, 0x35, 0x02, 0x42, 0x85, 0x6a, 0x81, 0x41, 0x78, 0xe1, 0x75, + /*0730:*/ 0xc2, 0x55, 0x5e, 0x15, 0x4c, 0x99, 0x22, 0xcc, 0x19, 0xc4, 0x91, 0x32, 0x80, 0x70, 0xa6, 0x7a, + /*0740:*/ 0x76, 0xa4, 0xfb, 0xfb, 0xa3, 0x94, 0x5d, 0xc7, 0x01, 0x92, 0x9a, 0xc7, 0xc1, 0x6f, 0x0e, 0x20, + /*0750:*/ 0xbc, 0x3d, 0x84, 0xf7, 0xa9, 0xe5, 0x6d, 0x72, 0x8c, 0x8a, 0x82, 0xfc, 0x53, 0x80, 0xdf, 0x34, + /*0760:*/ 0x82, 0xff, 0x69, 0xcb, 0x33, 0xbc, 0xeb, 0x6c, 0xe4, 0xbd, 0x9d, 0xc4, 0x67, 0xdc, 0x25, 0x55, + /*0770:*/ 0x51, 0xb5, 0x5f, 0xf5, 0x5c, 0xe4, 0x35, 0xfc, 0x55, 0xe5, 0x2d, 0xdf, 0x51, 0x2c, 0xcc, 0x28, + /*0780:*/ 0xaa, 0xe4, 0x7b, 0x5f, 0x87, 0x2a, 0x79, 0x48, 0xf3, 0xf6, 0xaf, 0x22, 0xf1, 0xe3, 0x62, 0x29, + /*0790:*/ 0x31, 0x65, 0x87, 0xef, 0x97, 0xa7, 0x18, 0xf6, 0xf4, 0xc7, 0x71, 0x5d, 0x53, 0xd5, 0x1b, 0x20, + /*07a0:*/ 0x4f, 0x15, 0x4b, 0x20, 0x3a, 0x5d, 0x37, 0xbb, 0x90, 0x80, 0xf3, 0xc2, 0xd0, 0x37, 0xb0, 0xe9, + /*07b0:*/ 0xad, 0xab, 0x28, 0xf4, 0x20, 0x23, 0x3d, 0x53, 0x68, 0xff, 0x00, 0x39, 0x99, 0x17, 0xde, 0xd1, + /*07c0:*/ 0x0d, 0x8d, 0xd9, 0x84, 0x03, 0xb9, 0x2b, 0x20, 0x8c, 0x98, 0x00, 0xbf, 0x59, 0x9c, 0xe8, 0xba, + /*07d0:*/ 0x29, 0x3f, 0xf8, 0x5c, 0x5b, 0xd2, 0xf3, 0x76, 0xf6, 0xac, 0x0b, 0x9e, 0x8d, 0xf4, 0x2a, 0xb2, + /*07e0:*/ 0x4e, 0xaf, 0xb9, 0xe9, 0xd1, 0xb3, 0x40, 0xa6, 0x08, 0xc5, 0x1a, 0x31, 0xb4, 0xd8, 0x05, 0x24, + /*07f0:*/ 0xdf, 0x29, 0xf0, 0xc0, 0xf6, 0x90, 0x0f, 0x0c, 0x72, 0xdb, 0x4d, 0x32, 0xbe, 0xd6, 0x72, 0x57, + /*0800:*/ 0xe3, 0xc3, 0xaa, 0x3c, 0x4b, 0x12, 0xea, 0xc8, 0xf6, 0xb8, 0x0f, 0xdf, 0xa9, 0x21, 0x8a, 0x20, + /*0810:*/ 0xfc, 0x2a, 0x14, 0xa0, 0x9d, 0xb4, 0xea, 0xbf, 0x09, 0xbe, 0xca, 0x32, 0xff, 0xd8, 0xfc, 0x91, + /*0820:*/ 0x2c, 0xf4, 0x58, 0x67, 0x79, 0x4a, 0xb7, 0x0f, 0x9d, 0x30, 0xf9, 0x8d, 0xbd, 0xaf, 0x28, 0x3b, + /*0830:*/ 0xdf, 0x8b, 0xa2, 0x83, 0xb1, 0xef, 0x3a, 0x1a, 0x8e, 0xff, 0x59, 0x1b, 0x25, 0xf7, 0x0f, 0x30, + /*0840:*/ 0x34, 0xc4, 0xbe, 0x4a, 0x41, 0xc4, 0x37, 0xf9, 0x59, 0x07, 0x42, 0x20, 0x28, 0xac, 0xca, 0x32, + /*0850:*/ 0xed, 0xd2, 0x03, 0x06, 0xa7, 0x96, 0x69, 0xb7, 0xe9, 0xde, 0xc8, 0x28, 0x06, 0xd8, 0x4d, 0xe7, + /*0860:*/ 0xab, 0xd5, 0xef, 0x00, 0x0f, 0x45, 0x50, 0xfb, 0x50, 0xbf, 0x79, 0x7d, 0xdc, 0x50, 0xa9, 0xec, + /*0870:*/ 0xbb, 0x92, 0x31, 0xce, 0x44, 0x9c, 0x06, 0x33, 0x8f, 0x39, 0x74, 0x74, 0xf4, 0x6c, 0xd6, 0xa6, + /*0880:*/ 0x8f, 0x50, 0x2b, 0x09, 0x1e, 0xeb, 0x31, 0x98, 0xc6, 0xfc, 0xfc, 0x40, 0x45, 0x45, 0x85, 0x82, + /*0890:*/ 0xa9, 0x4d, 0xd0, 0xfa, 0xd1, 0xe6, 0x0c, 0xda, 0x0a, 0x59, 0x2b, 0x7d, 0x9e, 0x93, 0x4e, 0x41, + /*08a0:*/ 0xce, 0x96, 0xc9, 0x9a, 0x7b, 0xd4, 0x83, 0xe8, 0x43, 0xdb, 0xb5, 0x6d, 0xe8, 0x1a, 0xa6, 0xe8, + /*08b0:*/ 0xf0, 0x5f, 0x7f, 0xf3, 0x40, 0x2c, 0x86, 0xbb, 0x7e, 0xfc, 0xa2, 0x64, 0xef, 0x99, 0xc8, 0xb7, + /*08c0:*/ 0x71, 0x9a, 0x4e, 0xd8, 0xe8, 0x16, 0x5d, 0x29, 0x7d, 0x76, 0x08, 0xdf, 0x0d, 0xde, 0x6b, 0x16, + /*08d0:*/ 0x29, 0xbd, 0xce, 0x46, 0x65, 0x85, 0xc8, 0xcd, 0xf4, 0x39, 0xa5, 0xa6, 0x87, 0xa8, 0x18, 0x85, + /*08e0:*/ 0x6b, 0x60, 0xd7, 0x94, 0xcd, 0x21, 0x04, 0x18, 0x73, 0x58, 0xb3, 0xd4, 0x88, 0x0a, 0xd0, 0x33, + /*08f0:*/ 0x70, 0xe7, 0x80, 0x18, 0x22, 0x48, 0xc4, 0xce, 0x53, 0xac, 0x96, 0x2d, 0xb3, 0x65, 0xd3, 0x6b, + /*0900:*/ 0x1f, 0xb9, 0xb4, 0xd9, 0x24, 0xf0, 0x13, 0x4d, 0xcc, 0x5e, 0x6d, 0xe8, 0x80, 0xce, 0xc8, 0xe4, + /*0910:*/ 0xb3, 0x56, 0x91, 0x7a, 0x27, 0xb0, 0x1a, 0x32, 0x55, 0x49, 0xa0, 0xc4, 0xa5, 0x44, 0xf0, 0xb4, + /*0920:*/ 0x8a, 0x35, 0x0b, 0x45, 0x37, 0xf5, 0x3c, 0xe4, 0x89, 0x46, 0x1a, 0x56, 0xea, 0xc0, 0xd3, 0x8e, + /*0930:*/ 0x65, 0x90, 0x7b, 0x8d, 0x32, 0x65, 0x51, 0x89, 0x8d, 0x96, 0xab, 0x98, 0xb1, 0xd6, 0x71, 0x6e, + /*0940:*/ 0x46, 0xf2, 0x33, 0xe9, 0x37, 0x14, 0xf7, 0x11, 0xd4, 0xa8, 0xbf, 0x2a, 0x22, 0xe9, 0xc7, 0xbd, + /*0950:*/ 0xad, 0x08, 0x95, 0x73, 0xb4, 0x5e, 0x1f, 0x92, 0xfa, 0x9a, 0x1a, 0xe9, 0x77, 0x22, 0xce, 0xa6, + /*0960:*/ 0xd2, 0xc5, 0xa3, 0xf9, 0x41, 0xd8, 0x88, 0x0b, 0xe2, 0x28, 0xf1, 0x7c, 0xda, 0x84, 0x71, 0xd1, + /*0970:*/ 0x00, 0x30, 0x6d, 0x6e, 0x6c, 0xba, 0x38, 0xcd, 0x51, 0x20, 0xe2, 0x85, 0x30, 0xc1, 0x4f, 0xba, + /*0980:*/ 0x8a, 0x89, 0xf2, 0x50, 0x43, 0xf6, 0x1b, 0x4a, 0xa7, 0x2e, 0x8b, 0x67, 0xc4, 0x6d, 0x32, 0x9a, + /*0990:*/ 0xba, 0xfb, 0xa7, 0xb2, 0x3f, 0xa3, 0x2d, 0xc6, 0x7c, 0x64, 0x94, 0xde, 0xcf, 0x27, 0x86, 0x90, + /*09a0:*/ 0xc7, 0xd5, 0xa3, 0x36, 0xa6, 0x10, 0xcb, 0xcd, 0x58, 0x53, 0x0b, 0xa6, 0xb4, 0x46, 0x2a, 0xf7, + /*09b0:*/ 0x28, 0x63, 0x6a, 0x4f, 0x0e, 0xd6, 0x48, 0x3f, 0x93, 0x09, 0x12, 0xb6, 0xd7, 0x4f, 0x59, 0x96, + /*09c0:*/ 0xf9, 0xa7, 0x31, 0x0f, 0x59, 0xe1, 0x27, 0xf1, 0x66, 0x99, 0xe7, 0xb4, 0x04, 0xdb, 0xb0, 0xa0, + /*09d0:*/ 0x41, 0x1c, 0x98, 0x4c, 0xed, 0x04, 0x19, 0x06, 0xd0, 0x4a, 0x94, 0xef, 0x17, 0xf0, 0x65, 0x5b, + /*09e0:*/ 0x47, 0x2e, 0x64, 0x59, 0xb4, 0x45, 0x26, 0x37, 0x21, 0x5a, 0x8a, 0x11, 0xda, 0x41, 0x71, 0x87, + /*09f0:*/ 0x43, 0x3d, 0xe7, 0xb9, 0xaf, 0x7e, 0x81, 0x81, 0xc9, 0xd1, 0xf1, 0x0f, 0x62, 0xcc, 0x35, 0xef, + /*0a00:*/ 0x8d, 0xee, 0x9d, 0x7a, 0x57, 0xa0, 0xad, 0x9b, 0x40, 0xc8, 0x28, 0xbf, 0xa8, 0xf4, 0xf5, 0x37, + /*0a10:*/ 0x60, 0xdb, 0xdb, 0xc8, 0xe5, 0xd1, 0x7b, 0xbc, 0x53, 0x43, 0x8b, 0xf8, 0x10, 0xbe, 0x9d, 0x56, + /*0a20:*/ 0x14, 0x75, 0xcc, 0x66, 0x5b, 0x8c, 0x2b, 0x33, 0xaf, 0xa6, 0xe4, 0x08, 0x29, 0xf6, 0x50, 0x7a, + /*0a30:*/ 0x0d, 0x11, 0xa1, 0xea, 0x30, 0x49, 0x98, 0x8b, 0xa6, 0x4d, 0x29, 0x73, 0x7d, 0xfa, 0x87, 0xc9, + /*0a40:*/ 0x6a, 0x13, 0xfa, 0x75, 0xa0, 0x5a, 0x89, 0xc0, 0xb4, 0x64, 0x96, 0x79, 0x42, 0x6f, 0x30, 0xef, + /*0a50:*/ 0x13, 0x1b, 0xe7, 0x44, 0xec, 0x55, 0xb1, 0x77, 0xa6, 0xd9, 0x63, 0x09, 0xc3, 0x29, 0x95, 0x5f, + /*0a60:*/ 0xee, 0x92, 0xb6, 0x6e, 0xb4, 0xfd, 0xf2, 0x48, 0x35, 0x13, 0x2c, 0xb7, 0x34, 0xd8, 0x2d, 0x6e, + /*0a70:*/ 0xce, 0x21, 0xda, 0xe8, 0x71, 0x86, 0x3a, 0x34, 0x80, 0x5d, 0x59, 0xd5, 0x32, 0x99, 0x95, 0x52, + /*0a80:*/ 0x83, 0xd5, 0x7b, 0xd5, 0xa7, 0xa3, 0x52, 0x48, 0x92, 0xdc, 0x1f, 0x34, 0x84, 0x72, 0x08, 0x5a, + /*0a90:*/ 0xce, 0xb7, 0x02, 0xea, 0xd1, 0x75, 0x39, 0xe2, 0xa5, 0xae, 0x72, 0x56, 0x2b, 0xcc, 0xd1, 0xc8, + /*0aa0:*/ 0x95, 0x54, 0x34, 0x35, 0x94, 0x80, 0xdb, 0x62, 0xbf, 0x1f, 0xe0, 0xbc, 0x0f, 0x43, 0xce, 0xce, + /*0ab0:*/ 0x64, 0xfe, 0xbe, 0x7d, 0xe1, 0xc6, 0x81, 0xfe, 0xa6, 0x2b, 0xd7, 0x02, 0x10, 0x83, 0x03, 0xb6, + /*0ac0:*/ 0x4d, 0x59, 0x5f, 0x12, 0x39, 0x90, 0x2d, 0x0c, 0xd8, 0x29, 0xbc, 0xae, 0xed, 0x41, 0x66, 0x37, + /*0ad0:*/ 0x2c, 0x90, 0xf7, 0xba, 0xf8, 0x09, 0x20, 0x3f, 0x38, 0xd4, 0x7a, 0x24, 0x7b, 0x1a, 0x8b, 0xc6, + /*0ae0:*/ 0x69, 0x2b, 0x4d, 0x15, 0xb3, 0xd7, 0x79, 0x5f, 0x87, 0xe5, 0x48, 0x5d, 0x2a, 0x89, 0x85, 0xd7, + /*0af0:*/ 0x96, 0xf9, 0x39, 0x91, 0xdb, 0x3d, 0x9e, 0x5b, 0x39, 0xe8, 0x3a, 0x29, 0x4c, 0xd1, 0x22, 0xce, + /*0b00:*/ 0x3f, 0xa4, 0xf3, 0xad, 0x28, 0xc2, 0xee, 0xa3, 0x27, 0x19, 0x0a, 0x86, 0x13, 0xeb, 0xcc, 0xc8, + /*0b10:*/ 0x69, 0xbf, 0x46, 0xf7, 0xe4, 0x6d, 0xf8, 0x31, 0xbb, 0xd7, 0x45, 0xfd, 0x0a, 0x68, 0xee, 0x2b, + /*0b20:*/ 0xb5, 0x71, 0xb2, 0xad, 0x5b, 0x80, 0x5e, 0x69, 0x58, 0x11, 0x6a, 0xea, 0x30, 0x88, 0x33, 0xec, + /*0b30:*/ 0xa9, 0xed, 0x2f, 0x8c, 0x95, 0x30, 0xec, 0x4a, 0xc1, 0x47, 0xbd, 0xd0, 0x60, 0x8c, 0x23, 0x0f, + /*0b40:*/ 0x9e, 0x11, 0x62, 0xc6, 0xc2, 0xb4, 0xc6, 0x43, 0x4c, 0xa6, 0x66, 0xe8, 0xbc, 0xed, 0x57, 0xfb, + /*0b50:*/ 0x6d, 0x73, 0x80, 0xd3, 0x5f, 0xe1, 0x90, 0x27, 0xd5, 0x32, 0x20, 0x9d, 0x1f, 0x72, 0x5d, 0xad, + /*0b60:*/ 0xdc, 0xb3, 0x3d, 0x86, 0x75, 0x95, 0x1b, 0x34, 0x52, 0x46, 0x66, 0x58, 0xf6, 0x9a, 0xd7, 0x06, + /*0b70:*/ 0xf0, 0x40, 0x64, 0x55, 0x74, 0xa5, 0x70, 0x56, 0x17, 0x71, 0xe7, 0xee, 0xf8, 0x18, 0x77, 0xdd, + /*0b80:*/ 0x23, 0x78, 0x01, 0xde, 0x3d, 0x5b, 0x97, 0xd1, 0x35, 0x00, 0x94, 0xd9, 0x12, 0xe3, 0x7b, 0x66, + /*0b90:*/ 0xac, 0x58, 0xdb, 0xe8, 0xb0, 0x41, 0x83, 0x3e, 0x7c, 0xdc, 0x04, 0x41, 0x2f, 0xf5, 0x89, 0xce, + /*0ba0:*/ 0xbd, 0xf6, 0xa9, 0x95, 0x20, 0x62, 0x66, 0x5d, 0x6a, 0x1d, 0x08, 0xca, 0x44, 0x80, 0x7e, 0xb0, + /*0bb0:*/ 0xfd, 0x45, 0x82, 0x92, 0x80, 0x52, 0x99, 0x90, 0x16, 0x59, 0xd1, 0x29, 0xa1, 0xf2, 0x56, 0x84, + /*0bc0:*/ 0xa4, 0x5d, 0xdd, 0x82, 0x27, 0x80, 0x17, 0x84, 0x1f, 0x6e, 0x71, 0xb0, 0x7c, 0xb8, 0x39, 0xf6, + /*0bd0:*/ 0x9e, 0x55, 0xe6, 0x85, 0xa6, 0x20, 0x56, 0x6b, 0x8e, 0x4e, 0xd5, 0xd1, 0x93, 0xa3, 0xf8, 0x01, + /*0be0:*/ 0xc5, 0x04, 0x73, 0x76, 0xdd, 0x79, 0x03, 0x50, 0xc3, 0x6f, 0x89, 0x53, 0x97, 0x3e, 0xf9, 0xa4, + /*0bf0:*/ 0xfa, 0xf8, 0xd6, 0x43, 0xcd, 0x98, 0x0d, 0x69, 0xf0, 0xff, 0xa3, 0xd6, 0xb9, 0xa6, 0x0a, 0x59, + /*0c00:*/ 0x87, 0x45, 0x5e, 0x1c, 0x0d, 0x5c, 0xc3, 0x30, 0x1c, 0x69, 0xd0, 0x26, 0xc4, 0x64, 0x9f, 0xd9, + /*0c10:*/ 0xd3, 0xad, 0xbe, 0x19, 0xfd, 0x77, 0x71, 0xdb, 0xa4, 0x60, 0x93, 0x6c, 0x7e, 0xc5, 0x11, 0x41, + /*0c20:*/ 0xab, 0x40, 0xa7, 0x57, 0x70, 0x4b, 0xac, 0x56, 0x21, 0x3e, 0xb7, 0xc3, 0x1e, 0x25, 0xf9, 0xab, + /*0c30:*/ 0x86, 0x8b, 0x56, 0xf1, 0x62, 0x37, 0x24, 0xe3, 0x38, 0xb3, 0x51, 0xa8, 0xcb, 0xaa, 0x09, 0xe8, + /*0c40:*/ 0x81, 0xa2, 0x9e, 0xc6, 0x4e, 0xbe, 0x7b, 0xfd, 0x96, 0x13, 0xb5, 0x2d, 0x7c, 0xf1, 0xa8, 0xf6, + /*0c50:*/ 0x3d, 0x01, 0x2d, 0x8a, 0x8d, 0xf7, 0x8c, 0x0e, 0x6a, 0xf0, 0x00, 0x32, 0xe0, 0x8a, 0xe8, 0xa6, + /*0c60:*/ 0x7a, 0x78, 0xad, 0xcb, 0xef, 0xc8, 0xfe, 0x06, 0x74, 0x04, 0x00, 0xf5, 0xc7, 0xf5, 0x00, 0xca, + /*0c70:*/ 0x9d, 0x50, 0x57, 0x95, 0x29, 0x13, 0x34, 0xe0, 0xa6, 0xad, 0x81, 0x09, 0x9f, 0x76, 0xc1, 0xde, + /*0c80:*/ 0x1b, 0x17, 0xd4, 0x9d, 0xa0, 0x68, 0x1e, 0x6d, 0xd8, 0x3a, 0xe3, 0xa8, 0x9b, 0xfd, 0x55, 0x37, + /*0c90:*/ 0xb9, 0xfb, 0x04, 0x17, 0x8c, 0x91, 0xcc, 0x51, 0xdf, 0x96, 0x51, 0x8d, 0x26, 0x1c, 0x38, 0x0c, + /*0ca0:*/ 0x74, 0x42, 0x6a, 0x48, 0xdb, 0xb0, 0xed, 0xca, 0x95, 0xa5, 0x07, 0x76, 0x39, 0xaa, 0x9d, 0xc1, + /*0cb0:*/ 0xf0, 0xe3, 0x71, 0xce, 0x8c, 0x09, 0x88, 0x63, 0x15, 0x6d, 0x15, 0x3a, 0xdb, 0xaf, 0xad, 0x8f, + /*0cc0:*/ 0x63, 0x64, 0x37, 0x65, 0x63, 0x19, 0x7f, 0x63, 0x8a, 0xb6, 0x21, 0xc9, 0x0b, 0xd3, 0x78, 0x0d, + /*0cd0:*/ 0x21, 0x08, 0x6e, 0x66, 0xf7, 0xd8, 0xfa, 0xdf, 0x1e, 0x67, 0xae, 0xa3, 0x0b, 0xa8, 0xfb, 0xab, + /*0ce0:*/ 0xa6, 0xcb, 0x28, 0x74, 0x47, 0x8e, 0x76, 0xb7, 0xf5, 0xe5, 0x8b, 0xe9, 0x90, 0x26, 0x78, 0xe8, + /*0cf0:*/ 0x88, 0x1a, 0x9b, 0xd6, 0x07, 0xe1, 0x4d, 0xe9, 0xc6, 0xc2, 0x3c, 0x42, 0xa5, 0x7c, 0x03, 0xb1, + /*0d00:*/ 0x40, 0xd8, 0xec, 0xdf, 0x63, 0x90, 0x38, 0x13, 0x17, 0x9a, 0x34, 0x93, 0x93, 0x7d, 0x17, 0x82, + /*0d10:*/ 0xac, 0x78, 0x36, 0x21, 0x8b, 0x13, 0x33, 0xe0, 0xb7, 0xc7, 0xf3, 0x35, 0xff, 0xd7, 0xf5, 0x18, + /*0d20:*/ 0xdc, 0x8f, 0xe9, 0xd3, 0x63, 0xf4, 0x69, 0x5a, 0xc2, 0xf7, 0x70, 0x1d, 0xd6, 0x2e, 0x24, 0x31, + /*0d30:*/ 0x03, 0x3f, 0x71, 0xc5, 0x1b, 0xa1, 0x0a, 0xa0, 0xaa, 0xfb, 0xd3, 0xc4, 0x2d, 0x0c, 0x5d, 0xb4, + /*0d40:*/ 0xf4, 0x69, 0xa2, 0x82, 0xe5, 0xd7, 0x2b, 0x2c, 0xf6, 0x08, 0x1d, 0xb2, 0x14, 0x98, 0x66, 0xc1, + /*0d50:*/ 0x15, 0x0d, 0xc9, 0xcc, 0x1d, 0xc2, 0x54, 0x9b, 0x80, 0x27, 0xec, 0x27, 0x70, 0x4b, 0x5c, 0xee, + /*0d60:*/ 0xc0, 0xd3, 0x3c, 0x68, 0x50, 0x00, 0xf5, 0x80, 0x56, 0x46, 0xc3, 0x30, 0x97, 0xca, 0x5e, 0x72, + /*0d70:*/ 0x50, 0x1d, 0xb2, 0x82, 0x22, 0x73, 0x6f, 0x01, 0xf9, 0xcc, 0x98, 0xf6, 0xc5, 0xdc, 0x75, 0x2e, + /*0d80:*/ 0xa6, 0x96, 0x75, 0x75, 0xf1, 0x61, 0x58, 0x2c, 0x9f, 0x7e, 0x5f, 0xba, 0x7b, 0xe3, 0xfa, 0x47, + /*0d90:*/ 0xf7, 0x8e, 0xc1, 0x0f, 0xeb, 0xf2, 0x7a, 0x4e, 0x35, 0x09, 0x60, 0xf0, 0x38, 0xeb, 0x57, 0x5e, + /*0da0:*/ 0xa3, 0x3f, 0x77, 0x3f, 0xc4, 0xcc, 0xf4, 0xf8, 0xc5, 0x33, 0x19, 0x8e, 0xc8, 0x4a, 0xd1, 0xe5, + /*0db0:*/ 0x17, 0x70, 0xdb, 0xf7, 0x7d, 0xbc, 0x7d, 0xe0, 0x2b, 0x7e, 0x10, 0x66, 0x51, 0x47, 0x64, 0xf9, + /*0dc0:*/ 0x62, 0xcf, 0x37, 0xbb, 0x92, 0xf5, 0xb3, 0xdf, 0x11, 0x37, 0x93, 0x81, 0x6f, 0xd8, 0xb4, 0x74, + /*0dd0:*/ 0x09, 0xcb, 0x36, 0x9e, 0x44, 0xe5, 0xce, 0x3e, 0xfb, 0x3b, 0xaa, 0x1b, 0xfc, 0x46, 0x7b, 0xe6, + /*0de0:*/ 0xb0, 0x86, 0x46, 0xbf, 0xf5, 0xc2, 0xa2, 0xdc, 0x5c, 0x91, 0xa7, 0x9f, 0x1b, 0xdd, 0x9f, 0x58, + /*0df0:*/ 0x12, 0x44, 0xfe, 0x55, 0x85, 0xc3, 0xfc, 0x12, 0x13, 0x3e, 0xf3, 0x7b, 0xd7, 0x47, 0x4d, 0x26, + /*0e00:*/ 0x93, 0x32, 0x45, 0x16, 0xd0, 0x03, 0x66, 0x23, 0xe2, 0x4f, 0x92, 0x21, 0x3c, 0x18, 0x9f, 0x2e, + /*0e10:*/ 0xdd, 0xec, 0x8f, 0xeb, 0x3b, 0xef, 0x26, 0xef, 0x35, 0x98, 0xf3, 0x26, 0x90, 0x3d, 0x01, 0x46, + /*0e20:*/ 0xc4, 0x3d, 0x49, 0x19, 0xc2, 0xc7, 0xc5, 0x57, 0xf1, 0xd4, 0x1d, 0x63, 0xb3, 0xe3, 0xec, 0x29, + /*0e30:*/ 0xb7, 0x8c, 0xa6, 0xb7, 0xae, 0x63, 0x79, 0x5e, 0xc8, 0x02, 0xde, 0x38, 0x4d, 0xee, 0x6e, 0x7e, + /*0e40:*/ 0x0f, 0x70, 0xe2, 0xc0, 0x23, 0x83, 0xf6, 0xd7, 0x9e, 0x53, 0xd5, 0x44, 0x96, 0xb1, 0xfe, 0x0c, + /*0e50:*/ 0xbb, 0x00, 0x6a, 0xb3, 0xab, 0xeb, 0x31, 0xae, 0x6e, 0x63, 0xed, 0x91, 0x16, 0x44, 0x43, 0xd4, + /*0e60:*/ 0x2d, 0xf3, 0x7a, 0x95, 0x5c, 0x93, 0xa9, 0x44, 0x91, 0x7c, 0xb0, 0xc7, 0xdd, 0x92, 0x1c, 0xde, + /*0e70:*/ 0xa6, 0xc3, 0xf1, 0x58, 0x4d, 0x25, 0xcd, 0x88, 0x1a, 0x54, 0xbe, 0x50, 0x2b, 0x9a, 0xfb, 0xbc, + /*0e80:*/ 0xd6, 0x4d, 0x59, 0x2d, 0xcd, 0x76, 0x16, 0x3c, 0x1c, 0xfd, 0x7a, 0xae, 0x41, 0xae, 0xfa, 0x95, + /*0e90:*/ 0xd6, 0xb8, 0x8b, 0xac, 0xa9, 0xee, 0x93, 0x2a, 0x55, 0x21, 0x4b, 0x6c, 0x1a, 0x28, 0x2f, 0x8d, + /*0ea0:*/ 0x9c, 0x42, 0xd0, 0xb0, 0x21, 0x90, 0x0a, 0xce, 0xa5, 0x55, 0x6d, 0x52, 0x8e, 0xb7, 0x98, 0xad, + /*0eb0:*/ 0xd4, 0xdf, 0x48, 0x48, 0x71, 0x7a, 0x66, 0x4a, 0xb2, 0x45, 0x17, 0xab, 0x5b, 0x91, 0x05, 0x7f, + /*0ec0:*/ 0x72, 0xf3, 0xd3, 0x89, 0x1f, 0x81, 0x1f, 0xd4, 0xe8, 0x38, 0x5d, 0x68, 0x24, 0xca, 0x5e, 0xe1, + /*0ed0:*/ 0xd4, 0x9e, 0xac, 0x17, 0x09, 0x0e, 0x88, 0x70, 0x7a, 0xae, 0xc1, 0xc8, 0x94, 0xf5, 0x6b, 0x21, + /*0ee0:*/ 0x69, 0xc5, 0xd2, 0xb6, 0x0b, 0xc7, 0x2e, 0x27, 0x0b, 0xf2, 0xfd, 0x74, 0x8b, 0xd6, 0xd9, 0x7d, + /*0ef0:*/ 0xcd, 0x58, 0x38, 0x20, 0xc8, 0x68, 0x48, 0x08, 0xbd, 0x18, 0x69, 0x0a, 0x4f, 0x04, 0x4e, 0xcf, + /*0f00:*/ 0x43, 0x7c, 0x6f, 0x11, 0x86, 0x5b, 0xbb, 0x5b, 0x25, 0x76, 0x77, 0xf0, 0x7b, 0xbd, 0xc7, 0xd2, + /*0f10:*/ 0x2c, 0x47, 0xf3, 0x13, 0x3c, 0xfd, 0xbc, 0xa3, 0x80, 0x22, 0xcf, 0x18, 0x92, 0x36, 0x09, 0x9a, + /*0f20:*/ 0x96, 0x72, 0x05, 0xb3, 0x67, 0xa2, 0x2a, 0xee, 0x1c, 0x7c, 0x84, 0x37, 0x1c, 0x0d, 0xaa, 0x02, + /*0f30:*/ 0xcd, 0xf6, 0xc6, 0x65, 0x14, 0x2d, 0xcd, 0x18, 0x42, 0xc2, 0x3f, 0xee, 0x09, 0xcd, 0x57, 0xf9, + /*0f40:*/ 0xdd, 0xa9, 0xd4, 0xf1, 0xb3, 0x97, 0x9f, 0xf7, 0xb7, 0x4a, 0x39, 0x9c, 0xb5, 0x64, 0xd2, 0x66, + /*0f50:*/ 0x58, 0x78, 0x69, 0x65, 0xfa, 0x21, 0xfd, 0x1e, 0x0f, 0xe2, 0x37, 0x57, 0xf9, 0x8d, 0x56, 0x34, + /*0f60:*/ 0x76, 0xb4, 0x07, 0xa4, 0x9b, 0xf4, 0x27, 0xf0, 0x26, 0x95, 0x23, 0xf5, 0x6a, 0x35, 0x99, 0x52, + /*0f70:*/ 0xac, 0x40, 0x51, 0xd2, 0xf2, 0x2b, 0x22, 0x54, 0xff, 0x45, 0xda, 0x84, 0x1e, 0x72, 0x53, 0xa3, + /*0f80:*/ 0xb2, 0x9e, 0xc0, 0x6e, 0x68, 0x62, 0xa1, 0x8a, 0x74, 0xa9, 0x90, 0xfa, 0x19, 0xd0, 0x25, 0x13, + /*0f90:*/ 0xd0, 0x3b, 0x59, 0xcd, 0x85, 0x5e, 0xc4, 0x4b, 0x7b, 0x3c, 0xd4, 0xc1, 0x91, 0xa9, 0xc0, 0xce, + /*0fa0:*/ 0x5a, 0xa6, 0xc0, 0x84, 0x0c, 0xea, 0xd5, 0xeb, 0xad, 0x6c, 0x81, 0x12, 0xb4, 0x3d, 0xac, 0x20, + /*0fb0:*/ 0xcc, 0x4c, 0x82, 0xa0, 0xc3, 0x77, 0x01, 0x20, 0xeb, 0xc0, 0xd5, 0x86, 0xa0, 0x79, 0x1f, 0x75, + /*0fc0:*/ 0x27, 0xf6, 0xd4, 0xae, 0x45, 0x0f, 0x42, 0x36, 0x7f, 0x96, 0x8a, 0x9a, 0x6d, 0x65, 0xa7, 0xa3, + /*0fd0:*/ 0x8b, 0x6a, 0xea, 0xb6, 0x72, 0xb8, 0x37, 0x3f, 0x3f, 0x64, 0x64, 0x84, 0xa3, 0x68, 0x44, 0x7a, + /*0fe0:*/ 0x10, 0xe6, 0x9c, 0x54, 0x54, 0x6b, 0xc9, 0x83, 0x88, 0x49, 0x71, 0x25, 0x7a, 0x01, 0x36, 0x15, + /*0ff0:*/ 0x8e, 0x84, 0x8c, 0x41, 0x8a, 0x07, 0xc3, 0x9a, 0x87, 0x16, 0x52, 0xe8, 0xe7, 0x49, 0xd3, 0xc8, + /*1000:*/ 0x8c, 0x4a, 0xfe, 0xd9, 0xd2, 0x8c, 0xac, 0x45, 0xf2, 0xc5, 0x57, 0x73, 0xf7, 0x47, 0x1c, 0x1d, + /*1010:*/ 0x33, 0x2a, 0x16, 0x87, 0xf2, 0xfc, 0xec, 0xcd, 0x41, 0x8f, 0x5e, 0xa4, 0x40, 0x75, 0x75, 0x33, + /*1020:*/ 0xcd, 0x40, 0x13, 0x77, 0xa6, 0xb7, 0x3a, 0xf4, 0xd5, 0x5c, 0x3d, 0x9e, 0xdc, 0xd2, 0x31, 0x4f, + /*1030:*/ 0x6a, 0x4f, 0xae, 0x9b, 0xa4, 0xe7, 0xb6, 0xb9, 0x3c, 0x87, 0x02, 0x5f, 0x48, 0xbe, 0x87, 0xa7, + /*1040:*/ 0x92, 0x52, 0x8f, 0x72, 0x15, 0xbe, 0xce, 0x65, 0xfe, 0x1d, 0x9e, 0xf8, 0x9f, 0xc3, 0x8e, 0x57, + /*1050:*/ 0xbf, 0xa7, 0xe6, 0x8f, 0xb1, 0x50, 0x8c, 0x19, 0x42, 0x8a, 0x4b, 0x6f, 0x4f, 0xcf, 0xe6, 0xd5, + /*1060:*/ 0x0d, 0xa3, 0xe7, 0x02, 0x2a, 0x35, 0x17, 0xc5, 0x74, 0xab, 0xa0, 0x6d, 0xee, 0x58, 0x35, 0x10, + /*1070:*/ 0xc6, 0xb6, 0xf1, 0x9b, 0xe2, 0x1e, 0xfc, 0xb8, 0x95, 0xcb, 0xbb, 0xb2, 0x0a, 0xc2, 0x1c, 0x67, + /*1080:*/ 0xa3, 0x1d, 0x62, 0x44, 0x96, 0xdb, 0x36, 0xf0, 0xfd, 0xd2, 0x48, 0x98, 0x92, 0xdc, 0xec, 0xf4, + /*1090:*/ 0x44, 0x81, 0xf8, 0x3a, 0x6f, 0x1e, 0x24, 0x14, 0x26, 0x0c, 0x15, 0x74, 0xf1, 0x45, 0x8d, 0xfb, + /*10a0:*/ 0xee, 0x32, 0x61, 0x72, 0x28, 0x41, 0xc4, 0x12, 0xc0, 0x37, 0xca, 0x7f, 0x70, 0x86, 0xce, 0xf5, + /*10b0:*/ 0x34, 0xcf, 0xc6, 0x99, 0x5a, 0x74, 0xc9, 0xad, 0xce, 0x7d, 0x35, 0x80, 0x00, 0x47, 0xbf, 0xdd, + /*10c0:*/ 0x49, 0x42, 0xde, 0x17, 0xf1, 0xf2, 0x77, 0x1f, 0x3e, 0x47, 0x7e, 0x18, 0x2a, 0xb5, 0xae, 0x43, + /*10d0:*/ 0x46, 0x7d, 0xa9, 0x10, 0xfa, 0x0a, 0xca, 0x54, 0xf6, 0x03, 0xe0, 0xa2, 0xd3, 0xe5, 0x2b, 0xca, + /*10e0:*/ 0xe5, 0x3b, 0x46, 0xb6, 0xe2, 0x0e, 0x36, 0x71, 0x68, 0xaf, 0x51, 0xc3, 0xd9, 0xeb, 0x64, 0x60, + /*10f0:*/ 0x78, 0x2c, 0xfc, 0x5f, 0x73, 0x1f, 0xa0, 0x8a, 0xa5, 0xe5, 0xc3, 0x90, 0x3e, 0xc8, 0x83, 0x56, + /*1100:*/ 0xda, 0x17, 0xee, 0x23, 0x3b, 0x7a, 0x6d, 0xfe, 0xef, 0xa9, 0xe8, 0x92, 0xc5, 0xa5, 0xd7, 0x5e, + /*1110:*/ 0x11, 0x18, 0xd8, 0xf5, 0x1c, 0xd8, 0x1d, 0x9b, 0x0b, 0x79, 0x91, 0xa3, 0x02, 0x7d, 0xa3, 0x0f, + /*1120:*/ 0xc2, 0xcc, 0xb0, 0x0d, 0xfc, 0x7e, 0xbd, 0x1b, 0xee, 0x42, 0x90, 0x65, 0x20, 0xd8, 0xad, 0x41, + /*1130:*/ 0x6b, 0xba, 0xb0, 0xeb, 0xaa, 0xa4, 0x1b, 0x80, 0x97, 0xa7, 0x88, 0x2e, 0xdc, 0xfd, 0x55, 0x65, + /*1140:*/ 0xe9, 0xf1, 0xb6, 0x9a, 0x27, 0xca, 0x23, 0x30, 0x46, 0x3e, 0x6f, 0x0c, 0x57, 0xc3, 0xd7, 0xca, + /*1150:*/ 0xe3, 0x99, 0xe6, 0x09, 0xa1, 0x5c, 0x72, 0xd8, 0x65, 0x08, 0x21, 0xfe, 0xb0, 0x48, 0xc9, 0xf9, + /*1160:*/ 0x42, 0xad, 0xda, 0x11, 0x70, 0x56, 0x0a, 0xa5, 0x3b, 0xd9, 0xee, 0xc7, 0x30, 0x9b, 0x23, 0xd9, + /*1170:*/ 0xa0, 0x82, 0x8d, 0xe0, 0x77, 0x67, 0x4a, 0x85, 0x8b, 0x52, 0x9a, 0x16, 0xf1, 0x6a, 0x74, 0x96, + /*1180:*/ 0xf7, 0xfe, 0xa6, 0x83, 0x72, 0xb6, 0x82, 0x78, 0x44, 0xd7, 0x51, 0x70, 0x92, 0x8e, 0x64, 0xc3, + /*1190:*/ 0x8c, 0x92, 0x18, 0xc9, 0x7a, 0x4d, 0x7e, 0xd1, 0x11, 0x53, 0xa6, 0x14, 0xed, 0x9c, 0x04, 0x01, + /*11a0:*/ 0xdb, 0x9f, 0xfd, 0x38, 0xc7, 0xf0, 0xb0, 0x70, 0x96, 0x7a, 0x67, 0xdc, 0x19, 0xeb, 0xaf, 0xf9, + /*11b0:*/ 0x25, 0x1f, 0xbc, 0xc0, 0xa4, 0xa8, 0x05, 0x7b, 0x9e, 0xd5, 0xe8, 0x1c, 0xe3, 0x71, 0xab, 0x92, + /*11c0:*/ 0xc9, 0xb4, 0xac, 0xb0, 0xe0, 0xf1, 0x59, 0x0b, 0x58, 0x3e, 0xca, 0x9d, 0x3e, 0xd0, 0xae, 0xeb, + /*11d0:*/ 0x51, 0xf0, 0x3c, 0xc0, 0xb9, 0x0b, 0xda, 0xba, 0x6b, 0xd8, 0x1f, 0x97, 0x68, 0x75, 0xbc, 0x88, + /*11e0:*/ 0x44, 0x5c, 0x37, 0xc7, 0x0c, 0xd7, 0xf1, 0x1d, 0x03, 0xe8, 0x0e, 0xa6, 0xae, 0xd0, 0x66, 0xa4, + /*11f0:*/ 0xd1, 0xf5, 0x52, 0xc8, 0x7b, 0x1e, 0xfe, 0x4b, 0x5d, 0xdd, 0xca, 0xad, 0x21, 0xde, 0x28, 0xf4, + /*1200:*/ 0x98, 0x98, 0x9c, 0xd2, 0x62, 0xd7, 0x00, 0xde, 0x6a, 0xf1, 0xa1, 0xe4, 0x1c, 0xaf, 0x1f, 0x9b, + /*1210:*/ 0x90, 0x8a, 0x40, 0x9d, 0x78, 0x64, 0x75, 0x60, 0xaa, 0xc7, 0xce, 0x63, 0x65, 0x1e, 0x65, 0x74, + /*1220:*/ 0x9b, 0x37, 0xb2, 0xb7, 0x54, 0xc5, 0x6d, 0xce, 0x1d, 0x08, 0x3a, 0x01, 0x07, 0xc1, 0x80, 0x21, + /*1230:*/ 0x1e, 0x25, 0xbe, 0x97, 0xbb, 0x53, 0x3f, 0x8a, 0xcf, 0x1c, 0xfe, 0x7f, 0x93, 0xfb, 0x0c, 0x5a, + /*1240:*/ 0x52, 0xf2, 0x63, 0xba, 0xd0, 0xa5, 0x5b, 0xd8, 0x98, 0xb8, 0x95, 0xd4, 0xc8, 0xb1, 0x04, 0x99, + /*1250:*/ 0x83, 0xb4, 0xcb, 0xe4, 0x3a, 0xea, 0x02, 0x5e, 0x88, 0x6e, 0xfd, 0xf8, 0x79, 0x5f, 0x03, 0x99, + /*1260:*/ 0x56, 0xea, 0x25, 0xc8, 0x08, 0x1b, 0x6a, 0x8d, 0x28, 0xe6, 0x08, 0x47, 0x67, 0xf5, 0xc7, 0x52, + /*1270:*/ 0x60, 0x08, 0x42, 0x5f, 0x58, 0x01, 0x0a, 0xf2, 0xa3, 0xa3, 0x1e, 0x91, 0x17, 0x5d, 0xe8, 0xe4, + /*1280:*/ 0x14, 0x10, 0x67, 0xc3, 0x1c, 0x3e, 0x71, 0x23, 0x45, 0xf3, 0xc9, 0x73, 0xc9, 0xc5, 0x94, 0x67, + /*1290:*/ 0x51, 0x22, 0xa5, 0xf9, 0x45, 0xce, 0x35, 0x20, 0xf7, 0xf7, 0x1a, 0xea, 0x52, 0x25, 0x17, 0xb1, + /*12a0:*/ 0xec, 0xc5, 0x4e, 0xe9, 0x03, 0x8f, 0xc2, 0x0c, 0xa3, 0x00, 0xd9, 0xe8, 0xe8, 0xb2, 0xbe, 0xaf, + /*12b0:*/ 0xcb, 0xda, 0xf8, 0xbe, 0x2d, 0x2e, 0x92, 0x23, 0x3b, 0x9b, 0x27, 0x65, 0x7f, 0x03, 0xc7, 0x8e, + /*12c0:*/ 0x9c, 0x86, 0x66, 0xf4, 0x67, 0xb4, 0x7b, 0x7d, 0x44, 0x73, 0x8e, 0x7e, 0x32, 0x87, 0x58, 0xa9, + /*12d0:*/ 0xcf, 0x92, 0xc8, 0x07, 0x41, 0xc5, 0x41, 0x17, 0x34, 0xed, 0x3b, 0xd6, 0x30, 0xca, 0x66, 0x50, + /*12e0:*/ 0x4a, 0x1e, 0x68, 0xcc, 0x91, 0xe2, 0x78, 0x38, 0xfc, 0x04, 0x72, 0xfb, 0xbb, 0x63, 0x4f, 0x30, + /*12f0:*/ 0xc2, 0xbb, 0x4a, 0xd5, 0xc9, 0x0e, 0x53, 0xc7, 0x5c, 0x83, 0x1d, 0xc0, 0x42, 0x22, 0xfa, 0xba, + /*1300:*/ 0x31, 0xfa, 0x85, 0x75, 0x8e, 0x7b, 0x1b, 0x63, 0x2a, 0x13, 0x2a, 0x33, 0x01, 0x86, 0xc0, 0xdd, + /*1310:*/ 0xfd, 0x14, 0xc5, 0x84, 0x9b, 0xcc, 0xa5, 0x89, 0x31, 0x27, 0x6e, 0x3b, 0xc6, 0xb0, 0xf2, 0x23, + /*1320:*/ 0x61, 0x52, 0x5b, 0x3a, 0xf2, 0x63, 0x3a, 0xc2, 0x6e, 0xaf, 0x98, 0x97, 0x5c, 0xbc, 0xd4, 0xf3, + /*1330:*/ 0xd4, 0x98, 0x25, 0x73, 0xc6, 0xbb, 0x64, 0x85, 0x88, 0x95, 0x0d, 0xcb, 0xaa, 0xfd, 0x57, 0x9c, + /*1340:*/ 0xa8, 0x4f, 0x32, 0xa4, 0xce, 0xf0, 0x0d, 0x1c, 0xac, 0x9a, 0x53, 0x84, 0xb8, 0x4e, 0x48, 0xc0, + /*1350:*/ 0xfb, 0xc2, 0x48, 0x1e, 0x76, 0xb4, 0xf2, 0x7c, 0xde, 0xe1, 0xc4, 0xf4, 0xb7, 0x09, 0x19, 0x7e, + /*1360:*/ 0x0d, 0x40, 0x92, 0xa3, 0x4e, 0x14, 0xcf, 0x15, 0x17, 0x6c, 0x81, 0x55, 0xaa, 0xce, 0xa6, 0x8b, + /*1370:*/ 0xbf, 0xd6, 0x30, 0x06, 0xa0, 0x1b, 0x18, 0x40, 0xca, 0x69, 0xab, 0xe2, 0x3e, 0xa5, 0xf2, 0x85, + /*1380:*/ 0x43, 0x54, 0x76, 0x5d, 0xe3, 0x96, 0xd4, 0x39, 0x47, 0x70, 0x1a, 0x71, 0x94, 0xcd, 0x9d, 0xfa, + /*1390:*/ 0xb0, 0x89, 0xab, 0x7a, 0x2e, 0x49, 0xb5, 0x34, 0x66, 0xbb, 0xdc, 0x6e, 0x5a, 0x1d, 0x65, 0x20, + /*13a0:*/ 0xce, 0x49, 0x1d, 0xeb, 0x73, 0x83, 0x00, 0x05, 0xb0, 0x5a, 0x56, 0xc3, 0xa5, 0x0f, 0x03, 0xb0, + /*13b0:*/ 0xdb, 0xb5, 0xf0, 0x61, 0x2c, 0xfd, 0x37, 0x38, 0x7d, 0xf8, 0xc4, 0x09, 0xd0, 0xf3, 0xdc, 0x62, + /*13c0:*/ 0xca, 0x29, 0x71, 0xb9, 0x44, 0xc4, 0x24, 0x21, 0xc5, 0xfe, 0x9c, 0xd9, 0xd4, 0x89, 0x44, 0x00, + /*13d0:*/ 0x20, 0xae, 0xd9, 0xae, 0xd6, 0xea, 0x5d, 0x04, 0x35, 0x4c, 0x09, 0x47, 0xfa, 0x85, 0x7f, 0x1e, + /*13e0:*/ 0x52, 0x62, 0xb7, 0x8a, 0x05, 0xc5, 0x47, 0x39, 0x2d, 0xe8, 0xf0, 0xf7, 0x57, 0x67, 0xf5, 0xda, + /*13f0:*/ 0x47, 0xe9, 0x10, 0x84, 0xb4, 0xf9, 0x3f, 0x8d, 0xae, 0xdd, 0xce, 0x76, 0xc9, 0xfe, 0x0b, 0x52, + /*1400:*/ 0x63, 0x1d, 0xde, 0x2a, 0x25, 0x54, 0x9c, 0xab, 0x2b, 0x52, 0x30, 0x8c, 0x80, 0xe8, 0x50, 0xe0, + /*1410:*/ 0x2b, 0x6b, 0xf5, 0x42, 0xbc, 0x26, 0x85, 0x9f, 0xd3, 0x9a, 0xbe, 0x41, 0xd2, 0xf1, 0xa6, 0xd7, + /*1420:*/ 0xf2, 0xcd, 0x72, 0xab, 0x8d, 0x4c, 0x46, 0x7b, 0xaf, 0x82, 0x58, 0xd7, 0x2f, 0x16, 0x07, 0x28, + /*1430:*/ 0xf0, 0x3a, 0x7e, 0x85, 0xc3, 0xf3, 0xe8, 0xe5, 0x00, 0x06, 0x00, 0xb5, 0x97, 0x19, 0x9f, 0xde, + /*1440:*/ 0x99, 0x1f, 0xf5, 0x08, 0x97, 0x02, 0x6e, 0x60, 0xc5, 0xa7, 0x77, 0x99, 0xcf, 0x04, 0xa6, 0x2f, + /*1450:*/ 0xb5, 0xca, 0xff, 0x4b, 0xd7, 0xee, 0xcc, 0x90, 0x6c, 0x77, 0xac, 0x95, 0x3f, 0x24, 0xa5, 0x50, + /*1460:*/ 0x00, 0x9d, 0xf5, 0x7e, 0xed, 0x37, 0xa8, 0xd6, 0xd7, 0xf2, 0xf7, 0x14, 0xb8, 0x2e, 0x7e, 0x1f, + /*1470:*/ 0xa3, 0x02, 0xec, 0x4c, 0xf5, 0xc6, 0x7b, 0x03, 0x99, 0x3b, 0x9d, 0xaf, 0xad, 0xe2, 0x44, 0x7c, + /*1480:*/ 0x89, 0xd6, 0xd3, 0x09, 0x0c, 0xed, 0x48, 0x17, 0x3e, 0xcc, 0xce, 0x08, 0x1d, 0x2d, 0x47, 0x36, + /*1490:*/ 0xf8, 0x6c, 0x37, 0xcd, 0x7c, 0xc7, 0xf3, 0x06, 0x17, 0x8c, 0xca, 0xfe, 0x36, 0x4c, 0xb8, 0x10, + /*14a0:*/ 0x08, 0xe6, 0xd5, 0xa8, 0x99, 0x56, 0x48, 0xe0, 0x18, 0x44, 0x72, 0x63, 0x3d, 0x09, 0xd5, 0xd9, + /*14b0:*/ 0x5a, 0xe1, 0x4c, 0x38, 0xd1, 0xdc, 0x0b, 0x47, 0xd3, 0x8a, 0x1a, 0xf8, 0xe8, 0x75, 0x3b, 0x1a, + /*14c0:*/ 0x9c, 0xcb, 0x89, 0x37, 0xc4, 0xa6, 0xa3, 0xbe, 0xf6, 0xe5, 0x40, 0xd3, 0x44, 0x1d, 0xea, 0x92, + /*14d0:*/ 0xfa, 0xf2, 0xd6, 0x0d, 0x52, 0xf0, 0x8c, 0x0b, 0x3a, 0x55, 0x75, 0x7a, 0xfc, 0xef, 0x81, 0xdb, + /*14e0:*/ 0xc5, 0x97, 0x81, 0xe3, 0x32, 0xd8, 0x8a, 0x49, 0xf0, 0x14, 0x28, 0x14, 0xac, 0x7a, 0xc6, 0x21, + /*14f0:*/ 0xe2, 0xa9, 0x61, 0xc4, 0xa5, 0xd2, 0x8d, 0xd6, 0x36, 0xba, 0x4f, 0x20, 0x43, 0xeb, 0xac, 0xef, + /*1500:*/ 0x6a, 0x81, 0x0a, 0x54, 0x37, 0x35, 0x34, 0x09, 0xce, 0xdc, 0x78, 0x43, 0x00, 0xc5, 0x46, 0x0e, + /*1510:*/ 0x17, 0xb1, 0x7a, 0x51, 0x96, 0x54, 0xee, 0x24, 0x32, 0xf9, 0x09, 0x66, 0xff, 0xf6, 0xb9, 0x9f, + /*1520:*/ 0x06, 0xa4, 0x55, 0x8c, 0x3b, 0x9d, 0xcd, 0x31, 0x01, 0x33, 0x61, 0xeb, 0xd3, 0x45, 0x49, 0x34, + /*1530:*/ 0x2e, 0xff, 0xa3, 0x7f, 0xf5, 0xb0, 0x37, 0x00, 0x31, 0x84, 0xb1, 0xa1, 0x9f, 0xa4, 0xdb, 0xc7, + /*1540:*/ 0xa2, 0xd9, 0x23, 0x4c, 0xf0, 0x09, 0x57, 0x9b, 0x4b, 0xbc, 0x6b, 0xe4, 0x15, 0x55, 0x9f, 0x3d, + /*1550:*/ 0x97, 0xa6, 0xab, 0x0a, 0x86, 0xde, 0xd3, 0x83, 0xd2, 0x81, 0x21, 0x75, 0x60, 0x66, 0xd8, 0xa1, + /*1560:*/ 0xd0, 0xdb, 0x08, 0x42, 0xe6, 0xf1, 0xeb, 0x6f, 0x59, 0xe2, 0x0f, 0xd1, 0x00, 0x3a, 0x09, 0x86, + /*1570:*/ 0x61, 0x8f, 0x3c, 0x6d, 0x02, 0x48, 0x41, 0x1a, 0x9b, 0xcd, 0x33, 0xd6, 0xbe, 0x15, 0x88, 0x2a, + /*1580:*/ 0x94, 0xf9, 0xc9, 0xda, 0x03, 0xb3, 0x1c, 0xaa, 0x22, 0x19, 0xa9, 0x9e, 0xdd, 0xe7, 0x7e, 0x92, + /*1590:*/ 0xdf, 0x06, 0xd7, 0x0c, 0xe0, 0x19, 0xa8, 0xec, 0x9a, 0x33, 0xfa, 0x30, 0xa7, 0xe9, 0xc9, 0x3d, + /*15a0:*/ 0x6a, 0x14, 0x89, 0x5b, 0xe9, 0x19, 0xfd, 0xf5, 0xdb, 0xfe, 0x70, 0x4a, 0x09, 0x18, 0x9a, 0x90, + /*15b0:*/ 0x16, 0x88, 0xb2, 0x60, 0x6e, 0x34, 0xa5, 0x22, 0x7e, 0x2d, 0x5a, 0x37, 0x0e, 0xbe, 0x71, 0x7e, + /*15c0:*/ 0x5a, 0xd4, 0x38, 0x0b, 0x25, 0x49, 0x4d, 0x07, 0x47, 0xee, 0x3d, 0xfe, 0x8f, 0x81, 0xdb, 0xb2, + /*15d0:*/ 0xda, 0x0d, 0x71, 0xbc, 0x10, 0x36, 0x69, 0xd5, 0xec, 0xdd, 0x57, 0xc4, 0xeb, 0x52, 0xd6, 0x2c, + /*15e0:*/ 0xce, 0xaf, 0xe7, 0xae, 0xfa, 0xf6, 0x22, 0x8e, 0x72, 0x39, 0xcb, 0x48, 0x0f, 0x76, 0x9c, 0x51, + /*15f0:*/ 0x54, 0x7b, 0x7c, 0x2d, 0x5d, 0x4e, 0x54, 0x82, 0xf4, 0xfd, 0x6b, 0xdf, 0x97, 0xed, 0xec, 0x68, + /*1600:*/ 0xb7, 0x03, 0x26, 0x74, 0x46, 0xcc, 0x3f, 0x6d, 0x49, 0x52, 0xce, 0xe2, 0x82, 0x12, 0x79, 0x85, + /*1610:*/ 0x95, 0xb6, 0x4c, 0x9e, 0x61, 0xd9, 0xc4, 0xaa, 0xd6, 0xcd, 0x0b, 0xad, 0x78, 0xd8, 0xed, 0x07, + /*1620:*/ 0x5c, 0x8b, 0xe4, 0x1c, 0x86, 0x85, 0xf2, 0xee, 0x98, 0x81, 0x4f, 0xa9, 0x74, 0x22, 0xd5, 0x7f, + /*1630:*/ 0xf3, 0x48, 0xec, 0x30, 0xde, 0x23, 0x10, 0xa8, 0x6e, 0x1e, 0xbb, 0x6b, 0x31, 0xd1, 0x26, 0x48, + /*1640:*/ 0xac, 0x4a, 0x19, 0x66, 0xef, 0x2e, 0x5f, 0xd9, 0x7a, 0xc6, 0xfa, 0xc3, 0x06, 0xf0, 0xfe, 0x6c, + /*1650:*/ 0xd3, 0xf5, 0xdd, 0x6b, 0x09, 0x39, 0x17, 0x99, 0x29, 0xff, 0x24, 0x51, 0x3b, 0x06, 0x35, 0x92, + /*1660:*/ 0xda, 0x9f, 0x9f, 0x32, 0x40, 0x5c, 0x05, 0x60, 0x18, 0xd5, 0xb4, 0xd7, 0x9d, 0x7f, 0xd8, 0x5b, + /*1670:*/ 0x3e, 0x67, 0xee, 0xaa, 0x12, 0xd0, 0xd1, 0x61, 0x78, 0x60, 0x28, 0x63, 0xd8, 0x91, 0xe1, 0x86, + /*1680:*/ 0x78, 0x01, 0x62, 0x55, 0xa8, 0x5c, 0x7d, 0xf5, 0x80, 0x97, 0x16, 0xaa, 0xcc, 0x62, 0xec, 0x35, + /*1690:*/ 0x18, 0x53, 0xda, 0xfc, 0x3b, 0x5b, 0x2f, 0xe5, 0xd0, 0xb9, 0xba, 0x31, 0xed, 0xbe, 0xe0, 0xf1, + /*16a0:*/ 0xfa, 0x54, 0x8f, 0x1d, 0x1a, 0xfc, 0xfb, 0xe0, 0xbb, 0x30, 0x0c, 0x6a, 0xf7, 0x80, 0x27, 0xbb, + /*16b0:*/ 0xb2, 0xc3, 0x38, 0xb9, 0x01, 0x2c, 0x93, 0x00, 0xac, 0xb0, 0xef, 0x9a, 0x44, 0x7d, 0xfb, 0x0b, + /*16c0:*/ 0x91, 0x36, 0xac, 0xb7, 0x0a, 0xe9, 0x29, 0xdc, 0x82, 0x8a, 0x76, 0x75, 0x12, 0xec, 0x81, 0x20, + /*16d0:*/ 0x55, 0x2b, 0x67, 0x28, 0xa6, 0x1a, 0x73, 0xde, 0x82, 0xac, 0x0f, 0xa6, 0xd8, 0xa6, 0x96, 0xf7, + /*16e0:*/ 0xe6, 0x27, 0x33, 0xa3, 0x4d, 0x37, 0x66, 0xbd, 0xcf, 0xa3, 0x70, 0x4f, 0xae, 0xb3, 0x55, 0x92, + /*16f0:*/ 0x8b, 0x7c, 0x5f, 0xd3, 0x5e, 0x8a, 0x84, 0xf8, 0x30, 0x95, 0x16, 0xb5, 0xfc, 0xc2, 0x23, 0x25, + /*1700:*/ 0x65, 0xdb, 0x48, 0xcd, 0xfc, 0xc4, 0xbf, 0xca, 0xa3, 0xd3, 0x8b, 0xe4, 0x5c, 0x7a, 0x97, 0x5d, + /*1710:*/ 0xa8, 0xc5, 0xf9, 0x1a, 0x91, 0x60, 0x3b, 0x20, 0x77, 0xe7, 0x35, 0x99, 0x43, 0x47, 0x1c, 0x96, + /*1720:*/ 0x54, 0xeb, 0x9f, 0xc0, 0x7e, 0xb0, 0xcd, 0x9f, 0x62, 0xec, 0x5c, 0xd9, 0x37, 0xc8, 0x4d, 0x92, + /*1730:*/ 0xc0, 0x76, 0xfa, 0x3b, 0xbd, 0x4b, 0xd1, 0x1f, 0x43, 0xd9, 0x55, 0x7a, 0xb8, 0x7c, 0x7b, 0xa3, + /*1740:*/ 0x0c, 0x26, 0x5f, 0x6b, 0x7c, 0x38, 0xc2, 0x72, 0x36, 0xd7, 0xc0, 0x5c, 0x57, 0x69, 0xd1, 0x1a, + /*1750:*/ 0xc6, 0xda, 0x20, 0x3a, 0x2a, 0x43, 0x2b, 0x32, 0x86, 0x37, 0x8d, 0x44, 0x20, 0x0c, 0xcf, 0xb4, + /*1760:*/ 0xe8, 0x7b, 0x38, 0xc2, 0xea, 0x4f, 0xd2, 0xf3, 0xe0, 0x44, 0x11, 0xa4, 0x60, 0x11, 0xea, 0x09, + /*1770:*/ 0x3a, 0x04, 0x0b, 0xe8, 0xcc, 0x55, 0xbf, 0xa2, 0xe7, 0xee, 0x4e, 0xbf, 0xc6, 0x10, 0xbf, 0x0c, + /*1780:*/ 0xb9, 0x24, 0xa9, 0x8c, 0x46, 0x81, 0xc7, 0x44, 0x3e, 0x63, 0x50, 0xce, 0x4c, 0x91, 0xfc, 0xe8, + /*1790:*/ 0x2e, 0x97, 0x76, 0xc5, 0xf4, 0xd0, 0x36, 0x5a, 0x6c, 0x30, 0xfe, 0xc1, 0x02, 0x86, 0x07, 0xd3, + /*17a0:*/ 0xeb, 0x57, 0x6d, 0x43, 0xf9, 0xfa, 0xc7, 0x39, 0xd5, 0xfa, 0x70, 0xa4, 0x55, 0x7c, 0x4e, 0x93, + /*17b0:*/ 0xca, 0xd9, 0x78, 0xcb, 0xa2, 0x1d, 0x79, 0x96, 0x55, 0x16, 0x94, 0x8d, 0x74, 0xda, 0xa5, 0x1c, + /*17c0:*/ 0xf6, 0xa3, 0xcc, 0x33, 0x0e, 0x3a, 0x29, 0xa0, 0xf9, 0x7d, 0x8b, 0x13, 0x6e, 0x7f, 0x02, 0x4a, + /*17d0:*/ 0x50, 0xd3, 0x7c, 0x1e, 0x09, 0x3c, 0xd0, 0x03, 0xad, 0x0d, 0xb2, 0xfa, 0xa1, 0x8b, 0xd3, 0x69, + /*17e0:*/ 0x91, 0x7a, 0x6a, 0xe2, 0x66, 0x1a, 0xe4, 0x3d, 0xdf, 0xab, 0x3f, 0xfa, 0x39, 0xb3, 0x66, 0x0a, + /*17f0:*/ 0x80, 0x1a, 0x07, 0x75, 0xe6, 0xfd, 0x9b, 0x9b, 0xfe, 0xf0, 0x9c, 0x3f, 0x9e, 0x43, 0xc8, 0xe3, + /*1800:*/ 0xbd, 0xb4, 0x32, 0x25, 0x4f, 0x96, 0x8f, 0xba, 0x46, 0x34, 0xdc, 0x9e, 0x18, 0xe8, 0x16, 0x9a, + /*1810:*/ 0xc1, 0x8c, 0x41, 0x16, 0x2d, 0x88, 0x0b, 0x1d, 0x6f, 0x2a, 0xbf, 0x99, 0x85, 0x14, 0xa3, 0x89, + /*1820:*/ 0x86, 0xac, 0xf6, 0xe3, 0x7b, 0xcf, 0x48, 0xec, 0xe0, 0x74, 0xbc, 0x96, 0x95, 0x4d, 0x76, 0x1d, + /*1830:*/ 0x5e, 0x76, 0x49, 0x63, 0x62, 0x75, 0x21, 0x87, 0x4d, 0x62, 0xb3, 0xfe, 0x0b, 0xf5, 0xed, 0x8c, + /*1840:*/ 0x95, 0x9c, 0xd3, 0xc5, 0x5f, 0x14, 0xd8, 0x4e, 0x41, 0xaa, 0xd9, 0x1f, 0xb3, 0x67, 0x35, 0xaf, + /*1850:*/ 0x0d, 0x3a, 0xcb, 0xe5, 0xcc, 0x84, 0xc4, 0xab, 0x45, 0x38, 0xa9, 0x45, 0x66, 0x12, 0x75, 0x93, + /*1860:*/ 0xc0, 0x36, 0x42, 0x88, 0xb6, 0x5e, 0x3f, 0xae, 0x67, 0xe5, 0x5f, 0xe2, 0xc1, 0x93, 0xca, 0x84, + /*1870:*/ 0x55, 0xa1, 0xda, 0xec, 0x53, 0xe8, 0x74, 0xc2, 0xdb, 0x25, 0xdf, 0x8a, 0xfb, 0xfa, 0xf0, 0x14, + /*1880:*/ 0xf7, 0x92, 0x67, 0xbb, 0x0a, 0x5e, 0xfa, 0x53, 0x4f, 0x5f, 0xf9, 0x05, 0x7b, 0xbd, 0x02, 0x3e, + /*1890:*/ 0x30, 0xdf, 0x90, 0xef, 0x3d, 0x84, 0x0b, 0x71, 0x8b, 0x08, 0xc3, 0xae, 0xb7, 0xdb, 0xe1, 0x19, + /*18a0:*/ 0x56, 0x85, 0x65, 0x98, 0x53, 0x32, 0x4b, 0xe7, 0xd5, 0x01, 0x4f, 0x02, 0xf2, 0xa1, 0xb6, 0x61, + /*18b0:*/ 0xf9, 0xa2, 0xd1, 0xb0, 0xb7, 0x87, 0x21, 0x62, 0x60, 0x7a, 0x91, 0x14, 0x7a, 0x11, 0x6d, 0xb4, + /*18c0:*/ 0x79, 0x40, 0xa4, 0x9a, 0x6d, 0xcf, 0xe2, 0x6d, 0x8a, 0xd2, 0x7d, 0xfb, 0x2b, 0x11, 0xfa, 0x92, + /*18d0:*/ 0xe3, 0x6f, 0x47, 0x7f, 0xa2, 0x41, 0x3b, 0x90, 0x36, 0x68, 0x90, 0x96, 0xf3, 0xf5, 0x27, 0xeb, + /*18e0:*/ 0x99, 0x6b, 0x31, 0x5b, 0x94, 0x7d, 0xa6, 0x2d, 0xdf, 0xfd, 0xee, 0x2c, 0x54, 0x59, 0x1c, 0xb7, + /*18f0:*/ 0xa9, 0xd0, 0x9a, 0x43, 0x82, 0x05, 0x47, 0xba, 0x26, 0xe3, 0x7d, 0x98, 0xd9, 0x4e, 0xe9, 0xed, + /*1900:*/ 0xbb, 0x30, 0x27, 0xb0, 0xed, 0xc4, 0x95, 0xb5, 0x64, 0x98, 0x66, 0xe6, 0x44, 0x9d, 0x63, 0x3f, + /*1910:*/ 0xb8, 0xdd, 0x35, 0xed, 0x79, 0x9c, 0x30, 0xd0, 0x5a, 0xfc, 0x14, 0xcf, 0x6b, 0x05, 0x48, 0x5d, + /*1920:*/ 0x35, 0xd7, 0xd6, 0x8c, 0xce, 0xee, 0x21, 0x73, 0x01, 0xeb, 0x8a, 0x14, 0x01, 0x1c, 0xee, 0x8a, + /*1930:*/ 0xbc, 0x7a, 0xbb, 0xbb, 0x7b, 0x89, 0x8a, 0xfa, 0x6a, 0xf8, 0x90, 0x6f, 0x07, 0xba, 0x77, 0x7b, + /*1940:*/ 0x27, 0x01, 0xfd, 0x67, 0x52, 0xcf, 0xf5, 0xc2, 0xa7, 0x2d, 0x79, 0xbf, 0x50, 0x7a, 0xc9, 0x1c, + /*1950:*/ 0x6a, 0x6f, 0x38, 0xa1, 0x76, 0x80, 0x22, 0x01, 0xa8, 0x4e, 0x6c, 0x8d, 0x64, 0x55, 0x63, 0x89, + /*1960:*/ 0xf8, 0xe4, 0x59, 0x37, 0xf7, 0xae, 0x6b, 0x61, 0x98, 0x7e, 0x43, 0xdd, 0xba, 0xf0, 0x07, 0x28, + /*1970:*/ 0x91, 0xe7, 0x8a, 0xf7, 0xe4, 0xaa, 0x86, 0x0b, 0x26, 0x1e, 0x3c, 0x45, 0x9b, 0x84, 0xd0, 0xe0, + /*1980:*/ 0xcf, 0x81, 0x1b, 0x61, 0x9b, 0xef, 0xde, 0x8c, 0xc0, 0xa4, 0x83, 0xe7, 0x31, 0x18, 0xf1, 0x66, + /*1990:*/ 0x2d, 0x65, 0x6f, 0x2e, 0xfb, 0x60, 0x99, 0xa4, 0xbd, 0x20, 0x6b, 0x83, 0xe6, 0x2d, 0x93, 0xbc, + /*19a0:*/ 0x9b, 0xce, 0xa5, 0x1e, 0x9b, 0xda, 0xb4, 0x69, 0x89, 0xb9, 0x42, 0x3a, 0x1a, 0xcc, 0x13, 0x7f, + /*19b0:*/ 0x5e, 0xc6, 0xa2, 0x4c, 0x8a, 0x82, 0xc0, 0x19, 0x2f, 0xe0, 0xac, 0x58, 0xb4, 0xbc, 0x69, 0x2f, + /*19c0:*/ 0x11, 0xa2, 0x85, 0x0b, 0x72, 0x32, 0x74, 0x83, 0x11, 0x58, 0xe0, 0x7a, 0xce, 0x55, 0xda, 0x6e, + /*19d0:*/ 0x2f, 0xe9, 0x6c, 0x62, 0xdc, 0xbd, 0x89, 0x0d, 0xfd, 0x7a, 0x32, 0xb9, 0x28, 0x7a, 0xc2, 0xb6, + /*19e0:*/ 0x10, 0x67, 0xf1, 0x6a, 0xe2, 0x04, 0x17, 0x9d, 0x2d, 0xe0, 0xde, 0xc3, 0xad, 0xff, 0xb6, 0x4b, + /*19f0:*/ 0x11, 0x3d, 0x53, 0x21, 0x6a, 0xe6, 0x30, 0xad, 0x15, 0x7d, 0x13, 0x28, 0x3c, 0xea, 0x29, 0x32, + /*1a00:*/ 0xa7, 0xb6, 0x67, 0x07, 0x1f, 0x0e, 0x72, 0xe8, 0xd7, 0xcf, 0x59, 0xb5, 0x68, 0xf4, 0xb6, 0x81, + /*1a10:*/ 0xed, 0xf5, 0xb8, 0xab, 0xfb, 0xee, 0x6c, 0x94, 0xff, 0x03, 0xa9, 0xc8, 0x1a, 0x30, 0x9b, 0x16, + /*1a20:*/ 0xff, 0x9b, 0x40, 0x57, 0x70, 0x9f, 0xb9, 0xcb, 0xf6, 0x79, 0x88, 0xee, 0x3f, 0xf1, 0xa0, 0x8d, + /*1a30:*/ 0x67, 0x26, 0x90, 0x71, 0x84, 0x34, 0xce, 0x7b, 0xaa, 0x83, 0xd1, 0x00, 0x33, 0xfd, 0x4d, 0x86, + /*1a40:*/ 0x55, 0x53, 0xc0, 0x6b, 0x3a, 0x44, 0xd8, 0xdb, 0x40, 0x24, 0xb8, 0xef, 0x7d, 0x2b, 0x7d, 0x03, + /*1a50:*/ 0x79, 0xaf, 0x0f, 0x86, 0x21, 0x4e, 0x41, 0xc6, 0x60, 0x21, 0x8e, 0x58, 0x26, 0x1b, 0x72, 0xfe, + /*1a60:*/ 0x71, 0x21, 0x0e, 0xa1, 0xd6, 0xf7, 0x41, 0x50, 0x68, 0xca, 0x3f, 0x62, 0xdf, 0xd1, 0x41, 0xe1, + /*1a70:*/ 0xdc, 0xc2, 0x7f, 0x82, 0xd8, 0x6e, 0x3e, 0xf9, 0x30, 0xee, 0x71, 0xcd, 0x1f, 0x0f, 0x4f, 0xb3, + /*1a80:*/ 0x03, 0xfb, 0x20, 0x75, 0x91, 0x1a, 0xbf, 0xb0, 0xc1, 0xc4, 0x65, 0x4b, 0x65, 0x52, 0x2a, 0x13, + /*1a90:*/ 0xb1, 0xb1, 0xc8, 0xe1, 0x9e, 0xc5, 0x78, 0x40, 0xae, 0xf6, 0x57, 0x12, 0xc9, 0x49, 0x24, 0xee, + /*1aa0:*/ 0x87, 0x6b, 0xa0, 0x0c, 0x0f, 0xb1, 0xbe, 0xac, 0xcb, 0x8b, 0xe9, 0x3f, 0x1b, 0xaa, 0x79, 0x9f, + /*1ab0:*/ 0xc4, 0xff, 0xac, 0xf9, 0xf7, 0x53, 0xab, 0xa8, 0xf2, 0x00, 0xc0, 0xa4, 0x24, 0x22, 0x97, 0x58, + /*1ac0:*/ 0x0c, 0x39, 0x96, 0xe2, 0xe9, 0xcf, 0x62, 0xcb, 0x8f, 0xdb, 0xa8, 0xdd, 0x5a, 0x5c, 0xb2, 0xce, + /*1ad0:*/ 0xae, 0x84, 0x2a, 0x68, 0x7c, 0x38, 0x56, 0x78, 0xe1, 0xa6, 0x7c, 0x6b, 0x8b, 0x47, 0x07, 0xe4, + /*1ae0:*/ 0xc7, 0x54, 0x9a, 0x76, 0x34, 0xe5, 0xf5, 0x23, 0x49, 0x15, 0x90, 0x73, 0xa3, 0x0a, 0x5c, 0x4b, + /*1af0:*/ 0x99, 0x6f, 0x7b, 0x0f, 0x61, 0x9e, 0xf9, 0xa5, 0x95, 0x42, 0xbd, 0x19, 0xa5, 0x31, 0x08, 0xdd, + /*1b00:*/ 0x9a, 0x23, 0xdb, 0x2c, 0x19, 0x50, 0xbb, 0xc3, 0x3b, 0x51, 0xec, 0xd9, 0x38, 0x5b, 0x1b, 0x58, + /*1b10:*/ 0x79, 0xfb, 0xa2, 0x94, 0x6a, 0xe1, 0xd9, 0x03, 0x58, 0xd2, 0xb7, 0xfe, 0xc2, 0x99, 0xf4, 0x45, + /*1b20:*/ 0x28, 0x00, 0x11, 0x41, 0x67, 0x09, 0x1a, 0x82, 0x48, 0x11, 0x25, 0x82, 0x66, 0xd9, 0x08, 0xe4, + /*1b30:*/ 0xf3, 0x4f, 0xf1, 0x4c, 0x40, 0x78, 0xb7, 0x40, 0x5f, 0x16, 0xd6, 0x4d, 0x9d, 0x25, 0xcb, 0xff, + /*1b40:*/ 0xe1, 0xe7, 0xaf, 0x0c, 0x5b, 0x9a, 0x57, 0xf6, 0xc1, 0xd0, 0x1c, 0x20, 0x68, 0x9a, 0x51, 0x7a, + /*1b50:*/ 0xbd, 0xcb, 0x96, 0x21, 0x57, 0xe4, 0x70, 0x9d, 0x9c, 0xda, 0xaa, 0x89, 0x0d, 0xc2, 0x53, 0xa9, + /*1b60:*/ 0x6b, 0x78, 0x12, 0xeb, 0x77, 0x4d, 0x5c, 0xe4, 0x5e, 0x2b, 0x30, 0x0f, 0xb3, 0x08, 0x9f, 0x68, + /*1b70:*/ 0xf1, 0xb4, 0x37, 0xac, 0xed, 0x39, 0x0e, 0x59, 0xfa, 0xc4, 0xa8, 0xfa, 0xcc, 0x76, 0x77, 0xba, + /*1b80:*/ 0x15, 0xae, 0xbe, 0x0f, 0x89, 0xb7, 0x3c, 0xf5, 0x27, 0x2c, 0xfc, 0x05, 0xb2, 0x32, 0x40, 0x61, + /*1b90:*/ 0x0d, 0xdd, 0x0a, 0x8a, 0x0c, 0xa5, 0x7e, 0x2c, 0x5e, 0x50, 0x6b, 0xa1, 0x3b, 0x87, 0x23, 0xa0, + /*1ba0:*/ 0xa9, 0x4c, 0x46, 0x4c, 0xfb, 0xe2, 0x39, 0x3a, 0x3b, 0x43, 0x9b, 0x24, 0x8b, 0x4c, 0xae, 0x25, + /*1bb0:*/ 0x81, 0x72, 0x5e, 0xaf, 0xe3, 0x3f, 0x8c, 0x5b, 0x2f, 0xfd, 0x48, 0x61, 0x29, 0x9e, 0xba, 0x76, + /*1bc0:*/ 0x73, 0x3c, 0xeb, 0xeb, 0x30, 0x18, 0xa9, 0x89, 0x4c, 0xbc, 0x09, 0xb6, 0xd7, 0x46, 0x27, 0x76, + /*1bd0:*/ 0x51, 0x41, 0x52, 0x29, 0x2a, 0x73, 0x2d, 0xf0, 0x13, 0x9c, 0x00, 0x38, 0xe1, 0xe6, 0xc7, 0x9c, + /*1be0:*/ 0x7b, 0x07, 0xab, 0xf0, 0xf9, 0x0f, 0xc0, 0xce, 0x6a, 0xba, 0x10, 0x03, 0xfa, 0x55, 0x8b, 0x1a, + /*1bf0:*/ 0xfc, 0xd4, 0xdf, 0x8d, 0xf5, 0x98, 0x7e, 0xf1, 0x70, 0xff, 0x41, 0x9d, 0x66, 0xa3, 0x3a, 0x99, + /*1c00:*/ 0x5e, 0xe2, 0x9f, 0x29, 0x3b, 0xc8, 0xe9, 0x32, 0xb7, 0x1a, 0xb3, 0x47, 0xde, 0x42, 0x2d, 0x37, + /*1c10:*/ 0x2f, 0x13, 0xe6, 0x4a, 0xd8, 0x4d, 0xfc, 0x65, 0x6b, 0xaa, 0xd7, 0x58, 0xab, 0x86, 0x95, 0x88, + /*1c20:*/ 0x36, 0xf8, 0xf9, 0xa6, 0xd6, 0x66, 0xf3, 0xa7, 0x18, 0x62, 0x7d, 0xa3, 0x5f, 0xbe, 0xac, 0xba, + /*1c30:*/ 0x9f, 0x02, 0x3b, 0xa7, 0x43, 0x2a, 0xb5, 0x48, 0x70, 0x76, 0xda, 0xa2, 0x06, 0xb4, 0x67, 0x48, + /*1c40:*/ 0x33, 0xd9, 0x2d, 0xce, 0xd2, 0xe0, 0xd5, 0x3b, 0x81, 0xbb, 0x7a, 0x6a, 0xa9, 0xe5, 0xac, 0x82, + /*1c50:*/ 0x7c, 0x05, 0x7d, 0x93, 0x03, 0x15, 0xc2, 0x8f, 0x14, 0x44, 0xf9, 0xe2, 0xb2, 0x85, 0xfd, 0xe4, + /*1c60:*/ 0x7f, 0xaf, 0x3f, 0x36, 0x1e, 0xdc, 0x0f, 0x81, 0x29, 0x22, 0xfd, 0xb6, 0xf4, 0xa1, 0xef, 0xe2, + /*1c70:*/ 0x28, 0x82, 0xcb, 0x1c, 0x50, 0x4b, 0x68, 0x92, 0xc5, 0x40, 0xba, 0x8f, 0xb0, 0x13, 0x1e, 0xb7, + /*1c80:*/ 0xc4, 0x89, 0x78, 0x90, 0x52, 0x4a, 0x0d, 0xa9, 0x21, 0x25, 0x46, 0x65, 0x6c, 0x3f, 0x44, 0xb6, + /*1c90:*/ 0x6c, 0x6b, 0x91, 0xe2, 0x84, 0x75, 0x33, 0x58, 0x67, 0xf1, 0x19, 0x91, 0xd2, 0x18, 0xdb, 0x6c, + /*1ca0:*/ 0x80, 0x06, 0x8f, 0xb4, 0x13, 0xde, 0x16, 0x1b, 0x70, 0x8e, 0x11, 0x92, 0xfd, 0xa5, 0x38, 0xbf, + /*1cb0:*/ 0x3b, 0x88, 0x8a, 0xec, 0x26, 0xe7, 0x04, 0x47, 0x34, 0x63, 0xcc, 0xcb, 0x57, 0x35, 0x2d, 0xe7, + /*1cc0:*/ 0x77, 0x7c, 0xe3, 0x84, 0xfc, 0xdd, 0x45, 0x3b, 0x45, 0x9e, 0x7c, 0xf8, 0x78, 0x5d, 0x42, 0x09, + /*1cd0:*/ 0x23, 0x9c, 0xf5, 0x8e, 0x95, 0x0a, 0xac, 0x64, 0x35, 0x20, 0x78, 0xca, 0x3e, 0x2b, 0x5f, 0xd5, + /*1ce0:*/ 0xb0, 0x22, 0xc6, 0x3a, 0x9a, 0x6f, 0xa7, 0x57, 0xf6, 0x83, 0xb4, 0xad, 0xe9, 0xd7, 0x0f, 0xaa, + /*1cf0:*/ 0x93, 0x49, 0x6b, 0x04, 0xf9, 0x35, 0x16, 0x37, 0x7f, 0x82, 0xac, 0x7e, 0x87, 0x32, 0x84, 0xef, + /*1d00:*/ 0x1c, 0x06, 0x6a, 0xdc, 0x26, 0x23, 0xcd, 0x39, 0x3c, 0x71, 0xae, 0x7d, 0x08, 0x6d, 0x76, 0xa4, + /*1d10:*/ 0xf0, 0x68, 0xd6, 0x6c, 0xec, 0xc4, 0x10, 0x6c, 0xaf, 0x8e, 0x50, 0x2c, 0xd8, 0x06, 0xcd, 0x19, + /*1d20:*/ 0x05, 0xf8, 0x16, 0x3a, 0x28, 0xb9, 0x2e, 0x00, 0x0b, 0xf9, 0xa9, 0x1b, 0x5a, 0xa5, 0x34, 0x9c, + /*1d30:*/ 0xbe, 0x65, 0xb5, 0xe6, 0xb4, 0xc1, 0x8a, 0xfe, 0x1c, 0x24, 0x0f, 0x7e, 0x91, 0x8c, 0x65, 0x3d, + /*1d40:*/ 0xaa, 0x26, 0x13, 0x91, 0x8b, 0xee, 0xd9, 0x0c, 0xdc, 0xc7, 0x08, 0x21, 0x8c, 0xc4, 0xb7, 0x86, + /*1d50:*/ 0x45, 0xf7, 0x11, 0x35, 0x9d, 0x76, 0x38, 0x81, 0x6c, 0xc5, 0x49, 0x87, 0xe2, 0xe9, 0x48, 0x5c, + /*1d60:*/ 0xf9, 0x15, 0x30, 0x10, 0x2e, 0xee, 0x6e, 0x4d, 0x9b, 0xd3, 0xb8, 0x10, 0xff, 0xdd, 0x5d, 0xe1, + /*1d70:*/ 0x2c, 0x38, 0xfe, 0x0f, 0xae, 0x14, 0xb9, 0x21, 0x74, 0x6a, 0xc0, 0xf8, 0x29, 0x2e, 0xa1, 0xb0, + /*1d80:*/ 0xf9, 0x3c, 0x72, 0x46, 0x1b, 0xe7, 0xa2, 0xef, 0x18, 0x0b, 0xe3, 0xc7, 0x6b, 0x60, 0x6a, 0x7f, + /*1d90:*/ 0x60, 0x36, 0xa5, 0xa9, 0x3b, 0x13, 0x97, 0xd4, 0xee, 0x5a, 0x23, 0xd0, 0xc9, 0x2d, 0x3a, 0x1f, + /*1da0:*/ 0x84, 0x86, 0x42, 0xc5, 0x94, 0xf0, 0x6f, 0x9e, 0xd7, 0xa9, 0xa0, 0x63, 0xd0, 0xc2, 0xa2, 0x57, + /*1db0:*/ 0x3a, 0xe5, 0x14, 0xc9, 0xce, 0x7a, 0x77, 0xfc, 0x72, 0x99, 0xf7, 0x02, 0x92, 0xdb, 0x95, 0xf3, + /*1dc0:*/ 0x66, 0x17, 0xb0, 0xe1, 0x83, 0xe3, 0x13, 0x55, 0xe4, 0xf2, 0xb7, 0x45, 0x35, 0x34, 0x5e, 0x3b, + /*1dd0:*/ 0x1d, 0x68, 0x0a, 0x38, 0x94, 0x43, 0x7b, 0xc0, 0x21, 0x77, 0x3e, 0x11, 0x51, 0xba, 0x1b, 0x0c, + /*1de0:*/ 0x1f, 0x0b, 0x28, 0x23, 0xca, 0x79, 0x5b, 0x3c, 0xc8, 0x4b, 0x84, 0xd8, 0xa0, 0xfc, 0x9d, 0x7f, + /*1df0:*/ 0xad, 0xce, 0x6a, 0xe4, 0x7b, 0xbd, 0xbc, 0xbe, 0x9c, 0xef, 0x2c, 0x5e, 0x5c, 0x64, 0x1e, 0x5d, + /*1e00:*/ 0x97, 0x83, 0x20, 0x63, 0x5b, 0x4d, 0x18, 0xdd, 0xe3, 0x08, 0x7a, 0xfd, 0x7a, 0xb0, 0xb4, 0x89, + /*1e10:*/ 0xfe, 0x5d, 0x59, 0x5a, 0x50, 0x91, 0x6a, 0xe3, 0xd8, 0xe4, 0x4c, 0x74, 0x06, 0x1e, 0xb8, 0xcb, + /*1e20:*/ 0x27, 0x0e, 0x57, 0x76, 0x4c, 0x31, 0x76, 0x86, 0xd4, 0x37, 0x93, 0x6c, 0x13, 0x45, 0x6d, 0x79, + /*1e30:*/ 0xef, 0xab, 0xb6, 0x07, 0x7b, 0x07, 0xc0, 0x26, 0xa1, 0x61, 0x40, 0xa0, 0x67, 0x36, 0xfc, 0xb5, + /*1e40:*/ 0x8b, 0x75, 0x02, 0xd8, 0x4d, 0x60, 0x40, 0xeb, 0xf4, 0x02, 0xb2, 0xe3, 0x5e, 0x22, 0x13, 0xf5, + /*1e50:*/ 0xb4, 0x71, 0xb9, 0x64, 0x3a, 0x71, 0xba, 0xdb, 0x4e, 0xbe, 0x8e, 0x35, 0x18, 0xe1, 0xf3, 0xf1, + /*1e60:*/ 0xde, 0xd9, 0xba, 0x88, 0x1e, 0x08, 0xd7, 0x79, 0x54, 0xdd, 0x1c, 0xda, 0xa3, 0xcd, 0x18, 0x7b, + /*1e70:*/ 0x84, 0x17, 0xc7, 0x0a, 0x17, 0x9f, 0x14, 0x58, 0x6c, 0xce, 0x7f, 0x1b, 0x7c, 0x0b, 0xcd, 0x82, + /*1e80:*/ 0xee, 0x1a, 0x9f, 0x24, 0x94, 0x01, 0x76, 0xbe, 0x68, 0xb5, 0xc5, 0x9e, 0x6f, 0x3c, 0x90, 0x02, + /*1e90:*/ 0x2b, 0x58, 0xc3, 0x2e, 0x9d, 0xc0, 0x4e, 0xa2, 0x78, 0xf2, 0x2d, 0x8a, 0x07, 0x82, 0xbe, 0xd4, + /*1ea0:*/ 0xbf, 0x4a, 0x08, 0xa3, 0xa5, 0x89, 0xe0, 0x3f, 0x28, 0x0b, 0xec, 0xac, 0x77, 0xdd, 0xac, 0x52, + /*1eb0:*/ 0x7a, 0x58, 0x65, 0x59, 0x48, 0x03, 0xf9, 0x27, 0xd1, 0xa9, 0x7b, 0x37, 0xbe, 0x4c, 0x6c, 0x6b, + /*1ec0:*/ 0x73, 0x15, 0x74, 0xfc, 0x83, 0x1e, 0xbd, 0x67, 0x20, 0x14, 0xe9, 0xad, 0x93, 0x13, 0xd5, 0x45, + /*1ed0:*/ 0x2a, 0xdc, 0x6c, 0xa3, 0x04, 0xe7, 0x5f, 0x58, 0xea, 0x95, 0x25, 0x25, 0xe8, 0xb5, 0x32, 0x26, + /*1ee0:*/ 0xd8, 0xa1, 0x16, 0x0c, 0xbe, 0x63, 0xee, 0xc3, 0x52, 0xba, 0x01, 0xbe, 0xfd, 0xc1, 0x9b, 0x5c, + /*1ef0:*/ 0xf4, 0x6d, 0x1c, 0x08, 0x0a, 0xd9, 0xd9, 0xa6, 0xd2, 0x24, 0x05, 0x7c, 0x05, 0x8c, 0x4a, 0x7a, + /*1f00:*/ 0xfe, 0x35, 0x11, 0x82, 0xb6, 0x94, 0xe1, 0x3e, 0xc3, 0xd1, 0xad, 0x88, 0x3c, 0x2f, 0xb2, 0x2c, + /*1f10:*/ 0x75, 0xef, 0x37, 0xd8, 0x33, 0x9a, 0xf6, 0x65, 0x8f, 0x58, 0xa7, 0x64, 0x52, 0xb8, 0x95, 0x19, + /*1f20:*/ 0xe6, 0xee, 0x39, 0x03, 0xdd, 0x8d, 0x33, 0x47, 0xb5, 0xb7, 0x4b, 0x6f, 0x55, 0xb6, 0x8e, 0xca, + /*1f30:*/ 0x3d, 0x6f, 0xc7, 0x39, 0x1f, 0x56, 0xa1, 0xa8, 0xef, 0x0b, 0xcb, 0x52, 0xea, 0x2d, 0x1f, 0x11, + /*1f40:*/ 0xee, 0x6b, 0x6a, 0x26, 0x84, 0xce, 0x02, 0x5a, 0x10, 0x2d, 0x6f, 0xd6, 0x8f, 0xf9, 0x68, 0xd8, + /*1f50:*/ 0x0a, 0x67, 0xeb, 0x09, 0x7c, 0xd0, 0xa8, 0xfd, 0x47, 0x40, 0x49, 0x6f, 0xb1, 0xcd, 0x01, 0xaa, + /*1f60:*/ 0x2d, 0x85, 0xb8, 0xc7, 0x81, 0x3e, 0xc7, 0xa9, 0xbe, 0xc5, 0xc6, 0x20, 0xf2, 0x4d, 0x61, 0xff, + /*1f70:*/ 0x64, 0x45, 0xed, 0xa0, 0xa0, 0xa8, 0xbb, 0xb4, 0x78, 0x44, 0x1c, 0x7f, 0xe8, 0x87, 0x7b, 0xc1, + /*1f80:*/ 0x29, 0xc2, 0x71, 0x0d, 0x9a, 0xa7, 0x9c, 0xc4, 0x03, 0x1b, 0x6c, 0x25, 0x2f, 0x9f, 0xc4, 0xd1, + /*1f90:*/ 0x67, 0x19, 0x81, 0x3f, 0x71, 0x94, 0xcd, 0xed, 0x84, 0x9d, 0x0f, 0x42, 0xae, 0x38, 0xdf, 0xbd, + /*1fa0:*/ 0xc3, 0x92, 0x6b, 0xa8, 0x8b, 0x18, 0x45, 0xe2, 0xf3, 0x1c, 0x7c, 0xe6, 0x06, 0xeb, 0x41, 0x48, + /*1fb0:*/ 0xe1, 0x44, 0x79, 0x28, 0xa2, 0xfe, 0x46, 0x85, 0x9d, 0x1a, 0x83, 0x1d, 0x9c, 0xe3, 0xe2, 0xc9, + /*1fc0:*/ 0x33, 0x68, 0xa8, 0xa9, 0x07, 0x9c, 0x7f, 0x71, 0xe7, 0xf0, 0x4e, 0x21, 0x90, 0x80, 0xc1, 0x3e, + /*1fd0:*/ 0x1f, 0xae, 0xdd, 0xb8, 0x5a, 0x17, 0x86, 0x9a, 0xdf, 0xec, 0xde, 0xaa, 0x48, 0x99, 0x4b, 0xd9, + /*1fe0:*/ 0xa8, 0x9b, 0xbc, 0x34, 0x65, 0x30, 0x1a, 0x72, 0xf4, 0x69, 0xee, 0x81, 0x06, 0x86, 0xbe, 0x65, + /*1ff0:*/ 0x74, 0x22, 0xdc, 0x45, 0x61, 0x4d, 0x11, 0x16, 0x94, 0xc3, 0xaf, 0x31, 0xf2, 0x2e, 0x7e, 0x0a, + /*2000:*/ 0xe9, 0xcc, 0x15, 0x55, 0xdd, 0x5c, 0x4b, 0xc8, 0xe6, 0x54, 0x65, 0x71, 0x96, 0xb6, 0x05, 0xa1, + /*2010:*/ 0xf6, 0x12, 0xf5, 0x2e, 0xbd, 0x04, 0x7d, 0xc9, 0xb6, 0xe1, 0x40, 0x64, 0x35, 0x33, 0x2e, 0x1e, + /*2020:*/ 0xfd, 0xcb, 0x48, 0x03, 0xc1, 0x90, 0x27, 0x65, 0x2c, 0xa5, 0x3b, 0xba, 0x99, 0x89, 0x1d, 0x63, + /*2030:*/ 0x27, 0x31, 0xa4, 0x45, 0x7a, 0x5d, 0xbb, 0x67, 0xea, 0x3e, 0x3d, 0x03, 0x71, 0x8b, 0xda, 0x94, + /*2040:*/ 0xc6, 0x09, 0xb6, 0xfb, 0x87, 0x2e, 0x50, 0x67, 0x04, 0x3d, 0xf0, 0x54, 0xd8, 0xcb, 0xee, 0x74, + /*2050:*/ 0x59, 0x15, 0x9a, 0x40, 0xb2, 0xf1, 0xae, 0xa2, 0x9c, 0x76, 0x6b, 0x2b, 0x70, 0xc8, 0xe9, 0x20, + /*2060:*/ 0x95, 0x16, 0xb8, 0xb2, 0x7e, 0x43, 0xd7, 0x5b, 0x3d, 0xce, 0x82, 0x22, 0x61, 0xff, 0x64, 0x14, + /*2070:*/ 0xcc, 0x7e, 0xf8, 0x73, 0x5e, 0x72, 0xf3, 0xfc, 0xea, 0xbf, 0x44, 0xc4, 0x1b, 0x25, 0xd1, 0xbd, + /*2080:*/ 0x95, 0x3a, 0xb0, 0x1b, 0x1f, 0xfa, 0x7b, 0xbe, 0x52, 0x80, 0x21, 0xb6, 0x22, 0x0b, 0x9c, 0x38, + /*2090:*/ 0x3d, 0xbb, 0xae, 0x2f, 0xd8, 0xaf, 0x45, 0x00, 0x47, 0x44, 0xcd, 0x6a, 0x66, 0x8c, 0xc5, 0x35, + /*20a0:*/ 0xfd, 0x6d, 0xe4, 0xf5, 0xfa, 0xfa, 0x00, 0xff, 0x96, 0xdb, 0x91, 0xad, 0x00, 0x05, 0xbe, 0x99, + /*20b0:*/ 0xa0, 0x15, 0x4d, 0xb6, 0xb5, 0x26, 0xc4, 0x82, 0xa9, 0xd4, 0xbc, 0x2f, 0xe1, 0x85, 0x18, 0xd0, + /*20c0:*/ 0xa7, 0xdc, 0xbe, 0x53, 0x84, 0xac, 0x2a, 0xc3, 0xf9, 0x8c, 0x01, 0x6e, 0xdb, 0x3e, 0x7a, 0xf4, + /*20d0:*/ 0x0b, 0xf3, 0x82, 0x34, 0x4d, 0x8a, 0x67, 0x0a, 0x68, 0x5c, 0x87, 0xd5, 0x12, 0x11, 0xf7, 0xd0, + /*20e0:*/ 0xf2, 0xd7, 0x3c, 0x2c, 0x7a, 0xf6, 0xee, 0x3a, 0x7f, 0xa3, 0x66, 0xb4, 0x76, 0x5e, 0x2b, 0x14, + /*20f0:*/ 0x17, 0xdc, 0x28, 0x89, 0xa4, 0xba, 0x8e, 0x66, 0x82, 0x18, 0xfe, 0x04, 0xcc, 0x44, 0xf8, 0xd9, + /*2100:*/ 0x76, 0x30, 0x30, 0xad, 0x4c, 0xa0, 0x5f, 0x8a, 0x7b, 0x59, 0x07, 0xb9, 0x1f, 0xdc, 0x88, 0xac, + /*2110:*/ 0xbf, 0xcb, 0x8d, 0x64, 0x34, 0x01, 0xd6, 0xb1, 0x03, 0xd7, 0xa8, 0x0b, 0x2f, 0xee, 0x98, 0x8d, + /*2120:*/ 0x18, 0x9f, 0x19, 0xf4, 0xc3, 0x9c, 0x44, 0x9a, 0x2b, 0xdf, 0x88, 0x79, 0xad, 0x0f, 0x13, 0x3e, + /*2130:*/ 0xd7, 0xb9, 0x5c, 0x50, 0xed, 0x0c, 0xda, 0xb0, 0xb6, 0x6e, 0xdb, 0x6d, 0x03, 0x31, 0xc6, 0x97, + /*2140:*/ 0xac, 0x8f, 0x9c, 0x2d, 0x16, 0x88, 0x72, 0x49, 0x82, 0x99, 0xc0, 0x71, 0x59, 0x27, 0xb6, 0x39, + /*2150:*/ 0xc8, 0x30, 0x56, 0x8e, 0x8f, 0xa2, 0xa5, 0xbe, 0xc4, 0x01, 0x1e, 0x12, 0x42, 0xab, 0xd1, 0x9c, + /*2160:*/ 0x4c, 0x34, 0xef, 0x87, 0x36, 0xf2, 0xce, 0xde, 0xf5, 0x23, 0x71, 0x12, 0x7e, 0xb6, 0x8e, 0x25, + /*2170:*/ 0x82, 0x7d, 0xd6, 0xac, 0x07, 0xbb, 0x01, 0xfc, 0x9d, 0x14, 0xdf, 0x24, 0x38, 0x7c, 0xd8, 0x42, + /*2180:*/ 0x3a, 0xf9, 0xb1, 0xfd, 0x66, 0x9f, 0x7c, 0x47, 0x9d, 0x57, 0x3b, 0x75, 0x44, 0x63, 0xe8, 0x4c, + /*2190:*/ 0x7c, 0xf2, 0xfc, 0xec, 0x43, 0x83, 0x87, 0xd3, 0x13, 0x73, 0x33, 0x98, 0x7d, 0x33, 0x0b, 0x4b, + /*21a0:*/ 0x44, 0xb2, 0xc1, 0x9c, 0xb3, 0x03, 0x67, 0x80, 0xef, 0x95, 0x06, 0xe0, 0xbb, 0xe1, 0xe5, 0x33, + /*21b0:*/ 0x21, 0x73, 0x1f, 0x91, 0xf1, 0x14, 0xdc, 0x9e, 0x53, 0xe3, 0x14, 0x85, 0x43, 0x1e, 0xaa, 0x5d, + /*21c0:*/ 0x08, 0x7b, 0x28, 0x8d, 0x43, 0x27, 0xec, 0x2d, 0xab, 0xe7, 0xe2, 0x09, 0xc9, 0x15, 0x1a, 0x87, + /*21d0:*/ 0x58, 0xa6, 0xfe, 0x35, 0xd0, 0xd9, 0x87, 0x39, 0x7e, 0xae, 0xc2, 0x91, 0x0a, 0x0f, 0xf3, 0x48, + /*21e0:*/ 0xe2, 0x5d, 0x4c, 0x1a, 0x56, 0xbb, 0x74, 0x8e, 0x9f, 0x25, 0xf0, 0x90, 0x46, 0xcf, 0x50, 0x35, + /*21f0:*/ 0x7a, 0x59, 0xe1, 0x6a, 0xd4, 0x24, 0x97, 0x4a, 0xca, 0xdb, 0xbd, 0x83, 0xd9, 0xa9, 0x6a, 0xae, + /*2200:*/ 0xea, 0x46, 0x97, 0x14, 0xdd, 0xaf, 0x46, 0x79, 0x98, 0xb7, 0x20, 0xf2, 0x3e, 0x98, 0xd8, 0x6c, + /*2210:*/ 0xc5, 0x57, 0x5d, 0xed, 0x08, 0xda, 0x0f, 0x98, 0x06, 0xd8, 0xdc, 0x2c, 0x28, 0x8d, 0xc5, 0x21, + /*2220:*/ 0x33, 0xc1, 0xc4, 0x2d, 0x1e, 0x85, 0x7b, 0x82, 0x12, 0x74, 0x78, 0x2b, 0xf5, 0x0b, 0x77, 0xeb, + /*2230:*/ 0xc8, 0x6f, 0x42, 0x83, 0xe2, 0x19, 0x25, 0x6b, 0xff, 0x92, 0xb7, 0x63, 0x82, 0xae, 0xc9, 0x0d, + /*2240:*/ 0xa0, 0xc3, 0x64, 0x6f, 0x13, 0x8c, 0xf2, 0x8a, 0xa2, 0xb6, 0x57, 0x99, 0x2e, 0x92, 0xa6, 0x3c, + /*2250:*/ 0xa1, 0x86, 0x05, 0x76, 0x4f, 0x55, 0x5d, 0x2b, 0x3c, 0x28, 0x30, 0x00, 0x51, 0x5e, 0xa1, 0x90, + /*2260:*/ 0x35, 0x0b, 0x78, 0xb6, 0x04, 0x82, 0xca, 0xe0, 0x3e, 0xb9, 0xe0, 0x12, 0x19, 0x62, 0xfd, 0x05, + /*2270:*/ 0x81, 0xd7, 0x78, 0xb9, 0x23, 0x14, 0xe3, 0xb3, 0x4d, 0xac, 0x97, 0x80, 0xac, 0x4c, 0x98, 0xea, + /*2280:*/ 0x60, 0x89, 0x62, 0x8b, 0xc0, 0xd2, 0x37, 0x5c, 0x5a, 0x63, 0xcf, 0x7a, 0x55, 0x3a, 0x67, 0xeb, + /*2290:*/ 0xec, 0xcb, 0xd6, 0xf7, 0x39, 0x33, 0xf0, 0x6e, 0x4c, 0x8c, 0x0f, 0x75, 0x60, 0x5a, 0x5f, 0x08, + /*22a0:*/ 0x52, 0x93, 0x86, 0x50, 0xf3, 0xf1, 0x99, 0x9f, 0x3a, 0x02, 0x9e, 0xe8, 0xca, 0xe7, 0x95, 0x47, + /*22b0:*/ 0xb0, 0x37, 0x4e, 0xa1, 0x53, 0xc8, 0xaf, 0xb6, 0x6e, 0x55, 0xdf, 0xf8, 0x7d, 0xf2, 0xe7, 0x36, + /*22c0:*/ 0xc2, 0xf8, 0xbc, 0x54, 0xe7, 0x01, 0x13, 0x6b, 0x3f, 0xcc, 0xd0, 0x84, 0xe4, 0xac, 0xd8, 0x0a, + /*22d0:*/ 0x26, 0x2f, 0x82, 0xe1, 0xce, 0x3d, 0x60, 0xe4, 0xb9, 0xb2, 0xad, 0xd9, 0x9c, 0x4c, 0x2f, 0xa3, + /*22e0:*/ 0x2b, 0x37, 0x8f, 0x0d, 0x65, 0x38, 0xc5, 0x76, 0xca, 0x97, 0xa1, 0x64, 0xca, 0x3c, 0x14, 0xb6, + /*22f0:*/ 0xb3, 0x68, 0xaf, 0xb2, 0x47, 0x66, 0x4b, 0x85, 0x21, 0x1e, 0xa2, 0x60, 0xd7, 0x85, 0x8a, 0x9b, + /*2300:*/ 0x35, 0x0e, 0xd8, 0x20, 0x12, 0x8b, 0xca, 0x25, 0x17, 0xc4, 0x57, 0xb8, 0x6a, 0x6f, 0xac, 0xa9, + /*2310:*/ 0xf4, 0xe9, 0x3c, 0xc1, 0x05, 0x4a, 0x8c, 0x5c, 0xba, 0xbb, 0x82, 0xe7, 0xa7, 0xd0, 0x58, 0x44, + /*2320:*/ 0x13, 0x86, 0xac, 0x3c, 0x63, 0x9b, 0xa8, 0xb5, 0x56, 0x13, 0x55, 0xce, 0xc3, 0xd3, 0x29, 0xec, + /*2330:*/ 0x96, 0x27, 0x17, 0xde, 0x8a, 0xec, 0x31, 0x56, 0x6e, 0x3b, 0xfa, 0x4e, 0xa9, 0x51, 0x9c, 0x1c, + /*2340:*/ 0x67, 0x70, 0xbb, 0xc7, 0x50, 0x2d, 0xfb, 0xc9, 0x21, 0x64, 0x4c, 0xdd, 0xe7, 0xd2, 0x57, 0xfe, + /*2350:*/ 0x09, 0x12, 0x0d, 0xe7, 0x5b, 0x0f, 0x81, 0x21, 0x13, 0x44, 0x2f, 0x57, 0xab, 0xe8, 0xac, 0xf6, + /*2360:*/ 0x02, 0x23, 0x3d, 0xa1, 0x4f, 0xf5, 0x54, 0x20, 0xe2, 0x82, 0x4d, 0xf4, 0x22, 0x15, 0xc5, 0x70, + /*2370:*/ 0xf7, 0x9d, 0xd7, 0x3b, 0xb5, 0x30, 0x82, 0x94, 0x47, 0x26, 0xba, 0xb1, 0x15, 0xe6, 0x7c, 0xba, + /*2380:*/ 0xb0, 0xcd, 0xd2, 0xe6, 0x69, 0x52, 0x35, 0x0b, 0x77, 0x78, 0xd2, 0x65, 0x7c, 0xa3, 0xba, 0x56, + /*2390:*/ 0x61, 0xa0, 0xb1, 0x93, 0x83, 0xa1, 0x28, 0x23, 0x37, 0xb5, 0x1f, 0x56, 0x64, 0xdc, 0x66, 0x02, + /*23a0:*/ 0x22, 0x2d, 0xa7, 0x14, 0x77, 0x3e, 0xc0, 0xdb, 0x5c, 0x84, 0x63, 0x0f, 0xea, 0x37, 0x36, 0x34, + /*23b0:*/ 0xab, 0xab, 0x99, 0x5b, 0x81, 0x37, 0x22, 0xa5, 0x94, 0xe5, 0xf2, 0x79, 0x2f, 0x45, 0xc7, 0xc9, + /*23c0:*/ 0xa7, 0xfa, 0x6d, 0xbe, 0x02, 0x99, 0x2e, 0xeb, 0x6c, 0xc8, 0xc3, 0x24, 0x48, 0xbc, 0x9b, 0x4e, + /*23d0:*/ 0x13, 0x05, 0xfe, 0x9f, 0x67, 0xe7, 0x62, 0xc3, 0x74, 0x6d, 0x24, 0xf9, 0x42, 0x71, 0x77, 0x85, + /*23e0:*/ 0x4f, 0xb4, 0xba, 0x77, 0xbc, 0xdc, 0x49, 0x94, 0x73, 0x24, 0xe1, 0x62, 0xe1, 0xee, 0x8f, 0xd1, + /*23f0:*/ 0xa1, 0x7a, 0x72, 0x40, 0xba, 0x5e, 0x8c, 0x60, 0x31, 0x6e, 0x5d, 0x71, 0x15, 0x42, 0xf9, 0x70, + /*2400:*/ 0x61, 0x88, 0x08, 0x72, 0xa7, 0x03, 0x92, 0x3d, 0xc0, 0x0f, 0xed, 0x11, 0xf9, 0x32, 0xbe, 0x42, + /*2410:*/ 0x03, 0xb3, 0xb9, 0x15, 0xe1, 0x50, 0x00, 0xcf, 0xcd, 0x19, 0x19, 0x82, 0x32, 0x39, 0x43, 0x1a, + /*2420:*/ 0x54, 0xbd, 0xf4, 0xd8, 0x47, 0xe1, 0x01, 0x7a, 0xf5, 0xdb, 0x6f, 0xae, 0xad, 0xd4, 0x52, 0x6a, + /*2430:*/ 0xe0, 0x98, 0xa8, 0x8e, 0x1b, 0x1c, 0x54, 0x75, 0x6f, 0x71, 0x53, 0xbd, 0xea, 0x26, 0x78, 0x50, + /*2440:*/ 0x7b, 0x10, 0xe5, 0x5b, 0x56, 0xe4, 0xd8, 0x47, 0x20, 0xf8, 0x39, 0xb5, 0x29, 0xab, 0x99, 0x66, + /*2450:*/ 0xe9, 0xc9, 0xa2, 0x30, 0x8e, 0x14, 0xfc, 0x2c, 0x14, 0xdc, 0xba, 0xc9, 0x8a, 0xa1, 0x06, 0xab, + /*2460:*/ 0xfd, 0xc8, 0x93, 0x52, 0x26, 0x44, 0xf6, 0x0d, 0xc9, 0x46, 0x8a, 0x4e, 0x0b, 0x96, 0x98, 0x4d, + /*2470:*/ 0xf3, 0x71, 0x8f, 0xdf, 0x02, 0x2a, 0xa6, 0x8b, 0xe7, 0x6d, 0x6c, 0x80, 0x18, 0x21, 0x3c, 0x7c, + /*2480:*/ 0x6f, 0xc0, 0xb6, 0xea, 0x5d, 0x78, 0xb5, 0x46, 0xf9, 0x27, 0xfa, 0x4f, 0xd3, 0xbe, 0x83, 0xe2, + /*2490:*/ 0xaa, 0x26, 0xee, 0x71, 0x86, 0x5d, 0xf1, 0x05, 0x15, 0x97, 0x98, 0x0a, 0xdd, 0xa3, 0x67, 0x93, + /*24a0:*/ 0x50, 0xc1, 0x1a, 0xa7, 0xd1, 0xa0, 0xcd, 0xa4, 0xfe, 0xfa, 0x5a, 0x0e, 0x34, 0x64, 0x4c, 0x00, + /*24b0:*/ 0x41, 0xfc, 0x6e, 0x8c, 0x65, 0x60, 0xa5, 0xe9, 0xea, 0xc1, 0xd2, 0xed, 0x27, 0xd1, 0x3c, 0x87, + /*24c0:*/ 0xbb, 0xdd, 0xc8, 0xfa, 0x10, 0xa4, 0x90, 0x68, 0x4d, 0x8c, 0x9f, 0x3d, 0x47, 0x41, 0x1e, 0x38, + /*24d0:*/ 0x55, 0x7a, 0x02, 0xb5, 0xfc, 0xea, 0xcc, 0x33, 0x15, 0x62, 0xa3, 0x0c, 0x16, 0x39, 0x3a, 0x1d, + /*24e0:*/ 0xfd, 0x6d, 0x89, 0xb2, 0x93, 0x18, 0xb1, 0xfb, 0x74, 0x2b, 0x58, 0x6e, 0x2e, 0xa3, 0x0a, 0xfc, + /*24f0:*/ 0xed, 0x5e, 0xc9, 0xfc, 0xda, 0xdc, 0x61, 0xf1, 0x1b, 0xdc, 0x8b, 0xd6, 0x19, 0x3d, 0x3f, 0x68, + /*2500:*/ 0x90, 0x83, 0x19, 0x79, 0xe7, 0xfe, 0x11, 0x14, 0xf7, 0xe7, 0x3d, 0x94, 0x08, 0x60, 0xbd, 0xaa, + /*2510:*/ 0xdd, 0x87, 0xd0, 0xf4, 0xd2, 0xf5, 0xe4, 0x90, 0xa8, 0x73, 0xae, 0xb6, 0xb3, 0x8a, 0xc1, 0x36, + /*2520:*/ 0xa1, 0x1a, 0x03, 0x7c, 0xbe, 0x9d, 0xcb, 0xbc, 0x3a, 0x0f, 0x16, 0x54, 0xdb, 0xd6, 0xb4, 0x84, + /*2530:*/ 0x79, 0xe3, 0x95, 0xee, 0x5a, 0x65, 0x88, 0x1a, 0x68, 0x82, 0xc1, 0x32, 0x47, 0x94, 0x4a, 0x8b, + /*2540:*/ 0xb8, 0x1b, 0xa4, 0x77, 0x49, 0x65, 0x51, 0xbb, 0xbd, 0x0c, 0xd2, 0x7b, 0xbd, 0xff, 0xd9, 0x72, + /*2550:*/ 0x2e, 0x37, 0xc2, 0xc0, 0xf0, 0x03, 0xc7, 0x13, 0x46, 0xef, 0x7b, 0xa1, 0xf1, 0xa5, 0xbd, 0x1f, + /*2560:*/ 0x0e, 0x2f, 0x4e, 0x20, 0x51, 0xc7, 0x54, 0x57, 0x84, 0x78, 0xac, 0x7b, 0xc9, 0xe1, 0x8d, 0x66, + /*2570:*/ 0x51, 0x12, 0x79, 0x7c, 0x9c, 0x3d, 0xe2, 0xf3, 0x8e, 0x6b, 0x77, 0x84, 0x47, 0x14, 0x4d, 0x87, + /*2580:*/ 0xac, 0xa0, 0x9a, 0x5f, 0xd7, 0x4f, 0x18, 0x44, 0x8e, 0x96, 0x6f, 0xf4, 0xf0, 0x45, 0x73, 0x36, + /*2590:*/ 0x34, 0xa5, 0xaa, 0x24, 0xec, 0xde, 0x68, 0xa3, 0xda, 0x9e, 0xfc, 0x19, 0xba, 0x0e, 0x31, 0x80, + /*25a0:*/ 0x20, 0xad, 0x73, 0x0c, 0x35, 0x2d, 0x5f, 0x50, 0x41, 0x58, 0x02, 0xb6, 0x4c, 0xeb, 0xcf, 0xa1, + /*25b0:*/ 0x6e, 0x54, 0x66, 0xf9, 0xfb, 0xfa, 0x73, 0x48, 0x53, 0x9d, 0xbc, 0x7b, 0xe4, 0x6e, 0xad, 0xa7, + /*25c0:*/ 0x68, 0x6c, 0x3a, 0xed, 0xd9, 0x01, 0x49, 0xbe, 0xe8, 0x03, 0x36, 0xb6, 0x06, 0x2f, 0xfc, 0xfa, + /*25d0:*/ 0x5c, 0xd1, 0xe2, 0x4d, 0x62, 0xdc, 0x1c, 0xb8, 0x9b, 0xfc, 0x6e, 0x26, 0x3c, 0x38, 0xc3, 0x3d, + /*25e0:*/ 0xe0, 0x52, 0x61, 0x10, 0x34, 0x97, 0x15, 0x3f, 0xa9, 0xdc, 0xc2, 0xad, 0x32, 0xf7, 0x3d, 0x70, + /*25f0:*/ 0xe7, 0xf1, 0x2e, 0xe8, 0x1e, 0xbd, 0x8e, 0x90, 0xfb, 0x22, 0x73, 0xde, 0xe7, 0xb8, 0x9c, 0xce, + /*2600:*/ 0x9b, 0x89, 0xd3, 0x51, 0xfd, 0xe9, 0x07, 0xbe, 0x32, 0x14, 0x04, 0x22, 0xf8, 0x73, 0x75, 0x39, + /*2610:*/ 0x6d, 0x77, 0x21, 0x58, 0x5e, 0x64, 0x98, 0x36, 0x67, 0xc4, 0xed, 0x70, 0x25, 0xf7, 0x79, 0x12, + /*2620:*/ 0x53, 0xa8, 0xff, 0x59, 0x0b, 0xb7, 0xe0, 0x78, 0x35, 0xe5, 0x47, 0x70, 0xd9, 0xc5, 0x13, 0xe7, + /*2630:*/ 0xda, 0xa9, 0x09, 0xc9, 0x17, 0x68, 0x58, 0xb8, 0xbc, 0xa3, 0xf3, 0xf6, 0x02, 0xda, 0x35, 0x93, + /*2640:*/ 0x7f, 0xf2, 0x4e, 0x5f, 0x2f, 0xf2, 0x30, 0xca, 0xce, 0x23, 0xb3, 0x13, 0xff, 0xa3, 0xd6, 0x76, + /*2650:*/ 0xf8, 0xd5, 0xb8, 0xad, 0x52, 0xe3, 0x55, 0x15, 0x6e, 0x3b, 0x61, 0x5e, 0x25, 0x97, 0xda, 0x62, + /*2660:*/ 0xe6, 0x5a, 0x1a, 0xc3, 0x2e, 0x5d, 0xcd, 0xb9, 0x41, 0xe3, 0x72, 0x0b, 0x12, 0x94, 0x95, 0x08, + /*2670:*/ 0x06, 0x86, 0x45, 0xf9, 0x38, 0x8d, 0x41, 0xf6, 0x3e, 0x84, 0x6d, 0x06, 0xfb, 0x41, 0x55, 0x0d, + /*2680:*/ 0x8e, 0x31, 0x8d, 0x8d, 0x7c, 0x9b, 0x1e, 0x54, 0x5a, 0xac, 0xe1, 0x3e, 0xc0, 0x03, 0x36, 0x23, + /*2690:*/ 0x81, 0x13, 0xe7, 0xcc, 0x1b, 0xc3, 0x9c, 0x6a, 0xc1, 0xfc, 0xe9, 0x9c, 0x20, 0xa0, 0x4a, 0x84, + /*26a0:*/ 0x0f, 0x17, 0xcc, 0xf1, 0xb6, 0xcc, 0xf9, 0x5e, 0x52, 0x0a, 0x70, 0x03, 0x24, 0x73, 0x65, 0x5b, + /*26b0:*/ 0x28, 0x8d, 0xe5, 0x99, 0x8e, 0x47, 0xfd, 0x75, 0x63, 0xd6, 0x6a, 0x16, 0xe7, 0xa8, 0x27, 0x44, + /*26c0:*/ 0x76, 0xf6, 0x81, 0xf9, 0xec, 0x37, 0x49, 0x5b, 0x50, 0x19, 0x11, 0x8e, 0xe4, 0x21, 0x6f, 0xca, + /*26d0:*/ 0xd3, 0x91, 0xb7, 0x2d, 0x91, 0x1b, 0x99, 0x19, 0xb6, 0xfb, 0xcd, 0xb6, 0xe4, 0x11, 0xd3, 0x26, + /*26e0:*/ 0x70, 0xa9, 0x3f, 0x3e, 0x81, 0x66, 0x8c, 0x97, 0xce, 0xe8, 0x98, 0x0a, 0x55, 0x57, 0x7f, 0x14, + /*26f0:*/ 0x8b, 0x9d, 0xb5, 0x81, 0x3b, 0x61, 0x25, 0x5e, 0xa0, 0xda, 0xcc, 0x64, 0xf1, 0xe2, 0xe4, 0xa0, + /*2700:*/ 0x86, 0xdb, 0xec, 0x17, 0x94, 0x06, 0xe8, 0xa3, 0x6d, 0x65, 0xd7, 0x0e, 0xda, 0x42, 0xfa, 0x65, + /*2710:*/ 0x2f, 0x86, 0xde, 0xb3, 0x0c, 0x85, 0x46, 0xb2, 0x5f, 0x43, 0x40, 0xc7, 0x06, 0xfc, 0xd7, 0xbc, + /*2720:*/ 0x13, 0x3d, 0x1e, 0x7c, 0xfe, 0x21, 0x92, 0x51, 0xcd, 0xb6, 0xf2, 0xdd, 0xf2, 0xf1, 0x63, 0x3d, + /*2730:*/ 0x23, 0x81, 0xd4, 0x82, 0x2e, 0x7b, 0x7d, 0x9b, 0xa4, 0x45, 0x30, 0xf5, 0xbf, 0x32, 0x01, 0xbd, + /*2740:*/ 0xda, 0x6e, 0xb6, 0x43, 0xbc, 0xb3, 0xf2, 0xbb, 0x7c, 0x99, 0xcc, 0x84, 0xc2, 0x32, 0x89, 0xe9, + /*2750:*/ 0xfa, 0xeb, 0x75, 0x52, 0x77, 0xc2, 0xf4, 0x18, 0x1f, 0x16, 0xef, 0x3a, 0xcd, 0xef, 0xce, 0x7f, + /*2760:*/ 0x69, 0xcf, 0x0d, 0x50, 0xa4, 0xc6, 0x17, 0xf8, 0x00, 0x28, 0xed, 0xa6, 0x98, 0x97, 0xb8, 0x42, + /*2770:*/ 0xae, 0xc1, 0x43, 0x4d, 0x00, 0x0c, 0x41, 0x67, 0xf1, 0xe5, 0xed, 0x28, 0x75, 0x64, 0x27, 0x57, + /*2780:*/ 0x0a, 0x42, 0xa0, 0x9f, 0x81, 0x6b, 0xf4, 0xa8, 0x4a, 0x92, 0xe4, 0xf4, 0xe2, 0x02, 0x5d, 0xf1, + /*2790:*/ 0x2c, 0xe6, 0x61, 0x2d, 0xc8, 0x73, 0x24, 0x58, 0xb9, 0x52, 0x8c, 0x3d, 0x69, 0x5f, 0xc4, 0xc5, + /*27a0:*/ 0x7c, 0x76, 0x40, 0x0f, 0x27, 0x98, 0x30, 0x34, 0xc7, 0xb3, 0x9f, 0x8c, 0xa2, 0x59, 0x90, 0x60, + /*27b0:*/ 0xe5, 0xbe, 0x1c, 0x06, 0xc5, 0x7e, 0x3b, 0xce, 0x8c, 0x18, 0x19, 0x52, 0xe5, 0x20, 0xc9, 0x58, + /*27c0:*/ 0xea, 0x6b, 0x24, 0x44, 0x8f, 0x8d, 0x41, 0xbc, 0xb7, 0xd9, 0x7d, 0x38, 0xc5, 0xf9, 0xe4, 0x8d, + /*27d0:*/ 0xf6, 0x7a, 0x01, 0x3d, 0x0f, 0x9c, 0xf3, 0x55, 0x54, 0x78, 0xa8, 0xb8, 0x2e, 0x4f, 0xfd, 0x4e, + /*27e0:*/ 0xc7, 0xea, 0x78, 0xbc, 0xa3, 0x35, 0xa6, 0x8a, 0x70, 0xfb, 0xef, 0xb0, 0x5e, 0x72, 0x91, 0x3e, + /*27f0:*/ 0x43, 0xc0, 0xb0, 0x1e, 0x7a, 0x3a, 0xcd, 0xa1, 0xfd, 0x02, 0x6b, 0x55, 0xc1, 0xd2, 0x3a, 0xd1, + /*2800:*/ 0x65, 0x71, 0x5d, 0x2c, 0x57, 0xce, 0x15, 0xec, 0x08, 0xb0, 0x83, 0xf0, 0xac, 0x4f, 0x10, 0xa0, + /*2810:*/ 0x80, 0xc3, 0x64, 0x82, 0x87, 0xb4, 0x99, 0x83, 0xd3, 0x3b, 0x21, 0x03, 0xbc, 0xa3, 0x8a, 0x4f, + /*2820:*/ 0xcb, 0x72, 0x0f, 0x13, 0x55, 0xb8, 0x50, 0x30, 0x8a, 0xc7, 0x3e, 0xc8, 0x1b, 0xd2, 0x80, 0xec, + /*2830:*/ 0x87, 0x25, 0x4f, 0x9f, 0x19, 0xd6, 0x3f, 0xfc, 0x7b, 0xed, 0x1b, 0x8b, 0xa8, 0x27, 0x82, 0xa2, + /*2840:*/ 0x67, 0xae, 0xed, 0xd9, 0x1d, 0xba, 0x29, 0x2c, 0xd2, 0x11, 0x6a, 0xbd, 0x98, 0x0a, 0xca, 0x16, + /*2850:*/ 0xaf, 0xe6, 0x80, 0x10, 0xe4, 0x3c, 0x0e, 0xd2, 0xd2, 0xfe, 0x4a, 0x71, 0x1f, 0x6e, 0x6e, 0xf4, + /*2860:*/ 0xf5, 0x4a, 0x27, 0xf8, 0xb8, 0x6a, 0xf1, 0x47, 0xbe, 0xfe, 0x48, 0x31, 0x87, 0xd1, 0x31, 0x1d, + /*2870:*/ 0x6e, 0x64, 0xde, 0x2a, 0x50, 0xb6, 0x47, 0xf2, 0x35, 0xd7, 0x97, 0x70, 0x2a, 0xf7, 0xf1, 0xa7, + /*2880:*/ 0x14, 0x57, 0x09, 0x45, 0xa9, 0x64, 0x6b, 0x3f, 0x98, 0xc7, 0xe9, 0xf4, 0x5f, 0x74, 0xe4, 0x44, + /*2890:*/ 0x34, 0xce, 0x4a, 0x60, 0x80, 0x6c, 0xe7, 0x88, 0xc9, 0xab, 0x26, 0x5a, 0xc4, 0x5f, 0xe3, 0x09, + /*28a0:*/ 0x2d, 0xc8, 0x95, 0xae, 0xfc, 0x8e, 0xdf, 0xc9, 0x3c, 0x65, 0x5c, 0xf5, 0x7c, 0x04, 0x20, 0xcb, + /*28b0:*/ 0x22, 0xb7, 0x6b, 0x91, 0xc3, 0x2d, 0xa0, 0x25, 0xc2, 0x69, 0x7b, 0x3d, 0x86, 0x1a, 0x20, 0x49, + /*28c0:*/ 0x8d, 0x42, 0xc1, 0xc4, 0x9a, 0x1f, 0xf3, 0x3f, 0x52, 0xf0, 0xf1, 0xe2, 0x5c, 0xf0, 0x37, 0x12, + /*28d0:*/ 0x99, 0x13, 0x21, 0x70, 0x39, 0x7c, 0x74, 0x22, 0xff, 0xc6, 0xc6, 0x0c, 0xbc, 0xf6, 0x8d, 0x72, + /*28e0:*/ 0xeb, 0xa4, 0x13, 0x79, 0xd7, 0x23, 0xa8, 0xdb, 0x59, 0x7b, 0x70, 0xfd, 0x06, 0xf5, 0x6c, 0x53, + /*28f0:*/ 0xe5, 0x04, 0x74, 0xa7, 0xc8, 0xb6, 0xe6, 0x95, 0x99, 0x95, 0x89, 0x55, 0xc7, 0xdd, 0xc9, 0x45, + /*2900:*/ 0xb5, 0x88, 0xc7, 0xbd, 0x0d, 0x52, 0xf0, 0x08, 0x03, 0x87, 0x9e, 0x8b, 0xe6, 0x68, 0x57, 0xde, + /*2910:*/ 0x81, 0x77, 0x92, 0x91, 0x45, 0x41, 0x3a, 0xfe, 0x2f, 0xf0, 0x2c, 0x3b, 0xed, 0x9d, 0x3e, 0xbf, + /*2920:*/ 0x4a, 0x8e, 0x7f, 0x54, 0xaa, 0x5c, 0x08, 0x84, 0x86, 0xf3, 0xc3, 0x04, 0x86, 0x2a, 0xab, 0xaf, + /*2930:*/ 0xcc, 0xac, 0xd8, 0x59, 0x7d, 0xa1, 0xd3, 0x70, 0x4f, 0xb1, 0x1b, 0x05, 0xbb, 0x61, 0x85, 0xd7, + /*2940:*/ 0x3b, 0xaf, 0x3c, 0x80, 0x2a, 0xae, 0x1b, 0xfe, 0x24, 0xb6, 0x1d, 0x23, 0x3d, 0xae, 0x39, 0x5a, + /*2950:*/ 0xe5, 0xc4, 0x23, 0x39, 0x4f, 0x4c, 0x7e, 0x83, 0x4e, 0x8a, 0x8a, 0x89, 0x5f, 0x9e, 0x28, 0x1b, + /*2960:*/ 0xd8, 0xdf, 0xb8, 0xf7, 0x0e, 0x9d, 0x83, 0x23, 0x33, 0x77, 0x09, 0x96, 0x4b, 0x3c, 0xd3, 0x34, + /*2970:*/ 0x32, 0x75, 0x8b, 0x57, 0xd0, 0x75, 0xa1, 0xbe, 0xbf, 0xaa, 0x47, 0xfd, 0x34, 0xe1, 0x8d, 0xb2, + /*2980:*/ 0x15, 0x23, 0xdb, 0x9e, 0x68, 0x87, 0x98, 0xf4, 0x50, 0xc2, 0x43, 0xaf, 0x3a, 0x76, 0xcb, 0xb8, + /*2990:*/ 0x3f, 0x8f, 0x5c, 0x0d, 0x82, 0x4d, 0x86, 0xfe, 0x53, 0x51, 0xea, 0xba, 0xf7, 0x47, 0x9f, 0xbd, + /*29a0:*/ 0xb9, 0xf3, 0xe7, 0x5c, 0x21, 0x05, 0x9f, 0xa0, 0x51, 0x53, 0xec, 0xda, 0xce, 0x5d, 0xd7, 0x54, + /*29b0:*/ 0xbb, 0x95, 0xb8, 0xf0, 0x81, 0xf5, 0x80, 0x72, 0x6c, 0x11, 0xf6, 0x50, 0x7e, 0xb6, 0x7b, 0x17, + /*29c0:*/ 0xd4, 0xd9, 0xca, 0x9f, 0x2a, 0x42, 0xef, 0x81, 0x72, 0x68, 0x21, 0x4a, 0x32, 0x41, 0xa8, 0x2b, + /*29d0:*/ 0x6b, 0xf7, 0xc2, 0x9d, 0xdc, 0x14, 0x0e, 0xfa, 0x35, 0x95, 0x7d, 0x9c, 0xb5, 0x2c, 0x52, 0xac, + /*29e0:*/ 0xf3, 0x4a, 0x82, 0x9a, 0x6b, 0xa6, 0x5a, 0x53, 0xbe, 0x75, 0x7e, 0xd7, 0x62, 0x28, 0xe1, 0x42, + /*29f0:*/ 0x1b, 0x44, 0x8c, 0xb3, 0xf7, 0x59, 0x60, 0xb4, 0x6d, 0x87, 0x89, 0xf3, 0x5b, 0xe9, 0x02, 0xee, + /*2a00:*/ 0x38, 0xdb, 0xcb, 0x3f, 0x5a, 0x99, 0x68, 0x43, 0x13, 0x62, 0x6b, 0x05, 0xd7, 0xc0, 0x81, 0x10, + /*2a10:*/ 0xbf, 0x56, 0x4e, 0x2a, 0x21, 0xe2, 0x17, 0x64, 0xfa, 0x2c, 0xc1, 0xee, 0xa0, 0xee, 0x91, 0xcb, + /*2a20:*/ 0x12, 0xaa, 0x14, 0x08, 0xc1, 0x29, 0x23, 0xb4, 0xc6, 0xaf, 0xff, 0xf8, 0x4d, 0x05, 0x6c, 0xe8, + /*2a30:*/ 0x20, 0x11, 0xdf, 0xc4, 0x0f, 0x2c, 0x49, 0xc9, 0xd3, 0xf2, 0x7d, 0x37, 0x9c, 0xc0, 0xc1, 0x99, + /*2a40:*/ 0xf5, 0xa1, 0x91, 0x10, 0x45, 0x6a, 0xf4, 0x61, 0x3e, 0x0f, 0x08, 0x4f, 0x84, 0xe9, 0x22, 0x0d, + /*2a50:*/ 0x1e, 0x78, 0x44, 0xd8, 0x31, 0x49, 0x6a, 0x31, 0x2a, 0x43, 0x5c, 0x64, 0x66, 0x43, 0x10, 0x9d, + /*2a60:*/ 0xa2, 0x74, 0x84, 0x28, 0xbf, 0x78, 0x5a, 0xfd, 0xbe, 0x2d, 0x01, 0xeb, 0x55, 0xa9, 0x41, 0x94, + /*2a70:*/ 0xd1, 0x7b, 0x72, 0x62, 0x82, 0x92, 0x64, 0xef, 0x05, 0xe9, 0xd0, 0x35, 0x3d, 0x46, 0x4d, 0xb4, + /*2a80:*/ 0x9f, 0x1e, 0x09, 0x38, 0x8c, 0x37, 0x70, 0x9e, 0xfb, 0x04, 0xa0, 0xd1, 0x49, 0x92, 0x85, 0x74, + /*2a90:*/ 0x23, 0x19, 0x41, 0xc3, 0x56, 0xf0, 0x89, 0xdf, 0x00, 0x83, 0x4b, 0xcb, 0xf1, 0x66, 0x9b, 0x8d, + /*2aa0:*/ 0x61, 0xf0, 0x6d, 0xee, 0x6b, 0x34, 0xc3, 0x88, 0x7e, 0xbf, 0x62, 0x3f, 0xe7, 0x4d, 0x85, 0x70, + /*2ab0:*/ 0xba, 0x7c, 0xe4, 0x78, 0x8f, 0xa1, 0x01, 0x58, 0x68, 0x67, 0x05, 0x36, 0x17, 0x0c, 0x4f, 0xe3, + /*2ac0:*/ 0xd4, 0x85, 0x39, 0x93, 0x8f, 0xf6, 0xd6, 0x93, 0x16, 0xd9, 0x19, 0x7c, 0xa6, 0x94, 0x76, 0xad, + /*2ad0:*/ 0xf4, 0xec, 0x5b, 0x63, 0x3d, 0x3e, 0x65, 0x29, 0x39, 0x6c, 0xa7, 0xe0, 0xbf, 0xe5, 0x64, 0x17, + /*2ae0:*/ 0xa9, 0xcb, 0xb9, 0x96, 0x58, 0x85, 0xdb, 0x55, 0x33, 0x31, 0x70, 0xac, 0x89, 0x01, 0x54, 0x83, + /*2af0:*/ 0x8d, 0x52, 0xa6, 0x6d, 0x71, 0x5f, 0x7b, 0xb6, 0x43, 0x8b, 0x44, 0x4e, 0xe4, 0x38, 0x67, 0x32, + /*2b00:*/ 0x4b, 0x5b, 0xea, 0xfd, 0xe5, 0x4c, 0x44, 0x15, 0x80, 0xde, 0x1c, 0x5d, 0x8c, 0xa5, 0xa1, 0x03, + /*2b10:*/ 0x56, 0x81, 0x78, 0x9b, 0xcc, 0x2f, 0xbb, 0x98, 0x55, 0xc8, 0x2b, 0x2c, 0x3d, 0x5a, 0x9c, 0x01, + /*2b20:*/ 0x73, 0x9f, 0x25, 0x24, 0x2a, 0xf9, 0xf0, 0x69, 0x59, 0x11, 0x7f, 0x0e, 0xa9, 0xfc, 0x14, 0x2d, + /*2b30:*/ 0x75, 0xa1, 0x24, 0xa0, 0x02, 0x29, 0x81, 0x04, 0x79, 0xfe, 0x7e, 0x99, 0x45, 0x01, 0xc0, 0xd4, + /*2b40:*/ 0x38, 0x9c, 0x9c, 0x24, 0xe8, 0x02, 0x26, 0xae, 0x10, 0x3d, 0x37, 0x33, 0xe3, 0x74, 0xd4, 0xfc, + /*2b50:*/ 0xe3, 0x82, 0x8e, 0xa2, 0x1c, 0x22, 0x8d, 0xd7, 0x94, 0xb3, 0xb3, 0x3c, 0xfc, 0xeb, 0xa9, 0x9c, + /*2b60:*/ 0xc6, 0x1c, 0x9e, 0x39, 0xaf, 0xb9, 0xfb, 0x65, 0x9a, 0xc7, 0xa3, 0xaa, 0x65, 0x23, 0x14, 0xb3, + /*2b70:*/ 0x30, 0x9f, 0x26, 0x3d, 0x44, 0x94, 0xe8, 0x44, 0xe1, 0xa8, 0x48, 0xb2, 0x6a, 0x1d, 0x2c, 0x49, + /*2b80:*/ 0xff, 0x90, 0x82, 0x9b, 0x21, 0xa9, 0xee, 0x51, 0x32, 0xfc, 0xa3, 0x77, 0x87, 0xf5, 0x1d, 0xc5, + /*2b90:*/ 0xd3, 0xb3, 0x1c, 0x25, 0x36, 0xa7, 0x23, 0xaf, 0xbf, 0x16, 0x25, 0x73, 0x91, 0x02, 0x04, 0xf7, + /*2ba0:*/ 0x4d, 0xe0, 0xa1, 0x12, 0x68, 0xa8, 0x89, 0xbe, 0x16, 0xed, 0x84, 0x18, 0x68, 0x17, 0x7b, 0x27, + /*2bb0:*/ 0x73, 0xc2, 0x07, 0xcf, 0x89, 0xdd, 0x18, 0x3c, 0x0f, 0x0c, 0x94, 0x2e, 0x9c, 0x44, 0xba, 0xf5, + /*2bc0:*/ 0x4f, 0x3b, 0xd4, 0xb7, 0x3a, 0x61, 0xd3, 0x4c, 0x1a, 0x09, 0x3c, 0x37, 0x29, 0x49, 0x8a, 0x38, + /*2bd0:*/ 0x91, 0xda, 0xb9, 0x64, 0x3c, 0xdd, 0xfe, 0x2a, 0x84, 0xb3, 0x56, 0x8c, 0xdb, 0x27, 0x73, 0x96, + /*2be0:*/ 0x5b, 0xfa, 0x89, 0x4d, 0xda, 0xd8, 0x0e, 0x72, 0x44, 0x6c, 0x66, 0x4f, 0x1a, 0x18, 0xa3, 0xf3, + /*2bf0:*/ 0xdc, 0xc0, 0x55, 0xa5, 0x25, 0x61, 0xd6, 0xf7, 0x09, 0xe1, 0xb6, 0x43, 0x4e, 0x1c, 0x6c, 0xd4, + /*2c00:*/ 0x49, 0xfe, 0x6c, 0xd1, 0xda, 0x1d, 0x53, 0xf7, 0x4e, 0x4d, 0xb2, 0x43, 0x0d, 0x98, 0x2e, 0x29, + /*2c10:*/ 0x9f, 0xd5, 0xfc, 0x21, 0x31, 0xd8, 0x74, 0x1a, 0x3b, 0xf7, 0x50, 0x06, 0x57, 0x6c, 0xbe, 0x5e, + /*2c20:*/ 0x5a, 0x29, 0xef, 0xac, 0xde, 0xf2, 0xe3, 0xad, 0x69, 0x6f, 0x67, 0x78, 0xce, 0x9f, 0xc4, 0x42, + /*2c30:*/ 0xb0, 0xac, 0xeb, 0x30, 0x7f, 0x23, 0x93, 0x86, 0xe7, 0x7d, 0x35, 0x32, 0xe3, 0x6b, 0x0e, 0x8b, + /*2c40:*/ 0x58, 0x83, 0x50, 0xe3, 0x5f, 0x12, 0xd4, 0xa7, 0xf2, 0x1b, 0xfb, 0xb1, 0xf9, 0x7e, 0x1e, 0x05, + /*2c50:*/ 0x7f, 0xec, 0x88, 0x2e, 0xd3, 0xda, 0x49, 0x3f, 0x3a, 0xc9, 0xb7, 0x3f, 0x44, 0xc5, 0xb6, 0x01, + /*2c60:*/ 0xb0, 0x6f, 0xa1, 0x3c, 0x9e, 0x44, 0x02, 0xf1, 0x11, 0x92, 0xf1, 0xd1, 0x7d, 0x2a, 0xa7, 0xc2, + /*2c70:*/ 0x7f, 0x5b, 0xc3, 0x0e, 0x03, 0xe1, 0x86, 0xf4, 0x63, 0x19, 0x15, 0xad, 0x1b, 0x0d, 0x9b, 0x04, + /*2c80:*/ 0x55, 0x49, 0xcb, 0x89, 0x85, 0x98, 0x6a, 0xd0, 0x18, 0x4d, 0xa2, 0x3e, 0x8c, 0x8b, 0x6c, 0x5b, + /*2c90:*/ 0xcf, 0xd1, 0xcb, 0xf3, 0x1a, 0x7b, 0x7b, 0x97, 0xe1, 0xa9, 0xd3, 0xcd, 0xc1, 0xbd, 0x25, 0x99, + /*2ca0:*/ 0x51, 0xde, 0x67, 0x08, 0x13, 0xa2, 0x91, 0x52, 0x4e, 0xf3, 0xca, 0xe7, 0xf3, 0xdc, 0x94, 0x1e, + /*2cb0:*/ 0x00, 0x60, 0x69, 0xfe, 0x98, 0xe9, 0x06, 0xc4, 0xf9, 0x9f, 0xdd, 0x2b, 0x25, 0x11, 0x41, 0x4f, + /*2cc0:*/ 0x7a, 0x75, 0x62, 0x4e, 0xbe, 0x00, 0x7b, 0xee, 0x38, 0x57, 0xd3, 0x5a, 0xf7, 0xc2, 0x33, 0x37, + /*2cd0:*/ 0x59, 0xe3, 0xd5, 0x20, 0x4e, 0xb1, 0x8d, 0xcf, 0x43, 0x03, 0xf3, 0x65, 0xca, 0xb6, 0xd1, 0x52, + /*2ce0:*/ 0x36, 0x8e, 0xdd, 0xb0, 0x30, 0x6c, 0xcf, 0xec, 0xe1, 0x04, 0xc1, 0x5b, 0x40, 0x7b, 0x4d, 0x02, + /*2cf0:*/ 0x91, 0x46, 0x3c, 0x90, 0x87, 0x60, 0xe4, 0x1b, 0xe0, 0xe1, 0x2c, 0xeb, 0x16, 0x6f, 0x6c, 0x72, + /*2d00:*/ 0xda, 0x71, 0x1f, 0x55, 0x3a, 0xe7, 0x52, 0x15, 0xff, 0x09, 0x4a, 0x84, 0x0c, 0xc5, 0x92, 0x69, + /*2d10:*/ 0x94, 0x5c, 0xb2, 0x15, 0x7f, 0x00, 0xe3, 0xf1, 0x43, 0x8b, 0x06, 0xa3, 0x51, 0xdf, 0xd1, 0x3c, + /*2d20:*/ 0x14, 0xe0, 0xe4, 0x18, 0xae, 0xe2, 0x56, 0x00, 0x6d, 0x04, 0xa0, 0xef, 0x21, 0xfe, 0x0e, 0xd6, + /*2d30:*/ 0x19, 0x78, 0x19, 0x98, 0xa4, 0x86, 0x6c, 0xc2, 0x39, 0x3b, 0x61, 0x33, 0xf9, 0xd9, 0xed, 0xcb, + /*2d40:*/ 0x8b, 0x14, 0x4e, 0xc2, 0x0f, 0x5d, 0xf0, 0x19, 0x0b, 0x21, 0x25, 0x61, 0x79, 0x93, 0x3d, 0x0d, + /*2d50:*/ 0xed, 0x6f, 0x1a, 0xa0, 0x19, 0xab, 0xb6, 0x56, 0xce, 0xa5, 0x51, 0xa4, 0x09, 0xf6, 0xc5, 0x95, + /*2d60:*/ 0x63, 0x85, 0x5f, 0x24, 0xd7, 0xd4, 0xba, 0x07, 0xa3, 0x62, 0x55, 0xe7, 0x3f, 0x7c, 0x3a, 0x8b, + /*2d70:*/ 0xc3, 0xc8, 0xe9, 0x94, 0x59, 0x59, 0xc9, 0x87, 0xc9, 0xc1, 0xdb, 0xb9, 0xc0, 0x13, 0xa1, 0x1e, + /*2d80:*/ 0xd4, 0x49, 0x32, 0xa3, 0x31, 0x42, 0xb4, 0x32, 0xed, 0x0a, 0xfd, 0xf4, 0xf8, 0x76, 0x01, 0x28, + /*2d90:*/ 0xaf, 0x1e, 0x7b, 0xd6, 0x7e, 0xf7, 0x05, 0x4c, 0x15, 0xee, 0x50, 0x74, 0x15, 0xbf, 0x19, 0xc7, + /*2da0:*/ 0x5e, 0xa6, 0x8d, 0xb9, 0x0d, 0xfc, 0x4a, 0xf1, 0x55, 0x4f, 0x2a, 0xea, 0x1c, 0x91, 0xdf, 0x47, + /*2db0:*/ 0xf2, 0x3a, 0xab, 0x09, 0x3a, 0x96, 0x92, 0x4b, 0xdd, 0xf7, 0x13, 0x82, 0xa1, 0x77, 0x44, 0x96, + /*2dc0:*/ 0xe2, 0x7b, 0x9d, 0xcb, 0xdd, 0x3b, 0x10, 0xf6, 0x45, 0x5b, 0xd0, 0x9e, 0xfb, 0x50, 0x10, 0x86, + /*2dd0:*/ 0x31, 0x05, 0x5c, 0x8e, 0x77, 0xb2, 0x49, 0x86, 0xe1, 0x35, 0x45, 0x65, 0x28, 0x5b, 0x05, 0xce, + /*2de0:*/ 0x4b, 0xef, 0xf2, 0x62, 0xde, 0xa3, 0x89, 0xf9, 0x8f, 0x68, 0x2a, 0x2c, 0xcd, 0x06, 0xd0, 0xb5, + /*2df0:*/ 0xb4, 0x4d, 0xa2, 0x38, 0xd1, 0x3c, 0x01, 0x13, 0x3c, 0x98, 0x8b, 0x72, 0x80, 0x4a, 0x22, 0x73, + /*2e00:*/ 0x45, 0x15, 0x5a, 0xaf, 0x27, 0x76, 0x7e, 0xd0, 0x5e, 0xad, 0x37, 0xdb, 0x59, 0xac, 0xd1, 0x11, + /*2e10:*/ 0x9e, 0xca, 0x10, 0x59, 0x29, 0x7d, 0x2f, 0xc4, 0xcb, 0x83, 0xdb, 0x96, 0x54, 0x7d, 0xa7, 0x4c, + /*2e20:*/ 0x61, 0x0b, 0x0e, 0xa1, 0xcd, 0xa5, 0x5d, 0x9c, 0x5d, 0xc7, 0x5a, 0x5d, 0x10, 0xfc, 0x43, 0x7b, + /*2e30:*/ 0x91, 0xd0, 0x2a, 0xdc, 0x9f, 0x4b, 0xeb, 0xaa, 0x53, 0xf3, 0x5a, 0x54, 0x16, 0x78, 0xd2, 0x67, + /*2e40:*/ 0x28, 0x1a, 0x39, 0x2e, 0x9a, 0x5b, 0xae, 0x7e, 0x2f, 0xc2, 0xf6, 0xa7, 0xaf, 0x8a, 0x84, 0xdf, + /*2e50:*/ 0x6b, 0xdb, 0xbc, 0xdf, 0xd7, 0x2e, 0xd5, 0x27, 0xbb, 0x31, 0x40, 0xb9, 0x54, 0xb1, 0xf9, 0x08, + /*2e60:*/ 0xdb, 0x69, 0xff, 0x2e, 0x40, 0xa9, 0x98, 0x36, 0x02, 0x24, 0x52, 0x27, 0x48, 0x5b, 0x16, 0x56, + /*2e70:*/ 0x8a, 0x2c, 0x7d, 0x15, 0xd1, 0xd8, 0xb2, 0x74, 0xbf, 0x2e, 0x65, 0x61, 0xe8, 0x1c, 0x53, 0x99, + /*2e80:*/ 0x54, 0x0a, 0xc0, 0x53, 0xc4, 0xdd, 0x62, 0x38, 0x49, 0x1a, 0xb7, 0xf1, 0xc0, 0xee, 0xf7, 0x58, + /*2e90:*/ 0xa9, 0xcd, 0xd2, 0x49, 0xcc, 0x6d, 0xee, 0x43, 0xd0, 0x0c, 0xd4, 0x4b, 0x15, 0x3d, 0x00, 0x7f, + /*2ea0:*/ 0x08, 0x29, 0x25, 0x1e, 0x13, 0xc4, 0xfa, 0x84, 0x9a, 0xbd, 0x22, 0xd9, 0xf8, 0x0f, 0xa9, 0xb6, + /*2eb0:*/ 0x13, 0x6f, 0x03, 0xd1, 0x91, 0xf7, 0x88, 0x36, 0xbd, 0xb3, 0xb1, 0x67, 0xca, 0x39, 0x4e, 0x1d, + /*2ec0:*/ 0xc7, 0xbc, 0xdf, 0xbb, 0x25, 0x1c, 0xcc, 0x59, 0xd1, 0x69, 0x9e, 0x56, 0xe3, 0x93, 0x63, 0xd5, + /*2ed0:*/ 0x44, 0xdd, 0x6b, 0x69, 0x1e, 0x51, 0xd0, 0x22, 0x69, 0x3f, 0x04, 0x43, 0xa5, 0xd6, 0x8f, 0x2f, + /*2ee0:*/ 0x6d, 0xe8, 0xd6, 0x0e, 0x3d, 0x58, 0x2a, 0x83, 0xd2, 0xee, 0x0e, 0x9d, 0x2c, 0xa8, 0xb5, 0xfa, + /*2ef0:*/ 0x65, 0x19, 0x04, 0x2d, 0x19, 0x8c, 0x07, 0xf5, 0x2f, 0x01, 0xf8, 0xc5, 0x38, 0x24, 0xd4, 0x6e, + /*2f00:*/ 0xfd, 0xd6, 0xad, 0xf6, 0xac, 0xcd, 0x92, 0x27, 0x93, 0x0b, 0xf9, 0x60, 0x22, 0x2b, 0xa2, 0xae, + /*2f10:*/ 0x86, 0x79, 0xd7, 0xd6, 0xb6, 0xad, 0x64, 0x59, 0x69, 0xe0, 0x83, 0xf3, 0xf9, 0x49, 0x19, 0x08, + /*2f20:*/ 0x9a, 0xa3, 0xfd, 0xf5, 0x92, 0x2d, 0x35, 0x06, 0x44, 0x32, 0xe7, 0xdf, 0x5e, 0x83, 0x93, 0x42, + /*2f30:*/ 0xe4, 0xf8, 0x24, 0xad, 0x65, 0x6d, 0x37, 0x58, 0x87, 0x80, 0x2b, 0xac, 0xc7, 0x27, 0xce, 0x2d, + /*2f40:*/ 0x07, 0x10, 0x7e, 0x1d, 0xa4, 0x80, 0x2c, 0x16, 0xf0, 0x3b, 0x66, 0x3d, 0x74, 0x15, 0x25, 0xe0, + /*2f50:*/ 0x46, 0xf3, 0x08, 0xbd, 0x0b, 0x6e, 0x44, 0x5a, 0xc5, 0x0e, 0x53, 0x01, 0x4b, 0x80, 0x16, 0x91, + /*2f60:*/ 0x07, 0x94, 0x8f, 0x66, 0xb9, 0x38, 0xa1, 0x44, 0xed, 0xd4, 0x44, 0x58, 0x36, 0xd2, 0x12, 0xf3, + /*2f70:*/ 0xb0, 0x41, 0x7a, 0xfa, 0xaa, 0xca, 0x35, 0xf2, 0xd6, 0x4e, 0xf7, 0x8b, 0xce, 0x9b, 0x7d, 0x67, + /*2f80:*/ 0xdc, 0xbb, 0x46, 0xc8, 0x19, 0xbf, 0x0d, 0xd0, 0x7a, 0xee, 0x10, 0xb7, 0x9c, 0x85, 0x94, 0xb4, + /*2f90:*/ 0xfd, 0x49, 0x0d, 0x77, 0x9e, 0x95, 0x0b, 0xe2, 0xd5, 0xef, 0x28, 0x08, 0xee, 0xbf, 0xf9, 0x4b, + /*2fa0:*/ 0x39, 0x74, 0x02, 0x96, 0x1a, 0x8f, 0x34, 0x8b, 0x3a, 0xd9, 0x3f, 0x63, 0xa4, 0xfd, 0x63, 0xbd, + /*2fb0:*/ 0xc6, 0xfd, 0x8f, 0x02, 0x97, 0x44, 0xbc, 0xb1, 0xe5, 0x95, 0xd0, 0x5b, 0xa8, 0x3c, 0x11, 0xd9, + /*2fc0:*/ 0x93, 0xbf, 0x66, 0x82, 0xdc, 0xdd, 0xd5, 0x99, 0xee, 0x92, 0x09, 0x8e, 0x06, 0x0e, 0x7e, 0x67, + /*2fd0:*/ 0x00, 0xb5, 0x93, 0xb3, 0x39, 0x00, 0xe2, 0xe2, 0xb7, 0xe3, 0xe0, 0x1f, 0x3e, 0xd7, 0x8a, 0xc7, + /*2fe0:*/ 0x7e, 0xa6, 0xce, 0x8b, 0x08, 0xaa, 0x9a, 0xde, 0x27, 0xd2, 0xaf, 0xca, 0x72, 0x41, 0xb0, 0x4f, + /*2ff0:*/ 0xea, 0xf5, 0x7b, 0x85, 0x46, 0x03, 0xa6, 0x1f, 0x50, 0x7f, 0x74, 0xba, 0x01, 0xae, 0x88, 0x1e, + /*3000:*/ 0x0a, 0x50, 0x71, 0xb9, 0xcc, 0x78, 0x5a, 0xdd, 0x4c, 0xad, 0x30, 0xbd, 0xe8, 0x34, 0x8a, 0xe1, + /*3010:*/ 0xaf, 0xa9, 0xeb, 0xb9, 0x22, 0x69, 0xd7, 0x30, 0x45, 0xa6, 0x06, 0xf3, 0xd6, 0x4e, 0xac, 0x19, + /*3020:*/ 0xcf, 0x12, 0x66, 0x1d, 0xd2, 0x11, 0xe1, 0xcf, 0x3c, 0x12, 0x21, 0xcd, 0x74, 0xd2, 0xba, 0x62, + /*3030:*/ 0xcc, 0x6c, 0xb9, 0x67, 0xfd, 0xc4, 0x5a, 0x94, 0xc5, 0x6f, 0x1e, 0xb7, 0x49, 0x8c, 0x24, 0x96, + /*3040:*/ 0xf1, 0x8c, 0x30, 0xb9, 0xfc, 0x2f, 0xdf, 0x9d, 0xb7, 0x6c, 0x81, 0x63, 0xf5, 0x0f, 0x1c, 0xfd, + /*3050:*/ 0x15, 0xbe, 0x0b, 0x36, 0xff, 0xa2, 0xc9, 0x07, 0x40, 0x85, 0x70, 0xe4, 0x4f, 0xb0, 0xa9, 0x11, + /*3060:*/ 0x8b, 0x8d, 0x6f, 0x74, 0x17, 0x7d, 0x4c, 0xf9, 0xc6, 0x23, 0x81, 0x56, 0x21, 0xcb, 0x99, 0x1c, + /*3070:*/ 0x31, 0x03, 0xa1, 0x05, 0x5a, 0x29, 0x9a, 0xf1, 0x2e, 0xf5, 0x07, 0xb1, 0x8b, 0x6b, 0xea, 0xb6, + /*3080:*/ 0xd0, 0xe8, 0x78, 0x93, 0xb3, 0x2d, 0xcf, 0xa6, 0xb8, 0x7e, 0xfe, 0x7c, 0x91, 0x25, 0xa6, 0xf1, + /*3090:*/ 0xc8, 0xaa, 0xff, 0xcd, 0x4a, 0xf3, 0x22, 0x62, 0x98, 0xbb, 0x95, 0xa7, 0x9e, 0xff, 0x23, 0x37, + /*30a0:*/ 0x88, 0x79, 0xbe, 0x02, 0x8e, 0x85, 0xd3, 0x8e, 0x38, 0x50, 0xab, 0x9a, 0x47, 0xa8, 0xa7, 0x1a, + /*30b0:*/ 0x22, 0x06, 0xd2, 0xcb, 0xa9, 0x49, 0xd0, 0xfc, 0xa2, 0x3f, 0xb5, 0x8c, 0x80, 0xa4, 0x65, 0xf0, + /*30c0:*/ 0x7a, 0xe0, 0xf5, 0x05, 0xf8, 0x1f, 0x75, 0x8b, 0x03, 0xa8, 0xd7, 0x45, 0xd1, 0x17, 0xf4, 0x85, + /*30d0:*/ 0x94, 0x85, 0x5a, 0xb3, 0x26, 0x52, 0x4d, 0x24, 0x45, 0x93, 0xd2, 0x19, 0x04, 0x3d, 0xb9, 0x4e, + /*30e0:*/ 0xe7, 0xac, 0x7c, 0xd3, 0x38, 0x2e, 0x13, 0xce, 0x72, 0xf7, 0x26, 0x49, 0x04, 0xd0, 0xe4, 0x9b, + /*30f0:*/ 0x0f, 0x4c, 0x91, 0x27, 0x37, 0x89, 0x20, 0x54, 0x8b, 0xf9, 0xbc, 0x46, 0xab, 0x97, 0x5d, 0xf3, + /*3100:*/ 0x8c, 0xf4, 0xdf, 0x79, 0x3d, 0x13, 0x84, 0xb1, 0x12, 0x33, 0x2d, 0x83, 0xc0, 0xb0, 0xc8, 0x77, + /*3110:*/ 0xb7, 0x2e, 0x24, 0x9d, 0xdd, 0x10, 0x31, 0x6f, 0x1b, 0xef, 0x9c, 0x20, 0xcd, 0x8d, 0x90, 0x07, + /*3120:*/ 0xbf, 0x1c, 0x6f, 0x46, 0xb6, 0x6e, 0xdd, 0x90, 0x8a, 0xf8, 0xf7, 0x14, 0xc0, 0xbe, 0xd4, 0x9b, + /*3130:*/ 0x6f, 0x2a, 0xf5, 0x37, 0xf5, 0xc9, 0x5a, 0x80, 0x5d, 0xef, 0x76, 0x99, 0x7c, 0xfd, 0xd7, 0x04, + /*3140:*/ 0xa5, 0x7b, 0xe5, 0x1e, 0x45, 0x20, 0x82, 0xaa, 0xf6, 0x4f, 0x6a, 0x34, 0xfd, 0xbe, 0x61, 0xc2, + /*3150:*/ 0x2d, 0xbc, 0x5f, 0xcc, 0x56, 0xc4, 0x4d, 0x62, 0x08, 0xcb, 0xf2, 0x2b, 0x1b, 0x79, 0xd6, 0xe3, + /*3160:*/ 0xb6, 0xc2, 0xb0, 0x98, 0xaa, 0xde, 0xb9, 0xf8, 0xf8, 0x26, 0x5e, 0xf1, 0x74, 0x61, 0x5e, 0x10, + /*3170:*/ 0xa6, 0xa7, 0x45, 0x50, 0x2b, 0x94, 0x6d, 0x0d, 0x03, 0x66, 0x81, 0xed, 0x6c, 0x30, 0x48, 0x96, + /*3180:*/ 0x56, 0xda, 0x29, 0x3d, 0x9a, 0xb1, 0xa3, 0x64, 0x1f, 0xcd, 0xc9, 0x63, 0x42, 0x01, 0x08, 0x34, + /*3190:*/ 0x1d, 0x0e, 0x92, 0xca, 0xec, 0x3f, 0x9f, 0x87, 0xda, 0x68, 0xbb, 0xf1, 0x7c, 0x47, 0xc5, 0x26, + /*31a0:*/ 0x72, 0xee, 0x46, 0x90, 0x5c, 0xa7, 0x49, 0xd8, 0xd8, 0xba, 0xd6, 0xc9, 0x52, 0x9f, 0x48, 0x38, + /*31b0:*/ 0x16, 0xd9, 0xe2, 0x99, 0x88, 0xab, 0x1f, 0xca, 0xd9, 0x63, 0xd4, 0xf2, 0x48, 0x07, 0x92, 0x45, + /*31c0:*/ 0xc9, 0xe7, 0x97, 0xdf, 0x7b, 0xf7, 0x4b, 0x69, 0x5b, 0x19, 0x3b, 0x3f, 0x79, 0xc2, 0x23, 0x90, + /*31d0:*/ 0xff, 0x84, 0x5a, 0x8a, 0xe8, 0xdf, 0xcb, 0xaf, 0x3d, 0xa0, 0x15, 0x81, 0x43, 0xc6, 0xb5, 0xd9, + /*31e0:*/ 0x68, 0xc7, 0x83, 0x0b, 0x8a, 0x77, 0x16, 0xb6, 0x75, 0x23, 0x98, 0x9d, 0x0a, 0x08, 0x47, 0x4f, + /*31f0:*/ 0x0b, 0x84, 0x21, 0xdf, 0x61, 0xd5, 0x75, 0x6a, 0x2e, 0x3d, 0x82, 0x58, 0xc6, 0xa8, 0x21, 0xa1, + /*3200:*/ 0xa6, 0x39, 0x33, 0x68, 0x31, 0x70, 0x73, 0x84, 0x15, 0x0e, 0xb5, 0x4f, 0xc4, 0x80, 0x9f, 0x10, + /*3210:*/ 0x34, 0xf5, 0x6d, 0xa6, 0x49, 0x8f, 0x85, 0x36, 0xb4, 0x4c, 0x2f, 0x1e, 0x60, 0xa6, 0xfc, 0xd6, + /*3220:*/ 0xb2, 0x48, 0x2c, 0x7b, 0xdc, 0x02, 0xc7, 0x21, 0x24, 0x47, 0x20, 0x45, 0xd6, 0xbb, 0x29, 0xf6, + /*3230:*/ 0x0d, 0x25, 0x12, 0x58, 0xfe, 0xec, 0x88, 0x29, 0x9d, 0x83, 0xe5, 0x24, 0xac, 0xa3, 0x9b, 0x1f, + /*3240:*/ 0x35, 0x58, 0xe2, 0x3a, 0xf0, 0x85, 0xe1, 0x37, 0xd4, 0x91, 0xe2, 0xbf, 0xd7, 0xf4, 0x03, 0xf2, + /*3250:*/ 0xe4, 0x9d, 0x09, 0x27, 0x95, 0x3f, 0x0e, 0x3d, 0xfd, 0xf7, 0x41, 0xee, 0xb1, 0x76, 0xe1, 0xaf, + /*3260:*/ 0xed, 0x68, 0x37, 0xd5, 0xea, 0xe8, 0x6e, 0xc6, 0x11, 0xe6, 0xd7, 0xb0, 0x59, 0x19, 0x4a, 0x83, + /*3270:*/ 0x3d, 0xec, 0x38, 0xc9, 0x5b, 0xed, 0xe8, 0xe3, 0x76, 0x03, 0xcd, 0x4a, 0x90, 0xa9, 0x21, 0xd5, + /*3280:*/ 0xf4, 0x89, 0xc2, 0x7a, 0xb7, 0xa6, 0x02, 0x40, 0x5c, 0xb7, 0xe7, 0xea, 0x3e, 0xb4, 0x3e, 0x42, + /*3290:*/ 0x81, 0x6e, 0x88, 0x87, 0x7c, 0xa1, 0x71, 0xd5, 0x08, 0x7f, 0x87, 0xa0, 0x34, 0x74, 0x4a, 0x73, + /*32a0:*/ 0x8b, 0xf6, 0xfe, 0x41, 0xc8, 0xd4, 0x1d, 0x3a, 0x1e, 0xae, 0xff, 0xf4, 0x7e, 0xfe, 0xdd, 0x44, + /*32b0:*/ 0x9a, 0x3e, 0x8f, 0x5e, 0xf1, 0xdd, 0xd2, 0x38, 0x61, 0x58, 0x1e, 0xf7, 0xcd, 0x30, 0x3d, 0x88, + /*32c0:*/ 0xc4, 0x14, 0x56, 0xb3, 0x1b, 0x68, 0x0a, 0x02, 0x58, 0x47, 0x42, 0xc6, 0xf0, 0x0c, 0x6a, 0xe9, + /*32d0:*/ 0xa4, 0x20, 0x32, 0x74, 0x5a, 0xf5, 0x54, 0xa4, 0x48, 0x61, 0x6a, 0xa8, 0x12, 0x6b, 0xd9, 0xa7, + /*32e0:*/ 0x0c, 0x6c, 0xcf, 0x74, 0x1c, 0x22, 0xe4, 0x7e, 0x94, 0xe6, 0xf6, 0x9f, 0x0f, 0x17, 0x2b, 0xb1, + /*32f0:*/ 0xf0, 0xb4, 0x3b, 0x6a, 0x98, 0xfd, 0x33, 0x56, 0x6b, 0x10, 0x3e, 0x75, 0xa8, 0x0e, 0x4a, 0x99, + /*3300:*/ 0x1c, 0xfb, 0xe4, 0x70, 0x94, 0x6f, 0xbd, 0xd9, 0x40, 0x68, 0x46, 0x1f, 0x42, 0xac, 0x6c, 0x2d, + /*3310:*/ 0x0d, 0x45, 0xb0, 0x63, 0x81, 0x15, 0xdc, 0x59, 0x54, 0x73, 0xd7, 0xcd, 0xf5, 0x39, 0x93, 0x0a, + /*3320:*/ 0x09, 0xc1, 0x6f, 0x26, 0xc2, 0x33, 0xdd, 0x31, 0x87, 0xab, 0xff, 0x93, 0x96, 0xa4, 0x27, 0xda, + /*3330:*/ 0xd3, 0x5e, 0x30, 0xb4, 0x04, 0x93, 0xd5, 0xdd, 0x83, 0x4b, 0x19, 0x36, 0xb4, 0xdd, 0xeb, 0x45, + /*3340:*/ 0x70, 0x7c, 0xe7, 0x0b, 0x53, 0xda, 0x85, 0x6f, 0x66, 0xcc, 0x88, 0x3d, 0xfe, 0x7f, 0x54, 0xe2, + /*3350:*/ 0x12, 0x18, 0xc8, 0xed, 0x0b, 0x49, 0xc3, 0x4e, 0x88, 0x24, 0xae, 0x50, 0x38, 0xed, 0x78, 0x69, + /*3360:*/ 0x0d, 0x2d, 0x31, 0x46, 0xce, 0x89, 0xcc, 0x3b, 0x34, 0x8e, 0x12, 0xf4, 0xa4, 0x84, 0x6b, 0xc1, + /*3370:*/ 0x2f, 0x69, 0x3a, 0x35, 0x67, 0xb7, 0x13, 0x9d, 0x14, 0x59, 0x2c, 0x73, 0xac, 0x97, 0x1c, 0xc9, + /*3380:*/ 0x23, 0xe0, 0xec, 0xf5, 0x84, 0xb6, 0x30, 0x8a, 0x7f, 0xe6, 0x9b, 0x0d, 0xad, 0xdc, 0xa4, 0x9e, + /*3390:*/ 0xe4, 0x9f, 0x92, 0xae, 0x05, 0xd7, 0xf3, 0x74, 0x54, 0x24, 0xf8, 0x9f, 0x09, 0xa4, 0xc9, 0x3c, + /*33a0:*/ 0x6d, 0xda, 0x01, 0xeb, 0x25, 0x06, 0x66, 0xdd, 0xc0, 0x2d, 0x73, 0xfd, 0x45, 0xd1, 0xe4, 0x34, + /*33b0:*/ 0x73, 0xb4, 0x62, 0x11, 0xaf, 0x82, 0x2d, 0xcb, 0xaa, 0xb7, 0x9c, 0x83, 0xc5, 0x57, 0x86, 0xc3, + /*33c0:*/ 0xdd, 0xa0, 0xf1, 0x6d, 0xf3, 0x5a, 0xbe, 0xa8, 0xb6, 0x9f, 0x66, 0x9c, 0x7b, 0x48, 0xf1, 0x71, + /*33d0:*/ 0x83, 0x94, 0x54, 0x8d, 0x85, 0xb5, 0x03, 0xd1, 0x88, 0xb9, 0xe6, 0xcb, 0x78, 0xab, 0xea, 0x24, + /*33e0:*/ 0x54, 0x7e, 0x3f, 0x66, 0xa0, 0x3e, 0x63, 0x9b, 0x8c, 0x57, 0x2c, 0xa9, 0x97, 0xba, 0xfd, 0x6e, + /*33f0:*/ 0x05, 0xbb, 0xda, 0x9f, 0x1c, 0x9d, 0x6d, 0xea, 0x04, 0x84, 0x8c, 0x07, 0x78, 0xa2, 0x80, 0x1e, + /*3400:*/ 0x1e, 0xe0, 0x0b, 0x8f, 0x89, 0xf3, 0x84, 0x23, 0x17, 0x71, 0xff, 0x15, 0x64, 0x49, 0x2e, 0x90, + /*3410:*/ 0x0e, 0x50, 0x20, 0x2f, 0xf1, 0x9b, 0xb9, 0xb3, 0xe6, 0xf0, 0xee, 0xbb, 0x5f, 0x6d, 0xa6, 0xa2, + /*3420:*/ 0x10, 0x8f, 0xaf, 0x2f, 0x4e, 0xe9, 0x27, 0xa0, 0x04, 0x48, 0xda, 0x9a, 0x03, 0x64, 0x33, 0x42, + /*3430:*/ 0x0e, 0x02, 0x2e, 0x1f, 0x0e, 0x87, 0x0c, 0xd7, 0xe7, 0x09, 0xac, 0x79, 0x42, 0x93, 0xd7, 0x4a, + /*3440:*/ 0xaa, 0x5f, 0x07, 0xed, 0xb1, 0xaf, 0x0c, 0x22, 0x63, 0x2a, 0x9c, 0x9d, 0x4b, 0x6c, 0xf6, 0x80, + /*3450:*/ 0x0a, 0x1e, 0x4a, 0x50, 0x07, 0x64, 0xc6, 0xcc, 0x3a, 0x2a, 0x64, 0x9e, 0xde, 0x5b, 0x2d, 0x6c, + /*3460:*/ 0xe3, 0x48, 0xb5, 0x11, 0x9d, 0x3c, 0xf0, 0x8f, 0x5c, 0x0d, 0xd7, 0x02, 0xf5, 0xce, 0xff, 0x71, + /*3470:*/ 0x06, 0xc4, 0x4b, 0x7d, 0x67, 0x7e, 0xef, 0xc4, 0x78, 0x60, 0xba, 0x58, 0x0f, 0xbc, 0x84, 0x7b, + /*3480:*/ 0xc5, 0xba, 0xde, 0x8b, 0xdc, 0x60, 0x78, 0xab, 0xf2, 0xde, 0xd4, 0xed, 0x00, 0x22, 0x6b, 0xa4, + /*3490:*/ 0x4a, 0x79, 0x43, 0x79, 0xba, 0x03, 0x84, 0x25, 0x0c, 0x41, 0x1d, 0x1f, 0x19, 0x23, 0x7c, 0xf7, + /*34a0:*/ 0x20, 0xa3, 0xfd, 0xa1, 0x4f, 0xff, 0xfe, 0x8c, 0x7e, 0xb9, 0x07, 0x7d, 0xbe, 0x79, 0x18, 0xa8, + /*34b0:*/ 0x24, 0x2a, 0x95, 0x01, 0xf3, 0x3f, 0xb1, 0xa6, 0xe4, 0xda, 0xcf, 0x68, 0x42, 0x08, 0x2c, 0x4d, + /*34c0:*/ 0x2a, 0xd7, 0xb3, 0x6f, 0x4a, 0xb4, 0x6b, 0xe9, 0x0b, 0xfb, 0x73, 0xb1, 0x21, 0x0a, 0x44, 0xab, + /*34d0:*/ 0x47, 0x02, 0xdb, 0xb5, 0x0b, 0x13, 0x6f, 0x0c, 0x78, 0x40, 0xbd, 0x73, 0x04, 0xf2, 0x7e, 0x54, + /*34e0:*/ 0x85, 0x35, 0x78, 0x52, 0x6d, 0xf4, 0x05, 0x70, 0x51, 0xa2, 0xb9, 0x6f, 0x34, 0x8c, 0x4b, 0x7b, + /*34f0:*/ 0xb8, 0x6c, 0x3b, 0xa5, 0xe7, 0x22, 0xc6, 0x46, 0xa8, 0x09, 0xc3, 0x6b, 0x19, 0x01, 0x50, 0xa5, + /*3500:*/ 0x58, 0xef, 0x4d, 0xfa, 0xee, 0x20, 0xbd, 0xcb, 0xd1, 0x56, 0xae, 0x7e, 0xc3, 0x6f, 0x61, 0x52, + /*3510:*/ 0xde, 0x9e, 0x59, 0xc4, 0x41, 0x52, 0x78, 0x39, 0x97, 0x30, 0x24, 0x9e, 0x92, 0xea, 0xbc, 0x69, + /*3520:*/ 0xf9, 0x8d, 0x1d, 0x1a, 0xce, 0x74, 0x52, 0x4f, 0x04, 0x5f, 0x0e, 0xd8, 0xb7, 0xb4, 0xf5, 0x5b, + /*3530:*/ 0xa9, 0x1c, 0xc0, 0x0d, 0xf3, 0xbc, 0x27, 0xde, 0x37, 0xe6, 0x26, 0x11, 0xd4, 0x9b, 0x25, 0x42, + /*3540:*/ 0xd7, 0xc1, 0xf6, 0xde, 0xb5, 0xae, 0x24, 0x59, 0x2a, 0x83, 0xb5, 0xa6, 0x8f, 0x03, 0xd3, 0xbf, + /*3550:*/ 0xcb, 0x58, 0x76, 0xe0, 0xf7, 0xdb, 0x63, 0xa4, 0x18, 0xbc, 0xfb, 0x0c, 0x76, 0x3e, 0x73, 0x71, + /*3560:*/ 0x4a, 0xdc, 0x5a, 0x0e, 0xf8, 0x59, 0x88, 0xc1, 0xc9, 0x55, 0x13, 0xc7, 0xab, 0x57, 0x85, 0x5b, + /*3570:*/ 0x46, 0x4d, 0x19, 0x14, 0x0c, 0xb0, 0x43, 0xd2, 0x92, 0xef, 0x6f, 0x8b, 0xd9, 0x06, 0xd3, 0x2f, + /*3580:*/ 0xaf, 0xf3, 0xa5, 0x09, 0x71, 0x96, 0x97, 0x5a, 0xfd, 0x03, 0x65, 0xad, 0x8e, 0x62, 0xce, 0x91, + /*3590:*/ 0x96, 0xd3, 0x91, 0x11, 0xb2, 0x85, 0xc7, 0xcb, 0x29, 0x79, 0x8d, 0x37, 0xd7, 0xec, 0x13, 0x43, + /*35a0:*/ 0x20, 0x08, 0x40, 0x8f, 0xa2, 0xee, 0xa5, 0x1f, 0xed, 0xa5, 0x78, 0x4b, 0x59, 0x50, 0x60, 0x09, + /*35b0:*/ 0x66, 0x0b, 0x0a, 0x5a, 0xc1, 0xd6, 0xe3, 0x96, 0xcd, 0xa2, 0x61, 0x26, 0x57, 0xa0, 0x51, 0x7e, + /*35c0:*/ 0x11, 0x21, 0xad, 0xce, 0xf5, 0x26, 0xdc, 0x8c, 0x3e, 0xd0, 0x61, 0xd8, 0x11, 0x2c, 0x7a, 0x68, + /*35d0:*/ 0xca, 0x95, 0x26, 0xde, 0x3c, 0xb4, 0xf1, 0x4b, 0x1e, 0xb8, 0x21, 0x83, 0x1e, 0xdb, 0xd9, 0x9d, + /*35e0:*/ 0x73, 0x60, 0xfa, 0x26, 0x2b, 0x41, 0xd1, 0x55, 0x16, 0x7b, 0x9f, 0xa8, 0xa4, 0x1f, 0x18, 0x5b, + /*35f0:*/ 0x6d, 0x22, 0xab, 0x73, 0x71, 0x7c, 0x04, 0xa8, 0xef, 0x3f, 0x1d, 0x2c, 0x9a, 0x98, 0x4e, 0xff, + /*3600:*/ 0xc7, 0xef, 0x7b, 0x63, 0x4d, 0x79, 0xe2, 0x33, 0x0a, 0xd8, 0x26, 0x30, 0xfc, 0xa3, 0x24, 0x5e, + /*3610:*/ 0x2f, 0xd7, 0xb3, 0x90, 0x1e, 0x45, 0x30, 0x41, 0x00, 0x59, 0x92, 0x62, 0x20, 0xb3, 0xff, 0x5d, + /*3620:*/ 0x47, 0x31, 0x6e, 0x87, 0xe5, 0x7e, 0x9d, 0x73, 0x8d, 0x3d, 0x74, 0x9c, 0x4b, 0xf7, 0xc8, 0x86, + /*3630:*/ 0xe4, 0xa7, 0xac, 0x4c, 0xf9, 0x51, 0x2f, 0x4d, 0xd2, 0x02, 0x9b, 0xcf, 0xb7, 0x68, 0x7f, 0x25, + /*3640:*/ 0xc7, 0x22, 0xfa, 0x75, 0xe5, 0xdd, 0x7e, 0xd3, 0x28, 0x07, 0x87, 0x78, 0x62, 0x20, 0x0e, 0xa1, + /*3650:*/ 0xab, 0x3e, 0xfd, 0xd0, 0x04, 0xe6, 0xd8, 0xf0, 0xa3, 0x1e, 0x05, 0xf5, 0x7e, 0x5e, 0xd8, 0xee, + /*3660:*/ 0x62, 0xc2, 0x71, 0xf7, 0x4a, 0x05, 0x84, 0x90, 0x15, 0x0a, 0x4a, 0x25, 0x32, 0x3c, 0x1c, 0xfe, + /*3670:*/ 0x14, 0xe2, 0x19, 0x3b, 0x97, 0xe4, 0x38, 0x8b, 0x7d, 0x30, 0x4b, 0x00, 0x62, 0x01, 0x68, 0x0f, + /*3680:*/ 0x01, 0xe3, 0xbb, 0x7d, 0x1a, 0x74, 0x0d, 0x09, 0x8e, 0x7a, 0xfe, 0x00, 0xc3, 0xb8, 0x23, 0xe7, + /*3690:*/ 0x98, 0xf5, 0xd7, 0x2b, 0x32, 0x2a, 0x4a, 0xbf, 0xe2, 0x21, 0x5f, 0xd8, 0x7a, 0x7c, 0x65, 0x0a, + /*36a0:*/ 0xba, 0x46, 0xfb, 0x66, 0x27, 0xdb, 0xd2, 0xa6, 0x52, 0x49, 0x7a, 0xb2, 0xee, 0x58, 0xe0, 0xc2, + /*36b0:*/ 0x90, 0x76, 0x90, 0x4a, 0x6f, 0xa1, 0x04, 0x44, 0xba, 0x9e, 0x40, 0x33, 0x16, 0x27, 0xa3, 0x0e, + /*36c0:*/ 0x6b, 0xed, 0x26, 0x0a, 0xaa, 0xc2, 0x09, 0x6a, 0xd6, 0x7c, 0x86, 0x9d, 0x3c, 0x57, 0x66, 0x01, + /*36d0:*/ 0xf0, 0x59, 0xd1, 0x2a, 0xf4, 0x5e, 0xa8, 0x4f, 0xff, 0x1a, 0xb2, 0xc6, 0xc6, 0xaa, 0x1e, 0x0d, + /*36e0:*/ 0x8d, 0x32, 0x05, 0x6d, 0x97, 0x25, 0xea, 0x32, 0x14, 0x4b, 0x6b, 0x20, 0x2a, 0x8c, 0x2b, 0xc1, + /*36f0:*/ 0x58, 0xcb, 0xa6, 0x87, 0x50, 0x96, 0xdb, 0x48, 0x3b, 0xcf, 0x6a, 0x41, 0x30, 0x72, 0x2d, 0x00, + /*3700:*/ 0x54, 0x6c, 0x03, 0x86, 0x88, 0x1a, 0x67, 0x8f, 0xa1, 0x4c, 0xdc, 0xf5, 0x7c, 0x16, 0xcf, 0x6f, + /*3710:*/ 0xa1, 0x5c, 0x59, 0x83, 0xb2, 0xca, 0xc3, 0xa4, 0x86, 0xa3, 0x0b, 0xab, 0x45, 0xeb, 0xf0, 0x21, + /*3720:*/ 0x8d, 0x06, 0x7f, 0x44, 0xa2, 0x4f, 0xeb, 0x63, 0x6f, 0x41, 0x11, 0x45, 0x7d, 0x00, 0xe9, 0x80, + /*3730:*/ 0x98, 0x25, 0xe3, 0x9c, 0x5f, 0x21, 0x9e, 0x3c, 0xfa, 0x8f, 0x0c, 0x35, 0x29, 0xce, 0x6e, 0xd6, + /*3740:*/ 0x48, 0x2c, 0x30, 0x90, 0xce, 0x35, 0x9d, 0x23, 0x10, 0x7d, 0x21, 0x0e, 0xc2, 0x93, 0x93, 0x8c, + /*3750:*/ 0xc5, 0xfc, 0xc6, 0x33, 0x05, 0x56, 0xa3, 0x53, 0x28, 0xd5, 0x3f, 0xc2, 0x80, 0x22, 0x9d, 0x5f, + /*3760:*/ 0xaa, 0x97, 0x06, 0x0b, 0xa1, 0xa7, 0x7b, 0x12, 0x7f, 0xcc, 0xca, 0xbc, 0x3e, 0x72, 0xd2, 0x17, + /*3770:*/ 0xb0, 0xd0, 0xe2, 0x0e, 0x36, 0xe4, 0xeb, 0xd5, 0x25, 0xc7, 0x94, 0xc4, 0x36, 0xa5, 0x2f, 0xee, + /*3780:*/ 0x03, 0xe3, 0x99, 0x3b, 0x9a, 0x57, 0x81, 0x71, 0xc6, 0xdc, 0x18, 0xea, 0x88, 0x10, 0x59, 0xfd, + /*3790:*/ 0x9d, 0x31, 0x71, 0x79, 0x55, 0x5d, 0x65, 0xf1, 0x20, 0x81, 0x9e, 0x0e, 0x42, 0x91, 0x2a, 0xa7, + /*37a0:*/ 0x0a, 0x79, 0xa8, 0x33, 0xd5, 0x00, 0x1d, 0x55, 0xb2, 0x47, 0xc6, 0xda, 0x47, 0x1e, 0x55, 0x7a, + /*37b0:*/ 0xb5, 0x16, 0xe9, 0x16, 0x75, 0x1c, 0x1a, 0x6e, 0x57, 0x30, 0xf4, 0xe1, 0xf0, 0x92, 0x2d, 0x28, + /*37c0:*/ 0xfa, 0x30, 0xc5, 0xc2, 0x6e, 0x6b, 0x0b, 0x98, 0x64, 0xd7, 0x3f, 0x6e, 0x73, 0x20, 0xb1, 0xda, + /*37d0:*/ 0x9a, 0xc4, 0x04, 0xe9, 0xc8, 0x8c, 0x09, 0xb3, 0x0f, 0x06, 0xa8, 0x07, 0x11, 0xc2, 0x15, 0x27, + /*37e0:*/ 0x08, 0xeb, 0x42, 0x29, 0xfb, 0x7c, 0xb2, 0xd5, 0x2c, 0x25, 0x85, 0x6b, 0x07, 0x51, 0xdc, 0x0a, + /*37f0:*/ 0x6b, 0xd4, 0xdb, 0x1d, 0xf7, 0x21, 0x59, 0xa0, 0xb5, 0xd9, 0xdf, 0x62, 0x34, 0xd0, 0xce, 0xad, + /*3800:*/ 0xfc, 0xad, 0x16, 0xcc, 0x01, 0x9d, 0x55, 0x5e, 0x84, 0xdd, 0x5f, 0xad, 0x3a, 0x36, 0x81, 0x5c, + /*3810:*/ 0xaf, 0x48, 0xce, 0x4d, 0xb7, 0x39, 0x02, 0x47, 0x20, 0x55, 0xd6, 0xbd, 0x4e, 0xf8, 0xe8, 0x78, + /*3820:*/ 0x74, 0xb3, 0x8e, 0x76, 0xbf, 0x71, 0x1e, 0x46, 0x5b, 0x33, 0x74, 0x23, 0xe1, 0x8b, 0xee, 0x89, + /*3830:*/ 0x38, 0xdb, 0xde, 0xb7, 0xae, 0x06, 0x3c, 0x51, 0x1b, 0xaf, 0xf6, 0x32, 0x61, 0x5b, 0xe2, 0xf6, + /*3840:*/ 0x7e, 0x0e, 0x78, 0xe8, 0xcf, 0x1a, 0x4a, 0x39, 0xf8, 0xda, 0x4f, 0x1b, 0xb5, 0xe4, 0x25, 0x3e, + /*3850:*/ 0x41, 0xef, 0x28, 0xcb, 0x17, 0x2f, 0xa4, 0x55, 0xd6, 0xf9, 0x88, 0x48, 0x26, 0x66, 0x56, 0xfe, + /*3860:*/ 0x30, 0x4d, 0x7d, 0x6b, 0xf8, 0x61, 0x80, 0x0f, 0x3d, 0x36, 0xb3, 0x7d, 0x73, 0x40, 0x17, 0x92, + /*3870:*/ 0x51, 0x58, 0x05, 0x49, 0x4b, 0x83, 0x13, 0x2a, 0x24, 0xd5, 0x92, 0xac, 0x40, 0x67, 0xe3, 0xa8, + /*3880:*/ 0xe9, 0xa6, 0x85, 0x58, 0xd7, 0xf4, 0xfc, 0x1d, 0xb5, 0x68, 0x19, 0xa7, 0xf8, 0xd8, 0xa5, 0x75, + /*3890:*/ 0xe0, 0x6d, 0xc6, 0x5a, 0xa6, 0xa3, 0x1c, 0x16, 0xd3, 0xf3, 0x61, 0xbb, 0x3c, 0x61, 0xb1, 0x3d, + /*38a0:*/ 0x58, 0xb9, 0x3f, 0x8a, 0xb2, 0x61, 0x6d, 0x78, 0x92, 0x20, 0x6e, 0xff, 0x69, 0x5e, 0x3e, 0xe2, + /*38b0:*/ 0x16, 0xb2, 0xc4, 0x44, 0x8d, 0xb9, 0x86, 0xa5, 0xcf, 0xc7, 0x97, 0xc1, 0x10, 0xed, 0xe7, 0x76, + /*38c0:*/ 0xe3, 0xa6, 0x51, 0x8f, 0x01, 0xb5, 0xd0, 0x34, 0xe2, 0xab, 0x7d, 0x45, 0xb6, 0x1f, 0x7c, 0xde, + /*38d0:*/ 0x5a, 0xa7, 0x59, 0x9e, 0xd2, 0x4b, 0x6d, 0xc8, 0xf4, 0x29, 0xb4, 0x73, 0x20, 0x0a, 0xc5, 0x60, + /*38e0:*/ 0xd1, 0x6e, 0xad, 0x8f, 0xb7, 0x56, 0xd3, 0xaa, 0xf9, 0xff, 0x16, 0xcc, 0x7b, 0x87, 0x2c, 0x3a, + /*38f0:*/ 0xa1, 0x1c, 0x57, 0x24, 0x5f, 0xb5, 0xb0, 0x99, 0x9c, 0xdb, 0xef, 0xdc, 0x4f, 0x6c, 0xea, 0x39, + /*3900:*/ 0x6d, 0x3d, 0x75, 0x65, 0x90, 0x79, 0xb5, 0x4b, 0xa9, 0x86, 0x74, 0xc5, 0xe6, 0x60, 0x7c, 0x2e, + /*3910:*/ 0xa4, 0x64, 0x93, 0xc8, 0x24, 0x54, 0x9b, 0xbf, 0x08, 0x07, 0xd1, 0x94, 0x87, 0xea, 0x9d, 0x88, + /*3920:*/ 0x19, 0x52, 0x32, 0xa4, 0xb5, 0x09, 0xf1, 0xb8, 0xee, 0x33, 0xc9, 0xff, 0x17, 0x9e, 0xbc, 0xb9, + /*3930:*/ 0xb4, 0x53, 0x93, 0xf4, 0x76, 0xa2, 0xd0, 0x87, 0xce, 0x22, 0xea, 0xee, 0xe3, 0xeb, 0x88, 0x58, + /*3940:*/ 0xb5, 0xb2, 0xd8, 0xed, 0x4c, 0x01, 0x2a, 0x8c, 0x25, 0x6f, 0xbf, 0xb1, 0xe5, 0x23, 0xf1, 0x7a, + /*3950:*/ 0x78, 0x2b, 0x32, 0x37, 0x99, 0xc3, 0xb0, 0x23, 0xa2, 0x9f, 0x72, 0xb6, 0x71, 0x88, 0x92, 0x32, + /*3960:*/ 0x52, 0x77, 0xd1, 0xb6, 0x0d, 0xbe, 0x6e, 0xd4, 0xdc, 0xf9, 0xb2, 0x0f, 0xcc, 0x8d, 0x8a, 0x96, + /*3970:*/ 0xce, 0x7f, 0x8f, 0xa4, 0x0e, 0x8f, 0x5f, 0x4c, 0x35, 0x54, 0xcb, 0xe2, 0xfa, 0xad, 0x5d, 0xd5, + /*3980:*/ 0x5d, 0x70, 0xf2, 0x82, 0x78, 0x27, 0xb9, 0xf9, 0x02, 0x15, 0x53, 0x00, 0xae, 0x29, 0x85, 0xf4, + /*3990:*/ 0xba, 0xc6, 0x0e, 0x6c, 0xb6, 0xe9, 0xef, 0xe1, 0x88, 0x42, 0xc5, 0x1a, 0x23, 0x5f, 0x19, 0xaf, + /*39a0:*/ 0x15, 0x9e, 0x26, 0x48, 0x42, 0x91, 0xc5, 0xc0, 0xfe, 0xfb, 0x72, 0x0c, 0x98, 0x98, 0xfa, 0xed, + /*39b0:*/ 0x94, 0x12, 0x1f, 0xc5, 0x14, 0x00, 0x55, 0xa5, 0x10, 0xc6, 0xf6, 0x3e, 0x64, 0x8c, 0xa7, 0x4e, + /*39c0:*/ 0x11, 0x84, 0x16, 0xeb, 0x48, 0x90, 0x49, 0xc2, 0xbf, 0x3c, 0xab, 0x54, 0xe4, 0x28, 0x59, 0x43, + /*39d0:*/ 0x77, 0xad, 0x1a, 0x14, 0xd8, 0xc3, 0x3e, 0x88, 0x3f, 0x7f, 0x38, 0xbf, 0xe2, 0x65, 0x89, 0x6d, + /*39e0:*/ 0x9e, 0x4e, 0x91, 0x5f, 0x6a, 0x70, 0x48, 0x17, 0xa0, 0x87, 0x68, 0x0d, 0x4b, 0x7c, 0x56, 0x1f, + /*39f0:*/ 0x57, 0xb0, 0x4d, 0x54, 0x78, 0x3e, 0x2b, 0xdb, 0x12, 0xed, 0x1d, 0x69, 0x7a, 0x48, 0x03, 0x46, + /*3a00:*/ 0x3c, 0xa8, 0x45, 0xff, 0xc7, 0x23, 0x17, 0x2d, 0xdd, 0x6b, 0xad, 0x4a, 0xff, 0x9d, 0x8d, 0xa2, + /*3a10:*/ 0x9e, 0x3d, 0x5b, 0xe6, 0x7a, 0x0f, 0x31, 0x6e, 0x0a, 0xca, 0xc4, 0x48, 0x91, 0xe5, 0xd2, 0x38, + /*3a20:*/ 0xfe, 0x87, 0x1b, 0x4a, 0xa1, 0xca, 0xd6, 0xad, 0x4d, 0x90, 0xff, 0x65, 0x93, 0xc1, 0x22, 0xdd, + /*3a30:*/ 0x46, 0x16, 0x89, 0x08, 0x6e, 0x6d, 0x35, 0x5e, 0x13, 0x95, 0x6d, 0x0e, 0xce, 0xd1, 0x3c, 0x98, + /*3a40:*/ 0x15, 0x0a, 0xee, 0xaa, 0xbb, 0x7e, 0xba, 0x21, 0x1c, 0x1d, 0x52, 0x6d, 0xaa, 0x86, 0xcd, 0x42, + /*3a50:*/ 0x52, 0xf4, 0xdf, 0xca, 0x57, 0xf8, 0x26, 0x7b, 0xc7, 0x31, 0x37, 0xec, 0xbb, 0x5b, 0x61, 0xe5, + /*3a60:*/ 0xda, 0xa9, 0x93, 0xd6, 0xe1, 0xd7, 0xcf, 0xdc, 0xeb, 0x3a, 0xcb, 0x19, 0x73, 0x40, 0xf3, 0xde, + /*3a70:*/ 0x5d, 0x4a, 0xaf, 0x46, 0x62, 0xbb, 0xf7, 0x4b, 0x4c, 0xe1, 0x50, 0xa7, 0xc5, 0x14, 0x71, 0xbf, + /*3a80:*/ 0x3a, 0x03, 0x8a, 0xd2, 0xaa, 0x9a, 0x44, 0x91, 0xaf, 0xd1, 0x44, 0x24, 0xa4, 0x0e, 0x47, 0x32, + /*3a90:*/ 0x51, 0x62, 0x14, 0x10, 0x8d, 0x21, 0x2d, 0x7e, 0x62, 0x12, 0x5d, 0xc1, 0x46, 0xcc, 0x9d, 0xd0, + /*3aa0:*/ 0xa0, 0xa2, 0x35, 0x33, 0xcb, 0x4c, 0xc0, 0x5a, 0x20, 0x2e, 0xc8, 0x49, 0x03, 0x12, 0x00, 0xc9, + /*3ab0:*/ 0x5c, 0xc8, 0xc3, 0xff, 0xfa, 0x1f, 0x85, 0x18, 0x78, 0xe4, 0x7f, 0x95, 0x07, 0xce, 0xb3, 0xf3, + /*3ac0:*/ 0xb1, 0x75, 0x76, 0xf3, 0xd8, 0x82, 0xc8, 0xc9, 0x5e, 0xb5, 0x30, 0xa6, 0xbf, 0xcb, 0x0a, 0x21, + /*3ad0:*/ 0x1e, 0x98, 0x06, 0x8e, 0x4c, 0x7a, 0xb4, 0x72, 0x36, 0xf5, 0xca, 0x07, 0xce, 0x90, 0xf2, 0x1f, + /*3ae0:*/ 0xcd, 0x68, 0xac, 0x7f, 0x12, 0x8a, 0x19, 0x2c, 0x60, 0x3a, 0x9a, 0x65, 0x79, 0x48, 0x01, 0x89, + /*3af0:*/ 0x9e, 0x61, 0xff, 0xe4, 0x36, 0x4f, 0x0d, 0x9b, 0x69, 0xaa, 0x9f, 0x01, 0x87, 0x53, 0x13, 0x0c, + /*3b00:*/ 0x93, 0x20, 0x21, 0x87, 0x41, 0x48, 0xfc, 0x82, 0xe9, 0x12, 0x4c, 0x17, 0xd0, 0xee, 0xdc, 0x68, + /*3b10:*/ 0xf9, 0xdd, 0x28, 0x13, 0xa4, 0x28, 0x12, 0x97, 0x38, 0xe9, 0xb9, 0x7c, 0x0e, 0xfe, 0xc3, 0xd3, + /*3b20:*/ 0x86, 0x7d, 0xb3, 0x82, 0x66, 0xb8, 0x98, 0xeb, 0xdd, 0x24, 0x82, 0xa6, 0x26, 0x82, 0xd0, 0xf0, + /*3b30:*/ 0x44, 0xd1, 0x1e, 0x49, 0xee, 0xf5, 0x48, 0x75, 0x87, 0xca, 0xe2, 0xdf, 0x81, 0x9a, 0x5b, 0x83, + /*3b40:*/ 0xfd, 0xa1, 0xef, 0x87, 0x83, 0x95, 0xe5, 0x8c, 0x74, 0x35, 0x38, 0xd9, 0x7c, 0x56, 0x5f, 0xf0, + /*3b50:*/ 0xd4, 0x60, 0xb8, 0x97, 0xe2, 0x96, 0x06, 0xd3, 0xc9, 0xc9, 0x88, 0x31, 0x02, 0x2a, 0xb2, 0x28, + /*3b60:*/ 0xb2, 0xcc, 0x91, 0xcb, 0x01, 0xec, 0xb5, 0x9d, 0x09, 0x6e, 0xd0, 0xde, 0xf0, 0xce, 0x72, 0x93, + /*3b70:*/ 0x6c, 0xcb, 0xaa, 0x2b, 0x29, 0x84, 0xbe, 0xab, 0xff, 0x42, 0x2e, 0x4f, 0xc1, 0x65, 0x22, 0x91, + /*3b80:*/ 0xac, 0xb3, 0xfb, 0x53, 0x98, 0x56, 0x8f, 0x16, 0xbe, 0x1d, 0x7f, 0x29, 0x17, 0xdc, 0x9d, 0xf8, + /*3b90:*/ 0x59, 0x8b, 0xa9, 0x76, 0x01, 0xa8, 0x24, 0xa7, 0x00, 0xdd, 0xa3, 0xe5, 0x6e, 0x27, 0x66, 0x2f, + /*3ba0:*/ 0xe7, 0x1d, 0x0d, 0x2a, 0x75, 0x80, 0x10, 0x38, 0xf6, 0x3d, 0x45, 0x18, 0xb0, 0x31, 0xcb, 0xe0, + /*3bb0:*/ 0x8e, 0x73, 0x14, 0xbc, 0x36, 0x16, 0xf3, 0xa8, 0xd5, 0x3e, 0xf6, 0xdc, 0xa7, 0x33, 0xcb, 0x49, + /*3bc0:*/ 0xb6, 0x45, 0x00, 0xb6, 0xcc, 0x9d, 0x40, 0xbc, 0x1d, 0x12, 0xbb, 0xe4, 0xd0, 0x3f, 0xa6, 0x28, + /*3bd0:*/ 0x5d, 0x0f, 0xa2, 0x90, 0xbe, 0x1f, 0x90, 0x6a, 0xb8, 0x22, 0x89, 0xf9, 0x3a, 0xdd, 0x7a, 0xe8, + /*3be0:*/ 0x63, 0x1f, 0x1f, 0x15, 0xa1, 0xbd, 0x72, 0x6d, 0x83, 0x02, 0x5e, 0x95, 0x5c, 0x33, 0x20, 0xb4, + /*3bf0:*/ 0xe5, 0x39, 0x87, 0xd9, 0x57, 0xd7, 0xb6, 0x86, 0x21, 0xff, 0xfa, 0x67, 0x7e, 0x94, 0xac, 0xda, + /*3c00:*/ 0xf0, 0xe0, 0x4e, 0xc4, 0x88, 0x84, 0x01, 0xcc, 0xfa, 0x37, 0x27, 0xbe, 0x63, 0x8f, 0x41, 0x94, + /*3c10:*/ 0x75, 0x06, 0x8c, 0x10, 0xd5, 0xf7, 0xe1, 0x2c, 0x92, 0xe1, 0x4f, 0xda, 0xdf, 0xac, 0x64, 0xe8, + /*3c20:*/ 0x8e, 0xbb, 0x8b, 0x9a, 0x70, 0x57, 0x50, 0xb3, 0x63, 0x77, 0xcf, 0xa6, 0xb0, 0x91, 0x13, 0xa4, + /*3c30:*/ 0x29, 0xf1, 0x27, 0x1d, 0x4e, 0x37, 0x6b, 0x81, 0xd3, 0x0d, 0x3c, 0xb6, 0x91, 0x42, 0xf4, 0x70, + /*3c40:*/ 0x64, 0x86, 0x2f, 0xee, 0xec, 0xc2, 0x97, 0xb7, 0xb6, 0xf2, 0x86, 0x8a, 0x7a, 0x2d, 0x6c, 0x06, + /*3c50:*/ 0x5d, 0x24, 0xd9, 0xf9, 0xc8, 0xd2, 0xd6, 0xb5, 0xb8, 0xd7, 0x0a, 0x1e, 0x31, 0x4f, 0x04, 0x9c, + /*3c60:*/ 0x4b, 0xe0, 0x21, 0xdf, 0xb3, 0x8d, 0xdf, 0xc7, 0x9d, 0x57, 0x62, 0xa4, 0xff, 0x88, 0x07, 0x0e, + /*3c70:*/ 0xad, 0x7f, 0x39, 0xe8, 0x8a, 0x04, 0x64, 0xde, 0x94, 0xc3, 0xa3, 0xd0, 0xc8, 0x40, 0x27, 0x63, + /*3c80:*/ 0x76, 0x4b, 0xa0, 0xe1, 0xdc, 0xf1, 0xec, 0x93, 0xd3, 0xa2, 0x69, 0x8a, 0xa7, 0xe2, 0x33, 0x97, + /*3c90:*/ 0x58, 0xff, 0x7e, 0x66, 0x24, 0x2c, 0x61, 0x7f, 0x3a, 0xdf, 0x92, 0x31, 0x4b, 0x66, 0x52, 0x7e, + /*3ca0:*/ 0xa3, 0x88, 0x7e, 0x57, 0xe6, 0x51, 0xf6, 0x7f, 0x98, 0x93, 0x6b, 0xd7, 0x7d, 0x7d, 0xee, 0x72, + /*3cb0:*/ 0xc6, 0x15, 0xe1, 0x30, 0x2a, 0xeb, 0x48, 0x8f, 0x8d, 0xed, 0x62, 0x0c, 0x53, 0x93, 0x62, 0x1e, + /*3cc0:*/ 0x61, 0x1a, 0x2e, 0x34, 0xad, 0xd2, 0x47, 0x0d, 0x08, 0x8e, 0xae, 0x35, 0x77, 0x25, 0x67, 0x00, + /*3cd0:*/ 0x9a, 0xf0, 0x51, 0x5e, 0x16, 0x94, 0x31, 0xd7, 0x24, 0x17, 0xa5, 0xe5, 0x2e, 0x92, 0x36, 0xcb, + /*3ce0:*/ 0x36, 0xf8, 0x16, 0xb7, 0x7b, 0xff, 0x2d, 0x25, 0x02, 0x00, 0xb3, 0x75, 0x78, 0xd5, 0xb2, 0x69, + /*3cf0:*/ 0xae, 0x95, 0xd8, 0xc4, 0x4e, 0xa1, 0x6f, 0x93, 0x20, 0xae, 0x74, 0x56, 0x7a, 0xed, 0x24, 0xbb, + /*3d00:*/ 0xc7, 0x8d, 0x0a, 0xbe, 0x9f, 0x5c, 0xd4, 0xa2, 0x20, 0xe9, 0x5e, 0x01, 0x6d, 0x16, 0xe1, 0x59, + /*3d10:*/ 0x05, 0x65, 0xa7, 0x5b, 0xdc, 0x3f, 0x15, 0xf0, 0x43, 0x97, 0x0f, 0x72, 0x60, 0x47, 0xf8, 0x1c, + /*3d20:*/ 0xff, 0xdc, 0xcf, 0xb1, 0xc3, 0x2a, 0x44, 0x9d, 0x37, 0xec, 0x8b, 0x0d, 0x7d, 0x37, 0xa5, 0x2f, + /*3d30:*/ 0x3c, 0x74, 0xca, 0x90, 0x2c, 0x0c, 0x8f, 0x88, 0x01, 0x48, 0x81, 0x0b, 0x8b, 0xf8, 0xc7, 0xb8, + /*3d40:*/ 0x96, 0x45, 0x06, 0x4e, 0x60, 0x04, 0xd8, 0xae, 0x30, 0xcb, 0x6b, 0xf9, 0xdd, 0x0a, 0x31, 0x8d, + /*3d50:*/ 0xde, 0x60, 0x42, 0xf3, 0xf1, 0x87, 0x31, 0x85, 0x25, 0x62, 0xcc, 0x92, 0x54, 0x49, 0x96, 0xd5, + /*3d60:*/ 0x72, 0xc7, 0xb7, 0xf1, 0x01, 0x0b, 0x30, 0xe5, 0x8b, 0xba, 0x49, 0x05, 0xe0, 0xa2, 0x54, 0xee, + /*3d70:*/ 0x45, 0xae, 0xd3, 0x75, 0x35, 0x61, 0x9a, 0x10, 0xee, 0x1f, 0x2a, 0x83, 0xfe, 0x81, 0x0d, 0xc4, + /*3d80:*/ 0xc2, 0x35, 0xc9, 0xf0, 0xed, 0x01, 0xf3, 0x5f, 0x9b, 0x66, 0x41, 0xc1, 0x10, 0x04, 0xc3, 0x57, + /*3d90:*/ 0x04, 0x74, 0x31, 0x72, 0xd9, 0x15, 0x9d, 0xe6, 0xc9, 0x2e, 0xb9, 0xd0, 0x2c, 0xe5, 0x27, 0x85, + /*3da0:*/ 0xa8, 0xe8, 0x8b, 0x44, 0x20, 0x99, 0x1e, 0x12, 0x33, 0xff, 0x4c, 0xa1, 0x59, 0x2c, 0x44, 0xd2, + /*3db0:*/ 0x51, 0x94, 0xa1, 0xc1, 0x65, 0xe8, 0x77, 0xad, 0xf7, 0x2c, 0x3c, 0x1b, 0xeb, 0x85, 0x31, 0x7e, + /*3dc0:*/ 0x7a, 0x3d, 0xe3, 0x49, 0xc3, 0xe7, 0x8f, 0xe1, 0x39, 0x88, 0x33, 0xd1, 0x8d, 0xf5, 0xec, 0x2c, + /*3dd0:*/ 0x43, 0x6a, 0x63, 0x8a, 0xad, 0x7b, 0x61, 0x8c, 0x55, 0x10, 0x89, 0x2e, 0x50, 0x0c, 0x72, 0x49, + /*3de0:*/ 0xad, 0xaf, 0xc4, 0x3f, 0x34, 0xdb, 0xc9, 0x23, 0x90, 0x18, 0xd6, 0x8c, 0xe9, 0xab, 0x5b, 0x01, + /*3df0:*/ 0x9c, 0x5d, 0x05, 0x65, 0x5c, 0x14, 0x27, 0x28, 0xa7, 0x42, 0x93, 0xbe, 0xde, 0xd2, 0x3a, 0x1f, + /*3e00:*/ 0x3f, 0x32, 0xaf, 0x89, 0x34, 0xfa, 0x7a, 0x0d, 0xdd, 0x66, 0xdc, 0x16, 0x60, 0x69, 0x24, 0x04, + /*3e10:*/ 0x1e, 0x9e, 0x55, 0x09, 0x3c, 0x98, 0xb3, 0x95, 0xcc, 0xa4, 0x51, 0xb4, 0x17, 0x80, 0x3a, 0x74, + /*3e20:*/ 0x2c, 0x2f, 0x54, 0x28, 0x83, 0xf9, 0xc4, 0x8a, 0x6b, 0x42, 0x57, 0x6c, 0x14, 0xba, 0xca, 0x51, + /*3e30:*/ 0x27, 0xeb, 0x90, 0x98, 0x59, 0x84, 0x0c, 0xea, 0x90, 0x6e, 0xf3, 0xb2, 0xc3, 0x50, 0xd2, 0x4e, + /*3e40:*/ 0xa0, 0xb3, 0xc0, 0x09, 0x41, 0x59, 0xb5, 0x18, 0x0e, 0x14, 0x27, 0xb1, 0x95, 0x21, 0x0c, 0xe7, + /*3e50:*/ 0x24, 0x79, 0x62, 0x9c, 0x90, 0xe5, 0x44, 0x98, 0x7b, 0x5f, 0xba, 0x46, 0x5f, 0x61, 0xbb, 0x25, + /*3e60:*/ 0xd3, 0x3b, 0x63, 0xdf, 0xc4, 0x76, 0xce, 0x55, 0x4d, 0xaf, 0x69, 0xfd, 0xab, 0xaa, 0x2c, 0x52, + /*3e70:*/ 0xaa, 0x20, 0x38, 0x7e, 0x29, 0x4a, 0x7d, 0x09, 0xee, 0xa8, 0x77, 0xe0, 0xed, 0x54, 0x64, 0x50, + /*3e80:*/ 0x19, 0x1f, 0xc7, 0x34, 0x79, 0xbf, 0x06, 0xf9, 0xac, 0x61, 0x6a, 0xd7, 0x8e, 0xb0, 0x65, 0x4d, + /*3e90:*/ 0xa0, 0xc1, 0x9a, 0xbb, 0x44, 0xbd, 0x30, 0xa0, 0xfb, 0xf5, 0x35, 0x91, 0xa7, 0x09, 0xbb, 0x48, + /*3ea0:*/ 0x4f, 0x94, 0x33, 0xe2, 0x3d, 0x79, 0xc0, 0x0b, 0x27, 0x42, 0x9f, 0x7c, 0x4c, 0x1a, 0xe5, 0x17, + /*3eb0:*/ 0xb2, 0xdf, 0xa3, 0x87, 0x4b, 0x76, 0xd3, 0x78, 0x24, 0x6b, 0xd4, 0x54, 0x7e, 0x73, 0x37, 0x2b, + /*3ec0:*/ 0xe1, 0xbe, 0xba, 0xbd, 0x6b, 0xb4, 0x5c, 0x7b, 0xba, 0xbc, 0x98, 0x65, 0xcb, 0xdf, 0xb9, 0x99, + /*3ed0:*/ 0x25, 0xeb, 0xe5, 0x93, 0xff, 0x8f, 0x82, 0x6c, 0x5f, 0x6b, 0xde, 0x47, 0xb7, 0x16, 0x92, 0x81, + /*3ee0:*/ 0x7c, 0x77, 0xe3, 0x0b, 0x6f, 0xf2, 0x9a, 0xa0, 0x98, 0xf4, 0xf5, 0xcd, 0x6e, 0xf4, 0x64, 0x65, + /*3ef0:*/ 0xc2, 0x87, 0x85, 0x54, 0x32, 0x11, 0x37, 0xde, 0xfb, 0x7e, 0x51, 0x64, 0x4b, 0x7f, 0x57, 0x34, + /*3f00:*/ 0x1c, 0xa3, 0x37, 0x11, 0x1e, 0x66, 0x43, 0xf5, 0x6d, 0x4d, 0x08, 0x94, 0x7c, 0x79, 0xb7, 0xfe, + /*3f10:*/ 0x20, 0x78, 0x2e, 0x19, 0x49, 0xf6, 0x3b, 0x86, 0xe4, 0xa1, 0xc5, 0x65, 0xef, 0xa9, 0x97, 0x55, + /*3f20:*/ 0x37, 0xed, 0x23, 0xd2, 0x5a, 0x14, 0x5a, 0xde, 0x6c, 0xda, 0x50, 0xfb, 0xcb, 0x56, 0x56, 0x8e, + /*3f30:*/ 0xf1, 0xd1, 0x18, 0x0d, 0x17, 0x7f, 0x3a, 0xb3, 0x07, 0x25, 0x1a, 0x76, 0x1f, 0xd8, 0x67, 0x97, + /*3f40:*/ 0x43, 0xfa, 0x02, 0xa8, 0x7c, 0x6d, 0x56, 0xb1, 0xd4, 0xba, 0x1d, 0x06, 0x60, 0x86, 0x66, 0xd6, + /*3f50:*/ 0xd5, 0x1b, 0x5e, 0x64, 0xf5, 0x02, 0x44, 0xa4, 0x8d, 0x21, 0x27, 0xd2, 0x16, 0xe4, 0xd9, 0xad, + /*3f60:*/ 0xac, 0x08, 0x12, 0x81, 0xd6, 0xe4, 0x4e, 0x68, 0xe4, 0xaf, 0x62, 0x8c, 0x7e, 0xef, 0x42, 0xa9, + /*3f70:*/ 0xff, 0x3f, 0x3b, 0x6c, 0x9f, 0xec, 0xa5, 0x9c, 0xf5, 0xf8, 0x4f, 0xa9, 0x37, 0x79, 0x86, 0x92, + /*3f80:*/ 0x2b, 0x6d, 0x75, 0xbc, 0x50, 0x5e, 0x78, 0x1c, 0xbe, 0x03, 0xcf, 0x7d, 0x37, 0x21, 0xcf, 0x43, + /*3f90:*/ 0x4e, 0x2b, 0x68, 0x7b, 0x77, 0x44, 0x39, 0x85, 0x1b, 0x1c, 0x4a, 0x1f, 0x75, 0x68, 0xa6, 0x9c, + /*3fa0:*/ 0x8c, 0x0f, 0x35, 0x78, 0x20, 0x1a, 0xe5, 0xa6, 0x2b, 0xbf, 0x4a, 0x08, 0x04, 0xe5, 0x9d, 0x08, + /*3fb0:*/ 0x4f, 0x03, 0x11, 0xc9, 0x08, 0x1a, 0xde, 0xd1, 0x9d, 0x7c, 0x74, 0x49, 0x5d, 0x09, 0xff, 0x38, + /*3fc0:*/ 0x29, 0x76, 0xa6, 0xf8, 0x9a, 0xda, 0xda, 0x9a, 0xb6, 0xc9, 0x39, 0x59, 0x62, 0xe1, 0x4b, 0x7f, + /*3fd0:*/ 0x11, 0xac, 0xa6, 0x21, 0x85, 0x0b, 0x2a, 0x0e, 0xa6, 0x89, 0x61, 0x00, 0xdc, 0xb0, 0x5a, 0x9b, + /*3fe0:*/ 0x1b, 0xbd, 0x44, 0x74, 0x01, 0xbc, 0x31, 0x7f, 0xbb, 0x2f, 0x4c, 0x83, 0x8d, 0xe2, 0x99, 0xea, + /*3ff0:*/ 0xad, 0xbb, 0xb4, 0xe5, 0xb6, 0x4d, 0xa8, 0xf6, 0x99, 0xe2, 0x85, 0x27, 0x08, 0x70, 0x84, 0x05, + /*4000:*/ 0xed, 0x8d, 0x0e, 0x89, 0x9a, 0x03, 0xc3, 0xe6, 0xa6, 0xe1, 0x8d, 0xc3, 0x2e, 0xdd, 0xc8, 0x53, + /*4010:*/ 0xb8, 0xd7, 0x88, 0xf6, 0x88, 0xb2, 0xb4, 0x38, 0xa6, 0xc4, 0xc1, 0x2c, 0x71, 0x41, 0x8f, 0xc3, + /*4020:*/ 0x51, 0x77, 0x20, 0x0c, 0xa6, 0x4c, 0xac, 0xcd, 0xf5, 0xae, 0x4c, 0x37, 0x57, 0xf5, 0x1c, 0x09, + /*4030:*/ 0xe3, 0xcf, 0x5c, 0x69, 0xed, 0x92, 0x5e, 0xce, 0xf1, 0x83, 0x41, 0xf7, 0xa1, 0x05, 0x3f, 0x56, + /*4040:*/ 0x5e, 0x76, 0x06, 0x63, 0xb7, 0x73, 0x2a, 0xe4, 0x83, 0x10, 0xe6, 0x30, 0x7e, 0x9a, 0xd6, 0xc5, + /*4050:*/ 0x8d, 0x7f, 0xf8, 0xeb, 0xf6, 0x05, 0x32, 0x24, 0xf1, 0x70, 0xa9, 0x85, 0x69, 0x5c, 0x37, 0x02, + /*4060:*/ 0x4a, 0x7e, 0x23, 0xee, 0x91, 0xa2, 0xdd, 0xaa, 0x51, 0x6b, 0x1b, 0x39, 0x76, 0x28, 0x9e, 0xbf, + /*4070:*/ 0xe5, 0xd9, 0xfe, 0x0b, 0x89, 0x63, 0xff, 0x47, 0x50, 0x8f, 0x66, 0x0e, 0x96, 0x0f, 0x3d, 0x8c, + /*4080:*/ 0xdd, 0x55, 0xfd, 0xae, 0x37, 0x18, 0x71, 0x0e, 0x08, 0x48, 0x65, 0x53, 0xb8, 0x1b, 0x9d, 0xc5, + /*4090:*/ 0x1f, 0x0f, 0x9e, 0x9a, 0xcf, 0xfb, 0x37, 0xf0, 0x6e, 0x5c, 0x8b, 0xec, 0x3b, 0x3a, 0xd3, 0xce, + /*40a0:*/ 0xc5, 0x94, 0x24, 0x88, 0x0b, 0x6a, 0x03, 0x4c, 0x52, 0xf7, 0xb2, 0x1d, 0x07, 0xae, 0x81, 0x3d, + /*40b0:*/ 0xf1, 0xfd, 0x8e, 0xcc, 0x3a, 0x47, 0x6e, 0xa9, 0x19, 0xf7, 0x16, 0x8e, 0x15, 0x93, 0x56, 0x20, + /*40c0:*/ 0x7e, 0x67, 0xd3, 0x17, 0xcb, 0xfa, 0x4b, 0xf1, 0x63, 0x02, 0x81, 0x14, 0x1e, 0xbd, 0x73, 0x95, + /*40d0:*/ 0xcc, 0xfd, 0x70, 0xa6, 0x30, 0x3e, 0x41, 0x64, 0x5a, 0x12, 0xc6, 0x50, 0x28, 0xf0, 0x83, 0x60, + /*40e0:*/ 0xd7, 0xb9, 0x72, 0x1d, 0x87, 0xab, 0x74, 0xf5, 0xb7, 0x30, 0xa1, 0xae, 0x89, 0x76, 0xfe, 0x92, + /*40f0:*/ 0x07, 0x34, 0x78, 0x8e, 0x8b, 0xb1, 0x44, 0x85, 0x37, 0xcf, 0xe8, 0x56, 0xe7, 0xaa, 0xa9, 0x70, + /*4100:*/ 0xe9, 0x79, 0x59, 0xa6, 0x3c, 0x9d, 0xad, 0xc5, 0x0f, 0x7d, 0x3c, 0x8e, 0xb9, 0xdc, 0xd4, 0xf7, + /*4110:*/ 0xe4, 0xcd, 0xa7, 0x27, 0xfd, 0x20, 0x33, 0x9d, 0x64, 0xcd, 0xcc, 0xaf, 0xb9, 0x43, 0xc6, 0x6b, + /*4120:*/ 0xcd, 0xaa, 0xf8, 0x8a, 0x97, 0x30, 0x95, 0xcc, 0xf2, 0x9f, 0x70, 0x25, 0x3f, 0x7b, 0x27, 0x0f, + /*4130:*/ 0xc2, 0x0f, 0xd7, 0x33, 0xde, 0x08, 0x90, 0xc2, 0x5d, 0xb5, 0xc0, 0x1a, 0x39, 0x86, 0xb3, 0x62, + /*4140:*/ 0xeb, 0x19, 0xee, 0x4c, 0x10, 0xe6, 0x75, 0x40, 0x7a, 0x9d, 0x8f, 0x80, 0x39, 0x75, 0x77, 0x37, + /*4150:*/ 0x27, 0x4e, 0x36, 0xa6, 0xc6, 0x7a, 0xb9, 0x0d, 0x7c, 0x5c, 0x7f, 0xbc, 0xe5, 0x9c, 0xe2, 0x13, + /*4160:*/ 0xfe, 0x3f, 0xc6, 0x30, 0xf8, 0xbb, 0xe6, 0x19, 0xcf, 0x2e, 0xfb, 0x6c, 0x10, 0x38, 0x61, 0x72, + /*4170:*/ 0xe3, 0x32, 0xfc, 0xcb, 0x72, 0x88, 0x6b, 0x62, 0x20, 0x32, 0x0b, 0xbc, 0xc3, 0xfd, 0x23, 0x9c, + /*4180:*/ 0xad, 0x96, 0xa7, 0xa4, 0x4e, 0x40, 0xfc, 0xac, 0x04, 0xbc, 0x8e, 0x17, 0x43, 0xba, 0x2b, 0xbf, + /*4190:*/ 0x0a, 0x5f, 0x2b, 0xaa, 0x74, 0x06, 0x1f, 0x75, 0x8e, 0xa4, 0x57, 0xdf, 0x1e, 0x4c, 0xfa, 0xb9, + /*41a0:*/ 0xb4, 0x33, 0x72, 0xd7, 0x88, 0x6b, 0x19, 0xb0, 0x36, 0x76, 0x07, 0xb2, 0x79, 0x77, 0x50, 0xc1, + /*41b0:*/ 0xb9, 0xa5, 0x28, 0x8d, 0xc8, 0x70, 0x3d, 0xdf, 0xe9, 0x96, 0x49, 0xf4, 0xbd, 0xed, 0x62, 0x3c, + /*41c0:*/ 0xe0, 0x63, 0x41, 0x84, 0x55, 0xef, 0x54, 0x2f, 0xb4, 0x94, 0x7d, 0x32, 0x56, 0x01, 0x04, 0x40, + /*41d0:*/ 0x73, 0x43, 0xdd, 0x84, 0xbe, 0xe6, 0x2f, 0xa1, 0xa7, 0xec, 0xed, 0x6f, 0x45, 0xd3, 0x74, 0x58, + /*41e0:*/ 0x5f, 0xae, 0x10, 0x4a, 0xe3, 0x7e, 0xc9, 0xca, 0xee, 0xe0, 0x05, 0xc5, 0x95, 0x34, 0xff, 0x5e, + /*41f0:*/ 0xda, 0x21, 0xf3, 0x49, 0x80, 0xf8, 0xd8, 0x33, 0x3a, 0x93, 0xab, 0xdd, 0x76, 0xdc, 0x77, 0x06, + /*4200:*/ 0x83, 0x9b, 0x67, 0x8a, 0xa0, 0x72, 0x2a, 0x32, 0x24, 0x00, 0x85, 0x1e, 0x27, 0x22, 0x91, 0x85, + /*4210:*/ 0xde, 0xb0, 0x9b, 0xc0, 0xa8, 0x03, 0x90, 0x9e, 0xe3, 0x18, 0x64, 0x91, 0x2c, 0xaa, 0x21, 0xbb, + /*4220:*/ 0xca, 0x34, 0x42, 0x9c, 0xcd, 0x73, 0x5e, 0xff, 0x7a, 0x9a, 0xc0, 0x1c, 0x6e, 0xb2, 0x45, 0xec, + /*4230:*/ 0x09, 0xe4, 0xed, 0x3f, 0xa2, 0xf2, 0x82, 0xa8, 0xa3, 0xc0, 0xd3, 0x4e, 0xbc, 0xe5, 0x11, 0x9b, + /*4240:*/ 0x5e, 0x3d, 0x0e, 0x1e, 0xcc, 0x85, 0x4c, 0x5d, 0x97, 0xa6, 0xa2, 0xe7, 0x90, 0xad, 0x0a, 0xf5, + /*4250:*/ 0x83, 0x65, 0xc6, 0xcc, 0x4f, 0x52, 0xe0, 0x38, 0xe9, 0x25, 0xa7, 0x83, 0x03, 0x4a, 0x0f, 0x72, + /*4260:*/ 0xe5, 0xc9, 0x36, 0x32, 0xb9, 0x7d, 0x58, 0xa2, 0x05, 0x0e, 0x30, 0x13, 0xd3, 0xfc, 0x30, 0x86, + /*4270:*/ 0xbd, 0xab, 0x67, 0xcf, 0x86, 0x4d, 0xa5, 0xfe, 0x6d, 0xb5, 0x91, 0x1e, 0xcf, 0x44, 0xc8, 0x40, + /*4280:*/ 0x2b, 0xaa, 0x96, 0x33, 0xb5, 0x8e, 0x32, 0x59, 0x0d, 0x0c, 0x6d, 0x91, 0x24, 0x7a, 0x49, 0x1a, + /*4290:*/ 0x8d, 0x8f, 0x14, 0xa6, 0x25, 0x35, 0xef, 0x8f, 0xb6, 0x53, 0xaf, 0xe2, 0xa5, 0xa4, 0x3d, 0x19, + /*42a0:*/ 0x9e, 0x61, 0x5c, 0x38, 0x60, 0xdc, 0x7a, 0x90, 0xda, 0xb0, 0xc7, 0x78, 0x2d, 0xc9, 0x8e, 0xc4, + /*42b0:*/ 0x2a, 0xe5, 0x9d, 0x10, 0x26, 0xef, 0x4f, 0x79, 0xf2, 0xf7, 0x89, 0x79, 0xdb, 0xc1, 0xf3, 0xc3, + /*42c0:*/ 0x38, 0x6a, 0xd3, 0x59, 0x31, 0x69, 0xfd, 0xd6, 0x9d, 0x26, 0x54, 0x44, 0x0e, 0x2b, 0xc5, 0x9a, + /*42d0:*/ 0x9f, 0x77, 0xb7, 0x73, 0x40, 0xc5, 0xa2, 0x46, 0x3b, 0xb9, 0xb6, 0xab, 0x58, 0x93, 0x88, 0x9c, + /*42e0:*/ 0xe5, 0xae, 0x1b, 0x90, 0xf8, 0xdf, 0xdf, 0xd6, 0x4d, 0x2e, 0x3b, 0xeb, 0x3a, 0x6f, 0xe3, 0x28, + /*42f0:*/ 0x73, 0x32, 0x71, 0xb3, 0x7c, 0xd8, 0x7a, 0xa2, 0xfc, 0x61, 0x56, 0x2c, 0x89, 0x63, 0x16, 0xbd, + /*4300:*/ 0xea, 0xd2, 0x49, 0x1b, 0x43, 0xcf, 0x2a, 0xce, 0xd2, 0x00, 0xe8, 0xef, 0x60, 0xf9, 0x9e, 0x41, + /*4310:*/ 0x23, 0xde, 0x64, 0xa1, 0x05, 0x64, 0x55, 0xdb, 0xb0, 0xac, 0x37, 0xd1, 0x41, 0xd4, 0xfa, 0xde, + /*4320:*/ 0x9c, 0x18, 0x46, 0x59, 0xac, 0x51, 0xc4, 0xd4, 0xb9, 0x4c, 0x35, 0xfa, 0xcd, 0xfd, 0x23, 0xde, + /*4330:*/ 0xa8, 0x5d, 0x7c, 0xdb, 0xa1, 0x1a, 0x99, 0x9d, 0x21, 0x12, 0x81, 0xa8, 0xd1, 0x20, 0xc2, 0xd4, + /*4340:*/ 0x6c, 0xe9, 0x8b, 0x16, 0x22, 0x55, 0x5b, 0x0e, 0x1d, 0xde, 0x36, 0x54, 0x96, 0x76, 0x51, 0x36, + /*4350:*/ 0x13, 0x4a, 0x9f, 0x0f, 0x42, 0x11, 0xb2, 0x8a, 0x69, 0xec, 0x5b, 0xbd, 0xbd, 0xe6, 0x90, 0x1d, + /*4360:*/ 0x6f, 0x36, 0x18, 0x6d, 0x71, 0x18, 0x6b, 0xa0, 0x08, 0x0c, 0x6a, 0xbd, 0xc9, 0xc9, 0x03, 0xbb, + /*4370:*/ 0x2b, 0x13, 0xc4, 0x81, 0xd4, 0x98, 0xaa, 0x33, 0xa7, 0x7c, 0x9d, 0x2a, 0xcf, 0xf4, 0xc8, 0x33, + /*4380:*/ 0xc8, 0x54, 0x80, 0x2e, 0x85, 0x05, 0xf3, 0x67, 0x34, 0x07, 0xe1, 0x5c, 0x49, 0x4a, 0x72, 0x7e, + /*4390:*/ 0x1b, 0x64, 0xc1, 0x66, 0xe8, 0x3d, 0x30, 0x38, 0x8c, 0x58, 0x3c, 0x0f, 0x64, 0x54, 0x9b, 0x1b, + /*43a0:*/ 0x5e, 0xb7, 0x87, 0x95, 0xf7, 0x92, 0xbe, 0x4c, 0x42, 0x03, 0x77, 0x74, 0xea, 0x9e, 0xf3, 0x92, + /*43b0:*/ 0x94, 0x0d, 0x47, 0x33, 0x23, 0x88, 0x74, 0x71, 0x47, 0xab, 0x1d, 0xd5, 0x92, 0x81, 0x73, 0x66, + /*43c0:*/ 0x62, 0xc3, 0x27, 0xe5, 0xe0, 0x84, 0xfa, 0xe4, 0x6a, 0x2e, 0x07, 0xea, 0xdb, 0x44, 0x24, 0xef, + /*43d0:*/ 0x8a, 0xb0, 0x5e, 0xb0, 0x61, 0x03, 0x9c, 0xf8, 0xc7, 0xc8, 0x34, 0x1b, 0x87, 0xc7, 0xf1, 0x3b, + /*43e0:*/ 0xb5, 0x7e, 0xb7, 0x37, 0x4d, 0x3a, 0xb7, 0x4b, 0x2e, 0x21, 0xe2, 0x3e, 0x0d, 0xe7, 0x07, 0x3c, + /*43f0:*/ 0x43, 0xb2, 0x6d, 0x87, 0xa9, 0x79, 0x96, 0x86, 0x0c, 0x0e, 0xbc, 0x0d, 0x5e, 0x5b, 0x9f, 0xbf, + /*4400:*/ 0xc0, 0xfe, 0x4b, 0x81, 0xa2, 0x91, 0x39, 0xf9, 0x59, 0xfa, 0x96, 0x80, 0x2a, 0x90, 0x13, 0x4c, + /*4410:*/ 0x4e, 0x08, 0x1e, 0xcc, 0xfe, 0x1f, 0x94, 0x2b, 0x1b, 0x3f, 0x80, 0xa2, 0x03, 0xc2, 0xee, 0x37, + /*4420:*/ 0x52, 0xa2, 0xb7, 0xfb, 0x2c, 0x42, 0xe6, 0xd9, 0x57, 0xa4, 0xdd, 0x41, 0x02, 0xfc, 0x9f, 0x40, + /*4430:*/ 0x62, 0xb8, 0xc6, 0x4b, 0x42, 0xe4, 0xd8, 0x50, 0x47, 0xad, 0xea, 0x55, 0x21, 0xe7, 0xbb, 0xa4, + /*4440:*/ 0xf5, 0x07, 0x70, 0x6f, 0xba, 0x7e, 0x30, 0x31, 0x03, 0x15, 0x9d, 0x44, 0x29, 0x16, 0xe0, 0x95, + /*4450:*/ 0x67, 0xf0, 0x4b, 0x27, 0x94, 0xaf, 0x48, 0x2f, 0x3d, 0xe8, 0x8c, 0x64, 0x47, 0x32, 0xa0, 0xb7, + /*4460:*/ 0x23, 0x27, 0xbf, 0xca, 0xdf, 0x6a, 0xc1, 0x41, 0x19, 0x82, 0xd4, 0x97, 0xee, 0x24, 0xbc, 0x65, + /*4470:*/ 0xd3, 0x8b, 0x10, 0xf8, 0x1b, 0x70, 0xe1, 0x5c, 0xeb, 0xa2, 0xa9, 0x89, 0x62, 0xec, 0xaa, 0xf6, + /*4480:*/ 0xb1, 0xda, 0xf9, 0xe5, 0x0c, 0x47, 0xa0, 0x06, 0x93, 0x6c, 0x54, 0xea, 0x48, 0x9d, 0x57, 0x90, + /*4490:*/ 0x8f, 0x5f, 0xd0, 0x6f, 0x97, 0x2a, 0x64, 0x46, 0x05, 0x22, 0x5a, 0xda, 0xbd, 0xb0, 0x47, 0x73, + /*44a0:*/ 0x62, 0x2c, 0x75, 0xcb, 0xed, 0x7d, 0x0b, 0x14, 0x30, 0xb3, 0x78, 0x4c, 0xe7, 0x9c, 0xaf, 0x9b, + /*44b0:*/ 0x7a, 0x97, 0xde, 0x12, 0xac, 0x5e, 0x6a, 0x96, 0xd7, 0xfd, 0x8c, 0x3f, 0xe8, 0xed, 0x61, 0x1d, + /*44c0:*/ 0x5e, 0xcf, 0xfb, 0xb9, 0x49, 0x80, 0xde, 0x1b, 0xb8, 0x12, 0x81, 0x5a, 0xdb, 0xd6, 0xb7, 0x0f, + /*44d0:*/ 0x50, 0xf5, 0x7e, 0xf8, 0xa6, 0xcc, 0xfa, 0x86, 0x25, 0xdb, 0xd1, 0xd1, 0xfb, 0x99, 0xbe, 0x28, + /*44e0:*/ 0x60, 0xc9, 0x83, 0xe6, 0x64, 0x56, 0xf6, 0x15, 0x8d, 0xf0, 0xad, 0xd2, 0x3f, 0x6f, 0x18, 0xe8, + /*44f0:*/ 0xee, 0x3c, 0x25, 0x52, 0x3f, 0x32, 0x29, 0x99, 0x36, 0xc2, 0x18, 0xb0, 0xea, 0xc5, 0x87, 0x60, + /*4500:*/ 0xda, 0xe4, 0x78, 0x89, 0xee, 0xaa, 0x9d, 0x4e, 0xfa, 0xca, 0xe1, 0xbe, 0xda, 0x46, 0x22, 0x28, + /*4510:*/ 0x13, 0x0e, 0xf1, 0x8e, 0x15, 0x6d, 0x68, 0x07, 0xc5, 0x0a, 0x41, 0x4f, 0x2d, 0xd6, 0x0c, 0x89, + /*4520:*/ 0x13, 0x5b, 0x79, 0x46, 0x0e, 0x14, 0x4d, 0x8a, 0xb1, 0xe0, 0x6e, 0xcc, 0x46, 0xa2, 0x35, 0xa6, + /*4530:*/ 0xf0, 0x61, 0x80, 0xe8, 0xd0, 0x24, 0xab, 0x1d, 0xa4, 0x28, 0x93, 0xb8, 0x87, 0xa5, 0xd0, 0xe4, + /*4540:*/ 0x9c, 0xfd, 0x29, 0x75, 0x8e, 0x85, 0x20, 0x25, 0xcb, 0xbb, 0x21, 0x20, 0xf9, 0x31, 0x07, 0xaf, + /*4550:*/ 0x5d, 0xf7, 0xc1, 0x7f, 0x89, 0xad, 0xab, 0xbf, 0x65, 0xf8, 0x71, 0xb0, 0x7f, 0xd2, 0xad, 0xd1, + /*4560:*/ 0x51, 0x48, 0x9f, 0xf0, 0xaa, 0xc0, 0xde, 0x60, 0x40, 0xe4, 0x2b, 0xb5, 0x0e, 0x24, 0xdd, 0xfa, + /*4570:*/ 0x0f, 0x52, 0xc3, 0x6e, 0xcc, 0xa2, 0xb9, 0x32, 0x30, 0x92, 0x24, 0x51, 0xb9, 0xff, 0x7d, 0xef, + /*4580:*/ 0x5b, 0x6c, 0xf2, 0xde, 0x08, 0x11, 0x94, 0x52, 0xac, 0x53, 0xd3, 0xc5, 0x97, 0xd6, 0xd2, 0x78, + /*4590:*/ 0x1c, 0x70, 0xea, 0xd8, 0x81, 0x7f, 0xd6, 0x3b, 0x27, 0x6f, 0x94, 0x59, 0x98, 0xcf, 0x5d, 0x06, + /*45a0:*/ 0x9b, 0x97, 0x47, 0xf9, 0x4f, 0x50, 0xb9, 0x56, 0x36, 0xb5, 0xb6, 0xb9, 0xe3, 0xe2, 0xce, 0x63, + /*45b0:*/ 0x0c, 0x3f, 0xc5, 0xe1, 0xde, 0x8f, 0xcb, 0x8b, 0x36, 0x8d, 0x8d, 0xb9, 0xa6, 0xfb, 0x1b, 0xe4, + /*45c0:*/ 0xe9, 0xea, 0xd0, 0xf0, 0x75, 0x2e, 0x75, 0x58, 0xfc, 0x48, 0x49, 0xad, 0x97, 0x3e, 0xc8, 0xdd, + /*45d0:*/ 0x12, 0x78, 0x79, 0xd1, 0xdc, 0xd7, 0x49, 0x05, 0x65, 0x64, 0x26, 0x9e, 0x00, 0xf5, 0x2b, 0xc2, + /*45e0:*/ 0x03, 0x74, 0xb3, 0x23, 0x74, 0xd5, 0xb4, 0x4b, 0xb4, 0x6e, 0x0e, 0x1e, 0xb3, 0xae, 0x14, 0xe2, + /*45f0:*/ 0xe8, 0xfb, 0xc2, 0xf6, 0xd5, 0x99, 0xd2, 0x90, 0x27, 0x13, 0xf9, 0x20, 0x7b, 0xd0, 0x76, 0x95, + /*4600:*/ 0x67, 0x45, 0x7a, 0x9b, 0x3c, 0x41, 0xc0, 0x6e, 0x6c, 0x2f, 0x0a, 0xe9, 0xcc, 0xa5, 0x8b, 0x41, + /*4610:*/ 0x8c, 0x27, 0xd6, 0xce, 0xde, 0x8f, 0x02, 0xd3, 0xad, 0xd5, 0x88, 0x19, 0xbb, 0xeb, 0xb8, 0x3c, + /*4620:*/ 0x45, 0xea, 0xff, 0xe8, 0x10, 0x93, 0xaf, 0xab, 0x24, 0xff, 0x10, 0x8e, 0x60, 0x92, 0x88, 0x0c, + /*4630:*/ 0x42, 0x17, 0xf4, 0x42, 0xbc, 0x7e, 0xfe, 0xbf, 0x14, 0x09, 0x6f, 0xff, 0xa2, 0x42, 0x43, 0x97, + /*4640:*/ 0x5f, 0x24, 0xae, 0xa1, 0xcf, 0x48, 0xe6, 0x35, 0x3f, 0x12, 0x55, 0x38, 0x0a, 0x91, 0x05, 0x46, + /*4650:*/ 0x9d, 0x80, 0xb3, 0x75, 0x24, 0x64, 0x19, 0x8e, 0xea, 0x65, 0x94, 0x22, 0xfe, 0x6c, 0xa4, 0x82, + /*4660:*/ 0x16, 0x96, 0x7f, 0x57, 0x4b, 0x72, 0x54, 0x9e, 0x84, 0x22, 0x06, 0x64, 0x24, 0xe1, 0x50, 0xc7, + /*4670:*/ 0x78, 0xb8, 0xa4, 0xb4, 0xfe, 0x60, 0xa1, 0x0c, 0xf6, 0xba, 0xdd, 0x93, 0x0f, 0xf5, 0x36, 0xe2, + /*4680:*/ 0xb6, 0x9c, 0xd3, 0xc8, 0x96, 0xb4, 0xd2, 0x02, 0x38, 0x42, 0x9a, 0x2f, 0x1b, 0x46, 0xd2, 0x20, + /*4690:*/ 0xc6, 0x90, 0xd5, 0xd4, 0x42, 0xf0, 0xd5, 0x14, 0xd1, 0xb1, 0xec, 0x02, 0x41, 0x25, 0xbb, 0x35, + /*46a0:*/ 0x0b, 0x9a, 0x66, 0x1d, 0xc8, 0xf9, 0xc1, 0x6a, 0x59, 0xfc, 0xc5, 0x57, 0xda, 0xdf, 0xe2, 0x8a, + /*46b0:*/ 0x8b, 0x1b, 0x21, 0x1d, 0x45, 0x76, 0x57, 0x8a, 0x0c, 0xd8, 0x21, 0xa0, 0x34, 0x42, 0xeb, 0xa7, + /*46c0:*/ 0x01, 0x62, 0x5f, 0x5d, 0xf5, 0x12, 0x44, 0x42, 0x4a, 0xb1, 0x2c, 0x9a, 0x44, 0x79, 0x9e, 0x6b, + /*46d0:*/ 0xde, 0xbf, 0x13, 0x8c, 0x22, 0x4f, 0xe7, 0x50, 0xd4, 0x0a, 0x18, 0x4f, 0x50, 0xf0, 0xbb, 0x16, + /*46e0:*/ 0xf5, 0x57, 0x2c, 0xd8, 0x66, 0x3f, 0x83, 0x62, 0xe8, 0x5a, 0xd4, 0x05, 0x67, 0xe0, 0xa7, 0x40, + /*46f0:*/ 0x08, 0xc3, 0x9e, 0x5b, 0xbb, 0x3a, 0xd3, 0x44, 0x15, 0xa6, 0xb3, 0x12, 0xea, 0x89, 0xd9, 0xbc, + /*4700:*/ 0xc1, 0xc8, 0x01, 0x39, 0x1c, 0xc7, 0xc0, 0xfa, 0xea, 0x85, 0xf9, 0x27, 0xe9, 0x10, 0x93, 0x49, + /*4710:*/ 0x5e, 0xa2, 0xb2, 0x40, 0xf3, 0x6f, 0xd1, 0xfb, 0x67, 0xfa, 0x1e, 0x44, 0xc5, 0x7d, 0x49, 0xbe, + /*4720:*/ 0xeb, 0xff, 0x2b, 0x0d, 0xcd, 0x82, 0xd5, 0x42, 0xd1, 0xf2, 0x26, 0x78, 0x8e, 0xec, 0x67, 0x01, + /*4730:*/ 0xb0, 0x5f, 0x0b, 0x28, 0x59, 0x49, 0x8d, 0x2d, 0x77, 0x30, 0x77, 0xfb, 0xf0, 0x1b, 0x1a, 0x83, + /*4740:*/ 0x93, 0x22, 0x0c, 0x92, 0xa5, 0x74, 0xbb, 0xe2, 0xa6, 0xe5, 0x9e, 0x86, 0x6c, 0x34, 0xee, 0x28, + /*4750:*/ 0xec, 0x81, 0xdc, 0x1f, 0x78, 0x54, 0x2c, 0x5a, 0xe6, 0xdf, 0x37, 0x61, 0xd1, 0x9b, 0x75, 0x87, + /*4760:*/ 0xc8, 0xe7, 0x9e, 0x1a, 0x26, 0x82, 0x16, 0xaa, 0x4e, 0x0a, 0xfc, 0xc1, 0xa6, 0xf3, 0xb6, 0xaf, + /*4770:*/ 0x1f, 0xff, 0xc2, 0xb4, 0xb7, 0x33, 0x13, 0xb3, 0xc4, 0xc7, 0x7d, 0xb1, 0xd3, 0x69, 0x5c, 0x8e, + /*4780:*/ 0xe7, 0x49, 0x52, 0x47, 0x16, 0x28, 0x14, 0x4a, 0x54, 0xb5, 0xe3, 0xa8, 0x62, 0x2d, 0x22, 0xb1, + /*4790:*/ 0x78, 0xe2, 0x15, 0x63, 0x6f, 0x0f, 0x7e, 0x5c, 0x3b, 0xc3, 0x12, 0xfd, 0x67, 0x62, 0x24, 0x12, + /*47a0:*/ 0x96, 0x75, 0x30, 0x87, 0x77, 0x81, 0x49, 0xa8, 0x95, 0x3b, 0x94, 0xb8, 0x32, 0x24, 0x65, 0xe5, + /*47b0:*/ 0xd7, 0x05, 0x07, 0xf4, 0xa2, 0xc7, 0x67, 0x1d, 0x0a, 0xc4, 0xee, 0x25, 0xf9, 0x6a, 0xc2, 0xf3, + /*47c0:*/ 0x06, 0xd9, 0xcc, 0x48, 0x0f, 0x85, 0xb0, 0x93, 0xdb, 0x27, 0x46, 0xfe, 0xc7, 0x8d, 0xcb, 0x02, + /*47d0:*/ 0xd5, 0xad, 0x0c, 0x18, 0xc1, 0x19, 0xab, 0xd5, 0xd9, 0xbf, 0x7a, 0xfe, 0xc1, 0x27, 0x80, 0xca, + /*47e0:*/ 0xca, 0x14, 0x1f, 0x4f, 0x64, 0xfb, 0xe5, 0x03, 0x28, 0x16, 0xa2, 0xc9, 0x09, 0x93, 0xdd, 0x40, + /*47f0:*/ 0xc3, 0x2f, 0x46, 0xd5, 0xcf, 0x29, 0xe0, 0x9c, 0xab, 0x0a, 0x5b, 0xab, 0xbd, 0x0e, 0x28, 0x16, + /*4800:*/ 0xc6, 0x5d, 0x3f, 0x5e, 0x41, 0x5a, 0x35, 0xd0, 0x3b, 0x9f, 0x49, 0x25, 0x00, 0x4b, 0x81, 0xda, + /*4810:*/ 0x04, 0xd4, 0x03, 0xe3, 0xd8, 0xb3, 0x51, 0xba, 0x4c, 0xe2, 0x1c, 0xb8, 0x9a, 0xaa, 0x0d, 0x00, + /*4820:*/ 0x21, 0x93, 0x0a, 0xcb, 0xa4, 0x1e, 0xf9, 0x50, 0x9f, 0xf0, 0xa3, 0x01, 0x84, 0xf1, 0xcf, 0x7f, + /*4830:*/ 0x93, 0x19, 0xbd, 0x53, 0x0c, 0xd1, 0x89, 0xe6, 0x2f, 0x10, 0x80, 0x91, 0x33, 0xb7, 0x99, 0xaa, + /*4840:*/ 0xe1, 0x26, 0xf7, 0xde, 0x76, 0x09, 0xf6, 0x45, 0x89, 0x33, 0xd0, 0xf0, 0xf8, 0xf6, 0xd4, 0x59, + /*4850:*/ 0x94, 0xf9, 0x06, 0xe5, 0x7c, 0xb4, 0x61, 0xac, 0x2f, 0x9a, 0x8e, 0x2d, 0x28, 0x37, 0x11, 0x3a, + /*4860:*/ 0x1d, 0xf7, 0x06, 0x79, 0x52, 0x8b, 0xa9, 0xd9, 0xa8, 0x89, 0xfc, 0xb4, 0xbf, 0xbe, 0x56, 0xfd, + /*4870:*/ 0x8a, 0x62, 0x89, 0x21, 0x6a, 0x58, 0x03, 0x22, 0x43, 0x56, 0x33, 0xca, 0x3e, 0x2a, 0x87, 0x66, + /*4880:*/ 0x16, 0xda, 0xb5, 0x96, 0x51, 0x86, 0xb9, 0x7e, 0x6d, 0xb5, 0xb5, 0xb2, 0x57, 0x5b, 0x75, 0xd5, + /*4890:*/ 0xd5, 0xc2, 0x72, 0x7b, 0x9e, 0xa5, 0xab, 0x45, 0x71, 0x77, 0x87, 0xc8, 0xb7, 0x0d, 0xbd, 0xea, + /*48a0:*/ 0x29, 0xd1, 0xc3, 0x15, 0x55, 0xa5, 0x16, 0x4c, 0x38, 0xa8, 0x86, 0x66, 0xd5, 0x7a, 0xf4, 0x47, + /*48b0:*/ 0x63, 0xb5, 0x01, 0x99, 0xec, 0xbb, 0x7e, 0x72, 0x4d, 0x6c, 0x49, 0x55, 0xde, 0xc1, 0xfa, 0xd9, + /*48c0:*/ 0x34, 0x60, 0x48, 0x48, 0x14, 0x9d, 0xb9, 0x9e, 0x5f, 0x2b, 0x7b, 0xbd, 0x68, 0x6a, 0xb2, 0x6d, + /*48d0:*/ 0xc6, 0x0b, 0x89, 0xbb, 0x84, 0xdd, 0x33, 0x5c, 0xc1, 0x36, 0x5e, 0xeb, 0x71, 0x39, 0x32, 0xd3, + /*48e0:*/ 0xdf, 0xdd, 0xd4, 0x46, 0x8d, 0x63, 0xaa, 0xea, 0x47, 0xc4, 0x15, 0x01, 0xe3, 0x37, 0xfc, 0x91, + /*48f0:*/ 0x92, 0xca, 0x90, 0xb5, 0xa0, 0x8d, 0xd7, 0xdb, 0x7a, 0xe2, 0x9d, 0x82, 0x7f, 0xb7, 0x40, 0x72, + /*4900:*/ 0xfb, 0x5e, 0xc9, 0x5a, 0xf9, 0xcf, 0xa8, 0x9f, 0x42, 0xa6, 0x66, 0xa6, 0x91, 0x41, 0x6c, 0xf8, + /*4910:*/ 0x59, 0xbf, 0x9e, 0xbb, 0x62, 0xab, 0x05, 0x1f, 0x19, 0x6e, 0x5f, 0x23, 0x48, 0x85, 0xa7, 0xaf, + /*4920:*/ 0xeb, 0x26, 0x7f, 0xb3, 0x42, 0xfe, 0x37, 0xd6, 0xa0, 0x9f, 0x47, 0xb3, 0x3a, 0x05, 0x6c, 0x78, + /*4930:*/ 0x08, 0x5d, 0xaa, 0x19, 0x37, 0xff, 0x69, 0x0d, 0x96, 0x2a, 0xd2, 0x8a, 0x0d, 0x7f, 0xbf, 0x5b, + /*4940:*/ 0x26, 0x40, 0x3e, 0x47, 0x30, 0xb5, 0xc1, 0x48, 0xa5, 0x4e, 0x76, 0xae, 0x8d, 0xba, 0x5b, 0x0b, + /*4950:*/ 0x22, 0xef, 0xdf, 0xa5, 0x33, 0xc6, 0xe9, 0x79, 0x5d, 0x1e, 0x6a, 0xec, 0xa2, 0xa6, 0xfa, 0x5f, + /*4960:*/ 0xac, 0x42, 0x67, 0x60, 0x06, 0x65, 0x6b, 0xf2, 0x3d, 0xbf, 0x92, 0x54, 0xfb, 0xe8, 0x7e, 0x1a, + /*4970:*/ 0xb5, 0x9b, 0x57, 0x86, 0x21, 0xc4, 0x80, 0x50, 0x54, 0xe7, 0xfc, 0x10, 0x9c, 0xb5, 0xde, 0x50, + /*4980:*/ 0x13, 0x92, 0x3a, 0x85, 0x09, 0xd3, 0x02, 0xa2, 0xf0, 0x38, 0xf0, 0x6d, 0x98, 0x9a, 0x59, 0x92, + /*4990:*/ 0xad, 0x89, 0x0d, 0xfd, 0xdf, 0x84, 0xbb, 0x77, 0x2d, 0x4c, 0xbb, 0x8c, 0xa5, 0xe2, 0xea, 0x45, + /*49a0:*/ 0xfd, 0x40, 0x07, 0xbc, 0xa0, 0xf0, 0x84, 0x48, 0x17, 0xd2, 0x58, 0x94, 0xbf, 0x89, 0x04, 0x7e, + /*49b0:*/ 0x6e, 0xc9, 0x7a, 0xcc, 0x4a, 0x65, 0xf7, 0xb4, 0xf4, 0x2f, 0xae, 0x6e, 0xae, 0x7f, 0x1c, 0xa7, + /*49c0:*/ 0xda, 0xce, 0x73, 0xda, 0x7c, 0x9c, 0xed, 0x7c, 0x5c, 0xc6, 0x56, 0x8b, 0xc7, 0xc1, 0x53, 0xb4, + /*49d0:*/ 0x5a, 0x30, 0x70, 0x09, 0xd7, 0xdd, 0x20, 0xd0, 0x2a, 0x47, 0x82, 0xb2, 0xa1, 0xd5, 0x69, 0x0a, + /*49e0:*/ 0xc1, 0xf8, 0xe9, 0x69, 0x60, 0x17, 0x3f, 0x4c, 0x79, 0x92, 0x33, 0x16, 0x92, 0xbf, 0x4a, 0x73, + /*49f0:*/ 0x7f, 0x0a, 0xd1, 0x96, 0x83, 0x53, 0x1c, 0x01, 0x01, 0x5d, 0xe4, 0xf1, 0xe3, 0xa1, 0xc4, 0x91, + /*4a00:*/ 0x71, 0x14, 0xbf, 0x60, 0x5a, 0xf5, 0x95, 0x0a, 0x45, 0x35, 0x39, 0x81, 0xea, 0xd4, 0x66, 0x69, + /*4a10:*/ 0xa6, 0x12, 0x6d, 0xa8, 0xb8, 0x32, 0x92, 0x1b, 0xa4, 0x59, 0x46, 0x6c, 0x8c, 0xed, 0xc0, 0x4c, + /*4a20:*/ 0x55, 0x99, 0xb3, 0xc1, 0x51, 0xfa, 0x30, 0xf0, 0x54, 0x2f, 0x6e, 0x7d, 0xbc, 0xb3, 0x9a, 0x9d, + /*4a30:*/ 0x27, 0x42, 0x30, 0xbf, 0x0e, 0x41, 0x87, 0x65, 0x70, 0x10, 0xbc, 0xf1, 0x4b, 0x3e, 0x64, 0x48, + /*4a40:*/ 0x88, 0xfb, 0xfa, 0x1b, 0x9a, 0xcb, 0xf5, 0xf7, 0x5c, 0xf8, 0xcc, 0xb2, 0xad, 0xc7, 0x96, 0x16, + /*4a50:*/ 0x36, 0xe4, 0x8c, 0x23, 0x21, 0x38, 0x60, 0x6c, 0x6d, 0xaa, 0xef, 0xc9, 0x26, 0xde, 0x1f, 0x17, + /*4a60:*/ 0xad, 0x4a, 0xa6, 0xbb, 0xcb, 0xce, 0x76, 0x40, 0x5e, 0x86, 0xdb, 0x97, 0x1f, 0x70, 0x86, 0xf7, + /*4a70:*/ 0x8f, 0xf8, 0x11, 0x39, 0x03, 0xc7, 0x0c, 0xcc, 0x71, 0x29, 0x00, 0x2a, 0x4e, 0x62, 0x49, 0xad, + /*4a80:*/ 0xb0, 0xfa, 0xfb, 0x80, 0x2e, 0xe8, 0x70, 0x73, 0x57, 0x42, 0xd3, 0xc0, 0x68, 0x7e, 0xaa, 0x0a, + /*4a90:*/ 0xdb, 0x99, 0x89, 0x07, 0x8a, 0x6d, 0x4c, 0x9c, 0xbc, 0x33, 0x4f, 0xee, 0x7f, 0x27, 0x45, 0x0f, + /*4aa0:*/ 0x7f, 0x16, 0xcb, 0x5b, 0xd7, 0x88, 0x9a, 0xbf, 0x4b, 0x98, 0x01, 0x1c, 0xaf, 0x06, 0x7f, 0x1e, + /*4ab0:*/ 0x4d, 0x07, 0x70, 0xb8, 0x7f, 0xac, 0xbb, 0x79, 0xc3, 0x10, 0x01, 0xbc, 0x43, 0x97, 0x46, 0x38, + /*4ac0:*/ 0x6e, 0x96, 0x82, 0x31, 0xe6, 0x2e, 0xa0, 0x56, 0xd6, 0xfa, 0xce, 0x3c, 0x43, 0xcd, 0xfe, 0x63, + /*4ad0:*/ 0x3d, 0xd8, 0x48, 0x28, 0x8d, 0x80, 0xb8, 0xe3, 0xfd, 0x3b, 0x74, 0x90, 0xbd, 0x64, 0x2d, 0x3f, + /*4ae0:*/ 0x18, 0x94, 0x39, 0x9c, 0x52, 0x8a, 0x6b, 0x88, 0x7b, 0xd2, 0xa7, 0x89, 0x16, 0x7b, 0x89, 0x45, + /*4af0:*/ 0xdd, 0x0e, 0xf1, 0xc7, 0xc4, 0x9b, 0xb8, 0x90, 0xb8, 0x97, 0x93, 0x4f, 0x98, 0x49, 0xef, 0xef, + /*4b00:*/ 0x0a, 0x78, 0xc9, 0xaf, 0xc3, 0xe2, 0xb6, 0x9c, 0x22, 0x69, 0x8b, 0x86, 0xff, 0x76, 0x04, 0x60, + /*4b10:*/ 0xab, 0x35, 0x92, 0x1c, 0xa8, 0xac, 0xdd, 0x99, 0x09, 0xdf, 0x97, 0xfe, 0x25, 0x86, 0x0a, 0x43, + /*4b20:*/ 0xdd, 0x5c, 0xee, 0x40, 0xdf, 0x68, 0x7b, 0x87, 0x70, 0xd0, 0x45, 0xa9, 0x9c, 0xd8, 0x19, 0xca, + /*4b30:*/ 0xfd, 0x08, 0x4a, 0xfc, 0x26, 0xfb, 0xb0, 0x3d, 0xab, 0xf9, 0x04, 0x77, 0x26, 0xc9, 0x18, 0x45, + /*4b40:*/ 0xdf, 0xf5, 0xed, 0x8a, 0xb6, 0x9a, 0x08, 0x2d, 0xa9, 0xb3, 0xd1, 0xea, 0x82, 0xfd, 0x5c, 0xbf, + /*4b50:*/ 0x32, 0x90, 0xc7, 0x2d, 0x01, 0xf9, 0x56, 0xb0, 0x6b, 0xfe, 0x7a, 0xe2, 0x03, 0x90, 0x48, 0x60, + /*4b60:*/ 0xdc, 0x0b, 0xc9, 0x2f, 0x95, 0xe6, 0x0b, 0x73, 0xb5, 0xeb, 0x3d, 0xfe, 0xbe, 0x7e, 0x89, 0x24, + /*4b70:*/ 0x15, 0x68, 0x08, 0x86, 0x38, 0xad, 0x27, 0x55, 0x9a, 0x56, 0x58, 0x06, 0x0a, 0x4b, 0x78, 0xde, + /*4b80:*/ 0x94, 0xb0, 0xa5, 0x95, 0x10, 0x85, 0x63, 0x8e, 0xcb, 0xd2, 0x26, 0x35, 0x14, 0xa3, 0x1d, 0xd8, + /*4b90:*/ 0x62, 0xc0, 0x42, 0x4c, 0xa4, 0xad, 0x9e, 0x59, 0x50, 0xf8, 0xcf, 0x55, 0xb8, 0x01, 0xfe, 0x68, + /*4ba0:*/ 0x92, 0x08, 0x8b, 0x8d, 0xd8, 0xab, 0x1d, 0xed, 0xec, 0x01, 0xbc, 0xf5, 0xe3, 0x7c, 0x5c, 0x13, + /*4bb0:*/ 0xef, 0x7d, 0x14, 0x21, 0xd1, 0x8e, 0x9b, 0xe4, 0x34, 0x78, 0x59, 0x45, 0x9c, 0x86, 0x37, 0xc2, + /*4bc0:*/ 0x24, 0xd1, 0xeb, 0x14, 0x83, 0x0a, 0x80, 0xde, 0x45, 0xa1, 0x17, 0x41, 0xd1, 0x36, 0x1e, 0x95, + /*4bd0:*/ 0x4d, 0x00, 0x13, 0x2d, 0x15, 0x7d, 0x4b, 0x52, 0x90, 0x32, 0x12, 0xc2, 0x7d, 0x72, 0xaa, 0x2a, + /*4be0:*/ 0x16, 0x54, 0x08, 0xb7, 0x2b, 0x86, 0xa5, 0xa6, 0x62, 0x2c, 0x8a, 0x0d, 0xd8, 0x50, 0x89, 0xf9, + /*4bf0:*/ 0xb2, 0x52, 0xd2, 0xd9, 0xa2, 0xa3, 0x21, 0x14, 0x87, 0x89, 0xe1, 0xe7, 0xce, 0xf0, 0x5f, 0xd8, + /*4c00:*/ 0x75, 0x61, 0xd6, 0x66, 0xcf, 0xda, 0x00, 0x21, 0xa6, 0xf0, 0xb4, 0x41, 0xcf, 0xf4, 0x71, 0x51, + /*4c10:*/ 0xba, 0x27, 0x32, 0x7c, 0x3c, 0xb6, 0xc8, 0x29, 0x53, 0x1f, 0xc5, 0xc1, 0xfd, 0x9f, 0xa8, 0x08, + /*4c20:*/ 0x30, 0x51, 0x7f, 0xf6, 0x8b, 0x6a, 0xa2, 0xbe, 0xd4, 0xf5, 0x15, 0xaf, 0x49, 0x19, 0xb9, 0x8e, + /*4c30:*/ 0x19, 0xfc, 0x70, 0x0c, 0x28, 0xdc, 0xee, 0x85, 0xb7, 0x5b, 0xde, 0x02, 0xdd, 0x85, 0x8c, 0x9b, + /*4c40:*/ 0x78, 0x13, 0x35, 0x1b, 0xd2, 0xe8, 0xcf, 0x9a, 0xc1, 0x3d, 0x21, 0xa2, 0xc5, 0x34, 0xdd, 0x9e, + /*4c50:*/ 0x6f, 0xeb, 0xc4, 0x82, 0x18, 0xd8, 0x5a, 0x31, 0x4a, 0x75, 0x45, 0xc9, 0x6f, 0x56, 0x63, 0x1f, + /*4c60:*/ 0xc9, 0x4d, 0x35, 0x74, 0x58, 0x31, 0xf1, 0x3e, 0xd7, 0xc5, 0x95, 0xf7, 0x29, 0x4f, 0x24, 0xf7, + /*4c70:*/ 0xd9, 0xba, 0xb6, 0x43, 0x34, 0x69, 0x34, 0x04, 0xf0, 0xac, 0x4c, 0x08, 0xed, 0xf9, 0xf4, 0xe3, + /*4c80:*/ 0xdc, 0xc5, 0x3e, 0x4f, 0x65, 0xde, 0xba, 0xb3, 0xaf, 0x6f, 0x1a, 0x1f, 0x21, 0x00, 0x80, 0xc2, + /*4c90:*/ 0x7c, 0x54, 0x55, 0x35, 0x05, 0x23, 0x65, 0x8c, 0x1a, 0x19, 0x2e, 0xd8, 0x4f, 0xfb, 0xb9, 0xfa, + /*4ca0:*/ 0x73, 0x5f, 0x33, 0x0e, 0xfb, 0x32, 0xf5, 0x84, 0x5e, 0xd1, 0x5d, 0x0c, 0x6d, 0x6b, 0x06, 0xc6, + /*4cb0:*/ 0x09, 0x5b, 0x14, 0x40, 0x84, 0x68, 0xca, 0x4e, 0xf3, 0xd0, 0xe0, 0x98, 0x86, 0xbe, 0xb8, 0x60, + /*4cc0:*/ 0x8c, 0xf6, 0xf3, 0x0e, 0xec, 0x70, 0xea, 0x53, 0x19, 0x2c, 0xfb, 0x69, 0x00, 0x37, 0x06, 0x36, + /*4cd0:*/ 0x3b, 0xee, 0xf1, 0x9e, 0xcb, 0xdb, 0x03, 0x00, 0x25, 0x35, 0xa1, 0x7b, 0xb2, 0x79, 0xce, 0x53, + /*4ce0:*/ 0xfe, 0xcb, 0x3c, 0x99, 0xde, 0x50, 0x5a, 0x26, 0xa0, 0xe4, 0x28, 0x96, 0xf6, 0x8d, 0x30, 0x97, + /*4cf0:*/ 0xcd, 0x6e, 0xbb, 0xb0, 0x70, 0x29, 0x60, 0xe8, 0x48, 0x1b, 0xe9, 0xfb, 0xa4, 0x29, 0xea, 0x52, + /*4d00:*/ 0x8f, 0x76, 0x77, 0x1a, 0xdb, 0xcd, 0x39, 0x7a, 0xcf, 0x9d, 0x66, 0xf3, 0x06, 0x9a, 0xb9, 0x80, + /*4d10:*/ 0xb7, 0xe7, 0xab, 0xbd, 0xe3, 0xbe, 0x33, 0xb2, 0x3a, 0x4b, 0x43, 0xc5, 0xa8, 0x91, 0x1c, 0xba, + /*4d20:*/ 0x89, 0xd4, 0x2b, 0xba, 0xfb, 0x91, 0xe0, 0x27, 0xf5, 0x57, 0xd8, 0x2d, 0x7b, 0xad, 0x3d, 0x0d, + /*4d30:*/ 0x2c, 0x21, 0xf8, 0x3a, 0x6a, 0x86, 0xbf, 0x66, 0x35, 0xb2, 0x3a, 0x55, 0xb7, 0x41, 0xf2, 0x8c, + /*4d40:*/ 0x82, 0x2f, 0xf9, 0x36, 0x5e, 0x63, 0xfe, 0x15, 0x23, 0x61, 0xa4, 0xee, 0x53, 0x45, 0xd3, 0xdc, + /*4d50:*/ 0xc5, 0x1b, 0xce, 0xb7, 0x3c, 0x23, 0x6d, 0x40, 0xa1, 0x28, 0x05, 0x0f, 0xd0, 0xb8, 0x9b, 0x48, + /*4d60:*/ 0xb3, 0xe1, 0x91, 0xe1, 0x0e, 0xe5, 0xd3, 0x7e, 0xaa, 0x7a, 0xad, 0xa1, 0xcb, 0xa9, 0x06, 0x4a, + /*4d70:*/ 0x22, 0x57, 0xa1, 0x7b, 0xd9, 0xf5, 0x09, 0x48, 0x09, 0x34, 0x88, 0xcf, 0xfd, 0xf8, 0xdd, 0x3d, + /*4d80:*/ 0xc2, 0x7c, 0x5b, 0x36, 0xb0, 0x53, 0x2f, 0x5f, 0x41, 0x3e, 0x15, 0x71, 0xb0, 0x06, 0x18, 0x68, + /*4d90:*/ 0x64, 0xc8, 0xdb, 0xab, 0x4a, 0x1f, 0xc0, 0x24, 0xd1, 0x4c, 0x59, 0xe8, 0x9e, 0xce, 0x10, 0x16, + /*4da0:*/ 0x68, 0x1f, 0x70, 0x1f, 0x31, 0xde, 0xa3, 0xe2, 0x20, 0xbb, 0xfc, 0x93, 0xa6, 0x43, 0x23, 0xea, + /*4db0:*/ 0x3a, 0x45, 0xe5, 0x93, 0x80, 0x92, 0x43, 0x5b, 0x05, 0x3d, 0x65, 0xe2, 0xbf, 0x56, 0x3f, 0x26, + /*4dc0:*/ 0x82, 0x0b, 0x1e, 0xd4, 0x46, 0x3a, 0x7a, 0x5a, 0x44, 0x91, 0x7e, 0x38, 0x3b, 0x6a, 0x17, 0xaf, + /*4dd0:*/ 0xc5, 0x5a, 0xb2, 0x68, 0xce, 0x68, 0x9c, 0x3c, 0x71, 0xc9, 0xde, 0xaa, 0x9b, 0xee, 0xd3, 0x50, + /*4de0:*/ 0x3c, 0xfd, 0xd8, 0x82, 0xc2, 0x6b, 0x92, 0x1a, 0xf9, 0x0c, 0x65, 0x20, 0x96, 0xc2, 0xd4, 0x2c, + /*4df0:*/ 0x0e, 0x89, 0x9d, 0xc7, 0xe0, 0xb9, 0x9b, 0x12, 0xad, 0xea, 0x0d, 0x97, 0x24, 0x99, 0xbe, 0x81, + /*4e00:*/ 0x08, 0x1f, 0x19, 0x70, 0x7f, 0x12, 0x9b, 0x46, 0x6b, 0xe3, 0xaf, 0x0b, 0xbb, 0xdd, 0xf9, 0xee, + /*4e10:*/ 0xfc, 0x40, 0x5b, 0x60, 0xb7, 0x9e, 0x00, 0xfe, 0x83, 0xca, 0x02, 0x31, 0xdb, 0x0a, 0x1a, 0xbe, + /*4e20:*/ 0xf1, 0x5f, 0xf9, 0x4f, 0xce, 0x03, 0x8c, 0xed, 0x31, 0x22, 0xaa, 0xcd, 0xa5, 0x34, 0xf5, 0xb2, + /*4e30:*/ 0x68, 0xad, 0x3e, 0xb4, 0x80, 0xa9, 0x11, 0x32, 0x56, 0x4d, 0xd6, 0x34, 0xe0, 0x3c, 0xf3, 0x49, + /*4e40:*/ 0x67, 0x5c, 0x8a, 0xf2, 0x08, 0xbf, 0x48, 0xac, 0xc1, 0x85, 0xa7, 0xfe, 0xcd, 0x8f, 0x46, 0x3c, + /*4e50:*/ 0xd5, 0x49, 0xfe, 0xf3, 0x9c, 0x61, 0x20, 0xd6, 0x16, 0x53, 0xfe, 0x67, 0x1d, 0x74, 0x44, 0x43, + /*4e60:*/ 0xab, 0x01, 0x7a, 0x1f, 0xdf, 0x83, 0x51, 0xbb, 0x25, 0xfc, 0xd7, 0x22, 0x94, 0x22, 0x03, 0x6c, + /*4e70:*/ 0x66, 0xa3, 0xa4, 0x0e, 0x19, 0x39, 0xd4, 0x9b, 0xfb, 0x4e, 0x37, 0x9d, 0x0d, 0xef, 0x7f, 0x7c, + /*4e80:*/ 0x08, 0x6b, 0xff, 0xbc, 0xab, 0xd9, 0xfe, 0xd9, 0x37, 0xd5, 0x8e, 0x5f, 0x33, 0xa3, 0xf1, 0xa4, + /*4e90:*/ 0x14, 0x77, 0xdb, 0x2b, 0xda, 0x8e, 0x5f, 0xb0, 0x33, 0x70, 0x6d, 0xd7, 0x84, 0xbf, 0xe5, 0x76, + /*4ea0:*/ 0xc3, 0xed, 0x1b, 0x34, 0xaa, 0xc1, 0x8d, 0x91, 0xf9, 0x44, 0x9b, 0xb7, 0x40, 0x92, 0x5d, 0xf3, + /*4eb0:*/ 0x3f, 0xe0, 0xb2, 0x34, 0x6b, 0x43, 0xc2, 0x04, 0xf5, 0x22, 0x95, 0xf5, 0xf6, 0x0a, 0x0d, 0x3c, + /*4ec0:*/ 0x51, 0xde, 0xa5, 0x32, 0x85, 0x29, 0x49, 0xd2, 0x37, 0x97, 0x44, 0x8f, 0x09, 0x49, 0xb7, 0xcb, + /*4ed0:*/ 0x76, 0xb5, 0x5d, 0x27, 0x24, 0x08, 0xb0, 0x73, 0x6d, 0xd5, 0xce, 0x44, 0xe2, 0xbf, 0x5a, 0xa1, + /*4ee0:*/ 0x52, 0x19, 0xdd, 0x09, 0xc1, 0x8c, 0x04, 0x0c, 0x5c, 0x4d, 0x80, 0xeb, 0x28, 0xb2, 0xf6, 0x74, + /*4ef0:*/ 0x98, 0xef, 0xe9, 0xfc, 0x67, 0xb1, 0x6a, 0x4d, 0x99, 0x50, 0xcc, 0x5e, 0x4e, 0x48, 0xaf, 0x3a, + /*4f00:*/ 0x2b, 0xf9, 0xd5, 0x8a, 0xf5, 0x2c, 0xb1, 0x48, 0x24, 0x3c, 0x93, 0xd8, 0xd0, 0x0a, 0x7a, 0x72, + /*4f10:*/ 0x20, 0xe6, 0xe1, 0x38, 0x6b, 0xa5, 0x30, 0x03, 0xaf, 0x3c, 0x52, 0x34, 0xdf, 0x42, 0x0c, 0x62, + /*4f20:*/ 0xfd, 0x7e, 0x11, 0x3a, 0x8b, 0x89, 0x36, 0x34, 0xf4, 0xdb, 0x88, 0xe4, 0xb9, 0x0a, 0xb8, 0x72, + /*4f30:*/ 0x3f, 0x42, 0x13, 0x7e, 0x4b, 0x4e, 0x6d, 0xae, 0x3c, 0x49, 0x26, 0x12, 0x75, 0x70, 0x8f, 0x43, + /*4f40:*/ 0xaa, 0xb3, 0x1a, 0x87, 0x12, 0x99, 0x43, 0x7c, 0x37, 0x52, 0xc6, 0xb1, 0x72, 0x5a, 0xab, 0xc8, + /*4f50:*/ 0x49, 0xd5, 0x30, 0x49, 0x8f, 0xf0, 0x06, 0xae, 0x97, 0x7d, 0x97, 0x57, 0x5e, 0x2b, 0x6a, 0x43, + /*4f60:*/ 0xa2, 0x8d, 0xa8, 0x4e, 0xcf, 0xa3, 0xbb, 0x1a, 0x28, 0x23, 0x06, 0x3d, 0x61, 0x2a, 0x4c, 0x97, + /*4f70:*/ 0x9a, 0xd2, 0x3e, 0xc1, 0x68, 0xc5, 0x3c, 0x81, 0x61, 0x7f, 0x8b, 0xea, 0x0f, 0x42, 0x9c, 0x89, + /*4f80:*/ 0xb8, 0xb1, 0x8a, 0xd1, 0x74, 0x09, 0x6c, 0x13, 0xee, 0x22, 0x8a, 0x3c, 0x59, 0xf6, 0x6c, 0xdb, + /*4f90:*/ 0xfd, 0xe9, 0x12, 0x29, 0xd9, 0x56, 0xdf, 0xe9, 0x9b, 0x4f, 0x30, 0x0e, 0x1c, 0x4c, 0x3f, 0x57, + /*4fa0:*/ 0xea, 0xd2, 0x9a, 0x00, 0x2d, 0x05, 0xfa, 0x0d, 0xcd, 0x2a, 0x6b, 0x7b, 0x12, 0xae, 0xe5, 0xe2, + /*4fb0:*/ 0xb0, 0xa1, 0x3c, 0xfc, 0xcb, 0x41, 0x00, 0x4c, 0x79, 0xbd, 0x02, 0x47, 0x36, 0x1b, 0x2a, 0xbc, + /*4fc0:*/ 0x46, 0x3a, 0x29, 0x68, 0x4b, 0x41, 0x5f, 0x47, 0x2b, 0xdb, 0x4c, 0x0d, 0xba, 0x7d, 0x3e, 0xd8, + /*4fd0:*/ 0x9a, 0x74, 0x62, 0x3d, 0x5d, 0x29, 0xec, 0x52, 0x65, 0x65, 0xdb, 0x95, 0xa5, 0x52, 0xff, 0xbb, + /*4fe0:*/ 0xef, 0xdb, 0xe9, 0xe4, 0xef, 0xb8, 0x0f, 0x94, 0x84, 0xab, 0xcb, 0x2e, 0x3c, 0x07, 0xee, 0xc1, + /*4ff0:*/ 0x26, 0xa5, 0xcd, 0xc4, 0x8f, 0xd7, 0x4c, 0xb5, 0x8c, 0xa8, 0x82, 0xbb, 0xda, 0xfe, 0x18, 0x25, + /*5000:*/ 0x0a, 0x5a, 0x1c, 0x02, 0x5a, 0x84, 0xa7, 0x1e, 0xdb, 0x8a, 0xc3, 0x97, 0xf0, 0x3a, 0x82, 0x06, + /*5010:*/ 0x08, 0x55, 0x93, 0x72, 0x66, 0xec, 0xac, 0x86, 0x3a, 0xb4, 0x27, 0xf4, 0x9d, 0x91, 0x96, 0xe8, + /*5020:*/ 0x6c, 0x06, 0x6c, 0xc0, 0xe4, 0x18, 0x1c, 0x54, 0x72, 0x2e, 0x4c, 0x56, 0xb6, 0x15, 0xe0, 0x72, + /*5030:*/ 0x66, 0xf0, 0xb0, 0xde, 0x53, 0x32, 0x30, 0x6c, 0xe4, 0x3f, 0x6e, 0x6e, 0x6a, 0xa3, 0xc5, 0x30, + /*5040:*/ 0xc8, 0xba, 0x71, 0x11, 0x9c, 0x57, 0x34, 0xb4, 0x92, 0x7d, 0x19, 0x3c, 0xcd, 0x9d, 0x22, 0xa2, + /*5050:*/ 0xf9, 0xdb, 0x99, 0x73, 0xfe, 0xcc, 0x10, 0x2d, 0xdf, 0x96, 0xf6, 0x8b, 0xce, 0x74, 0x91, 0xcb, + /*5060:*/ 0xd8, 0x50, 0x6b, 0x9d, 0x56, 0xec, 0x53, 0x7e, 0x5b, 0xaa, 0x7b, 0xa3, 0x9b, 0xaf, 0xa5, 0x7e, + /*5070:*/ 0xa4, 0xfa, 0x10, 0xdb, 0x73, 0x6e, 0xba, 0x66, 0x66, 0x17, 0xd5, 0x60, 0xa7, 0x9c, 0x4b, 0xdf, + /*5080:*/ 0xa7, 0x5e, 0x45, 0xfe, 0x5f, 0xbe, 0xf1, 0xd2, 0x63, 0x1a, 0x4d, 0x26, 0x22, 0x6e, 0x03, 0xe0, + /*5090:*/ 0x45, 0x89, 0x30, 0x41, 0x43, 0xad, 0x2b, 0xad, 0xf4, 0x0e, 0x0f, 0xa5, 0x33, 0xfc, 0x49, 0x30, + /*50a0:*/ 0x44, 0xf5, 0xc5, 0x8e, 0xe2, 0xa6, 0x32, 0x4b, 0x0c, 0xd5, 0x4d, 0x91, 0xe3, 0x48, 0xe2, 0xb7, + /*50b0:*/ 0xad, 0x24, 0xfb, 0xf9, 0x13, 0xe0, 0x3c, 0x8a, 0x03, 0xc6, 0x35, 0xbc, 0xd6, 0x6e, 0x03, 0x20, + /*50c0:*/ 0xda, 0x2b, 0x95, 0x22, 0x23, 0x55, 0xab, 0x79, 0x58, 0xd0, 0x55, 0x1a, 0x4d, 0xa4, 0xfd, 0x6e, + /*50d0:*/ 0x6b, 0x99, 0xc1, 0xf0, 0xba, 0x5d, 0x51, 0xfe, 0x59, 0xc3, 0x52, 0x19, 0x1b, 0x33, 0x89, 0x60, + /*50e0:*/ 0x07, 0xaf, 0x23, 0xd1, 0x01, 0xcd, 0xc9, 0xfa, 0x58, 0xa6, 0x7d, 0xec, 0x3e, 0x19, 0xc6, 0xc0, + /*50f0:*/ 0xa9, 0x5e, 0x9a, 0xb1, 0xe8, 0x58, 0xcb, 0x05, 0x36, 0x11, 0x98, 0xa3, 0x35, 0x32, 0x87, 0x44, + /*5100:*/ 0x5f, 0x6b, 0xdf, 0x09, 0x15, 0x42, 0xd7, 0xe9, 0x72, 0x56, 0x3f, 0x6b, 0x19, 0x08, 0x46, 0xf0, + /*5110:*/ 0x25, 0x77, 0x96, 0x04, 0x0f, 0x99, 0x4e, 0xa9, 0xbb, 0x7d, 0xad, 0x19, 0x6b, 0x2e, 0x42, 0x41, + /*5120:*/ 0xbc, 0xd2, 0xf0, 0x4b, 0xc6, 0xc5, 0x72, 0xa1, 0x39, 0x22, 0x56, 0x9b, 0x72, 0x34, 0x01, 0x3b, + /*5130:*/ 0x70, 0x33, 0x0f, 0xa3, 0x80, 0xf3, 0x9b, 0xcf, 0x4c, 0x22, 0xb5, 0xce, 0xd7, 0xe1, 0xdd, 0xa9, + /*5140:*/ 0xa0, 0x04, 0x87, 0xd0, 0xe2, 0x76, 0xed, 0xb6, 0x17, 0xb5, 0xf8, 0x20, 0x4c, 0xb2, 0x1c, 0x25, + /*5150:*/ 0x8b, 0x7e, 0x10, 0x65, 0xe3, 0xaa, 0x9b, 0x58, 0xfe, 0x41, 0x68, 0x9b, 0x2e, 0x02, 0x93, 0x86, + /*5160:*/ 0xab, 0xba, 0xb2, 0x70, 0xed, 0x13, 0x21, 0x94, 0xc7, 0x4f, 0xac, 0xb3, 0x77, 0xbb, 0xf1, 0x62, + /*5170:*/ 0x08, 0xfd, 0xe6, 0x53, 0xa0, 0x03, 0xc7, 0xbb, 0xcc, 0xf8, 0x90, 0x93, 0x2d, 0xc7, 0xee, 0xf8, + /*5180:*/ 0xf5, 0x08, 0xf8, 0x70, 0x2b, 0xc7, 0x29, 0x49, 0xc6, 0xc1, 0xbe, 0xc9, 0x48, 0x4b, 0xb4, 0x87, + /*5190:*/ 0xa3, 0xcb, 0x24, 0x88, 0x5f, 0xd7, 0xc0, 0x28, 0x2e, 0x13, 0x12, 0x6c, 0xf5, 0x00, 0x09, 0x12, + /*51a0:*/ 0x59, 0x8d, 0x38, 0x6c, 0xb7, 0x33, 0xda, 0x11, 0x66, 0x06, 0xd5, 0x11, 0x99, 0x1f, 0x3f, 0x44, + /*51b0:*/ 0xf1, 0x5e, 0x58, 0x7f, 0x30, 0xaf, 0x73, 0x8d, 0x24, 0x01, 0x5c, 0x1d, 0x02, 0x4a, 0x15, 0xd9, + /*51c0:*/ 0x8c, 0x6e, 0x12, 0xe6, 0x54, 0x73, 0xe9, 0x62, 0x31, 0xf9, 0x8e, 0x3c, 0x00, 0xff, 0x80, 0x48, + /*51d0:*/ 0xb9, 0x24, 0x18, 0x2f, 0xa7, 0xd8, 0x07, 0xd0, 0x84, 0x64, 0xe6, 0xad, 0x9d, 0xe9, 0xa7, 0xd8, + /*51e0:*/ 0x3c, 0xaa, 0x59, 0x19, 0x5a, 0x29, 0x61, 0xf8, 0x39, 0xcb, 0x16, 0x63, 0x9e, 0x6a, 0xc8, 0xcd, + /*51f0:*/ 0x5d, 0x4f, 0x97, 0x8c, 0xe3, 0xf1, 0x9a, 0xa0, 0x33, 0x24, 0x7c, 0x15, 0x65, 0x95, 0xb3, 0x09, + /*5200:*/ 0xaf, 0x2f, 0x11, 0x6c, 0xac, 0xea, 0x75, 0x33, 0x4b, 0x5a, 0xf3, 0x9f, 0x38, 0xa4, 0x60, 0xd8, + /*5210:*/ 0x0c, 0xff, 0x92, 0x97, 0x35, 0x63, 0xbe, 0x2f, 0x44, 0xa5, 0xc6, 0x4d, 0x61, 0x3e, 0xc5, 0xad, + /*5220:*/ 0xc6, 0x9b, 0x41, 0x02, 0x0c, 0x9d, 0x1e, 0xc5, 0xb1, 0x21, 0x0e, 0xd3, 0x44, 0xd8, 0x36, 0x49, + /*5230:*/ 0x73, 0x20, 0x23, 0xbc, 0x97, 0x99, 0xf0, 0xc2, 0x6f, 0x2c, 0x10, 0x69, 0x9d, 0xfe, 0x4d, 0x85, + /*5240:*/ 0xf7, 0xd6, 0x86, 0x87, 0x05, 0x42, 0x8d, 0xcb, 0xc7, 0x9f, 0xbd, 0x28, 0x0b, 0xdd, 0x8c, 0xe0, + /*5250:*/ 0x60, 0x61, 0x77, 0xb5, 0xca, 0x50, 0x33, 0x3d, 0xd4, 0x82, 0x51, 0x8d, 0x5b, 0x14, 0x28, 0x98, + /*5260:*/ 0x88, 0x90, 0x34, 0x1e, 0x77, 0xf6, 0x7f, 0xc2, 0x00, 0xf8, 0x55, 0x6d, 0xf9, 0xce, 0xb0, 0x3a, + /*5270:*/ 0xec, 0xe5, 0x5f, 0x8b, 0x2b, 0x12, 0x5c, 0x9b, 0x01, 0x33, 0xa6, 0x9b, 0x8b, 0xb1, 0x6a, 0x8d, + /*5280:*/ 0x70, 0xb2, 0x9e, 0x07, 0x27, 0x5a, 0x40, 0x5d, 0xba, 0x7f, 0x8b, 0x4c, 0x99, 0x49, 0x6e, 0x31, + /*5290:*/ 0x1e, 0xe4, 0x7e, 0x4a, 0x5d, 0xc3, 0xd1, 0x04, 0x0a, 0x7a, 0xab, 0x6a, 0x3c, 0x38, 0xa7, 0x7f, + /*52a0:*/ 0xd0, 0xcd, 0x06, 0x6a, 0x81, 0x37, 0x28, 0x25, 0xe9, 0xd2, 0xe6, 0x79, 0x1c, 0x43, 0x36, 0x80, + /*52b0:*/ 0x2b, 0x1d, 0xee, 0xd4, 0x4b, 0x7a, 0x5f, 0x9a, 0x7c, 0x38, 0xc1, 0x08, 0xa9, 0x17, 0x18, 0xd2, + /*52c0:*/ 0x6c, 0x78, 0xf0, 0xaa, 0xb4, 0x62, 0x38, 0x96, 0x6e, 0x96, 0x7b, 0x21, 0xc3, 0x21, 0x9b, 0xb2, + /*52d0:*/ 0x70, 0x5d, 0x7b, 0x2f, 0xb1, 0xc6, 0x96, 0x1a, 0xe0, 0xd7, 0x76, 0x6a, 0x6f, 0x4b, 0x23, 0x38, + /*52e0:*/ 0x9b, 0xc7, 0xac, 0xbf, 0x44, 0x01, 0x0f, 0xb6, 0x66, 0x97, 0xa5, 0xc6, 0xf8, 0xc2, 0xfa, 0x3b, + /*52f0:*/ 0x78, 0x48, 0xd1, 0xac, 0xe8, 0x47, 0xd0, 0x0e, 0x80, 0x0c, 0x52, 0xf0, 0xd4, 0x04, 0x4a, 0xd7, + /*5300:*/ 0x60, 0x49, 0xe5, 0x78, 0xe6, 0xc6, 0x91, 0xbc, 0x67, 0x12, 0x9a, 0x14, 0x39, 0x3a, 0xd5, 0x3a, + /*5310:*/ 0xa4, 0x2c, 0xfc, 0x1c, 0x30, 0x99, 0xdd, 0xf2, 0xba, 0xe6, 0xfa, 0xe3, 0x1d, 0xd9, 0xae, 0x64, + /*5320:*/ 0x11, 0x87, 0x92, 0x51, 0xc9, 0x61, 0x50, 0xb0, 0x82, 0x6d, 0x0b, 0x43, 0x8b, 0xf6, 0xae, 0x8e, + /*5330:*/ 0x83, 0x7d, 0x00, 0xfc, 0xd9, 0xf5, 0x4b, 0x14, 0x36, 0xf1, 0x4a, 0xea, 0x33, 0x92, 0x8c, 0x16, + /*5340:*/ 0x91, 0xb9, 0xf0, 0x44, 0xa2, 0x31, 0xed, 0x0e, 0x6b, 0x45, 0xb3, 0xe2, 0x47, 0xab, 0xc6, 0x70, + /*5350:*/ 0xf8, 0x84, 0xe8, 0xa4, 0x41, 0x9f, 0x32, 0xd5, 0x61, 0x6b, 0x81, 0x38, 0x34, 0x5b, 0x88, 0xf2, + /*5360:*/ 0x82, 0xae, 0x6c, 0x5e, 0xa0, 0x6f, 0xb1, 0x93, 0xaf, 0x6b, 0x04, 0xbe, 0xd5, 0xcb, 0xae, 0xac, + /*5370:*/ 0xd0, 0x09, 0x2a, 0x7d, 0x9f, 0xa6, 0xa9, 0xa2, 0x46, 0x61, 0x82, 0xaa, 0x95, 0x9c, 0xf1, 0x36, + /*5380:*/ 0x57, 0xb5, 0xcf, 0x5a, 0x00, 0x43, 0xac, 0x5c, 0xb4, 0xd9, 0xe2, 0x08, 0x03, 0x5c, 0x88, 0xc4, + /*5390:*/ 0xab, 0x50, 0xa6, 0x72, 0xae, 0xe0, 0x56, 0xba, 0x93, 0x9a, 0x87, 0x20, 0xe1, 0x08, 0x55, 0x2c, + /*53a0:*/ 0xeb, 0xff, 0xfd, 0xc6, 0x31, 0xc0, 0xb2, 0xce, 0x62, 0xe4, 0x8b, 0x31, 0xc3, 0xa9, 0x70, 0xed, + /*53b0:*/ 0x0f, 0x98, 0x04, 0x70, 0x07, 0xa3, 0x17, 0xc5, 0xb6, 0x15, 0x02, 0x2b, 0x62, 0x68, 0xb9, 0x18, + /*53c0:*/ 0xa4, 0x88, 0xf8, 0xad, 0x61, 0x63, 0x9d, 0x4f, 0x71, 0xd5, 0xbc, 0x32, 0x86, 0xa9, 0x2b, 0x6b, + /*53d0:*/ 0xdf, 0x2d, 0x0d, 0x4b, 0x6f, 0x65, 0xe4, 0x57, 0xae, 0x76, 0xac, 0x48, 0xeb, 0xa8, 0x12, 0xc5, + /*53e0:*/ 0x30, 0x93, 0x12, 0xfb, 0x85, 0xa9, 0x76, 0xe4, 0xca, 0x36, 0xbc, 0xb4, 0xd4, 0xa5, 0x6f, 0x3c, + /*53f0:*/ 0x77, 0x16, 0x05, 0x00, 0x3f, 0xd3, 0x0b, 0x93, 0x3e, 0xf0, 0xdd, 0xa3, 0xd9, 0xba, 0xfd, 0x6d, + /*5400:*/ 0x6e, 0x91, 0x64, 0x41, 0xa0, 0x40, 0xd7, 0x1a, 0x25, 0x33, 0xb8, 0x35, 0x50, 0x56, 0xa6, 0xf1, + /*5410:*/ 0x18, 0x19, 0x98, 0x5e, 0x74, 0x4b, 0xb0, 0xc0, 0xf2, 0xbb, 0x5b, 0x06, 0x1c, 0xc7, 0x35, 0x3b, + /*5420:*/ 0x3f, 0x00, 0x58, 0x20, 0x4a, 0x52, 0x25, 0xd2, 0x10, 0x79, 0x3b, 0x78, 0xd3, 0x6b, 0x39, 0x5c, + /*5430:*/ 0xf3, 0x22, 0xde, 0xb8, 0xd6, 0x8b, 0xe9, 0x2c, 0x03, 0x55, 0xd4, 0x82, 0x66, 0x33, 0x6e, 0xa1, + /*5440:*/ 0x68, 0xd8, 0x63, 0x1f, 0xda, 0xf8, 0x14, 0x4c, 0xfd, 0x78, 0x70, 0x3e, 0xdf, 0xdb, 0x83, 0x99, + /*5450:*/ 0x94, 0x61, 0xa5, 0x86, 0x64, 0xae, 0x9c, 0xfe, 0x33, 0xc7, 0x20, 0x04, 0x5a, 0xbe, 0xd4, 0x74, + /*5460:*/ 0xef, 0x19, 0x39, 0xf8, 0xf9, 0xff, 0xcc, 0x96, 0x3a, 0xb6, 0x1c, 0x54, 0xd8, 0xd7, 0xcb, 0xf6, + /*5470:*/ 0xd7, 0x97, 0x51, 0xd2, 0xd8, 0x86, 0x8e, 0x04, 0x5f, 0xc6, 0x5c, 0x3e, 0x71, 0x87, 0xa6, 0x50, + /*5480:*/ 0xeb, 0x41, 0x45, 0x45, 0xba, 0x0f, 0x67, 0x32, 0x44, 0x64, 0xbf, 0xde, 0xbc, 0x4c, 0x11, 0xfe, + /*5490:*/ 0xc2, 0x24, 0xe2, 0xf3, 0x30, 0xb2, 0x87, 0xa1, 0x62, 0xf6, 0xa0, 0x7d, 0xf7, 0xd9, 0x68, 0x83, + /*54a0:*/ 0x7a, 0x1b, 0x00, 0x0d, 0x01, 0xd8, 0xc0, 0xa6, 0x99, 0x2a, 0x95, 0x44, 0x5f, 0xda, 0xf6, 0xc3, + /*54b0:*/ 0xa0, 0x30, 0x0b, 0x1d, 0x88, 0xb4, 0xae, 0xc7, 0x2b, 0xae, 0x06, 0x2a, 0xb1, 0x72, 0x64, 0xec, + /*54c0:*/ 0x0b, 0xdc, 0xc6, 0xba, 0x92, 0xa6, 0xb9, 0x6e, 0x4f, 0x69, 0x12, 0x99, 0xb5, 0x00, 0xcf, 0x8d, + /*54d0:*/ 0x8e, 0x0b, 0x94, 0x75, 0xf2, 0x89, 0xb4, 0x35, 0x48, 0x9d, 0x7f, 0x76, 0x15, 0xb9, 0x92, 0x0b, + /*54e0:*/ 0x82, 0xba, 0x88, 0x8a, 0xff, 0x21, 0x3b, 0xd8, 0x53, 0x02, 0x78, 0x6a, 0x2a, 0x7c, 0x34, 0xb5, + /*54f0:*/ 0xfc, 0xc7, 0xb8, 0x99, 0xe0, 0xed, 0xb8, 0x52, 0xce, 0xc8, 0x68, 0x5e, 0x67, 0x2a, 0x7a, 0x4b, + /*5500:*/ 0x75, 0x78, 0x0f, 0x9d, 0xbe, 0x0e, 0x4c, 0xde, 0x5a, 0x1b, 0xc2, 0x36, 0xf3, 0xe4, 0x8a, 0xfd, + /*5510:*/ 0xf3, 0x72, 0x42, 0x38, 0xac, 0xd3, 0xc4, 0xaa, 0x16, 0xfa, 0x60, 0x8b, 0x4e, 0xd5, 0x87, 0x34, + /*5520:*/ 0x78, 0x01, 0x8b, 0x3b, 0x48, 0x1e, 0x57, 0x46, 0x59, 0x2d, 0x6c, 0xda, 0x80, 0xb2, 0x4b, 0x9c, + /*5530:*/ 0x77, 0xa2, 0x1c, 0xc0, 0x70, 0x63, 0xc1, 0x0e, 0x30, 0xf1, 0x26, 0xd1, 0xdd, 0x75, 0xf8, 0x3f, + /*5540:*/ 0x2c, 0xeb, 0x9d, 0xdf, 0xbc, 0x74, 0xff, 0x46, 0x6e, 0xbc, 0x7f, 0x9b, 0x41, 0xce, 0x20, 0xb0, + /*5550:*/ 0xb7, 0xff, 0x99, 0xc3, 0x13, 0x7c, 0xf6, 0x4b, 0xb3, 0x35, 0x37, 0xaa, 0xf2, 0x9a, 0xad, 0x67, + /*5560:*/ 0x81, 0xe0, 0x9d, 0xa6, 0x4f, 0x48, 0x68, 0xc2, 0x22, 0xaf, 0xf8, 0xdf, 0xf9, 0x2f, 0x08, 0x84, + /*5570:*/ 0x2c, 0xcb, 0xc4, 0x86, 0xe2, 0x5a, 0x38, 0x94, 0x45, 0x4d, 0xd7, 0x30, 0x97, 0x5a, 0xd4, 0x60, + /*5580:*/ 0x3b, 0x20, 0xb5, 0xf8, 0x39, 0x8c, 0x1a, 0x60, 0x05, 0xbb, 0x9e, 0x61, 0x8c, 0x56, 0x96, 0x39, + /*5590:*/ 0xe4, 0x78, 0x10, 0x07, 0x14, 0xb3, 0xbe, 0x0d, 0x24, 0x58, 0x78, 0xa8, 0x79, 0x29, 0xf0, 0xcc, + /*55a0:*/ 0x12, 0x4b, 0x5a, 0x9a, 0xa4, 0x4b, 0xa8, 0x37, 0x5e, 0xc3, 0x1b, 0x13, 0x77, 0x24, 0x09, 0x29, + /*55b0:*/ 0xcc, 0xf9, 0x05, 0xd7, 0x20, 0xe9, 0x16, 0xd5, 0xb0, 0x4d, 0x61, 0x44, 0xd7, 0x29, 0x9b, 0xd7, + /*55c0:*/ 0x6c, 0xaa, 0x82, 0xc9, 0x6e, 0x3a, 0x07, 0x8b, 0x9c, 0xef, 0x6a, 0xc0, 0x91, 0x11, 0x4b, 0x2d, + /*55d0:*/ 0x26, 0xd7, 0x3b, 0x11, 0x88, 0x4d, 0x6f, 0xf4, 0xad, 0xf3, 0xde, 0xdb, 0xa5, 0xb9, 0x7b, 0x64, + /*55e0:*/ 0x60, 0x7b, 0xd8, 0xf2, 0xd3, 0xa3, 0x64, 0x1a, 0x56, 0xc9, 0x5e, 0x6a, 0x86, 0xbd, 0x28, 0xea, + /*55f0:*/ 0x31, 0x28, 0x15, 0x84, 0x5c, 0xe5, 0x0a, 0x89, 0x54, 0x69, 0x14, 0x5b, 0xca, 0x24, 0x56, 0xc2, + /*5600:*/ 0x71, 0x96, 0xdf, 0x31, 0x9b, 0x72, 0x9f, 0xb3, 0xce, 0xd4, 0x87, 0xf6, 0x6f, 0x32, 0x89, 0x72, + /*5610:*/ 0x82, 0x7c, 0x59, 0x5c, 0x57, 0xfa, 0x01, 0x89, 0xd2, 0x2d, 0x45, 0xe3, 0x53, 0x62, 0xc9, 0x40, + /*5620:*/ 0x73, 0xa0, 0xcd, 0x96, 0xe1, 0xe5, 0x42, 0xed, 0x1a, 0x51, 0xb2, 0xb6, 0xc3, 0x18, 0xed, 0xd1, + /*5630:*/ 0x1f, 0x07, 0x69, 0x66, 0xbd, 0x27, 0x78, 0x6e, 0xd9, 0xf0, 0xe5, 0x37, 0x75, 0xbd, 0x67, 0xcf, + /*5640:*/ 0x62, 0x4e, 0xd2, 0xb1, 0xfa, 0xa9, 0x0c, 0x4a, 0xd3, 0x96, 0x96, 0x0f, 0xcd, 0x9b, 0x80, 0x1a, + /*5650:*/ 0x3b, 0x4a, 0x99, 0xdb, 0xd4, 0x16, 0x02, 0x62, 0x15, 0x97, 0xfa, 0xac, 0xd2, 0x04, 0x0b, 0xd5, + /*5660:*/ 0x7b, 0x20, 0x1d, 0xf3, 0x9c, 0xed, 0x32, 0x9b, 0x90, 0x2d, 0x95, 0xb1, 0x7e, 0x2c, 0xf8, 0x27, + /*5670:*/ 0x2c, 0x06, 0x8b, 0x23, 0x93, 0xc5, 0xa2, 0x0d, 0x94, 0xfc, 0xfd, 0x56, 0xe1, 0xe6, 0xa9, 0x81, + /*5680:*/ 0xe2, 0x48, 0x53, 0xee, 0x6d, 0xe9, 0x44, 0x92, 0x1b, 0x73, 0x16, 0xd6, 0x99, 0x12, 0xa4, 0x6a, + /*5690:*/ 0xa1, 0xfc, 0x8b, 0x1a, 0xf0, 0xb4, 0x1c, 0x67, 0xd4, 0x83, 0x65, 0x69, 0x9c, 0x64, 0xb1, 0x9e, + /*56a0:*/ 0x0b, 0x74, 0xbb, 0x0f, 0xa8, 0x7d, 0xb9, 0x39, 0x3b, 0x2c, 0x89, 0xcf, 0x70, 0x74, 0x27, 0xcf, + /*56b0:*/ 0x4a, 0xdd, 0x8a, 0xe5, 0x05, 0x46, 0x6d, 0x84, 0xba, 0x1d, 0x70, 0x78, 0x5a, 0x6f, 0x9a, 0xf1, + /*56c0:*/ 0xb4, 0xf8, 0x11, 0x7b, 0x39, 0xe7, 0x03, 0x67, 0x58, 0x6b, 0x64, 0x8c, 0x8d, 0xa3, 0xd2, 0x7d, + /*56d0:*/ 0xf4, 0x35, 0x4e, 0x48, 0x61, 0xc8, 0xaa, 0x57, 0xb9, 0xf5, 0xcd, 0x9c, 0xaa, 0x38, 0x78, 0x17, + /*56e0:*/ 0xaf, 0x59, 0x11, 0x2b, 0xfa, 0x49, 0x6c, 0xf3, 0xdf, 0x53, 0xb0, 0xb5, 0x3d, 0x1e, 0x37, 0x7e, + /*56f0:*/ 0x11, 0x2c, 0x56, 0xfa, 0xc7, 0x77, 0x6d, 0x6c, 0xd8, 0xd6, 0x12, 0x41, 0x12, 0xa2, 0x02, 0x06, + /*5700:*/ 0xcd, 0x5d, 0x75, 0xba, 0x86, 0xe5, 0xe5, 0x27, 0xdf, 0x8c, 0xd0, 0x06, 0xeb, 0x41, 0xbe, 0x8d, + /*5710:*/ 0xe1, 0xa2, 0x90, 0x8f, 0x4b, 0xbf, 0x76, 0x03, 0x75, 0x33, 0x29, 0x1a, 0x80, 0x57, 0xd6, 0x67, + /*5720:*/ 0x01, 0x72, 0xc1, 0x5a, 0xea, 0xd3, 0xbe, 0xb1, 0xac, 0x6c, 0x13, 0xc5, 0xc2, 0x72, 0x7d, 0x22, + /*5730:*/ 0xb0, 0xa2, 0xab, 0xf6, 0x52, 0x78, 0x37, 0xcf, 0x38, 0x1e, 0x13, 0xb9, 0xee, 0x71, 0x5a, 0xc4, + /*5740:*/ 0xfc, 0x6a, 0x11, 0xe1, 0xd6, 0x6e, 0x01, 0x32, 0x5a, 0x51, 0x35, 0x39, 0x59, 0x30, 0xc5, 0x15, + /*5750:*/ 0x87, 0x52, 0x63, 0xe8, 0x07, 0x39, 0xd8, 0xf0, 0x85, 0xf5, 0x7c, 0x31, 0x6d, 0xbf, 0x24, 0x27, + /*5760:*/ 0xf7, 0x66, 0xca, 0x6a, 0x81, 0xc8, 0x38, 0x02, 0x07, 0x20, 0x49, 0x2e, 0x9e, 0xe6, 0xe9, 0x5e, + /*5770:*/ 0x64, 0x81, 0xed, 0xea, 0xf9, 0x87, 0x53, 0xed, 0x06, 0xe0, 0x27, 0xba, 0x29, 0x0b, 0x00, 0xa0, + /*5780:*/ 0x2c, 0xbf, 0xee, 0x37, 0x44, 0x63, 0xa0, 0xf4, 0xe3, 0x9a, 0xc5, 0xba, 0x6f, 0x50, 0x1c, 0x72, + /*5790:*/ 0x14, 0x89, 0x3c, 0x14, 0xc4, 0xf7, 0x8c, 0x4d, 0x7d, 0x2a, 0xa2, 0xb4, 0x94, 0xfe, 0xfd, 0xce, + /*57a0:*/ 0xcf, 0x07, 0x71, 0x33, 0xe0, 0x46, 0xe0, 0x03, 0x94, 0x42, 0x9d, 0x55, 0x69, 0x2c, 0x3d, 0x74, + /*57b0:*/ 0x6b, 0x74, 0x52, 0x49, 0x34, 0x9c, 0x51, 0xc0, 0x19, 0x0c, 0x5e, 0x74, 0x76, 0xc2, 0x4a, 0x0a, + /*57c0:*/ 0x14, 0x88, 0x4e, 0x2a, 0xa5, 0x9a, 0x9e, 0xc3, 0x99, 0x72, 0x5e, 0xef, 0x9c, 0x94, 0xac, 0xa7, + /*57d0:*/ 0x61, 0x78, 0xc2, 0x36, 0x17, 0x82, 0x2d, 0xce, 0x7d, 0x92, 0xd0, 0x8a, 0x3b, 0x3e, 0x1f, 0x1d, + /*57e0:*/ 0x83, 0xf9, 0xa8, 0x44, 0xdf, 0xce, 0x84, 0x31, 0xdc, 0xf2, 0xd6, 0x0d, 0xb9, 0x0b, 0x89, 0xc5, + /*57f0:*/ 0x77, 0xae, 0xa1, 0x9a, 0x75, 0xc6, 0x93, 0x6e, 0xdb, 0x61, 0xdd, 0x3d, 0x8e, 0x7c, 0x4b, 0x53, + /*5800:*/ 0x14, 0x1d, 0x3c, 0x51, 0x5f, 0x60, 0xfe, 0x6a, 0x1d, 0xef, 0x49, 0x30, 0x03, 0xf3, 0xb2, 0x7c, + /*5810:*/ 0xf5, 0x1c, 0x88, 0x68, 0xf4, 0xb8, 0xf5, 0x36, 0x4f, 0x17, 0x11, 0x39, 0x44, 0xfc, 0xaa, 0xe2, + /*5820:*/ 0x51, 0x20, 0x77, 0xc7, 0xe0, 0xf4, 0x6e, 0x8c, 0xa5, 0x77, 0xc7, 0x66, 0x2c, 0x24, 0xb1, 0xae, + /*5830:*/ 0xc1, 0xbd, 0x1a, 0x64, 0x1c, 0x1e, 0xa3, 0xbb, 0x52, 0xb3, 0x53, 0x1a, 0x5e, 0x94, 0xd6, 0x10, + /*5840:*/ 0xd4, 0x17, 0x6e, 0x36, 0xe8, 0x09, 0x6a, 0x0f, 0x67, 0x73, 0x40, 0xb8, 0xcf, 0xdd, 0xc0, 0xac, + /*5850:*/ 0x3a, 0xfd, 0x08, 0xcd, 0xd2, 0x42, 0xc0, 0xb0, 0x4e, 0xc3, 0xca, 0x66, 0x2b, 0x84, 0x19, 0x6f, + /*5860:*/ 0x2e, 0xf2, 0x22, 0x21, 0x56, 0xb7, 0x17, 0xbe, 0x47, 0xc2, 0x96, 0x6e, 0x60, 0xf2, 0xc7, 0x1f, + /*5870:*/ 0x9b, 0xb5, 0x82, 0xea, 0x02, 0x46, 0x4e, 0x04, 0xca, 0x64, 0xa1, 0x70, 0xd6, 0xd0, 0xd7, 0x3d, + /*5880:*/ 0x15, 0x42, 0x68, 0x17, 0xfd, 0x7f, 0x7f, 0x9a, 0x12, 0x1b, 0xcc, 0x7a, 0x59, 0x85, 0x5e, 0xfd, + /*5890:*/ 0x74, 0x55, 0x8b, 0xc9, 0x55, 0xf7, 0x44, 0x64, 0xa8, 0xff, 0xd3, 0xb5, 0x32, 0x2e, 0xb1, 0x3a, + /*58a0:*/ 0x36, 0xe2, 0x4d, 0x18, 0x35, 0x37, 0x5c, 0x5b, 0x8d, 0x9b, 0x51, 0x51, 0x39, 0xb2, 0xbe, 0x5a, + /*58b0:*/ 0xaf, 0xf6, 0xa4, 0x35, 0xc5, 0x62, 0x26, 0x9e, 0x60, 0xa8, 0xad, 0x12, 0x89, 0xef, 0x23, 0x9a, + /*58c0:*/ 0x54, 0x74, 0xa6, 0x07, 0x40, 0xab, 0x97, 0xf4, 0xcc, 0xa9, 0x37, 0xd2, 0x43, 0xda, 0x9b, 0xdb, + /*58d0:*/ 0x07, 0x3c, 0x6f, 0x33, 0x64, 0x6b, 0xfd, 0xa7, 0x72, 0x5c, 0x61, 0xce, 0xe7, 0x2a, 0x21, 0x96, + /*58e0:*/ 0xac, 0xb4, 0x04, 0x2d, 0x0b, 0x8b, 0x6d, 0xa8, 0xbd, 0x48, 0xab, 0xcd, 0xc9, 0x1f, 0x12, 0xf3, + /*58f0:*/ 0xb6, 0x83, 0xec, 0xa2, 0x89, 0x8b, 0x89, 0x35, 0x62, 0x10, 0x5e, 0xc8, 0x28, 0xcc, 0x2f, 0xfb, + /*5900:*/ 0x85, 0xb4, 0x9a, 0xab, 0x51, 0x1a, 0x78, 0x84, 0x42, 0xec, 0x99, 0xad, 0x5b, 0x53, 0x24, 0x39, + /*5910:*/ 0x68, 0x4c, 0xdb, 0xef, 0xab, 0x5c, 0x89, 0xfa, 0x6f, 0xf7, 0x23, 0x6c, 0x42, 0x7d, 0xbf, 0xe9, + /*5920:*/ 0x29, 0x96, 0x1f, 0x47, 0x39, 0x86, 0x02, 0x36, 0x5a, 0x1a, 0x98, 0xe4, 0x1a, 0x7b, 0x03, 0x3b, + /*5930:*/ 0x6c, 0x5f, 0x41, 0x61, 0x20, 0x26, 0xe2, 0xf2, 0x26, 0x8a, 0xf7, 0x50, 0xe4, 0x50, 0xd2, 0x64, + /*5940:*/ 0xea, 0xec, 0xf5, 0x37, 0xea, 0xf7, 0x68, 0x8b, 0x31, 0x24, 0xc8, 0x78, 0x96, 0x2d, 0xc6, 0x9b, + /*5950:*/ 0x46, 0xa1, 0x9a, 0xe2, 0xdc, 0xbb, 0x26, 0x14, 0xd8, 0x7e, 0x78, 0xb9, 0x60, 0x1d, 0xc4, 0x4b, + /*5960:*/ 0x66, 0xad, 0x2d, 0x11, 0x40, 0x70, 0xcd, 0x41, 0xb5, 0xb5, 0x8d, 0xe1, 0xc2, 0x44, 0x6a, 0xcf, + /*5970:*/ 0x87, 0x28, 0xa8, 0x8a, 0xc6, 0x9b, 0xb4, 0xd8, 0x14, 0xae, 0x0e, 0xae, 0x4e, 0xde, 0x7f, 0xf1, + /*5980:*/ 0x79, 0xec, 0x9c, 0xed, 0x96, 0x33, 0xfd, 0x40, 0xae, 0xbf, 0x34, 0xa2, 0x9c, 0x5a, 0xf7, 0xcd, + /*5990:*/ 0x4b, 0xab, 0xaa, 0xd2, 0xd5, 0xb2, 0x39, 0xcd, 0x4a, 0x23, 0xc7, 0xb9, 0x82, 0x55, 0xa9, 0x00, + /*59a0:*/ 0xf1, 0x6d, 0x29, 0x99, 0x0d, 0xc6, 0x83, 0x5a, 0x21, 0xaa, 0x09, 0xb6, 0x24, 0x17, 0xd9, 0xbe, + /*59b0:*/ 0x56, 0xd8, 0x23, 0x56, 0x94, 0xe5, 0x72, 0xdd, 0xb3, 0xc7, 0x30, 0x76, 0x66, 0xc8, 0x79, 0xd6, + /*59c0:*/ 0xda, 0xa0, 0x85, 0x20, 0x75, 0xd4, 0x17, 0x65, 0x68, 0xb2, 0x47, 0xe7, 0xae, 0xfc, 0xe8, 0x40, + /*59d0:*/ 0xf0, 0x10, 0x64, 0xa8, 0x56, 0x29, 0x92, 0x4c, 0xe1, 0x8d, 0x80, 0x60, 0x3e, 0x05, 0x3d, 0xaa, + /*59e0:*/ 0x46, 0x9b, 0x4b, 0xa8, 0x80, 0xd7, 0xb0, 0x81, 0xa4, 0x5c, 0xc6, 0x12, 0xef, 0x4b, 0xda, 0x3f, + /*59f0:*/ 0x4b, 0x78, 0xf4, 0x64, 0x17, 0x52, 0xc2, 0xec, 0x4a, 0xc6, 0x44, 0x3b, 0x80, 0xcf, 0xd6, 0xa5, + /*5a00:*/ 0x44, 0xa5, 0x02, 0x3b, 0x05, 0x10, 0xd0, 0x69, 0xdf, 0x7e, 0x27, 0xf0, 0x25, 0x26, 0x09, 0xa8, + /*5a10:*/ 0xa7, 0x38, 0x72, 0xe5, 0x96, 0x62, 0x8a, 0xc7, 0x5e, 0xb1, 0x6a, 0xf6, 0x5a, 0x1a, 0x08, 0x88, + /*5a20:*/ 0xe4, 0x18, 0x42, 0xff, 0x53, 0xbb, 0x93, 0x7c, 0xc5, 0x34, 0x65, 0x29, 0xcc, 0xbe, 0xfa, 0xb2, + /*5a30:*/ 0xec, 0x59, 0x23, 0xd8, 0xb2, 0x31, 0xe4, 0xe1, 0xe1, 0xb7, 0xd9, 0x40, 0xbd, 0xb6, 0x1b, 0x29, + /*5a40:*/ 0xba, 0x10, 0x60, 0x3d, 0x93, 0x68, 0x2f, 0x08, 0x17, 0xf3, 0x43, 0xa8, 0x0c, 0x1e, 0xda, 0x76, + /*5a50:*/ 0x60, 0x8a, 0xb0, 0x2d, 0x44, 0x09, 0x24, 0xf2, 0xca, 0xa8, 0xf5, 0xd4, 0x4e, 0x2a, 0xbd, 0xd7, + /*5a60:*/ 0xed, 0x37, 0x24, 0x20, 0xfa, 0x00, 0x0a, 0x01, 0x4d, 0xc1, 0xfe, 0x71, 0x26, 0x76, 0xf0, 0x2f, + /*5a70:*/ 0x2b, 0xe9, 0xb5, 0xfe, 0xd9, 0x18, 0x96, 0x84, 0x51, 0xc1, 0x39, 0xf3, 0x1a, 0x87, 0x1c, 0xf6, + /*5a80:*/ 0x62, 0xed, 0xcd, 0xa7, 0x7e, 0x57, 0x6d, 0x08, 0xc6, 0x90, 0x6d, 0xe5, 0x6e, 0xee, 0x8f, 0x88, + /*5a90:*/ 0x07, 0x71, 0xab, 0x55, 0x66, 0xfc, 0xf7, 0x0b, 0x90, 0x97, 0xc9, 0xe9, 0xf0, 0xe5, 0x30, 0x9a, + /*5aa0:*/ 0xd0, 0x5a, 0x00, 0x9c, 0x1c, 0x3c, 0x49, 0x2a, 0x3e, 0x72, 0xb8, 0xfe, 0xab, 0x20, 0xc8, 0xf5, + /*5ab0:*/ 0xd7, 0xf9, 0x76, 0xbe, 0x33, 0x45, 0xac, 0x6b, 0x81, 0x50, 0x66, 0x9c, 0x24, 0xa0, 0x47, 0xe0, + /*5ac0:*/ 0xbe, 0x7f, 0xa2, 0x85, 0xb0, 0x8a, 0xfb, 0x42, 0x04, 0xe0, 0xed, 0xd6, 0xfd, 0xcc, 0x59, 0x6f, + /*5ad0:*/ 0xe7, 0x57, 0x63, 0x52, 0x03, 0x75, 0x28, 0x2d, 0x07, 0x7b, 0xe3, 0xf9, 0xfb, 0xa1, 0xef, 0x85, + /*5ae0:*/ 0x51, 0xf0, 0xf8, 0x76, 0x11, 0xa6, 0x80, 0xe4, 0x4b, 0x24, 0xfd, 0x1f, 0xc7, 0x68, 0x05, 0x8f, + /*5af0:*/ 0xd8, 0xdb, 0x52, 0xbd, 0x09, 0x85, 0x75, 0x5e, 0xe1, 0x61, 0x14, 0x60, 0xaf, 0xfd, 0xd2, 0xdf, + /*5b00:*/ 0xa3, 0x80, 0xc9, 0xa2, 0x80, 0x69, 0x47, 0xe9, 0xb7, 0xcd, 0xbb, 0xae, 0x53, 0xbd, 0xa8, 0xf6, + /*5b10:*/ 0x86, 0x88, 0x4c, 0xdb, 0xfc, 0xa7, 0xd1, 0x42, 0xfc, 0xb8, 0x9f, 0xe9, 0xf3, 0x7e, 0xeb, 0x13, + /*5b20:*/ 0x4f, 0xb0, 0xfa, 0xe0, 0x40, 0x42, 0xa6, 0x3b, 0x35, 0xf9, 0x72, 0x2f, 0x21, 0x17, 0x2d, 0xdd, + /*5b30:*/ 0xa2, 0x39, 0xa5, 0x88, 0xb2, 0x9b, 0xdb, 0x65, 0x3b, 0x70, 0x97, 0xb1, 0xe4, 0x4c, 0xda, 0x69, + /*5b40:*/ 0x88, 0x5c, 0xde, 0x5b, 0x89, 0x42, 0xe5, 0x13, 0x29, 0x73, 0x71, 0xe6, 0x37, 0x8a, 0x3e, 0x69, + /*5b50:*/ 0x66, 0xfd, 0xb2, 0x4b, 0x85, 0xa9, 0x29, 0x11, 0xce, 0x9b, 0x5a, 0x77, 0x48, 0xc8, 0x45, 0x19, + /*5b60:*/ 0x22, 0x07, 0x84, 0x91, 0xa0, 0x91, 0x5d, 0x7b, 0xde, 0x37, 0xd5, 0xcf, 0x62, 0x4e, 0x01, 0xd1, + /*5b70:*/ 0x87, 0x1f, 0xf9, 0x2d, 0xe6, 0x35, 0x67, 0x45, 0x69, 0x5a, 0x50, 0xaf, 0xae, 0xa8, 0x5b, 0x62, + /*5b80:*/ 0xbb, 0x03, 0x86, 0x97, 0x7f, 0x84, 0xe2, 0xbf, 0xc3, 0x04, 0x06, 0x1d, 0x08, 0xbc, 0x6d, 0x8e, + /*5b90:*/ 0xb9, 0x7a, 0x0d, 0xf1, 0x6c, 0xc6, 0x25, 0xd2, 0x17, 0x26, 0x05, 0x4c, 0xe3, 0xd6, 0x52, 0x19, + /*5ba0:*/ 0xf3, 0xd0, 0xb1, 0x0b, 0x62, 0x4d, 0x6c, 0x8e, 0xb8, 0x34, 0x1e, 0xd8, 0x0e, 0x88, 0xe2, 0x91, + /*5bb0:*/ 0xa8, 0xf0, 0xdf, 0x13, 0xb7, 0x5e, 0x12, 0xae, 0x21, 0x6b, 0x0c, 0x60, 0xa4, 0x40, 0xee, 0x1d, + /*5bc0:*/ 0x75, 0xfa, 0xd2, 0x0e, 0x21, 0x57, 0x15, 0x87, 0x0c, 0x30, 0x9f, 0x8a, 0x1c, 0xc6, 0xde, 0x93, + /*5bd0:*/ 0xb9, 0xc5, 0x3f, 0x48, 0x81, 0x07, 0xc0, 0xcb, 0x2f, 0xd3, 0x79, 0x60, 0x99, 0xab, 0x22, 0xa2, + /*5be0:*/ 0xcd, 0xc1, 0x6a, 0x6e, 0x87, 0xdf, 0xf9, 0x32, 0xba, 0x53, 0x25, 0xab, 0x0d, 0x3a, 0xcc, 0x31, + /*5bf0:*/ 0x61, 0x0e, 0xa7, 0x16, 0x4b, 0x2e, 0x1d, 0x94, 0xc5, 0x45, 0x80, 0x0c, 0x16, 0x93, 0x7c, 0xfd, + /*5c00:*/ 0x1f, 0xa1, 0x01, 0x20, 0xfb, 0xe3, 0x93, 0x92, 0x81, 0x38, 0x78, 0xd2, 0xda, 0xbd, 0xcd, 0xf0, + /*5c10:*/ 0xe6, 0x55, 0x6e, 0x33, 0x24, 0x06, 0xcb, 0xf1, 0xb3, 0x14, 0x90, 0x28, 0xe4, 0x33, 0xd7, 0xc8, + /*5c20:*/ 0x0d, 0xbb, 0x79, 0xcc, 0xe5, 0x9f, 0xcd, 0x78, 0x99, 0xb4, 0xab, 0xe1, 0x97, 0x30, 0x26, 0x62, + /*5c30:*/ 0xbe, 0x36, 0xfe, 0x00, 0x4d, 0xdf, 0x68, 0x50, 0x67, 0x63, 0xb6, 0xe2, 0x3b, 0xef, 0xbe, 0x2f, + /*5c40:*/ 0xca, 0xa2, 0xec, 0xc8, 0x79, 0x51, 0x56, 0x8c, 0xae, 0x14, 0xf8, 0xfc, 0x3f, 0x5f, 0x94, 0xdd, + /*5c50:*/ 0xb7, 0x0a, 0x1c, 0x79, 0xea, 0x22, 0x73, 0x33, 0x66, 0x7f, 0x4b, 0x0a, 0xb4, 0x51, 0xbd, 0xa7, + /*5c60:*/ 0xed, 0x46, 0x8f, 0xf9, 0x86, 0x65, 0x31, 0xfd, 0xf0, 0xdc, 0x2e, 0xee, 0xcf, 0xa7, 0x13, 0x9f, + /*5c70:*/ 0x07, 0x78, 0xc6, 0xc6, 0x07, 0x7b, 0x51, 0xda, 0x8f, 0x0b, 0xdb, 0xba, 0xd2, 0xde, 0xc6, 0x63, + /*5c80:*/ 0xbe, 0xd5, 0x92, 0xc6, 0xcb, 0xd3, 0xb3, 0xbb, 0x26, 0xe6, 0x10, 0x1f, 0x83, 0x69, 0x0e, 0x0a, + /*5c90:*/ 0xeb, 0xd5, 0x35, 0x71, 0xed, 0xa8, 0x77, 0x7a, 0x5a, 0x07, 0xaf, 0xd1, 0x3a, 0x00, 0xf6, 0x83, + /*5ca0:*/ 0x7e, 0x0d, 0x6c, 0xed, 0xd8, 0xc6, 0x3c, 0x15, 0x9d, 0xad, 0x5b, 0x1c, 0xb6, 0xfb, 0x4d, 0x89, + /*5cb0:*/ 0x0f, 0xa2, 0x8f, 0xf9, 0x3e, 0x48, 0x77, 0xeb, 0xd0, 0x8a, 0x0e, 0xfe, 0xd2, 0x15, 0x38, 0x1e, + /*5cc0:*/ 0x9c, 0x08, 0x60, 0xd8, 0xbf, 0x95, 0xb9, 0xe9, 0x5d, 0x6d, 0x7b, 0x8c, 0x86, 0x33, 0xe4, 0xb1, + /*5cd0:*/ 0x10, 0xf6, 0x0b, 0x1c, 0x2a, 0xcc, 0xe7, 0x3b, 0xc1, 0x18, 0x14, 0xf5, 0x8b, 0xf4, 0x50, 0x5b, + /*5ce0:*/ 0x64, 0x46, 0x8f, 0xc3, 0x70, 0xfb, 0x68, 0xe6, 0x9a, 0x73, 0x4e, 0x23, 0xc6, 0x21, 0x96, 0xf1, + /*5cf0:*/ 0x9f, 0xca, 0x75, 0xc4, 0xaf, 0xb2, 0xde, 0xd6, 0xa9, 0x5c, 0xa5, 0x18, 0x5d, 0x84, 0x79, 0xe3, + /*5d00:*/ 0xc5, 0xf5, 0x44, 0x5e, 0x63, 0xf0, 0xc8, 0x35, 0x15, 0xe3, 0xff, 0x04, 0x8a, 0x31, 0xd0, 0xee, + /*5d10:*/ 0xc6, 0xe4, 0x77, 0x30, 0xb8, 0x77, 0x49, 0x68, 0x1c, 0x33, 0x99, 0x2d, 0x7e, 0xf5, 0x45, 0xa9, + /*5d20:*/ 0x13, 0x69, 0xc2, 0xab, 0x3f, 0xea, 0x49, 0x07, 0x4b, 0xc9, 0x9d, 0x8a, 0x1f, 0x41, 0x7f, 0xf7, + /*5d30:*/ 0x98, 0x2d, 0x75, 0x11, 0x10, 0x23, 0xb7, 0xab, 0x26, 0x79, 0x04, 0x9c, 0x10, 0x2a, 0x75, 0xef, + /*5d40:*/ 0x54, 0xe6, 0xc7, 0xab, 0x2d, 0xe7, 0xb3, 0xf4, 0xdd, 0x9e, 0xb5, 0xda, 0xbd, 0x7b, 0xe9, 0xbd, + /*5d50:*/ 0x6b, 0xd8, 0xf3, 0x4b, 0x05, 0x76, 0xdb, 0x03, 0xa4, 0x2b, 0x37, 0x20, 0x8b, 0x3e, 0x2b, 0xa2, + /*5d60:*/ 0x18, 0x01, 0x8e, 0xcf, 0xf9, 0x3e, 0x8b, 0xf1, 0x80, 0x24, 0xde, 0x31, 0xd1, 0x81, 0x70, 0xaf, + /*5d70:*/ 0x82, 0xd7, 0x58, 0xa8, 0xdc, 0xce, 0x2b, 0x55, 0x44, 0x21, 0x2b, 0xe1, 0xac, 0x0e, 0x23, 0xe7, + /*5d80:*/ 0xb2, 0x0b, 0x5e, 0x12, 0x3c, 0x4e, 0x6e, 0x3b, 0xf7, 0xbb, 0xce, 0x72, 0x5a, 0x5d, 0x54, 0xa0, + /*5d90:*/ 0xf5, 0x2e, 0xce, 0x9f, 0x76, 0xbf, 0x25, 0xb1, 0xeb, 0x5a, 0xa6, 0x61, 0x7d, 0x98, 0x33, 0x2f, + /*5da0:*/ 0x49, 0x3d, 0xec, 0xdf, 0xef, 0xed, 0xa1, 0x90, 0xeb, 0xde, 0xc3, 0x89, 0xd0, 0x04, 0xa7, 0xa0, + /*5db0:*/ 0xaa, 0xb3, 0xed, 0x54, 0x13, 0xc4, 0x70, 0x90, 0xfa, 0x2a, 0xfd, 0x24, 0x87, 0xf5, 0x12, 0x82, + /*5dc0:*/ 0xf0, 0x39, 0xfd, 0x1a, 0xd5, 0x0f, 0x26, 0x4a, 0xaf, 0x40, 0xb4, 0x2e, 0x3f, 0x9c, 0xa7, 0x35, + /*5dd0:*/ 0xcb, 0x5d, 0xf3, 0x21, 0xea, 0xbf, 0xb9, 0x14, 0x01, 0x06, 0x36, 0xcc, 0x06, 0xba, 0xa9, 0x8a, + /*5de0:*/ 0x32, 0x22, 0x12, 0x22, 0x19, 0xff, 0x64, 0xd2, 0x33, 0x98, 0x90, 0xb0, 0x57, 0xcb, 0xe7, 0x6a, + /*5df0:*/ 0x58, 0xc9, 0x1d, 0x85, 0x08, 0x4e, 0x18, 0x57, 0x4b, 0x20, 0xd6, 0xbe, 0xaa, 0x8c, 0x44, 0xad, + /*5e00:*/ 0x83, 0x78, 0xe5, 0x79, 0x72, 0xc6, 0xa8, 0xf1, 0xe5, 0x09, 0x9d, 0x4f, 0x54, 0xd5, 0xb9, 0x7d, + /*5e10:*/ 0x5b, 0xe8, 0x9f, 0xb1, 0x45, 0xc2, 0xe3, 0xe3, 0xe2, 0xbf, 0x4d, 0xb4, 0x5b, 0x88, 0x15, 0x70, + /*5e20:*/ 0x94, 0xf0, 0xe6, 0x2c, 0x3c, 0x66, 0x15, 0xf2, 0xab, 0xdf, 0x57, 0x74, 0x59, 0x8e, 0x30, 0x0a, + /*5e30:*/ 0x52, 0xe0, 0x96, 0x54, 0x84, 0xbd, 0x28, 0x94, 0x80, 0x4d, 0xac, 0x0a, 0xc1, 0xf6, 0x36, 0x8b, + /*5e40:*/ 0x7b, 0x11, 0xce, 0x6e, 0x43, 0x50, 0xbc, 0x94, 0x93, 0x96, 0x29, 0xe3, 0xf3, 0x28, 0x1b, 0x88, + /*5e50:*/ 0x23, 0xb8, 0x7d, 0x0e, 0xd0, 0xb9, 0x46, 0x81, 0xa1, 0xb3, 0xba, 0xb9, 0x67, 0x48, 0xe6, 0xc5, + /*5e60:*/ 0x11, 0x12, 0xa3, 0xaa, 0xf3, 0x1d, 0xe0, 0x64, 0x20, 0x09, 0x31, 0xe4, 0x21, 0xd1, 0xbb, 0x6c, + /*5e70:*/ 0x67, 0x83, 0x43, 0xd1, 0x9b, 0x91, 0x3d, 0xdf, 0xea, 0xf3, 0xaf, 0x77, 0x4d, 0x58, 0x16, 0xe8, + /*5e80:*/ 0xce, 0xd6, 0x60, 0xaa, 0xa9, 0x40, 0x6d, 0x44, 0xbc, 0xb2, 0x46, 0x27, 0xc3, 0xa3, 0x5c, 0x18, + /*5e90:*/ 0xcd, 0xd9, 0xe5, 0xef, 0x91, 0x14, 0x3b, 0xff, 0xb2, 0xbd, 0x65, 0x9a, 0xf8, 0x75, 0x76, 0x7b, + /*5ea0:*/ 0x0f, 0xf8, 0xad, 0x0b, 0xbf, 0x4b, 0xdf, 0x2e, 0xa8, 0x45, 0xac, 0x4c, 0x3b, 0xb0, 0x18, 0x8e, + /*5eb0:*/ 0xb5, 0x85, 0x23, 0x1b, 0x63, 0xed, 0xaa, 0x09, 0x52, 0xb6, 0x36, 0xe0, 0xb8, 0x15, 0xa8, 0x8b, + /*5ec0:*/ 0x51, 0x4c, 0xa3, 0xca, 0x09, 0x3c, 0xec, 0x83, 0x91, 0xfb, 0x4f, 0x3b, 0xc5, 0x35, 0x4c, 0x13, + /*5ed0:*/ 0x0a, 0x8f, 0x58, 0xb5, 0x19, 0x29, 0xdd, 0x46, 0x53, 0xbd, 0xf4, 0x15, 0xdf, 0x29, 0xf5, 0xa4, + /*5ee0:*/ 0x25, 0x45, 0x85, 0xa3, 0x00, 0x75, 0x4d, 0x38, 0xfb, 0xfe, 0x53, 0xed, 0x1f, 0x14, 0xf2, 0x0e, + /*5ef0:*/ 0xb7, 0x40, 0x62, 0x88, 0x92, 0x54, 0x6e, 0xd2, 0xa5, 0x8d, 0x7a, 0x9b, 0x2b, 0xee, 0x74, 0xb0, + /*5f00:*/ 0xb0, 0x17, 0x2b, 0xd3, 0x46, 0x6a, 0x3d, 0xcb, 0xdc, 0x93, 0x00, 0xfc, 0xf1, 0x3d, 0x4d, 0x25, + /*5f10:*/ 0xe9, 0x8d, 0xdf, 0x8d, 0x0d, 0x4a, 0x3e, 0xcb, 0x58, 0xc2, 0x33, 0x72, 0x0b, 0xd2, 0x8d, 0x55, + /*5f20:*/ 0x74, 0x63, 0x66, 0x3f, 0x9b, 0xeb, 0x77, 0x17, 0xb9, 0x18, 0x9c, 0xc8, 0xb7, 0x9b, 0x52, 0x1c, + /*5f30:*/ 0xbd, 0xa9, 0xa1, 0x3d, 0x51, 0x7e, 0x9a, 0xf8, 0x94, 0x14, 0xb8, 0x59, 0xec, 0xe2, 0x2f, 0xf6, + /*5f40:*/ 0xdd, 0x8a, 0x44, 0x55, 0x72, 0xc8, 0x7b, 0xaf, 0xce, 0xd2, 0x85, 0xb8, 0x71, 0x2d, 0x2e, 0x9e, + /*5f50:*/ 0xcb, 0x22, 0xbf, 0xdb, 0xd3, 0x85, 0x08, 0x7c, 0x48, 0x06, 0xd7, 0xbe, 0x5a, 0xa6, 0x5a, 0xe5, + /*5f60:*/ 0x83, 0x6f, 0xbc, 0xc2, 0xf0, 0xce, 0xc1, 0x8c, 0x54, 0x5e, 0x01, 0x93, 0xc4, 0x48, 0x62, 0x29, + /*5f70:*/ 0xef, 0x74, 0x0a, 0x80, 0xb8, 0x03, 0x61, 0x67, 0x13, 0x38, 0xd5, 0x55, 0x89, 0xc1, 0x51, 0x06, + /*5f80:*/ 0x2f, 0xb6, 0x24, 0x34, 0xbe, 0x92, 0xc9, 0x9b, 0xa4, 0xc8, 0x50, 0x50, 0xb4, 0xf3, 0xba, 0xd3, + /*5f90:*/ 0x77, 0x18, 0xd1, 0x8d, 0x95, 0x11, 0x48, 0x0d, 0xbc, 0x2b, 0x0f, 0xee, 0x04, 0x6a, 0xd8, 0xa0, + /*5fa0:*/ 0x6a, 0xfb, 0x6e, 0xae, 0xac, 0x6c, 0xad, 0x4b, 0x66, 0x61, 0x35, 0x00, 0x29, 0x19, 0x31, 0x7d, + /*5fb0:*/ 0x67, 0x58, 0xd0, 0x95, 0x81, 0xfe, 0x31, 0x46, 0x91, 0xd8, 0xac, 0xb4, 0x5e, 0xbf, 0xf3, 0xfc, + /*5fc0:*/ 0x4a, 0xcc, 0x67, 0xc6, 0xbf, 0x89, 0xb9, 0x9a, 0x83, 0x3a, 0x6a, 0x00, 0xe3, 0x8e, 0x7f, 0x03, + /*5fd0:*/ 0xa2, 0xc6, 0x6e, 0x81, 0x9a, 0xd3, 0xf9, 0x9e, 0xb9, 0xe1, 0x15, 0x01, 0xb3, 0x6d, 0xc4, 0xea, + /*5fe0:*/ 0xa1, 0x3a, 0x29, 0x38, 0x64, 0x07, 0xeb, 0x7c, 0x96, 0x3c, 0x05, 0xc9, 0xee, 0x2c, 0x13, 0x91, + /*5ff0:*/ 0x30, 0x33, 0x84, 0x01, 0x31, 0xe0, 0xef, 0xe9, 0x31, 0x07, 0x59, 0x9b, 0xca, 0xc2, 0x73, 0xc1, + /*6000:*/ 0xbc, 0x1c, 0xd8, 0xc0, 0xce, 0x1d, 0xf4, 0x25, 0x2e, 0x88, 0xa1, 0xc1, 0x48, 0x98, 0x0c, 0xae, + /*6010:*/ 0x01, 0x9f, 0xe0, 0x94, 0x38, 0x4f, 0xd0, 0x8c, 0x36, 0x6b, 0x4d, 0xd5, 0x0b, 0x03, 0x8a, 0x5d, + /*6020:*/ 0x15, 0x3c, 0x3a, 0x09, 0x32, 0x95, 0xd8, 0xdb, 0x9f, 0xcf, 0x71, 0x67, 0x9b, 0xc6, 0xab, 0x87, + /*6030:*/ 0xd4, 0xfe, 0xad, 0xc2, 0xde, 0x17, 0x9c, 0xba, 0x4b, 0x1c, 0x73, 0x69, 0xe4, 0xa5, 0xc1, 0x90, + /*6040:*/ 0x2c, 0x25, 0xec, 0x91, 0x2e, 0xd9, 0x18, 0xe5, 0xa4, 0xfb, 0x4d, 0x6b, 0x31, 0x5d, 0xbb, 0xb5, + /*6050:*/ 0xb9, 0xe1, 0xdc, 0xf6, 0xcd, 0x88, 0x15, 0xbe, 0x82, 0xf7, 0x7e, 0x74, 0x9f, 0x67, 0x84, 0x38, + /*6060:*/ 0x60, 0x25, 0xa6, 0x22, 0x8a, 0xfa, 0xd1, 0x54, 0x9d, 0x4a, 0xab, 0x80, 0x8e, 0xf3, 0x46, 0x92, + /*6070:*/ 0x93, 0xd3, 0x56, 0xdf, 0x3c, 0xed, 0xfe, 0x16, 0x90, 0x7f, 0x22, 0xe8, 0xda, 0x79, 0xe3, 0x4d, + /*6080:*/ 0x32, 0x34, 0x05, 0xa4, 0x1e, 0xf8, 0xa1, 0xa4, 0x73, 0xe8, 0x3b, 0x94, 0xcc, 0xc5, 0x56, 0x86, + /*6090:*/ 0xd5, 0xc5, 0x52, 0x23, 0xf1, 0x3e, 0xbb, 0x73, 0x5f, 0x2e, 0xa4, 0x53, 0x18, 0x1d, 0xeb, 0xbc, + /*60a0:*/ 0xab, 0x38, 0x61, 0x83, 0x15, 0xcf, 0xbc, 0xff, 0xb7, 0x3e, 0x43, 0xa7, 0x48, 0x10, 0x64, 0x52, + /*60b0:*/ 0x3c, 0xae, 0x7c, 0x8f, 0xf0, 0x21, 0x96, 0x99, 0xc4, 0xc5, 0xaa, 0xfe, 0x96, 0xc0, 0x13, 0xa9, + /*60c0:*/ 0x91, 0xe2, 0xb3, 0x6b, 0x52, 0xea, 0x5f, 0xfa, 0xcd, 0xe3, 0x48, 0xd8, 0x8e, 0x8a, 0x8d, 0x8f, + /*60d0:*/ 0x89, 0x45, 0xf0, 0xcb, 0xc8, 0xc7, 0x21, 0x44, 0x22, 0xb3, 0xad, 0x68, 0x55, 0xd1, 0x59, 0xa6, + /*60e0:*/ 0xd0, 0x7e, 0xb2, 0xd3, 0xf1, 0xd1, 0x0a, 0x25, 0xc2, 0x3f, 0x3b, 0x40, 0x34, 0x03, 0x1e, 0xc3, + /*60f0:*/ 0x3c, 0x71, 0x70, 0xf8, 0x3a, 0x6a, 0x9d, 0x7c, 0x46, 0xbb, 0xd7, 0x79, 0x66, 0x6a, 0x3d, 0xb6, + /*6100:*/ 0x6f, 0x57, 0xa8, 0x22, 0xf3, 0x1e, 0x8c, 0x91, 0x44, 0x86, 0xa5, 0x91, 0xce, 0x11, 0x14, 0xc0, + /*6110:*/ 0x13, 0xaa, 0xaa, 0xbe, 0xb0, 0x7f, 0x2b, 0x6b, 0x12, 0x53, 0x75, 0x82, 0xcb, 0x1b, 0x56, 0xf8, + /*6120:*/ 0xc6, 0x1b, 0x83, 0x8c, 0x94, 0xd4, 0xfa, 0x0b, 0x2f, 0x90, 0x0d, 0xf0, 0x05, 0x80, 0xac, 0x2d, + /*6130:*/ 0xf2, 0x1c, 0x7a, 0x53, 0xce, 0x2a, 0xd2, 0xc8, 0xd7, 0x0c, 0x84, 0x60, 0xe1, 0x4d, 0xb1, 0x75, + /*6140:*/ 0x56, 0xc8, 0xf8, 0xab, 0x4d, 0x49, 0x16, 0x87, 0x41, 0x71, 0x1b, 0x0f, 0xed, 0x3a, 0xa6, 0xe4, + /*6150:*/ 0x92, 0x9e, 0xe7, 0xad, 0xb5, 0xb3, 0x0c, 0xa1, 0x7d, 0x00, 0x3d, 0x54, 0x11, 0xc6, 0x34, 0xb8, + /*6160:*/ 0x87, 0x2a, 0xb7, 0xf7, 0x56, 0xd1, 0x3e, 0x18, 0xa1, 0xcc, 0xc0, 0x71, 0x5d, 0xe3, 0x66, 0xf0, + /*6170:*/ 0xea, 0x05, 0xa4, 0xe2, 0x55, 0x77, 0x8c, 0x5c, 0xa5, 0xca, 0xb1, 0xae, 0xf4, 0x0f, 0xb3, 0x9d, + /*6180:*/ 0xb8, 0x0f, 0x1e, 0x0f, 0x8e, 0x5e, 0xbb, 0x0e, 0x26, 0x5e, 0x3a, 0xdc, 0xca, 0xb5, 0xa2, 0xad, + /*6190:*/ 0x1d, 0xfe, 0x65, 0x89, 0x4e, 0x67, 0x8c, 0xe3, 0xc6, 0x61, 0x0f, 0x28, 0x8c, 0x7a, 0xf0, 0x18, + /*61a0:*/ 0x26, 0xbd, 0x05, 0x5f, 0x08, 0xba, 0x7b, 0x76, 0xb3, 0xc0, 0x76, 0x52, 0xfe, 0xda, 0x9b, 0x79, + /*61b0:*/ 0xb9, 0x2b, 0x12, 0x05, 0xdf, 0x3f, 0xa3, 0x92, 0xff, 0x2f, 0x82, 0x65, 0x0c, 0xe6, 0x10, 0x26, + /*61c0:*/ 0x20, 0x3a, 0xbf, 0x49, 0x70, 0x40, 0x94, 0xd3, 0xc2, 0xd9, 0xf1, 0x66, 0xc4, 0x79, 0x57, 0xe6, + /*61d0:*/ 0xcd, 0x93, 0xd8, 0xc7, 0x21, 0xd0, 0x4d, 0x71, 0x39, 0x4c, 0xaf, 0xdf, 0xb8, 0x34, 0xa7, 0xdc, + /*61e0:*/ 0x94, 0x78, 0x2e, 0x1a, 0x6c, 0x1b, 0xb6, 0xe7, 0x18, 0x45, 0xb7, 0x05, 0xe9, 0x12, 0x20, 0x95, + /*61f0:*/ 0xa2, 0x6c, 0x35, 0x27, 0xaf, 0xdf, 0xed, 0x1f, 0x70, 0xd5, 0x74, 0x44, 0x65, 0x54, 0x38, 0x12, + /*6200:*/ 0x9c, 0xe8, 0x59, 0x3f, 0x9a, 0x07, 0x44, 0x32, 0xa7, 0x4b, 0x0a, 0xe5, 0x1d, 0x08, 0x82, 0x86, + /*6210:*/ 0xcf, 0x99, 0x47, 0x8d, 0xb4, 0x29, 0xa4, 0x96, 0x3f, 0x65, 0x8e, 0xaf, 0xb4, 0x44, 0xe9, 0x69, + /*6220:*/ 0x1e, 0xe8, 0xc8, 0xcb, 0x67, 0xd9, 0x78, 0x2e, 0xbb, 0x11, 0x72, 0xed, 0x4f, 0xe5, 0x95, 0xad, + /*6230:*/ 0x13, 0xc9, 0x68, 0x0c, 0x0e, 0xe4, 0xde, 0xcf, 0xb1, 0x65, 0xc5, 0x36, 0xe9, 0xeb, 0x25, 0xe7, + /*6240:*/ 0xdf, 0xe5, 0x02, 0x09, 0x31, 0x37, 0x99, 0x7a, 0xe3, 0xe5, 0x34, 0xf6, 0xea, 0x6e, 0xcc, 0x39, + /*6250:*/ 0x64, 0xbe, 0xb3, 0xd3, 0x0f, 0xf2, 0x7e, 0x18, 0xba, 0x53, 0x35, 0x19, 0x3f, 0x9f, 0x5a, 0x80, + /*6260:*/ 0x2a, 0xbb, 0x7e, 0x92, 0x31, 0xfd, 0x2a, 0x66, 0xee, 0x54, 0xd0, 0x32, 0xa3, 0x53, 0x2d, 0xfc, + /*6270:*/ 0xf5, 0x59, 0x13, 0xe1, 0xb0, 0xe9, 0x31, 0x07, 0x19, 0xe5, 0x08, 0x8e, 0x24, 0x87, 0x39, 0x8b, + /*6280:*/ 0xb2, 0xa8, 0xde, 0x81, 0xaa, 0x47, 0x5b, 0x9a, 0x41, 0xd5, 0xda, 0xb9, 0x61, 0x59, 0x4f, 0x30, + /*6290:*/ 0x25, 0xa3, 0x56, 0x4f, 0x9b, 0x9e, 0x63, 0x96, 0x75, 0xba, 0xfd, 0xf0, 0x4b, 0x64, 0x73, 0xbb, + /*62a0:*/ 0xa2, 0x96, 0x5b, 0xbf, 0xce, 0xc3, 0xa1, 0xa8, 0x90, 0xc9, 0x19, 0xf7, 0xb1, 0x82, 0xb7, 0xcc, + /*62b0:*/ 0xb1, 0x57, 0xa0, 0x13, 0x7c, 0x60, 0x34, 0x32, 0x65, 0xba, 0xf2, 0x5f, 0x41, 0xdc, 0x00, 0xd1, + /*62c0:*/ 0x5a, 0x38, 0xb6, 0x4f, 0x4d, 0xec, 0x18, 0x31, 0xc3, 0x8b, 0xaa, 0x06, 0xda, 0x2f, 0x2e, 0x7c, + /*62d0:*/ 0x2b, 0x57, 0x29, 0x81, 0x43, 0xb2, 0xca, 0xb9, 0x61, 0x2c, 0x94, 0x5e, 0x8e, 0xa2, 0x33, 0x80, + /*62e0:*/ 0x0a, 0x4b, 0x58, 0xa7, 0x1c, 0xf7, 0x0d, 0xc0, 0x1a, 0x61, 0x14, 0xf8, 0x82, 0x57, 0x5b, 0x0d, + /*62f0:*/ 0x17, 0x71, 0x8d, 0xf9, 0x42, 0x9a, 0x41, 0x1f, 0x84, 0x98, 0xcb, 0x38, 0x25, 0x4a, 0xb9, 0x0a, + /*6300:*/ 0xf1, 0xfc, 0x94, 0x14, 0x21, 0x51, 0xe3, 0xe5, 0x1a, 0xd9, 0x70, 0x31, 0x1a, 0x84, 0xaf, 0x08, + /*6310:*/ 0x20, 0x9f, 0x96, 0x61, 0x84, 0xf5, 0xfb, 0xfc, 0x4f, 0xf0, 0xb7, 0xcc, 0xef, 0x99, 0xb9, 0x6d, + /*6320:*/ 0x95, 0x11, 0x57, 0x20, 0x62, 0x62, 0xa8, 0xfb, 0xec, 0xf1, 0x0f, 0xcc, 0xc9, 0xf0, 0x63, 0xb8, + /*6330:*/ 0x59, 0xa4, 0xf8, 0xb0, 0xfd, 0xf6, 0xe2, 0x61, 0x45, 0x9b, 0xb4, 0x18, 0xf5, 0xe5, 0x9f, 0x3e, + /*6340:*/ 0x97, 0xe7, 0x3f, 0x08, 0xf7, 0x63, 0x9b, 0x71, 0x4f, 0x06, 0x95, 0x66, 0xa7, 0x2e, 0xa1, 0xa3, + /*6350:*/ 0xef, 0x22, 0xf7, 0x82, 0x00, 0xf8, 0xc6, 0x04, 0x03, 0xf6, 0x90, 0x4d, 0xd2, 0xe7, 0xb2, 0xda, + /*6360:*/ 0xeb, 0x4b, 0xff, 0x40, 0x33, 0x28, 0xed, 0x33, 0x81, 0x9e, 0xfa, 0x18, 0x43, 0xac, 0x82, 0x99, + /*6370:*/ 0x09, 0xa5, 0x7c, 0xd7, 0xc0, 0xf2, 0x9a, 0xeb, 0xb4, 0xb6, 0x18, 0x9a, 0x9c, 0x8e, 0x5e, 0xed, + /*6380:*/ 0x49, 0x18, 0xb6, 0x14, 0x74, 0x3b, 0x19, 0x2d, 0xa0, 0xdf, 0xc0, 0xa3, 0x56, 0x6b, 0x17, 0x80, + /*6390:*/ 0x40, 0x36, 0x2f, 0x5b, 0xf8, 0xc0, 0x39, 0x0b, 0x64, 0x73, 0x31, 0x15, 0x0f, 0x54, 0x3d, 0x52, + /*63a0:*/ 0x39, 0x99, 0xe3, 0x37, 0xaf, 0xae, 0xaa, 0xf2, 0x1e, 0xc4, 0x53, 0x41, 0xa8, 0x41, 0x82, 0x5c, + /*63b0:*/ 0xde, 0x4a, 0xef, 0xa9, 0x4b, 0x31, 0xfe, 0xdb, 0x5a, 0x2d, 0x55, 0xa2, 0x5a, 0x84, 0xda, 0xfc, + /*63c0:*/ 0x47, 0xbc, 0x8c, 0x5f, 0x6c, 0x30, 0x6f, 0xb7, 0xb0, 0x57, 0xe2, 0xe3, 0x30, 0x75, 0xae, 0x9d, + /*63d0:*/ 0x78, 0xd5, 0x98, 0x44, 0xee, 0x86, 0x44, 0x3c, 0xfd, 0x18, 0x0d, 0x5c, 0x16, 0x86, 0x04, 0xdb, + /*63e0:*/ 0x8a, 0xda, 0x0c, 0x37, 0xef, 0xb1, 0xea, 0xe5, 0x7c, 0x10, 0x6a, 0x17, 0x01, 0xd4, 0x44, 0x4e, + /*63f0:*/ 0xf3, 0xb3, 0x47, 0xce, 0x10, 0x78, 0x6e, 0x69, 0x98, 0x3e, 0x61, 0x21, 0xde, 0x65, 0x50, 0xb4, + /*6400:*/ 0x2e, 0x08, 0x08, 0x6b, 0xef, 0x25, 0x1b, 0x9d, 0x68, 0xee, 0xd0, 0xce, 0xd5, 0x36, 0xb0, 0xcd, + /*6410:*/ 0x4e, 0x0c, 0x19, 0x59, 0x57, 0xd8, 0xa1, 0x69, 0xe5, 0x1f, 0xba, 0x8d, 0x28, 0xa4, 0xe0, 0x56, + /*6420:*/ 0xdf, 0xab, 0xd0, 0x2a, 0x27, 0x60, 0xd3, 0xa1, 0x69, 0xbb, 0x77, 0xe5, 0xef, 0xa8, 0x99, 0xb4, + /*6430:*/ 0x3f, 0xc1, 0x09, 0x72, 0x69, 0xe9, 0x73, 0x5b, 0x59, 0x48, 0x4c, 0x1d, 0x9d, 0x73, 0xb6, 0x8e, + /*6440:*/ 0x2a, 0x66, 0x7e, 0xf5, 0xaf, 0x12, 0x69, 0xcf, 0x61, 0xbd, 0xd3, 0x84, 0xd3, 0x3a, 0xe4, 0xbf, + /*6450:*/ 0x7f, 0xeb, 0x21, 0x59, 0x72, 0x7c, 0xa6, 0x89, 0x6b, 0x2e, 0xc9, 0x46, 0xa8, 0x05, 0xc9, 0xf9, + /*6460:*/ 0x7a, 0x25, 0x27, 0xb8, 0xda, 0x80, 0xf6, 0xa7, 0x69, 0x28, 0x06, 0x5d, 0x8e, 0xa6, 0x0d, 0x3c, + /*6470:*/ 0x7b, 0x2a, 0xce, 0x1a, 0x13, 0x53, 0x98, 0x85, 0x1f, 0xc9, 0xce, 0xd0, 0xd4, 0x76, 0x6d, 0x6e, + /*6480:*/ 0xa9, 0x4e, 0x5a, 0x44, 0xc2, 0xb4, 0x6f, 0x5e, 0xe8, 0x8c, 0x88, 0xfb, 0xe2, 0x1e, 0x4b, 0x1a, + /*6490:*/ 0xa9, 0x55, 0x09, 0x70, 0x73, 0xf9, 0x4f, 0xd4, 0x4a, 0x53, 0xaa, 0x7e, 0x67, 0xe5, 0x61, 0x13, + /*64a0:*/ 0x53, 0xfc, 0xef, 0xe6, 0x82, 0x6a, 0xdf, 0x82, 0x87, 0x93, 0x8f, 0x85, 0x7a, 0x8e, 0x7a, 0xb9, + /*64b0:*/ 0xd8, 0xf9, 0xac, 0x79, 0x2c, 0x87, 0x9f, 0x40, 0x9a, 0xe3, 0x8b, 0xbd, 0x15, 0xaf, 0x70, 0xfb, + /*64c0:*/ 0x7f, 0x80, 0x74, 0x6c, 0x94, 0x02, 0x0d, 0xd2, 0x41, 0x7f, 0xe2, 0x38, 0xcb, 0xfe, 0x99, 0xef, + /*64d0:*/ 0xd7, 0x0e, 0x74, 0x93, 0x66, 0xae, 0xa7, 0x10, 0x42, 0x10, 0xf6, 0x77, 0x5e, 0x16, 0xe7, 0x4c, + /*64e0:*/ 0x41, 0x51, 0xc8, 0x80, 0x6c, 0xaf, 0xb9, 0xb6, 0x91, 0x17, 0xb3, 0xba, 0x00, 0x07, 0xe4, 0xd1, + /*64f0:*/ 0x89, 0x05, 0x31, 0xc9, 0x6c, 0x5a, 0x8f, 0x4c, 0xd2, 0x03, 0xe7, 0x79, 0x65, 0xfb, 0x6a, 0x60, + /*6500:*/ 0x6c, 0x1d, 0x88, 0x94, 0xf3, 0xc0, 0x15, 0xd0, 0xc3, 0xad, 0x93, 0x81, 0xee, 0x3e, 0x48, 0x9b, + /*6510:*/ 0xa7, 0xe8, 0x9b, 0x26, 0x55, 0x97, 0xcd, 0x15, 0xc1, 0xf0, 0x97, 0xb0, 0x47, 0x42, 0xba, 0xea, + /*6520:*/ 0x04, 0x2e, 0x31, 0xf8, 0xb3, 0xf5, 0xcb, 0xa4, 0xec, 0xf5, 0x59, 0xe4, 0x8f, 0x03, 0x69, 0x85, + /*6530:*/ 0x94, 0x55, 0x00, 0xeb, 0xa5, 0x15, 0xca, 0xe2, 0xac, 0xc7, 0xfb, 0x79, 0x23, 0xbc, 0x60, 0x2b, + /*6540:*/ 0x87, 0xcc, 0x55, 0xc5, 0xe8, 0x79, 0xd0, 0x1e, 0x4b, 0xde, 0xf6, 0xf0, 0x26, 0x87, 0x88, 0x29, + /*6550:*/ 0xf4, 0x78, 0x77, 0x42, 0xaf, 0x38, 0x53, 0xc4, 0x91, 0x7b, 0xf0, 0x2d, 0x12, 0x2d, 0xa3, 0x15, + /*6560:*/ 0xaf, 0x2d, 0x0d, 0xd1, 0xc5, 0x07, 0x55, 0x03, 0x8c, 0x1a, 0x51, 0x5d, 0x1c, 0xcb, 0xd2, 0xd5, + /*6570:*/ 0x6a, 0x9b, 0x6e, 0x48, 0x35, 0x7d, 0xd0, 0xc0, 0x45, 0x8f, 0x14, 0xca, 0x74, 0x9f, 0x84, 0xf8, + /*6580:*/ 0xd3, 0xd3, 0xe6, 0x14, 0x66, 0xc6, 0x8c, 0xde, 0x3b, 0x54, 0x33, 0x69, 0x20, 0x23, 0x60, 0x3d, + /*6590:*/ 0xc4, 0xd5, 0x7c, 0xc6, 0xa9, 0xd9, 0xf0, 0xbd, 0x4b, 0xbd, 0x0d, 0x5c, 0xea, 0x74, 0x0a, 0x6a, + /*65a0:*/ 0x17, 0x0d, 0x71, 0xfd, 0x9b, 0xa9, 0x0a, 0x1c, 0x80, 0xf6, 0x2a, 0xd9, 0xf7, 0x2f, 0x1b, 0x41, + /*65b0:*/ 0x06, 0x09, 0x10, 0x95, 0xfc, 0xbd, 0xe4, 0x81, 0x54, 0x47, 0x0e, 0xfd, 0xca, 0xe5, 0x6f, 0x49, + /*65c0:*/ 0x39, 0xe7, 0xb4, 0xea, 0x75, 0x3c, 0x02, 0x76, 0xb5, 0xa8, 0x0e, 0x4b, 0x81, 0x2d, 0xbc, 0x9d, + /*65d0:*/ 0xc9, 0x88, 0xea, 0x8f, 0xde, 0x8d, 0xdb, 0x69, 0x91, 0x6b, 0x30, 0xbf, 0xdb, 0x43, 0x57, 0xa3, + /*65e0:*/ 0xd2, 0xde, 0x8b, 0x8e, 0xaa, 0xc0, 0x46, 0xb5, 0x09, 0x61, 0xfd, 0x92, 0x11, 0x78, 0x73, 0xed, + /*65f0:*/ 0x89, 0xa3, 0xf9, 0x33, 0xd8, 0x5f, 0xbe, 0x1c, 0x82, 0x6c, 0xd1, 0xd0, 0x58, 0xb5, 0x72, 0x43, + /*6600:*/ 0x37, 0xd6, 0xca, 0x98, 0x30, 0x9c, 0x29, 0xae, 0x11, 0x14, 0x73, 0x17, 0x6d, 0x10, 0xea, 0xa6, + /*6610:*/ 0x2d, 0xf3, 0x1b, 0xe4, 0xd2, 0xba, 0x01, 0x52, 0x4b, 0xe9, 0x54, 0xb5, 0x3f, 0x9c, 0xb4, 0x9e, + /*6620:*/ 0xac, 0xe0, 0x93, 0x6d, 0xdc, 0x1d, 0xfa, 0xf7, 0x04, 0x8f, 0x4a, 0x7e, 0x97, 0xf3, 0x01, 0x38, + /*6630:*/ 0x2f, 0xa2, 0x3d, 0xcf, 0xd1, 0x4c, 0x6c, 0x57, 0xb5, 0x8e, 0xb3, 0x59, 0xdd, 0x84, 0x8c, 0x1a, + /*6640:*/ 0xaa, 0xc4, 0x9a, 0x6d, 0x7d, 0xd2, 0xf3, 0x5f, 0x60, 0x2d, 0xd3, 0xc3, 0xdb, 0x3c, 0xef, 0xea, + /*6650:*/ 0x0c, 0x99, 0x3a, 0xd0, 0xb5, 0xbb, 0xda, 0xcc, 0x35, 0xce, 0x81, 0xc1, 0x15, 0x61, 0x2d, 0x7c, + /*6660:*/ 0x20, 0xb1, 0x2a, 0x4c, 0x19, 0x79, 0xff, 0xe7, 0xfd, 0xa2, 0x7c, 0xd4, 0x81, 0xef, 0xd6, 0xc7, + /*6670:*/ 0x89, 0xfd, 0x67, 0x8f, 0xa0, 0x64, 0xb9, 0x84, 0x68, 0x87, 0xa2, 0x7d, 0x21, 0xa9, 0xd4, 0x28, + /*6680:*/ 0x89, 0x0d, 0x62, 0x08, 0x25, 0xb6, 0x41, 0x9f, 0x0c, 0x3b, 0xdf, 0x0d, 0x86, 0x9c, 0xbd, 0x16, + /*6690:*/ 0x6f, 0x03, 0x1b, 0xd8, 0x1c, 0x00, 0x91, 0x14, 0xc1, 0x3a, 0x45, 0x96, 0xa4, 0x4c, 0xa3, 0x27, + /*66a0:*/ 0x31, 0x4d, 0xf7, 0x8b, 0x69, 0xdc, 0xab, 0x4e, 0x91, 0xb7, 0x68, 0x46, 0x52, 0x04, 0xb4, 0xf0, + /*66b0:*/ 0xa3, 0x7d, 0xf2, 0xa3, 0x14, 0xb4, 0x12, 0xda, 0xa1, 0xb4, 0xa9, 0x6b, 0x22, 0x49, 0x0c, 0xaa, + /*66c0:*/ 0x1a, 0x95, 0x57, 0x4c, 0x6c, 0x0b, 0x72, 0x36, 0xf9, 0x02, 0x41, 0x17, 0xc9, 0x70, 0x7e, 0x10, + /*66d0:*/ 0xce, 0x4c, 0xd2, 0xa0, 0x46, 0xac, 0x64, 0x5a, 0x53, 0x12, 0x5a, 0xd1, 0x4b, 0x5c, 0x87, 0xa0, + /*66e0:*/ 0xb6, 0xc9, 0xf5, 0x6e, 0xa2, 0xbb, 0x3b, 0x6c, 0x55, 0x67, 0x73, 0xe2, 0x01, 0x5d, 0xac, 0x26, + /*66f0:*/ 0xad, 0x79, 0xc4, 0x56, 0x2c, 0x33, 0x66, 0x7b, 0xb9, 0xdf, 0x4f, 0x9e, 0xe5, 0x13, 0xb8, 0xf0, + /*6700:*/ 0x70, 0x53, 0x59, 0xa0, 0xc2, 0x74, 0xc5, 0xeb, 0x76, 0x4e, 0x1c, 0x0d, 0xfe, 0x98, 0x05, 0x57, + /*6710:*/ 0xd5, 0xbe, 0x81, 0xb2, 0x67, 0x0a, 0xcc, 0xde, 0xc1, 0x4e, 0x07, 0x80, 0x34, 0xee, 0x20, 0x93, + /*6720:*/ 0xbd, 0xc1, 0xd6, 0x72, 0x47, 0x17, 0xe0, 0x27, 0x90, 0xca, 0x97, 0x0e, 0x0f, 0x6c, 0xcc, 0xe2, + /*6730:*/ 0x97, 0x47, 0x49, 0x0c, 0x73, 0xaf, 0x47, 0x8d, 0x8a, 0x2a, 0x6e, 0xfb, 0x79, 0x81, 0xe2, 0xc8, + /*6740:*/ 0x97, 0x9f, 0x7e, 0x9b, 0xf4, 0x9a, 0x8f, 0x10, 0x75, 0x23, 0x4a, 0xb9, 0xbd, 0x0d, 0x25, 0xa1, + /*6750:*/ 0x50, 0xdf, 0x40, 0x23, 0xbf, 0x1c, 0x83, 0xcd, 0x4c, 0xb7, 0xa3, 0x51, 0x7f, 0xca, 0x44, 0x23, + /*6760:*/ 0xbe, 0xd8, 0x74, 0x8a, 0x4c, 0xb3, 0x72, 0x93, 0xaa, 0x9a, 0x32, 0x11, 0xc1, 0x4b, 0x9b, 0x96, + /*6770:*/ 0x88, 0x61, 0xc7, 0x22, 0xa3, 0x6c, 0x28, 0xf1, 0x17, 0xa5, 0x02, 0x5e, 0x6d, 0x71, 0x44, 0xe7, + /*6780:*/ 0xa6, 0x63, 0x9e, 0xee, 0xc6, 0xef, 0xc0, 0x18, 0xf8, 0xea, 0xf8, 0x78, 0x73, 0x8f, 0xae, 0xed, + /*6790:*/ 0xb3, 0x5b, 0x80, 0x12, 0x5b, 0x47, 0x48, 0x54, 0x3a, 0xf3, 0xaf, 0x37, 0x14, 0xc3, 0x8c, 0x09, + /*67a0:*/ 0x1e, 0x11, 0xb5, 0xc2, 0x82, 0xef, 0x31, 0x36, 0xe6, 0x73, 0xbe, 0xea, 0x98, 0x4f, 0x14, 0x17, + /*67b0:*/ 0x1d, 0xbb, 0x89, 0xba, 0x95, 0xf6, 0x79, 0xa9, 0x71, 0xc0, 0x47, 0xf1, 0x86, 0x18, 0x7c, 0x74, + /*67c0:*/ 0x18, 0x27, 0xb7, 0x28, 0x27, 0xf6, 0x2a, 0x4a, 0xcc, 0x8e, 0x7a, 0x0f, 0x90, 0x65, 0x9a, 0xc0, + /*67d0:*/ 0xd1, 0xba, 0xf3, 0xd8, 0x49, 0x6a, 0x88, 0x68, 0x41, 0xaa, 0xb9, 0x28, 0xfe, 0x4f, 0xe4, 0x3e, + /*67e0:*/ 0x1b, 0xc8, 0xa2, 0x0f, 0x38, 0x8d, 0x7b, 0x63, 0xee, 0x46, 0xbd, 0xa2, 0x75, 0xb3, 0x27, 0x35, + /*67f0:*/ 0x72, 0xa7, 0xd4, 0xdd, 0xea, 0xdb, 0xb6, 0x1a, 0x65, 0x39, 0xce, 0xc3, 0x83, 0x65, 0x2d, 0x83, + /*6800:*/ 0xb0, 0xf1, 0xd9, 0xa1, 0xb0, 0x48, 0x0f, 0x55, 0x48, 0x3b, 0x78, 0x98, 0xc9, 0x3a, 0x93, 0xbc, + /*6810:*/ 0xdb, 0x43, 0x32, 0x27, 0xf6, 0xba, 0xb7, 0xb7, 0x99, 0x11, 0x04, 0xa9, 0x4f, 0x8f, 0x89, 0x30, + /*6820:*/ 0x19, 0xad, 0x0d, 0x30, 0xfd, 0x02, 0xfa, 0x87, 0x73, 0xc1, 0x18, 0x07, 0x51, 0x54, 0x1b, 0xdf, + /*6830:*/ 0xae, 0xfd, 0x6f, 0x62, 0x23, 0x0b, 0x7b, 0xfb, 0x8a, 0xf8, 0x2b, 0xcc, 0x69, 0x0e, 0x56, 0x6d, + /*6840:*/ 0x35, 0x9d, 0xbd, 0x71, 0x51, 0xa7, 0xd9, 0xeb, 0x34, 0x9a, 0x95, 0x9d, 0x52, 0x71, 0x3e, 0x04, + /*6850:*/ 0x9f, 0x20, 0xfb, 0xf8, 0x6a, 0xf7, 0x7d, 0x3e, 0x1f, 0xeb, 0x71, 0xe4, 0xf1, 0xbf, 0xb8, 0xb9, + /*6860:*/ 0x62, 0x70, 0x84, 0x87, 0xdc, 0x9e, 0xaf, 0x21, 0xd7, 0xa3, 0x58, 0x03, 0x90, 0x9e, 0xcb, 0x9f, + /*6870:*/ 0x5d, 0x48, 0xfb, 0xb7, 0xa6, 0x0e, 0x94, 0xb2, 0xaa, 0x4a, 0xb5, 0x7e, 0xfc, 0x6b, 0xd1, 0x59, + /*6880:*/ 0x80, 0xec, 0xb0, 0x91, 0x68, 0x62, 0xd1, 0x93, 0x25, 0x70, 0xf7, 0x47, 0x31, 0x69, 0xc9, 0x05, + /*6890:*/ 0x31, 0x5b, 0x97, 0x48, 0x28, 0xee, 0xb0, 0x77, 0xac, 0x56, 0xde, 0xb0, 0x5f, 0x14, 0x19, 0x58, + /*68a0:*/ 0x1f, 0xd1, 0x31, 0xf6, 0x02, 0xcb, 0x81, 0x6a, 0xac, 0x57, 0x62, 0xea, 0xb9, 0xf0, 0x8f, 0xfd, + /*68b0:*/ 0x78, 0xbf, 0xbc, 0x3b, 0xf2, 0x41, 0x2c, 0xff, 0x6e, 0x83, 0x5d, 0xde, 0x22, 0x7b, 0x48, 0x65, + /*68c0:*/ 0xac, 0x72, 0xce, 0x12, 0xcf, 0x0c, 0x27, 0x9b, 0xd5, 0x8d, 0xf3, 0x32, 0x1a, 0x4f, 0x67, 0xa6, + /*68d0:*/ 0xeb, 0x6a, 0x4c, 0xc8, 0x81, 0x35, 0xd0, 0x22, 0x75, 0xc9, 0xd1, 0x29, 0x8e, 0x42, 0x73, 0x99, + /*68e0:*/ 0xdd, 0x50, 0x7e, 0x3c, 0xcb, 0x5f, 0xca, 0xbf, 0x8d, 0x66, 0x13, 0x0e, 0x19, 0x01, 0x58, 0x2d, + /*68f0:*/ 0x16, 0x91, 0xb4, 0x40, 0xba, 0xed, 0x9a, 0x02, 0x04, 0xa3, 0x82, 0x14, 0x9d, 0x8b, 0xcc, 0xd5, + /*6900:*/ 0xf5, 0x6f, 0x78, 0x60, 0xe5, 0x8b, 0x06, 0xc7, 0xf0, 0xb0, 0x5d, 0xd7, 0x2e, 0x0f, 0xa0, 0x6b, + /*6910:*/ 0x39, 0xcd, 0xb4, 0x2a, 0x2d, 0x81, 0x97, 0xa1, 0xab, 0x07, 0x8c, 0x7e, 0xbc, 0x68, 0x13, 0x38, + /*6920:*/ 0x85, 0x0a, 0x88, 0x17, 0xf3, 0xba, 0xbf, 0x58, 0x9c, 0xbe, 0x43, 0x3d, 0x36, 0xc3, 0x92, 0x8c, + /*6930:*/ 0x31, 0x90, 0xe3, 0x05, 0x3f, 0x6a, 0x25, 0x6e, 0x65, 0xd7, 0x62, 0x60, 0x6e, 0x79, 0x02, 0x62, + /*6940:*/ 0xec, 0xd5, 0x9b, 0x99, 0xe4, 0x30, 0xd8, 0xf1, 0x99, 0x45, 0x9d, 0xfb, 0x62, 0x5a, 0x3f, 0x3e, + /*6950:*/ 0x2d, 0x75, 0x94, 0x5c, 0x04, 0x31, 0xc0, 0x56, 0xeb, 0x37, 0x29, 0x60, 0x3c, 0x29, 0x63, 0x54, + /*6960:*/ 0x24, 0x1f, 0x34, 0xd3, 0x81, 0x5c, 0x2b, 0x07, 0x78, 0x6a, 0xab, 0x85, 0x02, 0x50, 0xd3, 0x0f, + /*6970:*/ 0x0f, 0x94, 0x3b, 0x33, 0x9a, 0xcc, 0x99, 0xad, 0xcc, 0xfc, 0xa3, 0xdf, 0xc9, 0xe7, 0x90, 0xb7, + /*6980:*/ 0xc1, 0x76, 0xb5, 0x01, 0x66, 0xa1, 0x33, 0x38, 0x26, 0xa6, 0xbb, 0xff, 0xaf, 0x10, 0x27, 0x0a, + /*6990:*/ 0x96, 0x6b, 0x1d, 0x74, 0xb1, 0x7d, 0xa9, 0x17, 0x5c, 0x4f, 0x2d, 0x2e, 0x69, 0xaa, 0xb6, 0x4f, + /*69a0:*/ 0x95, 0xa7, 0x90, 0xcd, 0x1b, 0x60, 0xb0, 0x68, 0x93, 0x91, 0xba, 0x34, 0xa8, 0x2d, 0xe4, 0xfe, + /*69b0:*/ 0xa0, 0x8b, 0x9e, 0x82, 0x77, 0x7a, 0xe3, 0x32, 0xc1, 0x8c, 0x50, 0xdf, 0x49, 0x5f, 0x57, 0xd4, + /*69c0:*/ 0x55, 0xe4, 0x25, 0xf0, 0x07, 0x91, 0xaa, 0x77, 0x9b, 0xf9, 0x99, 0xfb, 0x98, 0xd0, 0x01, 0xf8, + /*69d0:*/ 0x6b, 0x14, 0xd3, 0xc1, 0x2d, 0xcb, 0x3e, 0xb7, 0xd5, 0xe8, 0x61, 0x20, 0xbd, 0xa5, 0xe3, 0xe0, + /*69e0:*/ 0x11, 0x6e, 0x3b, 0xe5, 0x6e, 0xe0, 0xdc, 0x2f, 0x4c, 0x8b, 0x14, 0xa7, 0x08, 0x93, 0xcd, 0xf3, + /*69f0:*/ 0x5c, 0x8e, 0x30, 0xab, 0x09, 0x36, 0x70, 0xe9, 0x0c, 0x09, 0x93, 0x45, 0xad, 0x2a, 0x6c, 0xdf, + /*6a00:*/ 0x30, 0xe9, 0x50, 0xae, 0x8b, 0x94, 0x5f, 0x20, 0x52, 0xf1, 0x91, 0x22, 0x07, 0xb6, 0x3a, 0x14, + /*6a10:*/ 0xa1, 0x33, 0x78, 0x80, 0xa6, 0x49, 0x08, 0xbf, 0xfc, 0xc2, 0x4c, 0x49, 0xee, 0x93, 0x33, 0x77, + /*6a20:*/ 0xfd, 0x7d, 0xb6, 0x3d, 0x23, 0x8f, 0x5a, 0x90, 0xa0, 0xe0, 0x3c, 0xc9, 0x93, 0x97, 0x00, 0x16, + /*6a30:*/ 0xc2, 0xeb, 0x9b, 0xfa, 0x24, 0x04, 0xc7, 0x9e, 0x46, 0xbf, 0x14, 0xa7, 0x97, 0x03, 0x5d, 0x25, + /*6a40:*/ 0x08, 0xb2, 0xf4, 0xa0, 0x1e, 0xe5, 0x47, 0x36, 0x64, 0x7e, 0xab, 0x5d, 0xa8, 0x04, 0x18, 0x84, + /*6a50:*/ 0x8e, 0x3d, 0x96, 0xa8, 0xc9, 0xfb, 0xe0, 0x1f, 0x8d, 0xa8, 0x77, 0x73, 0xe5, 0x6c, 0xcf, 0xbf, + /*6a60:*/ 0x65, 0x9c, 0x73, 0x73, 0xed, 0x36, 0x18, 0xbd, 0xcb, 0xd0, 0xb2, 0x87, 0xea, 0x0a, 0x18, 0xf5, + /*6a70:*/ 0x7c, 0x0f, 0xf7, 0x6b, 0x35, 0x4f, 0xd9, 0x07, 0x8a, 0xa1, 0xa4, 0x21, 0x40, 0x81, 0x75, 0xff, + /*6a80:*/ 0x73, 0xeb, 0xcb, 0xda, 0x30, 0x09, 0xd5, 0x2a, 0x30, 0x5c, 0xd7, 0x86, 0x72, 0xe5, 0xc9, 0x31, + /*6a90:*/ 0xca, 0x91, 0xc9, 0x90, 0x48, 0xae, 0x14, 0x59, 0xc3, 0x7e, 0x82, 0xb6, 0x9d, 0x56, 0x10, 0x59, + /*6aa0:*/ 0xd7, 0x14, 0xbb, 0x47, 0x61, 0xd8, 0x53, 0x2b, 0x56, 0x62, 0xf2, 0x8f, 0x84, 0x58, 0x1b, 0xfb, + /*6ab0:*/ 0x95, 0x8d, 0x29, 0x78, 0xf5, 0x35, 0xeb, 0xe0, 0xe1, 0x1e, 0x9b, 0x66, 0x5f, 0xbd, 0xf9, 0x8f, + /*6ac0:*/ 0x3d, 0x12, 0x95, 0xb2, 0xbb, 0x75, 0x84, 0x36, 0x51, 0x33, 0xfa, 0x5a, 0x32, 0x16, 0x93, 0x12, + /*6ad0:*/ 0x12, 0x31, 0xb5, 0x48, 0x14, 0xb4, 0xdc, 0xcb, 0xb3, 0x38, 0xa7, 0x0b, 0x60, 0x56, 0xfa, 0x73, + /*6ae0:*/ 0x28, 0x5d, 0xcf, 0x1b, 0x56, 0x4d, 0x6f, 0xea, 0xea, 0xbd, 0xfc, 0xe6, 0x3c, 0x5c, 0x41, 0x8a, + /*6af0:*/ 0x3f, 0x6c, 0xfc, 0x7d, 0x8b, 0x66, 0x4d, 0x51, 0x8d, 0x71, 0x0e, 0xbf, 0xdd, 0xa1, 0x1e, 0x92, + /*6b00:*/ 0x7c, 0x4e, 0xd4, 0x6e, 0x0c, 0xaa, 0x50, 0x96, 0xce, 0x90, 0x55, 0xcb, 0x86, 0x24, 0xf2, 0x33, + /*6b10:*/ 0xab, 0x9b, 0xc6, 0x60, 0x0d, 0x7f, 0x5b, 0x94, 0x16, 0xd3, 0x55, 0xb7, 0xb4, 0x9e, 0xfe, 0xf0, + /*6b20:*/ 0xdc, 0xae, 0x2c, 0xc5, 0x24, 0x0f, 0x7e, 0x99, 0xe4, 0x77, 0x0e, 0x96, 0x90, 0xe8, 0x39, 0xac, + /*6b30:*/ 0x8a, 0x53, 0xfb, 0xe8, 0x75, 0x24, 0x69, 0x6f, 0xb2, 0x11, 0x2a, 0x45, 0x2d, 0x2f, 0x87, 0xac, + /*6b40:*/ 0xfa, 0xea, 0xd5, 0x70, 0x98, 0x39, 0xdb, 0x81, 0xcd, 0x56, 0xdd, 0x4f, 0xdf, 0x78, 0xe1, 0x2c, + /*6b50:*/ 0xab, 0x35, 0x54, 0x37, 0x11, 0xf7, 0x23, 0x31, 0xda, 0xb1, 0xd8, 0x76, 0x2e, 0x86, 0xaa, 0xc7, + /*6b60:*/ 0x8e, 0x73, 0x6a, 0xba, 0x2a, 0x98, 0xd3, 0x6b, 0x8a, 0x1f, 0x1d, 0xd3, 0xe9, 0x04, 0x3f, 0xf0, + /*6b70:*/ 0xdb, 0xb8, 0x06, 0xd9, 0xae, 0x7e, 0xcb, 0xbf, 0x3d, 0x85, 0xa6, 0x10, 0x30, 0xbc, 0x04, 0x96, + /*6b80:*/ 0x2a, 0xc8, 0x89, 0xa9, 0xa6, 0x14, 0xdc, 0x75, 0x4d, 0x5a, 0xe5, 0x4a, 0x89, 0x49, 0x58, 0x1a, + /*6b90:*/ 0x4a, 0x07, 0x55, 0x28, 0xd8, 0x5a, 0x12, 0xa0, 0x97, 0x0e, 0xcb, 0x3b, 0x70, 0xb1, 0xa9, 0xaf, + /*6ba0:*/ 0x3a, 0xd3, 0x5b, 0xbb, 0x07, 0x4a, 0x3e, 0x04, 0xa7, 0x2f, 0x1e, 0xb7, 0xa3, 0x80, 0xa5, 0x5d, + /*6bb0:*/ 0x52, 0x1c, 0x45, 0xd4, 0x11, 0xdf, 0x1a, 0xc0, 0x8d, 0xf6, 0xe4, 0x87, 0x07, 0xa3, 0xb3, 0xa1, + /*6bc0:*/ 0xe0, 0x5d, 0x68, 0x0a, 0x2f, 0x94, 0xc3, 0xab, 0x98, 0x76, 0x5e, 0x71, 0xf3, 0x75, 0xb2, 0xcd, + /*6bd0:*/ 0x38, 0x38, 0x8e, 0xa3, 0x10, 0xb8, 0xc3, 0x83, 0x71, 0xde, 0x20, 0xa2, 0x62, 0xa9, 0x5f, 0x28, + /*6be0:*/ 0xbb, 0xfd, 0x14, 0x11, 0x6c, 0x9f, 0x90, 0x0e, 0x47, 0x0d, 0xf0, 0x28, 0x52, 0x55, 0x1c, 0x5e, + /*6bf0:*/ 0xf2, 0x8d, 0x70, 0x81, 0x73, 0x6b, 0x7a, 0x7d, 0x21, 0x3e, 0x8e, 0x4c, 0x80, 0x38, 0x8e, 0x4c, + /*6c00:*/ 0x7e, 0x29, 0x99, 0x07, 0x05, 0x25, 0x81, 0x66, 0x64, 0x34, 0x95, 0x45, 0x8c, 0xf3, 0x00, 0x81, + /*6c10:*/ 0x81, 0xb8, 0x91, 0xb4, 0xfc, 0x83, 0xc4, 0xac, 0x60, 0xfd, 0x01, 0x04, 0x7a, 0xff, 0x87, 0x04, + /*6c20:*/ 0x79, 0x40, 0xc0, 0x93, 0x72, 0x66, 0x32, 0xc6, 0xc1, 0x42, 0xe5, 0x5e, 0x74, 0xd5, 0x3b, 0xb8, + /*6c30:*/ 0xde, 0xca, 0xbd, 0x17, 0xc0, 0x5f, 0x93, 0xe5, 0xdc, 0xe7, 0xdb, 0xf8, 0x53, 0x70, 0x01, 0x4d, + /*6c40:*/ 0x7a, 0x78, 0x1f, 0xc9, 0xa8, 0x96, 0xbb, 0xde, 0x29, 0xf8, 0x0b, 0x32, 0xd2, 0x9b, 0x00, 0x33, + /*6c50:*/ 0x96, 0xa5, 0xd6, 0x7f, 0x88, 0x78, 0x3d, 0x03, 0x39, 0x8b, 0x82, 0x48, 0x88, 0xd6, 0x2d, 0x3d, + /*6c60:*/ 0xc5, 0x13, 0xee, 0x2b, 0x61, 0x54, 0xf2, 0x10, 0xec, 0xd2, 0x8d, 0x4a, 0xc4, 0xbe, 0xef, 0x36, + /*6c70:*/ 0x39, 0x4f, 0xdc, 0x63, 0xb7, 0x0c, 0x40, 0x38, 0x47, 0x85, 0x40, 0xc7, 0x8b, 0xfa, 0x1f, 0x69, + /*6c80:*/ 0x9f, 0xd9, 0xf7, 0x4f, 0x68, 0x7f, 0x34, 0x23, 0xfc, 0x95, 0xee, 0xb2, 0x1c, 0x18, 0xda, 0x2a, + /*6c90:*/ 0x2b, 0x78, 0x53, 0x53, 0xa4, 0x32, 0x01, 0x83, 0xf6, 0x3e, 0xf5, 0x40, 0xb2, 0xae, 0x0f, 0x1f, + /*6ca0:*/ 0xf7, 0x1f, 0x7f, 0x69, 0x4e, 0x44, 0x54, 0x24, 0x2d, 0x82, 0x32, 0xd3, 0x71, 0x8f, 0xf4, 0x68, + /*6cb0:*/ 0x79, 0xc0, 0xdc, 0x98, 0xa6, 0xfb, 0x9b, 0xde, 0xa5, 0xb3, 0xea, 0xbd, 0x02, 0x64, 0xcc, 0xd9, + /*6cc0:*/ 0xa2, 0x25, 0x1c, 0x42, 0x15, 0xa8, 0xf0, 0xe5, 0x43, 0x94, 0x39, 0xaf, 0x10, 0xc3, 0x20, 0xa9, + /*6cd0:*/ 0x49, 0x2d, 0x12, 0x9f, 0x8e, 0xe5, 0x10, 0x5f, 0x67, 0xb4, 0x55, 0x7a, 0x58, 0x7c, 0xfd, 0xf0, + /*6ce0:*/ 0x13, 0x8a, 0xfe, 0xff, 0x5e, 0xfc, 0xc1, 0x93, 0x57, 0xa8, 0x7f, 0xe0, 0x5e, 0xad, 0x63, 0xa8, + /*6cf0:*/ 0x38, 0x0c, 0xa3, 0xfa, 0xb3, 0xab, 0x67, 0x4a, 0x09, 0xb8, 0xe5, 0xb2, 0xbd, 0x52, 0xa6, 0xb2, + /*6d00:*/ 0x9f, 0x07, 0xe7, 0xce, 0x31, 0xe3, 0x14, 0x82, 0x99, 0xca, 0xad, 0x55, 0x9b, 0xb6, 0x9e, 0x2f, + /*6d10:*/ 0xa4, 0x4f, 0xc7, 0xaa, 0x84, 0xfb, 0x22, 0x0a, 0x45, 0x7d, 0xab, 0x24, 0xd5, 0xe3, 0xd2, 0xb1, + /*6d20:*/ 0x12, 0xc7, 0xda, 0x73, 0xe8, 0xd4, 0x43, 0x56, 0xaa, 0x9d, 0xc9, 0x0a, 0x9a, 0x19, 0x12, 0x08, + /*6d30:*/ 0x89, 0x6f, 0x37, 0x59, 0xfe, 0x67, 0x0f, 0x3c, 0x7b, 0xae, 0x30, 0xa7, 0x1b, 0x6e, 0x8d, 0xb9, + /*6d40:*/ 0xd1, 0x6f, 0x94, 0x03, 0x95, 0x22, 0x90, 0xdd, 0x2a, 0xb2, 0xc2, 0x7a, 0x12, 0xe6, 0xad, 0x41, + /*6d50:*/ 0xe6, 0xeb, 0x85, 0x8e, 0x98, 0xc0, 0xe1, 0xeb, 0x87, 0xaa, 0xf0, 0xd4, 0xde, 0x5e, 0x32, 0xdb, + /*6d60:*/ 0x73, 0xca, 0xc8, 0x5f, 0x87, 0xca, 0x00, 0x3b, 0xfe, 0x3d, 0x0f, 0x90, 0x75, 0xe1, 0x8b, 0xf6, + /*6d70:*/ 0x73, 0x46, 0x86, 0x87, 0x98, 0xbf, 0x7d, 0x6d, 0x21, 0xec, 0xa3, 0x8c, 0x5a, 0x53, 0x48, 0x06, + /*6d80:*/ 0x56, 0x9a, 0x3d, 0x2b, 0x0a, 0xd7, 0x85, 0x14, 0x0f, 0x12, 0x19, 0x91, 0xcb, 0xb1, 0x9e, 0x6d, + /*6d90:*/ 0x9c, 0x27, 0xb2, 0x4e, 0x36, 0xeb, 0xa6, 0x25, 0x22, 0x4a, 0x15, 0x21, 0xd6, 0x23, 0xcf, 0xf1, + /*6da0:*/ 0xdf, 0xba, 0x0a, 0xb0, 0x6b, 0xd9, 0xd1, 0x43, 0xfd, 0x0a, 0xa8, 0xf3, 0xf0, 0x34, 0x78, 0x41, + /*6db0:*/ 0x7e, 0x70, 0xf4, 0x40, 0xbf, 0x82, 0x37, 0x79, 0xef, 0xe5, 0x80, 0x48, 0x1f, 0x91, 0x47, 0xd6, + /*6dc0:*/ 0x7e, 0x41, 0x92, 0x1e, 0x59, 0x28, 0x05, 0xcc, 0xa6, 0xd2, 0xb8, 0xe0, 0x2c, 0xc0, 0x23, 0x58, + /*6dd0:*/ 0x50, 0x3a, 0x96, 0x83, 0xd5, 0xa8, 0xa1, 0x82, 0x88, 0x43, 0xab, 0x0b, 0x88, 0xbe, 0xb7, 0x2d, + /*6de0:*/ 0x6f, 0x19, 0x74, 0x41, 0x6f, 0xb9, 0xd4, 0xea, 0x25, 0xe1, 0xc5, 0x62, 0x87, 0xb6, 0x0c, 0x2a, + /*6df0:*/ 0x5b, 0x9b, 0xa4, 0xa2, 0xcf, 0x9c, 0xb7, 0x60, 0x3a, 0x99, 0x1a, 0x37, 0xf9, 0xf9, 0xce, 0x49, + /*6e00:*/ 0x64, 0x2f, 0x3a, 0xc2, 0x35, 0x1b, 0x48, 0x99, 0x64, 0xdb, 0x26, 0xb4, 0x96, 0x74, 0x48, 0x2a, + /*6e10:*/ 0x98, 0x39, 0x51, 0x6b, 0x95, 0xb8, 0xaa, 0x47, 0xaf, 0xba, 0xc9, 0x75, 0x3a, 0x83, 0xf4, 0x6b, + /*6e20:*/ 0xc2, 0xe2, 0x9d, 0x35, 0x04, 0x4a, 0x7c, 0x2c, 0xa4, 0xac, 0xaf, 0xd4, 0xb6, 0x9c, 0x8c, 0xb1, + /*6e30:*/ 0xf7, 0xff, 0xca, 0xab, 0xda, 0x74, 0x70, 0xaf, 0xfc, 0x79, 0x64, 0x0f, 0x24, 0xb6, 0xab, 0x66, + /*6e40:*/ 0x0c, 0x31, 0x15, 0xaa, 0x1e, 0xa8, 0x52, 0xc2, 0x19, 0x93, 0x8c, 0x46, 0xbb, 0x66, 0x66, 0xa0, + /*6e50:*/ 0xfb, 0xc8, 0x1d, 0x39, 0x89, 0xed, 0xcc, 0x6c, 0x16, 0x88, 0x4d, 0xc4, 0x28, 0x98, 0x1b, 0x6d, + /*6e60:*/ 0xa4, 0x42, 0x67, 0x00, 0x06, 0xf8, 0xd5, 0x2b, 0xc2, 0xe3, 0xc7, 0xa7, 0x19, 0x32, 0xcf, 0x79, + /*6e70:*/ 0xce, 0x4b, 0x5f, 0x7f, 0xfe, 0xd6, 0xb1, 0xc8, 0xec, 0xe6, 0x96, 0x8b, 0x6a, 0xf6, 0xa4, 0x2b, + /*6e80:*/ 0xa7, 0x8f, 0xd8, 0xb1, 0x1f, 0xc5, 0xce, 0x24, 0xfe, 0xd0, 0xd7, 0xd7, 0xd9, 0xfb, 0x8e, 0x19, + /*6e90:*/ 0xfd, 0x6f, 0x54, 0x3a, 0x73, 0xbe, 0x0a, 0x5c, 0xd0, 0x1e, 0xf2, 0x85, 0x7c, 0x1e, 0x18, 0xc9, + /*6ea0:*/ 0x4f, 0x86, 0x9b, 0x71, 0x1f, 0x0a, 0x75, 0xc4, 0x5d, 0x68, 0xac, 0x1a, 0xef, 0xce, 0xdf, 0xb0, + /*6eb0:*/ 0x23, 0x4b, 0x79, 0xa1, 0x64, 0x86, 0x07, 0xa2, 0x91, 0x0d, 0x00, 0x36, 0xf1, 0xbe, 0xe7, 0x4a, + /*6ec0:*/ 0x03, 0x13, 0xf2, 0xc0, 0x40, 0x8a, 0x82, 0x49, 0xa8, 0x80, 0x9c, 0xda, 0x0c, 0xe8, 0xf9, 0xb3, + /*6ed0:*/ 0x5c, 0xbb, 0x5c, 0x2b, 0x8b, 0xf7, 0xdd, 0x8f, 0x7a, 0x7a, 0xac, 0x29, 0x65, 0x36, 0xb5, 0xc9, + /*6ee0:*/ 0xac, 0x60, 0x77, 0x12, 0xe3, 0x2e, 0xbf, 0x7c, 0xdd, 0x3a, 0x99, 0xe9, 0x79, 0xed, 0x36, 0x85, + /*6ef0:*/ 0x0b, 0xc5, 0xe7, 0x0d, 0xdb, 0x4d, 0x5e, 0x8c, 0x3a, 0xb5, 0xc2, 0x09, 0x52, 0xf9, 0xf8, 0x90, + /*6f00:*/ 0xbd, 0x35, 0x94, 0x27, 0x21, 0xe1, 0xbf, 0xa7, 0xb6, 0x1d, 0x31, 0x23, 0x55, 0x5c, 0xec, 0x78, + /*6f10:*/ 0xe6, 0x86, 0xd0, 0x3a, 0x32, 0x14, 0x2a, 0x20, 0x20, 0x59, 0x78, 0x24, 0xab, 0x27, 0xb5, 0xa0, + /*6f20:*/ 0x13, 0xfc, 0xf5, 0x5b, 0x1e, 0xad, 0x3a, 0x36, 0x40, 0x18, 0x4a, 0x73, 0x5b, 0xdd, 0x8d, 0xb2, + /*6f30:*/ 0xc3, 0xb9, 0xe4, 0x15, 0xf0, 0xd6, 0xf6, 0xf3, 0x5c, 0x26, 0x00, 0x22, 0xde, 0x9a, 0xa4, 0xe1, + /*6f40:*/ 0x36, 0xa6, 0xd9, 0xe7, 0xc9, 0x9e, 0xd7, 0xb2, 0x64, 0xfb, 0x24, 0xe9, 0xb0, 0xba, 0xa1, 0xa6, + /*6f50:*/ 0xc5, 0xc6, 0x7f, 0xbe, 0x22, 0x28, 0x02, 0x62, 0xb5, 0xf4, 0x38, 0xaa, 0x2d, 0x85, 0x45, 0xac, + /*6f60:*/ 0xe8, 0xcc, 0xfc, 0x2f, 0x75, 0xec, 0x09, 0xd2, 0xf5, 0x63, 0x64, 0xd0, 0x1a, 0xec, 0xfc, 0xfb, + /*6f70:*/ 0x59, 0xea, 0x70, 0x42, 0x09, 0xae, 0xe9, 0xd0, 0x4f, 0xbb, 0x34, 0xa8, 0x9e, 0x76, 0x2b, 0x13, + /*6f80:*/ 0x00, 0xe0, 0xde, 0x26, 0x12, 0x49, 0x6c, 0x1c, 0x52, 0xc1, 0x8d, 0xb9, 0x47, 0xaa, 0xff, 0xb3, + /*6f90:*/ 0x06, 0x54, 0x5e, 0x5f, 0x77, 0x82, 0x93, 0x8f, 0xd0, 0x62, 0xd6, 0xde, 0xd2, 0x00, 0xb2, 0xc2, + /*6fa0:*/ 0x7e, 0x08, 0x34, 0x9b, 0xc5, 0x2e, 0x6d, 0x3d, 0xbf, 0x06, 0xc8, 0xce, 0x3c, 0x96, 0x9b, 0x9c, + /*6fb0:*/ 0xe5, 0x94, 0x0c, 0x56, 0x4e, 0x54, 0xcf, 0xee, 0xff, 0xb3, 0x61, 0x66, 0xf3, 0x4a, 0xe0, 0x6b, + /*6fc0:*/ 0x20, 0xda, 0xe3, 0x5f, 0x04, 0xf7, 0xef, 0xc6, 0x27, 0x85, 0xb0, 0xf8, 0xf0, 0xf5, 0x37, 0x50, + /*6fd0:*/ 0x34, 0x5d, 0xde, 0x5e, 0x20, 0x57, 0x95, 0xe4, 0x30, 0x0d, 0xa9, 0xe8, 0x05, 0xb8, 0x5e, 0xbe, + /*6fe0:*/ 0x2d, 0x74, 0x7b, 0x4b, 0xff, 0x5a, 0x88, 0x31, 0xe5, 0x11, 0xe3, 0x90, 0xef, 0xb3, 0xd1, 0x28, + /*6ff0:*/ 0x92, 0x24, 0x4d, 0x93, 0xd3, 0x9c, 0xbf, 0xfc, 0x9d, 0x1f, 0x80, 0x4c, 0xdb, 0xbc, 0x82, 0x3f, + /*7000:*/ 0x0d, 0xc9, 0xa6, 0xf5, 0x90, 0x95, 0x0c, 0x18, 0x9b, 0x5a, 0x08, 0xe4, 0x6d, 0xed, 0x36, 0x63, + /*7010:*/ 0x78, 0x36, 0x56, 0xfc, 0x40, 0xa9, 0xbb, 0x23, 0xbe, 0x39, 0x16, 0xae, 0xe9, 0x3d, 0x2c, 0xc8, + /*7020:*/ 0x3f, 0x70, 0xfc, 0x9d, 0x6d, 0x3b, 0xc8, 0x75, 0xb5, 0x62, 0x8a, 0x80, 0xea, 0x90, 0x25, 0x1b, + /*7030:*/ 0xc2, 0x6c, 0x24, 0xc8, 0xab, 0x99, 0x6e, 0x32, 0x59, 0x3e, 0x03, 0xd1, 0xab, 0x20, 0xab, 0x64, + /*7040:*/ 0x55, 0xf5, 0x98, 0x31, 0x92, 0xc5, 0xcd, 0x26, 0x97, 0xe0, 0x80, 0xc5, 0xfe, 0x65, 0xd4, 0x21, + /*7050:*/ 0x45, 0x9e, 0xee, 0xad, 0x59, 0xd5, 0x32, 0x61, 0x62, 0x6b, 0x86, 0x53, 0xeb, 0xed, 0x36, 0x4c, + /*7060:*/ 0x59, 0x1e, 0x0f, 0xc7, 0xcf, 0xf4, 0x9b, 0x8c, 0x43, 0x08, 0x2f, 0x9a, 0x5e, 0x2c, 0x1f, 0xdb, + /*7070:*/ 0x5e, 0xd7, 0x0b, 0xe8, 0x4e, 0xe5, 0x76, 0x67, 0x18, 0xdc, 0xd9, 0x6e, 0x64, 0xf4, 0x8f, 0x98, + /*7080:*/ 0x47, 0x2f, 0x8d, 0x85, 0xbe, 0x9c, 0xd7, 0xaf, 0x2e, 0x56, 0x82, 0x9d, 0x71, 0x91, 0xbd, 0x7d, + /*7090:*/ 0xdd, 0x40, 0x85, 0xd9, 0x40, 0x7b, 0x2d, 0x51, 0xd6, 0xf4, 0xc9, 0x49, 0x1d, 0x5f, 0x1a, 0x23, + /*70a0:*/ 0xdc, 0xa7, 0x67, 0x16, 0xe4, 0xde, 0x7b, 0xd9, 0xf0, 0xd6, 0x0d, 0x0f, 0x20, 0x06, 0x22, 0x70, + /*70b0:*/ 0xcb, 0x63, 0x94, 0xab, 0xdb, 0xc8, 0x3c, 0xa6, 0x20, 0x70, 0xf4, 0xf4, 0x01, 0xac, 0x8e, 0xc7, + /*70c0:*/ 0x5a, 0x3c, 0x38, 0x5f, 0x39, 0x06, 0x47, 0x35, 0x5c, 0x98, 0xbf, 0x9c, 0x59, 0xd0, 0x8d, 0x2f, + /*70d0:*/ 0x73, 0x13, 0x06, 0x14, 0x5c, 0x10, 0xc6, 0x17, 0x87, 0xc6, 0x4d, 0x1e, 0x54, 0x67, 0x94, 0x2c, + /*70e0:*/ 0xf2, 0xfc, 0x9f, 0x8a, 0x55, 0x8e, 0xd4, 0x16, 0x76, 0xe2, 0x4f, 0x94, 0x29, 0xc9, 0x27, 0xd4, + /*70f0:*/ 0x84, 0xd1, 0xc3, 0x33, 0xc7, 0xf3, 0x5c, 0x82, 0x11, 0x95, 0x4f, 0xfb, 0x7b, 0xa1, 0x4d, 0xb4, + /*7100:*/ 0x8c, 0x83, 0xec, 0xb6, 0xb2, 0x27, 0xaf, 0xeb, 0x31, 0x07, 0x52, 0x40, 0xd0, 0xc4, 0x75, 0x78, + /*7110:*/ 0xf5, 0xcf, 0x28, 0xce, 0x4d, 0xcb, 0x72, 0x87, 0x97, 0x48, 0x7c, 0xc2, 0x76, 0xc7, 0x43, 0x36, + /*7120:*/ 0xa5, 0x95, 0x0f, 0x90, 0x8b, 0x0a, 0x90, 0xf0, 0xb3, 0x37, 0x59, 0x9d, 0x0a, 0xde, 0x1a, 0x3a, + /*7130:*/ 0x6e, 0xcd, 0xff, 0x66, 0x15, 0xef, 0xcc, 0x5b, 0x83, 0x84, 0x76, 0x9d, 0x07, 0xb3, 0xe4, 0x1c, + /*7140:*/ 0x36, 0xb3, 0x99, 0xf6, 0x62, 0x6c, 0x96, 0x5d, 0x56, 0xa7, 0xd7, 0xf2, 0xe2, 0x39, 0x9e, 0x63, + /*7150:*/ 0x54, 0x2b, 0x45, 0xc4, 0x4e, 0x55, 0x92, 0x80, 0xd7, 0x24, 0x4d, 0x05, 0x3a, 0x86, 0x34, 0x17, + /*7160:*/ 0xb1, 0x09, 0xb4, 0xaf, 0x34, 0x35, 0x69, 0x4f, 0x74, 0x1e, 0x9e, 0x8f, 0x9f, 0x7d, 0x89, 0x7d, + /*7170:*/ 0x7e, 0x5a, 0x0a, 0x38, 0xe1, 0x53, 0x73, 0x9a, 0x80, 0xdc, 0xea, 0x3f, 0x79, 0xf0, 0xd8, 0x48, + /*7180:*/ 0x7f, 0xf7, 0xc8, 0x73, 0x20, 0x3f, 0xbe, 0x71, 0xec, 0xc5, 0x8a, 0x65, 0x17, 0x16, 0xd0, 0xf4, + /*7190:*/ 0x7f, 0x21, 0x33, 0x94, 0xe1, 0xa5, 0x93, 0x32, 0x02, 0x0f, 0x3b, 0x74, 0x97, 0x88, 0x59, 0xcb, + /*71a0:*/ 0x12, 0xc5, 0x80, 0xd8, 0x7a, 0xe5, 0x89, 0x0c, 0x09, 0x62, 0x2b, 0x58, 0x9b, 0xef, 0xb5, 0x21, + /*71b0:*/ 0xed, 0xb2, 0x70, 0x45, 0x9e, 0x17, 0x87, 0x3b, 0x1b, 0xef, 0xb1, 0xee, 0xea, 0x0f, 0x6f, 0x70, + /*71c0:*/ 0x7d, 0x4d, 0xf9, 0x40, 0x11, 0x81, 0x97, 0xe7, 0x08, 0x94, 0x64, 0xd3, 0xe1, 0xbe, 0x76, 0xec, + /*71d0:*/ 0x95, 0x29, 0x5a, 0x83, 0xb3, 0x75, 0xd7, 0x10, 0xb1, 0x55, 0x7f, 0xc5, 0xd2, 0x57, 0xe3, 0xf8, + /*71e0:*/ 0xf0, 0x78, 0xef, 0xd9, 0x9a, 0xa5, 0xa8, 0xf6, 0x3d, 0xc8, 0xf2, 0xce, 0x58, 0xf0, 0x4b, 0x5a, + /*71f0:*/ 0xf3, 0xb7, 0xb3, 0xc8, 0x94, 0xe8, 0x1f, 0xef, 0x4b, 0x1d, 0x03, 0x0b, 0xc2, 0x51, 0xbf, 0x48, + /*7200:*/ 0xa7, 0xcf, 0xbe, 0x93, 0x5d, 0x93, 0x21, 0xfc, 0x33, 0x45, 0x6d, 0x79, 0xee, 0xb1, 0x8a, 0x60, + /*7210:*/ 0x70, 0xce, 0x7c, 0xbc, 0x58, 0x0b, 0x34, 0xb3, 0x8c, 0xd6, 0x8f, 0x94, 0x50, 0xbf, 0x0b, 0x50, + /*7220:*/ 0xc4, 0xf9, 0x9a, 0xd7, 0x95, 0x1e, 0xb0, 0x53, 0xe8, 0xd8, 0x14, 0x9e, 0x13, 0x5b, 0x9c, 0x9f, + /*7230:*/ 0xb4, 0xf5, 0x0d, 0x65, 0xfa, 0xe2, 0xaf, 0x04, 0x94, 0xda, 0x9f, 0x8e, 0x31, 0x0e, 0x66, 0xb6, + /*7240:*/ 0x45, 0x8b, 0xa5, 0xb5, 0xbc, 0x10, 0x30, 0xcf, 0xf7, 0x77, 0x79, 0x87, 0xd4, 0xe4, 0x32, 0xe3, + /*7250:*/ 0xce, 0x97, 0x4d, 0x63, 0xe8, 0xe5, 0x06, 0xf1, 0x3b, 0x30, 0x29, 0x35, 0xab, 0xe4, 0x46, 0x68, + /*7260:*/ 0x77, 0x94, 0xf7, 0x0d, 0x82, 0xf7, 0x61, 0xcb, 0x84, 0x2f, 0x2f, 0xfe, 0x5d, 0xe1, 0x25, 0x93, + /*7270:*/ 0xe2, 0xb3, 0xd2, 0x35, 0xf0, 0x3d, 0x43, 0x20, 0x1d, 0x4e, 0x9f, 0x35, 0x8c, 0x44, 0x95, 0xc5, + /*7280:*/ 0x71, 0x12, 0xd2, 0xc7, 0x8b, 0xf1, 0x30, 0x4a, 0x49, 0x51, 0xe4, 0xe9, 0x03, 0x9b, 0x14, 0x51, + /*7290:*/ 0x90, 0xbd, 0xbb, 0x9c, 0x21, 0xb8, 0xe0, 0x51, 0xe3, 0xca, 0xf4, 0xb4, 0x10, 0xd5, 0xa4, 0x8d, + /*72a0:*/ 0x9d, 0x3f, 0x28, 0x73, 0x7e, 0x5b, 0x6c, 0xe7, 0xca, 0x57, 0x66, 0x8d, 0x5b, 0x34, 0xe9, 0xaa, + /*72b0:*/ 0xb4, 0x2f, 0x56, 0x49, 0x1e, 0xa9, 0x14, 0xed, 0x2b, 0xee, 0x43, 0xa1, 0x3e, 0x10, 0xa4, 0xed, + /*72c0:*/ 0x1a, 0x13, 0xad, 0x78, 0x7a, 0xf2, 0x6e, 0xad, 0xca, 0x30, 0x2a, 0xa1, 0xd8, 0xf8, 0xe1, 0xd1, + /*72d0:*/ 0x91, 0x68, 0x5f, 0x6e, 0xd9, 0x06, 0x91, 0xd2, 0x8b, 0x2a, 0x9e, 0x29, 0x8c, 0xca, 0x5f, 0x46, + /*72e0:*/ 0x77, 0x6c, 0x19, 0xdc, 0x92, 0xf9, 0x8f, 0xc9, 0x68, 0x21, 0xe7, 0x6b, 0x89, 0xf5, 0x83, 0xa8, + /*72f0:*/ 0x6b, 0x9d, 0xe0, 0x1d, 0x77, 0x20, 0x16, 0x66, 0xe6, 0x53, 0xda, 0x32, 0x02, 0x39, 0x09, 0xcf, + /*7300:*/ 0xed, 0x34, 0xec, 0x87, 0xf7, 0xc0, 0x8d, 0xc7, 0xfc, 0x05, 0x7f, 0xc0, 0x6c, 0x78, 0x7c, 0xd9, + /*7310:*/ 0xa3, 0x30, 0xe3, 0xa2, 0x14, 0x0f, 0x42, 0xd6, 0x16, 0x62, 0xcb, 0xb6, 0x4a, 0xf4, 0xab, 0xee, + /*7320:*/ 0x29, 0x7e, 0xf3, 0xc1, 0x8e, 0xb9, 0xdd, 0x61, 0x44, 0x82, 0x2f, 0x1f, 0xc0, 0x28, 0x36, 0xb8, + /*7330:*/ 0x2c, 0xec, 0x2a, 0x4c, 0xe7, 0x50, 0x37, 0x9b, 0x6f, 0xb3, 0xb3, 0xc2, 0x1b, 0xf4, 0x91, 0x88, + /*7340:*/ 0x46, 0xb8, 0x2a, 0xbe, 0xc9, 0x56, 0x4e, 0x74, 0x16, 0xd7, 0x1f, 0x49, 0x3b, 0x50, 0xf2, 0x60, + /*7350:*/ 0xbe, 0x0f, 0x3d, 0x79, 0x4b, 0xae, 0x5d, 0xe5, 0x8b, 0xea, 0xd9, 0xe6, 0xca, 0x84, 0x85, 0x93, + /*7360:*/ 0x84, 0x98, 0x10, 0x0b, 0xa6, 0xfb, 0xb2, 0xa5, 0x3c, 0xc2, 0x79, 0x75, 0x56, 0x69, 0x26, 0x55, + /*7370:*/ 0x61, 0x6e, 0xf3, 0x3d, 0xb3, 0xfa, 0xdc, 0xd1, 0xe4, 0x57, 0x8f, 0x8f, 0x04, 0x61, 0xec, 0x42, + /*7380:*/ 0x6b, 0xe2, 0x89, 0xe2, 0x22, 0xc4, 0xde, 0x2e, 0xae, 0x0f, 0x78, 0x73, 0x0a, 0x7f, 0x33, 0x4a, + /*7390:*/ 0x26, 0x13, 0x11, 0x73, 0x32, 0x7f, 0x30, 0x28, 0x02, 0x40, 0x19, 0xfc, 0xaf, 0xf0, 0x12, 0x0c, + /*73a0:*/ 0x64, 0xcd, 0x83, 0x47, 0x66, 0x7e, 0xa5, 0x45, 0x0c, 0x91, 0xd4, 0x13, 0x45, 0x83, 0xd2, 0xbe, + /*73b0:*/ 0x1e, 0x7b, 0x00, 0x43, 0xd8, 0x12, 0x6c, 0xfe, 0xc4, 0x15, 0x34, 0x6e, 0x17, 0xb0, 0x18, 0x72, + /*73c0:*/ 0xc1, 0x08, 0x8d, 0x8c, 0x25, 0x24, 0x1a, 0xce, 0x06, 0xdb, 0x34, 0x8d, 0xec, 0xcb, 0x95, 0xf0, + /*73d0:*/ 0x09, 0x72, 0xa5, 0x5a, 0x22, 0x99, 0x0a, 0x93, 0x88, 0xea, 0x6e, 0x50, 0x80, 0x35, 0x0a, 0x12, + /*73e0:*/ 0x3f, 0x88, 0x4e, 0xe9, 0x64, 0x70, 0xc9, 0xea, 0x5a, 0xe1, 0x43, 0xe7, 0xb3, 0xd0, 0x32, 0x16, + /*73f0:*/ 0x58, 0xbf, 0x4b, 0xa0, 0x40, 0x26, 0xad, 0x4f, 0x83, 0xbe, 0x44, 0xbd, 0x29, 0xb2, 0x11, 0xd7, + /*7400:*/ 0x7a, 0x23, 0xe5, 0xc5, 0xda, 0xfc, 0xa6, 0xf8, 0xa1, 0x26, 0x99, 0xb3, 0xbb, 0x3d, 0xe6, 0x37, + /*7410:*/ 0x24, 0x36, 0x89, 0xa3, 0x67, 0x9b, 0x16, 0x46, 0xdf, 0x9c, 0x09, 0x07, 0x00, 0xf7, 0x14, 0xac, + /*7420:*/ 0x6c, 0x88, 0x2f, 0xfe, 0x3a, 0x88, 0xf2, 0xbf, 0x88, 0x87, 0x4e, 0xe5, 0x1a, 0xad, 0x70, 0x79, + /*7430:*/ 0x85, 0x2c, 0xa4, 0x2c, 0xf7, 0x8c, 0x2c, 0x9c, 0x16, 0x07, 0x3b, 0x64, 0x62, 0x94, 0x6b, 0xca, + /*7440:*/ 0x30, 0x6f, 0xe6, 0x86, 0x71, 0x82, 0x32, 0xd5, 0x22, 0xb7, 0x69, 0x44, 0x82, 0xab, 0xaa, 0xe1, + /*7450:*/ 0x5e, 0xf3, 0xd6, 0xb3, 0xf9, 0xe0, 0x1a, 0xfa, 0xf5, 0x54, 0x11, 0x7d, 0xf7, 0x38, 0xdb, 0x31, + /*7460:*/ 0x38, 0xfb, 0xf4, 0x3b, 0x47, 0x90, 0x1c, 0x57, 0xbf, 0x66, 0x4e, 0x68, 0xd9, 0x67, 0x03, 0x5a, + /*7470:*/ 0xa8, 0xd9, 0xe9, 0x91, 0xee, 0x66, 0x9c, 0x5f, 0xeb, 0x18, 0x12, 0xaf, 0x90, 0xf7, 0x58, 0x13, + /*7480:*/ 0x41, 0x5e, 0xa9, 0x66, 0xd7, 0x8a, 0xe7, 0x0c, 0xe9, 0x47, 0xa8, 0x96, 0x25, 0x7c, 0x5c, 0x38, + /*7490:*/ 0x46, 0xbc, 0x5a, 0x3d, 0x7f, 0xed, 0x9e, 0xc2, 0xc0, 0xde, 0x93, 0xcb, 0xfc, 0x19, 0x47, 0x5c, + /*74a0:*/ 0x5a, 0xca, 0x38, 0xd1, 0x88, 0xac, 0x7f, 0xf9, 0xad, 0x6f, 0x90, 0x62, 0x80, 0x6a, 0xac, 0x5e, + /*74b0:*/ 0x5c, 0x58, 0xfd, 0xa2, 0x62, 0xf8, 0x05, 0xbb, 0x5d, 0x63, 0x32, 0x74, 0x74, 0xc9, 0x1e, 0x28, + /*74c0:*/ 0xb6, 0x0e, 0x16, 0xa7, 0x4e, 0xc1, 0x51, 0x8e, 0x0d, 0xad, 0x1c, 0x8d, 0x3e, 0x86, 0x2b, 0x99, + /*74d0:*/ 0x77, 0x7c, 0x97, 0x70, 0xe9, 0xdf, 0x15, 0x83, 0xa9, 0x9c, 0x92, 0x7a, 0xf5, 0x54, 0x98, 0x7b, + /*74e0:*/ 0x33, 0xdf, 0xfb, 0xac, 0xde, 0xe8, 0x89, 0xda, 0x49, 0x77, 0x99, 0x22, 0xac, 0x52, 0x21, 0xf6, + /*74f0:*/ 0x7c, 0xf5, 0xa1, 0x67, 0x21, 0xc1, 0x7f, 0x65, 0x96, 0xcb, 0x84, 0x67, 0x1e, 0x87, 0x0f, 0x19, + /*7500:*/ 0x92, 0x53, 0x19, 0xce, 0x4f, 0xc5, 0x26, 0xef, 0x5b, 0xe6, 0xee, 0x9e, 0xe0, 0x4e, 0x26, 0xbc, + /*7510:*/ 0xa7, 0xe7, 0x06, 0x2d, 0x20, 0xd6, 0x5b, 0xe9, 0x57, 0x05, 0x50, 0xc1, 0x53, 0x3d, 0x0c, 0x29, + /*7520:*/ 0xc3, 0xb3, 0xd1, 0xe4, 0x20, 0x0f, 0xe1, 0xad, 0x1d, 0x0d, 0xe8, 0xd9, 0x8f, 0x32, 0xf8, 0x85, + /*7530:*/ 0xf4, 0xac, 0x21, 0x01, 0x5a, 0x64, 0xc8, 0x8c, 0x40, 0x2f, 0xf8, 0x52, 0xc8, 0x4d, 0x41, 0x2e, + /*7540:*/ 0x6d, 0x97, 0x57, 0x37, 0xca, 0xef, 0xba, 0x0a, 0xb2, 0x15, 0x38, 0x4c, 0xa1, 0xe1, 0x94, 0x1e, + /*7550:*/ 0xc2, 0x8e, 0x58, 0xe4, 0x8b, 0x6d, 0x52, 0x1d, 0x15, 0x7b, 0x10, 0x4b, 0x50, 0x32, 0x7b, 0xff, + /*7560:*/ 0x7b, 0xd4, 0xd9, 0xc6, 0x26, 0x21, 0x76, 0xf7, 0x4f, 0x9d, 0x35, 0x56, 0x50, 0x5a, 0x0b, 0x94, + /*7570:*/ 0x8d, 0x60, 0x84, 0x4d, 0xb2, 0xb3, 0x75, 0x9d, 0x34, 0xf6, 0x8f, 0x2d, 0xc9, 0x48, 0xd9, 0x16, + /*7580:*/ 0x20, 0xb4, 0xfa, 0xd4, 0x03, 0x1c, 0x0b, 0x6f, 0x56, 0x4a, 0x7b, 0x5b, 0x00, 0x4d, 0x09, 0x98, + /*7590:*/ 0x73, 0xd2, 0x14, 0xe7, 0xef, 0xc6, 0xba, 0x03, 0xab, 0xf9, 0xc4, 0x49, 0xa1, 0xc2, 0x56, 0xa5, + /*75a0:*/ 0x6b, 0xbc, 0x91, 0x76, 0x80, 0xc8, 0x85, 0x39, 0xd1, 0x05, 0x81, 0x7a, 0x78, 0x91, 0x7c, 0x4e, + /*75b0:*/ 0x15, 0x5a, 0x67, 0x76, 0x08, 0xa5, 0x76, 0xf1, 0x6f, 0xc4, 0x6d, 0x36, 0x40, 0xc1, 0x0a, 0x2b, + /*75c0:*/ 0xa3, 0x03, 0x6a, 0xf3, 0x20, 0xcc, 0x39, 0x24, 0x15, 0x21, 0x0d, 0xff, 0x0d, 0x75, 0x38, 0x93, + /*75d0:*/ 0x5a, 0x5b, 0xb0, 0x95, 0x27, 0x16, 0x4a, 0xd2, 0xf2, 0x44, 0x76, 0x1d, 0x01, 0xef, 0xf2, 0x9e, + /*75e0:*/ 0x92, 0xad, 0xe9, 0x00, 0x96, 0x51, 0x59, 0x9e, 0x03, 0xf8, 0xc4, 0xe8, 0xbb, 0xec, 0xa8, 0xce, + /*75f0:*/ 0x38, 0xb2, 0xc6, 0x7d, 0x8f, 0x08, 0xc8, 0xb1, 0x94, 0x41, 0xa8, 0xa0, 0x33, 0xcd, 0x6e, 0x85, + /*7600:*/ 0x56, 0x54, 0xf8, 0x93, 0xec, 0x92, 0x43, 0xee, 0xed, 0xac, 0xa6, 0x1a, 0xa6, 0xcd, 0x2a, 0xe5, + /*7610:*/ 0x78, 0xf5, 0x2e, 0x44, 0xaf, 0x5b, 0x21, 0x55, 0x12, 0x75, 0xf3, 0xb6, 0x09, 0x9c, 0x1a, 0x79, + /*7620:*/ 0xc3, 0xf4, 0x5c, 0x5f, 0xb9, 0xb9, 0xf1, 0x0b, 0x90, 0xf1, 0xc9, 0x81, 0x2c, 0x1f, 0xea, 0x57, + /*7630:*/ 0xfb, 0xce, 0x80, 0x90, 0xbc, 0x2b, 0x6b, 0x19, 0xaa, 0x6e, 0xef, 0xc3, 0xff, 0x04, 0x5a, 0x46, + /*7640:*/ 0x1a, 0x31, 0x58, 0x59, 0x90, 0x51, 0x5b, 0x6e, 0x8d, 0x0e, 0x03, 0xd9, 0x1f, 0x97, 0xdd, 0xdf, + /*7650:*/ 0x8c, 0xc7, 0xf7, 0x9c, 0x35, 0xfb, 0x11, 0xb1, 0x46, 0x93, 0x50, 0x93, 0xa4, 0xab, 0x2a, 0x9c, + /*7660:*/ 0xc9, 0x05, 0x67, 0x82, 0x4c, 0xa9, 0x5f, 0x12, 0xf0, 0xb4, 0x09, 0xe5, 0x95, 0x16, 0xa4, 0xd2, + /*7670:*/ 0x49, 0x01, 0x37, 0xb8, 0x69, 0xdf, 0x89, 0xbc, 0xe5, 0x9a, 0x0c, 0x6a, 0xfd, 0xae, 0xd9, 0xa0, + /*7680:*/ 0x3c, 0xeb, 0xb6, 0x4c, 0xe9, 0xcb, 0xc2, 0x88, 0xc6, 0x67, 0x8e, 0xa7, 0x69, 0xf5, 0xfc, 0xb6, + /*7690:*/ 0xb7, 0x26, 0xf1, 0x13, 0x9f, 0x30, 0xd2, 0x0f, 0xb0, 0x45, 0x39, 0x32, 0xc7, 0x37, 0xb2, 0xc4, + /*76a0:*/ 0x0c, 0xbd, 0x8b, 0xff, 0x2f, 0x79, 0x0c, 0x2a, 0xbe, 0x7b, 0xf5, 0x8e, 0x23, 0xb9, 0x83, 0xe2, + /*76b0:*/ 0xbe, 0x90, 0xcd, 0xa3, 0x81, 0x81, 0x64, 0x24, 0xf4, 0x09, 0x27, 0x58, 0xf5, 0x9e, 0x96, 0x1a, + /*76c0:*/ 0xd6, 0x75, 0x92, 0x63, 0x18, 0xd8, 0xe6, 0x5e, 0x83, 0x9e, 0x1a, 0xaf, 0xcf, 0x68, 0x72, 0xdc, + /*76d0:*/ 0xc3, 0x7b, 0xcb, 0x32, 0x28, 0x84, 0xfd, 0x6c, 0x39, 0x1d, 0xc9, 0x9c, 0x17, 0x2d, 0x28, 0x75, + /*76e0:*/ 0xba, 0xa4, 0x00, 0xea, 0xe6, 0x04, 0x1e, 0x70, 0x27, 0x67, 0xff, 0x5b, 0xdd, 0xd1, 0x8f, 0xfc, + /*76f0:*/ 0x71, 0x27, 0xd1, 0x53, 0xf3, 0xc6, 0xb3, 0x52, 0x47, 0x43, 0x6a, 0x01, 0x07, 0xf6, 0x0a, 0x21, + /*7700:*/ 0x2a, 0xda, 0x4e, 0x03, 0x41, 0x2f, 0xee, 0x85, 0xae, 0x7f, 0x3b, 0xe6, 0x38, 0xf7, 0x97, 0xde, + /*7710:*/ 0xf5, 0x67, 0x10, 0x52, 0xd5, 0x20, 0x73, 0x1b, 0xd9, 0x6b, 0x5c, 0x9a, 0x00, 0x90, 0xbc, 0xd3, + /*7720:*/ 0x9c, 0x8d, 0x26, 0x87, 0x97, 0x94, 0x8f, 0x6f, 0x05, 0x64, 0x8d, 0x7b, 0x6f, 0x51, 0xf1, 0xf1, + /*7730:*/ 0x43, 0xd2, 0xa3, 0x5e, 0xd5, 0x93, 0x4a, 0xe1, 0x83, 0x84, 0x7c, 0xde, 0xcf, 0x65, 0x1f, 0x6a, + /*7740:*/ 0x45, 0xba, 0x07, 0xa6, 0x8e, 0xe4, 0x01, 0x4d, 0x22, 0xdf, 0x00, 0x22, 0x39, 0x75, 0x3e, 0x0d, + /*7750:*/ 0x8d, 0x3c, 0x68, 0x5b, 0x7c, 0x81, 0xd1, 0xc6, 0x79, 0x2b, 0x54, 0xb7, 0xc1, 0x86, 0x2e, 0x03, + /*7760:*/ 0x44, 0xa6, 0xc0, 0xe0, 0x17, 0x59, 0x3a, 0xed, 0x0b, 0x6b, 0x0c, 0x08, 0x0a, 0xce, 0x9a, 0x31, + /*7770:*/ 0xa5, 0x94, 0x3c, 0x96, 0x29, 0x8f, 0xc7, 0xb0, 0xa3, 0x54, 0x91, 0x0d, 0xd5, 0x5e, 0xb3, 0x73, + /*7780:*/ 0x1a, 0xf6, 0x69, 0xb4, 0xb0, 0x16, 0xc1, 0x28, 0xdc, 0xbd, 0x4e, 0x2f, 0x89, 0x9d, 0xd2, 0xfe, + /*7790:*/ 0x4f, 0xb9, 0x7b, 0x81, 0xcb, 0xf3, 0x67, 0x99, 0x85, 0x44, 0x62, 0xb0, 0x77, 0xd8, 0x3b, 0x2b, + /*77a0:*/ 0xda, 0x8d, 0xcd, 0xa2, 0xf5, 0x00, 0x35, 0x98, 0xc2, 0xb0, 0x1f, 0x8d, 0x24, 0xac, 0x42, 0x1b, + /*77b0:*/ 0x8b, 0xe7, 0xc0, 0x66, 0xa8, 0x91, 0xf0, 0x68, 0x0b, 0x21, 0xe2, 0x0d, 0x71, 0x7f, 0x10, 0x7f, + /*77c0:*/ 0x54, 0x0d, 0x77, 0x01, 0x21, 0x48, 0xde, 0x35, 0x7d, 0x3d, 0x7d, 0xde, 0xc1, 0x3a, 0x18, 0x27, + /*77d0:*/ 0x63, 0xb2, 0x81, 0x34, 0x6f, 0x6f, 0x61, 0x8f, 0xd4, 0xcb, 0x95, 0x14, 0x13, 0xc5, 0x62, 0xf2, + /*77e0:*/ 0x53, 0xed, 0xad, 0x38, 0x92, 0x7d, 0xd5, 0x1b, 0x10, 0x45, 0x42, 0x78, 0xd1, 0x85, 0x2c, 0x42, + /*77f0:*/ 0xcb, 0x72, 0x74, 0x0b, 0x8a, 0x08, 0x39, 0x7b, 0x7b, 0xdb, 0x97, 0x69, 0xcc, 0x22, 0xc7, 0x6e, + /*7800:*/ 0x13, 0x5a, 0x2b, 0x90, 0x4b, 0xd7, 0xb3, 0x54, 0x7b, 0x64, 0xf4, 0x4e, 0x3e, 0xd2, 0xd1, 0xf0, + /*7810:*/ 0xbb, 0xa5, 0xab, 0xd4, 0xd7, 0x5d, 0xb4, 0x4b, 0x43, 0x8b, 0xe4, 0x0b, 0x27, 0xcb, 0x4c, 0xf9, + /*7820:*/ 0xe8, 0x9c, 0x24, 0x68, 0x42, 0x57, 0x9f, 0xa6, 0xc9, 0xc7, 0x53, 0xfc, 0x94, 0x1b, 0x18, 0x97, + /*7830:*/ 0xd5, 0xeb, 0x24, 0xbc, 0xb9, 0xaa, 0xc8, 0xe0, 0x01, 0x30, 0xc5, 0x01, 0x49, 0xc3, 0x61, 0x8a, + /*7840:*/ 0x47, 0x7a, 0x8d, 0x5b, 0x74, 0x0d, 0x48, 0xbf, 0x0c, 0xb3, 0xec, 0xe9, 0xe0, 0x1f, 0x6c, 0x36, + /*7850:*/ 0x67, 0xb7, 0xa1, 0xec, 0x9d, 0x51, 0x00, 0x4e, 0x2f, 0x58, 0xae, 0x7f, 0x61, 0x2e, 0x79, 0x24, + /*7860:*/ 0x50, 0x38, 0xe2, 0x3e, 0xc4, 0x00, 0xbb, 0xf2, 0x25, 0x5b, 0xa8, 0xf6, 0x75, 0x58, 0x30, 0xd9, + /*7870:*/ 0x63, 0x46, 0x4a, 0x62, 0xfc, 0x47, 0x83, 0xb5, 0xb7, 0xb0, 0x21, 0xf1, 0xfb, 0xaa, 0x6b, 0x17, + /*7880:*/ 0xb9, 0xa9, 0xea, 0xd0, 0x98, 0xfc, 0xd5, 0x76, 0x4f, 0x7f, 0x04, 0x69, 0x70, 0x49, 0xcc, 0x34, + /*7890:*/ 0x1f, 0x88, 0x0f, 0x63, 0x29, 0x47, 0x15, 0x56, 0x30, 0xfc, 0x99, 0xa9, 0xb9, 0x1a, 0x42, 0xe3, + /*78a0:*/ 0x0f, 0x28, 0x7a, 0xed, 0xca, 0xad, 0x55, 0x0f, 0xd7, 0xca, 0x5a, 0xae, 0x61, 0x4b, 0x24, 0xd2, + /*78b0:*/ 0x77, 0x68, 0xcc, 0xd2, 0x4f, 0x97, 0xc2, 0xeb, 0x79, 0x5c, 0x0a, 0xfe, 0x90, 0x5a, 0x31, 0xcb, + /*78c0:*/ 0x26, 0xa4, 0x73, 0x1e, 0xea, 0x43, 0xd4, 0x64, 0x6e, 0x0c, 0x07, 0x9d, 0xea, 0x6c, 0x91, 0x3c, + /*78d0:*/ 0x86, 0x72, 0xa6, 0xf2, 0xcd, 0x87, 0xc8, 0xbb, 0xfd, 0xef, 0x05, 0xa1, 0xf7, 0xff, 0x5f, 0x08, + /*78e0:*/ 0xc3, 0xc6, 0x55, 0x92, 0xb6, 0xf3, 0x3a, 0x87, 0x2b, 0x40, 0x3e, 0xe0, 0x37, 0x1f, 0xe2, 0xd4, + /*78f0:*/ 0x1e, 0x67, 0xc3, 0x87, 0xb6, 0x93, 0x76, 0x99, 0x22, 0x79, 0xfd, 0x1d, 0xbc, 0xf8, 0x2c, 0x54, + /*7900:*/ 0x10, 0x03, 0x2f, 0x36, 0xdb, 0x8c, 0x63, 0xba, 0x91, 0xbc, 0xca, 0xe1, 0xd7, 0xc7, 0x8e, 0x32, + /*7910:*/ 0x02, 0xb1, 0x77, 0x4d, 0x1d, 0x70, 0x2b, 0x3a, 0x84, 0xea, 0x1f, 0x78, 0xcc, 0xe8, 0x85, 0x30, + /*7920:*/ 0xbc, 0xe5, 0xb6, 0x15, 0x31, 0x4f, 0x61, 0xb2, 0x18, 0x5e, 0x36, 0xad, 0x70, 0x75, 0xd8, 0xe4, + /*7930:*/ 0x65, 0xdf, 0xac, 0xa1, 0xcc, 0x51, 0x1a, 0x0e, 0x8d, 0x45, 0xc4, 0x46, 0x73, 0x69, 0x2c, 0xc9, + /*7940:*/ 0xb3, 0x96, 0x4e, 0x58, 0x5d, 0x57, 0x68, 0x4e, 0x60, 0x48, 0x16, 0x74, 0x5e, 0xc3, 0xd8, 0x61, + /*7950:*/ 0x22, 0x30, 0x3b, 0x63, 0x96, 0x02, 0x35, 0x2a, 0x15, 0x21, 0x62, 0x92, 0x66, 0x7b, 0xfa, 0x90, + /*7960:*/ 0xfd, 0x63, 0x3c, 0xa7, 0x5a, 0x72, 0xd4, 0x95, 0x63, 0xb8, 0x57, 0x2e, 0x3a, 0x71, 0xa7, 0xd4, + /*7970:*/ 0xff, 0xf9, 0x02, 0xd4, 0xc1, 0xfe, 0xeb, 0x3e, 0x8c, 0xbf, 0xab, 0x16, 0x42, 0x2c, 0x0c, 0x57, + /*7980:*/ 0x12, 0xf0, 0x5a, 0x64, 0xf5, 0x09, 0x1c, 0x46, 0x7c, 0xfb, 0xe0, 0x68, 0x94, 0x97, 0x2c, 0x70, + /*7990:*/ 0x57, 0x13, 0xed, 0xec, 0xdc, 0xd8, 0xab, 0xba, 0x8e, 0x49, 0x87, 0x7c, 0x03, 0x6a, 0x5e, 0xf5, + /*79a0:*/ 0xca, 0x09, 0x96, 0x2c, 0x4b, 0xfb, 0x55, 0xb6, 0x1a, 0x04, 0xf0, 0xb0, 0xbc, 0x71, 0x4f, 0x68, + /*79b0:*/ 0x7c, 0xd4, 0x04, 0xd8, 0x16, 0x6d, 0xae, 0xa9, 0x62, 0xa7, 0xc0, 0xdd, 0x6c, 0xf5, 0x6a, 0x81, + /*79c0:*/ 0x56, 0xb9, 0x09, 0xed, 0x6a, 0xe1, 0x86, 0x44, 0xf7, 0x94, 0xbf, 0xda, 0xcc, 0xf6, 0x9c, 0x7a, + /*79d0:*/ 0xe8, 0x11, 0x1f, 0xdc, 0x7d, 0x22, 0xf2, 0xf1, 0xd2, 0x29, 0x28, 0x02, 0x90, 0x08, 0xb3, 0xdc, + /*79e0:*/ 0x13, 0xe5, 0x57, 0x6b, 0xd1, 0xd5, 0x4c, 0xc6, 0xed, 0xf2, 0x7f, 0x45, 0x38, 0x74, 0xd2, 0xe5, + /*79f0:*/ 0xb3, 0x38, 0x15, 0xc8, 0x55, 0xbe, 0x3c, 0x3d, 0x4e, 0x0c, 0xdd, 0x52, 0x4f, 0xea, 0x31, 0x26, + /*7a00:*/ 0x66, 0x93, 0x37, 0x93, 0x2b, 0x0e, 0x3b, 0x36, 0xd7, 0xd5, 0xc4, 0x9b, 0x3d, 0x0a, 0x25, 0x34, + /*7a10:*/ 0xcd, 0x7f, 0xea, 0x96, 0x9c, 0x34, 0x8f, 0xb8, 0x4a, 0x22, 0x4d, 0x64, 0x33, 0xc8, 0x79, 0x2d, + /*7a20:*/ 0xed, 0xe0, 0x63, 0x19, 0xac, 0xed, 0xf4, 0x95, 0x9e, 0x82, 0x87, 0x6d, 0xdd, 0x13, 0x7f, 0x00, + /*7a30:*/ 0xfe, 0x0a, 0xf8, 0x23, 0x1c, 0x6f, 0x53, 0xa4, 0xcd, 0x64, 0xe2, 0xae, 0xb8, 0x27, 0xff, 0x9f, + /*7a40:*/ 0xe9, 0x1e, 0xd7, 0x3e, 0x62, 0xc2, 0x3b, 0xfb, 0x2c, 0x93, 0x06, 0xcf, 0x21, 0xdb, 0x65, 0x8c, + /*7a50:*/ 0xc5, 0xe0, 0xfa, 0x99, 0x71, 0xf6, 0x55, 0x17, 0x64, 0xc9, 0xd6, 0x79, 0x0f, 0x0d, 0x4b, 0xdc, + /*7a60:*/ 0xcf, 0x24, 0x5d, 0x52, 0xed, 0x41, 0xe8, 0x06, 0x31, 0x87, 0x76, 0xdc, 0x4f, 0x79, 0x8e, 0x10, + /*7a70:*/ 0xa5, 0x5c, 0x37, 0x8c, 0xd4, 0xf7, 0x72, 0x77, 0xd9, 0x69, 0x24, 0x54, 0xdc, 0xf6, 0x35, 0x97, + /*7a80:*/ 0x0d, 0xe4, 0x14, 0xdd, 0xc7, 0x1c, 0x75, 0x5f, 0x2c, 0x33, 0xbe, 0xaa, 0x62, 0xbc, 0x53, 0x04, + /*7a90:*/ 0x18, 0xe0, 0x56, 0x8b, 0xdb, 0xcd, 0xcf, 0x98, 0xb5, 0x1b, 0xb4, 0xa9, 0x84, 0xb3, 0x89, 0xcf, + /*7aa0:*/ 0x5c, 0x57, 0x2d, 0x3d, 0xea, 0x89, 0xd7, 0x14, 0x1e, 0x3b, 0x1e, 0xfb, 0x2e, 0xf6, 0xa7, 0x62, + /*7ab0:*/ 0xd5, 0x21, 0x6f, 0xd2, 0x73, 0xd8, 0x3e, 0xde, 0x1a, 0x65, 0x9f, 0xd0, 0xeb, 0x90, 0x0b, 0x9d, + /*7ac0:*/ 0x21, 0xe5, 0x62, 0x5f, 0x31, 0x8c, 0x8e, 0x55, 0x8b, 0x85, 0x38, 0xa3, 0x16, 0xe8, 0x85, 0x48, + /*7ad0:*/ 0xce, 0xc9, 0xf3, 0x6e, 0x1c, 0x36, 0xd4, 0x38, 0x44, 0x92, 0x9b, 0xf0, 0xc4, 0x6a, 0x44, 0x13, + /*7ae0:*/ 0xfa, 0xde, 0x91, 0x4e, 0x04, 0xeb, 0x70, 0x2d, 0xb4, 0x5f, 0xc5, 0xe0, 0x49, 0x1c, 0x42, 0x4c, + /*7af0:*/ 0xca, 0xa2, 0x70, 0xc3, 0x5f, 0x38, 0x9c, 0x3b, 0xed, 0x96, 0xdf, 0x8d, 0x7f, 0x8c, 0xf9, 0x29, + /*7b00:*/ 0xe6, 0x5d, 0x4e, 0x0e, 0x9d, 0x47, 0x12, 0x37, 0x0c, 0x59, 0xf7, 0x01, 0xa9, 0xab, 0x4a, 0x08, + /*7b10:*/ 0x31, 0x9e, 0x5d, 0x7a, 0xbb, 0xe3, 0x69, 0x03, 0x53, 0xaf, 0xca, 0x96, 0x2e, 0x98, 0x12, 0xfd, + /*7b20:*/ 0x30, 0xab, 0xed, 0x90, 0xa2, 0x08, 0xd5, 0x2d, 0xcc, 0xda, 0xc3, 0x1b, 0xf9, 0x4c, 0x83, 0x71, + /*7b30:*/ 0xb0, 0x40, 0xc9, 0xe6, 0x1f, 0x03, 0x38, 0xc7, 0x6a, 0x85, 0xe1, 0xae, 0x1f, 0xca, 0x12, 0xe4, + /*7b40:*/ 0x6e, 0x9c, 0x1d, 0x6f, 0x6d, 0xa8, 0x2b, 0x9b, 0x46, 0x47, 0x8c, 0xba, 0x32, 0x3d, 0x98, 0x5d, + /*7b50:*/ 0x1e, 0xea, 0x08, 0xa6, 0x6d, 0xd8, 0x8a, 0x1c, 0x1c, 0xeb, 0x61, 0x0d, 0xc2, 0x9a, 0x3f, 0x79, + /*7b60:*/ 0xf4, 0x73, 0x8f, 0x30, 0xb7, 0x73, 0x06, 0x0c, 0xfc, 0x74, 0xf9, 0x60, 0x05, 0x46, 0xe9, 0x10, + /*7b70:*/ 0x1f, 0x8d, 0x01, 0x46, 0xd7, 0xc3, 0x72, 0x19, 0x7f, 0x45, 0x09, 0xe7, 0xe2, 0x9f, 0x7e, 0x57, + /*7b80:*/ 0x65, 0x0a, 0x4b, 0x02, 0x51, 0x20, 0xda, 0x6d, 0x09, 0xbf, 0x10, 0x02, 0xbc, 0xb9, 0x57, 0x5a, + /*7b90:*/ 0x4d, 0x49, 0x51, 0x9d, 0xb5, 0x1d, 0xb1, 0xf0, 0x1d, 0x31, 0xe1, 0xac, 0x27, 0x28, 0x6f, 0xc2, + /*7ba0:*/ 0x2f, 0xd2, 0x2e, 0xb6, 0xe8, 0xa9, 0xaa, 0xfd, 0x48, 0x61, 0x1a, 0xcc, 0x06, 0x33, 0x43, 0x42, + /*7bb0:*/ 0x5b, 0x37, 0x63, 0x31, 0xbc, 0x08, 0x0b, 0xea, 0x64, 0x64, 0xbf, 0x64, 0x48, 0xd6, 0x67, 0x02, + /*7bc0:*/ 0xda, 0xb3, 0xd4, 0x7b, 0xac, 0x59, 0x47, 0xde, 0x5a, 0x69, 0xac, 0xf4, 0xbc, 0x92, 0x5f, 0x23, + /*7bd0:*/ 0x0c, 0xd8, 0x07, 0x48, 0xd4, 0x7a, 0x7e, 0x5b, 0x09, 0xff, 0xc6, 0xc8, 0x6d, 0x64, 0xcb, 0x36, + /*7be0:*/ 0x0f, 0x71, 0xe9, 0x8a, 0xa2, 0xbe, 0xee, 0xaa, 0x21, 0xf5, 0xfe, 0xe6, 0xdc, 0x05, 0x19, 0x26, + /*7bf0:*/ 0x58, 0x85, 0x09, 0x62, 0x18, 0x96, 0x37, 0x0d, 0xde, 0xf5, 0xbf, 0xe6, 0x96, 0x15, 0xea, 0x51, + /*7c00:*/ 0x88, 0x63, 0x2e, 0x1d, 0x08, 0xad, 0xa2, 0x48, 0x0b, 0x93, 0x89, 0xb0, 0xfc, 0x89, 0xa7, 0x64, + /*7c10:*/ 0x85, 0x42, 0x55, 0x64, 0x67, 0x76, 0xb9, 0x88, 0x94, 0xa0, 0x4a, 0x6a, 0xf2, 0x5e, 0x02, 0xa8, + /*7c20:*/ 0x06, 0xd1, 0x43, 0x8b, 0xfa, 0xe7, 0x99, 0x3b, 0xdc, 0x61, 0xbe, 0x3e, 0x9a, 0xd7, 0xea, 0x8f, + /*7c30:*/ 0x67, 0xd4, 0xdd, 0x46, 0x5a, 0x87, 0xed, 0x92, 0x25, 0xe7, 0x0e, 0x27, 0x08, 0x49, 0xfc, 0x5c, + /*7c40:*/ 0x22, 0x35, 0xa8, 0x2f, 0xcd, 0x9a, 0xa2, 0x2a, 0x54, 0xf5, 0xdb, 0x0e, 0x2c, 0x77, 0xf6, 0x5d, + /*7c50:*/ 0xa3, 0x1f, 0xf5, 0xa3, 0x9a, 0xa7, 0x74, 0xce, 0x58, 0xb0, 0xbd, 0x88, 0x8e, 0x4f, 0x97, 0xff, + /*7c60:*/ 0x78, 0x0c, 0x9c, 0x7d, 0x5c, 0x65, 0x6c, 0x24, 0x7c, 0xe3, 0x7f, 0xee, 0x2f, 0x50, 0xf3, 0x1f, + /*7c70:*/ 0x7d, 0x6b, 0xd4, 0xc3, 0xe3, 0x3a, 0x88, 0x81, 0x8d, 0x61, 0x7f, 0xdc, 0xa9, 0x4b, 0xac, 0x0e, + /*7c80:*/ 0x76, 0x1e, 0x4e, 0xd8, 0xf7, 0x5b, 0x2c, 0x03, 0x37, 0xa6, 0x93, 0x78, 0xb0, 0xad, 0x96, 0xff, + /*7c90:*/ 0xf1, 0xaf, 0x9a, 0x1c, 0xa4, 0x9d, 0x04, 0x5a, 0xbd, 0x85, 0x1b, 0xd9, 0xad, 0x92, 0x1a, 0x28, + /*7ca0:*/ 0xe7, 0x7e, 0x08, 0x25, 0x67, 0xb8, 0x0c, 0x83, 0x2f, 0x3d, 0x92, 0xd7, 0xfe, 0xcf, 0x18, 0xee, + /*7cb0:*/ 0xd8, 0xd3, 0x2d, 0xec, 0x6f, 0x56, 0x3c, 0x6a, 0x69, 0x4b, 0x31, 0x8b, 0x7e, 0x9d, 0x18, 0x26, + /*7cc0:*/ 0xdc, 0xdd, 0x89, 0xc2, 0x1d, 0x32, 0x49, 0x27, 0xf7, 0x78, 0x46, 0x8e, 0xbf, 0x47, 0x37, 0x9d, + /*7cd0:*/ 0x45, 0xad, 0x46, 0x63, 0x9e, 0x70, 0xd7, 0xd9, 0xdd, 0x0f, 0x2f, 0xe1, 0x11, 0xe9, 0x93, 0xa2, + /*7ce0:*/ 0x99, 0x6e, 0xc4, 0x98, 0x6a, 0xf3, 0x31, 0x33, 0xe9, 0x54, 0x84, 0x6e, 0xc7, 0xe5, 0x7b, 0x79, + /*7cf0:*/ 0x4f, 0x06, 0x69, 0x36, 0x64, 0x23, 0x7e, 0xc5, 0xdc, 0x95, 0x1c, 0x34, 0x86, 0x93, 0x9e, 0xa9, + /*7d00:*/ 0x5f, 0xab, 0x6c, 0xff, 0xee, 0x8e, 0x80, 0x0b, 0x66, 0x76, 0xc0, 0x12, 0x75, 0x6d, 0x96, 0xb1, + /*7d10:*/ 0xaf, 0xb2, 0xe9, 0x96, 0x34, 0xcc, 0x99, 0x89, 0x59, 0xbc, 0xe0, 0xd5, 0xde, 0x1e, 0x7b, 0x3b, + /*7d20:*/ 0x88, 0xd3, 0xe4, 0x27, 0x06, 0x93, 0x4c, 0xf4, 0x8b, 0xdb, 0xef, 0xd3, 0x23, 0x85, 0x30, 0x37, + /*7d30:*/ 0x47, 0x54, 0x7e, 0x7d, 0xe7, 0x21, 0xeb, 0xc5, 0x55, 0x93, 0x1f, 0xd4, 0xf1, 0x8c, 0x7d, 0xd4, + /*7d40:*/ 0x3b, 0xfe, 0x83, 0x4a, 0xc8, 0x9a, 0xd4, 0x2a, 0x69, 0x52, 0x73, 0x81, 0x77, 0x8f, 0x7c, 0x98, + /*7d50:*/ 0xa0, 0x01, 0x7e, 0x7e, 0x34, 0x91, 0xb1, 0xea, 0x5b, 0x05, 0xa4, 0x0d, 0x41, 0x8c, 0x38, 0x0c, + /*7d60:*/ 0xfe, 0x32, 0x81, 0xee, 0x1a, 0x54, 0xcf, 0x01, 0x8e, 0xb3, 0x6e, 0xa0, 0x41, 0xa1, 0xa5, 0xa3, + /*7d70:*/ 0xc0, 0x18, 0x5e, 0x06, 0x32, 0x04, 0x85, 0x72, 0x60, 0x07, 0xb5, 0x30, 0xce, 0xfc, 0x21, 0xb4, + /*7d80:*/ 0xaa, 0xaa, 0xd9, 0xaf, 0xb1, 0x7e, 0xbd, 0x03, 0x32, 0x56, 0x55, 0x5c, 0xdb, 0xe3, 0x05, 0x06, + /*7d90:*/ 0x6b, 0x39, 0x67, 0x81, 0xcd, 0xd0, 0xc8, 0x5d, 0xb8, 0xae, 0xb6, 0x13, 0x3b, 0x6e, 0x4c, 0x4b, + /*7da0:*/ 0x8f, 0x12, 0x5f, 0x21, 0x61, 0x6c, 0xfc, 0x3f, 0x96, 0x1b, 0x82, 0x57, 0xf9, 0xbe, 0x5a, 0x91, + /*7db0:*/ 0x19, 0xac, 0xdd, 0x54, 0x2a, 0xd6, 0x8b, 0xa6, 0x0b, 0xb8, 0x7e, 0xeb, 0xaa, 0x86, 0x3a, 0x44, + /*7dc0:*/ 0x96, 0x7a, 0xec, 0x6a, 0x3e, 0xa0, 0x94, 0x3e, 0xb3, 0xe0, 0xc1, 0xf9, 0xd4, 0xff, 0xa4, 0x10, + /*7dd0:*/ 0x79, 0x8e, 0x83, 0x65, 0x2e, 0xd9, 0x90, 0xec, 0x00, 0xca, 0x2a, 0x86, 0xb8, 0x85, 0xf1, 0xa1, + /*7de0:*/ 0xdc, 0xfe, 0x54, 0x11, 0x67, 0xcf, 0x6d, 0x42, 0x6c, 0x2d, 0xf7, 0x8e, 0x9c, 0x5e, 0x0f, 0x62, + /*7df0:*/ 0x49, 0xf8, 0xb2, 0x4c, 0xc8, 0x7a, 0x47, 0x40, 0x59, 0xba, 0xa3, 0x8b, 0xad, 0x61, 0x8e, 0xd6, + /*7e00:*/ 0xbf, 0xd1, 0xf4, 0x3e, 0xb9, 0x80, 0x47, 0xd5, 0x94, 0xa9, 0xb9, 0xc1, 0x4d, 0xf4, 0x35, 0xa6, + /*7e10:*/ 0xa4, 0x13, 0x90, 0xcb, 0x7f, 0x9d, 0x08, 0xb7, 0x5a, 0x5e, 0x1f, 0x5a, 0x5c, 0x19, 0xc2, 0xce, + /*7e20:*/ 0xa2, 0xe4, 0xc1, 0x2c, 0xdb, 0xb9, 0x84, 0xb4, 0x7a, 0xa4, 0x0c, 0xaf, 0xf0, 0xdc, 0x7e, 0xe4, + /*7e30:*/ 0x27, 0x94, 0x69, 0x07, 0x6d, 0xc2, 0xaa, 0xc4, 0x95, 0x80, 0xb5, 0x94, 0xf8, 0x57, 0x0e, 0x97, + /*7e40:*/ 0x4d, 0x9a, 0x3e, 0x5c, 0x63, 0x44, 0x1b, 0x61, 0x22, 0xd8, 0x47, 0x4c, 0x35, 0x39, 0xa0, 0xfd, + /*7e50:*/ 0x52, 0x3c, 0x3f, 0x2f, 0x2d, 0x15, 0x19, 0x7b, 0xd9, 0x17, 0xa7, 0x90, 0x0f, 0xbe, 0x21, 0xf6, + /*7e60:*/ 0x7b, 0x58, 0x8f, 0x48, 0x77, 0x0e, 0xac, 0x66, 0xa3, 0x2f, 0x80, 0xee, 0xe6, 0x23, 0x72, 0x03, + /*7e70:*/ 0x8e, 0x56, 0x54, 0x13, 0x1e, 0x06, 0xbc, 0x5d, 0xdf, 0x78, 0xf5, 0x1f, 0x1e, 0x2f, 0xd6, 0x68, + /*7e80:*/ 0x50, 0x1d, 0xaf, 0x61, 0x5d, 0x4b, 0x38, 0x31, 0x2c, 0xef, 0x54, 0x3c, 0x5f, 0xfc, 0xb5, 0x5e, + /*7e90:*/ 0xd9, 0x96, 0x08, 0x31, 0x25, 0x20, 0x42, 0xfb, 0x19, 0xba, 0xc8, 0xf2, 0x0f, 0xe3, 0xfd, 0x5b, + /*7ea0:*/ 0xae, 0x65, 0xba, 0x26, 0xfa, 0x7a, 0xfd, 0x79, 0xfd, 0xda, 0x2b, 0xab, 0xb2, 0x0b, 0x40, 0x55, + /*7eb0:*/ 0x87, 0x81, 0x6d, 0xc1, 0x02, 0xa4, 0xbc, 0x94, 0x89, 0x81, 0x42, 0xe7, 0x40, 0xf0, 0xd0, 0xfe, + /*7ec0:*/ 0x54, 0x56, 0xf8, 0xfa, 0x0c, 0x53, 0xce, 0xac, 0x04, 0xe3, 0xfb, 0xc6, 0x2f, 0x87, 0x6b, 0xde, + /*7ed0:*/ 0x74, 0x0f, 0x7a, 0x5b, 0xb8, 0xf2, 0x0a, 0x66, 0xf0, 0xb2, 0x1e, 0xd8, 0x2f, 0x37, 0xe0, 0xc1, + /*7ee0:*/ 0x45, 0x62, 0x6b, 0x0b, 0xab, 0xe8, 0x1f, 0x31, 0x7a, 0x28, 0xca, 0x54, 0x6f, 0x36, 0x10, 0xd6, + /*7ef0:*/ 0x43, 0xc1, 0xe1, 0x0a, 0x2e, 0xb6, 0xce, 0xaf, 0x45, 0xdc, 0x18, 0x9e, 0xcf, 0x5a, 0xdd, 0xea, + /*7f00:*/ 0x2e, 0xd7, 0xe5, 0x55, 0x49, 0x3e, 0x08, 0x15, 0xf7, 0xe3, 0xf7, 0x78, 0x8e, 0x41, 0xd1, 0xf8, + /*7f10:*/ 0xf4, 0x7a, 0x59, 0x93, 0xc8, 0xdf, 0xdb, 0xe1, 0x88, 0x66, 0x21, 0x84, 0xb7, 0x4d, 0xd6, 0x4a, + /*7f20:*/ 0x61, 0x2c, 0x5b, 0x8b, 0xf4, 0xc3, 0x64, 0xcc, 0x73, 0x69, 0xca, 0x0b, 0x55, 0x38, 0xbd, 0x2a, + /*7f30:*/ 0x6d, 0x1f, 0xad, 0xe4, 0xfe, 0x3a, 0xbf, 0x4a, 0xff, 0x18, 0x5f, 0x9c, 0x5d, 0xa7, 0x2f, 0xbc, + /*7f40:*/ 0x71, 0x8a, 0xe0, 0x82, 0x4a, 0xd8, 0x92, 0xdb, 0xb6, 0x80, 0x29, 0xa4, 0xed, 0x65, 0x3f, 0x72, + /*7f50:*/ 0xc4, 0xbc, 0x05, 0x4f, 0x3a, 0x97, 0x5d, 0x3c, 0x24, 0x50, 0xa4, 0x5b, 0x4e, 0x75, 0xab, 0x20, + /*7f60:*/ 0x96, 0x42, 0xa3, 0x5b, 0x36, 0x74, 0x79, 0xb0, 0xd2, 0xce, 0x49, 0x23, 0xa2, 0x22, 0xd7, 0x21, + /*7f70:*/ 0x66, 0xbe, 0xc4, 0xa9, 0x0c, 0x9d, 0xb3, 0xfc, 0x18, 0x81, 0x48, 0x7e, 0x1b, 0xfa, 0xdf, 0xb8, + /*7f80:*/ 0xba, 0xae, 0x15, 0x16, 0xdf, 0xee, 0x6c, 0x53, 0xf9, 0x6a, 0x80, 0xbb, 0xe0, 0x5e, 0x98, 0x2d, + /*7f90:*/ 0x18, 0xf1, 0x45, 0x99, 0x2d, 0xb8, 0xc6, 0xff, 0x74, 0xf4, 0xaa, 0x0b, 0x94, 0x42, 0x09, 0xb8, + /*7fa0:*/ 0x26, 0x5f, 0x7c, 0x15, 0x17, 0xe0, 0x90, 0x04, 0x96, 0x1e, 0x8d, 0xa9, 0xc3, 0x59, 0xcb, 0x5a, + /*7fb0:*/ 0xc2, 0x22, 0x78, 0x9c, 0xbe, 0xb1, 0xc8, 0x5b, 0x84, 0xda, 0x24, 0x3f, 0x3b, 0xc9, 0x9b, 0x7a, + /*7fc0:*/ 0xbb, 0xfd, 0xe7, 0x4b, 0x23, 0x43, 0xd1, 0x04, 0x98, 0x14, 0x5e, 0x23, 0xdb, 0xb9, 0x18, 0x3c, + /*7fd0:*/ 0x4f, 0xdb, 0xe1, 0x14, 0x1e, 0x30, 0x19, 0xd6, 0xb6, 0x70, 0xd4, 0xe1, 0xe1, 0x40, 0xad, 0xff, + /*7fe0:*/ 0xe9, 0xcc, 0xd5, 0xfa, 0xc1, 0x2b, 0x66, 0x07, 0xde, 0x05, 0x6d, 0xe7, 0x97, 0x75, 0xb9, 0x3f, + /*7ff0:*/ 0x5f, 0xd2, 0xdf, 0xd2, 0xd1, 0x27, 0xfe, 0x29, 0xb7, 0xc5, 0xfa, 0x41, 0xfd, 0x39, 0x39, 0x45, + /*8000:*/ 0xc6, 0x96, 0xa2, 0xd5, 0x25, 0xab, 0x00, 0xe4, 0x4c, 0xc8, 0x48, 0xe5, 0x89, 0xa5, 0x0b, 0x13, + /*8010:*/ 0x82, 0xb5, 0x53, 0xd6, 0x4c, 0x47, 0x7d, 0x28, 0x39, 0xe5, 0xad, 0x94, 0xc4, 0x6d, 0x21, 0x1e, + /*8020:*/ 0xb0, 0x73, 0xd9, 0xcc, 0xa6, 0x2f, 0x0b, 0xf0, 0x9c, 0xd7, 0x5c, 0x5f, 0x99, 0xf6, 0x09, 0x6e, + /*8030:*/ 0x64, 0xb1, 0xce, 0xcc, 0xee, 0x55, 0xd9, 0xeb, 0x51, 0x5f, 0x03, 0x03, 0x6f, 0xc2, 0xea, 0x70, + /*8040:*/ 0xc3, 0x4c, 0xd1, 0x9e, 0x26, 0x06, 0x0f, 0x80, 0x2d, 0xf0, 0x43, 0x75, 0x09, 0x8c, 0x52, 0x6a, + /*8050:*/ 0xbb, 0x76, 0xda, 0x09, 0x2f, 0x00, 0x45, 0xad, 0x9a, 0x24, 0x12, 0x4c, 0x29, 0x58, 0x67, 0x4f, + /*8060:*/ 0xd8, 0xdd, 0xe9, 0x62, 0xd4, 0x95, 0x0d, 0x83, 0x62, 0xfe, 0x66, 0xad, 0x12, 0x06, 0xe1, 0x16, + /*8070:*/ 0xb8, 0x89, 0xb4, 0x9f, 0xa6, 0xb6, 0x4f, 0xa7, 0xfe, 0x72, 0xd5, 0xbc, 0x7c, 0x84, 0x62, 0xe2, + /*8080:*/ 0xb1, 0xfb, 0x0c, 0x54, 0xed, 0x69, 0x96, 0x68, 0x5c, 0x1b, 0xcf, 0xa3, 0x56, 0xdd, 0x0b, 0x78, + /*8090:*/ 0x9c, 0x5d, 0x7d, 0x9d, 0x05, 0x79, 0x72, 0xb9, 0xa9, 0x6e, 0xd1, 0xfb, 0x0c, 0x28, 0x2b, 0xa9, + /*80a0:*/ 0xf4, 0xb3, 0x41, 0xb1, 0x12, 0xe0, 0xe3, 0xf4, 0xf0, 0x6c, 0x86, 0x50, 0xf0, 0xaf, 0x23, 0x87, + /*80b0:*/ 0x67, 0x91, 0xe2, 0x07, 0x6c, 0x77, 0x16, 0xf9, 0x5f, 0x83, 0x8a, 0x46, 0xb6, 0xe3, 0x02, 0x59, + /*80c0:*/ 0x77, 0xaf, 0x3e, 0x98, 0x33, 0x3f, 0xb6, 0xf4, 0x02, 0x23, 0x50, 0xd8, 0x4b, 0xc9, 0x4e, 0xd9, + /*80d0:*/ 0x00, 0xe9, 0x68, 0x13, 0x44, 0xed, 0x2c, 0x4d, 0xd7, 0x60, 0xb4, 0x69, 0xc6, 0xd4, 0xe7, 0xc6, + /*80e0:*/ 0x57, 0xe4, 0xb0, 0x5d, 0x74, 0x51, 0xb5, 0x09, 0x54, 0x11, 0x58, 0x1b, 0xab, 0xf6, 0x54, 0xfb, + /*80f0:*/ 0xe4, 0xaa, 0x99, 0xb0, 0xc2, 0xa8, 0xc3, 0x2d, 0x52, 0x95, 0x39, 0x51, 0x4b, 0x18, 0x83, 0xe6, + /*8100:*/ 0xfc, 0x55, 0xd5, 0x0a, 0xae, 0x93, 0x70, 0x97, 0x60, 0x65, 0x63, 0x61, 0x72, 0x65, 0x9a, 0xe8, + /*8110:*/ 0x13, 0x86, 0x99, 0x14, 0x75, 0xca, 0xe2, 0x9b, 0x40, 0xaf, 0x63, 0x49, 0x50, 0xfc, 0x1d, 0x9b, + /*8120:*/ 0x2a, 0x26, 0xee, 0xbc, 0x88, 0x78, 0x1d, 0xd8, 0xd6, 0x51, 0x8b, 0x8f, 0x45, 0xf9, 0xe0, 0x4b, + /*8130:*/ 0x70, 0xb4, 0x6b, 0x84, 0x42, 0xe5, 0x7b, 0x26, 0xf0, 0xb4, 0xff, 0x15, 0x70, 0x23, 0xc7, 0xd6, + /*8140:*/ 0xd7, 0xa0, 0x22, 0x84, 0x8f, 0x3d, 0xd6, 0x25, 0x26, 0x22, 0x3e, 0xcf, 0x81, 0x67, 0x1e, 0xdc, + /*8150:*/ 0x23, 0xc7, 0x2a, 0xe7, 0x2e, 0x68, 0x65, 0x06, 0x2f, 0xe0, 0x57, 0xe0, 0x89, 0x27, 0x5f, 0xc6, + /*8160:*/ 0x81, 0x85, 0x04, 0xb0, 0xa3, 0xc9, 0xde, 0xe3, 0x4f, 0x68, 0x4d, 0xc7, 0xa2, 0xc9, 0xc2, 0x6c, + /*8170:*/ 0x42, 0x37, 0x7d, 0x94, 0xe4, 0x61, 0x26, 0x39, 0x26, 0xc7, 0x30, 0xd9, 0xfc, 0x5a, 0x82, 0x44, + /*8180:*/ 0xee, 0x2c, 0x82, 0x2f, 0xa3, 0x66, 0xfc, 0x7a, 0x6b, 0xde, 0x3a, 0xf8, 0xad, 0xc4, 0xcc, 0xdf, + /*8190:*/ 0x4f, 0x38, 0xf0, 0x1e, 0xd8, 0x0d, 0x7d, 0x98, 0x6b, 0x74, 0xa5, 0xd7, 0x10, 0xce, 0xa0, 0x53, + /*81a0:*/ 0x72, 0x51, 0xf1, 0x5a, 0xa0, 0x01, 0x2c, 0x33, 0xe5, 0xfe, 0x25, 0xeb, 0x6c, 0xe3, 0x79, 0x02, + /*81b0:*/ 0x87, 0x5a, 0x56, 0xe9, 0xb6, 0xd0, 0xd1, 0x41, 0xe4, 0x2f, 0x53, 0xed, 0xbd, 0x22, 0x14, 0xe0, + /*81c0:*/ 0x2d, 0x48, 0x8c, 0xb9, 0x67, 0xd8, 0x7b, 0x27, 0x58, 0x7a, 0x7c, 0xc8, 0xd6, 0x48, 0xec, 0xd9, + /*81d0:*/ 0xba, 0xcf, 0xd1, 0xc4, 0xbd, 0x7f, 0x38, 0xb7, 0xdf, 0x4a, 0xff, 0x99, 0xd8, 0xf4, 0xaa, 0xbf, + /*81e0:*/ 0x68, 0x9a, 0xcb, 0x63, 0xcd, 0x01, 0x05, 0x53, 0xfd, 0xae, 0xcd, 0xd7, 0xfe, 0xa7, 0x79, 0x42, + /*81f0:*/ 0x85, 0x63, 0x40, 0x44, 0x65, 0x1b, 0x83, 0x70, 0x16, 0x1f, 0xc0, 0xf1, 0xb2, 0x49, 0x0f, 0x99, + /*8200:*/ 0x40, 0xbe, 0x21, 0xfa, 0x8e, 0x85, 0xb7, 0x9d, 0xee, 0x28, 0xbc, 0xac, 0x2b, 0x85, 0x3b, 0xdf, + /*8210:*/ 0x4a, 0x72, 0x81, 0x6d, 0x0e, 0x75, 0x58, 0x34, 0x41, 0x5b, 0xa3, 0x0f, 0x00, 0x1b, 0x28, 0xcf, + /*8220:*/ 0xa7, 0x57, 0x4e, 0x78, 0x41, 0x7c, 0xf9, 0x4e, 0x44, 0xcb, 0x6f, 0x4b, 0x88, 0x84, 0x73, 0x4f, + /*8230:*/ 0xfa, 0x4a, 0xc4, 0xa9, 0xad, 0xd7, 0xeb, 0x1d, 0x52, 0xe4, 0xd7, 0xa3, 0xdc, 0x37, 0xae, 0x23, + /*8240:*/ 0xe3, 0xa6, 0x91, 0x02, 0x75, 0xf0, 0x16, 0xbb, 0x24, 0x09, 0x15, 0xa3, 0x79, 0xe2, 0xd9, 0x66, + /*8250:*/ 0x25, 0x27, 0xe8, 0x5e, 0x72, 0x7d, 0xc6, 0x38, 0xac, 0xfb, 0x62, 0x3b, 0x7d, 0x23, 0xe6, 0xbf, + /*8260:*/ 0x94, 0x12, 0x15, 0xcb, 0xd7, 0x73, 0xd7, 0xc9, 0x02, 0xff, 0xa5, 0xae, 0x15, 0x45, 0xc7, 0xfd, + /*8270:*/ 0x82, 0x77, 0x54, 0xd3, 0xc0, 0xcb, 0xc6, 0x1c, 0x8d, 0x58, 0x51, 0xd2, 0x82, 0x66, 0x03, 0x84, + /*8280:*/ 0x5a, 0x16, 0xad, 0x90, 0x0b, 0x29, 0x98, 0x6c, 0xa1, 0x53, 0xc3, 0x8e, 0x9e, 0x30, 0x61, 0x6f, + /*8290:*/ 0xc0, 0xc1, 0x8e, 0x61, 0x67, 0x82, 0x32, 0xb8, 0xa7, 0x4c, 0xa6, 0x78, 0x28, 0x72, 0xed, 0xc9, + /*82a0:*/ 0x17, 0x6d, 0xf4, 0xe1, 0x83, 0x9c, 0xa3, 0xc8, 0x57, 0x47, 0xf6, 0x0f, 0xa5, 0x43, 0x36, 0x78, + /*82b0:*/ 0x53, 0xd2, 0xf7, 0x75, 0xc2, 0x93, 0xb5, 0x4b, 0x5a, 0xbf, 0xa0, 0xfe, 0x09, 0xb3, 0xa4, 0x69, + /*82c0:*/ 0x3e, 0xee, 0x5e, 0xb1, 0xe6, 0x2b, 0xca, 0x21, 0x62, 0xed, 0xf5, 0x3a, 0xa6, 0x3c, 0x41, 0x44, + /*82d0:*/ 0x75, 0x03, 0xc8, 0x1e, 0x7f, 0x82, 0x5c, 0x9f, 0x77, 0x72, 0x73, 0xcf, 0xf4, 0x9e, 0x20, 0x63, + /*82e0:*/ 0x60, 0xe1, 0x4b, 0x42, 0xb4, 0xa1, 0xdf, 0xda, 0xdc, 0x2e, 0xda, 0x4f, 0xba, 0xf2, 0x2a, 0x44, + /*82f0:*/ 0x7a, 0x82, 0x40, 0xb9, 0x5d, 0xa2, 0x61, 0x1e, 0xea, 0xff, 0x9a, 0xd7, 0x85, 0x8b, 0x2a, 0x88, + /*8300:*/ 0x6a, 0xbc, 0xdb, 0x16, 0x1b, 0x43, 0x02, 0xbd, 0x36, 0xa1, 0x9e, 0x86, 0x45, 0x15, 0x4b, 0x07, + /*8310:*/ 0x05, 0xe0, 0x64, 0x85, 0xda, 0xc3, 0x61, 0xdd, 0xc6, 0xf7, 0xf1, 0x6b, 0xe0, 0xf0, 0x0b, 0xcd, + /*8320:*/ 0x6d, 0x6e, 0x33, 0x05, 0xdf, 0x4e, 0x18, 0x79, 0xfc, 0x85, 0x30, 0xf1, 0x04, 0xa8, 0x7a, 0x9a, + /*8330:*/ 0xbe, 0x72, 0x8f, 0x92, 0x30, 0xd8, 0x04, 0x19, 0xbc, 0x26, 0xc5, 0xe6, 0x71, 0xd3, 0x4d, 0xfc, + /*8340:*/ 0xe8, 0x44, 0xca, 0x60, 0xb6, 0x0a, 0x2f, 0x8a, 0x36, 0x83, 0x54, 0x6f, 0x68, 0xcd, 0xa6, 0x60, + /*8350:*/ 0x64, 0xdc, 0xcd, 0xde, 0xeb, 0x92, 0x47, 0x61, 0xce, 0xc7, 0xa9, 0x99, 0xd9, 0xad, 0x4e, 0x4d, + /*8360:*/ 0x11, 0xb5, 0x10, 0x46, 0x31, 0x91, 0x66, 0x42, 0xad, 0xe1, 0xb9, 0x79, 0x93, 0x62, 0xde, 0x40, + /*8370:*/ 0xd5, 0x1b, 0x74, 0x70, 0x73, 0xb1, 0xa7, 0xa3, 0x85, 0xcd, 0x55, 0x62, 0x8b, 0x2c, 0xf9, 0xcf, + /*8380:*/ 0xa5, 0x7f, 0x02, 0x3f, 0x58, 0x04, 0x7c, 0x02, 0x6f, 0x4d, 0xd4, 0x67, 0x95, 0x94, 0xf5, 0x42, + /*8390:*/ 0x57, 0xf9, 0xa1, 0x65, 0xc6, 0x2e, 0xb6, 0x7d, 0x1b, 0x93, 0x5b, 0xa3, 0x2d, 0x32, 0x77, 0x6b, + /*83a0:*/ 0xb0, 0xcd, 0xd6, 0x9b, 0xd6, 0x11, 0x7b, 0x5b, 0xc5, 0x10, 0x86, 0xc9, 0x74, 0x35, 0xfa, 0x67, + /*83b0:*/ 0xbc, 0xea, 0x5d, 0x46, 0x5c, 0xf6, 0x4f, 0xb7, 0x86, 0x58, 0xda, 0x5c, 0x38, 0xf5, 0x68, 0xb8, + /*83c0:*/ 0xcf, 0xbb, 0x7e, 0x76, 0x0d, 0xdd, 0x1b, 0x28, 0xcd, 0x4f, 0xb3, 0x99, 0x8c, 0x11, 0xef, 0x6e, + /*83d0:*/ 0x1b, 0xf0, 0x81, 0xb4, 0x6b, 0xb9, 0x34, 0xa4, 0x93, 0x5d, 0xf1, 0xca, 0xef, 0x45, 0x60, 0xc2, + /*83e0:*/ 0x35, 0xdf, 0x01, 0xcf, 0x2b, 0x3a, 0xb6, 0x1f, 0xd1, 0x8d, 0x3d, 0xe7, 0x12, 0x60, 0xed, 0xc4, + /*83f0:*/ 0x0b, 0x36, 0x84, 0xe3, 0x6b, 0x75, 0x09, 0x2a, 0x95, 0xad, 0xa5, 0x37, 0x4f, 0x75, 0xc5, 0x13, + /*8400:*/ 0x61, 0x74, 0x17, 0x83, 0x86, 0x94, 0x94, 0xfe, 0x0e, 0x7d, 0xc1, 0x54, 0x6b, 0x13, 0x3b, 0xd9, + /*8410:*/ 0x7c, 0xf7, 0x90, 0x56, 0x7d, 0x30, 0x42, 0xd0, 0x82, 0x42, 0xc3, 0x3a, 0x52, 0xdf, 0x70, 0x24, + /*8420:*/ 0xb3, 0xcb, 0x25, 0x15, 0x2d, 0x4e, 0xa9, 0xd4, 0x56, 0x33, 0xb9, 0x79, 0xca, 0xbd, 0xcc, 0x56, + /*8430:*/ 0x9f, 0x13, 0xc0, 0x44, 0xe4, 0x71, 0xdf, 0x2d, 0xf2, 0x55, 0x49, 0xae, 0x0f, 0x10, 0x4d, 0x03, + /*8440:*/ 0x08, 0x59, 0x6d, 0xf9, 0xb1, 0xd8, 0x14, 0x88, 0xdd, 0x0e, 0x0f, 0xa9, 0xbc, 0x5d, 0x74, 0xff, + /*8450:*/ 0x9b, 0xf8, 0x8c, 0xbb, 0xdf, 0xb4, 0x60, 0x64, 0x2f, 0x7b, 0x5e, 0x83, 0x52, 0xf5, 0x7a, 0xf7, + /*8460:*/ 0x33, 0x50, 0x08, 0x07, 0xb0, 0x2e, 0x7e, 0x88, 0xa8, 0x4b, 0xd2, 0xe5, 0xbc, 0x9c, 0xf2, 0x1b, + /*8470:*/ 0x64, 0xe9, 0x1c, 0x65, 0xb4, 0xec, 0x97, 0x0d, 0xd3, 0xa0, 0x8e, 0x02, 0xe9, 0x2b, 0xb1, 0x05, + /*8480:*/ 0x74, 0xe9, 0x8c, 0x18, 0x27, 0xcd, 0x6c, 0x59, 0x5d, 0xfd, 0xf3, 0x56, 0x5e, 0x56, 0xd7, 0xf0, + /*8490:*/ 0xa4, 0x0a, 0xc0, 0x16, 0x81, 0x07, 0x41, 0xc7, 0xf0, 0xe1, 0x08, 0x1a, 0xf8, 0xa8, 0x0f, 0xa7, + /*84a0:*/ 0x23, 0x95, 0xaa, 0x49, 0x3c, 0x5e, 0xb2, 0x7f, 0x69, 0xf3, 0x3d, 0xdd, 0xb4, 0x56, 0x96, 0xdb, + /*84b0:*/ 0xea, 0xf2, 0x34, 0xa8, 0xd0, 0xb7, 0x72, 0x98, 0x47, 0x15, 0x93, 0xf6, 0x57, 0x9c, 0xb1, 0x26, + /*84c0:*/ 0xf1, 0x00, 0xdf, 0xe8, 0xfb, 0x81, 0x15, 0x0f, 0x8d, 0x33, 0x9e, 0x79, 0x0e, 0x41, 0xf4, 0x16, + /*84d0:*/ 0x31, 0xdd, 0xfd, 0xec, 0x7d, 0x4b, 0x7e, 0x3b, 0xd7, 0x71, 0xf1, 0x1c, 0xb2, 0x53, 0x2b, 0x6f, + /*84e0:*/ 0xc5, 0x58, 0xf1, 0x50, 0xfe, 0xc3, 0x29, 0x82, 0xd2, 0xf4, 0x7c, 0xd7, 0x42, 0x8a, 0x7a, 0x83, + /*84f0:*/ 0x79, 0x42, 0x62, 0xde, 0x92, 0x64, 0x58, 0x6e, 0x9b, 0x24, 0x8d, 0x16, 0xb8, 0xf9, 0x83, 0xf9, + /*8500:*/ 0x8a, 0x35, 0x67, 0xf7, 0x07, 0xd5, 0x43, 0xd0, 0xc6, 0x71, 0x35, 0xfb, 0xb5, 0x9f, 0x0d, 0x84, + /*8510:*/ 0x9e, 0xa9, 0x69, 0x3b, 0x4e, 0x3c, 0xa3, 0x72, 0xd7, 0x48, 0xaf, 0xae, 0xba, 0xae, 0x4a, 0xf7, + /*8520:*/ 0x06, 0xce, 0xf6, 0xc8, 0x41, 0x0a, 0x7e, 0xfb, 0x76, 0xc6, 0xb0, 0xcc, 0xa9, 0xd9, 0xd3, 0xb6, + /*8530:*/ 0xfe, 0xc5, 0x62, 0x99, 0x28, 0x03, 0xdb, 0xa8, 0x10, 0xe9, 0xd2, 0x3b, 0x1b, 0xe2, 0xf5, 0x1b, + /*8540:*/ 0x81, 0xea, 0xfd, 0xd2, 0x9f, 0x34, 0xc8, 0xca, 0x58, 0x6d, 0x74, 0xbf, 0x2b, 0x53, 0x17, 0xf2, + /*8550:*/ 0x64, 0x15, 0xc0, 0x31, 0x77, 0x7a, 0x00, 0xcd, 0x28, 0x72, 0x56, 0x82, 0x81, 0xb8, 0xd8, 0x56, + /*8560:*/ 0x0f, 0xe1, 0xa3, 0xc2, 0xf8, 0x78, 0x01, 0x9f, 0x76, 0xd8, 0x77, 0xf6, 0x06, 0x78, 0x4c, 0xf4, + /*8570:*/ 0xf8, 0xab, 0x09, 0x9f, 0x81, 0x7c, 0xdf, 0x6c, 0x79, 0x0f, 0xb8, 0xed, 0xec, 0x92, 0x68, 0xb1, + /*8580:*/ 0x0d, 0xed, 0x5c, 0x62, 0xe1, 0x94, 0x91, 0xfd, 0x39, 0xbe, 0x65, 0x59, 0x45, 0xfb, 0x59, 0xe1, + /*8590:*/ 0xbd, 0xad, 0xbc, 0x41, 0xa0, 0x94, 0x49, 0xec, 0x29, 0x06, 0xe9, 0xd8, 0x64, 0x04, 0xe1, 0x70, + /*85a0:*/ 0x31, 0xb9, 0xe4, 0xdf, 0x23, 0xf9, 0x7d, 0x0f, 0x5d, 0x9a, 0xa6, 0x67, 0x4c, 0xde, 0xdd, 0xb6, + /*85b0:*/ 0xb2, 0xc5, 0x33, 0x87, 0xee, 0xb8, 0x36, 0xaa, 0x32, 0xdb, 0xc4, 0x90, 0x9b, 0xe0, 0xc2, 0x6c, + /*85c0:*/ 0xcd, 0xae, 0xff, 0x7e, 0x9a, 0x35, 0xa7, 0x4e, 0x48, 0xe2, 0x62, 0x1b, 0x0e, 0x7d, 0x9b, 0x44, + /*85d0:*/ 0x43, 0xbd, 0x55, 0x82, 0x88, 0x1a, 0x9c, 0x83, 0xfc, 0x1e, 0x3d, 0x8b, 0x6b, 0x29, 0x23, 0xf8, + /*85e0:*/ 0x1e, 0xba, 0xb4, 0x5b, 0xc5, 0x80, 0x12, 0x70, 0x48, 0x9b, 0x41, 0xfb, 0xe6, 0xc8, 0xf3, 0x19, + /*85f0:*/ 0x15, 0x7b, 0xc0, 0x8d, 0xb0, 0x49, 0x67, 0xcc, 0xf4, 0xe0, 0x12, 0x41, 0xf9, 0xfb, 0xd4, 0x1a, + /*8600:*/ 0xe8, 0x72, 0x1b, 0xfc, 0x02, 0xbe, 0x6d, 0x34, 0x96, 0xaf, 0xba, 0x96, 0x44, 0x7d, 0xce, 0x3f, + /*8610:*/ 0x0e, 0x58, 0x7b, 0xb1, 0x0d, 0xb7, 0x00, 0x43, 0x6d, 0x81, 0xaa, 0xa6, 0xe4, 0x5c, 0xf1, 0xa4, + /*8620:*/ 0x1f, 0xe4, 0xa8, 0x30, 0x2b, 0x0c, 0xbf, 0xdd, 0x69, 0xfa, 0xe7, 0xf7, 0x44, 0xff, 0x50, 0x2b, + /*8630:*/ 0x39, 0x73, 0xbd, 0x03, 0x22, 0x84, 0xef, 0x14, 0x08, 0x74, 0xa8, 0x85, 0x05, 0x64, 0xd4, 0xc7, + /*8640:*/ 0x30, 0xa4, 0x84, 0x2e, 0xbd, 0x8d, 0x0c, 0xee, 0xfc, 0x11, 0x0f, 0x0c, 0x3f, 0xb1, 0x48, 0x6e, + /*8650:*/ 0xb6, 0x09, 0x01, 0xc8, 0x54, 0x6a, 0xe7, 0x1b, 0x46, 0x90, 0x5b, 0x79, 0x64, 0x08, 0xa8, 0xda, + /*8660:*/ 0xb0, 0x7e, 0x1f, 0xc3, 0x8c, 0xee, 0x9e, 0x9f, 0x8b, 0x9b, 0xc2, 0x80, 0x2f, 0x4f, 0x0d, 0x3a, + /*8670:*/ 0x97, 0x3b, 0xcd, 0xfa, 0xde, 0xa0, 0xaf, 0x6d, 0x1e, 0xd2, 0x47, 0x31, 0xe0, 0xf3, 0xcf, 0x15, + /*8680:*/ 0x12, 0xae, 0x45, 0xbb, 0x28, 0x04, 0x5e, 0xf6, 0x2e, 0xab, 0xa5, 0x8f, 0xea, 0xd0, 0xa4, 0xbf, + /*8690:*/ 0xbe, 0xa7, 0x77, 0x5d, 0x7b, 0xab, 0x48, 0x5f, 0x1a, 0xe4, 0xc6, 0xb3, 0x62, 0x70, 0xdf, 0x82, + /*86a0:*/ 0x24, 0x59, 0xd6, 0x88, 0x5c, 0x36, 0xd6, 0x0c, 0xbe, 0xbc, 0xbd, 0xc6, 0x1a, 0xcb, 0x93, 0xfa, + /*86b0:*/ 0xff, 0x16, 0x26, 0xea, 0xd2, 0xd3, 0x41, 0x5a, 0x49, 0x00, 0x99, 0x12, 0x48, 0xbe, 0xa8, 0xc7, + /*86c0:*/ 0xe3, 0x5d, 0x3b, 0xb1, 0x40, 0x35, 0xee, 0xfe, 0xc3, 0x78, 0x2b, 0xfe, 0x10, 0x20, 0xc9, 0x96, + /*86d0:*/ 0x28, 0xc2, 0xb2, 0x17, 0x03, 0x69, 0x85, 0x74, 0xf5, 0xac, 0x28, 0x02, 0xd0, 0x97, 0x74, 0xf2, + /*86e0:*/ 0x22, 0x12, 0x80, 0xf1, 0x1b, 0xd8, 0x49, 0x1d, 0x70, 0x79, 0x56, 0x7a, 0xbb, 0x2e, 0x5b, 0x35, + /*86f0:*/ 0x17, 0x34, 0x9b, 0xef, 0xf8, 0x58, 0x8d, 0x4b, 0xf3, 0x9a, 0x7a, 0xb3, 0xf7, 0x8c, 0x08, 0x4c, + /*8700:*/ 0x1f, 0xe4, 0x47, 0x30, 0xa2, 0x16, 0x9e, 0xe3, 0x5f, 0xb6, 0x57, 0xb3, 0x93, 0x8f, 0xd0, 0x5e, + /*8710:*/ 0x3b, 0x8d, 0x64, 0x70, 0x7c, 0xbc, 0x6e, 0xc0, 0x12, 0x4b, 0x1e, 0xcd, 0x0b, 0x58, 0x5c, 0xed, + /*8720:*/ 0x19, 0x2f, 0x72, 0x39, 0xaf, 0x03, 0xaf, 0x8f, 0xe0, 0xc1, 0x3f, 0xcc, 0x8a, 0x9a, 0x95, 0x12, + /*8730:*/ 0x7c, 0x88, 0x38, 0x7d, 0x82, 0xdb, 0xbe, 0x58, 0xbb, 0xa8, 0x9b, 0x05, 0x5f, 0x81, 0xe4, 0xaa, + /*8740:*/ 0x58, 0x81, 0xdc, 0x5f, 0x8a, 0x7c, 0xc0, 0xbc, 0x57, 0xa8, 0x48, 0xa4, 0x7e, 0xd5, 0x6d, 0xc4, + /*8750:*/ 0x04, 0x62, 0xbd, 0x28, 0x0e, 0x5c, 0x97, 0x3b, 0xf2, 0x6f, 0xee, 0xe9, 0x0d, 0x5a, 0x9c, 0x79, + /*8760:*/ 0x17, 0xfe, 0xac, 0x66, 0xb0, 0xa6, 0x6e, 0x11, 0x9b, 0xbe, 0x0b, 0xb4, 0x32, 0x67, 0x47, 0x14, + /*8770:*/ 0x70, 0xd6, 0x1c, 0x8c, 0x8f, 0x95, 0x96, 0xa8, 0x46, 0x10, 0x82, 0x49, 0xb7, 0x69, 0xb7, 0x40, + /*8780:*/ 0x83, 0xad, 0xfa, 0x1f, 0x89, 0x05, 0x8a, 0x16, 0x58, 0xee, 0x9c, 0xfd, 0x9f, 0x0c, 0xc6, 0xca, + /*8790:*/ 0xaf, 0x47, 0x5a, 0x00, 0xcd, 0xd6, 0x83, 0x8d, 0x04, 0xf6, 0x18, 0xc7, 0xf3, 0xd2, 0x4c, 0x7c, + /*87a0:*/ 0xdf, 0xc8, 0x61, 0xa9, 0x82, 0x96, 0xf3, 0x18, 0x77, 0xe2, 0x0a, 0x2c, 0x77, 0x67, 0x3c, 0x65, + /*87b0:*/ 0xd4, 0x56, 0xb0, 0xa6, 0x57, 0x0e, 0x74, 0xc9, 0xb5, 0x5e, 0xde, 0xe3, 0x09, 0x69, 0x53, 0x77, + /*87c0:*/ 0xdf, 0xd6, 0x20, 0xba, 0x19, 0xd6, 0x16, 0xbd, 0x4c, 0x95, 0x94, 0x00, 0x4a, 0xf8, 0x72, 0x83, + /*87d0:*/ 0x4c, 0xf2, 0x96, 0xa7, 0x1e, 0xf9, 0x62, 0x98, 0x64, 0x1a, 0xa5, 0x40, 0xb1, 0xbe, 0xd5, 0xb6, + /*87e0:*/ 0x53, 0x5f, 0xb9, 0xce, 0xa3, 0xcf, 0x03, 0x46, 0x94, 0x85, 0xd8, 0xc4, 0x86, 0x23, 0x85, 0x08, + /*87f0:*/ 0x1a, 0x13, 0xa2, 0x41, 0xf6, 0x9d, 0x52, 0xc6, 0xb2, 0x67, 0xe3, 0x30, 0x23, 0xcb, 0x3a, 0x4b, + /*8800:*/ 0x41, 0x57, 0x5f, 0xd2, 0x75, 0x8b, 0x5f, 0x44, 0x39, 0x40, 0x34, 0x25, 0xf1, 0xda, 0x0a, 0xb0, + /*8810:*/ 0xf0, 0xac, 0x15, 0x8d, 0xee, 0x68, 0x5c, 0x39, 0xbf, 0x48, 0x9a, 0x82, 0xfd, 0x81, 0x45, 0x7e, + /*8820:*/ 0xce, 0x81, 0xe6, 0x97, 0x3d, 0xf4, 0x21, 0x8c, 0x9b, 0x36, 0xe6, 0xd0, 0xbf, 0xcc, 0xf2, 0x33, + /*8830:*/ 0x4e, 0x98, 0x70, 0x3f, 0x08, 0x52, 0x9f, 0xd4, 0x48, 0xf3, 0x0a, 0xd8, 0x51, 0xfb, 0x39, 0x9b, + /*8840:*/ 0x8a, 0xf1, 0x32, 0x55, 0xf0, 0x59, 0x68, 0x17, 0xc8, 0x35, 0xe3, 0x38, 0x8c, 0x40, 0xd4, 0xf7, + /*8850:*/ 0xd3, 0xe7, 0x20, 0x07, 0x84, 0xf8, 0xc0, 0x9a, 0x2c, 0x56, 0x6d, 0xaa, 0xae, 0xca, 0x16, 0x82, + /*8860:*/ 0x9a, 0xd1, 0x72, 0x2e, 0xd4, 0x12, 0xda, 0x65, 0xe6, 0x78, 0x01, 0x79, 0x16, 0xa2, 0x05, 0x45, + /*8870:*/ 0x0b, 0xbc, 0x65, 0xd4, 0xf5, 0x19, 0x9d, 0x1f, 0xa4, 0x49, 0x02, 0xe3, 0x0f, 0x1a, 0x82, 0x49, + /*8880:*/ 0x2c, 0xd2, 0x22, 0xdf, 0x97, 0x7d, 0xe6, 0xaf, 0x14, 0x03, 0xdf, 0x69, 0xe6, 0xf3, 0x07, 0x50, + /*8890:*/ 0x48, 0xe5, 0x42, 0xfe, 0xe3, 0x59, 0x91, 0x6d, 0xbc, 0xf6, 0xd1, 0xf0, 0x2a, 0xbd, 0x0a, 0x4d, + /*88a0:*/ 0x4f, 0x51, 0x6e, 0x0f, 0x76, 0xef, 0xa8, 0xb5, 0xa7, 0x8b, 0x49, 0xf3, 0xd5, 0x8e, 0xf4, 0x41, + /*88b0:*/ 0xf9, 0x57, 0x26, 0x2f, 0xcf, 0xa8, 0xd7, 0x76, 0x36, 0xd1, 0xf1, 0xb9, 0x26, 0x79, 0x92, 0xaf, + /*88c0:*/ 0xcc, 0xf6, 0xe9, 0xab, 0xf2, 0x96, 0xec, 0x5e, 0xbb, 0xcc, 0xf0, 0x89, 0x39, 0xc1, 0x83, 0x8f, + /*88d0:*/ 0xf5, 0x07, 0xb6, 0x17, 0x61, 0x17, 0x1c, 0xcd, 0xb6, 0x3b, 0xcc, 0x68, 0x8d, 0x52, 0x96, 0x18, + /*88e0:*/ 0xbf, 0x18, 0x00, 0xcf, 0xf5, 0x9c, 0x81, 0x20, 0xb0, 0xed, 0x63, 0xef, 0x1e, 0xa2, 0xac, 0x84, + /*88f0:*/ 0x19, 0xd8, 0x9a, 0x28, 0x68, 0x27, 0xb1, 0x99, 0x54, 0x4b, 0xe4, 0x0b, 0xcc, 0x55, 0x9e, 0x49, + /*8900:*/ 0xdb, 0xbc, 0x4d, 0x85, 0x1d, 0x83, 0x83, 0x46, 0x64, 0x27, 0xe1, 0x6d, 0x25, 0x24, 0x72, 0xfe, + /*8910:*/ 0xfb, 0x37, 0x67, 0x48, 0xf0, 0x7f, 0x7a, 0xbc, 0x9c, 0x9b, 0xa6, 0xe0, 0x55, 0xa4, 0x98, 0x3b, + /*8920:*/ 0x8e, 0xbe, 0x5b, 0x92, 0x29, 0x5e, 0xcd, 0x46, 0xcd, 0x83, 0x43, 0xfb, 0x8a, 0xaf, 0x68, 0x89, + /*8930:*/ 0xc6, 0x68, 0x32, 0x83, 0x7c, 0x33, 0x6e, 0xf9, 0x8f, 0x53, 0x40, 0xda, 0x2c, 0x6f, 0xcc, 0x7a, + /*8940:*/ 0xd7, 0x90, 0xd7, 0xc0, 0x29, 0x9d, 0xb7, 0x08, 0xe0, 0xa4, 0x41, 0x25, 0x7e, 0x39, 0x04, 0xf3, + /*8950:*/ 0x02, 0xb8, 0x4e, 0x3e, 0xee, 0x80, 0x07, 0x20, 0xdc, 0x49, 0x16, 0x9e, 0xab, 0xb0, 0x81, 0xd3, + /*8960:*/ 0x33, 0x00, 0xfe, 0xf6, 0x85, 0xcd, 0xf8, 0xe6, 0x79, 0x87, 0x1a, 0x5b, 0x1e, 0x11, 0x1b, 0xca, + /*8970:*/ 0x89, 0x35, 0xa5, 0x3a, 0x98, 0x0f, 0x4d, 0x20, 0x25, 0xe4, 0xbf, 0x48, 0x6d, 0x2c, 0x03, 0x97, + /*8980:*/ 0xff, 0xbb, 0x85, 0x3b, 0x1f, 0x17, 0x4f, 0xd6, 0xf4, 0xd4, 0xb8, 0x80, 0x49, 0x1a, 0x52, 0x26, + /*8990:*/ 0xbd, 0x81, 0x41, 0xe8, 0xc3, 0x63, 0x67, 0xf3, 0xe5, 0xeb, 0x57, 0xbe, 0x28, 0x83, 0xef, 0x3f, + /*89a0:*/ 0xcc, 0xff, 0x4f, 0xed, 0x19, 0xce, 0xe9, 0xe5, 0x0d, 0x1e, 0x0c, 0xd3, 0x8d, 0xed, 0xa3, 0x47, + /*89b0:*/ 0xb7, 0x1d, 0x63, 0x61, 0xc7, 0xfe, 0x36, 0xfa, 0x05, 0x30, 0xd9, 0x36, 0x04, 0xb8, 0x05, 0x1b, + /*89c0:*/ 0x89, 0xf3, 0xc0, 0x81, 0x07, 0xd5, 0xdf, 0x7f, 0x17, 0x5c, 0xaf, 0x75, 0x35, 0xeb, 0x2b, 0xac, + /*89d0:*/ 0x48, 0xd6, 0x07, 0xe7, 0x72, 0x3e, 0xa6, 0x30, 0x75, 0x77, 0x03, 0x74, 0x31, 0xe5, 0x8b, 0x10, + /*89e0:*/ 0xd0, 0x2a, 0x3c, 0xc7, 0x7d, 0xd4, 0x4e, 0xa5, 0xc9, 0xc7, 0xd1, 0xb8, 0xdb, 0x9d, 0x34, 0xbb, + /*89f0:*/ 0xce, 0x26, 0x16, 0x60, 0x38, 0x95, 0x28, 0x78, 0x60, 0xcb, 0x3f, 0xbd, 0xaa, 0x93, 0xed, 0xb3, + /*8a00:*/ 0x0d, 0xd0, 0x8c, 0xf4, 0x69, 0x24, 0x35, 0x84, 0x60, 0x2b, 0x48, 0x5b, 0x9a, 0x7e, 0xb8, 0xe1, + /*8a10:*/ 0xec, 0x6a, 0x17, 0x17, 0xb9, 0xdc, 0x5d, 0xa9, 0xf2, 0x95, 0x7f, 0xf5, 0xe7, 0x6c, 0x79, 0x93, + /*8a20:*/ 0xab, 0xb2, 0x52, 0x1a, 0x39, 0x5b, 0x3e, 0x49, 0x18, 0x19, 0x3c, 0xe7, 0x7e, 0xf4, 0x95, 0x96, + /*8a30:*/ 0x79, 0x30, 0xc0, 0x3f, 0x7a, 0xde, 0x28, 0xd9, 0x95, 0xe3, 0x69, 0x5b, 0xa5, 0x10, 0xb3, 0xe6, + /*8a40:*/ 0x1c, 0x01, 0xcc, 0xd4, 0xf2, 0x58, 0x76, 0x52, 0x9b, 0x1e, 0xa1, 0x90, 0xb0, 0xa4, 0x8e, 0x3e, + /*8a50:*/ 0x9f, 0x46, 0x9e, 0xa8, 0x75, 0x15, 0xe7, 0xfb, 0xf8, 0x5b, 0xb4, 0x55, 0x92, 0x12, 0x1b, 0x07, + /*8a60:*/ 0xb0, 0xe9, 0x0e, 0xf7, 0xf6, 0x1c, 0x7b, 0x31, 0x35, 0x2c, 0x3f, 0x12, 0x08, 0x1f, 0xe5, 0xf7, + /*8a70:*/ 0x7c, 0x9a, 0x32, 0xa2, 0xa5, 0x5c, 0x49, 0x54, 0x52, 0x0d, 0xca, 0xeb, 0x2c, 0x5e, 0x0d, 0xf2, + /*8a80:*/ 0x54, 0x10, 0x6b, 0x8f, 0x81, 0x1d, 0x56, 0x6e, 0x62, 0x7b, 0xfa, 0xe5, 0x65, 0x85, 0x71, 0xde, + /*8a90:*/ 0x53, 0x5e, 0x8a, 0x39, 0xed, 0x01, 0x3d, 0xe0, 0x37, 0x22, 0x1d, 0xd5, 0x6d, 0x94, 0xee, 0x8b, + /*8aa0:*/ 0x26, 0x8b, 0xe4, 0xf9, 0x2e, 0x14, 0xe8, 0x33, 0x59, 0xd1, 0x91, 0x32, 0x4a, 0x57, 0x4b, 0x8a, + /*8ab0:*/ 0x81, 0xbc, 0x57, 0x87, 0xe4, 0xa2, 0x73, 0x27, 0xd5, 0x25, 0x7b, 0x25, 0x09, 0x58, 0x29, 0xd5, + /*8ac0:*/ 0xb2, 0x7a, 0x3b, 0x59, 0x00, 0xf3, 0xba, 0x38, 0x72, 0xa2, 0xd3, 0x0e, 0x92, 0x0f, 0xbd, 0x9d, + /*8ad0:*/ 0x08, 0xbb, 0xe1, 0xdd, 0x55, 0x7c, 0xd7, 0xaa, 0xf6, 0x23, 0x2f, 0x21, 0xba, 0x7a, 0x4c, 0xe6, + /*8ae0:*/ 0xf6, 0x21, 0x8a, 0x3f, 0x28, 0xfa, 0x5d, 0x78, 0x4a, 0xba, 0x36, 0x1f, 0xdc, 0xeb, 0xa4, 0x25, + /*8af0:*/ 0x4a, 0x5c, 0x19, 0xab, 0xaf, 0x78, 0x25, 0x85, 0x5d, 0x2c, 0x56, 0x91, 0xb2, 0xc2, 0x4c, 0xd1, + /*8b00:*/ 0x12, 0x1b, 0x0f, 0xcf, 0x71, 0x79, 0x3f, 0x39, 0xd4, 0x0c, 0x02, 0xef, 0x4c, 0x77, 0x61, 0xb2, + /*8b10:*/ 0x3e, 0x7e, 0x2e, 0x89, 0x23, 0x88, 0x61, 0xd2, 0xb7, 0x7b, 0xe0, 0xfa, 0x91, 0xa6, 0x7b, 0x20, + /*8b20:*/ 0x26, 0x37, 0xbd, 0xd0, 0xaa, 0x0c, 0x6b, 0x9a, 0x12, 0x3a, 0xf6, 0xff, 0x39, 0x7f, 0x41, 0xee, + /*8b30:*/ 0x8b, 0xd3, 0xc6, 0x0e, 0x0e, 0xc1, 0x73, 0x60, 0x7e, 0xd0, 0x65, 0x4b, 0x47, 0x16, 0x17, 0xcd, + /*8b40:*/ 0x6d, 0x4d, 0x6e, 0x24, 0xdd, 0x1f, 0x24, 0x4c, 0x2a, 0xb1, 0x09, 0xf7, 0x77, 0xb6, 0x18, 0xe2, + /*8b50:*/ 0xa6, 0xd7, 0x2f, 0x41, 0xf8, 0x87, 0xb2, 0x89, 0x86, 0x60, 0xdc, 0x55, 0x0f, 0xbe, 0x68, 0xa9, + /*8b60:*/ 0x3c, 0x3e, 0xc1, 0xd9, 0x2b, 0x92, 0x1e, 0xb1, 0xe9, 0x97, 0xfc, 0xc8, 0xe9, 0x0a, 0xdc, 0xa6, + /*8b70:*/ 0x43, 0xe8, 0xc1, 0xeb, 0x02, 0x54, 0x9f, 0x94, 0xaa, 0xf2, 0xef, 0x72, 0xa3, 0x5b, 0x96, 0xfe, + /*8b80:*/ 0x33, 0xc5, 0x04, 0x0f, 0x37, 0x1c, 0x77, 0x5d, 0x53, 0x7c, 0xa3, 0x42, 0x0c, 0x40, 0x4a, 0x50, + /*8b90:*/ 0xc6, 0x44, 0x1e, 0xdd, 0x1c, 0x27, 0x87, 0x8f, 0x79, 0x8f, 0x2b, 0x7e, 0x2c, 0x2c, 0x08, 0xaf, + /*8ba0:*/ 0xc6, 0xcb, 0x68, 0xbe, 0xc7, 0x41, 0x9e, 0x01, 0xf5, 0x51, 0x04, 0xa2, 0x52, 0xb0, 0x58, 0xa6, + /*8bb0:*/ 0xc3, 0xd9, 0xf8, 0xe5, 0xe5, 0x60, 0x5a, 0x42, 0x1c, 0x92, 0x71, 0x27, 0x2b, 0x1b, 0x7b, 0xad, + /*8bc0:*/ 0x32, 0x24, 0x3e, 0x75, 0xa2, 0x64, 0xaa, 0x8e, 0xe1, 0x96, 0x6e, 0x80, 0xf7, 0x6f, 0xdb, 0xce, + /*8bd0:*/ 0xa8, 0xd5, 0x4a, 0x8b, 0xd4, 0x29, 0x10, 0x03, 0x17, 0x38, 0x5f, 0xdc, 0xca, 0xd7, 0xeb, 0xac, + /*8be0:*/ 0x45, 0x3d, 0xb8, 0x1b, 0x20, 0xae, 0x91, 0x6b, 0x63, 0xc7, 0xe4, 0x69, 0x94, 0xb9, 0x41, 0xe8, + /*8bf0:*/ 0xdc, 0x67, 0xb8, 0x0a, 0xfa, 0x72, 0x4e, 0x23, 0x12, 0xd9, 0xb1, 0x13, 0xf7, 0x53, 0xf6, 0x2b, + /*8c00:*/ 0x89, 0x06, 0x80, 0x67, 0x02, 0xc5, 0x4b, 0xbd, 0xaf, 0x60, 0x73, 0x90, 0x00, 0xd3, 0xfc, 0x9e, + /*8c10:*/ 0x59, 0x76, 0xaf, 0x70, 0x44, 0xd9, 0xae, 0x1a, 0x6b, 0xa7, 0x56, 0xad, 0x1b, 0xc2, 0xe6, 0xd5, + /*8c20:*/ 0xbc, 0x6f, 0x4a, 0xd9, 0x59, 0x11, 0xc1, 0xc5, 0xaf, 0x36, 0x26, 0x93, 0xd6, 0x20, 0x72, 0x61, + /*8c30:*/ 0x8e, 0xb6, 0x84, 0xab, 0x54, 0xcb, 0x7c, 0xf6, 0x84, 0x3b, 0x09, 0x3a, 0x46, 0x2f, 0xc6, 0x95, + /*8c40:*/ 0x07, 0x5f, 0xda, 0xf6, 0x8b, 0x30, 0x6d, 0xd9, 0xbb, 0x6f, 0x13, 0xea, 0x81, 0xa3, 0xd5, 0x72, + /*8c50:*/ 0x46, 0x43, 0x53, 0xe5, 0xbd, 0x02, 0x9c, 0x1d, 0x29, 0x94, 0x97, 0x01, 0xce, 0x6a, 0x76, 0x7b, + /*8c60:*/ 0xc3, 0xa5, 0x2f, 0xcf, 0xe4, 0x81, 0x32, 0xb5, 0x9f, 0xa1, 0x98, 0xea, 0xab, 0xe9, 0x6c, 0x8a, + /*8c70:*/ 0x37, 0x4e, 0x9e, 0x10, 0x1b, 0x87, 0xbd, 0x06, 0x77, 0xd5, 0x79, 0x79, 0xe3, 0x6d, 0x4e, 0x96, + /*8c80:*/ 0x51, 0x56, 0xd6, 0x18, 0x93, 0xe8, 0x69, 0xb4, 0x50, 0xf6, 0x61, 0xfc, 0x67, 0xdf, 0x82, 0xd4, + /*8c90:*/ 0x99, 0x06, 0x16, 0x97, 0x95, 0xd6, 0x43, 0xd6, 0x31, 0x4f, 0xb7, 0xeb, 0x2f, 0x3a, 0x3b, 0x1a, + /*8ca0:*/ 0xd9, 0xe2, 0xa1, 0xca, 0xbb, 0x76, 0x48, 0xe3, 0x47, 0xcc, 0xbe, 0x67, 0x24, 0xa2, 0xd0, 0x9a, + /*8cb0:*/ 0x7c, 0x30, 0x4f, 0x1b, 0x85, 0x08, 0xc9, 0xec, 0x98, 0x65, 0xb0, 0x93, 0x10, 0x1c, 0xca, 0x83, + /*8cc0:*/ 0x2d, 0x00, 0x68, 0x96, 0x39, 0x3f, 0x3f, 0x7c, 0x42, 0x6b, 0x6f, 0x41, 0x3f, 0xf3, 0x29, 0x66, + /*8cd0:*/ 0x98, 0xfb, 0x14, 0x3c, 0x8b, 0xd9, 0x5f, 0xdd, 0xe7, 0x8d, 0xbd, 0x40, 0x5a, 0x12, 0x41, 0x0c, + /*8ce0:*/ 0xd8, 0x02, 0x89, 0xc1, 0x65, 0x1b, 0xb2, 0x79, 0x6b, 0x98, 0x50, 0xff, 0xc8, 0xf0, 0x67, 0x66, + /*8cf0:*/ 0x51, 0xb8, 0x05, 0xc9, 0x1a, 0xcc, 0x7e, 0x28, 0x22, 0xc7, 0x11, 0xf6, 0xfc, 0x71, 0xeb, 0x97, + /*8d00:*/ 0x4b, 0x51, 0x53, 0x25, 0x88, 0xc9, 0x5e, 0x11, 0x84, 0x79, 0x4e, 0xf2, 0x02, 0x2f, 0xa6, 0x7e, + /*8d10:*/ 0x82, 0x65, 0x34, 0xfa, 0xd6, 0x33, 0xfe, 0xaa, 0x95, 0xe5, 0xb3, 0xd1, 0x5e, 0xf6, 0xdf, 0x96, + /*8d20:*/ 0x20, 0x29, 0xd6, 0xd4, 0xc1, 0x5c, 0x53, 0x2b, 0x4c, 0x32, 0xf4, 0xae, 0xfc, 0x69, 0x53, 0xfc, + /*8d30:*/ 0x2a, 0x7e, 0x83, 0xfb, 0x8f, 0x35, 0xe2, 0xd9, 0x5c, 0x12, 0x22, 0x5c, 0xc0, 0x75, 0x8a, 0x23, + /*8d40:*/ 0x8d, 0x63, 0xc8, 0xa9, 0x69, 0x40, 0x9c, 0x29, 0x22, 0xe9, 0x6a, 0x2b, 0x0c, 0xb7, 0xc8, 0x79, + /*8d50:*/ 0xb6, 0xcd, 0xaf, 0xac, 0x91, 0x96, 0x78, 0xb6, 0x29, 0x0b, 0xbd, 0x76, 0xd5, 0x2e, 0xcc, 0x39, + /*8d60:*/ 0x3b, 0xcc, 0xb1, 0xff, 0x91, 0xb9, 0xab, 0xcb, 0x34, 0xfb, 0xcf, 0xaf, 0xe3, 0xde, 0xb2, 0x37, + /*8d70:*/ 0xb5, 0x79, 0x47, 0xb3, 0xac, 0x9b, 0x20, 0xc4, 0xda, 0x7d, 0x6f, 0x49, 0x6f, 0x8b, 0xe3, 0x4b, + /*8d80:*/ 0x31, 0x23, 0x28, 0x63, 0x08, 0x59, 0x23, 0xf1, 0xa5, 0xea, 0x64, 0x08, 0x88, 0x34, 0xf3, 0x39, + /*8d90:*/ 0x62, 0xe8, 0x7a, 0x18, 0xed, 0x25, 0xa4, 0x68, 0x3d, 0xa6, 0x64, 0x0d, 0xdc, 0x99, 0x05, 0xc9, + /*8da0:*/ 0xb0, 0x9e, 0xc3, 0xe3, 0xa2, 0x9e, 0xc7, 0x92, 0x7a, 0xe1, 0xdd, 0x0e, 0x9d, 0x71, 0x6c, 0xf5, + /*8db0:*/ 0x73, 0xa5, 0xf9, 0xdf, 0x94, 0x49, 0xa3, 0x23, 0x73, 0xe0, 0x51, 0x6d, 0x0f, 0x9e, 0x1a, 0x87, + /*8dc0:*/ 0x3a, 0xef, 0xa4, 0x63, 0x13, 0x79, 0x7a, 0x2d, 0x0f, 0x7c, 0x88, 0x8b, 0xb1, 0x65, 0xbf, 0x0a, + /*8dd0:*/ 0xb5, 0x21, 0xc4, 0x7c, 0x65, 0xe3, 0x52, 0x1d, 0xa2, 0xf6, 0x1d, 0x93, 0x84, 0x86, 0x7a, 0xe8, + /*8de0:*/ 0x5f, 0x72, 0x4b, 0x85, 0x48, 0x8f, 0x23, 0x93, 0x7f, 0xdd, 0xef, 0x17, 0x46, 0x5d, 0xbe, 0xc0, + /*8df0:*/ 0x67, 0xbd, 0xe4, 0xd7, 0xc9, 0xca, 0x2e, 0xc6, 0x8b, 0xc3, 0x82, 0x28, 0x0f, 0xa6, 0x22, 0x9c, + /*8e00:*/ 0xaf, 0x0c, 0xa2, 0x5f, 0xe6, 0x91, 0x72, 0x6b, 0x43, 0x44, 0xd5, 0x8c, 0xd5, 0x55, 0xc2, 0x6a, + /*8e10:*/ 0x95, 0xe0, 0x42, 0x22, 0x41, 0xe7, 0xd5, 0x2a, 0xfa, 0xf7, 0xaa, 0x74, 0x29, 0x4f, 0x87, 0x2c, + /*8e20:*/ 0x38, 0x6a, 0x4a, 0x07, 0x38, 0xfd, 0x8c, 0xe2, 0x8d, 0xd8, 0x2b, 0x2e, 0xe7, 0x2b, 0xbc, 0x02, + /*8e30:*/ 0x22, 0xa1, 0x26, 0xce, 0x57, 0xab, 0x9b, 0x20, 0x02, 0x43, 0xaf, 0xb5, 0x73, 0x95, 0xc1, 0x5a, + /*8e40:*/ 0xe2, 0xe3, 0x7f, 0x60, 0x04, 0xab, 0xa3, 0x21, 0xf8, 0x18, 0xdb, 0x6b, 0x01, 0xdf, 0x6a, 0xac, + /*8e50:*/ 0xdb, 0x37, 0xa4, 0xdd, 0x4b, 0x0e, 0xfa, 0x39, 0xed, 0x64, 0xfb, 0xfc, 0x98, 0xe7, 0x71, 0x02, + /*8e60:*/ 0xdd, 0xbb, 0xa5, 0x62, 0x7e, 0x18, 0x16, 0xe1, 0x6e, 0xbd, 0x1d, 0xb3, 0xc5, 0x11, 0xd2, 0xdb, + /*8e70:*/ 0x20, 0x1f, 0x3a, 0x84, 0xda, 0x08, 0x7d, 0x58, 0x50, 0xc3, 0x3c, 0x5c, 0x7c, 0xc9, 0xb8, 0x78, + /*8e80:*/ 0x03, 0x57, 0x93, 0x71, 0x71, 0x28, 0xaf, 0x84, 0xd6, 0x89, 0xa2, 0xd4, 0x01, 0xcb, 0x26, 0x1b, + /*8e90:*/ 0x0a, 0x35, 0x38, 0xf8, 0x77, 0xb1, 0x09, 0x03, 0xb7, 0x1a, 0x0d, 0xb2, 0x82, 0x90, 0x22, 0x05, + /*8ea0:*/ 0x19, 0x63, 0x66, 0x58, 0x4a, 0xf9, 0x2f, 0x2f, 0xe2, 0xbb, 0x2b, 0x31, 0xca, 0xdc, 0x96, 0x47, + /*8eb0:*/ 0x88, 0x7d, 0x62, 0x75, 0xe6, 0x96, 0xf3, 0xa2, 0x1e, 0x62, 0x59, 0xff, 0x24, 0xbe, 0x2f, 0x8f, + /*8ec0:*/ 0xdf, 0xd5, 0x72, 0xfc, 0x0f, 0xc8, 0x10, 0x48, 0xa2, 0x90, 0xe0, 0x1a, 0xa2, 0x0c, 0x80, 0x80, + /*8ed0:*/ 0xda, 0xb8, 0x2f, 0x8c, 0xc4, 0x07, 0x49, 0x7a, 0x29, 0xf5, 0xbb, 0x02, 0x49, 0xc0, 0xa5, 0x5c, + /*8ee0:*/ 0x54, 0x6f, 0x05, 0xb6, 0x48, 0x1c, 0x41, 0xc9, 0xa2, 0x19, 0xab, 0xc4, 0x39, 0x6d, 0xf7, 0x7b, + /*8ef0:*/ 0x22, 0xc0, 0xbd, 0xbf, 0xd7, 0x88, 0x46, 0xe4, 0x18, 0x42, 0x06, 0xea, 0x45, 0xcb, 0x6a, 0xe1, + /*8f00:*/ 0x23, 0xe6, 0x93, 0x32, 0x7a, 0x56, 0x90, 0x80, 0xa9, 0xb1, 0xe3, 0x47, 0x6f, 0x71, 0x17, 0xb2, + /*8f10:*/ 0x6f, 0x5b, 0x23, 0x7a, 0x22, 0xea, 0xeb, 0xd1, 0x52, 0xed, 0x41, 0x71, 0xf5, 0x16, 0x98, 0x3a, + /*8f20:*/ 0x57, 0x79, 0x86, 0x99, 0xbf, 0xbe, 0xd2, 0x6b, 0x9d, 0x2a, 0x14, 0x61, 0x03, 0x5e, 0x4b, 0x5f, + /*8f30:*/ 0x02, 0x59, 0x22, 0x37, 0x13, 0x79, 0x7d, 0x47, 0xca, 0xc4, 0xe9, 0xa9, 0x0f, 0x33, 0x89, 0x72, + /*8f40:*/ 0x86, 0x3a, 0x79, 0x68, 0x17, 0x63, 0x6a, 0x0d, 0x50, 0x59, 0xd3, 0xb8, 0x3f, 0x32, 0x84, 0x6a, + /*8f50:*/ 0x7c, 0x11, 0x65, 0xb1, 0x34, 0xb6, 0x6a, 0x9f, 0x59, 0x28, 0xdd, 0xe8, 0xef, 0x10, 0x2a, 0x65, + /*8f60:*/ 0xde, 0x73, 0x8e, 0x15, 0x64, 0xcf, 0x99, 0xa9, 0x01, 0xdb, 0x79, 0x12, 0x99, 0x9b, 0x66, 0x0c, + /*8f70:*/ 0x5b, 0x2f, 0x31, 0xd4, 0xdd, 0x74, 0x8b, 0x64, 0x3e, 0x7e, 0xee, 0x85, 0xac, 0xcb, 0x94, 0x8a, + /*8f80:*/ 0xfb, 0xc8, 0x87, 0xce, 0xeb, 0x18, 0x23, 0xd4, 0x13, 0x4c, 0x22, 0xeb, 0x2d, 0x71, 0x7e, 0xd6, + /*8f90:*/ 0x4f, 0x06, 0x85, 0xf2, 0xf7, 0x4d, 0x39, 0xc3, 0x11, 0x33, 0x2a, 0x9e, 0xf8, 0x3c, 0xde, 0xef, + /*8fa0:*/ 0x06, 0xbe, 0xcd, 0x77, 0x21, 0xeb, 0xb0, 0xd6, 0xcf, 0x41, 0xd2, 0xd9, 0xb5, 0x8c, 0xa9, 0x51, + /*8fb0:*/ 0xae, 0x17, 0xe0, 0xb0, 0x60, 0x3f, 0x62, 0x82, 0x71, 0x28, 0x7e, 0xb9, 0x6d, 0x17, 0x26, 0xde, + /*8fc0:*/ 0xb0, 0x98, 0xeb, 0x35, 0x28, 0xb9, 0x1e, 0xd5, 0x82, 0xf7, 0xaf, 0xa2, 0x3b, 0xb7, 0xbe, 0xfd, + /*8fd0:*/ 0x4d, 0x68, 0x6a, 0x20, 0x61, 0x50, 0x47, 0xb2, 0x4a, 0x42, 0x7a, 0xfa, 0x29, 0xcc, 0x9e, 0x2f, + /*8fe0:*/ 0xd9, 0x50, 0x5b, 0xac, 0x1d, 0x02, 0x90, 0xd9, 0xe5, 0xe8, 0x51, 0x12, 0xe8, 0x3b, 0xb9, 0x06, + /*8ff0:*/ 0x93, 0xb5, 0x3c, 0xa3, 0xdf, 0x96, 0xd1, 0x07, 0xb5, 0xf7, 0x6d, 0xcd, 0x6e, 0x2c, 0xd3, 0x89, + /*9000:*/ 0xcd, 0x97, 0xfb, 0x6a, 0x85, 0xcf, 0x10, 0x46, 0xdc, 0xc6, 0xde, 0x2d, 0x28, 0x1a, 0xe7, 0x1a, + /*9010:*/ 0x6a, 0x19, 0x84, 0x67, 0x2d, 0x47, 0xb2, 0x05, 0xca, 0xe2, 0x74, 0xf6, 0xbc, 0x62, 0x15, 0x74, + /*9020:*/ 0x19, 0x15, 0x04, 0x73, 0xd1, 0x52, 0xe6, 0x57, 0xbf, 0x05, 0x0b, 0xe4, 0x38, 0x0c, 0x7c, 0x7b, + /*9030:*/ 0x87, 0x7c, 0xa0, 0xd3, 0x14, 0x94, 0xcc, 0x4d, 0x73, 0x12, 0xac, 0x5e, 0x7d, 0x74, 0xb3, 0x43, + /*9040:*/ 0xe1, 0x88, 0xca, 0x1d, 0x3d, 0x1c, 0xa1, 0x11, 0x83, 0xea, 0xf0, 0x72, 0x29, 0xda, 0xbe, 0xd3, + /*9050:*/ 0x98, 0xd2, 0xd8, 0xd6, 0x71, 0x9c, 0x7b, 0x44, 0xb8, 0x3c, 0xf6, 0x04, 0xc5, 0x32, 0xb8, 0x4e, + /*9060:*/ 0xb9, 0xcd, 0x59, 0x36, 0xe8, 0xd1, 0x63, 0x70, 0xd6, 0x5d, 0x0d, 0x49, 0xc8, 0x0e, 0xb6, 0x28, + /*9070:*/ 0x68, 0x67, 0xe8, 0x0c, 0x8c, 0x2f, 0x74, 0xfd, 0x56, 0x1d, 0x65, 0xaf, 0x33, 0xba, 0xf4, 0xe0, + /*9080:*/ 0x8c, 0xff, 0x5e, 0x96, 0x4c, 0xa9, 0x25, 0xde, 0x03, 0x8d, 0x38, 0xc6, 0xba, 0x40, 0xf8, 0xdf, + /*9090:*/ 0x93, 0xb4, 0x50, 0x58, 0x42, 0x73, 0x91, 0xad, 0xb4, 0x6f, 0x25, 0x0b, 0x7f, 0x5a, 0xd0, 0x69, + /*90a0:*/ 0x0e, 0x44, 0xbc, 0x27, 0xcc, 0x14, 0x07, 0xeb, 0x11, 0x20, 0x05, 0x3b, 0xf0, 0x73, 0x51, 0xc2, + /*90b0:*/ 0x3e, 0xbb, 0x85, 0xc9, 0xd7, 0xea, 0xd0, 0x0e, 0x25, 0xa1, 0x41, 0xe1, 0x70, 0xbd, 0xae, 0x81, + /*90c0:*/ 0xcc, 0x2b, 0x19, 0x39, 0x3b, 0xb3, 0x65, 0x2b, 0xd7, 0x9d, 0x94, 0xb3, 0xe1, 0xe7, 0xa5, 0xde, + /*90d0:*/ 0xd5, 0xe8, 0xb7, 0xc3, 0x4d, 0xbb, 0x32, 0x71, 0xa3, 0xfc, 0xb0, 0x6c, 0x8e, 0x20, 0xe7, 0xeb, + /*90e0:*/ 0x88, 0xc8, 0xa4, 0x76, 0xe8, 0xd5, 0xb1, 0x24, 0xbb, 0xa4, 0x35, 0xc8, 0x74, 0xb5, 0x3b, 0xba, + /*90f0:*/ 0x08, 0xbc, 0xbd, 0xcd, 0xe6, 0x0e, 0x71, 0x32, 0x0e, 0x88, 0x52, 0xfa, 0x45, 0xe7, 0x02, 0x3b, + /*9100:*/ 0x11, 0x5d, 0x8c, 0x07, 0x14, 0xc1, 0x68, 0x05, 0xc2, 0x4f, 0x03, 0x1c, 0x17, 0xa6, 0x38, 0xa1, + /*9110:*/ 0x9d, 0x07, 0xb0, 0xb3, 0x00, 0xab, 0x98, 0x89, 0x79, 0xd3, 0x8b, 0xb2, 0x93, 0x6b, 0x30, 0xf4, + /*9120:*/ 0x0c, 0xbd, 0xe3, 0x79, 0x3d, 0x1e, 0x3a, 0x75, 0xf8, 0x67, 0x3f, 0xd9, 0x20, 0x07, 0x22, 0xe6, + /*9130:*/ 0xc1, 0x4f, 0x85, 0x56, 0x68, 0xaa, 0xd1, 0x70, 0xd9, 0x3c, 0x24, 0xee, 0xdf, 0xcc, 0x1c, 0xda, + /*9140:*/ 0x76, 0xf5, 0x18, 0xd1, 0x53, 0x43, 0x3c, 0x1a, 0x51, 0xa4, 0x34, 0xce, 0xde, 0x4d, 0xfb, 0xee, + /*9150:*/ 0x8e, 0xca, 0xb7, 0x36, 0xae, 0x68, 0xcc, 0x22, 0x8b, 0xec, 0x66, 0xba, 0xcd, 0x93, 0x41, 0x75, + /*9160:*/ 0xc5, 0xba, 0x92, 0x23, 0xde, 0x1b, 0xc4, 0xc8, 0x75, 0xcb, 0xcc, 0x14, 0x2b, 0x99, 0x06, 0x43, + /*9170:*/ 0xd1, 0x9d, 0xae, 0xd5, 0x54, 0xda, 0x5f, 0x6f, 0x9c, 0x96, 0x52, 0x1c, 0xca, 0xf6, 0xab, 0x58, + /*9180:*/ 0xe4, 0xbd, 0x83, 0x35, 0xc6, 0x32, 0xae, 0xd7, 0x54, 0x59, 0x53, 0xb3, 0x33, 0xe6, 0xd9, 0x7c, + /*9190:*/ 0x72, 0xb5, 0xcb, 0x02, 0x92, 0xd8, 0xf2, 0x68, 0xd1, 0xdb, 0x93, 0xd8, 0x2e, 0xc9, 0xda, 0x87, + /*91a0:*/ 0x50, 0xf2, 0x6c, 0xf9, 0x58, 0x2e, 0x6a, 0x6a, 0xfc, 0x08, 0x56, 0x9c, 0x6e, 0xe1, 0xdf, 0xe2, + /*91b0:*/ 0x90, 0x38, 0xbe, 0xb9, 0xbc, 0x2e, 0xb9, 0x2c, 0xcc, 0xd9, 0x0d, 0x25, 0xe2, 0x37, 0xf4, 0x28, + /*91c0:*/ 0xe1, 0xc1, 0xf2, 0xc9, 0x68, 0xd3, 0xff, 0xa3, 0xf0, 0x28, 0x67, 0x48, 0xfb, 0x91, 0xfe, 0x46, + /*91d0:*/ 0xc4, 0xbf, 0x60, 0xe7, 0x97, 0x37, 0x3f, 0xd2, 0x7e, 0xdf, 0x3d, 0x27, 0x6d, 0x3e, 0x69, 0xa5, + /*91e0:*/ 0x7f, 0x2f, 0x57, 0xeb, 0x82, 0x7e, 0x94, 0x85, 0x69, 0xb2, 0x9d, 0xa6, 0x66, 0x16, 0xa7, 0xc2, + /*91f0:*/ 0x87, 0xe8, 0x72, 0x7c, 0x99, 0xd4, 0xb1, 0x43, 0xa8, 0x06, 0x32, 0x32, 0x1e, 0xb2, 0x6e, 0x2f, + /*9200:*/ 0xd0, 0xca, 0xe7, 0x10, 0xd5, 0xc2, 0xe5, 0x6b, 0x91, 0xac, 0xb4, 0x79, 0x6f, 0x23, 0xcc, 0xfc, + /*9210:*/ 0x09, 0xe4, 0x62, 0x5e, 0xb6, 0x58, 0xd1, 0x53, 0xd4, 0x10, 0x0b, 0x01, 0xf5, 0x26, 0x5f, 0x5a, + /*9220:*/ 0xcf, 0xf6, 0x44, 0x93, 0xad, 0xed, 0x64, 0xd2, 0xfd, 0x2c, 0x6a, 0xfe, 0x3c, 0x37, 0x44, 0xf0, + /*9230:*/ 0x0d, 0x21, 0xd3, 0x7b, 0x8d, 0x8a, 0xfe, 0x0c, 0xf9, 0x5a, 0x0a, 0x86, 0xed, 0xfb, 0x5b, 0x6b, + /*9240:*/ 0xbe, 0x39, 0xb9, 0x85, 0xf8, 0x76, 0xde, 0x5f, 0xd8, 0x6e, 0x95, 0xb6, 0xd5, 0x4b, 0x40, 0x32, + /*9250:*/ 0x4a, 0xf1, 0x1c, 0xa8, 0x48, 0xe2, 0xf3, 0x10, 0xa6, 0x51, 0xee, 0x2a, 0xbb, 0x65, 0xaa, 0xe6, + /*9260:*/ 0x4b, 0x9c, 0x5f, 0x30, 0xcc, 0xbe, 0xae, 0xe3, 0x0f, 0xbe, 0x34, 0x44, 0xf5, 0x3c, 0xb2, 0x6d, + /*9270:*/ 0xd5, 0x2f, 0x3b, 0x59, 0xc8, 0x7f, 0x48, 0xfa, 0x53, 0x6f, 0x85, 0x7b, 0xaa, 0x6d, 0xf5, 0x2c, + /*9280:*/ 0x0f, 0x23, 0x8a, 0x25, 0xee, 0x4f, 0x08, 0x00, 0xc9, 0x1d, 0x53, 0xdb, 0xad, 0x37, 0x35, 0x41, + /*9290:*/ 0x6c, 0x9f, 0xe2, 0x79, 0x6a, 0x21, 0x04, 0x05, 0xe6, 0x6f, 0x74, 0x9e, 0x9a, 0x1c, 0x33, 0xd6, + /*92a0:*/ 0x44, 0x5c, 0x09, 0x40, 0xcb, 0x0e, 0xe4, 0x27, 0xa3, 0xf8, 0xf7, 0xd4, 0xed, 0x09, 0x33, 0x71, + /*92b0:*/ 0x5d, 0x5c, 0x95, 0x25, 0x67, 0x0a, 0x5c, 0x2e, 0xb6, 0xe7, 0xb0, 0x10, 0x9c, 0x19, 0xb4, 0x39, + /*92c0:*/ 0x99, 0x11, 0xbd, 0x82, 0x87, 0x28, 0x6d, 0x75, 0x9d, 0x4e, 0x66, 0xbb, 0x1f, 0x01, 0x6b, 0x33, + /*92d0:*/ 0xf5, 0x01, 0x20, 0x9f, 0x69, 0x09, 0x99, 0x29, 0xda, 0x12, 0x5a, 0xa5, 0x47, 0xe2, 0x4d, 0x3c, + /*92e0:*/ 0x39, 0x54, 0x5e, 0x69, 0xa4, 0x54, 0x14, 0x1f, 0x3f, 0x75, 0xfc, 0x25, 0xa3, 0x3d, 0xc1, 0x65, + /*92f0:*/ 0xc6, 0xd0, 0xdb, 0x44, 0xbe, 0xe9, 0x6d, 0x3d, 0x00, 0x81, 0x3b, 0xed, 0xb5, 0xfd, 0xa6, 0x19, + /*9300:*/ 0x63, 0xa2, 0xf0, 0xd8, 0x86, 0xeb, 0x86, 0x20, 0xe2, 0xaa, 0x98, 0xf9, 0x21, 0x51, 0x40, 0x63, + /*9310:*/ 0x84, 0x80, 0x6d, 0x18, 0x84, 0x3c, 0x91, 0x6a, 0x93, 0x85, 0x25, 0x5b, 0x5a, 0x12, 0x61, 0xf3, + /*9320:*/ 0x20, 0x02, 0x6e, 0x52, 0x08, 0xcf, 0x9a, 0xda, 0xd0, 0xbc, 0xd5, 0x70, 0xca, 0x73, 0x28, 0xcb, + /*9330:*/ 0x6c, 0x97, 0xc1, 0xb0, 0x0e, 0xb7, 0xa2, 0xd7, 0xb8, 0xb2, 0xe3, 0x98, 0xf7, 0x9e, 0x60, 0xc6, + /*9340:*/ 0x54, 0x2d, 0x04, 0x98, 0x6f, 0x29, 0xbe, 0xdc, 0x67, 0xad, 0xfd, 0x2d, 0xf5, 0x0e, 0x11, 0xfb, + /*9350:*/ 0x00, 0xac, 0xef, 0x9d, 0x6c, 0x12, 0x26, 0xf4, 0xf0, 0xaf, 0x05, 0xe4, 0xbf, 0x07, 0x50, 0x17, + /*9360:*/ 0x9e, 0xf9, 0xfe, 0x37, 0x35, 0xa2, 0xb5, 0xff, 0x98, 0xd7, 0x05, 0xa2, 0xb2, 0xa7, 0x5c, 0x2a, + /*9370:*/ 0x3f, 0x67, 0x01, 0x06, 0xa9, 0x3e, 0xdc, 0x76, 0x97, 0xfb, 0x36, 0x72, 0x30, 0xb7, 0xe4, 0x30, + /*9380:*/ 0x51, 0xe3, 0xe7, 0xeb, 0xcc, 0xd3, 0x3d, 0x6f, 0x9e, 0x7e, 0x00, 0xc6, 0x7c, 0x14, 0xb0, 0xae, + /*9390:*/ 0x79, 0x1c, 0x0b, 0x55, 0xcc, 0x61, 0xaf, 0xfc, 0x96, 0xcf, 0xcc, 0xe1, 0x99, 0x4b, 0x85, 0xe7, + /*93a0:*/ 0xa8, 0x9b, 0x40, 0xa9, 0xf8, 0xe8, 0x68, 0xe7, 0x9d, 0xde, 0xf4, 0xdc, 0x93, 0x57, 0x0a, 0x54, + /*93b0:*/ 0x5e, 0x4a, 0x1c, 0xd7, 0x2f, 0xc4, 0x5d, 0x37, 0x98, 0xbc, 0x63, 0xf6, 0x5c, 0x9a, 0xc0, 0xf4, + /*93c0:*/ 0x5e, 0x07, 0xc5, 0xab, 0xe5, 0x51, 0xf1, 0xe9, 0x8d, 0xcd, 0x48, 0x54, 0xce, 0x87, 0x69, 0x51, + /*93d0:*/ 0x10, 0xb9, 0xe6, 0x47, 0x8c, 0x2f, 0x2f, 0xe1, 0x9b, 0xcd, 0x05, 0x55, 0x9c, 0xa7, 0x0f, 0x18, + /*93e0:*/ 0x76, 0xee, 0xc3, 0x7e, 0xfa, 0x69, 0xa3, 0x7f, 0xc2, 0xa9, 0xff, 0xaa, 0x7a, 0x2d, 0x13, 0xd1, + /*93f0:*/ 0xde, 0x8b, 0x1c, 0xd8, 0xe6, 0x6f, 0x12, 0xfc, 0x4c, 0xec, 0x79, 0x02, 0x17, 0x6f, 0xc3, 0xd1, + /*9400:*/ 0xb5, 0x6e, 0xff, 0x06, 0xf1, 0x06, 0xd6, 0xbe, 0xbf, 0x02, 0x04, 0x72, 0x48, 0xed, 0x80, 0x58, + /*9410:*/ 0xf0, 0x5f, 0x31, 0xcf, 0x4d, 0xec, 0xe0, 0x1b, 0x6d, 0x33, 0x69, 0xfd, 0x2f, 0x62, 0xb8, 0x93, + /*9420:*/ 0xac, 0x31, 0x56, 0x8e, 0x61, 0xde, 0x88, 0xea, 0x3f, 0xc4, 0x6b, 0xff, 0xcc, 0x6f, 0x10, 0x26, + /*9430:*/ 0x85, 0x04, 0x98, 0xe4, 0x3a, 0xda, 0x18, 0xa2, 0x99, 0x59, 0x73, 0x58, 0x91, 0x7c, 0x22, 0x7e, + /*9440:*/ 0x16, 0xd4, 0xd3, 0x20, 0x4c, 0x82, 0x21, 0x81, 0x43, 0x83, 0x36, 0x73, 0x04, 0x0e, 0x07, 0x79, + /*9450:*/ 0x81, 0xd7, 0x8e, 0x44, 0x50, 0x9f, 0x33, 0x68, 0x0c, 0x67, 0x18, 0xd3, 0xba, 0xbe, 0xc9, 0xb7, + /*9460:*/ 0xed, 0x8f, 0xb0, 0xdc, 0xc6, 0xab, 0x17, 0x84, 0xa0, 0x79, 0x78, 0xf9, 0x87, 0x8a, 0x21, 0xdf, + /*9470:*/ 0xe7, 0x4d, 0xfa, 0x3b, 0xd8, 0xf4, 0x00, 0x85, 0x00, 0x0d, 0x8e, 0x68, 0x7a, 0x5a, 0x1a, 0x6a, + /*9480:*/ 0x3a, 0x6d, 0x36, 0x12, 0xf4, 0xd4, 0x09, 0xf9, 0xc5, 0x50, 0x1c, 0xe6, 0xe0, 0x58, 0x25, 0xfa, + /*9490:*/ 0xbc, 0xea, 0xfe, 0x6e, 0x1f, 0x1a, 0x16, 0x8f, 0x2f, 0x0f, 0xb2, 0xf3, 0x85, 0xe0, 0x11, 0x9e, + /*94a0:*/ 0x90, 0xf1, 0xab, 0x01, 0xea, 0x9e, 0x03, 0xbe, 0xaa, 0x73, 0x8c, 0x96, 0xf2, 0x1c, 0x74, 0x46, + /*94b0:*/ 0xdd, 0x4c, 0xff, 0x63, 0x18, 0x4b, 0xee, 0x7d, 0xed, 0xff, 0x16, 0xc8, 0x8d, 0xac, 0x0e, 0xe1, + /*94c0:*/ 0x3b, 0x21, 0x1a, 0x5b, 0x69, 0x16, 0xb9, 0xb7, 0xbd, 0x97, 0x02, 0xb6, 0x29, 0xba, 0xd7, 0x0c, + /*94d0:*/ 0xb0, 0x33, 0xba, 0x5a, 0x0d, 0xd2, 0xe6, 0x32, 0x70, 0xd9, 0x71, 0xa3, 0x59, 0xce, 0xe0, 0xac, + /*94e0:*/ 0x9f, 0x3d, 0xd3, 0xba, 0x2e, 0x3d, 0x70, 0x1c, 0x19, 0x9e, 0xa5, 0x34, 0xef, 0xf7, 0x93, 0xcd, + /*94f0:*/ 0x6f, 0xd1, 0xfd, 0x72, 0x76, 0x3a, 0x33, 0x5c, 0x54, 0xd9, 0x85, 0xbf, 0x72, 0xfd, 0x13, 0xf0, + /*9500:*/ 0x5d, 0x37, 0x35, 0x42, 0x1c, 0xd2, 0x41, 0x66, 0x1d, 0xcb, 0xf9, 0x76, 0xd9, 0x26, 0x3b, 0xb7, + /*9510:*/ 0xe7, 0xf6, 0x32, 0xa9, 0x26, 0xba, 0x25, 0x9c, 0x35, 0xa5, 0x80, 0x11, 0x3d, 0x0d, 0x43, 0x80, + /*9520:*/ 0xd1, 0x90, 0xba, 0xe1, 0xc8, 0x1c, 0xe4, 0x83, 0x08, 0xaa, 0xaf, 0x66, 0x8e, 0x33, 0x9a, 0x4a, + /*9530:*/ 0xdd, 0x79, 0xf6, 0xa7, 0xfa, 0x15, 0x59, 0x61, 0xf6, 0x35, 0xd8, 0x0b, 0xe4, 0x86, 0xbb, 0x74, + /*9540:*/ 0xfa, 0x6b, 0xa5, 0x4e, 0xf8, 0x41, 0xa7, 0xb4, 0x37, 0x82, 0x8e, 0x5b, 0x1c, 0x71, 0xe2, 0xe1, + /*9550:*/ 0x57, 0xa8, 0xa1, 0xc3, 0x18, 0x6f, 0xcb, 0x31, 0x2e, 0x28, 0x9d, 0x09, 0x33, 0x67, 0x9b, 0xaf, + /*9560:*/ 0x6f, 0x07, 0x18, 0x49, 0xd1, 0x78, 0x5d, 0x87, 0xdf, 0xb7, 0x62, 0x14, 0x00, 0x7e, 0xc7, 0xe8, + /*9570:*/ 0x7f, 0xbc, 0x6a, 0xd4, 0x4c, 0x91, 0xc6, 0xde, 0xd3, 0x89, 0xc8, 0xbf, 0x90, 0xda, 0x84, 0x0f, + /*9580:*/ 0x56, 0xdd, 0x95, 0xae, 0x92, 0x78, 0xf3, 0x93, 0xf0, 0x6c, 0x9e, 0xab, 0xf5, 0xb7, 0xb5, 0x99, + /*9590:*/ 0xf6, 0xb3, 0x94, 0x57, 0xd1, 0x96, 0x91, 0x60, 0x31, 0x0d, 0xa9, 0xf4, 0x67, 0x62, 0xa4, 0xd5, + /*95a0:*/ 0xf1, 0x5e, 0x15, 0xd8, 0xba, 0x27, 0x4c, 0x2d, 0x1f, 0x92, 0x0e, 0x8a, 0x51, 0x74, 0xdd, 0x8f, + /*95b0:*/ 0x27, 0x89, 0x9b, 0xba, 0x1b, 0x1a, 0x01, 0x1e, 0x9a, 0xb5, 0x77, 0x72, 0x8e, 0xde, 0x73, 0xbb, + /*95c0:*/ 0xe9, 0x6a, 0xa1, 0xeb, 0xa2, 0xab, 0x70, 0x7a, 0x34, 0x34, 0x4f, 0x86, 0x2f, 0x26, 0x4f, 0x39, + /*95d0:*/ 0xab, 0x57, 0x4f, 0x76, 0xed, 0xf8, 0x30, 0xc0, 0x21, 0xb5, 0x17, 0x03, 0x8e, 0xf1, 0x4c, 0xe2, + /*95e0:*/ 0x50, 0x6e, 0xf8, 0x95, 0xee, 0x19, 0xc9, 0xf0, 0x7c, 0x06, 0x9e, 0x3d, 0x69, 0xdf, 0x90, 0x03, + /*95f0:*/ 0xae, 0xfb, 0xc4, 0x34, 0x9e, 0x0a, 0x7d, 0x2e, 0x4d, 0xc5, 0x97, 0x18, 0x01, 0xb7, 0xfb, 0xd7, + /*9600:*/ 0x89, 0x81, 0xd8, 0xd7, 0x2c, 0x12, 0x29, 0xd4, 0x3f, 0xa7, 0xcc, 0x67, 0x9a, 0xed, 0x17, 0xb9, + /*9610:*/ 0xd8, 0x74, 0x27, 0x54, 0xa0, 0x11, 0x44, 0xe0, 0x64, 0xfe, 0xa2, 0x57, 0xf5, 0x63, 0x55, 0xdd, + /*9620:*/ 0x7b, 0x45, 0xea, 0xc2, 0x19, 0xad, 0x3d, 0x68, 0xb7, 0x94, 0x89, 0xa6, 0x6e, 0x28, 0xd2, 0xbc, + /*9630:*/ 0x09, 0xe4, 0x75, 0x37, 0xd4, 0x26, 0x4e, 0xf1, 0x6c, 0x8b, 0x5d, 0x16, 0x12, 0xfc, 0x10, 0xff, + /*9640:*/ 0x12, 0x33, 0xdb, 0xd9, 0x7b, 0x22, 0x55, 0x7b, 0xe7, 0xc4, 0x9c, 0xd7, 0x50, 0x87, 0xc5, 0xde, + /*9650:*/ 0x8d, 0xe0, 0x74, 0xc7, 0x03, 0x9f, 0x64, 0x7f, 0xf4, 0xfd, 0xbd, 0xed, 0x0c, 0x14, 0x8c, 0x2a, + /*9660:*/ 0xf9, 0x2e, 0x06, 0x6e, 0xb7, 0x2a, 0x3e, 0x61, 0x02, 0xce, 0x84, 0xd4, 0xb6, 0x02, 0xee, 0x47, + /*9670:*/ 0x13, 0x01, 0x8c, 0x78, 0x6d, 0x2b, 0xea, 0xa2, 0x74, 0x3f, 0x87, 0x2d, 0x42, 0xa1, 0x7a, 0x63, + /*9680:*/ 0x25, 0x81, 0x88, 0x65, 0x0a, 0x42, 0x52, 0xa1, 0x8f, 0xba, 0xf5, 0x32, 0x27, 0xdd, 0x87, 0x68, + /*9690:*/ 0x95, 0x0e, 0x6e, 0xb3, 0x04, 0xbb, 0x40, 0x5e, 0x65, 0x0e, 0x51, 0x4c, 0x2a, 0x9c, 0x5a, 0x2e, + /*96a0:*/ 0xc9, 0xed, 0xc0, 0xe1, 0xb5, 0x7e, 0x69, 0xcf, 0x4e, 0x16, 0xe3, 0x11, 0x8e, 0xef, 0xb9, 0x44, + /*96b0:*/ 0x6b, 0x79, 0x1a, 0xf2, 0x7a, 0x58, 0xe7, 0xd3, 0xbb, 0x95, 0x9e, 0x9a, 0x63, 0xa2, 0x3c, 0x8c, + /*96c0:*/ 0xd3, 0x4f, 0x7e, 0x08, 0xd5, 0x48, 0x8f, 0x6f, 0x6d, 0x14, 0x44, 0x9d, 0x82, 0x1e, 0x27, 0x1c, + /*96d0:*/ 0xb7, 0x0d, 0xb5, 0xc8, 0x4a, 0x9e, 0x1d, 0x45, 0x6c, 0x69, 0x8d, 0x8b, 0x46, 0x21, 0x36, 0x51, + /*96e0:*/ 0xb8, 0x41, 0x18, 0x2f, 0x3c, 0x1f, 0xe1, 0xeb, 0x34, 0xc3, 0x09, 0xb5, 0xe8, 0xd7, 0x78, 0x60, + /*96f0:*/ 0xd5, 0x6f, 0xe4, 0xb1, 0x01, 0x3e, 0xac, 0xbf, 0xaa, 0xfd, 0x1a, 0x33, 0x75, 0xc7, 0x11, 0x66, + /*9700:*/ 0xed, 0x08, 0x5e, 0xbc, 0xa4, 0xc2, 0x12, 0x3e, 0x9f, 0xac, 0xc4, 0xee, 0xfe, 0xb2, 0xdb, 0x0f, + /*9710:*/ 0x0d, 0x6a, 0x03, 0x63, 0xe8, 0x9a, 0xfe, 0xde, 0xe1, 0x30, 0xba, 0x98, 0x1d, 0x33, 0x5c, 0x94, + /*9720:*/ 0x07, 0x88, 0x25, 0x84, 0xbe, 0x9c, 0x01, 0x21, 0xc3, 0x27, 0x98, 0xdb, 0x69, 0xb4, 0xec, 0x17, + /*9730:*/ 0x21, 0x15, 0x40, 0xbc, 0x54, 0xb3, 0xda, 0x62, 0x73, 0x09, 0x64, 0x6a, 0x41, 0x23, 0x8d, 0x47, + /*9740:*/ 0x19, 0xf7, 0x30, 0xe7, 0xb4, 0x2c, 0x60, 0xcb, 0x8c, 0xf3, 0xc4, 0xd8, 0xc5, 0x38, 0xba, 0xf7, + /*9750:*/ 0xf7, 0xe8, 0x1a, 0x07, 0x9c, 0xde, 0x82, 0x1c, 0x0f, 0xf9, 0x38, 0x4f, 0x32, 0xc0, 0x6c, 0x3d, + /*9760:*/ 0x4d, 0x90, 0x04, 0x0a, 0xe6, 0x34, 0xa9, 0x1d, 0xf6, 0x00, 0x97, 0xd8, 0x07, 0x8b, 0xfa, 0x3d, + /*9770:*/ 0x65, 0x0f, 0x31, 0x24, 0xd9, 0xf9, 0xdb, 0xc4, 0xbd, 0x6d, 0x14, 0xc5, 0x97, 0xdf, 0x6d, 0x22, + /*9780:*/ 0x82, 0x7b, 0x9d, 0x2e, 0x40, 0x53, 0x71, 0x0c, 0xde, 0x63, 0xe3, 0xf0, 0x50, 0xb9, 0x00, 0x99, + /*9790:*/ 0x76, 0x75, 0x3c, 0x90, 0x2d, 0x17, 0xb9, 0xed, 0x04, 0xcf, 0x14, 0x78, 0x8b, 0xe2, 0xcc, 0x7f, + /*97a0:*/ 0xa9, 0x49, 0xb0, 0x5d, 0x04, 0x64, 0xe4, 0x72, 0x55, 0x39, 0x1a, 0x9e, 0x88, 0xd4, 0x23, 0x9c, + /*97b0:*/ 0x04, 0xbf, 0xe0, 0x9b, 0xdf, 0xeb, 0x68, 0x6c, 0xc7, 0x04, 0xef, 0x6c, 0xb7, 0x6f, 0xd6, 0xff, + /*97c0:*/ 0xfe, 0x63, 0xeb, 0x9c, 0xc9, 0x7b, 0xfe, 0x30, 0x15, 0xce, 0x6c, 0xd2, 0x6f, 0xcc, 0x64, 0x5c, + /*97d0:*/ 0x76, 0x65, 0x45, 0xa6, 0x17, 0x85, 0x6c, 0xc5, 0x27, 0x2f, 0xd7, 0x16, 0x9e, 0xb7, 0x56, 0xb2, + /*97e0:*/ 0xb0, 0x72, 0x83, 0x5e, 0xde, 0xba, 0x80, 0xf1, 0x06, 0xe3, 0xaf, 0xcb, 0xad, 0xd8, 0x6b, 0xdd, + /*97f0:*/ 0x4a, 0xa9, 0xb6, 0x19, 0x48, 0x10, 0x50, 0xb7, 0xeb, 0x0a, 0x85, 0xa8, 0x9e, 0xbd, 0x10, 0x63, + /*9800:*/ 0x6c, 0x14, 0x33, 0x0a, 0x90, 0x63, 0x1f, 0xda, 0x0b, 0x1d, 0x19, 0xee, 0xf6, 0x20, 0xc5, 0x0c, + /*9810:*/ 0x79, 0x2d, 0x38, 0xbb, 0xdc, 0x38, 0x86, 0x4e, 0xce, 0x64, 0x1e, 0xfb, 0xfd, 0xbf, 0x8e, 0xa6, + /*9820:*/ 0x16, 0xec, 0xd9, 0x7b, 0x69, 0xb9, 0xc3, 0x96, 0x4a, 0x86, 0x43, 0x02, 0xf6, 0x74, 0xb5, 0x5f, + /*9830:*/ 0xb8, 0x39, 0xb1, 0x83, 0x40, 0x45, 0x72, 0xd8, 0xe9, 0x64, 0x81, 0x6a, 0xeb, 0x19, 0xbb, 0x42, + /*9840:*/ 0x61, 0xba, 0x45, 0x42, 0x47, 0x81, 0xe9, 0x19, 0x34, 0xdd, 0x80, 0x3e, 0xb9, 0x2c, 0x00, 0xad, + /*9850:*/ 0x0e, 0x3c, 0x71, 0x0b, 0xea, 0x1f, 0xf8, 0xa5, 0x38, 0x68, 0x66, 0x01, 0xa0, 0x70, 0xf4, 0x41, + /*9860:*/ 0x96, 0xa7, 0xb1, 0xae, 0x3c, 0xd9, 0xfd, 0x10, 0xb8, 0x4a, 0x70, 0x7b, 0x94, 0x00, 0xe8, 0xb6, + /*9870:*/ 0xa5, 0x24, 0xac, 0xa3, 0x5a, 0xd8, 0x6f, 0xa5, 0x48, 0x26, 0xd8, 0x7b, 0x4c, 0x5c, 0x30, 0x8b, + /*9880:*/ 0x6b, 0x55, 0x8a, 0x7b, 0x1b, 0xc8, 0xce, 0x9b, 0x7a, 0xc1, 0x36, 0xe7, 0x9a, 0x58, 0xe8, 0xc7, + /*9890:*/ 0x14, 0x8b, 0x01, 0x5f, 0x13, 0x04, 0x4c, 0x10, 0x43, 0x44, 0x33, 0x44, 0xe2, 0x60, 0xb6, 0x47, + /*98a0:*/ 0xca, 0x0a, 0x2e, 0x90, 0xa7, 0x49, 0xfc, 0x06, 0x3d, 0xf2, 0x4f, 0xd2, 0x69, 0x69, 0x6c, 0x0b, + /*98b0:*/ 0xe4, 0x37, 0x2a, 0x60, 0x8a, 0x8c, 0x0f, 0x33, 0xa9, 0xb1, 0xb3, 0xc8, 0xe6, 0x82, 0xa8, 0xaf, + /*98c0:*/ 0x56, 0x17, 0xc7, 0x77, 0xf6, 0xc9, 0xb2, 0x27, 0x79, 0x7e, 0xec, 0x3c, 0xba, 0xc4, 0x3b, 0x0f, + /*98d0:*/ 0x4f, 0xf4, 0x22, 0x13, 0x4c, 0x20, 0xda, 0xfb, 0xaf, 0x56, 0xae, 0x51, 0x27, 0x54, 0x15, 0x80, + /*98e0:*/ 0x85, 0x94, 0xb7, 0x97, 0x82, 0x8b, 0xef, 0xcf, 0x4a, 0xbf, 0xb8, 0x18, 0x2c, 0x37, 0x59, 0x8d, + /*98f0:*/ 0x32, 0xed, 0x94, 0x78, 0x56, 0x01, 0x05, 0xc0, 0xfe, 0x6f, 0x8c, 0x60, 0x7e, 0x77, 0xee, 0xc0, + /*9900:*/ 0xa8, 0x3f, 0x8d, 0xb9, 0x7d, 0x19, 0x8e, 0x95, 0xf8, 0xbe, 0xc5, 0xe8, 0x57, 0xbd, 0x3c, 0xfc, + /*9910:*/ 0x9b, 0xfd, 0x72, 0x44, 0xf4, 0x42, 0x2d, 0xcb, 0x8c, 0x81, 0x8c, 0x3b, 0x0c, 0xfe, 0x05, 0x42, + /*9920:*/ 0x55, 0xeb, 0xb9, 0x30, 0x27, 0xc5, 0x4c, 0x1b, 0x79, 0xd5, 0x9e, 0x2e, 0x50, 0x25, 0x08, 0x62, + /*9930:*/ 0xcc, 0x75, 0x72, 0x33, 0x26, 0xc3, 0xcd, 0x86, 0xb0, 0xe4, 0xee, 0xea, 0xd6, 0x2d, 0x57, 0xd3, + /*9940:*/ 0x80, 0x9c, 0xef, 0x9d, 0x78, 0x6d, 0x96, 0x28, 0xac, 0xed, 0x27, 0xea, 0x62, 0xbd, 0x8d, 0x9e, + /*9950:*/ 0x20, 0x2b, 0xc4, 0xe4, 0x3d, 0x61, 0x68, 0xff, 0x5c, 0x5d, 0x47, 0x44, 0x40, 0x4c, 0x9a, 0x47, + /*9960:*/ 0xa0, 0x24, 0x16, 0x1e, 0x88, 0xd5, 0x86, 0x29, 0x96, 0x0c, 0x4f, 0x13, 0x1f, 0x2c, 0x03, 0x98, + /*9970:*/ 0x56, 0xd9, 0x46, 0xe5, 0x18, 0x83, 0xed, 0x85, 0xd9, 0x8a, 0x8a, 0x88, 0xe6, 0x19, 0xf2, 0x7b, + /*9980:*/ 0xe4, 0x68, 0x3d, 0xfc, 0xbd, 0x71, 0x27, 0x22, 0xf4, 0x60, 0x51, 0x30, 0x52, 0x99, 0x43, 0x88, + /*9990:*/ 0x42, 0xa4, 0xe8, 0x16, 0xf2, 0x17, 0x3a, 0xd7, 0x2b, 0x85, 0x49, 0x53, 0x50, 0x14, 0x51, 0xd3, + /*99a0:*/ 0x4c, 0x85, 0xcc, 0x80, 0x1e, 0x49, 0x18, 0xb8, 0x3c, 0x3e, 0x1c, 0xbe, 0x56, 0x07, 0xf7, 0xc7, + /*99b0:*/ 0x9f, 0xda, 0xce, 0x00, 0x93, 0xe6, 0xa1, 0xda, 0xf1, 0x45, 0x7b, 0x3f, 0x26, 0x9c, 0xb6, 0xe8, + /*99c0:*/ 0xfb, 0xce, 0x3b, 0x85, 0x64, 0xf5, 0x85, 0x9c, 0x34, 0x4f, 0x89, 0x44, 0x52, 0x69, 0x99, 0xc9, + /*99d0:*/ 0x5d, 0x87, 0x52, 0x2c, 0xd3, 0x3a, 0x6e, 0x5c, 0x02, 0x41, 0x5c, 0x03, 0xa8, 0xfb, 0xcd, 0x82, + /*99e0:*/ 0xe6, 0xd7, 0xe2, 0x90, 0x06, 0x9e, 0x4f, 0xbc, 0x53, 0x79, 0x24, 0xd9, 0x20, 0xb6, 0x5f, 0xa6, + /*99f0:*/ 0x0d, 0x88, 0x85, 0xbe, 0x19, 0xe4, 0x1f, 0x95, 0xf8, 0x94, 0x6e, 0x01, 0x9d, 0xc0, 0xef, 0x18, + /*9a00:*/ 0xaf, 0xda, 0xac, 0x64, 0x8c, 0x7a, 0x84, 0x6d, 0x45, 0xa4, 0x34, 0x66, 0x9b, 0x81, 0xab, 0x69, + /*9a10:*/ 0x19, 0x49, 0x6c, 0xa8, 0xc6, 0x8b, 0x3b, 0xbd, 0xff, 0x27, 0x23, 0x48, 0xa6, 0x6b, 0xa9, 0x30, + /*9a20:*/ 0xf0, 0xbb, 0xe4, 0x08, 0x3d, 0x52, 0x21, 0x70, 0xbc, 0x42, 0x45, 0x92, 0xf7, 0x0c, 0x83, 0x33, + /*9a30:*/ 0x9f, 0x38, 0x28, 0x1b, 0xb3, 0xf2, 0xc4, 0x38, 0x24, 0x03, 0xfd, 0xa9, 0x18, 0x60, 0x54, 0xcc, + /*9a40:*/ 0xc1, 0xb0, 0x78, 0x8e, 0x99, 0x64, 0x9c, 0xeb, 0x02, 0xbc, 0x63, 0x7b, 0xd6, 0x03, 0x6d, 0xcb, + /*9a50:*/ 0x1f, 0x6f, 0x34, 0x59, 0xe6, 0x7e, 0xb0, 0x10, 0xbb, 0x5d, 0xe6, 0xfa, 0x66, 0xbe, 0x14, 0x10, + /*9a60:*/ 0xca, 0xd1, 0x3f, 0x99, 0x4c, 0x04, 0xfb, 0x56, 0x64, 0xec, 0x2e, 0x07, 0x61, 0x05, 0x9c, 0x8c, + /*9a70:*/ 0x1a, 0xc4, 0x34, 0x1d, 0xbf, 0x33, 0x69, 0x38, 0x9f, 0xa4, 0x9e, 0xbd, 0xc6, 0x4d, 0x49, 0xe4, + /*9a80:*/ 0xf3, 0xc5, 0x38, 0xb4, 0xb7, 0xa3, 0x0a, 0x49, 0x67, 0x9e, 0x79, 0xf0, 0xa7, 0x4c, 0x91, 0xf7, + /*9a90:*/ 0x42, 0x88, 0xc1, 0x4f, 0x01, 0xa0, 0x43, 0x6e, 0x39, 0xbd, 0x96, 0x07, 0x3e, 0xab, 0x70, 0x56, + /*9aa0:*/ 0x54, 0xe1, 0xc9, 0xa2, 0x9a, 0x98, 0xb9, 0xd6, 0x3c, 0x17, 0xa9, 0xbe, 0xc5, 0xe2, 0x36, 0x18, + /*9ab0:*/ 0xf4, 0x15, 0x9d, 0x0b, 0xa2, 0x66, 0x87, 0x79, 0x45, 0x6d, 0x24, 0x09, 0xa0, 0xcd, 0x87, 0xdc, + /*9ac0:*/ 0x3d, 0x69, 0x16, 0x6b, 0xef, 0xf4, 0x3b, 0x04, 0x34, 0x84, 0xf1, 0x19, 0x8c, 0x73, 0x90, 0xf0, + /*9ad0:*/ 0xde, 0xfb, 0xcf, 0x48, 0x44, 0x41, 0xf9, 0x81, 0xb3, 0xa7, 0x0a, 0xc2, 0xd4, 0x8c, 0x84, 0x9a, + /*9ae0:*/ 0x6a, 0x1c, 0x34, 0x63, 0x96, 0x0a, 0xe0, 0xc6, 0x10, 0x88, 0x8f, 0x8e, 0xac, 0x96, 0xee, 0xc0, + /*9af0:*/ 0x86, 0x16, 0x61, 0x8f, 0x35, 0xec, 0x47, 0x4e, 0x75, 0x17, 0x49, 0x0e, 0x3f, 0x34, 0x68, 0x7e, + /*9b00:*/ 0xae, 0x61, 0x0e, 0x7e, 0xd2, 0x81, 0x53, 0xd1, 0x53, 0x7a, 0x20, 0x7a, 0x40, 0x7a, 0x2e, 0xbc, + /*9b10:*/ 0x43, 0x3a, 0x66, 0x39, 0x0f, 0xc1, 0x85, 0xc0, 0x71, 0xe0, 0x15, 0x28, 0x47, 0xb5, 0xd1, 0x99, + /*9b20:*/ 0x6e, 0xd3, 0x48, 0xe0, 0x41, 0xa7, 0xf3, 0x27, 0x8f, 0xda, 0x55, 0x5f, 0x89, 0x0f, 0x9b, 0x91, + /*9b30:*/ 0xe9, 0x1f, 0x9b, 0x5e, 0x32, 0x53, 0x3e, 0x8c, 0x65, 0xd5, 0x92, 0x0b, 0x8c, 0x5f, 0x73, 0xcc, + /*9b40:*/ 0x0d, 0xc5, 0xa7, 0x1c, 0x80, 0x85, 0xca, 0xbc, 0x00, 0xf6, 0x73, 0x07, 0x9b, 0xb4, 0x93, 0x48, + /*9b50:*/ 0x22, 0xe3, 0xf9, 0x63, 0x9d, 0xe5, 0x82, 0x17, 0x3e, 0x65, 0x2b, 0x4f, 0x68, 0xc3, 0xc3, 0x6d, + /*9b60:*/ 0x8d, 0x9a, 0x5e, 0x47, 0xe6, 0x1f, 0x99, 0x94, 0xab, 0xd6, 0xc2, 0xeb, 0x05, 0x70, 0x23, 0x7a, + /*9b70:*/ 0x6b, 0xbd, 0xc0, 0x1d, 0xe2, 0x22, 0xa9, 0xb5, 0x56, 0xcb, 0x93, 0x2c, 0x88, 0xed, 0xd9, 0xbf, + /*9b80:*/ 0x14, 0x44, 0xb3, 0x99, 0xe2, 0x58, 0x2d, 0x78, 0x53, 0xc3, 0xbf, 0x94, 0xd0, 0x57, 0x95, 0xec, + /*9b90:*/ 0x25, 0xe2, 0x51, 0xb4, 0x6f, 0x2d, 0xf9, 0xb4, 0x15, 0x32, 0xa4, 0x20, 0xf8, 0x7e, 0x47, 0x65, + /*9ba0:*/ 0xc8, 0xb2, 0x95, 0xad, 0x41, 0xd5, 0x91, 0xbb, 0xd7, 0x66, 0x2c, 0x96, 0x7d, 0x78, 0x85, 0x3c, + /*9bb0:*/ 0x72, 0x21, 0x9d, 0xe4, 0x4a, 0x4a, 0x4f, 0x29, 0x76, 0x24, 0x82, 0x83, 0xb8, 0x19, 0x1b, 0x5a, + /*9bc0:*/ 0x1f, 0x13, 0x76, 0xc2, 0xe3, 0x69, 0x75, 0xea, 0x4a, 0xb0, 0xbd, 0x34, 0x87, 0x0c, 0xe3, 0xda, + /*9bd0:*/ 0x14, 0xce, 0x42, 0x65, 0x42, 0xed, 0x9a, 0x7f, 0x69, 0x83, 0x55, 0xa4, 0xbf, 0xd5, 0x91, 0xa9, + /*9be0:*/ 0x00, 0x57, 0xa1, 0x24, 0x8d, 0xd8, 0x01, 0xf7, 0x5a, 0x76, 0xf8, 0x15, 0x14, 0x80, 0xd0, 0x8e, + /*9bf0:*/ 0x26, 0xbb, 0x5c, 0x5b, 0x6b, 0x62, 0x5c, 0xa4, 0x75, 0xe2, 0x01, 0xd1, 0x46, 0x9b, 0x7f, 0x7f, + /*9c00:*/ 0x16, 0xd1, 0xa0, 0xfa, 0x4f, 0x8e, 0x3d, 0xe4, 0xe0, 0xab, 0xc4, 0x25, 0x7f, 0x3a, 0x1b, 0x17, + /*9c10:*/ 0x3a, 0x99, 0xff, 0xa6, 0x54, 0xce, 0x8d, 0x7c, 0xa6, 0x4a, 0xce, 0x6f, 0x98, 0xe3, 0x1d, 0x84, + /*9c20:*/ 0x8b, 0x74, 0xf7, 0x01, 0x99, 0x05, 0x21, 0xce, 0x4d, 0x0f, 0x4c, 0x91, 0x40, 0x24, 0xf4, 0x78, + /*9c30:*/ 0xec, 0x90, 0xc9, 0xca, 0xc2, 0x63, 0x97, 0x84, 0x56, 0x21, 0x88, 0x57, 0xc2, 0xc0, 0x9d, 0xbd, + /*9c40:*/ 0x78, 0xc8, 0x69, 0x9a, 0x00, 0xd0, 0xaa, 0x65, 0x9a, 0x74, 0x06, 0xf1, 0x66, 0x15, 0xcc, 0xf2, + /*9c50:*/ 0x2a, 0x6a, 0xc1, 0xf3, 0x02, 0x6e, 0x08, 0xc4, 0xea, 0x54, 0x55, 0x05, 0x86, 0xeb, 0x19, 0x4a, + /*9c60:*/ 0xa3, 0xee, 0xa7, 0x1a, 0x3c, 0x93, 0x34, 0x07, 0x91, 0x72, 0x36, 0xbd, 0xb7, 0x54, 0xc5, 0x05, + /*9c70:*/ 0xdb, 0xe3, 0xe6, 0x5d, 0x48, 0x58, 0x16, 0x23, 0xed, 0x21, 0x9e, 0xe6, 0xed, 0xb4, 0x8f, 0x75, + /*9c80:*/ 0x8d, 0x5b, 0x9a, 0x16, 0x65, 0x9e, 0x5f, 0xb9, 0xff, 0xc9, 0xcd, 0xd0, 0xa8, 0xd3, 0x36, 0x3e, + /*9c90:*/ 0x36, 0x67, 0x30, 0xf5, 0xd8, 0xbe, 0x1c, 0xe3, 0x30, 0x9e, 0x0c, 0x1b, 0x06, 0x6d, 0x34, 0x07, + /*9ca0:*/ 0x73, 0x56, 0x08, 0xff, 0xaa, 0x12, 0x5b, 0x46, 0x54, 0x57, 0xb5, 0x3d, 0x56, 0x95, 0x09, 0x9f, + /*9cb0:*/ 0x40, 0x99, 0x96, 0x83, 0x58, 0xbb, 0xcc, 0x88, 0x1a, 0x62, 0xbd, 0xb7, 0xaa, 0x27, 0x9a, 0xf7, + /*9cc0:*/ 0xd1, 0x23, 0x3c, 0xa7, 0x5f, 0x82, 0x20, 0x91, 0x0c, 0xa5, 0x4c, 0xda, 0x74, 0xf8, 0x0e, 0x59, + /*9cd0:*/ 0x68, 0x13, 0xd6, 0x07, 0xe2, 0x4e, 0x57, 0x5c, 0xd3, 0xb5, 0xb9, 0x11, 0xaa, 0x45, 0x74, 0xf2, + /*9ce0:*/ 0xf4, 0x37, 0x37, 0xff, 0x45, 0x6c, 0x51, 0x1d, 0xfe, 0xf0, 0x12, 0x40, 0x57, 0x6f, 0x41, 0x93, + /*9cf0:*/ 0xb0, 0x7c, 0xd3, 0x5d, 0xe4, 0x10, 0x0c, 0xe2, 0xfa, 0x90, 0xa9, 0x68, 0xf9, 0x41, 0xd4, 0x71, + /*9d00:*/ 0x2e, 0x46, 0xfb, 0x78, 0xca, 0xa6, 0x44, 0xec, 0xbf, 0xfb, 0x33, 0xea, 0xcd, 0x46, 0x64, 0xf0, + /*9d10:*/ 0x1e, 0x5a, 0x3a, 0x3a, 0xbe, 0x7f, 0x83, 0x94, 0xb2, 0x11, 0xb1, 0x32, 0x14, 0x05, 0xc0, 0xa0, + /*9d20:*/ 0x87, 0x7f, 0xb7, 0xf2, 0xe9, 0x08, 0xcb, 0x1f, 0x5d, 0x87, 0x30, 0xec, 0x05, 0xcf, 0xaa, 0x01, + /*9d30:*/ 0x2f, 0x23, 0x0d, 0x81, 0xde, 0x30, 0x8e, 0x03, 0x0e, 0x44, 0x6e, 0x62, 0xb9, 0x6e, 0x7c, 0x0e, + /*9d40:*/ 0x0a, 0x00, 0x63, 0xea, 0xb9, 0xbd, 0x9b, 0x8e, 0x1a, 0x3c, 0xb4, 0xff, 0xae, 0xd4, 0x15, 0x18, + /*9d50:*/ 0xe6, 0x0f, 0xfe, 0x28, 0x6e, 0xdc, 0x76, 0x2a, 0xf5, 0xd4, 0x14, 0xd8, 0x8c, 0x76, 0x35, 0xa8, + /*9d60:*/ 0x85, 0x38, 0x55, 0xfe, 0xc3, 0x83, 0xd5, 0xaa, 0x58, 0x92, 0xb8, 0x82, 0x45, 0x9c, 0xe5, 0x92, + /*9d70:*/ 0xd4, 0x11, 0xc9, 0xf9, 0xab, 0x5b, 0x9c, 0x77, 0xb3, 0xbe, 0x3f, 0x65, 0x89, 0xbd, 0x1d, 0xdf, + /*9d80:*/ 0x89, 0x64, 0xe3, 0x0b, 0xf4, 0xc8, 0xf2, 0xe1, 0x23, 0xbf, 0x13, 0x81, 0x33, 0x92, 0x94, 0x75, + /*9d90:*/ 0x1b, 0xd1, 0xfc, 0x34, 0xee, 0x54, 0xdc, 0x3c, 0x40, 0xf4, 0x5d, 0xdd, 0x64, 0xd5, 0xb0, 0xdf, + /*9da0:*/ 0x6a, 0xb6, 0x3b, 0x92, 0x71, 0x06, 0x33, 0xf7, 0xba, 0x9b, 0x4a, 0x79, 0x91, 0x31, 0x17, 0x86, + /*9db0:*/ 0x35, 0x37, 0x8f, 0x62, 0x57, 0x43, 0xe7, 0x72, 0x32, 0x56, 0x91, 0x41, 0xd5, 0xc9, 0x27, 0x54, + /*9dc0:*/ 0x7e, 0x61, 0x7b, 0x36, 0x15, 0x2d, 0xbd, 0x4d, 0x9f, 0x51, 0xfd, 0x85, 0x8d, 0x00, 0x91, 0xe3, + /*9dd0:*/ 0x64, 0xb1, 0x8b, 0x51, 0xbe, 0x0e, 0x5d, 0xdb, 0x41, 0x79, 0xec, 0x11, 0x95, 0xa7, 0xfa, 0x4b, + /*9de0:*/ 0xd3, 0x55, 0x98, 0xb2, 0xd2, 0x51, 0xfe, 0x51, 0x35, 0x9c, 0x22, 0x3e, 0x25, 0x91, 0x42, 0xc3, + /*9df0:*/ 0xb0, 0x75, 0x05, 0xeb, 0xf2, 0xcb, 0x7d, 0xaa, 0xb6, 0x4b, 0x82, 0x12, 0xc2, 0x88, 0xf9, 0x78, + /*9e00:*/ 0xf6, 0x01, 0x30, 0x50, 0x38, 0x6a, 0xcb, 0xb1, 0xf1, 0x27, 0xcb, 0xf7, 0xd3, 0xe1, 0x43, 0xf3, + /*9e10:*/ 0x9e, 0x8c, 0x92, 0xab, 0xcd, 0xa7, 0x03, 0xc3, 0xd0, 0x9c, 0x91, 0x8b, 0x2d, 0xde, 0xbc, 0x50, + /*9e20:*/ 0x63, 0x95, 0x4b, 0x7e, 0xda, 0xf4, 0x72, 0xe3, 0xcc, 0x2c, 0x35, 0x5d, 0x2c, 0xd0, 0x4b, 0x54, + /*9e30:*/ 0xaf, 0xf4, 0x42, 0x0e, 0xd4, 0x8a, 0x66, 0x56, 0x83, 0xd9, 0x5e, 0x1d, 0x81, 0xd3, 0xce, 0xad, + /*9e40:*/ 0x61, 0xca, 0x20, 0xe6, 0xc3, 0x17, 0xef, 0x4b, 0xbe, 0xf0, 0xbc, 0xda, 0xb3, 0x79, 0xb5, 0xcb, + /*9e50:*/ 0x38, 0x67, 0x2a, 0x17, 0x4f, 0xda, 0xfc, 0x1a, 0x87, 0x8d, 0xc3, 0x73, 0x87, 0x65, 0xf6, 0x03, + /*9e60:*/ 0xc9, 0xf0, 0xab, 0x2c, 0x6f, 0xae, 0x90, 0x15, 0x10, 0xf1, 0x8d, 0x90, 0x05, 0x1a, 0x27, 0x72, + /*9e70:*/ 0x2d, 0x2d, 0xfb, 0x1b, 0xec, 0x9a, 0x90, 0x21, 0x08, 0xb6, 0x58, 0x57, 0xb3, 0x3d, 0xb1, 0x29, + /*9e80:*/ 0x00, 0x62, 0x95, 0x68, 0x6b, 0x5b, 0xfb, 0x98, 0x6e, 0xbb, 0x9c, 0x53, 0x03, 0xd3, 0xda, 0x91, + /*9e90:*/ 0xac, 0xec, 0x1c, 0x4e, 0x56, 0xbb, 0x50, 0xe3, 0x23, 0xc0, 0x01, 0x63, 0x45, 0x01, 0xff, 0x30, + /*9ea0:*/ 0x6e, 0x6f, 0xe9, 0x60, 0xed, 0xab, 0x89, 0x5c, 0xcf, 0x0a, 0x89, 0x13, 0x39, 0x2a, 0xa6, 0x93, + /*9eb0:*/ 0x18, 0xc8, 0x26, 0xd3, 0x23, 0x8c, 0x22, 0xa4, 0x3c, 0xde, 0xe7, 0x7d, 0x9c, 0x5c, 0x35, 0x4c, + /*9ec0:*/ 0xb1, 0x6e, 0xfc, 0x19, 0xaa, 0x5a, 0x17, 0xad, 0x22, 0x75, 0x3e, 0x83, 0xa7, 0x7e, 0x72, 0xe0, + /*9ed0:*/ 0xaa, 0x75, 0x37, 0x2a, 0xd0, 0xd3, 0x8f, 0xbf, 0x20, 0x0b, 0x3e, 0xff, 0xea, 0x0b, 0x3c, 0x20, + /*9ee0:*/ 0x33, 0x6b, 0x28, 0xc8, 0x67, 0x85, 0x97, 0x61, 0x5f, 0x48, 0xaf, 0x38, 0x38, 0x07, 0x41, 0x6a, + /*9ef0:*/ 0x5e, 0x5a, 0x39, 0x4e, 0x45, 0xc6, 0xb5, 0x8f, 0xea, 0x78, 0x47, 0x51, 0x83, 0xb2, 0x98, 0xd1, + /*9f00:*/ 0x43, 0x0f, 0xc4, 0xaf, 0xad, 0xf4, 0x95, 0xe5, 0xc8, 0x6f, 0x48, 0x50, 0x83, 0x7c, 0xd4, 0xb9, + /*9f10:*/ 0x13, 0x7b, 0x60, 0x41, 0xf9, 0x2f, 0xe0, 0x31, 0x5f, 0x3f, 0x20, 0xce, 0x6f, 0xcd, 0x94, 0x0a, + /*9f20:*/ 0xd5, 0x0b, 0x01, 0x09, 0x5f, 0x1d, 0x43, 0x0a, 0x35, 0x05, 0x6b, 0xe6, 0x0a, 0x48, 0xb1, 0xa7, + /*9f30:*/ 0xe5, 0x03, 0x7f, 0x6b, 0xfe, 0xcc, 0xdf, 0x88, 0xbc, 0xde, 0x8f, 0x1f, 0xad, 0x77, 0xb0, 0xe9, + /*9f40:*/ 0x53, 0x1f, 0xad, 0xb0, 0x81, 0x9f, 0xa6, 0x9f, 0x7e, 0x36, 0x8e, 0xed, 0xba, 0xa9, 0x07, 0x78, + /*9f50:*/ 0x2f, 0xea, 0xdb, 0x66, 0x63, 0x32, 0x47, 0xbf, 0x38, 0xfe, 0x6b, 0xa8, 0x29, 0x27, 0x0a, 0x41, + /*9f60:*/ 0x0b, 0x84, 0x11, 0xcf, 0x5c, 0x57, 0x0f, 0x2a, 0xbc, 0x6f, 0xc8, 0xa8, 0x55, 0x19, 0xd8, 0xd0, + /*9f70:*/ 0x7c, 0xec, 0x19, 0x72, 0x50, 0xfa, 0x86, 0xf8, 0xa9, 0x1e, 0xb7, 0xa3, 0x96, 0xe2, 0x58, 0x17, + /*9f80:*/ 0x1c, 0xc9, 0x95, 0x38, 0x9e, 0x94, 0x9e, 0x16, 0xe1, 0x69, 0xe7, 0xea, 0xf2, 0x49, 0x5f, 0x9a, + /*9f90:*/ 0x64, 0x42, 0x5e, 0x7b, 0xb5, 0x4b, 0x5c, 0x29, 0x23, 0x84, 0xaf, 0xa3, 0x41, 0x54, 0xd2, 0x9e, + /*9fa0:*/ 0x25, 0x1d, 0x19, 0x1a, 0x86, 0x1d, 0xa5, 0xb4, 0xc6, 0x8f, 0x81, 0x1f, 0x06, 0xed, 0xb8, 0xee, + /*9fb0:*/ 0x1b, 0xf0, 0xb6, 0x78, 0xd1, 0x00, 0x85, 0x81, 0xff, 0xde, 0xdb, 0xc1, 0x6c, 0xb9, 0xdc, 0xb3, + /*9fc0:*/ 0x45, 0x16, 0x5f, 0xaf, 0x54, 0x17, 0xef, 0x0b, 0x98, 0x33, 0x29, 0xb5, 0x4a, 0xfb, 0x3d, 0x19, + /*9fd0:*/ 0x0d, 0x74, 0x8b, 0xee, 0x20, 0x94, 0x80, 0x59, 0xac, 0x93, 0xba, 0x50, 0x8a, 0x7b, 0xff, 0xd1, + /*9fe0:*/ 0xad, 0x7e, 0x91, 0x79, 0xcb, 0xb1, 0x64, 0x58, 0x55, 0x2a, 0xf8, 0xc4, 0xcd, 0x9b, 0xdc, 0x4c, + /*9ff0:*/ 0x17, 0x61, 0x19, 0x99, 0x54, 0x30, 0x20, 0x6b, 0xe9, 0xc8, 0xad, 0x1f, 0xcf, 0x61, 0x18, 0x5f, + /*a000:*/ 0x1d, 0x2d, 0xb1, 0xb6, 0xbf, 0xd9, 0xee, 0x38, 0x22, 0xd1, 0xd4, 0xad, 0xe7, 0xe4, 0xb3, 0xcd, + /*a010:*/ 0x65, 0x9c, 0x45, 0xcf, 0x2b, 0xe0, 0xde, 0x2c, 0x3a, 0x53, 0x1f, 0x98, 0x10, 0xf5, 0x15, 0xd8, + /*a020:*/ 0x53, 0xa4, 0x3c, 0x46, 0x00, 0x53, 0xab, 0x9b, 0x4f, 0x92, 0xb8, 0x70, 0x84, 0x24, 0xa7, 0xaf, + /*a030:*/ 0xe3, 0x0a, 0x5f, 0x89, 0x10, 0xa1, 0x72, 0x3d, 0x68, 0x14, 0x1d, 0xb9, 0x16, 0x4e, 0x6c, 0x19, + /*a040:*/ 0x43, 0x95, 0x83, 0xb8, 0x18, 0x61, 0x4d, 0x20, 0x6d, 0xb9, 0x97, 0x6b, 0x44, 0xe4, 0x9b, 0x2c, + /*a050:*/ 0xb5, 0x5a, 0xdd, 0xd5, 0xd1, 0x6a, 0xdf, 0x19, 0xf7, 0xb0, 0x5a, 0x09, 0xc1, 0x55, 0x3e, 0x88, + /*a060:*/ 0xbe, 0xa5, 0x49, 0x20, 0x95, 0x7f, 0xcb, 0x97, 0x5b, 0x51, 0x4d, 0xb0, 0x77, 0x89, 0xab, 0x4d, + /*a070:*/ 0xfc, 0x88, 0x20, 0x25, 0x68, 0x38, 0x6a, 0xb9, 0x5d, 0x0b, 0x9a, 0xe6, 0x96, 0xeb, 0x64, 0x66, + /*a080:*/ 0x1f, 0x7b, 0xb0, 0x2f, 0x35, 0xb6, 0x45, 0x25, 0x46, 0x09, 0x70, 0x98, 0xf8, 0xdc, 0x47, 0x14, + /*a090:*/ 0x7d, 0x61, 0xfa, 0x6e, 0x4e, 0x7c, 0x4f, 0x42, 0xe3, 0xaa, 0x1a, 0xf7, 0x44, 0xa8, 0x4a, 0x85, + /*a0a0:*/ 0xa5, 0xcc, 0x07, 0x7c, 0x2a, 0x23, 0xab, 0x1d, 0xf7, 0xa0, 0xd5, 0xd9, 0x9b, 0xfc, 0xf9, 0x9b, + /*a0b0:*/ 0xec, 0x93, 0xd4, 0x03, 0x86, 0x1d, 0x0b, 0x02, 0x82, 0xde, 0x06, 0xb3, 0xd1, 0x58, 0x03, 0xf1, + /*a0c0:*/ 0xbd, 0x8f, 0xf8, 0xc9, 0x39, 0x9d, 0xce, 0x16, 0x54, 0xb0, 0x42, 0x8b, 0xac, 0x08, 0x5c, 0xfb, + /*a0d0:*/ 0x0c, 0xcb, 0x79, 0xfc, 0x65, 0xe0, 0xe6, 0x54, 0xcd, 0x39, 0x6d, 0x3d, 0x67, 0x69, 0xf4, 0xb6, + /*a0e0:*/ 0x0d, 0x51, 0xb2, 0x3b, 0xc0, 0x61, 0x97, 0xde, 0xbd, 0x7f, 0x0a, 0xe0, 0xb0, 0xd7, 0x46, 0x21, + /*a0f0:*/ 0xb4, 0xa5, 0x9b, 0x96, 0x3c, 0xf5, 0x75, 0x39, 0x44, 0xb9, 0x06, 0xf2, 0xf7, 0x51, 0xc8, 0xfa, + /*a100:*/ 0x6f, 0x1c, 0x06, 0x3c, 0x90, 0xf0, 0xf6, 0x67, 0x17, 0xe8, 0xb2, 0x0c, 0x75, 0x40, 0x92, 0x4d, + /*a110:*/ 0x41, 0x08, 0x39, 0xf9, 0x71, 0xb8, 0xe5, 0xbf, 0x8f, 0xad, 0x90, 0x84, 0x29, 0x48, 0x8e, 0x75, + /*a120:*/ 0x4f, 0xb3, 0xf3, 0xe3, 0xc3, 0xf5, 0x3d, 0xe6, 0x95, 0xfb, 0x14, 0x5b, 0x89, 0xe4, 0xd8, 0xf3, + /*a130:*/ 0x16, 0x26, 0x76, 0xf5, 0x76, 0x43, 0x1f, 0xe3, 0x0b, 0xe4, 0xb7, 0x5a, 0x1a, 0x2c, 0x71, 0xb0, + /*a140:*/ 0xd4, 0xd0, 0x09, 0x8c, 0x64, 0x70, 0x57, 0x98, 0xe6, 0xa6, 0x10, 0x6f, 0xde, 0xe1, 0xa5, 0x45, + /*a150:*/ 0x9e, 0x41, 0x35, 0x3f, 0x78, 0x8e, 0xf1, 0x3c, 0x30, 0x32, 0xe2, 0xe1, 0xa6, 0xd8, 0x58, 0xc0, + /*a160:*/ 0xa4, 0x69, 0x1a, 0x5a, 0xb2, 0x56, 0x7f, 0x33, 0x3f, 0x10, 0x77, 0x92, 0xa7, 0xc0, 0xb2, 0xc0, + /*a170:*/ 0xf8, 0x27, 0xa5, 0xcd, 0xfa, 0x27, 0x9f, 0xe3, 0x28, 0x59, 0x54, 0xb3, 0x43, 0xf8, 0xd7, 0x20, + /*a180:*/ 0x25, 0xee, 0x34, 0x3d, 0x66, 0xa1, 0x48, 0x83, 0x61, 0x03, 0x29, 0xcb, 0xbb, 0x72, 0x56, 0x1d, + /*a190:*/ 0x66, 0xfc, 0xcf, 0x6e, 0x28, 0x22, 0xed, 0x3a, 0x2f, 0xdb, 0x4a, 0x0b, 0xa6, 0xbe, 0xb2, 0xe4, + /*a1a0:*/ 0x26, 0x40, 0x82, 0xd0, 0xab, 0xfa, 0x95, 0x03, 0x4d, 0xdb, 0x5b, 0x97, 0x65, 0x36, 0x4a, 0x5e, + /*a1b0:*/ 0xd9, 0x63, 0xc8, 0x9c, 0xbe, 0x70, 0x76, 0xee, 0xa0, 0xcf, 0x34, 0xad, 0xcd, 0xa1, 0x81, 0x19, + /*a1c0:*/ 0x71, 0x49, 0xb7, 0xc9, 0x47, 0xec, 0x92, 0x32, 0xc8, 0xf0, 0xe0, 0x30, 0xee, 0x9a, 0xbb, 0x11, + /*a1d0:*/ 0x8e, 0xe4, 0xa8, 0xdb, 0x1f, 0x29, 0xf5, 0xcf, 0x16, 0x82, 0x7b, 0xcf, 0x10, 0x48, 0xaa, 0x55, + /*a1e0:*/ 0x75, 0x9e, 0x8b, 0xc1, 0x34, 0xd2, 0x91, 0xd1, 0x56, 0x51, 0xee, 0xcb, 0xc5, 0x8b, 0xeb, 0x30, + /*a1f0:*/ 0xa9, 0x0c, 0xcd, 0x05, 0x7c, 0xd0, 0x64, 0x8b, 0x66, 0xba, 0x59, 0xd2, 0x0d, 0x87, 0x8f, 0xf6, + /*a200:*/ 0x67, 0x8b, 0x85, 0x44, 0x7f, 0xd9, 0x02, 0xfd, 0x75, 0x0b, 0x11, 0x45, 0xa5, 0x1d, 0x2a, 0x37, + /*a210:*/ 0xd8, 0xe7, 0xde, 0x33, 0xcf, 0xdb, 0xdb, 0x31, 0xe4, 0xf5, 0x41, 0xae, 0x33, 0x6e, 0x0e, 0x02, + /*a220:*/ 0x02, 0x38, 0xd7, 0x67, 0xb5, 0x24, 0xe9, 0x31, 0x91, 0x0f, 0x5f, 0x24, 0xd3, 0x2f, 0x41, 0xe7, + /*a230:*/ 0x8a, 0xb0, 0x5c, 0x88, 0x32, 0x4e, 0xff, 0xf1, 0xa4, 0xaf, 0xa8, 0x6b, 0x04, 0x5d, 0x0e, 0xb2, + /*a240:*/ 0xd8, 0x69, 0x74, 0x5b, 0xbc, 0x91, 0xf3, 0x59, 0x98, 0xf5, 0x13, 0xdd, 0x10, 0x45, 0x02, 0x6d, + /*a250:*/ 0xcb, 0x3e, 0x01, 0x31, 0xa0, 0x29, 0x07, 0x67, 0x3b, 0x04, 0x4a, 0xc3, 0x9c, 0x9e, 0x90, 0xa0, + /*a260:*/ 0x1d, 0xc1, 0x6a, 0x9e, 0xef, 0xd5, 0xf2, 0x1f, 0x91, 0xd0, 0xe7, 0xe2, 0x76, 0x83, 0xaa, 0x85, + /*a270:*/ 0xd6, 0x29, 0x8a, 0x74, 0x09, 0x94, 0xed, 0x4e, 0x2b, 0xd9, 0x6a, 0x55, 0x70, 0x3d, 0x16, 0x57, + /*a280:*/ 0xd4, 0x9e, 0x31, 0x66, 0x8b, 0xf4, 0x6a, 0x70, 0xce, 0xe5, 0x33, 0xc0, 0xb4, 0xcf, 0x41, 0xf7, + /*a290:*/ 0xb2, 0xbf, 0x95, 0xa1, 0xe3, 0x8b, 0x2e, 0x46, 0x1f, 0x44, 0xe5, 0xd0, 0x5e, 0x99, 0x4a, 0xb6, + /*a2a0:*/ 0x65, 0x90, 0x74, 0x2a, 0x8e, 0xbc, 0x1f, 0x17, 0x6a, 0x01, 0x05, 0xb7, 0xb5, 0xd2, 0xab, 0xf6, + /*a2b0:*/ 0xe6, 0x90, 0x5a, 0x07, 0xa1, 0x7c, 0x68, 0x9d, 0x7a, 0x88, 0x1c, 0x10, 0xa4, 0xe3, 0x7b, 0xbb, + /*a2c0:*/ 0xf4, 0xb0, 0x1f, 0x59, 0x96, 0x31, 0xea, 0xc5, 0xf2, 0x7e, 0x1e, 0x31, 0xa2, 0x94, 0x84, 0x3a, + /*a2d0:*/ 0xbd, 0x08, 0x8a, 0x3a, 0xa5, 0x6d, 0x0e, 0x45, 0x63, 0xd8, 0xe5, 0xf4, 0x53, 0xd5, 0x04, 0x64, + /*a2e0:*/ 0x43, 0x14, 0xed, 0x45, 0x96, 0x31, 0xdd, 0x73, 0xf8, 0xe5, 0x1f, 0x4f, 0xd7, 0x41, 0x9e, 0xed, + /*a2f0:*/ 0x87, 0xb0, 0x20, 0x8a, 0x51, 0xcf, 0x9e, 0x42, 0xe4, 0xb8, 0xce, 0x61, 0xbe, 0x3f, 0x03, 0xf6, + /*a300:*/ 0xdd, 0x55, 0x57, 0x17, 0x89, 0xe3, 0x11, 0x2f, 0x75, 0x54, 0x8f, 0xcc, 0x69, 0xc8, 0xd9, 0xd0, + /*a310:*/ 0x17, 0xfc, 0x6a, 0x4f, 0x11, 0x08, 0xc5, 0x67, 0xd4, 0xdd, 0x6e, 0x9c, 0xae, 0x18, 0x05, 0x50, + /*a320:*/ 0xd9, 0xb0, 0x75, 0x8c, 0x4a, 0x0a, 0xb9, 0x37, 0x91, 0x38, 0xab, 0x5e, 0xbc, 0xe0, 0x15, 0x07, + /*a330:*/ 0x10, 0xdd, 0x4c, 0xb2, 0xc7, 0x62, 0x57, 0x51, 0x72, 0xe9, 0x23, 0x50, 0x47, 0xf9, 0xc2, 0x31, + /*a340:*/ 0x40, 0x47, 0xfd, 0xe3, 0xf6, 0x45, 0xc4, 0xd8, 0x3b, 0x42, 0x47, 0xed, 0xd6, 0x36, 0x0a, 0x66, + /*a350:*/ 0x96, 0x1d, 0x3a, 0x27, 0x59, 0xa3, 0x51, 0xa6, 0xc0, 0x6c, 0xdb, 0x43, 0x0f, 0x86, 0xcb, 0xe6, + /*a360:*/ 0x01, 0x2d, 0x42, 0xcd, 0xa7, 0x63, 0x27, 0x0e, 0xd0, 0xdb, 0xa9, 0x39, 0xbe, 0x43, 0x78, 0x16, + /*a370:*/ 0x54, 0xcc, 0xff, 0x0d, 0x4c, 0x44, 0x22, 0x9e, 0xbf, 0x33, 0xbb, 0xb6, 0xd5, 0x9b, 0xe1, 0x80, + /*a380:*/ 0x26, 0x54, 0x76, 0xe7, 0xcb, 0x8b, 0x36, 0x9c, 0x85, 0xb7, 0xee, 0x62, 0x26, 0xa0, 0xd9, 0x99, + /*a390:*/ 0x1d, 0x8e, 0xfc, 0x66, 0xb8, 0x80, 0x64, 0x74, 0xc7, 0x5a, 0x51, 0x4e, 0x27, 0xac, 0x53, 0xb5, + /*a3a0:*/ 0x94, 0xf8, 0xab, 0xd9, 0xf9, 0x7b, 0xdd, 0xda, 0xac, 0xd6, 0xf8, 0x81, 0x8b, 0x1e, 0xd2, 0x11, + /*a3b0:*/ 0xc3, 0x2a, 0xc2, 0x32, 0xb5, 0x96, 0x11, 0xae, 0xa5, 0x44, 0xe8, 0xe3, 0x37, 0x2e, 0xe5, 0x46, + /*a3c0:*/ 0x89, 0xc1, 0x4a, 0x18, 0xdd, 0x0d, 0x08, 0x7c, 0x54, 0x4e, 0xe6, 0x48, 0x76, 0x74, 0x19, 0x7e, + /*a3d0:*/ 0x40, 0xf4, 0xf4, 0xe6, 0x04, 0x1c, 0xe2, 0x19, 0x2a, 0x87, 0x1d, 0x07, 0x3b, 0xf9, 0xf5, 0x72, + /*a3e0:*/ 0x67, 0xc5, 0xd5, 0x53, 0x5d, 0xa2, 0x6f, 0x87, 0x38, 0xe6, 0x3d, 0x7c, 0xf5, 0xcd, 0x02, 0xfc, + /*a3f0:*/ 0xf2, 0x74, 0x27, 0x62, 0x62, 0x71, 0x45, 0xaa, 0x1f, 0xbd, 0x49, 0x8c, 0xa3, 0xb8, 0xf7, 0x14, + /*a400:*/ 0xac, 0x49, 0xeb, 0xb3, 0x8f, 0x5f, 0x12, 0x46, 0x07, 0x28, 0x32, 0x4a, 0x50, 0x0e, 0x98, 0xb3, + /*a410:*/ 0x8f, 0x63, 0x38, 0x45, 0x76, 0xf1, 0xcf, 0x04, 0x86, 0x16, 0x2f, 0x10, 0xbd, 0xa0, 0xb1, 0xd1, + /*a420:*/ 0xe4, 0x32, 0x09, 0xa3, 0x0c, 0x4c, 0xf3, 0xb0, 0x3b, 0x7d, 0xa8, 0x9b, 0xf7, 0x6c, 0x11, 0xce, + /*a430:*/ 0xe4, 0x19, 0x8c, 0xbb, 0x27, 0x12, 0x73, 0x9f, 0xe9, 0x46, 0x4a, 0x82, 0xf9, 0x26, 0x30, 0x4e, + /*a440:*/ 0xef, 0x11, 0x55, 0x98, 0x2c, 0xa4, 0xf4, 0xa9, 0x42, 0x56, 0x67, 0x36, 0xbf, 0x8c, 0xe4, 0x8c, + /*a450:*/ 0xf8, 0x47, 0x8f, 0x73, 0x3a, 0x0c, 0xdd, 0xe6, 0x49, 0x29, 0x12, 0xf4, 0xc2, 0x7d, 0x72, 0x0f, + /*a460:*/ 0xa5, 0x5b, 0xb9, 0x19, 0xfe, 0x24, 0x65, 0xfd, 0x5a, 0xe6, 0x3f, 0xb0, 0x2c, 0x78, 0xec, 0x3f, + /*a470:*/ 0x1f, 0xc2, 0xa8, 0xd0, 0xdf, 0x1b, 0xa1, 0x9b, 0x47, 0x0b, 0x16, 0xb2, 0x1d, 0x75, 0xba, 0x23, + /*a480:*/ 0x20, 0x5a, 0x88, 0xca, 0x99, 0x54, 0x00, 0x8e, 0xd4, 0x9e, 0x31, 0x71, 0xdf, 0xb8, 0xf9, 0x23, + /*a490:*/ 0xc7, 0x88, 0x2a, 0x40, 0xc5, 0x5f, 0x17, 0x07, 0xe5, 0xab, 0x70, 0xff, 0xac, 0x79, 0xe8, 0x51, + /*a4a0:*/ 0x9c, 0x9f, 0x06, 0x43, 0x31, 0x7a, 0x0f, 0xa1, 0x12, 0x5a, 0x50, 0x86, 0x7a, 0x0f, 0xf9, 0xf2, + /*a4b0:*/ 0x13, 0x7d, 0x11, 0x72, 0x56, 0xa5, 0x54, 0x52, 0xb4, 0xcf, 0xb0, 0xdb, 0xce, 0xe1, 0x02, 0x8e, + /*a4c0:*/ 0xeb, 0xf8, 0xc6, 0xdd, 0xcf, 0x7f, 0x48, 0xa6, 0x18, 0xc1, 0x8e, 0xeb, 0xf7, 0xf0, 0x59, 0x2e, + /*a4d0:*/ 0xb5, 0xb0, 0x29, 0x7c, 0x46, 0x88, 0xfb, 0xf8, 0x5e, 0xb8, 0xd1, 0x96, 0x23, 0x8e, 0xaf, 0x06, + /*a4e0:*/ 0x44, 0x1b, 0xe0, 0xac, 0xf9, 0x5c, 0xa0, 0x2a, 0x05, 0xfc, 0x8f, 0x74, 0x4d, 0x42, 0x4c, 0xca, + /*a4f0:*/ 0xe8, 0x98, 0x96, 0x8c, 0x9b, 0x59, 0x92, 0xb1, 0x9a, 0x19, 0xed, 0x41, 0xc7, 0xe7, 0x61, 0x9b, + /*a500:*/ 0x30, 0x3c, 0x5b, 0x45, 0xcf, 0x90, 0xfb, 0xf4, 0x9f, 0xce, 0xc3, 0x83, 0x82, 0x70, 0xc2, 0xfd, + /*a510:*/ 0xb6, 0xcd, 0x94, 0x6a, 0x15, 0xa5, 0x30, 0x39, 0xa3, 0xbb, 0x0a, 0x70, 0x18, 0x69, 0x93, 0x7b, + /*a520:*/ 0x21, 0x1f, 0x7f, 0x71, 0x61, 0xb7, 0xa3, 0x21, 0xb1, 0xba, 0x65, 0x1d, 0x84, 0x39, 0xc7, 0x4e, + /*a530:*/ 0x21, 0x2f, 0xfe, 0x8a, 0x0f, 0xdf, 0x81, 0xbb, 0xb2, 0x72, 0x71, 0x25, 0xfa, 0xc2, 0xc5, 0xff, + /*a540:*/ 0x99, 0x6d, 0x1f, 0xa3, 0xfc, 0xf3, 0xec, 0x32, 0x92, 0xd3, 0x28, 0xf2, 0xc6, 0x26, 0x1f, 0xa0, + /*a550:*/ 0xe6, 0xdf, 0xc5, 0xb2, 0x6b, 0x17, 0x69, 0x64, 0xe1, 0xda, 0x68, 0x38, 0x14, 0xf5, 0x2e, 0xf5, + /*a560:*/ 0xaf, 0x57, 0x74, 0x44, 0xe1, 0x28, 0x6e, 0x2e, 0x28, 0x7f, 0x99, 0x1c, 0x23, 0x26, 0x96, 0x38, + /*a570:*/ 0xcb, 0x70, 0x62, 0x53, 0x1b, 0x70, 0xb3, 0x1b, 0xbb, 0x9a, 0x9e, 0x31, 0xfd, 0x6f, 0x74, 0x84, + /*a580:*/ 0x5c, 0xd5, 0xf7, 0x10, 0xf7, 0x76, 0xd4, 0x22, 0xe6, 0x5e, 0x4b, 0xad, 0x41, 0xe6, 0x23, 0xe5, + /*a590:*/ 0x36, 0xf1, 0x2b, 0x57, 0x87, 0x97, 0x60, 0x46, 0x9d, 0xea, 0x18, 0x25, 0xcf, 0x33, 0x4f, 0x68, + /*a5a0:*/ 0x4d, 0x9f, 0x61, 0x59, 0x09, 0xf4, 0x45, 0xa3, 0x03, 0x76, 0x68, 0x24, 0x18, 0x36, 0xbe, 0xb7, + /*a5b0:*/ 0x78, 0xf7, 0xdc, 0x21, 0xce, 0x36, 0x28, 0xd2, 0x79, 0xb9, 0xda, 0xf3, 0x7f, 0xc0, 0x74, 0x55, + /*a5c0:*/ 0x00, 0x38, 0x57, 0x73, 0x9b, 0x1e, 0x80, 0x84, 0x55, 0xfc, 0x35, 0x1c, 0xbd, 0x8c, 0x27, 0xf0, + /*a5d0:*/ 0x6d, 0xef, 0x8a, 0x6a, 0x3a, 0x76, 0x77, 0xd1, 0xf3, 0xf7, 0xbc, 0xdd, 0x97, 0x0b, 0x68, 0xcc, + /*a5e0:*/ 0x2b, 0xdc, 0x1f, 0xde, 0x52, 0x66, 0x67, 0x7d, 0x72, 0x4c, 0x2c, 0xa8, 0xf1, 0x8d, 0x6d, 0xa3, + /*a5f0:*/ 0x4c, 0x33, 0xcf, 0xa9, 0x25, 0x6b, 0x6e, 0xe0, 0x48, 0x81, 0x51, 0x85, 0xf4, 0x33, 0xda, 0x32, + /*a600:*/ 0x7b, 0xdd, 0xa8, 0x0e, 0x94, 0x08, 0xc2, 0x16, 0xd0, 0xdd, 0x93, 0x22, 0xdc, 0x90, 0x04, 0xc9, + /*a610:*/ 0xee, 0x2a, 0xcd, 0x58, 0xac, 0xf7, 0x9a, 0xe2, 0xd9, 0x0a, 0x7b, 0x18, 0x9f, 0x85, 0xfc, 0x8e, + /*a620:*/ 0xb6, 0x5c, 0x05, 0x46, 0x94, 0x55, 0xd5, 0x28, 0x84, 0x0a, 0xb1, 0x35, 0x8d, 0x38, 0x34, 0xd5, + /*a630:*/ 0xd6, 0x2b, 0x66, 0xd6, 0xc1, 0x19, 0x5d, 0x99, 0x2f, 0xbe, 0x7f, 0xd9, 0x53, 0xa5, 0x6f, 0xa0, + /*a640:*/ 0x18, 0xb5, 0x77, 0x12, 0x56, 0xdd, 0x64, 0x4c, 0x84, 0x43, 0xa6, 0x05, 0x29, 0xf2, 0x70, 0x88, + /*a650:*/ 0x64, 0x1e, 0x28, 0x35, 0x31, 0x2d, 0x9a, 0xa0, 0x1e, 0x05, 0x53, 0xa2, 0xf1, 0xa9, 0xa8, 0xae, + /*a660:*/ 0x6d, 0x93, 0x13, 0x2d, 0xeb, 0x94, 0xe9, 0x7f, 0x9e, 0x05, 0x52, 0x18, 0xa0, 0xaa, 0x4d, 0x25, + /*a670:*/ 0xf2, 0x1c, 0xa6, 0xf4, 0x38, 0x14, 0x36, 0xb6, 0x0c, 0x5f, 0xb3, 0x26, 0x1f, 0x35, 0x3d, 0x6d, + /*a680:*/ 0xa2, 0xa1, 0x06, 0x41, 0x44, 0xf2, 0xc2, 0xee, 0x8a, 0xf0, 0x5b, 0x4c, 0x15, 0xa2, 0x1d, 0xd1, + /*a690:*/ 0xd3, 0x44, 0x89, 0x49, 0x92, 0xe3, 0x1c, 0x15, 0x69, 0x43, 0xab, 0x10, 0xce, 0x16, 0xcf, 0x82, + /*a6a0:*/ 0x5b, 0x81, 0x1b, 0x86, 0x8b, 0x71, 0x79, 0x47, 0x49, 0x87, 0x8f, 0x73, 0x7a, 0xc2, 0xda, 0xb6, + /*a6b0:*/ 0x68, 0x45, 0x4d, 0x41, 0xbc, 0xec, 0x5c, 0x4a, 0xb1, 0x8b, 0x2d, 0xc2, 0x1f, 0x62, 0xd8, 0x8c, + /*a6c0:*/ 0x9e, 0x0d, 0x00, 0x5b, 0x20, 0x23, 0x39, 0xfe, 0x8c, 0x1c, 0x1d, 0xf6, 0xb8, 0x86, 0xb4, 0x2b, + /*a6d0:*/ 0xe2, 0xe9, 0x79, 0xc4, 0x30, 0xcf, 0xd8, 0xc4, 0x9d, 0xcf, 0x9d, 0xb2, 0xd3, 0x50, 0x2b, 0xdc, + /*a6e0:*/ 0xae, 0xfb, 0x67, 0x50, 0x73, 0x86, 0x0c, 0x01, 0x31, 0x8e, 0xb0, 0x98, 0x96, 0xe9, 0x3c, 0x58, + /*a6f0:*/ 0x08, 0x68, 0x0a, 0x63, 0xd2, 0xdf, 0xc7, 0x2e, 0xd5, 0xed, 0x14, 0xeb, 0x61, 0x56, 0x63, 0xa1, + /*a700:*/ 0xc1, 0xa9, 0x26, 0x25, 0xe8, 0x6c, 0xea, 0xa0, 0x5a, 0x8e, 0xaf, 0x5d, 0xca, 0x06, 0xa4, 0x64, + /*a710:*/ 0xad, 0xf8, 0xbd, 0x90, 0xbb, 0xbf, 0xb7, 0xb6, 0x25, 0x5d, 0x09, 0x39, 0x82, 0x01, 0x7d, 0xfb, + /*a720:*/ 0x31, 0x3c, 0x82, 0x2b, 0x40, 0x63, 0x01, 0x80, 0x4e, 0x7c, 0xe8, 0x6c, 0x9b, 0xef, 0x12, 0x2c, + /*a730:*/ 0x8d, 0x63, 0xff, 0xf5, 0xad, 0x77, 0x59, 0x39, 0x20, 0x99, 0x85, 0x51, 0xe7, 0x75, 0x07, 0xac, + /*a740:*/ 0xe8, 0x30, 0xa4, 0xc9, 0xbf, 0x9f, 0xa4, 0x1f, 0x11, 0x98, 0x01, 0x9b, 0xfb, 0x96, 0x7d, 0xa3, + /*a750:*/ 0xaf, 0x73, 0x15, 0x7b, 0xce, 0x7a, 0xce, 0x2c, 0x00, 0xa1, 0x0f, 0x3c, 0x49, 0x6c, 0x62, 0x4c, + /*a760:*/ 0x7c, 0xec, 0xbb, 0x44, 0xb5, 0xed, 0x16, 0x9d, 0x57, 0x2b, 0x76, 0x56, 0x57, 0x54, 0x8d, 0xd7, + /*a770:*/ 0xa1, 0x6c, 0xd8, 0x0f, 0xb5, 0x13, 0xe0, 0x56, 0xb6, 0xea, 0xaf, 0x60, 0x13, 0xd1, 0xf8, 0xbc, + /*a780:*/ 0x58, 0xa8, 0x52, 0x5e, 0x42, 0x1b, 0x70, 0x7d, 0x63, 0x7d, 0x8b, 0x69, 0x82, 0xc3, 0xab, 0x38, + /*a790:*/ 0x64, 0x82, 0xef, 0x3f, 0xa9, 0xd9, 0x51, 0x5c, 0x4b, 0x88, 0x35, 0x17, 0xc4, 0xd2, 0x2d, 0xa5, + /*a7a0:*/ 0x46, 0xb0, 0x11, 0xcf, 0x6d, 0x94, 0xa3, 0x93, 0x93, 0xb7, 0xa7, 0xf8, 0x09, 0x39, 0x03, 0x1c, + /*a7b0:*/ 0x15, 0xba, 0x34, 0x3e, 0xe0, 0x08, 0xda, 0x0a, 0x93, 0xa2, 0x35, 0x23, 0x9b, 0xa0, 0x49, 0x7e, + /*a7c0:*/ 0x58, 0xe4, 0x6d, 0xef, 0x21, 0xbd, 0xfb, 0x15, 0xe5, 0xb2, 0x26, 0xb9, 0xd9, 0xab, 0xef, 0x0e, + /*a7d0:*/ 0x12, 0xfc, 0x24, 0xd6, 0x5c, 0xfd, 0x0e, 0xf2, 0x00, 0x12, 0x0f, 0x22, 0x0c, 0x53, 0x54, 0xdd, + /*a7e0:*/ 0xe6, 0x04, 0x61, 0xcb, 0xf5, 0x4b, 0xd0, 0x91, 0x24, 0x7e, 0x91, 0x95, 0x07, 0x41, 0x4c, 0x32, + /*a7f0:*/ 0x64, 0x44, 0x4e, 0xdc, 0x0b, 0xf4, 0x8a, 0xb5, 0x75, 0xc8, 0x73, 0xee, 0xc3, 0x7d, 0xb0, 0xbf, + /*a800:*/ 0x63, 0x7d, 0x69, 0x96, 0x58, 0x9c, 0x10, 0xed, 0xe6, 0x5a, 0x55, 0xf7, 0x20, 0xda, 0xbd, 0x1b, + /*a810:*/ 0xba, 0x0a, 0xab, 0x36, 0x1f, 0xe3, 0xe0, 0x3c, 0x20, 0xae, 0x90, 0x60, 0xcd, 0xe0, 0x29, 0xe7, + /*a820:*/ 0x41, 0x27, 0x68, 0x1c, 0xf3, 0xcc, 0xb7, 0x79, 0xfb, 0x06, 0x48, 0x89, 0x61, 0xb2, 0x02, 0xb2, + /*a830:*/ 0xcf, 0x61, 0xe9, 0x77, 0x9f, 0x8d, 0x7e, 0x19, 0x2b, 0xd0, 0x2d, 0xf9, 0x61, 0x29, 0xc9, 0x46, + /*a840:*/ 0x84, 0xd1, 0x54, 0x4d, 0x83, 0xb0, 0x8c, 0x33, 0x4f, 0xa5, 0xeb, 0x98, 0xa0, 0x41, 0x5b, 0xa0, + /*a850:*/ 0x04, 0x09, 0x37, 0xc2, 0xa7, 0x5f, 0xdf, 0x63, 0xa8, 0x82, 0x78, 0xf9, 0xea, 0xfc, 0xde, 0xa5, + /*a860:*/ 0x5c, 0xe4, 0xd9, 0x80, 0x54, 0x78, 0x34, 0x77, 0x59, 0x2b, 0xbb, 0x38, 0x6e, 0xdd, 0x57, 0x9e, + /*a870:*/ 0xd7, 0xe3, 0x9c, 0x67, 0x2e, 0xc1, 0xa1, 0x9d, 0xf2, 0xa1, 0xb8, 0x99, 0xc0, 0x89, 0x83, 0x2c, + /*a880:*/ 0x03, 0xfc, 0xc0, 0x03, 0x77, 0x06, 0xc9, 0xbe, 0x8a, 0xe6, 0xaa, 0x42, 0x95, 0x43, 0x57, 0x30, + /*a890:*/ 0xdf, 0xc0, 0x71, 0x9b, 0x42, 0x39, 0x67, 0x35, 0xc1, 0xa8, 0xb0, 0x16, 0xe3, 0xc3, 0xa8, 0x20, + /*a8a0:*/ 0xd6, 0x11, 0xed, 0x12, 0x42, 0x62, 0x2e, 0x2b, 0x17, 0x43, 0x3a, 0x27, 0x0d, 0x83, 0xd6, 0x87, + /*a8b0:*/ 0x70, 0x0e, 0x84, 0x01, 0xfd, 0xa1, 0xd9, 0x2b, 0x5c, 0xdb, 0xf9, 0xbe, 0x27, 0xd3, 0x05, 0x7a, + /*a8c0:*/ 0x89, 0x77, 0x23, 0x7a, 0x0c, 0x4c, 0x3f, 0xb3, 0xbc, 0xc1, 0x80, 0xde, 0x88, 0x68, 0x6c, 0xbe, + /*a8d0:*/ 0x6b, 0xa0, 0xf4, 0xfe, 0x9d, 0xde, 0xa4, 0x8d, 0xc8, 0xfe, 0x8f, 0x0d, 0xf8, 0xfb, 0xe3, 0x33, + /*a8e0:*/ 0xd9, 0x9f, 0x38, 0x44, 0xf0, 0x1e, 0x13, 0x87, 0x4a, 0x35, 0x79, 0xbd, 0x56, 0x77, 0x4d, 0x2e, + /*a8f0:*/ 0xed, 0x44, 0x05, 0x70, 0xcb, 0xee, 0x56, 0xb8, 0x40, 0xc4, 0x29, 0x1a, 0xaf, 0x14, 0xd3, 0xd3, + /*a900:*/ 0x18, 0x34, 0x77, 0x79, 0x7c, 0x69, 0x36, 0xbc, 0x18, 0xea, 0xc8, 0x5e, 0xdf, 0x17, 0xfe, 0xf0, + /*a910:*/ 0x22, 0xd7, 0x5c, 0xa7, 0x24, 0xd8, 0xe9, 0x85, 0x2f, 0x08, 0xef, 0x68, 0x9a, 0xe9, 0x81, 0x80, + /*a920:*/ 0xe2, 0xb2, 0x5d, 0x11, 0x30, 0xf0, 0xa9, 0xab, 0x6b, 0xee, 0x2c, 0x62, 0x0a, 0xde, 0xec, 0x4e, + /*a930:*/ 0xd0, 0x25, 0xbb, 0xd5, 0xc5, 0x2d, 0xa8, 0xea, 0x1e, 0x7b, 0xfc, 0x84, 0x4b, 0x38, 0xb8, 0x90, + /*a940:*/ 0x8d, 0x4b, 0x3d, 0x7c, 0xa6, 0x8d, 0x1a, 0x73, 0x0f, 0x72, 0xb9, 0x2a, 0xc2, 0x31, 0x3c, 0xa5, + /*a950:*/ 0x18, 0xfe, 0x02, 0xb6, 0x2f, 0xfa, 0x3c, 0x23, 0x99, 0x73, 0x93, 0xcf, 0x14, 0x06, 0xb8, 0x76, + /*a960:*/ 0xf5, 0x66, 0xb2, 0xb8, 0x04, 0xd0, 0x10, 0x13, 0x38, 0x41, 0x17, 0x59, 0x20, 0x63, 0x09, 0xee, + /*a970:*/ 0x1b, 0xae, 0xc0, 0xea, 0xf3, 0xbf, 0xca, 0x9f, 0x25, 0x94, 0x0c, 0x96, 0x3f, 0x2d, 0x99, 0xc3, + /*a980:*/ 0x42, 0xe4, 0xe0, 0x92, 0x9c, 0x13, 0x0d, 0xb6, 0x87, 0xd6, 0x42, 0xbd, 0x35, 0xb2, 0x72, 0x57, + /*a990:*/ 0xb4, 0x52, 0x16, 0xa3, 0x86, 0x82, 0x21, 0x67, 0x5f, 0xff, 0x3d, 0x58, 0xcd, 0xb1, 0x9e, 0xbd, + /*a9a0:*/ 0x15, 0x87, 0x1e, 0x2f, 0x8d, 0x98, 0xcf, 0x4b, 0x93, 0x7b, 0x3f, 0xdd, 0x7c, 0x2b, 0xc5, 0x57, + /*a9b0:*/ 0x9b, 0x98, 0xfb, 0xc7, 0x53, 0xc3, 0x1f, 0xae, 0x9d, 0xd6, 0xed, 0xc8, 0xd0, 0xb6, 0x34, 0x21, + /*a9c0:*/ 0x94, 0xf3, 0x95, 0xfb, 0xf0, 0x80, 0x24, 0x98, 0x0f, 0xd1, 0xd3, 0xe0, 0xfd, 0xc5, 0xcd, 0xa6, + /*a9d0:*/ 0xda, 0xfb, 0x58, 0xb0, 0x1b, 0x9a, 0x24, 0x59, 0xaf, 0x55, 0xa6, 0x82, 0xab, 0x21, 0x40, 0x4a, + /*a9e0:*/ 0xaa, 0x4e, 0xcd, 0x23, 0x7d, 0x2b, 0xa3, 0x01, 0x18, 0x63, 0xfd, 0x2f, 0x12, 0xd3, 0x2b, 0x25, + /*a9f0:*/ 0xbd, 0xb0, 0x10, 0x59, 0x7c, 0x85, 0x5d, 0xdb, 0x28, 0x34, 0xd1, 0x1d, 0x9d, 0x50, 0x78, 0xef, + /*aa00:*/ 0x84, 0x97, 0x1a, 0x49, 0x1a, 0x8b, 0xd3, 0x88, 0xbe, 0x67, 0xac, 0x4a, 0x1f, 0x1b, 0x15, 0x21, + /*aa10:*/ 0x61, 0x85, 0xf3, 0x74, 0x48, 0x20, 0xe1, 0x55, 0x16, 0x2a, 0xf3, 0xdd, 0x5c, 0x9e, 0xc9, 0x13, + /*aa20:*/ 0x55, 0x70, 0xf7, 0xc1, 0x07, 0xcb, 0xa2, 0xa5, 0x7d, 0x7d, 0xcb, 0xbb, 0x56, 0x07, 0x7a, 0x5a, + /*aa30:*/ 0xa4, 0xf7, 0x1b, 0x28, 0x0a, 0x89, 0xef, 0x5a, 0x28, 0x01, 0xe0, 0xbb, 0x67, 0x9d, 0xab, 0x2f, + /*aa40:*/ 0xb8, 0x71, 0x48, 0x6c, 0x6e, 0x98, 0xc5, 0x7d, 0x81, 0xcd, 0xba, 0xc2, 0x70, 0x63, 0x9e, 0x87, + /*aa50:*/ 0x14, 0x54, 0xbb, 0xbb, 0xd6, 0x7b, 0xb1, 0xaa, 0xae, 0x22, 0xba, 0x87, 0x80, 0x59, 0x6f, 0x23, + /*aa60:*/ 0x06, 0x5c, 0x6c, 0x1d, 0x34, 0x70, 0xce, 0xfd, 0x37, 0x73, 0xff, 0x85, 0x92, 0xae, 0x13, 0xb7, + /*aa70:*/ 0x67, 0x5d, 0x32, 0xff, 0x39, 0x8e, 0x52, 0xaa, 0x3c, 0x99, 0xa7, 0xe9, 0x27, 0x4e, 0xbb, 0x58, + /*aa80:*/ 0x78, 0xa2, 0x85, 0x36, 0xad, 0xa5, 0xbe, 0xa9, 0x78, 0xc4, 0xae, 0x78, 0xef, 0xea, 0x18, 0x24, + /*aa90:*/ 0x50, 0x4a, 0x56, 0x85, 0x6c, 0xdc, 0x69, 0x14, 0xe2, 0xe0, 0xb3, 0x8d, 0x2e, 0xdf, 0x62, 0x47, + /*aaa0:*/ 0xcf, 0xf2, 0xee, 0xe2, 0x0b, 0xab, 0x08, 0xf0, 0x89, 0x29, 0x91, 0x12, 0xfc, 0x9f, 0x4c, 0xb9, + /*aab0:*/ 0x0c, 0x92, 0xd3, 0x0d, 0x41, 0x72, 0xce, 0x67, 0xbf, 0x72, 0x4a, 0xd5, 0x10, 0x3b, 0x7b, 0xa0, + /*aac0:*/ 0x6e, 0xf4, 0x51, 0x63, 0x47, 0x74, 0xd9, 0x5e, 0x0b, 0xb3, 0x3e, 0x56, 0xb9, 0x90, 0x30, 0xd8, + /*aad0:*/ 0xa6, 0x54, 0xf3, 0x87, 0x87, 0xf2, 0xca, 0xa8, 0x81, 0x72, 0xea, 0x07, 0x34, 0x2f, 0xb2, 0x11, + /*aae0:*/ 0x23, 0x49, 0xf5, 0x9d, 0x6c, 0x52, 0xd6, 0x41, 0x71, 0xe4, 0x2c, 0xc1, 0x4c, 0x30, 0x9e, 0xf3, + /*aaf0:*/ 0xb2, 0x21, 0x21, 0x3e, 0x1f, 0x12, 0x7b, 0x6b, 0xd1, 0xc7, 0xe8, 0xd0, 0x74, 0x1c, 0xf2, 0x46, + /*ab00:*/ 0xcc, 0x12, 0x89, 0x97, 0x9e, 0x92, 0x7f, 0x89, 0xdb, 0x82, 0x1c, 0xd4, 0xe8, 0xcd, 0x36, 0x76, + /*ab10:*/ 0x6c, 0x09, 0xe3, 0x15, 0x2e, 0x6a, 0xbf, 0x46, 0x28, 0x95, 0x2f, 0x01, 0x92, 0x00, 0x68, 0x6e, + /*ab20:*/ 0x5d, 0xbf, 0x3d, 0xc1, 0x29, 0xbf, 0x09, 0x4a, 0x08, 0x74, 0x79, 0x48, 0xb4, 0x5e, 0x5f, 0x52, + /*ab30:*/ 0x55, 0x0c, 0x41, 0x69, 0x3d, 0x48, 0xf6, 0xf0, 0x9b, 0x63, 0x1f, 0xaa, 0x6e, 0xfd, 0x7f, 0x0f, + /*ab40:*/ 0x83, 0x29, 0x68, 0xd7, 0xb5, 0xa6, 0x12, 0x05, 0x8f, 0x43, 0x07, 0xbc, 0x25, 0xd2, 0xec, 0xb3, + /*ab50:*/ 0xab, 0xc9, 0xf3, 0x1f, 0xbb, 0xc2, 0xe3, 0x78, 0x4e, 0xb6, 0x35, 0xfb, 0x94, 0xde, 0xf0, 0xd9, + /*ab60:*/ 0xe6, 0xec, 0xf8, 0xae, 0xf8, 0x46, 0x1a, 0x83, 0xd3, 0xdb, 0xfe, 0xbc, 0x80, 0x65, 0x4d, 0xc7, + /*ab70:*/ 0x83, 0x75, 0xb2, 0xdd, 0x77, 0xc3, 0x46, 0xd4, 0x32, 0xa4, 0x54, 0xef, 0x9b, 0xa3, 0x76, 0xb7, + /*ab80:*/ 0x9e, 0x60, 0x14, 0x6d, 0xd7, 0xb1, 0x47, 0x82, 0xef, 0x2c, 0xcf, 0x88, 0x17, 0x5c, 0xa1, 0xe6, + /*ab90:*/ 0x60, 0x22, 0xdb, 0x85, 0x18, 0x11, 0x08, 0xd0, 0x59, 0xc6, 0xe9, 0x19, 0x55, 0x3c, 0x81, 0xf4, + /*aba0:*/ 0x6d, 0xec, 0x1b, 0x88, 0xd6, 0xb6, 0x7a, 0x62, 0x5d, 0x7a, 0xc4, 0xf1, 0xf0, 0xa0, 0x09, 0x1a, + /*abb0:*/ 0xbc, 0xdf, 0x3c, 0xb0, 0x4f, 0x2b, 0xe1, 0x2e, 0x44, 0x3d, 0x9d, 0x0a, 0xb1, 0x1d, 0x66, 0x62, + /*abc0:*/ 0xbe, 0xbf, 0xe2, 0x2b, 0x66, 0xae, 0xa1, 0x35, 0x04, 0x63, 0x77, 0x97, 0xc9, 0x0b, 0xab, 0xeb, + /*abd0:*/ 0xf0, 0x61, 0xf2, 0x1f, 0xdb, 0x60, 0x51, 0x6f, 0xda, 0xd6, 0x19, 0xdf, 0x5b, 0xad, 0x6e, 0x02, + /*abe0:*/ 0x9c, 0xc8, 0xce, 0x0c, 0xa7, 0xcb, 0x93, 0x3d, 0x3c, 0xff, 0x9e, 0x88, 0xfa, 0xf9, 0x9c, 0x73, + /*abf0:*/ 0x9f, 0x3e, 0xbb, 0xa9, 0x40, 0x2c, 0x88, 0x4f, 0x19, 0x59, 0x1a, 0x42, 0x13, 0xca, 0x47, 0xb8, + /*ac00:*/ 0x46, 0x77, 0x49, 0xa0, 0xb7, 0xec, 0x73, 0x72, 0xb1, 0x9b, 0x61, 0x07, 0x8a, 0x61, 0x08, 0x1a, + /*ac10:*/ 0x4a, 0x59, 0x63, 0x60, 0x2a, 0x0f, 0x5a, 0xdf, 0x3c, 0x23, 0x83, 0x47, 0x32, 0x37, 0xde, 0x8a, + /*ac20:*/ 0x30, 0x10, 0x24, 0x3f, 0x31, 0x93, 0xcb, 0xca, 0xfa, 0x5c, 0xf0, 0xf9, 0x28, 0x50, 0x40, 0x2a, + /*ac30:*/ 0x62, 0xfd, 0x0b, 0x22, 0x52, 0x0b, 0xa4, 0x4d, 0xc4, 0xbc, 0x88, 0x32, 0x0f, 0x85, 0xab, 0xc9, + /*ac40:*/ 0x5c, 0x55, 0xc5, 0x63, 0xbb, 0x2f, 0xfb, 0x41, 0xf6, 0x52, 0xd7, 0x67, 0x35, 0x96, 0x0e, 0xf6, + /*ac50:*/ 0x46, 0x10, 0xaa, 0x92, 0x0a, 0xdf, 0xdf, 0xcb, 0x9b, 0xa7, 0xaa, 0x71, 0xe1, 0xd8, 0xfe, 0x03, + /*ac60:*/ 0xef, 0x25, 0x22, 0x72, 0x86, 0x42, 0x72, 0x00, 0xfc, 0xd2, 0x13, 0xbe, 0x03, 0x1c, 0x4c, 0x4d, + /*ac70:*/ 0x48, 0xb3, 0xaf, 0x7b, 0xb4, 0xa0, 0xe7, 0x0f, 0xc0, 0x40, 0x2b, 0x99, 0xfe, 0x6a, 0x8d, 0x82, + /*ac80:*/ 0x72, 0xef, 0x2b, 0x76, 0xdf, 0x82, 0x74, 0xd2, 0x17, 0xd0, 0xbc, 0xcf, 0x54, 0xb3, 0x6f, 0x34, + /*ac90:*/ 0xd7, 0x86, 0x90, 0x63, 0x1f, 0xdc, 0x54, 0xa6, 0xa7, 0x77, 0x4d, 0x84, 0x0d, 0x5a, 0x02, 0xc1, + /*aca0:*/ 0x3c, 0xd2, 0xc0, 0xc6, 0x1d, 0xa5, 0x60, 0x9b, 0x22, 0x08, 0x44, 0x01, 0xb8, 0x1a, 0xe4, 0x59, + /*acb0:*/ 0x63, 0x2b, 0x48, 0xed, 0xf1, 0x1f, 0x86, 0x18, 0x9c, 0x27, 0xe3, 0x11, 0xb8, 0x03, 0x1a, 0x28, + /*acc0:*/ 0xbb, 0x16, 0x90, 0x80, 0x8e, 0xc9, 0xd7, 0x57, 0x33, 0x82, 0x06, 0x44, 0x2b, 0x3f, 0xee, 0xbc, + /*acd0:*/ 0x4a, 0x19, 0x73, 0x96, 0x09, 0xb9, 0x26, 0x08, 0x57, 0xe9, 0x66, 0x86, 0x33, 0xfe, 0xf0, 0xad, + /*ace0:*/ 0xeb, 0x5f, 0x46, 0xd3, 0x8c, 0x6e, 0xa9, 0xeb, 0x0f, 0x58, 0x27, 0x1d, 0x37, 0x42, 0xd9, 0xbb, + /*acf0:*/ 0x65, 0x6d, 0xf0, 0x75, 0x89, 0xfb, 0x5e, 0x4d, 0xd7, 0x6d, 0x09, 0xb4, 0x42, 0x7e, 0x7c, 0x94, + /*ad00:*/ 0xa5, 0x34, 0x36, 0x13, 0x88, 0x1a, 0x12, 0x2b, 0x02, 0xd4, 0x38, 0x00, 0x25, 0xc4, 0x95, 0xe6, + /*ad10:*/ 0x3c, 0x9b, 0xbe, 0x55, 0x5d, 0x58, 0x6c, 0xef, 0x36, 0xbf, 0xeb, 0x90, 0x74, 0x93, 0x14, 0x07, + /*ad20:*/ 0xad, 0xfa, 0x42, 0x13, 0x7b, 0x13, 0x17, 0x1a, 0x9b, 0x0f, 0x36, 0xee, 0x61, 0x76, 0xe2, 0x85, + /*ad30:*/ 0x99, 0x42, 0x29, 0x50, 0x20, 0x7e, 0x3f, 0x09, 0xaf, 0x3a, 0xe5, 0x3f, 0x53, 0xf6, 0x76, 0x79, + /*ad40:*/ 0xfb, 0x8c, 0x73, 0xc9, 0x83, 0xf6, 0x1c, 0x21, 0xec, 0x05, 0x07, 0x10, 0xbc, 0x16, 0x8e, 0x65, + /*ad50:*/ 0x7f, 0xfe, 0x4a, 0x3e, 0xbe, 0xf7, 0x74, 0x47, 0x51, 0x89, 0x5f, 0xad, 0xc1, 0x9e, 0xa1, 0x6a, + /*ad60:*/ 0x69, 0x33, 0x5c, 0x10, 0x48, 0x10, 0xbb, 0x49, 0x98, 0x63, 0x04, 0xe4, 0x19, 0xfa, 0x45, 0x93, + /*ad70:*/ 0x09, 0x0d, 0xda, 0x37, 0x2e, 0xff, 0x4f, 0xaf, 0xdc, 0x3d, 0x71, 0x3e, 0x0c, 0x97, 0x3b, 0x8f, + /*ad80:*/ 0x80, 0xfc, 0x34, 0x24, 0x4e, 0x37, 0xaa, 0x11, 0xd0, 0x4a, 0x57, 0x9b, 0xa6, 0x6c, 0x4d, 0xc1, + /*ad90:*/ 0x65, 0x07, 0x6d, 0x1c, 0x9e, 0x06, 0xd9, 0xe3, 0x1a, 0x3f, 0xe0, 0xf1, 0x36, 0x9e, 0x74, 0x65, + /*ada0:*/ 0x5c, 0x75, 0xd2, 0xf5, 0xd9, 0xbc, 0x3c, 0x4f, 0x24, 0x4e, 0x04, 0x62, 0x04, 0x97, 0x3e, 0x6e, + /*adb0:*/ 0xc4, 0x01, 0x4c, 0x88, 0xfb, 0xb0, 0xdf, 0x7d, 0x45, 0xcd, 0xa0, 0xca, 0x91, 0x96, 0x11, 0x6e, + /*adc0:*/ 0x56, 0x5d, 0xe5, 0xd1, 0xf3, 0x2c, 0x4a, 0xf6, 0x07, 0xb3, 0x6d, 0xb6, 0x6b, 0x98, 0x7b, 0x9b, + /*add0:*/ 0x80, 0x7a, 0x02, 0x83, 0xc7, 0xef, 0x0e, 0x00, 0x81, 0xfc, 0x95, 0x64, 0xe4, 0xc0, 0xb3, 0xc1, + /*ade0:*/ 0x2f, 0xfe, 0x4a, 0x97, 0xa1, 0x1c, 0x68, 0xde, 0xee, 0xc6, 0xcc, 0x23, 0x33, 0x5c, 0x2b, 0xcd, + /*adf0:*/ 0xa1, 0x4b, 0xff, 0x97, 0x08, 0x01, 0x51, 0x5a, 0xc1, 0x69, 0x6a, 0xbc, 0xac, 0x3f, 0xc4, 0xf3, + /*ae00:*/ 0x5d, 0x75, 0x53, 0x23, 0x8d, 0xb5, 0x43, 0x8d, 0x2f, 0x41, 0x05, 0xd2, 0x7f, 0x88, 0xdd, 0x9e, + /*ae10:*/ 0xb8, 0x5b, 0x13, 0x34, 0x1a, 0x74, 0x5c, 0x6e, 0x81, 0xd3, 0x65, 0x6e, 0x02, 0xcf, 0xf1, 0xf2, + /*ae20:*/ 0xf2, 0x87, 0xca, 0xab, 0x11, 0x6e, 0xea, 0xf6, 0xa4, 0xa8, 0x82, 0xa8, 0x00, 0xbd, 0xc7, 0x80, + /*ae30:*/ 0x4f, 0xeb, 0x73, 0xbc, 0x9f, 0xbb, 0xc4, 0x17, 0x58, 0x68, 0x1f, 0x36, 0xfb, 0x3c, 0xda, 0xf4, + /*ae40:*/ 0xf4, 0xea, 0x6a, 0xce, 0x79, 0xe9, 0xb1, 0x83, 0x6d, 0x27, 0x22, 0xdc, 0x01, 0xf8, 0xec, 0x58, + /*ae50:*/ 0x6b, 0x58, 0x03, 0x24, 0x50, 0xeb, 0xed, 0xa9, 0x1c, 0x01, 0x1a, 0x7c, 0x50, 0xe3, 0x5e, 0x78, + /*ae60:*/ 0x90, 0xe8, 0x50, 0xfd, 0xe8, 0x34, 0xfc, 0x7c, 0x3e, 0x7b, 0x61, 0xd5, 0x93, 0x65, 0x47, 0xed, + /*ae70:*/ 0xfe, 0x63, 0xc1, 0xd1, 0x31, 0x86, 0x78, 0xa1, 0x68, 0xee, 0xfa, 0x4f, 0x5c, 0xf2, 0x45, 0x90, + /*ae80:*/ 0x7c, 0xb9, 0x6d, 0x98, 0x89, 0x3f, 0x3e, 0xc8, 0x0d, 0x02, 0xa2, 0x2e, 0xfd, 0x96, 0x3e, 0x16, + /*ae90:*/ 0xd6, 0xc8, 0x46, 0x89, 0xf5, 0x82, 0x71, 0xe7, 0x93, 0xcb, 0x57, 0x14, 0xce, 0xef, 0x51, 0x53, + /*aea0:*/ 0xaa, 0x3d, 0xe7, 0xdc, 0xbf, 0x14, 0xc1, 0x14, 0xdc, 0x24, 0xd1, 0xc9, 0x61, 0xb3, 0x0a, 0x9d, + /*aeb0:*/ 0xca, 0xcb, 0x00, 0x49, 0xc0, 0x9a, 0xbe, 0x59, 0x10, 0x9a, 0x0a, 0x75, 0x0a, 0x7a, 0x2d, 0xe2, + /*aec0:*/ 0x87, 0xe5, 0xb1, 0x32, 0x55, 0x8d, 0xd2, 0x3a, 0x0b, 0x3b, 0xd9, 0x16, 0xb1, 0x78, 0xa8, 0x83, + /*aed0:*/ 0x13, 0x30, 0x2f, 0xf8, 0xa0, 0x91, 0x55, 0xc5, 0x0b, 0x5e, 0x4a, 0x90, 0x1c, 0x10, 0x7c, 0x5a, + /*aee0:*/ 0x8e, 0x4b, 0x4b, 0xea, 0x12, 0xe2, 0x51, 0xfa, 0xc4, 0x5a, 0x52, 0x33, 0xff, 0xf9, 0x18, 0xc1, + /*aef0:*/ 0x5b, 0xa1, 0x29, 0xeb, 0x3f, 0xab, 0xf8, 0x1c, 0xa2, 0x7e, 0x97, 0xfd, 0x59, 0x04, 0x1a, 0x0c, + /*af00:*/ 0x60, 0x5e, 0x3d, 0x23, 0x5e, 0x0b, 0x8e, 0x2b, 0xf5, 0x57, 0xe7, 0x06, 0x71, 0x11, 0x68, 0xb6, + /*af10:*/ 0x5a, 0xc4, 0x49, 0xfa, 0x24, 0x17, 0xe7, 0xf7, 0xd2, 0xca, 0xc8, 0xbf, 0x5c, 0x5a, 0x98, 0xe5, + /*af20:*/ 0xb8, 0x72, 0x85, 0xb0, 0x8c, 0x4c, 0x49, 0xbc, 0x5f, 0xd5, 0xb3, 0x36, 0xa0, 0xc9, 0x59, 0xbc, + /*af30:*/ 0xc8, 0x5e, 0x00, 0xa4, 0x09, 0x95, 0x48, 0x31, 0x96, 0x76, 0x80, 0xee, 0x49, 0x9a, 0xac, 0xe4, + /*af40:*/ 0xbe, 0x94, 0xa5, 0xc6, 0x6c, 0xd0, 0xce, 0xcf, 0xa8, 0xdf, 0x61, 0xbb, 0xe5, 0x7a, 0x59, 0xe3, + /*af50:*/ 0x7d, 0xad, 0x3b, 0xa9, 0xcc, 0x26, 0xe7, 0x4e, 0x29, 0x5b, 0xed, 0x59, 0x43, 0x70, 0xdd, 0xb6, + /*af60:*/ 0xbf, 0x6c, 0xa6, 0x12, 0x87, 0xd0, 0xa2, 0x33, 0xf2, 0x9a, 0x8a, 0x39, 0xca, 0x63, 0x1e, 0x6a, + /*af70:*/ 0xf4, 0xf7, 0x4a, 0x97, 0xc6, 0x62, 0x85, 0xb1, 0x98, 0xf4, 0xbd, 0x2d, 0x2c, 0xf7, 0xe8, 0x47, + /*af80:*/ 0x73, 0x61, 0xda, 0x0b, 0xca, 0xc7, 0xa8, 0x37, 0x72, 0xdd, 0x08, 0xed, 0xfe, 0xb2, 0xc2, 0xa7, + /*af90:*/ 0x1f, 0x30, 0xce, 0x3a, 0x2e, 0xd8, 0x73, 0x77, 0xbf, 0xe1, 0x53, 0xab, 0xcf, 0xbf, 0x1d, 0xa2, + /*afa0:*/ 0x7b, 0xe6, 0x93, 0xa8, 0x0b, 0x1d, 0x7b, 0xdb, 0xaa, 0x83, 0x91, 0x76, 0x0b, 0xda, 0x09, 0x17, + /*afb0:*/ 0xe6, 0x8a, 0x25, 0x89, 0x1e, 0x9e, 0xe3, 0xec, 0xed, 0x9e, 0xfd, 0x5e, 0xb1, 0x47, 0x78, 0xd9, + /*afc0:*/ 0x1e, 0x2a, 0xfe, 0x92, 0x9b, 0x73, 0x70, 0x16, 0x2d, 0xdf, 0x76, 0x18, 0x35, 0x84, 0x40, 0xed, + /*afd0:*/ 0x42, 0xb5, 0xa6, 0x89, 0x52, 0x75, 0xf0, 0xbb, 0x20, 0xea, 0xea, 0xec, 0xa2, 0x40, 0xc8, 0x32, + /*afe0:*/ 0x82, 0xfb, 0x84, 0x0b, 0x99, 0x22, 0x39, 0x22, 0x0a, 0xde, 0x4f, 0x92, 0x96, 0xd1, 0xa5, 0xf1, + /*aff0:*/ 0x6b, 0xf4, 0x01, 0x04, 0x3d, 0x65, 0x70, 0x82, 0xe2, 0x2e, 0x76, 0xfc, 0x25, 0x81, 0x24, 0x59, + /*b000:*/ 0x7c, 0x77, 0x24, 0xab, 0x00, 0x06, 0x74, 0x9e, 0xa7, 0x6c, 0xaa, 0x04, 0x30, 0xed, 0x9d, 0xb3, + /*b010:*/ 0x56, 0xfc, 0x85, 0x8d, 0xa2, 0x90, 0xc3, 0xcd, 0x08, 0xd2, 0x71, 0xd7, 0xf2, 0x2e, 0x28, 0xfb, + /*b020:*/ 0x13, 0x28, 0xfc, 0x43, 0x40, 0x56, 0x80, 0xc4, 0x56, 0xd1, 0x39, 0x96, 0x1f, 0xdc, 0xa8, 0x70, + /*b030:*/ 0x32, 0x84, 0x40, 0xa1, 0x98, 0xb6, 0x1e, 0x7f, 0xbc, 0x05, 0xb8, 0x2c, 0x95, 0x26, 0xfd, 0x41, + /*b040:*/ 0x20, 0xbb, 0x88, 0x9f, 0x26, 0xf6, 0x4e, 0x99, 0x0e, 0x9c, 0xd9, 0xac, 0xc9, 0xcf, 0x71, 0x31, + /*b050:*/ 0xab, 0x6e, 0x05, 0xfd, 0x20, 0x69, 0x50, 0x93, 0x54, 0xe5, 0xc4, 0x0b, 0xc6, 0xa4, 0xd4, 0x00, + /*b060:*/ 0xcb, 0x58, 0x27, 0x33, 0x07, 0x01, 0xd6, 0xce, 0x25, 0xdf, 0xf9, 0x36, 0x54, 0x94, 0xf1, 0x40, + /*b070:*/ 0x61, 0x69, 0x12, 0x79, 0x5c, 0xb0, 0xf1, 0xba, 0xd2, 0x01, 0x9a, 0xd7, 0x96, 0xbe, 0x34, 0x95, + /*b080:*/ 0x06, 0xe7, 0x05, 0xc3, 0x13, 0x58, 0x4e, 0x85, 0xb6, 0xdb, 0x72, 0xba, 0x5e, 0x15, 0xc9, 0x0a, + /*b090:*/ 0x62, 0x60, 0x53, 0x3f, 0xad, 0x29, 0x3f, 0xe3, 0xe1, 0xbb, 0x23, 0xcc, 0x13, 0xb9, 0xbd, 0x85, + /*b0a0:*/ 0x5d, 0x84, 0x0b, 0x5f, 0x7c, 0x4d, 0x2e, 0x64, 0x41, 0x06, 0x39, 0x71, 0x2b, 0x30, 0x14, 0x59, + /*b0b0:*/ 0xfe, 0x18, 0x80, 0x37, 0x17, 0x9e, 0x40, 0xa8, 0x55, 0xf2, 0xf6, 0xcc, 0x4c, 0xad, 0x10, 0x88, + /*b0c0:*/ 0x70, 0x6d, 0xcc, 0x69, 0xc9, 0xfd, 0x11, 0xa3, 0xba, 0xd0, 0x6a, 0xe0, 0x65, 0xd1, 0xb8, 0x38, + /*b0d0:*/ 0x55, 0xec, 0x1a, 0x81, 0xd0, 0x51, 0x33, 0x31, 0x3b, 0x5a, 0xc9, 0x26, 0xc6, 0xf2, 0x78, 0x2d, + /*b0e0:*/ 0x8e, 0x4e, 0x22, 0x8b, 0x0d, 0x74, 0x4d, 0x36, 0x18, 0x45, 0xdc, 0x41, 0x44, 0x35, 0x6a, 0x3b, + /*b0f0:*/ 0x66, 0x2c, 0xd4, 0x61, 0x92, 0xb8, 0x48, 0xab, 0xa2, 0xb6, 0x09, 0x7f, 0xa7, 0x91, 0xe9, 0x97, + /*b100:*/ 0x53, 0x59, 0x03, 0x08, 0x00, 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x88, 0x00, 0x01, 0x01, 0xff, 0x0a, + /*b110:*/ 0x1f, 0x03, 0xff, 0x04, 0x1e, 0x06, 0x2d, 0x5c, 0x0f, 0x8d, 0x03, 0x01, 0x34, 0xfe, 0x33, 0xff, + /*b120:*/ 0x78, 0x43, 0xfd, 0x43, 0x50, 0xc3, 0x38, 0xc7, 0x00, 0x18, 0x20, 0x20, 0x20, 0x20, 0x14, 0x02, + /*b130:*/ 0x0c, 0x32, 0xe3, 0xbc, 0x00, 0x00, 0x05, 0x28, 0x0a, 0x2d, 0x00, 0x28, 0x0a, 0x32, 0x00, 0xc4, + /*b140:*/ 0x09, 0x3c, 0x00, 0xf0, 0x0a, 0x50, 0x00, 0x1e, 0x1e, 0x8c, 0x00, 0x96, 0x00, 0x14, 0x0a, 0x04, + /*b150:*/ 0x29, 0x1a, 0x64, 0x07, 0x66, 0x64, 0xc0, 0x20, 0x02, 0xaf, 0x00, 0x03, 0x0e, 0x1f, 0x08, 0x2a, + /*b160:*/ 0x00, 0x20, 0x04, 0x1b, 0x00, 0x80, 0x14, 0xc0, 0xc8, 0xc8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0x38, + /*b170:*/ 0x37, 0x35, 0x34, 0x32, 0x31, 0x2f, 0x2d, 0x01, 0x04, 0x07, 0x09, 0x0b, 0x0d, 0x0f, 0x13, 0x00, + /*b180:*/ 0x00, 0x00, 0x40, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x20, 0x20, 0x20, 0x20, + /*b190:*/ 0x20, 0x20, 0x20, 0x10, 0x5a, 0x5e, 0x61, 0x64, 0x67, 0x6a, 0x6d, 0x39, 0x00, 0x0a, 0x00, 0x10, + /*b1a0:*/ 0x27, 0x66, 0x12, 0xd4, 0x10, 0xff, 0x1a, 0x00, 0x28, 0x28, 0x1c, 0x26, 0x66, 0x66, 0x66, 0x66, + /*b1b0:*/ 0x66, 0x66, 0x66, 0xff, 0xc8, 0x11, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x11, + /*b1c0:*/ 0x04, 0x20, 0x40, 0x03, 0x00, 0x1f, 0x00, 0x1d, 0x2d, 0x1d, 0x2b, 0x1d, 0x28, 0x1d, 0x2c, 0x1d, + /*b1d0:*/ 0x20, 0xdc, 0x73, 0xfe, 0x73, 0xe5, 0xcd, 0x0d, 0x04, 0x02, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + /*b1e0:*/ 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + /*b1f0:*/ 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, + /*b200:*/ 0x27, 0x29, 0x2a, 0x2d, 0x2b, 0x28, 0x2c, 0x20, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x14, + /*b210:*/ 0x12, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, + /*b220:*/ 0x01, 0x00, 0x1d, 0x66, 0x66, 0x6d, 0x6d, 0x73, 0x73, 0x7a, 0x7a, 0x80, 0x80, 0x86, 0x86, 0x8d, + /*b230:*/ 0x8d, 0x93, 0x93, 0x9a, 0x9a, 0xa0, 0xa0, 0xa6, 0xa6, 0xad, 0xad, 0xb3, 0xb3, 0x80, 0x80, 0x80, + /*b240:*/ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + /*b250:*/ 0x80, 0x0a, 0x1c, 0x2b, 0x1e, 0x0a, 0x80, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b260:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b270:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b280:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b290:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x48, 0xb2, + /*b300:*/ 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b310:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b320:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b330:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b340:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b350:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b360:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b370:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b380:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b390:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b400:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b410:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b420:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b430:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b440:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, + /*b450:*/ 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x08, 0x00, 0x19, 0x19, 0x00, 0x10, 0xe2, 0x04, 0xb6, 0x08, 0x1e, + /*b460:*/ 0x05, 0x28, 0xf5, 0x28, 0x1e, 0x05, 0x01, 0x30, 0x00, 0x30, 0x00, 0x00, 0x50, 0x00, 0x50, 0xf0, + /*b470:*/ 0xd2, 0xf0, 0xd2, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0xc0, 0x32, 0x70, 0x00, 0x00, + /*b480:*/ 0x00, 0x80, 0x04, 0x2e, 0x1b, 0x64, 0x07, 0x00, 0x00, 0x56, 0x35, 0x05, 0x10, 0x00, 0x00, 0x0b, + /*b490:*/ 0x20, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, 0x37, 0x33, + /*b4a0:*/ 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x03, 0x0f, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf0, + /*b4b0:*/ 0x15, 0x1b, 0x2e, 0x49, 0x40, 0xff, 0x0b, 0x20, 0x0c, 0x18, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + /*b4c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b4d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x88, 0x55, + /*b4e0:*/ 0x15, 0x21, 0x11, 0x92, 0x87, 0x4f, 0x13, 0x01, 0x01, 0x89, 0x00, 0x4b, 0x00, 0x01, 0x34, 0x00, + /*b4f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b500:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b510:*/ 0x00, 0x02, 0x5e, 0x01, 0x03, 0x0e, 0x1f, 0x00, 0xde, 0x01, 0x19, 0x04, 0x1b, 0x00, 0x10, 0x0a, + /*b520:*/ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b530:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x05, 0x00, 0x00, + /*b540:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, + /*b550:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x28, 0x00, 0x77, 0x18, 0x80, 0x18, 0x80, 0x1a, + /*b560:*/ 0x01, 0x19, 0x3f, 0x4d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x6d, 0x10, 0x0a, 0x00, 0x00, + /*b570:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x04, 0x40, 0x40, 0x03, 0x00, 0x2e, 0x1b, + /*b580:*/ 0x44, 0x00, 0x19, 0x01, 0x00, 0xbe, 0x00, 0xde, 0x3f, 0xd0, 0x80, 0x08, 0x03, 0x00, 0x00, 0x00, + /*b590:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x7d, 0x10, 0x00, 0x01, 0x54, 0x00, + /*b5f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b600:*/ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x51, + /*b610:*/ 0x51, 0x51, 0x51, 0xcd, 0x0d, 0x04, 0x00, 0x00, 0x1c, 0x80, 0x00, 0x04, 0xff, 0x2e, 0x1b, 0x05, + /*b620:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b630:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b640:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b650:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b660:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b670:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b680:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b690:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6e0:*/ 0x00, 0x00, 0x00, 0x1d, 0x1a, 0x16, 0x00, 0x01, 0x55, 0x1b, 0x00, 0x01, 0x00, 0x01, 0x1a, 0x00, + /*b6f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b700:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b710:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b720:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x32, 0x00, 0x1e, 0x04, 0x80, 0xc0, 0x04, + /*b730:*/ 0x28, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b740:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b750:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b760:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b770:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b780:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b790:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x00, 0x28, 0x00, 0x00, 0x51, 0x00, + /*b7f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b800:*/ 0xff}; +#endif + +const char *rmi_config_ver = "N51XX_SY_1216"; + +const u8 rmi_fw[] = { + /*0000:*/ 0x02, 0x62, 0x3e, 0x94, 0x00, 0x00, 0x00, 0x05, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, + /*0010:*/ 0x53, 0x37, 0x33, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0020:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0030:*/ 0x44, 0x53, 0x34, 0x20, 0x52, 0x33, 0x2e, 0x35, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0040:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0050:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0060:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0070:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0080:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*0090:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00a0:*/ 0x49, 0x32, 0x43, 0x00, 0x04, 0x00, 0xff, 0x00, 0x0c, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, + /*00b0:*/ 0x09, 0xd9, 0x94, 0xe6, 0x23, 0xe3, 0x8d, 0xce, 0x50, 0x96, 0xc3, 0x4b, 0x8f, 0x1a, 0x4f, 0x6d, + /*00c0:*/ 0x57, 0x05, 0x48, 0x7c, 0xd7, 0x03, 0xb0, 0x50, 0xe0, 0x77, 0x3c, 0x8b, 0x79, 0xf6, 0x71, 0x75, + /*00d0:*/ 0xca, 0xec, 0xb0, 0x31, 0x53, 0xaa, 0x37, 0xe9, 0x19, 0x47, 0x46, 0x84, 0xba, 0x28, 0x18, 0xe9, + /*00e0:*/ 0x51, 0x89, 0xe7, 0xce, 0x3e, 0x64, 0x26, 0xa6, 0x25, 0x31, 0xc5, 0x0d, 0x9a, 0xa9, 0x93, 0xfa, + /*00f0:*/ 0x8a, 0x67, 0xd2, 0x1b, 0x4b, 0x66, 0x4d, 0x12, 0xa8, 0x62, 0x72, 0xf6, 0xed, 0xb7, 0x09, 0x4e, + /*0100:*/ 0xce, 0xd6, 0xc5, 0x28, 0x69, 0xd2, 0xa9, 0x7d, 0x39, 0xf4, 0xe4, 0x78, 0x56, 0xd2, 0x53, 0x4e, + /*0110:*/ 0x35, 0x9f, 0xa7, 0xc9, 0x55, 0x7b, 0xec, 0xb3, 0xd2, 0xb0, 0x47, 0x38, 0x01, 0x7e, 0xf6, 0x5d, + /*0120:*/ 0xa3, 0xef, 0xc0, 0x55, 0xf3, 0xca, 0x62, 0x4f, 0xc8, 0x13, 0xbd, 0x20, 0xe6, 0x3a, 0xac, 0xcd, + /*0130:*/ 0x2b, 0x4b, 0x2c, 0x18, 0x21, 0x16, 0xf3, 0xb6, 0xaa, 0x41, 0xe2, 0x66, 0xfc, 0x6f, 0x1f, 0xce, + /*0140:*/ 0x14, 0xd1, 0x9c, 0x00, 0x78, 0x74, 0x94, 0xa6, 0xd2, 0x4e, 0xff, 0x63, 0x8f, 0x42, 0xcb, 0x54, + /*0150:*/ 0xcc, 0x1b, 0x3f, 0x78, 0xf2, 0xf6, 0x8a, 0xbe, 0x7f, 0x80, 0x69, 0x1a, 0x1a, 0xff, 0xc2, 0x2a, + /*0160:*/ 0x12, 0x01, 0xc8, 0x11, 0xe3, 0xe2, 0x83, 0xc2, 0x71, 0x24, 0x74, 0x0e, 0x6b, 0xd3, 0x26, 0xb3, + /*0170:*/ 0xda, 0xdc, 0xfd, 0x86, 0xe6, 0xdc, 0xb0, 0x14, 0xc0, 0x87, 0x68, 0x6d, 0x15, 0x39, 0x99, 0x81, + /*0180:*/ 0xf4, 0x8f, 0xfa, 0x4b, 0x47, 0x53, 0x99, 0x05, 0xe8, 0x9f, 0xd7, 0x8c, 0x0a, 0xdd, 0x12, 0x95, + /*0190:*/ 0xc6, 0xd0, 0xe3, 0xf9, 0x2c, 0xb0, 0xee, 0x4f, 0x50, 0x51, 0x9e, 0x2c, 0x7f, 0x07, 0xd7, 0xd7, + /*01a0:*/ 0xa6, 0xfc, 0x58, 0x56, 0x65, 0x04, 0x49, 0x73, 0x05, 0x3e, 0xd2, 0xe9, 0x37, 0xb8, 0xd7, 0xbc, + /*01b0:*/ 0x79, 0x5f, 0x8c, 0xc7, 0x28, 0xe6, 0x39, 0xef, 0x29, 0x7f, 0x26, 0x52, 0xd8, 0xda, 0x99, 0x4c, + /*01c0:*/ 0x6b, 0x6e, 0x7a, 0xd3, 0x9e, 0x75, 0xca, 0x55, 0xb2, 0x29, 0x88, 0xb8, 0x0b, 0x1d, 0x1c, 0x81, + /*01d0:*/ 0x98, 0x15, 0xf7, 0x59, 0x1d, 0x73, 0xc3, 0x8d, 0x42, 0x5e, 0xce, 0x78, 0x9b, 0x36, 0x49, 0xbe, + /*01e0:*/ 0xad, 0xc9, 0x81, 0xa4, 0x7e, 0x4c, 0xcb, 0x35, 0x52, 0x17, 0xd7, 0x73, 0x29, 0x4e, 0x81, 0xdf, + /*01f0:*/ 0x66, 0x04, 0x1d, 0x49, 0x3f, 0xa0, 0xf2, 0x2f, 0x42, 0xd0, 0xf4, 0xe9, 0x49, 0xae, 0x52, 0xf7, + /*0200:*/ 0xce, 0x67, 0x45, 0x5c, 0x59, 0x91, 0xb0, 0x83, 0xc0, 0x2e, 0xf4, 0x77, 0xcb, 0x65, 0xb5, 0xd3, + /*0210:*/ 0x18, 0x15, 0x9e, 0x05, 0x30, 0x8f, 0xb7, 0xb8, 0x40, 0x1f, 0x71, 0xb1, 0x0f, 0x81, 0x03, 0x89, + /*0220:*/ 0xb7, 0x6d, 0xef, 0x46, 0x6e, 0x45, 0x46, 0xc5, 0xd3, 0x94, 0x92, 0x41, 0xca, 0xc5, 0x32, 0xac, + /*0230:*/ 0x34, 0x10, 0x2b, 0x1a, 0x4f, 0xec, 0x94, 0xcf, 0x91, 0xd9, 0x80, 0xf1, 0x60, 0x9d, 0xe7, 0x63, + /*0240:*/ 0x51, 0xa7, 0xec, 0xe6, 0x1d, 0xf8, 0x38, 0xc7, 0xec, 0xe7, 0x69, 0x08, 0x02, 0x7b, 0x09, 0x89, + /*0250:*/ 0x84, 0x9a, 0xbd, 0x1f, 0x04, 0x9f, 0xf3, 0x20, 0xc8, 0x23, 0x4c, 0xd7, 0x0a, 0x64, 0x47, 0x43, + /*0260:*/ 0xb6, 0xc8, 0xad, 0xb7, 0xd5, 0xa4, 0xb0, 0xea, 0x57, 0x8d, 0xe9, 0x4e, 0x18, 0x81, 0x08, 0x26, + /*0270:*/ 0x68, 0x66, 0xe6, 0x0b, 0xb2, 0x5d, 0xf5, 0xc3, 0xc1, 0xc1, 0x25, 0x84, 0xdd, 0x00, 0x34, 0x10, + /*0280:*/ 0x94, 0xb6, 0xaf, 0x9f, 0x6a, 0xd5, 0x34, 0x1e, 0x9a, 0x42, 0xd0, 0xa7, 0xc9, 0xd7, 0x3f, 0xc3, + /*0290:*/ 0x43, 0xf2, 0x80, 0x94, 0x2e, 0xb9, 0xdb, 0x60, 0x76, 0xc5, 0xf5, 0x6f, 0xe8, 0x83, 0x96, 0x1b, + /*02a0:*/ 0xe4, 0xdc, 0x2e, 0x2b, 0xb5, 0x80, 0x99, 0x1c, 0x26, 0xda, 0x52, 0x46, 0x1f, 0x54, 0x1c, 0x0e, + /*02b0:*/ 0xee, 0x3a, 0xd2, 0x3f, 0x8f, 0x98, 0x5b, 0xf3, 0x5b, 0xa2, 0x33, 0x03, 0xef, 0x98, 0x35, 0xed, + /*02c0:*/ 0x73, 0xd5, 0xe3, 0x66, 0xca, 0xd7, 0x62, 0x65, 0x93, 0xe2, 0x4d, 0x2c, 0x3c, 0xa9, 0x47, 0xfa, + /*02d0:*/ 0x3d, 0x52, 0x65, 0x92, 0xc1, 0x57, 0xf4, 0x92, 0xff, 0x86, 0x14, 0x22, 0xb1, 0x5b, 0x72, 0xc3, + /*02e0:*/ 0x17, 0x47, 0xb6, 0x8d, 0xb4, 0x55, 0xf9, 0xf9, 0x89, 0xf2, 0xfa, 0xc5, 0xc9, 0xc7, 0xe0, 0xd6, + /*02f0:*/ 0x2c, 0xba, 0x56, 0xc1, 0xc6, 0x0f, 0x69, 0x51, 0x0e, 0x7c, 0x1e, 0x6a, 0x5d, 0x2f, 0x2d, 0x26, + /*0300:*/ 0xaf, 0xa0, 0x68, 0x71, 0x08, 0xf3, 0x10, 0xea, 0xb1, 0xc8, 0x48, 0x14, 0x73, 0xcb, 0x9c, 0x33, + /*0310:*/ 0x9d, 0x4d, 0x2b, 0x1d, 0x18, 0xc2, 0x61, 0xbe, 0xde, 0x02, 0x96, 0x68, 0xf0, 0xaa, 0x9c, 0xb8, + /*0320:*/ 0x2a, 0x94, 0xf2, 0xc1, 0xc3, 0xdb, 0xf9, 0x6e, 0x5b, 0x6e, 0xb5, 0xb4, 0xa3, 0x0e, 0xb6, 0xb9, + /*0330:*/ 0x95, 0x0e, 0x18, 0x69, 0x40, 0x4c, 0xcb, 0xf7, 0xf3, 0xd6, 0x53, 0x16, 0xc1, 0xcf, 0xc0, 0x34, + /*0340:*/ 0xcb, 0xe9, 0x2b, 0x3f, 0xdd, 0xe0, 0xa4, 0x4e, 0x97, 0x41, 0x72, 0x15, 0xfc, 0x7a, 0x40, 0x84, + /*0350:*/ 0x96, 0xeb, 0x45, 0x16, 0x96, 0xcb, 0x72, 0x8d, 0xb6, 0xca, 0x00, 0x58, 0x56, 0x88, 0x47, 0x39, + /*0360:*/ 0x90, 0x34, 0x76, 0x5c, 0x46, 0x70, 0x96, 0x89, 0xd0, 0x34, 0x60, 0xbd, 0x7d, 0x0e, 0xdb, 0xa6, + /*0370:*/ 0x0f, 0x17, 0x49, 0x67, 0x27, 0x87, 0x06, 0xae, 0x69, 0x19, 0x89, 0xcd, 0xb2, 0x68, 0xa1, 0x1b, + /*0380:*/ 0x52, 0xb4, 0x1d, 0xfa, 0xc4, 0x5b, 0xf1, 0xe8, 0x1f, 0xef, 0xa7, 0x5e, 0x87, 0x18, 0x0d, 0xdb, + /*0390:*/ 0xdf, 0xc9, 0xf3, 0x03, 0x3c, 0xfd, 0x9f, 0x0b, 0xa0, 0x17, 0x2b, 0x4b, 0xad, 0x14, 0x66, 0xb5, + /*03a0:*/ 0x31, 0x7b, 0x5f, 0xc7, 0x03, 0xa7, 0x83, 0x9c, 0xab, 0x7b, 0x58, 0x1b, 0x39, 0xb8, 0xc4, 0x44, + /*03b0:*/ 0xdd, 0xa1, 0xf8, 0xe8, 0x9e, 0x51, 0x92, 0xb1, 0xd5, 0xfa, 0x8e, 0x53, 0x7a, 0x51, 0xd9, 0x1b, + /*03c0:*/ 0xa2, 0x4a, 0x7f, 0xc6, 0xf7, 0x58, 0x64, 0xe3, 0x8d, 0x35, 0xbf, 0xb0, 0xd6, 0x11, 0x88, 0x05, + /*03d0:*/ 0x17, 0x26, 0x53, 0x5a, 0x02, 0x3d, 0xe1, 0x35, 0x2a, 0x81, 0xd3, 0xac, 0xfd, 0xb6, 0xdc, 0xf0, + /*03e0:*/ 0x35, 0x02, 0x6f, 0x72, 0xcd, 0x53, 0xf3, 0xbf, 0x18, 0x3e, 0x4f, 0x64, 0xee, 0x02, 0xfc, 0xdd, + /*03f0:*/ 0x78, 0xb8, 0x46, 0x06, 0x46, 0x0a, 0x13, 0xa0, 0x07, 0xc2, 0x42, 0x2a, 0xd2, 0xb3, 0x5d, 0x74, + /*0400:*/ 0x8b, 0x1d, 0x47, 0x64, 0x9b, 0x78, 0x86, 0x62, 0x89, 0x5f, 0xdd, 0x65, 0x16, 0x89, 0x46, 0x73, + /*0410:*/ 0xe0, 0x54, 0x1d, 0xf1, 0xc2, 0x20, 0x12, 0x49, 0x6e, 0x45, 0xf1, 0xce, 0x25, 0x3e, 0xb5, 0x1b, + /*0420:*/ 0x09, 0xd6, 0xc7, 0xb4, 0xe7, 0x79, 0xfb, 0x48, 0x3e, 0x7a, 0x86, 0xa5, 0xc1, 0xca, 0x99, 0xb9, + /*0430:*/ 0xeb, 0xe1, 0x06, 0x4b, 0xe5, 0xf0, 0xa2, 0xf0, 0xd9, 0xff, 0x6b, 0x76, 0x9f, 0x86, 0x6e, 0x6f, + /*0440:*/ 0xe6, 0x7a, 0xe8, 0x74, 0x77, 0x25, 0xc1, 0x86, 0x2a, 0xc7, 0x1e, 0xe4, 0xb5, 0x88, 0x3a, 0xd7, + /*0450:*/ 0x43, 0x1e, 0xc9, 0x66, 0xa9, 0x0b, 0x7a, 0x9b, 0x8f, 0x9f, 0xb5, 0x9a, 0x89, 0x5f, 0x2f, 0xa7, + /*0460:*/ 0xe1, 0x1d, 0x19, 0x20, 0x6f, 0x17, 0x71, 0xd1, 0x33, 0x63, 0xdf, 0xed, 0x82, 0x08, 0x28, 0xab, + /*0470:*/ 0x3c, 0xb5, 0x73, 0x84, 0x3f, 0x78, 0x19, 0x26, 0x5b, 0x6d, 0x08, 0x8f, 0xde, 0x61, 0x87, 0x24, + /*0480:*/ 0x60, 0xd9, 0x85, 0xa9, 0x88, 0x5b, 0xcf, 0x56, 0xd6, 0x23, 0x88, 0xfc, 0xf3, 0x2c, 0xae, 0x7c, + /*0490:*/ 0x31, 0x33, 0xee, 0xc6, 0xf0, 0xff, 0xae, 0x56, 0x90, 0xba, 0x15, 0xbe, 0xfb, 0x18, 0xae, 0x8b, + /*04a0:*/ 0xe9, 0x34, 0x9d, 0xbb, 0xbe, 0xf6, 0xea, 0x90, 0x87, 0xf3, 0x55, 0xd5, 0xca, 0x3e, 0xc3, 0x04, + /*04b0:*/ 0x17, 0xab, 0x3c, 0x9e, 0x2a, 0x11, 0x07, 0x24, 0xbe, 0x3c, 0x4a, 0x2a, 0x11, 0xe1, 0x48, 0x52, + /*04c0:*/ 0x93, 0x5f, 0xee, 0x8f, 0x57, 0x3e, 0x06, 0x53, 0xc5, 0xc7, 0x16, 0x60, 0x01, 0x83, 0xc1, 0xb5, + /*04d0:*/ 0x9b, 0xf5, 0xaf, 0x0e, 0xe3, 0x03, 0x80, 0xb0, 0x42, 0x71, 0xf1, 0x14, 0xa0, 0x21, 0x3e, 0xd8, + /*04e0:*/ 0xb9, 0x15, 0x8c, 0x8a, 0xdc, 0x48, 0x51, 0xdc, 0xe4, 0x9c, 0x2e, 0x5f, 0x41, 0x55, 0x4f, 0x10, + /*04f0:*/ 0x4d, 0x5a, 0x4c, 0x32, 0xfa, 0x6e, 0x54, 0x63, 0x57, 0x43, 0x19, 0x0f, 0x97, 0x18, 0x4e, 0xa9, + /*0500:*/ 0xde, 0x48, 0x20, 0x1f, 0xc5, 0x24, 0x15, 0xe0, 0x56, 0x58, 0x99, 0x2d, 0xf8, 0xb2, 0x3d, 0xc9, + /*0510:*/ 0x39, 0xe0, 0xfb, 0xf0, 0x3c, 0x67, 0xc1, 0x98, 0x5f, 0x13, 0x52, 0x10, 0x0e, 0xe2, 0x64, 0xfc, + /*0520:*/ 0x22, 0x38, 0x9a, 0x59, 0x78, 0x7f, 0x0d, 0x8c, 0xc3, 0xb6, 0x3a, 0x76, 0x1b, 0x91, 0x66, 0xaa, + /*0530:*/ 0x02, 0x90, 0x41, 0xfb, 0x50, 0x6f, 0xb9, 0xba, 0x6b, 0x6a, 0xc8, 0x2f, 0xdb, 0x06, 0x9f, 0x1c, + /*0540:*/ 0xc2, 0xec, 0x4e, 0xa2, 0x9a, 0xbf, 0x24, 0xb6, 0x56, 0x7e, 0x0e, 0xd8, 0x6a, 0x83, 0x7f, 0x35, + /*0550:*/ 0xfc, 0xe8, 0xf4, 0xc6, 0x49, 0x4d, 0xeb, 0xa3, 0x99, 0xb7, 0x07, 0xff, 0x25, 0x4a, 0x72, 0xd9, + /*0560:*/ 0xe7, 0xce, 0x3d, 0x37, 0x9b, 0x77, 0x4a, 0x06, 0x1b, 0x41, 0xc9, 0xae, 0x2e, 0x51, 0x41, 0x94, + /*0570:*/ 0x14, 0x08, 0xc4, 0x74, 0x7c, 0xa2, 0xfe, 0xa1, 0x4e, 0x6b, 0x31, 0x0e, 0xb2, 0x41, 0xd1, 0x44, + /*0580:*/ 0xde, 0xc6, 0x53, 0xd3, 0x14, 0xec, 0x71, 0x19, 0x91, 0x3d, 0x5b, 0xb0, 0xd0, 0x89, 0x5d, 0xa0, + /*0590:*/ 0x0c, 0x16, 0xb7, 0x5c, 0x6c, 0xbb, 0x17, 0xb3, 0xd0, 0xea, 0x14, 0x4c, 0x80, 0xa3, 0xb3, 0xe4, + /*05a0:*/ 0x4e, 0xdf, 0x8d, 0x11, 0xc1, 0x4a, 0x2b, 0x72, 0x4a, 0x9f, 0x09, 0x8d, 0x2d, 0x74, 0x3d, 0x62, + /*05b0:*/ 0x0e, 0x9c, 0xa0, 0x2b, 0x9f, 0xc1, 0x7e, 0xeb, 0x6f, 0x55, 0x8e, 0x4f, 0xe1, 0x74, 0xb4, 0x53, + /*05c0:*/ 0x0f, 0x32, 0xf4, 0x99, 0xec, 0x0e, 0xc4, 0x38, 0x27, 0xd2, 0xd0, 0x6f, 0x6e, 0x34, 0xba, 0x1b, + /*05d0:*/ 0x60, 0xbd, 0xcb, 0x06, 0xfe, 0x2e, 0xd1, 0x81, 0x56, 0x9d, 0xcf, 0x68, 0x3e, 0xa5, 0xa0, 0x1a, + /*05e0:*/ 0x7e, 0x52, 0x0f, 0xad, 0x55, 0x6f, 0x00, 0xc6, 0xd4, 0x24, 0x74, 0x75, 0x2e, 0x5b, 0x61, 0xd6, + /*05f0:*/ 0x1d, 0xf9, 0xab, 0xdf, 0x58, 0xfb, 0xac, 0x07, 0x57, 0x22, 0x3d, 0xdd, 0x11, 0xe5, 0xa2, 0x2d, + /*0600:*/ 0xeb, 0x99, 0x3c, 0xb3, 0x65, 0x08, 0x79, 0xe7, 0x82, 0x65, 0x8f, 0x6e, 0x43, 0xa8, 0xa0, 0x51, + /*0610:*/ 0xde, 0xd1, 0xf4, 0xb4, 0x38, 0xa7, 0xb8, 0x68, 0x92, 0xb9, 0x99, 0x2d, 0x9f, 0x2b, 0x0c, 0xe7, + /*0620:*/ 0x31, 0xcd, 0x05, 0xcb, 0x97, 0xb8, 0xf1, 0xf2, 0xfc, 0x2b, 0xb0, 0x17, 0xcd, 0x7b, 0x62, 0x6a, + /*0630:*/ 0x0d, 0x30, 0xaa, 0x14, 0xd6, 0xd2, 0xd7, 0x66, 0xc0, 0x1f, 0x57, 0xe9, 0xd8, 0xe5, 0x4d, 0xe3, + /*0640:*/ 0x23, 0xaf, 0xa2, 0xbb, 0x01, 0xda, 0xcd, 0x3e, 0xf8, 0x4a, 0x6d, 0x11, 0xe5, 0x8f, 0x5f, 0x8e, + /*0650:*/ 0x08, 0x30, 0x98, 0x6a, 0xad, 0x73, 0x4e, 0xcf, 0xd6, 0xc8, 0x51, 0x73, 0xf4, 0x3e, 0xd5, 0x8e, + /*0660:*/ 0x7c, 0x26, 0x9c, 0xcc, 0xe8, 0xf4, 0xfb, 0x69, 0x43, 0xac, 0x08, 0x60, 0xae, 0x90, 0xb6, 0x84, + /*0670:*/ 0x40, 0xc8, 0x73, 0xbb, 0xfc, 0xff, 0xf3, 0x16, 0xaf, 0x21, 0xd2, 0x4f, 0x29, 0x8e, 0xb3, 0x69, + /*0680:*/ 0xe6, 0xfe, 0x47, 0x85, 0xdd, 0x0b, 0x4d, 0x12, 0x8b, 0x1b, 0x55, 0xdf, 0x65, 0xb5, 0x4a, 0xdd, + /*0690:*/ 0x4d, 0x67, 0x68, 0xf2, 0x38, 0xd5, 0x73, 0x00, 0xbe, 0x37, 0x2f, 0xab, 0xda, 0x25, 0x6d, 0x26, + /*06a0:*/ 0x62, 0x47, 0xa9, 0x73, 0x6b, 0x87, 0x26, 0x66, 0xb6, 0x4f, 0xee, 0x15, 0x7f, 0x3e, 0xc1, 0xe4, + /*06b0:*/ 0xa9, 0x13, 0xd3, 0x56, 0xb7, 0x1c, 0x81, 0x21, 0x2a, 0xa6, 0x1c, 0x3f, 0x58, 0xe2, 0xd9, 0x38, + /*06c0:*/ 0xc2, 0x0d, 0x49, 0x3e, 0x8c, 0xdf, 0x6b, 0x56, 0x76, 0xc4, 0xe6, 0x9d, 0x4f, 0x5b, 0x77, 0x0f, + /*06d0:*/ 0x18, 0x38, 0xeb, 0x07, 0xc1, 0x00, 0x0c, 0xfa, 0x8e, 0x60, 0x6b, 0xde, 0xcc, 0xf5, 0xd1, 0x2a, + /*06e0:*/ 0x0d, 0x0f, 0x01, 0x93, 0xf9, 0x12, 0x55, 0x3f, 0x51, 0x4e, 0x84, 0xcd, 0x89, 0x3e, 0xf8, 0xee, + /*06f0:*/ 0xca, 0x1c, 0x5c, 0xa8, 0x9c, 0x3d, 0x5d, 0xad, 0x12, 0x1a, 0xf5, 0x28, 0xb3, 0x57, 0xb7, 0xb7, + /*0700:*/ 0x64, 0x74, 0xcb, 0x92, 0x4a, 0xdf, 0x9b, 0xb2, 0xfa, 0x08, 0xa1, 0xcc, 0xde, 0x6d, 0x0b, 0x9e, + /*0710:*/ 0x4e, 0x6d, 0xde, 0xfc, 0x69, 0xe2, 0xaa, 0x4e, 0x49, 0x10, 0xd9, 0xec, 0x58, 0x7c, 0x1e, 0x84, + /*0720:*/ 0x8d, 0x50, 0x6c, 0x90, 0x5f, 0x76, 0x67, 0x77, 0x66, 0x95, 0x54, 0xec, 0xda, 0xc6, 0xd4, 0x44, + /*0730:*/ 0x0a, 0xe5, 0xbe, 0x52, 0x08, 0xdf, 0x44, 0x62, 0x77, 0x38, 0x15, 0x73, 0xa2, 0xcc, 0xa3, 0x06, + /*0740:*/ 0xd0, 0xb2, 0x7b, 0xe2, 0xdd, 0x55, 0xd2, 0xa3, 0x65, 0x51, 0x8f, 0x39, 0x0c, 0x3e, 0x19, 0xf6, + /*0750:*/ 0x52, 0xa6, 0x4c, 0xf0, 0xb1, 0x2c, 0xe2, 0x71, 0x89, 0x40, 0x92, 0x7b, 0x11, 0xa0, 0x76, 0xfa, + /*0760:*/ 0x07, 0x23, 0x2d, 0x8e, 0xb1, 0xbc, 0x5e, 0x04, 0xdb, 0xba, 0xa0, 0x2e, 0xc0, 0xc5, 0xac, 0x03, + /*0770:*/ 0x65, 0xbe, 0x68, 0x95, 0xbe, 0x0d, 0x6e, 0xe4, 0x3e, 0xbe, 0x88, 0x47, 0x2f, 0xb8, 0xd9, 0xf6, + /*0780:*/ 0x59, 0x2b, 0xe0, 0x27, 0xc6, 0xbc, 0xf4, 0x0d, 0x01, 0x46, 0x7a, 0x70, 0xfe, 0x0c, 0xcc, 0x30, + /*0790:*/ 0x97, 0xa7, 0x19, 0x00, 0x5a, 0x5b, 0x3a, 0xfa, 0xc8, 0x07, 0x33, 0xa3, 0x31, 0x3f, 0x0c, 0xe1, + /*07a0:*/ 0x81, 0xa7, 0xef, 0x18, 0x7f, 0x78, 0x9d, 0x3f, 0x79, 0xe2, 0x59, 0x02, 0x55, 0xe0, 0xae, 0x2b, + /*07b0:*/ 0xaf, 0xdf, 0x2d, 0x7b, 0x3d, 0xd8, 0x1a, 0x28, 0xfb, 0xcd, 0x01, 0x12, 0xb8, 0xbf, 0x13, 0x45, + /*07c0:*/ 0xfd, 0x46, 0xb3, 0x8d, 0x46, 0x74, 0x76, 0xfd, 0x35, 0x7c, 0xe4, 0x6e, 0xe9, 0xc5, 0x42, 0x60, + /*07d0:*/ 0x0d, 0xfd, 0x2e, 0xf1, 0xcb, 0x30, 0xb1, 0x4e, 0x23, 0xf0, 0x68, 0x99, 0x95, 0xba, 0x8d, 0x5f, + /*07e0:*/ 0x08, 0xf7, 0x43, 0xed, 0xa1, 0x12, 0x1b, 0x54, 0x27, 0x78, 0x31, 0x19, 0xf7, 0xbb, 0x5d, 0xdd, + /*07f0:*/ 0x89, 0x97, 0x69, 0x27, 0x86, 0x00, 0x6a, 0x3b, 0xc5, 0xef, 0x13, 0xa0, 0x70, 0x91, 0x5c, 0xfa, + /*0800:*/ 0x05, 0xc6, 0xfa, 0x45, 0x1a, 0xbd, 0x58, 0x86, 0xfd, 0x0d, 0x51, 0x5d, 0xc6, 0x21, 0x55, 0x15, + /*0810:*/ 0x18, 0x11, 0x42, 0x81, 0xde, 0xbb, 0x44, 0x37, 0xaf, 0x59, 0xa5, 0x6d, 0x2a, 0xf8, 0x97, 0xc3, + /*0820:*/ 0x47, 0x5a, 0x09, 0x01, 0xfd, 0x6c, 0xcb, 0x59, 0xfd, 0x48, 0x36, 0xaf, 0x7a, 0x13, 0x62, 0xa3, + /*0830:*/ 0xc0, 0xa9, 0xe5, 0xa6, 0xbc, 0xf5, 0xd6, 0xa0, 0xa4, 0x52, 0xa4, 0xb8, 0x6f, 0x9d, 0x05, 0x30, + /*0840:*/ 0x71, 0x59, 0x44, 0xac, 0xa1, 0x81, 0x1d, 0xc3, 0xc7, 0xe6, 0xee, 0xde, 0xed, 0xd5, 0xf5, 0x67, + /*0850:*/ 0x11, 0x04, 0xc2, 0x33, 0xe2, 0x9c, 0x26, 0xb5, 0x05, 0x80, 0xa4, 0x51, 0xca, 0xd7, 0xc6, 0xda, + /*0860:*/ 0x08, 0xe6, 0xa1, 0xc5, 0xc2, 0x25, 0xc1, 0xa7, 0x5c, 0x84, 0x67, 0xbf, 0x4b, 0x69, 0xf3, 0xc3, + /*0870:*/ 0x4c, 0xfe, 0xc5, 0xa3, 0xdb, 0x05, 0xe4, 0x17, 0x94, 0x0c, 0x05, 0xf2, 0x73, 0x9b, 0xf0, 0xe5, + /*0880:*/ 0x6b, 0x4e, 0x44, 0xcc, 0x4c, 0xcd, 0x40, 0x4d, 0x18, 0x2f, 0xe0, 0xa8, 0x8c, 0xb8, 0x6d, 0x02, + /*0890:*/ 0xc8, 0x13, 0x1f, 0x46, 0x2c, 0x42, 0x63, 0x9c, 0xb3, 0xb8, 0xc3, 0x60, 0xb8, 0xfe, 0x84, 0x5c, + /*08a0:*/ 0xa0, 0x6d, 0xba, 0x03, 0xf7, 0x98, 0xfd, 0x44, 0xaa, 0xcf, 0x24, 0x5b, 0x51, 0x77, 0x57, 0x63, + /*08b0:*/ 0x3f, 0x19, 0x7a, 0x7f, 0x56, 0x35, 0x2a, 0x32, 0xd8, 0x2c, 0x3a, 0x2a, 0x32, 0xf7, 0x5a, 0xd6, + /*08c0:*/ 0x1a, 0xb7, 0x81, 0xb1, 0xd1, 0x4f, 0xb2, 0xa6, 0xea, 0xde, 0x1d, 0x9b, 0x12, 0x31, 0x3f, 0x9d, + /*08d0:*/ 0xd6, 0x68, 0x60, 0x0d, 0x12, 0x57, 0xa9, 0x0e, 0xab, 0x0a, 0xe2, 0x46, 0xf8, 0x22, 0x06, 0x3f, + /*08e0:*/ 0xa5, 0x21, 0xa1, 0xea, 0xe6, 0xd1, 0x74, 0x03, 0x14, 0xad, 0x4e, 0x60, 0x8a, 0xe1, 0x59, 0x07, + /*08f0:*/ 0x45, 0x73, 0x5c, 0x13, 0x98, 0xf1, 0x18, 0x5f, 0x26, 0xdb, 0x2c, 0xa2, 0x43, 0xe6, 0x9a, 0xf9, + /*0900:*/ 0x90, 0x16, 0xaf, 0x08, 0x7e, 0xa3, 0xba, 0x46, 0x95, 0xce, 0x18, 0x2e, 0x32, 0x73, 0x63, 0x0a, + /*0910:*/ 0xe4, 0xfb, 0x81, 0x51, 0x0f, 0x81, 0x8a, 0x6e, 0x79, 0xd3, 0x53, 0x5c, 0x95, 0x2d, 0xc3, 0x86, + /*0920:*/ 0x62, 0xd8, 0xd5, 0x64, 0xe3, 0xda, 0xb0, 0xa6, 0x3d, 0x12, 0xb4, 0xfc, 0x26, 0x84, 0x8c, 0xcf, + /*0930:*/ 0x08, 0x84, 0xab, 0xe2, 0x0e, 0x18, 0xf5, 0x6a, 0x7b, 0xcc, 0xd5, 0x27, 0x9d, 0x2b, 0x66, 0x6e, + /*0940:*/ 0x9e, 0xfe, 0x7d, 0x30, 0x2d, 0x77, 0x33, 0x0e, 0xc4, 0x74, 0xc2, 0x12, 0x10, 0x5c, 0xf4, 0xb5, + /*0950:*/ 0xe7, 0xbb, 0x96, 0xd8, 0xc6, 0x07, 0x22, 0x31, 0xd6, 0x7a, 0xd6, 0xa6, 0x86, 0xa7, 0x53, 0x31, + /*0960:*/ 0xff, 0x41, 0x87, 0xad, 0xda, 0x77, 0xe7, 0xaf, 0x36, 0xc9, 0xda, 0x41, 0x2e, 0x9d, 0xd0, 0x08, + /*0970:*/ 0x02, 0x81, 0xc1, 0x88, 0xac, 0xb4, 0x40, 0xb8, 0x4f, 0x8b, 0xb4, 0xc7, 0x7e, 0x65, 0x58, 0x68, + /*0980:*/ 0x04, 0x17, 0x69, 0xbd, 0xb5, 0xf2, 0x66, 0xf3, 0xab, 0x7b, 0x2c, 0xba, 0x63, 0x47, 0x9d, 0x17, + /*0990:*/ 0xce, 0x6d, 0x77, 0xf6, 0x25, 0x14, 0x58, 0x1c, 0xa6, 0xbc, 0xd1, 0xa6, 0x74, 0xed, 0x49, 0x55, + /*09a0:*/ 0x6d, 0x46, 0xfe, 0xdd, 0xea, 0x7b, 0x50, 0xf9, 0xb2, 0x5b, 0xa5, 0x2e, 0x7b, 0x90, 0x24, 0x51, + /*09b0:*/ 0xda, 0x35, 0x01, 0x31, 0x15, 0x15, 0xba, 0x83, 0x9b, 0x82, 0x1a, 0xe0, 0x20, 0x2a, 0xb1, 0xd7, + /*09c0:*/ 0x1b, 0x46, 0xb8, 0xea, 0xc2, 0xb8, 0x2d, 0x44, 0xe0, 0x0d, 0xd6, 0x3c, 0x9e, 0xe2, 0xcf, 0x44, + /*09d0:*/ 0x1d, 0x24, 0x58, 0xb0, 0x68, 0x0a, 0xfe, 0x05, 0x36, 0x8a, 0x96, 0x91, 0x40, 0xfa, 0x12, 0xb8, + /*09e0:*/ 0xd0, 0xf1, 0x6b, 0xd4, 0x76, 0x4e, 0x62, 0x7d, 0xf6, 0x8e, 0xe8, 0x77, 0x48, 0x02, 0xef, 0x6f, + /*09f0:*/ 0xac, 0xc6, 0xd9, 0x21, 0x96, 0x91, 0xcd, 0xf1, 0xa6, 0xe1, 0xd5, 0xd0, 0x6d, 0x62, 0x95, 0xbf, + /*0a00:*/ 0xf6, 0x91, 0x7b, 0xf0, 0xd6, 0x63, 0x6d, 0x5c, 0xd3, 0x9d, 0x8f, 0xe7, 0x3e, 0x2a, 0x82, 0xc6, + /*0a10:*/ 0x38, 0x24, 0xb0, 0x2c, 0x7d, 0x8f, 0x00, 0x26, 0xbd, 0x4c, 0xf0, 0x45, 0xc6, 0x16, 0xdd, 0x82, + /*0a20:*/ 0xa3, 0x8b, 0x32, 0xe4, 0xd8, 0xa8, 0x71, 0xca, 0x1d, 0x02, 0x4f, 0x58, 0x50, 0xd4, 0x8d, 0x21, + /*0a30:*/ 0x3a, 0x68, 0x49, 0x34, 0xac, 0x55, 0xbb, 0xc4, 0x3d, 0x9e, 0x2a, 0x90, 0x6d, 0x4b, 0x15, 0x6b, + /*0a40:*/ 0xe6, 0xe2, 0x04, 0x78, 0xe6, 0x8f, 0xd4, 0xf7, 0xce, 0x64, 0x95, 0xfb, 0xc7, 0x77, 0x6e, 0x4f, + /*0a50:*/ 0xea, 0x44, 0x2f, 0x34, 0x67, 0xbc, 0xef, 0xba, 0xe5, 0x02, 0xa0, 0x87, 0x26, 0x4f, 0x40, 0x95, + /*0a60:*/ 0x9d, 0x63, 0xcb, 0xc2, 0xdd, 0xf2, 0x31, 0x4f, 0x28, 0xee, 0x12, 0x8a, 0x5e, 0x05, 0xad, 0xd6, + /*0a70:*/ 0x55, 0x16, 0xfc, 0x3f, 0x5d, 0x35, 0x57, 0xdc, 0xef, 0x33, 0x98, 0x31, 0xb7, 0xc1, 0xe4, 0x05, + /*0a80:*/ 0x28, 0x17, 0xf0, 0x0c, 0x0e, 0x92, 0xf4, 0xa7, 0x02, 0x57, 0xb3, 0x9f, 0xcb, 0xd4, 0x83, 0x41, + /*0a90:*/ 0x50, 0xbe, 0xba, 0xe4, 0x3a, 0xdc, 0xe4, 0xc5, 0xab, 0x5b, 0xa5, 0x47, 0x81, 0xc3, 0x8b, 0x34, + /*0aa0:*/ 0x2b, 0xe7, 0x52, 0x4a, 0x0d, 0x78, 0x57, 0x1c, 0xa6, 0x50, 0x6c, 0xe0, 0x19, 0xc0, 0x12, 0xa1, + /*0ab0:*/ 0x0c, 0x54, 0x53, 0x89, 0xff, 0xbd, 0xd1, 0x2c, 0xb3, 0x59, 0xd9, 0x43, 0xc2, 0xd5, 0x92, 0xab, + /*0ac0:*/ 0xe6, 0xc9, 0xfa, 0x39, 0xec, 0x29, 0xfd, 0x17, 0xf4, 0x87, 0x3b, 0x1f, 0x16, 0x22, 0x5d, 0x1b, + /*0ad0:*/ 0x49, 0x95, 0x59, 0xe5, 0xa6, 0x7f, 0xb0, 0x25, 0x38, 0x34, 0x2d, 0x10, 0x62, 0x20, 0x3c, 0x55, + /*0ae0:*/ 0x8a, 0x5e, 0x1d, 0x31, 0x45, 0x23, 0xa9, 0x62, 0x2b, 0x35, 0x3f, 0x60, 0xe3, 0xb7, 0xf0, 0x85, + /*0af0:*/ 0xcc, 0x0b, 0xba, 0xa9, 0x1b, 0xde, 0x36, 0x65, 0x11, 0x9e, 0x69, 0x01, 0xfd, 0x3b, 0xb0, 0xa9, + /*0b00:*/ 0x99, 0x37, 0x01, 0xcf, 0x08, 0x35, 0x1b, 0x15, 0x36, 0x55, 0x40, 0x29, 0xc0, 0x67, 0x3d, 0x2e, + /*0b10:*/ 0xd3, 0xe1, 0x27, 0x5b, 0x43, 0x0d, 0xec, 0xa8, 0x1c, 0x2f, 0x75, 0x73, 0xc9, 0x91, 0x4c, 0x1b, + /*0b20:*/ 0xe0, 0x75, 0xe2, 0xcb, 0xcc, 0x15, 0x58, 0x84, 0x32, 0x88, 0xec, 0x1d, 0x68, 0x89, 0xed, 0xc5, + /*0b30:*/ 0xb5, 0xcf, 0x7c, 0xa8, 0xe4, 0x14, 0x8f, 0x76, 0x7f, 0xc3, 0xd0, 0xde, 0xd8, 0x59, 0xb1, 0x1d, + /*0b40:*/ 0xc8, 0x72, 0x68, 0x7c, 0x2a, 0x6a, 0xc2, 0x45, 0xf2, 0xbb, 0xe6, 0x48, 0x30, 0x0f, 0x37, 0xa1, + /*0b50:*/ 0x71, 0x5e, 0x98, 0xa3, 0x7d, 0x53, 0x9c, 0x21, 0xdd, 0xf6, 0x75, 0x90, 0xcd, 0xd8, 0x09, 0x9b, + /*0b60:*/ 0x0f, 0x36, 0xda, 0x1c, 0xf9, 0x18, 0xa3, 0xc2, 0x2b, 0xf0, 0xec, 0x0f, 0xff, 0x04, 0xf6, 0xfc, + /*0b70:*/ 0x39, 0x93, 0x96, 0x93, 0x5d, 0xac, 0x8a, 0x08, 0xc3, 0x10, 0xe0, 0xfc, 0xf9, 0x28, 0x97, 0x0d, + /*0b80:*/ 0x69, 0xa2, 0x55, 0x7c, 0x39, 0x66, 0xb5, 0xaf, 0x88, 0x7b, 0x56, 0x1e, 0x5b, 0xbf, 0x51, 0xf5, + /*0b90:*/ 0x75, 0x71, 0x8d, 0x2c, 0xf1, 0x6e, 0x23, 0x93, 0xbc, 0x4d, 0x0b, 0x82, 0x73, 0x57, 0x14, 0x62, + /*0ba0:*/ 0x53, 0x75, 0xd5, 0x75, 0xed, 0x96, 0x4e, 0x62, 0xf4, 0x26, 0x85, 0x33, 0x6d, 0x3f, 0xf8, 0x8b, + /*0bb0:*/ 0xcd, 0x71, 0x27, 0x83, 0xd5, 0x55, 0x2c, 0x3a, 0x2f, 0xa6, 0x52, 0xc4, 0xf5, 0xfa, 0x21, 0xc1, + /*0bc0:*/ 0xbe, 0xbe, 0x02, 0x7f, 0xc2, 0xf6, 0x8c, 0xf5, 0xa7, 0x4f, 0x7d, 0xaa, 0x0d, 0xd1, 0x50, 0x15, + /*0bd0:*/ 0xda, 0x9e, 0x94, 0x99, 0x40, 0xb2, 0x40, 0xf3, 0xc7, 0x0f, 0x3f, 0x65, 0x32, 0xd6, 0x87, 0xdc, + /*0be0:*/ 0x54, 0x27, 0xac, 0xd9, 0x5b, 0xa1, 0x8d, 0x7f, 0x7e, 0x6f, 0x71, 0xa0, 0xee, 0x56, 0x2d, 0x58, + /*0bf0:*/ 0x85, 0x1f, 0x59, 0xf0, 0x52, 0xf3, 0x76, 0x46, 0xe0, 0xd6, 0x71, 0xf7, 0xb2, 0x4f, 0xc2, 0xa6, + /*0c00:*/ 0xe6, 0x15, 0xa0, 0x5a, 0x9c, 0x13, 0xbd, 0x46, 0x44, 0xa8, 0xd2, 0x44, 0xf8, 0xec, 0xe4, 0xd1, + /*0c10:*/ 0xa2, 0x9f, 0x5b, 0xda, 0x80, 0x80, 0x37, 0x1e, 0x99, 0xbe, 0xf7, 0x3a, 0xf1, 0xa8, 0x3d, 0x16, + /*0c20:*/ 0x90, 0x5f, 0xb0, 0xa7, 0x04, 0x8d, 0x21, 0xc5, 0xa3, 0x75, 0xaf, 0x7f, 0x54, 0xe5, 0x91, 0xaf, + /*0c30:*/ 0x05, 0xf1, 0xc3, 0xf7, 0x9e, 0xf5, 0x22, 0x31, 0xc9, 0xa9, 0x23, 0x60, 0x18, 0x3f, 0xc2, 0x55, + /*0c40:*/ 0x69, 0xbe, 0x13, 0xc3, 0x22, 0x9c, 0xb7, 0x26, 0x79, 0x06, 0xdf, 0x6e, 0x37, 0x79, 0xd9, 0x88, + /*0c50:*/ 0xdf, 0xb3, 0x21, 0xc0, 0xff, 0x78, 0xdf, 0x0f, 0x58, 0x59, 0x09, 0xc5, 0x48, 0x6a, 0xc4, 0x67, + /*0c60:*/ 0x89, 0x88, 0x8e, 0x22, 0x9a, 0x0e, 0xb2, 0x82, 0x29, 0xb0, 0x2e, 0xd4, 0xaa, 0x7e, 0x82, 0xfa, + /*0c70:*/ 0x58, 0x3e, 0x63, 0x5c, 0x53, 0x6d, 0xbf, 0xbd, 0xe0, 0x68, 0x0a, 0xca, 0x6e, 0x4c, 0xc8, 0x62, + /*0c80:*/ 0xe5, 0x45, 0xa3, 0x1f, 0xf1, 0xe1, 0x0d, 0xee, 0xd2, 0xff, 0xbb, 0x18, 0x80, 0x2e, 0xc0, 0xba, + /*0c90:*/ 0x59, 0xe7, 0x51, 0x1c, 0xf0, 0x26, 0x04, 0x43, 0x7b, 0xc5, 0xec, 0x74, 0x89, 0x27, 0x7c, 0xcf, + /*0ca0:*/ 0x99, 0xbe, 0xe7, 0x7d, 0x5b, 0x2f, 0x4b, 0xa8, 0xae, 0xb9, 0xe9, 0x04, 0xa3, 0x28, 0x9b, 0x60, + /*0cb0:*/ 0x6e, 0x3b, 0x4b, 0x1e, 0x14, 0x02, 0x6b, 0x90, 0x5f, 0x54, 0xa5, 0x8e, 0x29, 0x7f, 0xcc, 0xa2, + /*0cc0:*/ 0x43, 0xd6, 0x19, 0xfc, 0xef, 0x65, 0x3f, 0xff, 0x85, 0xb8, 0xcd, 0x50, 0x17, 0x33, 0x00, 0xce, + /*0cd0:*/ 0x8c, 0xd9, 0xe1, 0x7f, 0x2d, 0x53, 0x2b, 0xe7, 0x6b, 0xe3, 0x38, 0x39, 0xbd, 0x96, 0xe6, 0x1a, + /*0ce0:*/ 0x9b, 0x9a, 0x75, 0xdc, 0x59, 0xd4, 0x7c, 0x90, 0xbd, 0x20, 0x72, 0xa2, 0x6b, 0x34, 0x86, 0x98, + /*0cf0:*/ 0x91, 0xa4, 0xf8, 0xa8, 0xaf, 0x54, 0x8a, 0x0f, 0x0a, 0xcc, 0x3d, 0x9a, 0x26, 0xbe, 0x1d, 0x3f, + /*0d00:*/ 0x8b, 0x32, 0x78, 0x47, 0x2b, 0xb3, 0x12, 0x5f, 0xf2, 0xb8, 0x63, 0x2a, 0xd3, 0x4e, 0xc1, 0xbb, + /*0d10:*/ 0x24, 0x9a, 0xac, 0x8c, 0x34, 0xe3, 0x03, 0x81, 0xbd, 0xdf, 0x5f, 0xae, 0xa4, 0x29, 0x9a, 0x17, + /*0d20:*/ 0x11, 0x31, 0xc7, 0xba, 0xcf, 0xed, 0x48, 0x68, 0x7f, 0x85, 0xfe, 0xdb, 0xfe, 0x50, 0x86, 0xe6, + /*0d30:*/ 0xbb, 0x68, 0x44, 0xa6, 0xb6, 0x5b, 0xe3, 0xf4, 0x84, 0x32, 0x3d, 0x7c, 0x4c, 0xd8, 0xf3, 0xe5, + /*0d40:*/ 0xa0, 0x3b, 0x18, 0x91, 0x7a, 0xe7, 0x56, 0x5f, 0xa1, 0xd6, 0xf0, 0xbf, 0x23, 0xf0, 0x89, 0x26, + /*0d50:*/ 0x03, 0xf8, 0x5e, 0xc6, 0x55, 0xb4, 0x78, 0x25, 0xb1, 0x4b, 0x32, 0x1b, 0xf7, 0x67, 0x37, 0xae, + /*0d60:*/ 0xc6, 0x23, 0x0e, 0x85, 0x90, 0x15, 0x3e, 0x38, 0xb4, 0x42, 0xc0, 0x77, 0xe6, 0x52, 0xa1, 0xc8, + /*0d70:*/ 0x64, 0x96, 0x63, 0x20, 0x14, 0x9c, 0xe8, 0xc8, 0x88, 0x24, 0xa3, 0x40, 0xd1, 0xb2, 0x7f, 0xed, + /*0d80:*/ 0x4a, 0xb8, 0x8e, 0x71, 0x73, 0x58, 0x7d, 0x51, 0x7e, 0xde, 0x58, 0x64, 0x6f, 0xa9, 0x19, 0xa1, + /*0d90:*/ 0x0e, 0x7f, 0x20, 0x6e, 0xfa, 0xfb, 0x9f, 0xc6, 0xd3, 0xc5, 0x4d, 0xd2, 0x1b, 0x5e, 0x8a, 0x14, + /*0da0:*/ 0xb9, 0x6a, 0xcf, 0xf6, 0x2c, 0xa0, 0x85, 0xdd, 0xa4, 0xa1, 0x0d, 0x75, 0xd0, 0x75, 0xa1, 0x07, + /*0db0:*/ 0xf4, 0x45, 0x09, 0x7a, 0xbd, 0x00, 0x03, 0xbd, 0x4c, 0x42, 0x49, 0xb2, 0x3c, 0x09, 0xd8, 0x87, + /*0dc0:*/ 0xfb, 0xa1, 0xc2, 0x1a, 0xd7, 0x16, 0xae, 0x3a, 0x0b, 0x61, 0x4b, 0x34, 0x98, 0x32, 0x77, 0x23, + /*0dd0:*/ 0xc8, 0x0b, 0x8b, 0x81, 0xed, 0xc1, 0x56, 0x8a, 0xcc, 0x79, 0x03, 0x58, 0x01, 0x57, 0xc1, 0x94, + /*0de0:*/ 0x60, 0x2c, 0x0a, 0x56, 0x12, 0xf1, 0xd8, 0xb8, 0xaa, 0x4e, 0xb5, 0x7b, 0xb5, 0xe6, 0x35, 0x1c, + /*0df0:*/ 0x20, 0x87, 0x40, 0x52, 0xd0, 0xe1, 0xf8, 0x59, 0xb3, 0xaf, 0x45, 0x0b, 0xce, 0xb0, 0xf7, 0x48, + /*0e00:*/ 0x3d, 0x60, 0x16, 0xbb, 0x1c, 0x3d, 0xf8, 0x10, 0xba, 0xfa, 0x86, 0x47, 0xb8, 0x9f, 0x89, 0x43, + /*0e10:*/ 0xc9, 0x3f, 0xa7, 0x5f, 0x3b, 0xa6, 0x30, 0x60, 0xce, 0x7a, 0x29, 0x87, 0xf1, 0x38, 0xde, 0x17, + /*0e20:*/ 0x70, 0xc5, 0x10, 0xb9, 0xa4, 0x0e, 0x13, 0x8b, 0xa9, 0x5c, 0x8a, 0xe8, 0x11, 0xfe, 0xf0, 0x0e, + /*0e30:*/ 0x63, 0x22, 0xc5, 0xeb, 0x16, 0x7a, 0x8e, 0xbc, 0x90, 0x54, 0x6e, 0x54, 0x8f, 0x41, 0xb8, 0x13, + /*0e40:*/ 0xe8, 0x2e, 0x7a, 0xaf, 0xf6, 0xcf, 0x11, 0xf8, 0xd8, 0xdf, 0x06, 0x00, 0x76, 0xa3, 0x05, 0x0a, + /*0e50:*/ 0x92, 0x37, 0xb9, 0x87, 0x84, 0x53, 0xfe, 0x6f, 0x27, 0xdc, 0xa0, 0x75, 0xd8, 0x83, 0xa7, 0xa2, + /*0e60:*/ 0x65, 0xa9, 0x45, 0x3f, 0xfe, 0xf2, 0xef, 0x4e, 0xc0, 0xc9, 0x9f, 0x58, 0xa6, 0xfd, 0x62, 0xc8, + /*0e70:*/ 0x69, 0x36, 0xd5, 0xad, 0x64, 0xc1, 0xdb, 0x55, 0x29, 0xe4, 0x37, 0xe8, 0xde, 0x1e, 0x1c, 0x80, + /*0e80:*/ 0x58, 0xb3, 0x31, 0x7a, 0x14, 0xbd, 0xde, 0x3c, 0xf9, 0x64, 0xbb, 0xb4, 0x2d, 0x4e, 0x78, 0x52, + /*0e90:*/ 0xe6, 0xba, 0x90, 0xf7, 0x36, 0xc3, 0x56, 0xaf, 0xf4, 0x06, 0xe3, 0xee, 0x12, 0x3e, 0x35, 0x41, + /*0ea0:*/ 0xcd, 0xe7, 0x3d, 0xec, 0x02, 0x8f, 0x88, 0x23, 0x7e, 0x84, 0x81, 0x24, 0x49, 0x46, 0xe9, 0x4c, + /*0eb0:*/ 0xaf, 0x7c, 0x81, 0x34, 0x63, 0xcd, 0xe0, 0x55, 0xa1, 0xdb, 0x2e, 0x8a, 0xb7, 0x08, 0x89, 0x22, + /*0ec0:*/ 0x01, 0xeb, 0xa8, 0x20, 0x90, 0xc5, 0x43, 0x51, 0xd1, 0x49, 0xa7, 0x80, 0xd8, 0xb3, 0xda, 0xcb, + /*0ed0:*/ 0x06, 0x68, 0x27, 0x0f, 0x8b, 0xc5, 0x85, 0x19, 0x8b, 0x72, 0x7f, 0x9c, 0x01, 0x9e, 0x9c, 0x89, + /*0ee0:*/ 0xb2, 0x95, 0xe0, 0xcb, 0x15, 0xd8, 0xc7, 0x60, 0x48, 0x93, 0x24, 0x18, 0x78, 0xc0, 0x8b, 0x40, + /*0ef0:*/ 0x5a, 0x2f, 0xe9, 0xc9, 0xc4, 0xec, 0xb3, 0x26, 0xb5, 0xdf, 0x88, 0x1b, 0xf3, 0x4f, 0x0e, 0xe4, + /*0f00:*/ 0xc0, 0x7c, 0x07, 0xf1, 0xcd, 0xa6, 0xb2, 0x8e, 0x53, 0x74, 0x42, 0x89, 0xb5, 0x8c, 0xa7, 0xcc, + /*0f10:*/ 0x22, 0x2a, 0x15, 0x6c, 0xc8, 0x45, 0xdf, 0x88, 0xbc, 0xec, 0x64, 0xea, 0x73, 0x22, 0xde, 0xe4, + /*0f20:*/ 0xb1, 0x55, 0x66, 0x37, 0xbc, 0x8d, 0x67, 0x60, 0x13, 0xcb, 0xc2, 0x3e, 0xe1, 0x5f, 0x9c, 0x90, + /*0f30:*/ 0xc8, 0xa5, 0x8e, 0x70, 0x48, 0xf3, 0xcd, 0xcf, 0x3b, 0x73, 0xfc, 0x98, 0x0f, 0xa0, 0x2e, 0x6e, + /*0f40:*/ 0x53, 0xfc, 0xcb, 0xd9, 0x2e, 0x7e, 0x9e, 0x2f, 0x66, 0x23, 0xd4, 0xe3, 0xb5, 0xda, 0xb0, 0xef, + /*0f50:*/ 0x7c, 0x28, 0xc4, 0xe3, 0x6b, 0xeb, 0x28, 0x06, 0x83, 0xcd, 0x58, 0xd1, 0xa4, 0x08, 0x73, 0x36, + /*0f60:*/ 0x7d, 0x87, 0xdf, 0x67, 0x72, 0x23, 0x8a, 0x8d, 0xce, 0x4d, 0xcd, 0x95, 0x7e, 0xec, 0x8e, 0x9e, + /*0f70:*/ 0x0c, 0x21, 0x09, 0x89, 0x4b, 0x2e, 0x86, 0xd7, 0x1b, 0x7e, 0xbc, 0x67, 0x17, 0x4d, 0x18, 0xa7, + /*0f80:*/ 0xba, 0xca, 0x25, 0x30, 0x2d, 0x72, 0xb1, 0xfe, 0x49, 0xd9, 0xdc, 0x54, 0x8e, 0x81, 0x47, 0x50, + /*0f90:*/ 0x03, 0x95, 0xb4, 0xb6, 0x37, 0x36, 0xeb, 0xc4, 0xc3, 0x9d, 0x90, 0xaf, 0x24, 0x03, 0x6d, 0x78, + /*0fa0:*/ 0x35, 0x12, 0x17, 0x64, 0xb3, 0xb5, 0x20, 0xf5, 0xc6, 0xc1, 0xd2, 0xdd, 0xa8, 0x5f, 0xdb, 0xc8, + /*0fb0:*/ 0xc2, 0xa9, 0xbd, 0x38, 0x9a, 0xc2, 0x75, 0x29, 0xca, 0xb2, 0x5f, 0x02, 0x9d, 0x02, 0x25, 0x12, + /*0fc0:*/ 0x2a, 0x90, 0x56, 0x93, 0x1b, 0xcd, 0x5c, 0x75, 0x73, 0xdc, 0xeb, 0x03, 0x62, 0x52, 0x02, 0x6d, + /*0fd0:*/ 0x14, 0x20, 0xeb, 0x16, 0x2a, 0x08, 0x1c, 0x0f, 0xbb, 0x36, 0x0a, 0x0a, 0x9f, 0x44, 0x1c, 0xb5, + /*0fe0:*/ 0xb7, 0x60, 0x82, 0xcc, 0x33, 0xa0, 0x53, 0xb3, 0xb7, 0xe5, 0xc5, 0x9a, 0xb7, 0xa3, 0xf2, 0x2e, + /*0ff0:*/ 0x85, 0x8b, 0xc9, 0x5c, 0xe9, 0x22, 0x82, 0xb1, 0x23, 0x7f, 0x39, 0xf6, 0xd8, 0x6e, 0x1a, 0xb4, + /*1000:*/ 0xb8, 0xe2, 0x6f, 0x88, 0xe1, 0x34, 0x48, 0x15, 0xb1, 0x37, 0x42, 0x64, 0xe1, 0xb6, 0xc6, 0x7a, + /*1010:*/ 0x21, 0x55, 0x20, 0x11, 0x29, 0x1b, 0xc3, 0x81, 0x1e, 0x43, 0x28, 0xb0, 0x2c, 0x0c, 0x71, 0x04, + /*1020:*/ 0x24, 0xde, 0xbb, 0x81, 0xac, 0xb7, 0xb5, 0xda, 0xf9, 0x85, 0x78, 0x2c, 0xdb, 0xfb, 0x1f, 0xed, + /*1030:*/ 0x95, 0xd6, 0x67, 0x04, 0xa7, 0xde, 0xc4, 0x00, 0x6a, 0xf4, 0x97, 0xe6, 0xa5, 0x46, 0x9f, 0x42, + /*1040:*/ 0x68, 0x79, 0xea, 0xcd, 0xfa, 0xb1, 0xb0, 0x97, 0xfc, 0x78, 0xc3, 0xa8, 0xcc, 0xdd, 0x09, 0x9b, + /*1050:*/ 0x93, 0x5b, 0x0a, 0xd2, 0xe4, 0x42, 0x98, 0x61, 0xbe, 0xa2, 0xbe, 0x8f, 0xf4, 0x1f, 0x1a, 0xeb, + /*1060:*/ 0xda, 0x59, 0x1e, 0xe5, 0x8e, 0x41, 0x3c, 0x96, 0x14, 0xb9, 0xb0, 0x16, 0x07, 0x38, 0xa4, 0xc9, + /*1070:*/ 0xb3, 0xff, 0xb4, 0xf1, 0xed, 0xe7, 0xe5, 0x4e, 0x21, 0x90, 0x5f, 0x35, 0x6e, 0x9f, 0xfb, 0xd3, + /*1080:*/ 0x57, 0x86, 0x12, 0xe1, 0xde, 0x74, 0x33, 0xe5, 0xf3, 0x29, 0x3f, 0xe6, 0x49, 0x30, 0xae, 0xaa, + /*1090:*/ 0x62, 0xaf, 0xd5, 0x1f, 0xc8, 0xca, 0x4f, 0xea, 0x00, 0xda, 0x4e, 0xba, 0x21, 0x5f, 0xeb, 0x85, + /*10a0:*/ 0xa9, 0x77, 0xce, 0x2e, 0x98, 0xa5, 0xa0, 0x22, 0x12, 0x9f, 0x15, 0xaa, 0x25, 0xd9, 0x65, 0x03, + /*10b0:*/ 0x7b, 0xda, 0x3e, 0x29, 0xb1, 0x94, 0x5f, 0x9b, 0x7d, 0x0e, 0xf0, 0xe3, 0x29, 0x95, 0xef, 0xc5, + /*10c0:*/ 0x0b, 0x97, 0x61, 0x8b, 0xa2, 0x03, 0xe1, 0x33, 0x76, 0x0c, 0xb7, 0xe6, 0xaa, 0x4d, 0x66, 0xc1, + /*10d0:*/ 0x5c, 0x9c, 0xa9, 0x36, 0xef, 0xda, 0xe4, 0xad, 0xed, 0xbf, 0x93, 0x9a, 0xdd, 0xa4, 0x52, 0xcb, + /*10e0:*/ 0x5f, 0xdb, 0x61, 0x82, 0xfe, 0x77, 0x86, 0x28, 0x33, 0x3d, 0x90, 0xbb, 0x86, 0x6a, 0xb3, 0x15, + /*10f0:*/ 0x2f, 0x91, 0xfe, 0x99, 0x18, 0xb9, 0xe9, 0x47, 0x27, 0xfe, 0x78, 0x07, 0x33, 0xa0, 0x96, 0xb8, + /*1100:*/ 0x06, 0x09, 0x74, 0xad, 0x1a, 0x75, 0x49, 0xbe, 0x35, 0xe9, 0x18, 0x1a, 0x79, 0x31, 0x9f, 0xf2, + /*1110:*/ 0x35, 0x4f, 0xa9, 0xf4, 0xfa, 0x64, 0x20, 0xbb, 0x0d, 0x65, 0x1f, 0x80, 0x5b, 0x8d, 0x83, 0xca, + /*1120:*/ 0x2a, 0x42, 0xea, 0x84, 0x15, 0x6e, 0xd3, 0xbb, 0x51, 0xe5, 0x65, 0x95, 0x44, 0x09, 0x56, 0x50, + /*1130:*/ 0x53, 0x8f, 0xbb, 0xd9, 0xf7, 0x5d, 0xc9, 0xdf, 0x16, 0x95, 0xa6, 0x8a, 0x22, 0x29, 0xd9, 0x00, + /*1140:*/ 0xcf, 0x55, 0xab, 0xc8, 0x90, 0x96, 0x8f, 0x07, 0xdd, 0x0b, 0x40, 0xb6, 0xde, 0xd3, 0x1d, 0x96, + /*1150:*/ 0x58, 0xff, 0x89, 0x25, 0xfb, 0x2d, 0x0c, 0xcc, 0x05, 0xb4, 0xe9, 0x47, 0x60, 0xeb, 0xb4, 0xe2, + /*1160:*/ 0x24, 0x99, 0xb9, 0xf1, 0x88, 0xba, 0x1e, 0xd3, 0x16, 0xa7, 0x6e, 0x44, 0x48, 0x57, 0x90, 0x04, + /*1170:*/ 0x37, 0x94, 0xd3, 0x42, 0x1c, 0xbd, 0x51, 0x2c, 0x0d, 0x4f, 0x71, 0xf8, 0x98, 0x71, 0x16, 0x48, + /*1180:*/ 0x53, 0x2b, 0x62, 0x90, 0x21, 0xc3, 0xbf, 0xf4, 0x83, 0x11, 0xb5, 0xd4, 0xc7, 0xe4, 0x73, 0x65, + /*1190:*/ 0xed, 0x01, 0x49, 0xf2, 0xb1, 0x1b, 0xb8, 0x6c, 0xce, 0x55, 0xe1, 0xa7, 0x58, 0xf0, 0x2f, 0x24, + /*11a0:*/ 0xf5, 0xc1, 0x26, 0x02, 0x78, 0x66, 0x48, 0x7d, 0x2f, 0xb9, 0x81, 0x4b, 0xac, 0x73, 0x6d, 0x0d, + /*11b0:*/ 0xfd, 0xe6, 0x27, 0xa8, 0x3a, 0xcd, 0x35, 0x4d, 0xa4, 0xc8, 0xf7, 0xb5, 0x2c, 0xa0, 0xa6, 0x4a, + /*11c0:*/ 0x57, 0xb8, 0x62, 0xb3, 0xd7, 0xd4, 0x2a, 0xa9, 0xa5, 0x93, 0x5b, 0x23, 0x0f, 0x88, 0xb3, 0x69, + /*11d0:*/ 0xd2, 0x89, 0x21, 0x66, 0x9c, 0x4a, 0x40, 0xce, 0x22, 0x0d, 0xcf, 0xff, 0x1b, 0x60, 0xae, 0xff, + /*11e0:*/ 0x10, 0xb0, 0xfb, 0x5c, 0x02, 0x26, 0x72, 0x3d, 0xb1, 0x9b, 0x7e, 0xab, 0x18, 0xba, 0x0a, 0x49, + /*11f0:*/ 0xf0, 0x1f, 0xfd, 0x53, 0xa7, 0x96, 0xe8, 0xf7, 0xde, 0xab, 0xf0, 0x72, 0xce, 0x21, 0xb9, 0xb9, + /*1200:*/ 0x8f, 0x14, 0xb5, 0x13, 0x37, 0x61, 0x72, 0x73, 0xa3, 0xca, 0x5c, 0x63, 0x60, 0xe4, 0x99, 0xd5, + /*1210:*/ 0x6f, 0x38, 0x72, 0x7e, 0xa4, 0xf6, 0xc9, 0xb7, 0xc4, 0x66, 0xd9, 0xdd, 0x50, 0x2c, 0x56, 0x21, + /*1220:*/ 0x66, 0x3f, 0x3b, 0xc4, 0x28, 0x50, 0x87, 0x9b, 0x2f, 0xec, 0x71, 0xd8, 0x3a, 0x1b, 0x71, 0x97, + /*1230:*/ 0x2d, 0xf3, 0x59, 0xdf, 0x3d, 0xc6, 0x22, 0x44, 0xa2, 0xf0, 0x8f, 0xed, 0x6a, 0x11, 0x03, 0x49, + /*1240:*/ 0x8f, 0x86, 0x98, 0xc7, 0x34, 0xc6, 0x20, 0x1f, 0x96, 0x39, 0x2e, 0x6e, 0xa3, 0x5f, 0x26, 0x17, + /*1250:*/ 0xaf, 0x24, 0x7a, 0x70, 0x3d, 0x23, 0x30, 0x97, 0x4d, 0xf5, 0x9c, 0x9c, 0xfe, 0x64, 0x15, 0x99, + /*1260:*/ 0xee, 0x9e, 0xb1, 0x85, 0x28, 0xe8, 0xcd, 0xc8, 0x3a, 0x5e, 0x8f, 0x0c, 0x20, 0x48, 0x56, 0x62, + /*1270:*/ 0x88, 0xf8, 0x70, 0x0c, 0xee, 0x60, 0x12, 0xbf, 0xee, 0xa8, 0x94, 0xe6, 0x03, 0x10, 0x1f, 0x6e, + /*1280:*/ 0x5c, 0x60, 0x27, 0x5e, 0x64, 0xa3, 0x65, 0x88, 0xe6, 0x65, 0x53, 0xc3, 0xe8, 0x9c, 0xd5, 0xc6, + /*1290:*/ 0xe5, 0x55, 0x19, 0xdc, 0xc6, 0x9f, 0x80, 0x65, 0x35, 0x32, 0xea, 0xd1, 0xb4, 0x4f, 0xf8, 0x0b, + /*12a0:*/ 0xc5, 0x53, 0x74, 0x61, 0x01, 0xb6, 0x0b, 0x60, 0x46, 0x54, 0xd7, 0x21, 0x7e, 0x90, 0xc5, 0x7e, + /*12b0:*/ 0x38, 0xd6, 0x5c, 0x70, 0x02, 0x44, 0x35, 0xc9, 0x83, 0xb6, 0x7b, 0x47, 0xb6, 0xb8, 0x22, 0x39, + /*12c0:*/ 0x87, 0x10, 0xe0, 0x72, 0xec, 0x04, 0x86, 0x62, 0xfe, 0xb8, 0xf3, 0x2d, 0x63, 0x39, 0xd0, 0x6f, + /*12d0:*/ 0x23, 0x80, 0xc1, 0x51, 0xd5, 0xeb, 0x4a, 0x8d, 0x03, 0xce, 0xb9, 0xf1, 0x59, 0x13, 0x6f, 0xc8, + /*12e0:*/ 0x03, 0x64, 0x6e, 0x1b, 0x8b, 0x24, 0xe0, 0x91, 0x0b, 0xbb, 0x9d, 0x34, 0x13, 0x42, 0xf6, 0xd4, + /*12f0:*/ 0x0c, 0xe9, 0xb9, 0x4c, 0x5b, 0xb5, 0xd0, 0x18, 0x11, 0x80, 0x78, 0x1c, 0xfc, 0x89, 0xe8, 0xb2, + /*1300:*/ 0xde, 0xf7, 0x01, 0x2a, 0x07, 0x39, 0x8f, 0x4e, 0x34, 0xce, 0xf8, 0xd1, 0x86, 0x44, 0x02, 0xc4, + /*1310:*/ 0x3e, 0xd7, 0x8e, 0x49, 0x2e, 0x84, 0x86, 0x6d, 0x4f, 0x67, 0xbf, 0x80, 0x2d, 0xe2, 0x5a, 0x1b, + /*1320:*/ 0xed, 0xbe, 0xd2, 0x41, 0x25, 0x78, 0x53, 0x1c, 0x04, 0xa8, 0x2f, 0x9c, 0x4e, 0xaf, 0x8c, 0x97, + /*1330:*/ 0x38, 0xac, 0x56, 0xd9, 0x81, 0x08, 0x91, 0x0c, 0xf0, 0x20, 0xdb, 0x0a, 0x68, 0x87, 0x3f, 0x44, + /*1340:*/ 0xd5, 0xee, 0xb1, 0x04, 0x09, 0x42, 0x86, 0xd2, 0x5c, 0xd9, 0xa9, 0x6d, 0x52, 0x68, 0xd9, 0x29, + /*1350:*/ 0x82, 0x42, 0xbb, 0x2a, 0xc9, 0x7e, 0x9b, 0x8f, 0x57, 0xcf, 0x90, 0xf0, 0x7e, 0xd6, 0x42, 0xef, + /*1360:*/ 0xd2, 0xf4, 0xbe, 0xae, 0x6e, 0xdb, 0x71, 0xe5, 0xb8, 0xe0, 0x11, 0x20, 0x8b, 0xfd, 0x96, 0x59, + /*1370:*/ 0x48, 0x94, 0x49, 0xf0, 0x3d, 0x37, 0xa7, 0xa4, 0x7d, 0x5e, 0x93, 0x0b, 0x55, 0x92, 0x7a, 0x69, + /*1380:*/ 0xdc, 0x9f, 0xb5, 0x0e, 0xe7, 0x4a, 0x60, 0x3f, 0x44, 0x6a, 0x93, 0x52, 0x6a, 0x6f, 0x18, 0xf9, + /*1390:*/ 0xda, 0x98, 0x94, 0x38, 0xb7, 0x45, 0x4a, 0xcf, 0xb1, 0xc5, 0xf7, 0x03, 0x39, 0x8a, 0x21, 0x07, + /*13a0:*/ 0xb1, 0x3f, 0x53, 0x5a, 0xde, 0xde, 0xee, 0xf5, 0xbd, 0x1d, 0xb3, 0xea, 0xa2, 0x0e, 0x0c, 0xe4, + /*13b0:*/ 0xd2, 0x25, 0x45, 0xc5, 0x29, 0xfa, 0x9e, 0x3a, 0x75, 0x8a, 0x75, 0x3e, 0x3b, 0x8e, 0x82, 0xea, + /*13c0:*/ 0xef, 0x7e, 0x1e, 0x4c, 0xb4, 0x26, 0x15, 0x19, 0x82, 0x40, 0x12, 0xe1, 0x04, 0x4c, 0x48, 0x24, + /*13d0:*/ 0xad, 0xed, 0x4b, 0xe8, 0xc5, 0x0c, 0x15, 0x91, 0x22, 0x7f, 0xb5, 0xd0, 0x9e, 0x73, 0x6e, 0x59, + /*13e0:*/ 0xd0, 0xfb, 0x26, 0xb2, 0x2a, 0x60, 0xdb, 0x1c, 0xd0, 0x86, 0xd6, 0x7d, 0xdd, 0xfe, 0x64, 0x1c, + /*13f0:*/ 0xd2, 0xb1, 0x9e, 0x73, 0xeb, 0x5b, 0x99, 0x4b, 0x13, 0x14, 0xc2, 0xf3, 0x20, 0xdf, 0x55, 0xc1, + /*1400:*/ 0x57, 0xf2, 0x13, 0x0f, 0xc9, 0x8f, 0xa1, 0x7e, 0x94, 0x1f, 0xff, 0xf6, 0x78, 0x8c, 0x46, 0xf9, + /*1410:*/ 0xd1, 0x99, 0xa3, 0xe9, 0xe8, 0x0e, 0x97, 0x00, 0xde, 0x34, 0xd9, 0x14, 0xd7, 0x1e, 0xa4, 0x83, + /*1420:*/ 0x39, 0xa9, 0xda, 0x7c, 0x47, 0x54, 0x40, 0x45, 0x13, 0x49, 0x55, 0x7d, 0x00, 0x79, 0xb0, 0x00, + /*1430:*/ 0x32, 0x1b, 0x3b, 0x53, 0xc9, 0x96, 0x1c, 0xb4, 0xb3, 0xac, 0xaa, 0x67, 0xbb, 0x42, 0xaa, 0xcf, + /*1440:*/ 0x81, 0x08, 0x5a, 0x56, 0x3e, 0x0e, 0x41, 0x18, 0xdb, 0xe7, 0x99, 0xd0, 0x0e, 0xe9, 0x40, 0x1b, + /*1450:*/ 0xc7, 0x6a, 0x57, 0x12, 0x89, 0x64, 0xb6, 0x1d, 0xd1, 0xd6, 0x04, 0xa5, 0xa1, 0xb0, 0xe9, 0x46, + /*1460:*/ 0x32, 0x88, 0x9b, 0x39, 0x06, 0xab, 0x4f, 0xef, 0xef, 0x49, 0xfb, 0x42, 0x58, 0x01, 0xcc, 0x29, + /*1470:*/ 0x53, 0x06, 0xc7, 0xb2, 0x09, 0x63, 0xff, 0xd3, 0x7d, 0xb3, 0xbb, 0x54, 0xd3, 0x2c, 0x7e, 0x4b, + /*1480:*/ 0xf8, 0x05, 0x7e, 0xb3, 0x55, 0x38, 0xc9, 0x92, 0x15, 0x12, 0xd4, 0xde, 0x38, 0x29, 0x8d, 0xcf, + /*1490:*/ 0xaa, 0xc4, 0x88, 0x61, 0x36, 0x34, 0x95, 0x3c, 0x48, 0xfb, 0xec, 0x5e, 0xdf, 0x72, 0x83, 0xff, + /*14a0:*/ 0xe7, 0x8f, 0x72, 0x1a, 0xaf, 0xa8, 0xef, 0xbf, 0xbe, 0xb7, 0x57, 0xa8, 0xa4, 0xe0, 0x80, 0x2a, + /*14b0:*/ 0x45, 0x3a, 0xf0, 0x80, 0x5d, 0xd5, 0x3a, 0x3c, 0x03, 0x77, 0x66, 0xd1, 0x46, 0xb0, 0x92, 0x2e, + /*14c0:*/ 0x54, 0xce, 0xe5, 0x08, 0x00, 0xfd, 0x84, 0xf0, 0x0d, 0x2f, 0xd9, 0x9b, 0x73, 0x31, 0x40, 0x53, + /*14d0:*/ 0x66, 0x2d, 0xd1, 0x84, 0xc8, 0xfe, 0x1a, 0xdf, 0xd4, 0x4a, 0x80, 0x30, 0x56, 0xc3, 0x26, 0x3b, + /*14e0:*/ 0x61, 0xde, 0x37, 0x34, 0x08, 0xbd, 0x40, 0xd8, 0x5e, 0xdf, 0x45, 0xf4, 0xe4, 0x2b, 0xf7, 0x4b, + /*14f0:*/ 0x8f, 0xf5, 0xa7, 0x70, 0x50, 0x25, 0x48, 0x18, 0xfd, 0x1a, 0xb5, 0xfd, 0xf2, 0x6a, 0xb4, 0x1b, + /*1500:*/ 0x44, 0xd5, 0x3f, 0x59, 0x23, 0x4b, 0x96, 0x7e, 0x72, 0x3a, 0xf1, 0x6e, 0x13, 0x40, 0x7b, 0x17, + /*1510:*/ 0x20, 0x09, 0xf2, 0x09, 0xb7, 0x77, 0xd3, 0x4e, 0x21, 0xbf, 0xac, 0x16, 0x2c, 0x9c, 0x95, 0x17, + /*1520:*/ 0xd1, 0x4b, 0x55, 0x00, 0x8a, 0xff, 0x4e, 0x25, 0x59, 0xba, 0xad, 0x4c, 0xf9, 0x17, 0xce, 0xec, + /*1530:*/ 0x1e, 0xdd, 0xfb, 0xb0, 0x4f, 0x5d, 0xca, 0xe8, 0x29, 0xb1, 0xba, 0x5e, 0x77, 0x2c, 0xf2, 0xa3, + /*1540:*/ 0x26, 0x86, 0x39, 0x86, 0x9d, 0xa4, 0xd5, 0x0a, 0x94, 0xea, 0xbf, 0x39, 0xc4, 0x21, 0x4c, 0xd7, + /*1550:*/ 0x5f, 0xdb, 0xdd, 0x10, 0x14, 0x81, 0x45, 0x36, 0xe4, 0xe5, 0xcc, 0x84, 0x8f, 0x8c, 0xa3, 0xee, + /*1560:*/ 0x23, 0x0e, 0x1c, 0xf9, 0x23, 0xa7, 0x48, 0xac, 0x69, 0xfc, 0x09, 0x30, 0xf6, 0x2c, 0x44, 0x04, + /*1570:*/ 0xe7, 0x3f, 0xc1, 0xeb, 0xb7, 0x28, 0x1b, 0x1f, 0xe0, 0x47, 0x54, 0x41, 0xf8, 0x4f, 0x6c, 0xb4, + /*1580:*/ 0xb3, 0x23, 0x1f, 0x7c, 0xb2, 0xfc, 0x96, 0x1a, 0xf1, 0x37, 0x28, 0x66, 0xf8, 0xa8, 0x6b, 0xe1, + /*1590:*/ 0x4b, 0xb5, 0x61, 0xf2, 0xd2, 0xa7, 0x8c, 0xfc, 0x24, 0x3e, 0x4e, 0xc7, 0x00, 0xd4, 0x20, 0x06, + /*15a0:*/ 0x1f, 0xe3, 0x48, 0xe5, 0x95, 0x2c, 0xa7, 0x10, 0x55, 0x5f, 0xe2, 0x51, 0x8d, 0x80, 0x7c, 0x2d, + /*15b0:*/ 0x86, 0x05, 0x1e, 0x95, 0xd1, 0x19, 0xe1, 0xe9, 0x1f, 0x94, 0x26, 0x82, 0x57, 0x8b, 0x63, 0xd2, + /*15c0:*/ 0xa7, 0xff, 0xb1, 0x5a, 0x82, 0x87, 0xd2, 0xc6, 0x1a, 0x01, 0xa2, 0xa6, 0xe9, 0xc1, 0x09, 0xb7, + /*15d0:*/ 0xc1, 0x00, 0x92, 0xdf, 0x2a, 0xee, 0xb7, 0xb0, 0x89, 0xf5, 0x23, 0x24, 0xac, 0xf3, 0xc9, 0xfc, + /*15e0:*/ 0xd2, 0x26, 0xdc, 0x0b, 0xf4, 0x00, 0xbb, 0x39, 0x74, 0xe8, 0x31, 0xa2, 0xbb, 0x5b, 0x79, 0xcd, + /*15f0:*/ 0x09, 0x89, 0x45, 0x29, 0xba, 0xee, 0x42, 0x5c, 0x38, 0xa1, 0xd2, 0x94, 0xaa, 0x26, 0x31, 0x6d, + /*1600:*/ 0x74, 0xec, 0xb0, 0xdb, 0xfc, 0x70, 0x70, 0xf3, 0x3e, 0xa2, 0x5f, 0xef, 0xab, 0xbc, 0x2c, 0xc2, + /*1610:*/ 0x17, 0xc9, 0x3b, 0xd0, 0xba, 0xf9, 0x4a, 0x54, 0x43, 0x8e, 0xc7, 0x96, 0x1c, 0x66, 0x0e, 0x25, + /*1620:*/ 0xb6, 0x62, 0x08, 0x51, 0x57, 0x1f, 0x5d, 0xfa, 0x16, 0x8b, 0x14, 0x06, 0x20, 0x01, 0x79, 0xda, + /*1630:*/ 0xc9, 0x41, 0x59, 0x33, 0x38, 0xb6, 0x92, 0xe9, 0xea, 0x6d, 0x03, 0x75, 0x86, 0xa1, 0x6f, 0xb7, + /*1640:*/ 0x15, 0xe2, 0xa4, 0x48, 0x7d, 0xa3, 0x89, 0x72, 0x38, 0xfc, 0xab, 0x06, 0xac, 0x9e, 0xc7, 0xa0, + /*1650:*/ 0x94, 0x51, 0x5c, 0x7a, 0xea, 0x80, 0xc8, 0x7d, 0xf6, 0x7d, 0xbf, 0x42, 0xdb, 0x04, 0x62, 0x9e, + /*1660:*/ 0xba, 0x05, 0x1f, 0xaa, 0x94, 0x62, 0xfc, 0x83, 0xa2, 0x96, 0x71, 0xe5, 0x89, 0x70, 0xc1, 0x17, + /*1670:*/ 0x25, 0xd3, 0x40, 0x0d, 0x25, 0x25, 0x19, 0xb8, 0x13, 0xba, 0x50, 0x30, 0xab, 0x97, 0x0d, 0x3c, + /*1680:*/ 0x73, 0xa5, 0x86, 0xa7, 0x37, 0x99, 0xa8, 0xff, 0x37, 0xeb, 0x1a, 0xca, 0x80, 0xe9, 0xda, 0xb6, + /*1690:*/ 0x1c, 0xbc, 0x29, 0x6f, 0x96, 0x50, 0x28, 0xd1, 0x63, 0x17, 0x1b, 0xb4, 0xfa, 0x3c, 0x9b, 0x30, + /*16a0:*/ 0xa2, 0xe2, 0x76, 0x5d, 0x6e, 0x07, 0xef, 0xb2, 0x20, 0x83, 0x26, 0x13, 0x1d, 0xd0, 0x35, 0x17, + /*16b0:*/ 0x49, 0xf8, 0x38, 0x88, 0xeb, 0x18, 0xd1, 0x8f, 0x54, 0x96, 0x70, 0x42, 0x4c, 0x7c, 0x42, 0x21, + /*16c0:*/ 0xba, 0x4a, 0xb5, 0xc0, 0x07, 0xee, 0x00, 0xe4, 0x0f, 0x9c, 0xe5, 0x57, 0xaf, 0x18, 0x38, 0x0c, + /*16d0:*/ 0x0e, 0x08, 0x61, 0x76, 0xb8, 0xf4, 0x91, 0x73, 0xa3, 0xab, 0x54, 0x8c, 0x84, 0x4e, 0xff, 0xee, + /*16e0:*/ 0x36, 0x1c, 0x95, 0x31, 0x29, 0x6b, 0x52, 0xeb, 0x77, 0x78, 0xed, 0x17, 0x00, 0xbf, 0x71, 0x4a, + /*16f0:*/ 0x44, 0x5f, 0xfe, 0xb1, 0x14, 0xe5, 0xf2, 0xa5, 0x25, 0x4d, 0x90, 0x61, 0x97, 0x83, 0x27, 0xff, + /*1700:*/ 0xa9, 0x04, 0xd2, 0xcc, 0xfe, 0xae, 0xf0, 0x31, 0x90, 0x2d, 0xcb, 0xea, 0x8e, 0xd9, 0xbf, 0x66, + /*1710:*/ 0x32, 0xbb, 0x23, 0xf5, 0x97, 0xf7, 0xf4, 0x00, 0xd9, 0x18, 0xf7, 0x49, 0xc8, 0x6c, 0xb7, 0xa7, + /*1720:*/ 0xb4, 0x94, 0x25, 0x8d, 0xe6, 0xfc, 0x04, 0x70, 0x52, 0x8a, 0x3c, 0x73, 0x83, 0x54, 0xd6, 0x80, + /*1730:*/ 0x78, 0x17, 0xb8, 0xe8, 0xf1, 0x81, 0x5c, 0xc9, 0x02, 0x81, 0xe2, 0x79, 0x28, 0xa1, 0x2a, 0x1a, + /*1740:*/ 0x88, 0xa5, 0xcf, 0x00, 0x69, 0xeb, 0xff, 0x47, 0x24, 0x37, 0x3c, 0x61, 0x9e, 0x8a, 0xa9, 0x5e, + /*1750:*/ 0xc7, 0xe6, 0xe3, 0x39, 0x39, 0x5e, 0x24, 0x8e, 0x47, 0x2d, 0x86, 0x37, 0x3c, 0xfd, 0x4b, 0xf2, + /*1760:*/ 0xfd, 0x16, 0xa7, 0x3f, 0x0c, 0x90, 0x99, 0x81, 0x91, 0x98, 0x76, 0x8e, 0xd9, 0xc4, 0x87, 0x9c, + /*1770:*/ 0x5e, 0xaa, 0x8f, 0xa1, 0x12, 0xc8, 0x7a, 0x55, 0x63, 0x43, 0x80, 0x38, 0xa5, 0x92, 0x51, 0x20, + /*1780:*/ 0x74, 0x98, 0xb3, 0x05, 0xc8, 0xf1, 0xae, 0xe1, 0xf8, 0x7c, 0x73, 0x63, 0xe7, 0x6c, 0x70, 0x43, + /*1790:*/ 0x1a, 0xed, 0x1c, 0xd5, 0x44, 0x7f, 0x89, 0x4f, 0x92, 0x38, 0x02, 0x05, 0x8d, 0x1e, 0x71, 0x44, + /*17a0:*/ 0x31, 0x10, 0xc9, 0xae, 0xb0, 0x6e, 0x62, 0xd3, 0xd6, 0x00, 0x99, 0xa7, 0x1b, 0x81, 0xc2, 0x4f, + /*17b0:*/ 0x81, 0x5c, 0xf3, 0x30, 0xe6, 0x80, 0xc2, 0xa7, 0x1c, 0x42, 0xbb, 0x61, 0xd9, 0xd2, 0x0d, 0xe2, + /*17c0:*/ 0xc3, 0xd1, 0x9c, 0x28, 0xda, 0xb4, 0x62, 0x8b, 0x48, 0x56, 0x97, 0x08, 0x23, 0x94, 0x96, 0xa3, + /*17d0:*/ 0x98, 0x66, 0x39, 0x36, 0xd3, 0xb5, 0x67, 0x0c, 0x01, 0x3c, 0x12, 0xda, 0xc9, 0x42, 0x25, 0x47, + /*17e0:*/ 0xeb, 0x29, 0xe5, 0x53, 0xc8, 0x12, 0x98, 0x44, 0x6f, 0x73, 0x4f, 0x7c, 0x5f, 0xcd, 0x69, 0x02, + /*17f0:*/ 0x5b, 0x3c, 0xad, 0xc9, 0xcb, 0xd4, 0xe5, 0x8d, 0x5c, 0x73, 0xa0, 0x9d, 0x51, 0xf4, 0x99, 0x19, + /*1800:*/ 0xe1, 0xe0, 0x22, 0xcf, 0x00, 0xbd, 0x63, 0xab, 0xd7, 0x9b, 0xb6, 0x2a, 0xdd, 0xa1, 0x1e, 0x3d, + /*1810:*/ 0x19, 0xe0, 0x63, 0x6f, 0x3f, 0xf6, 0x4a, 0x70, 0xd8, 0x6d, 0x73, 0xa7, 0x88, 0xbc, 0xcd, 0x7d, + /*1820:*/ 0xae, 0xe2, 0xe4, 0x2b, 0x63, 0x44, 0x29, 0x83, 0xfc, 0x3b, 0x69, 0x9f, 0x11, 0x8e, 0xee, 0xf5, + /*1830:*/ 0xb0, 0x38, 0xd2, 0x71, 0xe3, 0x90, 0xde, 0x04, 0x81, 0x29, 0xbf, 0xc7, 0x4d, 0xb9, 0xf2, 0x29, + /*1840:*/ 0x57, 0xc3, 0xa5, 0x41, 0x3f, 0x1b, 0x70, 0xec, 0x48, 0x97, 0xee, 0xb9, 0xce, 0xfd, 0xbb, 0x74, + /*1850:*/ 0x12, 0xf4, 0x57, 0x4b, 0x44, 0xcd, 0x6c, 0xdd, 0xd6, 0xd5, 0x0f, 0xa0, 0xc9, 0x40, 0x52, 0x8f, + /*1860:*/ 0x8c, 0x22, 0x4e, 0xb2, 0x3c, 0x12, 0x5a, 0x13, 0x1f, 0x24, 0xcc, 0xb8, 0xd2, 0xa6, 0xb4, 0xe1, + /*1870:*/ 0x22, 0x71, 0x96, 0x48, 0xf3, 0x08, 0xd5, 0x55, 0x20, 0x71, 0x1e, 0x9b, 0x51, 0x56, 0xf3, 0x81, + /*1880:*/ 0x3f, 0x3b, 0x4c, 0xe7, 0x67, 0xa4, 0x24, 0x1c, 0x84, 0x4d, 0x57, 0xd7, 0x33, 0x2d, 0xb2, 0x3e, + /*1890:*/ 0xff, 0xe4, 0x42, 0xbb, 0x37, 0x4b, 0x5c, 0x71, 0xf0, 0xd8, 0x5a, 0xc8, 0xcb, 0xbc, 0x46, 0x60, + /*18a0:*/ 0x4e, 0x33, 0x9e, 0x9b, 0x02, 0x83, 0xf7, 0x65, 0x61, 0x14, 0x69, 0xd5, 0x9d, 0x78, 0xef, 0x44, + /*18b0:*/ 0x79, 0xf3, 0x5c, 0xf9, 0xab, 0x9b, 0x6b, 0x93, 0x12, 0x7a, 0x2d, 0x1d, 0xab, 0xff, 0xf8, 0x1d, + /*18c0:*/ 0xcb, 0x2e, 0x2d, 0xa8, 0x24, 0xcd, 0x74, 0x7e, 0xc1, 0xb7, 0xf1, 0x7f, 0x5a, 0xa7, 0x4f, 0xd5, + /*18d0:*/ 0xe1, 0x7c, 0xbe, 0x5c, 0xcc, 0x8d, 0xb0, 0xe8, 0x05, 0x0c, 0xc6, 0x53, 0x79, 0xa3, 0xe6, 0xda, + /*18e0:*/ 0xa6, 0x23, 0x6c, 0x9d, 0x1b, 0x98, 0xa9, 0x78, 0xe2, 0x20, 0xd6, 0xcf, 0xb1, 0x12, 0x4c, 0xec, + /*18f0:*/ 0xb7, 0xb3, 0x04, 0x1d, 0xe3, 0xf0, 0xc2, 0xa6, 0x97, 0x29, 0xef, 0x43, 0x55, 0xef, 0xff, 0x71, + /*1900:*/ 0xb1, 0x1f, 0x4e, 0x0f, 0x08, 0x05, 0x91, 0x19, 0xd0, 0x73, 0x6b, 0x36, 0x7d, 0x1d, 0xae, 0xc6, + /*1910:*/ 0xbf, 0xdb, 0x03, 0x3f, 0xc7, 0x06, 0xf3, 0xed, 0x15, 0xa3, 0xda, 0x03, 0xbd, 0x57, 0x6f, 0x86, + /*1920:*/ 0x30, 0x77, 0x7b, 0x2c, 0xd9, 0xa9, 0x77, 0x8f, 0xf0, 0xe3, 0x78, 0x75, 0x88, 0x13, 0x3b, 0x1a, + /*1930:*/ 0xa8, 0xdf, 0x4a, 0x09, 0xb0, 0x52, 0x55, 0x79, 0xba, 0x0a, 0xf3, 0x36, 0x9a, 0x0c, 0xd5, 0x93, + /*1940:*/ 0xed, 0x15, 0x47, 0x80, 0xb8, 0x0d, 0xb7, 0xd7, 0x6d, 0x51, 0xd0, 0x1c, 0xc5, 0x2c, 0x8d, 0x31, + /*1950:*/ 0xb7, 0x35, 0x62, 0xf9, 0xa3, 0xd2, 0xfa, 0x26, 0xe7, 0x61, 0x3f, 0x85, 0xae, 0x96, 0x85, 0xf9, + /*1960:*/ 0xb3, 0x4a, 0x1b, 0x0e, 0x30, 0x2a, 0xc2, 0x10, 0xe8, 0xfb, 0x16, 0xc0, 0x74, 0x29, 0x2a, 0x16, + /*1970:*/ 0x39, 0xd9, 0xd8, 0xaf, 0x45, 0x92, 0x5e, 0xdf, 0xa4, 0x2f, 0xae, 0x42, 0xc2, 0xf5, 0x7b, 0xa1, + /*1980:*/ 0x33, 0x26, 0xa1, 0x06, 0x7f, 0x57, 0x4e, 0x1e, 0x5d, 0xaa, 0x5c, 0xa1, 0x52, 0xdb, 0xb3, 0xba, + /*1990:*/ 0x8f, 0x4e, 0x6f, 0x00, 0xc2, 0x95, 0x12, 0x0c, 0xe7, 0xf0, 0xad, 0xb8, 0x33, 0xc0, 0xfc, 0x3b, + /*19a0:*/ 0x9f, 0x06, 0x4d, 0x4c, 0x45, 0x5c, 0xea, 0x12, 0x92, 0xff, 0x3e, 0xa7, 0xc6, 0x4b, 0x15, 0xb0, + /*19b0:*/ 0x51, 0x59, 0x5d, 0x40, 0xb1, 0xff, 0xae, 0xfb, 0x9a, 0x66, 0xc0, 0x1c, 0x38, 0x7b, 0x6f, 0xa7, + /*19c0:*/ 0xc6, 0x81, 0xbe, 0x91, 0xb1, 0xb0, 0xce, 0x2b, 0x7c, 0x04, 0x69, 0xdd, 0x67, 0xd1, 0x9e, 0x9e, + /*19d0:*/ 0x41, 0x3c, 0x90, 0x04, 0x17, 0x5c, 0x73, 0x51, 0xfd, 0x49, 0x7e, 0x2d, 0x0a, 0xd3, 0x77, 0x1d, + /*19e0:*/ 0xbc, 0x8e, 0x2e, 0xf6, 0x44, 0x20, 0x8a, 0x3f, 0x44, 0xa2, 0xd6, 0x8c, 0x40, 0xac, 0x6c, 0x91, + /*19f0:*/ 0xa4, 0x34, 0xe6, 0xbe, 0x3b, 0x55, 0xde, 0x9b, 0x3b, 0x97, 0xba, 0xbc, 0x43, 0x79, 0xe5, 0xba, + /*1a00:*/ 0xc5, 0x34, 0x87, 0xb9, 0x68, 0xef, 0x83, 0x9c, 0x90, 0x55, 0x27, 0xcb, 0xc2, 0x57, 0xad, 0x27, + /*1a10:*/ 0xe8, 0xe4, 0xe0, 0xa6, 0x03, 0x27, 0x9f, 0x41, 0x38, 0xb4, 0x1e, 0x7b, 0xa4, 0xe2, 0xab, 0x27, + /*1a20:*/ 0x7b, 0x81, 0xfa, 0x9a, 0x7b, 0xc0, 0xb6, 0xd4, 0xe4, 0x0f, 0xf2, 0x2c, 0x25, 0x73, 0xef, 0x3f, + /*1a30:*/ 0xae, 0xb2, 0x84, 0xd9, 0x6d, 0xc2, 0x41, 0x34, 0xc1, 0x00, 0x69, 0xc7, 0x68, 0xda, 0xca, 0xbb, + /*1a40:*/ 0x82, 0x97, 0x93, 0xb8, 0x21, 0xe4, 0xee, 0xd9, 0x65, 0xcc, 0xa9, 0x89, 0x70, 0x3d, 0x87, 0x8a, + /*1a50:*/ 0x98, 0xaf, 0x73, 0xdd, 0x9e, 0x41, 0x9b, 0xad, 0xbb, 0xb8, 0xfb, 0x3e, 0xdd, 0x57, 0xd0, 0x66, + /*1a60:*/ 0xc8, 0x11, 0x42, 0xd8, 0x84, 0x5e, 0x20, 0x4c, 0xe9, 0xaa, 0xad, 0x08, 0x8f, 0x9d, 0x9e, 0xf9, + /*1a70:*/ 0x47, 0xfb, 0x46, 0x89, 0xaa, 0xec, 0x21, 0x32, 0x56, 0x49, 0x47, 0xc3, 0x0d, 0x26, 0x06, 0xe8, + /*1a80:*/ 0xfe, 0x50, 0xbb, 0xf1, 0x13, 0xec, 0x78, 0x02, 0xcb, 0xe2, 0x5d, 0x4c, 0xe5, 0x17, 0x50, 0x9a, + /*1a90:*/ 0x29, 0x24, 0x06, 0xd2, 0x27, 0xf1, 0xcc, 0x31, 0x44, 0xc5, 0xeb, 0xda, 0xbf, 0x7f, 0xe0, 0xa8, + /*1aa0:*/ 0x27, 0xad, 0xc9, 0xf1, 0x22, 0xce, 0x52, 0x1f, 0x66, 0xac, 0x29, 0xc3, 0x6b, 0xea, 0x7e, 0xdc, + /*1ab0:*/ 0x57, 0xc1, 0xee, 0xf2, 0xa3, 0x9d, 0xc2, 0xdb, 0x47, 0xa3, 0xd1, 0x40, 0xda, 0xa8, 0x4f, 0x51, + /*1ac0:*/ 0x31, 0x7a, 0x58, 0xf4, 0x76, 0xef, 0xe4, 0xeb, 0x47, 0xd8, 0x33, 0x1e, 0x33, 0x1d, 0xca, 0xd8, + /*1ad0:*/ 0xce, 0x20, 0x21, 0x6d, 0xd4, 0xa4, 0x0d, 0x9b, 0x41, 0x8e, 0xcb, 0x00, 0xb3, 0x3c, 0x7f, 0x2a, + /*1ae0:*/ 0xe1, 0x4f, 0x43, 0x10, 0xde, 0x96, 0x71, 0xd1, 0x23, 0x21, 0x2b, 0x4a, 0xab, 0x4d, 0x88, 0xbb, + /*1af0:*/ 0x4e, 0x7d, 0x51, 0x42, 0x86, 0xd0, 0x45, 0x8a, 0x12, 0x01, 0xec, 0x87, 0xc3, 0xa4, 0xfc, 0x9e, + /*1b00:*/ 0x38, 0x47, 0xd6, 0xdb, 0xbb, 0x9f, 0x76, 0xa7, 0x7a, 0x20, 0x6c, 0x1f, 0x2b, 0x85, 0xbf, 0xf0, + /*1b10:*/ 0x2b, 0x17, 0x29, 0xd3, 0xc1, 0x21, 0x76, 0x33, 0x54, 0xc7, 0x00, 0x8b, 0x42, 0xf7, 0x4b, 0x1f, + /*1b20:*/ 0x90, 0x95, 0xe3, 0x00, 0x06, 0x7c, 0x16, 0x8e, 0x55, 0x75, 0x25, 0x72, 0xcf, 0x6c, 0xaf, 0x03, + /*1b30:*/ 0x60, 0xde, 0xe0, 0x4f, 0xb5, 0x46, 0x98, 0xb9, 0xbf, 0x42, 0x6d, 0x50, 0xcf, 0xe2, 0x7c, 0xe7, + /*1b40:*/ 0x69, 0xa1, 0x38, 0x08, 0xbb, 0x4d, 0x28, 0xf0, 0x1a, 0x09, 0x2b, 0x15, 0xa9, 0x90, 0x50, 0x09, + /*1b50:*/ 0x9a, 0xd0, 0x06, 0x1d, 0xe6, 0x25, 0xb9, 0x11, 0xbd, 0x10, 0xc1, 0x8d, 0x99, 0xba, 0x51, 0xca, + /*1b60:*/ 0xc1, 0x6b, 0x26, 0xac, 0x6a, 0x81, 0xd7, 0xbd, 0x84, 0xc8, 0x6d, 0xb1, 0x22, 0x73, 0x99, 0x7c, + /*1b70:*/ 0x7d, 0xdc, 0xcc, 0xa8, 0x36, 0xcf, 0xf7, 0x85, 0xb2, 0x2f, 0x3a, 0xfa, 0x31, 0x21, 0x5b, 0x86, + /*1b80:*/ 0xf3, 0xae, 0x82, 0xc3, 0x69, 0x08, 0xf4, 0xa4, 0xfc, 0x70, 0x9f, 0xf3, 0x64, 0xdb, 0x90, 0xa8, + /*1b90:*/ 0x2c, 0x81, 0xe2, 0x2b, 0x59, 0x5b, 0x8d, 0xed, 0x08, 0x37, 0x88, 0xd0, 0xca, 0xf2, 0xaf, 0x6e, + /*1ba0:*/ 0x46, 0x00, 0x60, 0x6f, 0xbf, 0x7b, 0xf4, 0x69, 0xa1, 0x92, 0x4e, 0x30, 0x2c, 0x0f, 0xa1, 0xcb, + /*1bb0:*/ 0xbf, 0x8e, 0xe9, 0x1b, 0xe5, 0x90, 0x6c, 0x90, 0x5a, 0x5e, 0x92, 0xdf, 0x4f, 0xc6, 0x9c, 0x07, + /*1bc0:*/ 0xaf, 0xdd, 0x6b, 0x7c, 0x28, 0x8b, 0x01, 0x42, 0x1a, 0x7f, 0x43, 0xca, 0xbf, 0x9f, 0xf4, 0x56, + /*1bd0:*/ 0x88, 0xc2, 0x6e, 0xb4, 0x2d, 0xec, 0x75, 0x55, 0x88, 0x89, 0xec, 0x34, 0xd1, 0x4e, 0x7f, 0x58, + /*1be0:*/ 0x2d, 0xaf, 0x4b, 0x74, 0x9e, 0x1f, 0x40, 0x17, 0xcd, 0xa5, 0x03, 0x63, 0x2a, 0x52, 0xb5, 0x85, + /*1bf0:*/ 0x37, 0xac, 0xf9, 0x35, 0xe7, 0x04, 0x4f, 0x6f, 0x9b, 0xe4, 0x21, 0xd7, 0xc1, 0x37, 0x03, 0x6a, + /*1c00:*/ 0xc5, 0x2e, 0xf2, 0xa7, 0xfa, 0x3f, 0x41, 0x08, 0xf2, 0xf1, 0x9b, 0x3b, 0xef, 0xf8, 0x39, 0x16, + /*1c10:*/ 0xf9, 0xe9, 0xe7, 0x7c, 0xb9, 0x7c, 0xde, 0x7b, 0xd8, 0x32, 0xdf, 0x67, 0xff, 0x6f, 0x47, 0x8f, + /*1c20:*/ 0x4f, 0x90, 0x80, 0x6a, 0xf6, 0x3f, 0xef, 0x14, 0xd5, 0x9c, 0x78, 0x65, 0x95, 0xb3, 0x16, 0x7e, + /*1c30:*/ 0x22, 0xc1, 0x12, 0xb6, 0x7e, 0x8a, 0xa8, 0x2e, 0x06, 0x29, 0x41, 0xe7, 0x19, 0xf3, 0x60, 0xc1, + /*1c40:*/ 0xe7, 0xad, 0x7b, 0xd6, 0xf4, 0xa3, 0x9a, 0x60, 0x33, 0xfc, 0x00, 0x37, 0xe3, 0xe8, 0xba, 0xa7, + /*1c50:*/ 0xbe, 0x25, 0x09, 0x0b, 0x6b, 0x10, 0x9e, 0x5a, 0x8b, 0xfb, 0x16, 0x34, 0xae, 0x70, 0x16, 0x62, + /*1c60:*/ 0x08, 0x44, 0x83, 0x13, 0xa2, 0xb4, 0x5f, 0xe6, 0x4e, 0x97, 0xf0, 0x38, 0x32, 0xf0, 0xeb, 0x15, + /*1c70:*/ 0x3f, 0x22, 0xa5, 0x2d, 0xda, 0x5e, 0x8a, 0xc7, 0x1a, 0x67, 0xbc, 0x27, 0xb6, 0xe2, 0x33, 0xe0, + /*1c80:*/ 0x7e, 0xe1, 0x48, 0xcf, 0xbb, 0x98, 0xd5, 0xf4, 0x46, 0x9f, 0xc0, 0xa8, 0x9b, 0x5d, 0xcd, 0x51, + /*1c90:*/ 0xae, 0xab, 0xf8, 0xf1, 0x3a, 0x61, 0xb7, 0x40, 0x68, 0x8f, 0xb9, 0x65, 0xfe, 0x7f, 0xcf, 0x9d, + /*1ca0:*/ 0xc3, 0xf8, 0x9c, 0x02, 0x69, 0xa4, 0x46, 0xfd, 0x90, 0x94, 0xb4, 0x17, 0x48, 0x24, 0xd7, 0x9b, + /*1cb0:*/ 0x9e, 0xad, 0xe4, 0x0c, 0x7b, 0x8e, 0xf5, 0xcc, 0xf6, 0x6d, 0x8b, 0x25, 0x27, 0xd0, 0x12, 0x25, + /*1cc0:*/ 0x4e, 0x26, 0xca, 0x25, 0x3e, 0x0f, 0x85, 0x07, 0x03, 0xad, 0xb5, 0xed, 0xb5, 0xd3, 0x42, 0xbc, + /*1cd0:*/ 0xaa, 0xa5, 0xd1, 0xbb, 0xa9, 0xd7, 0x2f, 0x8e, 0x1a, 0x05, 0x00, 0xf1, 0xcd, 0x8b, 0x30, 0x11, + /*1ce0:*/ 0xa9, 0x3c, 0x7d, 0x08, 0x86, 0xf0, 0xc0, 0x5e, 0x89, 0x2a, 0xdc, 0xf7, 0xaa, 0xfa, 0x69, 0xf4, + /*1cf0:*/ 0xed, 0x1f, 0x73, 0x5f, 0x12, 0x9f, 0x7d, 0x6d, 0x56, 0x38, 0x39, 0x52, 0xfb, 0xa1, 0x59, 0xc5, + /*1d00:*/ 0x33, 0x4b, 0x60, 0x65, 0x0a, 0xee, 0x64, 0xbc, 0xd1, 0x08, 0x07, 0x65, 0xa7, 0x25, 0x08, 0xd5, + /*1d10:*/ 0xc5, 0x66, 0x36, 0x26, 0x2b, 0x08, 0xb2, 0x9a, 0x94, 0x84, 0x3e, 0xb3, 0x1e, 0xff, 0xeb, 0x0b, + /*1d20:*/ 0x17, 0xa2, 0xc2, 0x3b, 0x2d, 0x87, 0xdf, 0xcc, 0x2d, 0x33, 0x90, 0xd1, 0xb8, 0x13, 0x52, 0xf9, + /*1d30:*/ 0xf6, 0xde, 0xba, 0x43, 0x17, 0x57, 0x4b, 0x25, 0xe7, 0xd6, 0x6f, 0x92, 0xed, 0x9a, 0xf6, 0x33, + /*1d40:*/ 0x79, 0x3b, 0xfb, 0x4f, 0x06, 0xff, 0x16, 0x17, 0xba, 0xdd, 0x76, 0x85, 0x31, 0xaa, 0x6a, 0x02, + /*1d50:*/ 0x8a, 0xd0, 0x4e, 0xcd, 0xd1, 0x16, 0xa0, 0x81, 0xff, 0x68, 0x17, 0x89, 0xdc, 0x66, 0x1a, 0x01, + /*1d60:*/ 0xf5, 0x61, 0xe6, 0xb7, 0x9c, 0xc8, 0x4a, 0x0c, 0x8c, 0xbc, 0x4e, 0x8f, 0x1e, 0x8f, 0x44, 0x1b, + /*1d70:*/ 0x31, 0x53, 0x99, 0xa3, 0x4b, 0x59, 0xfe, 0xc1, 0x51, 0x98, 0x5a, 0x4f, 0x27, 0x56, 0x37, 0xe5, + /*1d80:*/ 0x90, 0x48, 0x02, 0x07, 0xaf, 0xf7, 0xbd, 0xe1, 0xcb, 0xe0, 0x08, 0x4f, 0x75, 0x68, 0x38, 0xdc, + /*1d90:*/ 0xb0, 0xad, 0x92, 0xc0, 0xf9, 0xc8, 0x84, 0x25, 0x4f, 0xac, 0x0e, 0x89, 0x41, 0x26, 0x0e, 0xb8, + /*1da0:*/ 0xa0, 0x73, 0x56, 0x16, 0xd9, 0x70, 0xdf, 0xde, 0xd8, 0x9b, 0x84, 0x8b, 0x2c, 0xe2, 0x2e, 0x80, + /*1db0:*/ 0x39, 0x33, 0x20, 0x18, 0x29, 0x72, 0x69, 0x2d, 0x61, 0x44, 0x67, 0xc5, 0x56, 0x04, 0x7d, 0xe5, + /*1dc0:*/ 0xc8, 0xdb, 0xb1, 0x6d, 0x5d, 0x2b, 0x34, 0x4e, 0xdd, 0x14, 0xff, 0x4b, 0x5a, 0xae, 0xa6, 0xee, + /*1dd0:*/ 0x5c, 0x81, 0xee, 0x61, 0x5d, 0x9f, 0x0d, 0x24, 0x21, 0x05, 0x48, 0x58, 0xe9, 0x12, 0x3a, 0x17, + /*1de0:*/ 0x73, 0x77, 0xb6, 0x54, 0x63, 0xd0, 0xe6, 0x7c, 0x87, 0x6b, 0xdf, 0xdd, 0x24, 0xd9, 0xd5, 0xc0, + /*1df0:*/ 0x4f, 0xed, 0xb6, 0x18, 0x72, 0x46, 0x98, 0x51, 0x78, 0x63, 0xe3, 0xf7, 0x55, 0xbe, 0x2b, 0x1a, + /*1e00:*/ 0x92, 0xb1, 0x7e, 0x7f, 0x37, 0xb0, 0xf8, 0x3c, 0x54, 0xc3, 0xf2, 0x8c, 0xa3, 0x57, 0x57, 0xd0, + /*1e10:*/ 0x7f, 0x72, 0x59, 0xda, 0xfe, 0xe2, 0x11, 0x84, 0x35, 0x69, 0xcc, 0x58, 0x19, 0x02, 0x17, 0x7a, + /*1e20:*/ 0xf1, 0xfc, 0x3a, 0x5f, 0x44, 0x2c, 0x8d, 0x61, 0xf5, 0x6f, 0x47, 0xd4, 0xc7, 0xe7, 0xb4, 0xe4, + /*1e30:*/ 0x39, 0xe6, 0xde, 0xf3, 0xa7, 0x40, 0x30, 0xf4, 0x47, 0x58, 0xd6, 0x9e, 0x2b, 0x26, 0x67, 0x59, + /*1e40:*/ 0xb6, 0xf1, 0x28, 0x8a, 0x23, 0xad, 0x08, 0xd0, 0x84, 0xf3, 0xd8, 0xfa, 0xfb, 0x72, 0x0a, 0x94, + /*1e50:*/ 0x89, 0xca, 0x41, 0x88, 0x2f, 0x33, 0xa1, 0x42, 0xbb, 0xe2, 0x30, 0x90, 0xb1, 0xa4, 0xbb, 0x28, + /*1e60:*/ 0x2b, 0xc5, 0x6f, 0xb2, 0x36, 0xd7, 0x35, 0xc5, 0x57, 0xb5, 0x94, 0x77, 0x63, 0x0c, 0x9a, 0x72, + /*1e70:*/ 0xf8, 0x93, 0xcf, 0x24, 0x28, 0xb6, 0x62, 0x95, 0x8d, 0xf4, 0x5e, 0xb8, 0x71, 0x49, 0x74, 0x97, + /*1e80:*/ 0xeb, 0xd0, 0x51, 0x58, 0x14, 0xe1, 0xc9, 0x70, 0xf1, 0x49, 0x26, 0x46, 0x1e, 0x3f, 0x36, 0x81, + /*1e90:*/ 0xb6, 0xc8, 0x1c, 0x9c, 0x5d, 0x67, 0x35, 0x25, 0xc1, 0x9b, 0x76, 0x3a, 0x95, 0x52, 0xb2, 0xe1, + /*1ea0:*/ 0xb2, 0x8a, 0x56, 0x1b, 0x82, 0x67, 0xfe, 0x48, 0x08, 0x3e, 0x5f, 0xc6, 0xf8, 0xe9, 0xb8, 0xe0, + /*1eb0:*/ 0x7e, 0x93, 0x99, 0xed, 0x22, 0x58, 0x6e, 0x5a, 0x8d, 0x9a, 0x51, 0xf1, 0x74, 0x6e, 0x92, 0x91, + /*1ec0:*/ 0xd6, 0x76, 0x19, 0xd2, 0xaf, 0xee, 0xaa, 0x0d, 0x91, 0x36, 0xae, 0xa6, 0xc6, 0xea, 0x8e, 0xe2, + /*1ed0:*/ 0x43, 0x34, 0x45, 0x6e, 0x11, 0x49, 0x32, 0x8d, 0x8d, 0x08, 0xfd, 0xc5, 0xf5, 0xb8, 0xf7, 0x49, + /*1ee0:*/ 0x66, 0x00, 0x6b, 0x50, 0x61, 0x3e, 0x24, 0xa3, 0x67, 0x0c, 0x9f, 0x3b, 0x4d, 0x69, 0x0d, 0xe5, + /*1ef0:*/ 0x66, 0x67, 0xf2, 0xcd, 0x79, 0x88, 0x36, 0xff, 0x21, 0x3b, 0x41, 0xcb, 0x88, 0x67, 0xdb, 0xa7, + /*1f00:*/ 0xc8, 0x3d, 0x16, 0xda, 0x7e, 0x58, 0x76, 0xdc, 0x0c, 0xd7, 0x96, 0x23, 0x59, 0x6f, 0xe2, 0xda, + /*1f10:*/ 0x62, 0xf7, 0x9f, 0x11, 0xee, 0x3f, 0x84, 0xeb, 0xbb, 0xeb, 0x62, 0x79, 0xa9, 0x6c, 0x93, 0x82, + /*1f20:*/ 0x07, 0x8f, 0x98, 0xcc, 0x27, 0x16, 0xf1, 0x65, 0x40, 0x20, 0x40, 0x00, 0x31, 0x16, 0xdb, 0x9c, + /*1f30:*/ 0x3a, 0x03, 0xc1, 0x73, 0x5f, 0x0e, 0x5a, 0xc1, 0x19, 0x5a, 0xcb, 0x72, 0x73, 0x62, 0x3c, 0x83, + /*1f40:*/ 0x8c, 0x05, 0x39, 0x8c, 0x10, 0x81, 0x06, 0xb9, 0x9a, 0x37, 0xed, 0x5a, 0xb0, 0x92, 0x75, 0x51, + /*1f50:*/ 0x20, 0x62, 0xc6, 0xca, 0xf7, 0x0d, 0xd0, 0x7a, 0x98, 0x41, 0x43, 0x5b, 0x08, 0x08, 0xb2, 0x04, + /*1f60:*/ 0x7f, 0x86, 0x84, 0x39, 0xe3, 0x7e, 0x5f, 0x9b, 0xff, 0x8a, 0x49, 0x78, 0x40, 0x99, 0x71, 0x77, + /*1f70:*/ 0xbd, 0xb3, 0x01, 0xfa, 0x4f, 0x57, 0x9c, 0xe4, 0x92, 0x00, 0xef, 0xcd, 0x60, 0x4a, 0xb8, 0x73, + /*1f80:*/ 0xb6, 0xd0, 0x51, 0x62, 0x34, 0x27, 0xb0, 0x40, 0xd9, 0x25, 0x8c, 0x7b, 0x47, 0x7f, 0x33, 0xdd, + /*1f90:*/ 0x64, 0x9d, 0x1b, 0xfb, 0xe8, 0x4f, 0x85, 0x95, 0x62, 0xb7, 0x87, 0x43, 0x47, 0x28, 0xec, 0xda, + /*1fa0:*/ 0x08, 0x52, 0x16, 0xca, 0x11, 0xf7, 0x35, 0x5c, 0x6d, 0xbd, 0xa6, 0x3d, 0xe3, 0x45, 0x78, 0xe7, + /*1fb0:*/ 0xb9, 0x08, 0xc3, 0xca, 0x97, 0x8e, 0x88, 0x6e, 0xb2, 0x00, 0x15, 0x9c, 0x44, 0x6f, 0x98, 0x80, + /*1fc0:*/ 0xe6, 0x24, 0x0e, 0xf9, 0xaa, 0xf6, 0x22, 0x54, 0xd5, 0xde, 0x97, 0x93, 0x77, 0x25, 0x79, 0xbf, + /*1fd0:*/ 0x93, 0xb1, 0x26, 0xbd, 0x8e, 0x6f, 0x71, 0xeb, 0xeb, 0x26, 0xb9, 0xca, 0x21, 0x53, 0x21, 0x73, + /*1fe0:*/ 0x1b, 0x09, 0x60, 0x03, 0xe3, 0x28, 0x7c, 0x8e, 0x55, 0x59, 0x99, 0x6a, 0xb8, 0xdc, 0x15, 0xf3, + /*1ff0:*/ 0xcf, 0x96, 0x61, 0x26, 0x2b, 0x2b, 0x32, 0xaa, 0xa0, 0x37, 0x1f, 0x3c, 0x22, 0x9e, 0xc2, 0x14, + /*2000:*/ 0x43, 0x79, 0x50, 0x7b, 0xf7, 0x72, 0xc8, 0xc4, 0xb5, 0x9e, 0x04, 0xe7, 0x7b, 0xd5, 0x01, 0xd0, + /*2010:*/ 0xd9, 0xf2, 0x57, 0x76, 0x6a, 0x11, 0xd4, 0xe5, 0x0f, 0xcd, 0xd8, 0xd1, 0x5c, 0xf1, 0x9d, 0x7e, + /*2020:*/ 0x31, 0x43, 0xdf, 0x82, 0x81, 0x30, 0xe1, 0xf9, 0x85, 0x9d, 0xbf, 0xe8, 0x6d, 0xb9, 0xa0, 0x40, + /*2030:*/ 0x4e, 0x7f, 0x88, 0x3f, 0xb4, 0x78, 0xb8, 0x5a, 0x30, 0x39, 0xf1, 0xb5, 0x3e, 0x13, 0x91, 0x63, + /*2040:*/ 0x88, 0xce, 0xc3, 0x29, 0xde, 0x4c, 0x40, 0x0d, 0x1f, 0x98, 0x36, 0x78, 0x0b, 0x6a, 0x0e, 0x3a, + /*2050:*/ 0x4c, 0x24, 0xe5, 0x5c, 0x48, 0x9f, 0x4c, 0xa7, 0xc7, 0x2d, 0x57, 0x7a, 0x2a, 0xa1, 0x5e, 0x47, + /*2060:*/ 0xbc, 0x29, 0x31, 0xb5, 0x51, 0xe6, 0x01, 0x22, 0x61, 0xcb, 0xed, 0x8f, 0xb9, 0xc7, 0x47, 0xf3, + /*2070:*/ 0x74, 0x32, 0xc3, 0x83, 0xf8, 0x29, 0x61, 0x07, 0x5d, 0xc1, 0xe4, 0x45, 0x53, 0xcd, 0x3d, 0x7a, + /*2080:*/ 0xfd, 0x65, 0xce, 0x29, 0xdc, 0x73, 0x22, 0xa8, 0x99, 0xfb, 0xcb, 0xee, 0xc7, 0xb4, 0x96, 0x7f, + /*2090:*/ 0x5a, 0xb9, 0xd6, 0xa0, 0xd1, 0xcc, 0x6f, 0x87, 0x6e, 0x82, 0x66, 0xa3, 0x81, 0xb2, 0xee, 0x2e, + /*20a0:*/ 0x32, 0x32, 0xd8, 0xf3, 0x3e, 0xfc, 0x43, 0xc1, 0x3c, 0x2c, 0xa4, 0x43, 0x3b, 0x10, 0x5b, 0x2b, + /*20b0:*/ 0xf0, 0x6a, 0xce, 0xee, 0x77, 0xb2, 0xb8, 0xac, 0x87, 0xdb, 0x6c, 0x85, 0xc5, 0x61, 0x45, 0x47, + /*20c0:*/ 0xb1, 0xb8, 0x95, 0x39, 0x7f, 0xdc, 0x3c, 0xfb, 0xf3, 0x1a, 0x0d, 0xbf, 0xd8, 0x43, 0xcb, 0x7b, + /*20d0:*/ 0xfa, 0xf0, 0xa5, 0x56, 0xca, 0x40, 0xe1, 0x54, 0xe9, 0x8a, 0x33, 0xee, 0x00, 0xdd, 0xcf, 0xb6, + /*20e0:*/ 0x95, 0x67, 0x91, 0x36, 0xac, 0x3b, 0xa3, 0x72, 0xf6, 0x24, 0x5c, 0xed, 0x39, 0x53, 0xc0, 0xfd, + /*20f0:*/ 0x25, 0x61, 0x7b, 0x4d, 0x67, 0xff, 0x5b, 0x6d, 0xce, 0x5b, 0x85, 0x9b, 0x20, 0xc5, 0x8a, 0x62, + /*2100:*/ 0x70, 0x14, 0x6a, 0x7e, 0x78, 0x54, 0x4b, 0x77, 0x2b, 0xb9, 0x42, 0x12, 0xca, 0xb5, 0xad, 0x37, + /*2110:*/ 0x6d, 0x2f, 0x3e, 0x2e, 0x32, 0x0c, 0xba, 0x17, 0x1e, 0x4b, 0xd0, 0x0f, 0x29, 0xf9, 0x45, 0xa0, + /*2120:*/ 0xa4, 0x7b, 0xb9, 0xce, 0x7f, 0x3a, 0xd5, 0xaf, 0x1c, 0xeb, 0x49, 0xb9, 0xb6, 0x5d, 0x61, 0x1f, + /*2130:*/ 0x7a, 0x36, 0xab, 0x92, 0x9e, 0xb9, 0xfb, 0x54, 0xcf, 0xf1, 0xd4, 0x1f, 0xdd, 0x48, 0xc4, 0xd1, + /*2140:*/ 0x6a, 0x73, 0x9d, 0x07, 0xce, 0x87, 0x9f, 0x53, 0x82, 0x28, 0x43, 0x27, 0x53, 0x85, 0x19, 0x5d, + /*2150:*/ 0xd6, 0x88, 0x3e, 0xe1, 0x77, 0x4a, 0x1f, 0x73, 0x4d, 0x82, 0x42, 0x87, 0x49, 0x5b, 0x1f, 0x49, + /*2160:*/ 0x1c, 0x46, 0xaf, 0x7f, 0xbc, 0xa4, 0xdf, 0x0b, 0xa5, 0x8f, 0xdf, 0x0a, 0x33, 0x13, 0xc4, 0x33, + /*2170:*/ 0xa9, 0x7c, 0x05, 0x76, 0x83, 0xbd, 0x2a, 0xa2, 0x48, 0xfa, 0xf9, 0x0a, 0xfb, 0x17, 0xa8, 0x46, + /*2180:*/ 0x10, 0x9b, 0x16, 0x17, 0x45, 0xa1, 0x0b, 0xf9, 0x63, 0x5f, 0x5a, 0xb7, 0x86, 0x84, 0xc8, 0x3f, + /*2190:*/ 0x1d, 0x8a, 0xf1, 0xba, 0x57, 0x00, 0xd9, 0x7e, 0x52, 0xf0, 0x2d, 0x05, 0x26, 0x72, 0x97, 0xb4, + /*21a0:*/ 0x8d, 0x92, 0x37, 0xf8, 0x02, 0x9e, 0x6a, 0x41, 0x68, 0x37, 0x76, 0xb0, 0xeb, 0xca, 0xbc, 0xd3, + /*21b0:*/ 0x7a, 0xdf, 0xa9, 0x2c, 0x30, 0x36, 0x1c, 0x1d, 0x0e, 0x19, 0x2b, 0xc0, 0x7a, 0x59, 0x29, 0x82, + /*21c0:*/ 0x36, 0x5e, 0x76, 0x8e, 0x50, 0x27, 0xc4, 0x6c, 0xfb, 0xf0, 0x19, 0x9d, 0x40, 0x0c, 0x21, 0x95, + /*21d0:*/ 0x2d, 0xdc, 0xaf, 0x0d, 0x23, 0xde, 0xa2, 0x6a, 0xf3, 0x7a, 0x30, 0x3e, 0x2b, 0x07, 0xd4, 0x3d, + /*21e0:*/ 0xaa, 0x45, 0xec, 0x32, 0x87, 0x23, 0xb2, 0xb9, 0x77, 0xca, 0x6e, 0xfb, 0x68, 0xfc, 0x22, 0x0c, + /*21f0:*/ 0x5a, 0xff, 0x25, 0xfa, 0x62, 0x40, 0xe7, 0xb9, 0x3f, 0x84, 0x17, 0x35, 0x2a, 0x72, 0xff, 0x42, + /*2200:*/ 0xab, 0x0e, 0xbe, 0xe6, 0x46, 0x28, 0xb7, 0xb3, 0x9d, 0x84, 0x7e, 0x5f, 0x02, 0xd7, 0xe9, 0xa2, + /*2210:*/ 0x68, 0xb1, 0x27, 0xc6, 0x89, 0xda, 0xc3, 0x37, 0x3b, 0x6c, 0x1a, 0x70, 0x08, 0xaa, 0x84, 0x7c, + /*2220:*/ 0xc9, 0x7e, 0x69, 0x4c, 0x5c, 0x8c, 0x98, 0x82, 0xc8, 0xe0, 0x58, 0x17, 0xeb, 0x8a, 0xda, 0x2a, + /*2230:*/ 0xe3, 0x68, 0x5a, 0x65, 0xef, 0x23, 0xd4, 0x46, 0x02, 0x8e, 0x68, 0xb5, 0x19, 0x25, 0x31, 0x69, + /*2240:*/ 0xd2, 0xc6, 0xe0, 0x84, 0x8e, 0x0a, 0xc4, 0x72, 0x9a, 0x4a, 0x1d, 0x56, 0x06, 0x4a, 0x9f, 0xaa, + /*2250:*/ 0x7a, 0xbe, 0x37, 0x5a, 0x38, 0xd0, 0x7b, 0xaa, 0x11, 0x40, 0x6a, 0xdb, 0xea, 0x6b, 0xa5, 0x7a, + /*2260:*/ 0xa3, 0x8e, 0xa1, 0x8e, 0x93, 0x9c, 0x38, 0x09, 0x27, 0x9d, 0xf2, 0x07, 0xfb, 0xf0, 0xba, 0x4d, + /*2270:*/ 0x9d, 0xaa, 0xa6, 0xd3, 0x32, 0x86, 0x3f, 0xd1, 0x6b, 0xcf, 0x86, 0x61, 0xdc, 0x28, 0xf0, 0x6a, + /*2280:*/ 0x11, 0x1f, 0x6d, 0x2e, 0xaf, 0x98, 0x59, 0x5b, 0x97, 0x2a, 0xd5, 0x5f, 0xf1, 0xca, 0x9d, 0xb6, + /*2290:*/ 0x48, 0x87, 0x21, 0x85, 0xfa, 0xb5, 0x80, 0x01, 0x85, 0x9e, 0xc3, 0x57, 0x20, 0xb9, 0x86, 0xea, + /*22a0:*/ 0x27, 0x8e, 0x29, 0xa7, 0xca, 0x5c, 0x89, 0x50, 0xc6, 0xa2, 0x6b, 0xdb, 0x0b, 0x0c, 0xc4, 0x1f, + /*22b0:*/ 0x57, 0x20, 0xbe, 0xfe, 0xcf, 0xca, 0x4b, 0x81, 0xb9, 0x6e, 0x82, 0x4f, 0x5d, 0xa9, 0xf5, 0x2e, + /*22c0:*/ 0x32, 0x07, 0x8d, 0x67, 0x65, 0x00, 0xe6, 0x92, 0x82, 0x68, 0x79, 0x54, 0x45, 0x89, 0x3e, 0xd0, + /*22d0:*/ 0x0d, 0x5c, 0x42, 0x11, 0xe6, 0xdd, 0xf5, 0xd0, 0x59, 0x1e, 0xd5, 0xb7, 0x0b, 0xd5, 0x80, 0xb7, + /*22e0:*/ 0xa9, 0x02, 0x96, 0xea, 0x77, 0x7d, 0x63, 0x72, 0x6c, 0x16, 0xb2, 0xfb, 0xf8, 0x28, 0xe5, 0xb1, + /*22f0:*/ 0x7a, 0x1c, 0xb0, 0xbd, 0xcd, 0xe0, 0x7f, 0xe8, 0xca, 0x36, 0xa9, 0x84, 0x87, 0x8e, 0x43, 0x42, + /*2300:*/ 0xe5, 0x06, 0xea, 0x4d, 0xef, 0xa5, 0x70, 0x40, 0xe1, 0xc1, 0x25, 0xec, 0x3d, 0x25, 0x14, 0xb1, + /*2310:*/ 0x90, 0x01, 0x67, 0x4e, 0xea, 0x7c, 0xf7, 0x8b, 0xca, 0x8d, 0x17, 0xc6, 0xa2, 0x73, 0x28, 0x09, + /*2320:*/ 0x8a, 0x9a, 0x02, 0x1d, 0x55, 0x86, 0xdd, 0x2f, 0x02, 0x9c, 0x3b, 0x8e, 0x2c, 0x54, 0x14, 0x62, + /*2330:*/ 0x5a, 0x5a, 0x96, 0x97, 0x40, 0x55, 0xd2, 0x8f, 0xb9, 0x79, 0x4e, 0x9a, 0xe0, 0xb3, 0xb8, 0xa9, + /*2340:*/ 0xfe, 0xbb, 0xc5, 0xca, 0x9a, 0x07, 0x9d, 0x20, 0x89, 0x9b, 0xb0, 0x2d, 0x57, 0xc9, 0x74, 0xbe, + /*2350:*/ 0x21, 0xc8, 0xd9, 0x6d, 0x3a, 0x12, 0xcd, 0xa8, 0xb4, 0xa4, 0x44, 0x2c, 0xca, 0xff, 0x5c, 0xd0, + /*2360:*/ 0xa0, 0x0a, 0x1f, 0xe4, 0x1b, 0x68, 0xbe, 0xe6, 0x27, 0xa6, 0x41, 0x58, 0xf9, 0x45, 0x5d, 0xd5, + /*2370:*/ 0xb0, 0x5e, 0x03, 0x29, 0xa0, 0xa7, 0x38, 0xfd, 0x80, 0x30, 0xa8, 0x59, 0x15, 0xc5, 0x9a, 0x73, + /*2380:*/ 0xb1, 0x37, 0xe9, 0x1f, 0xfe, 0x24, 0x29, 0x25, 0xdb, 0x02, 0xd4, 0x31, 0xbc, 0xff, 0x51, 0xc0, + /*2390:*/ 0x6a, 0xee, 0x2c, 0xc5, 0xe7, 0x99, 0xa2, 0x3f, 0xeb, 0xbe, 0x12, 0x89, 0xfd, 0xd7, 0x81, 0xe3, + /*23a0:*/ 0x2b, 0xc2, 0x17, 0x83, 0x4d, 0x0e, 0x38, 0x3d, 0x5a, 0xae, 0xf3, 0xdf, 0xd1, 0xcb, 0x1b, 0xca, + /*23b0:*/ 0x6f, 0xfc, 0xe9, 0xd4, 0x22, 0x6a, 0x1d, 0x22, 0xe2, 0xef, 0x2e, 0xde, 0xcd, 0x24, 0x93, 0xf1, + /*23c0:*/ 0x8f, 0xff, 0x43, 0x31, 0x63, 0x6b, 0xc9, 0xfc, 0x87, 0x77, 0xbe, 0x5b, 0x1c, 0x65, 0xad, 0x90, + /*23d0:*/ 0xd0, 0x5a, 0x63, 0x00, 0x3c, 0x41, 0x68, 0x2b, 0x1d, 0xdf, 0x4b, 0x72, 0x8c, 0xdd, 0x0a, 0x9b, + /*23e0:*/ 0xe6, 0xab, 0x61, 0x2f, 0xe8, 0xaa, 0x1a, 0x0f, 0x3a, 0x9b, 0x1a, 0x46, 0x6a, 0xf2, 0xaa, 0x2c, + /*23f0:*/ 0xa9, 0x20, 0xab, 0xf0, 0xb3, 0x6a, 0xd9, 0x8a, 0x8e, 0x28, 0x40, 0xb6, 0xd4, 0x47, 0x86, 0x0f, + /*2400:*/ 0x86, 0x10, 0x9c, 0xbc, 0xad, 0x68, 0x19, 0x3c, 0x4d, 0xed, 0x32, 0xa7, 0xfd, 0x26, 0xa1, 0x69, + /*2410:*/ 0x15, 0xf4, 0xe1, 0x59, 0x48, 0x9d, 0xab, 0x05, 0x46, 0x54, 0x3a, 0xcc, 0x77, 0x91, 0xfd, 0x48, + /*2420:*/ 0x21, 0x49, 0x98, 0x26, 0x9a, 0x08, 0xe9, 0x63, 0x3b, 0x43, 0x0b, 0x00, 0xa4, 0x51, 0xf3, 0xcb, + /*2430:*/ 0x95, 0xba, 0x03, 0x48, 0xd7, 0x6e, 0x43, 0xdc, 0x6a, 0xfa, 0x35, 0x83, 0x19, 0xd9, 0xc0, 0x90, + /*2440:*/ 0x3d, 0x8b, 0x22, 0x63, 0xaf, 0xb5, 0x00, 0x5d, 0x65, 0x2c, 0x5f, 0xbc, 0xad, 0x40, 0x94, 0x55, + /*2450:*/ 0x23, 0x0e, 0x1d, 0x14, 0x51, 0x01, 0x64, 0x28, 0x94, 0x39, 0xbc, 0x50, 0x9c, 0x76, 0xbf, 0x6c, + /*2460:*/ 0xd2, 0xc3, 0xd9, 0xd6, 0x8f, 0x20, 0x46, 0xe4, 0xe0, 0x6e, 0x2a, 0x36, 0x48, 0x03, 0x2c, 0x1b, + /*2470:*/ 0xc1, 0xdb, 0x9d, 0x91, 0x30, 0xfc, 0xf7, 0x8f, 0x05, 0x73, 0xac, 0xcc, 0x7d, 0xc6, 0x2a, 0x0f, + /*2480:*/ 0xc6, 0xce, 0xd6, 0x6c, 0xc9, 0x2a, 0x9f, 0x80, 0x58, 0xd0, 0x84, 0x16, 0xd6, 0xe2, 0xe8, 0x75, + /*2490:*/ 0x0e, 0x93, 0x96, 0x1b, 0xb3, 0xa3, 0x60, 0x24, 0x30, 0x9d, 0x67, 0xaf, 0xc3, 0x16, 0xe0, 0x36, + /*24a0:*/ 0xdc, 0x6e, 0x59, 0xf6, 0x81, 0xfb, 0x6c, 0x5e, 0x96, 0x5c, 0xd3, 0xac, 0xa3, 0x29, 0xdf, 0x02, + /*24b0:*/ 0xf3, 0x3c, 0x47, 0x1f, 0x94, 0x26, 0x9f, 0x18, 0x80, 0xc1, 0x28, 0xeb, 0x23, 0xd5, 0x7d, 0x2a, + /*24c0:*/ 0x73, 0x7d, 0x44, 0x40, 0x48, 0x33, 0x64, 0x4f, 0x9c, 0x69, 0x12, 0xe6, 0xa8, 0x58, 0xa6, 0x10, + /*24d0:*/ 0x50, 0x64, 0xb1, 0x3c, 0x6c, 0x07, 0x7e, 0xf5, 0x2d, 0x87, 0x3a, 0x67, 0xa7, 0x72, 0xad, 0xaa, + /*24e0:*/ 0xe8, 0x07, 0x51, 0xf0, 0xbf, 0x5d, 0x91, 0xc5, 0x3d, 0xba, 0x82, 0xe6, 0xd6, 0xf3, 0x06, 0x42, + /*24f0:*/ 0x38, 0x12, 0x84, 0xc1, 0x4c, 0x16, 0xc4, 0xbf, 0xca, 0xcc, 0x88, 0xcf, 0x6d, 0xb3, 0x64, 0xb7, + /*2500:*/ 0x83, 0x3d, 0xb3, 0xc4, 0xeb, 0x8a, 0xb4, 0x51, 0xe2, 0xd2, 0xa7, 0x7d, 0x7a, 0x42, 0x06, 0x76, + /*2510:*/ 0x12, 0xd2, 0xd6, 0x93, 0x59, 0xa4, 0xd9, 0x03, 0xf1, 0x86, 0x9b, 0xb3, 0xb7, 0x95, 0xcc, 0xe6, + /*2520:*/ 0x9f, 0x58, 0x50, 0x65, 0xfc, 0xbd, 0x56, 0xd3, 0x0c, 0x62, 0xc7, 0x26, 0x18, 0x37, 0x9f, 0x1f, + /*2530:*/ 0x59, 0x2e, 0x19, 0x85, 0x53, 0x2f, 0x89, 0x34, 0x6d, 0xcd, 0x55, 0x5b, 0x43, 0xe9, 0x04, 0x58, + /*2540:*/ 0x3d, 0x5d, 0x35, 0x8e, 0x87, 0xcc, 0x0b, 0x86, 0x3f, 0x6f, 0xdc, 0x2e, 0xb2, 0xf6, 0x9a, 0x34, + /*2550:*/ 0x32, 0xef, 0x53, 0x27, 0xbd, 0x7f, 0x46, 0xce, 0xf5, 0x12, 0x45, 0x61, 0x30, 0x05, 0x75, 0xa7, + /*2560:*/ 0x15, 0x6a, 0xb2, 0xe5, 0x64, 0xde, 0x84, 0x1b, 0xef, 0x1d, 0xeb, 0x9d, 0xc8, 0x40, 0x59, 0xf7, + /*2570:*/ 0xd7, 0x8d, 0xb1, 0x43, 0x4d, 0xbf, 0xb8, 0x6f, 0x5f, 0x1e, 0xd8, 0x78, 0xb0, 0x76, 0x6c, 0x98, + /*2580:*/ 0xb3, 0xc5, 0xe6, 0x42, 0xe6, 0x75, 0xfd, 0xeb, 0x5b, 0xc4, 0xea, 0xa8, 0xc3, 0x09, 0x0c, 0x14, + /*2590:*/ 0x10, 0xd3, 0x07, 0x51, 0x18, 0xb7, 0x92, 0x96, 0x9c, 0x89, 0x69, 0xa6, 0xba, 0xe4, 0xed, 0x46, + /*25a0:*/ 0xdd, 0x8a, 0x2b, 0x72, 0x79, 0xe5, 0x99, 0xb6, 0x9e, 0x9a, 0x6e, 0x43, 0x6f, 0xd8, 0xbb, 0x1f, + /*25b0:*/ 0xea, 0x95, 0xe4, 0x91, 0xfd, 0x22, 0x9a, 0xa3, 0x70, 0x17, 0x4e, 0x20, 0xc9, 0x58, 0x8b, 0x68, + /*25c0:*/ 0xac, 0xcb, 0x5a, 0xc6, 0xdb, 0xe4, 0x3d, 0xb6, 0x38, 0x64, 0x9a, 0x92, 0xe2, 0x7d, 0xf0, 0x4d, + /*25d0:*/ 0x7f, 0x7d, 0x32, 0x2c, 0xf1, 0xc5, 0x5f, 0xf6, 0x69, 0x87, 0xa9, 0x5d, 0x28, 0x5b, 0x4c, 0x47, + /*25e0:*/ 0xd9, 0x6a, 0x2f, 0x30, 0xdc, 0x94, 0x08, 0xe7, 0x19, 0x85, 0x82, 0x8d, 0xf7, 0xce, 0x71, 0x5e, + /*25f0:*/ 0x14, 0x5a, 0x69, 0x2a, 0xb1, 0x43, 0x4c, 0xc4, 0xd1, 0xbf, 0xcb, 0x22, 0x57, 0xa4, 0x17, 0x48, + /*2600:*/ 0x41, 0x40, 0x19, 0xb6, 0xed, 0x43, 0xf6, 0xba, 0xec, 0x75, 0x34, 0xd7, 0x1b, 0xf8, 0x24, 0x75, + /*2610:*/ 0xb2, 0xd3, 0x5c, 0xf3, 0xa1, 0x09, 0xea, 0xa7, 0xd8, 0x51, 0x83, 0xc4, 0xe1, 0x19, 0x4a, 0x6f, + /*2620:*/ 0x18, 0x23, 0xba, 0x6d, 0xea, 0x68, 0xf2, 0x9f, 0x94, 0xbd, 0x7a, 0xdc, 0xb8, 0xbf, 0x31, 0x1a, + /*2630:*/ 0x9e, 0xfa, 0xa2, 0xcd, 0xd2, 0x06, 0xc5, 0xd4, 0x40, 0xeb, 0x36, 0xca, 0x5a, 0xd6, 0xc6, 0x1e, + /*2640:*/ 0x4d, 0xdf, 0xcd, 0x9d, 0x0e, 0x03, 0x8a, 0x17, 0x0e, 0x14, 0x71, 0xf4, 0xf8, 0x7b, 0x0b, 0x3e, + /*2650:*/ 0x75, 0xf2, 0xed, 0x86, 0xe7, 0x80, 0xa8, 0xdc, 0x49, 0x2f, 0xe7, 0xc8, 0x4c, 0xa4, 0x41, 0x31, + /*2660:*/ 0xe5, 0xa4, 0x18, 0x26, 0x92, 0xd9, 0x8d, 0xb6, 0x7d, 0x8e, 0xaa, 0xff, 0x36, 0xdd, 0x05, 0x6e, + /*2670:*/ 0x90, 0x3f, 0x4c, 0xf8, 0x9d, 0xbc, 0xba, 0x80, 0x23, 0xa8, 0x0e, 0xff, 0x30, 0x3a, 0x72, 0x35, + /*2680:*/ 0xa2, 0x0d, 0x5d, 0xcc, 0xcf, 0xef, 0xc1, 0x85, 0x50, 0xdd, 0x44, 0x1e, 0x2b, 0x27, 0x1d, 0x24, + /*2690:*/ 0x69, 0x3c, 0xc6, 0x1d, 0xdc, 0xd7, 0x36, 0xbb, 0xc4, 0xd9, 0x6e, 0xb2, 0x47, 0x1a, 0x10, 0x31, + /*26a0:*/ 0xe8, 0x0d, 0xcd, 0x1a, 0x6e, 0x5f, 0xf4, 0xeb, 0xb9, 0xa2, 0xa9, 0xaa, 0x2e, 0x24, 0x63, 0xf2, + /*26b0:*/ 0x06, 0x8d, 0xa2, 0x9e, 0x43, 0x67, 0x5f, 0x54, 0x46, 0xa4, 0x9a, 0x21, 0xab, 0x3a, 0x94, 0xb9, + /*26c0:*/ 0x31, 0x26, 0x2b, 0x00, 0xd9, 0xc8, 0x8a, 0xd9, 0x21, 0x57, 0x1d, 0xad, 0x5b, 0xe7, 0x16, 0x97, + /*26d0:*/ 0x7b, 0xaf, 0xdc, 0x29, 0x0e, 0x65, 0xbb, 0xa6, 0x37, 0x60, 0xd3, 0x3a, 0x16, 0x54, 0xad, 0xc2, + /*26e0:*/ 0x24, 0x16, 0x37, 0x50, 0x70, 0xa4, 0xbf, 0x2f, 0x2e, 0xbb, 0x70, 0x7f, 0x8c, 0x02, 0x79, 0xd4, + /*26f0:*/ 0xd8, 0xcd, 0x30, 0x86, 0x41, 0xb2, 0x04, 0xee, 0x02, 0x48, 0xc4, 0xe3, 0x0f, 0x07, 0x16, 0x33, + /*2700:*/ 0x84, 0xb9, 0xe3, 0xcb, 0x93, 0x08, 0x0a, 0xb9, 0x43, 0xa3, 0xde, 0x93, 0x3c, 0x28, 0x87, 0xc6, + /*2710:*/ 0x86, 0xcd, 0x2c, 0x76, 0xf1, 0xcf, 0x6b, 0x9d, 0x5f, 0xe5, 0x4a, 0x2d, 0xf6, 0xa5, 0xaf, 0x07, + /*2720:*/ 0x86, 0xa1, 0x47, 0xa7, 0x2a, 0xb3, 0xa7, 0xa7, 0x58, 0xe4, 0x0f, 0x8c, 0x01, 0xe3, 0x1d, 0x9a, + /*2730:*/ 0xc5, 0xe6, 0xac, 0x1b, 0x54, 0xf0, 0x67, 0x9b, 0x41, 0xdd, 0x28, 0x6a, 0xed, 0xf0, 0x09, 0x3a, + /*2740:*/ 0xd1, 0x73, 0x7a, 0x22, 0x4f, 0x1e, 0x51, 0xa4, 0xdf, 0x72, 0xf7, 0xef, 0xb9, 0xbb, 0x3b, 0x4d, + /*2750:*/ 0x12, 0x3b, 0xd3, 0xcb, 0x3d, 0xe2, 0xe4, 0x2b, 0x11, 0x9b, 0x3a, 0xa1, 0x53, 0xaa, 0xeb, 0xc4, + /*2760:*/ 0xc9, 0xbc, 0x1c, 0x58, 0xd1, 0x52, 0x8f, 0x32, 0xac, 0xee, 0x91, 0xe6, 0x2f, 0x24, 0x92, 0x33, + /*2770:*/ 0xdd, 0xe5, 0xab, 0x20, 0x8c, 0x5f, 0x2a, 0x17, 0x93, 0x25, 0x9e, 0xb7, 0x93, 0x60, 0x6e, 0xde, + /*2780:*/ 0x42, 0x5e, 0x76, 0x54, 0xe9, 0x33, 0xf2, 0xd0, 0x8a, 0x15, 0xec, 0x0b, 0xff, 0x40, 0xf2, 0xe7, + /*2790:*/ 0x2e, 0x17, 0xeb, 0x36, 0x13, 0x9d, 0xe3, 0xd2, 0xa4, 0x14, 0x27, 0xbe, 0x8f, 0x3a, 0x80, 0xa7, + /*27a0:*/ 0x5d, 0xb8, 0xa7, 0xf6, 0x6a, 0x7f, 0x39, 0xdb, 0xa6, 0x39, 0x14, 0xfa, 0x57, 0xa7, 0x77, 0xbf, + /*27b0:*/ 0xe3, 0xe4, 0xf0, 0x8f, 0x13, 0x85, 0xd4, 0x21, 0xfb, 0x5c, 0x0d, 0xb8, 0xea, 0x0a, 0xb5, 0xb4, + /*27c0:*/ 0x92, 0x9f, 0x2b, 0x48, 0x47, 0x14, 0x26, 0x04, 0x4c, 0xe9, 0x66, 0x11, 0x55, 0x09, 0x09, 0x81, + /*27d0:*/ 0x80, 0x04, 0x2c, 0x3d, 0x2e, 0x53, 0x28, 0x5e, 0x75, 0x34, 0xc5, 0x26, 0x03, 0xfe, 0x1a, 0xe5, + /*27e0:*/ 0x69, 0xea, 0xec, 0x65, 0x5f, 0xaa, 0x8f, 0x51, 0xfe, 0x66, 0xd2, 0x7c, 0x14, 0x95, 0xfc, 0xaf, + /*27f0:*/ 0x93, 0x95, 0xe9, 0x2a, 0x21, 0x73, 0x19, 0x03, 0xc0, 0x22, 0xb8, 0xcb, 0xfa, 0x70, 0xde, 0xb1, + /*2800:*/ 0x22, 0xa5, 0xc1, 0xf5, 0x7c, 0xb1, 0xe4, 0x27, 0xbc, 0xd5, 0xcf, 0x5f, 0x8d, 0x0c, 0xb1, 0x32, + /*2810:*/ 0x32, 0x42, 0xa0, 0x9a, 0x4e, 0xbf, 0x49, 0x8f, 0xb1, 0xd9, 0x54, 0xe9, 0x43, 0x87, 0x62, 0xb2, + /*2820:*/ 0xe5, 0xc8, 0xda, 0xbb, 0x94, 0x2c, 0x70, 0x98, 0x53, 0x34, 0xaa, 0x5e, 0x6e, 0x83, 0x62, 0x33, + /*2830:*/ 0x82, 0xeb, 0x3f, 0xa2, 0x3b, 0x47, 0xfa, 0x8a, 0x53, 0x9f, 0xc4, 0xff, 0x5f, 0x42, 0x54, 0xea, + /*2840:*/ 0x39, 0xf6, 0xc5, 0x6f, 0x25, 0xcb, 0x8e, 0xc2, 0x6a, 0xa2, 0x89, 0xed, 0x4d, 0xee, 0x3b, 0xe9, + /*2850:*/ 0xba, 0x33, 0x84, 0x55, 0xc3, 0x3e, 0xae, 0xba, 0xd4, 0x1a, 0x15, 0x76, 0xe8, 0x86, 0x6c, 0xf2, + /*2860:*/ 0x71, 0x9e, 0xa9, 0x53, 0x47, 0xbc, 0x84, 0x0a, 0xdf, 0x7e, 0x76, 0x58, 0xdd, 0x29, 0x11, 0x33, + /*2870:*/ 0xa8, 0xf4, 0x83, 0xe9, 0xad, 0x0f, 0x49, 0x14, 0x5d, 0xd2, 0x1d, 0xa7, 0x9a, 0xa7, 0x99, 0xdb, + /*2880:*/ 0xff, 0x6c, 0x7d, 0x15, 0x8d, 0x8a, 0x57, 0x2e, 0x20, 0x0a, 0xcb, 0x45, 0x76, 0x0b, 0x7b, 0xf0, + /*2890:*/ 0x7f, 0xb7, 0x76, 0x74, 0x25, 0xec, 0x3c, 0x57, 0xd7, 0x59, 0xb0, 0x8e, 0xef, 0xb3, 0x69, 0xa6, + /*28a0:*/ 0x56, 0x78, 0x16, 0x52, 0x5a, 0xa1, 0x1a, 0xf1, 0x71, 0xe6, 0xfb, 0x0e, 0xcc, 0xde, 0xa7, 0xf5, + /*28b0:*/ 0x13, 0x3f, 0xe4, 0x6a, 0x8f, 0x59, 0xb1, 0x99, 0x3b, 0x87, 0x51, 0xee, 0x93, 0x50, 0xd6, 0xac, + /*28c0:*/ 0x70, 0xc6, 0xd8, 0x62, 0xad, 0x35, 0xc0, 0xb4, 0xd4, 0x2b, 0xba, 0x47, 0x5c, 0x7d, 0xc9, 0xb5, + /*28d0:*/ 0x77, 0x88, 0xf2, 0x89, 0x2e, 0x0e, 0x32, 0x9d, 0x7f, 0xc5, 0x23, 0x59, 0xc7, 0x9c, 0x2e, 0xa4, + /*28e0:*/ 0x55, 0x9f, 0xd1, 0xbd, 0xaf, 0x79, 0x22, 0xb3, 0xdc, 0xb6, 0xb0, 0xc4, 0xa6, 0x94, 0x0b, 0x75, + /*28f0:*/ 0x84, 0x73, 0xb4, 0x9e, 0xed, 0xd5, 0x7b, 0x4d, 0x2c, 0x99, 0x38, 0x40, 0xd1, 0xec, 0x86, 0x20, + /*2900:*/ 0x98, 0xe4, 0x4b, 0xad, 0xa4, 0x1f, 0x52, 0xb1, 0x1e, 0xc1, 0x6a, 0x36, 0xe1, 0x81, 0x01, 0xf8, + /*2910:*/ 0xea, 0xbf, 0xaf, 0x50, 0xcb, 0x26, 0x91, 0xc0, 0xaf, 0x58, 0x83, 0x18, 0x35, 0x9f, 0x5d, 0x81, + /*2920:*/ 0x2d, 0xb6, 0x57, 0x44, 0xce, 0x5f, 0x90, 0x0d, 0x80, 0x6c, 0xd3, 0xc7, 0x54, 0x09, 0x17, 0xde, + /*2930:*/ 0xe7, 0x6c, 0xef, 0x31, 0xa5, 0x19, 0xc3, 0xfd, 0x8e, 0x66, 0xd5, 0x6c, 0x12, 0x3c, 0x42, 0xc6, + /*2940:*/ 0x35, 0xc8, 0x76, 0x06, 0x1e, 0xc0, 0xfc, 0xe7, 0xc0, 0x0c, 0x0c, 0x79, 0xec, 0x36, 0x82, 0xf2, + /*2950:*/ 0xcc, 0x60, 0x97, 0x2e, 0xf7, 0x81, 0x35, 0xa0, 0x47, 0x1b, 0xbc, 0xfe, 0x2e, 0x0f, 0xdc, 0xfc, + /*2960:*/ 0xa6, 0xc2, 0xe5, 0x86, 0x4f, 0x26, 0x8d, 0x45, 0x1f, 0x41, 0xdf, 0x94, 0x0c, 0x7e, 0x56, 0x3f, + /*2970:*/ 0x1c, 0x8a, 0xfd, 0x31, 0x83, 0xf8, 0x14, 0x25, 0xf0, 0x01, 0x42, 0x26, 0xe3, 0xf8, 0x9a, 0x17, + /*2980:*/ 0xa8, 0x9b, 0x88, 0x39, 0x52, 0x1e, 0x4b, 0x8b, 0x06, 0x67, 0x75, 0x7d, 0xa1, 0x11, 0x4a, 0x98, + /*2990:*/ 0x2c, 0x84, 0x91, 0x87, 0xdc, 0x4a, 0xf7, 0x8d, 0x81, 0x60, 0x85, 0xb9, 0xd8, 0x70, 0x55, 0xa6, + /*29a0:*/ 0xae, 0x44, 0xbd, 0x27, 0x2a, 0x4e, 0x36, 0xcc, 0x02, 0x8e, 0x21, 0x4b, 0xbf, 0xdc, 0x86, 0xa8, + /*29b0:*/ 0xb8, 0x61, 0xad, 0x98, 0x96, 0xd5, 0x02, 0xc5, 0x1f, 0xe2, 0x6b, 0xf3, 0x4c, 0x54, 0xc0, 0x4f, + /*29c0:*/ 0xfb, 0x39, 0x1a, 0xf7, 0x2e, 0x56, 0xc8, 0x95, 0x7e, 0x1f, 0xeb, 0xa9, 0x1e, 0xec, 0xe7, 0x48, + /*29d0:*/ 0x2c, 0x03, 0x11, 0xde, 0xec, 0x97, 0x23, 0x2e, 0x16, 0x42, 0x4c, 0xdd, 0x4b, 0x18, 0x32, 0x6e, + /*29e0:*/ 0x6e, 0x0e, 0x1f, 0xf9, 0x69, 0xbd, 0xde, 0xf9, 0x37, 0xb8, 0xf8, 0x98, 0xf8, 0x5c, 0x88, 0xaa, + /*29f0:*/ 0x61, 0xb3, 0xe7, 0x79, 0x92, 0x68, 0xef, 0x86, 0x04, 0xba, 0x18, 0x5e, 0xa6, 0x03, 0x68, 0x4b, + /*2a00:*/ 0x26, 0xe5, 0x5f, 0x0f, 0xf6, 0xb2, 0xae, 0x02, 0x40, 0xbe, 0xa7, 0x1a, 0xec, 0x22, 0x5e, 0xe6, + /*2a10:*/ 0x21, 0x42, 0xd9, 0xb0, 0xd2, 0xe4, 0x89, 0xf5, 0xd0, 0x2d, 0xd6, 0x23, 0x39, 0xc9, 0xdb, 0xeb, + /*2a20:*/ 0x53, 0x55, 0xbf, 0x01, 0x36, 0x17, 0xf9, 0x05, 0x20, 0x80, 0x13, 0x38, 0x32, 0x2d, 0x09, 0x98, + /*2a30:*/ 0x04, 0x6a, 0x90, 0x6c, 0x18, 0x52, 0x41, 0x82, 0xc7, 0x0c, 0xe9, 0xae, 0x12, 0x35, 0xc9, 0xaf, + /*2a40:*/ 0x43, 0x52, 0x68, 0x19, 0x2f, 0xff, 0x75, 0xf7, 0xab, 0x9d, 0x58, 0x13, 0x0f, 0xa4, 0x17, 0x3f, + /*2a50:*/ 0x9f, 0x29, 0x37, 0xb9, 0x28, 0x00, 0x19, 0x06, 0xb9, 0xe9, 0x54, 0x6d, 0xa7, 0x21, 0x58, 0xf9, + /*2a60:*/ 0xa5, 0xf2, 0xc5, 0x10, 0x50, 0x0d, 0x50, 0x0d, 0xb4, 0xe5, 0xb8, 0x27, 0xa3, 0xe7, 0xab, 0x25, + /*2a70:*/ 0x8d, 0x8c, 0x09, 0x28, 0xd8, 0x8c, 0x69, 0x34, 0xd2, 0x8e, 0xa1, 0xf7, 0x49, 0x35, 0xa0, 0x2f, + /*2a80:*/ 0x06, 0x38, 0x57, 0xfe, 0x6f, 0xdc, 0x68, 0xcd, 0xfc, 0x71, 0xf1, 0x9e, 0xb9, 0x1e, 0x75, 0xff, + /*2a90:*/ 0x90, 0x36, 0xbc, 0x7a, 0x86, 0x65, 0xd3, 0xeb, 0x71, 0xa1, 0x62, 0x05, 0x33, 0xa5, 0x3c, 0xe5, + /*2aa0:*/ 0x2b, 0xfd, 0x7b, 0x4c, 0x25, 0x6f, 0x7b, 0xba, 0xdf, 0x90, 0x9e, 0xed, 0x8c, 0x1a, 0x7b, 0xac, + /*2ab0:*/ 0x08, 0xa7, 0x7d, 0xf4, 0xf4, 0xa2, 0x60, 0x48, 0xd5, 0x53, 0x39, 0xb4, 0xd9, 0x59, 0x8c, 0xcc, + /*2ac0:*/ 0x20, 0xb7, 0x16, 0x97, 0x7e, 0xd9, 0x6f, 0x2b, 0x57, 0xd9, 0xb5, 0xfa, 0x67, 0x3f, 0xc6, 0x45, + /*2ad0:*/ 0x50, 0x16, 0x24, 0x46, 0x4f, 0x5c, 0xfe, 0x43, 0xc7, 0x7d, 0x35, 0xec, 0x69, 0x41, 0xf6, 0x8f, + /*2ae0:*/ 0xaf, 0x55, 0x53, 0x43, 0xc7, 0x08, 0x1c, 0x15, 0x0e, 0x77, 0xea, 0x2d, 0x80, 0x05, 0xf6, 0x5e, + /*2af0:*/ 0x66, 0x93, 0x9b, 0x2b, 0xd8, 0xc3, 0xc1, 0xf4, 0x3a, 0x6e, 0x1a, 0x81, 0x7e, 0xba, 0x14, 0xe2, + /*2b00:*/ 0x62, 0x13, 0xb4, 0x2b, 0x64, 0x83, 0x75, 0x8d, 0x7c, 0xce, 0x9d, 0xbd, 0x65, 0xd5, 0x4b, 0x28, + /*2b10:*/ 0x37, 0xb3, 0xc2, 0x7c, 0xcd, 0xbd, 0x68, 0x52, 0xa9, 0x23, 0x3e, 0xdf, 0xb6, 0xec, 0x34, 0x06, + /*2b20:*/ 0x36, 0xd7, 0x41, 0x1e, 0xff, 0x03, 0xa3, 0x53, 0x76, 0x06, 0x05, 0x1f, 0xe0, 0x56, 0xc7, 0xb5, + /*2b30:*/ 0x13, 0xc1, 0x82, 0x6c, 0x72, 0x9f, 0x9f, 0xa5, 0x33, 0x68, 0x2f, 0x54, 0x75, 0x02, 0xd6, 0xfa, + /*2b40:*/ 0x02, 0x9d, 0xe2, 0xde, 0xaf, 0x77, 0xb6, 0x5d, 0xc7, 0xa6, 0xff, 0xaf, 0x91, 0x07, 0x63, 0xd5, + /*2b50:*/ 0x75, 0xf4, 0xa6, 0xf6, 0x66, 0xe2, 0x8c, 0xb0, 0xf5, 0x40, 0xd8, 0xc3, 0xfd, 0x7c, 0xb7, 0xe4, + /*2b60:*/ 0x6f, 0xd1, 0xfa, 0xe5, 0x86, 0xba, 0x04, 0xb4, 0x65, 0xba, 0x92, 0x80, 0xa0, 0x40, 0x2c, 0xe1, + /*2b70:*/ 0x5f, 0xdb, 0xc3, 0x62, 0x73, 0xf7, 0xa9, 0x9d, 0xbf, 0x17, 0x13, 0x6d, 0xc9, 0x4a, 0x8a, 0x51, + /*2b80:*/ 0x72, 0x8f, 0xad, 0x35, 0x5a, 0xac, 0x43, 0x70, 0xd2, 0xc2, 0x64, 0xaf, 0x33, 0x76, 0xe5, 0xda, + /*2b90:*/ 0x59, 0xb2, 0xdf, 0x54, 0x61, 0x9f, 0x9a, 0xa3, 0x57, 0x74, 0xf1, 0x22, 0xcc, 0x4d, 0x87, 0x68, + /*2ba0:*/ 0x4f, 0x77, 0xcb, 0xc1, 0x7c, 0xb5, 0xaf, 0x6f, 0xe0, 0x79, 0xbd, 0xa6, 0x2b, 0xf1, 0xb3, 0x4c, + /*2bb0:*/ 0xcf, 0x7e, 0xa4, 0x41, 0x32, 0x49, 0x72, 0x8b, 0x3c, 0xaf, 0xe4, 0xf4, 0x38, 0x30, 0x95, 0xb7, + /*2bc0:*/ 0x16, 0x80, 0x59, 0x18, 0x3d, 0x24, 0x91, 0xa5, 0x13, 0x4e, 0x8e, 0xe3, 0xe0, 0x55, 0x86, 0x3c, + /*2bd0:*/ 0xe9, 0x28, 0xae, 0x85, 0x2a, 0x08, 0xa0, 0xa5, 0x99, 0xdd, 0x66, 0xfd, 0x55, 0x4f, 0x71, 0x73, + /*2be0:*/ 0x05, 0xd6, 0x82, 0xbf, 0x7f, 0x4c, 0x3f, 0x20, 0xaf, 0x7d, 0x15, 0x71, 0x5a, 0x1a, 0x11, 0xaf, + /*2bf0:*/ 0xcc, 0xc8, 0x3f, 0x3a, 0x20, 0x0e, 0x87, 0x31, 0xdb, 0x6a, 0xe7, 0x41, 0x26, 0x72, 0xce, 0xe0, + /*2c00:*/ 0xd7, 0x69, 0x04, 0x34, 0x58, 0x82, 0xac, 0x25, 0x70, 0x0f, 0x2a, 0x71, 0x4b, 0x03, 0x39, 0x74, + /*2c10:*/ 0x74, 0x7a, 0x42, 0xde, 0x91, 0xaa, 0xdf, 0xf3, 0x9c, 0x7f, 0x72, 0x54, 0x40, 0x31, 0x01, 0xfd, + /*2c20:*/ 0x71, 0xc5, 0x2d, 0x5e, 0xfa, 0xb9, 0xab, 0x2c, 0x86, 0x63, 0x6e, 0xa7, 0xde, 0x01, 0xe8, 0x0f, + /*2c30:*/ 0x97, 0x72, 0xa2, 0x18, 0x4b, 0xd8, 0xb1, 0x04, 0xd7, 0x66, 0x2b, 0xad, 0x5b, 0xe5, 0x2c, 0x68, + /*2c40:*/ 0x78, 0xb4, 0xb5, 0x28, 0xc3, 0x8b, 0x05, 0x01, 0xf3, 0xcc, 0xf0, 0x21, 0x30, 0x1b, 0xd4, 0xab, + /*2c50:*/ 0x0a, 0x97, 0x8e, 0x46, 0xcf, 0x9a, 0xc7, 0x40, 0xe2, 0xd0, 0x8f, 0x00, 0xd7, 0x02, 0x7e, 0xab, + /*2c60:*/ 0xd3, 0xd4, 0xf4, 0x8d, 0x1f, 0x3e, 0x29, 0x26, 0x17, 0xf6, 0x06, 0xfa, 0x41, 0x45, 0x53, 0xa6, + /*2c70:*/ 0x9d, 0x50, 0xdc, 0xf8, 0x19, 0x76, 0x83, 0xc7, 0x9c, 0xe3, 0x24, 0x24, 0xd3, 0x3a, 0x14, 0x61, + /*2c80:*/ 0xb5, 0x6b, 0x08, 0x21, 0x08, 0xb1, 0xe5, 0x64, 0x8f, 0x5c, 0x2f, 0x17, 0x47, 0xef, 0x89, 0x72, + /*2c90:*/ 0x9d, 0x9e, 0x24, 0x36, 0xe9, 0x38, 0x11, 0xf2, 0x1c, 0xaf, 0x15, 0xe3, 0xac, 0x90, 0x93, 0x91, + /*2ca0:*/ 0x22, 0x30, 0x7f, 0x4d, 0x13, 0x3f, 0x64, 0x5e, 0x60, 0xc0, 0xf3, 0x47, 0xad, 0xdb, 0x94, 0xc4, + /*2cb0:*/ 0x10, 0x2e, 0xdd, 0x45, 0x21, 0xc7, 0xca, 0x0d, 0xd2, 0x3e, 0xb8, 0x28, 0xa3, 0x6c, 0x75, 0xfd, + /*2cc0:*/ 0xbc, 0xf7, 0x05, 0x70, 0x00, 0xf6, 0xda, 0xc4, 0xd0, 0x6d, 0xa7, 0x67, 0x3a, 0xa2, 0x1e, 0x4f, + /*2cd0:*/ 0xdc, 0xf8, 0x5c, 0xde, 0xb8, 0x63, 0xe6, 0xcd, 0xcd, 0x9f, 0x63, 0x54, 0x34, 0xd4, 0xa7, 0xd2, + /*2ce0:*/ 0xcf, 0xef, 0x89, 0x81, 0x83, 0x93, 0xf1, 0xda, 0xee, 0x97, 0x5a, 0x97, 0x89, 0x62, 0x03, 0xc6, + /*2cf0:*/ 0x64, 0x9d, 0x1f, 0xbb, 0x4e, 0x11, 0xf8, 0x7f, 0x6e, 0x3a, 0xd9, 0x97, 0x0d, 0xb6, 0xf1, 0x8c, + /*2d00:*/ 0xfd, 0x2d, 0x21, 0x3a, 0x20, 0xee, 0x22, 0x0a, 0xca, 0x9a, 0x46, 0x95, 0x99, 0x70, 0x84, 0x62, + /*2d10:*/ 0x65, 0x4c, 0x56, 0x13, 0x9f, 0xc4, 0xf3, 0xb1, 0x3a, 0x05, 0xe9, 0x14, 0xec, 0xb4, 0x63, 0x17, + /*2d20:*/ 0x08, 0x63, 0xc5, 0x3c, 0x0f, 0xf2, 0x26, 0xea, 0x2e, 0xc1, 0x0d, 0xc8, 0xe8, 0x02, 0x36, 0xbb, + /*2d30:*/ 0x62, 0x69, 0x99, 0x0e, 0xfc, 0xa9, 0x84, 0x1a, 0xfa, 0x38, 0xb3, 0xac, 0x7f, 0x74, 0x9e, 0x7f, + /*2d40:*/ 0xad, 0xeb, 0x76, 0xab, 0x09, 0xba, 0x81, 0x4e, 0x2a, 0x68, 0x00, 0xce, 0x1f, 0xc2, 0xc2, 0x25, + /*2d50:*/ 0x86, 0x77, 0x70, 0x27, 0x23, 0xe7, 0xf2, 0x71, 0x50, 0xc2, 0x0b, 0x30, 0x98, 0xbc, 0x0d, 0xb3, + /*2d60:*/ 0x41, 0xa7, 0x30, 0xc4, 0x32, 0x96, 0x5d, 0xa8, 0x57, 0xa4, 0x89, 0x16, 0xd3, 0x4f, 0x4b, 0x6c, + /*2d70:*/ 0xb3, 0xea, 0xc3, 0x8f, 0xc1, 0x4b, 0x19, 0xc8, 0x3d, 0xea, 0xe3, 0xf2, 0x57, 0x94, 0x4f, 0x27, + /*2d80:*/ 0x87, 0x19, 0x07, 0x46, 0xfb, 0x3e, 0x52, 0x5c, 0xdc, 0x5b, 0xb4, 0xd5, 0xee, 0x16, 0x39, 0x70, + /*2d90:*/ 0x2c, 0x0c, 0xf2, 0xe5, 0x78, 0xef, 0x10, 0xe9, 0x0f, 0xbd, 0x30, 0xdb, 0x42, 0xb9, 0xb5, 0x04, + /*2da0:*/ 0x0f, 0xa6, 0x43, 0x7b, 0x93, 0x3b, 0xb5, 0xf3, 0xb0, 0x1c, 0x52, 0x5e, 0x68, 0xb4, 0xda, 0xba, + /*2db0:*/ 0x3b, 0x66, 0x50, 0x97, 0xcd, 0x26, 0xf0, 0x3c, 0x76, 0xa3, 0xad, 0xe1, 0x42, 0x00, 0xde, 0x59, + /*2dc0:*/ 0x90, 0x70, 0xf5, 0x2f, 0x71, 0xd5, 0x82, 0x83, 0xfb, 0x74, 0xd2, 0x46, 0xbc, 0xad, 0x40, 0xf3, + /*2dd0:*/ 0x37, 0x9e, 0x6e, 0xa6, 0xa7, 0x1a, 0x3e, 0xbb, 0x5b, 0xd3, 0x09, 0x04, 0x68, 0xcf, 0xdb, 0xdd, + /*2de0:*/ 0x9e, 0x31, 0x4d, 0xf9, 0x41, 0x8d, 0xf2, 0xfc, 0x8b, 0xc6, 0x84, 0xf0, 0x77, 0xd6, 0xf0, 0x33, + /*2df0:*/ 0x5f, 0x8c, 0x26, 0x23, 0x96, 0x7a, 0x28, 0x6c, 0xfd, 0x39, 0xab, 0xa8, 0x95, 0xd2, 0xa6, 0x93, + /*2e00:*/ 0xe0, 0x0e, 0xe5, 0x2d, 0x92, 0xa4, 0xee, 0xfe, 0x4e, 0x7e, 0x7e, 0xe3, 0xae, 0x1d, 0x85, 0xfb, + /*2e10:*/ 0xb7, 0xc3, 0x7c, 0x16, 0x83, 0x98, 0x62, 0x48, 0xfe, 0x97, 0xae, 0xc7, 0x43, 0x00, 0xc4, 0xe7, + /*2e20:*/ 0x62, 0xc1, 0xcf, 0xfe, 0x7d, 0xce, 0xbe, 0xdc, 0xfa, 0x73, 0xde, 0xc5, 0x04, 0x22, 0x56, 0x18, + /*2e30:*/ 0x9c, 0xf9, 0xea, 0xab, 0x3a, 0x82, 0xb6, 0xab, 0xc7, 0x55, 0xe1, 0xe7, 0x4e, 0x88, 0xc9, 0xf5, + /*2e40:*/ 0x48, 0x1a, 0x92, 0xd0, 0x2e, 0x2a, 0x00, 0xbe, 0x2f, 0x10, 0x74, 0x8e, 0xde, 0x04, 0x01, 0x82, + /*2e50:*/ 0xe3, 0x21, 0xc2, 0x63, 0xab, 0x2b, 0x68, 0x6a, 0x2b, 0xfb, 0xd8, 0xca, 0xb9, 0x8b, 0x75, 0xe3, + /*2e60:*/ 0xd5, 0xe3, 0xcf, 0x0d, 0xde, 0x70, 0x39, 0x88, 0x85, 0xa5, 0x52, 0x96, 0x6c, 0x95, 0x44, 0x8b, + /*2e70:*/ 0x5e, 0x31, 0x57, 0xb3, 0xe8, 0xef, 0x7a, 0x1e, 0xfa, 0x56, 0x4a, 0xe9, 0x5a, 0xb2, 0xba, 0x24, + /*2e80:*/ 0x01, 0x19, 0x1c, 0x4e, 0xa9, 0xd3, 0xdf, 0xcb, 0xe0, 0x48, 0xb1, 0xd6, 0x30, 0xca, 0xa8, 0x5c, + /*2e90:*/ 0x91, 0x2f, 0x37, 0x8b, 0x9a, 0x06, 0x2a, 0x4d, 0x30, 0x32, 0x13, 0x4b, 0x4b, 0x67, 0x61, 0xbc, + /*2ea0:*/ 0xc3, 0x74, 0xae, 0xeb, 0xcb, 0x45, 0xd6, 0xaa, 0xf7, 0x60, 0xb6, 0x4b, 0xf5, 0x83, 0xe8, 0x7f, + /*2eb0:*/ 0x3a, 0x91, 0xdd, 0x92, 0xfa, 0xe7, 0x49, 0x8c, 0x20, 0x60, 0x74, 0x68, 0xe5, 0x24, 0xce, 0xc1, + /*2ec0:*/ 0x83, 0xa7, 0x43, 0xb3, 0x8d, 0x3f, 0xd6, 0x23, 0x2b, 0x1c, 0xc5, 0x7d, 0xdc, 0x00, 0xea, 0x3f, + /*2ed0:*/ 0x78, 0xc8, 0x72, 0x9a, 0x59, 0x37, 0x86, 0xfb, 0x33, 0x35, 0x8f, 0x9f, 0x7d, 0x67, 0xe9, 0x6e, + /*2ee0:*/ 0x11, 0xd5, 0x0e, 0x95, 0x3d, 0xcc, 0xb7, 0x1d, 0x06, 0xf5, 0x72, 0x48, 0xdc, 0x8f, 0xbe, 0xbf, + /*2ef0:*/ 0xd2, 0x37, 0x03, 0xa9, 0x2f, 0xa6, 0x7e, 0x73, 0xd7, 0xbe, 0xd2, 0xd2, 0x21, 0xbf, 0x1d, 0xf4, + /*2f00:*/ 0x61, 0xd1, 0x58, 0x0e, 0x83, 0xcd, 0xdb, 0x2a, 0x94, 0x5c, 0xe7, 0x38, 0x34, 0x68, 0x3a, 0x12, + /*2f10:*/ 0x80, 0xa7, 0x2b, 0x5a, 0xc6, 0x49, 0x20, 0x8f, 0x45, 0x5d, 0x04, 0xcf, 0xc6, 0xc8, 0xa3, 0x24, + /*2f20:*/ 0xc7, 0x33, 0xb3, 0x6c, 0x63, 0x78, 0x8f, 0xcf, 0xe3, 0x61, 0xf5, 0xe3, 0x0a, 0x43, 0xfd, 0x89, + /*2f30:*/ 0x62, 0x82, 0xe0, 0x91, 0x66, 0xf4, 0x04, 0x60, 0xe2, 0x15, 0x1a, 0x81, 0xe2, 0x1e, 0x6f, 0xc6, + /*2f40:*/ 0xcc, 0x87, 0xe4, 0xb5, 0xf2, 0xe5, 0xcf, 0x22, 0x11, 0xfe, 0x03, 0x3a, 0xc3, 0x0f, 0x0c, 0xe7, + /*2f50:*/ 0xb7, 0x87, 0xf9, 0x45, 0x5a, 0x78, 0x18, 0xba, 0x73, 0x63, 0x4d, 0x89, 0x00, 0xeb, 0x35, 0xa6, + /*2f60:*/ 0xee, 0x71, 0xa1, 0xb1, 0x17, 0xc6, 0x83, 0x69, 0xab, 0x7a, 0x18, 0xed, 0xaa, 0x1c, 0x56, 0x88, + /*2f70:*/ 0x89, 0x3e, 0x3a, 0x54, 0x18, 0x7d, 0x3e, 0x72, 0x86, 0x0f, 0xa4, 0xfb, 0x96, 0x14, 0x12, 0x7b, + /*2f80:*/ 0x94, 0x3c, 0x6a, 0xbc, 0x8b, 0x2d, 0x81, 0x36, 0x24, 0x12, 0xfc, 0x73, 0x78, 0xcd, 0xe4, 0x7a, + /*2f90:*/ 0xfb, 0xd2, 0x48, 0xfa, 0x59, 0x8b, 0xf0, 0x2a, 0xe8, 0xae, 0xf5, 0x88, 0x31, 0xdf, 0xbe, 0x89, + /*2fa0:*/ 0x6b, 0x6e, 0xa1, 0x8f, 0x57, 0x94, 0x92, 0x0c, 0x0c, 0x23, 0x81, 0x6b, 0x48, 0x9b, 0xe7, 0x96, + /*2fb0:*/ 0xd3, 0xe3, 0x3b, 0x4a, 0xff, 0xe4, 0x7a, 0x79, 0xa2, 0x25, 0xf0, 0x08, 0x04, 0x59, 0x91, 0xe3, + /*2fc0:*/ 0x44, 0xa4, 0xf1, 0xe6, 0x56, 0x34, 0xc0, 0x94, 0x75, 0x51, 0x7c, 0x78, 0x71, 0xdd, 0xb9, 0x36, + /*2fd0:*/ 0xb8, 0xf5, 0xc3, 0xf4, 0xb6, 0x87, 0x72, 0xcb, 0x99, 0x79, 0x24, 0x12, 0xc8, 0x3e, 0xf6, 0xcd, + /*2fe0:*/ 0x00, 0x6f, 0x4e, 0x47, 0xac, 0x90, 0x08, 0x69, 0x26, 0xd2, 0x5e, 0x84, 0x71, 0x5f, 0xb2, 0x1e, + /*2ff0:*/ 0x7f, 0x3c, 0x9d, 0x9d, 0x11, 0x37, 0xa6, 0x2d, 0x12, 0x0c, 0xb3, 0x43, 0x2b, 0xe0, 0x03, 0x40, + /*3000:*/ 0x04, 0x7b, 0xc5, 0x3a, 0x76, 0xf1, 0xa0, 0xf6, 0x40, 0x30, 0x60, 0xf7, 0xe4, 0x08, 0x0f, 0x0e, + /*3010:*/ 0x3a, 0x7d, 0x2c, 0xac, 0xe1, 0x11, 0xfc, 0x01, 0xef, 0x9c, 0x5b, 0x94, 0xda, 0x52, 0x80, 0xe4, + /*3020:*/ 0x98, 0x17, 0x01, 0xc2, 0x95, 0xa2, 0xce, 0x8b, 0x61, 0xb2, 0x96, 0x70, 0xdc, 0xfc, 0x33, 0x63, + /*3030:*/ 0x25, 0xa2, 0x7a, 0x70, 0xe3, 0xb5, 0x65, 0x98, 0xe2, 0x99, 0x46, 0x54, 0x0d, 0x36, 0xff, 0xfd, + /*3040:*/ 0x36, 0x4d, 0x26, 0x4c, 0x1d, 0x67, 0xea, 0xd8, 0x2b, 0x0d, 0xd4, 0x9f, 0xab, 0x77, 0xde, 0x9d, + /*3050:*/ 0x0d, 0xa1, 0x12, 0x41, 0xa6, 0xc5, 0x37, 0x6d, 0x76, 0xdb, 0xdb, 0xa2, 0x90, 0xa3, 0xbf, 0x96, + /*3060:*/ 0xb7, 0xef, 0x0b, 0xd0, 0xf0, 0xda, 0x1e, 0x91, 0xcf, 0x4e, 0xd8, 0x18, 0x0e, 0x80, 0x0a, 0x4b, + /*3070:*/ 0x51, 0xf0, 0x05, 0xb0, 0x18, 0xc2, 0x95, 0xb7, 0xa6, 0x83, 0x66, 0x92, 0x99, 0x06, 0x0e, 0x93, + /*3080:*/ 0xff, 0x18, 0x70, 0x1c, 0x4f, 0xec, 0x72, 0x13, 0x38, 0xcb, 0x6d, 0xe7, 0x81, 0x7a, 0xb4, 0x90, + /*3090:*/ 0x16, 0xc2, 0xac, 0xaa, 0x09, 0xdc, 0x5b, 0xe2, 0x6a, 0xf3, 0xfe, 0xc6, 0x63, 0x17, 0x33, 0x72, + /*30a0:*/ 0xbd, 0xee, 0x7c, 0xb4, 0x1c, 0x54, 0x18, 0xff, 0x10, 0x87, 0xe1, 0x26, 0xe5, 0xa6, 0x1a, 0xba, + /*30b0:*/ 0xd3, 0x96, 0x31, 0xf1, 0x95, 0x71, 0xbf, 0xe2, 0x6e, 0x37, 0xaa, 0x89, 0x64, 0x94, 0xdf, 0x77, + /*30c0:*/ 0xc3, 0x26, 0x42, 0xe2, 0xc2, 0xa5, 0x62, 0xea, 0x02, 0x58, 0xa6, 0x55, 0x71, 0xe5, 0xf5, 0x5b, + /*30d0:*/ 0x3c, 0xea, 0x7f, 0x64, 0xac, 0xc0, 0xc4, 0x86, 0xc0, 0xa9, 0xeb, 0xcb, 0x17, 0x13, 0xff, 0x9e, + /*30e0:*/ 0xe0, 0xbb, 0xd0, 0x78, 0xfb, 0xfb, 0x5e, 0xe8, 0xb9, 0xbc, 0x71, 0x91, 0x67, 0x17, 0x18, 0x57, + /*30f0:*/ 0x66, 0x96, 0x10, 0x74, 0xca, 0xb9, 0x26, 0x7b, 0x4d, 0x70, 0xf0, 0xa7, 0x17, 0x45, 0xe8, 0x9a, + /*3100:*/ 0xe6, 0x8a, 0x20, 0xca, 0x70, 0x36, 0x05, 0x97, 0x9b, 0x72, 0x5b, 0xf4, 0x8d, 0x53, 0x53, 0xbb, + /*3110:*/ 0x7f, 0xdd, 0x50, 0xb7, 0x15, 0xec, 0xd2, 0x2f, 0x4b, 0xa6, 0xdc, 0x3d, 0x35, 0xf4, 0xa0, 0x33, + /*3120:*/ 0xaa, 0x3a, 0xff, 0x10, 0x6f, 0x90, 0x12, 0x28, 0x2b, 0x63, 0x07, 0xa6, 0x9d, 0xd9, 0xa7, 0x9a, + /*3130:*/ 0x3c, 0x70, 0xbd, 0x00, 0x8f, 0x32, 0x13, 0x70, 0xff, 0xd0, 0x19, 0x50, 0xcb, 0x96, 0x3f, 0xfe, + /*3140:*/ 0x11, 0x89, 0x27, 0xfb, 0xbf, 0x3d, 0x0d, 0x76, 0x99, 0x06, 0xc3, 0x75, 0xd4, 0xa4, 0x3c, 0xbe, + /*3150:*/ 0xdb, 0x7c, 0x0c, 0xf1, 0xb7, 0xf4, 0x56, 0xdd, 0x90, 0x54, 0xbd, 0x3e, 0x69, 0x15, 0xda, 0x17, + /*3160:*/ 0xf7, 0xb8, 0x06, 0xf5, 0xab, 0x2d, 0x69, 0xb2, 0xaf, 0xa9, 0x01, 0xa0, 0xc4, 0x61, 0x79, 0x63, + /*3170:*/ 0xb9, 0x9c, 0x06, 0x21, 0x1d, 0x8c, 0xd3, 0x31, 0x65, 0x12, 0x4e, 0xb0, 0xcb, 0x2a, 0x36, 0x06, + /*3180:*/ 0x28, 0xff, 0x9d, 0x97, 0xd0, 0x75, 0xbc, 0x69, 0xec, 0x90, 0xb3, 0xf9, 0x4a, 0x94, 0xf0, 0xd6, + /*3190:*/ 0xd0, 0xd5, 0xd2, 0xb3, 0xd9, 0x58, 0x02, 0x75, 0x60, 0xf0, 0x49, 0x45, 0xe5, 0xa8, 0x41, 0x77, + /*31a0:*/ 0xb7, 0xd4, 0x8d, 0x93, 0x05, 0xb8, 0x56, 0xb9, 0xe8, 0x79, 0x9e, 0x83, 0xc4, 0x45, 0xe5, 0x20, + /*31b0:*/ 0xa9, 0x7d, 0x7a, 0xf7, 0x20, 0x23, 0x6c, 0xf4, 0x57, 0xc2, 0xba, 0x79, 0xa8, 0x8c, 0x01, 0x9e, + /*31c0:*/ 0x66, 0x6a, 0xae, 0x76, 0x49, 0x27, 0x74, 0xe7, 0x17, 0x84, 0xaa, 0x49, 0xb5, 0x16, 0x37, 0xea, + /*31d0:*/ 0x6c, 0x01, 0x90, 0x79, 0x21, 0xe2, 0x0d, 0x77, 0xca, 0x7a, 0xf8, 0xff, 0x41, 0x21, 0xf5, 0x1c, + /*31e0:*/ 0xf7, 0x9f, 0x8b, 0xa3, 0x5c, 0xc1, 0x5b, 0xce, 0xbb, 0x12, 0x22, 0xf8, 0xd0, 0x36, 0x67, 0x23, + /*31f0:*/ 0xa1, 0x1d, 0xf7, 0x60, 0x33, 0xa3, 0x85, 0xcd, 0x0f, 0xeb, 0x39, 0xa7, 0xda, 0xd5, 0xcd, 0x8c, + /*3200:*/ 0xaf, 0x12, 0x06, 0xe8, 0x4c, 0x44, 0x1d, 0x93, 0xfc, 0x89, 0x93, 0x00, 0x64, 0xa3, 0xcc, 0x00, + /*3210:*/ 0x00, 0x09, 0x9a, 0x19, 0x9e, 0xbc, 0x82, 0x1c, 0x22, 0x1a, 0x65, 0x08, 0x99, 0xe8, 0x42, 0x68, + /*3220:*/ 0x98, 0x1d, 0x63, 0x25, 0x00, 0xda, 0xa5, 0xce, 0xf2, 0x6b, 0x6c, 0x12, 0x3b, 0xda, 0xde, 0xa2, + /*3230:*/ 0xaa, 0xd3, 0x5e, 0x3d, 0x32, 0x84, 0x53, 0x53, 0x7f, 0x44, 0x68, 0xbd, 0x1e, 0xea, 0xd6, 0x38, + /*3240:*/ 0xba, 0x80, 0xf5, 0x2d, 0x29, 0x10, 0x53, 0x4f, 0xc7, 0x72, 0xc6, 0xab, 0xfd, 0xe5, 0x6b, 0x74, + /*3250:*/ 0x30, 0xe7, 0x86, 0x5c, 0x39, 0x6e, 0x9d, 0xf2, 0x06, 0xa6, 0xc1, 0x2d, 0x62, 0x5e, 0x6b, 0x08, + /*3260:*/ 0xf8, 0x05, 0xb8, 0xa0, 0xc3, 0x36, 0x92, 0x13, 0xcd, 0x55, 0x51, 0xca, 0x1c, 0xcf, 0xb4, 0x70, + /*3270:*/ 0x6d, 0xa4, 0x5d, 0x8c, 0xa4, 0x56, 0xe9, 0xd2, 0x79, 0xe1, 0xe4, 0xfa, 0x68, 0x91, 0xb9, 0x45, + /*3280:*/ 0x28, 0x3c, 0xf2, 0x2e, 0x40, 0xda, 0x1b, 0xc4, 0x0e, 0x22, 0x17, 0x7c, 0xd4, 0xc6, 0x74, 0xc9, + /*3290:*/ 0x13, 0x9c, 0xa5, 0x12, 0xa8, 0x7d, 0xa4, 0x68, 0xff, 0x17, 0xb0, 0xdd, 0xae, 0xcb, 0xb3, 0x95, + /*32a0:*/ 0x15, 0xec, 0x61, 0x2a, 0x40, 0x92, 0x0f, 0x44, 0xfb, 0x62, 0xd5, 0xf7, 0x75, 0x69, 0x0d, 0xa8, + /*32b0:*/ 0xb6, 0x99, 0x85, 0xac, 0x63, 0x9d, 0x7c, 0x50, 0xa5, 0xed, 0x27, 0x3d, 0xd8, 0x6e, 0x54, 0xb5, + /*32c0:*/ 0x43, 0x27, 0xab, 0x2d, 0x29, 0x4d, 0x2e, 0x10, 0xc9, 0xa4, 0x25, 0xa4, 0x5b, 0x43, 0xb0, 0x1a, + /*32d0:*/ 0x5c, 0xfd, 0x36, 0xc9, 0xfb, 0x04, 0x02, 0x9e, 0x13, 0x2b, 0xc8, 0xfa, 0xfa, 0x4d, 0x06, 0x1d, + /*32e0:*/ 0xdd, 0xb4, 0x02, 0x35, 0xac, 0x92, 0xb3, 0x9d, 0xd4, 0xb0, 0xea, 0xeb, 0x0b, 0xce, 0xbe, 0x02, + /*32f0:*/ 0xc1, 0x58, 0xc9, 0x3c, 0x04, 0x67, 0x48, 0x60, 0x5c, 0xe3, 0x0d, 0x86, 0xfc, 0x94, 0x1f, 0x87, + /*3300:*/ 0x20, 0xff, 0x0c, 0x15, 0x4f, 0x26, 0xc7, 0x71, 0xfd, 0x97, 0xff, 0xe9, 0xce, 0x84, 0x20, 0xcb, + /*3310:*/ 0xcf, 0x8f, 0x03, 0x17, 0x34, 0x50, 0xe5, 0xca, 0x30, 0xd2, 0x0c, 0x05, 0x2b, 0x61, 0x80, 0x9a, + /*3320:*/ 0x85, 0xa2, 0x3a, 0xa9, 0xfe, 0xf0, 0xda, 0xc4, 0xeb, 0xc7, 0x77, 0xc0, 0x03, 0x48, 0xaf, 0x40, + /*3330:*/ 0xab, 0xc0, 0xf6, 0xc6, 0xb7, 0x49, 0x02, 0x39, 0x6a, 0xfb, 0x17, 0x5e, 0x06, 0x3a, 0xad, 0x30, + /*3340:*/ 0x25, 0x7d, 0xbf, 0x48, 0xa9, 0x79, 0x0e, 0x7e, 0x2d, 0x2e, 0xa2, 0xa9, 0x66, 0xda, 0x55, 0x37, + /*3350:*/ 0x0e, 0x04, 0x76, 0x06, 0x84, 0x40, 0x10, 0x22, 0x23, 0xbf, 0xe7, 0xef, 0xd4, 0xc8, 0x95, 0x30, + /*3360:*/ 0x88, 0x4a, 0xbf, 0x09, 0x69, 0x9a, 0x05, 0xe6, 0xd1, 0x48, 0xea, 0x7b, 0x31, 0x4e, 0x47, 0x73, + /*3370:*/ 0x8d, 0xe4, 0x0a, 0x12, 0x7b, 0xb8, 0xfb, 0x48, 0x80, 0x5c, 0x1c, 0x35, 0xcc, 0x68, 0x93, 0x65, + /*3380:*/ 0x60, 0x3b, 0x3a, 0x6e, 0x3c, 0x99, 0x51, 0xbf, 0x27, 0x1f, 0x24, 0x5e, 0x40, 0xc2, 0xf0, 0x48, + /*3390:*/ 0x60, 0x3d, 0x5c, 0xc3, 0x4d, 0xb7, 0xdf, 0x10, 0x54, 0x62, 0x5e, 0x6e, 0xb9, 0xd2, 0x5a, 0x95, + /*33a0:*/ 0xfc, 0x10, 0xa8, 0xc2, 0xfc, 0x77, 0x3a, 0xea, 0x99, 0x12, 0x7c, 0xa6, 0xd7, 0x2b, 0xba, 0xd0, + /*33b0:*/ 0xa1, 0x31, 0x6d, 0xc2, 0x26, 0x7c, 0xc4, 0x03, 0x32, 0x27, 0x48, 0x6a, 0x80, 0x02, 0xa8, 0x58, + /*33c0:*/ 0x23, 0xba, 0xb1, 0x8c, 0x8e, 0x66, 0x83, 0x54, 0x6c, 0x96, 0xad, 0xfa, 0xe6, 0xaa, 0x98, 0x6a, + /*33d0:*/ 0xd9, 0x7e, 0x03, 0xf9, 0xe2, 0x54, 0xf1, 0x0a, 0x41, 0x19, 0x33, 0x7a, 0x13, 0x85, 0xfa, 0xd8, + /*33e0:*/ 0xa5, 0xbc, 0x55, 0x2e, 0xc2, 0x39, 0x7d, 0xbf, 0x82, 0xd4, 0x3d, 0x43, 0x6f, 0xf0, 0xc0, 0x8c, + /*33f0:*/ 0x30, 0xdc, 0x25, 0x0b, 0x20, 0x09, 0x13, 0x0e, 0x64, 0x62, 0x7e, 0xd5, 0xdd, 0xc3, 0x87, 0x95, + /*3400:*/ 0xe0, 0xae, 0x49, 0xf1, 0x8a, 0xb1, 0x89, 0x76, 0x94, 0x0e, 0xd3, 0x14, 0x8d, 0xfa, 0xb3, 0xf1, + /*3410:*/ 0x3f, 0x3a, 0xa9, 0x07, 0xf8, 0x6a, 0x81, 0x60, 0x73, 0x3b, 0x81, 0xd8, 0xbc, 0xf2, 0xf1, 0x62, + /*3420:*/ 0xcb, 0xa3, 0x60, 0xb5, 0x27, 0x06, 0x57, 0x91, 0x5b, 0xd3, 0xab, 0x95, 0xe9, 0x42, 0xce, 0x1a, + /*3430:*/ 0x80, 0xd8, 0x54, 0x8b, 0x12, 0x5e, 0x75, 0x31, 0xc6, 0x74, 0xe7, 0xfb, 0xe7, 0xa4, 0xf8, 0xbc, + /*3440:*/ 0xff, 0x8d, 0x3c, 0x9b, 0xcf, 0x3e, 0xc7, 0x3a, 0xd9, 0x8f, 0x85, 0xc9, 0x17, 0xe6, 0x43, 0x04, + /*3450:*/ 0xa2, 0xa6, 0xba, 0x06, 0x6f, 0xa1, 0x0a, 0x1a, 0x61, 0xc3, 0x4c, 0x2c, 0x9d, 0x0f, 0xcc, 0xf6, + /*3460:*/ 0x74, 0x2e, 0x12, 0xc7, 0xa4, 0x79, 0x27, 0xd8, 0x75, 0x92, 0xab, 0x1e, 0x18, 0xd5, 0xb5, 0xc8, + /*3470:*/ 0xa7, 0x57, 0x58, 0x40, 0xcd, 0x3e, 0xb4, 0x1e, 0x99, 0xde, 0x5f, 0x97, 0x76, 0x83, 0xac, 0x61, + /*3480:*/ 0x41, 0xbd, 0xb6, 0x05, 0xf7, 0xec, 0x2a, 0x50, 0xb3, 0x03, 0xca, 0x2d, 0x0f, 0xf1, 0x2a, 0xc7, + /*3490:*/ 0x87, 0x41, 0xcd, 0xfc, 0x19, 0x0a, 0x7e, 0xf6, 0x14, 0x06, 0xfd, 0x03, 0x6e, 0xdf, 0xcf, 0x12, + /*34a0:*/ 0x9a, 0xa9, 0xe6, 0xe7, 0xb8, 0x30, 0x5a, 0xfb, 0xe7, 0xe4, 0xe0, 0x66, 0x26, 0x8a, 0x32, 0x68, + /*34b0:*/ 0x59, 0x2b, 0xca, 0x10, 0x59, 0x71, 0x23, 0x07, 0xb6, 0xb6, 0xc4, 0x55, 0xdb, 0xd7, 0xe9, 0xc1, + /*34c0:*/ 0x6d, 0x21, 0xf3, 0x12, 0x68, 0x7d, 0x4d, 0x58, 0x15, 0xd4, 0xc0, 0x03, 0x89, 0x62, 0x33, 0x4a, + /*34d0:*/ 0x34, 0x9e, 0xc3, 0x93, 0xda, 0xd8, 0xe8, 0x42, 0x4e, 0x8a, 0x2a, 0xc3, 0x4c, 0x5e, 0xd1, 0x84, + /*34e0:*/ 0x7e, 0xfb, 0x57, 0x11, 0x8a, 0xda, 0xdf, 0x37, 0x67, 0xdd, 0xbc, 0x67, 0x67, 0x23, 0xaf, 0xe6, + /*34f0:*/ 0x1c, 0xaf, 0x65, 0xf6, 0x9f, 0x93, 0x64, 0x5c, 0x97, 0xe2, 0x23, 0xbb, 0xcf, 0xb7, 0x37, 0x6c, + /*3500:*/ 0xfa, 0xc6, 0x26, 0xb6, 0x00, 0xc0, 0xf1, 0x3a, 0x99, 0x2a, 0x2b, 0x75, 0xb9, 0x59, 0xf8, 0xaa, + /*3510:*/ 0x9a, 0x93, 0x1a, 0x91, 0x49, 0x58, 0x1f, 0x4a, 0xf2, 0xe2, 0x17, 0x6d, 0xd7, 0x8a, 0xba, 0xa8, + /*3520:*/ 0x74, 0xe5, 0xa9, 0x95, 0xb8, 0xc9, 0x5e, 0x04, 0x2c, 0x23, 0x04, 0xa2, 0x43, 0x1b, 0x78, 0x8f, + /*3530:*/ 0x8d, 0x82, 0xd7, 0x3f, 0x5a, 0x2b, 0x8c, 0x8e, 0xd9, 0x59, 0x54, 0xf1, 0x02, 0x6d, 0x5e, 0x74, + /*3540:*/ 0xf7, 0xf5, 0xb2, 0x08, 0xce, 0x35, 0x71, 0x96, 0x83, 0xc9, 0x1f, 0xb3, 0x47, 0xdf, 0x5a, 0x10, + /*3550:*/ 0x95, 0x2b, 0x1f, 0xf4, 0x6b, 0x96, 0xc0, 0x72, 0x16, 0x8a, 0x98, 0xf1, 0x4a, 0x75, 0x6c, 0x7e, + /*3560:*/ 0xff, 0x07, 0xe3, 0x60, 0xa1, 0xcc, 0xe2, 0xd0, 0xbc, 0xe2, 0x61, 0xa9, 0x14, 0x9c, 0xea, 0xa9, + /*3570:*/ 0x8d, 0x0f, 0xe4, 0x3e, 0x2d, 0xee, 0x77, 0x13, 0x89, 0xa7, 0x5f, 0x6c, 0x3b, 0x2b, 0xc3, 0xeb, + /*3580:*/ 0x6c, 0x89, 0xd9, 0x55, 0xbc, 0xe8, 0xe6, 0x1a, 0xf9, 0xcf, 0xa8, 0x7a, 0x59, 0xd4, 0x5c, 0x3b, + /*3590:*/ 0x03, 0x34, 0x17, 0xe3, 0xaf, 0x69, 0x16, 0x75, 0xb1, 0x03, 0x6f, 0x40, 0xb2, 0xf5, 0x88, 0x36, + /*35a0:*/ 0x3e, 0x1e, 0x0e, 0x75, 0xfd, 0x8c, 0x40, 0x5d, 0x07, 0x7f, 0xc0, 0x63, 0x45, 0xa2, 0x86, 0x52, + /*35b0:*/ 0xbb, 0x20, 0xab, 0x78, 0xb2, 0x73, 0x44, 0xfd, 0xac, 0xca, 0xa7, 0x93, 0x46, 0x44, 0xc0, 0x20, + /*35c0:*/ 0x44, 0x8c, 0xc4, 0xb5, 0x15, 0xed, 0x52, 0xf1, 0x67, 0x35, 0x35, 0xb0, 0x4d, 0xd5, 0x4c, 0xb0, + /*35d0:*/ 0x31, 0x6f, 0xfe, 0x67, 0x38, 0x17, 0x97, 0xab, 0xce, 0x8f, 0xb0, 0xc1, 0x9d, 0x84, 0x1d, 0xef, + /*35e0:*/ 0x19, 0x4b, 0x4f, 0x09, 0xf9, 0x5d, 0xea, 0x98, 0xf6, 0xcf, 0xf3, 0x76, 0x41, 0x94, 0x32, 0xa6, + /*35f0:*/ 0x9f, 0xb4, 0x20, 0xed, 0xda, 0xdb, 0x9e, 0x89, 0xa3, 0xaf, 0x62, 0x0a, 0x76, 0xae, 0x78, 0x84, + /*3600:*/ 0xa3, 0xda, 0x48, 0xaa, 0x16, 0xd5, 0x50, 0x27, 0xcb, 0x8d, 0xd0, 0x7e, 0x3b, 0x4e, 0x7f, 0x92, + /*3610:*/ 0x68, 0x58, 0xc0, 0xec, 0x95, 0xc0, 0x37, 0x17, 0x38, 0x09, 0xfa, 0xd8, 0x87, 0xf0, 0xd7, 0xe9, + /*3620:*/ 0xcf, 0x2d, 0x74, 0x29, 0xb8, 0x07, 0x8b, 0xb5, 0x09, 0xc6, 0x4f, 0xe7, 0x65, 0xe9, 0xc5, 0x8a, + /*3630:*/ 0xc1, 0xee, 0xa8, 0xbf, 0xa4, 0x3f, 0x25, 0x47, 0xee, 0x18, 0xca, 0x7d, 0x8f, 0xc8, 0xfa, 0xf9, + /*3640:*/ 0xb8, 0xab, 0x00, 0xa1, 0x72, 0xc3, 0x16, 0x35, 0x50, 0x2c, 0x8f, 0x1a, 0x63, 0xc6, 0x7f, 0x20, + /*3650:*/ 0x9b, 0x1a, 0xc1, 0xb5, 0xbd, 0xfb, 0xb5, 0x42, 0x95, 0xdf, 0x1c, 0xa5, 0x62, 0x89, 0x78, 0x2f, + /*3660:*/ 0xb3, 0xa6, 0x57, 0x0a, 0x1a, 0x67, 0xf9, 0xdc, 0x21, 0x27, 0xee, 0xe2, 0x7b, 0x00, 0xd6, 0x26, + /*3670:*/ 0x2b, 0x12, 0xce, 0x69, 0x8d, 0x57, 0x26, 0x14, 0x21, 0x24, 0x71, 0x1a, 0x67, 0x3e, 0x8a, 0xa1, + /*3680:*/ 0xa2, 0xb1, 0x3a, 0x08, 0xaa, 0xcf, 0x32, 0xfc, 0xc7, 0x95, 0x42, 0xdb, 0x72, 0x26, 0x34, 0xe2, + /*3690:*/ 0x8d, 0x44, 0x5e, 0x02, 0xd3, 0x89, 0x08, 0x9c, 0x61, 0x54, 0xeb, 0x2b, 0x4e, 0xa6, 0x5d, 0x3e, + /*36a0:*/ 0x69, 0x0b, 0xd2, 0xfb, 0x00, 0xdd, 0xa7, 0x24, 0x44, 0x89, 0x68, 0x14, 0xcb, 0x2c, 0xbb, 0xf7, + /*36b0:*/ 0x8b, 0xef, 0xe9, 0x24, 0xb6, 0x60, 0x3b, 0x9d, 0xdf, 0xfb, 0x0c, 0x6f, 0xb1, 0xf1, 0x09, 0x7c, + /*36c0:*/ 0xa2, 0x53, 0xfc, 0x44, 0x89, 0x43, 0x93, 0x0f, 0xe3, 0x34, 0x39, 0xaa, 0x70, 0x6f, 0x28, 0x5a, + /*36d0:*/ 0x1c, 0x58, 0x68, 0xb3, 0xe2, 0xee, 0xf6, 0xb8, 0x43, 0x54, 0xb8, 0xdf, 0x9a, 0xed, 0x38, 0xf0, + /*36e0:*/ 0xd5, 0xfe, 0x11, 0xc5, 0x46, 0x98, 0x99, 0x25, 0x29, 0xa6, 0xbb, 0x03, 0x5e, 0x5f, 0x7b, 0xfe, + /*36f0:*/ 0xce, 0x22, 0x24, 0xb3, 0x6f, 0x77, 0xab, 0x90, 0x02, 0xe4, 0x0c, 0x5c, 0x6e, 0x6e, 0x86, 0x3a, + /*3700:*/ 0x0e, 0xbf, 0x93, 0x9a, 0x78, 0xba, 0xa3, 0x55, 0xfd, 0xbc, 0x0e, 0xde, 0x99, 0xc3, 0x6b, 0x6d, + /*3710:*/ 0x87, 0x90, 0x93, 0x10, 0xb4, 0x7e, 0xce, 0x84, 0x98, 0xed, 0x01, 0x7e, 0x8d, 0x8c, 0x48, 0x06, + /*3720:*/ 0xbb, 0x58, 0xce, 0xd3, 0x6d, 0x41, 0x3b, 0x41, 0x13, 0x84, 0x68, 0x33, 0xf2, 0xb3, 0xba, 0x05, + /*3730:*/ 0x41, 0x55, 0xdf, 0x13, 0x1a, 0xb8, 0x86, 0x20, 0x5a, 0xbb, 0x7a, 0x36, 0x3b, 0x77, 0x1a, 0xe8, + /*3740:*/ 0x46, 0x31, 0x27, 0x0d, 0xb8, 0x7a, 0x19, 0x2c, 0x4d, 0xd1, 0xfb, 0xc3, 0xda, 0x2b, 0x0d, 0x97, + /*3750:*/ 0x04, 0xef, 0xf7, 0x54, 0xf3, 0xc4, 0xa6, 0x32, 0xb9, 0xce, 0xca, 0xd8, 0x88, 0x63, 0x0c, 0x5c, + /*3760:*/ 0xa7, 0xe6, 0xe1, 0xa7, 0xc4, 0xdc, 0xb1, 0x6e, 0xb7, 0xd3, 0x82, 0x69, 0xca, 0xa0, 0x57, 0x5d, + /*3770:*/ 0xfd, 0x41, 0x58, 0x8d, 0xe0, 0x8c, 0x51, 0x81, 0xc4, 0xa1, 0x52, 0xa9, 0x6d, 0x86, 0x06, 0x43, + /*3780:*/ 0x07, 0x07, 0xcb, 0xb8, 0xd7, 0xdb, 0x65, 0xb3, 0xc9, 0xe8, 0x43, 0x0f, 0xe2, 0x3d, 0xde, 0x30, + /*3790:*/ 0x66, 0xca, 0x30, 0x25, 0xba, 0x71, 0x9e, 0x12, 0x73, 0x40, 0xf2, 0xd6, 0xff, 0xa7, 0x51, 0x72, + /*37a0:*/ 0x44, 0x7e, 0xd5, 0xba, 0xa8, 0x89, 0x4a, 0xf8, 0x30, 0x1e, 0xe9, 0x3c, 0xab, 0x16, 0xc9, 0x51, + /*37b0:*/ 0x3c, 0xef, 0xfe, 0x6f, 0x8f, 0x04, 0x47, 0xbc, 0xce, 0x7d, 0x27, 0x61, 0x28, 0xd8, 0x47, 0x9f, + /*37c0:*/ 0x1c, 0x89, 0x6c, 0x25, 0xc9, 0x61, 0x8d, 0x47, 0x63, 0xb3, 0x6f, 0xbc, 0xb9, 0x44, 0x8e, 0x50, + /*37d0:*/ 0x60, 0x5a, 0xa3, 0x26, 0x5d, 0xb8, 0x3c, 0xf9, 0xef, 0x8f, 0xfc, 0xdb, 0xd6, 0x62, 0x87, 0xd2, + /*37e0:*/ 0xfd, 0x95, 0xbd, 0x61, 0x2b, 0xcc, 0xef, 0xf7, 0x74, 0x96, 0x30, 0x10, 0x48, 0x0f, 0x84, 0xaf, + /*37f0:*/ 0x0c, 0x5d, 0x8f, 0xb8, 0x4e, 0x08, 0x60, 0xf5, 0x84, 0x1b, 0xa7, 0x02, 0x58, 0xc4, 0x1c, 0x6e, + /*3800:*/ 0xd2, 0x6d, 0xe1, 0x70, 0x4f, 0x57, 0x67, 0xfe, 0xbb, 0x59, 0x03, 0xac, 0x98, 0xa6, 0x88, 0xc4, + /*3810:*/ 0x93, 0x4c, 0x53, 0x55, 0xbe, 0xc0, 0x97, 0x09, 0x61, 0x05, 0x11, 0x9e, 0x43, 0x9b, 0x03, 0x56, + /*3820:*/ 0x77, 0x89, 0xcb, 0x32, 0x15, 0xe9, 0x0b, 0xa8, 0xe7, 0x00, 0x66, 0xbf, 0xf9, 0xbf, 0x9f, 0x77, + /*3830:*/ 0xde, 0xf2, 0x50, 0x0d, 0x88, 0xb8, 0x4d, 0x16, 0x42, 0x0b, 0xaf, 0xda, 0xe2, 0x9c, 0x29, 0xf8, + /*3840:*/ 0xc5, 0x2b, 0xf6, 0xfc, 0x89, 0xf0, 0x0c, 0x2e, 0xf7, 0xb8, 0xb9, 0x60, 0x31, 0x5d, 0x7a, 0x8a, + /*3850:*/ 0x7f, 0xdf, 0xf2, 0xa6, 0xd6, 0x39, 0x4f, 0x20, 0xaf, 0x07, 0xc9, 0x9c, 0xd0, 0x8f, 0x21, 0x2c, + /*3860:*/ 0xae, 0x78, 0x1a, 0x00, 0xad, 0x52, 0x07, 0x2c, 0xbd, 0x99, 0x8e, 0x43, 0x68, 0xa0, 0x47, 0xf6, + /*3870:*/ 0xf9, 0xb7, 0xe1, 0x42, 0x53, 0x37, 0x8c, 0x5d, 0xcc, 0x5e, 0x7c, 0x70, 0x89, 0x0c, 0xeb, 0x66, + /*3880:*/ 0x5c, 0x5f, 0x96, 0xf1, 0x29, 0xa9, 0x49, 0x68, 0xb2, 0x9f, 0x5c, 0x49, 0x85, 0xb9, 0x47, 0x4c, + /*3890:*/ 0xb9, 0x40, 0x42, 0x29, 0x98, 0x2e, 0xbc, 0xd1, 0xde, 0xd1, 0xe4, 0x67, 0x66, 0x98, 0x7c, 0x6a, + /*38a0:*/ 0x60, 0x00, 0xd2, 0xd0, 0x3f, 0xcb, 0xc0, 0xde, 0x18, 0x95, 0xb9, 0xd7, 0xbc, 0x2c, 0x39, 0xc7, + /*38b0:*/ 0x90, 0x59, 0x88, 0xa9, 0x17, 0xcd, 0x81, 0x28, 0x09, 0x97, 0xe0, 0x34, 0x7a, 0x6a, 0xcb, 0x0c, + /*38c0:*/ 0x8a, 0x9c, 0xf2, 0x9d, 0xa6, 0xce, 0xdd, 0x09, 0x13, 0x4e, 0x0f, 0x51, 0xfc, 0xa0, 0x11, 0xf5, + /*38d0:*/ 0x74, 0xd2, 0x3e, 0xcb, 0x93, 0xca, 0x60, 0x48, 0x00, 0xb6, 0xd9, 0xa6, 0x7b, 0x14, 0x26, 0x8f, + /*38e0:*/ 0x75, 0x77, 0x74, 0x55, 0xd6, 0x29, 0x6f, 0x6f, 0x4d, 0xac, 0x4c, 0x7b, 0xba, 0x9c, 0xb5, 0x88, + /*38f0:*/ 0x0f, 0x7c, 0x45, 0x74, 0x26, 0xe2, 0x2e, 0xd4, 0x45, 0x79, 0x29, 0x07, 0xd6, 0x58, 0x7d, 0x8c, + /*3900:*/ 0x93, 0x61, 0x8d, 0x96, 0xef, 0xc2, 0xc5, 0xa5, 0xf6, 0xab, 0xa1, 0x20, 0x44, 0x61, 0xd7, 0x60, + /*3910:*/ 0x62, 0x79, 0xa7, 0x7a, 0xeb, 0x8f, 0xd9, 0x96, 0xce, 0xf9, 0xb1, 0xb0, 0xe7, 0xfe, 0xe0, 0x69, + /*3920:*/ 0x2b, 0xbd, 0xfd, 0xb2, 0x25, 0x6b, 0x8b, 0x11, 0x8b, 0x59, 0x92, 0xfa, 0xcd, 0x6c, 0xd0, 0x90, + /*3930:*/ 0xb4, 0xde, 0x70, 0x32, 0xa9, 0x4d, 0x08, 0x92, 0x47, 0x0c, 0x7a, 0xb6, 0x00, 0xe2, 0x1c, 0x71, + /*3940:*/ 0xa0, 0x39, 0x1c, 0xcb, 0x96, 0xc2, 0xda, 0x70, 0x50, 0x29, 0x35, 0x3e, 0x28, 0xf6, 0x86, 0xbb, + /*3950:*/ 0xb2, 0x8a, 0xba, 0x93, 0xf9, 0x42, 0xf4, 0xc9, 0xa8, 0x54, 0x03, 0xd3, 0xb4, 0xc4, 0x40, 0xbf, + /*3960:*/ 0x72, 0x1f, 0x86, 0xfe, 0x32, 0xc3, 0x44, 0x80, 0x9c, 0x77, 0x7b, 0x30, 0xb2, 0xeb, 0x44, 0x2c, + /*3970:*/ 0xee, 0x15, 0x00, 0x16, 0x1b, 0x57, 0xfe, 0x22, 0x9f, 0x4a, 0x7e, 0x40, 0xe8, 0xd3, 0xb1, 0x12, + /*3980:*/ 0xe2, 0x78, 0x36, 0x94, 0x61, 0x9e, 0x46, 0x37, 0x5b, 0x17, 0x0a, 0x58, 0xd5, 0x40, 0x25, 0x52, + /*3990:*/ 0x08, 0xc6, 0x42, 0x50, 0xb7, 0x4d, 0x76, 0xe4, 0x05, 0xb7, 0x3f, 0x83, 0x0b, 0xab, 0x32, 0x1a, + /*39a0:*/ 0x66, 0xcc, 0x14, 0xc5, 0x98, 0xb6, 0x37, 0x7d, 0x44, 0xbd, 0xb0, 0x38, 0x29, 0x17, 0xe0, 0xa7, + /*39b0:*/ 0x27, 0x2f, 0x66, 0x88, 0x8a, 0x45, 0x53, 0xda, 0x57, 0x9d, 0xcc, 0xca, 0x25, 0x83, 0xe8, 0x18, + /*39c0:*/ 0x6e, 0x8a, 0x22, 0x0a, 0x35, 0x49, 0x78, 0x85, 0x05, 0xe1, 0xec, 0x02, 0x62, 0x3e, 0xad, 0x6b, + /*39d0:*/ 0x71, 0x95, 0xf7, 0xd7, 0x29, 0xea, 0x21, 0xc4, 0x63, 0x5f, 0x68, 0x9f, 0x10, 0x9d, 0x31, 0x39, + /*39e0:*/ 0x92, 0xc9, 0x79, 0x66, 0x9b, 0xb4, 0xe0, 0x53, 0xb4, 0x2b, 0xd8, 0xe8, 0xea, 0x4f, 0x47, 0x88, + /*39f0:*/ 0xaa, 0xb1, 0x7f, 0x5d, 0xd0, 0x16, 0x80, 0xa9, 0x24, 0xd5, 0x51, 0x68, 0x58, 0xff, 0x5b, 0x35, + /*3a00:*/ 0x11, 0x32, 0x0d, 0x3d, 0xb9, 0xa5, 0x3b, 0xb8, 0x5c, 0x19, 0xc1, 0xe7, 0x04, 0xcb, 0x7c, 0xc2, + /*3a10:*/ 0x01, 0x87, 0xea, 0xf3, 0x5a, 0x55, 0xb9, 0x31, 0x27, 0x95, 0xae, 0x6e, 0x68, 0x1a, 0x64, 0xda, + /*3a20:*/ 0x78, 0x65, 0x56, 0x67, 0x61, 0x03, 0xb9, 0xfb, 0x99, 0x0c, 0xa9, 0xa6, 0x72, 0x88, 0x89, 0x3f, + /*3a30:*/ 0xd1, 0x3e, 0xe3, 0xb1, 0x93, 0x09, 0xce, 0x0e, 0x0b, 0x7c, 0x08, 0xa5, 0x82, 0x4e, 0x2a, 0x52, + /*3a40:*/ 0x99, 0x0d, 0xee, 0x35, 0x28, 0xff, 0xe2, 0x17, 0x65, 0xfb, 0xb4, 0x59, 0x05, 0x86, 0xf2, 0x0a, + /*3a50:*/ 0xff, 0xb4, 0x4c, 0xe0, 0x0e, 0x9b, 0xd6, 0x86, 0xb3, 0xb3, 0x6f, 0x22, 0x35, 0x0c, 0x77, 0x3a, + /*3a60:*/ 0xd5, 0x42, 0x5b, 0x1a, 0xc6, 0x45, 0xb4, 0x16, 0x4e, 0x7b, 0x22, 0xbb, 0xb3, 0xe2, 0x18, 0x8f, + /*3a70:*/ 0xf0, 0x13, 0xc4, 0xaf, 0x03, 0x7f, 0xbe, 0x0f, 0x43, 0x5f, 0x83, 0xd3, 0x57, 0xbf, 0xc0, 0x6b, + /*3a80:*/ 0xb3, 0xea, 0x7f, 0x39, 0xa1, 0xf6, 0xb2, 0x67, 0xeb, 0xa0, 0x6a, 0x1f, 0xc8, 0x0b, 0x33, 0x06, + /*3a90:*/ 0x5b, 0x69, 0x67, 0x82, 0x39, 0x27, 0x38, 0xa5, 0x14, 0xa2, 0x68, 0xbc, 0xe8, 0x52, 0xf7, 0xcb, + /*3aa0:*/ 0x4c, 0xfd, 0xa3, 0x9a, 0x23, 0x9c, 0xa1, 0xd7, 0x3e, 0x1d, 0x3b, 0x6b, 0x6e, 0x1e, 0xbc, 0x8b, + /*3ab0:*/ 0xff, 0xc1, 0xa5, 0x3e, 0xa9, 0x5b, 0x7f, 0x86, 0xa6, 0x95, 0xf0, 0xcc, 0x3b, 0xeb, 0x76, 0x77, + /*3ac0:*/ 0x51, 0x51, 0x3e, 0xe6, 0x97, 0x38, 0x1e, 0xd1, 0x34, 0x20, 0xb2, 0xeb, 0x8a, 0x35, 0xc1, 0x5f, + /*3ad0:*/ 0x5e, 0xd9, 0x97, 0xab, 0x30, 0x95, 0xae, 0x5e, 0xb0, 0x62, 0xa3, 0x4c, 0x12, 0xf6, 0x0c, 0xd7, + /*3ae0:*/ 0x16, 0x92, 0x97, 0x27, 0xcb, 0xe7, 0x1e, 0xf1, 0x87, 0xc4, 0xd1, 0x09, 0xb9, 0xe6, 0xff, 0xb6, + /*3af0:*/ 0xab, 0xc7, 0x9c, 0x42, 0x55, 0xab, 0x1f, 0x6a, 0x85, 0x80, 0x6f, 0xc4, 0x3c, 0x16, 0x9b, 0x89, + /*3b00:*/ 0x9c, 0x42, 0xed, 0xd9, 0x97, 0xdc, 0x4f, 0xe2, 0x69, 0xdd, 0xab, 0xe7, 0x2c, 0x9a, 0xda, 0x91, + /*3b10:*/ 0x7c, 0x71, 0x63, 0x41, 0x48, 0xc0, 0x6f, 0x24, 0xd6, 0xaf, 0x6b, 0x30, 0xce, 0xc0, 0x86, 0xff, + /*3b20:*/ 0xa9, 0x26, 0x91, 0xd7, 0x42, 0xa0, 0x00, 0x4e, 0x39, 0xb0, 0x6c, 0xfc, 0xad, 0xd4, 0x22, 0xd0, + /*3b30:*/ 0x6d, 0xb6, 0xf1, 0xeb, 0xbd, 0x28, 0x72, 0x87, 0x15, 0xb5, 0x17, 0x76, 0x0a, 0x31, 0xc2, 0x2b, + /*3b40:*/ 0xc0, 0x5f, 0x4a, 0x52, 0xa0, 0xed, 0x9e, 0xe0, 0x7d, 0x7e, 0x6e, 0x0c, 0x12, 0x03, 0x27, 0x58, + /*3b50:*/ 0x28, 0x68, 0xb0, 0x6e, 0x19, 0xfb, 0xec, 0x50, 0x0e, 0xc8, 0xf9, 0x0b, 0xfb, 0xfd, 0xf4, 0x17, + /*3b60:*/ 0x79, 0xec, 0xaf, 0x1b, 0x79, 0x15, 0x23, 0x9a, 0x06, 0xcd, 0x60, 0xbc, 0x95, 0x5d, 0x8a, 0x76, + /*3b70:*/ 0x49, 0x3e, 0xa9, 0xd3, 0xcb, 0xed, 0x2f, 0x5f, 0xe0, 0xa7, 0xb8, 0xc7, 0x01, 0x60, 0x78, 0x0d, + /*3b80:*/ 0x33, 0x8b, 0xda, 0xb8, 0x04, 0x15, 0x00, 0x6a, 0xe6, 0x4e, 0x43, 0xb6, 0xd2, 0x0d, 0x81, 0x60, + /*3b90:*/ 0x74, 0x6c, 0x09, 0xdb, 0x05, 0xc3, 0xb4, 0xc3, 0x8f, 0xae, 0x23, 0xeb, 0xe0, 0x32, 0x73, 0x24, + /*3ba0:*/ 0xa9, 0xfa, 0xee, 0xc0, 0xfe, 0x44, 0x14, 0x41, 0xce, 0xe9, 0x31, 0x8a, 0x24, 0x8d, 0xd3, 0xa9, + /*3bb0:*/ 0x49, 0x0c, 0xe0, 0x6b, 0xb6, 0xd5, 0xf8, 0x5d, 0xe2, 0x5b, 0xac, 0xc8, 0x31, 0x5b, 0xb3, 0x25, + /*3bc0:*/ 0xe2, 0x3f, 0x51, 0x22, 0x38, 0x6c, 0x72, 0x68, 0xdd, 0xe9, 0x80, 0xb4, 0x39, 0xa3, 0xe0, 0xc1, + /*3bd0:*/ 0x3b, 0x02, 0x7d, 0x63, 0xbe, 0xb0, 0xb2, 0x80, 0x87, 0x6e, 0x55, 0x32, 0x4e, 0x12, 0x92, 0xee, + /*3be0:*/ 0xf0, 0xe1, 0x45, 0xf5, 0x1b, 0x1b, 0xa4, 0x56, 0xa6, 0x11, 0x92, 0xa1, 0x15, 0x56, 0x25, 0xb7, + /*3bf0:*/ 0x94, 0x8e, 0x04, 0x12, 0x1c, 0x4b, 0x9a, 0x87, 0x84, 0x70, 0x1e, 0xdb, 0x49, 0xeb, 0xd5, 0xfa, + /*3c00:*/ 0xa2, 0xb1, 0x11, 0xd2, 0x8c, 0x4f, 0x88, 0xed, 0xf9, 0x69, 0x08, 0x53, 0xff, 0x82, 0x79, 0x18, + /*3c10:*/ 0x2b, 0xf8, 0xa6, 0x87, 0xdd, 0x13, 0xa0, 0x7b, 0xfc, 0x51, 0x7d, 0xde, 0xac, 0xfc, 0x8b, 0xd4, + /*3c20:*/ 0x0e, 0xf5, 0x61, 0x7e, 0x0f, 0xa9, 0x96, 0xd2, 0xcf, 0x85, 0x2c, 0x4d, 0x9b, 0x12, 0xbe, 0xf9, + /*3c30:*/ 0x7c, 0x4f, 0x75, 0x68, 0x4d, 0x34, 0x98, 0xf8, 0x5f, 0xc4, 0xcf, 0x29, 0x87, 0x26, 0xec, 0x09, + /*3c40:*/ 0x64, 0xd0, 0x6e, 0x92, 0x13, 0xc4, 0x49, 0xc1, 0xb3, 0xe2, 0x2a, 0x70, 0x03, 0x28, 0x83, 0xde, + /*3c50:*/ 0x28, 0x33, 0x6a, 0x48, 0x9e, 0xf2, 0x8b, 0x9b, 0x52, 0xc3, 0xc3, 0x20, 0x8b, 0xc3, 0xdb, 0x74, + /*3c60:*/ 0x56, 0xb6, 0x7a, 0x2b, 0xe8, 0x7d, 0x2d, 0x54, 0x27, 0x8b, 0xa8, 0xa3, 0x52, 0x99, 0xcb, 0x9a, + /*3c70:*/ 0xbf, 0x32, 0xa7, 0xb4, 0x82, 0x51, 0x05, 0xad, 0xc2, 0x81, 0x7f, 0xaa, 0xfe, 0x87, 0x1e, 0xb4, + /*3c80:*/ 0x57, 0xb7, 0x63, 0x6a, 0x7d, 0x5d, 0x0f, 0x8c, 0x77, 0x16, 0x1f, 0x49, 0xa4, 0xba, 0x0f, 0x56, + /*3c90:*/ 0x1c, 0x73, 0x95, 0x42, 0x1e, 0x56, 0xc6, 0x11, 0x5a, 0x0d, 0x3d, 0x88, 0x23, 0xc8, 0xaa, 0x5d, + /*3ca0:*/ 0x60, 0x87, 0xce, 0xd0, 0xd0, 0xea, 0x43, 0xd4, 0x31, 0xbb, 0xb3, 0xd9, 0xbb, 0x5e, 0x56, 0x79, + /*3cb0:*/ 0x4e, 0x6c, 0x4a, 0x54, 0x1a, 0x96, 0x81, 0xe2, 0xdb, 0x47, 0xc4, 0x6d, 0xb3, 0xfa, 0xc0, 0x0e, + /*3cc0:*/ 0xdd, 0x3d, 0x12, 0xe3, 0x51, 0x66, 0x05, 0xe1, 0xe1, 0x8e, 0x3d, 0x0a, 0x7d, 0xb2, 0xe5, 0x7d, + /*3cd0:*/ 0x78, 0x10, 0xb9, 0x95, 0xf1, 0xdc, 0xa7, 0xcd, 0x3a, 0xcf, 0xf3, 0xe0, 0x11, 0x10, 0x6b, 0xc2, + /*3ce0:*/ 0xc0, 0x9b, 0x7e, 0xc1, 0x40, 0x7e, 0x57, 0xfa, 0xe8, 0x95, 0x42, 0x52, 0x32, 0xe2, 0x3f, 0xf0, + /*3cf0:*/ 0x74, 0x94, 0xd7, 0x2f, 0x47, 0xdc, 0xe0, 0x98, 0x09, 0xf1, 0x51, 0xca, 0x0f, 0x03, 0xfc, 0xf6, + /*3d00:*/ 0x89, 0xef, 0xa6, 0x49, 0x1b, 0x05, 0x1b, 0x3e, 0xbc, 0x3d, 0xde, 0x32, 0x4e, 0xff, 0xcb, 0x44, + /*3d10:*/ 0x86, 0xbf, 0xeb, 0x1f, 0xeb, 0x15, 0x37, 0xb9, 0xde, 0x68, 0xd0, 0x91, 0x37, 0xff, 0x9b, 0xf9, + /*3d20:*/ 0xcd, 0x62, 0xf8, 0x1a, 0xfb, 0x80, 0x60, 0x15, 0x76, 0x62, 0x01, 0x8c, 0x9e, 0xda, 0x93, 0xd9, + /*3d30:*/ 0x51, 0x5a, 0x87, 0xd4, 0xe0, 0x24, 0x67, 0xac, 0xa7, 0x72, 0x33, 0x54, 0xc0, 0x94, 0x15, 0x23, + /*3d40:*/ 0x10, 0xa3, 0x18, 0xde, 0x0d, 0x0f, 0xd9, 0xc1, 0x52, 0xad, 0x37, 0xd2, 0x6d, 0xf0, 0x57, 0x20, + /*3d50:*/ 0xe6, 0xaf, 0x21, 0xe5, 0xa5, 0x32, 0xd5, 0xfe, 0xca, 0x57, 0x50, 0x75, 0xd7, 0xb7, 0x20, 0xa2, + /*3d60:*/ 0x3c, 0xf0, 0xa2, 0xca, 0xce, 0x43, 0xe5, 0xe0, 0xaa, 0xb2, 0xf3, 0x5d, 0x12, 0x15, 0x46, 0x72, + /*3d70:*/ 0xfe, 0x99, 0x21, 0x2a, 0x43, 0x6f, 0x9f, 0x70, 0x42, 0x9d, 0xe9, 0xf7, 0x8e, 0xc7, 0x4a, 0xd9, + /*3d80:*/ 0x05, 0x09, 0xc6, 0xb5, 0x9f, 0x4b, 0x6f, 0xb9, 0x53, 0x4b, 0x4e, 0x3f, 0x01, 0x7b, 0x3e, 0x7c, + /*3d90:*/ 0x75, 0x61, 0x32, 0x46, 0xb9, 0x3d, 0xc6, 0xdf, 0x75, 0x05, 0x6a, 0xe5, 0x7e, 0xbf, 0x44, 0xdd, + /*3da0:*/ 0xc5, 0xca, 0xa8, 0x9a, 0x9b, 0x71, 0xf7, 0x98, 0xa3, 0xec, 0xee, 0x1c, 0xc9, 0x8d, 0x10, 0x11, + /*3db0:*/ 0xd6, 0x3b, 0xda, 0x3c, 0x35, 0x89, 0x3d, 0x8d, 0x9a, 0xcc, 0x43, 0x17, 0x1e, 0x32, 0x05, 0x23, + /*3dc0:*/ 0x70, 0xa4, 0x26, 0x69, 0xc1, 0x8a, 0x83, 0x7a, 0xdf, 0x9d, 0x1a, 0x3b, 0xcc, 0x22, 0x52, 0x76, + /*3dd0:*/ 0xe5, 0x7e, 0xc3, 0x63, 0xf8, 0xd1, 0xc1, 0x3a, 0x8e, 0x88, 0x64, 0x80, 0x50, 0x5f, 0xa0, 0x8d, + /*3de0:*/ 0x16, 0x89, 0x88, 0x57, 0x21, 0x38, 0xc1, 0x76, 0x19, 0xc5, 0x5b, 0x90, 0x92, 0xd3, 0x45, 0xf5, + /*3df0:*/ 0xf4, 0x79, 0x35, 0xf5, 0x1a, 0x2d, 0x53, 0xe1, 0x7c, 0x23, 0x3a, 0x52, 0x6f, 0x4c, 0x44, 0x87, + /*3e00:*/ 0x99, 0x71, 0xf7, 0x13, 0x5b, 0x4f, 0x50, 0x15, 0x06, 0x10, 0x32, 0xc4, 0xb7, 0x81, 0xd7, 0x73, + /*3e10:*/ 0xeb, 0x20, 0x8b, 0x92, 0x62, 0xd1, 0x37, 0xe7, 0x6b, 0xe8, 0x8c, 0x5b, 0xe3, 0x27, 0x13, 0x07, + /*3e20:*/ 0x39, 0xdc, 0x1b, 0xa7, 0x67, 0x40, 0x8b, 0x44, 0x83, 0xff, 0x47, 0x1a, 0xfa, 0x0d, 0x27, 0x98, + /*3e30:*/ 0x4c, 0xc9, 0xe4, 0x76, 0x9f, 0x4f, 0xc3, 0xf7, 0x3a, 0x51, 0x54, 0x84, 0x75, 0x21, 0x6b, 0xb8, + /*3e40:*/ 0x3f, 0x01, 0x54, 0x46, 0x7f, 0x0d, 0x0d, 0x26, 0x4a, 0x6a, 0x92, 0xe1, 0x8a, 0x3a, 0x22, 0x9f, + /*3e50:*/ 0x01, 0x00, 0x55, 0x3a, 0x16, 0x2a, 0xc5, 0xad, 0x3a, 0xb1, 0x76, 0xd5, 0x13, 0xf2, 0x6a, 0xd4, + /*3e60:*/ 0x7f, 0x50, 0xca, 0x75, 0x20, 0x77, 0xd0, 0xbf, 0x34, 0x7e, 0x22, 0xd7, 0x9a, 0xaf, 0xcb, 0x0b, + /*3e70:*/ 0x07, 0x67, 0x77, 0xb9, 0xa5, 0xaf, 0x86, 0x42, 0x3f, 0xc1, 0x4b, 0x17, 0xc1, 0x0c, 0xe7, 0x4e, + /*3e80:*/ 0xab, 0x11, 0xe3, 0xbd, 0x21, 0x30, 0xe3, 0x58, 0x0f, 0xbe, 0xeb, 0xaa, 0xe0, 0x0c, 0x25, 0xfd, + /*3e90:*/ 0x8f, 0xc2, 0x67, 0x5b, 0xbf, 0x62, 0xe8, 0x5b, 0x0a, 0x08, 0xd5, 0xee, 0xf4, 0x0a, 0x90, 0x58, + /*3ea0:*/ 0xf6, 0x6d, 0x0e, 0x17, 0x3f, 0x7b, 0x63, 0x52, 0x9b, 0x1e, 0xd5, 0x57, 0x44, 0xc9, 0x2f, 0x36, + /*3eb0:*/ 0xd0, 0x82, 0x95, 0x9a, 0xf8, 0xe7, 0x52, 0x3b, 0xda, 0x91, 0xf1, 0xd4, 0x33, 0xb6, 0xca, 0x5b, + /*3ec0:*/ 0xf5, 0x86, 0x72, 0x9f, 0x5a, 0x75, 0xaf, 0xde, 0xcc, 0xc2, 0x86, 0x7f, 0x36, 0xcc, 0x0f, 0x90, + /*3ed0:*/ 0x69, 0x7b, 0x7b, 0xa4, 0xdf, 0xf3, 0x65, 0x6d, 0xb2, 0xd5, 0xd0, 0x47, 0x27, 0x80, 0x03, 0x86, + /*3ee0:*/ 0x0c, 0x5a, 0x6b, 0x53, 0x62, 0x54, 0x87, 0xe3, 0xd7, 0x19, 0xdb, 0x6d, 0xb8, 0x4f, 0x7c, 0x32, + /*3ef0:*/ 0xd1, 0xd6, 0xe1, 0x1e, 0xa0, 0x02, 0x28, 0xed, 0x7e, 0xe0, 0x11, 0x8c, 0x94, 0x64, 0xa8, 0xee, + /*3f00:*/ 0x25, 0x81, 0x1d, 0x38, 0xa7, 0x2d, 0x65, 0xdc, 0x64, 0x2e, 0x61, 0xb5, 0x1e, 0xc7, 0x50, 0x20, + /*3f10:*/ 0x2a, 0x20, 0x28, 0x65, 0xba, 0x5a, 0xb3, 0x31, 0x10, 0x07, 0x4f, 0xb0, 0x74, 0x53, 0xd2, 0xb3, + /*3f20:*/ 0xf3, 0xbe, 0x5a, 0x5c, 0x0b, 0xcc, 0x31, 0x8e, 0xfe, 0x0f, 0xd2, 0x27, 0x1f, 0x4e, 0x76, 0xd0, + /*3f30:*/ 0x6a, 0xf6, 0x23, 0x19, 0x2e, 0xc7, 0x79, 0xcf, 0x27, 0xe6, 0xb9, 0x64, 0xa0, 0x46, 0x30, 0xf9, + /*3f40:*/ 0x7a, 0x7e, 0x42, 0x98, 0x68, 0x20, 0x56, 0x59, 0xe5, 0xf2, 0x32, 0x9e, 0x24, 0xf3, 0x39, 0xcb, + /*3f50:*/ 0x8d, 0x1c, 0x40, 0xc8, 0x56, 0x5d, 0x61, 0x03, 0xbc, 0x9f, 0x9b, 0x1c, 0xe6, 0x6d, 0xa2, 0xee, + /*3f60:*/ 0xf1, 0x33, 0x5a, 0xe7, 0x7e, 0xf7, 0x9c, 0xd4, 0x9c, 0xd9, 0x20, 0xce, 0x9f, 0x80, 0x18, 0x8a, + /*3f70:*/ 0xaa, 0xe7, 0x44, 0x87, 0xd7, 0x23, 0xc6, 0x9c, 0x9c, 0x5d, 0x0c, 0xc0, 0xc9, 0x6f, 0x7b, 0x3d, + /*3f80:*/ 0x49, 0xa7, 0x2d, 0x88, 0x0b, 0xf3, 0x23, 0xec, 0x42, 0xfd, 0xc7, 0x61, 0x0d, 0xa2, 0xed, 0xac, + /*3f90:*/ 0x13, 0x07, 0xe5, 0xd6, 0x77, 0x55, 0x48, 0xa1, 0x34, 0xbb, 0xe2, 0x77, 0x30, 0xc0, 0x15, 0x19, + /*3fa0:*/ 0xfd, 0xdf, 0xd2, 0x39, 0x60, 0xc6, 0x98, 0x0e, 0x82, 0xfd, 0xe1, 0xef, 0x34, 0xf0, 0x83, 0x8c, + /*3fb0:*/ 0x9e, 0x2b, 0x1b, 0xdf, 0xf5, 0xfc, 0x42, 0x78, 0x43, 0xa1, 0x6d, 0xa4, 0x0a, 0x65, 0xae, 0xfe, + /*3fc0:*/ 0xf6, 0xdb, 0xfb, 0x02, 0x9d, 0x53, 0x15, 0xcf, 0x9d, 0x65, 0x1b, 0x9e, 0xfb, 0x20, 0x50, 0xe4, + /*3fd0:*/ 0xe3, 0xf0, 0x5d, 0xc8, 0x68, 0xb8, 0xd8, 0xa3, 0xe3, 0xff, 0xc5, 0xc1, 0x8c, 0xab, 0xcc, 0x8d, + /*3fe0:*/ 0xa1, 0x7a, 0x17, 0xe5, 0xdc, 0xb1, 0xf1, 0xea, 0x0c, 0x47, 0x0e, 0x22, 0xe2, 0x2e, 0x45, 0x3a, + /*3ff0:*/ 0x36, 0x66, 0xbb, 0x39, 0x38, 0xbd, 0x44, 0x1a, 0x53, 0xce, 0xd9, 0x41, 0x2c, 0x01, 0x2b, 0x49, + /*4000:*/ 0x81, 0x18, 0x05, 0x96, 0x4d, 0xd8, 0xd2, 0x38, 0xab, 0xef, 0xf9, 0x44, 0xc0, 0x12, 0xfe, 0xa3, + /*4010:*/ 0x16, 0xdf, 0x1f, 0xe8, 0xcd, 0x87, 0xb2, 0x00, 0x76, 0xcb, 0xa3, 0x14, 0xfa, 0x4c, 0x3b, 0x22, + /*4020:*/ 0xd8, 0x5b, 0x2e, 0xe3, 0x06, 0xee, 0x77, 0xd1, 0x3f, 0xbb, 0x22, 0x9a, 0xd5, 0x10, 0x09, 0xc0, + /*4030:*/ 0x91, 0xd7, 0x81, 0x8d, 0x95, 0x6c, 0x57, 0x72, 0xf3, 0x67, 0xa6, 0xc8, 0x29, 0xc5, 0xd1, 0x85, + /*4040:*/ 0xac, 0x37, 0x1e, 0x5b, 0x7b, 0x5f, 0x69, 0x35, 0x39, 0xce, 0x5d, 0xea, 0x6a, 0x3b, 0x4c, 0xa7, + /*4050:*/ 0x12, 0x3a, 0x68, 0xa8, 0xc9, 0x72, 0xc3, 0x1b, 0x98, 0xdb, 0x61, 0xd4, 0xc4, 0xf9, 0x8f, 0x8b, + /*4060:*/ 0xd9, 0x29, 0xf4, 0x89, 0xcb, 0x3b, 0x28, 0x62, 0x0a, 0x9c, 0x2d, 0x9e, 0xc1, 0xab, 0xe6, 0xb5, + /*4070:*/ 0x7e, 0x66, 0x51, 0xc7, 0x9c, 0x6f, 0xa8, 0xd4, 0x5d, 0xa5, 0x22, 0xed, 0x30, 0x26, 0xb6, 0x2b, + /*4080:*/ 0x85, 0x6d, 0x76, 0xc6, 0x86, 0x0e, 0xef, 0xe2, 0x1e, 0x9a, 0xaa, 0xf9, 0xae, 0xed, 0x02, 0x26, + /*4090:*/ 0x68, 0x0b, 0x15, 0xf9, 0x45, 0xf8, 0xb7, 0xcb, 0xfc, 0xff, 0xf2, 0x3e, 0xc9, 0x5a, 0x35, 0x14, + /*40a0:*/ 0x6b, 0x67, 0x69, 0xe9, 0x03, 0x12, 0xf4, 0xfb, 0x46, 0xa7, 0x9c, 0xc8, 0x43, 0x03, 0x08, 0xea, + /*40b0:*/ 0xf8, 0x5b, 0xdb, 0x29, 0xad, 0x73, 0x8c, 0x19, 0x18, 0x70, 0x47, 0xd7, 0x40, 0x66, 0x50, 0xfe, + /*40c0:*/ 0xf2, 0x00, 0xc4, 0xeb, 0x20, 0x8f, 0x20, 0xf1, 0x9d, 0xea, 0x23, 0x37, 0x8f, 0x22, 0x5d, 0xff, + /*40d0:*/ 0x8c, 0x17, 0xaa, 0x6a, 0x3a, 0xad, 0x9a, 0x79, 0x74, 0xe9, 0xdc, 0xc2, 0x97, 0x96, 0xb0, 0xf8, + /*40e0:*/ 0x86, 0x38, 0x13, 0x41, 0xfa, 0x08, 0xd9, 0x2a, 0x18, 0xbc, 0x4a, 0xb6, 0x2a, 0x7e, 0x8f, 0x0d, + /*40f0:*/ 0xeb, 0x09, 0x6c, 0xec, 0x39, 0xdc, 0x2e, 0x4c, 0xcd, 0x58, 0x0f, 0xaf, 0x7e, 0x0f, 0x04, 0x71, + /*4100:*/ 0x8f, 0xa4, 0x08, 0xe6, 0x2b, 0xda, 0xde, 0x42, 0x48, 0xb4, 0xa3, 0x4c, 0x1c, 0x70, 0x4d, 0x5c, + /*4110:*/ 0x5c, 0x5b, 0xca, 0x00, 0xa4, 0x2c, 0x9c, 0x39, 0x23, 0xcc, 0xf8, 0xbb, 0xa2, 0x5a, 0xe9, 0x33, + /*4120:*/ 0xe0, 0xa5, 0xb6, 0xcc, 0x86, 0x70, 0x8c, 0xd9, 0x22, 0x34, 0xf2, 0x44, 0xd0, 0xcb, 0x23, 0xbe, + /*4130:*/ 0xee, 0xa1, 0xeb, 0xbf, 0x17, 0xb5, 0x95, 0x5d, 0xc2, 0x35, 0xd2, 0x7e, 0xbb, 0xc4, 0xd7, 0xb3, + /*4140:*/ 0x43, 0x9e, 0x03, 0x5b, 0xc8, 0x54, 0xd8, 0x78, 0x8d, 0x6d, 0x3f, 0x51, 0x40, 0x0a, 0x9d, 0x44, + /*4150:*/ 0xcf, 0xc5, 0x9d, 0xe8, 0x44, 0x9b, 0xb7, 0x65, 0xd5, 0x42, 0x6f, 0xb5, 0x1f, 0x1a, 0x52, 0x36, + /*4160:*/ 0x73, 0x30, 0x29, 0xb4, 0x4c, 0x31, 0xa4, 0xff, 0xc8, 0x54, 0xb2, 0xde, 0xa7, 0x10, 0xa9, 0xb4, + /*4170:*/ 0x3b, 0xfd, 0x20, 0xdf, 0xc6, 0xcc, 0xfa, 0x32, 0xea, 0xf3, 0x60, 0x08, 0x4a, 0x29, 0x16, 0x72, + /*4180:*/ 0xb3, 0x4c, 0x7a, 0xe5, 0xc1, 0x88, 0x29, 0x23, 0x10, 0x02, 0x14, 0xad, 0x24, 0x64, 0xe3, 0x9e, + /*4190:*/ 0xfc, 0xd3, 0x5b, 0x43, 0xee, 0x1a, 0x4b, 0x1e, 0x49, 0xf2, 0x53, 0x37, 0xae, 0x21, 0xe9, 0x4b, + /*41a0:*/ 0x61, 0x89, 0xd0, 0x70, 0x94, 0x20, 0x17, 0x75, 0x59, 0x01, 0x0a, 0xb4, 0x98, 0xb2, 0x98, 0x0b, + /*41b0:*/ 0x17, 0x99, 0xc3, 0xfe, 0x63, 0x51, 0x97, 0xb2, 0x3b, 0x71, 0x54, 0x63, 0x70, 0x12, 0x3f, 0x26, + /*41c0:*/ 0xbe, 0x0e, 0x39, 0x26, 0xf6, 0xe4, 0xda, 0x87, 0xb2, 0x45, 0x03, 0x71, 0xce, 0xe6, 0xc1, 0xd1, + /*41d0:*/ 0x05, 0xfc, 0x46, 0x37, 0x27, 0x92, 0xb2, 0xa2, 0xfd, 0xa7, 0x9f, 0xa3, 0xdd, 0x94, 0x38, 0x83, + /*41e0:*/ 0x3e, 0x7b, 0xa2, 0x1d, 0xc2, 0x32, 0x36, 0xbf, 0x35, 0x2d, 0xa6, 0x1d, 0xf0, 0x94, 0x01, 0x78, + /*41f0:*/ 0xd3, 0x80, 0x66, 0x5f, 0xc8, 0xa5, 0x12, 0x99, 0x35, 0xb7, 0x96, 0x7b, 0x18, 0x41, 0x85, 0x9a, + /*4200:*/ 0x4b, 0x56, 0xd4, 0xf4, 0x3e, 0xe3, 0x17, 0xb8, 0x46, 0x55, 0xe8, 0x54, 0xbc, 0x1f, 0x43, 0x18, + /*4210:*/ 0xf4, 0xb7, 0x51, 0x7c, 0xd2, 0xa6, 0x3d, 0x75, 0xb6, 0x1d, 0x29, 0xad, 0x5b, 0xb7, 0xb0, 0x4c, + /*4220:*/ 0xc9, 0x51, 0xc0, 0x09, 0x25, 0x40, 0x90, 0xd7, 0x7c, 0x43, 0xfb, 0xa2, 0x86, 0x69, 0x0e, 0x3e, + /*4230:*/ 0x2b, 0x3e, 0xe9, 0x13, 0xef, 0x95, 0x70, 0x17, 0x57, 0x02, 0x0b, 0x50, 0x9d, 0x94, 0x1b, 0xb6, + /*4240:*/ 0x1e, 0x6b, 0x5e, 0x5f, 0xa1, 0x78, 0xc3, 0xfd, 0x5c, 0x2d, 0x66, 0x3e, 0xbe, 0x44, 0x03, 0x4e, + /*4250:*/ 0x95, 0x44, 0x28, 0xba, 0x09, 0xdc, 0x2d, 0x25, 0x68, 0xac, 0x17, 0x90, 0x5f, 0x2a, 0x8e, 0x74, + /*4260:*/ 0x88, 0x30, 0x7d, 0x60, 0x5b, 0xfd, 0x21, 0x3c, 0x72, 0x0c, 0x48, 0x90, 0x14, 0x8d, 0xc7, 0x8b, + /*4270:*/ 0xa9, 0x92, 0x66, 0xaa, 0xe4, 0x2d, 0x1b, 0x6f, 0xaf, 0x40, 0xd1, 0x63, 0x78, 0x7c, 0x19, 0x0a, + /*4280:*/ 0x30, 0x75, 0x7c, 0xb5, 0xaf, 0x64, 0xb7, 0x37, 0x60, 0x11, 0x7c, 0xc0, 0x1f, 0xa1, 0xeb, 0xf8, + /*4290:*/ 0x2b, 0x9b, 0x95, 0x31, 0x9f, 0x51, 0x8e, 0x5b, 0x88, 0xaa, 0x13, 0x54, 0xa8, 0xba, 0x21, 0xfe, + /*42a0:*/ 0x3c, 0xc3, 0x28, 0x7f, 0xc6, 0x03, 0xbc, 0x53, 0xde, 0xcd, 0x3c, 0x88, 0xd9, 0xa6, 0x3b, 0xe8, + /*42b0:*/ 0x47, 0x97, 0xca, 0xe9, 0x30, 0x9d, 0xb2, 0x3e, 0x61, 0x87, 0xc2, 0x65, 0x1a, 0x3d, 0x43, 0x8c, + /*42c0:*/ 0x0d, 0x46, 0x44, 0x20, 0xfb, 0x36, 0xd1, 0x1b, 0x67, 0x63, 0x5a, 0x75, 0xdc, 0x14, 0x26, 0xb3, + /*42d0:*/ 0xca, 0x3a, 0xab, 0x17, 0x2e, 0xaf, 0xe1, 0xec, 0x76, 0xc5, 0xc2, 0xef, 0xba, 0xfa, 0xb7, 0xa9, + /*42e0:*/ 0x52, 0xb9, 0x3e, 0xe5, 0x74, 0x21, 0xc3, 0x6b, 0x24, 0x43, 0xcb, 0x82, 0x73, 0x5d, 0x49, 0x59, + /*42f0:*/ 0xa1, 0xf8, 0x5c, 0x95, 0xea, 0x94, 0x93, 0x5b, 0x01, 0xda, 0xd9, 0x19, 0x50, 0x8d, 0x40, 0xa5, + /*4300:*/ 0x83, 0x34, 0x52, 0x7e, 0x41, 0x3f, 0x81, 0x87, 0xc5, 0x5a, 0x70, 0xc9, 0x04, 0x07, 0xe9, 0x68, + /*4310:*/ 0x8e, 0x56, 0x93, 0x6f, 0x2b, 0x2a, 0x7a, 0x16, 0xdb, 0x4e, 0x7b, 0x2b, 0xcd, 0xe0, 0x24, 0x9a, + /*4320:*/ 0xc1, 0xbd, 0x2e, 0x4b, 0x36, 0xba, 0x49, 0x97, 0xbf, 0x97, 0x51, 0x2a, 0xfd, 0xe5, 0xf9, 0x71, + /*4330:*/ 0xf2, 0xf0, 0x2a, 0xe1, 0x33, 0x99, 0x49, 0xf6, 0x7f, 0xea, 0x07, 0x1d, 0x55, 0x88, 0x2b, 0x24, + /*4340:*/ 0xed, 0x3b, 0x9f, 0xd4, 0xaf, 0x50, 0x6b, 0xfe, 0xdf, 0xe2, 0x66, 0x0d, 0xdc, 0x13, 0x5e, 0xf9, + /*4350:*/ 0x66, 0xb8, 0x61, 0x52, 0x93, 0x14, 0x12, 0x8e, 0x36, 0x21, 0xe2, 0x34, 0xa0, 0xd6, 0xde, 0x0e, + /*4360:*/ 0x8d, 0x35, 0x01, 0xfb, 0xe7, 0xe7, 0x60, 0x41, 0xe8, 0xab, 0xf5, 0x4c, 0x82, 0x60, 0x69, 0xbe, + /*4370:*/ 0x3e, 0x9e, 0x9f, 0x65, 0xa3, 0x0a, 0x6e, 0xba, 0x86, 0xff, 0x45, 0x20, 0x8a, 0x3d, 0xf9, 0xfa, + /*4380:*/ 0xe8, 0x01, 0xf4, 0x42, 0x21, 0x5d, 0xa5, 0x3b, 0xff, 0x80, 0xd1, 0xbf, 0xe0, 0x9d, 0x99, 0xf1, + /*4390:*/ 0xe0, 0x97, 0x14, 0xd9, 0xc7, 0x1a, 0x3b, 0xf2, 0x21, 0x76, 0x56, 0x75, 0xf6, 0x8b, 0x75, 0x95, + /*43a0:*/ 0x5d, 0x0d, 0x2e, 0x59, 0xcb, 0xf2, 0x0e, 0xde, 0x42, 0xb8, 0xdd, 0x86, 0x2a, 0xcc, 0xb3, 0x97, + /*43b0:*/ 0x7d, 0x5f, 0x81, 0xb7, 0xf5, 0x88, 0x54, 0xea, 0xdb, 0x0a, 0x97, 0x08, 0x08, 0x55, 0x97, 0x51, + /*43c0:*/ 0x1d, 0x8d, 0xae, 0xf4, 0x5a, 0xc5, 0x84, 0xef, 0x07, 0xb0, 0xb3, 0x4d, 0x3b, 0xfb, 0xe8, 0x33, + /*43d0:*/ 0x24, 0xed, 0x5a, 0xb3, 0xa4, 0xe6, 0x0c, 0x14, 0xb3, 0xd2, 0x39, 0x8f, 0x1e, 0x39, 0xe0, 0x00, + /*43e0:*/ 0xfc, 0x4e, 0x0a, 0x0e, 0x76, 0x8c, 0xef, 0x21, 0xec, 0x95, 0xf8, 0x18, 0xa6, 0x66, 0xce, 0xec, + /*43f0:*/ 0x62, 0x22, 0xf5, 0xfe, 0xc8, 0x6c, 0x6e, 0x3e, 0x42, 0x35, 0xde, 0xce, 0xa9, 0x73, 0x8c, 0xc9, + /*4400:*/ 0xe2, 0xaa, 0xe8, 0xfa, 0xab, 0x13, 0xcb, 0x06, 0xf7, 0xee, 0x99, 0xfd, 0x2d, 0x0b, 0x92, 0xe2, + /*4410:*/ 0x79, 0x96, 0x6b, 0xf3, 0x73, 0x01, 0x26, 0x48, 0x32, 0xcd, 0x19, 0x2a, 0x12, 0x84, 0xa0, 0xca, + /*4420:*/ 0x5f, 0xc0, 0xe8, 0x86, 0x40, 0x8c, 0xa3, 0xd5, 0x2e, 0x14, 0x5d, 0x58, 0xad, 0x2b, 0xcf, 0xf7, + /*4430:*/ 0xeb, 0x8c, 0xba, 0x59, 0x18, 0x13, 0x62, 0x14, 0xe6, 0x01, 0x89, 0xeb, 0xae, 0x22, 0xf6, 0x66, + /*4440:*/ 0xd5, 0x9a, 0x07, 0x76, 0x87, 0xf8, 0xb9, 0x1b, 0xa5, 0x4f, 0xa2, 0xfd, 0x84, 0xcd, 0x1d, 0x81, + /*4450:*/ 0x1b, 0xda, 0xd6, 0x14, 0x60, 0xfa, 0x17, 0x14, 0x59, 0x18, 0x06, 0x70, 0x06, 0x61, 0x03, 0x80, + /*4460:*/ 0x44, 0x8f, 0x5e, 0xb8, 0xb8, 0xc5, 0x80, 0x43, 0xb5, 0x35, 0x97, 0xbe, 0x4c, 0x25, 0x38, 0xfd, + /*4470:*/ 0x2b, 0xa6, 0xbc, 0xcc, 0x37, 0x34, 0x23, 0x44, 0x32, 0x85, 0xf1, 0x7d, 0xea, 0xc5, 0xb2, 0x3d, + /*4480:*/ 0xed, 0x58, 0xe3, 0x07, 0xed, 0xb4, 0x52, 0x84, 0xf4, 0xcf, 0xa4, 0xe9, 0x4b, 0xe4, 0x35, 0xb5, + /*4490:*/ 0x4b, 0x3d, 0xb1, 0x2f, 0x6f, 0xcc, 0x9f, 0xc5, 0xf1, 0x6e, 0x74, 0xe4, 0x07, 0x1e, 0xef, 0x0e, + /*44a0:*/ 0xf0, 0x32, 0x3f, 0x91, 0x7d, 0x44, 0x0c, 0xe6, 0xb9, 0x3a, 0xdd, 0x8b, 0x0b, 0x34, 0x7b, 0x28, + /*44b0:*/ 0x10, 0xe5, 0xc9, 0x95, 0x34, 0x18, 0xa7, 0xd2, 0x6f, 0x67, 0x8b, 0x3d, 0xa3, 0x49, 0x16, 0xb8, + /*44c0:*/ 0x9e, 0x1b, 0x64, 0x2d, 0xbe, 0xf9, 0x81, 0x16, 0xcb, 0xd5, 0x2f, 0x67, 0x1d, 0x54, 0x64, 0xb8, + /*44d0:*/ 0xee, 0x98, 0x75, 0x12, 0xa1, 0x62, 0xb9, 0xa6, 0x4b, 0xc7, 0x8f, 0x85, 0x77, 0xd2, 0xf4, 0x8f, + /*44e0:*/ 0x36, 0xbe, 0xa3, 0xe7, 0x6c, 0xf9, 0xb1, 0x88, 0xf8, 0xf0, 0xac, 0x74, 0x32, 0xa5, 0x47, 0x69, + /*44f0:*/ 0x6d, 0xb6, 0x11, 0xc7, 0x47, 0x0d, 0xdf, 0x35, 0xf3, 0x59, 0x66, 0x2b, 0x47, 0xd7, 0x21, 0x46, + /*4500:*/ 0x57, 0x53, 0x83, 0x33, 0x66, 0x00, 0x78, 0x82, 0x93, 0x7c, 0xb8, 0x46, 0x3b, 0xe6, 0xd5, 0xe9, + /*4510:*/ 0xee, 0xac, 0x1a, 0x7f, 0x88, 0xb3, 0xc1, 0x06, 0xd1, 0x97, 0x9f, 0xa6, 0x03, 0xea, 0x7a, 0x41, + /*4520:*/ 0xfd, 0xae, 0xc6, 0x75, 0x11, 0x77, 0x35, 0x1b, 0x7b, 0x79, 0x6b, 0xb0, 0x0d, 0xd8, 0x7c, 0xd2, + /*4530:*/ 0x7a, 0x50, 0x58, 0x38, 0x94, 0x8e, 0x19, 0x4d, 0x97, 0x45, 0x53, 0xf9, 0x99, 0xa2, 0x8c, 0xaf, + /*4540:*/ 0xf9, 0x87, 0x11, 0x5a, 0xd3, 0x09, 0xcb, 0x63, 0x93, 0x0e, 0xd1, 0xbf, 0x27, 0x88, 0x3d, 0xb6, + /*4550:*/ 0x17, 0x96, 0x20, 0x9a, 0x27, 0x49, 0xd9, 0x45, 0x05, 0x34, 0x70, 0xa6, 0x4e, 0xab, 0x6b, 0xa2, + /*4560:*/ 0x3c, 0xa6, 0x2e, 0xf2, 0x29, 0xfe, 0x7a, 0xc9, 0x06, 0x7d, 0xa1, 0xb6, 0x8b, 0xf2, 0xbf, 0xe7, + /*4570:*/ 0xd0, 0x02, 0x39, 0x04, 0x19, 0x22, 0xf0, 0x18, 0x6e, 0x7f, 0x00, 0x4b, 0x8a, 0x42, 0xa7, 0xe3, + /*4580:*/ 0x8f, 0x46, 0x0a, 0x92, 0x12, 0x7a, 0xe5, 0xf9, 0x4a, 0x4f, 0x28, 0xb2, 0x57, 0x1c, 0x8a, 0xb2, + /*4590:*/ 0x6d, 0xce, 0x6e, 0x42, 0xd6, 0x68, 0xba, 0x60, 0xb2, 0x2a, 0x82, 0x12, 0x80, 0x8c, 0x61, 0xc9, + /*45a0:*/ 0xdb, 0xdf, 0x9f, 0x0a, 0x18, 0x8b, 0x7c, 0xf4, 0x25, 0xba, 0x7f, 0x7e, 0x0d, 0x7e, 0x17, 0xc8, + /*45b0:*/ 0x05, 0x39, 0x13, 0x55, 0x55, 0x0d, 0x0f, 0x21, 0x5d, 0xf8, 0x6a, 0x83, 0x2a, 0xe4, 0x25, 0xa9, + /*45c0:*/ 0x27, 0x6b, 0x3b, 0xa5, 0xff, 0x66, 0xfc, 0x83, 0xcf, 0x73, 0xef, 0xfc, 0x72, 0x51, 0x58, 0x97, + /*45d0:*/ 0x52, 0x1f, 0x57, 0x54, 0xa5, 0xe6, 0x14, 0xe5, 0xfe, 0xb2, 0x3e, 0xb7, 0x52, 0x13, 0x62, 0x8c, + /*45e0:*/ 0x39, 0xfe, 0x67, 0x45, 0xc4, 0xf3, 0x16, 0xd7, 0xa1, 0x0e, 0x16, 0xe1, 0xb2, 0xb9, 0xba, 0xe7, + /*45f0:*/ 0xe1, 0x5c, 0x44, 0x6c, 0xaf, 0xae, 0xea, 0xdf, 0x16, 0x7a, 0xd1, 0xcd, 0xe6, 0x77, 0xf8, 0x0c, + /*4600:*/ 0x99, 0xc9, 0x07, 0xa4, 0x3a, 0xa9, 0x7a, 0x79, 0xe1, 0x00, 0x76, 0xbf, 0x8c, 0x54, 0xf9, 0x13, + /*4610:*/ 0xf3, 0x2d, 0xe5, 0xc1, 0xcc, 0x39, 0x18, 0xbb, 0x68, 0x44, 0x14, 0xdb, 0x52, 0x3f, 0x9d, 0x5e, + /*4620:*/ 0x70, 0x80, 0xd1, 0x12, 0x69, 0xe8, 0xe5, 0x05, 0x9b, 0x3f, 0x34, 0x24, 0xf6, 0xb9, 0x14, 0xaf, + /*4630:*/ 0x62, 0x38, 0x5b, 0x41, 0xa7, 0x2a, 0x4f, 0x75, 0xb1, 0x4a, 0x5c, 0xef, 0x78, 0x21, 0x9c, 0x78, + /*4640:*/ 0xd7, 0xf8, 0x4e, 0xe6, 0x9c, 0x2e, 0xde, 0xe5, 0x65, 0x3d, 0xfe, 0x7b, 0xd2, 0xea, 0x2f, 0x15, + /*4650:*/ 0x35, 0x6e, 0xc7, 0xfe, 0xcc, 0xe6, 0x3d, 0x40, 0xb6, 0x4a, 0xb8, 0x0e, 0x78, 0x26, 0xba, 0xa0, + /*4660:*/ 0xf5, 0xdd, 0xfd, 0x89, 0x5a, 0xb8, 0x3d, 0x92, 0x62, 0x32, 0xe8, 0xc5, 0xc8, 0x69, 0x93, 0xb0, + /*4670:*/ 0xd2, 0xaa, 0xe2, 0xda, 0x9c, 0xe4, 0xd7, 0x41, 0x5e, 0xdc, 0x74, 0xab, 0x36, 0x1b, 0xaf, 0x71, + /*4680:*/ 0xdd, 0xd2, 0x67, 0x25, 0x38, 0x10, 0xd3, 0xc6, 0x00, 0x8e, 0xe6, 0xba, 0xea, 0x91, 0x81, 0x45, + /*4690:*/ 0x2e, 0xad, 0x9b, 0x38, 0xe8, 0x77, 0x1d, 0x11, 0x81, 0xd4, 0x90, 0x1a, 0xac, 0xb5, 0x66, 0xdf, + /*46a0:*/ 0x5e, 0x4c, 0xc1, 0x1e, 0x82, 0x7a, 0xb1, 0x89, 0xbe, 0xb1, 0xe1, 0xad, 0x4d, 0xd4, 0xce, 0xa3, + /*46b0:*/ 0x76, 0x0f, 0x2a, 0xe7, 0x5b, 0x4a, 0x75, 0x0d, 0xbb, 0xd9, 0xf8, 0xe0, 0x8c, 0xd3, 0x0f, 0x3d, + /*46c0:*/ 0xbe, 0x17, 0x58, 0x15, 0x5a, 0x83, 0x2e, 0x81, 0xae, 0xa5, 0x69, 0xe2, 0x71, 0xf4, 0x24, 0xd7, + /*46d0:*/ 0xd2, 0x18, 0x5c, 0x74, 0x2c, 0x2e, 0xe7, 0xae, 0x6e, 0xe9, 0x18, 0x64, 0x83, 0x24, 0xb4, 0x5b, + /*46e0:*/ 0x6e, 0xe3, 0xb3, 0xae, 0x38, 0xe0, 0xb4, 0xba, 0xfe, 0xf7, 0x82, 0xed, 0xa3, 0x88, 0xad, 0xa9, + /*46f0:*/ 0xa6, 0x37, 0xf2, 0xc5, 0x83, 0xf8, 0x24, 0xc9, 0x56, 0x8e, 0x94, 0xa3, 0x7d, 0xa7, 0x2b, 0x83, + /*4700:*/ 0xc2, 0xe9, 0x87, 0xa0, 0x85, 0x05, 0x4d, 0x35, 0x1e, 0xe0, 0x9e, 0x06, 0xbf, 0x81, 0x26, 0xde, + /*4710:*/ 0x6d, 0x55, 0x5f, 0x93, 0xad, 0x80, 0x1e, 0xa5, 0x5c, 0x9d, 0xa6, 0xac, 0x19, 0xa1, 0xf7, 0xb4, + /*4720:*/ 0x65, 0x4a, 0xfd, 0xe1, 0xeb, 0x3d, 0xb9, 0x44, 0x53, 0x8f, 0xd0, 0xbe, 0x7d, 0xcf, 0xd5, 0x6c, + /*4730:*/ 0xf8, 0x32, 0xde, 0x8f, 0x50, 0x63, 0xa7, 0x4d, 0xe5, 0x0a, 0x5b, 0x2a, 0x2c, 0xd1, 0xcd, 0x32, + /*4740:*/ 0x96, 0xd1, 0x4e, 0x21, 0x08, 0xa7, 0x4a, 0xbd, 0x96, 0x51, 0xa3, 0x18, 0x7a, 0xb2, 0xba, 0x41, + /*4750:*/ 0xb6, 0x99, 0x70, 0xc8, 0xc1, 0x7b, 0xb8, 0x84, 0xa2, 0x20, 0x8a, 0x1e, 0x1b, 0x9b, 0x56, 0xd4, + /*4760:*/ 0xc6, 0xdd, 0x00, 0xfe, 0xa6, 0xb1, 0xb6, 0x8b, 0x02, 0x5b, 0xcd, 0xdf, 0xb5, 0x72, 0xe4, 0xd0, + /*4770:*/ 0x9d, 0x95, 0x1d, 0x44, 0xf2, 0x73, 0x7f, 0x18, 0x5b, 0xc5, 0xc3, 0xc4, 0xdd, 0xc6, 0x13, 0x58, + /*4780:*/ 0x71, 0x44, 0xec, 0x5b, 0xf6, 0x43, 0x89, 0x21, 0xd8, 0x91, 0x64, 0xb6, 0x69, 0x89, 0x91, 0x4f, + /*4790:*/ 0x78, 0x3d, 0xfb, 0xa1, 0x73, 0x96, 0x5f, 0xbf, 0xc0, 0x19, 0x82, 0x0f, 0xb5, 0x2b, 0x3f, 0x1d, + /*47a0:*/ 0xba, 0x9a, 0xe8, 0x2e, 0xe5, 0xb9, 0xb9, 0xe7, 0x4c, 0x27, 0x00, 0xca, 0x79, 0xac, 0x5a, 0xfd, + /*47b0:*/ 0x13, 0xcb, 0x53, 0x35, 0x65, 0xfa, 0x4d, 0xed, 0xe7, 0x98, 0xe4, 0x00, 0xa0, 0x0f, 0x9d, 0xfc, + /*47c0:*/ 0x54, 0x71, 0x69, 0x14, 0x0b, 0xd4, 0x46, 0x62, 0xa9, 0xa5, 0x72, 0x75, 0x5d, 0x22, 0x7b, 0x82, + /*47d0:*/ 0x3d, 0xf2, 0x2b, 0xd8, 0x8e, 0x77, 0xc8, 0xf8, 0x97, 0xc3, 0xce, 0x00, 0xdf, 0xa8, 0x00, 0x8a, + /*47e0:*/ 0x2a, 0x12, 0x75, 0x10, 0xa8, 0x21, 0x82, 0x86, 0xbd, 0xa8, 0xa1, 0x75, 0xc1, 0x9a, 0x00, 0x71, + /*47f0:*/ 0x27, 0x73, 0x00, 0xb8, 0x2a, 0x04, 0x21, 0xb8, 0xc4, 0x56, 0xa0, 0xef, 0xd2, 0x90, 0xc7, 0x23, + /*4800:*/ 0x4e, 0x51, 0x7e, 0xcb, 0x9b, 0x5e, 0x4c, 0xae, 0xb0, 0x62, 0xbe, 0x39, 0x3d, 0x19, 0x39, 0x5f, + /*4810:*/ 0x32, 0x13, 0x86, 0x6a, 0x5a, 0xad, 0x11, 0x6c, 0x74, 0xf9, 0x5e, 0x78, 0x5e, 0x6e, 0x04, 0xcf, + /*4820:*/ 0xeb, 0x2d, 0xe1, 0x7c, 0x5a, 0xfa, 0x7d, 0x26, 0xdc, 0x68, 0x43, 0x09, 0x55, 0x1c, 0x32, 0xcf, + /*4830:*/ 0xd8, 0x6d, 0x89, 0xa1, 0xab, 0xb3, 0x17, 0x94, 0x18, 0x25, 0x86, 0x76, 0xc2, 0x05, 0xf4, 0x11, + /*4840:*/ 0x06, 0x39, 0x9b, 0x1b, 0x89, 0xab, 0x3d, 0x33, 0x77, 0x09, 0xf1, 0x16, 0x7d, 0x44, 0x2e, 0x05, + /*4850:*/ 0xe4, 0x38, 0xc6, 0xc6, 0x4e, 0xdb, 0xe1, 0x2f, 0x98, 0xae, 0x45, 0xf5, 0xf5, 0x34, 0x50, 0x05, + /*4860:*/ 0xf0, 0x32, 0x1f, 0x7a, 0x7c, 0xf5, 0x71, 0xa5, 0x08, 0xbb, 0x61, 0x58, 0x3b, 0x4d, 0x48, 0xf8, + /*4870:*/ 0x9b, 0x76, 0x32, 0x34, 0x1b, 0x3d, 0x13, 0x1e, 0xf8, 0xed, 0x51, 0x6b, 0x24, 0xa5, 0xe9, 0x96, + /*4880:*/ 0x34, 0x98, 0x68, 0xfb, 0xa9, 0x4d, 0x12, 0xa1, 0xa1, 0x0d, 0x6e, 0x32, 0x82, 0xb4, 0xd3, 0xb1, + /*4890:*/ 0xb5, 0x20, 0x42, 0xa0, 0xe2, 0x3f, 0x8e, 0xac, 0xe9, 0x37, 0xc5, 0x14, 0x91, 0x5d, 0xd4, 0xd3, + /*48a0:*/ 0xed, 0x11, 0x04, 0x27, 0x90, 0xe1, 0x6d, 0xe4, 0xef, 0xd3, 0x41, 0xe3, 0xdc, 0xd3, 0xfc, 0x4c, + /*48b0:*/ 0x22, 0x59, 0xc2, 0x33, 0x3c, 0x08, 0xbb, 0x80, 0x32, 0x44, 0xf9, 0x50, 0x11, 0x26, 0x12, 0xd8, + /*48c0:*/ 0x68, 0x6c, 0x3b, 0x7f, 0x54, 0x94, 0x03, 0x59, 0x00, 0xea, 0x1d, 0x9d, 0xbb, 0x22, 0xe2, 0xbd, + /*48d0:*/ 0xd6, 0x00, 0xe9, 0xcf, 0x9f, 0x86, 0x05, 0x2f, 0x48, 0x2b, 0x79, 0x86, 0x0f, 0x4c, 0xc9, 0xb2, + /*48e0:*/ 0x2d, 0xbb, 0xde, 0x59, 0x01, 0x47, 0x98, 0x6b, 0x0d, 0xb2, 0xeb, 0x84, 0x66, 0x1a, 0xd4, 0xa3, + /*48f0:*/ 0x0f, 0xb9, 0xb7, 0xd9, 0xa5, 0x0b, 0x23, 0xa8, 0x49, 0xc9, 0x47, 0xd3, 0xff, 0x94, 0xcd, 0x5e, + /*4900:*/ 0x78, 0x6a, 0x58, 0x7b, 0x41, 0x12, 0x8d, 0x50, 0x3e, 0xa4, 0x50, 0x53, 0x1d, 0x84, 0xda, 0x58, + /*4910:*/ 0x6f, 0x7f, 0x90, 0x58, 0xaf, 0xfa, 0x25, 0xd0, 0x02, 0xd8, 0xea, 0xc9, 0x35, 0x88, 0xd9, 0xf3, + /*4920:*/ 0x02, 0xa8, 0xf0, 0xbc, 0x8b, 0x46, 0x42, 0xc5, 0x36, 0xf6, 0xcf, 0x15, 0x5c, 0x74, 0x98, 0x2d, + /*4930:*/ 0x29, 0x7f, 0x80, 0xe5, 0xae, 0xb7, 0xb6, 0xf3, 0x11, 0xcc, 0x54, 0x1f, 0xb4, 0x93, 0x34, 0xbe, + /*4940:*/ 0x85, 0x7f, 0x4e, 0x3d, 0x1e, 0xe9, 0x63, 0x9c, 0x17, 0x10, 0x28, 0xfb, 0x5a, 0xbc, 0xcb, 0x71, + /*4950:*/ 0xb5, 0x64, 0x09, 0x84, 0x9c, 0x6b, 0x8c, 0x54, 0x35, 0xc7, 0x75, 0xc2, 0x6c, 0x3a, 0xee, 0xc2, + /*4960:*/ 0xcb, 0xb6, 0x57, 0xad, 0x23, 0xea, 0x18, 0x65, 0x6f, 0xd8, 0xbe, 0x2d, 0x5f, 0x05, 0x18, 0x0e, + /*4970:*/ 0x1d, 0xe6, 0xce, 0xaa, 0xd7, 0xf3, 0x36, 0xed, 0xc9, 0x8c, 0xaf, 0x33, 0x80, 0xe0, 0xf2, 0x80, + /*4980:*/ 0x78, 0x4d, 0xa9, 0x69, 0xa7, 0x1c, 0xd6, 0x13, 0x0f, 0xdd, 0xd6, 0x58, 0x05, 0xc8, 0xad, 0x98, + /*4990:*/ 0x2e, 0x6f, 0xcd, 0x38, 0x75, 0x85, 0x99, 0xd2, 0xc3, 0x3f, 0x8b, 0xcb, 0x8b, 0xf0, 0xcf, 0x87, + /*49a0:*/ 0x84, 0xd5, 0xf7, 0xb9, 0xca, 0x85, 0x3e, 0x5d, 0x0a, 0xbd, 0xd8, 0x4b, 0xfb, 0x5a, 0xdc, 0x84, + /*49b0:*/ 0x3e, 0x0f, 0x0e, 0x16, 0x6b, 0x0a, 0x17, 0xac, 0xc6, 0x91, 0x65, 0xd0, 0x7b, 0xaf, 0x41, 0xea, + /*49c0:*/ 0xaf, 0xa9, 0x9e, 0x8f, 0xfb, 0x38, 0xee, 0xe9, 0xf8, 0xcd, 0x90, 0xf4, 0xc0, 0x9c, 0xb3, 0x2f, + /*49d0:*/ 0x0d, 0x52, 0xdc, 0x83, 0x06, 0xfd, 0xb0, 0xe8, 0x2e, 0x89, 0x1a, 0x1f, 0xb0, 0x86, 0x05, 0x2b, + /*49e0:*/ 0x00, 0xac, 0x0a, 0x8e, 0xf7, 0x3b, 0xb0, 0xa3, 0x94, 0x6e, 0x5b, 0xb9, 0x02, 0x34, 0xc5, 0xa1, + /*49f0:*/ 0x65, 0xce, 0x03, 0x23, 0x71, 0x3b, 0x96, 0x96, 0x20, 0x29, 0x13, 0x6a, 0x5d, 0x1d, 0xab, 0x44, + /*4a00:*/ 0xc2, 0xfc, 0xab, 0x74, 0xf9, 0x90, 0xeb, 0xf7, 0x4a, 0x08, 0x8e, 0x47, 0x9f, 0x16, 0xc0, 0x07, + /*4a10:*/ 0x97, 0x36, 0x59, 0x1b, 0xce, 0x87, 0xf4, 0xf9, 0x4c, 0x8b, 0xa9, 0xa0, 0x06, 0x25, 0x4e, 0x0f, + /*4a20:*/ 0xc3, 0xb9, 0x67, 0xe1, 0xb1, 0xfd, 0x4c, 0x5e, 0xad, 0x29, 0x28, 0xc5, 0x34, 0x00, 0x11, 0x23, + /*4a30:*/ 0xb9, 0x29, 0xb3, 0x5a, 0x5c, 0x31, 0x67, 0x23, 0x84, 0xa6, 0xd9, 0x26, 0x27, 0x11, 0x09, 0x21, + /*4a40:*/ 0x43, 0x0b, 0x8b, 0x97, 0xbc, 0x4d, 0x9b, 0x3b, 0x21, 0xf8, 0x8d, 0xa2, 0x1f, 0xbb, 0xca, 0xd7, + /*4a50:*/ 0x38, 0xcf, 0xb7, 0x20, 0x7c, 0x95, 0x0d, 0x42, 0xaf, 0xf4, 0x71, 0x6f, 0x3c, 0x47, 0xb1, 0x0d, + /*4a60:*/ 0x76, 0x26, 0x14, 0x70, 0xff, 0x2c, 0xd8, 0x06, 0xc0, 0xdd, 0x18, 0xa1, 0x18, 0x83, 0x26, 0x6e, + /*4a70:*/ 0x9a, 0x3b, 0x25, 0xf0, 0xfb, 0x7e, 0xab, 0xaf, 0x9a, 0x26, 0x90, 0xd1, 0xb2, 0x29, 0x94, 0x49, + /*4a80:*/ 0x45, 0x4b, 0x4b, 0x95, 0xf4, 0xd6, 0xc6, 0x30, 0xc5, 0xf7, 0x21, 0x1b, 0x48, 0x45, 0x50, 0x01, + /*4a90:*/ 0xb1, 0xb8, 0x83, 0xe4, 0xfb, 0xbb, 0x5a, 0xc6, 0x63, 0xe2, 0x5e, 0x85, 0x98, 0x3e, 0xdf, 0x67, + /*4aa0:*/ 0x75, 0xbd, 0xb6, 0x59, 0x67, 0x47, 0x01, 0xea, 0xe3, 0x2d, 0xcc, 0xde, 0xf8, 0x58, 0x37, 0x99, + /*4ab0:*/ 0xb6, 0xbd, 0xec, 0xd5, 0x51, 0x9c, 0x22, 0x4e, 0x96, 0x52, 0x2a, 0x2a, 0x2e, 0x3b, 0x82, 0x98, + /*4ac0:*/ 0xd8, 0xae, 0x56, 0x6a, 0x20, 0x7c, 0x4d, 0x86, 0x46, 0x1c, 0x0c, 0x91, 0x4c, 0xe4, 0x23, 0xf2, + /*4ad0:*/ 0x0d, 0x06, 0x89, 0x72, 0xd3, 0xd7, 0x24, 0xd9, 0xb8, 0x4e, 0xb2, 0x6a, 0x72, 0x75, 0x74, 0x9a, + /*4ae0:*/ 0x94, 0x65, 0x97, 0xac, 0xdf, 0x1d, 0x5c, 0x48, 0x0e, 0xa7, 0x1a, 0x22, 0x69, 0x2e, 0xb3, 0x92, + /*4af0:*/ 0x6e, 0x69, 0xdc, 0x65, 0xd1, 0xf0, 0xfa, 0xf5, 0x41, 0x5c, 0x78, 0x54, 0x72, 0x1a, 0x8e, 0xe7, + /*4b00:*/ 0xc8, 0x7c, 0xd2, 0x43, 0x6b, 0x78, 0xe9, 0x22, 0xc3, 0x87, 0x28, 0x3c, 0x10, 0x8d, 0x86, 0x9f, + /*4b10:*/ 0x93, 0xdf, 0x0c, 0x5c, 0x55, 0x91, 0x4c, 0x7f, 0x3a, 0x80, 0x47, 0x5f, 0x73, 0xba, 0xa1, 0xbb, + /*4b20:*/ 0xe2, 0xb5, 0xba, 0xfc, 0x83, 0x0f, 0x70, 0xe5, 0xea, 0x7c, 0x9e, 0xe8, 0x8e, 0x3d, 0x3a, 0xde, + /*4b30:*/ 0x5c, 0x60, 0xc7, 0x99, 0x21, 0x3e, 0x2d, 0x35, 0x45, 0xee, 0x11, 0xe6, 0xdd, 0x3f, 0x21, 0xb4, + /*4b40:*/ 0xae, 0x9c, 0x69, 0x48, 0x86, 0xec, 0xac, 0x6c, 0x53, 0x98, 0xba, 0x8c, 0xcc, 0xf2, 0x10, 0x39, + /*4b50:*/ 0x7b, 0x83, 0x71, 0x8b, 0xda, 0x2f, 0xd3, 0xca, 0x64, 0xd8, 0x56, 0xdc, 0xc2, 0x34, 0x51, 0x64, + /*4b60:*/ 0x78, 0x90, 0x57, 0x1d, 0xa7, 0xae, 0x70, 0x77, 0x3d, 0x0d, 0xef, 0x4d, 0x58, 0xae, 0xe1, 0xe4, + /*4b70:*/ 0xe6, 0xee, 0xfd, 0x21, 0x12, 0xf7, 0x3b, 0x8d, 0x9f, 0xb2, 0x62, 0xe4, 0x97, 0x6b, 0x46, 0x69, + /*4b80:*/ 0xfa, 0x03, 0x9e, 0x30, 0x9b, 0x16, 0xad, 0xe5, 0xe6, 0x06, 0xf6, 0x8e, 0x87, 0x68, 0xa6, 0x48, + /*4b90:*/ 0x91, 0xa2, 0x77, 0x54, 0xc4, 0xd8, 0x52, 0x58, 0x59, 0x66, 0x19, 0xc9, 0x88, 0x4e, 0x4e, 0xd7, + /*4ba0:*/ 0xd3, 0x8a, 0x3f, 0x33, 0xa2, 0x55, 0xfe, 0x6a, 0x00, 0xc3, 0x40, 0xec, 0x36, 0x5f, 0x61, 0x0a, + /*4bb0:*/ 0xbe, 0x37, 0x62, 0x35, 0x75, 0x82, 0x73, 0x20, 0x52, 0x22, 0x01, 0x48, 0x6a, 0x64, 0x99, 0x81, + /*4bc0:*/ 0xa2, 0x86, 0xb6, 0x62, 0xe9, 0x23, 0x73, 0xdf, 0x4b, 0xc2, 0xf8, 0x08, 0x7d, 0xe6, 0x0f, 0x5d, + /*4bd0:*/ 0x98, 0xbd, 0xb7, 0x7e, 0x60, 0x8d, 0xfd, 0x30, 0x59, 0x38, 0xf8, 0xa2, 0xa3, 0x7e, 0x92, 0x4a, + /*4be0:*/ 0xe1, 0x46, 0x20, 0xab, 0xa8, 0x0f, 0x5f, 0x4e, 0x95, 0xa3, 0x23, 0x4b, 0x50, 0x92, 0x39, 0xb3, + /*4bf0:*/ 0x45, 0xa3, 0x67, 0xee, 0xbe, 0x0f, 0xea, 0x34, 0xd1, 0x2d, 0x0f, 0x78, 0x31, 0xfc, 0x4b, 0x32, + /*4c00:*/ 0xe6, 0x2b, 0x63, 0xab, 0xda, 0xf1, 0xbc, 0x55, 0xc2, 0xfe, 0x9e, 0xae, 0x07, 0x4f, 0x1e, 0x0c, + /*4c10:*/ 0x18, 0x78, 0xf5, 0x6a, 0x6c, 0xa4, 0x8b, 0xc3, 0xe3, 0xd1, 0x87, 0x04, 0x8d, 0x9a, 0xb7, 0x87, + /*4c20:*/ 0x68, 0x8b, 0x44, 0x6e, 0x2f, 0x0b, 0x07, 0x33, 0x43, 0x87, 0x0f, 0x86, 0x08, 0x7a, 0xd6, 0xb5, + /*4c30:*/ 0x3c, 0x5f, 0x81, 0x49, 0x10, 0xa4, 0x07, 0x09, 0xef, 0xc9, 0xb4, 0xbf, 0x95, 0x84, 0x0a, 0x5c, + /*4c40:*/ 0xfd, 0x44, 0xfe, 0x7f, 0xf4, 0x5a, 0xb0, 0xb4, 0xb1, 0x42, 0xe8, 0xbf, 0x82, 0xf7, 0xe9, 0x09, + /*4c50:*/ 0x97, 0x6c, 0xbf, 0x30, 0x2b, 0x83, 0xd1, 0x40, 0xe8, 0x2b, 0xb8, 0x10, 0x54, 0x12, 0xaa, 0x8f, + /*4c60:*/ 0x33, 0x76, 0x1a, 0xc9, 0x70, 0x6e, 0xaa, 0xa7, 0xe9, 0xcd, 0x16, 0x58, 0x2c, 0x18, 0xb0, 0x4f, + /*4c70:*/ 0x2c, 0x0c, 0x7d, 0xd2, 0xa4, 0x42, 0x3f, 0xbf, 0x50, 0x14, 0xa3, 0x8f, 0x10, 0x8a, 0xd6, 0xcc, + /*4c80:*/ 0x89, 0xf8, 0xdb, 0x77, 0x0f, 0x91, 0xf0, 0x9b, 0xbd, 0x1a, 0xfd, 0xc6, 0x2b, 0x58, 0x26, 0x92, + /*4c90:*/ 0x31, 0xf3, 0x6c, 0xdd, 0xd1, 0x39, 0x25, 0xc6, 0xff, 0x7d, 0x97, 0xae, 0x2d, 0xa7, 0x72, 0xa8, + /*4ca0:*/ 0x9b, 0x02, 0x3a, 0xad, 0x61, 0x73, 0x82, 0xf2, 0xbb, 0x18, 0x7e, 0xf4, 0x3c, 0x66, 0x8f, 0x6a, + /*4cb0:*/ 0xb9, 0xb0, 0xad, 0x7a, 0x25, 0x3a, 0xbe, 0x0c, 0x78, 0xc3, 0x3c, 0x53, 0xd7, 0x3d, 0xf8, 0xb5, + /*4cc0:*/ 0xab, 0xd9, 0xe2, 0x59, 0xaf, 0x37, 0x67, 0x31, 0xc2, 0x6d, 0x02, 0xf8, 0x0b, 0x96, 0xd0, 0x50, + /*4cd0:*/ 0x8a, 0x35, 0xdf, 0x92, 0x27, 0x44, 0x2c, 0x5d, 0x31, 0x84, 0x3d, 0x12, 0xe6, 0xe3, 0xd1, 0x01, + /*4ce0:*/ 0xe8, 0xd3, 0xbb, 0x68, 0x6c, 0x12, 0x74, 0x0a, 0x83, 0x53, 0x29, 0x88, 0xff, 0xec, 0xef, 0x2f, + /*4cf0:*/ 0xe2, 0xa8, 0x8e, 0xd0, 0x07, 0xb8, 0x6e, 0xae, 0x80, 0x9c, 0x34, 0x51, 0xcd, 0xdb, 0x59, 0x2c, + /*4d00:*/ 0x06, 0x7e, 0x72, 0x9c, 0xa7, 0x7f, 0xeb, 0x2d, 0x4e, 0x1e, 0xfe, 0xa6, 0x89, 0x93, 0x8a, 0x6d, + /*4d10:*/ 0x82, 0xec, 0x91, 0x75, 0x2b, 0x13, 0x72, 0x2d, 0x21, 0xa6, 0x3c, 0x99, 0x03, 0xc2, 0x39, 0x33, + /*4d20:*/ 0xb1, 0xd9, 0xae, 0x23, 0x04, 0x33, 0xd7, 0x03, 0x19, 0x83, 0x04, 0xdd, 0x1b, 0x7b, 0x19, 0xd0, + /*4d30:*/ 0xf7, 0x75, 0x2f, 0x8b, 0xda, 0x8d, 0xad, 0xae, 0xd3, 0x84, 0x0a, 0x14, 0xf7, 0xb6, 0x4a, 0x6f, + /*4d40:*/ 0xf6, 0x6c, 0x2b, 0x8c, 0x2a, 0x0d, 0x21, 0xc0, 0x16, 0x2f, 0x76, 0x75, 0xac, 0x58, 0xa4, 0x2d, + /*4d50:*/ 0xae, 0xa5, 0x0c, 0xe7, 0xc4, 0x16, 0xb2, 0xc3, 0xf0, 0x56, 0x39, 0xa2, 0xc9, 0xc4, 0x05, 0xd1, + /*4d60:*/ 0x6b, 0xe6, 0x25, 0xdb, 0x9b, 0x0f, 0x41, 0x9c, 0x59, 0xe5, 0x81, 0xca, 0x47, 0x78, 0x66, 0xae, + /*4d70:*/ 0xb7, 0x5d, 0x90, 0xa2, 0xcc, 0x8a, 0x66, 0x5c, 0x36, 0xd8, 0x22, 0x4d, 0x26, 0x4c, 0x66, 0x4a, + /*4d80:*/ 0x08, 0xce, 0x04, 0x8c, 0x3f, 0x02, 0xcc, 0x06, 0x36, 0x41, 0x0b, 0x27, 0x7a, 0x1c, 0x4d, 0x84, + /*4d90:*/ 0xbc, 0x32, 0x5e, 0x32, 0x2c, 0x35, 0x24, 0xaa, 0x29, 0x0d, 0xd1, 0xfc, 0x5b, 0x16, 0x5b, 0x63, + /*4da0:*/ 0x3b, 0x22, 0x15, 0x80, 0xe7, 0x2b, 0x25, 0x78, 0xc5, 0xae, 0x8a, 0x9f, 0xff, 0xc0, 0xbd, 0x49, + /*4db0:*/ 0x56, 0x77, 0x5b, 0xf0, 0xee, 0x4d, 0xc7, 0x60, 0x9d, 0x53, 0x60, 0xd7, 0xd9, 0xa9, 0x22, 0x9d, + /*4dc0:*/ 0xa9, 0x1f, 0x58, 0x0e, 0x55, 0x7e, 0xc1, 0x39, 0x38, 0x70, 0x7c, 0x7b, 0x9f, 0xc8, 0x74, 0x91, + /*4dd0:*/ 0xbf, 0x5c, 0xd9, 0xba, 0x67, 0x9f, 0xe7, 0xcb, 0xe6, 0xda, 0x6c, 0xb5, 0xe2, 0x15, 0x77, 0x35, + /*4de0:*/ 0x43, 0x09, 0x40, 0x0f, 0x2a, 0x2d, 0x58, 0x1a, 0xda, 0xd4, 0x42, 0x34, 0x02, 0x5e, 0x28, 0x5b, + /*4df0:*/ 0x93, 0x26, 0x9e, 0xfb, 0x2a, 0x3f, 0xb0, 0x48, 0xc6, 0x22, 0x75, 0x54, 0x72, 0xbc, 0x68, 0x2a, + /*4e00:*/ 0xb3, 0x90, 0xe6, 0xaf, 0x37, 0x08, 0x41, 0xad, 0xf9, 0x45, 0x97, 0x4a, 0x10, 0x07, 0x51, 0x3d, + /*4e10:*/ 0x19, 0xd9, 0x36, 0xa4, 0x4f, 0x42, 0x92, 0xd3, 0x2e, 0x7e, 0xe1, 0x30, 0xbe, 0x9f, 0x2f, 0x79, + /*4e20:*/ 0x34, 0xc8, 0x95, 0xee, 0x28, 0x5e, 0x01, 0x05, 0xc3, 0x00, 0xcb, 0x49, 0x38, 0xcf, 0x52, 0xa4, + /*4e30:*/ 0x2b, 0xb2, 0xcd, 0xb8, 0x7c, 0x74, 0xb6, 0xd5, 0x8a, 0xff, 0x61, 0x35, 0x19, 0x5f, 0xea, 0x54, + /*4e40:*/ 0x9f, 0xa9, 0xa0, 0x47, 0x2b, 0x98, 0x65, 0x1d, 0x13, 0xe2, 0x2d, 0x86, 0xa4, 0x96, 0xb6, 0x19, + /*4e50:*/ 0xc0, 0x72, 0xfd, 0x06, 0x92, 0x7f, 0x1d, 0x98, 0x47, 0x39, 0x66, 0xff, 0xea, 0x00, 0x80, 0x34, + /*4e60:*/ 0xd4, 0x73, 0x0e, 0xc5, 0x88, 0x1c, 0x66, 0xf7, 0x0c, 0xb4, 0x67, 0x75, 0xe5, 0x8b, 0x37, 0x03, + /*4e70:*/ 0x41, 0x96, 0x6d, 0x62, 0xda, 0xbb, 0x77, 0x2a, 0x93, 0x2b, 0xf6, 0xce, 0x8a, 0x89, 0x25, 0x0a, + /*4e80:*/ 0x97, 0x73, 0x99, 0x68, 0x2d, 0xbe, 0x96, 0x31, 0x16, 0xba, 0xfe, 0x05, 0x0e, 0x37, 0x58, 0x3f, + /*4e90:*/ 0x2d, 0xce, 0xd1, 0x8e, 0x9d, 0x0a, 0xac, 0x91, 0x06, 0xbd, 0x38, 0x8c, 0x43, 0x43, 0xf8, 0xbd, + /*4ea0:*/ 0x43, 0xb7, 0xfc, 0xf1, 0xe0, 0x53, 0x59, 0x67, 0xbb, 0x99, 0x22, 0xd7, 0xb5, 0x9d, 0xed, 0x85, + /*4eb0:*/ 0xae, 0xbc, 0xb3, 0xa4, 0x6a, 0xe2, 0x5b, 0x8d, 0x4e, 0x93, 0x31, 0x44, 0xeb, 0x5b, 0x78, 0x1f, + /*4ec0:*/ 0x1c, 0x20, 0x20, 0x1d, 0xb6, 0xd2, 0x51, 0x96, 0x0b, 0xcd, 0x09, 0x5c, 0x44, 0x20, 0x0d, 0xc5, + /*4ed0:*/ 0x7a, 0x54, 0x0c, 0xef, 0xb9, 0x2e, 0x34, 0x56, 0xa5, 0xbd, 0x06, 0x4f, 0x73, 0x1a, 0x4b, 0x97, + /*4ee0:*/ 0x43, 0xcd, 0xf6, 0xe1, 0x35, 0x29, 0x82, 0x0e, 0xcc, 0x62, 0x4f, 0xe9, 0x32, 0x40, 0x78, 0x33, + /*4ef0:*/ 0xa2, 0xcb, 0x4d, 0x6a, 0x7f, 0x04, 0x5b, 0x04, 0x45, 0xc4, 0xd2, 0xef, 0x6d, 0x51, 0xff, 0xe3, + /*4f00:*/ 0x28, 0xbb, 0x23, 0x1e, 0x21, 0x7f, 0x19, 0x61, 0x7c, 0xb6, 0x6f, 0x8f, 0x2a, 0x10, 0x2b, 0x3e, + /*4f10:*/ 0x77, 0x6a, 0x6d, 0xfa, 0x2a, 0x63, 0xa2, 0x09, 0xde, 0x84, 0x67, 0xd2, 0x1b, 0xf2, 0x06, 0x5e, + /*4f20:*/ 0xc4, 0x63, 0xce, 0xe0, 0x23, 0x85, 0xb3, 0x30, 0x22, 0x61, 0xd4, 0x99, 0x2b, 0x3a, 0xca, 0xf4, + /*4f30:*/ 0x80, 0xba, 0x0a, 0xee, 0xa3, 0x58, 0xfc, 0xcd, 0x3e, 0x66, 0x3e, 0xfe, 0xb5, 0xaa, 0xdf, 0x69, + /*4f40:*/ 0x62, 0x8e, 0x7e, 0xda, 0x44, 0x4d, 0xc6, 0x6a, 0x0b, 0x20, 0x52, 0xbb, 0xf3, 0xf3, 0x0c, 0x39, + /*4f50:*/ 0x4b, 0xf8, 0x6c, 0x94, 0xce, 0x1f, 0x11, 0x5f, 0x6f, 0xbd, 0x4b, 0xbc, 0xcc, 0x21, 0xf0, 0x0c, + /*4f60:*/ 0x8f, 0x64, 0x98, 0x82, 0x99, 0x47, 0xa1, 0x73, 0x46, 0x0d, 0x1b, 0xd4, 0x66, 0x16, 0xd2, 0xed, + /*4f70:*/ 0xaf, 0xcd, 0x35, 0x5c, 0x61, 0xe7, 0xdc, 0xd3, 0xac, 0x82, 0xa1, 0xea, 0x90, 0x33, 0x19, 0x8a, + /*4f80:*/ 0x68, 0x20, 0x1c, 0xfd, 0xae, 0xfc, 0x6f, 0x8a, 0x69, 0xcd, 0xcc, 0x8e, 0x22, 0x68, 0xef, 0x8a, + /*4f90:*/ 0xa9, 0x64, 0x86, 0xcc, 0x2f, 0x46, 0xc6, 0x8d, 0x81, 0x1f, 0x5a, 0xc9, 0x3d, 0xdc, 0x84, 0xf3, + /*4fa0:*/ 0x27, 0x81, 0x4d, 0x34, 0xc3, 0x66, 0x2b, 0xbb, 0x13, 0xa4, 0x7d, 0x02, 0x91, 0x43, 0x7d, 0x2c, + /*4fb0:*/ 0x5b, 0x7b, 0xd0, 0x82, 0x51, 0xa8, 0x1b, 0x9b, 0xbd, 0xa3, 0x95, 0x5b, 0xca, 0x21, 0x48, 0x34, + /*4fc0:*/ 0xaa, 0x00, 0x30, 0x3d, 0xa0, 0x6c, 0x5a, 0xa6, 0x16, 0xa6, 0x92, 0x6b, 0x25, 0xb6, 0x47, 0xbb, + /*4fd0:*/ 0xb0, 0x2b, 0xb7, 0x82, 0x1b, 0xa3, 0x4a, 0xc4, 0x72, 0xbe, 0xf7, 0xbf, 0xaf, 0xcf, 0xaf, 0x2b, + /*4fe0:*/ 0x0e, 0x9e, 0x88, 0x91, 0xe6, 0xcd, 0x2a, 0x50, 0x73, 0xd8, 0xf7, 0x6e, 0xf6, 0x7d, 0xb4, 0xc9, + /*4ff0:*/ 0xb6, 0xb8, 0x03, 0x90, 0xf8, 0xbe, 0x36, 0x95, 0x5c, 0x91, 0x54, 0x24, 0x6f, 0xfd, 0x6c, 0xa5, + /*5000:*/ 0x07, 0xfd, 0x75, 0x1e, 0x2e, 0xcb, 0x11, 0x08, 0x84, 0x18, 0xc6, 0xcb, 0xdd, 0x01, 0xf1, 0x5a, + /*5010:*/ 0x64, 0xf7, 0x8b, 0x64, 0xa4, 0x6f, 0xe8, 0xad, 0xc2, 0x27, 0x86, 0xeb, 0xca, 0xdd, 0xe1, 0x2e, + /*5020:*/ 0x10, 0x34, 0x9c, 0x03, 0x7e, 0x6b, 0x5a, 0x7f, 0x83, 0xe6, 0xd3, 0x60, 0xe7, 0x1e, 0xec, 0xd2, + /*5030:*/ 0x63, 0xe6, 0x60, 0xd2, 0xab, 0x12, 0x56, 0x65, 0x3d, 0xfe, 0x9c, 0x36, 0xab, 0x5a, 0x43, 0x57, + /*5040:*/ 0xf1, 0x12, 0x31, 0x7c, 0xa8, 0xf4, 0xbc, 0x48, 0x36, 0x0f, 0xa7, 0xc4, 0x47, 0x3c, 0x67, 0xc9, + /*5050:*/ 0xbd, 0xa3, 0x46, 0x86, 0x13, 0x0e, 0xc2, 0xdc, 0x43, 0xa3, 0xa6, 0x16, 0xfa, 0xa7, 0xeb, 0xae, + /*5060:*/ 0xbb, 0x6d, 0x07, 0x3d, 0xb5, 0x2c, 0xad, 0x2a, 0x7c, 0x78, 0xd1, 0x58, 0x31, 0x5a, 0x1e, 0x5c, + /*5070:*/ 0xf9, 0xbf, 0x89, 0xbf, 0x99, 0xc5, 0xd2, 0x6b, 0x0d, 0xf1, 0xbe, 0x27, 0xfc, 0x60, 0x70, 0xb5, + /*5080:*/ 0xbd, 0xd4, 0x59, 0x37, 0x9c, 0xd4, 0x94, 0xd9, 0x3e, 0x32, 0x8a, 0xe9, 0xe1, 0x26, 0x25, 0x81, + /*5090:*/ 0x47, 0x4a, 0x0e, 0xfc, 0xa0, 0xae, 0xa3, 0x94, 0x2e, 0x1f, 0x56, 0x83, 0xc4, 0xc8, 0x23, 0x99, + /*50a0:*/ 0xf1, 0x23, 0xdd, 0xb1, 0xa6, 0x6b, 0xa7, 0x37, 0x39, 0x54, 0xb4, 0xbc, 0x67, 0x65, 0x9d, 0x69, + /*50b0:*/ 0x23, 0x28, 0xf2, 0x69, 0xbf, 0xd4, 0xdf, 0x54, 0xd5, 0x05, 0x21, 0xbc, 0xe5, 0xb6, 0xe1, 0xd2, + /*50c0:*/ 0xae, 0x2c, 0x87, 0x03, 0x21, 0x77, 0xe0, 0x86, 0xe7, 0x1a, 0x55, 0x8c, 0x0d, 0x14, 0x78, 0xbb, + /*50d0:*/ 0xe1, 0xc8, 0xf1, 0xd3, 0xf7, 0x10, 0x58, 0x23, 0xf7, 0x39, 0x38, 0x05, 0xbe, 0x62, 0xb0, 0x14, + /*50e0:*/ 0xd1, 0x9f, 0xdd, 0xb9, 0xf8, 0x79, 0x37, 0x1f, 0x8b, 0xf9, 0x54, 0x71, 0xde, 0x08, 0xeb, 0x46, + /*50f0:*/ 0xbf, 0xa8, 0x74, 0xd5, 0xc6, 0x92, 0xb7, 0x18, 0xed, 0xae, 0xcd, 0x62, 0x29, 0xf7, 0xb9, 0x74, + /*5100:*/ 0x27, 0x91, 0x95, 0x3b, 0x34, 0x64, 0x17, 0xbf, 0x35, 0x52, 0xb0, 0x9e, 0x1a, 0x0e, 0x37, 0x48, + /*5110:*/ 0xaa, 0x47, 0x2b, 0xe5, 0xbb, 0x48, 0xc5, 0xe5, 0x58, 0x35, 0xd7, 0x3a, 0x1a, 0x55, 0xf8, 0x30, + /*5120:*/ 0xd4, 0xdd, 0x07, 0xd0, 0x31, 0x42, 0xce, 0x57, 0x2e, 0xdd, 0xea, 0x97, 0x7a, 0xbe, 0xa3, 0xc0, + /*5130:*/ 0x2a, 0xb2, 0xad, 0xf2, 0x13, 0x54, 0x09, 0x90, 0x0d, 0xe7, 0x58, 0xf2, 0x37, 0x51, 0xd8, 0x1d, + /*5140:*/ 0x2e, 0x72, 0x34, 0x51, 0xd6, 0x21, 0x41, 0x3c, 0x5e, 0xab, 0x16, 0xec, 0x1a, 0x23, 0xd4, 0xde, + /*5150:*/ 0x40, 0x3f, 0x5c, 0xce, 0xb0, 0x9f, 0x1a, 0x96, 0xf6, 0x78, 0x9d, 0xec, 0xef, 0x73, 0x63, 0x11, + /*5160:*/ 0x12, 0x57, 0x71, 0x01, 0x20, 0xa5, 0x63, 0xdc, 0x33, 0x18, 0x1a, 0x67, 0x1c, 0x6a, 0x82, 0xfe, + /*5170:*/ 0x41, 0xca, 0x6b, 0x17, 0x62, 0x75, 0xda, 0xff, 0xa0, 0x8e, 0xb3, 0x75, 0xab, 0x13, 0x81, 0x2d, + /*5180:*/ 0x4c, 0x35, 0x3a, 0x6b, 0xe2, 0x7d, 0x31, 0x8d, 0xc0, 0x7b, 0xb3, 0x6b, 0xd9, 0xea, 0xaf, 0x52, + /*5190:*/ 0x93, 0x35, 0x76, 0x9b, 0xc9, 0xc4, 0x85, 0x08, 0xf7, 0x6c, 0x79, 0xcf, 0x80, 0x8a, 0x03, 0xed, + /*51a0:*/ 0xe5, 0xac, 0x2a, 0x22, 0xdb, 0x37, 0x67, 0xa2, 0xcb, 0xa0, 0xd4, 0x34, 0x04, 0x40, 0xc4, 0x09, + /*51b0:*/ 0xae, 0xde, 0xea, 0xa4, 0xd0, 0x1f, 0x33, 0x3e, 0x00, 0xa0, 0x10, 0x68, 0x1e, 0xe9, 0x95, 0xa9, + /*51c0:*/ 0x91, 0x9d, 0xb1, 0x73, 0xc9, 0xa1, 0x89, 0xce, 0x72, 0x4a, 0x41, 0xc9, 0x35, 0x2c, 0x0f, 0x10, + /*51d0:*/ 0xb0, 0xab, 0xe1, 0x72, 0x48, 0x2f, 0x53, 0x3c, 0x3d, 0x6f, 0x9d, 0x09, 0x82, 0x88, 0x14, 0xee, + /*51e0:*/ 0x38, 0xa9, 0x72, 0x01, 0xfd, 0xd4, 0x24, 0xba, 0x14, 0xb9, 0x90, 0x4a, 0x0c, 0x9a, 0xe4, 0x47, + /*51f0:*/ 0x9f, 0x72, 0xe2, 0x3b, 0x9e, 0x0e, 0x72, 0x43, 0xf4, 0x74, 0xb6, 0x57, 0x53, 0x88, 0x33, 0xef, + /*5200:*/ 0xf5, 0x8a, 0xd1, 0x96, 0x0f, 0x47, 0xb3, 0x98, 0x8a, 0xd5, 0x49, 0x2d, 0x0f, 0xf6, 0x99, 0x53, + /*5210:*/ 0x68, 0xa9, 0x84, 0x38, 0xe6, 0x88, 0x94, 0x27, 0x7f, 0xfa, 0xd4, 0x13, 0x37, 0x2a, 0xe1, 0xfe, + /*5220:*/ 0x8f, 0xe4, 0x56, 0x1b, 0xce, 0xbf, 0x27, 0x8b, 0x62, 0xb3, 0xbb, 0xca, 0xa7, 0x81, 0x8a, 0xb4, + /*5230:*/ 0x4a, 0x73, 0xba, 0x09, 0xcf, 0xab, 0xa1, 0xfa, 0x7b, 0xc6, 0xdb, 0xd4, 0x12, 0x15, 0x89, 0x58, + /*5240:*/ 0xc0, 0xd1, 0xe5, 0x26, 0x3f, 0x99, 0xe0, 0xa6, 0x0f, 0xb6, 0x81, 0xbf, 0x72, 0x53, 0x3a, 0xda, + /*5250:*/ 0x2f, 0x8a, 0xa5, 0x93, 0x6a, 0xc5, 0x89, 0x0c, 0xc6, 0x44, 0xda, 0xed, 0x46, 0x76, 0x7e, 0x9a, + /*5260:*/ 0xd5, 0x96, 0x96, 0x7c, 0xa5, 0x90, 0x80, 0xb4, 0x71, 0x01, 0xdb, 0x08, 0xe6, 0x37, 0x2b, 0x5c, + /*5270:*/ 0x83, 0xca, 0x24, 0x1e, 0x9b, 0xd6, 0x71, 0xe6, 0xfc, 0xae, 0x0f, 0x24, 0xbc, 0x89, 0x13, 0x4f, + /*5280:*/ 0xbc, 0x43, 0x5c, 0x9c, 0x3f, 0x48, 0x94, 0xe0, 0x66, 0xf0, 0x4a, 0x76, 0xa0, 0x08, 0x9a, 0x10, + /*5290:*/ 0x09, 0x8b, 0xa6, 0x2c, 0xc5, 0x9d, 0xd6, 0xc5, 0x45, 0xd1, 0x63, 0x43, 0x44, 0x0f, 0xca, 0x5b, + /*52a0:*/ 0x66, 0x77, 0xa3, 0x44, 0x90, 0x2c, 0xe4, 0xab, 0x28, 0xcb, 0x06, 0xab, 0x98, 0x64, 0x2b, 0xfb, + /*52b0:*/ 0x4a, 0x7b, 0xb5, 0x9b, 0x12, 0xca, 0x30, 0xa7, 0x01, 0x5a, 0x99, 0x53, 0xde, 0x87, 0x24, 0x1a, + /*52c0:*/ 0xa6, 0xec, 0x13, 0xd1, 0x0c, 0xf0, 0x90, 0x41, 0x4c, 0x00, 0x91, 0x86, 0xbb, 0x1e, 0xf0, 0xed, + /*52d0:*/ 0x81, 0xeb, 0xa7, 0x39, 0x6e, 0xfd, 0x88, 0xf8, 0x31, 0x23, 0x73, 0x6c, 0xd0, 0x21, 0xf4, 0x16, + /*52e0:*/ 0xc3, 0x6f, 0xcc, 0xb0, 0x46, 0x78, 0x96, 0x2d, 0x5e, 0xeb, 0x10, 0x68, 0x7b, 0x1e, 0xaa, 0x21, + /*52f0:*/ 0x8e, 0x22, 0x75, 0xbf, 0xaf, 0xbc, 0x00, 0xa2, 0x45, 0x65, 0x5b, 0x6b, 0x32, 0x0e, 0xe7, 0x05, + /*5300:*/ 0xa2, 0xbc, 0xcc, 0x21, 0x5f, 0x32, 0x68, 0xad, 0x74, 0x7e, 0xdd, 0xe5, 0x80, 0x22, 0x0e, 0x30, + /*5310:*/ 0x18, 0xc7, 0x38, 0xd2, 0xec, 0x8d, 0x19, 0xf5, 0xb7, 0xe4, 0x15, 0x8f, 0x44, 0x40, 0x5a, 0xf0, + /*5320:*/ 0x03, 0x91, 0xc7, 0x4c, 0x21, 0xa2, 0xe7, 0xe0, 0x41, 0x22, 0x7c, 0xde, 0xb8, 0xf1, 0xe5, 0x8d, + /*5330:*/ 0x83, 0x56, 0xd5, 0x46, 0x68, 0x9a, 0x33, 0xb7, 0xba, 0xd2, 0x35, 0x62, 0x54, 0x4e, 0x4a, 0x73, + /*5340:*/ 0x3d, 0x52, 0x6d, 0x25, 0x2c, 0x04, 0x03, 0x05, 0x41, 0x01, 0x74, 0xfa, 0xe2, 0x49, 0x48, 0xdc, + /*5350:*/ 0xf7, 0x77, 0x03, 0x33, 0x85, 0xda, 0xa3, 0xb8, 0xef, 0xf8, 0x0d, 0x04, 0x55, 0x85, 0x21, 0xdf, + /*5360:*/ 0xe8, 0xc4, 0x2d, 0x14, 0xe2, 0xf2, 0x55, 0xc8, 0xbe, 0xf0, 0xfd, 0x1b, 0x4f, 0x7b, 0x2c, 0x40, + /*5370:*/ 0x0b, 0x9f, 0x79, 0x98, 0xfa, 0x2d, 0x3a, 0xc5, 0xa2, 0x94, 0xdb, 0xcc, 0x5c, 0x50, 0x0b, 0x24, + /*5380:*/ 0x12, 0x2e, 0xe8, 0x91, 0x87, 0xf5, 0x63, 0xcd, 0x08, 0x75, 0xa9, 0x47, 0x22, 0x81, 0xba, 0xa6, + /*5390:*/ 0xd2, 0x60, 0xc4, 0x39, 0x28, 0xf8, 0x8f, 0x03, 0xc0, 0x1a, 0xac, 0xb0, 0x98, 0xb9, 0x0e, 0x18, + /*53a0:*/ 0x2a, 0xa8, 0x7c, 0xb5, 0xbd, 0xb8, 0x43, 0x20, 0xe2, 0x7e, 0xe5, 0x30, 0x18, 0x76, 0xca, 0xe5, + /*53b0:*/ 0xe0, 0xd6, 0x57, 0xa8, 0x6a, 0xdf, 0x35, 0x4c, 0x35, 0xd4, 0xa2, 0x6b, 0x4a, 0x05, 0xf9, 0xa4, + /*53c0:*/ 0x9c, 0x35, 0x61, 0xff, 0x0b, 0x77, 0x41, 0x99, 0x65, 0xed, 0x56, 0xa4, 0x6e, 0xfb, 0xd6, 0x08, + /*53d0:*/ 0x9e, 0x54, 0x04, 0x1e, 0x02, 0x71, 0xab, 0x2b, 0xed, 0xeb, 0xc4, 0x26, 0x98, 0xfa, 0xc6, 0xd5, + /*53e0:*/ 0xc8, 0x19, 0xb3, 0xa0, 0xe7, 0xb9, 0x11, 0x5b, 0xf2, 0x9b, 0x5d, 0xd8, 0x7c, 0x14, 0x98, 0x07, + /*53f0:*/ 0x5f, 0xf0, 0xcc, 0xad, 0x8d, 0x70, 0x30, 0xb7, 0x87, 0xea, 0x60, 0x0e, 0xcf, 0x06, 0x3d, 0xa5, + /*5400:*/ 0x0d, 0xad, 0x7c, 0x35, 0xe8, 0xc8, 0x7d, 0x72, 0x33, 0xa5, 0x10, 0x14, 0x93, 0xca, 0x95, 0x54, + /*5410:*/ 0xda, 0xb7, 0x18, 0xc1, 0xae, 0xc5, 0x98, 0xc6, 0xe2, 0xc5, 0xd5, 0xac, 0x56, 0x55, 0xcc, 0xd1, + /*5420:*/ 0x04, 0xbe, 0x6c, 0xb8, 0xc9, 0xa7, 0xac, 0x52, 0x4b, 0x91, 0xf5, 0x0c, 0x77, 0xf8, 0x75, 0x79, + /*5430:*/ 0xe2, 0x56, 0xa3, 0xe8, 0xff, 0xf7, 0x22, 0x5a, 0x24, 0x4e, 0x6e, 0xf1, 0xc9, 0xcb, 0xd0, 0xd3, + /*5440:*/ 0xfc, 0x16, 0x82, 0xb5, 0x49, 0x47, 0xfe, 0x27, 0x8a, 0xd5, 0xa3, 0xc0, 0x5c, 0x90, 0xf1, 0xfb, + /*5450:*/ 0xb2, 0xec, 0x3d, 0xb6, 0x01, 0x6e, 0x14, 0x32, 0xc9, 0xcc, 0xfa, 0xfa, 0xc5, 0x17, 0xff, 0xb3, + /*5460:*/ 0x18, 0x6f, 0xd5, 0x04, 0x7a, 0xa7, 0xfc, 0xcf, 0x18, 0x25, 0xe3, 0x69, 0x86, 0x27, 0xeb, 0x16, + /*5470:*/ 0x93, 0xf6, 0x6e, 0x3b, 0xc7, 0x73, 0xf8, 0x83, 0xb7, 0xce, 0x82, 0x8d, 0x4a, 0x0a, 0xcb, 0xe3, + /*5480:*/ 0x07, 0x55, 0x79, 0x8c, 0x18, 0x39, 0x31, 0xdf, 0xca, 0xcb, 0xfd, 0x41, 0x1b, 0xfb, 0xb6, 0x35, + /*5490:*/ 0x09, 0x59, 0xca, 0x90, 0xad, 0x71, 0x46, 0xeb, 0xf6, 0x18, 0xb2, 0xb6, 0x3f, 0xa9, 0x08, 0x03, + /*54a0:*/ 0x57, 0x57, 0xf1, 0x0c, 0x73, 0x26, 0x20, 0x33, 0xef, 0x74, 0xa7, 0xe7, 0x6e, 0x25, 0x9a, 0x7e, + /*54b0:*/ 0x3a, 0x66, 0xf1, 0x97, 0x07, 0xcc, 0x89, 0xea, 0x4d, 0x3c, 0x92, 0x15, 0xd9, 0xe1, 0x99, 0x89, + /*54c0:*/ 0x2c, 0xd4, 0x5a, 0xf3, 0x51, 0x10, 0xa0, 0x54, 0x77, 0x7e, 0x1a, 0x07, 0x02, 0x87, 0x0e, 0xb8, + /*54d0:*/ 0x87, 0x11, 0xce, 0xd2, 0xd8, 0x84, 0x30, 0x2a, 0xe7, 0x08, 0x49, 0x8b, 0x7c, 0xcb, 0xaf, 0x43, + /*54e0:*/ 0x17, 0x15, 0x17, 0xa1, 0xa0, 0xa2, 0x74, 0x4c, 0xa9, 0xcc, 0xe0, 0x26, 0xd5, 0xc1, 0xc3, 0x4a, + /*54f0:*/ 0x69, 0x0c, 0x89, 0x52, 0xcd, 0xae, 0x47, 0xd7, 0x6e, 0x0c, 0xc5, 0x62, 0x6e, 0xaa, 0x0e, 0x08, + /*5500:*/ 0x40, 0x32, 0x21, 0x50, 0x6c, 0xd8, 0xb7, 0xd6, 0xc7, 0xd3, 0x3f, 0xae, 0x4f, 0x0d, 0xba, 0xaa, + /*5510:*/ 0x37, 0x17, 0xbd, 0x13, 0x0a, 0xcc, 0x12, 0x3d, 0x6b, 0xab, 0x12, 0xc9, 0xf4, 0xa6, 0xe9, 0x64, + /*5520:*/ 0x73, 0xa2, 0xd6, 0xe0, 0x1f, 0x8d, 0xd7, 0xab, 0x95, 0x4d, 0x8d, 0x25, 0xca, 0xe8, 0x9f, 0xca, + /*5530:*/ 0xf6, 0x54, 0x4a, 0xbf, 0x1d, 0xeb, 0xf6, 0x39, 0x20, 0xaa, 0x2c, 0xc9, 0x3c, 0xa7, 0x0c, 0x4b, + /*5540:*/ 0x85, 0x92, 0x23, 0x48, 0xed, 0x7c, 0x55, 0x0a, 0xbb, 0x4f, 0x65, 0xac, 0x6d, 0x23, 0x4c, 0x5e, + /*5550:*/ 0xf9, 0x9e, 0xa7, 0x76, 0x4d, 0xdd, 0xfb, 0x52, 0x68, 0x75, 0x1d, 0xab, 0xc9, 0x53, 0xa8, 0xfc, + /*5560:*/ 0x39, 0xcf, 0xea, 0x93, 0x90, 0x50, 0x95, 0x3e, 0x91, 0x4a, 0xac, 0xc7, 0x80, 0x02, 0x84, 0x1a, + /*5570:*/ 0x6a, 0xf3, 0x61, 0xad, 0xca, 0x78, 0x09, 0x67, 0x8a, 0x41, 0x79, 0xda, 0x5b, 0x8f, 0x79, 0xc2, + /*5580:*/ 0xf4, 0x73, 0x26, 0xb8, 0x8c, 0xf8, 0x64, 0x7f, 0xba, 0x25, 0xa7, 0x90, 0xf5, 0x49, 0xd6, 0x5f, + /*5590:*/ 0x4c, 0xf4, 0x18, 0x5d, 0xe0, 0x20, 0x61, 0xc5, 0x59, 0x69, 0x89, 0x48, 0x29, 0xbb, 0x98, 0xcd, + /*55a0:*/ 0x92, 0x42, 0x80, 0x91, 0xc4, 0x35, 0x24, 0x7d, 0x70, 0x35, 0x23, 0x90, 0xa4, 0x19, 0x2d, 0x8a, + /*55b0:*/ 0xf3, 0x7b, 0x89, 0x1b, 0xb9, 0xe2, 0x4e, 0x12, 0xa5, 0x41, 0x7e, 0x4e, 0x84, 0xb7, 0x0d, 0x6b, + /*55c0:*/ 0xf2, 0xb6, 0xb8, 0x29, 0x1a, 0x85, 0xa3, 0xc5, 0x00, 0x71, 0xf4, 0xad, 0x4c, 0x62, 0x75, 0xc5, + /*55d0:*/ 0xa8, 0xd1, 0xad, 0xcd, 0x4e, 0x62, 0xd5, 0x37, 0xf0, 0xaf, 0x4c, 0xdd, 0x31, 0x83, 0x92, 0x81, + /*55e0:*/ 0xb9, 0x11, 0x20, 0xcc, 0x4c, 0x4f, 0xff, 0x3e, 0x5b, 0x68, 0xb9, 0xbf, 0x3b, 0x1b, 0x8f, 0xdf, + /*55f0:*/ 0xd7, 0x13, 0x13, 0x49, 0x3f, 0x6e, 0x00, 0x87, 0xae, 0x8d, 0x9d, 0x00, 0x66, 0x29, 0x30, 0x6e, + /*5600:*/ 0x65, 0x28, 0x09, 0x87, 0xa4, 0xf7, 0xde, 0xf8, 0x04, 0xba, 0x20, 0x0c, 0xb0, 0x68, 0x13, 0xfb, + /*5610:*/ 0x73, 0x66, 0x82, 0x04, 0xea, 0xd6, 0x7b, 0x89, 0x43, 0x52, 0x08, 0x3a, 0x37, 0x17, 0x56, 0xa3, + /*5620:*/ 0x63, 0xbd, 0x01, 0x82, 0x9c, 0xeb, 0x44, 0x3c, 0x01, 0xf9, 0x77, 0x64, 0x0a, 0x18, 0xff, 0x50, + /*5630:*/ 0xe5, 0x15, 0x69, 0xa3, 0x2d, 0xcc, 0xb0, 0xba, 0xb1, 0xef, 0x78, 0x3c, 0x07, 0x19, 0xfd, 0x7a, + /*5640:*/ 0xd6, 0x91, 0x66, 0x35, 0xd1, 0xef, 0x8e, 0xc2, 0xf6, 0xb0, 0xfe, 0x5d, 0x2c, 0x7e, 0x28, 0x77, + /*5650:*/ 0x1d, 0xc6, 0x3e, 0x5f, 0x58, 0x11, 0x3f, 0x72, 0xf6, 0x1e, 0x59, 0x88, 0xcf, 0x16, 0x52, 0xc9, + /*5660:*/ 0x7f, 0x31, 0xce, 0x87, 0x22, 0x3b, 0x81, 0xab, 0x52, 0xb5, 0x22, 0x67, 0x56, 0xdf, 0xe8, 0xed, + /*5670:*/ 0x72, 0xe5, 0xff, 0xcf, 0xa7, 0xf1, 0xa3, 0xb7, 0x97, 0x8e, 0x9c, 0x56, 0x5b, 0x0c, 0x0c, 0x5a, + /*5680:*/ 0x2e, 0x08, 0xa1, 0xee, 0xcb, 0xd2, 0xc9, 0x26, 0xa8, 0x38, 0xd4, 0x94, 0x8e, 0x47, 0xb0, 0x69, + /*5690:*/ 0x0d, 0x5e, 0xbb, 0xc0, 0x53, 0x8a, 0xc8, 0x98, 0x7a, 0x9f, 0xa6, 0x5c, 0x8a, 0x6f, 0x87, 0xbf, + /*56a0:*/ 0xd2, 0xae, 0x7e, 0x57, 0xd5, 0xc5, 0xf3, 0x7b, 0xcb, 0x04, 0x27, 0xd3, 0x95, 0x43, 0x28, 0x8d, + /*56b0:*/ 0x6f, 0xe5, 0xa4, 0xaa, 0x88, 0x52, 0xea, 0x6a, 0xa7, 0xbf, 0x18, 0x15, 0xd5, 0x0d, 0x57, 0xf1, + /*56c0:*/ 0xe2, 0x8e, 0xfc, 0x86, 0x19, 0xf1, 0xce, 0xee, 0xab, 0x7e, 0x56, 0xfb, 0xac, 0xe8, 0x20, 0xfb, + /*56d0:*/ 0x77, 0x43, 0x09, 0xf5, 0xca, 0xf6, 0xd1, 0x80, 0x3d, 0xed, 0xd1, 0x8c, 0x67, 0xc1, 0x6d, 0x99, + /*56e0:*/ 0x76, 0xb3, 0xcd, 0xc0, 0x22, 0xd2, 0xe3, 0xff, 0xe6, 0x00, 0xff, 0xe2, 0x48, 0xdc, 0x73, 0xc5, + /*56f0:*/ 0x10, 0x1d, 0x32, 0x90, 0x42, 0xfd, 0xe5, 0x2c, 0x94, 0x1a, 0x9d, 0x7f, 0x11, 0x1e, 0x7a, 0xf6, + /*5700:*/ 0xba, 0x50, 0x22, 0x08, 0xc5, 0x38, 0xb8, 0x15, 0xb7, 0x80, 0x50, 0x45, 0x1d, 0xe8, 0x4d, 0x9f, + /*5710:*/ 0xd5, 0xbc, 0x45, 0xd6, 0x83, 0x3d, 0x59, 0xf3, 0x1e, 0x33, 0x60, 0x83, 0x91, 0xb8, 0x0e, 0xb9, + /*5720:*/ 0x16, 0x6c, 0x57, 0xaf, 0x4d, 0x91, 0x84, 0x0c, 0xe4, 0x0f, 0x25, 0xdc, 0xed, 0x09, 0x73, 0xc9, + /*5730:*/ 0xcf, 0x6f, 0x96, 0x37, 0x9f, 0xf0, 0xd8, 0xee, 0xbb, 0x55, 0x9d, 0xf1, 0xa8, 0xfd, 0xbd, 0x93, + /*5740:*/ 0xb6, 0xc5, 0x43, 0xf3, 0xa6, 0x0f, 0x9d, 0x33, 0x04, 0x6b, 0x3f, 0xd1, 0x73, 0xd4, 0xaf, 0xe4, + /*5750:*/ 0x23, 0xf8, 0xc5, 0xa1, 0xbb, 0x86, 0x42, 0x7e, 0x14, 0x15, 0x32, 0xe0, 0xe9, 0x9c, 0x8e, 0xa1, + /*5760:*/ 0x4c, 0xee, 0x6c, 0x0f, 0xb3, 0xd2, 0x1c, 0xc9, 0x52, 0x14, 0x06, 0x06, 0xb5, 0x38, 0x77, 0x5f, + /*5770:*/ 0x4e, 0xa0, 0x32, 0xe6, 0x4d, 0x51, 0x67, 0x44, 0x8f, 0xb2, 0x6e, 0x57, 0x63, 0xb1, 0x19, 0x20, + /*5780:*/ 0xd3, 0x04, 0x3c, 0xf3, 0x37, 0xc5, 0x86, 0x44, 0xec, 0xf0, 0x20, 0xe1, 0x52, 0xeb, 0xe7, 0xeb, + /*5790:*/ 0x17, 0x87, 0xa1, 0x6e, 0xa9, 0xe5, 0xae, 0x75, 0x3d, 0x3c, 0x44, 0x6d, 0x20, 0x76, 0xc5, 0x84, + /*57a0:*/ 0x7e, 0x45, 0xf4, 0x57, 0x85, 0x5c, 0x41, 0x4b, 0x45, 0xf5, 0x8f, 0x89, 0xab, 0x01, 0xce, 0x9a, + /*57b0:*/ 0xe2, 0x47, 0xcb, 0xe6, 0x14, 0x14, 0x0e, 0x23, 0xb8, 0xa1, 0x15, 0x4b, 0x67, 0xfe, 0xf5, 0x38, + /*57c0:*/ 0x48, 0x9b, 0x48, 0x3e, 0x60, 0xd2, 0x9e, 0x86, 0x60, 0xa1, 0xf1, 0x31, 0x8c, 0x95, 0x93, 0xfc, + /*57d0:*/ 0xd4, 0x26, 0xb9, 0xd5, 0x36, 0xac, 0x57, 0x03, 0x86, 0xac, 0xcb, 0xb7, 0x75, 0x66, 0xda, 0x48, + /*57e0:*/ 0x74, 0x17, 0x12, 0x22, 0xd1, 0xf0, 0x9f, 0xed, 0x50, 0xcf, 0xea, 0xc5, 0xce, 0x94, 0x68, 0x81, + /*57f0:*/ 0x2a, 0x0e, 0xf3, 0x48, 0xe3, 0x03, 0xf0, 0xe4, 0x4e, 0x95, 0xfa, 0xc0, 0xda, 0x35, 0x41, 0x23, + /*5800:*/ 0x0d, 0x8b, 0xcc, 0xff, 0x25, 0xe5, 0x18, 0x88, 0x25, 0x20, 0x0c, 0xa5, 0x32, 0xae, 0xfe, 0x89, + /*5810:*/ 0xaa, 0xc6, 0xa3, 0x47, 0x0e, 0xc8, 0x8a, 0x83, 0xd9, 0x2a, 0x97, 0x85, 0xbf, 0xe5, 0x9f, 0xe6, + /*5820:*/ 0x0e, 0x79, 0x21, 0x25, 0xc2, 0x99, 0x81, 0x28, 0x70, 0x32, 0x23, 0xa3, 0x4d, 0x8a, 0x2d, 0x97, + /*5830:*/ 0xbb, 0x7d, 0xa7, 0x9a, 0xee, 0xb6, 0xed, 0xda, 0x09, 0x5f, 0x9f, 0xfc, 0x1a, 0x27, 0xd0, 0x94, + /*5840:*/ 0xb7, 0x83, 0x29, 0x59, 0x46, 0x63, 0x01, 0xc9, 0x10, 0xbe, 0x37, 0xf8, 0xac, 0x4f, 0x84, 0x10, + /*5850:*/ 0x8a, 0x8e, 0x08, 0x99, 0x13, 0x29, 0x0e, 0x8b, 0xd3, 0xd4, 0x89, 0x8e, 0xd6, 0xe7, 0x1c, 0x47, + /*5860:*/ 0xbb, 0x24, 0x6f, 0x25, 0x74, 0x9c, 0x08, 0x85, 0x49, 0x5b, 0x15, 0x25, 0xc2, 0x09, 0xb4, 0x33, + /*5870:*/ 0xe3, 0xc3, 0xe9, 0xa9, 0xa2, 0xa4, 0x38, 0x7f, 0x81, 0xa1, 0x16, 0xcb, 0x28, 0x42, 0xf2, 0x9f, + /*5880:*/ 0x37, 0x48, 0x73, 0xa2, 0xcf, 0x40, 0x4b, 0xea, 0x8f, 0x86, 0xf0, 0x74, 0x54, 0xe9, 0xc8, 0xa2, + /*5890:*/ 0x62, 0x9a, 0x6b, 0x5a, 0x82, 0x02, 0xf3, 0x63, 0x67, 0xdd, 0xb7, 0x81, 0xe6, 0xa9, 0x98, 0x44, + /*58a0:*/ 0xb6, 0xb1, 0x63, 0xb7, 0x18, 0xb9, 0x54, 0x10, 0xac, 0x44, 0x97, 0x03, 0x92, 0x11, 0xfe, 0x84, + /*58b0:*/ 0xeb, 0x60, 0x6f, 0x15, 0xf5, 0x61, 0x87, 0x3e, 0x5b, 0x27, 0x87, 0x3b, 0xaf, 0x6b, 0xa9, 0x65, + /*58c0:*/ 0x42, 0x27, 0xe5, 0x0d, 0xba, 0x83, 0xe1, 0xf2, 0x7c, 0xda, 0x1b, 0x1e, 0x7b, 0x12, 0xc5, 0x36, + /*58d0:*/ 0x6a, 0x4b, 0x10, 0x65, 0xa3, 0xfd, 0xd6, 0xf9, 0x5b, 0xf7, 0xd6, 0x93, 0xa4, 0x01, 0x64, 0xf0, + /*58e0:*/ 0x10, 0x10, 0x9b, 0x94, 0xa7, 0x16, 0x1c, 0x34, 0xc0, 0x3d, 0x33, 0xba, 0x46, 0x41, 0x5e, 0x3c, + /*58f0:*/ 0xdf, 0xaf, 0xab, 0x39, 0x94, 0x36, 0xe0, 0x7c, 0x83, 0x80, 0x92, 0xa9, 0x3b, 0xb1, 0x4e, 0x1d, + /*5900:*/ 0xff, 0x97, 0x02, 0x0d, 0x7b, 0x57, 0x23, 0x1f, 0x85, 0x41, 0xc9, 0xdd, 0x83, 0x7b, 0x01, 0x97, + /*5910:*/ 0xe0, 0x28, 0x15, 0x91, 0x49, 0x5c, 0x7f, 0xaf, 0xf1, 0x40, 0xac, 0x45, 0xf7, 0xf3, 0x26, 0x37, + /*5920:*/ 0xc5, 0xd6, 0xa6, 0xc5, 0xe1, 0x70, 0xd1, 0xca, 0x0a, 0x33, 0x54, 0x33, 0xe6, 0x7f, 0xf2, 0xb0, + /*5930:*/ 0xd5, 0x09, 0xb8, 0xe0, 0x7f, 0x54, 0x81, 0x7f, 0xd3, 0x14, 0x1a, 0xbf, 0xeb, 0x1b, 0xd5, 0xa7, + /*5940:*/ 0x81, 0x5c, 0xa4, 0x0a, 0xc7, 0x05, 0x33, 0xce, 0x97, 0xf4, 0xd8, 0x74, 0xac, 0xe1, 0x90, 0x3f, + /*5950:*/ 0xc3, 0x8d, 0x5e, 0xe2, 0x43, 0xda, 0x55, 0xbe, 0x3b, 0x12, 0x9a, 0xfc, 0xb8, 0x7f, 0x9e, 0xd1, + /*5960:*/ 0x36, 0x6e, 0x2b, 0x89, 0xe3, 0x49, 0x9b, 0x5c, 0xa8, 0xe6, 0xc4, 0xb6, 0x9d, 0xea, 0xe4, 0x71, + /*5970:*/ 0x19, 0x15, 0x7e, 0x4a, 0x28, 0xa9, 0x11, 0x31, 0xc7, 0xb2, 0xf7, 0x16, 0x38, 0xb5, 0x99, 0x92, + /*5980:*/ 0xfe, 0x9a, 0xa1, 0x08, 0xfd, 0xbc, 0xea, 0x14, 0x43, 0xa8, 0xc3, 0xc7, 0xdb, 0xae, 0x7f, 0xc4, + /*5990:*/ 0x26, 0x1d, 0x75, 0x6b, 0xbd, 0x9e, 0x46, 0x07, 0x2c, 0x3c, 0x96, 0xef, 0x54, 0xfa, 0xb7, 0x64, + /*59a0:*/ 0x3a, 0x36, 0xf6, 0xcf, 0x0e, 0xe4, 0xd8, 0x45, 0x3a, 0x11, 0x68, 0x05, 0xed, 0xf0, 0xf7, 0xe8, + /*59b0:*/ 0x39, 0x57, 0xa8, 0x9c, 0x37, 0xc9, 0x04, 0x3d, 0xf8, 0x15, 0xf6, 0xcf, 0x8a, 0x11, 0x84, 0xcd, + /*59c0:*/ 0x5f, 0xe7, 0xb9, 0x23, 0xbb, 0xab, 0xe2, 0xc5, 0x82, 0xef, 0xd4, 0x08, 0x42, 0x15, 0xcd, 0x55, + /*59d0:*/ 0xfa, 0x6c, 0x50, 0x4e, 0x53, 0xfc, 0x47, 0x9d, 0x7d, 0xdc, 0x5b, 0xda, 0x05, 0x64, 0xfa, 0xcf, + /*59e0:*/ 0x41, 0x88, 0xd1, 0xbd, 0x3f, 0x15, 0xcd, 0xba, 0xb1, 0x67, 0xf6, 0x7a, 0x82, 0x76, 0x1a, 0x64, + /*59f0:*/ 0xf7, 0x75, 0xfa, 0x71, 0xdf, 0x9a, 0xf9, 0x05, 0xb2, 0x30, 0x5a, 0x74, 0x53, 0x3d, 0xd8, 0x97, + /*5a00:*/ 0x7c, 0xdf, 0xd8, 0xda, 0x91, 0xa2, 0x0f, 0xed, 0x0b, 0x08, 0x95, 0x4c, 0x90, 0x13, 0x24, 0xd3, + /*5a10:*/ 0xb0, 0x63, 0xae, 0x46, 0x86, 0x56, 0x4c, 0x1a, 0x36, 0x41, 0x34, 0x2f, 0x30, 0x9e, 0xf0, 0x91, + /*5a20:*/ 0x9b, 0x51, 0x02, 0x8a, 0x70, 0x71, 0xfd, 0xf8, 0x19, 0xc2, 0xb3, 0xaf, 0x5e, 0x65, 0xd2, 0xca, + /*5a30:*/ 0xcc, 0x80, 0x2f, 0xcc, 0xd4, 0xe9, 0xce, 0xa0, 0x6d, 0x38, 0x5e, 0x00, 0x02, 0x2d, 0xcc, 0x4e, + /*5a40:*/ 0x05, 0xe5, 0x4f, 0xeb, 0x7d, 0x94, 0x74, 0x6e, 0xaa, 0xa5, 0xc0, 0xce, 0xaa, 0xd6, 0xed, 0xcf, + /*5a50:*/ 0x84, 0xdd, 0x44, 0xa6, 0xc8, 0x01, 0x2f, 0x30, 0xd0, 0x1a, 0xa1, 0x14, 0x83, 0x82, 0xe2, 0x6a, + /*5a60:*/ 0x6e, 0x0a, 0x42, 0xf6, 0x14, 0xbc, 0xd8, 0xa4, 0x44, 0x67, 0x29, 0x92, 0xaf, 0x0b, 0x8b, 0x6a, + /*5a70:*/ 0xa5, 0x45, 0x7f, 0xd3, 0x46, 0xc9, 0xec, 0x29, 0xa9, 0x3d, 0xa3, 0xd2, 0x56, 0x5f, 0xd8, 0x37, + /*5a80:*/ 0x2d, 0xf0, 0x07, 0x91, 0xe2, 0xc9, 0x78, 0xbe, 0x4c, 0x00, 0x5a, 0xda, 0x89, 0xc7, 0x96, 0xd6, + /*5a90:*/ 0x67, 0x1a, 0x33, 0x98, 0x9c, 0x0a, 0x96, 0x82, 0x44, 0x07, 0x9d, 0x08, 0x39, 0x83, 0x5d, 0xae, + /*5aa0:*/ 0x03, 0xa7, 0x36, 0xc6, 0xb1, 0x15, 0xd2, 0x80, 0x97, 0xbb, 0x6e, 0x93, 0x22, 0x99, 0xc1, 0x12, + /*5ab0:*/ 0xd9, 0x63, 0xa4, 0xa6, 0xc0, 0x99, 0x53, 0xeb, 0x9b, 0x38, 0x72, 0xe0, 0x3f, 0x2d, 0xb3, 0xd1, + /*5ac0:*/ 0x15, 0xef, 0x6f, 0xfe, 0x36, 0x11, 0xfb, 0x7a, 0xa9, 0x53, 0x44, 0x76, 0xeb, 0xfa, 0x29, 0x75, + /*5ad0:*/ 0xc0, 0xd9, 0xbf, 0x98, 0x44, 0xcb, 0x57, 0x0f, 0xa6, 0x1e, 0xab, 0xff, 0xa2, 0x1d, 0x0c, 0x70, + /*5ae0:*/ 0x2c, 0x67, 0x03, 0x82, 0x3f, 0x0e, 0x3f, 0x0b, 0xad, 0xa4, 0x42, 0x72, 0xf7, 0xbf, 0x6d, 0x6e, + /*5af0:*/ 0xf5, 0x58, 0x82, 0xdd, 0xbd, 0xd2, 0xc8, 0x1a, 0xa0, 0xf9, 0xb7, 0x27, 0x14, 0x7b, 0xe2, 0x42, + /*5b00:*/ 0xa1, 0xe2, 0xcd, 0x52, 0x65, 0xee, 0x08, 0x02, 0x2c, 0x8f, 0x8d, 0x2f, 0x6c, 0x5f, 0xa2, 0x1c, + /*5b10:*/ 0xde, 0x77, 0xa7, 0xc7, 0x4d, 0xa3, 0x87, 0x92, 0x9c, 0xb1, 0xf3, 0xcc, 0x5a, 0x8e, 0x9a, 0x98, + /*5b20:*/ 0xb9, 0x7e, 0xee, 0x20, 0x57, 0x1a, 0x27, 0x80, 0xda, 0x66, 0x34, 0xb7, 0xa6, 0xea, 0x15, 0xcd, + /*5b30:*/ 0x8f, 0x47, 0x05, 0xb6, 0x86, 0xd7, 0xb9, 0x21, 0x27, 0x9c, 0x47, 0x0e, 0x4b, 0x80, 0x10, 0x8d, + /*5b40:*/ 0x06, 0x02, 0xe8, 0x42, 0x34, 0x08, 0x67, 0x1e, 0x77, 0xd4, 0xdc, 0x61, 0xd7, 0xe5, 0xad, 0xb9, + /*5b50:*/ 0x3d, 0xf9, 0x16, 0xdf, 0x5f, 0x12, 0xd9, 0x7d, 0xaa, 0xce, 0x5d, 0x5c, 0x4f, 0xe4, 0x5d, 0x28, + /*5b60:*/ 0xd0, 0x3f, 0xea, 0xb8, 0xcc, 0xc9, 0xbe, 0x07, 0xe3, 0x27, 0x97, 0x35, 0x70, 0xb3, 0xac, 0xd4, + /*5b70:*/ 0x7a, 0xc7, 0xff, 0xc4, 0x44, 0xf8, 0x36, 0xd7, 0xb8, 0x5c, 0x7b, 0xcc, 0xd5, 0xac, 0xef, 0x16, + /*5b80:*/ 0xd4, 0x3e, 0x1c, 0xf7, 0x47, 0xa1, 0xf9, 0xeb, 0xb4, 0xd2, 0x7d, 0x0a, 0x03, 0x61, 0xb4, 0xe4, + /*5b90:*/ 0x2c, 0x3c, 0x05, 0xe6, 0x87, 0xc2, 0x07, 0xd7, 0xce, 0xc9, 0xb6, 0x98, 0xa7, 0xc8, 0x18, 0x9f, + /*5ba0:*/ 0x12, 0x4b, 0x50, 0x52, 0xfc, 0xc7, 0xd1, 0x70, 0xff, 0x06, 0xe8, 0x5b, 0xbf, 0xce, 0xf4, 0xc1, + /*5bb0:*/ 0xa0, 0xbd, 0x97, 0x8d, 0x8c, 0x3a, 0xe3, 0xf6, 0x87, 0x3b, 0x37, 0xdd, 0xb0, 0x53, 0x08, 0x25, + /*5bc0:*/ 0xbb, 0x18, 0x46, 0xf5, 0x0b, 0x39, 0x3f, 0xe7, 0x62, 0x7e, 0x29, 0x87, 0x70, 0xca, 0xa8, 0x35, + /*5bd0:*/ 0xfc, 0x36, 0xbf, 0x69, 0x24, 0xe0, 0x11, 0x7e, 0x9c, 0x09, 0x97, 0xdb, 0x83, 0x22, 0x3a, 0xa5, + /*5be0:*/ 0x5e, 0x05, 0xe7, 0x31, 0xaa, 0x44, 0x4c, 0x9b, 0xd5, 0xcc, 0x7e, 0x78, 0x86, 0xa6, 0x4b, 0x59, + /*5bf0:*/ 0x12, 0xa4, 0x98, 0xab, 0x18, 0xf6, 0x34, 0x4d, 0xc8, 0xa5, 0xdc, 0xa1, 0x96, 0x30, 0x8c, 0xed, + /*5c00:*/ 0xe6, 0x68, 0x6f, 0x90, 0xa4, 0xd3, 0x25, 0x5a, 0x35, 0x89, 0x94, 0x66, 0x0e, 0x7c, 0x91, 0x84, + /*5c10:*/ 0x89, 0x3a, 0xb6, 0x7e, 0x34, 0x0f, 0x05, 0x6a, 0x82, 0x9a, 0xbc, 0x13, 0x01, 0xed, 0x43, 0xde, + /*5c20:*/ 0xdb, 0x16, 0xf3, 0x5b, 0xa9, 0xad, 0xca, 0x66, 0xb9, 0x73, 0x61, 0xd8, 0xb2, 0x9c, 0x61, 0xfe, + /*5c30:*/ 0xe7, 0x2f, 0xad, 0xec, 0x9d, 0x96, 0xe3, 0xd9, 0x35, 0xb2, 0xf9, 0x3a, 0xf8, 0xf7, 0x6f, 0x9d, + /*5c40:*/ 0x2a, 0xcf, 0x0e, 0x72, 0x15, 0x9d, 0xe2, 0x74, 0x35, 0x82, 0x26, 0x48, 0x68, 0x66, 0x2c, 0x33, + /*5c50:*/ 0x82, 0x46, 0x33, 0x66, 0xa3, 0xf3, 0xbb, 0x01, 0xfe, 0xf5, 0x1b, 0x49, 0xd2, 0xdf, 0x42, 0xb3, + /*5c60:*/ 0x59, 0x5b, 0x7f, 0xee, 0xbe, 0x16, 0xf0, 0x17, 0x50, 0xf8, 0xc0, 0xfb, 0x99, 0xd6, 0x7f, 0x9c, + /*5c70:*/ 0x6c, 0x92, 0x83, 0x53, 0x32, 0x0e, 0x87, 0x26, 0x32, 0xd7, 0x5e, 0x9b, 0x2c, 0x93, 0x01, 0xa4, + /*5c80:*/ 0x83, 0x2d, 0x78, 0x58, 0x8c, 0x34, 0x8a, 0xdd, 0x94, 0xec, 0xe3, 0x61, 0x05, 0x57, 0xaa, 0xcf, + /*5c90:*/ 0x63, 0x63, 0x98, 0x3e, 0xc3, 0x6c, 0xce, 0x7d, 0x40, 0xbe, 0x23, 0x07, 0x13, 0x61, 0x21, 0x96, + /*5ca0:*/ 0x0f, 0x78, 0x5d, 0x6e, 0x84, 0x24, 0x01, 0x16, 0x5b, 0x52, 0x41, 0x64, 0x35, 0xe6, 0xb5, 0x8f, + /*5cb0:*/ 0xeb, 0xfa, 0x3b, 0xc1, 0x04, 0xaf, 0x39, 0x21, 0x13, 0xc8, 0x63, 0x6b, 0xab, 0xb6, 0x42, 0x5f, + /*5cc0:*/ 0xb5, 0x54, 0x76, 0x62, 0x47, 0xed, 0x55, 0x62, 0x81, 0x3e, 0xea, 0xdb, 0xf3, 0xcd, 0x81, 0x6c, + /*5cd0:*/ 0xa5, 0x7b, 0xaf, 0x77, 0x22, 0xe8, 0x13, 0x66, 0xf2, 0x50, 0xc1, 0xc9, 0xb0, 0xae, 0x99, 0x08, + /*5ce0:*/ 0xea, 0x4c, 0x17, 0xbe, 0x80, 0xb4, 0x66, 0x41, 0x27, 0xdb, 0x7f, 0xc8, 0xe1, 0x79, 0xc7, 0x48, + /*5cf0:*/ 0xc9, 0xc4, 0x69, 0x8d, 0x5d, 0x50, 0x6e, 0x82, 0xdc, 0x96, 0xa2, 0x2b, 0x2d, 0xc0, 0xf7, 0x0b, + /*5d00:*/ 0x00, 0xe9, 0xab, 0x36, 0xe4, 0xe3, 0xb8, 0xd6, 0xa7, 0xe8, 0x8c, 0xe5, 0x84, 0x72, 0xa6, 0xfa, + /*5d10:*/ 0xf5, 0xbf, 0xd6, 0xec, 0xe9, 0x65, 0x6f, 0x7b, 0xcc, 0x6c, 0x43, 0x77, 0x04, 0x63, 0x84, 0x25, + /*5d20:*/ 0x27, 0xc7, 0x58, 0xe4, 0xa9, 0x34, 0x68, 0x57, 0xeb, 0xe4, 0x5f, 0x24, 0x5e, 0xeb, 0x9b, 0x3c, + /*5d30:*/ 0x69, 0x4b, 0xa1, 0xfc, 0x33, 0xbf, 0x4a, 0xd9, 0x24, 0x77, 0x2c, 0x07, 0xd5, 0x32, 0xe6, 0x31, + /*5d40:*/ 0xf3, 0xa8, 0xc9, 0x36, 0xf0, 0x9a, 0x89, 0xa7, 0xce, 0x85, 0x98, 0x08, 0x8a, 0x95, 0x20, 0x0d, + /*5d50:*/ 0x94, 0xf3, 0xb0, 0x1b, 0x15, 0x27, 0xde, 0xa9, 0xb1, 0xfc, 0x89, 0xdc, 0x61, 0x25, 0x8b, 0xd4, + /*5d60:*/ 0x6a, 0xff, 0x02, 0x30, 0xf8, 0xff, 0x60, 0x0b, 0x43, 0x2a, 0x46, 0x27, 0x2b, 0xad, 0x91, 0x93, + /*5d70:*/ 0x19, 0x7d, 0x56, 0x0b, 0x47, 0xd0, 0x52, 0xa1, 0x34, 0x6b, 0xbd, 0xb1, 0x3d, 0x66, 0x51, 0x25, + /*5d80:*/ 0x00, 0xf9, 0xa0, 0x3e, 0x7f, 0xd5, 0xc3, 0xb4, 0x32, 0x63, 0x30, 0x6b, 0x41, 0xe6, 0x53, 0x7c, + /*5d90:*/ 0x02, 0xd9, 0xa2, 0xa9, 0xb4, 0x97, 0xc2, 0x4c, 0x2f, 0x68, 0xd0, 0x8e, 0x72, 0x0f, 0xac, 0x57, + /*5da0:*/ 0x1d, 0xf2, 0x6f, 0xe6, 0x6f, 0x5b, 0x4a, 0x7e, 0xf6, 0x77, 0x77, 0x0a, 0xac, 0x58, 0x32, 0x39, + /*5db0:*/ 0x61, 0xef, 0x09, 0x44, 0x85, 0x3f, 0x25, 0x99, 0x86, 0x97, 0x0a, 0x20, 0x28, 0x1d, 0xb9, 0x82, + /*5dc0:*/ 0x2b, 0x99, 0x4a, 0x6e, 0x54, 0x3b, 0xe8, 0x12, 0xde, 0xfb, 0xc7, 0x97, 0xa5, 0x23, 0x79, 0xed, + /*5dd0:*/ 0x4d, 0x8f, 0xca, 0x7f, 0xb6, 0x25, 0x08, 0x97, 0x50, 0xda, 0x73, 0xe0, 0x8f, 0xa8, 0xc5, 0xce, + /*5de0:*/ 0xa2, 0xb8, 0x2f, 0x5f, 0x10, 0xce, 0xb0, 0xd6, 0x90, 0x2a, 0x84, 0x90, 0x9e, 0xaf, 0x7c, 0x5c, + /*5df0:*/ 0xfb, 0x69, 0xe9, 0x33, 0x50, 0x43, 0xf5, 0x37, 0x75, 0x82, 0x30, 0xd0, 0x83, 0x7f, 0x6b, 0xe5, + /*5e00:*/ 0x93, 0x03, 0xce, 0xca, 0x41, 0x5c, 0x91, 0x31, 0x15, 0x00, 0x5c, 0x88, 0xa4, 0xcd, 0xd1, 0xb1, + /*5e10:*/ 0x11, 0x12, 0x35, 0x1c, 0xbf, 0xb7, 0xf5, 0x76, 0xf6, 0x78, 0xe4, 0x31, 0x03, 0xce, 0xbe, 0x43, + /*5e20:*/ 0xae, 0xc0, 0x32, 0x28, 0xc1, 0xf1, 0x67, 0x2b, 0x00, 0x99, 0xc5, 0xb5, 0x54, 0xe2, 0x67, 0x3b, + /*5e30:*/ 0xf0, 0x2f, 0x7f, 0x71, 0xf1, 0x56, 0xe0, 0x2c, 0x4c, 0x38, 0x88, 0x12, 0x28, 0x1c, 0x4c, 0x98, + /*5e40:*/ 0xa6, 0xf7, 0x2e, 0xbc, 0x68, 0x16, 0xf4, 0x79, 0x65, 0x91, 0x6c, 0x5e, 0xe2, 0x3e, 0x10, 0x9e, + /*5e50:*/ 0x88, 0xab, 0xb3, 0x14, 0x0e, 0x25, 0x6e, 0xd3, 0x0c, 0x63, 0x1c, 0xa5, 0x18, 0xc5, 0x9c, 0x8b, + /*5e60:*/ 0x12, 0x9e, 0x2c, 0xbe, 0x37, 0x59, 0x2c, 0x4c, 0xfb, 0x2b, 0xec, 0x4a, 0x5b, 0x6b, 0x69, 0xf0, + /*5e70:*/ 0xcc, 0x22, 0x77, 0x5d, 0xa1, 0xe0, 0x25, 0x16, 0x11, 0x23, 0x76, 0x8d, 0xbb, 0x9d, 0xea, 0x19, + /*5e80:*/ 0x40, 0x73, 0x68, 0x9b, 0x72, 0x63, 0x0c, 0xe6, 0x87, 0x58, 0x8f, 0x6d, 0x5a, 0xd6, 0xf2, 0xbc, + /*5e90:*/ 0x82, 0x57, 0x50, 0x6e, 0x35, 0x92, 0x4a, 0x88, 0x5e, 0x26, 0x50, 0xe7, 0x93, 0x8e, 0x41, 0xe4, + /*5ea0:*/ 0xdd, 0xe7, 0xdf, 0x64, 0xfa, 0x3b, 0x94, 0xea, 0xae, 0xd4, 0x60, 0x64, 0x73, 0x43, 0x27, 0xe5, + /*5eb0:*/ 0xb7, 0x22, 0x2b, 0x79, 0x13, 0x24, 0xaf, 0x74, 0xf4, 0x97, 0x05, 0xde, 0x6f, 0xa8, 0xf9, 0x34, + /*5ec0:*/ 0xb5, 0xa6, 0x17, 0x06, 0x9b, 0x5c, 0xdf, 0xe7, 0x7b, 0x12, 0x48, 0xb2, 0x7b, 0x68, 0xe9, 0x5a, + /*5ed0:*/ 0xc4, 0x4a, 0xab, 0x49, 0xb5, 0xce, 0x69, 0xec, 0x77, 0x42, 0x61, 0x85, 0xf5, 0x5f, 0x05, 0x2a, + /*5ee0:*/ 0x17, 0x65, 0xef, 0x88, 0x5c, 0x23, 0x5f, 0xb3, 0xf1, 0x55, 0x49, 0x46, 0x51, 0xee, 0x22, 0x4e, + /*5ef0:*/ 0xb6, 0x43, 0x84, 0xfd, 0x99, 0xe3, 0x7b, 0x77, 0xfa, 0x63, 0x5b, 0x88, 0xd7, 0xa0, 0xc0, 0x49, + /*5f00:*/ 0x87, 0xac, 0x08, 0x20, 0x72, 0x84, 0xd9, 0x1a, 0xf7, 0x4d, 0xe9, 0x05, 0xbc, 0x19, 0xe8, 0x2b, + /*5f10:*/ 0x1b, 0x1d, 0xe6, 0x76, 0x7d, 0x1f, 0x19, 0x15, 0x8b, 0xcd, 0x78, 0x3f, 0x99, 0x6a, 0xcb, 0x65, + /*5f20:*/ 0xaf, 0x0b, 0x05, 0xcb, 0x64, 0x3d, 0x54, 0xb6, 0x79, 0xfd, 0x66, 0xdc, 0x7c, 0x30, 0x87, 0x57, + /*5f30:*/ 0x94, 0x16, 0xce, 0x4b, 0x6a, 0x94, 0x57, 0x87, 0xea, 0x8d, 0xdc, 0x6c, 0xb5, 0x89, 0xd7, 0x55, + /*5f40:*/ 0x3b, 0xb2, 0x6b, 0x44, 0x10, 0x43, 0x79, 0x0f, 0xc0, 0xa2, 0x42, 0x59, 0x80, 0x7a, 0xf7, 0x02, + /*5f50:*/ 0x2a, 0xa2, 0x9c, 0x0a, 0x73, 0xfc, 0xbb, 0xab, 0x2b, 0x9b, 0xb5, 0xb0, 0xcc, 0x2c, 0x9b, 0xf3, + /*5f60:*/ 0x3c, 0xbe, 0x64, 0xb8, 0x00, 0x12, 0x58, 0x99, 0x8d, 0x7c, 0x2d, 0xcd, 0xb7, 0x8e, 0xef, 0x55, + /*5f70:*/ 0x3e, 0x91, 0xa5, 0x4f, 0xf8, 0x47, 0x8d, 0x04, 0x2e, 0xd5, 0x71, 0x59, 0x07, 0x01, 0x49, 0x99, + /*5f80:*/ 0x05, 0x1f, 0x50, 0xf0, 0x5e, 0x2f, 0xd8, 0xb5, 0x34, 0x02, 0x0c, 0x55, 0x91, 0x36, 0x64, 0xd5, + /*5f90:*/ 0x29, 0x63, 0x58, 0x81, 0xae, 0x49, 0xe4, 0xa5, 0x34, 0x17, 0xa8, 0x98, 0x2a, 0x70, 0x1a, 0xd9, + /*5fa0:*/ 0x3b, 0xc2, 0x90, 0x3e, 0x1a, 0xf5, 0xa7, 0x7d, 0xa5, 0x12, 0x6d, 0xf8, 0x2a, 0x6a, 0x7a, 0x16, + /*5fb0:*/ 0x65, 0x4e, 0xc6, 0xc3, 0xd8, 0xea, 0xa9, 0x5f, 0xfc, 0x68, 0x21, 0x29, 0x35, 0x0a, 0xbf, 0xf0, + /*5fc0:*/ 0x54, 0x3e, 0x64, 0x4e, 0x67, 0x4d, 0xf7, 0x9d, 0xe5, 0x9f, 0x90, 0x70, 0x4a, 0xfa, 0xea, 0xc3, + /*5fd0:*/ 0xd7, 0x61, 0x53, 0xcc, 0x41, 0x99, 0xed, 0x44, 0x16, 0xc0, 0xe1, 0x15, 0x50, 0xaf, 0xa0, 0x2d, + /*5fe0:*/ 0x45, 0x02, 0xad, 0x0f, 0xcc, 0x6e, 0xa4, 0x45, 0x7b, 0x2e, 0x49, 0x84, 0x0f, 0x51, 0x05, 0xe7, + /*5ff0:*/ 0x64, 0x1c, 0xbc, 0xa5, 0x79, 0x51, 0xab, 0xc6, 0x5c, 0x6a, 0xe3, 0x66, 0x96, 0x75, 0x8c, 0x3f, + /*6000:*/ 0xca, 0xe6, 0x4d, 0xf5, 0x3f, 0x56, 0x05, 0x3c, 0xa9, 0xb8, 0x0d, 0xc1, 0xbc, 0xfe, 0x9a, 0x63, + /*6010:*/ 0x3c, 0x1f, 0x3f, 0xee, 0xd3, 0x53, 0x2d, 0xfb, 0xb6, 0x49, 0x04, 0x88, 0xaa, 0x2e, 0x67, 0x4b, + /*6020:*/ 0x04, 0x0e, 0x9d, 0xbd, 0xd0, 0x95, 0x3f, 0xb4, 0xef, 0x26, 0x78, 0xad, 0x04, 0x21, 0x60, 0x5b, + /*6030:*/ 0x08, 0xd4, 0x13, 0x85, 0xbe, 0x05, 0x8a, 0x36, 0xfc, 0xb9, 0x44, 0x3e, 0xb0, 0x01, 0xff, 0x0f, + /*6040:*/ 0x4d, 0x0f, 0x38, 0x57, 0xca, 0x00, 0xe7, 0x40, 0xf1, 0xb7, 0x95, 0xf6, 0xf7, 0x6d, 0x22, 0x4b, + /*6050:*/ 0x34, 0x14, 0xed, 0x01, 0xc2, 0x91, 0x5d, 0x68, 0xb5, 0xf7, 0x6a, 0xa1, 0x12, 0xd8, 0x84, 0x4f, + /*6060:*/ 0xf0, 0x99, 0x9a, 0x56, 0xd7, 0x2c, 0xd1, 0x38, 0xb5, 0x94, 0x81, 0xf2, 0x05, 0x8f, 0x5f, 0x1c, + /*6070:*/ 0xb2, 0xdb, 0x4c, 0x98, 0x7a, 0x62, 0x82, 0xe9, 0x02, 0x58, 0x98, 0xa3, 0x78, 0xf0, 0x67, 0x21, + /*6080:*/ 0x22, 0x4c, 0xa7, 0x73, 0x6f, 0xc1, 0x50, 0xd8, 0xde, 0x6d, 0x85, 0xfd, 0xa0, 0x84, 0x8f, 0xbc, + /*6090:*/ 0x04, 0x20, 0x88, 0x6f, 0x73, 0x74, 0x18, 0x7d, 0xa1, 0x23, 0xfd, 0xb4, 0x25, 0xc1, 0x1b, 0x4b, + /*60a0:*/ 0x93, 0x43, 0x8a, 0x3b, 0x89, 0x81, 0x11, 0x9f, 0xf7, 0x8e, 0x0c, 0xdc, 0xfe, 0x74, 0x9f, 0xaf, + /*60b0:*/ 0x83, 0xe4, 0xbb, 0x37, 0xaf, 0x4d, 0x5d, 0x68, 0xf4, 0xa0, 0x73, 0x24, 0x06, 0x55, 0xbe, 0xe7, + /*60c0:*/ 0xe9, 0xbb, 0xfa, 0x94, 0x28, 0x4b, 0xd6, 0xa5, 0x06, 0xa7, 0x9a, 0x30, 0xc4, 0x22, 0xec, 0xa7, + /*60d0:*/ 0x1b, 0xbc, 0x9d, 0xb9, 0x54, 0xe4, 0x8a, 0xc1, 0x79, 0xa4, 0x5f, 0xc3, 0xf3, 0xe6, 0xe6, 0x4b, + /*60e0:*/ 0x9f, 0x93, 0x77, 0x53, 0xed, 0x12, 0xbb, 0xc7, 0x7f, 0xc0, 0x8e, 0xbb, 0xcf, 0xd1, 0x2e, 0x8c, + /*60f0:*/ 0x17, 0x20, 0xc6, 0x03, 0xc9, 0x8e, 0x89, 0x33, 0x8f, 0x19, 0x83, 0x29, 0xd9, 0xb7, 0x8e, 0x58, + /*6100:*/ 0x7c, 0x3c, 0xf4, 0x9c, 0x63, 0x70, 0xbe, 0xba, 0x9a, 0x02, 0x5f, 0x44, 0x04, 0xcd, 0x24, 0xf3, + /*6110:*/ 0x1a, 0x8d, 0xaa, 0xff, 0x69, 0x71, 0x97, 0x98, 0x06, 0x4d, 0xcc, 0xd9, 0x76, 0x34, 0x6f, 0x91, + /*6120:*/ 0xff, 0xef, 0x1b, 0x65, 0x39, 0x6e, 0xb7, 0xb0, 0x5f, 0x9e, 0xfb, 0x42, 0x50, 0xc1, 0xf4, 0x79, + /*6130:*/ 0x9c, 0x56, 0xfa, 0xcc, 0x51, 0x54, 0xca, 0x53, 0x2d, 0xa4, 0x01, 0x00, 0xfd, 0x4e, 0x1d, 0x8b, + /*6140:*/ 0x54, 0x3d, 0xcc, 0x2c, 0xef, 0x12, 0x10, 0x55, 0xaf, 0x7c, 0xd1, 0xcc, 0xf2, 0x60, 0xc6, 0xcd, + /*6150:*/ 0xfa, 0x1d, 0x13, 0x93, 0xb7, 0x14, 0x0a, 0x6c, 0xe2, 0xf6, 0x21, 0x0a, 0x08, 0xa0, 0x48, 0xef, + /*6160:*/ 0x9d, 0xae, 0x72, 0x00, 0xd3, 0xef, 0xe7, 0x22, 0x1e, 0xd4, 0x98, 0x6c, 0xf3, 0x44, 0x81, 0xaf, + /*6170:*/ 0xe5, 0x57, 0x4b, 0xf9, 0xcb, 0x4c, 0x26, 0x0a, 0x73, 0xe4, 0x55, 0xc9, 0x43, 0x03, 0x29, 0xd9, + /*6180:*/ 0x79, 0xd1, 0x12, 0x5c, 0x06, 0x3c, 0xf1, 0x7d, 0x80, 0x26, 0x73, 0x20, 0x07, 0x99, 0xf4, 0xfa, + /*6190:*/ 0x34, 0x51, 0xb5, 0x59, 0x75, 0x72, 0xd7, 0x61, 0xf4, 0xd0, 0x44, 0x71, 0xc1, 0x13, 0xc7, 0xfd, + /*61a0:*/ 0x59, 0xc6, 0x49, 0x49, 0x70, 0xc4, 0x78, 0xf7, 0x3a, 0xe3, 0x5a, 0x8a, 0xf8, 0xc5, 0x52, 0xe0, + /*61b0:*/ 0xbd, 0x47, 0x38, 0x2a, 0x50, 0xb3, 0x80, 0x93, 0x60, 0x63, 0xfd, 0x01, 0xd6, 0x98, 0xb4, 0xea, + /*61c0:*/ 0x78, 0x13, 0x47, 0x50, 0xf5, 0xf9, 0x86, 0x6c, 0x95, 0x6d, 0x5a, 0xfa, 0x6f, 0x8f, 0x00, 0xed, + /*61d0:*/ 0x9a, 0xfa, 0xd4, 0x78, 0x2f, 0x3a, 0x62, 0x0e, 0x76, 0x15, 0x4b, 0xdf, 0x79, 0x1a, 0x6a, 0xcf, + /*61e0:*/ 0x75, 0x49, 0xfd, 0xf7, 0x63, 0x59, 0xd8, 0x46, 0xc2, 0xc1, 0x87, 0xbf, 0x6c, 0xfe, 0xcf, 0xe6, + /*61f0:*/ 0x10, 0x6f, 0x16, 0xa9, 0xfb, 0xae, 0x43, 0x1b, 0x04, 0xa1, 0x2d, 0xfa, 0x0b, 0x85, 0x31, 0x3d, + /*6200:*/ 0x45, 0x0f, 0xe4, 0xe6, 0xe8, 0xf0, 0x1c, 0x5e, 0x03, 0x4a, 0x25, 0x0a, 0xcf, 0xdd, 0x10, 0x17, + /*6210:*/ 0xef, 0xac, 0x90, 0xf4, 0x03, 0xc9, 0xec, 0x98, 0x78, 0x35, 0x8c, 0x96, 0x3b, 0x83, 0xd1, 0xed, + /*6220:*/ 0x53, 0x89, 0x9d, 0x9d, 0xab, 0xa9, 0x99, 0x8c, 0x0b, 0xd4, 0xcb, 0xf9, 0x5e, 0x02, 0x4c, 0x5c, + /*6230:*/ 0x11, 0xec, 0x45, 0x0e, 0xba, 0x35, 0x64, 0xa2, 0xa0, 0x20, 0x5f, 0xae, 0x7b, 0x28, 0x9d, 0x38, + /*6240:*/ 0x0c, 0x9a, 0x88, 0x75, 0x69, 0xc7, 0x2b, 0xdd, 0x06, 0xd6, 0xfb, 0xd0, 0x56, 0x29, 0x81, 0xb7, + /*6250:*/ 0xfe, 0x00, 0x0d, 0xc5, 0xf7, 0x79, 0x1f, 0xec, 0x75, 0x67, 0x1c, 0x04, 0xae, 0x39, 0x8b, 0x11, + /*6260:*/ 0xdd, 0xed, 0x83, 0x97, 0x59, 0x22, 0x02, 0x38, 0xe8, 0x04, 0x0f, 0x4f, 0xf5, 0xd1, 0x89, 0x0a, + /*6270:*/ 0xe4, 0x5a, 0x17, 0x3f, 0x66, 0x1b, 0x70, 0x5a, 0xfa, 0xea, 0xc7, 0x8f, 0x24, 0x42, 0xd5, 0x2d, + /*6280:*/ 0x47, 0x63, 0x19, 0xad, 0x95, 0x94, 0xac, 0x45, 0xbc, 0xb2, 0x15, 0xb6, 0xd3, 0x76, 0x78, 0xee, + /*6290:*/ 0x2f, 0xbc, 0x98, 0xfc, 0x0b, 0x71, 0x48, 0x21, 0x1b, 0xda, 0xc4, 0x76, 0x3f, 0x43, 0x12, 0x4a, + /*62a0:*/ 0x7b, 0x64, 0x24, 0x6b, 0xea, 0xbf, 0x9f, 0xdd, 0x47, 0x8a, 0x25, 0x2d, 0x8d, 0x3e, 0xe6, 0x1b, + /*62b0:*/ 0x7f, 0xea, 0xc8, 0xa7, 0xb1, 0x80, 0x30, 0xa7, 0x20, 0xc9, 0x6e, 0x8b, 0xee, 0xc8, 0x6a, 0x47, + /*62c0:*/ 0x20, 0xe7, 0x27, 0x25, 0x4b, 0x14, 0x3e, 0x98, 0xf3, 0x87, 0x95, 0x20, 0x59, 0xb8, 0x71, 0x44, + /*62d0:*/ 0x35, 0xf8, 0x72, 0xf8, 0x06, 0x94, 0xde, 0x42, 0xe5, 0x93, 0x57, 0x30, 0xd7, 0xc4, 0x36, 0x0a, + /*62e0:*/ 0x07, 0x53, 0xd8, 0x86, 0x17, 0x6b, 0xda, 0xf8, 0x35, 0x14, 0xa6, 0xd3, 0x35, 0xfd, 0xcd, 0xba, + /*62f0:*/ 0x43, 0x6c, 0x91, 0xb9, 0x77, 0x8a, 0xf1, 0x9a, 0x6d, 0x77, 0x47, 0x7b, 0x80, 0x3a, 0xb8, 0x39, + /*6300:*/ 0x34, 0x43, 0x31, 0x79, 0x25, 0x37, 0x01, 0x2b, 0xad, 0x07, 0xac, 0x67, 0xe2, 0xea, 0x2c, 0x29, + /*6310:*/ 0x5f, 0xfa, 0x6d, 0x73, 0x76, 0x58, 0x75, 0x0a, 0x40, 0x4d, 0xbf, 0x31, 0x0f, 0xa8, 0x4e, 0xf0, + /*6320:*/ 0x39, 0xba, 0xe2, 0x18, 0x91, 0x2d, 0xe5, 0xe4, 0xbf, 0x37, 0x86, 0x8d, 0xbe, 0x14, 0x93, 0x9f, + /*6330:*/ 0x0d, 0x95, 0x21, 0xc8, 0xae, 0x76, 0x90, 0x87, 0xad, 0xdb, 0x07, 0x11, 0x27, 0x24, 0xcb, 0xce, + /*6340:*/ 0x5d, 0x8f, 0x49, 0x84, 0xc2, 0x10, 0xe9, 0xd1, 0xa5, 0x0c, 0xea, 0xf0, 0x0d, 0x3f, 0x20, 0xf6, + /*6350:*/ 0x0e, 0x54, 0x7f, 0xca, 0x89, 0xf1, 0x10, 0x37, 0x06, 0xbe, 0x67, 0xdd, 0x9b, 0x1d, 0x6b, 0xd0, + /*6360:*/ 0x92, 0x5c, 0x78, 0xca, 0xbe, 0x5f, 0x4d, 0xc3, 0xc8, 0xfa, 0x48, 0x57, 0x7f, 0xda, 0x82, 0xb1, + /*6370:*/ 0x0d, 0xe2, 0xc3, 0x28, 0x76, 0x33, 0x0f, 0x6b, 0x0a, 0xc6, 0xbb, 0xdb, 0x1c, 0x94, 0x4f, 0x6a, + /*6380:*/ 0xe9, 0xff, 0x5c, 0xf9, 0x99, 0x45, 0x74, 0xda, 0xca, 0x3a, 0x2d, 0x1b, 0xf5, 0x98, 0xb0, 0xc8, + /*6390:*/ 0x4d, 0xa0, 0x8f, 0x78, 0xc5, 0xe8, 0xb8, 0xea, 0x63, 0x20, 0x34, 0x23, 0x67, 0xea, 0x30, 0xa7, + /*63a0:*/ 0x42, 0xf7, 0x2d, 0x0f, 0x35, 0xe3, 0xe0, 0x36, 0xad, 0x97, 0xe9, 0x02, 0x36, 0x02, 0x6d, 0x5f, + /*63b0:*/ 0x04, 0x5c, 0xcc, 0x65, 0x5a, 0x3b, 0x5a, 0x9f, 0xe3, 0x71, 0xb2, 0x9c, 0x49, 0xd6, 0x0a, 0x24, + /*63c0:*/ 0xfb, 0xd2, 0xb0, 0x7e, 0x72, 0x16, 0xe1, 0x7f, 0xb1, 0xbf, 0x04, 0x9f, 0xd2, 0xe5, 0x53, 0x98, + /*63d0:*/ 0xad, 0x68, 0x08, 0x9c, 0x4d, 0xa8, 0x5b, 0x22, 0xd9, 0xaf, 0x56, 0xb4, 0xad, 0x45, 0x9c, 0x07, + /*63e0:*/ 0x15, 0xc8, 0xc0, 0xec, 0x5f, 0x09, 0x02, 0x3b, 0xf9, 0xe3, 0xbc, 0x7d, 0x27, 0xe2, 0x2d, 0xde, + /*63f0:*/ 0xea, 0x7a, 0xdd, 0x90, 0x63, 0xed, 0x55, 0x10, 0xf4, 0x95, 0x73, 0x24, 0xd1, 0xcb, 0x1d, 0x3d, + /*6400:*/ 0xcf, 0x45, 0x53, 0x41, 0x47, 0x94, 0x85, 0xc0, 0x8b, 0x1f, 0xd1, 0x0d, 0x46, 0x13, 0x42, 0xef, + /*6410:*/ 0xe9, 0xc5, 0xc4, 0xa9, 0xa2, 0xf0, 0x87, 0x35, 0x34, 0x00, 0xbe, 0xc5, 0x5d, 0x40, 0x11, 0x75, + /*6420:*/ 0x8b, 0xec, 0x46, 0xd3, 0x1d, 0x54, 0xdc, 0xb3, 0x6c, 0x6e, 0x3b, 0x49, 0xa9, 0x80, 0xe8, 0x76, + /*6430:*/ 0x5d, 0xad, 0xce, 0x0e, 0x96, 0x24, 0xfd, 0x79, 0xb1, 0x58, 0x79, 0x98, 0x50, 0x29, 0x64, 0x8c, + /*6440:*/ 0x85, 0xd8, 0x16, 0x7b, 0xec, 0xa9, 0xb7, 0x53, 0x18, 0x55, 0x41, 0x44, 0x12, 0xf6, 0x52, 0x77, + /*6450:*/ 0x6c, 0x0f, 0xfe, 0x71, 0xf8, 0xf6, 0xf8, 0xb3, 0xb3, 0x47, 0xb6, 0xe5, 0x9e, 0x28, 0x4f, 0x87, + /*6460:*/ 0x92, 0xb0, 0x0c, 0x60, 0xbe, 0x7a, 0x91, 0xf3, 0x6e, 0x9a, 0xae, 0x2b, 0x37, 0x20, 0x8d, 0xf8, + /*6470:*/ 0x08, 0xdd, 0x65, 0xbe, 0xe5, 0x83, 0xeb, 0x6d, 0xf0, 0xe9, 0x07, 0x29, 0xb2, 0x3b, 0x10, 0x8a, + /*6480:*/ 0x95, 0xc7, 0x57, 0xdd, 0x21, 0x7b, 0xb0, 0x48, 0x91, 0x88, 0x68, 0x87, 0x93, 0x85, 0x82, 0x50, + /*6490:*/ 0xfa, 0x3d, 0xb9, 0x26, 0x86, 0xa2, 0x84, 0x47, 0x9d, 0x41, 0x91, 0xe5, 0x2e, 0xcb, 0xd1, 0x92, + /*64a0:*/ 0xcb, 0xb2, 0x20, 0x33, 0x05, 0x1e, 0xde, 0x16, 0x75, 0x5f, 0xc1, 0xd1, 0x84, 0x2c, 0x98, 0xb9, + /*64b0:*/ 0xf4, 0xba, 0x69, 0x13, 0x6f, 0x51, 0x55, 0x07, 0xcd, 0x4e, 0x10, 0x61, 0xd9, 0x67, 0x4b, 0x57, + /*64c0:*/ 0x8e, 0x3a, 0x88, 0x09, 0xdb, 0xfe, 0x71, 0x34, 0x5d, 0xd8, 0x7e, 0xb1, 0x10, 0xa8, 0x07, 0xf7, + /*64d0:*/ 0x05, 0x3c, 0x3c, 0x81, 0xb4, 0xd9, 0x13, 0x31, 0x9b, 0x9d, 0x97, 0xee, 0xeb, 0x07, 0xbb, 0x0a, + /*64e0:*/ 0xa9, 0x76, 0x8d, 0x3b, 0x49, 0x35, 0xeb, 0x31, 0x32, 0x99, 0x25, 0x3f, 0x44, 0xf5, 0x6c, 0x76, + /*64f0:*/ 0x08, 0x34, 0x96, 0xd8, 0xfa, 0x6f, 0xef, 0x23, 0xf1, 0x7d, 0x77, 0x07, 0x56, 0x46, 0x18, 0x2c, + /*6500:*/ 0x80, 0xa3, 0xbc, 0x4e, 0x35, 0xfc, 0x9a, 0x32, 0xc9, 0x64, 0x15, 0xd1, 0x2d, 0x47, 0xa1, 0xd7, + /*6510:*/ 0x87, 0xb3, 0xc3, 0x99, 0x64, 0xfe, 0xd1, 0x53, 0xce, 0x5c, 0x56, 0x54, 0x3e, 0x9c, 0xf7, 0xa3, + /*6520:*/ 0xb5, 0x81, 0xf3, 0x54, 0x35, 0xbc, 0x1c, 0x40, 0x52, 0xe4, 0xba, 0x08, 0x45, 0xf7, 0x6a, 0x85, + /*6530:*/ 0xc9, 0xe6, 0x0a, 0x2d, 0xe5, 0xf6, 0x86, 0x30, 0x61, 0x5f, 0xa8, 0x7a, 0xdb, 0x2c, 0x38, 0x78, + /*6540:*/ 0xff, 0x45, 0x9f, 0x7b, 0xcf, 0xf7, 0x66, 0x8d, 0x57, 0xfe, 0xcd, 0x0a, 0x3c, 0xbb, 0x4a, 0x45, + /*6550:*/ 0x82, 0x01, 0xd0, 0x30, 0x34, 0x22, 0xd9, 0x84, 0xb5, 0x19, 0x5e, 0xe2, 0xa9, 0x23, 0x3b, 0xfb, + /*6560:*/ 0xed, 0x42, 0xb2, 0x80, 0xdc, 0x8c, 0xae, 0x27, 0x6e, 0x54, 0xab, 0x9c, 0x87, 0x60, 0x18, 0xd6, + /*6570:*/ 0x57, 0x62, 0x6b, 0xb9, 0x87, 0xc4, 0x28, 0x52, 0x42, 0xc2, 0x0c, 0x83, 0xad, 0x1e, 0x79, 0xce, + /*6580:*/ 0x50, 0x49, 0x8b, 0xd4, 0xe7, 0x10, 0x1a, 0x32, 0x5a, 0x8f, 0x98, 0xd1, 0x20, 0x29, 0xc1, 0x35, + /*6590:*/ 0x02, 0x7f, 0xcf, 0x18, 0xac, 0x45, 0x24, 0x9f, 0xd3, 0x82, 0xe5, 0x95, 0xdc, 0x68, 0x2d, 0x1a, + /*65a0:*/ 0x8c, 0x6e, 0xa5, 0x79, 0x2b, 0xde, 0x17, 0x6c, 0x8b, 0x23, 0x06, 0x92, 0x01, 0x4e, 0x29, 0x3d, + /*65b0:*/ 0x5e, 0x8e, 0x45, 0x13, 0x85, 0x1c, 0x13, 0x61, 0xf4, 0xbb, 0x1b, 0x39, 0xcd, 0xd7, 0x3f, 0xde, + /*65c0:*/ 0xd3, 0xbe, 0x60, 0x41, 0xda, 0xe4, 0x95, 0xa6, 0xf8, 0x10, 0xe5, 0xe9, 0x34, 0x47, 0x49, 0x75, + /*65d0:*/ 0x7b, 0xa0, 0xbe, 0xa1, 0x4d, 0xce, 0xe3, 0xa5, 0xe7, 0xb3, 0x88, 0xf2, 0x06, 0x7c, 0xa5, 0x5f, + /*65e0:*/ 0xb7, 0x08, 0x1a, 0x19, 0x33, 0xc9, 0x66, 0x29, 0x77, 0xf6, 0x00, 0x48, 0x3c, 0x1b, 0xda, 0xa6, + /*65f0:*/ 0xb9, 0x31, 0xc3, 0xf6, 0x81, 0x32, 0x77, 0x69, 0x61, 0x7e, 0xc5, 0xe4, 0x90, 0xb1, 0xdd, 0x01, + /*6600:*/ 0xac, 0x89, 0xcf, 0x5b, 0x49, 0x10, 0xef, 0x23, 0x0d, 0x05, 0x87, 0x0f, 0xa2, 0x62, 0x24, 0x49, + /*6610:*/ 0x54, 0xa1, 0x9d, 0xc2, 0x4f, 0x4f, 0x06, 0x61, 0xa4, 0x24, 0x76, 0xd7, 0xcd, 0x59, 0x34, 0xb9, + /*6620:*/ 0xcc, 0x25, 0x41, 0x2e, 0xbd, 0x73, 0x3e, 0x07, 0xe7, 0xf0, 0x8f, 0xf3, 0xe0, 0x82, 0xf4, 0xc8, + /*6630:*/ 0x1f, 0x93, 0x0c, 0x79, 0xa3, 0x83, 0xba, 0xa1, 0x2e, 0x1b, 0x08, 0x0c, 0x26, 0x5e, 0x92, 0x75, + /*6640:*/ 0x2a, 0x8c, 0xcb, 0x4d, 0x1b, 0xd6, 0x95, 0x66, 0xf1, 0xa8, 0xea, 0x41, 0x49, 0x0c, 0x62, 0x7f, + /*6650:*/ 0x98, 0x9e, 0xd8, 0xf1, 0x2b, 0x26, 0x07, 0xe7, 0xa7, 0xb2, 0xc3, 0x95, 0xcb, 0x5f, 0xa7, 0x4f, + /*6660:*/ 0x5d, 0x45, 0x57, 0x00, 0xb1, 0x1d, 0xd5, 0x8b, 0x7a, 0x00, 0x78, 0xeb, 0x57, 0xad, 0xe4, 0x4b, + /*6670:*/ 0xa6, 0x47, 0xfe, 0x40, 0x19, 0x6b, 0x3f, 0xac, 0xba, 0xe8, 0xaf, 0x03, 0xe8, 0x8e, 0x1f, 0xb1, + /*6680:*/ 0x89, 0x26, 0x4b, 0x57, 0x2e, 0x74, 0xc0, 0xd8, 0x42, 0x2c, 0xb5, 0x0b, 0x95, 0xf0, 0x2f, 0x04, + /*6690:*/ 0x00, 0x44, 0x19, 0xdd, 0xff, 0x6f, 0xe4, 0x6e, 0x93, 0x33, 0x2e, 0xd1, 0x4a, 0xc5, 0x68, 0x5c, + /*66a0:*/ 0x9c, 0xea, 0x25, 0x9f, 0x78, 0xac, 0x08, 0xc1, 0x84, 0x8d, 0x08, 0x25, 0xb0, 0x79, 0x13, 0xbb, + /*66b0:*/ 0xf0, 0x5c, 0x2c, 0xa9, 0x22, 0x7c, 0xd4, 0xf9, 0xbe, 0xc4, 0x99, 0x8b, 0xba, 0xe0, 0x1b, 0x3a, + /*66c0:*/ 0xa2, 0xe8, 0xbf, 0x1a, 0xe2, 0x90, 0xd2, 0x0c, 0xfc, 0x7c, 0x96, 0x17, 0xd7, 0x25, 0x14, 0xa1, + /*66d0:*/ 0x67, 0xfe, 0xb2, 0x62, 0xca, 0x38, 0x0c, 0x6e, 0x6d, 0x6c, 0x65, 0x27, 0xb5, 0x53, 0x49, 0xc6, + /*66e0:*/ 0x62, 0x53, 0xc2, 0x14, 0x14, 0xf7, 0xec, 0xef, 0xfa, 0x9f, 0x81, 0x71, 0x80, 0xf7, 0x03, 0x9c, + /*66f0:*/ 0x69, 0x37, 0x38, 0xfc, 0xa6, 0x3b, 0x31, 0x81, 0x7e, 0x4c, 0x81, 0xf9, 0xd4, 0x17, 0xfe, 0x92, + /*6700:*/ 0x4d, 0x93, 0x1b, 0xbd, 0xcf, 0x5a, 0xfa, 0xfb, 0xaa, 0xcf, 0xf9, 0x10, 0xb2, 0x0f, 0xd7, 0x2f, + /*6710:*/ 0x71, 0x20, 0xd0, 0xda, 0x25, 0xd8, 0x6d, 0xe2, 0x81, 0x1d, 0x17, 0x55, 0x16, 0x1a, 0x66, 0xcc, + /*6720:*/ 0x21, 0x95, 0xf7, 0x3d, 0x96, 0xe1, 0x71, 0x59, 0x7c, 0x9c, 0xdd, 0xbe, 0xf8, 0xa5, 0x14, 0xe4, + /*6730:*/ 0x21, 0x31, 0x2c, 0xe2, 0x6e, 0x4a, 0x4e, 0x27, 0x29, 0x73, 0xf6, 0x9a, 0x8b, 0x04, 0xcd, 0x34, + /*6740:*/ 0xa4, 0x0f, 0x15, 0x57, 0x51, 0x42, 0x95, 0xf7, 0x54, 0x35, 0x0d, 0xd2, 0x5b, 0x9f, 0xd7, 0x51, + /*6750:*/ 0xff, 0x30, 0x1e, 0xa3, 0x14, 0x20, 0xa9, 0x46, 0xca, 0x87, 0x55, 0x83, 0x24, 0x2f, 0x97, 0x6f, + /*6760:*/ 0xc0, 0x03, 0xe3, 0x9a, 0x97, 0x92, 0x80, 0x95, 0x38, 0x69, 0x78, 0x2d, 0xed, 0xb0, 0x32, 0x85, + /*6770:*/ 0xfa, 0xb8, 0x78, 0x8c, 0xc2, 0x5d, 0x7b, 0xc9, 0x17, 0x6e, 0xca, 0x3b, 0xdd, 0x7d, 0xbc, 0xbe, + /*6780:*/ 0x80, 0xe0, 0xfb, 0x80, 0x5d, 0x33, 0xc1, 0xa3, 0x47, 0xf2, 0xdc, 0x97, 0x7d, 0xb1, 0xce, 0xbd, + /*6790:*/ 0xf2, 0x4d, 0xec, 0x19, 0xdc, 0x87, 0x15, 0x44, 0x0e, 0xe9, 0xbe, 0x14, 0x8a, 0xbb, 0x4b, 0x4b, + /*67a0:*/ 0x65, 0x64, 0x90, 0x12, 0x6c, 0xd5, 0x34, 0x33, 0xde, 0xd4, 0x66, 0x8c, 0x0e, 0xef, 0xfe, 0xa6, + /*67b0:*/ 0x95, 0x1b, 0x81, 0x0e, 0xa1, 0xa2, 0xf8, 0x3c, 0xd4, 0xa9, 0xea, 0xc6, 0x39, 0x10, 0x36, 0x08, + /*67c0:*/ 0xd0, 0xce, 0x40, 0x1e, 0x2e, 0x83, 0x19, 0x64, 0x1d, 0x64, 0x65, 0xc2, 0xda, 0xad, 0xc4, 0x0a, + /*67d0:*/ 0x64, 0xe6, 0x58, 0x26, 0x05, 0x6b, 0xec, 0x41, 0xea, 0x55, 0x4d, 0x4c, 0x1a, 0xac, 0x7c, 0x72, + /*67e0:*/ 0x4c, 0x4d, 0x56, 0xab, 0x0a, 0x2d, 0x17, 0xe9, 0x2a, 0x9d, 0xe1, 0xc1, 0x84, 0xb0, 0xd9, 0x95, + /*67f0:*/ 0x7d, 0x4a, 0x11, 0x77, 0xeb, 0x93, 0x02, 0x9b, 0xb1, 0xfb, 0xd2, 0xa9, 0xf1, 0xde, 0x59, 0x25, + /*6800:*/ 0x5a, 0x49, 0x62, 0xc1, 0xad, 0xbb, 0x50, 0x5f, 0xaf, 0x8e, 0xb7, 0xdf, 0x11, 0x55, 0xf4, 0xb9, + /*6810:*/ 0x29, 0xc3, 0xc8, 0x70, 0xea, 0xcd, 0x9c, 0x65, 0x72, 0x29, 0xfb, 0x3b, 0x12, 0x69, 0xf4, 0x4c, + /*6820:*/ 0xbc, 0x6d, 0xbf, 0xce, 0xc9, 0x09, 0x38, 0xf1, 0x00, 0x81, 0x47, 0x24, 0x60, 0x46, 0x2c, 0x14, + /*6830:*/ 0xf1, 0xd5, 0x92, 0xdd, 0x44, 0x68, 0x20, 0x44, 0x70, 0xf1, 0xd2, 0x0e, 0x32, 0x1f, 0x60, 0xed, + /*6840:*/ 0x58, 0x02, 0x5a, 0x79, 0x2c, 0xa1, 0x3c, 0x70, 0x3e, 0xb5, 0xf4, 0x64, 0xa1, 0x69, 0x56, 0x76, + /*6850:*/ 0xd3, 0xf9, 0x61, 0xc4, 0xe7, 0x11, 0x07, 0x10, 0x1f, 0x87, 0xa2, 0x8d, 0x2a, 0xb1, 0x6d, 0x4a, + /*6860:*/ 0xa8, 0x79, 0x62, 0x7c, 0xf6, 0xfc, 0x22, 0x18, 0xa0, 0x22, 0x91, 0x33, 0xb9, 0x8a, 0xe6, 0xc6, + /*6870:*/ 0x98, 0x2d, 0x80, 0x49, 0x53, 0x2f, 0x76, 0xd0, 0x9a, 0x4b, 0x5c, 0x5b, 0x21, 0xe1, 0x19, 0xb3, + /*6880:*/ 0x76, 0x20, 0x90, 0xe3, 0xd7, 0xa5, 0x83, 0xcb, 0x0c, 0x9c, 0x04, 0x63, 0xf0, 0x1d, 0xfb, 0x07, + /*6890:*/ 0xd7, 0xae, 0x43, 0xfe, 0x97, 0x1e, 0x6e, 0xb4, 0xb3, 0xea, 0xf7, 0x7c, 0x31, 0x75, 0xf3, 0x04, + /*68a0:*/ 0x93, 0x40, 0xd7, 0x18, 0x3d, 0xaf, 0x3f, 0x22, 0x4e, 0x7f, 0x34, 0xb7, 0xb1, 0x43, 0x9f, 0xc3, + /*68b0:*/ 0xeb, 0x05, 0x6e, 0xb0, 0xdd, 0xa5, 0x0d, 0x0d, 0x80, 0x78, 0x3a, 0xdc, 0x8e, 0xb1, 0x8d, 0x40, + /*68c0:*/ 0x4b, 0x94, 0xfb, 0x04, 0xf5, 0x34, 0x39, 0x90, 0x02, 0x56, 0xd4, 0xd8, 0xd3, 0x9d, 0x51, 0x10, + /*68d0:*/ 0x36, 0x6c, 0x12, 0xcc, 0x8c, 0x80, 0x8b, 0xee, 0x60, 0xdc, 0x6b, 0x38, 0x2e, 0xe0, 0x4d, 0x1f, + /*68e0:*/ 0x9f, 0x83, 0x6b, 0x3d, 0x7e, 0xc2, 0x56, 0x01, 0xe2, 0x80, 0xf6, 0xd2, 0xbf, 0x0f, 0x52, 0x78, + /*68f0:*/ 0x28, 0xe3, 0xaf, 0x74, 0x74, 0x56, 0x98, 0x62, 0x53, 0x10, 0x48, 0xb3, 0xcd, 0xc7, 0x63, 0x37, + /*6900:*/ 0x4c, 0x7b, 0x4a, 0x13, 0x52, 0x46, 0xaf, 0xd8, 0xbb, 0x27, 0x12, 0x87, 0x02, 0x9a, 0xae, 0xff, + /*6910:*/ 0x49, 0xcc, 0x5f, 0xd2, 0x09, 0x10, 0x08, 0xe6, 0x70, 0x53, 0x36, 0xf2, 0x0e, 0x54, 0x34, 0x66, + /*6920:*/ 0x42, 0x26, 0x59, 0x1b, 0xdf, 0x88, 0x33, 0x9a, 0xb1, 0xaf, 0xa6, 0xdb, 0x71, 0xa9, 0xea, 0x89, + /*6930:*/ 0xe8, 0xdb, 0xb9, 0xcf, 0x78, 0x03, 0x5c, 0x33, 0x9b, 0x2c, 0x1e, 0x84, 0x97, 0x99, 0xc8, 0xdb, + /*6940:*/ 0xdd, 0x94, 0x98, 0xf3, 0x8f, 0x1f, 0xfb, 0xf2, 0x45, 0x46, 0x66, 0xb9, 0x24, 0x4d, 0x2f, 0x69, + /*6950:*/ 0x3a, 0xb7, 0x5c, 0x0e, 0x53, 0xf9, 0xdb, 0x65, 0xbb, 0x13, 0xd0, 0x18, 0x61, 0x5c, 0x95, 0xa4, + /*6960:*/ 0x1b, 0xdf, 0x9b, 0x3d, 0x8c, 0x62, 0x39, 0x19, 0x80, 0xec, 0x37, 0xa7, 0x60, 0xa4, 0x56, 0xf1, + /*6970:*/ 0xf5, 0x4b, 0x1f, 0xd2, 0x1d, 0x5c, 0x83, 0x7c, 0xc3, 0xbe, 0xe6, 0x6f, 0x02, 0x1f, 0xfc, 0xbd, + /*6980:*/ 0xad, 0x2a, 0x56, 0x61, 0x3f, 0xfd, 0x73, 0xac, 0x38, 0x89, 0xe5, 0x13, 0x14, 0xcd, 0x3e, 0x94, + /*6990:*/ 0x43, 0x37, 0xb1, 0x29, 0x9e, 0xbf, 0xa5, 0xc2, 0x10, 0x4e, 0xac, 0xc8, 0x5e, 0x72, 0xa5, 0x85, + /*69a0:*/ 0x30, 0xe2, 0xcb, 0x49, 0x0e, 0x7a, 0x30, 0x32, 0x03, 0x0b, 0xf7, 0xec, 0x54, 0x07, 0xc5, 0xd5, + /*69b0:*/ 0xb3, 0x86, 0xe6, 0x22, 0x3c, 0x69, 0x39, 0xa4, 0xda, 0xa8, 0xea, 0xc9, 0xcc, 0x67, 0xda, 0xf4, + /*69c0:*/ 0xbd, 0xf4, 0xd4, 0x6d, 0x4d, 0x89, 0x9c, 0xcb, 0x5a, 0x22, 0x9a, 0x29, 0x6d, 0x70, 0xff, 0x43, + /*69d0:*/ 0xc8, 0xdb, 0x38, 0x2e, 0x44, 0x8c, 0x19, 0x50, 0x82, 0xc1, 0x0a, 0xa5, 0xdf, 0x0e, 0xd2, 0x49, + /*69e0:*/ 0x08, 0x39, 0xdb, 0xf6, 0xc3, 0xa9, 0xad, 0x58, 0x17, 0x0c, 0xac, 0x0c, 0x61, 0x18, 0xaf, 0x6f, + /*69f0:*/ 0xbc, 0x52, 0x8e, 0x80, 0x6b, 0x8b, 0xd9, 0x94, 0x1c, 0x83, 0x13, 0xe9, 0x1e, 0xd6, 0x83, 0x3d, + /*6a00:*/ 0x32, 0x59, 0x6f, 0x6d, 0x8d, 0xa0, 0x4e, 0x1b, 0x7b, 0x14, 0xda, 0x28, 0x6a, 0x15, 0x56, 0xc2, + /*6a10:*/ 0x89, 0x65, 0xc1, 0x42, 0x01, 0x3a, 0x2a, 0xc3, 0x29, 0xd1, 0x3e, 0x65, 0xae, 0x00, 0xbf, 0x67, + /*6a20:*/ 0xbd, 0xd4, 0x20, 0xfd, 0xf8, 0x46, 0x06, 0x2b, 0xe5, 0x31, 0x6f, 0x70, 0x3b, 0x81, 0x81, 0x4a, + /*6a30:*/ 0xc7, 0xcf, 0x72, 0x99, 0x2c, 0x2d, 0x4b, 0xdf, 0xc3, 0x09, 0xe3, 0x5b, 0x29, 0x1d, 0x59, 0xd3, + /*6a40:*/ 0xe0, 0x89, 0x7e, 0xc4, 0x8c, 0x30, 0x46, 0x8a, 0x6b, 0x3b, 0xd0, 0x1b, 0x30, 0xe5, 0x14, 0x51, + /*6a50:*/ 0x34, 0xbc, 0x4c, 0xd5, 0x4b, 0x04, 0x2f, 0x1b, 0x7c, 0x50, 0x01, 0xdf, 0x5f, 0xa2, 0xdf, 0x10, + /*6a60:*/ 0x56, 0xbc, 0xde, 0x26, 0x5a, 0x11, 0xa7, 0xc8, 0xc9, 0x78, 0xa0, 0x5a, 0xb4, 0xfc, 0x6b, 0xa6, + /*6a70:*/ 0xb0, 0x08, 0xbc, 0xd8, 0xfd, 0xf2, 0xb0, 0xa2, 0xd5, 0xc3, 0x92, 0x0f, 0xcc, 0x6d, 0xbf, 0xb0, + /*6a80:*/ 0xc9, 0x9f, 0xc2, 0x4e, 0xf6, 0x5a, 0xc1, 0x26, 0x16, 0x3d, 0x90, 0x50, 0x65, 0x53, 0xd4, 0x66, + /*6a90:*/ 0xab, 0x4d, 0xce, 0x70, 0xd3, 0x91, 0x56, 0x4f, 0x14, 0x29, 0x4c, 0x8f, 0x8c, 0xf7, 0xcb, 0xad, + /*6aa0:*/ 0xca, 0x87, 0x67, 0x0d, 0x48, 0xc1, 0x15, 0xa1, 0xbd, 0x22, 0xb4, 0xa7, 0x41, 0x10, 0xfc, 0x49, + /*6ab0:*/ 0x35, 0x01, 0xc5, 0xa7, 0xf1, 0xd1, 0x92, 0xa3, 0x19, 0xf0, 0x75, 0x65, 0xf0, 0xe3, 0xec, 0x64, + /*6ac0:*/ 0xd9, 0x9d, 0x3f, 0x5e, 0x89, 0x5e, 0x30, 0xad, 0x98, 0x83, 0xca, 0x09, 0xc4, 0x80, 0x7d, 0x3f, + /*6ad0:*/ 0x9b, 0x74, 0x59, 0xde, 0xdf, 0x75, 0xad, 0xf2, 0x09, 0x1d, 0xff, 0xaf, 0x80, 0x71, 0x77, 0x0b, + /*6ae0:*/ 0xc1, 0x47, 0xad, 0xde, 0x6c, 0x59, 0x06, 0x38, 0x59, 0x8e, 0xe8, 0x99, 0x77, 0xd4, 0xf1, 0xab, + /*6af0:*/ 0x24, 0x2a, 0x51, 0x46, 0x9f, 0x9c, 0x00, 0x24, 0x86, 0x93, 0x82, 0xbf, 0x52, 0x68, 0x46, 0xdf, + /*6b00:*/ 0xd7, 0x3f, 0xb1, 0x23, 0x2b, 0xd4, 0xc7, 0xb1, 0x4a, 0x9b, 0x31, 0xe0, 0x20, 0x8a, 0xaa, 0xc2, + /*6b10:*/ 0x9e, 0x4d, 0xd8, 0x14, 0xfd, 0x89, 0xfc, 0xfa, 0x3a, 0x42, 0xe3, 0xed, 0x21, 0x23, 0x17, 0xe4, + /*6b20:*/ 0xe8, 0xd2, 0x88, 0xea, 0x58, 0x9f, 0xb4, 0xff, 0xfc, 0xce, 0x9d, 0x8d, 0x9a, 0xa4, 0x8c, 0xaf, + /*6b30:*/ 0x17, 0xf3, 0x80, 0x16, 0x9b, 0xcf, 0x16, 0x25, 0x88, 0x2e, 0x37, 0x59, 0x64, 0x27, 0x1b, 0xb5, + /*6b40:*/ 0xba, 0x9e, 0x89, 0xbd, 0xc2, 0xfd, 0x65, 0x31, 0x8b, 0xc8, 0xc2, 0x6b, 0x11, 0xfd, 0xf6, 0x86, + /*6b50:*/ 0x64, 0xdd, 0xe4, 0xb8, 0xa8, 0x9b, 0x64, 0x47, 0xce, 0x85, 0x01, 0xb9, 0xa2, 0xf1, 0xe4, 0x40, + /*6b60:*/ 0x6a, 0x46, 0x60, 0x6d, 0x28, 0xea, 0x53, 0xf7, 0x47, 0x28, 0x48, 0x72, 0xe7, 0x71, 0x61, 0xb9, + /*6b70:*/ 0x24, 0xd6, 0xc6, 0xc6, 0x0d, 0x5f, 0x07, 0xe6, 0xa0, 0xcf, 0x50, 0x2e, 0x8a, 0xb1, 0xa1, 0x64, + /*6b80:*/ 0x8c, 0xf4, 0x82, 0x81, 0xed, 0x60, 0xe6, 0x1c, 0xc0, 0x16, 0x98, 0x43, 0x6c, 0x26, 0x7d, 0xc1, + /*6b90:*/ 0x2a, 0xa5, 0xbb, 0x2b, 0x30, 0xa5, 0xd3, 0xf2, 0x00, 0x7b, 0x37, 0xe8, 0x8b, 0x15, 0xdc, 0xaf, + /*6ba0:*/ 0xc7, 0x08, 0x83, 0x66, 0x5f, 0x9b, 0x7b, 0xbb, 0x2d, 0x4c, 0x14, 0xb7, 0xb1, 0x18, 0x82, 0x62, + /*6bb0:*/ 0x0a, 0xfa, 0x55, 0x8a, 0xc8, 0x61, 0xe6, 0x18, 0x1f, 0xcc, 0xe0, 0xf1, 0x66, 0x73, 0x08, 0xac, + /*6bc0:*/ 0x66, 0x0d, 0x3e, 0x4f, 0xfc, 0xbe, 0xd8, 0x0b, 0xad, 0x84, 0xcd, 0x31, 0x6e, 0x78, 0x54, 0xa7, + /*6bd0:*/ 0x1e, 0x23, 0x0b, 0x2d, 0x19, 0x70, 0xaa, 0x27, 0x7a, 0x46, 0x7d, 0x0d, 0x98, 0xfe, 0x60, 0x7e, + /*6be0:*/ 0x61, 0x05, 0xce, 0x71, 0x2e, 0x96, 0x01, 0x99, 0x38, 0x5e, 0x09, 0x03, 0x38, 0x7d, 0x07, 0xbf, + /*6bf0:*/ 0x19, 0xc9, 0xa3, 0x48, 0x56, 0x6f, 0xc1, 0xc2, 0x67, 0x38, 0xfb, 0xa8, 0x45, 0xc2, 0xd9, 0x7d, + /*6c00:*/ 0x4b, 0xb7, 0x69, 0xad, 0x47, 0x6d, 0x2d, 0xe8, 0xcb, 0x35, 0x27, 0x14, 0x1a, 0x70, 0x20, 0x58, + /*6c10:*/ 0xfb, 0x58, 0xa1, 0x40, 0x1f, 0x58, 0x7a, 0xfd, 0x05, 0x58, 0xbe, 0x82, 0xb6, 0x4b, 0x93, 0x0d, + /*6c20:*/ 0xe0, 0x84, 0xed, 0xf8, 0x33, 0x76, 0x6c, 0x59, 0x8a, 0xab, 0x2e, 0x26, 0x40, 0xea, 0xb0, 0x43, + /*6c30:*/ 0x99, 0xf5, 0xbe, 0x65, 0xe7, 0x78, 0xdc, 0x77, 0x0b, 0xf5, 0xed, 0x37, 0x61, 0x4e, 0x08, 0x1f, + /*6c40:*/ 0x03, 0xfd, 0xa4, 0x53, 0xa6, 0x00, 0x50, 0x49, 0xb5, 0xe3, 0x7d, 0x62, 0xef, 0x0f, 0xc9, 0x76, + /*6c50:*/ 0x60, 0x3a, 0x23, 0x42, 0x68, 0xb0, 0xfa, 0x0e, 0x2b, 0x6c, 0x3b, 0xed, 0x68, 0x12, 0x06, 0x59, + /*6c60:*/ 0xf2, 0x6a, 0xf0, 0xae, 0xe1, 0x16, 0xc3, 0x56, 0xe2, 0x59, 0xec, 0x1d, 0x0e, 0x8e, 0x81, 0xb3, + /*6c70:*/ 0xce, 0xe3, 0x73, 0x98, 0x9c, 0xd7, 0x61, 0xe1, 0xac, 0x9c, 0x9c, 0xd2, 0x1e, 0x4a, 0x14, 0x47, + /*6c80:*/ 0x65, 0x44, 0x0a, 0x75, 0x89, 0x0a, 0x1f, 0x57, 0x5d, 0x7e, 0x8f, 0x04, 0x9c, 0xd1, 0x85, 0x98, + /*6c90:*/ 0x01, 0x6d, 0x62, 0xd2, 0xb6, 0x90, 0xc4, 0xbf, 0xe3, 0x68, 0xb4, 0x28, 0x2f, 0x12, 0x05, 0x63, + /*6ca0:*/ 0x27, 0x85, 0xf5, 0x01, 0xda, 0xea, 0x64, 0xf4, 0x0e, 0x10, 0x8b, 0xd7, 0x0a, 0x7b, 0x49, 0xff, + /*6cb0:*/ 0xbe, 0xf9, 0x9d, 0xfd, 0x76, 0xa8, 0x69, 0x04, 0x9e, 0xf1, 0x42, 0xd4, 0x5f, 0x14, 0x54, 0x76, + /*6cc0:*/ 0x7f, 0x9d, 0xc0, 0xe3, 0x2c, 0xda, 0x53, 0x1b, 0x7a, 0x15, 0x30, 0x64, 0xab, 0xce, 0x8b, 0x93, + /*6cd0:*/ 0x3c, 0x5b, 0x08, 0x58, 0x89, 0x94, 0xb6, 0xb2, 0x93, 0xd0, 0x29, 0x7f, 0x0c, 0x5b, 0xa6, 0x1d, + /*6ce0:*/ 0xe4, 0x20, 0x8d, 0x45, 0xc8, 0xb1, 0xee, 0xa7, 0x1f, 0x1e, 0x20, 0x3e, 0xef, 0x44, 0x23, 0x0a, + /*6cf0:*/ 0x6a, 0x13, 0x75, 0x8e, 0x80, 0xfc, 0x00, 0x7b, 0xff, 0x0a, 0xb4, 0x78, 0x2f, 0x00, 0x43, 0xde, + /*6d00:*/ 0x54, 0x85, 0x90, 0xbe, 0x67, 0x1f, 0xfa, 0xc5, 0x4b, 0xb7, 0x10, 0x8c, 0xb7, 0x09, 0xe0, 0xbb, + /*6d10:*/ 0x9e, 0xa8, 0xb4, 0x57, 0x34, 0x69, 0x47, 0x62, 0x59, 0x45, 0x75, 0x8e, 0x3d, 0x1f, 0xd7, 0xe9, + /*6d20:*/ 0xc4, 0xb2, 0x21, 0x5b, 0x96, 0x09, 0xd0, 0x4d, 0x22, 0x5e, 0xf3, 0xa2, 0x7b, 0x53, 0x0c, 0x6a, + /*6d30:*/ 0x91, 0xba, 0xd2, 0x4d, 0x9d, 0x3a, 0x68, 0xbd, 0x6a, 0xb7, 0x64, 0x7c, 0xd9, 0x18, 0xb3, 0x64, + /*6d40:*/ 0x2c, 0x81, 0x53, 0xdc, 0x01, 0xe6, 0x72, 0x6e, 0xcb, 0xb0, 0x6b, 0xce, 0x35, 0x2f, 0x15, 0xeb, + /*6d50:*/ 0xae, 0xfc, 0x7c, 0x34, 0xda, 0xde, 0xd8, 0x11, 0xc4, 0xb9, 0xf8, 0x73, 0x51, 0xdf, 0x45, 0x99, + /*6d60:*/ 0xae, 0x86, 0x8d, 0x80, 0x3e, 0xc1, 0x7e, 0x63, 0xae, 0xdd, 0x24, 0xbe, 0xe1, 0xfe, 0x71, 0x99, + /*6d70:*/ 0xaf, 0xf9, 0xec, 0x67, 0x14, 0xe2, 0x17, 0x3b, 0x0b, 0x5a, 0xb4, 0x40, 0x5d, 0x29, 0x05, 0x67, + /*6d80:*/ 0xae, 0x25, 0xef, 0xbf, 0x41, 0x47, 0x3d, 0x12, 0xd3, 0x80, 0xed, 0x57, 0xfa, 0x3e, 0x9c, 0x32, + /*6d90:*/ 0x3b, 0x04, 0xf0, 0xc8, 0x96, 0x67, 0x5a, 0x32, 0x04, 0x88, 0xa8, 0x81, 0x1f, 0x3f, 0xe7, 0xd5, + /*6da0:*/ 0x0f, 0xc5, 0x78, 0x8a, 0x95, 0x24, 0x72, 0xf2, 0x0b, 0xd4, 0xa5, 0xa9, 0x5a, 0xf1, 0xef, 0x53, + /*6db0:*/ 0x45, 0x53, 0x2b, 0xd2, 0xd7, 0x33, 0x02, 0x55, 0xcd, 0xd5, 0x11, 0x80, 0xa3, 0xbb, 0xf1, 0xed, + /*6dc0:*/ 0x5e, 0x4c, 0x50, 0xa2, 0x18, 0xd1, 0xcd, 0xd2, 0x30, 0x87, 0x49, 0x99, 0xd2, 0x33, 0x96, 0x50, + /*6dd0:*/ 0x71, 0xe4, 0x19, 0x8b, 0x59, 0x95, 0xd4, 0x88, 0x4d, 0x7b, 0x19, 0xdb, 0x09, 0x22, 0x02, 0x36, + /*6de0:*/ 0xc7, 0x60, 0xde, 0xfc, 0x22, 0x2c, 0x06, 0xa8, 0x75, 0x07, 0xe4, 0x3a, 0xa3, 0xfa, 0xa1, 0x85, + /*6df0:*/ 0x1e, 0x0c, 0x8d, 0x27, 0xa2, 0xa3, 0x0f, 0x68, 0x54, 0xee, 0xb5, 0x17, 0x48, 0x36, 0x7e, 0x9e, + /*6e00:*/ 0x7f, 0xe1, 0x8f, 0x09, 0xaa, 0xfe, 0x4f, 0x5d, 0xfd, 0x17, 0xe9, 0x42, 0x57, 0xa8, 0x3f, 0x18, + /*6e10:*/ 0xb6, 0x52, 0xf5, 0xa9, 0xcd, 0xd4, 0x30, 0x39, 0xa4, 0xc7, 0x1a, 0x6c, 0x7a, 0x81, 0xb7, 0xfb, + /*6e20:*/ 0xca, 0xab, 0xb8, 0xeb, 0x8b, 0x2b, 0x20, 0x4f, 0x0d, 0xbb, 0x44, 0x2f, 0xc7, 0x2c, 0x7c, 0x8a, + /*6e30:*/ 0x92, 0x48, 0x85, 0x92, 0xea, 0xd2, 0xde, 0x4e, 0xad, 0xec, 0x90, 0xe4, 0xe2, 0x9d, 0x4b, 0x7b, + /*6e40:*/ 0xce, 0xab, 0x43, 0x19, 0x65, 0xc2, 0xc2, 0xe2, 0x3c, 0xea, 0x7c, 0xd3, 0xd7, 0x76, 0x56, 0x5c, + /*6e50:*/ 0xd4, 0xad, 0x31, 0xb7, 0xeb, 0x3b, 0x54, 0x01, 0x18, 0x9f, 0x0a, 0xec, 0xb2, 0x0b, 0xcb, 0x5e, + /*6e60:*/ 0xf9, 0x2f, 0x13, 0x10, 0xce, 0xa5, 0x73, 0x89, 0x3a, 0x8f, 0x69, 0xa3, 0x61, 0xcc, 0x05, 0x10, + /*6e70:*/ 0x96, 0x67, 0x61, 0xfb, 0xde, 0x0d, 0xdc, 0x19, 0x7e, 0xc2, 0xf6, 0x0f, 0x00, 0x07, 0x52, 0x90, + /*6e80:*/ 0x36, 0xda, 0x40, 0xc5, 0x99, 0xa7, 0xd5, 0xd2, 0x13, 0x40, 0x8a, 0x49, 0xae, 0xd2, 0x53, 0x54, + /*6e90:*/ 0x37, 0x66, 0x64, 0x1c, 0x75, 0xb3, 0x31, 0xf6, 0x80, 0x86, 0xe3, 0xb1, 0x1d, 0xfb, 0x1b, 0x36, + /*6ea0:*/ 0x9b, 0x7d, 0x7a, 0x67, 0x64, 0x6a, 0x31, 0xd4, 0xc9, 0xc8, 0x11, 0x91, 0xb4, 0x78, 0x2a, 0x3f, + /*6eb0:*/ 0xef, 0x4f, 0x12, 0x7d, 0x03, 0xe9, 0x8c, 0x2a, 0x27, 0xd5, 0x70, 0x5c, 0x3b, 0x87, 0xc6, 0x7e, + /*6ec0:*/ 0xfb, 0x7e, 0x46, 0x08, 0x06, 0x17, 0x89, 0x29, 0x6c, 0x5d, 0xac, 0x0e, 0x96, 0x53, 0x77, 0x0f, + /*6ed0:*/ 0x6b, 0xd7, 0x07, 0xe7, 0xf4, 0xbd, 0xdf, 0x40, 0xbf, 0xf9, 0x91, 0x38, 0xdb, 0xb5, 0x0d, 0x0b, + /*6ee0:*/ 0x04, 0xcc, 0x5e, 0x4b, 0x62, 0xeb, 0xd1, 0xf6, 0xc9, 0x91, 0xf6, 0x27, 0xf1, 0x71, 0xf7, 0xe3, + /*6ef0:*/ 0x6f, 0xb0, 0x85, 0xa2, 0x79, 0x45, 0xe8, 0x0c, 0x15, 0xbf, 0x65, 0x29, 0xfa, 0x4f, 0xed, 0xea, + /*6f00:*/ 0x51, 0xe2, 0xc9, 0x57, 0x47, 0x84, 0x5f, 0x4d, 0x04, 0xb2, 0xa4, 0xc4, 0xc6, 0x6a, 0xef, 0x15, + /*6f10:*/ 0x27, 0xf3, 0x1c, 0xc6, 0x39, 0xd9, 0x26, 0xee, 0x32, 0xde, 0x51, 0x9c, 0x51, 0x64, 0x4b, 0xc7, + /*6f20:*/ 0xf1, 0xc3, 0x69, 0xcb, 0xce, 0x9c, 0x81, 0x1d, 0x5b, 0x25, 0xe8, 0x17, 0xbc, 0xf4, 0x42, 0x0a, + /*6f30:*/ 0x6f, 0x6a, 0x51, 0x99, 0x62, 0x29, 0x97, 0x39, 0x88, 0xc3, 0xc8, 0x4e, 0x58, 0x9a, 0x86, 0xe1, + /*6f40:*/ 0x36, 0xa6, 0x26, 0x6b, 0x06, 0x90, 0x56, 0x62, 0xc4, 0xb7, 0x24, 0x85, 0xd3, 0x37, 0x17, 0x36, + /*6f50:*/ 0x1a, 0xef, 0xce, 0x8c, 0xf3, 0x3f, 0x3c, 0x36, 0x19, 0x8f, 0xb7, 0x29, 0x69, 0x83, 0x31, 0xb1, + /*6f60:*/ 0x87, 0x8d, 0xc5, 0x2e, 0x6e, 0x0e, 0x4f, 0xdb, 0xee, 0xcd, 0x96, 0xbc, 0x59, 0x85, 0x80, 0xef, + /*6f70:*/ 0xe5, 0xcf, 0xa1, 0x9d, 0xf9, 0xe0, 0x2d, 0xe3, 0x2c, 0x38, 0xf2, 0x0a, 0x11, 0x1b, 0x3e, 0x58, + /*6f80:*/ 0x1b, 0x8a, 0x19, 0x32, 0x6c, 0x64, 0xb3, 0x78, 0xf1, 0x66, 0xbd, 0x9b, 0x69, 0xbe, 0x85, 0x53, + /*6f90:*/ 0xf7, 0x92, 0xa6, 0xd9, 0xc3, 0xac, 0x77, 0xba, 0x52, 0x64, 0x89, 0x30, 0xd6, 0x30, 0x4f, 0xa6, + /*6fa0:*/ 0xc2, 0xec, 0xd9, 0x96, 0x50, 0xfb, 0x30, 0xe4, 0xb6, 0xea, 0xb9, 0x37, 0xfe, 0x5c, 0x0f, 0x8c, + /*6fb0:*/ 0x1b, 0xae, 0x0a, 0x82, 0xc6, 0x00, 0x2c, 0x9c, 0xca, 0xb2, 0x44, 0xc0, 0x87, 0x5d, 0x9e, 0x81, + /*6fc0:*/ 0x0b, 0x08, 0x2d, 0xf0, 0xde, 0x57, 0xd7, 0x67, 0x02, 0xf8, 0x8d, 0x14, 0x4e, 0x37, 0xef, 0x06, + /*6fd0:*/ 0x7b, 0xfe, 0x96, 0x0f, 0x7b, 0xc0, 0x28, 0xe6, 0x4e, 0x88, 0xba, 0xc9, 0x78, 0x3c, 0x3e, 0x35, + /*6fe0:*/ 0x82, 0x92, 0x27, 0x11, 0x95, 0x5d, 0x4b, 0x3d, 0xb6, 0x70, 0x57, 0x05, 0xfd, 0x2f, 0x8a, 0xd4, + /*6ff0:*/ 0xa4, 0xd5, 0x80, 0x1f, 0xde, 0xb8, 0x8c, 0xaa, 0x46, 0x75, 0x23, 0x34, 0x7a, 0x67, 0xf5, 0x08, + /*7000:*/ 0xed, 0x66, 0xd7, 0x1e, 0x1d, 0x17, 0x75, 0x41, 0x8e, 0xaa, 0x72, 0x6b, 0xeb, 0x46, 0x33, 0x33, + /*7010:*/ 0x5b, 0xb4, 0x19, 0x3f, 0x1b, 0x51, 0xdf, 0x9c, 0x74, 0x3a, 0x8c, 0x43, 0x72, 0xf6, 0xf4, 0xb4, + /*7020:*/ 0x53, 0x29, 0x76, 0x5f, 0x71, 0x61, 0x79, 0x8a, 0x29, 0xe7, 0x06, 0x81, 0xe2, 0xc7, 0xd4, 0x4d, + /*7030:*/ 0x86, 0x5a, 0xcb, 0xf8, 0xcd, 0x90, 0x0d, 0x7c, 0x72, 0x04, 0xf3, 0xc0, 0x0a, 0x7f, 0xb1, 0xca, + /*7040:*/ 0xab, 0x5c, 0x81, 0x6a, 0x66, 0x1e, 0x09, 0x66, 0xbd, 0x39, 0x3b, 0xec, 0x9e, 0xa1, 0xf7, 0xfa, + /*7050:*/ 0x1d, 0xbe, 0x5c, 0x31, 0x08, 0xcd, 0x9b, 0x32, 0xf7, 0x1f, 0x50, 0x3a, 0x59, 0xbd, 0x6a, 0xa0, + /*7060:*/ 0xea, 0xcc, 0xcd, 0x50, 0x2c, 0x54, 0x5b, 0x2d, 0x0f, 0xc2, 0x68, 0xe4, 0xe1, 0x2c, 0xf9, 0xbf, + /*7070:*/ 0x50, 0x55, 0x2c, 0x53, 0x9a, 0x07, 0xb2, 0xe4, 0x9d, 0x0f, 0xde, 0xc4, 0x9e, 0xe5, 0xe8, 0x26, + /*7080:*/ 0xb3, 0x7a, 0x40, 0x35, 0xc1, 0x1b, 0x28, 0xc0, 0xe4, 0x83, 0x07, 0x32, 0xc0, 0xfb, 0xb5, 0x68, + /*7090:*/ 0xba, 0xf2, 0xab, 0xe2, 0xe5, 0xaf, 0x17, 0x4e, 0x0a, 0x9d, 0xf9, 0x7d, 0x8a, 0x8b, 0xc4, 0x5d, + /*70a0:*/ 0x36, 0x14, 0xe2, 0x96, 0x91, 0xd2, 0x3d, 0x39, 0x6e, 0xda, 0xb4, 0xe3, 0xcb, 0x43, 0x73, 0xb4, + /*70b0:*/ 0x99, 0xa2, 0x4a, 0x4b, 0x78, 0x35, 0x09, 0xe6, 0x37, 0xa7, 0xe3, 0xf5, 0x1b, 0xac, 0x0e, 0x0f, + /*70c0:*/ 0x84, 0xd4, 0xd3, 0xf8, 0x37, 0xee, 0x8d, 0x80, 0x6a, 0xd0, 0xd5, 0xb6, 0x67, 0xeb, 0x4b, 0xc0, + /*70d0:*/ 0x69, 0x9f, 0xe6, 0x45, 0xb8, 0xe0, 0x84, 0x3c, 0xe3, 0xab, 0x9e, 0xd7, 0x83, 0x5b, 0x75, 0x48, + /*70e0:*/ 0xdd, 0xde, 0x89, 0x82, 0x1e, 0x68, 0x96, 0x20, 0x29, 0x3b, 0xa8, 0x8a, 0xfc, 0xd3, 0x85, 0x69, + /*70f0:*/ 0x3a, 0x94, 0x7e, 0x1c, 0xe1, 0x00, 0xb8, 0xdf, 0xe7, 0xa8, 0x5f, 0x87, 0xce, 0x95, 0xf1, 0xb7, + /*7100:*/ 0x69, 0x97, 0xac, 0x98, 0xdb, 0x50, 0x77, 0x37, 0x99, 0xae, 0xe8, 0x7e, 0xb1, 0x95, 0xf3, 0x10, + /*7110:*/ 0x8b, 0x97, 0x7d, 0xfd, 0x2b, 0x9c, 0xb5, 0x09, 0x5f, 0x9d, 0x0a, 0xa1, 0x08, 0x37, 0x89, 0xe4, + /*7120:*/ 0x17, 0xaf, 0xd3, 0x33, 0xd2, 0xe5, 0x33, 0x9a, 0xe1, 0xab, 0x83, 0xdc, 0x20, 0xdd, 0xe1, 0xdf, + /*7130:*/ 0x25, 0x7d, 0x72, 0x29, 0x7e, 0x69, 0x97, 0x69, 0xd4, 0xdc, 0x8b, 0xda, 0x92, 0x99, 0x21, 0xec, + /*7140:*/ 0xe1, 0x3c, 0x7f, 0x9c, 0xc3, 0xac, 0x3a, 0x55, 0xde, 0x82, 0xb7, 0x98, 0x1f, 0xd3, 0xa9, 0x7c, + /*7150:*/ 0xdb, 0x71, 0x5b, 0xd8, 0xe9, 0xb9, 0x01, 0x0d, 0xb7, 0x36, 0x9d, 0xa4, 0xde, 0x90, 0x57, 0x43, + /*7160:*/ 0x88, 0xdf, 0xd4, 0xaf, 0xbf, 0xd1, 0x4d, 0xdd, 0x25, 0xd1, 0xf0, 0x6b, 0x99, 0xc2, 0x1e, 0xda, + /*7170:*/ 0x22, 0x52, 0xc1, 0xbc, 0x09, 0xbd, 0xdf, 0x2b, 0x76, 0xfc, 0xbf, 0xc4, 0x43, 0x0b, 0x8f, 0x22, + /*7180:*/ 0x09, 0x8d, 0x31, 0x30, 0x82, 0x56, 0x96, 0x5d, 0x65, 0xa5, 0x1f, 0xa2, 0x6c, 0x18, 0x95, 0x07, + /*7190:*/ 0x5f, 0xd1, 0xa5, 0x6b, 0xbc, 0x7a, 0xbb, 0x90, 0xbb, 0x75, 0xc6, 0xba, 0xac, 0xcb, 0x78, 0x3c, + /*71a0:*/ 0xa2, 0x10, 0x68, 0x07, 0x5a, 0xf5, 0x61, 0xc9, 0x44, 0x90, 0x44, 0x2c, 0xe3, 0x00, 0x2d, 0xb1, + /*71b0:*/ 0x52, 0x64, 0x27, 0xd2, 0x0a, 0xc2, 0x0c, 0x75, 0x67, 0x5b, 0xaf, 0xea, 0x5f, 0xbe, 0xea, 0x35, + /*71c0:*/ 0x88, 0x19, 0x2d, 0x1c, 0xa5, 0x84, 0x06, 0xc5, 0x5c, 0x95, 0xc7, 0x4c, 0x30, 0xf1, 0x06, 0xed, + /*71d0:*/ 0xa9, 0x41, 0x66, 0x5e, 0x2c, 0x97, 0x8a, 0x87, 0x5e, 0xb6, 0xee, 0x5e, 0x86, 0xf4, 0xd0, 0xf2, + /*71e0:*/ 0x47, 0x1f, 0x3b, 0x1e, 0xc2, 0xfa, 0x49, 0x50, 0x28, 0x80, 0xd1, 0x9e, 0xf5, 0x5c, 0x55, 0xee, + /*71f0:*/ 0x1c, 0x49, 0x6d, 0xd2, 0xf2, 0x81, 0x3e, 0x19, 0x2a, 0x35, 0xd4, 0xae, 0xd2, 0xe8, 0xf7, 0x9f, + /*7200:*/ 0x08, 0x95, 0x97, 0x15, 0xb1, 0x16, 0x3e, 0xb3, 0x43, 0xf1, 0x95, 0xbf, 0xc8, 0x7b, 0xa9, 0x09, + /*7210:*/ 0xd5, 0x82, 0x6b, 0x0c, 0x4a, 0xe0, 0x74, 0xa7, 0xd8, 0x3d, 0x21, 0x9c, 0xf4, 0x9f, 0xf1, 0xa0, + /*7220:*/ 0x13, 0x7c, 0x48, 0x0d, 0x2c, 0x8b, 0xb7, 0x71, 0xb7, 0xe5, 0x1c, 0x30, 0x36, 0xe8, 0x2a, 0x72, + /*7230:*/ 0x92, 0x9b, 0xf0, 0x92, 0xdc, 0x9d, 0x3f, 0xd3, 0x3e, 0xe3, 0xc3, 0x22, 0xff, 0x20, 0x06, 0x91, + /*7240:*/ 0x7f, 0x39, 0xe4, 0x99, 0x68, 0xd2, 0xaa, 0x0b, 0x1c, 0x1c, 0xc2, 0x3b, 0xa0, 0x0b, 0x65, 0x47, + /*7250:*/ 0xf9, 0x25, 0x8e, 0xac, 0x71, 0x8f, 0x17, 0x4d, 0xed, 0x64, 0x35, 0xb8, 0x4f, 0x28, 0x90, 0x1d, + /*7260:*/ 0x44, 0x9b, 0xb3, 0xe5, 0x42, 0x5b, 0x77, 0x47, 0x3c, 0x17, 0x38, 0x9d, 0x13, 0xe7, 0xca, 0x9e, + /*7270:*/ 0xf1, 0x86, 0xcf, 0xe3, 0x21, 0x35, 0x9a, 0x3d, 0x9b, 0x0e, 0x40, 0xf7, 0x56, 0x30, 0x22, 0x48, + /*7280:*/ 0x0b, 0xd6, 0xae, 0x1b, 0xf9, 0x2d, 0xbd, 0x62, 0x4f, 0xc7, 0xd3, 0x59, 0x0a, 0x26, 0xc9, 0xc8, + /*7290:*/ 0x0e, 0xe0, 0x28, 0x8a, 0x8d, 0x46, 0x42, 0x48, 0xea, 0x78, 0x8d, 0x51, 0x3c, 0x34, 0x84, 0x96, + /*72a0:*/ 0x3e, 0xcc, 0xf0, 0x98, 0x94, 0x68, 0x81, 0xed, 0xd3, 0xe1, 0x0d, 0x46, 0x3d, 0xcb, 0xea, 0xf0, + /*72b0:*/ 0xc6, 0x7e, 0x15, 0x97, 0x86, 0x0d, 0xd0, 0x84, 0xcb, 0x1b, 0xa6, 0x0e, 0xce, 0xa4, 0x7c, 0xbd, + /*72c0:*/ 0x65, 0x0c, 0x9f, 0x98, 0x7d, 0x13, 0x8e, 0x7a, 0x0a, 0xa9, 0xa7, 0x20, 0x3b, 0xa1, 0x4b, 0xda, + /*72d0:*/ 0xe7, 0x8a, 0x2e, 0x3f, 0xe2, 0xff, 0x11, 0xb7, 0x08, 0x8b, 0x80, 0xc9, 0xa1, 0xb4, 0xf6, 0xde, + /*72e0:*/ 0xce, 0x58, 0xb7, 0xf6, 0x5e, 0x73, 0xdb, 0xfe, 0x18, 0x87, 0x1e, 0x45, 0xe7, 0xa1, 0x84, 0xc2, + /*72f0:*/ 0xfa, 0x6a, 0x90, 0x4b, 0x4e, 0x41, 0x28, 0xc0, 0x1c, 0xb7, 0x1d, 0xc2, 0xb6, 0xa2, 0x0b, 0x08, + /*7300:*/ 0x0b, 0x61, 0xcb, 0xf6, 0xd6, 0xa1, 0x3a, 0x36, 0x23, 0x9b, 0x5c, 0x08, 0x91, 0x34, 0xfa, 0xc5, + /*7310:*/ 0x46, 0x0c, 0x54, 0x67, 0x59, 0x7f, 0x90, 0xc3, 0x05, 0x58, 0x3a, 0xee, 0x28, 0x62, 0x7b, 0xf7, + /*7320:*/ 0x25, 0xd5, 0x31, 0x6c, 0x03, 0x15, 0x7a, 0xf5, 0x3d, 0xd5, 0x53, 0x5a, 0xe6, 0xd3, 0x95, 0x6d, + /*7330:*/ 0x56, 0xb9, 0x8b, 0x3a, 0xca, 0x52, 0xe5, 0xe2, 0x6d, 0xfe, 0xf0, 0x39, 0x54, 0x7c, 0xdc, 0x10, + /*7340:*/ 0xd5, 0x46, 0xe3, 0x3b, 0xad, 0x1a, 0x3b, 0x49, 0x55, 0x28, 0x7a, 0x03, 0x3e, 0x0f, 0x4e, 0x11, + /*7350:*/ 0x64, 0x1b, 0x27, 0xa5, 0x63, 0x48, 0x70, 0x41, 0xff, 0x45, 0x85, 0x91, 0xce, 0x5b, 0xbb, 0x69, + /*7360:*/ 0x84, 0x15, 0x9d, 0x80, 0xf1, 0x1e, 0xad, 0x8e, 0xca, 0x73, 0x6c, 0x9a, 0x15, 0xd8, 0x47, 0xc1, + /*7370:*/ 0x99, 0x46, 0x4a, 0xd1, 0x70, 0x03, 0x24, 0x59, 0x1c, 0x42, 0x43, 0xf0, 0x6d, 0x49, 0xb9, 0xe0, + /*7380:*/ 0x1a, 0x20, 0x4e, 0x53, 0x08, 0x12, 0x31, 0x45, 0x11, 0xdf, 0xd5, 0x40, 0x42, 0xf5, 0x96, 0xa8, + /*7390:*/ 0x6c, 0x00, 0x0f, 0xbc, 0x92, 0xdc, 0xb3, 0x08, 0x15, 0xd6, 0x36, 0xff, 0x6b, 0x34, 0xfc, 0x42, + /*73a0:*/ 0x90, 0x30, 0x27, 0x6d, 0xf5, 0x65, 0x3c, 0x49, 0x22, 0x0c, 0x26, 0x6c, 0x8a, 0xb7, 0x26, 0xf0, + /*73b0:*/ 0xec, 0xcc, 0x00, 0x5f, 0xbd, 0x54, 0x31, 0x04, 0xe6, 0x9c, 0xe4, 0x54, 0x7b, 0x3e, 0x41, 0xe6, + /*73c0:*/ 0xcd, 0xda, 0x15, 0x1c, 0xaa, 0xb7, 0x27, 0x5f, 0xfd, 0xf6, 0xde, 0x9f, 0x04, 0xdd, 0x0e, 0xad, + /*73d0:*/ 0xda, 0xda, 0x34, 0xd0, 0x61, 0x64, 0xfa, 0x34, 0x3a, 0x9e, 0x8b, 0xb7, 0xaa, 0x35, 0x00, 0xa8, + /*73e0:*/ 0x94, 0x62, 0xbc, 0xac, 0xcb, 0x94, 0xeb, 0x92, 0x66, 0xc5, 0xc5, 0x54, 0x05, 0xb7, 0x86, 0x6c, + /*73f0:*/ 0x98, 0xa5, 0xa6, 0xd4, 0x83, 0xf0, 0x0c, 0x80, 0xa2, 0x82, 0x8c, 0x51, 0x31, 0xad, 0xe0, 0xa0, + /*7400:*/ 0x95, 0x71, 0xd1, 0xb4, 0x12, 0xd5, 0xcd, 0x25, 0x2f, 0x09, 0xa3, 0xd5, 0x1c, 0xe4, 0x4c, 0x73, + /*7410:*/ 0x94, 0x19, 0x1f, 0xe5, 0xcb, 0x66, 0xfa, 0x14, 0xaa, 0x1c, 0xdf, 0xdb, 0x48, 0x95, 0x9c, 0x20, + /*7420:*/ 0xd8, 0xb3, 0x46, 0xc9, 0xc7, 0xf6, 0x0e, 0x63, 0x1c, 0xec, 0x4e, 0xbe, 0xdd, 0x08, 0xdb, 0x94, + /*7430:*/ 0x2d, 0x38, 0x86, 0xae, 0xd3, 0x76, 0x04, 0xb2, 0xc1, 0x0e, 0x63, 0x6c, 0x22, 0xd5, 0xc9, 0x7f, + /*7440:*/ 0x6f, 0x83, 0x54, 0x52, 0x9f, 0xc5, 0x0a, 0x43, 0xa1, 0xa8, 0x9c, 0x4a, 0x1e, 0x7a, 0x2f, 0xcf, + /*7450:*/ 0x56, 0x9a, 0x46, 0x83, 0xc0, 0x2e, 0x43, 0x62, 0x54, 0x16, 0x37, 0xdd, 0x9e, 0xcf, 0xcb, 0xc5, + /*7460:*/ 0xe1, 0x8e, 0x5f, 0x83, 0xc8, 0xac, 0x6e, 0xb3, 0xcf, 0xdc, 0x3d, 0x14, 0xb0, 0x99, 0x25, 0x47, + /*7470:*/ 0x1f, 0xd6, 0xa9, 0xe3, 0x8f, 0x29, 0x98, 0x6d, 0xf5, 0xac, 0x2d, 0x6b, 0x07, 0x15, 0x71, 0xa0, + /*7480:*/ 0x4b, 0x5d, 0xd7, 0x5f, 0x55, 0xcc, 0xca, 0xd2, 0x9e, 0xd5, 0x8c, 0x42, 0x61, 0xaf, 0xee, 0x46, + /*7490:*/ 0x2d, 0x10, 0xce, 0x31, 0xf8, 0xeb, 0x96, 0xdd, 0x29, 0x1d, 0xb6, 0x75, 0x79, 0x85, 0xf6, 0xc9, + /*74a0:*/ 0x28, 0x17, 0x8c, 0x23, 0x56, 0x0e, 0xc0, 0xb2, 0x96, 0xdf, 0x21, 0xbf, 0x14, 0x8b, 0x3e, 0xe3, + /*74b0:*/ 0x21, 0xe1, 0x48, 0x07, 0x1c, 0x47, 0x8d, 0x12, 0xc2, 0xdd, 0xfd, 0x8e, 0x22, 0xbf, 0x68, 0xa9, + /*74c0:*/ 0xe1, 0x2e, 0x96, 0x3a, 0x1d, 0xa0, 0x7e, 0x94, 0xfa, 0x9c, 0xbb, 0x72, 0xf2, 0xa1, 0xc7, 0x17, + /*74d0:*/ 0x65, 0x8a, 0xb6, 0x8f, 0xdf, 0x18, 0xdd, 0x27, 0x11, 0x9d, 0x32, 0xdf, 0x9d, 0xb1, 0x00, 0x83, + /*74e0:*/ 0x00, 0xe3, 0x2c, 0xc1, 0xd5, 0x6e, 0x7d, 0x05, 0x4e, 0x93, 0x48, 0x03, 0x86, 0x3c, 0xe7, 0xe2, + /*74f0:*/ 0x5a, 0x59, 0x25, 0x4e, 0xa9, 0xb5, 0x6a, 0x27, 0x3e, 0x06, 0x75, 0xea, 0xca, 0x1a, 0x70, 0x20, + /*7500:*/ 0xbb, 0x04, 0xca, 0x0d, 0x7c, 0xe3, 0x3e, 0x0b, 0xe7, 0xdb, 0xeb, 0xbe, 0x41, 0x4d, 0x04, 0xd5, + /*7510:*/ 0x6f, 0xa2, 0x2c, 0x42, 0x5f, 0xc5, 0x6b, 0x66, 0x10, 0xf4, 0xb9, 0x14, 0x44, 0x7d, 0xfc, 0xa3, + /*7520:*/ 0x42, 0x95, 0x2b, 0xc3, 0x9e, 0x31, 0x75, 0x8f, 0x92, 0x25, 0xfa, 0xf5, 0xde, 0x86, 0x5f, 0x57, + /*7530:*/ 0xa8, 0x26, 0x41, 0x39, 0xc9, 0xc7, 0x56, 0x1f, 0x4a, 0x52, 0x7a, 0x25, 0x82, 0x1d, 0xa2, 0xd1, + /*7540:*/ 0xcd, 0x35, 0xa4, 0x1b, 0x73, 0xd8, 0x8e, 0x17, 0x2d, 0xfb, 0x49, 0x60, 0x54, 0x60, 0x1a, 0x7d, + /*7550:*/ 0x16, 0xe3, 0x8a, 0xa5, 0xd0, 0x2f, 0x81, 0xc7, 0xb4, 0x75, 0xb6, 0xba, 0xfc, 0xae, 0x96, 0x25, + /*7560:*/ 0x4e, 0xba, 0x0d, 0x8a, 0x22, 0x59, 0xe8, 0xa3, 0xd3, 0xb0, 0x87, 0xc1, 0xa7, 0x72, 0x07, 0x51, + /*7570:*/ 0x60, 0xed, 0x1c, 0xd3, 0xb1, 0x2d, 0xfb, 0xb5, 0xbc, 0xb4, 0x01, 0x22, 0x0e, 0xfe, 0x75, 0xfa, + /*7580:*/ 0x9a, 0x4b, 0xe2, 0xb3, 0x89, 0xb9, 0xe9, 0x58, 0x63, 0xf5, 0x14, 0xec, 0x1f, 0x18, 0x4c, 0x3a, + /*7590:*/ 0xf0, 0xfd, 0x0f, 0x75, 0x29, 0x40, 0x51, 0x7e, 0x39, 0xfd, 0x74, 0xa1, 0xf5, 0x7d, 0xf5, 0x6b, + /*75a0:*/ 0x15, 0x91, 0xf1, 0xd5, 0x72, 0x23, 0x07, 0x58, 0xd8, 0x7b, 0x85, 0xe3, 0x66, 0x31, 0x2b, 0x8a, + /*75b0:*/ 0xa4, 0x79, 0x58, 0x71, 0x43, 0xdb, 0x81, 0xdd, 0xb4, 0x49, 0x7d, 0x6c, 0xd7, 0xea, 0x6c, 0x07, + /*75c0:*/ 0x01, 0xfe, 0x6b, 0x50, 0x43, 0x49, 0x37, 0xd4, 0x63, 0x4f, 0xaa, 0x59, 0x44, 0xa1, 0x89, 0xac, + /*75d0:*/ 0x4c, 0x41, 0x7c, 0x0a, 0x30, 0x95, 0xa9, 0xb1, 0x4b, 0x64, 0x1e, 0x5c, 0x4b, 0xee, 0xe0, 0x0c, + /*75e0:*/ 0x7b, 0xa0, 0xc8, 0x8b, 0x3c, 0xe7, 0xec, 0x19, 0xc1, 0x9b, 0x06, 0x1c, 0xae, 0x83, 0x11, 0xc4, + /*75f0:*/ 0x48, 0xb7, 0xda, 0x18, 0xd7, 0xf3, 0x77, 0x32, 0xf4, 0x15, 0xc3, 0x62, 0x0a, 0x01, 0x98, 0x5a, + /*7600:*/ 0x5f, 0x43, 0xfb, 0x25, 0x23, 0xde, 0xfe, 0xdb, 0x2c, 0x88, 0xaa, 0x5e, 0x57, 0xcc, 0x33, 0x3c, + /*7610:*/ 0x66, 0x4a, 0x85, 0x4f, 0xfe, 0xf3, 0x72, 0x2e, 0xba, 0x3e, 0x4c, 0x31, 0x7e, 0x48, 0xe4, 0xe3, + /*7620:*/ 0x2d, 0x6e, 0xbc, 0x1c, 0x0f, 0x88, 0x58, 0x12, 0x35, 0xfa, 0x3f, 0xe0, 0xe2, 0xc9, 0x62, 0xee, + /*7630:*/ 0xe3, 0x5d, 0x3b, 0x33, 0x21, 0x14, 0x29, 0x3f, 0x99, 0x5d, 0x81, 0x54, 0x27, 0xb8, 0xba, 0xc6, + /*7640:*/ 0xcb, 0x61, 0x60, 0x74, 0xee, 0xbc, 0x9b, 0xa7, 0x43, 0x5a, 0x05, 0xcb, 0x7b, 0x82, 0x80, 0xe3, + /*7650:*/ 0xea, 0xed, 0x26, 0x35, 0xa9, 0x0f, 0xb8, 0xf3, 0x3f, 0x6b, 0x06, 0xd7, 0x91, 0x7a, 0x29, 0x1f, + /*7660:*/ 0x37, 0x2e, 0x7a, 0xac, 0x48, 0xda, 0x47, 0x0f, 0x39, 0x50, 0x38, 0xa7, 0x3d, 0x3b, 0x4e, 0xbf, + /*7670:*/ 0x78, 0x1c, 0x62, 0x97, 0x46, 0xd9, 0x9a, 0x34, 0x68, 0x9e, 0x2d, 0x60, 0x8e, 0x74, 0xfd, 0xfa, + /*7680:*/ 0xf1, 0xad, 0x01, 0x6f, 0x71, 0xc5, 0xc1, 0xc0, 0x2c, 0x34, 0x3e, 0xe9, 0x26, 0xeb, 0xa6, 0xce, + /*7690:*/ 0xf7, 0x9c, 0x25, 0x0b, 0x9f, 0x38, 0x54, 0xda, 0x17, 0xf5, 0x57, 0x7e, 0xfc, 0xd2, 0x60, 0xaf, + /*76a0:*/ 0x67, 0x58, 0x29, 0x71, 0x49, 0xeb, 0x4e, 0x91, 0x01, 0x42, 0x35, 0xd6, 0x18, 0x77, 0x72, 0xb4, + /*76b0:*/ 0xad, 0x56, 0xde, 0xa7, 0x36, 0x13, 0xfd, 0x7d, 0x8b, 0xe3, 0xf3, 0x5d, 0xb5, 0xb5, 0x8e, 0x30, + /*76c0:*/ 0x60, 0x44, 0x24, 0x9f, 0x34, 0xc0, 0x55, 0xf7, 0xab, 0xd1, 0x50, 0xfa, 0x3b, 0x92, 0x84, 0x90, + /*76d0:*/ 0xc0, 0xc3, 0xca, 0x33, 0xec, 0x34, 0x88, 0x29, 0xcd, 0x62, 0xc9, 0xd6, 0xda, 0x1c, 0x36, 0x57, + /*76e0:*/ 0x33, 0x6a, 0xe5, 0x11, 0x52, 0x63, 0xed, 0xcf, 0x63, 0x07, 0x34, 0x72, 0xf5, 0xf8, 0xc2, 0xba, + /*76f0:*/ 0xd5, 0x20, 0xde, 0xcc, 0x8f, 0xc6, 0xf1, 0x20, 0x2b, 0x34, 0x78, 0xfb, 0x73, 0x42, 0x98, 0xa8, + /*7700:*/ 0x69, 0x4c, 0x1e, 0xd1, 0xdb, 0x9a, 0xe6, 0x3c, 0x68, 0x79, 0x10, 0x5f, 0xbb, 0xbc, 0x4f, 0x54, + /*7710:*/ 0x58, 0x0c, 0xee, 0x5e, 0x83, 0x47, 0x29, 0xd7, 0xee, 0xc7, 0xea, 0xc9, 0xd3, 0x94, 0xc5, 0x7a, + /*7720:*/ 0x73, 0xfd, 0x72, 0x43, 0x15, 0x7f, 0xfb, 0x5d, 0x05, 0x2f, 0x3a, 0x69, 0x9e, 0x58, 0xcc, 0xd3, + /*7730:*/ 0xf5, 0xbd, 0x47, 0x6f, 0xbd, 0x63, 0xfb, 0xbb, 0x5f, 0xe5, 0xa0, 0x28, 0x88, 0x29, 0x05, 0xa0, + /*7740:*/ 0x1d, 0xbc, 0x48, 0xd9, 0xbc, 0xd5, 0xa0, 0xcc, 0x27, 0x46, 0xf2, 0xca, 0xee, 0xe9, 0x6b, 0xa3, + /*7750:*/ 0x63, 0xed, 0xf5, 0xe8, 0x5e, 0x1b, 0x1d, 0x91, 0xa4, 0x50, 0xb1, 0x61, 0x95, 0x53, 0xb4, 0xd6, + /*7760:*/ 0xda, 0x3d, 0x56, 0x92, 0xbb, 0x85, 0x79, 0x86, 0x1d, 0x32, 0xcd, 0xeb, 0xfd, 0x86, 0x57, 0x2f, + /*7770:*/ 0x35, 0xd1, 0x6d, 0xd8, 0xab, 0x6a, 0x86, 0xec, 0xa3, 0xe9, 0x9b, 0x1b, 0xa7, 0x24, 0x1c, 0xc4, + /*7780:*/ 0xad, 0x5d, 0xc4, 0x71, 0xad, 0xe5, 0xff, 0xcf, 0x6e, 0xf8, 0x7b, 0xfb, 0x24, 0xb3, 0xe7, 0x49, + /*7790:*/ 0x6d, 0xe0, 0xfa, 0xe2, 0x32, 0xfc, 0xcb, 0xb8, 0x10, 0x30, 0x8b, 0x57, 0x45, 0x0c, 0xe6, 0x40, + /*77a0:*/ 0x45, 0x52, 0xbf, 0xab, 0x4d, 0x16, 0xc9, 0x89, 0x67, 0x3f, 0xb7, 0x01, 0x65, 0x3e, 0xa8, 0x60, + /*77b0:*/ 0x7d, 0x02, 0x1e, 0xba, 0xe7, 0x3d, 0x01, 0x7e, 0x84, 0x60, 0xce, 0xed, 0xac, 0xc3, 0x20, 0x4b, + /*77c0:*/ 0x2b, 0xcd, 0x7c, 0x48, 0xbe, 0xeb, 0x62, 0x4b, 0x1e, 0xea, 0x14, 0x52, 0xe9, 0xe5, 0xc0, 0xe7, + /*77d0:*/ 0xf8, 0x38, 0xf9, 0x9d, 0xaa, 0x1c, 0x5a, 0x45, 0xf7, 0x17, 0x34, 0xc4, 0xcd, 0x20, 0xa7, 0xa4, + /*77e0:*/ 0x63, 0xd8, 0xbd, 0x4b, 0xf1, 0xdb, 0x91, 0x00, 0xd7, 0x2e, 0x65, 0xa9, 0xbd, 0x50, 0xe5, 0x0a, + /*77f0:*/ 0xda, 0x2f, 0x8f, 0x30, 0xc2, 0xf3, 0xf1, 0xa5, 0x7f, 0x36, 0x82, 0x18, 0xb7, 0xbb, 0x28, 0xb5, + /*7800:*/ 0xd5, 0x8d, 0x06, 0xcb, 0x99, 0x9a, 0xa6, 0xc5, 0x56, 0xfe, 0xca, 0x08, 0x92, 0x79, 0x32, 0xdd, + /*7810:*/ 0xbc, 0x82, 0x04, 0x70, 0x2c, 0xfd, 0x26, 0x47, 0x0c, 0xa2, 0x4c, 0xf5, 0xb3, 0x86, 0x86, 0xdf, + /*7820:*/ 0xd0, 0x43, 0x37, 0xd4, 0x5c, 0x34, 0xae, 0x35, 0x13, 0xc1, 0xc5, 0xa8, 0xca, 0x63, 0x8e, 0xb6, + /*7830:*/ 0xb3, 0xb5, 0x1d, 0xd0, 0x79, 0x77, 0xef, 0x84, 0x88, 0xf0, 0xba, 0xe9, 0xd0, 0x9a, 0x6c, 0x55, + /*7840:*/ 0xa0, 0xd9, 0x0e, 0x5d, 0x9e, 0x6d, 0x6e, 0x1f, 0x9d, 0xcc, 0x1c, 0x68, 0x16, 0xa5, 0xe5, 0x86, + /*7850:*/ 0x24, 0x83, 0x2b, 0xb7, 0xc6, 0xac, 0xa4, 0xa7, 0x38, 0xca, 0xdf, 0xec, 0x9e, 0x7c, 0x7d, 0x63, + /*7860:*/ 0x6e, 0x5e, 0xb2, 0x59, 0x24, 0xb5, 0xed, 0x8e, 0xa7, 0xf0, 0x63, 0x85, 0x48, 0x73, 0x6c, 0xa8, + /*7870:*/ 0xe6, 0x95, 0x6c, 0xd6, 0xf4, 0x7e, 0xdc, 0xa2, 0x61, 0x00, 0xf1, 0x9f, 0xf4, 0x51, 0x5b, 0x1a, + /*7880:*/ 0x47, 0xdc, 0x57, 0x16, 0xf1, 0x8f, 0x0c, 0xfa, 0xa3, 0xb3, 0x3d, 0xe8, 0xd5, 0xc8, 0x6a, 0x52, + /*7890:*/ 0xb8, 0xcb, 0x57, 0x9a, 0x81, 0xb3, 0x5e, 0x47, 0xb2, 0xcb, 0x64, 0x7e, 0x2f, 0x92, 0xb2, 0x57, + /*78a0:*/ 0xd1, 0x3a, 0x9f, 0x6f, 0xc6, 0xeb, 0x5e, 0xbf, 0x84, 0xf9, 0x7d, 0x31, 0x63, 0x96, 0x3d, 0x4c, + /*78b0:*/ 0x17, 0x38, 0x91, 0xd3, 0xde, 0xe6, 0x04, 0xf6, 0xe9, 0xa2, 0x7e, 0xd6, 0xe9, 0xd4, 0x50, 0x61, + /*78c0:*/ 0x5c, 0x75, 0x57, 0xee, 0x7e, 0x03, 0xe9, 0x06, 0x8c, 0x57, 0x4a, 0x8d, 0xc8, 0x54, 0x08, 0xca, + /*78d0:*/ 0x17, 0xa8, 0x9c, 0x27, 0x28, 0xc3, 0xe4, 0x85, 0xd1, 0x2d, 0x33, 0x44, 0x74, 0xc6, 0x50, 0x42, + /*78e0:*/ 0xd9, 0x29, 0x00, 0x38, 0xa4, 0xe6, 0xb9, 0xf3, 0xfa, 0x40, 0xb9, 0x83, 0x20, 0xed, 0x22, 0xb7, + /*78f0:*/ 0xf0, 0xf4, 0xe7, 0x10, 0x73, 0xc3, 0xe9, 0x5a, 0xe6, 0xed, 0x21, 0x7e, 0x7c, 0xc6, 0x78, 0x00, + /*7900:*/ 0x94, 0x02, 0x42, 0x91, 0xa0, 0x24, 0x71, 0x85, 0x14, 0x97, 0x94, 0xfa, 0x75, 0x84, 0xbc, 0x36, + /*7910:*/ 0xd1, 0x69, 0xb3, 0x13, 0xf2, 0x67, 0x0a, 0xc3, 0xcf, 0xe5, 0x4c, 0x9f, 0x49, 0xc3, 0xc2, 0x35, + /*7920:*/ 0xdf, 0xb2, 0xb5, 0x0e, 0xf6, 0x05, 0x77, 0x6e, 0x5f, 0x84, 0x58, 0x8c, 0x99, 0xee, 0xb4, 0xe7, + /*7930:*/ 0x38, 0xa1, 0xa6, 0x31, 0x62, 0x20, 0x1f, 0x13, 0x4b, 0xc8, 0x44, 0x6b, 0x06, 0x3d, 0xd3, 0x69, + /*7940:*/ 0x89, 0x24, 0xa1, 0xa3, 0x78, 0x1f, 0x0b, 0x49, 0x0b, 0x59, 0xa7, 0x75, 0x02, 0x13, 0x33, 0xe2, + /*7950:*/ 0x5c, 0x20, 0x5b, 0xe5, 0x92, 0x61, 0x7a, 0x82, 0xaf, 0x4a, 0x08, 0x91, 0xc8, 0x1f, 0x66, 0xd5, + /*7960:*/ 0xf8, 0x3b, 0xb3, 0x65, 0xcf, 0xc6, 0x01, 0xfa, 0x32, 0x27, 0xfe, 0xec, 0x0f, 0xbf, 0xd0, 0x99, + /*7970:*/ 0xf5, 0x5b, 0xd0, 0x78, 0xa3, 0x0f, 0x0d, 0xac, 0x12, 0x6c, 0xa5, 0x50, 0xc5, 0x89, 0x32, 0x5e, + /*7980:*/ 0x9f, 0x76, 0xcf, 0x66, 0x81, 0xca, 0xdf, 0x7a, 0x29, 0xf3, 0x1b, 0xe9, 0xfb, 0x53, 0x68, 0x72, + /*7990:*/ 0xdf, 0x88, 0x6a, 0xbb, 0x55, 0x9b, 0xd2, 0x8f, 0xca, 0x84, 0xcd, 0x66, 0x67, 0x37, 0x04, 0x20, + /*79a0:*/ 0x99, 0xb2, 0x70, 0x70, 0x50, 0x93, 0x54, 0x27, 0x7f, 0xe2, 0x9e, 0x9e, 0xaf, 0xe6, 0xd0, 0x4a, + /*79b0:*/ 0x8c, 0x64, 0x3e, 0xfe, 0xb7, 0xbf, 0xdf, 0x0a, 0x86, 0x72, 0xf2, 0x9f, 0x96, 0xdb, 0x13, 0x73, + /*79c0:*/ 0x75, 0xfe, 0x7e, 0xa8, 0xce, 0xa4, 0x24, 0x54, 0xe2, 0x72, 0x76, 0xfa, 0x75, 0x23, 0xd6, 0xa9, + /*79d0:*/ 0x63, 0xf0, 0x5a, 0xdf, 0x80, 0xb7, 0x6d, 0x42, 0x87, 0x7e, 0x53, 0xcf, 0xaa, 0x0b, 0x42, 0x2a, + /*79e0:*/ 0x6f, 0xe9, 0x11, 0xd7, 0xb8, 0xbd, 0x70, 0xe0, 0x0d, 0xdc, 0x2e, 0x3e, 0x83, 0x79, 0x9b, 0x1e, + /*79f0:*/ 0xc9, 0x6b, 0x82, 0x5d, 0x85, 0x61, 0xd1, 0x80, 0xac, 0x64, 0xae, 0x89, 0xc6, 0x8a, 0x24, 0x0b, + /*7a00:*/ 0xc3, 0x24, 0xf9, 0xdb, 0x93, 0xc7, 0xd5, 0x09, 0xae, 0x72, 0xf9, 0x1c, 0x59, 0xd7, 0xa1, 0x45, + /*7a10:*/ 0x41, 0xff, 0xc2, 0xa7, 0x8d, 0x63, 0x9f, 0x6f, 0x84, 0x77, 0x42, 0xa3, 0x8f, 0x8b, 0xba, 0x5b, + /*7a20:*/ 0xdf, 0xc0, 0xad, 0xc8, 0x37, 0x34, 0x11, 0x02, 0xc3, 0xcd, 0xdc, 0x51, 0x98, 0xa2, 0xc8, 0x6e, + /*7a30:*/ 0x45, 0x71, 0xd3, 0x52, 0xa6, 0xdb, 0xa0, 0x5a, 0x9b, 0x5b, 0xe5, 0x2e, 0x6c, 0x94, 0xd6, 0xe8, + /*7a40:*/ 0xd1, 0xcf, 0x3a, 0x9a, 0x92, 0x99, 0x76, 0x71, 0xb7, 0x76, 0x0a, 0x69, 0xbe, 0x76, 0x9a, 0x6f, + /*7a50:*/ 0xa3, 0xc0, 0x30, 0xef, 0x79, 0xf8, 0xc0, 0xd4, 0x01, 0xd5, 0x32, 0x75, 0xfc, 0x94, 0x95, 0x77, + /*7a60:*/ 0x25, 0x93, 0xfa, 0x16, 0x82, 0xac, 0xa7, 0xad, 0x30, 0xd2, 0xfe, 0xed, 0x90, 0x5b, 0xf1, 0xca, + /*7a70:*/ 0x6c, 0x9b, 0x49, 0x5b, 0x63, 0x1c, 0xbd, 0xeb, 0x59, 0x56, 0xd2, 0x48, 0xf0, 0xfb, 0x76, 0xe9, + /*7a80:*/ 0x84, 0xdf, 0xd8, 0xa8, 0x1a, 0x69, 0x09, 0x3c, 0x62, 0x89, 0x15, 0x7c, 0x8b, 0x37, 0x40, 0x6a, + /*7a90:*/ 0x00, 0xc6, 0x8d, 0xe8, 0x34, 0xc1, 0x89, 0xa8, 0x9e, 0xe1, 0x0c, 0x48, 0x63, 0xc0, 0xc2, 0xf7, + /*7aa0:*/ 0x8c, 0xe2, 0xed, 0x3c, 0xaf, 0xbf, 0xef, 0xf9, 0xd8, 0xa0, 0x44, 0xfc, 0x3f, 0xc2, 0x00, 0xa6, + /*7ab0:*/ 0x14, 0xa3, 0xf0, 0xf4, 0xf3, 0x08, 0x21, 0x65, 0xb4, 0xae, 0x40, 0xfd, 0x1f, 0x20, 0xbc, 0x1c, + /*7ac0:*/ 0xa6, 0x61, 0xec, 0x33, 0xa4, 0xa5, 0xd7, 0x47, 0x2b, 0x7a, 0x67, 0x0c, 0xd9, 0xbf, 0x4e, 0xf2, + /*7ad0:*/ 0x08, 0x2f, 0xf0, 0xa3, 0x3b, 0xf3, 0xf0, 0xf9, 0x8d, 0xad, 0x6e, 0x2f, 0x99, 0x65, 0x8d, 0x53, + /*7ae0:*/ 0xe3, 0xec, 0x7f, 0xf2, 0xff, 0x58, 0x38, 0x17, 0xd0, 0xc8, 0xd5, 0xe6, 0x92, 0x75, 0xe9, 0x77, + /*7af0:*/ 0x90, 0x1b, 0xa2, 0xbe, 0x35, 0xc9, 0x39, 0x0c, 0x67, 0x35, 0x9a, 0xb8, 0x7c, 0x6f, 0xe3, 0x46, + /*7b00:*/ 0xc3, 0xa7, 0x83, 0x1e, 0xe1, 0x61, 0x6a, 0x74, 0xcc, 0x1d, 0x57, 0xa4, 0xaa, 0x0c, 0x4b, 0x70, + /*7b10:*/ 0xa0, 0xa3, 0xc9, 0xa0, 0x95, 0xcf, 0xa6, 0xfa, 0x2b, 0x7e, 0x0d, 0x32, 0xe0, 0xdc, 0x23, 0xfc, + /*7b20:*/ 0x61, 0x93, 0xfa, 0xf7, 0x13, 0x26, 0xb0, 0xd8, 0xff, 0xbb, 0xc8, 0xfa, 0xfa, 0x91, 0x31, 0xcf, + /*7b30:*/ 0xcd, 0x54, 0x8c, 0xfc, 0x6d, 0x6b, 0x30, 0x00, 0x11, 0x43, 0x8c, 0xdc, 0x86, 0xf8, 0x11, 0x18, + /*7b40:*/ 0xee, 0xd5, 0xef, 0x9b, 0x79, 0x10, 0xc0, 0x2f, 0x08, 0xaa, 0xe3, 0xc5, 0x53, 0x7e, 0x61, 0xa0, + /*7b50:*/ 0xe2, 0xf0, 0xab, 0x8d, 0x70, 0x51, 0xd6, 0x2c, 0x6a, 0xbb, 0x2b, 0x26, 0x21, 0x61, 0x3f, 0x42, + /*7b60:*/ 0x3b, 0xd9, 0x24, 0x7d, 0xe6, 0x2c, 0x6d, 0xbb, 0xcc, 0xf4, 0x17, 0x12, 0x9e, 0xb0, 0x1e, 0xac, + /*7b70:*/ 0x28, 0xf0, 0xe6, 0x12, 0xf8, 0xde, 0x1f, 0xf4, 0x10, 0x43, 0xcb, 0x1f, 0xb6, 0xb3, 0x93, 0x18, + /*7b80:*/ 0x37, 0x3a, 0xe4, 0xc2, 0x7c, 0xaf, 0x0f, 0xea, 0x9c, 0x41, 0x78, 0x56, 0x46, 0x23, 0xeb, 0xce, + /*7b90:*/ 0x9e, 0x4b, 0xfb, 0x68, 0x3e, 0x68, 0x75, 0xe5, 0xfb, 0x9c, 0xf1, 0x5a, 0xba, 0x50, 0x82, 0x26, + /*7ba0:*/ 0x06, 0x0f, 0xfb, 0x39, 0x04, 0x17, 0x6d, 0x73, 0xa6, 0x7a, 0x57, 0x7b, 0xe7, 0xe3, 0x77, 0x23, + /*7bb0:*/ 0xfa, 0x99, 0x7f, 0x16, 0xa8, 0xbe, 0x80, 0xb1, 0x0d, 0x56, 0xb4, 0x5e, 0xd2, 0x1e, 0x73, 0xc7, + /*7bc0:*/ 0xe8, 0x07, 0xea, 0x35, 0xde, 0xd1, 0xc2, 0x0f, 0x40, 0x05, 0x64, 0x8d, 0x4f, 0x2a, 0xd8, 0x91, + /*7bd0:*/ 0x85, 0xa0, 0xca, 0x88, 0xad, 0xd5, 0xbc, 0x64, 0xcf, 0x62, 0xce, 0x57, 0x3d, 0xc9, 0x08, 0x51, + /*7be0:*/ 0x3f, 0x0c, 0xb1, 0xbf, 0xb3, 0xc0, 0x53, 0xe4, 0xd9, 0x28, 0xc6, 0x5f, 0xd9, 0x23, 0x87, 0x19, + /*7bf0:*/ 0x3b, 0xbc, 0x81, 0x46, 0xbe, 0x15, 0x84, 0x60, 0xc6, 0x9b, 0x8c, 0x50, 0x5f, 0xff, 0x94, 0xd4, + /*7c00:*/ 0x7c, 0xbe, 0x72, 0x2d, 0x08, 0x63, 0xba, 0x21, 0x0a, 0x18, 0x23, 0x06, 0x47, 0x37, 0x74, 0x67, + /*7c10:*/ 0xa4, 0xf1, 0x95, 0xcc, 0x92, 0x9e, 0x36, 0x51, 0xaf, 0xbc, 0x8b, 0x20, 0x0f, 0x88, 0x92, 0x03, + /*7c20:*/ 0xa5, 0xbf, 0x0e, 0xa6, 0x48, 0xb5, 0xc7, 0x73, 0xab, 0x12, 0x3e, 0x24, 0x45, 0xb4, 0x65, 0x35, + /*7c30:*/ 0x7d, 0xb8, 0xb0, 0x0e, 0xc6, 0xb9, 0x66, 0x7f, 0x7a, 0x42, 0x43, 0xf0, 0xf2, 0x5b, 0x07, 0xe1, + /*7c40:*/ 0x4c, 0xb4, 0xc6, 0x3c, 0x67, 0xca, 0x6b, 0xe4, 0x01, 0xd6, 0x4d, 0x55, 0x3b, 0xc8, 0x73, 0x9b, + /*7c50:*/ 0x79, 0x58, 0xee, 0x29, 0x78, 0xe6, 0x7e, 0xf3, 0xc6, 0x60, 0xe0, 0xb6, 0x27, 0xca, 0x6c, 0x49, + /*7c60:*/ 0xb5, 0x36, 0x1d, 0x16, 0x44, 0xc0, 0x17, 0xf0, 0xfe, 0x35, 0xd4, 0x04, 0xb7, 0x4a, 0x0c, 0x41, + /*7c70:*/ 0xe1, 0x71, 0x56, 0x26, 0xfd, 0x92, 0xaa, 0xc5, 0x97, 0x16, 0x55, 0xc6, 0x8c, 0xb3, 0x4b, 0x12, + /*7c80:*/ 0xb9, 0x6f, 0xca, 0x13, 0x41, 0x7c, 0x39, 0x55, 0x23, 0x6a, 0xe0, 0xc8, 0x11, 0x03, 0xb7, 0xf0, + /*7c90:*/ 0x01, 0x7b, 0x90, 0xa0, 0xa4, 0x77, 0xbe, 0x09, 0xa8, 0xcb, 0xd6, 0x24, 0x12, 0x26, 0xc9, 0x4d, + /*7ca0:*/ 0xd3, 0xb0, 0x09, 0x0b, 0x02, 0x1a, 0xbe, 0x7c, 0x0f, 0x24, 0xad, 0xa7, 0xf0, 0x20, 0xaa, 0xae, + /*7cb0:*/ 0xa4, 0x50, 0x0f, 0xe9, 0xfb, 0x54, 0x0e, 0x05, 0x32, 0xc7, 0x14, 0xfe, 0x5f, 0xd7, 0x5b, 0x3d, + /*7cc0:*/ 0x34, 0x72, 0xa7, 0x11, 0xc4, 0x20, 0x6a, 0x26, 0x9a, 0x27, 0x43, 0x11, 0xdd, 0xd4, 0x98, 0xad, + /*7cd0:*/ 0x3c, 0x00, 0x61, 0x33, 0xe7, 0x9f, 0x9b, 0xef, 0xb3, 0xe4, 0x24, 0x09, 0x40, 0x62, 0x84, 0x9d, + /*7ce0:*/ 0x00, 0x00, 0xf9, 0xb9, 0x7a, 0xca, 0x31, 0x0f, 0x3d, 0x6e, 0x28, 0x94, 0x2a, 0xb4, 0x44, 0xd5, + /*7cf0:*/ 0xab, 0x39, 0xf5, 0xf6, 0xe2, 0x90, 0x42, 0x01, 0x04, 0x8f, 0x0e, 0x29, 0xcc, 0xbd, 0x73, 0x3c, + /*7d00:*/ 0x08, 0x60, 0x9a, 0x31, 0x96, 0xb8, 0x1d, 0xcb, 0xcb, 0x30, 0xba, 0xdc, 0x15, 0xec, 0x1c, 0x2d, + /*7d10:*/ 0x72, 0x31, 0x7d, 0x93, 0xf5, 0x4f, 0x67, 0x11, 0x28, 0x09, 0x2d, 0x11, 0xc1, 0x94, 0xee, 0xa3, + /*7d20:*/ 0xac, 0x13, 0xbb, 0xb3, 0x86, 0x00, 0x98, 0xd7, 0x09, 0xc0, 0xd7, 0x7c, 0x56, 0x5b, 0x80, 0x1c, + /*7d30:*/ 0x40, 0x52, 0xc5, 0x99, 0x1e, 0x5f, 0x77, 0x0c, 0x6c, 0x66, 0xe4, 0x5d, 0x92, 0x86, 0xcb, 0x33, + /*7d40:*/ 0x57, 0x64, 0xdf, 0x12, 0xcd, 0x80, 0xf3, 0x49, 0xc2, 0x9e, 0x63, 0xe6, 0xb7, 0xbe, 0x9d, 0x77, + /*7d50:*/ 0xe5, 0xd4, 0xe3, 0xc5, 0x7d, 0x0f, 0x41, 0x33, 0xc7, 0x4d, 0x64, 0x47, 0x23, 0x5a, 0xd1, 0x37, + /*7d60:*/ 0x3f, 0xb9, 0xb8, 0x0a, 0xbf, 0x6f, 0xff, 0xe8, 0x85, 0xae, 0x31, 0x77, 0xf6, 0xc2, 0xbe, 0x0c, + /*7d70:*/ 0x52, 0xdb, 0x9e, 0x63, 0xbd, 0xe5, 0x1a, 0xdc, 0x78, 0x07, 0x46, 0x25, 0x2e, 0x2c, 0xe1, 0xdc, + /*7d80:*/ 0x76, 0x81, 0xd6, 0x5c, 0xf8, 0x81, 0x84, 0xea, 0x30, 0x90, 0xda, 0x6c, 0x5b, 0x55, 0xb4, 0x18, + /*7d90:*/ 0x89, 0x7b, 0xe0, 0x77, 0x6f, 0x9e, 0xfc, 0x88, 0x8f, 0x03, 0xd8, 0xaa, 0x16, 0xb9, 0x44, 0xb1, + /*7da0:*/ 0x4e, 0x3f, 0x60, 0x73, 0xe5, 0xe7, 0x97, 0xe8, 0x37, 0x42, 0x46, 0x92, 0x91, 0xf4, 0x03, 0xff, + /*7db0:*/ 0xdd, 0xed, 0x76, 0xce, 0x37, 0xbd, 0x06, 0xa6, 0x46, 0x97, 0xe0, 0xed, 0x2b, 0xdf, 0x04, 0x5e, + /*7dc0:*/ 0x97, 0x6c, 0x96, 0xee, 0x99, 0x79, 0x33, 0xba, 0x0a, 0x56, 0x4a, 0xa4, 0x8a, 0x2e, 0x4d, 0x94, + /*7dd0:*/ 0xab, 0x2d, 0xf0, 0x34, 0xc1, 0x11, 0xb1, 0xc9, 0x99, 0xfe, 0x6f, 0xf8, 0x70, 0x4e, 0x8f, 0x52, + /*7de0:*/ 0x0d, 0xa5, 0xb4, 0xbb, 0x7e, 0x26, 0x04, 0x80, 0xdc, 0x3d, 0x24, 0xc0, 0x7a, 0x40, 0x0d, 0x89, + /*7df0:*/ 0x9a, 0x0c, 0x12, 0xa7, 0x56, 0x76, 0xb8, 0x3d, 0xac, 0xba, 0xbf, 0x23, 0x81, 0x2c, 0xe9, 0x18, + /*7e00:*/ 0xac, 0x48, 0xbc, 0xaf, 0x78, 0xcd, 0xd2, 0x31, 0x05, 0x9a, 0x75, 0x50, 0x90, 0x48, 0x7a, 0xd0, + /*7e10:*/ 0x87, 0x86, 0x25, 0xaa, 0xd2, 0x41, 0x36, 0x85, 0x77, 0x76, 0x68, 0x06, 0xdf, 0x7b, 0xfa, 0x4f, + /*7e20:*/ 0x1e, 0x99, 0xe4, 0x93, 0x43, 0xde, 0x4a, 0x4c, 0x97, 0xdb, 0x1f, 0x2c, 0xa4, 0x40, 0x02, 0xcd, + /*7e30:*/ 0xf4, 0x85, 0x40, 0xbe, 0x28, 0xa4, 0x10, 0x5c, 0x62, 0x6f, 0x83, 0x9d, 0x5b, 0xbf, 0xec, 0xf6, + /*7e40:*/ 0xb5, 0xec, 0x11, 0x6f, 0x10, 0x10, 0xe9, 0x25, 0x28, 0x05, 0xfa, 0x2d, 0xf8, 0x9f, 0x9e, 0xa5, + /*7e50:*/ 0x0e, 0x9c, 0x7a, 0x27, 0x10, 0xaa, 0x6b, 0x9d, 0xcc, 0x3f, 0x02, 0xdd, 0x62, 0x53, 0x16, 0xfc, + /*7e60:*/ 0x3a, 0x6a, 0x9e, 0x44, 0xfd, 0x02, 0x72, 0x20, 0xd3, 0x86, 0xe4, 0xaf, 0x4e, 0xba, 0x06, 0x97, + /*7e70:*/ 0xc7, 0x7f, 0x53, 0xd5, 0x0d, 0xd3, 0x14, 0xad, 0x58, 0xfc, 0x86, 0x4c, 0x4d, 0x67, 0x54, 0xa2, + /*7e80:*/ 0x6e, 0xbc, 0x6c, 0x46, 0xbf, 0x41, 0xad, 0xf3, 0x8a, 0x1d, 0x82, 0x46, 0xde, 0x33, 0x4c, 0x63, + /*7e90:*/ 0xea, 0x15, 0xad, 0xf4, 0x9e, 0x8e, 0x9f, 0x95, 0xa7, 0x77, 0x02, 0xee, 0x22, 0x7f, 0xfb, 0x62, + /*7ea0:*/ 0x1e, 0x47, 0x4b, 0xb7, 0x60, 0xc7, 0xa4, 0xa6, 0x9a, 0x6c, 0x27, 0x1f, 0x6e, 0x72, 0xb3, 0x91, + /*7eb0:*/ 0x3c, 0x54, 0xf5, 0x78, 0x9c, 0x52, 0x80, 0xb7, 0xc0, 0x60, 0x12, 0xc2, 0x87, 0x41, 0x76, 0xd8, + /*7ec0:*/ 0x5f, 0x34, 0x4b, 0xf5, 0x81, 0x64, 0x81, 0x97, 0xa6, 0x3e, 0x27, 0x7f, 0x79, 0x90, 0xd9, 0xda, + /*7ed0:*/ 0xd4, 0x06, 0xbb, 0x54, 0x37, 0xd2, 0x65, 0x64, 0x70, 0xaa, 0x8d, 0xd0, 0x29, 0x5f, 0xa3, 0x53, + /*7ee0:*/ 0x93, 0xf6, 0x80, 0x35, 0x02, 0x59, 0x7a, 0x66, 0x57, 0xcd, 0x5a, 0xfb, 0xca, 0x1f, 0x5a, 0xdc, + /*7ef0:*/ 0xc8, 0x54, 0xb1, 0xf6, 0xb6, 0x42, 0xe8, 0x2b, 0x24, 0xee, 0x82, 0xe1, 0xf0, 0xf8, 0x51, 0x22, + /*7f00:*/ 0x0c, 0x8b, 0x6b, 0x30, 0xab, 0xb8, 0x54, 0xfe, 0x44, 0x03, 0xd8, 0x17, 0xa7, 0x15, 0xe7, 0xa1, + /*7f10:*/ 0xe6, 0xe4, 0x59, 0x36, 0xfd, 0xd3, 0x49, 0xe3, 0x73, 0x41, 0xa9, 0x30, 0xe4, 0xc5, 0x5b, 0x68, + /*7f20:*/ 0x63, 0x4e, 0xd4, 0x19, 0x3c, 0x1a, 0xf5, 0xde, 0x0a, 0x4f, 0x97, 0x59, 0x3b, 0x3f, 0xb1, 0x66, + /*7f30:*/ 0x9f, 0x0e, 0x56, 0xd8, 0xaf, 0x45, 0x60, 0x79, 0x74, 0xbd, 0x3d, 0xd1, 0xa9, 0x74, 0x4b, 0xa3, + /*7f40:*/ 0xd4, 0xfe, 0x1e, 0xc3, 0x8a, 0x63, 0x2e, 0x13, 0xe3, 0x57, 0xd3, 0xd0, 0x99, 0x17, 0x34, 0xa8, + /*7f50:*/ 0x01, 0x4a, 0xa6, 0x04, 0x77, 0x1f, 0xf0, 0xaa, 0x47, 0xfe, 0x93, 0xcb, 0x04, 0x4d, 0x89, 0x3d, + /*7f60:*/ 0xfc, 0x97, 0xc9, 0x64, 0x64, 0x4d, 0x92, 0x29, 0x88, 0xf4, 0x0c, 0xcc, 0x1b, 0x93, 0xdd, 0xb2, + /*7f70:*/ 0x84, 0x1a, 0x41, 0x88, 0xfa, 0xa5, 0x02, 0xf5, 0x01, 0x0a, 0x53, 0xc3, 0x3d, 0x3c, 0x56, 0x41, + /*7f80:*/ 0xde, 0x46, 0xfd, 0xdb, 0x5f, 0xe7, 0xf9, 0xc7, 0xb7, 0x16, 0x07, 0xd9, 0x60, 0xd6, 0xde, 0xea, + /*7f90:*/ 0x3d, 0xb8, 0xcb, 0xaf, 0x78, 0x2a, 0xeb, 0x60, 0x7e, 0xf4, 0x81, 0x81, 0x0b, 0xa2, 0x3a, 0xdb, + /*7fa0:*/ 0xc0, 0x4f, 0x30, 0x19, 0x37, 0xab, 0xc3, 0x61, 0x6f, 0xeb, 0x89, 0x08, 0x8a, 0xab, 0x5c, 0xb0, + /*7fb0:*/ 0x37, 0x16, 0x05, 0x4b, 0x4f, 0x03, 0x9d, 0x0e, 0x79, 0x88, 0x2c, 0x1b, 0xe7, 0x20, 0x9c, 0xff, + /*7fc0:*/ 0xce, 0x91, 0x6a, 0x6b, 0x73, 0x5a, 0x7b, 0xa0, 0x6a, 0x3e, 0xab, 0xb4, 0x8d, 0x3a, 0xce, 0x53, + /*7fd0:*/ 0x43, 0x57, 0x2f, 0x93, 0xae, 0x51, 0x28, 0xd9, 0xb8, 0x1e, 0x0d, 0x35, 0x6a, 0x22, 0x00, 0x12, + /*7fe0:*/ 0x36, 0x4e, 0xed, 0x2d, 0x98, 0xd1, 0x68, 0xbe, 0x34, 0x81, 0xea, 0x36, 0xab, 0xd2, 0x8c, 0x1a, + /*7ff0:*/ 0xf0, 0x19, 0x85, 0x36, 0x02, 0xff, 0x87, 0x6a, 0x84, 0x20, 0x5a, 0xa0, 0x57, 0xba, 0xa3, 0x04, + /*8000:*/ 0x84, 0x34, 0x21, 0xef, 0xbc, 0x7b, 0xde, 0xec, 0x8c, 0x4b, 0x65, 0x20, 0x4d, 0x3f, 0x2a, 0xae, + /*8010:*/ 0x0c, 0xad, 0x59, 0xce, 0x99, 0x77, 0x05, 0xb8, 0xc8, 0x18, 0xf9, 0xe0, 0xac, 0xcd, 0xbc, 0xfe, + /*8020:*/ 0xa1, 0x37, 0xc5, 0xba, 0xa5, 0xb3, 0xf2, 0x01, 0x81, 0x17, 0x79, 0xa7, 0x22, 0x9d, 0x04, 0x05, + /*8030:*/ 0x8f, 0xf6, 0xc1, 0x74, 0x42, 0xb5, 0xa3, 0x4d, 0x41, 0x5e, 0x98, 0x5e, 0xa7, 0xd3, 0xb0, 0xb5, + /*8040:*/ 0x8d, 0xf9, 0xc8, 0x20, 0x47, 0x50, 0x32, 0x4a, 0x9c, 0x10, 0xe7, 0x8d, 0x1b, 0xcf, 0xd8, 0x75, + /*8050:*/ 0x9d, 0x3d, 0x56, 0x88, 0xe6, 0x9b, 0xa1, 0xf1, 0xd0, 0x74, 0x26, 0x87, 0xfa, 0xab, 0xea, 0x8f, + /*8060:*/ 0xaf, 0x3c, 0x38, 0xd5, 0xe2, 0xe6, 0x05, 0xbd, 0x57, 0x0c, 0x05, 0x80, 0xc3, 0xd7, 0xde, 0x66, + /*8070:*/ 0x14, 0x67, 0x4a, 0x3e, 0x4a, 0xe6, 0xe0, 0x54, 0xfa, 0xce, 0x09, 0x8a, 0x75, 0xd0, 0x87, 0x39, + /*8080:*/ 0xb1, 0xfb, 0x0c, 0x54, 0xed, 0x69, 0x96, 0x68, 0x5c, 0x1b, 0xcf, 0xa3, 0x56, 0xdd, 0x0b, 0x78, + /*8090:*/ 0x9c, 0x5d, 0x7d, 0x9d, 0x05, 0x79, 0x72, 0xb9, 0xa9, 0x6e, 0xd1, 0xfb, 0x0c, 0x28, 0x2b, 0xa9, + /*80a0:*/ 0xf4, 0xb3, 0x41, 0xb1, 0x12, 0xe0, 0xe3, 0xf4, 0xf0, 0x6c, 0x86, 0x50, 0xf0, 0xaf, 0x23, 0x87, + /*80b0:*/ 0x67, 0x91, 0xe2, 0x07, 0x6c, 0x77, 0x16, 0xf9, 0x5f, 0x83, 0x8a, 0x46, 0xb6, 0xe3, 0x02, 0x59, + /*80c0:*/ 0x77, 0xaf, 0x3e, 0x98, 0x33, 0x3f, 0xb6, 0xf4, 0x02, 0x23, 0x50, 0xd8, 0x4b, 0xc9, 0x4e, 0xd9, + /*80d0:*/ 0x00, 0xe9, 0x68, 0x13, 0x44, 0xed, 0x2c, 0x4d, 0xd7, 0x60, 0xb4, 0x69, 0xc6, 0xd4, 0xe7, 0xc6, + /*80e0:*/ 0x57, 0xe4, 0xb0, 0x5d, 0x74, 0x51, 0xb5, 0x09, 0x54, 0x11, 0x58, 0x1b, 0xab, 0xf6, 0x54, 0xfb, + /*80f0:*/ 0xe4, 0xaa, 0x99, 0xb0, 0xc2, 0xa8, 0xc3, 0x2d, 0x52, 0x95, 0x39, 0x51, 0x4b, 0x18, 0x83, 0xe6, + /*8100:*/ 0xfc, 0x55, 0xd5, 0x0a, 0xae, 0x93, 0x70, 0x97, 0x60, 0x65, 0x63, 0x61, 0x72, 0x65, 0x9a, 0xe8, + /*8110:*/ 0x13, 0x86, 0x99, 0x14, 0x75, 0xca, 0xe2, 0x9b, 0x40, 0xaf, 0x63, 0x49, 0x50, 0xfc, 0x1d, 0x9b, + /*8120:*/ 0x2a, 0x26, 0xee, 0xbc, 0x88, 0x78, 0x1d, 0xd8, 0xd6, 0x51, 0x8b, 0x8f, 0x45, 0xf9, 0xe0, 0x4b, + /*8130:*/ 0x29, 0x6a, 0x46, 0xf6, 0x9b, 0x5b, 0x6e, 0x2c, 0x83, 0xbf, 0x03, 0x82, 0x8f, 0xb6, 0xe4, 0x76, + /*8140:*/ 0x6b, 0x70, 0xaf, 0x88, 0x69, 0x6e, 0x82, 0x00, 0x44, 0x71, 0x3d, 0xf3, 0x05, 0x0d, 0xa0, 0x33, + /*8150:*/ 0x92, 0x10, 0x87, 0x70, 0xda, 0x2d, 0x0c, 0x97, 0x41, 0x1f, 0x5c, 0x2f, 0x3d, 0x8b, 0xe8, 0x53, + /*8160:*/ 0xf3, 0x01, 0x1e, 0x79, 0x47, 0x60, 0xf1, 0x72, 0x9e, 0x0d, 0x5d, 0x45, 0x93, 0xb9, 0x5f, 0x57, + /*8170:*/ 0x88, 0xaf, 0x23, 0x27, 0x0e, 0xaa, 0xab, 0x4b, 0x29, 0x37, 0x10, 0xe0, 0x81, 0xd1, 0xd0, 0x4d, + /*8180:*/ 0xdf, 0x72, 0xe9, 0xbb, 0xc2, 0x80, 0x3b, 0x42, 0xc2, 0x61, 0x10, 0xd0, 0x07, 0xb9, 0x0b, 0x05, + /*8190:*/ 0x09, 0xb8, 0xa6, 0x11, 0x92, 0x90, 0x22, 0x73, 0xd2, 0x02, 0xfc, 0x4a, 0x99, 0x28, 0x7e, 0x0a, + /*81a0:*/ 0xa6, 0x24, 0xe8, 0xc4, 0xa2, 0xe0, 0x5c, 0x32, 0x5d, 0x3a, 0xc2, 0xd7, 0x6c, 0x77, 0x9a, 0xa7, + /*81b0:*/ 0x3e, 0xa2, 0x42, 0xd8, 0x14, 0x84, 0x0a, 0x46, 0x0e, 0x0f, 0x94, 0x5f, 0x0e, 0x4c, 0x5a, 0x9a, + /*81c0:*/ 0x75, 0x50, 0x8f, 0xe4, 0x5c, 0xaa, 0xf4, 0x99, 0x29, 0x14, 0x8a, 0xac, 0xd3, 0x5b, 0xcc, 0x87, + /*81d0:*/ 0x03, 0xc2, 0x58, 0xd3, 0x63, 0x09, 0x92, 0x1f, 0xb4, 0x59, 0x5e, 0x5c, 0x5a, 0x03, 0x32, 0x30, + /*81e0:*/ 0x28, 0xb8, 0xdb, 0x8a, 0xdc, 0x93, 0x74, 0xf6, 0xe9, 0x3c, 0xfa, 0x31, 0xef, 0xa7, 0xf4, 0x79, + /*81f0:*/ 0x11, 0x97, 0x4a, 0xbd, 0xa3, 0x95, 0x3e, 0x40, 0x6a, 0x72, 0xe0, 0x7c, 0x2b, 0xe8, 0xa4, 0x0d, + /*8200:*/ 0x01, 0x74, 0x6f, 0x3d, 0x70, 0x89, 0x04, 0x37, 0x1b, 0x1b, 0x05, 0x69, 0x89, 0x9b, 0xa0, 0x48, + /*8210:*/ 0x5b, 0x5f, 0x25, 0x8f, 0xb7, 0xc1, 0xe7, 0xf3, 0x04, 0x3b, 0xf7, 0x18, 0xfe, 0x44, 0xc7, 0x60, + /*8220:*/ 0x6d, 0xae, 0x7d, 0x08, 0xe3, 0x6f, 0xc6, 0x4f, 0x36, 0xe5, 0x86, 0xbc, 0x99, 0x12, 0x1a, 0xb6, + /*8230:*/ 0x06, 0x4c, 0xe6, 0x52, 0xeb, 0x42, 0xfb, 0x66, 0x87, 0x8b, 0x67, 0x0e, 0xac, 0xd5, 0xb8, 0x02, + /*8240:*/ 0x5e, 0xc8, 0xed, 0x80, 0x66, 0x7c, 0x83, 0x0b, 0x85, 0x28, 0x84, 0x2d, 0xbd, 0xfc, 0x2e, 0x13, + /*8250:*/ 0x4a, 0x09, 0x39, 0x52, 0x88, 0xc1, 0xb5, 0xc6, 0x81, 0x56, 0xed, 0xfd, 0xdb, 0x55, 0xa5, 0x57, + /*8260:*/ 0x1a, 0xaa, 0xec, 0x95, 0x96, 0xca, 0x51, 0xfa, 0xd0, 0x88, 0xe8, 0xd2, 0x85, 0x8c, 0xc9, 0x73, + /*8270:*/ 0x98, 0x99, 0xc0, 0x5b, 0xef, 0x4e, 0xe9, 0xd0, 0x25, 0x0b, 0x9d, 0xdd, 0x8a, 0xc3, 0x06, 0x2b, + /*8280:*/ 0x2f, 0x45, 0xb2, 0x7b, 0x2c, 0x49, 0x41, 0xa9, 0x5c, 0xcf, 0x00, 0x6f, 0xbe, 0x9f, 0x9f, 0x3c, + /*8290:*/ 0x10, 0xd7, 0xf1, 0x80, 0x8e, 0x9c, 0x99, 0xb8, 0xc5, 0xee, 0x98, 0x46, 0x49, 0xf3, 0x33, 0xea, + /*82a0:*/ 0x6c, 0xc2, 0x8b, 0x3b, 0x14, 0x45, 0xbd, 0xce, 0x5f, 0x2c, 0xec, 0x88, 0x2f, 0x9d, 0x5d, 0xd5, + /*82b0:*/ 0xee, 0x8f, 0x0d, 0x07, 0xaa, 0x04, 0xdd, 0xaa, 0x2f, 0x80, 0xd8, 0xd3, 0xa2, 0xb1, 0x90, 0xdd, + /*82c0:*/ 0x0b, 0x0e, 0xd8, 0x70, 0x4a, 0x22, 0x8a, 0x49, 0x85, 0xcd, 0xf6, 0x63, 0x14, 0x3a, 0x28, 0x8c, + /*82d0:*/ 0x65, 0x7f, 0x18, 0x90, 0x3d, 0xa2, 0x7d, 0x1c, 0x1f, 0x04, 0xc3, 0xc4, 0xbc, 0x0e, 0xb1, 0x19, + /*82e0:*/ 0xae, 0x35, 0xa7, 0xf7, 0x3f, 0x4d, 0x6a, 0xb5, 0x57, 0x98, 0x44, 0x62, 0x6d, 0xbd, 0x29, 0x5a, + /*82f0:*/ 0x7a, 0x82, 0x40, 0xb9, 0x5d, 0xa2, 0x61, 0x1e, 0xea, 0xff, 0x9a, 0xd7, 0x85, 0x8b, 0x2a, 0x88, + /*8300:*/ 0x6a, 0xbc, 0xdb, 0x16, 0x1b, 0x43, 0x02, 0xbd, 0x36, 0xa1, 0x9e, 0x86, 0x45, 0x15, 0x4b, 0x07, + /*8310:*/ 0xaf, 0x96, 0x11, 0xcb, 0xb7, 0x23, 0xb1, 0xb2, 0xcf, 0x25, 0x99, 0xd5, 0x31, 0xc9, 0xde, 0x7a, + /*8320:*/ 0x7b, 0x74, 0x80, 0x3d, 0xcd, 0x17, 0xab, 0x63, 0xe6, 0x27, 0x17, 0xce, 0x07, 0xb3, 0x12, 0xec, + /*8330:*/ 0x5f, 0x5f, 0xe7, 0xcb, 0x92, 0xb1, 0xe9, 0x58, 0x57, 0x40, 0xb4, 0x43, 0xcb, 0x61, 0x45, 0xd8, + /*8340:*/ 0x15, 0xe3, 0xd9, 0xc1, 0x65, 0x88, 0x33, 0x6b, 0xc5, 0x9d, 0x93, 0x49, 0xd6, 0x95, 0xb5, 0x5a, + /*8350:*/ 0x07, 0xae, 0x98, 0xe8, 0xda, 0x3e, 0x7c, 0x5c, 0x29, 0xfb, 0xd1, 0xbf, 0x2d, 0x45, 0x2f, 0xb2, + /*8360:*/ 0xcc, 0xfd, 0x93, 0xb3, 0x5d, 0x4e, 0x68, 0xce, 0xa7, 0x6b, 0xf5, 0xf4, 0xa8, 0x4c, 0x9f, 0x2f, + /*8370:*/ 0xe4, 0xf6, 0x4a, 0x0d, 0xe8, 0xb1, 0x07, 0xb0, 0x5a, 0xc7, 0x2e, 0xbe, 0x32, 0xc6, 0x84, 0x7b, + /*8380:*/ 0x19, 0xba, 0x32, 0x9d, 0x2b, 0x01, 0x53, 0x5d, 0x91, 0x21, 0x21, 0xed, 0xe7, 0x71, 0xe5, 0xe0, + /*8390:*/ 0xae, 0x15, 0x51, 0xec, 0xfb, 0x4c, 0xe3, 0x35, 0xa3, 0x04, 0x70, 0x22, 0x26, 0x38, 0xa8, 0x3d, + /*83a0:*/ 0x41, 0x39, 0xc0, 0x87, 0xc3, 0x33, 0x8a, 0x3a, 0x73, 0xb4, 0x20, 0x99, 0x3d, 0xe8, 0xbd, 0x19, + /*83b0:*/ 0xa7, 0xa2, 0x06, 0xb1, 0xd7, 0xa4, 0x09, 0x04, 0xfa, 0x48, 0xa6, 0xd0, 0xa9, 0xbb, 0xeb, 0x42, + /*83c0:*/ 0x33, 0xf9, 0x10, 0x6e, 0xda, 0x32, 0x8e, 0x31, 0x71, 0xfb, 0x91, 0x8a, 0x3b, 0xe2, 0x27, 0x4d, + /*83d0:*/ 0xb2, 0x5d, 0x40, 0x1c, 0x3b, 0xf2, 0xb8, 0x30, 0x90, 0x59, 0xe4, 0xa3, 0xa7, 0x80, 0x89, 0xbb, + /*83e0:*/ 0xaa, 0x6a, 0x85, 0x9e, 0x93, 0x92, 0xe0, 0x72, 0x2f, 0x32, 0x49, 0xa9, 0x91, 0x72, 0xc8, 0xf7, + /*83f0:*/ 0x06, 0x28, 0x9d, 0x81, 0xb1, 0x2a, 0x25, 0x60, 0x45, 0x83, 0xec, 0x2b, 0x7e, 0x4b, 0x4c, 0xc9, + /*8400:*/ 0x68, 0x27, 0xc6, 0x76, 0x9d, 0x4b, 0x7f, 0x22, 0x5e, 0x29, 0xad, 0x2f, 0x4c, 0xf2, 0x40, 0xea, + /*8410:*/ 0x27, 0x0f, 0xed, 0xb4, 0x65, 0x07, 0x05, 0x8d, 0x12, 0x5f, 0x71, 0x2d, 0x75, 0x6d, 0x3f, 0xef, + /*8420:*/ 0xd0, 0xd5, 0xd8, 0x3e, 0x54, 0x85, 0xc1, 0x50, 0xd3, 0x56, 0x39, 0xd1, 0x10, 0x84, 0x2d, 0xbb, + /*8430:*/ 0x7c, 0xd4, 0x6a, 0x49, 0x40, 0xc6, 0xdd, 0xb3, 0xd5, 0x80, 0x58, 0x0b, 0xa2, 0x98, 0x34, 0xbc, + /*8440:*/ 0xf6, 0x31, 0xde, 0xa7, 0xed, 0x6e, 0xc0, 0x74, 0x33, 0x9f, 0x25, 0x8f, 0xf1, 0xf2, 0x27, 0x95, + /*8450:*/ 0xe3, 0x25, 0xe4, 0x3d, 0x28, 0x05, 0xe7, 0x68, 0x8e, 0xdf, 0xbe, 0x45, 0xe4, 0x11, 0x71, 0x19, + /*8460:*/ 0x6d, 0x34, 0xd6, 0x56, 0x52, 0x04, 0xaf, 0x5d, 0x4e, 0x22, 0x22, 0x98, 0xd3, 0x52, 0x26, 0xf4, + /*8470:*/ 0xd1, 0x73, 0xa1, 0x97, 0xa0, 0x3c, 0xef, 0xfa, 0x80, 0x7a, 0xe4, 0x1d, 0xe8, 0x53, 0x04, 0x19, + /*8480:*/ 0x4d, 0x65, 0x55, 0xf4, 0xf2, 0x55, 0x94, 0xf6, 0xcb, 0x1e, 0xfe, 0x91, 0x42, 0x83, 0xa7, 0x5a, + /*8490:*/ 0x8d, 0x81, 0xba, 0xd6, 0xaa, 0x4c, 0xb8, 0xfd, 0x36, 0xfc, 0x0e, 0x42, 0xe3, 0xd4, 0xdf, 0xfc, + /*84a0:*/ 0xb3, 0x71, 0x22, 0x91, 0xe5, 0xea, 0xce, 0xa0, 0xb7, 0xfb, 0x03, 0x19, 0xa7, 0x0a, 0xb0, 0xf5, + /*84b0:*/ 0x26, 0xfe, 0x01, 0xe9, 0x05, 0xc4, 0x09, 0x61, 0xb5, 0x29, 0x07, 0xcb, 0xce, 0x14, 0x7d, 0x49, + /*84c0:*/ 0xfd, 0xe1, 0x91, 0x10, 0x62, 0x0d, 0xf8, 0x37, 0x8f, 0xed, 0xf2, 0x5e, 0x31, 0x6e, 0x80, 0xeb, + /*84d0:*/ 0x08, 0x10, 0x7c, 0x07, 0x61, 0x7e, 0xd2, 0xf4, 0xfc, 0xc8, 0xf1, 0x88, 0xdb, 0x02, 0xe5, 0xa8, + /*84e0:*/ 0x63, 0x91, 0x43, 0x24, 0x77, 0x61, 0x05, 0x56, 0x73, 0xfa, 0x9c, 0x50, 0x9c, 0x93, 0x75, 0x5b, + /*84f0:*/ 0xb2, 0x6c, 0xec, 0x9d, 0x7d, 0x33, 0x1d, 0xb4, 0xa8, 0x1c, 0xc8, 0x4d, 0x9b, 0xde, 0xa8, 0x9e, + /*8500:*/ 0x6d, 0xef, 0x92, 0xd5, 0x2f, 0xdf, 0x14, 0xc3, 0xa0, 0xd7, 0x42, 0x31, 0xec, 0xc9, 0x1e, 0x63, + /*8510:*/ 0x99, 0x1e, 0xd7, 0xce, 0xaf, 0x03, 0xd8, 0x59, 0x74, 0xa3, 0x50, 0xd9, 0x5b, 0x38, 0xc8, 0xbe, + /*8520:*/ 0xa0, 0xfd, 0xa9, 0x08, 0x97, 0xf3, 0x58, 0x28, 0xa7, 0xc3, 0x3c, 0x92, 0x99, 0x45, 0x13, 0xfd, + /*8530:*/ 0xae, 0xb3, 0xe9, 0x27, 0xa6, 0xa2, 0x9c, 0x81, 0x8f, 0x78, 0x1d, 0x8a, 0x26, 0x73, 0x04, 0x67, + /*8540:*/ 0xbd, 0xe8, 0x02, 0xb2, 0x69, 0xf4, 0x6b, 0xad, 0xd8, 0xd8, 0x34, 0x5e, 0xff, 0xb3, 0xbe, 0x82, + /*8550:*/ 0xd4, 0xde, 0x4c, 0xd1, 0x83, 0xc9, 0x94, 0x12, 0xfe, 0x7d, 0x15, 0xd1, 0x70, 0x75, 0x2c, 0x1b, + /*8560:*/ 0xd6, 0x5b, 0x0e, 0x96, 0x8d, 0xf4, 0x29, 0x61, 0xca, 0x50, 0xe4, 0x00, 0xa5, 0x56, 0x4f, 0xf8, + /*8570:*/ 0xcb, 0xef, 0xe8, 0x56, 0x77, 0x99, 0x28, 0x91, 0x05, 0xb8, 0xc2, 0x70, 0xaf, 0x0a, 0x55, 0x02, + /*8580:*/ 0xa1, 0x1f, 0x38, 0x04, 0x2e, 0xc5, 0x69, 0xbe, 0xca, 0xa2, 0x15, 0x08, 0x71, 0xe4, 0x90, 0xed, + /*8590:*/ 0x5c, 0x54, 0x54, 0x72, 0x6f, 0x42, 0x75, 0x7e, 0xc7, 0x87, 0x23, 0xce, 0x3b, 0xc8, 0xe1, 0x2f, + /*85a0:*/ 0xc8, 0x18, 0xf8, 0x13, 0x52, 0xbf, 0x6f, 0x2b, 0xae, 0x40, 0x3a, 0x3e, 0x51, 0x59, 0x44, 0xd1, + /*85b0:*/ 0xca, 0x6f, 0x40, 0x7e, 0xaa, 0x2f, 0x3e, 0xc2, 0xa8, 0x6d, 0xb6, 0x7b, 0xc4, 0xcd, 0xec, 0xd4, + /*85c0:*/ 0x6d, 0x3e, 0x8e, 0x17, 0x9c, 0x08, 0x97, 0xe6, 0x07, 0x70, 0x93, 0xe0, 0xf3, 0x33, 0xa2, 0x17, + /*85d0:*/ 0x1c, 0x3d, 0x67, 0x8f, 0xdc, 0x9e, 0x6a, 0x9c, 0x1d, 0xb4, 0x1d, 0x0d, 0x62, 0x63, 0xd8, 0x34, + /*85e0:*/ 0xd0, 0xb9, 0x84, 0x72, 0xa9, 0xef, 0x53, 0x6d, 0x0b, 0xc3, 0xd7, 0xe4, 0x4d, 0x66, 0x14, 0x1c, + /*85f0:*/ 0x86, 0x4b, 0x41, 0xa5, 0x61, 0x42, 0x50, 0xa1, 0x70, 0xe9, 0x6e, 0xf1, 0x01, 0xfd, 0x1a, 0x92, + /*8600:*/ 0x8a, 0x68, 0xf6, 0x21, 0x27, 0x77, 0xb6, 0x35, 0x41, 0xd4, 0xd9, 0x01, 0xcc, 0x5f, 0x23, 0x82, + /*8610:*/ 0xc5, 0xca, 0x09, 0x4e, 0x67, 0x10, 0xfa, 0x7c, 0xcb, 0xde, 0x53, 0x53, 0xe2, 0x3c, 0x0f, 0x65, + /*8620:*/ 0x08, 0x4b, 0x8c, 0x5b, 0xd0, 0x36, 0xce, 0x2c, 0x90, 0x03, 0x0b, 0x7c, 0x02, 0x84, 0x02, 0x97, + /*8630:*/ 0xb0, 0xcd, 0xbe, 0xa1, 0x44, 0x0e, 0x56, 0x0e, 0xe9, 0x72, 0xc1, 0xd8, 0xd4, 0x25, 0xac, 0xfb, + /*8640:*/ 0x04, 0xe3, 0xba, 0x9a, 0x11, 0x4a, 0x16, 0x83, 0xdd, 0xcf, 0x77, 0x9e, 0xe7, 0x2d, 0xf4, 0xfd, + /*8650:*/ 0xa1, 0x70, 0xac, 0xc6, 0xb8, 0x8e, 0x40, 0xdc, 0x6b, 0x1a, 0x9e, 0x09, 0x4b, 0x6b, 0xed, 0xbd, + /*8660:*/ 0xb8, 0xc5, 0x50, 0x59, 0x7f, 0x71, 0x67, 0xbb, 0xac, 0x74, 0x06, 0xa6, 0x2b, 0x2b, 0x6f, 0xb9, + /*8670:*/ 0x92, 0xdb, 0xac, 0x6e, 0x88, 0x56, 0x80, 0x7c, 0xcd, 0x6f, 0x01, 0x5c, 0xa8, 0x10, 0x66, 0xe1, + /*8680:*/ 0x4e, 0x28, 0x32, 0xd4, 0xf0, 0x1f, 0x71, 0x3b, 0xcb, 0x80, 0x86, 0x00, 0xe5, 0x85, 0xd5, 0xf6, + /*8690:*/ 0x69, 0x62, 0xbf, 0x3a, 0x52, 0x6e, 0xcd, 0x21, 0xde, 0x16, 0xe2, 0x6b, 0x64, 0x0e, 0xae, 0x4e, + /*86a0:*/ 0xf3, 0xaa, 0xb4, 0xbe, 0xc7, 0xd0, 0xe1, 0xc4, 0x41, 0xf0, 0xaa, 0x83, 0xf3, 0xfa, 0x36, 0x97, + /*86b0:*/ 0x10, 0x36, 0x9a, 0xad, 0xd4, 0x61, 0xf2, 0x19, 0x0e, 0xce, 0xa5, 0x31, 0x24, 0x69, 0xf2, 0xde, + /*86c0:*/ 0xb7, 0x90, 0xd1, 0x0b, 0x2b, 0xc7, 0x16, 0x95, 0xf2, 0xa9, 0x54, 0x59, 0x8c, 0x03, 0x66, 0xb5, + /*86d0:*/ 0xf4, 0x5c, 0x10, 0x9c, 0xae, 0x19, 0xdd, 0x81, 0xbf, 0x82, 0x6b, 0x3d, 0xf2, 0x52, 0xe3, 0xb4, + /*86e0:*/ 0x59, 0x3e, 0x9b, 0x5f, 0x6a, 0x49, 0xa7, 0xb9, 0x5b, 0xae, 0xd7, 0xc0, 0x9f, 0xd5, 0x73, 0x7c, + /*86f0:*/ 0x9f, 0xba, 0xcc, 0x8f, 0x8a, 0x87, 0x91, 0xac, 0x5e, 0x24, 0x89, 0xe6, 0x8c, 0x7a, 0x61, 0x04, + /*8700:*/ 0x0d, 0xd0, 0x28, 0x83, 0xe0, 0x78, 0x7c, 0x7c, 0x97, 0xf6, 0x8c, 0x24, 0x56, 0x47, 0xb3, 0x6e, + /*8710:*/ 0xcb, 0xd3, 0x5c, 0x36, 0xb2, 0xe9, 0x2c, 0x6b, 0xae, 0xf8, 0x09, 0xb2, 0x1c, 0xa9, 0x5b, 0xbc, + /*8720:*/ 0xde, 0x9b, 0x8b, 0xcc, 0xc3, 0x05, 0x3d, 0xb9, 0x3d, 0x7b, 0xba, 0xd3, 0xb0, 0x89, 0xfc, 0xb4, + /*8730:*/ 0x0a, 0x90, 0x19, 0x7d, 0x96, 0x67, 0x0f, 0x0f, 0x1b, 0x0f, 0x7c, 0xef, 0xed, 0x9f, 0x5f, 0x4e, + /*8740:*/ 0x27, 0x5e, 0x64, 0xd9, 0xc5, 0xd8, 0xe8, 0x70, 0xfc, 0xe0, 0xca, 0x69, 0x16, 0x4a, 0xae, 0x0d, + /*8750:*/ 0x53, 0x2f, 0x1b, 0x51, 0x0e, 0x4c, 0xcc, 0x4d, 0x5c, 0x43, 0x63, 0x0a, 0x69, 0x10, 0x5a, 0xe9, + /*8760:*/ 0x90, 0x93, 0xd0, 0x14, 0xc8, 0x36, 0x30, 0xce, 0xfa, 0x29, 0x88, 0xa8, 0x19, 0xff, 0x32, 0x9c, + /*8770:*/ 0xbf, 0xa0, 0xc3, 0x09, 0x7d, 0x6a, 0xb0, 0xbd, 0x42, 0x6f, 0xdd, 0x59, 0x6b, 0xe7, 0xae, 0x05, + /*8780:*/ 0x7b, 0xcd, 0x9e, 0xeb, 0xcd, 0xf5, 0x4c, 0x19, 0xce, 0xc3, 0x6f, 0x1c, 0x66, 0x55, 0x9b, 0x17, + /*8790:*/ 0xd5, 0x5b, 0xaf, 0xa9, 0x84, 0xf6, 0x80, 0xfd, 0x6f, 0x3e, 0xc1, 0x8e, 0x7b, 0x05, 0x8c, 0x63, + /*87a0:*/ 0xf3, 0xb8, 0x7e, 0x91, 0x1c, 0x26, 0x25, 0x96, 0xf9, 0xab, 0xce, 0x80, 0xba, 0x61, 0x03, 0xd9, + /*87b0:*/ 0xb8, 0x72, 0x4b, 0x40, 0xea, 0x4b, 0x8c, 0x2d, 0x83, 0x70, 0x50, 0x5f, 0x42, 0x6f, 0x0d, 0xdf, + /*87c0:*/ 0xa4, 0xdc, 0x3d, 0x01, 0x51, 0x5f, 0x94, 0x0e, 0x7f, 0xc0, 0x2e, 0xa1, 0xe2, 0x5b, 0x99, 0xf5, + /*87d0:*/ 0x32, 0xad, 0x9a, 0x2f, 0x7c, 0xcd, 0x09, 0xb4, 0x71, 0x3b, 0x2e, 0xba, 0xbd, 0xf8, 0xce, 0xba, + /*87e0:*/ 0x34, 0x93, 0xd6, 0x2d, 0x35, 0xac, 0x33, 0x99, 0x3a, 0x1a, 0x94, 0xf6, 0x9a, 0x59, 0xf0, 0xcc, + /*87f0:*/ 0xe5, 0x46, 0xde, 0xfb, 0x31, 0x7f, 0x0c, 0x95, 0x66, 0x2c, 0xc2, 0x84, 0x00, 0xf6, 0x12, 0xfa, + /*8800:*/ 0xb8, 0xbd, 0x24, 0xd3, 0xdd, 0x4d, 0xfc, 0xc9, 0x38, 0xfe, 0x14, 0xd4, 0xb6, 0xe2, 0xc3, 0x2a, + /*8810:*/ 0x3f, 0xc3, 0x7e, 0x66, 0x30, 0x4b, 0x3a, 0x14, 0x3d, 0xbb, 0x6f, 0x30, 0x3f, 0xce, 0x27, 0xc4, + /*8820:*/ 0xd2, 0xc0, 0x60, 0x41, 0x86, 0x83, 0x11, 0x0c, 0x7e, 0x1a, 0x16, 0xca, 0xb9, 0x44, 0xde, 0xbe, + /*8830:*/ 0x84, 0xac, 0x43, 0x67, 0x49, 0x07, 0xb4, 0xc9, 0x75, 0x19, 0xf1, 0x70, 0x95, 0xfb, 0x06, 0x73, + /*8840:*/ 0x3d, 0x0a, 0x5b, 0x66, 0x13, 0x7c, 0x0e, 0x10, 0x62, 0x26, 0x30, 0x26, 0x3e, 0xd7, 0x27, 0x57, + /*8850:*/ 0xd3, 0xd4, 0x83, 0x31, 0x42, 0xcd, 0x95, 0xcf, 0xbd, 0xf7, 0x46, 0x36, 0x93, 0x91, 0xfc, 0x36, + /*8860:*/ 0x34, 0x4b, 0xb8, 0x3a, 0x20, 0xcb, 0x4d, 0x91, 0x78, 0x9e, 0xa7, 0xb4, 0x1a, 0xe4, 0xe2, 0x4a, + /*8870:*/ 0x1a, 0xee, 0x39, 0x3a, 0x39, 0xac, 0xa0, 0x4d, 0x12, 0xdf, 0xe6, 0xad, 0xdc, 0xf3, 0x71, 0xa7, + /*8880:*/ 0xcb, 0x34, 0xc8, 0xd2, 0xc8, 0x35, 0x82, 0x2a, 0xef, 0x42, 0x32, 0x8a, 0x6c, 0x57, 0xbc, 0xb5, + /*8890:*/ 0xd4, 0x8f, 0xca, 0x10, 0x5a, 0x4e, 0x41, 0xc1, 0x1c, 0x50, 0x3a, 0xca, 0x62, 0x95, 0x6b, 0x29, + /*88a0:*/ 0x25, 0xbb, 0xfd, 0xc3, 0xbe, 0x2b, 0xce, 0xf6, 0x83, 0xd5, 0xfa, 0x26, 0x30, 0xfa, 0x36, 0xa9, + /*88b0:*/ 0xe7, 0x26, 0x4e, 0x95, 0xbb, 0x73, 0xbe, 0x56, 0xc6, 0x26, 0xb4, 0xa7, 0x60, 0x27, 0x19, 0x8f, + /*88c0:*/ 0x1d, 0x49, 0xe2, 0xfd, 0x99, 0xce, 0xb1, 0x75, 0x20, 0x34, 0xcf, 0x55, 0xa1, 0xab, 0x4b, 0x4b, + /*88d0:*/ 0x89, 0x8b, 0x5e, 0x24, 0xe6, 0x8f, 0xbe, 0x6a, 0xfb, 0x23, 0x9b, 0x52, 0xe2, 0xcd, 0x37, 0xb8, + /*88e0:*/ 0xa1, 0xc3, 0xf6, 0x6b, 0xb8, 0x11, 0x33, 0x1f, 0xa6, 0xd2, 0xed, 0x54, 0x0c, 0xce, 0xba, 0xe2, + /*88f0:*/ 0x20, 0xb6, 0xca, 0x6d, 0x69, 0xde, 0xc6, 0x7e, 0xa4, 0xd0, 0xbb, 0xb3, 0x31, 0x81, 0xc7, 0x17, + /*8900:*/ 0x07, 0x76, 0xc3, 0x72, 0xaf, 0x66, 0x3c, 0x9f, 0x9b, 0x95, 0x51, 0xdc, 0x94, 0xbf, 0xd0, 0x84, + /*8910:*/ 0xb8, 0x7c, 0x88, 0xda, 0x3d, 0x2b, 0x15, 0x20, 0xb7, 0x26, 0x9d, 0x3f, 0xd0, 0x5c, 0x10, 0x26, + /*8920:*/ 0x42, 0x4a, 0xfc, 0x1f, 0xf9, 0xe3, 0x25, 0x1b, 0xe2, 0x4e, 0x35, 0x76, 0xdf, 0x4c, 0xcc, 0x7e, + /*8930:*/ 0x13, 0x46, 0x8d, 0x40, 0xdf, 0xa4, 0xbd, 0x71, 0x6d, 0xa3, 0x8b, 0x0b, 0x2c, 0x31, 0x8c, 0xbd, + /*8940:*/ 0x5e, 0x3c, 0x19, 0x0b, 0x2b, 0x59, 0x9d, 0xb2, 0x7f, 0xb7, 0xe1, 0xe4, 0x42, 0x9a, 0x20, 0xcd, + /*8950:*/ 0x9e, 0x49, 0x9b, 0x4e, 0x3f, 0xca, 0xc3, 0x45, 0x23, 0xd3, 0x56, 0xd8, 0xe9, 0x83, 0xae, 0x53, + /*8960:*/ 0x7e, 0x53, 0x83, 0x37, 0xa0, 0x03, 0x06, 0x26, 0x7b, 0x4d, 0x87, 0x50, 0x48, 0xab, 0x50, 0x7b, + /*8970:*/ 0x5b, 0x91, 0x69, 0xeb, 0xbc, 0xce, 0x22, 0x12, 0x36, 0xbc, 0x36, 0xb1, 0xde, 0xf3, 0x92, 0xce, + /*8980:*/ 0x8e, 0x4b, 0x5c, 0xdc, 0xa5, 0x46, 0xab, 0x1d, 0x60, 0x0b, 0xf2, 0x2b, 0xbe, 0xf4, 0xa5, 0xa2, + /*8990:*/ 0x69, 0xf1, 0x7e, 0x5f, 0x53, 0x28, 0xd9, 0xec, 0xb7, 0xf5, 0x8b, 0x9d, 0x87, 0x18, 0xac, 0x7c, + /*89a0:*/ 0x33, 0x1e, 0x8b, 0xfc, 0x77, 0x4c, 0xae, 0xbc, 0x33, 0xae, 0x25, 0xa0, 0x7a, 0x91, 0xd3, 0x22, + /*89b0:*/ 0xc4, 0xbf, 0x18, 0xb3, 0xa3, 0x6a, 0x79, 0x22, 0xb5, 0x07, 0x30, 0xd8, 0x71, 0x79, 0xf7, 0xd2, + /*89c0:*/ 0x35, 0xab, 0x51, 0xce, 0x51, 0xcb, 0xd6, 0x22, 0x61, 0xf8, 0x92, 0xe7, 0xeb, 0xb0, 0x15, 0x9a, + /*89d0:*/ 0xb4, 0x6f, 0x5c, 0x9c, 0x0f, 0xad, 0x41, 0x61, 0xbe, 0xbd, 0x0e, 0xc4, 0xb0, 0x15, 0x34, 0xc4, + /*89e0:*/ 0xf7, 0x8c, 0xf0, 0x26, 0xbe, 0x7f, 0x99, 0xd0, 0x04, 0x5a, 0x90, 0x9d, 0x16, 0xe8, 0x93, 0x8a, + /*89f0:*/ 0x39, 0xb0, 0x2c, 0xfa, 0x03, 0x78, 0xb3, 0x2e, 0x5d, 0x06, 0x6a, 0x21, 0x3b, 0x8a, 0x7a, 0x22, + /*8a00:*/ 0x10, 0x70, 0x82, 0x1c, 0x69, 0x88, 0x89, 0x51, 0x11, 0x43, 0x7c, 0x9c, 0x3e, 0xcd, 0x7e, 0x7a, + /*8a10:*/ 0x99, 0xb4, 0x1c, 0xf3, 0xd8, 0xd3, 0x1b, 0xfa, 0x9d, 0xec, 0xd4, 0x36, 0xcc, 0xac, 0x5e, 0xc3, + /*8a20:*/ 0xd9, 0x45, 0x7b, 0xc6, 0x7b, 0x1d, 0xfe, 0xa5, 0xac, 0xb9, 0x22, 0xe0, 0x18, 0xc0, 0x1d, 0x04, + /*8a30:*/ 0xfe, 0x9a, 0xb9, 0xc8, 0x40, 0xa2, 0xcc, 0x3e, 0xb4, 0x81, 0xfe, 0x0f, 0xf8, 0xc4, 0xe0, 0x89, + /*8a40:*/ 0xfc, 0xfd, 0x93, 0x2d, 0xd0, 0x00, 0x52, 0x70, 0x5a, 0x95, 0x41, 0x4e, 0xbd, 0xd3, 0x76, 0x2b, + /*8a50:*/ 0xa4, 0xa3, 0x56, 0x22, 0x50, 0x6d, 0xc2, 0xd2, 0x59, 0xea, 0xe8, 0x32, 0x9c, 0x84, 0xdc, 0x93, + /*8a60:*/ 0xad, 0xdb, 0xaf, 0xba, 0xb3, 0x0e, 0x38, 0x0a, 0xac, 0xde, 0xe7, 0xff, 0x87, 0xcd, 0x9b, 0x80, + /*8a70:*/ 0xea, 0x72, 0x10, 0x66, 0xff, 0x63, 0x7f, 0xe6, 0x33, 0x88, 0xd2, 0xc0, 0xdc, 0xd6, 0xcb, 0xe6, + /*8a80:*/ 0xcb, 0x37, 0x70, 0x74, 0x72, 0x26, 0xac, 0x73, 0xbf, 0x1d, 0x6f, 0x75, 0x6c, 0xe5, 0xb5, 0x37, + /*8a90:*/ 0x4e, 0xc3, 0x85, 0x58, 0x79, 0x2a, 0x21, 0x51, 0xe1, 0x16, 0x00, 0x31, 0x75, 0x0e, 0x79, 0x5e, + /*8aa0:*/ 0x3d, 0x84, 0x19, 0x22, 0x2b, 0x97, 0x4a, 0x59, 0x2b, 0xa0, 0x79, 0x53, 0x45, 0x34, 0x35, 0x2f, + /*8ab0:*/ 0x8a, 0xfd, 0x64, 0xf2, 0x0b, 0xb5, 0xe4, 0xb9, 0x73, 0xe9, 0xee, 0x47, 0xb0, 0x51, 0x5a, 0x5f, + /*8ac0:*/ 0xf9, 0x2a, 0xe1, 0xd5, 0x5a, 0xee, 0x67, 0xaf, 0xb5, 0xfa, 0x28, 0x8a, 0xec, 0xec, 0x5f, 0x38, + /*8ad0:*/ 0x4a, 0xdb, 0x0e, 0x1a, 0xbd, 0x57, 0x09, 0xcc, 0x02, 0x09, 0xa4, 0x1f, 0xe1, 0x5b, 0x4d, 0x80, + /*8ae0:*/ 0xb0, 0x85, 0x97, 0xbb, 0x7e, 0x3e, 0x14, 0x18, 0xe6, 0xc8, 0x84, 0x57, 0x88, 0x3c, 0xe8, 0x09, + /*8af0:*/ 0x91, 0x93, 0xda, 0x5a, 0x77, 0x9a, 0x23, 0x77, 0x18, 0x1c, 0x16, 0xb8, 0x22, 0xf6, 0xc5, 0x73, + /*8b00:*/ 0xc3, 0xc4, 0x44, 0x4b, 0x8b, 0xa5, 0x4f, 0xdc, 0xa1, 0x65, 0xc1, 0x99, 0xfb, 0x97, 0xf8, 0x4f, + /*8b10:*/ 0xe9, 0xd0, 0xc4, 0x66, 0xd4, 0xed, 0x3e, 0x58, 0x8d, 0x6c, 0x09, 0xe7, 0xad, 0xde, 0x66, 0xa6, + /*8b20:*/ 0x82, 0xfc, 0xc2, 0xf8, 0x04, 0x6f, 0x5c, 0x6a, 0xeb, 0x96, 0x85, 0x28, 0x03, 0xc7, 0x3f, 0xa7, + /*8b30:*/ 0x31, 0x75, 0x71, 0x56, 0x8d, 0x98, 0x0d, 0x08, 0x21, 0x1f, 0x59, 0x0c, 0x99, 0x72, 0x6a, 0xa4, + /*8b40:*/ 0xa7, 0x6f, 0x34, 0x70, 0x5e, 0x5a, 0xb5, 0x73, 0x01, 0xcb, 0xea, 0xa9, 0x59, 0x14, 0xa1, 0xfb, + /*8b50:*/ 0xda, 0x5d, 0x7d, 0x22, 0x35, 0x83, 0xd1, 0x16, 0x8a, 0x15, 0x2f, 0x4a, 0xb8, 0xfa, 0xf6, 0x6f, + /*8b60:*/ 0x92, 0x64, 0xbb, 0x32, 0xcb, 0x56, 0xd8, 0xec, 0xda, 0xec, 0xb7, 0x52, 0x77, 0x90, 0x36, 0x29, + /*8b70:*/ 0x65, 0x47, 0xdc, 0xc8, 0x31, 0x6b, 0xa5, 0xff, 0xf3, 0x00, 0x8d, 0x49, 0xb5, 0x70, 0xa7, 0x48, + /*8b80:*/ 0x53, 0x05, 0x6b, 0x0f, 0x49, 0x50, 0xb2, 0xdb, 0x8d, 0x77, 0x6d, 0x45, 0x03, 0xc4, 0x5a, 0xc0, + /*8b90:*/ 0x1f, 0x1d, 0x0f, 0x13, 0xc3, 0x7d, 0x0f, 0x75, 0xfc, 0xc5, 0xf1, 0x73, 0xcc, 0x14, 0x97, 0xc3, + /*8ba0:*/ 0x87, 0x45, 0xc7, 0x9e, 0xd5, 0x6b, 0x9b, 0x84, 0xd4, 0x00, 0x77, 0x0f, 0x67, 0xb1, 0x2c, 0xc8, + /*8bb0:*/ 0xdc, 0xa5, 0x13, 0xb0, 0x61, 0x61, 0x2b, 0x9c, 0xda, 0x51, 0xad, 0xfc, 0x49, 0x05, 0xc0, 0x47, + /*8bc0:*/ 0xb2, 0x43, 0x1c, 0x54, 0x47, 0xd4, 0xfb, 0x5a, 0xb3, 0x95, 0xda, 0xee, 0x0b, 0x0a, 0x4a, 0x94, + /*8bd0:*/ 0x4d, 0x3d, 0xdf, 0xf0, 0xb3, 0xb0, 0xb8, 0x60, 0xf7, 0x80, 0x97, 0xa8, 0xea, 0xdf, 0xde, 0x5e, + /*8be0:*/ 0x61, 0xff, 0x2a, 0x17, 0x6d, 0xfe, 0x53, 0x98, 0x4e, 0x2c, 0x22, 0x09, 0xc7, 0x09, 0x5b, 0xa0, + /*8bf0:*/ 0x2f, 0x90, 0xce, 0xb8, 0x70, 0xf1, 0xb2, 0x7c, 0xa0, 0x91, 0x8d, 0x9b, 0x26, 0x1a, 0x5c, 0x5b, + /*8c00:*/ 0xbc, 0x3d, 0xa8, 0xbb, 0x47, 0xde, 0x20, 0x1c, 0x22, 0xb7, 0xdf, 0xdf, 0x04, 0x5e, 0x97, 0xf7, + /*8c10:*/ 0xa7, 0xbb, 0x2e, 0x78, 0x62, 0xe9, 0xad, 0x73, 0x60, 0x37, 0x8d, 0x2c, 0x5d, 0x3e, 0xe3, 0x40, + /*8c20:*/ 0xdd, 0xb4, 0xc6, 0x1d, 0xe4, 0x8c, 0x79, 0x12, 0x3e, 0xe2, 0x38, 0x2e, 0xd4, 0xec, 0xcc, 0xeb, + /*8c30:*/ 0xe4, 0x37, 0xd5, 0x6e, 0x1b, 0x05, 0x20, 0xa3, 0x36, 0x45, 0x0f, 0xcf, 0xad, 0x31, 0x5b, 0xb6, + /*8c40:*/ 0x6f, 0x10, 0xc4, 0x95, 0x3b, 0xef, 0x07, 0xf4, 0xae, 0x4e, 0xb8, 0x93, 0x88, 0x30, 0x6a, 0x92, + /*8c50:*/ 0x83, 0xcd, 0xab, 0x19, 0xca, 0x30, 0xd2, 0x1d, 0x27, 0x00, 0x22, 0x42, 0xe8, 0x5f, 0x60, 0x54, + /*8c60:*/ 0x0d, 0xa1, 0xcf, 0x27, 0xb2, 0x95, 0xd2, 0x65, 0x1d, 0xb4, 0xb4, 0xc2, 0x57, 0x61, 0x7e, 0x12, + /*8c70:*/ 0x5e, 0x84, 0x0f, 0xa3, 0x02, 0xfe, 0x2e, 0x3c, 0xf2, 0x0e, 0xd7, 0x22, 0xb9, 0xae, 0xb6, 0xed, + /*8c80:*/ 0x48, 0xfd, 0xe3, 0x02, 0x42, 0xf4, 0x5e, 0x84, 0xb5, 0xce, 0xe4, 0x39, 0xa1, 0x26, 0x57, 0xc2, + /*8c90:*/ 0xe1, 0x05, 0x82, 0x66, 0x53, 0x6b, 0x7b, 0x26, 0x32, 0x58, 0x6f, 0x1c, 0x9c, 0x79, 0xa8, 0xd5, + /*8ca0:*/ 0x0b, 0xab, 0x75, 0xed, 0x34, 0x55, 0xc4, 0x55, 0x8a, 0x08, 0xb5, 0xdd, 0x96, 0xc8, 0xf0, 0x0f, + /*8cb0:*/ 0x3b, 0xe9, 0x03, 0xc5, 0x21, 0xcb, 0x52, 0xac, 0x80, 0x1a, 0x05, 0x81, 0x44, 0x75, 0x19, 0xb4, + /*8cc0:*/ 0x9e, 0x2e, 0x40, 0x50, 0xbf, 0xb2, 0x56, 0x1d, 0xd0, 0xc6, 0xcb, 0x09, 0x95, 0x55, 0xfd, 0xcc, + /*8cd0:*/ 0xd0, 0x5e, 0x3a, 0xab, 0x13, 0xf0, 0xdc, 0xb6, 0xfd, 0x80, 0x92, 0xf5, 0x24, 0xd9, 0xcc, 0xd2, + /*8ce0:*/ 0xf9, 0x37, 0xef, 0x42, 0x56, 0x0a, 0xf3, 0x67, 0xf4, 0x09, 0x0a, 0x3b, 0x24, 0x46, 0x85, 0x4c, + /*8cf0:*/ 0x54, 0x2b, 0x1d, 0xee, 0xc6, 0x2c, 0xe2, 0x30, 0x42, 0x20, 0xda, 0x3c, 0xe5, 0xac, 0x84, 0x9e, + /*8d00:*/ 0x64, 0xc1, 0xf8, 0xbc, 0x2b, 0xcb, 0xb1, 0x92, 0xa6, 0x82, 0x9f, 0x31, 0xec, 0x5b, 0x82, 0x41, + /*8d10:*/ 0x9b, 0x59, 0xe8, 0x70, 0x87, 0xcf, 0xd0, 0xd3, 0xfc, 0xc9, 0xbe, 0x8a, 0xba, 0x8e, 0x81, 0x7c, + /*8d20:*/ 0x54, 0xf3, 0x96, 0x66, 0xec, 0x3e, 0x0c, 0x7d, 0xdf, 0x46, 0xe3, 0xdf, 0xad, 0x64, 0x10, 0xc1, + /*8d30:*/ 0x7e, 0x71, 0x62, 0xd4, 0xc9, 0x92, 0x6f, 0xae, 0x46, 0x33, 0x44, 0xfd, 0xb2, 0x68, 0x4e, 0xd4, + /*8d40:*/ 0xdf, 0x00, 0x1e, 0xda, 0xfd, 0x25, 0x01, 0x56, 0x2e, 0xd6, 0xec, 0xa0, 0xca, 0x47, 0x3e, 0x9f, + /*8d50:*/ 0x0e, 0xd8, 0x91, 0x51, 0xb3, 0x5e, 0xf1, 0x09, 0x6a, 0xa2, 0x66, 0x90, 0xe7, 0x5d, 0x89, 0x97, + /*8d60:*/ 0x4e, 0xb1, 0x2b, 0xe4, 0x2b, 0x0a, 0x5e, 0x29, 0x19, 0xd7, 0xbd, 0x72, 0xc4, 0xf4, 0xdd, 0xbf, + /*8d70:*/ 0x2f, 0x9c, 0x37, 0x41, 0xed, 0x5e, 0x6f, 0x8e, 0x54, 0xdb, 0x4b, 0x60, 0x5b, 0x24, 0x5e, 0x7c, + /*8d80:*/ 0x8f, 0xf5, 0x6a, 0xb8, 0x1a, 0x31, 0xd9, 0x64, 0xb6, 0x5a, 0x47, 0x59, 0xf9, 0x19, 0xc8, 0x67, + /*8d90:*/ 0xc3, 0x92, 0x0d, 0xb7, 0x27, 0xfa, 0x88, 0x10, 0x96, 0x27, 0x76, 0xf9, 0x0a, 0x29, 0x09, 0x36, + /*8da0:*/ 0x93, 0xe2, 0x00, 0x29, 0xdc, 0x27, 0x35, 0x82, 0x45, 0x27, 0xc9, 0xf9, 0x87, 0xdb, 0x02, 0x2c, + /*8db0:*/ 0xcd, 0x80, 0x60, 0x8f, 0xab, 0x34, 0x59, 0xb1, 0x95, 0x50, 0xc7, 0x7f, 0x8b, 0xd5, 0x32, 0x1a, + /*8dc0:*/ 0xed, 0xd5, 0xef, 0x9a, 0x0b, 0x5f, 0x67, 0x53, 0xdf, 0xe3, 0xa0, 0xa0, 0x45, 0xef, 0xd0, 0x96, + /*8dd0:*/ 0xf2, 0x4a, 0x03, 0xe7, 0x88, 0xe1, 0x0d, 0xcc, 0x37, 0x8a, 0x2b, 0x83, 0x45, 0x23, 0x99, 0x2a, + /*8de0:*/ 0xc0, 0x57, 0xd0, 0xea, 0xd5, 0xb7, 0xc4, 0x38, 0xae, 0xe5, 0x2c, 0x77, 0x97, 0xc2, 0x7b, 0xcf, + /*8df0:*/ 0x76, 0x5f, 0x29, 0xf4, 0xbb, 0xb8, 0xcf, 0xb4, 0xd7, 0xe5, 0x58, 0x02, 0xf0, 0x10, 0xe8, 0xda, + /*8e00:*/ 0x29, 0x06, 0xc3, 0x56, 0xf1, 0x1b, 0x22, 0xc9, 0x83, 0x3d, 0x68, 0xca, 0x32, 0x1c, 0x3a, 0x2b, + /*8e10:*/ 0xbe, 0x83, 0xb6, 0x19, 0x0b, 0xad, 0xa7, 0x0e, 0x7b, 0x4e, 0x9e, 0xa5, 0xaa, 0xc6, 0xb8, 0x33, + /*8e20:*/ 0x66, 0x57, 0xca, 0x1e, 0x61, 0xef, 0x4b, 0x1b, 0xb9, 0x4a, 0xc1, 0x84, 0x65, 0x43, 0x38, 0xa2, + /*8e30:*/ 0x13, 0x05, 0x4e, 0xe4, 0xe8, 0xac, 0x47, 0xd9, 0xb8, 0x3e, 0x14, 0xd4, 0x0c, 0x98, 0xdc, 0x1f, + /*8e40:*/ 0x92, 0x74, 0x92, 0xaf, 0xa6, 0x56, 0x36, 0xc4, 0xf0, 0xd5, 0x14, 0x66, 0xb2, 0xc9, 0x68, 0x51, + /*8e50:*/ 0xaf, 0x93, 0xa6, 0xe7, 0x76, 0x74, 0x18, 0x84, 0xc6, 0xb3, 0x93, 0x19, 0xc8, 0xe8, 0x92, 0x31, + /*8e60:*/ 0x84, 0xb2, 0xd2, 0x1a, 0x6d, 0x70, 0x95, 0xaa, 0x16, 0x63, 0x2d, 0xa9, 0x90, 0x9e, 0x66, 0x80, + /*8e70:*/ 0x71, 0xe0, 0xc6, 0xc4, 0x50, 0xf8, 0x20, 0x80, 0xcd, 0xbe, 0x08, 0x5d, 0xdd, 0x69, 0x51, 0xbb, + /*8e80:*/ 0x1a, 0xd0, 0x28, 0x7f, 0x02, 0x0f, 0xac, 0x90, 0xb6, 0xfc, 0xaa, 0x81, 0x09, 0x3e, 0xc5, 0x72, + /*8e90:*/ 0x7e, 0x30, 0xe3, 0x42, 0x81, 0x8b, 0x03, 0x8b, 0x1f, 0x96, 0x02, 0xfa, 0xe1, 0xf3, 0xc5, 0x1e, + /*8ea0:*/ 0xfd, 0x5e, 0x30, 0xfe, 0xec, 0x09, 0x86, 0x83, 0x48, 0x78, 0x41, 0x48, 0xf7, 0x42, 0xa0, 0xe5, + /*8eb0:*/ 0xc7, 0x50, 0x5b, 0x60, 0xa8, 0xb1, 0xdc, 0xe4, 0xc3, 0x30, 0xca, 0x3b, 0xdc, 0x16, 0x13, 0xf7, + /*8ec0:*/ 0xca, 0xff, 0x1f, 0x74, 0x73, 0x47, 0x52, 0x2c, 0x54, 0x2f, 0x1b, 0xe2, 0xb5, 0xaf, 0xaf, 0xc7, + /*8ed0:*/ 0x2c, 0x53, 0x16, 0x0f, 0xf7, 0xe7, 0x99, 0x7d, 0x57, 0x88, 0xe6, 0x39, 0xe7, 0x66, 0x73, 0xaf, + /*8ee0:*/ 0xab, 0x9f, 0x74, 0x4f, 0x0a, 0xd9, 0x0d, 0x9d, 0xc1, 0x5c, 0x43, 0x8d, 0x7a, 0x90, 0x56, 0xe2, + /*8ef0:*/ 0xd7, 0x8e, 0x76, 0xd9, 0xe9, 0x7f, 0x93, 0x66, 0x1c, 0x32, 0x1e, 0xda, 0x25, 0xbf, 0x28, 0x85, + /*8f00:*/ 0xea, 0xe8, 0x72, 0x9b, 0x7b, 0x32, 0xd7, 0xac, 0x20, 0xc2, 0x2e, 0x08, 0x27, 0x0e, 0xa6, 0x80, + /*8f10:*/ 0x6c, 0x15, 0x49, 0x20, 0xda, 0x01, 0xae, 0x5f, 0x07, 0x1e, 0xc2, 0x13, 0xcf, 0x51, 0xbe, 0xca, + /*8f20:*/ 0x68, 0x22, 0x59, 0xff, 0x0c, 0x05, 0xe2, 0x3a, 0xa3, 0xce, 0x60, 0xde, 0x7b, 0xa7, 0x89, 0xa1, + /*8f30:*/ 0x8b, 0xad, 0xc0, 0x5d, 0x5e, 0x31, 0x52, 0x64, 0x1a, 0xc1, 0x0e, 0xd2, 0xb2, 0x56, 0x4c, 0x01, + /*8f40:*/ 0xd9, 0x0e, 0xa8, 0x1b, 0x64, 0x7b, 0xa7, 0xcd, 0x02, 0x6f, 0x43, 0xbe, 0xfa, 0x46, 0x5c, 0xdd, + /*8f50:*/ 0xae, 0x5b, 0xe7, 0x53, 0x11, 0x3a, 0xc9, 0x03, 0xfb, 0x64, 0xfd, 0xfc, 0x89, 0x45, 0xf5, 0x8b, + /*8f60:*/ 0x54, 0x41, 0x15, 0xa2, 0x68, 0x72, 0x35, 0x21, 0xcf, 0xa5, 0x20, 0xb5, 0xbc, 0x3c, 0x0d, 0xa0, + /*8f70:*/ 0xed, 0xf5, 0xe9, 0xfd, 0xb2, 0x8e, 0x12, 0xc3, 0xcf, 0x9a, 0x96, 0x2f, 0x19, 0x9f, 0x2a, 0xdc, + /*8f80:*/ 0x1d, 0x7e, 0x2d, 0x98, 0x7d, 0x88, 0x6a, 0x84, 0x4a, 0xb5, 0xca, 0xaf, 0x77, 0x83, 0xea, 0x92, + /*8f90:*/ 0x10, 0xd9, 0x81, 0xc5, 0x8b, 0x38, 0x01, 0xc6, 0x4b, 0x00, 0x85, 0x58, 0xaa, 0x79, 0xe4, 0x95, + /*8fa0:*/ 0x09, 0x31, 0x93, 0x5e, 0x74, 0xee, 0x87, 0x26, 0x91, 0xd7, 0x82, 0x89, 0x77, 0x99, 0xf7, 0xc2, + /*8fb0:*/ 0x3e, 0x0b, 0xd9, 0xe6, 0x67, 0x15, 0x8b, 0x62, 0xe7, 0x1f, 0xde, 0x9c, 0xf4, 0xee, 0x19, 0x06, + /*8fc0:*/ 0xec, 0x04, 0x9f, 0xe2, 0xcd, 0x27, 0xce, 0x57, 0xb2, 0xa8, 0x8c, 0xac, 0x9f, 0x26, 0xdb, 0xc7, + /*8fd0:*/ 0x44, 0xcc, 0x03, 0x0b, 0x44, 0xff, 0xa5, 0x52, 0x79, 0x7d, 0xea, 0x54, 0x31, 0xa0, 0xe9, 0xbb, + /*8fe0:*/ 0x89, 0x05, 0x07, 0x7a, 0x29, 0x3f, 0xa1, 0xd2, 0xff, 0xd2, 0x5b, 0x1a, 0x86, 0xca, 0x96, 0x6b, + /*8ff0:*/ 0x86, 0x59, 0x7a, 0x43, 0x82, 0xd4, 0x63, 0x9f, 0x92, 0xfa, 0x54, 0x92, 0x72, 0x2b, 0x1b, 0x4d, + /*9000:*/ 0x98, 0x22, 0x9f, 0xbf, 0x4e, 0xd9, 0x15, 0xbf, 0x77, 0x18, 0xf3, 0x40, 0x25, 0xfc, 0x32, 0xe1, + /*9010:*/ 0x6e, 0xc5, 0xd4, 0xc7, 0x92, 0xf3, 0xa3, 0x44, 0x29, 0xe3, 0xdb, 0x95, 0xe9, 0x9d, 0xdf, 0x6a, + /*9020:*/ 0x46, 0xd6, 0xcd, 0x67, 0x36, 0x09, 0xfa, 0xa1, 0x01, 0xc4, 0x55, 0x84, 0x1c, 0xb4, 0x02, 0x7e, + /*9030:*/ 0x5f, 0x70, 0x25, 0xc1, 0x61, 0x9c, 0xfc, 0xa2, 0xa2, 0x15, 0x17, 0x7d, 0x9c, 0x5f, 0x67, 0x41, + /*9040:*/ 0xca, 0x60, 0x0b, 0x9e, 0x48, 0x71, 0x16, 0xc6, 0x0b, 0xf4, 0x03, 0x86, 0xb5, 0x0e, 0xad, 0xc6, + /*9050:*/ 0xf8, 0xbd, 0x96, 0x46, 0xe1, 0xc6, 0xe0, 0x96, 0x0a, 0x95, 0xda, 0x5f, 0xba, 0x0b, 0x56, 0xc1, + /*9060:*/ 0x39, 0x20, 0xd0, 0xa8, 0xf4, 0x06, 0x7c, 0xc7, 0x02, 0xed, 0x5a, 0x7b, 0xaa, 0x0f, 0x4c, 0x71, + /*9070:*/ 0xf7, 0x8a, 0xeb, 0x95, 0xd9, 0x08, 0xfa, 0x57, 0xd4, 0x0a, 0xed, 0x10, 0xda, 0xf8, 0x3e, 0xa0, + /*9080:*/ 0xeb, 0xf2, 0x27, 0x2f, 0x7f, 0x65, 0x47, 0x76, 0x33, 0x0f, 0x96, 0xc7, 0x6e, 0xbe, 0x07, 0xe7, + /*9090:*/ 0xd5, 0xdc, 0x49, 0xc3, 0x94, 0x32, 0xc0, 0xa0, 0xb1, 0x80, 0xab, 0x0a, 0xd7, 0x7b, 0x88, 0x10, + /*90a0:*/ 0xa1, 0x0b, 0x23, 0x5b, 0x2f, 0x61, 0x67, 0xd0, 0x01, 0xd9, 0xb4, 0xc3, 0xda, 0x34, 0xb3, 0x09, + /*90b0:*/ 0x58, 0x9f, 0x7b, 0x65, 0x4e, 0x8b, 0xc2, 0xb7, 0x19, 0x6f, 0x27, 0x72, 0x8e, 0x20, 0x32, 0x23, + /*90c0:*/ 0xcb, 0xbd, 0x3a, 0x97, 0xf6, 0xb0, 0xc0, 0xab, 0x23, 0x2d, 0x37, 0x1f, 0x00, 0x54, 0xbc, 0x51, + /*90d0:*/ 0x17, 0xd1, 0x79, 0xbe, 0x2b, 0x24, 0xe7, 0xfc, 0x2a, 0x61, 0x04, 0xc9, 0xc5, 0x95, 0x7e, 0x09, + /*90e0:*/ 0x53, 0x9f, 0x6c, 0x93, 0x26, 0x48, 0xa1, 0x21, 0x84, 0xcc, 0x3c, 0xbc, 0x48, 0x67, 0xdb, 0x82, + /*90f0:*/ 0x73, 0xdf, 0x42, 0xe4, 0xf0, 0x34, 0x28, 0xff, 0xa5, 0x32, 0x4d, 0x6f, 0xa7, 0x09, 0x07, 0xa9, + /*9100:*/ 0x70, 0xaf, 0x1a, 0xd4, 0x41, 0x92, 0x7a, 0x7e, 0x6b, 0x7b, 0x43, 0xd1, 0xa8, 0x79, 0xdd, 0x29, + /*9110:*/ 0xf9, 0x37, 0xb3, 0x3f, 0xad, 0x3c, 0x59, 0xc2, 0x01, 0x5c, 0x50, 0xbd, 0x65, 0x57, 0xbe, 0x63, + /*9120:*/ 0x62, 0x8e, 0x3f, 0x66, 0xf3, 0xd7, 0x38, 0xa4, 0x65, 0x67, 0xab, 0x24, 0xbb, 0x5c, 0x94, 0x38, + /*9130:*/ 0xda, 0x46, 0x36, 0xc3, 0x06, 0x88, 0x7e, 0xba, 0x7c, 0x2c, 0xc1, 0x47, 0x78, 0x1d, 0x9f, 0x5b, + /*9140:*/ 0xd8, 0x58, 0xc7, 0xd4, 0x7c, 0x47, 0xab, 0x05, 0xe2, 0xcb, 0x44, 0xe2, 0xbf, 0x9b, 0xc8, 0xe9, + /*9150:*/ 0x45, 0xe7, 0x3f, 0x27, 0x8a, 0xbe, 0xed, 0x82, 0x09, 0xa3, 0xa4, 0x71, 0x65, 0x4d, 0x8f, 0xdd, + /*9160:*/ 0x52, 0xfa, 0x4f, 0xfb, 0x47, 0x70, 0x03, 0x34, 0x34, 0xc2, 0x3a, 0xf4, 0xb5, 0xa2, 0xa5, 0xc6, + /*9170:*/ 0x82, 0xea, 0x76, 0x1b, 0x89, 0x14, 0xd4, 0xec, 0x2e, 0x47, 0xb1, 0x22, 0xde, 0xaf, 0xa0, 0x36, + /*9180:*/ 0x8d, 0xcf, 0xc1, 0xe0, 0x49, 0x07, 0xbf, 0x7c, 0xad, 0xf9, 0xf5, 0x10, 0x70, 0x49, 0x5e, 0x76, + /*9190:*/ 0x0a, 0x64, 0xa1, 0xde, 0x47, 0xde, 0x42, 0xc4, 0xc9, 0x0e, 0xcc, 0x97, 0x16, 0xa3, 0x72, 0x94, + /*91a0:*/ 0xde, 0x16, 0x03, 0xa1, 0xf6, 0x87, 0x97, 0x5c, 0x6a, 0xed, 0x99, 0x94, 0x48, 0x27, 0xc9, 0x33, + /*91b0:*/ 0x42, 0xdc, 0x13, 0x8b, 0xef, 0x93, 0x21, 0xa1, 0x53, 0x8f, 0xd8, 0xcb, 0xb1, 0xef, 0x66, 0xfa, + /*91c0:*/ 0xc5, 0x01, 0xa9, 0x11, 0xfc, 0x52, 0x91, 0x28, 0x82, 0x00, 0x7d, 0xeb, 0xfc, 0xbb, 0x03, 0x3c, + /*91d0:*/ 0x90, 0x83, 0x0d, 0x37, 0x10, 0xdc, 0xdf, 0xd3, 0x6d, 0xb8, 0x36, 0xc1, 0xad, 0x4e, 0xf5, 0x54, + /*91e0:*/ 0xed, 0x2b, 0x85, 0x14, 0xe4, 0x50, 0x80, 0x88, 0x7e, 0x9d, 0x0c, 0x41, 0x13, 0x8b, 0x2b, 0x32, + /*91f0:*/ 0x2e, 0xc6, 0x52, 0x2e, 0x3f, 0x12, 0x53, 0xee, 0x63, 0x6d, 0xad, 0xfb, 0x04, 0xf9, 0xc0, 0xc4, + /*9200:*/ 0x7e, 0x71, 0x59, 0x9f, 0x28, 0xc8, 0xde, 0x50, 0xd3, 0xe3, 0xeb, 0xdd, 0x01, 0x55, 0x83, 0x8b, + /*9210:*/ 0xed, 0x76, 0x01, 0x02, 0xc4, 0x94, 0xb1, 0x47, 0xfe, 0xa8, 0x0e, 0x95, 0xdf, 0xaa, 0x82, 0x44, + /*9220:*/ 0x9b, 0x61, 0x65, 0xbc, 0x4b, 0xbc, 0x86, 0x85, 0xbd, 0x45, 0xee, 0x87, 0xd0, 0x76, 0x68, 0xe1, + /*9230:*/ 0xa7, 0x19, 0x0a, 0x75, 0xc4, 0x22, 0x32, 0x75, 0x01, 0x03, 0x8c, 0x98, 0xfa, 0x13, 0x79, 0x17, + /*9240:*/ 0x43, 0x8a, 0x76, 0x6e, 0xa7, 0x22, 0x46, 0x29, 0x0f, 0xb3, 0x1f, 0xa5, 0xf6, 0x34, 0x6d, 0x03, + /*9250:*/ 0xef, 0xf9, 0xcf, 0x52, 0x17, 0xef, 0x65, 0x01, 0xd9, 0x9d, 0xc1, 0x74, 0x10, 0x96, 0x5a, 0x60, + /*9260:*/ 0xc1, 0xc1, 0x79, 0xcc, 0xfe, 0x44, 0x80, 0x12, 0x15, 0x12, 0xf3, 0xa4, 0x6f, 0x45, 0x53, 0x03, + /*9270:*/ 0xbf, 0xcb, 0xbc, 0xaf, 0x11, 0xab, 0x2d, 0x56, 0x12, 0xeb, 0xd8, 0x16, 0x40, 0xd1, 0x2b, 0xfb, + /*9280:*/ 0xc5, 0x76, 0x7d, 0xc3, 0xe1, 0xcc, 0xd4, 0x0a, 0x15, 0xef, 0x78, 0x64, 0xdb, 0x1b, 0x67, 0x40, + /*9290:*/ 0x7c, 0xb9, 0x01, 0xc8, 0xaf, 0x29, 0xcc, 0x06, 0x74, 0x72, 0xd1, 0xf8, 0x9e, 0x77, 0x0a, 0xe4, + /*92a0:*/ 0x4d, 0x3e, 0xc5, 0x35, 0xd1, 0x3e, 0xcd, 0x8b, 0xd6, 0x75, 0x18, 0x0c, 0xdd, 0xc1, 0x1a, 0x2a, + /*92b0:*/ 0x83, 0x26, 0x64, 0x6b, 0x3a, 0x53, 0x04, 0x13, 0xb2, 0x51, 0x89, 0x17, 0xfd, 0xe7, 0x8e, 0x8b, + /*92c0:*/ 0xfb, 0xd1, 0x17, 0x61, 0x42, 0x30, 0x0b, 0xcb, 0x1d, 0x4b, 0x95, 0xbe, 0x60, 0xce, 0xf9, 0x53, + /*92d0:*/ 0xd5, 0x46, 0x7a, 0x46, 0x20, 0xed, 0x2b, 0xb0, 0x7a, 0x76, 0x07, 0x50, 0xcf, 0x72, 0x29, 0x93, + /*92e0:*/ 0x6d, 0x49, 0x43, 0xde, 0xb5, 0x06, 0x7a, 0xed, 0x99, 0x4e, 0x1b, 0x87, 0x71, 0xc8, 0x60, 0xb4, + /*92f0:*/ 0xd4, 0x3b, 0xe8, 0xbd, 0x2a, 0x21, 0x23, 0xba, 0x42, 0x81, 0xde, 0xe8, 0x60, 0xd7, 0xfd, 0xfd, + /*9300:*/ 0x99, 0x2b, 0x50, 0xfc, 0xa6, 0xa0, 0x03, 0xa2, 0x29, 0xdf, 0x0e, 0x2c, 0x02, 0x06, 0x33, 0xe7, + /*9310:*/ 0x34, 0x9a, 0x54, 0x43, 0x0c, 0xeb, 0xf0, 0xe8, 0x61, 0x05, 0x6a, 0x60, 0xb5, 0x64, 0xc7, 0x58, + /*9320:*/ 0xd0, 0x24, 0xe0, 0xfe, 0x6a, 0xd8, 0xb0, 0xa5, 0xe0, 0xbf, 0x3b, 0x54, 0xba, 0x0c, 0x93, 0x12, + /*9330:*/ 0x4e, 0x80, 0xf4, 0xd4, 0x17, 0x6b, 0x78, 0x48, 0x37, 0x41, 0x69, 0x73, 0xc8, 0xee, 0xaf, 0x71, + /*9340:*/ 0x5e, 0xe1, 0x3a, 0x70, 0x9a, 0x67, 0x9d, 0x7e, 0x26, 0xb9, 0x0f, 0x81, 0x2f, 0x53, 0x4b, 0x8b, + /*9350:*/ 0xf8, 0x64, 0x5f, 0x1e, 0xfe, 0xef, 0xf8, 0x31, 0xbc, 0x43, 0x1e, 0xf7, 0x38, 0x82, 0x8d, 0xb9, + /*9360:*/ 0x30, 0x99, 0xc8, 0x13, 0xb0, 0xde, 0x00, 0x93, 0xe3, 0x0b, 0xb9, 0x12, 0x92, 0x9f, 0xb3, 0x8e, + /*9370:*/ 0xd6, 0xda, 0xfa, 0x7b, 0x13, 0xb4, 0xcc, 0x9e, 0x8a, 0x65, 0xb0, 0x4e, 0x07, 0xda, 0xa6, 0x6d, + /*9380:*/ 0x29, 0xae, 0xf2, 0xbc, 0xd9, 0xde, 0xfc, 0x45, 0x20, 0x25, 0x2f, 0x21, 0x5c, 0x74, 0x95, 0x6b, + /*9390:*/ 0x9c, 0xa4, 0xa3, 0x06, 0xf8, 0x83, 0x09, 0x9f, 0x4c, 0xcc, 0x7b, 0xdb, 0xd7, 0x08, 0xd7, 0x79, + /*93a0:*/ 0x3e, 0x57, 0xef, 0xdb, 0x4d, 0xc6, 0x4b, 0x3e, 0xdd, 0xb4, 0x2a, 0xd2, 0x61, 0x72, 0x82, 0xff, + /*93b0:*/ 0x29, 0xf5, 0x8d, 0xbe, 0x68, 0xd2, 0x14, 0x53, 0x29, 0x15, 0x03, 0xfd, 0x04, 0x14, 0x24, 0x6a, + /*93c0:*/ 0x2d, 0xe4, 0x26, 0x4a, 0xba, 0x1a, 0xf9, 0x09, 0x8c, 0x48, 0x34, 0xc4, 0x86, 0xcc, 0xb3, 0x80, + /*93d0:*/ 0x14, 0x9e, 0xd4, 0xd0, 0x9f, 0xac, 0xdb, 0xc1, 0xfa, 0x25, 0xb2, 0x09, 0x9e, 0x69, 0xa5, 0x2c, + /*93e0:*/ 0x13, 0x6c, 0xec, 0x2e, 0x2d, 0xfa, 0xe6, 0x3b, 0xa0, 0x03, 0xeb, 0x79, 0xf3, 0x62, 0x81, 0xd1, + /*93f0:*/ 0x72, 0x11, 0xd0, 0xaa, 0xd3, 0xf0, 0x6b, 0xb4, 0xc7, 0x88, 0xa6, 0x0f, 0x50, 0x92, 0x55, 0x59, + /*9400:*/ 0x85, 0xe2, 0xf8, 0x6a, 0x32, 0xa9, 0xa6, 0xde, 0xdd, 0x2e, 0x0e, 0x3d, 0xbc, 0x66, 0x70, 0xfc, + /*9410:*/ 0x79, 0xdb, 0xc7, 0x01, 0x86, 0xdb, 0xb5, 0xd3, 0x28, 0xf2, 0xbd, 0x01, 0xe5, 0x6e, 0x47, 0xef, + /*9420:*/ 0x96, 0x22, 0x86, 0x63, 0x7b, 0xa3, 0x8a, 0xa0, 0x54, 0x2c, 0x4f, 0x22, 0xd0, 0x1a, 0xb4, 0x76, + /*9430:*/ 0xca, 0x51, 0x0b, 0x59, 0x86, 0x73, 0xf9, 0x29, 0xa1, 0xc0, 0xcc, 0xe9, 0xbd, 0x50, 0x4b, 0xfd, + /*9440:*/ 0x3b, 0x57, 0xae, 0x82, 0xc1, 0xcc, 0x6d, 0xbc, 0xd6, 0x5f, 0x18, 0x30, 0xd9, 0xb8, 0x29, 0x1f, + /*9450:*/ 0x33, 0x7e, 0x73, 0xf2, 0x14, 0xb2, 0xce, 0x04, 0x0d, 0x53, 0x5b, 0x0d, 0x8c, 0x0f, 0x79, 0xe2, + /*9460:*/ 0x95, 0x96, 0xf9, 0x78, 0xc5, 0x48, 0x05, 0xc1, 0xd4, 0x3c, 0x69, 0x80, 0x24, 0x11, 0x3e, 0xdb, + /*9470:*/ 0x14, 0x91, 0x2f, 0xc8, 0xcc, 0x76, 0xd3, 0x8b, 0x31, 0x49, 0x6d, 0x4a, 0xbc, 0x8e, 0xe7, 0x35, + /*9480:*/ 0xe2, 0xf2, 0x6d, 0x13, 0x23, 0xa0, 0x7a, 0xa7, 0x65, 0x19, 0x4b, 0xee, 0xe5, 0xc3, 0xdc, 0xce, + /*9490:*/ 0x91, 0x51, 0x2c, 0x1c, 0x52, 0xcd, 0x10, 0x2c, 0xc0, 0x13, 0x00, 0x98, 0xbb, 0xa4, 0x8b, 0xad, + /*94a0:*/ 0x56, 0x76, 0x2a, 0xc4, 0xeb, 0xef, 0xa4, 0x8e, 0xf1, 0x12, 0x01, 0x6a, 0xd6, 0xb8, 0x3d, 0xfc, + /*94b0:*/ 0x03, 0x78, 0x75, 0xef, 0x67, 0xe6, 0xeb, 0xf2, 0xf9, 0xb8, 0x80, 0xfe, 0x7c, 0xac, 0x30, 0xb3, + /*94c0:*/ 0x90, 0xc6, 0x6b, 0xd8, 0xf9, 0xad, 0x80, 0x93, 0x6e, 0x88, 0x62, 0xb7, 0xf7, 0xe8, 0x01, 0x3a, + /*94d0:*/ 0x6f, 0x97, 0x7b, 0x0a, 0x20, 0x95, 0x5e, 0x1f, 0xdd, 0x71, 0x59, 0xd4, 0x51, 0x14, 0xe4, 0xa6, + /*94e0:*/ 0xf3, 0x01, 0x9f, 0x7f, 0x57, 0x59, 0x85, 0xf0, 0x72, 0x17, 0xa7, 0xc0, 0x4c, 0x15, 0x15, 0x7e, + /*94f0:*/ 0xd3, 0xbb, 0xc8, 0xc2, 0x31, 0x3c, 0x2a, 0x10, 0x89, 0xf7, 0xa2, 0x22, 0x81, 0x45, 0xa0, 0xdd, + /*9500:*/ 0xd2, 0x4e, 0x50, 0xc1, 0x4e, 0xdf, 0xc0, 0x2e, 0x54, 0x14, 0x07, 0x99, 0x03, 0x37, 0x6c, 0x8f, + /*9510:*/ 0x43, 0x86, 0x08, 0xbe, 0x29, 0xfa, 0x91, 0xdc, 0x00, 0x65, 0x04, 0xa6, 0xc0, 0x20, 0x47, 0x1a, + /*9520:*/ 0x0d, 0x08, 0x91, 0x87, 0x14, 0x90, 0xe4, 0x92, 0xed, 0x79, 0x1b, 0xed, 0x98, 0xca, 0xfc, 0x57, + /*9530:*/ 0x81, 0xf1, 0x2c, 0xda, 0xc7, 0x02, 0xde, 0xf3, 0xd4, 0xda, 0xd2, 0x88, 0x3d, 0x8e, 0x47, 0xaa, + /*9540:*/ 0x50, 0x59, 0x14, 0xf8, 0x41, 0x37, 0xfb, 0x57, 0x47, 0xf3, 0x51, 0xb4, 0x80, 0x5a, 0x24, 0xbb, + /*9550:*/ 0x66, 0xe7, 0x06, 0x32, 0x2d, 0x86, 0x1b, 0x8c, 0x88, 0x39, 0x0a, 0x87, 0x26, 0xee, 0xda, 0x54, + /*9560:*/ 0x8c, 0x0a, 0x8b, 0x3d, 0x2b, 0x26, 0x72, 0x46, 0xe0, 0xdc, 0x8e, 0xd4, 0xb7, 0x10, 0x8d, 0x3c, + /*9570:*/ 0x37, 0x53, 0xd4, 0x11, 0xd6, 0x3e, 0x62, 0xc9, 0x55, 0xc3, 0xdd, 0x28, 0x6d, 0xb9, 0x65, 0x0c, + /*9580:*/ 0xa5, 0x3f, 0xdb, 0xfd, 0xf9, 0x5f, 0x72, 0xf7, 0xeb, 0xd6, 0x2c, 0xdc, 0xc6, 0xa1, 0x3d, 0xd9, + /*9590:*/ 0x35, 0x01, 0xff, 0xe6, 0x8b, 0x7d, 0x4f, 0x38, 0x9a, 0x34, 0xd0, 0x12, 0xdf, 0xbd, 0x98, 0xc3, + /*95a0:*/ 0x91, 0xd5, 0xc6, 0x81, 0x09, 0xf4, 0x62, 0x6a, 0x0c, 0x5f, 0x40, 0xcc, 0x5e, 0xe3, 0x06, 0x38, + /*95b0:*/ 0xc1, 0xfe, 0xf7, 0xac, 0x7e, 0x82, 0xc2, 0x87, 0x56, 0x4b, 0x2a, 0x10, 0x70, 0xc2, 0x2c, 0x9c, + /*95c0:*/ 0x7f, 0x55, 0x5e, 0x58, 0x54, 0xc8, 0x38, 0x2c, 0x02, 0xbd, 0xe2, 0x2d, 0xb9, 0x47, 0x64, 0xe5, + /*95d0:*/ 0x0a, 0x3e, 0xb4, 0xc4, 0x85, 0x2d, 0x22, 0xd3, 0x2f, 0x58, 0xdd, 0xca, 0x40, 0x8a, 0x8f, 0x46, + /*95e0:*/ 0x32, 0x9f, 0x2b, 0x87, 0x6f, 0x90, 0x19, 0xcf, 0x4e, 0x7a, 0x6d, 0x45, 0xc5, 0x3d, 0x12, 0x3e, + /*95f0:*/ 0x82, 0x23, 0x6a, 0x69, 0x21, 0x29, 0x94, 0x1c, 0x8b, 0x95, 0xbd, 0x06, 0x24, 0xb1, 0xbc, 0x12, + /*9600:*/ 0x6a, 0x25, 0xd5, 0x56, 0xbf, 0xb6, 0xde, 0x8d, 0xc9, 0xa9, 0x88, 0x8d, 0x93, 0xe8, 0x55, 0x7a, + /*9610:*/ 0x5c, 0xe5, 0xae, 0x4b, 0xa0, 0xfc, 0xbe, 0xea, 0x6d, 0x89, 0xa6, 0x02, 0xfa, 0x73, 0xa4, 0x77, + /*9620:*/ 0x90, 0x5a, 0x1b, 0x0c, 0x7e, 0x2f, 0xa6, 0xad, 0x96, 0x9d, 0x3e, 0x59, 0x27, 0x4b, 0x72, 0x2d, + /*9630:*/ 0xd3, 0xb3, 0x01, 0x6d, 0x07, 0x31, 0xe4, 0x52, 0x43, 0xe0, 0x95, 0x46, 0x0e, 0x15, 0x1b, 0x24, + /*9640:*/ 0xb0, 0x4c, 0xc9, 0x93, 0xeb, 0x19, 0xb1, 0xf7, 0xe1, 0x7f, 0x90, 0xaa, 0x46, 0x39, 0xd7, 0x87, + /*9650:*/ 0xc8, 0xc0, 0xb4, 0x55, 0x6f, 0x7b, 0xff, 0x49, 0xa4, 0xca, 0x8c, 0xe2, 0x87, 0x03, 0x56, 0x4e, + /*9660:*/ 0x21, 0x17, 0xbb, 0x15, 0xec, 0x10, 0x87, 0x15, 0xe3, 0x94, 0x75, 0x1a, 0x28, 0x44, 0x8f, 0xeb, + /*9670:*/ 0xfb, 0x27, 0x43, 0xdf, 0x1a, 0xcd, 0x79, 0x6b, 0x3e, 0x92, 0x09, 0xc5, 0xd5, 0x32, 0x30, 0x91, + /*9680:*/ 0xb5, 0x53, 0x1b, 0xfb, 0x4a, 0x1d, 0x57, 0x9b, 0x66, 0x68, 0x69, 0x6f, 0xca, 0x7f, 0xe0, 0xb1, + /*9690:*/ 0x20, 0xdf, 0x9e, 0xb2, 0x14, 0xaa, 0xdc, 0x0a, 0xab, 0x55, 0x25, 0xeb, 0xd7, 0xcc, 0x82, 0x9f, + /*96a0:*/ 0xfe, 0xbd, 0x49, 0x89, 0x82, 0xb9, 0xc0, 0x97, 0xf6, 0x36, 0x87, 0x25, 0x09, 0xf7, 0xd8, 0xa0, + /*96b0:*/ 0xb5, 0x47, 0x3b, 0x7c, 0x7d, 0x7a, 0xbe, 0xed, 0x13, 0x7f, 0xb0, 0x86, 0xd8, 0x9c, 0x52, 0x4b, + /*96c0:*/ 0xa6, 0xad, 0x90, 0x16, 0x28, 0xbe, 0x75, 0x6f, 0x41, 0xdc, 0x0f, 0x71, 0x00, 0xcd, 0xae, 0x1d, + /*96d0:*/ 0x56, 0x8d, 0x7a, 0xc5, 0xec, 0xe3, 0xef, 0x55, 0x97, 0x6f, 0x8e, 0x55, 0xc3, 0xdc, 0x97, 0x5a, + /*96e0:*/ 0x86, 0x91, 0x38, 0xda, 0xc9, 0x1c, 0x98, 0x62, 0xe1, 0xc9, 0x45, 0x26, 0x2d, 0x19, 0xcd, 0x83, + /*96f0:*/ 0x81, 0x25, 0x2f, 0x93, 0xa2, 0x34, 0x74, 0x01, 0x96, 0x30, 0x18, 0xc3, 0xa7, 0xd9, 0xd7, 0x5b, + /*9700:*/ 0xcf, 0x33, 0x35, 0x0b, 0xfa, 0xdd, 0x4a, 0x14, 0xdb, 0x05, 0xf4, 0x34, 0xde, 0xa8, 0xeb, 0xaa, + /*9710:*/ 0x35, 0x82, 0xf6, 0x47, 0x28, 0x84, 0x56, 0x8f, 0xbe, 0xf7, 0xc8, 0xaa, 0xdd, 0x39, 0x9b, 0x40, + /*9720:*/ 0xe9, 0x80, 0x16, 0xe6, 0x1e, 0x3a, 0xfb, 0x82, 0x62, 0x73, 0x05, 0x92, 0x13, 0x1d, 0x46, 0x29, + /*9730:*/ 0x04, 0xcf, 0xc3, 0x8b, 0xb3, 0xb4, 0x95, 0x66, 0xcd, 0x07, 0x10, 0x18, 0x03, 0x19, 0xb7, 0x3f, + /*9740:*/ 0x43, 0x30, 0x87, 0xd8, 0x37, 0x1d, 0x57, 0x4d, 0x9d, 0x94, 0x5f, 0xe7, 0xf9, 0xa3, 0xa3, 0xe9, + /*9750:*/ 0xa4, 0x23, 0x3d, 0x53, 0xe2, 0xe0, 0xd9, 0x12, 0xbb, 0x38, 0xc1, 0xe9, 0xbb, 0x44, 0xdf, 0x87, + /*9760:*/ 0x2c, 0x8f, 0x38, 0x34, 0x9e, 0xd5, 0xcc, 0x1f, 0x24, 0x42, 0x1e, 0xa6, 0xf3, 0x2f, 0xd0, 0xc2, + /*9770:*/ 0xf4, 0x11, 0x5f, 0xa6, 0x10, 0x78, 0xc4, 0x78, 0x3a, 0xad, 0x14, 0xf5, 0x1b, 0xb2, 0x19, 0x20, + /*9780:*/ 0x8b, 0xbd, 0x38, 0xe4, 0x8d, 0x62, 0x00, 0xe9, 0x34, 0xab, 0x3d, 0x43, 0x75, 0x5d, 0xa7, 0xc6, + /*9790:*/ 0x0f, 0x2b, 0x30, 0x0e, 0xd7, 0x9b, 0x94, 0x9e, 0x84, 0xc7, 0xe1, 0x83, 0x24, 0x3c, 0xaa, 0x0f, + /*97a0:*/ 0x60, 0x22, 0x6d, 0x12, 0xd7, 0xec, 0x95, 0x82, 0xff, 0xa7, 0x87, 0xef, 0xf4, 0x7c, 0xd7, 0x13, + /*97b0:*/ 0x3f, 0x5f, 0x59, 0xc1, 0x73, 0x4a, 0x8f, 0x34, 0x2e, 0x25, 0xa0, 0xb5, 0xea, 0xd0, 0x0e, 0x46, + /*97c0:*/ 0xba, 0x74, 0x40, 0x2f, 0xab, 0x21, 0xc8, 0x3e, 0x05, 0x41, 0xe8, 0x6b, 0x2c, 0x6f, 0x85, 0x3c, + /*97d0:*/ 0xbb, 0x8f, 0xa3, 0x58, 0x86, 0x9d, 0x7b, 0xfc, 0x21, 0xe6, 0x7b, 0x7e, 0xad, 0xe3, 0x16, 0x68, + /*97e0:*/ 0x06, 0xad, 0x90, 0xc4, 0x31, 0xaf, 0xcd, 0x25, 0xaf, 0x79, 0x22, 0x0a, 0xb8, 0xc8, 0x07, 0xa1, + /*97f0:*/ 0x84, 0xbc, 0x99, 0x79, 0x99, 0x64, 0xd4, 0x26, 0xec, 0x5c, 0x0e, 0x3d, 0xa3, 0xd9, 0x08, 0xd5, + /*9800:*/ 0x30, 0xa2, 0xb5, 0x6d, 0x52, 0x5f, 0x4a, 0x3b, 0xc3, 0x2f, 0x20, 0xcf, 0x28, 0xfc, 0xd4, 0x1c, + /*9810:*/ 0xfa, 0xc0, 0x18, 0xa3, 0x44, 0x4a, 0xaf, 0xa5, 0xaa, 0x52, 0xe8, 0xee, 0x84, 0x9b, 0x28, 0xf7, + /*9820:*/ 0xc1, 0x48, 0x69, 0xaa, 0xe6, 0x16, 0xf0, 0xf8, 0x9d, 0x02, 0x09, 0xf0, 0xad, 0xa3, 0x51, 0x2a, + /*9830:*/ 0x15, 0x1a, 0x4e, 0xcf, 0x96, 0x33, 0xeb, 0x66, 0x10, 0x58, 0xc0, 0x17, 0xe9, 0x57, 0x6e, 0xbc, + /*9840:*/ 0xe1, 0x2a, 0xd9, 0x78, 0x55, 0xd8, 0xef, 0x29, 0x70, 0xa6, 0xdc, 0x12, 0x89, 0xce, 0xfd, 0x7a, + /*9850:*/ 0x14, 0xe6, 0x0e, 0x03, 0xc9, 0xb3, 0x21, 0x8b, 0xfd, 0x01, 0xfa, 0x12, 0x34, 0x9b, 0x47, 0x23, + /*9860:*/ 0x3c, 0x3a, 0x70, 0x72, 0x70, 0x45, 0xf0, 0xa2, 0x04, 0xf9, 0xe6, 0x3f, 0x22, 0xf6, 0x41, 0x71, + /*9870:*/ 0x10, 0xe1, 0x44, 0x5d, 0xd7, 0x03, 0xa9, 0x07, 0x34, 0x5e, 0x50, 0xb9, 0x1b, 0x77, 0x18, 0x05, + /*9880:*/ 0x90, 0x8d, 0xfe, 0x48, 0x63, 0xe8, 0xbd, 0xe1, 0x59, 0xa9, 0x6b, 0xe2, 0xb9, 0xdf, 0x28, 0x1b, + /*9890:*/ 0xe9, 0x74, 0x48, 0x42, 0xed, 0x66, 0xc4, 0xf6, 0xaf, 0x72, 0xf7, 0x8a, 0x14, 0xf4, 0xb1, 0x3a, + /*98a0:*/ 0x9d, 0x10, 0xb9, 0x37, 0xe6, 0x53, 0xe3, 0x08, 0x0d, 0xf4, 0x43, 0x02, 0x07, 0x18, 0x9c, 0x42, + /*98b0:*/ 0xdb, 0xa9, 0x34, 0xfa, 0x14, 0x63, 0xfd, 0xb5, 0x0d, 0x93, 0xc3, 0x20, 0x5d, 0xc4, 0x05, 0xb1, + /*98c0:*/ 0x35, 0x37, 0xa0, 0x7a, 0x2f, 0xa3, 0x0f, 0xf9, 0xa0, 0x1e, 0x96, 0x79, 0xe1, 0x6a, 0xf0, 0xec, + /*98d0:*/ 0x73, 0x20, 0xa5, 0x76, 0xd6, 0xe8, 0x0e, 0x63, 0xe9, 0x0c, 0x6b, 0xf7, 0x61, 0x92, 0xee, 0xf3, + /*98e0:*/ 0x94, 0x53, 0xbd, 0x4e, 0x9c, 0xc9, 0xd4, 0x30, 0x07, 0x6f, 0xcf, 0xf8, 0x14, 0xf7, 0xfc, 0xdd, + /*98f0:*/ 0x3d, 0x77, 0x0c, 0x49, 0xc2, 0x90, 0xa2, 0xfa, 0x04, 0x3a, 0x63, 0xeb, 0x94, 0xc0, 0x2c, 0xfa, + /*9900:*/ 0x7c, 0x86, 0x94, 0x0f, 0x47, 0x38, 0x7d, 0xee, 0x5c, 0xa7, 0xa4, 0x6c, 0x7c, 0x12, 0xaa, 0x45, + /*9910:*/ 0xfb, 0xd0, 0x5d, 0xa9, 0xb5, 0x92, 0xef, 0x89, 0x61, 0x0b, 0xf2, 0xf4, 0xeb, 0x42, 0x96, 0x34, + /*9920:*/ 0x14, 0xa8, 0xed, 0x8e, 0x41, 0x87, 0x72, 0xd0, 0x13, 0x7b, 0x7d, 0x76, 0x1e, 0x5b, 0xb2, 0xee, + /*9930:*/ 0xbc, 0x84, 0xc0, 0xbd, 0xb1, 0x6a, 0x67, 0x08, 0xee, 0x0b, 0x0e, 0xf8, 0x27, 0x61, 0xff, 0x81, + /*9940:*/ 0xc0, 0xc2, 0xa1, 0x32, 0xfb, 0x00, 0x32, 0x62, 0x58, 0xc6, 0x8c, 0xe3, 0x25, 0x28, 0x91, 0x32, + /*9950:*/ 0x56, 0xba, 0x80, 0x5e, 0x91, 0xeb, 0x2b, 0x77, 0x3e, 0x80, 0x91, 0x40, 0x0d, 0x05, 0x92, 0xf6, + /*9960:*/ 0x9a, 0xf4, 0x7b, 0x03, 0x24, 0xdd, 0x02, 0xf0, 0x33, 0x82, 0x6f, 0xc8, 0x6d, 0x35, 0xe8, 0xd3, + /*9970:*/ 0xe6, 0x1e, 0x16, 0x5b, 0x97, 0x32, 0xea, 0xa2, 0xf4, 0xfb, 0x87, 0xff, 0x17, 0x96, 0xa5, 0xe0, + /*9980:*/ 0xfe, 0xdd, 0x12, 0xcc, 0x01, 0xd5, 0xb2, 0x00, 0xcd, 0x17, 0xc3, 0x05, 0x2e, 0x3b, 0x83, 0x7f, + /*9990:*/ 0x38, 0xe2, 0xfc, 0xf7, 0xa4, 0x14, 0xd9, 0x24, 0x44, 0xbd, 0x7f, 0x58, 0xfb, 0xbd, 0x5d, 0x55, + /*99a0:*/ 0xc6, 0x58, 0x09, 0x2d, 0x37, 0x84, 0x8f, 0x16, 0x3f, 0xa6, 0xac, 0x43, 0x36, 0xda, 0x5e, 0x61, + /*99b0:*/ 0x81, 0x0c, 0xeb, 0xa9, 0x5f, 0xb1, 0xee, 0xd6, 0xee, 0x11, 0xaf, 0x05, 0x76, 0x76, 0x4d, 0xa9, + /*99c0:*/ 0xd1, 0xd5, 0x5e, 0x15, 0x35, 0xc1, 0x08, 0x01, 0x51, 0x0d, 0xbe, 0x00, 0x04, 0xb9, 0xf0, 0xc3, + /*99d0:*/ 0x1f, 0xc2, 0xeb, 0x76, 0xb3, 0xa6, 0xca, 0xd0, 0x41, 0xc5, 0x75, 0x48, 0x75, 0x5b, 0x68, 0x9e, + /*99e0:*/ 0x84, 0xe7, 0xda, 0xe2, 0x03, 0x0b, 0xf5, 0x86, 0x22, 0x4d, 0x1e, 0x92, 0xd8, 0xc4, 0x1a, 0x9b, + /*99f0:*/ 0x3e, 0x1c, 0x5d, 0x53, 0x39, 0xeb, 0xb3, 0xd5, 0x84, 0x93, 0x17, 0xe2, 0x2e, 0x0a, 0xed, 0xb0, + /*9a00:*/ 0x6e, 0xb7, 0x27, 0x0b, 0x85, 0x5d, 0x8f, 0x0b, 0x5a, 0x52, 0x25, 0xc5, 0x11, 0xa0, 0xd9, 0xe8, + /*9a10:*/ 0xd5, 0x02, 0x07, 0x27, 0x21, 0x80, 0x3c, 0xd0, 0x43, 0x9c, 0x32, 0xd4, 0x95, 0xa0, 0xca, 0x0e, + /*9a20:*/ 0x25, 0x72, 0x08, 0x38, 0x86, 0x25, 0xf5, 0x18, 0x3b, 0x7d, 0x13, 0x19, 0x3f, 0xed, 0xc3, 0x6f, + /*9a30:*/ 0x54, 0x03, 0x64, 0xf1, 0x2a, 0x69, 0x9f, 0x58, 0x5f, 0x68, 0xdf, 0x39, 0x6b, 0x2c, 0xb5, 0x39, + /*9a40:*/ 0xeb, 0x49, 0x37, 0xbb, 0x1a, 0xc1, 0x3b, 0xb0, 0x71, 0xa4, 0x1d, 0x17, 0xfd, 0x23, 0xba, 0x5c, + /*9a50:*/ 0xde, 0x7a, 0x9e, 0x57, 0x8e, 0x6d, 0x1c, 0x4e, 0x41, 0xe4, 0xa2, 0xd4, 0xee, 0xbf, 0x9c, 0x8c, + /*9a60:*/ 0x66, 0x76, 0xf8, 0x62, 0x21, 0xae, 0xad, 0x3e, 0x2a, 0x64, 0xcf, 0xa1, 0x32, 0x69, 0xe4, 0xb3, + /*9a70:*/ 0xe3, 0xff, 0xf7, 0xd7, 0x85, 0x5f, 0xd8, 0x9c, 0xe9, 0xe7, 0x5b, 0xc1, 0xd2, 0x2e, 0xbb, 0xc9, + /*9a80:*/ 0xeb, 0xbf, 0x81, 0x51, 0x14, 0x6c, 0xf6, 0x23, 0x4e, 0xed, 0x68, 0x29, 0xb6, 0x90, 0x05, 0x24, + /*9a90:*/ 0x98, 0x53, 0xf3, 0x2a, 0x09, 0x88, 0xb5, 0xe1, 0x19, 0xc5, 0xac, 0x15, 0xb3, 0x12, 0x78, 0x25, + /*9aa0:*/ 0xb6, 0x09, 0xc7, 0x50, 0x39, 0x61, 0xee, 0x82, 0x85, 0x59, 0x7f, 0x10, 0x4f, 0xb7, 0x4c, 0xa6, + /*9ab0:*/ 0xb2, 0xce, 0x19, 0x5e, 0x3b, 0x94, 0xd2, 0x1f, 0x3b, 0xa2, 0xd6, 0x06, 0xe8, 0x04, 0xeb, 0x10, + /*9ac0:*/ 0xaa, 0x1b, 0x92, 0x0b, 0x98, 0x20, 0x7c, 0x02, 0x40, 0x2a, 0x9e, 0xbd, 0xeb, 0x73, 0x27, 0x6b, + /*9ad0:*/ 0x6d, 0xc5, 0x3e, 0x99, 0x06, 0x82, 0x22, 0xe6, 0xb8, 0x54, 0x88, 0x03, 0x7f, 0xf9, 0x8c, 0xda, + /*9ae0:*/ 0xc4, 0xfe, 0xd7, 0x94, 0x52, 0xca, 0x5a, 0x73, 0xba, 0x76, 0xb7, 0x90, 0x82, 0xaf, 0xb1, 0x02, + /*9af0:*/ 0xc4, 0x11, 0x84, 0x19, 0x65, 0xf3, 0x6c, 0x2d, 0x57, 0x11, 0x9e, 0xa5, 0x39, 0x74, 0xcd, 0x98, + /*9b00:*/ 0x6b, 0x89, 0x7c, 0x59, 0xea, 0x89, 0x41, 0x51, 0xbb, 0xd1, 0xc5, 0x01, 0xa0, 0xad, 0x35, 0xcd, + /*9b10:*/ 0x0a, 0x05, 0x28, 0xa1, 0x02, 0xb0, 0xf5, 0xf3, 0xd6, 0xb4, 0x8b, 0x05, 0xd5, 0x72, 0xa7, 0x9a, + /*9b20:*/ 0xb6, 0x13, 0xc6, 0xa0, 0xd4, 0x73, 0xa0, 0xd1, 0x15, 0x53, 0x2b, 0xb0, 0x43, 0x75, 0xfb, 0xb5, + /*9b30:*/ 0x81, 0x85, 0x30, 0xd0, 0xd4, 0x8c, 0x84, 0xea, 0x89, 0xb1, 0x9f, 0x9c, 0xc7, 0x5a, 0x56, 0x88, + /*9b40:*/ 0xa1, 0x74, 0xb3, 0x41, 0xdb, 0x6e, 0x7b, 0x02, 0x16, 0x6c, 0xbc, 0x95, 0x21, 0x5d, 0x83, 0x62, + /*9b50:*/ 0x56, 0x4c, 0xd5, 0x2a, 0xd3, 0xe3, 0xa0, 0xad, 0x49, 0x95, 0x12, 0x84, 0x81, 0xcd, 0xc1, 0x49, + /*9b60:*/ 0xcd, 0xc8, 0x77, 0x75, 0x67, 0x80, 0x3e, 0x83, 0x92, 0x4a, 0xe9, 0xa1, 0xa6, 0xe5, 0xa5, 0x7c, + /*9b70:*/ 0xf4, 0x33, 0x63, 0x69, 0x91, 0x08, 0x12, 0xfa, 0xe0, 0x8e, 0x4f, 0xaf, 0xfb, 0x24, 0x96, 0xcd, + /*9b80:*/ 0xf8, 0xb9, 0xa7, 0xbb, 0xc1, 0x59, 0xe8, 0x6f, 0xbc, 0xee, 0x25, 0x3f, 0xa0, 0x52, 0x92, 0x3e, + /*9b90:*/ 0xf3, 0x4b, 0xc3, 0x11, 0xa4, 0x94, 0x40, 0x24, 0x47, 0x9e, 0x71, 0xc5, 0x76, 0x57, 0xf1, 0xef, + /*9ba0:*/ 0x11, 0x53, 0x1a, 0x7f, 0x39, 0x23, 0x36, 0x13, 0x06, 0xe2, 0x20, 0x9e, 0x3b, 0x6d, 0x85, 0xef, + /*9bb0:*/ 0x80, 0x42, 0xaa, 0x08, 0x51, 0x91, 0x0c, 0xad, 0x68, 0xbe, 0xb8, 0xe2, 0x5f, 0xb1, 0xbb, 0xc8, + /*9bc0:*/ 0x0a, 0x32, 0x10, 0xbb, 0xb3, 0x07, 0x1c, 0x50, 0x4d, 0xca, 0x26, 0xf4, 0x5a, 0x20, 0x99, 0x95, + /*9bd0:*/ 0xe5, 0x2c, 0xbb, 0x80, 0x59, 0xef, 0x7d, 0x0c, 0x46, 0x4c, 0xa3, 0xcf, 0xc6, 0x9e, 0x6a, 0x0a, + /*9be0:*/ 0xa3, 0x17, 0x40, 0x77, 0x0e, 0xf6, 0x19, 0x93, 0x9a, 0x06, 0xc9, 0x3c, 0xc5, 0xcb, 0x33, 0x6e, + /*9bf0:*/ 0xb3, 0xfa, 0xeb, 0xbf, 0x63, 0x16, 0xad, 0x55, 0x79, 0xee, 0x5b, 0x15, 0x4e, 0xe1, 0x65, 0xa9, + /*9c00:*/ 0x69, 0x00, 0x7a, 0x99, 0xbf, 0x32, 0x32, 0x24, 0x66, 0xc0, 0xf0, 0x63, 0x3c, 0x94, 0xdf, 0xb2, + /*9c10:*/ 0x4b, 0xc8, 0x9a, 0xdd, 0xac, 0x0b, 0x6a, 0x20, 0x9e, 0xb9, 0x88, 0x9e, 0x60, 0x51, 0x04, 0xbc, + /*9c20:*/ 0x87, 0xd2, 0x9f, 0x53, 0x8d, 0x3f, 0x47, 0x5d, 0x17, 0xe0, 0xf8, 0xe1, 0x5f, 0xa9, 0x5a, 0xc3, + /*9c30:*/ 0xdf, 0xfc, 0x7f, 0xbe, 0x9c, 0x0d, 0x56, 0xe6, 0x7f, 0xe3, 0xf4, 0xfb, 0x5b, 0x4c, 0xd8, 0x3f, + /*9c40:*/ 0xc5, 0xc7, 0x7d, 0xc5, 0xa4, 0x74, 0x20, 0xe7, 0xb8, 0x35, 0x3d, 0xd0, 0xfe, 0x97, 0xb3, 0x7c, + /*9c50:*/ 0x5b, 0xba, 0x6f, 0x58, 0x1c, 0x47, 0xc8, 0xb7, 0x16, 0xf4, 0xa5, 0xb3, 0xb1, 0x51, 0x8a, 0x7d, + /*9c60:*/ 0x31, 0x9c, 0x20, 0x0e, 0x5a, 0x9d, 0x70, 0xea, 0xe2, 0x55, 0xe5, 0x0e, 0xe3, 0x0c, 0x62, 0x5b, + /*9c70:*/ 0xf3, 0xd3, 0x48, 0xfc, 0x20, 0xc0, 0x75, 0x6e, 0x16, 0xe8, 0xe8, 0xce, 0xf0, 0x1d, 0x4c, 0xdc, + /*9c80:*/ 0x82, 0xe0, 0x22, 0x34, 0xf6, 0x0a, 0x8b, 0xe5, 0x0c, 0x44, 0xc0, 0x8d, 0x77, 0xd9, 0xf3, 0x68, + /*9c90:*/ 0x04, 0xe2, 0xd1, 0x10, 0x0a, 0xbd, 0x34, 0xac, 0xcb, 0x0b, 0xcf, 0xab, 0xb7, 0x30, 0x73, 0x53, + /*9ca0:*/ 0x3a, 0xc2, 0x37, 0x21, 0x48, 0x8e, 0xf9, 0xa6, 0x4b, 0x85, 0xe4, 0x6c, 0xf3, 0x58, 0x71, 0xdb, + /*9cb0:*/ 0xe9, 0x4f, 0xc4, 0x80, 0xe1, 0xad, 0x5d, 0xe5, 0x82, 0xc9, 0x6f, 0xa6, 0xc7, 0xaf, 0x7d, 0x58, + /*9cc0:*/ 0xbc, 0xaa, 0x21, 0x43, 0x7f, 0xe5, 0x4c, 0x2e, 0x51, 0x52, 0xfe, 0xdd, 0x4f, 0xe0, 0xd7, 0xce, + /*9cd0:*/ 0x1e, 0x20, 0xcd, 0x24, 0x7d, 0xf8, 0xa2, 0x34, 0x80, 0xf0, 0x00, 0xef, 0x43, 0x97, 0xd6, 0xb6, + /*9ce0:*/ 0xd5, 0x4d, 0x14, 0xd3, 0x2f, 0x77, 0x74, 0xbb, 0xa4, 0x51, 0x72, 0x2b, 0x5d, 0x9c, 0xe2, 0x61, + /*9cf0:*/ 0xe8, 0xac, 0xf0, 0x96, 0x45, 0x92, 0xab, 0x9d, 0x6c, 0x86, 0xb6, 0x0d, 0x43, 0xdb, 0xe4, 0x86, + /*9d00:*/ 0x87, 0xe4, 0xc5, 0xd2, 0x92, 0x3c, 0x7e, 0x63, 0x2a, 0x07, 0x00, 0xf8, 0xfb, 0x9a, 0x99, 0x32, + /*9d10:*/ 0xe8, 0xf9, 0xb1, 0x88, 0x56, 0xb5, 0x7f, 0xcf, 0x6c, 0xe8, 0x63, 0xeb, 0x67, 0x4a, 0x53, 0xb1, + /*9d20:*/ 0x5f, 0x79, 0x73, 0x9e, 0xfa, 0xd3, 0x59, 0x00, 0xb6, 0xf6, 0x70, 0x20, 0x2d, 0x1b, 0x8e, 0x71, + /*9d30:*/ 0xea, 0xf0, 0x11, 0x2f, 0x12, 0xf3, 0xd2, 0x16, 0x51, 0xcd, 0x75, 0x70, 0x82, 0x06, 0x82, 0xa6, + /*9d40:*/ 0x03, 0x84, 0xc6, 0x5d, 0x54, 0xf5, 0xbe, 0xcd, 0x9e, 0x23, 0x69, 0xe2, 0x62, 0xfc, 0x86, 0x69, + /*9d50:*/ 0xb8, 0xfd, 0x6c, 0x67, 0x3a, 0x70, 0x74, 0xad, 0x0d, 0xce, 0xaa, 0x92, 0xd2, 0xc8, 0xfc, 0xeb, + /*9d60:*/ 0x32, 0xc7, 0x8f, 0x51, 0x7c, 0xf8, 0x94, 0x13, 0x49, 0xd2, 0xd0, 0x92, 0x47, 0x74, 0x65, 0x0f, + /*9d70:*/ 0x4d, 0xf2, 0x78, 0x30, 0x0c, 0xca, 0xe3, 0x12, 0x73, 0x46, 0x90, 0xac, 0xc1, 0x0b, 0x9e, 0xed, + /*9d80:*/ 0x2a, 0x32, 0xa0, 0x01, 0xdb, 0x4b, 0x80, 0x6d, 0xc3, 0x1b, 0x11, 0xad, 0x81, 0x84, 0xdd, 0x20, + /*9d90:*/ 0x21, 0x90, 0x7c, 0xda, 0x2d, 0x59, 0x89, 0x61, 0x66, 0x4d, 0x35, 0x8d, 0xcd, 0x59, 0xed, 0x6c, + /*9da0:*/ 0x2b, 0xde, 0xd1, 0x71, 0xf6, 0x62, 0x18, 0x6d, 0x2a, 0xfa, 0xcf, 0xd2, 0x78, 0x2e, 0x91, 0xed, + /*9db0:*/ 0xef, 0x42, 0xaf, 0x27, 0x5f, 0xe8, 0xc8, 0xd4, 0x49, 0xae, 0x29, 0xeb, 0x55, 0x53, 0x48, 0xdc, + /*9dc0:*/ 0x5d, 0xa0, 0xf9, 0x8a, 0x2b, 0x88, 0x65, 0x88, 0x94, 0x45, 0x38, 0xa9, 0xb4, 0xc4, 0xcf, 0x8e, + /*9dd0:*/ 0x56, 0x2a, 0x92, 0x76, 0x1e, 0x68, 0x50, 0x89, 0x7f, 0x99, 0x3b, 0xf1, 0x74, 0xdd, 0xf1, 0x0e, + /*9de0:*/ 0xb5, 0xd2, 0x0f, 0x80, 0x65, 0xe8, 0xe3, 0xc5, 0x66, 0x69, 0x75, 0xeb, 0x78, 0x2e, 0xc5, 0xbf, + /*9df0:*/ 0x35, 0xb9, 0x39, 0x0c, 0x7f, 0x81, 0x03, 0xbf, 0x14, 0xd1, 0x99, 0x4b, 0xd6, 0xaf, 0x44, 0x1e, + /*9e00:*/ 0x04, 0xe6, 0xd0, 0x26, 0x69, 0xe9, 0x35, 0xca, 0xe0, 0x39, 0xa6, 0x74, 0x2c, 0x5e, 0xe8, 0xeb, + /*9e10:*/ 0x53, 0x8e, 0xce, 0xc9, 0xd6, 0xa8, 0xe5, 0x78, 0x8a, 0xf8, 0xe1, 0x62, 0xe0, 0x71, 0xcf, 0xa2, + /*9e20:*/ 0x87, 0xf9, 0x51, 0x52, 0x94, 0x64, 0xde, 0xce, 0xa3, 0x09, 0x3c, 0x16, 0x7d, 0xce, 0xbb, 0xf9, + /*9e30:*/ 0x81, 0xb8, 0x86, 0xe3, 0x5f, 0xf9, 0x24, 0x8d, 0xfc, 0xbd, 0x5f, 0xd7, 0x15, 0x1a, 0x3e, 0x9f, + /*9e40:*/ 0x11, 0xab, 0xc4, 0xee, 0x23, 0x3b, 0x66, 0x66, 0xbb, 0x52, 0xfa, 0x75, 0x78, 0x37, 0x54, 0x71, + /*9e50:*/ 0x47, 0x4a, 0x9a, 0x8a, 0x7a, 0x7b, 0x1a, 0x18, 0x45, 0x4b, 0xf5, 0x91, 0x3a, 0xf1, 0x1a, 0x9f, + /*9e60:*/ 0x0e, 0x00, 0xc2, 0xa0, 0xc9, 0xfa, 0x95, 0x89, 0x8b, 0x59, 0x3b, 0x52, 0x16, 0xb8, 0x20, 0x89, + /*9e70:*/ 0xee, 0x83, 0xda, 0xda, 0x37, 0x5f, 0x8a, 0x7e, 0x9f, 0xbe, 0x7e, 0x20, 0xca, 0xb8, 0x52, 0xd4, + /*9e80:*/ 0x3d, 0x4d, 0xe2, 0x6e, 0xe9, 0x63, 0xfc, 0xaa, 0x74, 0xb2, 0x49, 0xac, 0x95, 0xd4, 0xb9, 0xf1, + /*9e90:*/ 0x97, 0xe7, 0xc8, 0x87, 0xab, 0xc5, 0xd2, 0x70, 0xe2, 0x8b, 0xe3, 0x3a, 0xa4, 0x58, 0x98, 0x31, + /*9ea0:*/ 0xce, 0x21, 0xbd, 0xf1, 0xc2, 0x7f, 0x87, 0x7a, 0xc9, 0x9f, 0xb2, 0x0b, 0x49, 0x1d, 0xff, 0x5a, + /*9eb0:*/ 0x60, 0x39, 0x77, 0x7e, 0x6f, 0xa3, 0x1a, 0x44, 0x81, 0x25, 0xac, 0x67, 0x9a, 0xa1, 0xbe, 0x9d, + /*9ec0:*/ 0x9e, 0xa4, 0x37, 0x7e, 0xb7, 0xdc, 0xd0, 0xbf, 0x57, 0x62, 0x9e, 0x6c, 0x8c, 0x4e, 0x2e, 0x3c, + /*9ed0:*/ 0xd3, 0x38, 0x91, 0x0c, 0xf4, 0x57, 0x91, 0x87, 0x00, 0x26, 0xd4, 0x0c, 0x22, 0x21, 0x0b, 0xab, + /*9ee0:*/ 0x1f, 0x3a, 0xe2, 0xcd, 0x41, 0x4c, 0xae, 0xfe, 0x9d, 0x11, 0xd1, 0x9b, 0xca, 0xc0, 0x95, 0x56, + /*9ef0:*/ 0xf9, 0xff, 0x70, 0xcd, 0xe2, 0x2b, 0x67, 0x5a, 0x1e, 0x5e, 0xb1, 0x70, 0x7f, 0x80, 0xb8, 0xd9, + /*9f00:*/ 0x85, 0x4f, 0x6a, 0xc5, 0xb1, 0xd3, 0x93, 0x11, 0x81, 0xf0, 0x9a, 0xf8, 0xf5, 0x97, 0x95, 0x63, + /*9f10:*/ 0x23, 0x45, 0x77, 0x19, 0x92, 0xdd, 0x33, 0x83, 0x48, 0x6e, 0xc7, 0xbd, 0x6a, 0xa8, 0x82, 0xb1, + /*9f20:*/ 0x5c, 0x64, 0x36, 0xda, 0xa2, 0x11, 0xbe, 0xc8, 0x9e, 0xc6, 0x43, 0x62, 0xe0, 0x02, 0x5f, 0x2f, + /*9f30:*/ 0x18, 0x29, 0xda, 0x32, 0x0e, 0xe5, 0x6c, 0xfa, 0x74, 0x79, 0x8b, 0xd2, 0x89, 0x3c, 0x88, 0xe3, + /*9f40:*/ 0xb5, 0x1d, 0x90, 0xce, 0x8d, 0x82, 0x41, 0xeb, 0x83, 0x90, 0x5e, 0xba, 0x6a, 0xb7, 0x1a, 0xb5, + /*9f50:*/ 0x54, 0xd7, 0x3c, 0x26, 0x63, 0x3c, 0x22, 0x80, 0x0a, 0x9e, 0xf8, 0x24, 0x82, 0x54, 0x64, 0x84, + /*9f60:*/ 0x51, 0xa9, 0x89, 0x2d, 0x39, 0x83, 0x35, 0x15, 0x1b, 0x95, 0x03, 0xf1, 0xb6, 0x2d, 0xd4, 0x96, + /*9f70:*/ 0x9b, 0x80, 0x13, 0x5c, 0x06, 0xf5, 0xa0, 0x76, 0xad, 0x2a, 0x02, 0x73, 0x96, 0x47, 0xe5, 0x38, + /*9f80:*/ 0xb8, 0x5d, 0x22, 0x37, 0xa5, 0x4c, 0x17, 0x36, 0xb2, 0x17, 0xd4, 0x6d, 0x5f, 0x54, 0xc2, 0xc7, + /*9f90:*/ 0x60, 0xe4, 0xd6, 0x53, 0x51, 0x20, 0x29, 0x3a, 0xa3, 0x15, 0x73, 0x13, 0xcc, 0xb6, 0xda, 0x81, + /*9fa0:*/ 0xcc, 0xe7, 0xd0, 0x9b, 0xb4, 0x52, 0xc9, 0x5a, 0x10, 0xda, 0x05, 0x08, 0xc9, 0x6e, 0x56, 0x9a, + /*9fb0:*/ 0xe8, 0x5f, 0xa4, 0x29, 0xff, 0x31, 0xad, 0x4a, 0x25, 0x46, 0x72, 0xab, 0xa1, 0xbf, 0x3a, 0x36, + /*9fc0:*/ 0x0b, 0x1d, 0x06, 0x90, 0xc3, 0x8b, 0x8e, 0x8e, 0x84, 0x60, 0xcf, 0x2d, 0xa3, 0x93, 0x2f, 0x68, + /*9fd0:*/ 0x53, 0x89, 0xb6, 0x2e, 0xde, 0xbc, 0x18, 0x7c, 0xbd, 0x66, 0x54, 0x92, 0xed, 0x0f, 0xf5, 0x82, + /*9fe0:*/ 0xdf, 0xba, 0x99, 0xc9, 0x8c, 0x63, 0xc2, 0x3b, 0x25, 0x6e, 0x86, 0x83, 0xf9, 0xe0, 0x1c, 0x34, + /*9ff0:*/ 0x8e, 0x27, 0xe0, 0x76, 0xe5, 0xa3, 0x23, 0x89, 0x5a, 0x0c, 0x7d, 0x37, 0xcc, 0x74, 0xeb, 0x22, + /*a000:*/ 0x13, 0x21, 0xa9, 0x64, 0x68, 0x50, 0xaa, 0x35, 0x5b, 0x57, 0x29, 0xff, 0xc1, 0x83, 0xb8, 0x00, + /*a010:*/ 0x11, 0x85, 0xa8, 0xe7, 0xbb, 0xc7, 0x9f, 0x8e, 0x73, 0x0b, 0x23, 0xfe, 0x4c, 0x59, 0x1e, 0x31, + /*a020:*/ 0x55, 0x74, 0x50, 0xf0, 0xb1, 0x95, 0xae, 0x8e, 0xbf, 0x46, 0x82, 0x05, 0xab, 0x19, 0x33, 0xe4, + /*a030:*/ 0x7f, 0xf5, 0xbd, 0x83, 0xa9, 0x0f, 0xf3, 0xe7, 0x88, 0x41, 0x47, 0xa7, 0x7f, 0xf3, 0xa3, 0x49, + /*a040:*/ 0x23, 0x18, 0xe7, 0x31, 0xba, 0xbf, 0x77, 0x47, 0x43, 0xa7, 0x79, 0x9e, 0xf7, 0xfb, 0x86, 0xfa, + /*a050:*/ 0x78, 0xe0, 0x7d, 0x89, 0xc4, 0xb5, 0x1d, 0xd5, 0xf9, 0x78, 0xbf, 0x24, 0x7c, 0xb0, 0xf7, 0x6c, + /*a060:*/ 0x95, 0xce, 0xe4, 0x98, 0xa8, 0xb1, 0x8d, 0x13, 0x16, 0xcf, 0x1c, 0xc8, 0x13, 0xf0, 0xfa, 0x10, + /*a070:*/ 0x64, 0x10, 0xd4, 0xb9, 0xab, 0xb2, 0x5d, 0x52, 0x92, 0x69, 0x18, 0xec, 0x27, 0xa7, 0x73, 0xde, + /*a080:*/ 0x2e, 0xfb, 0xa3, 0xe3, 0xc7, 0xf9, 0xb1, 0x16, 0xdf, 0x5c, 0x60, 0xfa, 0x3a, 0x1d, 0x1a, 0x51, + /*a090:*/ 0x6d, 0x00, 0xaf, 0x1d, 0x17, 0x7d, 0x99, 0xb2, 0x8e, 0x39, 0x84, 0x86, 0x81, 0xdb, 0x4b, 0xe6, + /*a0a0:*/ 0xc9, 0xa4, 0x6d, 0x0a, 0x53, 0xe3, 0x5e, 0x2b, 0x5b, 0x01, 0x81, 0x75, 0x0a, 0x84, 0xda, 0x5c, + /*a0b0:*/ 0x9b, 0x42, 0x5c, 0xab, 0x7b, 0xb8, 0x65, 0x41, 0xb2, 0x6e, 0x74, 0x64, 0x45, 0xc0, 0xe7, 0x24, + /*a0c0:*/ 0xf4, 0x64, 0xd8, 0x95, 0x0c, 0x7a, 0xf9, 0x8c, 0x08, 0xf6, 0xd1, 0xe8, 0x36, 0xbc, 0x9f, 0x1e, + /*a0d0:*/ 0x46, 0xa8, 0xfa, 0xe9, 0xf6, 0x36, 0x00, 0xf3, 0x1d, 0x5b, 0x63, 0xdc, 0xe0, 0xe7, 0x3f, 0xb6, + /*a0e0:*/ 0xb3, 0x2b, 0x74, 0x8d, 0xfb, 0x5e, 0x37, 0x41, 0x51, 0x1f, 0x82, 0x89, 0x37, 0x26, 0x7d, 0x1e, + /*a0f0:*/ 0x7e, 0x37, 0xf1, 0xb4, 0xcc, 0x65, 0x19, 0xe5, 0x99, 0x41, 0x4d, 0x93, 0x52, 0x7b, 0x2b, 0xa4, + /*a100:*/ 0xb7, 0x31, 0x13, 0x64, 0xdd, 0xed, 0x04, 0x94, 0x22, 0x7e, 0x35, 0xdb, 0xb5, 0xc7, 0xf2, 0x82, + /*a110:*/ 0x8d, 0xdf, 0x99, 0x41, 0x65, 0x8c, 0xd7, 0xbe, 0x8b, 0xbf, 0xf8, 0x28, 0x07, 0x33, 0x76, 0x7b, + /*a120:*/ 0x17, 0xc5, 0x83, 0x06, 0x63, 0xf5, 0x0c, 0x6a, 0xc8, 0x56, 0x42, 0x13, 0xa5, 0x28, 0x85, 0xba, + /*a130:*/ 0xb2, 0x25, 0x2d, 0x95, 0xf2, 0xff, 0x40, 0x20, 0x68, 0xd8, 0x11, 0xfc, 0xf4, 0x02, 0x76, 0x99, + /*a140:*/ 0xcf, 0x58, 0x0a, 0xa0, 0x6e, 0x2e, 0x13, 0xfd, 0x57, 0x66, 0x0b, 0xea, 0x05, 0x52, 0xc9, 0x8d, + /*a150:*/ 0xf8, 0xff, 0x68, 0x08, 0xc4, 0x10, 0xfd, 0x6d, 0x11, 0xa7, 0x40, 0xcb, 0xe6, 0xc6, 0x67, 0xbc, + /*a160:*/ 0x5b, 0xaa, 0xfc, 0xaf, 0xa9, 0x0e, 0xe0, 0x41, 0x8e, 0xa3, 0x83, 0x3e, 0xd6, 0x53, 0xe6, 0x77, + /*a170:*/ 0xfb, 0x1e, 0xcd, 0xfe, 0x06, 0x71, 0x0d, 0xc4, 0xf5, 0xff, 0xbc, 0xef, 0xbf, 0x0c, 0x58, 0xee, + /*a180:*/ 0xe2, 0x51, 0xf5, 0x32, 0xe9, 0x14, 0x46, 0x13, 0xc7, 0x2a, 0xd9, 0x91, 0x2b, 0xf1, 0x68, 0xce, + /*a190:*/ 0x14, 0xfd, 0xf7, 0x48, 0x1b, 0x08, 0x26, 0xdb, 0xc6, 0xdf, 0x1d, 0x4a, 0xc8, 0xac, 0xf2, 0x9b, + /*a1a0:*/ 0x23, 0xce, 0x72, 0xff, 0x3d, 0xdc, 0x4a, 0x9b, 0xe6, 0x6b, 0xcd, 0x3d, 0x07, 0xb3, 0x65, 0x58, + /*a1b0:*/ 0x08, 0x00, 0xea, 0x68, 0x65, 0x40, 0xb0, 0x0e, 0xfc, 0x37, 0x9a, 0x3b, 0xe2, 0x14, 0x9c, 0xdf, + /*a1c0:*/ 0x74, 0x1b, 0x7a, 0xc2, 0xf6, 0x5d, 0x2e, 0xdd, 0xdd, 0xf1, 0x9d, 0x7b, 0x6c, 0xf5, 0xe8, 0xc2, + /*a1d0:*/ 0x3f, 0x5b, 0xb3, 0xe0, 0xc7, 0xf4, 0xc3, 0x60, 0x81, 0x9a, 0xff, 0x4a, 0x50, 0xbf, 0xff, 0x14, + /*a1e0:*/ 0x9a, 0xea, 0x5e, 0x7b, 0x5f, 0xeb, 0xad, 0xf1, 0x40, 0x19, 0x67, 0x45, 0x6b, 0x69, 0x18, 0x55, + /*a1f0:*/ 0xb6, 0x39, 0x32, 0x15, 0xd0, 0xad, 0xb5, 0x66, 0xb2, 0x43, 0x13, 0x27, 0x90, 0xc8, 0x82, 0x7f, + /*a200:*/ 0x65, 0x0e, 0xc4, 0x4f, 0xec, 0xa5, 0xa0, 0x93, 0x72, 0x4e, 0x1c, 0xfd, 0xae, 0x29, 0x7f, 0x52, + /*a210:*/ 0xde, 0x65, 0xd4, 0xc4, 0x41, 0x48, 0xf3, 0xe7, 0x7b, 0xe9, 0xcc, 0x40, 0xd4, 0xfd, 0xa9, 0x72, + /*a220:*/ 0xe9, 0x22, 0x3a, 0xc9, 0xd2, 0x95, 0xd7, 0x84, 0xf4, 0x00, 0x05, 0x1c, 0xd7, 0x06, 0xa5, 0x02, + /*a230:*/ 0x41, 0xf2, 0x95, 0xb9, 0x46, 0x25, 0xf1, 0x27, 0x4f, 0xaa, 0x34, 0x8d, 0x1d, 0x06, 0x1f, 0x43, + /*a240:*/ 0x69, 0x13, 0x99, 0xcd, 0x6a, 0xd2, 0xa0, 0x6f, 0x47, 0x36, 0x39, 0xda, 0xdd, 0x73, 0x07, 0x58, + /*a250:*/ 0x6e, 0x4c, 0x2a, 0xd1, 0x8a, 0x1b, 0xfc, 0xcd, 0x22, 0xed, 0xb9, 0x43, 0xb6, 0x28, 0xfd, 0x58, + /*a260:*/ 0xa5, 0x03, 0x30, 0xd4, 0x5a, 0xca, 0x12, 0xb2, 0x8d, 0x06, 0x42, 0x26, 0x72, 0x71, 0xef, 0xf5, + /*a270:*/ 0x09, 0x89, 0x86, 0xf1, 0xd9, 0xb2, 0xa6, 0xc1, 0x7d, 0xa2, 0x8c, 0xbc, 0x31, 0xfa, 0x2a, 0xd2, + /*a280:*/ 0x3c, 0xd3, 0xf4, 0x60, 0x9c, 0x23, 0xf7, 0xc8, 0x17, 0xf0, 0xd2, 0x89, 0x25, 0xff, 0x45, 0x26, + /*a290:*/ 0x5a, 0xa7, 0x68, 0x96, 0x72, 0xca, 0xba, 0x5e, 0xab, 0x97, 0x6d, 0xba, 0xb9, 0x05, 0x91, 0x92, + /*a2a0:*/ 0xa5, 0xa1, 0x02, 0x1a, 0x82, 0xaa, 0xa9, 0xf2, 0x51, 0x96, 0x78, 0x25, 0xae, 0x82, 0x89, 0x55, + /*a2b0:*/ 0xba, 0x05, 0xd0, 0x4c, 0x86, 0x6b, 0x61, 0x9b, 0x77, 0x4c, 0x8d, 0x6f, 0x7a, 0xac, 0x58, 0x82, + /*a2c0:*/ 0xcb, 0xf3, 0xca, 0xe2, 0x7f, 0x9f, 0xbb, 0x69, 0x77, 0x23, 0x15, 0x5b, 0x72, 0x2d, 0x6c, 0x4f, + /*a2d0:*/ 0x20, 0x38, 0x5a, 0x5a, 0x37, 0xd8, 0x2e, 0x71, 0x33, 0x4a, 0x14, 0x56, 0xbb, 0x04, 0xc7, 0xb3, + /*a2e0:*/ 0xd8, 0x33, 0x1c, 0xa4, 0xd5, 0x57, 0xbf, 0x10, 0xda, 0x1c, 0x30, 0x15, 0x87, 0x87, 0xc2, 0x28, + /*a2f0:*/ 0xf6, 0x6c, 0x0d, 0x11, 0x1f, 0xb9, 0x87, 0x86, 0x67, 0x77, 0xbf, 0xee, 0xf6, 0x6d, 0x01, 0x6c, + /*a300:*/ 0xb4, 0x00, 0x91, 0x0e, 0xf4, 0x0b, 0x45, 0x85, 0x9e, 0x47, 0x4b, 0xe0, 0x73, 0xc8, 0x7f, 0xc3, + /*a310:*/ 0xd7, 0x38, 0x5c, 0x3d, 0x75, 0x0a, 0x48, 0xc6, 0x25, 0xb1, 0x2d, 0xdf, 0xc1, 0xd2, 0xfe, 0xd8, + /*a320:*/ 0x63, 0xf0, 0x46, 0xe8, 0x63, 0xb6, 0x72, 0xe3, 0x82, 0xbb, 0x31, 0x2f, 0x12, 0xfb, 0x10, 0x01, + /*a330:*/ 0xe4, 0xe2, 0x73, 0xe2, 0x08, 0x2d, 0x1e, 0x60, 0x90, 0x8a, 0x49, 0x9f, 0xf3, 0x9a, 0x97, 0x4d, + /*a340:*/ 0x62, 0xa2, 0x8a, 0xee, 0x27, 0x5f, 0x17, 0xfb, 0x36, 0x2b, 0xef, 0x7d, 0xcf, 0x74, 0xce, 0xa0, + /*a350:*/ 0x4d, 0x99, 0x34, 0x50, 0xa9, 0x49, 0x57, 0x20, 0x44, 0xd3, 0x84, 0xc9, 0xac, 0xba, 0xe6, 0x5b, + /*a360:*/ 0xd2, 0xd1, 0x91, 0xc6, 0x7a, 0xea, 0x3c, 0x0f, 0x4a, 0xc6, 0x30, 0xaa, 0x80, 0xbd, 0x72, 0x0d, + /*a370:*/ 0x83, 0xa2, 0x65, 0x47, 0x47, 0x80, 0x80, 0xf5, 0xab, 0xf6, 0x4c, 0x15, 0x6d, 0x99, 0x63, 0x06, + /*a380:*/ 0xea, 0xb7, 0x5a, 0x6e, 0x5b, 0x70, 0x4c, 0x00, 0x72, 0x0d, 0x27, 0xb7, 0xd0, 0x81, 0xe9, 0xee, + /*a390:*/ 0x23, 0x95, 0xce, 0xc6, 0xa7, 0x71, 0xb5, 0xd9, 0x8f, 0xe5, 0xed, 0xba, 0x88, 0x62, 0x44, 0xbd, + /*a3a0:*/ 0x1a, 0x76, 0x49, 0x41, 0xfd, 0x4f, 0x9e, 0x1d, 0x6e, 0xfc, 0x9e, 0x62, 0xc2, 0xd3, 0x54, 0x1b, + /*a3b0:*/ 0xf4, 0x69, 0xf0, 0x29, 0xf4, 0xbb, 0x32, 0x5a, 0x1f, 0x5f, 0x70, 0xe3, 0xe6, 0x86, 0x03, 0xe7, + /*a3c0:*/ 0x85, 0xbd, 0x29, 0x9c, 0x1a, 0xb3, 0xae, 0xa6, 0xca, 0xbf, 0x4f, 0x47, 0xc1, 0xb3, 0x52, 0xd2, + /*a3d0:*/ 0xf1, 0x50, 0x51, 0x23, 0xd6, 0x60, 0x55, 0x61, 0x41, 0xec, 0xf3, 0x23, 0xb7, 0x8f, 0x1c, 0x15, + /*a3e0:*/ 0x60, 0x8c, 0xd7, 0x79, 0x0b, 0x77, 0x19, 0x4e, 0x04, 0x42, 0xb0, 0x5c, 0xb9, 0x0c, 0xb9, 0x4a, + /*a3f0:*/ 0x0b, 0x2b, 0xf3, 0xd7, 0x4a, 0xd1, 0x46, 0xc2, 0x80, 0xf1, 0xab, 0xac, 0x19, 0xb6, 0x69, 0x2b, + /*a400:*/ 0x7d, 0x0b, 0x05, 0xbb, 0x27, 0x37, 0x80, 0x65, 0x98, 0x60, 0x25, 0xe3, 0xab, 0x75, 0x2a, 0xac, + /*a410:*/ 0x6a, 0xb0, 0x3a, 0x41, 0x09, 0xcb, 0x85, 0x49, 0xa8, 0x88, 0x6f, 0x9c, 0x07, 0xef, 0x96, 0xca, + /*a420:*/ 0xd6, 0x14, 0x41, 0xbf, 0xe7, 0x3a, 0x35, 0xc1, 0x7a, 0x75, 0x3a, 0x2e, 0x9f, 0x7a, 0xd2, 0xfc, + /*a430:*/ 0xb0, 0x9d, 0x46, 0xd6, 0xb8, 0xa9, 0x69, 0x19, 0x4a, 0x1d, 0x48, 0xf5, 0xbb, 0x22, 0x78, 0x41, + /*a440:*/ 0x21, 0xbc, 0x25, 0xd2, 0xb9, 0x00, 0x4b, 0xcd, 0x4e, 0x16, 0x06, 0x91, 0x2b, 0xb9, 0x12, 0xbc, + /*a450:*/ 0x57, 0xa0, 0x41, 0x60, 0x88, 0x76, 0xa0, 0xe7, 0xe6, 0xc9, 0x16, 0x62, 0x70, 0x79, 0x56, 0xe3, + /*a460:*/ 0xa4, 0x03, 0x9d, 0x46, 0x62, 0xb3, 0x1b, 0x42, 0x1b, 0x2d, 0x11, 0x83, 0xba, 0x35, 0xa7, 0x8d, + /*a470:*/ 0x38, 0xb7, 0xfa, 0xa4, 0x4c, 0x02, 0x1c, 0x60, 0x47, 0x62, 0x96, 0xbe, 0x83, 0x15, 0x9f, 0x31, + /*a480:*/ 0xd5, 0x84, 0x2a, 0x8e, 0x7e, 0xb1, 0xba, 0x69, 0x09, 0xa2, 0x68, 0xfa, 0xf9, 0xf0, 0xd3, 0x47, + /*a490:*/ 0x3c, 0x10, 0x50, 0x4c, 0x7f, 0x3b, 0x2d, 0x56, 0x0f, 0xa4, 0xea, 0x83, 0xc5, 0x94, 0x02, 0x86, + /*a4a0:*/ 0x24, 0x10, 0xae, 0x94, 0x7e, 0x8e, 0xdb, 0xe1, 0xda, 0x9f, 0xd5, 0x79, 0x1f, 0x74, 0x75, 0x81, + /*a4b0:*/ 0x86, 0x71, 0xce, 0xf6, 0x47, 0x93, 0xb4, 0xad, 0x0e, 0x3f, 0x02, 0x8b, 0xd9, 0xaa, 0xea, 0x19, + /*a4c0:*/ 0x94, 0x6e, 0x43, 0xaa, 0xd6, 0x85, 0x5c, 0x07, 0x52, 0xd0, 0xde, 0xad, 0x23, 0x14, 0x09, 0x0c, + /*a4d0:*/ 0xf9, 0xab, 0x4b, 0x77, 0x4d, 0x26, 0xa3, 0x05, 0x61, 0x06, 0x32, 0xe4, 0xac, 0x89, 0xb8, 0xbe, + /*a4e0:*/ 0x85, 0x80, 0xde, 0xf0, 0xdb, 0x36, 0x1b, 0x68, 0x62, 0x86, 0xa0, 0x72, 0x71, 0x62, 0x7f, 0xd3, + /*a4f0:*/ 0xbf, 0x14, 0x3b, 0x1f, 0x84, 0x63, 0x47, 0x20, 0x09, 0x42, 0x57, 0xb6, 0x72, 0x09, 0xa8, 0xac, + /*a500:*/ 0xb0, 0x9b, 0xdf, 0x64, 0x4f, 0x47, 0xe4, 0x03, 0x72, 0x91, 0x88, 0x9d, 0x71, 0x13, 0x9f, 0xf2, + /*a510:*/ 0xf0, 0x90, 0x1b, 0xf8, 0x3c, 0x98, 0xff, 0x75, 0x63, 0xb4, 0x83, 0x9c, 0x28, 0x0a, 0x3b, 0x7d, + /*a520:*/ 0xda, 0xcc, 0xff, 0x1b, 0x5b, 0x20, 0x19, 0xb9, 0x54, 0xcf, 0xf6, 0x56, 0x9c, 0xb7, 0x73, 0xa3, + /*a530:*/ 0xbc, 0x12, 0x86, 0x03, 0xe5, 0x00, 0x9f, 0xf5, 0x27, 0xdd, 0xa0, 0xbd, 0x33, 0xe4, 0x31, 0x8e, + /*a540:*/ 0x04, 0xb7, 0x98, 0x16, 0x6d, 0x8c, 0x6c, 0x27, 0x91, 0x34, 0x70, 0x90, 0xca, 0x5f, 0x80, 0x9a, + /*a550:*/ 0xf9, 0x33, 0xf5, 0x26, 0xcd, 0xee, 0x48, 0xfc, 0xde, 0x3d, 0x69, 0xd7, 0x57, 0x94, 0x8e, 0xa1, + /*a560:*/ 0xda, 0x9e, 0x53, 0x93, 0x45, 0x53, 0x43, 0xa7, 0x33, 0x9c, 0x2d, 0x4b, 0x77, 0xe4, 0x65, 0x3f, + /*a570:*/ 0xce, 0x65, 0xa7, 0x47, 0xe1, 0x25, 0xbe, 0x56, 0xd8, 0xa6, 0xb7, 0x81, 0x8b, 0x77, 0x74, 0x74, + /*a580:*/ 0xa9, 0x66, 0xe5, 0x57, 0xa8, 0x69, 0x41, 0xc1, 0xff, 0x69, 0xa7, 0x76, 0x10, 0xd5, 0xab, 0x08, + /*a590:*/ 0x15, 0xb1, 0x7f, 0xa2, 0x33, 0xbe, 0x71, 0xae, 0x2c, 0x49, 0x45, 0x17, 0xba, 0x0c, 0xe0, 0xc1, + /*a5a0:*/ 0x6c, 0x2f, 0x12, 0x72, 0xa8, 0x84, 0x96, 0x8e, 0x33, 0x13, 0xb2, 0xea, 0x3a, 0x6a, 0x47, 0xb3, + /*a5b0:*/ 0xf3, 0x79, 0xbf, 0xf6, 0x61, 0x97, 0xbf, 0xd4, 0xe0, 0xcc, 0x23, 0xa8, 0x37, 0x21, 0xeb, 0x6e, + /*a5c0:*/ 0x20, 0x07, 0x4f, 0x93, 0x2d, 0x42, 0xf0, 0xba, 0x97, 0x8e, 0xfe, 0x33, 0xe5, 0x70, 0x6c, 0x1f, + /*a5d0:*/ 0x1f, 0xac, 0xd2, 0x48, 0xee, 0x4d, 0x50, 0xc2, 0x26, 0x93, 0x11, 0x08, 0x1a, 0x5d, 0x05, 0x4c, + /*a5e0:*/ 0xf9, 0x2a, 0x27, 0xfa, 0x1f, 0xfa, 0xcd, 0x60, 0xee, 0xa1, 0xf8, 0x61, 0xed, 0xc4, 0xb3, 0x6f, + /*a5f0:*/ 0x53, 0xb2, 0xd2, 0x4a, 0x62, 0xbe, 0x11, 0xd3, 0x88, 0x1f, 0x64, 0xb2, 0xc9, 0x42, 0x87, 0xa8, + /*a600:*/ 0xa0, 0xd6, 0xb3, 0x78, 0x9d, 0xcb, 0x7f, 0xec, 0x7f, 0xb9, 0xad, 0x23, 0x78, 0x1f, 0x5f, 0xd0, + /*a610:*/ 0x3f, 0x61, 0x45, 0xf3, 0x55, 0xee, 0xd1, 0xd6, 0x2c, 0x59, 0x20, 0x1c, 0x6e, 0xd7, 0xaa, 0xf0, + /*a620:*/ 0xf2, 0x4b, 0x77, 0x95, 0x93, 0x68, 0x0a, 0xc8, 0x31, 0x06, 0x01, 0xf9, 0x58, 0xc8, 0xb0, 0x49, + /*a630:*/ 0xe3, 0x87, 0x5f, 0x5e, 0xd1, 0x95, 0xbe, 0xf6, 0xcc, 0xf2, 0xbb, 0xb9, 0x5d, 0xa7, 0x9e, 0x4d, + /*a640:*/ 0xde, 0x0e, 0x52, 0xe0, 0xf2, 0x88, 0x3b, 0xca, 0x7c, 0x74, 0x0f, 0x76, 0x6c, 0xb5, 0xa2, 0xab, + /*a650:*/ 0xb2, 0x02, 0xdc, 0xae, 0x83, 0x7b, 0xd8, 0x01, 0x24, 0x11, 0x49, 0xe9, 0x58, 0x00, 0xad, 0x54, + /*a660:*/ 0x89, 0xa6, 0x84, 0x7e, 0x79, 0x20, 0x6a, 0xf8, 0x5e, 0xc3, 0x25, 0x29, 0xb7, 0x15, 0x8b, 0xaa, + /*a670:*/ 0x67, 0xf4, 0x08, 0x88, 0x75, 0xe0, 0xee, 0x5e, 0x40, 0xb0, 0x93, 0x77, 0x44, 0x1e, 0xe6, 0x92, + /*a680:*/ 0xe9, 0x54, 0xfc, 0x8c, 0x9c, 0x03, 0x2b, 0x8e, 0x4a, 0x04, 0x3d, 0x76, 0xa4, 0x07, 0xe2, 0x62, + /*a690:*/ 0xfb, 0x17, 0xab, 0x7c, 0x32, 0x69, 0xb7, 0xb8, 0x53, 0x4a, 0x6a, 0xe2, 0x9c, 0xd8, 0xf1, 0x7c, + /*a6a0:*/ 0x31, 0xfd, 0x2e, 0xdc, 0xb8, 0xce, 0xf0, 0xa3, 0x90, 0xe4, 0xc1, 0xa1, 0xf8, 0xda, 0xb9, 0x74, + /*a6b0:*/ 0x95, 0x9e, 0x2f, 0xcf, 0x74, 0x90, 0x5e, 0x10, 0x2c, 0xf7, 0x8f, 0x82, 0xa6, 0x6d, 0x97, 0xb2, + /*a6c0:*/ 0x25, 0x44, 0x5b, 0xae, 0x03, 0x6a, 0x09, 0xe8, 0x69, 0x9b, 0xdf, 0x34, 0x57, 0x5e, 0x1b, 0x58, + /*a6d0:*/ 0x36, 0x4a, 0x79, 0x26, 0x1a, 0x6f, 0x4e, 0xa1, 0xf6, 0xfd, 0xa9, 0x6a, 0xd4, 0xb6, 0x2c, 0x1e, + /*a6e0:*/ 0x54, 0xee, 0x6a, 0x3d, 0x13, 0xed, 0x98, 0xb9, 0xd1, 0xc7, 0x40, 0x3b, 0xb1, 0x08, 0x74, 0xf2, + /*a6f0:*/ 0x9e, 0x23, 0x70, 0x0f, 0xfe, 0xcf, 0xe0, 0x42, 0x94, 0xb9, 0xfb, 0x1a, 0xf5, 0xfa, 0xee, 0xe5, + /*a700:*/ 0x60, 0xf3, 0x74, 0x2e, 0x8a, 0x6b, 0x45, 0xbe, 0x6f, 0x0e, 0x98, 0xa8, 0xe4, 0x39, 0x81, 0xdf, + /*a710:*/ 0xd1, 0x0e, 0x17, 0xfc, 0xd1, 0xfe, 0x65, 0xa6, 0xe0, 0xe0, 0x3a, 0xd2, 0xe6, 0xb5, 0xe7, 0x50, + /*a720:*/ 0x08, 0x6a, 0x16, 0x66, 0x2e, 0x7f, 0x9d, 0x24, 0xbb, 0x88, 0xa8, 0x39, 0xac, 0xe4, 0x83, 0xf1, + /*a730:*/ 0x82, 0x24, 0x25, 0xbc, 0x70, 0x61, 0x83, 0xf8, 0x33, 0x88, 0xee, 0xd7, 0x03, 0x31, 0x88, 0x22, + /*a740:*/ 0x06, 0xee, 0x65, 0x98, 0x1c, 0x79, 0x74, 0x8d, 0x62, 0xda, 0x8c, 0x4d, 0xa6, 0x65, 0x39, 0x0b, + /*a750:*/ 0xbb, 0xaa, 0x7b, 0x3e, 0xc7, 0x21, 0x34, 0xbc, 0x1a, 0xd0, 0x83, 0x0d, 0x28, 0x32, 0x03, 0xd6, + /*a760:*/ 0x1d, 0x57, 0x40, 0x62, 0xd3, 0xba, 0x59, 0xdd, 0x21, 0x3a, 0xb6, 0xcc, 0x9f, 0xd9, 0x48, 0xa1, + /*a770:*/ 0x5f, 0x79, 0xb0, 0x25, 0x6f, 0x8b, 0x9c, 0x9a, 0x38, 0x02, 0x45, 0xfb, 0xc4, 0x4c, 0x19, 0x6a, + /*a780:*/ 0x80, 0x89, 0x53, 0xfc, 0x16, 0x92, 0xa2, 0x65, 0x6f, 0x49, 0xca, 0x34, 0x44, 0xd7, 0x47, 0xb1, + /*a790:*/ 0xca, 0xcb, 0x6f, 0x1b, 0x4e, 0xad, 0x40, 0x93, 0x3e, 0x17, 0x51, 0x24, 0xc7, 0xa4, 0x91, 0x94, + /*a7a0:*/ 0x85, 0xbc, 0x2e, 0x1a, 0xc0, 0x60, 0x26, 0xb9, 0x50, 0x3b, 0x40, 0xb0, 0x35, 0x85, 0xb7, 0x1f, + /*a7b0:*/ 0x06, 0x30, 0x1e, 0x8e, 0x23, 0xf2, 0xad, 0x79, 0xe5, 0x6e, 0xfa, 0xf6, 0x68, 0x11, 0xdc, 0xce, + /*a7c0:*/ 0x35, 0xe2, 0x8e, 0xcb, 0x2d, 0xe1, 0x00, 0x4b, 0x47, 0xeb, 0x86, 0x23, 0x94, 0xfb, 0xa2, 0x30, + /*a7d0:*/ 0xf5, 0x36, 0x9e, 0x94, 0xc9, 0x80, 0x16, 0xdc, 0x57, 0x9e, 0xb5, 0x8a, 0x0c, 0x0e, 0xcb, 0x28, + /*a7e0:*/ 0xf4, 0x5f, 0x4d, 0xc2, 0xa3, 0x6a, 0x07, 0x86, 0xda, 0xf4, 0x6c, 0x4e, 0xc8, 0xa1, 0xac, 0x9b, + /*a7f0:*/ 0x15, 0xd7, 0x86, 0x2c, 0x83, 0x2d, 0x5a, 0x83, 0x51, 0x6a, 0xd5, 0x1b, 0x92, 0xf7, 0x63, 0x8b, + /*a800:*/ 0x1d, 0x94, 0xc5, 0x1c, 0x6d, 0x85, 0xb1, 0x77, 0x54, 0x86, 0x46, 0xc4, 0x42, 0x73, 0x6e, 0xf2, + /*a810:*/ 0x81, 0x4a, 0xb0, 0xac, 0x34, 0x32, 0xe6, 0x00, 0x93, 0x55, 0xe6, 0x78, 0x31, 0xb8, 0xc4, 0x9c, + /*a820:*/ 0xe0, 0xdd, 0x9d, 0xa4, 0x67, 0x6c, 0x8c, 0x64, 0xf1, 0xd6, 0x5d, 0x4a, 0x2e, 0xff, 0x6e, 0x7e, + /*a830:*/ 0xc5, 0x09, 0x8e, 0x27, 0xbe, 0x1e, 0xc4, 0xe3, 0x8b, 0x6b, 0x4b, 0x72, 0xb6, 0x18, 0xf3, 0x69, + /*a840:*/ 0x0e, 0x2e, 0xda, 0xb3, 0x0b, 0x35, 0x1a, 0xb2, 0x17, 0xa6, 0x25, 0x96, 0xbc, 0xe8, 0x41, 0xdb, + /*a850:*/ 0xc5, 0x76, 0xa3, 0xe9, 0x11, 0xf1, 0xc1, 0xe0, 0xde, 0x91, 0x1b, 0x26, 0x93, 0x9c, 0xd6, 0xe9, + /*a860:*/ 0x3a, 0xb8, 0x91, 0xd5, 0x02, 0x1b, 0x7a, 0x0c, 0x3e, 0x0a, 0x01, 0xe0, 0x4b, 0xdc, 0xd7, 0xa4, + /*a870:*/ 0x41, 0x19, 0x3a, 0xd5, 0xa9, 0x3d, 0x9e, 0x51, 0x01, 0xa2, 0xb4, 0xbf, 0xf3, 0xbf, 0x54, 0xe0, + /*a880:*/ 0xdc, 0x29, 0xdc, 0x44, 0xd9, 0x6d, 0xd0, 0x93, 0x45, 0x59, 0x78, 0xa7, 0xce, 0x43, 0x2e, 0x60, + /*a890:*/ 0xae, 0xab, 0x59, 0x9f, 0x4b, 0xfe, 0x8e, 0x43, 0x5c, 0xd8, 0xbd, 0x59, 0xa4, 0x6e, 0x9d, 0xab, + /*a8a0:*/ 0xf1, 0xb6, 0x24, 0x4a, 0x05, 0x39, 0x4b, 0xbd, 0x66, 0x55, 0xcf, 0x43, 0xd4, 0x59, 0xc6, 0x0d, + /*a8b0:*/ 0x1b, 0x08, 0xe5, 0x5b, 0x15, 0xc9, 0x40, 0x30, 0xc4, 0x82, 0xfb, 0xf9, 0xd8, 0xee, 0x89, 0x81, + /*a8c0:*/ 0x9c, 0xa1, 0x5c, 0xd5, 0x4a, 0x76, 0x1d, 0x57, 0xa0, 0x9e, 0xb8, 0x7d, 0x10, 0x86, 0x99, 0x5b, + /*a8d0:*/ 0x96, 0x08, 0x92, 0x19, 0xca, 0xb4, 0xef, 0x92, 0x4f, 0x80, 0x80, 0x5f, 0xe1, 0xf8, 0x89, 0x72, + /*a8e0:*/ 0xc0, 0x51, 0xf5, 0xa4, 0xda, 0x24, 0xca, 0x43, 0xf3, 0x4e, 0x3a, 0x72, 0x88, 0x3d, 0x1d, 0x36, + /*a8f0:*/ 0xa6, 0xdb, 0x52, 0x3e, 0x8c, 0x41, 0x16, 0xb7, 0x5c, 0x0a, 0x64, 0x2a, 0x53, 0x62, 0x28, 0x67, + /*a900:*/ 0xa4, 0x5d, 0x75, 0x75, 0x4e, 0x45, 0x80, 0x6b, 0xb7, 0xc8, 0x84, 0xaa, 0xe9, 0x53, 0x7e, 0x86, + /*a910:*/ 0x2e, 0x80, 0x39, 0x72, 0x3b, 0x03, 0xd2, 0x8a, 0xe9, 0xa6, 0xd0, 0xfc, 0x2e, 0xe4, 0x87, 0xd1, + /*a920:*/ 0xc3, 0x2b, 0x42, 0x46, 0xe6, 0xe4, 0x38, 0xa1, 0x0c, 0x18, 0xe4, 0x31, 0xd4, 0xd1, 0xd3, 0x50, + /*a930:*/ 0xcb, 0xd0, 0x67, 0x68, 0x15, 0x8e, 0x47, 0x85, 0x4b, 0x94, 0x13, 0x8b, 0x2c, 0x66, 0xa0, 0x2f, + /*a940:*/ 0xd3, 0xf8, 0x7a, 0xcc, 0xb4, 0xb4, 0x26, 0xb7, 0xbd, 0x2c, 0xff, 0xaa, 0x93, 0xfb, 0xa0, 0xc0, + /*a950:*/ 0xc3, 0x55, 0x3b, 0x98, 0xe6, 0xac, 0x75, 0xd0, 0x0b, 0x3a, 0x7c, 0xd0, 0xe1, 0x45, 0x3f, 0x4b, + /*a960:*/ 0xc2, 0xe1, 0x72, 0xbd, 0xda, 0x91, 0xd8, 0x4d, 0x1e, 0x37, 0xdb, 0x09, 0xf6, 0xb6, 0x84, 0x90, + /*a970:*/ 0xdb, 0xde, 0xb4, 0x45, 0xed, 0x6b, 0x85, 0x15, 0x41, 0x8e, 0x04, 0x62, 0x10, 0x31, 0x75, 0x75, + /*a980:*/ 0xa2, 0xce, 0x16, 0xa0, 0xdd, 0x28, 0x98, 0x39, 0xf8, 0x15, 0xcc, 0x93, 0x75, 0xc4, 0xf1, 0xa1, + /*a990:*/ 0xc7, 0xab, 0x0e, 0x86, 0x54, 0x70, 0x2f, 0x39, 0x76, 0x49, 0x20, 0x87, 0x42, 0x6e, 0x37, 0x7b, + /*a9a0:*/ 0x31, 0x8d, 0x72, 0xf3, 0x97, 0xae, 0x38, 0xb7, 0x63, 0x38, 0xb3, 0x65, 0x86, 0xa2, 0x0b, 0xaa, + /*a9b0:*/ 0x6a, 0x16, 0xf0, 0xe6, 0xf4, 0xd0, 0x29, 0x66, 0xbb, 0x6c, 0xd0, 0x2e, 0x86, 0x44, 0xe8, 0x39, + /*a9c0:*/ 0xd1, 0x37, 0x50, 0xd3, 0x5c, 0xdd, 0x5a, 0xf4, 0xc0, 0x08, 0x35, 0x82, 0xd9, 0xdf, 0x76, 0xc8, + /*a9d0:*/ 0x65, 0x54, 0x18, 0xf3, 0xf3, 0x48, 0xfc, 0x03, 0x0d, 0x2e, 0xee, 0xdb, 0xd8, 0x89, 0x47, 0x1a, + /*a9e0:*/ 0xd1, 0x90, 0xaf, 0xe7, 0x87, 0x92, 0xb0, 0x32, 0x02, 0x7d, 0x5b, 0xd1, 0x75, 0xa9, 0xd0, 0xfc, + /*a9f0:*/ 0x0e, 0x02, 0x64, 0x31, 0xba, 0xc0, 0x40, 0xfc, 0x48, 0xc5, 0x74, 0x6c, 0xbb, 0x76, 0x05, 0x2b, + /*aa00:*/ 0x92, 0xd0, 0xed, 0xd4, 0x1e, 0x87, 0x63, 0xba, 0x01, 0x0a, 0xf9, 0xb3, 0xe3, 0x3a, 0xbf, 0x34, + /*aa10:*/ 0x4d, 0x92, 0x00, 0xc4, 0xf4, 0x13, 0x65, 0x72, 0xaf, 0x4f, 0x1e, 0xa9, 0x35, 0xc9, 0x3b, 0x76, + /*aa20:*/ 0xba, 0x0b, 0x34, 0x4f, 0xaf, 0xcf, 0x13, 0x39, 0x4a, 0xb0, 0xf3, 0x4c, 0x2e, 0x88, 0xfa, 0x4a, + /*aa30:*/ 0xde, 0xa1, 0x3b, 0xcf, 0x21, 0x2c, 0x0f, 0x2e, 0x32, 0xe6, 0x24, 0x83, 0xe5, 0x6b, 0x36, 0x21, + /*aa40:*/ 0x7f, 0xe1, 0x25, 0xa5, 0x49, 0xf0, 0xb5, 0x9f, 0x93, 0xe9, 0x59, 0x09, 0x19, 0x8f, 0x71, 0x6b, + /*aa50:*/ 0x08, 0x53, 0xfd, 0x6e, 0xdc, 0x53, 0x7b, 0xfe, 0x0f, 0xa2, 0x2b, 0x16, 0xca, 0xca, 0x31, 0x3d, + /*aa60:*/ 0x79, 0x13, 0x0b, 0x8a, 0x39, 0x1d, 0x9f, 0x70, 0x94, 0xc5, 0x3c, 0xa0, 0x3d, 0x2f, 0x73, 0xe0, + /*aa70:*/ 0x27, 0x37, 0x49, 0xe4, 0x84, 0xf5, 0xe6, 0x68, 0xfb, 0xab, 0x15, 0x76, 0xee, 0x65, 0x3c, 0xbf, + /*aa80:*/ 0x30, 0x90, 0x0c, 0x6d, 0x15, 0xfc, 0xa0, 0x1b, 0xb6, 0xa5, 0xea, 0x32, 0x63, 0x4f, 0x6b, 0x20, + /*aa90:*/ 0x0d, 0x04, 0xff, 0xaf, 0x95, 0xe4, 0x9b, 0xe8, 0xae, 0x91, 0x85, 0x3a, 0x6b, 0x9d, 0xa7, 0x3a, + /*aaa0:*/ 0x3b, 0x88, 0xd6, 0xc4, 0x28, 0x02, 0x17, 0x20, 0xfc, 0x2b, 0x8d, 0x73, 0x2f, 0xcb, 0xd4, 0x31, + /*aab0:*/ 0x4a, 0x30, 0xa5, 0x52, 0x56, 0xbd, 0xed, 0xb2, 0x88, 0x5d, 0xa7, 0xf6, 0xcf, 0xe2, 0x70, 0x7b, + /*aac0:*/ 0x46, 0x4f, 0x24, 0x65, 0xdb, 0xaf, 0x56, 0xef, 0x07, 0x30, 0x0b, 0xa6, 0x8f, 0xc3, 0x9e, 0x39, + /*aad0:*/ 0x0c, 0x91, 0xd8, 0x2b, 0x14, 0xa0, 0xc9, 0x93, 0x8a, 0x94, 0x22, 0xee, 0x81, 0x74, 0xbc, 0x12, + /*aae0:*/ 0x69, 0x0b, 0x3f, 0x4a, 0x3b, 0x79, 0x9b, 0x6f, 0x2f, 0x0d, 0x6f, 0xd0, 0x3f, 0xf8, 0x2d, 0x50, + /*aaf0:*/ 0x0a, 0xa0, 0xda, 0xb4, 0x0a, 0xf4, 0xda, 0xdb, 0x21, 0x85, 0x8b, 0xf9, 0x61, 0xa4, 0xe6, 0xda, + /*ab00:*/ 0x42, 0xf8, 0x02, 0x1e, 0x78, 0x34, 0x8c, 0xd2, 0xbd, 0xf0, 0x3b, 0x75, 0x5b, 0x0b, 0x7e, 0x91, + /*ab10:*/ 0x60, 0xcd, 0x20, 0xab, 0x04, 0x61, 0x9b, 0x45, 0x04, 0x53, 0x0d, 0x27, 0x27, 0x18, 0x27, 0x44, + /*ab20:*/ 0x14, 0xb0, 0xe2, 0x54, 0x7d, 0x41, 0xbc, 0x44, 0xf4, 0x94, 0xfe, 0xf3, 0xfa, 0x6a, 0x0f, 0xda, + /*ab30:*/ 0xe1, 0x7c, 0x5e, 0x72, 0x64, 0xe2, 0xe7, 0xd7, 0x81, 0x49, 0x69, 0x94, 0x9e, 0xee, 0xb6, 0x8a, + /*ab40:*/ 0x20, 0xf8, 0x19, 0x48, 0xc5, 0x9c, 0x7e, 0x25, 0xb6, 0xf6, 0xe6, 0x92, 0xba, 0xb0, 0x0d, 0x47, + /*ab50:*/ 0x9f, 0x4e, 0x40, 0x7f, 0x90, 0x6b, 0x56, 0xdc, 0x07, 0x4f, 0x88, 0xcb, 0xf0, 0x1f, 0x09, 0x1d, + /*ab60:*/ 0xad, 0x14, 0x36, 0x7e, 0x19, 0x32, 0xdd, 0x75, 0x3a, 0xc2, 0x46, 0xc6, 0xb4, 0xce, 0x11, 0xee, + /*ab70:*/ 0x5d, 0x15, 0xdd, 0xd0, 0xc5, 0xfc, 0x59, 0x39, 0x14, 0x0b, 0x87, 0x37, 0x71, 0x24, 0x33, 0x5d, + /*ab80:*/ 0xb6, 0x71, 0xea, 0x4c, 0xd8, 0x5b, 0x73, 0x3e, 0x7d, 0x40, 0x8b, 0x65, 0x16, 0xa1, 0x08, 0xf1, + /*ab90:*/ 0xfd, 0x2f, 0xab, 0xed, 0x8f, 0xeb, 0x7e, 0xfb, 0x40, 0x26, 0x66, 0xce, 0x05, 0x07, 0x6b, 0x65, + /*aba0:*/ 0x93, 0x00, 0x69, 0xbc, 0xdf, 0x11, 0x67, 0xf5, 0x39, 0x9a, 0xce, 0x51, 0xcf, 0x63, 0x90, 0xa5, + /*abb0:*/ 0xcc, 0x0b, 0xf9, 0x00, 0x44, 0xe4, 0x14, 0xc1, 0x16, 0xa6, 0x3f, 0x1b, 0x15, 0x2e, 0x7d, 0x3e, + /*abc0:*/ 0x86, 0xbd, 0xc5, 0x4a, 0x3b, 0xff, 0x2f, 0x9b, 0x73, 0x2b, 0x40, 0x1b, 0xa0, 0xb1, 0x51, 0x84, + /*abd0:*/ 0x76, 0x8b, 0x5e, 0x61, 0x32, 0xc1, 0xcc, 0xb6, 0xd8, 0x39, 0xce, 0xbb, 0xe6, 0x82, 0xf0, 0x72, + /*abe0:*/ 0x09, 0x07, 0xe5, 0x25, 0x98, 0x60, 0x02, 0x37, 0x29, 0x5a, 0x9f, 0xca, 0x83, 0x90, 0x85, 0x28, + /*abf0:*/ 0xa7, 0x88, 0xae, 0xb8, 0x77, 0xee, 0x61, 0x85, 0x32, 0x57, 0xb6, 0xf8, 0x3c, 0x69, 0x39, 0xc0, + /*ac00:*/ 0x3d, 0x78, 0x30, 0x86, 0x7a, 0x8f, 0x86, 0x4b, 0xe7, 0x0d, 0xb1, 0x6f, 0x4a, 0x21, 0x56, 0x40, + /*ac10:*/ 0xb8, 0xd6, 0x1e, 0x36, 0xca, 0xb0, 0x94, 0xb0, 0x1c, 0x84, 0x6b, 0x45, 0xe7, 0xee, 0x10, 0xf6, + /*ac20:*/ 0xdd, 0xa0, 0x32, 0x58, 0x04, 0xad, 0x5e, 0xd2, 0x99, 0x74, 0x78, 0x56, 0x78, 0x7e, 0x81, 0x0f, + /*ac30:*/ 0x2d, 0x2b, 0x86, 0x0d, 0x67, 0xd3, 0x00, 0xf8, 0xe5, 0xb0, 0x2b, 0xf9, 0x86, 0x8f, 0xf7, 0x48, + /*ac40:*/ 0x7d, 0xc0, 0xf6, 0x65, 0x55, 0xe2, 0xed, 0xb3, 0x17, 0xb5, 0x5c, 0xc7, 0xc2, 0xba, 0xf6, 0x51, + /*ac50:*/ 0xf9, 0x9b, 0x63, 0xd9, 0xf9, 0x31, 0xfe, 0xe2, 0x70, 0x50, 0x81, 0x09, 0x4c, 0xf6, 0x5a, 0x8c, + /*ac60:*/ 0x9c, 0xcf, 0x66, 0x48, 0xb7, 0x7c, 0x95, 0x9d, 0xbd, 0x3f, 0x65, 0x5d, 0x6b, 0x3d, 0xe1, 0x3e, + /*ac70:*/ 0x5c, 0x3a, 0xff, 0xcc, 0x19, 0xef, 0x3f, 0xa5, 0xe0, 0xaf, 0xa9, 0x58, 0x9f, 0xae, 0xb7, 0x7d, + /*ac80:*/ 0xad, 0xde, 0x83, 0x6f, 0xfa, 0x44, 0x1a, 0x44, 0x8f, 0x46, 0xed, 0x15, 0x73, 0xb4, 0x3d, 0x92, + /*ac90:*/ 0x56, 0xb5, 0x56, 0x42, 0xe6, 0x3d, 0xc4, 0x5a, 0xd9, 0xa7, 0x57, 0x01, 0x50, 0x06, 0x76, 0xf2, + /*aca0:*/ 0x20, 0xa5, 0x8f, 0xb0, 0xc5, 0xe8, 0x44, 0x51, 0xec, 0xf8, 0x36, 0x6f, 0x0e, 0xf6, 0xa8, 0xd4, + /*acb0:*/ 0x60, 0xe3, 0x01, 0xe5, 0xaf, 0xf9, 0xae, 0x1e, 0x6e, 0x5c, 0x6f, 0x2f, 0x29, 0xc3, 0xc3, 0xa5, + /*acc0:*/ 0xf4, 0xb8, 0x5f, 0x8e, 0x12, 0xab, 0x00, 0xaa, 0xbd, 0x06, 0x8a, 0x1e, 0xbb, 0x43, 0xc4, 0xbd, + /*acd0:*/ 0x9d, 0xe5, 0x6d, 0x6f, 0xad, 0xf7, 0x87, 0xfd, 0xc4, 0xd4, 0x65, 0x1e, 0xa5, 0xbc, 0x79, 0x88, + /*ace0:*/ 0x01, 0xdb, 0xd9, 0xaa, 0x2c, 0xde, 0x23, 0xfb, 0xee, 0x54, 0x92, 0x24, 0x70, 0x65, 0xd7, 0xbb, + /*acf0:*/ 0xfd, 0x33, 0x1e, 0x61, 0xa5, 0xd6, 0x97, 0x71, 0x1f, 0x9a, 0xf8, 0x72, 0xe1, 0x42, 0x40, 0x16, + /*ad00:*/ 0x73, 0xda, 0x68, 0xca, 0xe0, 0x46, 0xf0, 0xaa, 0x64, 0x0b, 0x8e, 0x0a, 0x36, 0x82, 0xd9, 0x63, + /*ad10:*/ 0x06, 0xc5, 0x84, 0x65, 0xea, 0xd7, 0xd1, 0x29, 0x00, 0xf1, 0xf3, 0x27, 0x7d, 0x1a, 0x7d, 0x42, + /*ad20:*/ 0xc3, 0x80, 0x5f, 0xb8, 0xaf, 0x37, 0x43, 0x96, 0x83, 0x65, 0xff, 0xe0, 0x71, 0x43, 0x83, 0x64, + /*ad30:*/ 0xe7, 0x88, 0x6e, 0xf5, 0x18, 0x92, 0x78, 0xd0, 0x1c, 0xa3, 0x3d, 0x5a, 0x01, 0xd0, 0xb6, 0xf2, + /*ad40:*/ 0xd7, 0x14, 0x28, 0x8c, 0x2c, 0xac, 0xdb, 0x35, 0x3e, 0x26, 0x52, 0x18, 0xfb, 0x5d, 0x07, 0x49, + /*ad50:*/ 0x19, 0x4c, 0x0c, 0x62, 0xab, 0x3b, 0x6c, 0x7b, 0x90, 0x41, 0x47, 0x30, 0xf9, 0x41, 0xe0, 0x59, + /*ad60:*/ 0xc9, 0xeb, 0x0a, 0xa6, 0x23, 0xad, 0x2d, 0xd5, 0x87, 0x20, 0xd4, 0xf9, 0x76, 0x7d, 0xfc, 0xfe, + /*ad70:*/ 0x19, 0x77, 0xef, 0x35, 0xb8, 0xeb, 0xca, 0x15, 0xd1, 0x46, 0xcb, 0x34, 0xef, 0xcf, 0x18, 0x8f, + /*ad80:*/ 0x77, 0xfe, 0x62, 0xb8, 0xa9, 0xcd, 0x47, 0xd7, 0x0c, 0xb6, 0x36, 0xaf, 0xde, 0x5a, 0x1d, 0x55, + /*ad90:*/ 0x76, 0x51, 0x64, 0x77, 0x90, 0x93, 0xab, 0x38, 0xeb, 0x97, 0x73, 0xcc, 0xa7, 0x1b, 0x0d, 0x1f, + /*ada0:*/ 0x8d, 0x77, 0x40, 0xb4, 0x66, 0x85, 0xbc, 0xda, 0x3a, 0xd4, 0xb0, 0x00, 0x5e, 0x9a, 0x97, 0xf1, + /*adb0:*/ 0x94, 0xb3, 0x1c, 0x53, 0x46, 0xf3, 0xbd, 0x4b, 0xa5, 0x92, 0xf1, 0xba, 0xad, 0xbf, 0xdd, 0x83, + /*adc0:*/ 0x45, 0x20, 0x58, 0x52, 0x23, 0xbf, 0x86, 0x9f, 0xe8, 0xb4, 0xef, 0x72, 0x17, 0xae, 0x86, 0x54, + /*add0:*/ 0xba, 0x7e, 0x47, 0x08, 0x21, 0x68, 0x39, 0x5d, 0x8a, 0x4a, 0x19, 0x7e, 0x82, 0x5d, 0xdf, 0x81, + /*ade0:*/ 0x58, 0xfe, 0xe3, 0xd4, 0x99, 0xa8, 0x4b, 0x3e, 0x95, 0xea, 0xba, 0x72, 0x4c, 0x87, 0xfc, 0x8b, + /*adf0:*/ 0x8d, 0x92, 0x0a, 0xbe, 0xe5, 0xdf, 0xa9, 0xbc, 0x55, 0x24, 0x14, 0xcc, 0xb1, 0x74, 0xaa, 0x47, + /*ae00:*/ 0x87, 0x3f, 0x81, 0xe7, 0x5a, 0xd2, 0x38, 0x8c, 0x98, 0x90, 0x71, 0xe1, 0x5f, 0xd7, 0xbb, 0x15, + /*ae10:*/ 0xd0, 0xf7, 0x87, 0xac, 0xe1, 0xd6, 0xec, 0xa5, 0xcf, 0x1c, 0xd4, 0x26, 0xb7, 0x34, 0x01, 0xaf, + /*ae20:*/ 0xf5, 0x27, 0x01, 0xaf, 0xa7, 0xfb, 0xde, 0x81, 0xb3, 0xa7, 0x72, 0x13, 0x0f, 0xbe, 0x73, 0x80, + /*ae30:*/ 0xb5, 0xfc, 0xd7, 0xee, 0xed, 0x32, 0x73, 0xe3, 0x8e, 0x8f, 0x0e, 0x28, 0xa8, 0x20, 0x3a, 0xf7, + /*ae40:*/ 0xbc, 0xe2, 0x2b, 0x87, 0xce, 0x46, 0xb6, 0x75, 0xd8, 0x55, 0x9b, 0x32, 0xbd, 0x30, 0x94, 0x83, + /*ae50:*/ 0x39, 0xfb, 0x28, 0xc9, 0x23, 0xeb, 0x9a, 0x55, 0xc2, 0x40, 0xa6, 0x5a, 0x04, 0xad, 0xab, 0x00, + /*ae60:*/ 0xb3, 0x51, 0xbf, 0x07, 0x9e, 0xbd, 0x44, 0x76, 0x2f, 0x23, 0x26, 0x92, 0x57, 0xdc, 0x92, 0xe8, + /*ae70:*/ 0x50, 0x21, 0xbb, 0x03, 0x6c, 0x23, 0xa1, 0xb4, 0xbd, 0x48, 0x24, 0x8f, 0xfe, 0x9b, 0x3c, 0x67, + /*ae80:*/ 0x32, 0xaf, 0x9e, 0x9a, 0x64, 0x1d, 0xb7, 0xe1, 0x81, 0x76, 0x26, 0x33, 0x3d, 0x6d, 0xbf, 0x80, + /*ae90:*/ 0x14, 0x66, 0xef, 0x49, 0xca, 0x69, 0xe9, 0xdc, 0xb5, 0x4c, 0x94, 0xa8, 0x97, 0x27, 0x5e, 0x1d, + /*aea0:*/ 0x02, 0xe9, 0x8b, 0x07, 0x0e, 0xbb, 0xb4, 0x59, 0x28, 0x68, 0x61, 0xb5, 0x11, 0x23, 0xb4, 0xde, + /*aeb0:*/ 0x83, 0x0c, 0xbf, 0x91, 0xfd, 0xf2, 0x3a, 0x3a, 0xd7, 0xe4, 0xc6, 0x90, 0x95, 0x7d, 0x35, 0x8b, + /*aec0:*/ 0x1a, 0x42, 0xf4, 0xfc, 0x90, 0xe3, 0x1a, 0xe3, 0x5d, 0xd2, 0x0e, 0xcd, 0xbd, 0x18, 0x46, 0x20, + /*aed0:*/ 0x1b, 0x0f, 0x82, 0x79, 0xca, 0x8d, 0xac, 0x92, 0x8e, 0x7b, 0x81, 0xf9, 0xde, 0x7d, 0x9a, 0xa6, + /*aee0:*/ 0x95, 0x31, 0x49, 0x54, 0x28, 0x27, 0x22, 0x04, 0xdf, 0xf2, 0x1a, 0xb7, 0x7f, 0xf0, 0x94, 0x00, + /*aef0:*/ 0x25, 0x16, 0x5c, 0x2a, 0x36, 0x5b, 0xec, 0x7f, 0xd7, 0x79, 0x12, 0x6c, 0x25, 0x25, 0xa6, 0x5c, + /*af00:*/ 0x7c, 0xe8, 0x94, 0x0d, 0x7b, 0xe7, 0x8d, 0x57, 0x60, 0xaf, 0x88, 0xbc, 0xf1, 0x8b, 0xd8, 0x40, + /*af10:*/ 0x62, 0x77, 0xb1, 0xa7, 0x6b, 0xee, 0x26, 0xca, 0x6b, 0x33, 0xa0, 0x92, 0x28, 0x6d, 0x45, 0xf6, + /*af20:*/ 0x6d, 0xd5, 0x3a, 0x9c, 0x7c, 0xc1, 0x1c, 0xe2, 0x46, 0x00, 0x3c, 0xb8, 0x7b, 0xc7, 0x44, 0xd4, + /*af30:*/ 0xa8, 0x82, 0xab, 0x08, 0x11, 0x75, 0x29, 0x08, 0x99, 0xfb, 0x60, 0xed, 0x2b, 0x93, 0xa1, 0x4b, + /*af40:*/ 0x1d, 0x25, 0xee, 0xef, 0x64, 0xb5, 0x5d, 0xa8, 0x9f, 0xcf, 0x5b, 0xc7, 0x2d, 0x7c, 0x69, 0x66, + /*af50:*/ 0xc4, 0x64, 0x13, 0xd8, 0xad, 0x60, 0x57, 0x56, 0x18, 0x09, 0x72, 0x15, 0x43, 0x4c, 0x6b, 0x6d, + /*af60:*/ 0xc1, 0x24, 0x15, 0x4d, 0x7b, 0x0f, 0x8c, 0x46, 0x52, 0xff, 0x6c, 0xfa, 0x3d, 0xb0, 0xfd, 0x3a, + /*af70:*/ 0x72, 0x48, 0x5f, 0x88, 0x39, 0x72, 0x2a, 0x37, 0x1b, 0x95, 0x4e, 0x06, 0xa0, 0x9a, 0xdb, 0x1b, + /*af80:*/ 0x01, 0xcb, 0xc1, 0x98, 0x30, 0xaf, 0xfe, 0xb5, 0x2a, 0xaa, 0xc9, 0xed, 0x80, 0x9e, 0x43, 0xcb, + /*af90:*/ 0x63, 0x52, 0xf8, 0x63, 0xa0, 0x4d, 0x00, 0xa8, 0xc6, 0xf4, 0xfe, 0x47, 0xfc, 0x23, 0xc7, 0xba, + /*afa0:*/ 0x23, 0x81, 0x12, 0x13, 0xe3, 0xe7, 0xea, 0x47, 0xd3, 0x59, 0xb8, 0xcc, 0xb4, 0xb3, 0x8c, 0xcb, + /*afb0:*/ 0xc0, 0x0a, 0x8f, 0x34, 0xe4, 0xd8, 0x0e, 0x6f, 0x1e, 0x08, 0xc4, 0xc6, 0xb9, 0x98, 0x40, 0x16, + /*afc0:*/ 0x60, 0x1d, 0xc1, 0x8e, 0x43, 0xdf, 0xd1, 0x86, 0x04, 0x6e, 0x50, 0xc0, 0xe9, 0x99, 0x1d, 0x55, + /*afd0:*/ 0x9b, 0x2f, 0xdf, 0x0b, 0x6a, 0xcc, 0x9f, 0x54, 0xdf, 0x8a, 0x75, 0xaa, 0x3d, 0x7f, 0xf8, 0x49, + /*afe0:*/ 0x4b, 0x91, 0x58, 0x67, 0x32, 0x61, 0xae, 0x0a, 0x5c, 0x81, 0x05, 0x49, 0x2c, 0x90, 0x62, 0xdb, + /*aff0:*/ 0x79, 0x55, 0xa3, 0xb5, 0x6a, 0x74, 0x24, 0x81, 0x24, 0xa0, 0xcf, 0x14, 0xe3, 0x0a, 0xf0, 0xdd, + /*b000:*/ 0x23, 0x98, 0xfc, 0x13, 0x94, 0xe0, 0x73, 0xc2, 0x44, 0x25, 0x79, 0x88, 0x6c, 0xe8, 0xb4, 0x5e, + /*b010:*/ 0x57, 0xcf, 0xd3, 0x3b, 0xa1, 0x81, 0xbf, 0xa7, 0x96, 0xd3, 0x06, 0xfe, 0xa9, 0x4e, 0xe7, 0x0f, + /*b020:*/ 0x26, 0x4a, 0x73, 0x60, 0x4c, 0x95, 0x0e, 0xf3, 0x75, 0x29, 0x63, 0x50, 0x54, 0xbb, 0xc0, 0x88, + /*b030:*/ 0x55, 0x7e, 0xf0, 0x09, 0x14, 0x7a, 0xdb, 0x31, 0x76, 0xfa, 0x86, 0x28, 0xf2, 0x2a, 0x01, 0xcb, + /*b040:*/ 0x21, 0xa3, 0x39, 0xa1, 0x26, 0xb7, 0x5d, 0x54, 0xae, 0x2b, 0xe6, 0xd7, 0x7d, 0xb3, 0x8f, 0x8a, + /*b050:*/ 0x0e, 0x8e, 0x12, 0x31, 0x8e, 0x75, 0x7e, 0x66, 0xa0, 0xfe, 0x66, 0x90, 0xde, 0x47, 0x00, 0xa6, + /*b060:*/ 0x14, 0xa3, 0x49, 0xe7, 0xe3, 0xd0, 0xdc, 0x99, 0xbc, 0x64, 0xaf, 0xd7, 0xdc, 0x73, 0x36, 0x05, + /*b070:*/ 0x13, 0xd7, 0xac, 0xd5, 0x55, 0x6a, 0xda, 0xb0, 0x10, 0xe6, 0x6b, 0x17, 0xe9, 0xf1, 0x80, 0x19, + /*b080:*/ 0xcf, 0xfb, 0x15, 0x61, 0xf6, 0x3b, 0xa3, 0xc2, 0x21, 0x63, 0xe0, 0xb0, 0x89, 0xe4, 0xd2, 0xf8, + /*b090:*/ 0xc8, 0x14, 0x1a, 0xb5, 0xfa, 0x1f, 0x83, 0xd7, 0x9c, 0x5b, 0x3c, 0x5c, 0x28, 0x62, 0x5e, 0x56, + /*b0a0:*/ 0x7d, 0x17, 0x5f, 0x8e, 0xd3, 0x6c, 0x17, 0xa4, 0xd7, 0xde, 0xb8, 0xf3, 0xbb, 0x27, 0x45, 0x74, + /*b0b0:*/ 0x24, 0x50, 0x6a, 0x4c, 0xf0, 0xf6, 0xe6, 0x47, 0x23, 0x77, 0x41, 0x1c, 0xcc, 0x0b, 0x24, 0xe2, + /*b0c0:*/ 0x09, 0x99, 0x72, 0x69, 0x5f, 0x9b, 0x88, 0x45, 0x4b, 0x29, 0x79, 0x98, 0xb2, 0x51, 0xbf, 0x14, + /*b0d0:*/ 0x27, 0x74, 0xa9, 0x98, 0x98, 0x1d, 0x34, 0xd3, 0x1c, 0x86, 0xf5, 0x00, 0xa9, 0x46, 0x1e, 0xd9, + /*b0e0:*/ 0x76, 0x27, 0xe7, 0x05, 0x47, 0xe8, 0x2f, 0xe0, 0x75, 0x15, 0x79, 0x29, 0x6a, 0xca, 0xed, 0xf5, + /*b0f0:*/ 0xf9, 0xca, 0x2d, 0x1d, 0x92, 0x6f, 0xcb, 0xd4, 0xec, 0x9a, 0x79, 0xa4, 0x3a, 0xb6, 0x7b, 0x38, + /*b100:*/ 0x53, 0x59, 0x02, 0x02, 0x00, 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x89, 0x00, 0x01, 0x01, 0xff, 0x0a, + /*b110:*/ 0x1f, 0x03, 0xff, 0x04, 0x1e, 0x06, 0x2d, 0x72, 0x0f, 0x7b, 0x02, 0x01, 0x31, 0xff, 0x31, 0xff, + /*b120:*/ 0x78, 0x43, 0xfd, 0x43, 0x84, 0xe4, 0x6c, 0xe8, 0x00, 0x70, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x04, + /*b130:*/ 0x0c, 0x32, 0x70, 0x17, 0x0a, 0x0a, 0x05, 0x80, 0x0c, 0x46, 0x00, 0x80, 0x0c, 0x5a, 0x00, 0x28, + /*b140:*/ 0x0a, 0x8c, 0x00, 0xb8, 0x0b, 0x96, 0x00, 0x1e, 0x1e, 0x64, 0x00, 0xf4, 0x01, 0x14, 0x0a, 0x04, + /*b150:*/ 0x29, 0x1a, 0x0a, 0x64, 0x03, 0x66, 0x64, 0xc0, 0x20, 0x02, 0x87, 0x00, 0x80, 0x02, 0x0e, 0x1f, + /*b160:*/ 0x01, 0x2a, 0x00, 0x20, 0x0a, 0x1b, 0x00, 0x80, 0x0a, 0xa8, 0xa0, 0x80, 0x88, 0x88, 0x88, 0x68, + /*b170:*/ 0x68, 0x2e, 0x2d, 0x2b, 0x2a, 0x29, 0x28, 0x27, 0x25, 0x01, 0x04, 0x07, 0x09, 0x0b, 0x0d, 0x0f, + /*b180:*/ 0x13, 0x00, 0xe8, 0x03, 0x00, 0x14, 0x00, 0xe8, 0x03, 0x9a, 0x64, 0xda, 0xb8, 0x0b, 0x00, 0xc0, + /*b190:*/ 0x80, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, + /*b1a0:*/ 0x10, 0x5a, 0x5e, 0x61, 0x64, 0x67, 0x6a, 0x6d, 0x39, 0x00, 0x1e, 0x00, 0x10, 0x0a, 0x17, 0x00, + /*b1b0:*/ 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x30, 0x04, 0x20, 0x40, 0x03, 0x04, 0x03, 0x00, + /*b1c0:*/ 0x1d, 0x2b, 0x1d, 0x2c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x7d, 0x51, 0x51, 0x51, 0xcd, + /*b1d0:*/ 0x0d, 0x04, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + /*b1e0:*/ 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, + /*b1f0:*/ 0x1d, 0x1e, 0x1f, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x29, 0x2a, 0x2b, 0x2c, 0xff, 0xff, + /*b200:*/ 0xff, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x14, 0x12, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, + /*b210:*/ 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x1d, 0xff, 0xff, 0xff, 0x00, + /*b220:*/ 0x10, 0x00, 0x10, 0x00, 0x10, 0x00, 0x10, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + /*b230:*/ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + /*b240:*/ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + /*b250:*/ 0x80, 0x80, 0x80, 0x80, 0x80, 0x66, 0x66, 0x6d, 0x6d, 0x73, 0x73, 0x7a, 0x7a, 0x80, 0x80, 0x86, + /*b260:*/ 0x86, 0x8d, 0x8d, 0x93, 0x93, 0x9a, 0x9a, 0xa0, 0xa0, 0xa6, 0xa6, 0xad, 0xad, 0xb3, 0xb3, 0x80, + /*b270:*/ 0x80, 0x80, 0x80, 0x04, 0x02, 0xff, 0x08, 0xff, 0xff, 0x03, 0x1c, 0x43, 0x80, 0x08, 0x10, 0x0a, + /*b280:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b290:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b2f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0x5d, 0xdc, 0x9d, + /*b300:*/ 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b310:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b320:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b330:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b340:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b350:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b360:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b370:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b380:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b390:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b3f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b400:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b410:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b420:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b430:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b440:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b450:*/ 0x04, 0x3f, 0x03, 0x1e, 0x05, 0x0e, 0x08, 0x00, 0x19, 0x19, 0x00, 0x10, 0xe2, 0x04, 0xb6, 0x08, + /*b460:*/ 0x1e, 0x05, 0x28, 0xf5, 0x28, 0x1e, 0x05, 0x01, 0x30, 0x00, 0x30, 0x00, 0x00, 0x50, 0x00, 0x50, + /*b470:*/ 0xf0, 0xd2, 0xf0, 0xd2, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0xc0, 0x0f, 0x49, 0x00, + /*b480:*/ 0x00, 0x00, 0x85, 0x03, 0x2e, 0x1e, 0x0a, 0x64, 0x07, 0x00, 0x00, 0x56, 0x35, 0x05, 0x10, 0x00, + /*b490:*/ 0x00, 0x0b, 0x20, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x53, + /*b4a0:*/ 0x37, 0x33, 0x30, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x03, 0x0f, 0x00, 0x03, 0x00, 0x00, + /*b4b0:*/ 0x00, 0xf0, 0x15, 0x1e, 0x2e, 0x4c, 0x40, 0xff, 0x4b, 0x20, 0x0c, 0x18, 0x09, 0x04, 0x00, 0x00, + /*b4c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b4d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0x8a, 0x56, + /*b4e0:*/ 0x15, 0x21, 0x11, 0x94, 0x89, 0x50, 0x13, 0x01, 0x01, 0x8b, 0x00, 0x4c, 0x00, 0x01, 0x34, 0x00, + /*b4f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b500:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x5e, 0x01, 0x80, + /*b510:*/ 0x03, 0x0e, 0x1f, 0x00, 0xde, 0x01, 0x19, 0x04, 0x1b, 0x00, 0x10, 0x0a, 0xc0, 0x00, 0x00, 0x00, + /*b520:*/ 0x00, 0x00, 0x00, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b530:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + /*b540:*/ 0xff, 0x00, 0xc0, 0x80, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, + /*b550:*/ 0x00, 0x00, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x10, + /*b560:*/ 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x04, 0x40, 0x40, 0x03, + /*b570:*/ 0x00, 0x2e, 0x1e, 0x44, 0x00, 0x19, 0x01, 0x01, 0xbe, 0x00, 0xde, 0x3d, 0x90, 0x80, 0x08, 0x03, + /*b580:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b590:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b5e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x70, 0x0b, 0x00, 0x01, 0x54, 0x00, + /*b5f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b600:*/ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x51, 0x51, + /*b610:*/ 0x51, 0x51, 0x51, 0xcd, 0x0d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x00, 0x04, 0xff, 0x2e, + /*b620:*/ 0x1e, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b630:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b640:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b650:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b660:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b670:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b680:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b690:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b6e0:*/ 0x00, 0x00, 0x00, 0x1f, 0x1c, 0x16, 0x00, 0x01, 0x55, 0x1d, 0x00, 0x01, 0x00, 0x01, 0x1a, 0x00, + /*b6f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b700:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b710:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b720:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0xff, 0xff, 0x03, 0x32, + /*b730:*/ 0x00, 0x80, 0x08, 0x10, 0x0a, 0x04, 0x28, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b740:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b750:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b760:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b770:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b780:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b790:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7a0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7b0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7c0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7d0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b7e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x28, 0x00, 0x00, 0x51, 0x00, + /*b7f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /*b800:*/ 0xff}; +#else const char *rmi_config_ver = "N80XX_SY_0518"; const u8 rmi_fw[] = { @@ -2917,4 +11765,5 @@ const u8 rmi_fw[] = { /*b5e0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0xb4, 0x0b, 0x00, 0x01, 0x54, 0x00, /*b5f0:*/ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*b600:*/ 0xff}; -#endif /* __RMI_FW_H */
\ No newline at end of file + #endif + #endif /* __RMI_FW_H */ diff --git a/drivers/input/touchscreen/synaptics_fw_updater.c b/drivers/input/touchscreen/synaptics_fw_updater.c index 1a15fdc..2b8293f 100644 --- a/drivers/input/touchscreen/synaptics_fw_updater.c +++ b/drivers/input/touchscreen/synaptics_fw_updater.c @@ -399,39 +399,79 @@ int synaptics_fw_updater(struct synaptics_drv_data *data, u8 *fw_data) { struct synaptics_ts_fw_block *fw; int irq = gpio_to_irq(data->gpio); - bool update = true; + bool update = false; fw = kzalloc(sizeof(struct synaptics_ts_fw_block), GFP_KERNEL); data->fw = fw; if (NULL == fw_data) { - u8 *buf, *fw_version; - buf = kzalloc(4, GFP_KERNEL); - fw_version = kzalloc(4, GFP_KERNEL); + u8 buf[5] = {0, }; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + if (data->pdata->support_extend_button) { + fw->fw_data = (u8 *)rmi_fw_button; + + /* set firmware data */ + data->firm_version[0] = rmi_fw_button[0xb100]; + data->firm_version[1] = rmi_fw_button[0xb101]; + data->firm_version[2] = rmi_fw_button[0xb102]; + data->firm_version[3] = rmi_fw_button[0xb103]; + data->firm_version[4] = '\0'; + + strncpy(data->firm_config, rmi_config_ver_button, + sizeof(data->firm_config)); + } else { + fw->fw_data = (u8 *)rmi_fw; + + data->firm_version[0] = rmi_fw[0xb100]; + data->firm_version[1] = rmi_fw[0xb101]; + data->firm_version[2] = rmi_fw[0xb102]; + data->firm_version[3] = rmi_fw[0xb103]; + data->firm_version[4] = '\0'; + + strncpy(data->firm_config, rmi_config_ver, + sizeof(data->firm_config)); + } +#else fw->fw_data = (u8 *)rmi_fw; - strncpy(fw_version, &rmi_fw[0xb100], - sizeof(fw_version)); - strncpy(data->firm_version, fw_version, - sizeof(data->firm_version)); + + data->firm_version[0] = rmi_fw[0xb100]; + data->firm_version[1] = rmi_fw[0xb101]; + data->firm_version[2] = rmi_fw[0xb102]; + data->firm_version[3] = rmi_fw[0xb103]; + data->firm_version[4] = '\0'; + strncpy(data->firm_config, rmi_config_ver, sizeof(data->firm_config)); - synaptics_ts_read_block(data, +#endif + if (synaptics_ts_read_block(data, data->f34.control_base_addr, - buf, 4); - - printk(KERN_DEBUG "[TSP] IC FW. : [%s], new FW. : [%s]\n", - buf, fw_version); - - if (strncmp((char *)fw_version, (char *)buf, 4) == 0) - update = false; - - kfree(buf); - kfree(fw_version); - - } else + buf, 4) > 0) + printk(KERN_DEBUG "[TSP] block read success!\n"); + else + printk(KERN_DEBUG "[TSP] block read failed!\n"); + + printk(KERN_DEBUG "[TSP] IC FW. : [%c%c%.2d%.2d00], new FW. : [%c%c%.2d%.2d00]\n", + buf[0],buf[1],buf[2],buf[3], + data->firm_version[0],data->firm_version[1], + data->firm_version[2],data->firm_version[3]); + + /* update firm > tsp */ + /* + if (strcmp(data->firm_version, buf) > 0) { + printk(KERN_DEBUG "[TSP] update!\n"); + update = true; + } + */ + /* update if firm != tsp */ + if (strncmp(data->firm_version, buf, 4) != 0) + update = true; + } else { fw->fw_data = fw_data; - + update = true; + } + if (update) { + printk(KERN_DEBUG "[TSP] tsp update!!\n"); disable_irq(irq); wake_lock(&data->wakelock); synaptics_fw_initialize(data); @@ -463,6 +503,13 @@ int synaptics_fw_updater(struct synaptics_drv_data *data, u8 *fw_data) void forced_fw_update(struct synaptics_drv_data *data) { +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + if (data->pdata->support_extend_button) + synaptics_fw_updater(data, (u8 *)rmi_fw_button); + else + synaptics_fw_updater(data, (u8 *)rmi_fw); +#else synaptics_fw_updater(data, (u8 *)rmi_fw); +#endif } diff --git a/drivers/input/touchscreen/synaptics_s7301.c b/drivers/input/touchscreen/synaptics_s7301.c index bd2bf8f..fb152e1 100644 --- a/drivers/input/touchscreen/synaptics_s7301.c +++ b/drivers/input/touchscreen/synaptics_s7301.c @@ -15,6 +15,14 @@ #include <linux/synaptics_s7301.h> +#define REPORT_MT_NOZ(x, y, w_max, w_min) \ +do { \ + input_report_abs(data->input, ABS_MT_POSITION_X, x); \ + input_report_abs(data->input, ABS_MT_POSITION_Y, y); \ + input_report_abs(data->input, ABS_MT_TOUCH_MAJOR, w_max); \ + input_report_abs(data->input, ABS_MT_TOUCH_MINOR, w_min); \ +} while (0) + #define REPORT_MT(x, y, z, w_max, w_min) \ do { \ input_report_abs(data->input, ABS_MT_POSITION_X, x); \ @@ -185,6 +193,29 @@ void set_dvfs_lock(struct synaptics_drv_data *data, bool en) } #endif /* CONFIG_SEC_TOUCHSCREEN_DVFS_LOCK */ +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) +static void forced_release_buttons(struct synaptics_drv_data *data) +{ + int i; +#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) + printk(KERN_DEBUG "[TSP] %s\n", __func__); +#endif + if (data->pdata->support_extend_button) { + for (i = 0; i < data->pdata->extend_button_map->nbuttons; i++) { + input_report_key(data->input, + data->pdata->extend_button_map->map[i], + 0); + } + } else { + for (i = 0; i < data->pdata->button_map->nbuttons; i++) { + input_report_key(data->input, + data->pdata->button_map->map[i], 0); + } + } + input_sync(data->input); +} +#endif + static void forced_release_fingers(struct synaptics_drv_data *data) { int i; @@ -200,6 +231,9 @@ static void forced_release_fingers(struct synaptics_drv_data *data) data->finger[i].z = 0; } input_sync(data->input); +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + forced_release_buttons(data); +#endif set_dvfs_lock(data, false); return ; } @@ -212,9 +246,9 @@ static int synaptics_ts_set_func_info(struct synaptics_drv_data *data) u16 base_addr = FUNC_ADDR_FIRST; u16 last_addr = FUNC_ADDR_LAST; - for (i = 0; i <= PAGE_MAX; i += PAGE_MAX) { - base_addr += i; - last_addr += i; + for (i = 0; i <= PAGE_MAX; i += NEXT_PAGE) { + base_addr = i + FUNC_ADDR_FIRST; + last_addr = i + FUNC_ADDR_LAST; for (addr = base_addr; addr >= last_addr; addr -= FUNC_ADDR_SIZE) { synaptics_ts_read_block(data, @@ -245,6 +279,12 @@ static int synaptics_ts_set_func_info(struct synaptics_drv_data *data) SET_FUNC_ADDR(11, i); break; +#if defined (CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + case 0x1a: + SET_FUNC_ADDR(1a, i); + break; +#endif + case 0x34: SET_FUNC_ADDR(34, i); break; @@ -253,12 +293,26 @@ static int synaptics_ts_set_func_info(struct synaptics_drv_data *data) SET_FUNC_ADDR(54, i); break; +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + case 0x51: + SET_FUNC_ADDR(51, i); + break; +#endif + default: break; } } } - return cnt; +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + cnt--; +#endif + +#if defined (CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + return (5 != cnt); +#else + return (4 != cnt); +#endif } static int synaptics_ts_read_dummy(struct synaptics_drv_data *data) @@ -314,17 +368,43 @@ static void inform_charger_connection(struct charger_callbacks *cb, int mode) struct synaptics_drv_data, callbacks); data->charger_connection = !!mode; - if (data->ready) + if (data->ready) { +#if !defined(CONFIG_MACH_KONA) set_charger_connection_bit(data); +#endif + } } +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) +static void set_palm_threshold(struct synaptics_drv_data *data) +{ + u8 threshold = data->pdata->palm_threshold; + + synaptics_ts_write_data(data, + data->f11.control_base_addr + 17, threshold); +} +#endif + static int synaptics_ts_set_func(struct synaptics_drv_data *data) { int i = 0; - + int retry_count = 10; + int ret = 0; + printk(KERN_DEBUG "[TSP] %s\n", __func__); - - if (synaptics_ts_set_func_info(data) != 4) { + + while(retry_count--) { + ret = synaptics_ts_set_func_info(data); + + if (ret) { + pr_err("[TSP] failed to get function info retry_count = %d \n",retry_count); + continue; + } else { + break; + } + } + + if (ret) { pr_err("[TSP] failed to get function info.\n"); forced_fw_update(data); synaptics_ts_set_func_info(data); @@ -340,40 +420,159 @@ static int synaptics_ts_set_func(struct synaptics_drv_data *data) return synaptics_ts_read_dummy(data); } +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) +static void synaptics_ts_check_buttons(struct synaptics_drv_data *data) +{ + int ret = 0, i, pos_button = 1; + u16 touch_key_addr = data->f1a.data_base_addr; + u8 touch_key_data; + u8 check_mask_data; + + ret = synaptics_ts_read_block(data, + touch_key_addr, &touch_key_data, 1); + + if (ret < 0) { + pr_err("[TSP] failed to read button data\n"); + return ; + } + +#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) + printk(KERN_DEBUG "[TSP] button [0x%x]\n", touch_key_data); +#endif + + if (data->pdata->support_extend_button) { + if (data->pdata->enable_extend_button_event) { + for (i = 0; i < data->pdata->extend_button_map->nbuttons; i++) { + if ((touch_key_data & (pos_button<<i)) != 0) { + input_report_key(data->input, + data->pdata->extend_button_map->map[i], + 1); + } else { + input_report_key(data->input, + data->pdata->extend_button_map->map[i], + 0); + } + input_sync(data->input); + } + } else { + /* check mask data and return */ + check_mask_data = touch_key_data & + data->pdata->extend_button_map->button_mask; + + if (check_mask_data != 0) { + printk(KERN_DEBUG "[TSP] igb\n"); + return; + } + + for (i = 0; i < data->pdata->extend_button_map->nbuttons; i++) { + if ((data->pdata->extend_button_map->button_mask & (pos_button<<i)) !=0) + continue; + + if ((touch_key_data & (pos_button<<i)) != 0) { + input_report_key(data->input, + data->pdata->extend_button_map->map[i], + 1); + printk(KERN_DEBUG "[TSP] b[%d][%c]\n", i, 'p'); + } else { + input_report_key(data->input, + data->pdata->extend_button_map->map[i], + 0); + printk(KERN_DEBUG "[TSP] b[%d][%c]\n", i, 'r'); + } + input_sync(data->input); + } + } + } else { + for (i = 0; i < data->pdata->button_map->nbuttons; i++) { + if ((touch_key_data & (pos_button<<i)) != 0) + input_report_key(data->input, + data->pdata->button_map->map[i], 1); + else + input_report_key(data->input, + data->pdata->button_map->map[i], 0); + input_sync(data->input); + } + } +} +#endif + static int check_interrupt_status(struct synaptics_drv_data *data, u32 *finger_status) { int ret = 0; u8 buf[3]; + u8 tmp; u16 addr = 0; + int analog_int = 0; /* read the interrupt status */ addr = data->f01.data_base_addr + 1; ret = synaptics_ts_read_data(data, - addr, buf); + addr, &tmp); if (ret < 0) { pr_err("[TSP] failed to read i2c data(%d)\n", __LINE__); return -EIO; } - /* read the finger states */ - addr = data->f11.data_base_addr; - ret = synaptics_ts_read_block(data, - addr, buf, 3); - if (ret < 0) { - pr_err("[TSP] failed to read i2c data(%d)\n", __LINE__); - return -EIO; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + /* check button */ + if ((tmp & 0x10) != 0) { + synaptics_ts_check_buttons(data); } +#endif - *finger_status = (u32) (buf[0] | (buf[1] << 8) | - ((buf[2] & 0xf) << 16)); + /* check analog interrupt */ + if (tmp & 0x4) + analog_int = 1; - if (data->debug) - printk(KERN_DEBUG - "[TSP] finger_status : 0x%x\n", - *finger_status); +#if defined(CONFIG_MACH_KONA) + /* check interrupt status register */ + if ((tmp & 0x0F) == 0x2) { + addr = data->f01.data_base_addr; + /* check esd status register */ + ret = synaptics_ts_read_data(data, + addr, &tmp); + if (ret < 0) { + pr_err("[TSP] failed to read i2c data(%d)\n", __LINE__); + return -EIO; + } else if ((tmp & 0x3) == 0x3) { + pr_err("[TSP] esd detect\n"); + forced_release_fingers(data); + data->pdata->hw_reset(); + return 0; + } + } +#else + /* esd detect */ + if ((tmp & 0x0F) == 0x03) { + pr_err("[TSP] esd detect\n"); + data->pdata->hw_reset(); + return 0; + } +#endif - return 0; + if (analog_int) { + /* read the finger states */ + addr = data->f11.data_base_addr; + ret = synaptics_ts_read_block(data, + addr, buf, 3); + if (ret < 0) { + pr_err("[TSP] failed to read i2c data(%d)\n", __LINE__); + return -EIO; + } + + *finger_status = (u32) (buf[0] | (buf[1] << 8) | + ((buf[2] & 0xf) << 16)); + + if (data->debug) + printk(KERN_DEBUG + "[TSP] finger_status : [%d] 0x%x\n", analog_int, + *finger_status); + } + if (analog_int == 1) + return 1; + else + return 0; } static void synaptics_ts_read_points(struct synaptics_drv_data *data, @@ -383,10 +582,33 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, bool finger_pressed = false; int ret = 0; int id = 0; +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + u8 palm; + u8 surface_data[4]; + u16 palm_addr = data->f11.data_base_addr + 53; + u16 surface_addr = data->f51.data_base_addr; + int angle = 0; +#endif u16 addr = data->f11.data_base_addr + 3; + u16 x = 0, y = 0; + +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + ret = synaptics_ts_read_block(data, + palm_addr, &palm, 1); + if (ret < 0) { + pr_err("[TSP] failed to read palm data\n"); + return ; + } + + palm = (palm & 0x02) ? 1 : 0; +#endif for (id = 0; id < MAX_TOUCH_NUM; id++, addr += sizeof(struct finger_data)) { +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) + if ((finger_status & (0x3 << (id * 2))) == 0x3) + continue; +#endif if (finger_status & (0x3 << (id * 2))) { ret = synaptics_ts_read_block(data, addr, (u8 *) &buf, 5); @@ -394,6 +616,15 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, pr_err("[TSP] failed to read finger[%u]\n", id); return ; } +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + ret = synaptics_ts_read_block(data, + surface_addr + (id * 4), + surface_data, 4); + if (ret < 0) { + pr_err("[TSP] failed to read surface data\n"); + return ; + } +#endif #if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) if (data->debug) @@ -405,13 +636,47 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, buf.z); #endif - data->finger[id].x = - (buf.x_msb << 4) + - (buf.xy_lsb & 0x0F); - data->finger[id].y = - (buf.y_msb << 4) + - (buf.xy_lsb >> 4); + x = (buf.x_msb << 4) + (buf.xy_lsb & 0x0F); + y = (buf.y_msb << 4) + (buf.xy_lsb >> 4); + + if (data->pdata->swap_xy) + swap(x, y); + + if (data->pdata->invert_x) + x = data->pdata->max_x - x; + + if (data->pdata->invert_y) + y = data->pdata->max_y - y; + data->finger[id].x = x; + data->finger[id].y = y; + +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + data->finger[id].w_max = surface_data[2]; + data->finger[id].w_min = surface_data[3]; + if (data->pdata->support_extend_button) { + if (surface_data[1] >= 90 && surface_data[1] <= 180) + angle = surface_data[1] - 90; + else if (surface_data[1] < 90) + angle = -(90 - surface_data[1]); + else + printk(KERN_DEBUG "[TSP] wrong TSP angle data [%d][%d]\n", id, + surface_data[1]); + } else { + if (surface_data[1] <= 90) + angle = surface_data[1]; + else if (surface_data[1] > 168 && surface_data[1] < 256) + angle = -(256 - surface_data[1]); + else + printk(KERN_DEBUG "[TSP] wrong TSP angle data [%d][%d]\n", id, + surface_data[1]); + } + + if (data->finger[id].w_max < + data->finger[id].w_min) + swap(data->finger[id].w_max, + data->finger[id].w_min); +#else if ((buf.w >> 4) > (buf.w & 0x0F)) { data->finger[id].w_max = @@ -424,7 +689,12 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, data->finger[id].w_max = (buf.w & 0x0F); } - +#endif +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + data->finger[id].angle = angle; + data->finger[id].width = surface_data[0]; +#endif + data->finger[id].z = buf.z; if (data->finger[id].z) { if (MT_STATUS_INACTIVE == @@ -438,19 +708,35 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, data->finger[id].x, data->finger[id].y, data->finger[id].z); +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + printk(KERN_DEBUG + "[TSP] palm %d, surface_data %d, %d\n", + palm, + surface_data[0], + surface_data[1]); +#endif #else printk(KERN_DEBUG "s7301 %d P\n", id); #endif } #if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) - else if (data->debug) + else if (data->debug) { printk(KERN_DEBUG "[TSP] ID: %d, x: %d, y: %d, z: %d\n", id, data->finger[id].x, data->finger[id].y, data->finger[id].z); +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + printk(KERN_DEBUG + "[TSP] palm %d, surface_data %d, %d, %d\n", + palm, + surface_data[0], + surface_data[1], + angle); +#endif + } #endif } } else if (MT_STATUS_PRESS == data->finger[id].status) { @@ -464,7 +750,29 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, } } +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + if (palm) { + if (data->palm_flag == 3) + data->palm_flag = 1; + else { + data->palm_flag = 3; + palm = 3; + } + } else { + if (data->palm_flag == 2) + data->palm_flag = 0; + else { + data->palm_flag = 2; + palm = 2; + } + } +#endif + for (id = 0; id < MAX_TOUCH_NUM; ++id) { +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) + if ((finger_status & (0x3 << (id * 2))) == 0x3) + continue; +#endif if (MT_STATUS_INACTIVE == data->finger[id].status) continue; @@ -477,12 +785,30 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, case MT_STATUS_PRESS: case MT_STATUS_MOVE: finger_pressed = true; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) + if (0 == !!data->finger[id].z) + break; + + REPORT_MT_NOZ( + data->finger[id].x, + data->finger[id].y, + data->finger[id].w_max, + data->finger[id].w_min); +#else REPORT_MT( data->finger[id].x, data->finger[id].y, data->finger[id].z, data->finger[id].w_max, data->finger[id].w_min); +#endif +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + input_report_abs(data->input, ABS_MT_WIDTH_MAJOR, + data->finger[id].width); + input_report_abs(data->input, ABS_MT_ANGLE, + data->finger[id].angle); + input_report_abs(data->input, ABS_MT_PALM, palm); +#endif break; case MT_STATUS_RELEASE: @@ -496,11 +822,17 @@ static void synaptics_ts_read_points(struct synaptics_drv_data *data, set_dvfs_lock(data, finger_pressed); } +#if 0 +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + synaptics_ts_check_buttons(data); +#endif +#endif + static irqreturn_t synaptics_ts_irq_handler(int irq, void *_data) { struct synaptics_drv_data *data = (struct synaptics_drv_data *)_data; u32 finger_status = 0; - if (!check_interrupt_status(data, &finger_status)) + if (check_interrupt_status(data, &finger_status) == 1) synaptics_ts_read_points(data, finger_status); return IRQ_HANDLED; } @@ -510,6 +842,13 @@ static void synaptics_ts_early_suspend(struct early_suspend *h) { struct synaptics_drv_data *data = container_of(h, struct synaptics_drv_data, early_suspend); +#if defined(CONFIG_MACH_KONA) + disable_irq(data->client->irq); + forced_release_fingers(data); + if (!wake_lock_active(&data->wakelock)) { + data->pdata->set_power(0); + } +#else printk(KERN_DEBUG "[TSP] %s\n", __func__); cancel_delayed_work_sync(&data->resume_dwork); mutex_lock(&data->mutex); @@ -522,6 +861,7 @@ static void synaptics_ts_early_suspend(struct early_suspend *h) } } mutex_unlock(&data->mutex); +#endif } static void synaptics_ts_late_resume(struct early_suspend *h) @@ -531,11 +871,20 @@ static void synaptics_ts_late_resume(struct early_suspend *h) printk(KERN_DEBUG "[TSP] %s\n", __func__); +#if defined(CONFIG_MACH_KONA) + /* turned on tsp power */ + data->pdata->set_power(1); + + mdelay(200); + enable_irq(data->client->irq); +#else if (data->suspend) { if (data->pdata->set_power(1)) data->pdata->hw_reset(); } + schedule_delayed_work(&data->resume_dwork, HZ / 10); +#endif } #endif @@ -572,7 +921,12 @@ static void init_function_data_dwork(struct work_struct *work) #endif data->ready = true; +#if !defined(CONFIG_MACH_KONA) set_charger_connection_bit(data); +#endif +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + set_palm_threshold(data); +#endif if (data->client->irq) { ret = request_threaded_irq(data->client->irq, NULL, @@ -602,8 +956,10 @@ static void synaptics_ts_resume_dwork(struct work_struct *work) mutex_lock(&data->mutex); if (data->suspend) { data->suspend = false; +#if !defined(CONFIG_MACH_KONA) set_charger_connection_bit(data); synaptics_ts_drawing_mode(data); +#endif synaptics_ts_read_dummy(data); enable_irq(data->client->irq); } @@ -619,6 +975,19 @@ static void synaptics_ts_noti_dwork(struct work_struct *work) set_charger_connection_bit(data); } +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) +static void synaptics_reset_ts_dwork(struct work_struct *work) +{ + struct synaptics_drv_data *data = + container_of(work, struct synaptics_drv_data, + reset_dwork.work); + + if (data->firmware_update_check != true) { + data->pdata->hw_reset(); + } +} +#endif + static int synaptics_ts_open(struct input_dev *dev) { struct synaptics_drv_data *data = @@ -671,6 +1040,11 @@ static int __init synaptics_ts_probe(struct i2c_client *client, ddata->gpio = pdata->gpio_attn; ddata->x_line = pdata->x_line; ddata->y_line = pdata->y_line; +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + ddata->palm_flag = 0; +#endif + if (pdata->swap_xy) + swap(pdata->x_line, pdata->y_line); /* Register callbacks */ /* To inform tsp , charger connection status*/ @@ -702,18 +1076,48 @@ static int __init synaptics_ts_probe(struct i2c_client *client, __set_bit(EV_KEY, input->evbit); __set_bit(MT_TOOL_FINGER, input->keybit); __set_bit(INPUT_PROP_DIRECT, input->propbit); + +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYLED) + if (pdata->led_event) { + __set_bit(EV_LED, input->evbit); + __set_bit(LED_MISC, input->ledbit); + } +#endif input_mt_init_slots(input, MAX_TOUCH_NUM); input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->max_x, 0, 0); input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->max_y, 0, 0); +#if !defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) input_set_abs_params(input, ABS_MT_PRESSURE, 0, - pdata->max_pressure, 0, 0); + pdata->max_pressure, 0, 0); +#endif input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, pdata->max_width, 0, 0); input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, pdata->max_width, 0, 0); +#if defined(CONFIG_SEC_TOUCHSCREEN_SURFACE_TOUCH) + input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, + pdata->x_line * pdata->y_line, 0, 0); + input_set_abs_params(input, ABS_MT_ANGLE, + MIN_ANGLE, MAX_ANGLE, 0, 0); + input_set_abs_params(input, ABS_MT_PALM, + 0, 1, 0, 0); +#endif +#if defined (CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + if (pdata->support_extend_button) { + for (ret = 0; ret < pdata->extend_button_map->nbuttons; ret++) { + if (pdata->extend_button_map->map[ret] != KEY_RESERVED) + input_set_capability(input, EV_KEY, + pdata->extend_button_map->map[ret]); + } + } else { + for (ret = 0; ret < pdata->button_map->nbuttons; ret++) + input_set_capability(input, EV_KEY, + pdata->button_map->map[ret]); + } +#endif ret = input_register_device(input); if (ret) { @@ -727,8 +1131,16 @@ static int __init synaptics_ts_probe(struct i2c_client *client, INIT_DELAYED_WORK(&ddata->init_dwork, init_function_data_dwork); INIT_DELAYED_WORK(&ddata->resume_dwork, synaptics_ts_resume_dwork); +#if !defined(CONFIG_MACH_KONA) INIT_DELAYED_WORK(&ddata->noti_dwork, synaptics_ts_noti_dwork); +#endif schedule_delayed_work(&ddata->init_dwork, HZ); + +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_WORKAROUND) + pdata->hw_reset(); +// INIT_DELAYED_WORK(&ddata->reset_dwork, synaptics_reset_ts_dwork); +// schedule_delayed_work(&ddata->reset_dwork, HZ*10); +#endif ret = set_tsp_sysfs(ddata); if (ret) { diff --git a/drivers/input/touchscreen/synaptics_sysfs.c b/drivers/input/touchscreen/synaptics_sysfs.c index 510bc98..be82954 100644 --- a/drivers/input/touchscreen/synaptics_sysfs.c +++ b/drivers/input/touchscreen/synaptics_sysfs.c @@ -18,6 +18,10 @@ #include <linux/synaptics_s7301.h> #include "synaptics_sysfs.h" +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYLED) +struct device *synaptics_with_gpio_led_device; +#endif + const char *sec_sysfs_cmd_list[] = { "fw_update", "get_fw_ver_bin", @@ -50,7 +54,11 @@ static int synaptics_ts_load_fw(struct synaptics_drv_data *data) old_fs = get_fs(); set_fs(KERNEL_DS); +#if defined(CONFIG_MACH_KONA) + fp = filp_open(SYNAPTICS_FW2, O_RDONLY, S_IRUSR); +#else fp = filp_open(SYNAPTICS_FW, O_RDONLY, S_IRUSR); +#endif if (IS_ERR(fp)) { printk(KERN_ERR "[TSP] failed to open %s.\n", SYNAPTICS_FW); error = -ENOENT; @@ -63,8 +71,14 @@ static int synaptics_ts_load_fw(struct synaptics_drv_data *data) fw_data = kzalloc(fw_size, GFP_KERNEL); nread = vfs_read(fp, (char __user *)fw_data, fw_size, &fp->f_pos); +#if defined(CONFIG_MACH_KONA) + printk(KERN_DEBUG "[TSP] start, file path %s, size %u Bytes\n", + SYNAPTICS_FW2, fw_size); +#else printk(KERN_DEBUG "[TSP] start, file path %s, size %u Bytes\n", SYNAPTICS_FW, fw_size); +#endif + if (nread != fw_size) { printk(KERN_ERR "[TSP] failed to read firmware file, nread %u Bytes\n", @@ -142,9 +156,69 @@ static void soft_reset(struct synaptics_drv_data *data) static void check_all_raw_cap(struct synaptics_drv_data *data) { - int i; + int i, j, k=0; u16 temp = 0; - u16 length = data->x_line * data->y_line * 2; + u16 length; + +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + u8 escape_rx_line; + + if (data->pdata->support_extend_button) + escape_rx_line = data->pdata->extend_button_map->nbuttons; + else + escape_rx_line = data->pdata->button_map->nbuttons; + + length = data->x_line * (data->y_line + escape_rx_line) * 2; + + if (NULL == data->references) + data->references = kzalloc(length, GFP_KERNEL); + + data->refer_min = 0xffff; + data->refer_max = 0x0; + + /* set the index */ + set_report_index(data, 0x0000); + + /* Set the GetReport bit to run the AutoScan */ + set_report_mode(data, 0x01, 0x00); + + /* read all report data */ + synaptics_ts_read_block(data, + data->f54.data_base_addr + 3, + data->references, length); + + for (i = 0; i < data->x_line; i++) { + for (j = 0; j < data->y_line + escape_rx_line; j++) { + temp = (u16)(data->references[k] | + (data->references[k+1] << 8)); + + if (k != 0 && j !=0) { + if (j >= data->y_line) { + if (data->debug) { + printk(KERN_DEBUG + "[TSP][skip] raw cap[%d] : %u\n", + k, temp); + } + k += 2; + continue; + } + } + if (data->debug) { + if (data->debug) { + printk(KERN_DEBUG + "[TSP] raw cap[%d] : %u\n", + k, temp); + } + } + if (temp < data->refer_min) + data->refer_min = temp; + if (temp > data->refer_max) + data->refer_max = temp; + k += 2; + } + } +#else + length = data->x_line * data->y_line * 2; if (NULL == data->references) data->references = kzalloc(length, GFP_KERNEL); @@ -179,6 +253,7 @@ static void check_all_raw_cap(struct synaptics_drv_data *data) if (temp > data->refer_max) data->refer_max = temp; } +#endif printk(KERN_DEBUG "[TSP] min : %u, max : %u\n", data->refer_min, data->refer_max); } @@ -333,6 +408,56 @@ static void check_rx_to_rx(struct synaptics_drv_data *data) kfree(buff); } +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) +static void check_delta_cap(struct synaptics_drv_data *data) +{ + int i, k=0; + u16 temp = 0; + u16 length; + u8 escape_rx_line; + u8 *btn_data; + int start_button_data; + + if (data->pdata->support_extend_button) + escape_rx_line = data->pdata->extend_button_map->nbuttons; + else + escape_rx_line = data->pdata->button_map->nbuttons; + + length = escape_rx_line * 2; + + btn_data = kzalloc(length, GFP_KERNEL); + + data->refer_min = 0xffff; + data->refer_max = 0x0; + + start_button_data = ((data->x_line * (data->y_line + escape_rx_line)) + data->y_line) * 2; + + /* set the index */ + set_report_index(data, start_button_data); + + /* Set the GetReport bit to run the AutoScan */ + set_report_mode(data, 0x01, 0x00); + + /* read all report data */ + synaptics_ts_read_block(data, + data->f54.data_base_addr + 3, + btn_data, length); + + for (i = 0; i < escape_rx_line; i++) { + temp = (u16)(btn_data[k] | (btn_data[k+1] << 8)); + printk(KERN_DEBUG "[TSP] index[btn:%d] data[0x%x]\n", i, temp); + + if (temp > BUTTON_THRESHOLD_LIMIT) + data->pdata->button_pressure[i] = BUTTON_THRESHOLD_MIN; + else + data->pdata->button_pressure[i] = temp; + k = k + 2; + } + + kfree(btn_data); +} +#endif + static void check_diagnostics_mode(struct synaptics_drv_data *data) { /* Set report mode */ @@ -355,6 +480,12 @@ static void check_diagnostics_mode(struct synaptics_drv_data *data) check_rx_to_rx(data); break; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + case REPORT_TYPE_DELTA_CAP: + check_delta_cap(data); + break; +#endif + default: break; } @@ -427,11 +558,25 @@ static u16 get_value(struct synaptics_drv_data *data, u32 pos_x, u32 pos_y) { u16 tmp = 0; + u8 escape_rx_line; switch (data->cmd_report_type) { case REPORT_TYPE_RAW_CAP: { - u16 position = (u16)(data->y_line * pos_x) + pos_y; + u16 position; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYS) + if (data->pdata->support_extend_button) + escape_rx_line = + data->pdata->extend_button_map->nbuttons; + else + escape_rx_line = + data->pdata->button_map->nbuttons; + + position = (u16)((data->y_line + + escape_rx_line) * pos_x) + pos_y; +#else + position = (u16)(data->y_line * pos_x) + pos_y; +#endif position *= 2; tmp = (u16)(data->references[position] | (data->references[position+1] << 8)); @@ -845,6 +990,263 @@ static struct attribute_group sec_sysfs_attr_group = { .attrs = sec_sysfs_attributes, }; +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYLED) +static ssize_t sec_touchkey_sensitivity_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + printk(KERN_INFO "[TSP] do noting!\n"); + return size; +} + +static ssize_t sec_touchkey_back_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON4]); + else + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON2]); +} + +static ssize_t sec_touchkey_menu_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON2]); + else + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON1]); +} + +static ssize_t sec_touchkey_threshold_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d %d %d %d %d\n", + BUTTON5_0_THRESHOLD, + BUTTON5_1_THRESHOLD, + BUTTON5_2_THRESHOLD, + BUTTON5_3_THRESHOLD, + BUTTON5_4_THRESHOLD); + else + return sprintf(buf, "%d %d\n", + BUTTON2_0_THRESHOLD, + BUTTON2_1_THRESHOLD); +} + +static ssize_t sec_touchkey_dummy_btn1_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON1]); + else { + printk(KERN_DEBUG "[TSP] dummy btn1 not supported\n"); + return 0; + } +} + +static ssize_t sec_touchkey_dummy_btn3_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON3]); + else { + printk(KERN_DEBUG "[TSP] dummy btn3 not supported\n"); + return 0; + } +} + +static ssize_t sec_touchkey_dummy_btn5_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d\n", data->pdata->button_pressure[BUTTON5]); + else { + printk(KERN_DEBUG "[TSP] dummy btn5 not supported\n"); + return 0; + } +} + +static ssize_t sec_touchkey_button_all_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int irq = gpio_to_irq(data->gpio); + + disable_irq(irq); + synaptics_ts_write_data(data, 0xf0, 0x01); + data->cmd_report_type = REPORT_TYPE_DELTA_CAP; + check_diagnostics_mode(data); + synaptics_ts_write_data(data, 0xf0, 0x00); + enable_irq(irq); + + if (data->pdata->support_extend_button) + return sprintf(buf, "%d %d %d %d %d\n", + data->pdata->button_pressure[BUTTON1], + data->pdata->button_pressure[BUTTON2], + data->pdata->button_pressure[BUTTON3], + data->pdata->button_pressure[BUTTON4], + data->pdata->button_pressure[BUTTON5]); + else + return sprintf(buf, "%d %d\n", + data->pdata->button_pressure[BUTTON1], + data->pdata->button_pressure[BUTTON2]); +} + +static ssize_t sec_touchkey_button_status_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + u8 int_status = 0; + u8 button_status = 0; + + /* check interrupt status */ + synaptics_ts_read_data(data, + data->f01.data_base_addr + 1, + &int_status); + + /* check button status */ + synaptics_ts_read_data(data, + data->f1a.data_base_addr, + &button_status); + + return sprintf(buf, "%d %d\n", + int_status, + button_status); +} + +static ssize_t sec_brightness_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct synaptics_drv_data *data = dev_get_drvdata(dev); + int on_off; + + if (sscanf(buf, "%d\n", &on_off) == 1) { + //printk(KERN_DEBUG "[TSPLED] touch_led_on [%d]\n", on_off); + data->pdata->led_control(on_off); + } else { + printk(KERN_DEBUG "[TSPLED] buffer read failed\n"); + } + return size; +} + +static ssize_t sec_extra_button_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + int extra_event; + + if (sscanf(buf, "%d\n", &extra_event) == 1) { + printk(KERN_DEBUG "[TSP] extra event [%d]\n", extra_event); + } else { + printk(KERN_DEBUG "[TSP] buffer read failed\n"); + } + return size; +} + +static DEVICE_ATTR(touch_sensitivity, S_IRUGO | S_IWUSR, + NULL, sec_touchkey_sensitivity_store); +static DEVICE_ATTR(touchkey_back, S_IRUGO | S_IWUSR, + sec_touchkey_back_show, NULL); +static DEVICE_ATTR(touchkey_menu, S_IRUGO | S_IWUSR, + sec_touchkey_menu_show, NULL); +static DEVICE_ATTR(touchkey_threshold, S_IRUGO | S_IWUSR, + sec_touchkey_threshold_show, NULL); +static DEVICE_ATTR(touchkey_dummy_btn1, S_IRUGO | S_IWUSR, + sec_touchkey_dummy_btn1_show, NULL); +static DEVICE_ATTR(touchkey_dummy_btn3, S_IRUGO | S_IWUSR, + sec_touchkey_dummy_btn3_show, NULL); +static DEVICE_ATTR(touchkey_dummy_btn5, S_IRUGO | S_IWUSR, + sec_touchkey_dummy_btn5_show, NULL); +static DEVICE_ATTR(touchkey_button_all, S_IRUGO | S_IWUSR, + sec_touchkey_button_all_show, NULL); +static DEVICE_ATTR(brightness, S_IRUGO | S_IWUSR, + NULL, sec_brightness_store); +static DEVICE_ATTR(extra_button_event, S_IRUGO | S_IWUSR, + NULL, sec_extra_button_store); +static DEVICE_ATTR(touchkey_button_status, S_IRUGO | S_IWUSR, + sec_touchkey_button_status_show, NULL); + +static struct attribute *sec_touchkey_sysfs_attributes[] = { + &dev_attr_touch_sensitivity.attr, + &dev_attr_touchkey_back.attr, + &dev_attr_touchkey_menu.attr, + &dev_attr_touchkey_threshold.attr, + &dev_attr_touchkey_dummy_btn1.attr, + &dev_attr_touchkey_dummy_btn3.attr, + &dev_attr_touchkey_dummy_btn5.attr, + &dev_attr_touchkey_button_all.attr, + &dev_attr_brightness.attr, + &dev_attr_extra_button_event.attr, + &dev_attr_touchkey_button_status.attr, + NULL, +}; + +static struct attribute_group sec_touchkey_sysfs_attr_group = { + .attrs = sec_touchkey_sysfs_attributes, +}; +#endif + int set_tsp_sysfs(struct synaptics_drv_data *data) { int ret = 0; @@ -861,6 +1263,23 @@ int set_tsp_sysfs(struct synaptics_drv_data *data) pr_err("[TSP] failed to create sysfs group\n"); goto err_device_create; } +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYLED) + synaptics_with_gpio_led_device = device_create(sec_class, + NULL, 0, data, "sec_touchkey"); + if (IS_ERR(synaptics_with_gpio_led_device)) { + pr_err("[TSP] failed to create device for tsp_touchkey sysfs\n"); + ret = -ENODEV; + goto err_device_create; + } + + ret = sysfs_create_group(&synaptics_with_gpio_led_device->kobj, + &sec_touchkey_sysfs_attr_group); + if (ret) { + pr_err("[TSP] failed to create sec_touchkey sysfs group\n"); + goto err_device_create; + } +#endif + return 0; err_device_create: @@ -877,6 +1296,10 @@ void remove_tsp_sysfs(struct synaptics_drv_data *data) kfree(data->tx_to_gnd); sysfs_remove_group(&data->dev->kobj, &sec_sysfs_attr_group); +#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S7301_KEYLED) + sysfs_remove_group(&synaptics_with_gpio_led_device->kobj, + &sec_touchkey_sysfs_attr_group); +#endif put_device(data->dev); device_unregister(data->dev); } diff --git a/drivers/input/touchscreen/synaptics_sysfs.h b/drivers/input/touchscreen/synaptics_sysfs.h index 6d212c8..0f62b54 100644 --- a/drivers/input/touchscreen/synaptics_sysfs.h +++ b/drivers/input/touchscreen/synaptics_sysfs.h @@ -15,6 +15,7 @@ #include <linux/wakelock.h> #define SYNAPTICS_FW "/sdcard/firmware/synaptics_fw" +#define SYNAPTICS_FW2 "/sdcard/synaptics_fw.img" #define FULL_RAW_CAP_LOWER_LIMIT 1000 #define FULL_RAW_CAP_UPPER_LIMIT 3000 #define MAX_RX_SIZE 45 diff --git a/drivers/input/touchscreen/wacom/w9002_flash.c b/drivers/input/touchscreen/wacom/w9002_flash.c new file mode 100644 index 0000000..e2fe54d --- /dev/null +++ b/drivers/input/touchscreen/wacom/w9002_flash.c @@ -0,0 +1,1253 @@ +/* + * w9002_flash.c - Wacom Digitizer Controller Flash Driver + * + * + * 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., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <linux/wacom_i2c.h> +#include "w9002_flash.h" + +static int wacom_i2c_flash_chksum(struct wacom_i2c *wac_i2c, + unsigned char *flash_data, + unsigned long *max_address) +{ + unsigned long i; + unsigned long chksum = 0; + + for (i = 0x0000; i <= *max_address; i++) + chksum += flash_data[i]; + + chksum &= 0xFFFF; + + return (int)chksum; +} + +static int wacom_flash_cmd(struct wacom_i2c *wac_i2c) +{ + int rv, len, i; + u8 buf[10]; + bool i2c_mode = WACOM_I2C_MODE_BOOT; + +#if defined(CONFIG_MACH_KONA) + buf[0] = 0x0d; + buf[1] = FLASH_START0; + buf[2] = FLASH_START1; + buf[3] = FLASH_START2; + buf[4] = FLASH_START3; + buf[5] = FLASH_START4; + buf[6] = FLASH_START5; + buf[7] = 0x0d; + + len = 8; + rv = wacom_i2c_send(wac_i2c, buf, len, i2c_mode); +#else + + for (i = 0; i < 2; ++i) { + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x32; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, i2c_mode); + if (rv < 0) { + printk(KERN_DEBUG "epen:fail change to normal:%d\n", + rv); + + i2c_mode = WACOM_I2C_MODE_NORMAL; + continue; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 2; + buf[len++] = 2; + + rv = wacom_i2c_send(wac_i2c, buf, len, i2c_mode); + if (rv < 0) { + printk(KERN_DEBUG "epen:fail change to normal:%d\n", + rv); + i2c_mode = WACOM_I2C_MODE_NORMAL; + continue; + } + } +#endif + if (rv < 0) { + printk(KERN_ERR + "Sending flash command failed\n"); + return -1; + } + + printk(KERN_DEBUG "epen:flash cmd sent:%d\n", rv); + msleep(500); + + return 0; +} + +static bool flash_query(struct wacom_i2c *wac_i2c) +{ + int rv, ECH; + u8 buf[4]; + u16 len; + unsigned char command[CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + printk(KERN_DEBUG "epen: %s\n", __func__); + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 5; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_QUERY; + command[6] = ECH = 7; + + rv = wacom_i2c_send(wac_i2c, command, 7, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + if ((response[3] != QUERY_CMD) || (response[4] != ECH)) { + printk(KERN_DEBUG "epen: res3:%d res4:%d\n", response[3], + response[4]); + return false; + } + if (response[5] != QUERY_RSP) { + printk(KERN_DEBUG "epen: res5:%d\n", response[5]); + return false; + } + + return true; +} + +static bool flash_blver(struct wacom_i2c *wac_i2c, int *blver) +{ + int rv, ECH; + u8 buf[4]; + u16 len; + unsigned char command[CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 5; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_BLVER; + command[6] = ECH = 7; + + rv = wacom_i2c_send(wac_i2c, command, 7, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + if ((response[3] != BOOT_CMD) || (response[4] != ECH)) + return false; + + *blver = (int)response[5]; + + return true; +} + +static bool flash_mputype(struct wacom_i2c *wac_i2c, int *pMpuType) +{ + int rv, ECH; + u8 buf[4]; + u16 len; + unsigned char command[CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; /* Command-MSB, SET_REPORT */ + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 5; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_MPU; + command[6] = ECH = 7; + + rv = wacom_i2c_send(wac_i2c, command, 7, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + usleep_range(1000, 1000); + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + if ((response[3] != MPU_CMD) || (response[4] != ECH)) + return false; + + *pMpuType = (int)response[5]; + + return true; +} + +static bool flash_security_unlock(struct wacom_i2c *wac_i2c, int *status) +{ + int rv, ECH; + u8 buf[4]; + u16 len; + unsigned char command[CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 5; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_SECURITY_UNLOCK; + command[6] = ECH = 7; + + rv = wacom_i2c_send(wac_i2c, command, 7, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return 0; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + usleep_range(1000, 1000); + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + if ((response[3] != SEC_CMD) || (response[4] != ECH)) + return false; + + *status = (int)response[5]; + + return true; +} + +static bool flash_end(struct wacom_i2c *wac_i2c) +{ + int rv, ECH; + u8 buf[4]; + u16 len; + unsigned char command[CMD_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 5; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_EXIT; + command[6] = ECH = 7; + + rv = wacom_i2c_send(wac_i2c, command, 7, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + return true; +} + +static int GetBLVersion(struct wacom_i2c *wac_i2c, int *pBLVer) +{ + int rv; + int retry = 0; + + wacom_flash_cmd(wac_i2c); + do { + msleep(100); + rv = flash_query(wac_i2c); + retry++; + } while (rv < 0 && retry < 10); + + if (rv < 0) + return EXIT_FAIL_GET_BOOT_LOADER_VERSION; + + rv = flash_blver(wac_i2c, pBLVer); + if (rv) + return EXIT_OK; + else + return EXIT_FAIL_GET_BOOT_LOADER_VERSION; +} + +static int GetMpuType(struct wacom_i2c *wac_i2c, int *pMpuType) +{ + int rv; + + if (!flash_query(wac_i2c)) { + if (!wacom_flash_cmd(wac_i2c)) { + return EXIT_FAIL_ENTER_FLASH_MODE; + } else { + msleep(100); + if (!flash_query(wac_i2c)) + return EXIT_FAIL_FLASH_QUERY; + } + } + + rv = flash_mputype(wac_i2c, pMpuType); + if (rv) + return EXIT_OK; + else + return EXIT_FAIL_GET_MPU_TYPE; +} + +static int SetSecurityUnlock(struct wacom_i2c *wac_i2c, int *pStatus) +{ + int rv; + + if (!flash_query(wac_i2c)) { + if (!wacom_flash_cmd(wac_i2c)) { + return EXIT_FAIL_ENTER_FLASH_MODE; + } else { + msleep(100); + if (!flash_query(wac_i2c)) + return EXIT_FAIL_FLASH_QUERY; + } + } + + rv = flash_security_unlock(wac_i2c, pStatus); + if (rv) + return EXIT_OK; + else + return EXIT_FAIL; +} + +static bool flash_erase(struct wacom_i2c *wac_i2c, bool bAllUserArea, + int *eraseBlock, int num) +{ + int rv, ECH; + unsigned char sum; + unsigned char buf[72]; + unsigned char cmd_chksum; + u16 len; + int i, j; + unsigned char command[CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + for (i = 0; i < num; i++) { + /*msleep(500);*/ +retry: + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: failing 1:%d\n", i); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 7; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_ERASE_FLASH; + command[6] = ECH = i; + command[7] = *eraseBlock; + eraseBlock++; + + sum = 0; + for (j = 0; j < 8; j++) + sum += command[j]; + cmd_chksum = ~sum + 1; + command[8] = cmd_chksum; + + rv = wacom_i2c_send(wac_i2c, command, 9, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: failing 2:%d\n", i); + return false; + } + + switch (i) { + case 0: + msleep(3000); + break; + + case 1: + msleep(3000); + break; + + case 2: + msleep(5000); + break; + + case 3: + msleep(500); + break; + + default: + msleep(5000); + break; + } + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: failing 3:%d\n", i); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: failing 4:%d\n", i); + return false; + } + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: failing 5:%d\n", i); + return false; + } + + if ((response[3] != ERS_CMD) || (response[4] != ECH)) { + printk(KERN_DEBUG "epen: failing 6:%d\n", i); + return false; + } + + if (response[5] == 0x80) { + printk(KERN_DEBUG "epen: retry\n"); + goto retry; + } + if (response[5] != ACK) { + printk(KERN_DEBUG "epen: failing 7:%d res5:%d\n", i, + response[5]); + return false; + } + } + return true; +} + +static bool is_flash_marking(struct wacom_i2c *wac_i2c, + size_t data_size, bool *bMarking, int iMpuID) +{ + const int MAX_CMD_SIZE = (12 + FLASH_BLOCK_SIZE + 2); + int rv, ECH; + unsigned char flash_data[FLASH_BLOCK_SIZE]; + unsigned char buf[300]; + unsigned char sum; + int len; + unsigned int i, j; + unsigned char response[RSP_SIZE]; + unsigned char command[MAX_CMD_SIZE]; + + *bMarking = false; + + printk(KERN_DEBUG "epen: started\n"); + for (i = 0; i < FLASH_BLOCK_SIZE; i++) + flash_data[i] = 0xFF; + + flash_data[56] = 0x00; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 76; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_VERIFY_FLASH; + command[6] = ECH = 1; + command[7] = 0xC0; + command[8] = 0x1F; + command[9] = 0x01; + command[10] = 0x00; + command[11] = 8; + + sum = 0; + for (j = 0; j < 12; j++) + sum += command[j]; + + command[MAX_CMD_SIZE - 2] = ~sum + 1; + + sum = 0; + printk(KERN_DEBUG "epen: start writing command\n"); + for (i = 12; i < (FLASH_BLOCK_SIZE + 12); i++) { + command[i] = flash_data[i - 12]; + sum += flash_data[i - 12]; + } + command[MAX_CMD_SIZE - 1] = ~sum + 1; + + printk(KERN_DEBUG "epen: sending command\n"); + rv = wacom_i2c_send(wac_i2c, command, MAX_CMD_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + rv = wacom_i2c_recv(wac_i2c, response, RSP_SIZE, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + printk(KERN_DEBUG "epen: checking response\n"); + if ((response[3] != MARK_CMD) || + (response[4] != ECH) || (response[5] != ACK)) { + printk(KERN_DEBUG "epen: fails res3:%d res4:%d res5:%d\n", + response[3], response[4], response[5]); + return false; + } + + *bMarking = true; + return true; +} + +static bool flash_write_block(struct wacom_i2c *wac_i2c, char *flash_data, + unsigned long ulAddress, u8 *pcommand_id) +{ + const int MAX_COM_SIZE = (12 + FLASH_BLOCK_SIZE + 2); + int len, ECH; + unsigned char buf[300]; + int rv; + unsigned char sum; + unsigned char command[MAX_COM_SIZE]; + unsigned char response[RSP_SIZE]; + unsigned int i; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) + return false; + + command[0] = 5; + command[1] = 0; + command[2] = 76; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_WRITE_FLASH; + command[6] = ECH = ++(*pcommand_id); + command[7] = ulAddress & 0x000000ff; + command[8] = (ulAddress & 0x0000ff00) >> 8; + command[9] = (ulAddress & 0x00ff0000) >> 16; + command[10] = (ulAddress & 0xff000000) >> 24; + command[11] = 8; + sum = 0; + for (i = 0; i < 12; i++) + sum += command[i]; + command[MAX_COM_SIZE - 2] = ~sum + 1; + + sum = 0; + for (i = 12; i < (FLASH_BLOCK_SIZE + 12); i++) { + command[i] = flash_data[ulAddress + (i - 12)]; + sum += flash_data[ulAddress + (i - 12)]; + } + command[MAX_COM_SIZE - 1] = ~sum + 1; + + rv = wacom_i2c_send(wac_i2c, command, BOOT_CMD_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + if ((response[3] != WRITE_CMD) || + (response[4] != ECH) || response[5] != ACK) + return false; + + return true; + +} + +static bool flash_write(struct wacom_i2c *wac_i2c, + unsigned char *flash_data, size_t data_size, + unsigned long start_address, unsigned long *max_address, + int mpuType) +{ + unsigned long ulAddress; + int i; + bool rv; + unsigned long pageNo = 0; + u8 command_id = 0; + + printk(KERN_DEBUG "epen: flash_write start\n"); + + for (ulAddress = start_address; ulAddress < *max_address; + ulAddress += FLASH_BLOCK_SIZE) { + unsigned int j; + bool bWrite = false; + + /* Wacom 2012/10/04: skip if all each data locating on + from ulAddr to ulAddr+Block_SIZE_W are 0xff */ + for (i = 0; i < FLASH_BLOCK_SIZE; i++) { + if (flash_data[ulAddress + i] != 0xFF) + break; + } + if (i == (FLASH_BLOCK_SIZE)) { + /*printk(KERN_DEBUG"epen:BLOCK PASSED\n"); */ + continue; + } + /* Wacom 2012/10/04 */ + + for (j = 0; j < FLASH_BLOCK_SIZE; j++) { + if (flash_data[ulAddress + j] == 0xFF) + continue; + else { + bWrite = true; + break; + } + } + + if (!bWrite) { + pageNo++; + continue; + } + + rv = flash_write_block(wac_i2c, flash_data, ulAddress, + &command_id); + if (!rv) + return false; + + pageNo++; + } + + return true; +} + +static bool flash_verify(struct wacom_i2c *wac_i2c, + unsigned char *flash_data, size_t data_size, + unsigned long start_address, + unsigned long *max_address, int mpuType) +{ + int ECH; + unsigned long ulAddress; + int rv; + unsigned long pageNo = 0; + u8 command_id = 0; + printk(KERN_DEBUG "epen: verify starts\n"); + for (ulAddress = start_address; ulAddress < *max_address; + ulAddress += FLASH_BLOCK_SIZE) { + const int MAX_CMD_SIZE = 12 + FLASH_BLOCK_SIZE + 2; + unsigned char buf[300]; + unsigned char sum; + int len; + unsigned int i, j; + unsigned char command[MAX_CMD_SIZE]; + unsigned char response[RSP_SIZE]; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 76; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_VERIFY_FLASH; + command[6] = ECH = ++command_id; + command[7] = ulAddress & 0x000000ff; + command[8] = (ulAddress & 0x0000ff00) >> 8; + command[9] = (ulAddress & 0x00ff0000) >> 16; + command[10] = (ulAddress & 0xff000000) >> 24; + command[11] = 8; + + sum = 0; + for (j = 0; j < 12; j++) + sum += command[j]; + command[MAX_CMD_SIZE - 2] = ~sum + 1; + + sum = 0; + for (i = 12; i < (FLASH_BLOCK_SIZE + 12); i++) { + command[i] = flash_data[ulAddress + (i - 12)]; + sum += flash_data[ulAddress + (i - 12)]; + } + command[MAX_CMD_SIZE - 1] = ~sum + 1; + + rv = wacom_i2c_send(wac_i2c, command, BOOT_CMD_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + if (ulAddress <= 0x0ffff) + ndelay(250000); + else if (ulAddress >= 0x10000 && ulAddress <= 0x20000) + ndelay(350000); + else + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 5 rv:%d\n", rv); + return false; + } + + if ((response[3] != VERIFY_CMD) || + (response[4] != ECH) || (response[5] != ACK)) { + printk(KERN_DEBUG "epen: res3:%d res4:%d res5:%d\n", + response[3], response[4], response[5]); + return false; + } + pageNo++; + } + + return true; +} + +static bool flash_marking(struct wacom_i2c *wac_i2c, + size_t data_size, bool bMarking, int iMpuID) +{ + const int MAX_CMD_SIZE = 12 + FLASH_BLOCK_SIZE + 2; + int rv, ECH; + unsigned char flash_data[FLASH_BLOCK_SIZE]; + unsigned char buf[300]; + unsigned char response[RSP_SIZE]; + unsigned char sum; + int len; + unsigned int i, j; + unsigned char command[MAX_CMD_SIZE]; + + for (i = 0; i < FLASH_BLOCK_SIZE; i++) + flash_data[i] = 0xFF; + + if (bMarking) + flash_data[56] = 0x00; + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x37; + buf[len++] = CMD_SET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 1 rv:%d\n", rv); + return false; + } + + command[0] = 5; + command[1] = 0; + command[2] = 76; + command[3] = 0; + command[4] = BOOT_CMD_REPORT_ID; + command[5] = BOOT_WRITE_FLASH; + command[6] = ECH = 1; + command[7] = 0xC0; + command[8] = 0x1F; + command[9] = 0x01; + command[10] = 0x00; + command[11] = 8; + + sum = 0; + for (j = 0; j < 12; j++) + sum += command[j]; + command[MAX_CMD_SIZE - 2] = ~sum + 1; + + sum = 0; + for (i = 12; i < (FLASH_BLOCK_SIZE + 12); i++) { + command[i] = flash_data[i - 12]; + sum += flash_data[i - 12]; + } + command[MAX_CMD_SIZE - 1] = ~sum + 1; + + rv = wacom_i2c_send(wac_i2c, command, BOOT_CMD_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 2 rv:%d\n", rv); + return false; + } + + usleep_range(10000, 10000); + + len = 0; + buf[len++] = 4; + buf[len++] = 0; + buf[len++] = 0x38; + buf[len++] = CMD_GET_FEATURE; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 3 rv:%d\n", rv); + return false; + } + + len = 0; + buf[len++] = 5; + buf[len++] = 0; + + rv = wacom_i2c_send(wac_i2c, buf, len, WACOM_I2C_MODE_BOOT); + if (rv < 0) { + printk(KERN_DEBUG "epen: 4 rv:%d\n", rv); + return false; + } + + printk(KERN_DEBUG "epen: confirming marking\n"); + rv = wacom_i2c_recv(wac_i2c, response, BOOT_RSP_SIZE, + WACOM_I2C_MODE_BOOT); + if (rv < 0) + return false; + + if ((response[3] != 1) || (response[4] != ECH)\ + || (response[5] != ACK)) { + printk(KERN_DEBUG "epen: failing res3:%d res4:%d res5:%d\n", + response[3], response[4], response[5]); + return false; + } + + return true; +} + +int wacom_i2c_flash(struct wacom_i2c *wac_i2c) +{ + unsigned long max_address = 0; + unsigned long start_address = 0x4000; + int eraseBlock[50], eraseBlockNum; + bool bRet; + int iChecksum; + int iBLVer, iMpuType, iStatus; + bool bMarking; + int iRet; + unsigned long ulMaxRange; + + if (Binary == NULL) { + printk(KERN_ERR"[E-PEN] Data is NULL. Exit.\n"); + return -1; + } + +#ifdef WACOM_HAVE_FWE_PIN + if (wac_i2c->have_fwe_pin) { + wac_i2c->wac_pdata->compulsory_flash_mode(true); + /*Reset */ + wac_i2c->wac_pdata->reset_platform_hw(); + msleep(200); + printk(KERN_DEBUG "epen: Set FWE\n"); + } +#endif + wake_lock(&wac_i2c->wakelock); + + printk(KERN_DEBUG "epen:start getting the boot loader version\n"); + /*Obtain boot loader version */ + iRet = GetBLVersion(wac_i2c, &iBLVer); + if (iRet != EXIT_OK) { + printk(KERN_DEBUG "epen:failed to get Boot Loader version\n"); + goto fw_update_error; + } + + printk(KERN_DEBUG "epen: start getting the MPU version\n"); + /*Obtain MPU type: this can be manually done in user space */ + iRet = GetMpuType(wac_i2c, &iMpuType); + if (iRet != EXIT_OK) { + printk(KERN_DEBUG "epen: failed to get MPU type\n"); + goto fw_update_error; + } + + /*Set start and end address and block numbers */ + eraseBlockNum = 0; + start_address = 0x4000; + max_address = 0x12FFF; + eraseBlock[eraseBlockNum++] = 2; + eraseBlock[eraseBlockNum++] = 1; + eraseBlock[eraseBlockNum++] = 0; + eraseBlock[eraseBlockNum++] = 3; + + printk(KERN_DEBUG "epen: obtaining the checksum\n"); + /*Calculate checksum */ + iChecksum = wacom_i2c_flash_chksum(wac_i2c, Binary, &max_address); + printk(KERN_DEBUG "epen: Checksum is :%d\n", iChecksum); + + bRet = true; + + printk(KERN_DEBUG "epen: setting the security unlock\n"); + /*Unlock security */ + iRet = SetSecurityUnlock(wac_i2c, &iStatus); + if (iRet != EXIT_OK) { + printk(KERN_DEBUG "epen: failed to set security unlock\n"); + goto fw_update_error; + } + + /*Set adress range */ + ulMaxRange = max_address; + ulMaxRange -= start_address; + ulMaxRange >>= 6; + if (max_address > (ulMaxRange << 6)) + ulMaxRange++; + + printk(KERN_DEBUG "epen: connecting to Wacom Digitizer\n"); + printk(KERN_DEBUG "epen: erasing the current firmware\n"); + /*Erase the old program */ + bRet = flash_erase(wac_i2c, true, eraseBlock, eraseBlockNum); + if (!bRet) { + printk(KERN_DEBUG "epen: failed to erase the user program\n"); + iRet = EXIT_FAIL_ERASE; + goto fw_update_error; + } + printk(KERN_DEBUG "epen: erasing done\n"); + + max_address = 0x11FC0; + + printk(KERN_DEBUG "epen: writing new firmware\n"); + /*Write the new program */ + bRet = + flash_write(wac_i2c, Binary, DATA_SIZE, start_address, &max_address, + iMpuType); + if (!bRet) { + printk(KERN_DEBUG "epen: failed to write firmware\n"); + iRet = EXIT_FAIL_WRITE_FIRMWARE; + goto fw_update_error; + } + + printk(KERN_DEBUG "epen: start marking\n"); + /*Set mark in writing process */ + bRet = flash_marking(wac_i2c, DATA_SIZE, true, iMpuType); + if (!bRet) { + printk(KERN_DEBUG "epen: failed to mark firmware\n"); + iRet = EXIT_FAIL_WRITE_FIRMWARE; + goto fw_update_error; + } + + /*Set the address for verify */ + start_address = 0x4000; + max_address = 0x11FBF; + + printk(KERN_DEBUG "epen: start the verification\n"); + /*Verify the written program */ + bRet = + flash_verify(wac_i2c, Binary, DATA_SIZE, start_address, + &max_address, iMpuType); + if (!bRet) { + printk(KERN_DEBUG "epen: failed to verify the firmware\n"); + iRet = EXIT_FAIL_VERIFY_FIRMWARE; + goto fw_update_error; + } + + printk(KERN_DEBUG "epen: checking the mark\n"); + /*Set mark */ + bRet = is_flash_marking(wac_i2c, DATA_SIZE, &bMarking, iMpuType); + if (!bRet) { + printk(KERN_DEBUG "epen: marking firmwrae failed\n"); + iRet = EXIT_FAIL_WRITING_MARK_NOT_SET; + goto fw_update_error; + } + + /*Enable */ + printk(KERN_DEBUG "epen: closing the boot mode\n"); + bRet = flash_end(wac_i2c); + if (!bRet) { + printk(KERN_DEBUG "epen: closing boot mode failed\n"); + iRet = EXIT_FAIL_WRITING_MARK_NOT_SET; + goto fw_update_error; + } + iRet = EXIT_OK; + printk(KERN_DEBUG "epen: write and verify completed\n"); + +fw_update_error: + wake_unlock(&wac_i2c->wakelock); + +#ifdef WACOM_HAVE_FWE_PIN + if (wac_i2c->have_fwe_pin) { + wac_i2c->wac_pdata->compulsory_flash_mode(false); + /*Reset */ + wac_i2c->wac_pdata->reset_platform_hw(); + msleep(200); + } +#endif + return iRet; +} diff --git a/drivers/input/touchscreen/wacom/w9002_flash.h b/drivers/input/touchscreen/wacom/w9002_flash.h new file mode 100644 index 0000000..a6d0e49 --- /dev/null +++ b/drivers/input/touchscreen/wacom/w9002_flash.h @@ -0,0 +1,211 @@ +/* + * w9002_flash.h + * + * + * 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., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include "wacom_i2c_func.h" +#include "wacom_i2c_firm.h" + +#ifndef _WACOM_I2C_FLASH_H +#define _WACOM_I2C_FLASH_H + +#define WACOM_CMD_QUERY0 0x04 +#define WACOM_CMD_QUERY1 0x00 +#define WACOM_CMD_QUERY2 0x33 +#define WACOM_CMD_QUERY3 0x02 +#define WACOM_CMD_THROW0 0x05 +#define WACOM_CMD_THROW1 0x00 +#define WACOM_QUERY_SIZE 19 +#define WACOM_RETRY_CNT 100 + +struct flash { + int BLen; + unsigned long size; + unsigned char *data; +}; + +#define FLASH_START0 'f' +#define FLASH_START1 'l' +#define FLASH_START2 'a' +#define FLASH_START3 's' +#define FLASH_START4 'h' +#define FLASH_START5 '\r' +#define FLASH_ACK 0x06 + +#define pana_QUERY 0x11 + +#define flash_END 0x80 +#define flash_VERIFY 0x81 +#define flash_WRITE 0x82 +#define flash_READ 0x83 +#define flash_ERASE 0x84 +#define flash_SET_INFO 0x85 +#define flash_END_TO_BOOT 0x87 +#define flash_BAUDRATE 0x88 + +#define flash_QUERY 0xE0 +#define flash_BLVER 0xE1 +#define flash_UNITID 0xE2 +#define flash_GET_INFO 0xE3 +#define flash_FWVER 0xE4 +#define flash_MPU 0xE8 + +#define pen_QUERY '*' + +#define V09 0 +#define V095 1 + +#define HIDIIC_VERSION V095 + +#define FLASH_BLOCK_SIZE 64 + +#define ASCINT_ON 0x0 +#define ASCINT_OFF 0x1 +#define ASCINT_ERROR 0xFF + +/*#define WRITE 0*/ +#define VERIFY 1 +#define WRITEVERIFY 2 +#define ERASE 3 +#define GETVERSION 4 + +#define USER_ADDRESS 0x56 +#define BOOT_ADDRESS 0x57 + +#define CMD_GET_FEATURE 2 +#define CMD_SET_FEATURE 3 + +#define ACK 0 + +#define BOOT_CMD_SIZE 78 +#define BOOT_RSP_SIZE 6 + +#define BOOT_CMD_REPORT_ID 7 + +#define BOOT_ERASE_FLASH 0 +#define BOOT_WRITE_FLASH 1 +#define BOOT_VERIFY_FLASH 2 +#define BOOT_EXIT 3 +#define BOOT_BLVER 4 +#define BOOT_MPU 5 +#define BOOT_SECURITY_UNLOCK 6 +#define BOOT_QUERY 7 + +#define QUERY_CMD 0x07 +#define QUERY_ECH 'D' +#define QUERY_RSP 0x06 + +#define BOOT_CMD 0x04 +#define BOOT_ECH 'D' + +#define MPU_CMD 0x05 +#define MPU_ECH 'D' + +#define SEC_CMD 0x06 +#define SEC_ECH 'D' +#define SEC_RSP 0x00 + +#define ERS_CMD 0x00 +#define ERS_ECH 'D' +#define ERS_RSP 0x00 + +#define MARK_CMD 0x02 +#define MARK_ECH 'D' +#define MARK_RSP 0x00 + +#define WRITE_CMD 0x01 +#define WRITE_ECH 'D' +#define WRITE_RSP 0x00 + +#define VERIFY_CMD 0x02 +#define VERIFY_ECH 'D' +#define VERIFY_RSP 0x00 + +#define CMD_SIZE (72+6) +#define RSP_SIZE 6 + +#define DATA_SIZE (65536 * 2) + +/*exit codes*/ +#define EXIT_OK (0) +#define EXIT_REBOOT (1) +#define EXIT_FAIL (2) +#define EXIT_USAGE (3) +#define EXIT_NO_SUCH_FILE (4) +#define EXIT_NO_INTEL_HEX (5) +#define EXIT_FAIL_OPEN_COM_PORT (6) +#define EXIT_FAIL_ENTER_FLASH_MODE (7) +#define EXIT_FAIL_FLASH_QUERY (8) +#define EXIT_FAIL_BAUDRATE_CHANGE (9) +#define EXIT_FAIL_WRITE_FIRMWARE (10) +#define EXIT_FAIL_EXIT_FLASH_MODE (11) +#define EXIT_CANCEL_UPDATE (12) +#define EXIT_SUCCESS_UPDATE (13) +#define EXIT_FAIL_HID2SERIAL (14) +#define EXIT_FAIL_VERIFY_FIRMWARE (15) +#define EXIT_FAIL_MAKE_WRITING_MARK (16) +#define EXIT_FAIL_ERASE_WRITING_MARK (17) +#define EXIT_FAIL_READ_WRITING_MARK (18) +#define EXIT_EXIST_MARKING (19) +#define EXIT_FAIL_MISMATCHING (20) +#define EXIT_FAIL_ERASE (21) +#define EXIT_FAIL_GET_BOOT_LOADER_VERSION (22) +#define EXIT_FAIL_GET_MPU_TYPE (23) +#define EXIT_MISMATCH_BOOTLOADER (24) +#define EXIT_MISMATCH_MPUTYPE (25) +#define EXIT_FAIL_ERASE_BOOT (26) +#define EXIT_FAIL_WRITE_BOOTLOADER (27) +#define EXIT_FAIL_SWAP_BOOT (28) +#define EXIT_FAIL_WRITE_DATA (29) +#define EXIT_FAIL_GET_FIRMWARE_VERSION (30) +#define EXIT_FAIL_GET_UNIT_ID (31) +#define EXIT_FAIL_SEND_STOP_COMMAND (32) +#define EXIT_FAIL_SEND_QUERY_COMMAND (33) +#define EXIT_NOT_FILE_FOR_535 (34) +#define EXIT_NOT_FILE_FOR_514 (35) +#define EXIT_NOT_FILE_FOR_503 (36) +#define EXIT_MISMATCH_MPU_TYPE (37) +#define EXIT_NOT_FILE_FOR_515 (38) +#define EXIT_NOT_FILE_FOR_1024 (39) +#define EXIT_FAIL_VERIFY_WRITING_MARK (40) +#define EXIT_DEVICE_NOT_FOUND (41) +#define EXIT_FAIL_WRITING_MARK_NOT_SET (42) + +/*For Report Descreptor of HID over I2C*/ +#define HID_USAGE_UNDEFINED 0x00 +#define HID_USAGE_PAGE 0x05 +#define HID_USAGE_PAGE_DIGITIZER 0x0d +#define HID_USAGE_PAGE_DESKTOP 0x01 +#define HID_USAGE 0x09 +#define HID_USAGE_X 0x30 +#define HID_USAGE_Y 0x31 +#define HID_USAGE_X_TILT 0x3d +#define HID_USAGE_Y_TILT 0x3e +#define HID_USAGE_FINGER 0x22 +#define HID_USAGE_STYLUS 0x20 +#define HID_USAGE_TIP_PRESSURE 0x30 +#define HID_COLLECTION 0xc0 + +#define I2C_REQ_GET_REPORT 0x01 +#define I2C_REQ_SET_REPORT 0x09 + +#define WAC_HID_FEATURE_REPORT 0x03 +#define WAC_MSG_RETRIES 5 + +extern int wacom_i2c_flash(struct wacom_i2c *wac_i2c); + +#endif /*_WACOM_I2C_FLASH_H*/ diff --git a/drivers/input/touchscreen/wacom/wacom_i2c.c b/drivers/input/touchscreen/wacom/wacom_i2c.c index e0dd530..4a47709 100644 --- a/drivers/input/touchscreen/wacom/wacom_i2c.c +++ b/drivers/input/touchscreen/wacom/wacom_i2c.c @@ -25,7 +25,11 @@ #include <linux/uaccess.h> #include <linux/firmware.h> #include "wacom_i2c_func.h" +#ifdef CONFIG_EPEN_WACOM_G9PL +#include "w9002_flash.h" +#else #include "wacom_i2c_flash.h" +#endif #ifdef WACOM_IMPORT_FW_ALGO #include "wacom_i2c_coord_tables.h" #endif @@ -151,13 +155,19 @@ int wacom_i2c_get_ums_data(struct wacom_i2c *wac_i2c, u8 **ums_data) "[E-PEN] start, file path %s, size %ld Bytes\n", WACOM_FW_PATH, fsize); +#ifndef CONFIG_MACH_KONA if (fsize != nSize) { printk(KERN_ERR "[E-PEN] UMS firmware size is different\n"); ret = -EFBIG; goto size_error; } +#endif +#ifdef CONFIG_MACH_KONA + *ums_data = kmalloc(65536*2, GFP_KERNEL); +#else *ums_data = kmalloc(fsize, GFP_KERNEL); +#endif if (IS_ERR(*ums_data)) { printk(KERN_ERR "[E-PEN] %s, kmalloc failed\n", __func__); @@ -165,6 +175,10 @@ int wacom_i2c_get_ums_data(struct wacom_i2c *wac_i2c, u8 **ums_data) goto malloc_error; } +#ifdef CONFIG_MACH_KONA + memset((void *)*ums_data, 0xff, 65536*2); +#endif + nread = vfs_read(fp, (char __user *)*ums_data, fsize, &fp->f_pos); printk(KERN_NOTICE "[E-PEN] nread %ld Bytes\n", nread); @@ -223,12 +237,25 @@ int wacom_i2c_fw_update_UMS(struct wacom_i2c *wac_i2c) return 0; } -#if defined(CONFIG_MACH_Q1_BD) || defined(CONFIG_MACH_T0) +#if defined(CONFIG_MACH_Q1_BD) || defined(CONFIG_MACH_T0)\ + || defined(CONFIG_MACH_KONA) int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c) { int ret; int retry = 3; const struct firmware *firm_data = NULL; + +#if defined(CONFIG_MACH_KONA) + u8 *flash_data; + + flash_data = kmalloc(65536*2, GFP_KERNEL); + if (IS_ERR(flash_data)) { + printk(KERN_ERR + "[E-PEN] %s, kmalloc failed\n", __func__); + return -1; + } + memset((void *)flash_data, 0xff, 65536*2); +#endif firmware_updating_state = true; @@ -242,8 +269,14 @@ int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c) ret, retry); continue; } +#if defined(CONFIG_MACH_KONA) + memcpy((void *)flash_data, + (const void *)firm_data->data, + firm_data->size); + wacom_i2c_set_firm_data((unsigned char *)flash_data); +#else wacom_i2c_set_firm_data((unsigned char *)firm_data->data); - +#endif ret = wacom_i2c_flash(wac_i2c); if (ret == 0) { @@ -259,6 +292,10 @@ int wacom_i2c_firm_update(struct wacom_i2c *wac_i2c) } firmware_updating_state = false; + +#if defined(CONFIG_MACH_KONA) + kfree(flash_data); +#endif if (ret < 0) return -1; @@ -535,6 +572,14 @@ static void wacom_i2c_set_input_values(struct i2c_client *client, /* __set_bit(BTN_STYLUS2, input_dev->keybit); */ /* __set_bit(ABS_MISC, input_dev->absbit); */ + + /*softkey*/ +#ifdef WACOM_USE_SOFTKEY + __set_bit(EV_LED, input_dev->evbit); + __set_bit(LED_MISC, input_dev->ledbit); + __set_bit(KEY_MENU, input_dev->keybit); + __set_bit(KEY_BACK, input_dev->keybit); +#endif } static int wacom_check_emr_prox(struct wacom_g5_callbacks *cb) @@ -1349,6 +1394,9 @@ static int wacom_i2c_probe(struct i2c_client *client, /*Set switch type*/ wac_i2c->invert_pen_insert = wacom_i2c_invert_by_switch_type(); +#elif defined(CONFIG_MACH_KONA) + wac_i2c->wac_pdata->late_resume_platform_hw(); + msleep(200); #endif #ifdef WACOM_PDCT_WORK_AROUND wac_i2c->pen_pdct = PDCT_NOSIGNAL; @@ -1447,7 +1495,7 @@ static int wacom_i2c_probe(struct i2c_client *client, printk(KERN_ERR "[E-PEN] exynos_cpufreq_get_level Error\n"); #ifdef SEC_BUS_LOCK wac_i2c->dvfs_lock_status = false; -#if defined(CONFIG_MACH_P4NOTE) +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) wac_i2c->bus_dev = dev_get("exynos-busfreq"); #endif /* CONFIG_MACH_P4NOTE */ #endif /* SEC_BUS_LOCK */ diff --git a/drivers/input/touchscreen/wacom/wacom_i2c_firm.c b/drivers/input/touchscreen/wacom/wacom_i2c_firm.c index fddb8c9..f826f86 100644 --- a/drivers/input/touchscreen/wacom/wacom_i2c_firm.c +++ b/drivers/input/touchscreen/wacom/wacom_i2c_firm.c @@ -71,6 +71,13 @@ char Firmware_checksum[] = { 0x1F, 0x27, 0x85, 0x8B, 0xFB, }; const char B713X_checksum[] = { 0x1F, 0xB5, 0x84, 0x38, 0x34, }; /*checksum for 0x16*/ const char B660X_checksum[] = { 0x1F, 0x83, 0x88, 0xD4, 0x67, }; +#elif defined(CONFIG_MACH_KONA) +const unsigned int Binary_nLength = 0xCBCB; +const unsigned char Mpu_type = 0x00; +unsigned int Firmware_version_of_file = 0x65D; +unsigned char *firmware_name = "epen/W9002_B781.bin"; + +char Firmware_checksum[] = { 0x1F, 0x72, 0xCD, 0x6E, 0xE3, }; #endif void wacom_i2c_set_firm_data(unsigned char *Binary_new) diff --git a/drivers/input/touchscreen/wacom/wacom_i2c_flash.c b/drivers/input/touchscreen/wacom/wacom_i2c_flash.c index 691e66c..cf92018 100644 --- a/drivers/input/touchscreen/wacom/wacom_i2c_flash.c +++ b/drivers/input/touchscreen/wacom/wacom_i2c_flash.c @@ -73,6 +73,28 @@ int wacom_i2c_flash_cmd(struct wacom_i2c *wac_i2c) int ret, len, i; u8 buf[10], flashq; + +#if defined(CONFIG_MACH_KONA) + buf[0] = 0x0d; + buf[1] = FLASH_START0; + buf[2] = FLASH_START1; + buf[3] = FLASH_START2; + buf[4] = FLASH_START3; + buf[5] = FLASH_START4; + buf[6] = FLASH_START5; + buf[7] = 0x0d; + + printk(KERN_DEBUG "[E-PEN][jjals] w9002 running!!\n"); + + len = 8; + ret = i2c_master_send(wac_i2c->client, buf, len); + + if (ret < 0) { + printk(KERN_ERR + "Sending flash command failed\n"); + return -1; + } +#else buf[0] = 0x0d; buf[1] = FLASH_START0; @@ -110,8 +132,7 @@ int wacom_i2c_flash_cmd(struct wacom_i2c *wac_i2c) printk(KERN_DEBUG "[E-PEN]: flash send?:%d\n", ret); msleep(270); } - - wac_i2c->boot_mode = true; +#endif return 0; } @@ -174,6 +195,9 @@ int wacom_i2c_flash_enter(struct wacom_i2c *wac_i2c) { if (wacom_i2c_flash_query(wac_i2c, FLASH_QUERY, FLASH_ACK) == -1) return ERR_NOT_FLASH; + + wac_i2c->boot_mode = true; + return 0; } diff --git a/drivers/input/touchscreen/wacom/wacom_i2c_func.c b/drivers/input/touchscreen/wacom/wacom_i2c_func.c index 18a7900..a981cbc 100644 --- a/drivers/input/touchscreen/wacom/wacom_i2c_func.c +++ b/drivers/input/touchscreen/wacom/wacom_i2c_func.c @@ -381,7 +381,8 @@ int wacom_i2c_query(struct wacom_i2c *wac_i2c) #if defined(CONFIG_MACH_Q1_BD)\ || defined(CONFIG_MACH_P4NOTE)\ - || defined(CONFIG_MACH_T0) + || defined(CONFIG_MACH_T0)\ + || defined(CONFIG_MACH_KONA) wac_feature->x_max = (u16) WACOM_MAX_COORD_X; wac_feature->y_max = (u16) WACOM_MAX_COORD_Y; #else @@ -425,7 +426,7 @@ int wacom_i2c_query(struct wacom_i2c *wac_i2c) } wac_i2c->query_status = true; -#if defined(CONFIG_MACH_P4NOTE) +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) wacom_checksum(wac_i2c); #endif @@ -797,6 +798,9 @@ static bool wacom_i2c_coord_range(s16 *x, s16 *y) #if defined(CONFIG_MACH_T0) if ((*x >= 0) && (*y >= 0) && (*x <= WACOM_POSX_MAX) && (*y <= WACOM_POSY_MAX - 50)) +#elif defined(CONFIG_MACH_KONA) + if ((*x >= WACOM_POSX_OFFSET) && (*y >= WACOM_POSX_OFFSET) && + (*x <= WACOM_POSY_MAX) && (*y <= WACOM_POSX_MAX)) #else if ((*x <= WACOM_POSX_MAX) && (*y <= WACOM_POSY_MAX)) #endif @@ -805,6 +809,29 @@ static bool wacom_i2c_coord_range(s16 *x, s16 *y) return false; } +#ifdef WACOM_USE_SOFTKEY +static int keycode[] = { + KEY_MENU, KEY_BACK, +}; +void wacom_i2c_softkey(struct wacom_i2c *wac_i2c, s16 key, s16 pressed) +{ + if (gpio_get_value(wac_i2c->wac_pdata->gpio_pendct) && pressed) + forced_release(wac_i2c); + + input_report_key(wac_i2c->input_dev, + keycode[key], pressed); + input_sync(wac_i2c->input_dev); + +#if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP) + printk(KERN_DEBUG "[E-PEN] keycode:%d pressed:%d\n", + keycode[key], pressed); +#else + printk(KERN_DEBUG "[E-PEN] pressed:%d\n", + pressed); +#endif +} +#endif + int wacom_i2c_coord(struct wacom_i2c *wac_i2c) { bool prox = false; @@ -817,6 +844,9 @@ int wacom_i2c_coord(struct wacom_i2c *wac_i2c) u8 gain = 0; u8 height = 0; int aveStrength = 2; +#ifdef WACOM_USE_SOFTKEY + static s16 softkey, pressed, keycode; +#endif #ifdef WACOM_IRQ_WORK_AROUND cancel_delayed_work(&wac_i2c->pendct_dwork); @@ -854,6 +884,15 @@ int wacom_i2c_coord(struct wacom_i2c *wac_i2c) pr_debug("[E-PEN] is in(%d)\n", wac_i2c->tool); #endif } +#ifdef WACOM_USE_SOFTKEY + softkey = !!(data[5] & 0x80); + if (softkey) { + pressed = !!(data[5] & 0x40); + keycode = (data[5] & 0x30) >> 4; + wacom_i2c_softkey(wac_i2c, keycode, pressed); + return 0; + } +#endif prox = !!(data[0] & 0x10); stylus = !!(data[0] & 0x20); @@ -976,9 +1015,16 @@ int wacom_i2c_coord(struct wacom_i2c *wac_i2c) wac_i2c->side_pressed = stylus; } #if defined(CONFIG_SAMSUNG_KERNEL_DEBUG_USER) - else + else { printk(KERN_DEBUG "[E-PEN] raw data x=%d, y=%d\n", x, y); +#ifdef CONFIG_MACH_KONA + /* Pen should be released in the NOT AA area even if rdy value is 1. */ + if (wac_i2c->pen_pressed || wac_i2c->side_pressed + || wac_i2c->pen_prox) + forced_release(wac_i2c); +#endif + } #endif } else { diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig index aeedd90..cc7c047 100644 --- a/drivers/media/video/Kconfig +++ b/drivers/media/video/Kconfig @@ -652,6 +652,15 @@ config VIDEO_SLP_S5C73M3 ---help--- This driver supports s5c73m3 ISP camera module with MIPI CSI-2 as well +config VIDEO_SR130PC20 + tristate "SR130PC20 camera driver" + depends on I2C && VIDEO_V4L2 + ---help--- + This driver supports SR130PC20 SoC camera module. + The SR130PC20 camera module uses siliconfile camera sensor + supporting 1.3M capture with MIPI interface. And also, It support + VGA recording with 25fps. + config VIDEO_IMPROVE_STREAMOFF bool "Improve shtter lag" depends on VIDEO_FIMC_MIPI diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile index 64f0f5b..7ce4839 100644 --- a/drivers/media/video/Makefile +++ b/drivers/media/video/Makefile @@ -92,6 +92,7 @@ obj-$(CONFIG_VIDEO_M5MOLS) += m5mols/ obj-$(CONFIG_VIDEO_S5C73M3) += s5c73m3.o obj-$(CONFIG_VIDEO_ISX012) += isx012.o obj-$(CONFIG_VIDEO_S5C73M3_SPI) += s5c73m3_spi.o +obj-$(CONFIG_VIDEO_SR130PC20) += sr130pc20.o obj-$(CONFIG_VIDEO_SLP_S5C73M3) += slp_s5c73m3.o obj-$(CONFIG_VIDEO_SLP_S5K4ECGX) += slp_s5k4ecgx.o obj-$(CONFIG_VIDEO_SLP_DB8131M) += slp_db8131m.o diff --git a/drivers/media/video/isx012.c b/drivers/media/video/isx012.c index 427d59b..e33a430 100644 --- a/drivers/media/video/isx012.c +++ b/drivers/media/video/isx012.c @@ -28,6 +28,7 @@ #define isx012_wait_ae_stable_cap(sd) isx012_wait_ae_stable(sd, false, false) static int dbg_level; +static u32 VendorID; static const struct isx012_fps isx012_framerates[] = { { I_FPS_0, FRAME_RATE_AUTO }, @@ -42,6 +43,11 @@ static const struct isx012_framesize isx012_preview_frmsizes[] = { { PREVIEW_SZ_320x240, 320, 240 }, { PREVIEW_SZ_CIF, 352, 288 }, { PREVIEW_SZ_528x432, 528, 432 }, +#if defined(CONFIG_MACH_P4NOTELTE_KOR_SKT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_KT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_LGT) /*For 4G VT call in Domestic*/ + { PREVIEW_SZ_VERTICAL_VGA, 480, 640 }, +#endif { PREVIEW_SZ_VGA, 640, 480 }, { PREVIEW_SZ_D1, 720, 480 }, { PREVIEW_SZ_880x720, 880, 720 }, @@ -83,154 +89,167 @@ static struct isx012_control isx012_ctrls[] = { static const struct isx012_regs reg_datas = { .ev = { ISX012_REGSET(GET_EV_INDEX(EV_MINUS_4), - ISX012_ExpSetting_M4Step), + ISX012_ExpSetting_M4Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_MINUS_3), - ISX012_ExpSetting_M3Step), + ISX012_ExpSetting_M3Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_MINUS_2), - ISX012_ExpSetting_M2Step), + ISX012_ExpSetting_M2Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_MINUS_1), - ISX012_ExpSetting_M1Step), + ISX012_ExpSetting_M1Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_DEFAULT), - ISX012_ExpSetting_Default), + ISX012_ExpSetting_Default, 0), ISX012_REGSET(GET_EV_INDEX(EV_PLUS_1), - ISX012_ExpSetting_P1Step), + ISX012_ExpSetting_P1Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_PLUS_2), - ISX012_ExpSetting_P2Step), + ISX012_ExpSetting_P2Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_PLUS_3), - ISX012_ExpSetting_P3Step), + ISX012_ExpSetting_P3Step, 0), ISX012_REGSET(GET_EV_INDEX(EV_PLUS_4), - ISX012_ExpSetting_P4Step), + ISX012_ExpSetting_P4Step, 0), }, .metering = { - ISX012_REGSET(METERING_MATRIX, isx012_Metering_Matrix), - ISX012_REGSET(METERING_CENTER, isx012_Metering_Center), - ISX012_REGSET(METERING_SPOT, isx012_Metering_Spot), + ISX012_REGSET(METERING_MATRIX, isx012_Metering_Matrix, 0), + ISX012_REGSET(METERING_CENTER, isx012_Metering_Center, 0), + ISX012_REGSET(METERING_SPOT, isx012_Metering_Spot, 0), }, .iso = { - ISX012_REGSET(ISO_AUTO, isx012_ISO_Auto), - ISX012_REGSET(ISO_50, isx012_ISO_50), - ISX012_REGSET(ISO_100, isx012_ISO_100), - ISX012_REGSET(ISO_200, isx012_ISO_200), - ISX012_REGSET(ISO_400, isx012_ISO_400), + ISX012_REGSET(ISO_AUTO, isx012_ISO_Auto, 0), + ISX012_REGSET(ISO_50, isx012_ISO_50, 0), + ISX012_REGSET(ISO_100, isx012_ISO_100, 0), + ISX012_REGSET(ISO_200, isx012_ISO_200, 0), + ISX012_REGSET(ISO_400, isx012_ISO_400, 0), }, .effect = { - ISX012_REGSET(IMAGE_EFFECT_NONE, isx012_Effect_Normal), - ISX012_REGSET(IMAGE_EFFECT_BNW, isx012_Effect_Black_White), - ISX012_REGSET(IMAGE_EFFECT_SEPIA, isx012_Effect_Sepia), + ISX012_REGSET(IMAGE_EFFECT_NONE, isx012_Effect_Normal, 0), + ISX012_REGSET(IMAGE_EFFECT_BNW, isx012_Effect_Black_White, 0), + ISX012_REGSET(IMAGE_EFFECT_SEPIA, isx012_Effect_Sepia, 0), ISX012_REGSET(IMAGE_EFFECT_NEGATIVE, - ISX012_Effect_Negative), - ISX012_REGSET(IMAGE_EFFECT_SOLARIZE, isx012_Effect_Solar), - ISX012_REGSET(IMAGE_EFFECT_SKETCH, isx012_Effect_Sketch), - ISX012_REGSET(IMAGE_EFFECT_POINT_COLOR_3, isx012_Effect_Pastel), + ISX012_Effect_Negative, 0), + ISX012_REGSET(IMAGE_EFFECT_SOLARIZE, isx012_Effect_Solar, 0), + ISX012_REGSET(IMAGE_EFFECT_SKETCH, isx012_Effect_Sketch, 0), + ISX012_REGSET(IMAGE_EFFECT_POINT_COLOR_3, + isx012_Effect_Pastel, 0), }, .white_balance = { - ISX012_REGSET(WHITE_BALANCE_AUTO, isx012_WB_Auto), - ISX012_REGSET(WHITE_BALANCE_SUNNY, isx012_WB_Sunny), - ISX012_REGSET(WHITE_BALANCE_CLOUDY, isx012_WB_Cloudy), + ISX012_REGSET(WHITE_BALANCE_AUTO, isx012_WB_Auto, 0), + ISX012_REGSET(WHITE_BALANCE_SUNNY, isx012_WB_Sunny, 0), + ISX012_REGSET(WHITE_BALANCE_CLOUDY, isx012_WB_Cloudy, 0), ISX012_REGSET(WHITE_BALANCE_TUNGSTEN, - isx012_WB_Tungsten), + isx012_WB_Tungsten, 0), ISX012_REGSET(WHITE_BALANCE_FLUORESCENT, - isx012_WB_Fluorescent), + isx012_WB_Fluorescent, 0), }, .scene_mode = { - ISX012_REGSET(SCENE_MODE_NONE, isx012_Scene_Default), - ISX012_REGSET(SCENE_MODE_PORTRAIT, isx012_Scene_Portrait), - ISX012_REGSET(SCENE_MODE_NIGHTSHOT, isx012_Scene_Nightshot), - ISX012_REGSET(SCENE_MODE_BACK_LIGHT, isx012_Scene_Backlight), - ISX012_REGSET(SCENE_MODE_LANDSCAPE, isx012_Scene_Landscape), - ISX012_REGSET(SCENE_MODE_SPORTS, isx012_Scene_Sports), + ISX012_REGSET(SCENE_MODE_NONE, isx012_Scene_Default, 0), + ISX012_REGSET(SCENE_MODE_PORTRAIT, isx012_Scene_Portrait, 0), + ISX012_REGSET(SCENE_MODE_NIGHTSHOT, isx012_Scene_Nightshot, 0), + ISX012_REGSET(SCENE_MODE_BACK_LIGHT, isx012_Scene_Backlight, 0), + ISX012_REGSET(SCENE_MODE_LANDSCAPE, isx012_Scene_Landscape, 0), + ISX012_REGSET(SCENE_MODE_SPORTS, isx012_Scene_Sports, 0), ISX012_REGSET(SCENE_MODE_PARTY_INDOOR, - isx012_Scene_Party_Indoor), - ISX012_REGSET(SCENE_MODE_BEACH_SNOW, isx012_Scene_Beach_Snow), - ISX012_REGSET(SCENE_MODE_SUNSET, isx012_Scene_Sunset), - ISX012_REGSET(SCENE_MODE_DUSK_DAWN, isx012_Scene_Duskdawn), - ISX012_REGSET(SCENE_MODE_FALL_COLOR, isx012_Scene_Fall_Color), - ISX012_REGSET(SCENE_MODE_FIREWORKS, isx012_Scene_Fireworks), - ISX012_REGSET(SCENE_MODE_TEXT, isx012_Scene_Text), + isx012_Scene_Party_Indoor, 0), + ISX012_REGSET(SCENE_MODE_BEACH_SNOW, + isx012_Scene_Beach_Snow, 0), + ISX012_REGSET(SCENE_MODE_SUNSET, isx012_Scene_Sunset, 0), + ISX012_REGSET(SCENE_MODE_DUSK_DAWN, isx012_Scene_Duskdawn, 0), + ISX012_REGSET(SCENE_MODE_FALL_COLOR, + isx012_Scene_Fall_Color, 0), + ISX012_REGSET(SCENE_MODE_FIREWORKS, isx012_Scene_Fireworks, 0), + ISX012_REGSET(SCENE_MODE_TEXT, isx012_Scene_Text, 0), ISX012_REGSET(SCENE_MODE_CANDLE_LIGHT, - isx012_Scene_Candle_Light), + isx012_Scene_Candle_Light, 0), }, .saturation = { - ISX012_REGSET(SATURATION_MINUS_2, isx012_Saturation_Minus_2), - ISX012_REGSET(SATURATION_MINUS_1, isx012_Saturation_Minus_1), - ISX012_REGSET(SATURATION_DEFAULT, isx012_Saturation_Default), - ISX012_REGSET(SATURATION_PLUS_1, isx012_Saturation_Plus_1), - ISX012_REGSET(SATURATION_PLUS_2, isx012_Saturation_Plus_2), + ISX012_REGSET(SATURATION_MINUS_2, isx012_Saturation_Minus_2, 0), + ISX012_REGSET(SATURATION_MINUS_1, isx012_Saturation_Minus_1, 0), + ISX012_REGSET(SATURATION_DEFAULT, isx012_Saturation_Default, 0), + ISX012_REGSET(SATURATION_PLUS_1, isx012_Saturation_Plus_1, 0), + ISX012_REGSET(SATURATION_PLUS_2, isx012_Saturation_Plus_2, 0), }, .contrast = { - ISX012_REGSET(CONTRAST_MINUS_2, isx012_Contrast_Minus_2), - ISX012_REGSET(CONTRAST_MINUS_1, isx012_Contrast_Minus_1), - ISX012_REGSET(CONTRAST_DEFAULT, isx012_Contrast_Default), - ISX012_REGSET(CONTRAST_PLUS_1, isx012_Contrast_Plus_1), - ISX012_REGSET(CONTRAST_PLUS_2, isx012_Contrast_Plus_2), + ISX012_REGSET(CONTRAST_MINUS_2, isx012_Contrast_Minus_2, 0), + ISX012_REGSET(CONTRAST_MINUS_1, isx012_Contrast_Minus_1, 0), + ISX012_REGSET(CONTRAST_DEFAULT, isx012_Contrast_Default, 0), + ISX012_REGSET(CONTRAST_PLUS_1, isx012_Contrast_Plus_1, 0), + ISX012_REGSET(CONTRAST_PLUS_2, isx012_Contrast_Plus_2, 0), }, .sharpness = { - ISX012_REGSET(SHARPNESS_MINUS_2, isx012_Sharpness_Minus_2), - ISX012_REGSET(SHARPNESS_MINUS_1, isx012_Sharpness_Minus_1), - ISX012_REGSET(SHARPNESS_DEFAULT, isx012_Sharpness_Default), - ISX012_REGSET(SHARPNESS_PLUS_1, isx012_Sharpness_Plus_1), - ISX012_REGSET(SHARPNESS_PLUS_2, isx012_Sharpness_Plus_2), + ISX012_REGSET(SHARPNESS_MINUS_2, isx012_Sharpness_Minus_2, 0), + ISX012_REGSET(SHARPNESS_MINUS_1, isx012_Sharpness_Minus_1, 0), + ISX012_REGSET(SHARPNESS_DEFAULT, isx012_Sharpness_Default, 0), + ISX012_REGSET(SHARPNESS_PLUS_1, isx012_Sharpness_Plus_1, 0), + ISX012_REGSET(SHARPNESS_PLUS_2, isx012_Sharpness_Plus_2, 0), }, .fps = { - ISX012_REGSET(I_FPS_0, isx012_fps_auto), - ISX012_REGSET(I_FPS_7, isx012_fps_7fix), - ISX012_REGSET(I_FPS_15, isx012_fps_15fix), - ISX012_REGSET(I_FPS_25, isx012_fps_25fix), - ISX012_REGSET(I_FPS_30, isx012_fps_30fix), + ISX012_REGSET(I_FPS_0, isx012_fps_auto, 0), + ISX012_REGSET(I_FPS_7, isx012_fps_7fix, 0), + ISX012_REGSET(I_FPS_15, isx012_fps_15fix, 0), + ISX012_REGSET(I_FPS_25, isx012_fps_25fix, 0), + ISX012_REGSET(I_FPS_30, isx012_fps_30fix, 0), }, .preview_size = { - ISX012_REGSET(PREVIEW_SZ_320x240, isx012_320_Preview), - ISX012_REGSET(PREVIEW_SZ_VGA, isx012_640_Preview), - ISX012_REGSET(PREVIEW_SZ_D1, isx012_720_Preview), - ISX012_REGSET(PREVIEW_SZ_XGA, isx012_1024_768_Preview), - ISX012_REGSET(PREVIEW_SZ_PVGA, isx012_1280_Preview_E), + ISX012_REGSET(PREVIEW_SZ_320x240, isx012_320_Preview, 0), +#if defined(CONFIG_MACH_P4NOTELTE_KOR_SKT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_KT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_LGT) /*For 4G VT call in Domestic*/ + ISX012_REGSET(PREVIEW_SZ_VERTICAL_VGA, isx012_480_Preview, 0), +#endif + ISX012_REGSET(PREVIEW_SZ_VGA, isx012_640_Preview, 0), + ISX012_REGSET(PREVIEW_SZ_D1, isx012_720_Preview, 0), + ISX012_REGSET(PREVIEW_SZ_XGA, isx012_1024_768_Preview, 0), + ISX012_REGSET(PREVIEW_SZ_PVGA, isx012_1280_Preview_E, 0), }, .capture_size = { - ISX012_REGSET(CAPTURE_SZ_VGA, isx012_VGA_Capture), - ISX012_REGSET(CAPTURE_SZ_960_720, isx012_960_720_Capture), - ISX012_REGSET(CAPTURE_SZ_3MP, isx012_3M_Capture), - ISX012_REGSET(CAPTURE_SZ_5MP, isx012_5M_Capture), + ISX012_REGSET(CAPTURE_SZ_VGA, isx012_VGA_Capture, 0), + ISX012_REGSET(CAPTURE_SZ_960_720, isx012_960_720_Capture, 0), + ISX012_REGSET(CAPTURE_SZ_3MP, isx012_3M_Capture, 0), + ISX012_REGSET(CAPTURE_SZ_5MP, isx012_5M_Capture, 0), }, /* AF */ - .af_window_reset = ISX012_REGSET_TABLE(ISX012_AF_Window_Reset), - .af_winddow_set = ISX012_REGSET_TABLE(ISX012_AF_Window_Set), - .af_restart = ISX012_REGSET_TABLE(ISX012_AF_ReStart), - .af_saf_off = ISX012_REGSET_TABLE(ISX012_AF_SAF_OFF), - .af_touch_saf_off = ISX012_REGSET_TABLE(ISX012_AF_TouchSAF_OFF), - .cancel_af_macro = ISX012_REGSET_TABLE(ISX012_AF_Cancel_Macro_ON), - .cancel_af_normal = ISX012_REGSET_TABLE(ISX012_AF_Cancel_Macro_OFF), - .af_macro_mode = ISX012_REGSET_TABLE(ISX012_AF_Macro_ON), - .af_normal_mode = ISX012_REGSET_TABLE(ISX012_AF_Macro_OFF), - .af_camcorder_start = ISX012_REGSET_TABLE(ISX012_Camcorder_SAF_Start), + .af_window_reset = ISX012_REGSET_TABLE(ISX012_AF_Window_Reset, 1), + .af_winddow_set = ISX012_REGSET_TABLE(ISX012_AF_Window_Set, 0), + .af_restart = ISX012_REGSET_TABLE(ISX012_AF_ReStart, 0), + .af_saf_off = ISX012_REGSET_TABLE(ISX012_AF_SAF_OFF, 0), + .af_touch_saf_off = ISX012_REGSET_TABLE(ISX012_AF_TouchSAF_OFF, 0), + .cancel_af_macro = ISX012_REGSET_TABLE(ISX012_AF_Cancel_Macro_ON, 0), + .cancel_af_normal = ISX012_REGSET_TABLE(ISX012_AF_Cancel_Macro_OFF, 0), + .af_macro_mode = ISX012_REGSET_TABLE(ISX012_AF_Macro_ON, 0), + .af_normal_mode = ISX012_REGSET_TABLE(ISX012_AF_Macro_OFF, 0), + .af_camcorder_start = ISX012_REGSET_TABLE( + ISX012_Camcorder_SAF_Start, 0), /* Flash */ - .flash_ae_line = ISX012_REGSET_TABLE(ISX012_Flash_AELINE), - .flash_on = ISX012_REGSET_TABLE(ISX012_Flash_ON), - .flash_off = ISX012_REGSET_TABLE(ISX012_Flash_OFF), - .ae_manual = ISX012_REGSET_TABLE(ISX012_ae_manual_mode), - .flash_fast_ae_awb = ISX012_REGSET_TABLE(ISX012_flash_fast_ae_awb), + .flash_ae_line = ISX012_REGSET_TABLE(ISX012_Flash_AELINE, 0), + .flash_on = ISX012_REGSET_TABLE(ISX012_Flash_ON, 1), + .flash_off = ISX012_REGSET_TABLE(ISX012_Flash_OFF, 1), + .ae_manual = ISX012_REGSET_TABLE(ISX012_ae_manual_mode, 0), + .flash_fast_ae_awb = ISX012_REGSET_TABLE(ISX012_flash_fast_ae_awb, 0), - .init_reg = ISX012_REGSET_TABLE(ISX012_Init_Reg), + .init_reg = ISX012_REGSET_TABLE(ISX012_Init_Reg, 1), /* Camera mode */ - .preview_mode = ISX012_REGSET_TABLE(ISX012_Preview_Mode), - .capture_mode = ISX012_REGSET_TABLE(ISX012_Capture_Mode), + .preview_mode = ISX012_REGSET_TABLE(ISX012_Preview_Mode, 0), + .capture_mode = ISX012_REGSET_TABLE(ISX012_Capture_Mode, 0), .capture_mode_night = - ISX012_REGSET_TABLE(ISX012_Lowlux_Night_Capture_Mode), - .halfrelease_mode = ISX012_REGSET_TABLE(ISX012_Halfrelease_Mode), + ISX012_REGSET_TABLE(ISX012_Lowlux_Night_Capture_Mode, 0), + .halfrelease_mode = ISX012_REGSET_TABLE(ISX012_Halfrelease_Mode, 0), .halfrelease_mode_night = - ISX012_REGSET_TABLE(ISX012_Lowlux_night_Halfrelease_Mode), - .camcorder_on = ISX012_REGSET_TABLE(ISX012_Camcorder_Mode_ON), - .camcorder_off = ISX012_REGSET_TABLE(ISX012_Camcorder_Mode_OFF), - - .lowlux_night_reset = ISX012_REGSET_TABLE(ISX012_Lowlux_Night_Reset), - - .set_pll_4 = ISX012_REGSET_TABLE(ISX012_Pll_Setting_4), - .softlanding = ISX012_REGSET_TABLE(ISX012_Sensor_Off_VCM), + ISX012_REGSET_TABLE(ISX012_Lowlux_night_Halfrelease_Mode, 0), + .camcorder_on = ISX012_REGSET_TABLE(ISX012_Camcorder_Mode_ON, 1), + .camcorder_off = ISX012_REGSET_TABLE(ISX012_Camcorder_Mode_OFF, 1), + + .lowlux_night_reset = ISX012_REGSET_TABLE(ISX012_Lowlux_Night_Reset, 0), + + .set_pll_4 = ISX012_REGSET_TABLE(ISX012_Pll_Setting_4, 1), + .shading_0 = ISX012_REGSET_TABLE(ISX012_Shading_0, 1), + .shading_1 = ISX012_REGSET_TABLE(ISX012_Shading_1, 1), + .shading_2 = ISX012_REGSET_TABLE(ISX012_Shading_2, 1), + .shading_nocal = ISX012_REGSET_TABLE(ISX012_Shading_Nocal, 1), + .softlanding = ISX012_REGSET_TABLE(ISX012_Sensor_Off_VCM, 0), #if 0 /* def CONFIG_VIDEO_ISX012_P8*/ - .antibanding = ISX012_REGSET_TABLE(ISX012_ANTIBANDING_REG), + .antibanding = ISX012_REGSET_TABLE(ISX012_ANTIBANDING_REG, 0), #endif }; @@ -854,6 +873,8 @@ static int isx012_i2c_burst_write_list(struct v4l2_subdev *sd, struct i2c_msg msg = {isx012_client->addr, 0, 4, buf}; + cam_trace("%s\n", name); + if (!isx012_client->adapter) { printk(KERN_ERR "%s: %d can't search i2c client adapter\n", __func__, __LINE__); return -EIO; @@ -965,7 +986,12 @@ static int isx012_set_from_table(struct v4l2_subdev *sd, table->name); # endif /* DEBUG_WRITE_REGS */ - err = isx012_write_regs(sd, table->reg, table->array_size); + if (table->burst) { + err = isx012_i2c_burst_write_list(sd, + table->reg, table->array_size, setting_name); + } else + err = isx012_write_regs(sd, table->reg, table->array_size); + CHECK_ERR_MSG(err, "write regs(%s), err=%d\n", setting_name, err); return 0; @@ -2098,11 +2124,11 @@ static int isx012_do_af(struct v4l2_subdev *sd, u32 touch) break; af_dbg("AF state= %d(0x%X)\n", read_value, read_value); - msleep_debug(30, false); + msleep_debug(10, false); } if (unlikely(count >= AF_SEARCH_COUNT)) { - cam_warn("warning, AF check failed. val=0x%X\n\n", read_value); + cam_warn("warning, AF check timeout. val=0x%X\n\n", read_value); isx012_writeb(sd, REG_INTCLR, 0x10); goto check_fail; } @@ -2195,6 +2221,13 @@ static int isx012_set_af(struct v4l2_subdev *sd, s32 val) state->focus.start = val; if (val == AUTO_FOCUS_ON) { + if ((state->runmode != RUNMODE_RUNNING) && + (state->runmode != RUNMODE_RECORDING)) { + cam_err("error, AF can't start, not in preview\n"); + state->focus.start = AUTO_FOCUS_OFF; + return -ESRCH; + } + err = queue_work(state->workqueue, &state->af_work); if (likely(err)) state->focus.status = AF_RESULT_DOING; @@ -2604,6 +2637,10 @@ static int isx012_control_stream(struct v4l2_subdev *sd, u32 cmd) #if !defined(CONFIG_VIDEO_IMPROVE_STREAMOFF) state->capture.pre_req = 0; #endif + + if (state->focus.status == AF_RESULT_DOING) + isx012_set_af(sd, AUTO_FOCUS_OFF); + if (!((state->runmode == RUNMODE_RUNNING) && state->capture.pre_req)) { isx012_writeb(sd, 0x00BF, 0x01); @@ -3126,8 +3163,10 @@ static int isx012_s_mbus_fmt(struct v4l2_subdev *sd, isx012_set_framesize(sd, isx012_preview_frmsizes, ARRAY_SIZE(isx012_preview_frmsizes), true); - if (previous_index != state->preview.frmsize->index) + if ((state->preview.frmsize != NULL) && + (previous_index != state->preview.frmsize->index)) state->preview.update_frmsize = 1; + } else { /* * In case of image capture mode, @@ -3136,6 +3175,15 @@ static int isx012_s_mbus_fmt(struct v4l2_subdev *sd, isx012_set_framesize(sd, isx012_capture_frmsizes, ARRAY_SIZE(isx012_capture_frmsizes), false); + /* for maket app. + * Samsung camera app does not use unmatched ratio.*/ + if (unlikely(NULL == state->preview.frmsize)) { + cam_warn("warning, capture without preview resolution\n"); + } else if (unlikely(FRM_RATIO(state->preview.frmsize) + != FRM_RATIO(state->capture.frmsize))) { + cam_warn("warning, capture ratio " \ + "is different with preview ratio\n"); + } } return 0; @@ -3540,22 +3588,9 @@ static int isx012_s_stream(struct v4l2_subdev *sd, int enable) return 0; } -#if 0 /* DSLIM */ -static int isx012_reset(struct v4l2_subdev *sd, u32 val) -{ - struct isx012_state *state = to_state(sd); - - cam_trace("EX\n"); - - isx012_return_focus(sd); - state->initialized = 0; - - return 0; -} -#endif - void isx012_Sensor_Calibration(struct v4l2_subdev *sd) { + struct isx012_state *state = to_state(sd); int status = 0; int temp = 0; @@ -3573,11 +3608,14 @@ void isx012_Sensor_Calibration(struct v4l2_subdev *sd) /* Write Shading Table */ if (temp == 0x0) - ISX012_BURST_WRITE_LIST(ISX012_Shading_0); + isx012_set_from_table(sd, "Shading_0", + &state->regs->shading_0, 1, 0); else if (temp == 0x1) - ISX012_BURST_WRITE_LIST(ISX012_Shading_1); + isx012_set_from_table(sd, "Shading_1", + &state->regs->shading_1, 1, 0); else if (temp == 0x2) - ISX012_BURST_WRITE_LIST(ISX012_Shading_2); + isx012_set_from_table(sd, "Shading_2", + &state->regs->shading_2, 1, 0); /* Write NorR */ isx012_readw(sd, 0x0054, &status); @@ -3615,11 +3653,14 @@ void isx012_Sensor_Calibration(struct v4l2_subdev *sd) /* Write Shading Table */ if (temp == 0x0) - ISX012_BURST_WRITE_LIST(ISX012_Shading_0); + isx012_set_from_table(sd, "Shading_0", + &state->regs->shading_0, 1, 0); else if (temp == 0x1) - ISX012_BURST_WRITE_LIST(ISX012_Shading_1); + isx012_set_from_table(sd, "Shading_1", + &state->regs->shading_1, 1, 0); else if (temp == 0x2) - ISX012_BURST_WRITE_LIST(ISX012_Shading_2); + isx012_set_from_table(sd, "Shading_2", + &state->regs->shading_2, 1, 0); /* Write NorR */ isx012_readw(sd, 0x0045, &status); @@ -3645,7 +3686,8 @@ void isx012_Sensor_Calibration(struct v4l2_subdev *sd) boot_dbg("Cal: PreB read : %x\n", temp); isx012_writew(sd, 0x680A, temp); } else - ISX012_BURST_WRITE_LIST(ISX012_Shading_Nocal); + isx012_set_from_table(sd, "Shading_nocal", + &state->regs->shading_nocal, 1, 0); } } @@ -3658,10 +3700,46 @@ static inline int isx012_check_i2c(struct v4l2_subdev *sd, u16 data) if (unlikely(err)) return err; - cam_info("version: 0x%04X is 0x6017?\n", val); + cam_dbg("version: 0x%04X is 0x6017?\n", val); + return 0; +} + +static int isx012_check_vendorid(struct v4l2_subdev *sd) +{ + struct isx012_state *state = to_state(sd); + int status = 0; + int temp = 0; + int temp_msb = 0; + int temp_lsb = 0; + + /* Read OTP version */ + isx012_readw(sd, 0x004F, &status); + cam_dbg("OTP : 0x004F read 0x%04X\n", status); + if ((status & 0x10) == 0x10) { + isx012_readw(sd, 0x0051, &status); + temp = (status&0xFFFC); + cam_dbg("OTP1 : 0x0051 read : 0x%04X\n", temp); + } else { + isx012_readw(sd, 0x0042, &status); + temp = status&0xFFFC; + cam_dbg("OTP0 : 0x0042 read : 0x%04X\n", temp); + } + + temp_msb = (temp&0x03FC) << 6; + temp_lsb = (temp&0xFC00) >> 10; + VendorID = temp_msb | temp_lsb; + cam_info("Vendor ID: 0x%04X\n", VendorID); + return 0; } +u32 isx012_get_vendorid(void) +{ + cam_dbg("VendorID: 0x%04X\n", VendorID); + + return VendorID; +} + static int isx012_post_poweron(struct v4l2_subdev *sd) { struct isx012_state *state = to_state(sd); @@ -3675,7 +3753,14 @@ static int isx012_post_poweron(struct v4l2_subdev *sd) cam_err("%s: error, I2C check fail\n", __func__); return err; } - cam_info("I2C check success!\n"); + cam_dbg("I2C check success!\n"); + + err = isx012_check_vendorid(sd); + if (err) { + cam_err("%s: error, VendorID check fail\n", __func__); + return err; + } + cam_dbg("VendorID check success!\n"); msleep_debug(10, false); err = isx012_is_om_changed(sd); @@ -3953,8 +4038,8 @@ static int is_sysdev(struct device *dev, void *str) return !strcmp(dev_name(dev), (char *)str) ? 1 : 0; } -ssize_t cam_loglevel_show(struct device *dev, struct device_attribute *attr, - char *buf) +static ssize_t cam_loglevel_show(struct device *dev, + struct device_attribute *attr, char *buf) { char temp_buf[60] = {0,}; @@ -3980,8 +4065,9 @@ ssize_t cam_loglevel_show(struct device *dev, struct device_attribute *attr, return strlen(buf); } -ssize_t cam_loglevel_store(struct device *dev, struct device_attribute *attr, - const char *buf, size_t count) +static ssize_t cam_loglevel_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) { printk(KERN_DEBUG "CAM buf=%s, count=%d\n", buf, count); @@ -4056,6 +4142,6 @@ static void __exit v4l2_i2c_drv_cleanup(void) module_init(v4l2_i2c_drv_init); module_exit(v4l2_i2c_drv_cleanup); -MODULE_DESCRIPTION("LSI ISX012 3MP SOC camera driver"); +MODULE_DESCRIPTION("SONY ISX012 5MP SOC camera driver"); MODULE_AUTHOR("Dong-Seong Lim <dongseong.lim@samsung.com>"); MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/isx012.h b/drivers/media/video/isx012.h index 5e65195..e427cc2 100644 --- a/drivers/media/video/isx012.h +++ b/drivers/media/video/isx012.h @@ -38,9 +38,9 @@ /* #define CONFIG_DEBUG_NO_FRAME */ /** Debuging Feature **/ -/* #define CONFIG_CAM_DEBUG */ -/* #define CONFIG_CAM_TRACE */ /* Enable it with CONFIG_CAM_DEBUG */ -/* #define CONFIG_CAM_AF_DEBUG *//* Enable it with CONFIG_CAM_DEBUG */ +#define CONFIG_CAM_DEBUG +#define CONFIG_CAM_TRACE /* Enable it with CONFIG_CAM_DEBUG */ +#define CONFIG_CAM_AF_DEBUG //* Enable it with CONFIG_CAM_DEBUG */ /* #define DEBUG_WRITE_REGS */ /***********************************/ @@ -193,6 +193,11 @@ enum isx012_preview_frame_size { PREVIEW_SZ_320x240, /* 320x240 */ PREVIEW_SZ_CIF, /* 352x288 */ PREVIEW_SZ_528x432, /* 528x432 */ +#if defined(CONFIG_MACH_P4NOTELTE_KOR_SKT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_KT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_LGT) /*For 4G VT call in Domestic*/ + PREVIEW_SZ_VERTICAL_VGA, /* 480x640 */ +#endif PREVIEW_SZ_VGA, /* 640x480 */ PREVIEW_SZ_D1, /* 720x480 */ PREVIEW_SZ_880x720, /* 880x720 */ @@ -458,12 +463,12 @@ struct regset_table { const char *const name; }; -#define ISX012_REGSET(x, y) \ +#define ISX012_REGSET(x, y, z) \ [(x)] = { \ .name = #y, \ } -#define ISX012_REGSET_TABLE(y) \ +#define ISX012_REGSET_TABLE(y, z) \ { \ .name = #y, \ } @@ -476,31 +481,36 @@ struct regset_table { #ifdef DEBUG_WRITE_REGS const char * const name; #endif + const u32 burst; /* on/off */ }; #ifdef DEBUG_WRITE_REGS -#define ISX012_REGSET(x, y) \ +#define ISX012_REGSET(x, y, z) \ [(x)] = { \ .reg = (y), \ .array_size = ARRAY_SIZE((y)), \ .name = #y, \ + .burst = z, \ } -#define ISX012_REGSET_TABLE(y) \ +#define ISX012_REGSET_TABLE(y, z) \ { \ .reg = (y), \ .array_size = ARRAY_SIZE((y)), \ .name = #y, \ + .burst = z, \ } #else /* !DEBUG_WRITE_REGS */ -#define ISX012_REGSET(x, y) \ +#define ISX012_REGSET(x, y, z) \ [(x)] = { \ .reg = (y), \ .array_size = ARRAY_SIZE((y)), \ + .burst = z, \ } -#define ISX012_REGSET_TABLE(y) \ +#define ISX012_REGSET_TABLE(y, z) \ { \ .reg = (y), \ .array_size = ARRAY_SIZE((y)), \ + .burst = z, \ } #endif /* DEBUG_WRITE_REGS */ @@ -558,6 +568,11 @@ struct isx012_regs { struct regset_table init_reg; struct regset_table set_pll_4; + struct regset_table shading_0; + struct regset_table shading_1; + struct regset_table shading_2; + struct regset_table shading_nocal; + #ifdef CONFIG_VIDEO_ISX012_P8 struct regset_table antibanding; #endif /* CONFIG_VIDEO_ISX012_P8 */ @@ -658,7 +673,7 @@ extern int isx012_create_file(struct class *cls); #define ISX012_CNT_CM_CHECK 280 /* 160 -> 180 */ #define ISX012_CNT_STREAMOFF 300 -#define AF_SEARCH_COUNT 200 +#define AF_SEARCH_COUNT 550 /* about 6s */ #define AE_STABLE_SEARCH_COUNT 7 /* Sensor AF first,second window size. @@ -736,6 +751,10 @@ extern int isx012_create_file(struct class *cls); #define TUNING_FILE_PATH "/mnt/sdcard/isx012_regs.h" #endif /* CONFIG_LOAD_FILE*/ +#ifdef CONFIG_MACH_KONA +#include "isx012_regs_kona.h" +#else /* P4NOTE */ #include "isx012_regs.h" +#endif #endif /* __ISX012_H__ */ diff --git a/drivers/media/video/isx012_regs.h b/drivers/media/video/isx012_regs.h index fa8de0c..0bb1a28 100644 --- a/drivers/media/video/isx012_regs.h +++ b/drivers/media/video/isx012_regs.h @@ -28,7 +28,7 @@ /* change 4129 to 4802 */ #define AE_SCL_SUBRACT_VALUE 4802 -const uint16_t aeoffset_table[] = { // normal 4.6times +static const uint16_t aeoffset_table[] = { /* normal 4.6times */ 0, 35, 70, 103, 136, 167, 198, 228, 257, 285, 313, 339, 366, 391, 416, 441, 465, 488, 511, 533, 555, 576, 597, 618, 638, 657, 677, 696, 714, 732, @@ -4760,7 +4760,6 @@ static const isx012_regset_t isx012_720_Preview[] = { {0x0090,0x02D0,0x02}, //HSIZE_MONI : 720 {0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 - }; static const isx012_regset_t isx012_640_Preview[] = @@ -4769,6 +4768,15 @@ static const isx012_regset_t isx012_640_Preview[] = {0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 }; +#if defined(CONFIG_MACH_P4NOTELTE_KOR_SKT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_KT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_LGT) /*For 4G VT call in Domestic*/ +static const isx012_regset_t isx012_480_Preview[] = { +{0x0090, 0x01E0, 0x02}, /* HSIZE_MONI : 480 */ +{0x0096, 0x0280, 0x02}, /* VSIZE_MONI : 640 */ +}; +#endif + static const isx012_regset_t isx012_320_Preview[] = { {0x0090,0x0140,0x02}, //HSIZE_MONI : 320 @@ -11223,7 +11231,7 @@ static const isx012_regset_t ISX012_ae_manual_mode[] = static const isx012_regset_t ISX012_flash_fast_ae_awb[] = { {0x5E32,0x0A,0x01}, -{0x5E3D,0x05,0x01}, +{0x5E3D,0x05,0x01}, /* Don't fix me. 0x05 */ {0x0181,0x01,0x01}, // CAP_HALF_AE_CTRL {0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF diff --git a/drivers/media/video/isx012_regs_kona.h b/drivers/media/video/isx012_regs_kona.h new file mode 100644 index 0000000..9d9496b --- /dev/null +++ b/drivers/media/video/isx012_regs_kona.h @@ -0,0 +1,11284 @@ +/* drivers/media/video/s5k5ccgx_regs-p4w.h + * + * Driver for s5k5ccgx (5MP Camera) from SEC(LSI), firmware EVT1.1 + * + * Copyright (C) 2010, SAMSUNG ELECTRONICS + * + * 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. + * + * Change Date: 2012.06.28 + */ + +#ifndef __ISX012_REGS_H__ +#define __ISX012_REGS_H__ + +#define AE_OFSETVAL 3450 //for tuning // max 5.1times +#define AE_MAXDIFF 4000 //for tuning // max =< 5000 +#define GLOWLIGHT_DEFAULT 0x002B //for tuning +#define GLOWLIGHT_ISO50 0xB52A //for tuning +#define GLOWLIGHT_ISO100 0x9DBA //for tuning +#define GLOWLIGHT_ISO200 0x864A //for tuning +#define GLOWLIGHT_ISO400 0x738A //for tuning + +#define ESD_VALUE 0xA6A6 + +/* change 4129 to 4802 */ +#define AE_SCL_SUBRACT_VALUE 4802 + +static const uint16_t aeoffset_table[] = { /* normal 4.6times */ + 0, 35, 70, 103, 136, 167, 198, 228, 257, 285, + 313, 339, 366, 391, 416, 441, 465, 488, 511, 533, + 555, 576, 597, 618, 638, 657, 677, 696, 714, 732, + 750, 768, 785, 802, 818, 835, 851, 866, 882, 897, + 912, 927, 941, 955, 969, 983, 997, 1010, 1023, 1036, + 1049, 1061, 1074, 1086, 1098, 1109, 1121, 1133, 1144, 1155, + 1166, 1177, 1187, 1198, 1208, 1219, 1229, 1239, 1248, 1258, + 1268, 1277, 1286, 1296, 1305, 1314, 1322, 1331, 1340, 1348, + 1357, 1365, 1373, 1381, 1389, 1397, 1405, 1413, 1420, 1428, + 1435, 1443, 1450, 1457, 1464, 1471, 1478, 1485, 1492, 1499, + 1505, 1512, 1518, 1525, 1531, 1538, 1544, 1550, 1556, 1562, + 1568, 1574, 1580, 1585, 1591, 1597, 1602, 1608, 1613, 1619, + 1624, 1629, 1635, 1640, 1645, 1650, 1655, 1660, 1665, 1670, + 1675, 1679, 1684, 1689, 1693, 1698, 1703, 1707, 1712, 1716, + 1720, 1725, 1729, 1733, 1737, 1742, 1746, 1750, 1754, 1758, + 1762, 1766, 1770, 1774, 1777, 1781, 1785, 1789, 1792, 1796, + 1800, 1803, 1807, 1810, 1814, 1817, 1821, 1824, 1828, 1831, + 1834, 1837, 1841, 1844, 1847, 1850, 1853, 1856, 1860, 1863, + 1866, 1869, 1872, 1875, 1877, 1880, 1883, 1886, 1889, 1892, + 1894, 1897, 1900, 1903, 1905, 1908, 1911, 1913, 1916, 1918, + 1921, 1923, 1926, 1928, 1931, 1933, 1936, 1938, 1941, 1943, + 1945, 1948, 1950, 1952, 1954, 1957, 1959, 1961, 1963, 1965, + 1968, 1970, 1972, 1974, 1976, 1978, 1980, 1982, 1984, 1986, + 1988, 1990, 1992, 1994, 1996, 1998, 2000, 2002, 2003, 2005, + 2007, 2009, 2011, 2013, 2014, 2016, 2018, 2020, 2021, 2023, + 2025, 2026, 2028, 2030, 2031, 2033, 2034, 2036, 2038, 2039, + 2041, 2042, 2044, 2045, 2047, 2048, 2050, 2051, 2053, 2054, + 2056, 2057, 2059, 2060, 2061, 2063, 2064, 2066, 2067, 2068, + 2070, 2071, 2072, 2074, 2075, 2076, 2077, 2079, 2080, 2081, + 2082, 2084, 2085, 2086, 2087, 2089, 2090, 2091, 2092, 2093, + 2094, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, + 2105, 2106, 2107, 2109, 2110, 2111, 2112, 2113, 2114, 2115, + 2116, 2117, 2118, 2119, 2120, 2120, 2121, 2122, 2123, 2124, + 2125, 2126, 2127, 2128, 2129, 2130, 2130, 2131, 2132, 2133, + 2134, 2135, 2136, 2136, 2137, 2138, 2139, 2140, 2141, 2141, + 2142, 2143, 2144, 2144, 2145, 2146, 2147, 2148, 2148, 2149, + 2150, 2150, 2151, 2152, 2153, 2153, 2154, 2155, 2155, 2156, + 2157, 2158, 2158, 2159, 2160, 2160, 2161, 2162, 2162, 2163, + 2163, 2164, 2165, 2165, 2166, 2167, 2167, 2168, 2168, 2169, + 2170, 2170, 2171, 2171, 2172, 2172, 2173, 2174, 2174, 2175, + 2175, 2176, 2176, 2177, 2177, 2178, 2179, 2179, 2180, 2180, + 2181, 2181, 2182, 2182, 2183, 2183, 2184, 2184, 2185, 2185, + 2186, 2186, 2186, 2187, 2187, 2188, 2188, 2189, 2189, 2190, + 2190, 2191, 2191, 2191, 2192, 2192, 2193, 2193, 2194, 2194, + 2194, 2195, 2195, 2196, 2196, 2196, 2197, 2197, 2198, 2198, + 2198, 2199, 2199, 2200, 2200, 2200, 2201, 2201, 2201, 2202, + 2202, 2203, 2203, 2203, 2204, 2204, 2204, 2205, 2205, 2205, + 2206, 2206, 2206, 2207, 2207, 2207, 2208, 2208, 2208, 2209, + 2209, 2209, 2210, 2210, 2210, 2210, 2211, 2211, 2211, 2212, + 2212, 2212, 2213, 2213, 2213, 2213, 2214, 2214, 2214, 2214, +}; + +static const isx012_regset_t ISX012_Init_Reg[] = +{ +///////////////////////////////////// +//AF driver setting//³»ºÎ AF driver// +///////////////////////////////////// +{0x66C2,0x0C,0x01},//AF_INTERNAL_LENSDRV_ADRS +{0x66C3,0x02,0x01},//AF_INTERNAL_LENSDRV_SIZE +{0x66C5,0x14,0x01},//AF_INTERNAL_LENSDRV_SHIFT +{0x66C8,0x0000,0x02},//AF_INTERNAL_LENSDRV_FIXEDPTN +{0x66CA,0x000F,0x02}, +{0x000B,0x01,0x01},//AF_EXT : AF driver start + +////////////////////////////////////////// +// ISX012_Initial_Setting.ini // +////////////////////////////////////////// +// AE window add V02 +{0x6000,0x06,0x01}, // CENTER_FIXWEIGHT_00_TYPE1 : +{0x6001,0x06,0x01}, // CENTER_FIXWEIGHT_01_TYPE1 : +{0x6002,0x06,0x01}, // CENTER_FIXWEIGHT_02_TYPE1 : +{0x6003,0x06,0x01}, // CENTER_FIXWEIGHT_03_TYPE1 : +{0x6004,0x06,0x01}, // CENTER_FIXWEIGHT_04_TYPE1 : +{0x6005,0x06,0x01}, // CENTER_FIXWEIGHT_05_TYPE1 : +{0x6006,0x06,0x01}, // CENTER_FIXWEIGHT_06_TYPE1 : +{0x6007,0x06,0x01}, // CENTER_FIXWEIGHT_07_TYPE1 : +{0x6008,0x06,0x01}, // CENTER_FIXWEIGHT_08_TYPE1 : +{0x6009,0x0C,0x01}, // CENTER_FIXWEIGHT_09_TYPE1 : +{0x600A,0x0C,0x01}, // CENTER_FIXWEIGHT_10_TYPE1 : +{0x600B,0x0C,0x01}, // CENTER_FIXWEIGHT_11_TYPE1 : +{0x600C,0x10,0x01}, // CENTER_FIXWEIGHT_12_TYPE1 : +{0x600D,0x10,0x01}, // CENTER_FIXWEIGHT_13_TYPE1 : +{0x600E,0x10,0x01}, // CENTER_FIXWEIGHT_14_TYPE1 : +{0x600F,0x0C,0x01}, // CENTER_FIXWEIGHT_15_TYPE1 : +{0x6010,0x0C,0x01}, // CENTER_FIXWEIGHT_16_TYPE1 : +{0x6011,0x0C,0x01}, // CENTER_FIXWEIGHT_17_TYPE1 : +{0x6012,0x0C,0x01}, // CENTER_FIXWEIGHT_18_TYPE1 : +{0x6013,0x0C,0x01}, // CENTER_FIXWEIGHT_19_TYPE1 : +{0x6014,0x18,0x01}, // CENTER_FIXWEIGHT_20_TYPE1 : +{0x6015,0x18,0x01}, // CENTER_FIXWEIGHT_21_TYPE1 : +{0x6016,0x18,0x01}, // CENTER_FIXWEIGHT_22_TYPE1 : +{0x6017,0x18,0x01}, // CENTER_FIXWEIGHT_23_TYPE1 : +{0x6018,0x18,0x01}, // CENTER_FIXWEIGHT_24_TYPE1 : +{0x6019,0x0C,0x01}, // CENTER_FIXWEIGHT_25_TYPE1 : +{0x601A,0x0C,0x01}, // CENTER_FIXWEIGHT_26_TYPE1 : +{0x601B,0x0C,0x01}, // CENTER_FIXWEIGHT_27_TYPE1 : +{0x601C,0x18,0x01}, // CENTER_FIXWEIGHT_28_TYPE1 : +{0x601D,0x18,0x01}, // CENTER_FIXWEIGHT_29_TYPE1 : +{0x601E,0x1E,0x01}, // CENTER_FIXWEIGHT_30_TYPE1 : +{0x601F,0x1E,0x01}, // CENTER_FIXWEIGHT_31_TYPE1 : +{0x6020,0x1E,0x01}, // CENTER_FIXWEIGHT_32_TYPE1 : +{0x6021,0x18,0x01}, // CENTER_FIXWEIGHT_33_TYPE1 : +{0x6022,0x18,0x01}, // CENTER_FIXWEIGHT_34_TYPE1 : +{0x6023,0x0C,0x01}, // CENTER_FIXWEIGHT_35_TYPE1 : +{0x6024,0x0C,0x01}, // CENTER_FIXWEIGHT_36_TYPE1 : +{0x6025,0x18,0x01}, // CENTER_FIXWEIGHT_37_TYPE1 : +{0x6026,0x18,0x01}, // CENTER_FIXWEIGHT_38_TYPE1 : +{0x6027,0x1E,0x01}, // CENTER_FIXWEIGHT_39_TYPE1 : +{0x6028,0x1E,0x01}, // CENTER_FIXWEIGHT_40_TYPE1 : +{0x6029,0x1E,0x01}, // CENTER_FIXWEIGHT_41_TYPE1 : +{0x602A,0x18,0x01}, // CENTER_FIXWEIGHT_42_TYPE1 : +{0x602B,0x18,0x01}, // CENTER_FIXWEIGHT_43_TYPE1 : +{0x602C,0x0C,0x01}, // CENTER_FIXWEIGHT_44_TYPE1 : +{0x602D,0x0C,0x01}, // CENTER_FIXWEIGHT_45_TYPE1 : +{0x602E,0x0C,0x01}, // CENTER_FIXWEIGHT_46_TYPE1 : +{0x602F,0x18,0x01}, // CENTER_FIXWEIGHT_47_TYPE1 : +{0x6030,0x18,0x01}, // CENTER_FIXWEIGHT_48_TYPE1 : +{0x6031,0x18,0x01}, // CENTER_FIXWEIGHT_49_TYPE1 : +{0x6032,0x18,0x01}, // CENTER_FIXWEIGHT_50_TYPE1 : +{0x6033,0x18,0x01}, // CENTER_FIXWEIGHT_51_TYPE1 : +{0x6034,0x0C,0x01}, // CENTER_FIXWEIGHT_52_TYPE1 : +{0x6035,0x0C,0x01}, // CENTER_FIXWEIGHT_53_TYPE1 : +{0x6036,0x0C,0x01}, // CENTER_FIXWEIGHT_54_TYPE1 : +{0x6037,0x0C,0x01}, // CENTER_FIXWEIGHT_55_TYPE1 : +{0x6038,0x0C,0x01}, // CENTER_FIXWEIGHT_56_TYPE1 : +{0x6039,0x0C,0x01}, // CENTER_FIXWEIGHT_57_TYPE1 : +{0x603A,0x0C,0x01}, // CENTER_FIXWEIGHT_58_TYPE1 : +{0x603B,0x0C,0x01}, // CENTER_FIXWEIGHT_59_TYPE1 : +{0x603C,0x0C,0x01}, // CENTER_FIXWEIGHT_60_TYPE1 : +{0x603D,0x0C,0x01}, // CENTER_FIXWEIGHT_61_TYPE1 : +{0x603E,0x0C,0x01}, // CENTER_FIXWEIGHT_62_TYPE1 : + + +//AF filter +{0x6D14,0x0001,0x02}, // HPF_HBPF_CORSL_Y1 : +{0x6D16,0x0001,0x02}, // HPF_HBPF_CORSL_Y2 : +{0x6D18,0x0002,0x02}, // HPF_HBPF_CORSL_Y3 : +{0x6D1A,0x0005,0x02}, // HPF_HBPF_CORSL_Y4 : + +{0x6D20,0x0004,0x02}, // HPF_HBPF_CORL_Y1 : +{0x6D22,0x0004,0x02}, // HPF_HBPF_CORL_Y2 : +{0x6D24,0x000F,0x02}, // HPF_HBPF_CORL_Y3 : +{0x6D26,0x001E,0x02}, // HPF_HBPF_CORL_Y4 : + +{0x6D2C,0x000E,0x02}, // HPF_HBPF_CORH_Y1 : +{0x6D2E,0x000F,0x02}, // HPF_HBPF_CORH_Y2 : +{0x6D30,0x0022,0x02}, // HPF_HBPF_CORH_Y3 : +{0x6D32,0x004D,0x02}, // HPF_HBPF_CORH_Y4 : + +{0x6D44,0x0001,0x02}, // HPF_LBPF_CORSL_Y1 : +{0x6D46,0x0001,0x02}, // HPF_LBPF_CORSL_Y2 : +{0x6D48,0x0002,0x02}, // HPF_LBPF_CORSL_Y3 : +{0x6D4A,0x0004,0x02}, // HPF_LBPF_CORSL_Y4 : + +{0x6D50,0x03FF,0x02}, // HPF_LBPF_CORL_Y1 : +{0x6D52,0x03FF,0x02}, // HPF_LBPF_CORL_Y2 : +{0x6D54,0x03FF,0x02}, // HPF_LBPF_CORL_Y3 : +{0x6D56,0x03FF,0x02}, // HPF_LBPF_CORL_Y4 : + +{0x6D5C,0x03FF,0x02}, // HPF_LBPF_CORH_Y1 : +{0x6D5E,0x03FF,0x02}, // HPF_LBPF_CORH_Y2 : +{0x6D60,0x03FF,0x02}, // HPF_LBPF_CORH_Y3 : +{0x6D62,0x03FF,0x02}, // HPF_LBPF_CORH_Y4 : + +{0x6D74,0x0001,0x02}, // HPF_VHBPF_CORSL_Y1 : +{0x6D76,0x0001,0x02}, // HPF_VHBPF_CORSL_Y2 : +{0x6D78,0x0002,0x02}, // HPF_VHBPF_CORSL_Y3 : +{0x6D7A,0x0005,0x02}, // HPF_VHBPF_CORSL_Y4 : + +{0x6D80,0x0004,0x02}, // HPF_VHBPF_CORL_Y1 : +{0x6D82,0x0005,0x02}, // HPF_VHBPF_CORL_Y2 : +{0x6D84,0x000C,0x02}, // HPF_VHBPF_CORL_Y3 : +{0x6D86,0x001C,0x02}, // HPF_VHBPF_CORL_Y4 : + +{0x6D8C,0x000D,0x02}, // HPF_VHBPF_CORH_Y1 : +{0x6D8E,0x0010,0x02}, // HPF_VHBPF_CORH_Y2 : +{0x6D90,0x0026,0x02}, // HPF_VHBPF_CORH_Y3 : +{0x6D92,0x004D,0x02}, // HPF_VHBPF_CORH_Y4 : + +// CAF Ãß°¡ºÎºÐ +{0x6622,0x0004,0x02}, // AF_CAF_PARAM_WOBBLE_STEP : +{0x6624,0x0008,0x02}, // AF_CAF_CLIMB_STEP : +{0x6687,0x01,0x01}, // AF_CAF_CLIMB_PEAK_BACK_STEP_ENABLE : +{0x6698,0x00,0x01}, // AF_CAF_WOBBLE_FILTER_ENABLE : +{0x66A4,0x06,0x01}, // AF_CAF_OPD_FLAT_MOVE_ENABLE : +{0x66B0,0x0002,0x02}, // AF_CAF_WAIT_FOR_AF_STABLE_TH : +{0x5003,0x04,0x01}, // Z1_HOLD = 1 +//110819 +{0x6696,0x16,0x01}, //AF_CAF_WOBBLE_START_INTERVAL_COUNTER +{0x6716,0x0000,0x02}, // CAF_LVD_WOB_HBPF_VAL1 : +{0x6718,0x0000,0x02}, // CAF_LVD_WOB_HBPF_VAL2 : +{0x671A,0x00C8,0x02}, // CAF_LVD_WOB_HBPF_RATE1 : +{0x671C,0x00C8,0x02}, // CAF_LVD_WOB_HBPF_RATE2 : +{0x671E,0x00,0x01}, // CAF_LVD_WOB_HBPF_SHIFT : +{0x6720,0x0000,0x02}, // CAF_LVD_WOB_LBPF_VAL1 : +{0x6722,0x0000,0x02}, // CAF_LVD_WOB_LBPF_VAL2 : +{0x6724,0x0014,0x02}, // CAF_LVD_WOB_LBPF_RATE1 : +{0x6726,0x0014,0x02}, // CAF_LVD_WOB_LBPF_RATE2 : +{0x6728,0x00,0x01}, // CAF_LVD_WOB_LBPF_SHIFT : +{0x672A,0x0000,0x02}, // CAF_LVD_CLMP_HBPF_VAL1 : +{0x672C,0x0000,0x02}, // CAF_LVD_CLMP_HBPF_VAL2 : +{0x672E,0x012C,0x02}, // CAF_LVD_CLMP_HBPF_RATE1 : +{0x6730,0x012C,0x02}, // CAF_LVD_CLMP_HBPF_RATE2 : +{0x6732,0x00,0x01}, // CAF_LVD_CLMP_HBPF_SHIFT : +{0x6734,0x0000,0x02}, // CAF_LVD_CLMP_LBPF_VAL1 : +{0x6736,0x0000,0x02}, // CAF_LVD_CLMP_LBPF_VAL2 : +{0x6738,0x0046,0x02}, // CAF_LVD_CLMP_LBPF_RATE1 : +{0x673A,0x0046,0x02}, // CAF_LVD_CLMP_LBPF_RATE2 : +{0x673C,0x00,0x01}, // CAF_LVD_CLMP_LBPF_SHIFT : +{0x661E,0x00C8,0x02}, //AF_CAF_FAR_POSITION +{0x6620,0x02BC,0x02}, //AF_CAF_NEAR_POSITION + +//Ãß°¡¼ÂÆúκРSAFºÎºÐ +{0x00B2,0x02,0x01}, // AFMODE_MONI : manual AF mode +{0x028E,0x00,0x01}, // AF_SN1_2 : +{0x028F,0x00,0x01}, // AF_SN3_4 : +{0x0290,0x00,0x01}, // AF_SN5_6 : +{0x0291,0x00,0x01}, // AF_SN7_8 : +{0x0292,0x00,0x01}, // AF_SN9_10 : +{0x0293,0x00,0x01}, // AF_SN11_12 : +{0x6604,0x00,0x01}, // AF_SEARCH_DIR : +{0x6616,0x01,0x01}, // AF_DIRECTBACK_F :On=1 +{0x661B,0x03,0x01}, // AF_OPDDATA_SAVE : +{0x661C,0x00,0x01}, // AF_MONOTONY_POS : +{0x663E,0x00,0x01}, // AF_SEARCH_SECOND_DIR : +{0x663F,0x01,0x01}, // AF_DIRECTBACK_SECOND_F : +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F : AF off½Ã zero positionÀ¸·Î °¥Áö(01) ÇöÀ§Ä¡¿¡ ÀÖÀ»Áö(00) Á¤ÇÔ +{0x6675,0x01,0x01}, // CAP_AF_CANCEL_F : 1·Î ¼³Á¤½Ã capture¸ðµå¿¡¼ AFÀÚµ¿ ĵ½½ +{0x6676,0x02,0x01}, // AF_SAxF_MODE : +{0x669E,0x02,0x01}, // AF_SECOND_WND_CHK : +{0x6600,0x00C8,0x02}, // AF_SEARCH_AREA_LOW : +{0x6602,0x02BC,0x02}, // AF_SEARCH_AREA_HIGH : +{0x6640,0x02,0x01}, // AF_DROPN_ON_PEAK_DETECT_SECOND : +{0x6641,0x02,0x01}, // AF_UPN_ON_PEAK_DETECT_SECOND : +{0x6642,0x02,0x01}, //AF_DROPRATE_ON_DETECT_SECOND_HBPF +{0x6643,0x02,0x01}, //AF_DROPRATE_ON_DETECT_SECOND_LBPF +{0x6644,0x14,0x01}, // AF_UPRATE_ON_PEAK_DETECT_HBPF_SECOND : +{0x6646,0x08,0x01}, // AF_OPD_WEIGHT_TH : +{0x664A,0x04,0x01}, // AF_DROPN_ON_PEAK_DETECT : +{0x664B,0x02,0x01}, // AF_UPN_ON_PEAK_DETECT : +{0x664C,0xFF,0x01}, // AF_UPRATE_ON_PEAK_DETECT_HBPF : +{0x665A,0x00C8,0x02}, // AF_LENSPOS_ON_AFNG : +{0x665C,0x0018,0x02}, // AF_DRV_AMOUNT_TONEAR_F : +{0x665E,0x0003,0x02}, // AF_DRV_AMOUNT_TONEAR_S : +{0x6660,0x0018,0x02}, // AF_DRV_AMOUNT_TOFAR_F : +{0x6662,0x0003,0x02}, // AF_DRV_AMOUNT_TOFAR_S : +{0x6666,0x00C8,0x02}, // AF_AREA_LOW_TYPE1 : +{0x6668,0x02BC,0x02}, // AF_AREA_HIGH_TYPE1 : +{0x669A,0x01F4,0x02}, // AF_OPD_MONOTONYUP_HBPF_TH : +{0x66E4,0x50,0x01}, // AF_TH_1STDEPEND_HBPF_RATE : +{0x66EE,0x03E8,0x02}, // AF_LVD_HBPF_VAL1_1ST : +{0x66F0,0x4E20,0x02}, // AF_LVD_HBPF_VAL2_1ST : +{0x66F2,0x004C,0x02}, // AF_LVD_HBPF_RATE1_1ST : +{0x66F4,0x0019,0x02}, // AF_LVD_HBPF_RATE2_1ST : +{0x66F6,0x00,0x01}, // AF_LVD_HBPF_SHIFT_1ST : +{0x6702,0x03E8,0x02}, // AF_LVD_HBPF_VAL1_2ND : +{0x6704,0x4E20,0x02}, // AF_LVD_HBPF_VAL2_2ND : +{0x6706,0x0003,0x02}, // AF_LVD_HBPF_RATE1_2ND : +{0x6708,0x0003,0x02}, // AF_LVD_HBPF_RATE2_2ND : +{0x670A,0x00,0x01}, // AF_LVD_HBPF_SHIFT_2ND : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +//chooys add +{0x6677,0x00,0x01}, // AF_SEND_PARTITION : Use=1 +{0x6678,0x20,0x01}, // AF_SENDNUM_ALL +{0x6679,0x01,0x01}, // AF_SENDNUM_UP +{0x667A,0x01,0x01}, // AF_SENDNUM_DOWN +{0x667C,0x0002,0x02}, // AF_SENDAMOUNT_ADDLIMIT +{0x667E,0x0020,0x02}, //AF_SENDLINE + +// AF opd_TH +{0x660E,0x5A,0x01}, // AF_HBPF_PEAK_OPD_TH_MIN +{0x6610,0x5A,0x01}, // AF_HBPF_PEAK_OPD_TH_MAX + +{0x66E4,0xC8,0x01}, +{0x66E5,0xC8,0x01}, + +//AF opd window setting +{0x6A30,0x044E,0x02}, // AF_OPD0_HDELAY : +{0x6A32,0x02E5,0x02}, // AF_OPD0_VDELAY : +{0x6A34,0x01D8,0x02}, // AF_OPD0_HVALID : +{0x6A36,0x01D8,0x02}, // AF_OPD0_VVALID : +{0x6A38,0x0412,0x02}, // AF_OPD1_HDELAY : +{0x6A3A,0x02A9,0x02}, // AF_OPD1_VDELAY : +{0x6A3C,0x0251,0x02}, // AF_OPD1_HVALID : +{0x6A3E,0x0251,0x02}, // AF_OPD1_VVALID : +{0x6A40,0x04B4,0x02}, // AF_OPD2_HDELAY : +{0x6A42,0x0114,0x02}, // AF_OPD2_VDELAY : +{0x6A44,0x0118,0x02}, // AF_OPD2_HVALID : +{0x6A46,0x0118,0x02}, // AF_OPD2_VVALID : +{0x6A48,0x0469,0x02}, // AF_OPD3_HDELAY : +{0x6A4A,0x00C9,0x02}, // AF_OPD3_VDELAY : +{0x6A4C,0x01AE,0x02}, // AF_OPD3_HVALID : +{0x6A4E,0x01AE,0x02}, // AF_OPD3_VVALID : +{0x6A50,0x04C6,0x02}, // AF_OPD4_HDELAY : +{0x6A52,0x035D,0x02}, // AF_OPD4_VDELAY : +{0x6A54,0x00E6,0x02}, // AF_OPD4_HVALID : +{0x6A56,0x00E6,0x02}, // AF_OPD4_VVALID : +{0x6A58,0x048A,0x02}, // AF_OPD5_HDELAY : +{0x6A5A,0x0321,0x02}, // AF_OPD5_VDELAY : +{0x6A5C,0x015F,0x02}, // AF_OPD5_HVALID : +{0x6A5E,0x015F,0x02}, // AF_OPD5_VVALID : +{0x6A60,0x04B4,0x02}, // AF_OPD6_HDELAY : +{0x6A62,0x0579,0x02}, // AF_OPD6_VDELAY : +{0x6A64,0x0118,0x02}, // AF_OPD6_HVALID : +{0x6A66,0x0118,0x02}, // AF_OPD6_VVALID : +{0x6A68,0x0469,0x02}, // AF_OPD7_HDELAY : +{0x6A6A,0x052C,0x02}, // AF_OPD7_VDELAY : +{0x6A6C,0x01AE,0x02}, // AF_OPD7_HVALID : +{0x6A6E,0x01AE,0x02}, // AF_OPD7_VVALID : +{0x6A70,0x021D,0x02}, // AF_OPD8_HDELAY : +{0x6A72,0x02F5,0x02}, // AF_OPD8_VDELAY : +{0x6A74,0x01AE,0x02}, // AF_OPD8_HVALID : +{0x6A76,0x01AE,0x02}, // AF_OPD8_VVALID : +{0x6A78,0x06A4,0x02}, // AF_OPD9_HDELAY : +{0x6A7A,0x02F5,0x02}, // AF_OPD9_VDELAY : +{0x6A7C,0x01AE,0x02}, // AF_OPD9_HVALID : +{0x6A7E,0x01AE,0x02}, // AF_OPD9_VVALID : +{0x6A80,0x06,0x01}, // AF_OPD1A_WEIGHT : +{0x6A81,0x05,0x01}, // AF_OPD1B_WEIGHT : +{0x6A82,0x02,0x01}, // AF_OPD2A_WEIGHT : +{0x6A83,0x02,0x01}, // AF_OPD2B_WEIGHT : +{0x6A84,0x08,0x01}, // AF_OPD3A_WEIGHT : +{0x6A85,0x07,0x01}, // AF_OPD3B_WEIGHT : +{0x6A86,0x04,0x01}, // AF_OPD4A_WEIGHT : +{0x6A87,0x03,0x01}, // AF_OPD4B_WEIGHT : +{0x6A88,0x01,0x01}, // AF_OPD5A_WEIGHT : +{0x6A89,0x01,0x01}, // AF_OPD5B_WEIGHT : + + +//lee haknoh add +{0x661C,0x00,0x01}, +//S,66BE,0F,8, //AF_JUDGE_CONF +//S,669A,01F4,16, //AF_OPD_MONOTONYUP_HBPF_TH +//S,669C,03E8,16, //AF_OPD_MONOTONYUP_LBPF_TH +{0x673D,0x01,0x01}, //AF_MANUAL_MOVE_TYTPE : manual mode½Ã AF_MANUAL_POS·Î À̵¿ÇÒÁö ¼³Á¤ +{0x6648,0x00C8,0x02}, //AF_MANUAL_POS +{0x66E0,0x00C8,0x02}, //AF_POS_INF_SET +{0x66E2,0x02BC,0x02}, //AF_POS_MACRO_SET +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode + + +//Ãß°¡ ¼¼Æà ºÎºÐ +{0x00F7,0x52,0x01}, // INIT_QLTY0 : Standard 82 +{0x00F8,0x59,0x01}, // INIT_QLTY1 : Fine 89 +{0x00F9,0x5F,0x01}, // INIT_QLTY2 : SuperFine 95 + +//minimum shutter speed +{0x6800,0x03,0x01}, //SHTMINLINE + +/////// Normal AE Line ////// +// normal capture AE line +{0x0326,0x21,0x01}, // SHTCTRLTIME1_TYPE1 : +{0x0327,0x19,0x01}, // AGCGAIN1_TYPE1 : +{0x0328,0x52,0x01}, // SHTCTRLTIME2_TYPE1 : +{0x0329,0x23,0x01}, // AGCGAIN2_TYPE1 : +{0x032A,0x3E,0x01}, // SHTCTRLTIME3_TYPE1 : +{0x032B,0x3F,0x01}, // AGCGAIN3_TYPE1 : + +// normal preview AE line +{0x032C,0x7C,0x01}, // SHTCTRLTIME1_TYPE2 +{0x032D,0x3D,0x01}, // AGCGAIN1_TYPE2 +{0x032E,0x7C,0x01}, // SHTCTRLTIME2_TYPE2 +{0x032F,0x3D,0x01}, // AGCGAIN2_TYPE2 +{0x0330,0x3E,0x01}, // SHTCTRLTIME3_TYPE2 +{0x0331,0x3F,0x01}, // AGCGAIN3_TYPE2 + +// flash ae line +{0x0332,0x42,0x01}, // SHTCTRLTIME1_TYPE3 : +{0x0333,0x3C,0x01}, // AGCGAIN1_TYPE3 : +{0x0334,0x42,0x01}, // SHTCTRLTIME2_TYPE3 : +{0x0335,0x3C,0x01}, // AGCGAIN2_TYPE3 : +{0x0336,0x21,0x01}, // SHTCTRLTIME3_TYPE3 : +{0x0337,0x3C,0x01}, // AGCGAIN3_TYPE3 : + +//sports ae line +{0x0338,0x00,0x01}, // SHTCTRLTIME1_TYPE4 +{0x0339,0x14,0x01}, // AGCGAIN1_TYPE4 +{0x033A,0x21,0x01}, // SHTCTRLTIME2_TYPE4 +{0x033B,0x19,0x01}, // AGCGAIN2_TYPE4 +{0x033C,0x3E,0x01}, // SHTCTRLTIME3_TYPE4 +{0x033D,0x3D,0x01}, // AGCGAIN3_TYPE4 + +//night mode AF ae line +{0x033E,0xFF,0x01}, // SHTCTRLTIME1_TYPE5 : +{0x033F,0x00,0x01}, // AGCGAIN1_TYPE5 : +{0x0340,0xFF,0x01}, // SHTCTRLTIME2_TYPE5 : +{0x0341,0x00,0x01}, // AGCGAIN2_TYPE5 : +{0x0342,0xA6,0x01}, // SHTCTRLTIME3_TYPE5 : +{0x0343,0x49,0x01}, // AGCGAIN3_TYPE5 : + +//night mode capture ae line +{0x0344,0xFF,0x01}, // SHTCTRLTIME1_TYPE6 : +{0x0345,0x00,0x01}, // AGCGAIN1_TYPE6 : +{0x0346,0xFF,0x01}, // SHTCTRLTIME2_TYPE6 : +{0x0347,0x00,0x01}, // AGCGAIN2_TYPE6 : +{0x0348,0xFA,0x01}, // SHTCTRLTIME3_TYPE6 : +{0x0349,0x3B,0x01}, // AGCGAIN3_TYPE6 : + +// fire mode line +{0x0356,0x01,0x01}, // SHTCTRLTIME1_TYPE9 : +{0x0357,0x04,0x01}, // AGCGAIN1_TYPE9 : +{0x0358,0x01,0x01}, // SHTCTRLTIME2_TYPE9 : +{0x0359,0x04,0x01}, // AGCGAIN2_TYPE9 : +{0x035A,0xF8,0x01}, // SHTCTRLTIME3_TYPE9 : +{0x035B,0x04,0x01}, // AGCGAIN3_TYPE9 : + +// fire mode AF line +{0x035C,0x01,0x01}, // SHTCTRLTIME1_TYPE10 : +{0x035D,0x04,0x01}, // AGCGAIN1_TYPE10 : +{0x035E,0x01,0x01}, // SHTCTRLTIME2_TYPE10 : +{0x035F,0x04,0x01}, // AGCGAIN2_TYPE10 : +{0x0360,0x21,0x01}, // SHTCTRLTIME3_TYPE10 : +{0x0361,0x3E,0x01}, // AGCGAIN3_TYPE10 : + + +//AE ref tunning +{0x5E8A,0x02,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x02,0x01}, // EVREF_GAIN_B : +{0x5E8C,0xFD,0x01}, // EVREF_GAIN_C : +{0x5E8D,0xFD,0x01}, // EVREF_GAIN_D : +{0x5E8E,0xFD,0x01}, // EVREF_GAIN_E : +{0x5E8F,0x90,0x01}, // EVREF_TH_A : +{0x5E90,0x94,0x01}, // EVREF_TH_B : +{0x5E91,0xA5,0x01}, // EVREF_TH_C : +{0x5E92,0xC0,0x01}, // EVREF_TH_D : +{0x5E93,0xD5,0x01}, // EVREF_TH_E : + + +//gamma Ilumi +{0x9211,0x58,0x01}, // GAIN_TH_A_TYPE3 : +{0x9212,0x63,0x01}, // GAIN_TH_B_TYPE3 : +{0x9213,0x9F,0x01}, // GAIN_TH_C_TYPE3 : + +{0x984E,0x0A,0x01}, // GAMMA0_0CLIP_A : +{0x984F,0x0A,0x01}, // GAMMA0_0CLIP_B : +{0x9850,0x05,0x01}, // GAMMA0_0CLIP_C : +{0x9851,0x1E,0x01}, // GAMMA0_SLOPE_A : +{0x9852,0x1E,0x01}, // GAMMA0_SLOPE_B : +{0x9853,0x1E,0x01}, // GAMMA0_SLOPE_C : +{0x9854,0x0A,0x01}, // GAMMA1_0CLIP_A : +{0x9855,0x0F,0x01}, // GAMMA1_0CLIP_B : +{0x9856,0x0F,0x01}, // GAMMA1_0CLIP_C : +{0x9857,0x32,0x01}, // GAMMA1_SLOPE_A : +{0x9858,0x1E,0x01}, // GAMMA1_SLOPE_B : +{0x9859,0x1E,0x01}, // GAMMA1_SLOPE_C : + + +//Gammma Table 0 +{0x7000,0x0000,0x02}, // G0_KNOT_G0 : +{0x7002,0x0015,0x02}, // G0_KNOT_G1 : +{0x7004,0x002C,0x02}, // G0_KNOT_G2 : +{0x7006,0x0041,0x02}, // G0_KNOT_G3 : +{0x7008,0x004D,0x02}, // G0_KNOT_G4 : +{0x700A,0x005B,0x02}, // G0_KNOT_G5 : +{0x700C,0x0060,0x02}, // G0_KNOT_G6 : +{0x700E,0x0068,0x02}, // G0_KNOT_G7 : +{0x7010,0x006F,0x02}, // G0_KNOT_G8 : +{0x7012,0x0078,0x02}, // G0_KNOT_G9 : +{0x7014,0x0057,0x02}, // G0_KNOT_G10 : +{0x7016,0x0090,0x02}, // G0_KNOT_G11 : +{0x7018,0x00BB,0x02}, // G0_KNOT_G12 : +{0x701A,0x00D6,0x02}, // G0_KNOT_G13 : +{0x701C,0x00E5,0x02}, // G0_KNOT_G14 : +{0x701E,0x00F0,0x02}, // G0_KNOT_G15 : +{0x7020,0x00F9,0x02}, // G0_KNOT_G16 : +{0x7022,0x0103,0x02}, // G0_KNOT_G17 : +{0x7024,0x010C,0x02}, // G0_KNOT_G18 : +{0x7026,0x00,0x01}, // G0_KNOT_R0_OFFSET : +{0x7027,0x00,0x01}, // G0_KNOT_R2_OFFSET : +{0x7028,0x00,0x01}, // G0_KNOT_R4_OFFSET : +{0x7029,0x00,0x01}, // G0_KNOT_R6_OFFSET : +{0x702A,0x00,0x01}, // G0_KNOT_R8_OFFSET : +{0x702B,0x00,0x01}, // G0_KNOT_R10_OFFSET : +{0x702C,0x00,0x01}, // G0_KNOT_R12_OFFSET : +{0x702D,0x00,0x01}, // G0_KNOT_R14_OFFSET : +{0x702E,0x00,0x01}, // G0_KNOT_R16_OFFSET : +{0x702F,0x00,0x01}, // G0_KNOT_R18_OFFSET : +{0x7030,0x00,0x01}, // G0_KNOT_B0_OFFSET : +{0x7031,0x00,0x01}, // G0_KNOT_B2_OFFSET : +{0x7032,0x00,0x01}, // G0_KNOT_B4_OFFSET : +{0x7033,0x00,0x01}, // G0_KNOT_B6_OFFSET : +{0x7034,0x00,0x01}, // G0_KNOT_B8_OFFSET : +{0x7035,0x00,0x01}, // G0_KNOT_B10_OFFSET : +{0x7036,0x00,0x01}, // G0_KNOT_B12_OFFSET : +{0x7037,0x00,0x01}, // G0_KNOT_B14_OFFSET : +{0x7038,0x00,0x01}, // G0_KNOT_B16_OFFSET : +{0x7039,0x00,0x01}, // G0_KNOT_B18_OFFSET : +{0x703A,0x0611,0x02}, // G0_LOWGM_ON_R : +{0x703C,0x1E0A,0x02}, // G0_0CLIP_R : +{0x703E,0x0611,0x02}, // G0_LOWGM_ON_G : +{0x7040,0x1E0A,0x02}, // G0_0CLIP_G : +{0x7042,0x0611,0x02}, // G0_LOWGM_ON_B : +{0x7044,0x1E0A,0x02}, // G0_0CLIP_B : +{0x7046,0x9C,0x01}, // G0_KNOT_GAINCTRL_TH_L : +{0x7047,0xA1,0x01}, // G0_KNOT_GAINCTRL_TH_H : +{0x7048,0x0000,0x02}, // G0_KNOT_L_G0 : +{0x704A,0x0007,0x02}, // G0_KNOT_L_G1 : +{0x704C,0x0016,0x02}, // G0_KNOT_L_G2 : +{0x704E,0x002A,0x02}, // G0_KNOT_L_G3 : +{0x7050,0x0039,0x02}, // G0_KNOT_L_G4 : +{0x7052,0x004A,0x02}, // G0_KNOT_L_G5 : +{0x7054,0x0051,0x02}, // G0_KNOT_L_G6 : +{0x7056,0x005D,0x02}, // G0_KNOT_L_G7 : +{0x7058,0x0065,0x02}, // G0_KNOT_L_G8 : +{0x705A,0x006C,0x02}, // G0_KNOT_L_G9 : +{0x705C,0x004E,0x02}, // G0_KNOT_L_G10 : +{0x705E,0x0083,0x02}, // G0_KNOT_L_G11 : +{0x7060,0x00AA,0x02}, // G0_KNOT_L_G12 : +{0x7062,0x00C8,0x02}, // G0_KNOT_L_G13 : +{0x7064,0x00E1,0x02}, // G0_KNOT_L_G14 : +{0x7066,0x00F5,0x02}, // G0_KNOT_L_G15 : +{0x7068,0x0100,0x02}, // G0_KNOT_L_G16 : +{0x706A,0x0106,0x02}, // G0_KNOT_L_G17 : +{0x706C,0x010C,0x02}, // G0_KNOT_L_G18 : + +//Gammma Table 1 +{0x7200,0x0000,0x02}, // G1_KNOT_G0 : +{0x7202,0x0008,0x02}, // G1_KNOT_G1 : +{0x7204,0x0020,0x02}, // G1_KNOT_G2 : +{0x7206,0x0037,0x02}, // G1_KNOT_G3 : +{0x7208,0x004D,0x02}, // G1_KNOT_G4 : +{0x720A,0x0064,0x02}, // G1_KNOT_G5 : +{0x720C,0x006E,0x02}, // G1_KNOT_G6 : +{0x720E,0x0072,0x02}, // G1_KNOT_G7 : +{0x7210,0x007A,0x02}, // G1_KNOT_G8 : +{0x7212,0x007E,0x02}, // G1_KNOT_G9 : +{0x7214,0x0064,0x02}, // G1_KNOT_G10 : +{0x7216,0x0093,0x02}, // G1_KNOT_G11 : +{0x7218,0x00B7,0x02}, // G1_KNOT_G12 : +{0x721A,0x00CD,0x02}, // G1_KNOT_G13 : +{0x721C,0x00DD,0x02}, // G1_KNOT_G14 : +{0x721E,0x00ED,0x02}, // G1_KNOT_G15 : +{0x7220,0x00F9,0x02}, // G1_KNOT_G16 : +{0x7222,0x0102,0x02}, // G1_KNOT_G17 : +{0x7224,0x0101,0x02}, // G1_KNOT_G18 : +{0x7226,0x00,0x01}, // G1_KNOT_R0_OFFSET : +{0x7227,0x00,0x01}, // G1_KNOT_R2_OFFSET : +{0x7228,0x00,0x01}, // G1_KNOT_R4_OFFSET : +{0x7229,0x00,0x01}, // G1_KNOT_R6_OFFSET : +{0x722A,0x00,0x01}, // G1_KNOT_R8_OFFSET : +{0x722B,0x00,0x01}, // G1_KNOT_R10_OFFSET : +{0x722C,0x00,0x01}, // G1_KNOT_R12_OFFSET : +{0x722D,0x00,0x01}, // G1_KNOT_R14_OFFSET : +{0x722E,0x00,0x01}, // G1_KNOT_R16_OFFSET : +{0x722F,0x00,0x01}, // G1_KNOT_R18_OFFSET : +{0x7230,0x00,0x01}, // G1_KNOT_B0_OFFSET : +{0x7231,0x00,0x01}, // G1_KNOT_B2_OFFSET : +{0x7232,0x00,0x01}, // G1_KNOT_B4_OFFSET : +{0x7233,0x00,0x01}, // G1_KNOT_B6_OFFSET : +{0x7234,0x00,0x01}, // G1_KNOT_B8_OFFSET : +{0x7235,0x00,0x01}, // G1_KNOT_B10_OFFSET : +{0x7236,0x00,0x01}, // G1_KNOT_B12_OFFSET : +{0x7237,0x00,0x01}, // G1_KNOT_B14_OFFSET : +{0x7238,0x00,0x01}, // G1_KNOT_B16_OFFSET : +{0x7239,0x00,0x01}, // G1_KNOT_B18_OFFSET : +{0x723A,0x0321,0x02}, // G1_LOWGM_ON_R : +{0x723C,0x0C00,0x02}, // G1_0CLIP_R : +{0x723E,0x0321,0x02}, // G1_LOWGM_ON_G : +{0x7240,0x0C00,0x02}, // G1_0CLIP_G : +{0x7242,0x0321,0x02}, // G1_LOWGM_ON_B : +{0x7244,0x0C00,0x02}, // G1_0CLIP_B : + + +//Gammma Table 2 +{0x7400,0x0000,0x02}, // G2_KNOT_G0 : +{0x7402,0x000A,0x02}, // G2_KNOT_G1 : +{0x7404,0x0023,0x02}, // G2_KNOT_G2 : +{0x7406,0x0038,0x02}, // G2_KNOT_G3 : +{0x7408,0x003F,0x02}, // G2_KNOT_G4 : +{0x740A,0x0047,0x02}, // G2_KNOT_G5 : +{0x740C,0x004F,0x02}, // G2_KNOT_G6 : +{0x740E,0x0058,0x02}, // G2_KNOT_G7 : +{0x7410,0x005F,0x02}, // G2_KNOT_G8 : +{0x7412,0x0068,0x02}, // G2_KNOT_G9 : +{0x7414,0x0044,0x02}, // G2_KNOT_G10 : +{0x7416,0x0083,0x02}, // G2_KNOT_G11 : +{0x7418,0x00B6,0x02}, // G2_KNOT_G12 : +{0x741A,0x00D1,0x02}, // G2_KNOT_G13 : +{0x741C,0x00E4,0x02}, // G2_KNOT_G14 : +{0x741E,0x00F0,0x02}, // G2_KNOT_G15 : +{0x7420,0x00F9,0x02}, // G2_KNOT_G16 : +{0x7422,0x0103,0x02}, // G2_KNOT_G17 : +{0x7424,0x010C,0x02}, // G2_KNOT_G18 : +{0x7426,0x00,0x01}, // G2_KNOT_R0_OFFSET : +{0x7427,0x00,0x01}, // G2_KNOT_R2_OFFSET : +{0x7428,0x00,0x01}, // G2_KNOT_R4_OFFSET : +{0x7429,0x00,0x01}, // G2_KNOT_R6_OFFSET : +{0x742A,0x00,0x01}, // G2_KNOT_R8_OFFSET : +{0x742B,0x00,0x01}, // G2_KNOT_R10_OFFSET : +{0x742C,0x00,0x01}, // G2_KNOT_R12_OFFSET : +{0x742D,0x00,0x01}, // G2_KNOT_R14_OFFSET : +{0x742E,0x00,0x01}, // G2_KNOT_R16_OFFSET : +{0x742F,0x00,0x01}, // G2_KNOT_R18_OFFSET : +{0x7430,0x00,0x01}, // G2_KNOT_B0_OFFSET : +{0x7431,0x00,0x01}, // G2_KNOT_B2_OFFSET : +{0x7432,0x00,0x01}, // G2_KNOT_B4_OFFSET : +{0x7433,0x00,0x01}, // G2_KNOT_B6_OFFSET : +{0x7434,0x00,0x01}, // G2_KNOT_B8_OFFSET : +{0x7435,0x00,0x01}, // G2_KNOT_B10_OFFSET : +{0x7436,0x00,0x01}, // G2_KNOT_B12_OFFSET : +{0x7437,0x00,0x01}, // G2_KNOT_B14_OFFSET : +{0x7438,0x00,0x01}, // G2_KNOT_B16_OFFSET : +{0x7439,0x00,0x01}, // G2_KNOT_B18_OFFSET : +{0x743A,0x0611,0x02}, // G2_LOWGM_ON_R : +{0x743C,0x1E0A,0x02}, // G2_0CLIP_R : +{0x743E,0x0611,0x02}, // G2_LOWGM_ON_G : +{0x7440,0x1E0A,0x02}, // G2_0CLIP_G : +{0x7442,0x0611,0x02}, // G2_LOWGM_ON_B : +{0x7444,0x1E0A,0x02}, // G2_0CLIP_B : + + +//AWB tuning +{0x64A4,0xFF,0x01}, // OUTFRM_LEFT00 : +{0x64A5,0xFF,0x01}, // OUTFRM_LEFT01 : +{0x64A6,0xFF,0x01}, // OUTFRM_LEFT02 : +{0x64A7,0xFF,0x01}, // OUTFRM_LEFT03 : +{0x64A8,0xFF,0x01}, // OUTFRM_LEFT04 : +{0x64A9,0xFF,0x01}, // OUTFRM_LEFT05 : +{0x64AA,0xFF,0x01}, // OUTFRM_LEFT06 : +{0x64AB,0xFF,0x01}, // OUTFRM_LEFT07 : +{0x64AC,0xFF,0x01}, // OUTFRM_LEFT08 : +{0x64AD,0xFD,0x01}, // OUTFRM_LEFT09 : +{0x64AE,0xCB,0x01}, // OUTFRM_LEFT10 : +{0x64AF,0xA9,0x01}, // OUTFRM_LEFT11 : +{0x64B0,0x90,0x01}, // OUTFRM_LEFT12 : +{0x64B1,0x7D,0x01}, // OUTFRM_LEFT13 : +{0x64B2,0x70,0x01}, // OUTFRM_LEFT14 : +{0x64B3,0x65,0x01}, // OUTFRM_LEFT15 : +{0x64B4,0x5C,0x01}, // OUTFRM_LEFT16 : +{0x64B5,0x55,0x01}, // OUTFRM_LEFT17 : +{0x64B6,0x4F,0x01}, // OUTFRM_LEFT18 : +{0x64B7,0x32,0x01}, // OUTFRM_LEFT19 : +{0x64B8,0x4D,0x01}, // OUTFRM_LEFT20 : +{0x64B9,0x40,0x01}, // OUTFRM_LEFT21 : +{0x64BA,0x2D,0x01}, // OUTFRM_LEFT22 : +{0x64BB,0x2B,0x01}, // OUTFRM_LEFT23 : +{0x64BC,0x29,0x01}, // OUTFRM_LEFT24 : +{0x64BD,0x27,0x01}, // OUTFRM_LEFT25 : +{0x64BE,0x25,0x01}, // OUTFRM_LEFT26 : +{0x64BF,0x23,0x01}, // OUTFRM_LEFT27 : +{0x64C0,0x21,0x01}, // OUTFRM_LEFT28 : +{0x64C1,0x1F,0x01}, // OUTFRM_LEFT29 : +{0x64C2,0x1D,0x01}, // OUTFRM_LEFT30 : +{0x64C3,0x1B,0x01}, // OUTFRM_LEFT31 : +{0x64C4,0x1A,0x01}, // OUTFRM_LEFT32 : +{0x64C5,0x1A,0x01}, // OUTFRM_LEFT33 : +{0x64C6,0x1A,0x01}, // OUTFRM_LEFT34 : +{0x64C7,0x28,0x01}, // OUTFRM_LEFT35 : +{0x64C8,0x27,0x01}, // OUTFRM_LEFT36 : +{0x64C9,0x26,0x01}, // OUTFRM_LEFT37 : +{0x64CA,0xFF,0x01}, // OUTFRM_RIGHT00 : +{0x64CB,0xFF,0x01}, // OUTFRM_RIGHT01 : +{0x64CC,0xFF,0x01}, // OUTFRM_RIGHT02 : +{0x64CD,0xFF,0x01}, // OUTFRM_RIGHT03 : +{0x64CE,0xFF,0x01}, // OUTFRM_RIGHT04 : +{0x64CF,0xFF,0x01}, // OUTFRM_RIGHT05 : +{0x64D0,0xFF,0x01}, // OUTFRM_RIGHT06 : +{0x64D1,0xFF,0x01}, // OUTFRM_RIGHT07 : +{0x64D2,0xFF,0x01}, // OUTFRM_RIGHT08 : +{0x64D3,0xFF,0x01}, // OUTFRM_RIGHT09 : +{0x64D4,0xD3,0x01}, // OUTFRM_RIGHT10 : +{0x64D5,0xB1,0x01}, // OUTFRM_RIGHT11 : +{0x64D6,0x98,0x01}, // OUTFRM_RIGHT12 : +{0x64D7,0x85,0x01}, // OUTFRM_RIGHT13 : +{0x64D8,0x78,0x01}, // OUTFRM_RIGHT14 : +{0x64D9,0x6D,0x01}, // OUTFRM_RIGHT15 : +{0x64DA,0x64,0x01}, // OUTFRM_RIGHT16 : +{0x64DB,0x5D,0x01}, // OUTFRM_RIGHT17 : +{0x64DC,0x57,0x01}, // OUTFRM_RIGHT18 : +{0x64DD,0x63,0x01}, // OUTFRM_RIGHT19 : +{0x64DE,0x5E,0x01}, // OUTFRM_RIGHT20 : +{0x64DF,0x5A,0x01}, // OUTFRM_RIGHT21 : +{0x64E0,0x56,0x01}, // OUTFRM_RIGHT22 : +{0x64E1,0x52,0x01}, // OUTFRM_RIGHT23 : +{0x64E2,0x50,0x01}, // OUTFRM_RIGHT24 : +{0x64E3,0x4E,0x01}, // OUTFRM_RIGHT25 : +{0x64E4,0x4C,0x01}, // OUTFRM_RIGHT26 : +{0x64E5,0x4A,0x01}, // OUTFRM_RIGHT27 : +{0x64E6,0x48,0x01}, // OUTFRM_RIGHT28 : +{0x64E7,0x46,0x01}, // OUTFRM_RIGHT29 : +{0x64E8,0x44,0x01}, // OUTFRM_RIGHT30 : +{0x64E9,0x43,0x01}, // OUTFRM_RIGHT31 : +{0x64EA,0x42,0x01}, // OUTFRM_RIGHT32 : +{0x64EB,0x42,0x01}, // OUTFRM_RIGHT33 : +{0x64EC,0x42,0x01}, // OUTFRM_RIGHT34 : +{0x64ED,0x30,0x01}, // OUTFRM_RIGHT35 : +{0x64EE,0x2F,0x01}, // OUTFRM_RIGHT36 : +{0x64EF,0x2E,0x01}, // OUTFRM_RIGHT37 : +{0x64F0,0x2163,0x02}, // OUTFRM_TOP : +{0x64F2,0x1400,0x02}, // OUTFRM_BOTM : +{0x64F4,0x19,0x01}, // OUTFRM_FLTOP : +{0x64F5,0x14,0x01}, // OUTFRM_FLBOTM : +{0x64F6,0xFF,0x01}, // OUTAIM_LEFT00 : +{0x64F7,0xFF,0x01}, // OUTAIM_LEFT01 : +{0x64F8,0xFF,0x01}, // OUTAIM_LEFT02 : +{0x64F9,0xFF,0x01}, // OUTAIM_LEFT03 : +{0x64FA,0xFF,0x01}, // OUTAIM_LEFT04 : +{0x64FB,0xFF,0x01}, // OUTAIM_LEFT05 : +{0x64FC,0xFF,0x01}, // OUTAIM_LEFT06 : +{0x64FD,0xFF,0x01}, // OUTAIM_LEFT07 : +{0x64FE,0xFF,0x01}, // OUTAIM_LEFT08 : +{0x64FF,0xFF,0x01}, // OUTAIM_LEFT09 : +{0x6500,0x91,0x01}, // OUTAIM_LEFT10 : +{0x6501,0x91,0x01}, // OUTAIM_LEFT11 : +{0x6502,0x91,0x01}, // OUTAIM_LEFT12 : +{0x6503,0x66,0x01}, // OUTAIM_LEFT13 : +{0x6504,0x5D,0x01}, // OUTAIM_LEFT14 : +{0x6505,0x3C,0x01}, // OUTAIM_LEFT15 : +{0x6506,0x3C,0x01}, // OUTAIM_LEFT16 : +{0x6507,0x3C,0x01}, // OUTAIM_LEFT17 : +{0x6508,0x3A,0x01}, // OUTAIM_LEFT18 : +{0x6509,0x39,0x01}, // OUTAIM_LEFT19 : +{0x650A,0x40,0x01}, // OUTAIM_LEFT20 : +{0x650B,0x46,0x01}, // OUTAIM_LEFT21 : +{0x650C,0x42,0x01}, // OUTAIM_LEFT22 : +{0x650D,0x3D,0x01}, // OUTAIM_LEFT23 : +{0x650E,0x3A,0x01}, // OUTAIM_LEFT24 : +{0x650F,0x3E,0x01}, // OUTAIM_LEFT25 : +{0x6510,0x38,0x01}, // OUTAIM_LEFT26 : +{0x6511,0x36,0x01}, // OUTAIM_LEFT27 : +{0x6512,0x34,0x01}, // OUTAIM_LEFT28 : +{0x6513,0x32,0x01}, // OUTAIM_LEFT29 : +{0x6514,0x30,0x01}, // OUTAIM_LEFT30 : +{0x6515,0x2F,0x01}, // OUTAIM_LEFT31 : +{0x6516,0x2D,0x01}, // OUTAIM_LEFT32 : +{0x6517,0x2C,0x01}, // OUTAIM_LEFT33 : +{0x6518,0x2B,0x01}, // OUTAIM_LEFT34 : +{0x6519,0x2A,0x01}, // OUTAIM_LEFT35 : +{0x651A,0x29,0x01}, // OUTAIM_LEFT36 : +{0x651B,0x28,0x01}, // OUTAIM_LEFT37 : +{0x651C,0xFF,0x01}, // OUTAIM_RIGHT00 : +{0x651D,0xFF,0x01}, // OUTAIM_RIGHT01 : +{0x651E,0xFF,0x01}, // OUTAIM_RIGHT02 : +{0x651F,0xFF,0x01}, // OUTAIM_RIGHT03 : +{0x6520,0xFF,0x01}, // OUTAIM_RIGHT04 : +{0x6521,0xFF,0x01}, // OUTAIM_RIGHT05 : +{0x6522,0xFF,0x01}, // OUTAIM_RIGHT06 : +{0x6523,0xFF,0x01}, // OUTAIM_RIGHT07 : +{0x6524,0xFF,0x01}, // OUTAIM_RIGHT08 : +{0x6525,0xFF,0x01}, // OUTAIM_RIGHT09 : +{0x6526,0xD9,0x01}, // OUTAIM_RIGHT10 : +{0x6527,0xB7,0x01}, // OUTAIM_RIGHT11 : +{0x6528,0x96,0x01}, // OUTAIM_RIGHT12 : +{0x6529,0x6C,0x01}, // OUTAIM_RIGHT13 : +{0x652A,0x64,0x01}, // OUTAIM_RIGHT14 : +{0x652B,0x62,0x01}, // OUTAIM_RIGHT15 : +{0x652C,0x62,0x01}, // OUTAIM_RIGHT16 : +{0x652D,0x61,0x01}, // OUTAIM_RIGHT17 : +{0x652E,0x60,0x01}, // OUTAIM_RIGHT18 : +{0x652F,0x5E,0x01}, // OUTAIM_RIGHT19 : +{0x6530,0x5B,0x01}, // OUTAIM_RIGHT20 : +{0x6531,0x4F,0x01}, // OUTAIM_RIGHT21 : +{0x6532,0x48,0x01}, // OUTAIM_RIGHT22 : +{0x6533,0x43,0x01}, // OUTAIM_RIGHT23 : +{0x6534,0x41,0x01}, // OUTAIM_RIGHT24 : +{0x6535,0x40,0x01}, // OUTAIM_RIGHT25 : +{0x6536,0x3D,0x01}, // OUTAIM_RIGHT26 : +{0x6537,0x3B,0x01}, // OUTAIM_RIGHT27 : +{0x6538,0x39,0x01}, // OUTAIM_RIGHT28 : +{0x6539,0x37,0x01}, // OUTAIM_RIGHT29 : +{0x653A,0x36,0x01}, // OUTAIM_RIGHT30 : +{0x653B,0x35,0x01}, // OUTAIM_RIGHT31 : +{0x653C,0x33,0x01}, // OUTAIM_RIGHT32 : +{0x653D,0x32,0x01}, // OUTAIM_RIGHT33 : +{0x653E,0x31,0x01}, // OUTAIM_RIGHT34 : +{0x653F,0x30,0x01}, // OUTAIM_RIGHT35 : +{0x6540,0x2F,0x01}, // OUTAIM_RIGHT36 : +{0x6541,0x2E,0x01}, // OUTAIM_RIGHT37 : +{0x6542,0x1F40,0x02}, // OUTAIM_TOP : +{0x6544,0x1752,0x02}, // OUTAIM_BOTM : +{0x6546,0x19,0x01}, // OUTAIM_FLTOP : +{0x6547,0x17,0x01}, // OUTAIM_FLBOTM : + +{0x657A,0x82,0x01}, // IN_CTMP_FRM_BG0 : +{0x657B,0x78,0x01}, // IN_CTMP_FRM_BG1 : +{0x657C,0x65,0x01}, // IN_CTMP_FRM_BG2 : +{0x657D,0x5B,0x01}, // IN_CTMP_FRM_BG3 : +{0x657E,0x55,0x01}, // IN_CTMP_FRM_BG4 : +{0x657F,0x4F,0x01}, // IN_CTMP_FRM_BG5 : +{0x6580,0x49,0x01}, // IN_CTMP_FRM_BG6 : +{0x6581,0x43,0x01}, // IN_CTMP_FRM_BG7 : +{0x6582,0x3E,0x01}, // IN_CTMP_FRM_BG8 : +{0x6583,0x35,0x01}, // IN_CTMP_FRM_BG9 : +{0x6584,0x30,0x01}, // IN_CTMP_FRM_BG10 : +{0x6585,0x23,0x01}, // IN_CTMP_FRM_RG0 : +{0x6586,0x33,0x01}, // IN_CTMP_FRM_RG1 : +{0x6587,0x3F,0x01}, // IN_CTMP_FRM_RG2 : +{0x6588,0x53,0x01}, // IN_CTMP_FRM_RG3 : +{0x6589,0x63,0x01}, // IN_CTMP_FRM_RG4 : +{0x658A,0x76,0x01}, // IN_CTMP_FRM_RG5 : +{0x658B,0x9A,0x01}, // IN_CTMP_FRM_RG6 : +{0x658C,0x00,0x01}, // IN_CTMP_WEIGHT00_01 : +{0x658D,0x00,0x01}, // IN_CTMP_WEIGHT02_03 : +{0x658E,0x00,0x01}, // IN_CTMP_WEIGHT04_05 : +{0x658F,0x00,0x01}, // IN_CTMP_WEIGHT06_07 : +{0x6590,0x00,0x01}, // IN_CTMP_WEIGHT08_09 : +{0x6591,0x00,0x01}, // IN_CTMP_WEIGHT10_11 : +{0x6592,0x00,0x01}, // IN_CTMP_WEIGHT12_13 : +{0x6593,0x00,0x01}, // IN_CTMP_WEIGHT14_15 : +{0x6594,0x00,0x01}, // IN_CTMP_WEIGHT16_17 : +{0x6595,0x00,0x01}, // IN_CTMP_WEIGHT18_19 : +{0x6596,0x00,0x01}, // IN_CTMP_WEIGHT20_21 : +{0x6597,0x00,0x01}, // IN_CTMP_WEIGHT22_23 : +{0x6598,0x00,0x01}, // IN_CTMP_WEIGHT24_25 : +{0x6599,0x00,0x01}, // IN_CTMP_WEIGHT26_27 : +{0x659A,0x00,0x01}, // IN_CTMP_WEIGHT28_29 : +{0x659B,0x00,0x01}, // IN_CTMP_WEIGHT30_31 : +{0x659C,0x00,0x01}, // IN_CTMP_WEIGHT32_33 : +{0x659D,0x00,0x01}, // IN_CTMP_WEIGHT34_35 : +{0x659E,0x00,0x01}, // IN_CTMP_WEIGHT36_37 : +{0x659F,0x00,0x01}, // IN_CTMP_WEIGHT38_39 : +{0x65A0,0x00,0x01}, // IN_CTMP_WEIGHT40_41 : +{0x65A1,0x00,0x01}, // IN_CTMP_WEIGHT42_43 : +{0x65A2,0x00,0x01}, // IN_CTMP_WEIGHT44_45 : +{0x65A3,0x00,0x01}, // IN_CTMP_WEIGHT46_47 : +{0x65A4,0x00,0x01}, // IN_CTMP_WEIGHT48_49 : +{0x65A5,0x00,0x01}, // IN_CTMP_WEIGHT50_51 : +{0x65A6,0x00,0x01}, // IN_CTMP_WEIGHT52_53 : +{0x65A7,0x00,0x01}, // IN_CTMP_WEIGHT54_55 : +{0x65A8,0x00,0x01}, // IN_CTMP_WEIGHT56_57 : +{0x65A9,0x10,0x01}, // IN_CTMP_WEIGHT58_59 : + +{0x65AA,0x78,0x01}, // OUT_CTMP_FRM_BG0 : +{0x65AB,0x74,0x01}, // OUT_CTMP_FRM_BG1 : +{0x65AC,0x70,0x01}, // OUT_CTMP_FRM_BG2 : +{0x65AD,0x6D,0x01}, // OUT_CTMP_FRM_BG3 : +{0x65AE,0x69,0x01}, // OUT_CTMP_FRM_BG4 : +{0x65AF,0x66,0x01}, // OUT_CTMP_FRM_BG5 : +{0x65B0,0x61,0x01}, // OUT_CTMP_FRM_BG6 : +{0x65B1,0x5D,0x01}, // OUT_CTMP_FRM_BG7 : +{0x65B2,0x52,0x01}, // OUT_CTMP_FRM_BG8 : +{0x65B3,0x4B,0x01}, // OUT_CTMP_FRM_BG9 : +{0x65B4,0x44,0x01}, // OUT_CTMP_FRM_BG10 : +{0x65B5,0x19,0x01}, // OUT_CTMP_FRM_RG0 : +{0x65B6,0x27,0x01}, // OUT_CTMP_FRM_RG1 : +{0x65B7,0x32,0x01}, // OUT_CTMP_FRM_RG2 : +{0x65B8,0x3A,0x01}, // OUT_CTMP_FRM_RG3 : +{0x65B9,0x43,0x01}, // OUT_CTMP_FRM_RG4 : +{0x65BA,0x4A,0x01}, // OUT_CTMP_FRM_RG5 : +{0x65BB,0x5E,0x01}, // OUT_CTMP_FRM_RG6 : +{0x65BC,0x00,0x01}, // OUT_CTMP_WEIGHT00_01 : +{0x65BD,0x00,0x01}, // OUT_CTMP_WEIGHT02_03 : +{0x65BE,0x00,0x01}, // OUT_CTMP_WEIGHT04_05 : +{0x65BF,0x00,0x01}, // OUT_CTMP_WEIGHT06_07 : +{0x65C0,0x33,0x01}, // OUT_CTMP_WEIGHT08_09 : +{0x65C1,0x00,0x01}, // OUT_CTMP_WEIGHT10_11 : +{0x65C2,0x30,0x01}, // OUT_CTMP_WEIGHT12_13 : +{0x65C3,0x33,0x01}, // OUT_CTMP_WEIGHT14_15 : +{0x65C4,0x00,0x01}, // OUT_CTMP_WEIGHT16_17 : +{0x65C5,0x30,0x01}, // OUT_CTMP_WEIGHT18_19 : +{0x65C6,0x33,0x01}, // OUT_CTMP_WEIGHT20_21 : +{0x65C7,0x00,0x01}, // OUT_CTMP_WEIGHT22_23 : +{0x65C8,0x30,0x01}, // OUT_CTMP_WEIGHT24_25 : +{0x65C9,0x33,0x01}, // OUT_CTMP_WEIGHT26_27 : +{0x65CA,0x00,0x01}, // OUT_CTMP_WEIGHT28_29 : +{0x65CB,0x30,0x01}, // OUT_CTMP_WEIGHT30_31 : +{0x65CC,0x44,0x01}, // OUT_CTMP_WEIGHT32_33 : +{0x65CD,0x00,0x01}, // OUT_CTMP_WEIGHT34_35 : +{0x65CE,0x40,0x01}, // OUT_CTMP_WEIGHT36_37 : +{0x65CF,0x55,0x01}, // OUT_CTMP_WEIGHT38_39 : +{0x65D0,0x05,0x01}, // OUT_CTMP_WEIGHT40_41 : +{0x65D1,0x20,0x01}, // OUT_CTMP_WEIGHT42_43 : +{0x65D2,0x72,0x01}, // OUT_CTMP_WEIGHT44_45 : +{0x65D3,0x07,0x01}, // OUT_CTMP_WEIGHT46_47 : +{0x65D4,0x00,0x01}, // OUT_CTMP_WEIGHT48_49 : +{0x65D5,0x00,0x01}, // OUT_CTMP_WEIGHT50_51 : +{0x65D6,0x00,0x01}, // OUT_CTMP_WEIGHT52_53 : +{0x65D7,0x00,0x01}, // OUT_CTMP_WEIGHT54_55 : +{0x65D8,0x00,0x01}, // OUT_CTMP_WEIGHT56_57 : +{0x65D9,0x00,0x01}, // OUT_CTMP_WEIGHT58_59 : + +{0x6400,0xAA,0x01}, // INFRM_LEFT00 : +{0x6401,0xAA,0x01}, // INFRM_LEFT01 : +{0x6402,0xAA,0x01}, // INFRM_LEFT02 : +{0x6403,0xAA,0x01}, // INFRM_LEFT03 : +{0x6404,0xAA,0x01}, // INFRM_LEFT04 : +{0x6405,0xAA,0x01}, // INFRM_LEFT05 : +{0x6406,0xAA,0x01}, // INFRM_LEFT06 : +{0x6407,0xAA,0x01}, // INFRM_LEFT07 : +{0x6408,0xAA,0x01}, // INFRM_LEFT08 : +{0x6409,0xAE,0x01}, // INFRM_LEFT09 : +{0x640A,0xA0,0x01}, // INFRM_LEFT10 : +{0x640B,0x8C,0x01}, // INFRM_LEFT11 : +{0x640C,0x72,0x01}, // INFRM_LEFT12 : +{0x640D,0x64,0x01}, // INFRM_LEFT13 : +{0x640E,0x5A,0x01}, // INFRM_LEFT14 : +{0x640F,0x52,0x01}, // INFRM_LEFT15 : +{0x6410,0x48,0x01}, // INFRM_LEFT16 : +{0x6411,0x43,0x01}, // INFRM_LEFT17 : +{0x6412,0x3D,0x01}, // INFRM_LEFT18 : +{0x6413,0x37,0x01}, // INFRM_LEFT19 : +{0x6414,0x33,0x01}, // INFRM_LEFT20 : +{0x6415,0x30,0x01}, // INFRM_LEFT21 : +{0x6416,0x2E,0x01}, // INFRM_LEFT22 : +{0x6417,0x2B,0x01}, // INFRM_LEFT23 : +{0x6418,0x28,0x01}, // INFRM_LEFT24 : +{0x6419,0x26,0x01}, // INFRM_LEFT25 : +{0x641A,0x24,0x01}, // INFRM_LEFT26 : +{0x641B,0x23,0x01}, // INFRM_LEFT27 : +{0x641C,0x22,0x01}, // INFRM_LEFT28 : +{0x641D,0x22,0x01}, // INFRM_LEFT29 : +{0x641E,0x21,0x01}, // INFRM_LEFT30 : +{0x641F,0x20,0x01}, // INFRM_LEFT31 : +{0x6420,0x1D,0x01}, // INFRM_LEFT32 : +{0x6421,0x1A,0x01}, // INFRM_LEFT33 : +{0x6422,0x18,0x01}, // INFRM_LEFT34 : +{0x6423,0x17,0x01}, // INFRM_LEFT35 : +{0x6424,0x16,0x01}, // INFRM_LEFT36 : +{0x6425,0x17,0x01}, // INFRM_LEFT37 : +{0x6426,0xAF,0x01}, // INFRM_RIGHT00 : +{0x6427,0xAF,0x01}, // INFRM_RIGHT01 : +{0x6428,0xAF,0x01}, // INFRM_RIGHT02 : +{0x6429,0xAF,0x01}, // INFRM_RIGHT03 : +{0x642A,0xAF,0x01}, // INFRM_RIGHT04 : +{0x642B,0xAF,0x01}, // INFRM_RIGHT05 : +{0x642C,0xAF,0x01}, // INFRM_RIGHT06 : +{0x642D,0xAF,0x01}, // INFRM_RIGHT07 : +{0x642E,0xAF,0x01}, // INFRM_RIGHT08 : +{0x642F,0xAA,0x01}, // INFRM_RIGHT09 : +{0x6430,0xB2,0x01}, // INFRM_RIGHT10 : +{0x6431,0xB4,0x01}, // INFRM_RIGHT11 : +{0x6432,0xB6,0x01}, // INFRM_RIGHT12 : +{0x6433,0xB4,0x01}, // INFRM_RIGHT13 : +{0x6434,0x9B,0x01}, // INFRM_RIGHT14 : +{0x6435,0x8E,0x01}, // INFRM_RIGHT15 : +{0x6436,0x84,0x01}, // INFRM_RIGHT16 : +{0x6437,0x7A,0x01}, // INFRM_RIGHT17 : +{0x6438,0x72,0x01}, // INFRM_RIGHT18 : +{0x6439,0x6A,0x01}, // INFRM_RIGHT19 : +{0x643A,0x63,0x01}, // INFRM_RIGHT20 : +{0x643B,0x5E,0x01}, // INFRM_RIGHT21 : +{0x643C,0x58,0x01}, // INFRM_RIGHT22 : +{0x643D,0x53,0x01}, // INFRM_RIGHT23 : +{0x643E,0x4E,0x01}, // INFRM_RIGHT24 : +{0x643F,0x4A,0x01}, // INFRM_RIGHT25 : +{0x6440,0x46,0x01}, // INFRM_RIGHT26 : +{0x6441,0x42,0x01}, // INFRM_RIGHT27 : +{0x6442,0x3F,0x01}, // INFRM_RIGHT28 : +{0x6443,0x3C,0x01}, // INFRM_RIGHT29 : +{0x6444,0x3A,0x01}, // INFRM_RIGHT30 : +{0x6445,0x38,0x01}, // INFRM_RIGHT31 : +{0x6446,0x37,0x01}, // INFRM_RIGHT32 : +{0x6447,0x35,0x01}, // INFRM_RIGHT33 : +{0x6448,0x33,0x01}, // INFRM_RIGHT34 : +{0x6449,0x32,0x01}, // INFRM_RIGHT35 : +{0x644A,0x32,0x01}, // INFRM_RIGHT36 : +{0x644B,0x32,0x01}, // INFRM_RIGHT37 : +{0x644C,0x24FA,0x02}, // INFRM_TOP : +{0x644E,0x0940,0x02}, // INFRM_BOTM : +{0x6450,0x19,0x01}, // INFRM_FLTOP : +{0x6451,0x10,0x01}, // INFRM_FLBOTM : +{0x6452,0x91,0x01}, // INAIM_LEFT00 : +{0x6453,0x91,0x01}, // INAIM_LEFT01 : +{0x6454,0x91,0x01}, // INAIM_LEFT02 : +{0x6455,0x91,0x01}, // INAIM_LEFT03 : +{0x6456,0x91,0x01}, // INAIM_LEFT04 : +{0x6457,0x91,0x01}, // INAIM_LEFT05 : +{0x6458,0x91,0x01}, // INAIM_LEFT06 : +{0x6459,0x91,0x01}, // INAIM_LEFT07 : +{0x645A,0x91,0x01}, // INAIM_LEFT08 : +{0x645B,0x91,0x01}, // INAIM_LEFT09 : +{0x645C,0x91,0x01}, // INAIM_LEFT10 : +{0x645D,0x91,0x01}, // INAIM_LEFT11 : +{0x645E,0x91,0x01}, // INAIM_LEFT12 : +{0x645F,0x66,0x01}, // INAIM_LEFT13 : +{0x6460,0x71,0x01}, // INAIM_LEFT14 : +{0x6461,0x5A,0x01}, // INAIM_LEFT15 : +{0x6462,0x4E,0x01}, // INAIM_LEFT16 : +{0x6463,0x47,0x01}, // INAIM_LEFT17 : +{0x6464,0x42,0x01}, // INAIM_LEFT18 : +{0x6465,0x3C,0x01}, // INAIM_LEFT19 : +{0x6466,0x38,0x01}, // INAIM_LEFT20 : +{0x6467,0x36,0x01}, // INAIM_LEFT21 : +{0x6468,0x33,0x01}, // INAIM_LEFT22 : +{0x6469,0x30,0x01}, // INAIM_LEFT23 : +{0x646A,0x2F,0x01}, // INAIM_LEFT24 : +{0x646B,0x2B,0x01}, // INAIM_LEFT25 : +{0x646C,0x29,0x01}, // INAIM_LEFT26 : +{0x646D,0x27,0x01}, // INAIM_LEFT27 : +{0x646E,0x26,0x01}, // INAIM_LEFT28 : +{0x646F,0x28,0x01}, // INAIM_LEFT29 : +{0x6470,0x2A,0x01}, // INAIM_LEFT30 : +{0x6471,0x28,0x01}, // INAIM_LEFT31 : +{0x6472,0x26,0x01}, // INAIM_LEFT32 : +{0x6473,0x24,0x01}, // INAIM_LEFT33 : +{0x6474,0x29,0x01}, // INAIM_LEFT34 : +{0x6475,0x28,0x01}, // INAIM_LEFT35 : +{0x6476,0x29,0x01}, // INAIM_LEFT36 : +{0x6477,0x26,0x01}, // INAIM_LEFT37 : +{0x6478,0xFF,0x01}, // INAIM_RIGHT00 : +{0x6479,0xFF,0x01}, // INAIM_RIGHT01 : +{0x647A,0xFF,0x01}, // INAIM_RIGHT02 : +{0x647B,0xFF,0x01}, // INAIM_RIGHT03 : +{0x647C,0xFF,0x01}, // INAIM_RIGHT04 : +{0x647D,0xFF,0x01}, // INAIM_RIGHT05 : +{0x647E,0xFF,0x01}, // INAIM_RIGHT06 : +{0x647F,0xFF,0x01}, // INAIM_RIGHT07 : +{0x6480,0xFF,0x01}, // INAIM_RIGHT08 : +{0x6481,0xFF,0x01}, // INAIM_RIGHT09 : +{0x6482,0xD9,0x01}, // INAIM_RIGHT10 : +{0x6483,0xB7,0x01}, // INAIM_RIGHT11 : +{0x6484,0x96,0x01}, // INAIM_RIGHT12 : +{0x6485,0x68,0x01}, // INAIM_RIGHT13 : +{0x6486,0x72,0x01}, // INAIM_RIGHT14 : +{0x6487,0x71,0x01}, // INAIM_RIGHT15 : +{0x6488,0x6E,0x01}, // INAIM_RIGHT16 : +{0x6489,0x6A,0x01}, // INAIM_RIGHT17 : +{0x648A,0x65,0x01}, // INAIM_RIGHT18 : +{0x648B,0x60,0x01}, // INAIM_RIGHT19 : +{0x648C,0x5B,0x01}, // INAIM_RIGHT20 : +{0x648D,0x56,0x01}, // INAIM_RIGHT21 : +{0x648E,0x51,0x01}, // INAIM_RIGHT22 : +{0x648F,0x4C,0x01}, // INAIM_RIGHT23 : +{0x6490,0x47,0x01}, // INAIM_RIGHT24 : +{0x6491,0x44,0x01}, // INAIM_RIGHT25 : +{0x6492,0x41,0x01}, // INAIM_RIGHT26 : +{0x6493,0x3E,0x01}, // INAIM_RIGHT27 : +{0x6494,0x3B,0x01}, // INAIM_RIGHT28 : +{0x6495,0x39,0x01}, // INAIM_RIGHT29 : +{0x6496,0x37,0x01}, // INAIM_RIGHT30 : +{0x6497,0x34,0x01}, // INAIM_RIGHT31 : +{0x6498,0x33,0x01}, // INAIM_RIGHT32 : +{0x6499,0x32,0x01}, // INAIM_RIGHT33 : +{0x649A,0x31,0x01}, // INAIM_RIGHT34 : +{0x649B,0x30,0x01}, // INAIM_RIGHT35 : +{0x649C,0x2F,0x01}, // INAIM_RIGHT36 : +{0x649D,0x2E,0x01}, // INAIM_RIGHT37 : +{0x649E,0x1E00,0x02}, // INAIM_TOP : +{0x64A0,0x0DFF,0x02}, // INAIM_BOTM : +{0x64A2,0x18,0x01}, // INAIM_FLTOP : +{0x64A3,0x09,0x01}, // INAIM_FLBOTM : + +//AWB setting +{0x629A,0x13,0x01}, // CAT_AWB_2 : OPDG ±â´É off +{0x629B,0x41,0x01}, // CAT_AWB_3 : outdoor_°¡ÁßÄ¡ on +{0x625F,0x15,0x01}, // CAT_AWB_1 : MWB½Ã userÁÂÇ¥·Î ÁÂÇ¥ °íÁ¤(AWB½Ã¿¡´Â ¿µÇâ ¹«) +{0x629C,0x80,0x01}, // FRMOUT_RATIO_BLEND1_OUT +{0x6224,0x04,0x01}, // ATW_DELAY +{0x6226,0x08,0x01}, // ATW_GAINS_IN_NR : +{0x6227,0x04,0x01}, // ATW_GAINS_IN : +{0x6228,0x08,0x01}, // ATW_GAINS_OUT_NR : +{0x6229,0x04,0x01}, // ATW_GAINS_OUT : + +//Bluesky threshold º¯°æ +{0x6548,0x18F7,0x02}, // OUTAIM_TOP_BLUESKY : + +//Hue, Gain setting +{0x6E86,0x0000,0x02}, // IBYHUE1_POS1 : +{0x6E88,0xFFF5,0x02}, // IRYHUE1_POS1 : +{0x6E8A,0xFFF8,0x02}, // IBYHUE2_POS1 : +{0x6E8C,0xFFF5,0x02}, // IRYHUE2_POS1 : +{0x6E8E,0xFFF8,0x02}, // IBYHUE3_POS1 : +{0x6E90,0xFFEE,0x02}, // IRYHUE3_POS1 : +{0x6E92,0x0000,0x02}, // IBYHUE4_POS1 : +{0x6E94,0xFFEC,0x02}, // IRYHUE4_POS1 : +{0x6E96,0x0000,0x02}, // IBYHUE1_POS2 : +{0x6E98,0xFFF5,0x02}, // IRYHUE1_POS2 : +{0x6E9A,0xFFFD,0x02}, // IBYHUE2_POS2 : +{0x6E9C,0xFFF5,0x02}, // IRYHUE2_POS2 : +{0x6E9E,0xFFFD,0x02}, // IBYHUE3_POS2 : +{0x6EA0,0xFFEE,0x02}, // IRYHUE3_POS2 : +{0x6EA2,0x0000,0x02}, // IBYHUE4_POS2 : +{0x6EA4,0xFFEC,0x02}, // IRYHUE4_POS2 : +{0x6EA6,0x0000,0x02}, // IBYHUE1_POS3 : +{0x6EA8,0xFFF5,0x02}, // IRYHUE1_POS3 : +{0x6EAA,0xFFF8,0x02}, // IBYHUE2_POS3 : +{0x6EAC,0xFFF5,0x02}, // IRYHUE2_POS3 : +{0x6EAE,0xFFF8,0x02}, // IBYHUE3_POS3 : +{0x6EB0,0xFFEE,0x02}, // IRYHUE3_POS3 : +{0x6EB2,0x0000,0x02}, // IBYHUE4_POS3 : +{0x6EB4,0xFFEC,0x02}, // IRYHUE4_POS3 : +{0x6EB6,0x0000,0x02}, // IBYHUE1_POS4 : +{0x6EB8,0xFFF5,0x02}, // IRYHUE1_POS4 : +{0x6EBA,0xFFF8,0x02}, // IBYHUE2_POS4 : +{0x6EBC,0xFFF5,0x02}, // IRYHUE2_POS4 : +{0x6EBE,0xFFF8,0x02}, // IBYHUE3_POS4 : +{0x6EC0,0xFFEE,0x02}, // IRYHUE3_POS4 : +{0x6EC2,0x0000,0x02}, // IBYHUE4_POS4 : +{0x6EC4,0xFFEC,0x02}, // IRYHUE4_POS4 : +{0x6EC6,0x0000,0x02}, // IBYHUE1_POS5 : +{0x6EC8,0xFFF5,0x02}, // IRYHUE1_POS5 : +{0x6ECA,0xFFF8,0x02}, // IBYHUE2_POS5 : +{0x6ECC,0xFFF5,0x02}, // IRYHUE2_POS5 : +{0x6ECE,0xFFF8,0x02}, // IBYHUE3_POS5 : +{0x6ED0,0xFFEE,0x02}, // IRYHUE3_POS5 : +{0x6ED2,0x0000,0x02}, // IBYHUE4_POS5 : +{0x6ED4,0xFFEC,0x02}, // IRYHUE4_POS5 : +{0x6ED6,0x0000,0x02}, // IBYHUE1_POS6 : +{0x6ED8,0xFFF5,0x02}, // IRYHUE1_POS6 : +{0x6EDA,0xFFF8,0x02}, // IBYHUE2_POS6 : +{0x6EDC,0xFFF5,0x02}, // IRYHUE2_POS6 : +{0x6EDE,0xFFF8,0x02}, // IBYHUE3_POS6 : +{0x6EE0,0xFFEE,0x02}, // IRYHUE3_POS6 : +{0x6EE2,0x0000,0x02}, // IBYHUE4_POS6 : +{0x6EE4,0xFFEC,0x02}, // IRYHUE4_POS6 : +{0x6EE6,0x0000,0x02}, // IBYHUE1_POS7 : +{0x6EE8,0xFFF5,0x02}, // IRYHUE1_POS7 : +{0x6EEA,0xFFEA,0x02}, // IBYHUE2_POS7 : +{0x6EEC,0xFFF5,0x02}, // IRYHUE2_POS7 : +{0x6EEE,0xFFEA,0x02}, // IBYHUE3_POS7 : +{0x6EF0,0xFFEE,0x02}, // IRYHUE3_POS7 : +{0x6EF2,0x0000,0x02}, // IBYHUE4_POS7 : +{0x6EF4,0xFFEC,0x02}, // IRYHUE4_POS7 : +{0x6EF6,0xFFF2,0x02}, // IBYHUE1_OUT : +{0x6EF8,0x0000,0x02}, // IRYHUE1_OUT : +{0x6EFA,0xFFFA,0x02}, // IBYHUE2_OUT : +{0x6EFC,0x0000,0x02}, // IRYHUE2_OUT : +{0x6EFE,0xFFFA,0x02}, // IBYHUE3_OUT : +{0x6F00,0xFFE7,0x02}, // IRYHUE3_OUT : +{0x6F02,0xFFF2,0x02}, // IBYHUE4_OUT : +{0x6F04,0xFFE7,0x02}, // IRYHUE4_OUT : +{0x6F06,0x0000,0x02}, // IBYHUE1_R2_POS4 : +{0x6F08,0xFFF5,0x02}, // IRYHUE1_R2_POS4 : +{0x6F0A,0xFFF8,0x02}, // IBYHUE2_R2_POS4 : +{0x6F0C,0xFFF5,0x02}, // IRYHUE2_R2_POS4 : +{0x6F0E,0xFFF8,0x02}, // IBYHUE3_R2_POS4 : +{0x6F10,0xFFEE,0x02}, // IRYHUE3_R2_POS4 : +{0x6F12,0x0000,0x02}, // IBYHUE4_R2_POS4 : +{0x6F14,0xFFEC,0x02}, // IRYHUE4_R2_POS4 : +{0x6F16,0x0000,0x02}, // IBYHUE1_R2_POS5 : +{0x6F18,0xFFF5,0x02}, // IRYHUE1_R2_POS5 : +{0x6F1A,0xFFF8,0x02}, // IBYHUE2_R2_POS5 : +{0x6F1C,0xFFF5,0x02}, // IRYHUE2_R2_POS5 : +{0x6F1E,0xFFF8,0x02}, // IBYHUE3_R2_POS5 : +{0x6F20,0xFFEE,0x02}, // IRYHUE3_R2_POS5 : +{0x6F22,0x0000,0x02}, // IBYHUE4_R2_POS5 : +{0x6F24,0xFFEC,0x02}, // IRYHUE4_R2_POS5 : +{0x6F26,0x4B,0x01}, // IRYGAIN1_POS1 : +{0x6F27,0x50,0x01}, // IBYGAIN1_POS1 : +{0x6F28,0x4B,0x01}, // IRYGAIN2_POS1 : +{0x6F29,0x57,0x01}, // IBYGAIN2_POS1 : +{0x6F2A,0x56,0x01}, // IRYGAIN3_POS1 : +{0x6F2B,0x57,0x01}, // IBYGAIN3_POS1 : +{0x6F2C,0x56,0x01}, // IRYGAIN4_POS1 : +{0x6F2D,0x50,0x01}, // IBYGAIN4_POS1 : +{0x6F2E,0x4B,0x01}, // IRYGAIN1_POS2 : +{0x6F2F,0x50,0x01}, // IBYGAIN1_POS2 : +{0x6F30,0x4B,0x01}, // IRYGAIN2_POS2 : +{0x6F31,0x57,0x01}, // IBYGAIN2_POS2 : +{0x6F32,0x54,0x01}, // IRYGAIN3_POS2 : +{0x6F33,0x57,0x01}, // IBYGAIN3_POS2 : +{0x6F34,0x54,0x01}, // IRYGAIN4_POS2 : +{0x6F35,0x50,0x01}, // IBYGAIN4_POS2 : +{0x6F36,0x4B,0x01}, // IRYGAIN1_POS3 : +{0x6F37,0x50,0x01}, // IBYGAIN1_POS3 : +{0x6F38,0x4B,0x01}, // IRYGAIN2_POS3 : +{0x6F39,0x57,0x01}, // IBYGAIN2_POS3 : +{0x6F3A,0x50,0x01}, // IRYGAIN3_POS3 : +{0x6F3B,0x57,0x01}, // IBYGAIN3_POS3 : +{0x6F3C,0x50,0x01}, // IRYGAIN4_POS3 : +{0x6F3D,0x50,0x01}, // IBYGAIN4_POS3 : +{0x6F3E,0x4B,0x01}, // IRYGAIN1_POS4 : +{0x6F3F,0x50,0x01}, // IBYGAIN1_POS4 : +{0x6F40,0x4B,0x01}, // IRYGAIN2_POS4 : +{0x6F41,0x57,0x01}, // IBYGAIN2_POS4 : +{0x6F42,0x50,0x01}, // IRYGAIN3_POS4 : +{0x6F43,0x57,0x01}, // IBYGAIN3_POS4 : +{0x6F44,0x50,0x01}, // IRYGAIN4_POS4 : +{0x6F45,0x50,0x01}, // IBYGAIN4_POS4 : +{0x6F46,0x4B,0x01}, // IRYGAIN1_POS5 : +{0x6F47,0x50,0x01}, // IBYGAIN1_POS5 : +{0x6F48,0x4B,0x01}, // IRYGAIN2_POS5 : +{0x6F49,0x57,0x01}, // IBYGAIN2_POS5 : +{0x6F4A,0x50,0x01}, // IRYGAIN3_POS5 : +{0x6F4B,0x57,0x01}, // IBYGAIN3_POS5 : +{0x6F4C,0x50,0x01}, // IRYGAIN4_POS5 : +{0x6F4D,0x50,0x01}, // IBYGAIN4_POS5 : +{0x6F4E,0x4B,0x01}, // IRYGAIN1_POS6 : +{0x6F4F,0x50,0x01}, // IBYGAIN1_POS6 : +{0x6F50,0x4B,0x01}, // IRYGAIN2_POS6 : +{0x6F51,0x57,0x01}, // IBYGAIN2_POS6 : +{0x6F52,0x50,0x01}, // IRYGAIN3_POS6 : +{0x6F53,0x57,0x01}, // IBYGAIN3_POS6 : +{0x6F54,0x50,0x01}, // IRYGAIN4_POS6 : +{0x6F55,0x50,0x01}, // IBYGAIN4_POS6 : +{0x6F56,0x4B,0x01}, // IRYGAIN1_POS7 : +{0x6F57,0x50,0x01}, // IBYGAIN1_POS7 : +{0x6F58,0x4B,0x01}, // IRYGAIN2_POS7 : +{0x6F59,0x57,0x01}, // IBYGAIN2_POS7 : +{0x6F5A,0x50,0x01}, // IRYGAIN3_POS7 : +{0x6F5B,0x57,0x01}, // IBYGAIN3_POS7 : +{0x6F5C,0x50,0x01}, // IRYGAIN4_POS7 : +{0x6F5D,0x50,0x01}, // IBYGAIN4_POS7 : +{0x6F5E,0x50,0x01}, // IRYGAIN1_OUT : +{0x6F5F,0x5A,0x01}, // IBYGAIN1_OUT : +{0x6F60,0x50,0x01}, // IRYGAIN2_OUT : +{0x6F61,0x51,0x01}, // IBYGAIN2_OUT : +{0x6F62,0x64,0x01}, // IRYGAIN3_OUT : +{0x6F63,0x51,0x01}, // IBYGAIN3_OUT : +{0x6F64,0x64,0x01}, // IRYGAIN4_OUT : +{0x6F65,0x5A,0x01}, // IBYGAIN4_OUT : +{0x6F66,0x4B,0x01}, // IRYGAIN1_R2_POS4 : +{0x6F67,0x50,0x01}, // IBYGAIN1_R2_POS4 : +{0x6F68,0x4B,0x01}, // IRYGAIN2_R2_POS4 : +{0x6F69,0x57,0x01}, // IBYGAIN2_R2_POS4 : +{0x6F6A,0x50,0x01}, // IRYGAIN3_R2_POS4 : +{0x6F6B,0x57,0x01}, // IBYGAIN3_R2_POS4 : +{0x6F6C,0x50,0x01}, // IRYGAIN4_R2_POS4 : +{0x6F6D,0x50,0x01}, // IBYGAIN4_R2_POS4 : +{0x6F6E,0x4B,0x01}, // IRYGAIN1_R2_POS5 : +{0x6F6F,0x50,0x01}, // IBYGAIN1_R2_POS5 : +{0x6F70,0x4B,0x01}, // IRYGAIN2_R2_POS5 : +{0x6F71,0x57,0x01}, // IBYGAIN2_R2_POS5 : +{0x6F72,0x50,0x01}, // IRYGAIN3_R2_POS5 : +{0x6F73,0x57,0x01}, // IBYGAIN3_R2_POS5 : +{0x6F74,0x50,0x01}, // IRYGAIN4_R2_POS5 : +{0x6F75,0x50,0x01}, // IBYGAIN4_R2_POS5 : + + +//LMT outdoor setting +{0x6E54,0xFFB1,0x02}, // LM_GRG_OUT : +{0x6E56,0x0015,0x02}, // LM_GRB_OUT : +{0x6E58,0xFFE5,0x02}, // LM_GGR_OUT : +{0x6E5A,0xFFFA,0x02}, // LM_GGB_OUT : +{0x6E5C,0xFFDA,0x02}, // LM_GBR_OUT : +{0x6E5E,0xFFE9,0x02}, // LM_GBG_OUT : + +//MC3 ON&OFF +{0x6C49,0xF5,0x01}, // MAIN_CONFIG4 : + + +//////////////////////////////////////////////////////////////// + +{0x941F,0x00,0x01}, // AP_N_GC_POS_CORE_A : <<N´ë¿ª Coring ¾ç¼öÃø Äھ ¹üÀ§ A¼³Á¤°ª +{0x9420,0x00,0x01}, // AP_N_GC_POS_CORE_B : +{0x9421,0x02,0x01}, // AP_N_GC_POS_CORE_C1 : +{0x9422,0x01,0x01}, // AP_N_GC_POS_CORE_C2 : +{0x9423,0x20,0x01}, // AP_N_GC_POS_SLOPE_A : <<N´ë¿ª Coring ¾ç¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x9424,0x0D,0x01}, // AP_N_GC_POS_SLOPE_B : +{0x9425,0x0F,0x01}, // AP_N_GC_POS_SLOPE_C1 : +{0x9426,0x08,0x01}, // AP_N_GC_POS_SLOPE_C2 : +{0x9427,0x00,0x01}, // AP_N_GC_NEG_CORE_A : <<N´ë¿ª Coring À½¼öÃøÄھ¹üÀ§ A¼³Á¤°ª +{0x9428,0x00,0x01}, // AP_N_GC_NEG_CORE_B : +{0x9429,0x02,0x01}, // AP_N_GC_NEG_CORE_C1 : +{0x942A,0x01,0x01}, // AP_N_GC_NEG_CORE_C2 : +{0x942B,0x20,0x01}, // AP_N_GC_NEG_SLOPE_A : <<N´ë¿ª Coring À½¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x942C,0x13,0x01}, // AP_N_GC_NEG_SLOPE_B : +{0x942D,0x10,0x01}, // AP_N_GC_NEG_SLOPE_C1 : +{0x942E,0x08,0x01}, // AP_N_GC_NEG_SLOPE_C2 : +{0x942F,0x20,0x01}, // AP_N_GAIN_POS_A : <<N´ë¿ª POST Gain ¾ç¼öÃø A¼³Á¤°ª +{0x9430,0x3C,0x01}, // AP_N_GAIN_POS_B : +{0x9431,0x33,0x01}, // AP_N_GAIN_POS_C1 : +{0x9432,0x30,0x01}, // AP_N_GAIN_POS_C2 : +{0x9433,0x20,0x01}, // AP_N_GAIN_NEG_A : <<N´ë¿ª POST Gain À½¼öÃø A¼³Á¤°ª +{0x9434,0x48,0x01}, // AP_N_GAIN_NEG_B : +{0x9435,0x37,0x01}, // AP_N_GAIN_NEG_C1 : +{0x9436,0x38,0x01}, // AP_N_GAIN_NEG_C2 : +//////////////////////////////////////////////////////////////// + +{0x9437,0x01,0x01}, // AP_H_GC_POS_CORE_A : <<H´ë¿ª Coring ¾ç¼öÃøÄھ¹üÀ§ A¼³Á¤°ª +{0x9438,0x01,0x01}, // AP_H_GC_POS_CORE_B : +{0x9439,0x00,0x01}, // AP_H_GC_POS_CORE_C1 : +{0x943A,0x00,0x01}, // AP_H_GC_POS_CORE_C2 : +{0x943B,0x38,0x01}, // AP_H_GC_POS_SLOPE_A : <<H´ë¿ª Coring ¾ç¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x943C,0x3F,0x01}, // AP_H_GC_POS_SLOPE_B : +{0x943D,0x30,0x01}, // AP_H_GC_POS_SLOPE_C1 : +{0x943E,0x13,0x01}, // AP_H_GC_POS_SLOPE_C2 : +{0x943F,0x00,0x01}, // AP_H_GC_NEG_CORE_A : <<H´ë¿ª Coring À½¼öÃøÄھ¹üÀ§ A¼³Á¤°ª +{0x9440,0x01,0x01}, // AP_H_GC_NEG_CORE_B : +{0x9441,0x00,0x01}, // AP_H_GC_NEG_CORE_C1 : +{0x9442,0x00,0x01}, // AP_H_GC_NEG_CORE_C2 : +{0x9443,0x38,0x01}, // AP_H_GC_NEG_SLOPE_A : <<H´ë¿ª Coring À½¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x9444,0x09,0x01}, // AP_H_GC_NEG_SLOPE_B : +{0x9445,0x2D,0x01}, // AP_H_GC_NEG_SLOPE_C1 : +{0x9446,0x0A,0x01}, // AP_H_GC_NEG_SLOPE_C2 : +{0x9447,0x50,0x01}, // AP_H_GAIN_POS_A : <<H´ë¿ª POST Gain ¾ç¼öÃø A¼³Á¤°ª +{0x9448,0x38,0x01}, // AP_H_GAIN_POS_B : +{0x9449,0x72,0x01}, // AP_H_GAIN_POS_C1 : +{0x944A,0x72,0x01}, // AP_H_GAIN_POS_C2 : +{0x944B,0x50,0x01}, // AP_H_GAIN_NEG_A : <<H´ë¿ª POST Gain À½¼öÃø A¼³Á¤°ª +{0x944C,0x40,0x01}, // AP_H_GAIN_NEG_B : +{0x944D,0x66,0x01}, // AP_H_GAIN_NEG_C1 : +{0x944E,0x96,0x01}, // AP_H_GAIN_NEG_C2 : +{0x944F,0x01,0x01}, // AP_L_GC_POS_CORE_A : <<L´ë¿ª Coring ¾ç¼öÃøÄھ¹üÀ§ A¼³Á¤°ª +{0x9450,0x00,0x01}, // AP_L_GC_POS_CORE_B : +{0x9451,0x00,0x01}, // AP_L_GC_POS_CORE_C1 : +{0x9452,0x04,0x01}, // AP_L_GC_POS_CORE_C2 +{0x9453,0x24,0x01}, // AP_L_GC_POS_SLOPE_A : <<L´ë¿ª Coring ¾ç¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x9454,0x20,0x01}, // AP_L_GC_POS_SLOPE_B : +{0x9455,0x08,0x01}, // AP_L_GC_POS_SLOPE_C1 : +{0x9456,0x08,0x01}, // AP_L_GC_POS_SLOPE_C2 : +{0x9457,0x01,0x01}, // AP_L_GC_NEG_CORE_A : <L´ë¿ª Coring À½¼öÃøÄھ¹üÀ§ A¼³Á¤°ª +{0x9458,0x00,0x01}, // AP_L_GC_NEG_CORE_B : +{0x9459,0x00,0x01}, // AP_L_GC_NEG_CORE_C1 +{0x945A,0x04,0x01}, // AP_L_GC_NEG_CORE_C2 +{0x945B,0x24,0x01}, // AP_L_GC_NEG_SLOPE_A : <<L´ë¿ª Coring À½¼öÃø °íÁøÆøÂÊ ±â¿ï±â A¼³Á¤°ª +{0x945C,0x20,0x01}, // AP_L_GC_NEG_SLOPE_B : +{0x945D,0x04,0x01}, // AP_L_GC_NEG_SLOPE_C1 : +{0x945E,0x04,0x01}, // AP_L_GC_NEG_SLOPE_C2 : +{0x945F,0x0A,0x01}, // AP_L_GAIN_POS_A : <<L´ë¿ª POST Gain ¾ç¼öÃø A¼³Á¤°ª +{0x9460,0x11,0x01}, // AP_L_GAIN_POS_B : +{0x9461,0x1C,0x01}, // AP_L_GAIN_POS_C1 : +{0x9462,0x60,0x01}, // AP_L_GAIN_POS_C2 : +{0x9463,0x08,0x01}, // AP_L_GAIN_NEG_A : <<L´ë¿ª POST Gain À½¼öÃø A¼³Á¤°ª +{0x9464,0x0B,0x01}, // AP_L_GAIN_NEG_B : +{0x9465,0x0A,0x01}, // AP_L_GAIN_NEG_C1 : +{0x9466,0x20,0x01}, // AP_L_GAIN_NEG_C2 : +//////////////////////////////////////////////////////////////// +{0x9468,0x0200,0x02}, // AP_N_GC_POS_TH_A : <<N´ë¿ª Coring ¾ç¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x946A,0x00C0,0x02}, // AP_N_GC_POS_TH_B : +{0x946C,0x0168,0x02}, // AP_N_GC_POS_TH_C1 : +{0x946E,0x0168,0x02}, // AP_N_GC_POS_TH_C2 : +{0x9470,0x0200,0x02}, // AP_N_GC_NEG_TH_A : <<N´ë¿ª Coring À½¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x9472,0x00C0,0x02}, // AP_N_GC_NEG_TH_B : +{0x9474,0x00B4,0x02}, // AP_N_GC_NEG_TH_C1 : +{0x9476,0x00B4,0x02}, // AP_N_GC_NEG_TH_C2 : +{0x9478,0x0000,0x02}, // AP_N_LD_DARK_TH_A : <<£Î´ë¿ª LevelDepend ÀúÈÖµµ ÀÓ°èÄ¡ A¼³Á¤°ª +{0x947A,0x0000,0x02}, // AP_N_LD_DARK_TH_B : +{0x947C,0x0000,0x02}, // AP_N_LD_DARK_TH_C1 : +{0x947E,0x0000,0x02}, // AP_N_LD_DARK_TH_C2 : +{0x9480,0x0096,0x02}, // AP_N_LD_HIGH_TH0_X_A: <<£Î´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0 A¼³Á¤°ª +{0x9482,0x0050,0x02}, // AP_N_LD_HIGH_TH0_X_B : +{0x9484,0x0050,0x02}, // AP_N_LD_HIGH_TH0_X_C1 : +{0x9486,0x0050,0x02}, // AP_N_LD_HIGH_TH0_X_C2 : +{0x9488,0x0080,0x02}, // AP_N_LD_HIGH_TH0_Y_A : <<£Î´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0¿¡¼ÀÇ Ãâ·Â Gain A¼³Á¤°ª +{0x948A,0x0080,0x02}, // AP_N_LD_HIGH_TH0_Y_B : +{0x948C,0x0080,0x02}, // AP_N_LD_HIGH_TH0_Y_C1 : +{0x948E,0x0080,0x02}, // AP_N_LD_HIGH_TH0_Y_C2 : +{0x9490,0x00C8,0x02}, // AP_N_LD_HIGH_TH1_X_A : <<N´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡1 A¼³Á¤°ª +{0x9492,0x012C,0x02}, // AP_N_LD_HIGH_TH1_X_B : +{0x9494,0x00C8,0x02}, // AP_N_LD_HIGH_TH1_X_C1 : +{0x9496,0x00C8,0x02}, // AP_N_LD_HIGH_TH1_X_C2 +{0x9498,0x01F4,0x02}, // AP_N_LD_HIGH_TH2_X_A : <<N´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡2 A¼³Á¤°ª +{0x949A,0x0200,0x02}, // AP_N_LD_HIGH_TH2_X_B : +{0x949C,0x0200,0x02}, // AP_N_LD_HIGH_TH2_X_C1 : +{0x949E,0x0200,0x02}, // AP_N_LD_HIGH_TH2_X_C2 : +//////////////////////////////////////////////////////////////// + +{0x94A0,0x0050,0x02}, // AP_H_GC_POS_TH_A : <<H´ë¿ª Coring ¾ç¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94A2,0x00A0,0x02}, // AP_H_GC_POS_TH_B : +{0x94A4,0x0033,0x02}, // AP_H_GC_POS_TH_C1 : +{0x94A6,0x0033,0x02}, // AP_H_GC_POS_TH_C2 : +{0x94A8,0x0050,0x02}, // AP_H_GC_NEG_TH_A : <<H´ë¿ª Coring À½¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94AA,0x00A0,0x02}, // AP_H_GC_NEG_TH_B : +{0x94AC,0x0033,0x02}, // AP_H_GC_NEG_TH_C1 : +{0x94AE,0x0033,0x02}, // AP_H_GC_NEG_TH_C2 : +{0x94B0,0x0021,0x02}, // AP_H_LD_DARK_TH_A : <<H´ë¿ª LevelDepend ÀúÈÖµµ ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94B2,0x0000,0x02}, // AP_H_LD_DARK_TH_B : +{0x94B4,0x0000,0x02}, // AP_H_LD_DARK_TH_C1 : +{0x94B6,0x0000,0x02}, // AP_H_LD_DARK_TH_C2 +{0x94B8,0x01F4,0x02}, // AP_H_LD_HIGH_TH0_X_A : <<H´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0 A¼³Á¤°ª +{0x94BA,0x0083,0x02}, // AP_H_LD_HIGH_TH0_X_B : +{0x94BC,0x0064,0x02}, // AP_H_LD_HIGH_TH0_X_C1 : +{0x94BE,0x0064,0x02}, // AP_H_LD_HIGH_TH0_X_C2 : +{0x94C0,0x0080,0x02}, // AP_H_LD_HIGH_TH0_Y_A : <<H´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0¿¡¼ÀÇ Ãâ·Â Gain A¼³Á¤°ª +{0x94C2,0x0080,0x02}, // AP_H_LD_HIGH_TH0_Y_B : +{0x94C4,0x0080,0x02}, // AP_H_LD_HIGH_TH0_Y_C1 : +{0x94C6,0x0080,0x02}, // AP_H_LD_HIGH_TH0_Y_C2 : +{0x94C8,0x0244,0x02}, // AP_H_LD_HIGH_TH1_X_A : <<H´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡1 A¼³Á¤ +{0x94CA,0x01AA,0x02}, // AP_H_LD_HIGH_TH1_X_B : +{0x94CC,0x00C8,0x02}, // AP_H_LD_HIGH_TH1_X_C1 : +{0x94CE,0x00C8,0x02}, // AP_H_LD_HIGH_TH1_X_C2 : +{0x94D0,0x02EC,0x02}, // AP_H_LD_HIGH_TH2_X_A : <<H´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡2 A¼³Á¤°ª +{0x94D2,0x01EF,0x02}, // AP_H_LD_HIGH_TH2_X_B : +{0x94D4,0x01E0,0x02}, // AP_H_LD_HIGH_TH2_X_C1 : +{0x94D6,0x01E0,0x02}, // AP_H_LD_HIGH_TH2_X_C2 : +{0x94D8,0x0001,0x02}, // AP_L_GC_POS_TH_A : <<L´ë¿ª Coring ¾ç¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94DA,0x0040,0x02}, // AP_L_GC_POS_TH_B : +{0x94DC,0x0010,0x02}, // AP_L_GC_POS_TH_C1 : +{0x94DE,0x0010,0x02}, // AP_L_GC_POS_TH_C2 : +{0x94E0,0x0001,0x02}, // AP_L_GC_NEG_TH_A : <<L´ë¿ª Coring À½¼öÃø °íÁøÆø ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94E2,0x0030,0x02}, // AP_L_GC_NEG_TH_B : +{0x94E4,0x0020,0x02}, // AP_L_GC_NEG_TH_C1 : +{0x94E6,0x0020,0x02}, // AP_L_GC_NEG_TH_C2 : +{0x94E8,0x0000,0x02}, // AP_L_LD_DARK_TH_A : <<L´ë¿ª LevelDepend ÀúÈÖµµ ÀÓ°èÄ¡ A¼³Á¤°ª +{0x94EA,0x0000,0x02}, // AP_L_LD_DARK_TH_B : +{0x94EC,0x0000,0x02}, // AP_L_LD_DARK_TH_C1 : +{0x94EE,0x0000,0x02}, // AP_L_LD_DARK_TH_C2 : +{0x94F0,0x015E,0x02}, // AP_L_LD_HIGH_TH0_X_A : <<L´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0 A¼³Á¤°ª +{0x94F2,0x015E,0x02}, // AP_L_LD_HIGH_TH0_X_B : +{0x94F4,0x0010,0x02}, // AP_L_LD_HIGH_TH0_X_C1 : +{0x94F6,0x0010,0x02}, // AP_L_LD_HIGH_TH0_X_C2 : +{0x94F8,0x0080,0x02}, // AP_L_LD_HIGH_TH0_Y_A : <<L´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡0¿¡¼ÀÇ Ãâ·Â Gain A¼³Á¤°ª +{0x94FA,0x0080,0x02}, // AP_L_LD_HIGH_TH0_Y_B : +{0x94FC,0x0080,0x02}, // AP_L_LD_HIGH_TH0_Y_C1 : +{0x94FE,0x0080,0x02}, // AP_L_LD_HIGH_TH0_Y_C2 : +{0x9500,0x0226,0x02}, // AP_L_LD_HIGH_TH1_X_A : <<L´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡1 A¼³Á¤°ª +{0x9502,0x0226,0x02}, // AP_L_LD_HIGH_TH1_X_B : +{0x9504,0x0020,0x02}, // AP_L_LD_HIGH_TH1_X_C1 : +{0x9506,0x0020,0x02}, // AP_L_LD_HIGH_TH1_X_C2 : +{0x9508,0x02A2,0x02}, // AP_L_LD_HIGH_TH2_X_A : <<L´ë¿ª LevelDepend °íÈÖµµ ÀÓ°èÄ¡2 A¼³Á¤°ª +{0x950A,0x028A,0x02}, // AP_L_LD_HIGH_TH2_X_B : +{0x950C,0x0050,0x02}, // AP_L_LD_HIGH_TH2_X_C1 : +{0x950E,0x0050,0x02}, // AP_L_LD_HIGH_TH2_X_C2 : + +//blendÈÄ ¸®¹ÌÆ® ¼³Á¤ + +{0x9510,0x0020,0x02}, // AP_POST_LIM_POS_A : << +{0x9512,0x0060,0x02}, // AP_POST_LIM_POS_B : +{0x9514,0x0060,0x02}, // AP_POST_LIM_POS_C1 : +{0x9516,0x0060,0x02}, // AP_POST_LIM_POS_C2 : +{0x9518,0x0030,0x02}, // AP_POST_LIM_NEG_A : << +{0x951A,0x0048,0x02}, // AP_POST_LIM_NEG_B : +{0x951C,0x0048,0x02}, // AP_POST_LIM_NEG_C1 : +{0x951E,0x0048,0x02}, // AP_POST_LIM_NEG_C2 : +{0x9520,0x0000,0x02}, // AP_POST_CORE_POS_A : << +{0x9522,0x0000,0x02}, // AP_POST_CORE_POS_B : +{0x9524,0x0001,0x02}, // AP_POST_CORE_POS_C1 : +{0x9526,0x0001,0x02}, // AP_POST_CORE_POS_C2 : +{0x9528,0x0002,0x02}, // AP_POST_CORE_NEG_A : < +{0x952A,0x0000,0x02}, // AP_POST_CORE_NEG_B : +{0x952C,0x0000,0x02}, // AP_POST_CORE_NEG_C1 : +{0x952E,0x0000,0x02}, // AP_POST_CORE_NEG_C2 : + +//level defender ¼³Á¤ + +{0x9530,0x0000,0x02}, // AP_N_LD_DARK_SLOPE_A : << N´ë¿ª LevelDepend ÀúÈÖµµÂÊ ±â¿ï±â A¼³Á¤°ª +{0x9532,0x0000,0x02}, +{0x9534,0x0000,0x02}, // AP_N_LD_DARK_SLOPE_B : +{0x9536,0x0000,0x02}, +{0x9538,0x0000,0x02}, // AP_N_LD_DARK_SLOPE_C1 : +{0x953A,0x0000,0x02}, +{0x953C,0x0000,0x02}, // AP_N_LD_DARK_SLOPE_C2 : +{0x953E,0x0000,0x02}, +{0x9540,0x0061,0x02}, // AP_N_LD_HIGH_SLOPE0_A : << N´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡0¢¦ÀÓ°èÄ¡1¿¡¼ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x9542,0x0000,0x02}, +{0x9544,0x0031,0x02}, // AP_N_LD_HIGH_SLOPE0_B : +{0x9546,0x0000,0x02}, +{0x9548,0x0000,0x02}, // AP_N_LD_HIGH_SLOPE0_C1 : +{0x954A,0x0000,0x02}, +{0x954C,0x0000,0x02}, // AP_N_LD_HIGH_SLOPE0_C2 : +{0x954E,0x0000,0x02}, +{0x9550,0x001C,0x02}, // AP_N_LD_HIGH_SLOPE1_A : <<N´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡1¢¦ÀÓ°èÄ¡2¿¡¼ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x9552,0x0000,0x02}, +{0x9554,0x000C,0x02}, // AP_N_LD_HIGH_SLOPE1_B : +{0x9556,0x0000,0x02}, +{0x9558,0x001A,0x02}, // AP_N_LD_HIGH_SLOPE1_C1 : +{0x955A,0x0000,0x02}, +{0x955C,0x001A,0x02}, // AP_N_LD_HIGH_SLOPE1_C2 : +{0x955E,0x0000,0x02}, +{0x9560,0x0000,0x02}, // AP_N_LD_HIGH_SLOPE2_A : <<N´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡2ì¤Ë½ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x9562,0x0000,0x02}, +{0x9564,0x0005,0x02}, // AP_N_LD_HIGH_SLOPE2_B : +{0x9566,0x0000,0x02}, +{0x9568,0x0014,0x02}, // AP_N_LD_HIGH_SLOPE2_C1 : +{0x956A,0x0000,0x02}, +{0x956C,0x0014,0x02}, // AP_N_LD_HIGH_SLOPE2_C2 : +{0x956E,0x0000,0x02}, +{0x9570,0x0000,0x02}, // AP_H_LD_DARK_SLOPE_A : <<H´ë¿ª LevelDepend ÀúÈÖµµÂÊ ±â¿ï±â A¼³Á¤°ª +{0x9572,0x0000,0x02}, +{0x9574,0x0000,0x02}, // AP_H_LD_DARK_SLOPE_B : +{0x9576,0x0000,0x02}, +{0x9578,0x0000,0x02}, // AP_H_LD_DARK_SLOPE_C1 : +{0x957A,0x0000,0x02}, +{0x957C,0x0000,0x02}, // AP_H_LD_DARK_SLOPE_C2 : +{0x957E,0x0000,0x02}, +{0x9580,0x0025,0x02}, // AP_H_LD_HIGH_SLOPE0_A : <<H´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡0¢¦ÀÓ°èÄ¡1¿¡¼ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x9582,0x0000,0x02}, +{0x9584,0x0025,0x02}, // AP_H_LD_HIGH_SLOPE0_B : +{0x9586,0x0000,0x02}, +{0x9588,0x0064,0x02}, // AP_H_LD_HIGH_SLOPE0_C1 : +{0x958A,0x0000,0x02}, +{0x958C,0x004D,0x02}, // AP_H_LD_HIGH_SLOPE0_C2 : +{0x958E,0x0000,0x02}, +{0x9590,0x0050,0x02}, // AP_H_LD_HIGH_SLOPE1_A : <<H´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡1¢¦ÀÓ°èÄ¡2¿¡¼ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x9592,0x0000,0x02}, +{0x9594,0x0050,0x02}, // AP_H_LD_HIGH_SLOPE1_B : +{0x9596,0x0000,0x02}, +{0x9598,0x0004,0x02}, // AP_H_LD_HIGH_SLOPE1_C1 : +{0x959A,0x0000,0x02}, +{0x959C,0x000C,0x02}, // AP_H_LD_HIGH_SLOPE1_C2 : +{0x959E,0x0000,0x02}, +{0x95A0,0x0000,0x02}, // AP_H_LD_HIGH_SLOPE2_A : <<H´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡2ì¤Ë½ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x95A2,0x0000,0x02}, +{0x95A4,0x0000,0x02}, // AP_H_LD_HIGH_SLOPE2_B : +{0x95A6,0x0000,0x02}, +{0x95A8,0x000D,0x02}, // AP_H_LD_HIGH_SLOPE2_C1 : +{0x95AA,0x0000,0x02}, +{0x95AC,0x000D,0x02}, // AP_H_LD_HIGH_SLOPE2_C2 : +{0x95AE,0x0000,0x02}, +{0x95B0,0x0000,0x02}, // AP_L_LD_DARK_SLOPE_A : <<L´ë¿ª LevelDepend ÀúÈÖµµÂÊ ±â¿ï±â A¼³Á¤°ª +{0x95B2,0x0000,0x02}, +{0x95B4,0x0000,0x02}, // AP_L_LD_DARK_SLOPE_B : +{0x95B6,0x0000,0x02}, +{0x95B8,0x0000,0x02}, // AP_L_LD_DARK_SLOPE_C1 : +{0x95BA,0x0000,0x02}, +{0x95BC,0x0000,0x02}, // AP_L_LD_DARK_SLOPE_C2 : +{0x95BE,0x0000,0x02}, +{0x95C0,0x0020,0x02}, // AP_L_LD_HIGH_SLOPE0_A : <<L´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡0¢¦ÀÓ°èÄ¡1¿¡¼ÀÇ ±â¿ï±â A¼³Á¤ +{0x95C2,0x0000,0x02}, +{0x95C4,0x0023,0x02}, // AP_L_LD_HIGH_SLOPE0_B : +{0x95C6,0x0000,0x02}, +{0x95C8,0x012C,0x02}, // AP_L_LD_HIGH_SLOPE0_C1 : +{0x95CA,0x0000,0x02}, +{0x95CC,0x012C,0x02}, // AP_L_LD_HIGH_SLOPE0_C2 : +{0x95CE,0x0000,0x02}, +{0x95D0,0x0051,0x02}, // AP_L_LD_HIGH_SLOPE1_A : <<L´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡1¢¦ÀÓ°èÄ¡2¿¡¼ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x95D2,0x0000,0x02}, +{0x95D4,0x0050,0x02}, // AP_L_LD_HIGH_SLOPE1_B : +{0x95D6,0x0000,0x02}, +{0x95D8,0x0058,0x02}, // AP_L_LD_HIGH_SLOPE1_C1 : +{0x95DA,0x0000,0x02}, +{0x95DC,0x0058,0x02}, // AP_L_LD_HIGH_SLOPE1_C2 : +{0x95DE,0x0000,0x02}, +{0x95E0,0x0000,0x02}, // AP_L_LD_HIGH_SLOPE2_A : <<L´ë¿ª LevelDepend °íÈÖµµÂÊ ÀÓ°èÄ¡2ì¤Ë½ÀÇ ±â¿ï±â A¼³Á¤°ª +{0x95E2,0x0000,0x02}, +{0x95E4,0x0050,0x02}, // AP_L_LD_HIGH_SLOPE2_B : +{0x95E6,0x0000,0x02}, +{0x95E8,0x002A,0x02}, // AP_L_LD_HIGH_SLOPE2_C1 : +{0x95EA,0x0000,0x02}, +{0x95EC,0x002A,0x02}, // AP_L_LD_HIGH_SLOPE2_C2 : +{0x95EE,0x0000,0x02}, + +//C-sup tuning +{0x6C47,0x0F,0x01}, // MAIN_CONFIG2 : +{0x6C48,0x03,0x01}, // MAIN_CONFIG3 : +{0x9805,0x0A,0x01}, // CS_SLP_C_A : +{0x9806,0x0A,0x01}, // CS_SLP_C_B : +{0x9807,0x0A,0x01}, // CS_SLP_C_C : +{0x9808,0x20,0x01}, // CS_SLP_YC_A : +{0x9809,0x20,0x01}, // CS_SLP_YC_B : +{0x980A,0x20,0x01}, // CS_SLP_YC_C : +{0x980B,0x20,0x01}, // CS_SLP_Y_A : +{0x980C,0x20,0x01}, // CS_SLP_Y_B : +{0x980D,0x20,0x01}, // CS_SLP_Y_C : +{0x980E,0x14,0x01}, // CS_CBHLEV_A : +{0x980F,0x14,0x01}, // CS_CBHLEV_B : +{0x9810,0x14,0x01}, // CS_CBHLEV_C : +{0x9811,0x14,0x01}, // CS_CRHLEV_A : +{0x9812,0x14,0x01}, // CS_CRHLEV_B : +{0x9813,0x14,0x01}, // CS_CRHLEV_C : +{0x9802,0x77,0x01}, // CS_YHCOEF_A : +{0x9803,0x77,0x01}, // CS_YHCOEF_B : +{0x9804,0x77,0x01}, // CS_YHCOEF_C : +{0x9808,0x20,0x01}, // CS_SLP_YC_A : +{0x9809,0x20,0x01}, // CS_SLP_YC_B : +{0x980A,0x20,0x01}, // CS_SLP_YC_C : +{0x980B,0x20,0x01}, // CS_SLP_Y_A : +{0x980C,0x20,0x01}, // CS_SLP_Y_B : +{0x980D,0x20,0x01}, // CS_SLP_Y_C : +{0x9814,0x14,0x01}, // CS_CBHLEV_Y_A : +{0x9815,0x14,0x01}, // CS_CBHLEV_Y_B : +{0x9816,0x14,0x01}, // CS_CBHLEV_Y_C : +{0x9817,0x00,0x01}, // CS_CRHLEV_Y_A : +{0x9818,0x00,0x01}, // CS_CRHLEV_Y_B : +{0x9819,0x00,0x01}, // CS_CRHLEV_Y_C : +{0x9836,0x0000,0x02}, // CS_CBLLEV_Y_A : +{0x9838,0x0000,0x02}, // CS_CBLLEV_Y_B : +{0x983A,0x0000,0x02}, // CS_CBLLEV_Y_C : +{0x983C,0xFFEC,0x02}, // CS_CRLLEV_Y_A : +{0x983E,0xFFEC,0x02}, // CS_CRLLEV_Y_B : +{0x9840,0xFFEC,0x02}, // CS_CRLLEV_Y_C : +{0x981A,0x03,0x01}, // CS_SLP_YC_L_A : +{0x981B,0x03,0x01}, // CS_SLP_YC_L_B : +{0x981C,0x03,0x01}, // CS_SLP_YC_L_C : +{0x981D,0x32,0x01}, // CS_SLP_Y_L_A : +{0x981E,0x20,0x01}, // CS_SLP_Y_L_B : +{0x981F,0x20,0x01}, // CS_SLP_Y_L_C : +{0x9820,0x1E,0x01}, // CS_YLCOEF_A : +{0x9821,0x1E,0x01}, // CS_YLCOEF_B : +{0x9822,0x1E,0x01}, // CS_YLCOEF_C : +{0x9823,0x32,0x01}, // CS_CBHLEV_Y_L_A : +{0x9824,0x32,0x01}, // CS_CBHLEV_Y_L_B : +{0x9825,0x32,0x01}, // CS_CBHLEV_Y_L_C : +{0x9826,0x32,0x01}, // CS_CRHLEV_Y_L_A : +{0x9827,0x32,0x01}, // CS_CRHLEV_Y_L_B : +{0x9828,0x32,0x01}, // CS_CRHLEV_Y_L_C : +{0x982A,0xFFEC,0x02}, // CS_CBLLEV_A : +{0x982C,0xFFEC,0x02}, // CS_CBLLEV_B : +{0x982E,0xFFEC,0x02}, // CS_CBLLEV_C : +{0x9830,0xFFEC,0x02}, // CS_CRLLEV_A : +{0x9832,0xFFEC,0x02}, // CS_CRLLEV_B : +{0x9834,0xFFEC,0x02}, // CS_CRLLEV_C : +{0x9836,0x0000,0x02}, // CS_CBLLEV_Y_A : +{0x9838,0x0000,0x02}, // CS_CBLLEV_Y_B : +{0x983A,0x0000,0x02}, // CS_CBLLEV_Y_C : +{0x983C,0xFFEC,0x02}, // CS_CRLLEV_Y_A : +{0x983E,0xFFEC,0x02}, // CS_CRLLEV_Y_B : +{0x9840,0xFFEC,0x02}, // CS_CRLLEV_Y_C : +{0x9842,0xFFCE,0x02}, // CS_CBLLEV_Y_L_A : +{0x9844,0xFFCE,0x02}, // CS_CBLLEV_Y_L_B : +{0x9846,0xFFCE,0x02}, // CS_CBLLEV_Y_L_C : +{0x9848,0xFFCE,0x02}, // CS_CRLLEV_Y_L_A : +{0x984A,0xFFCE,0x02}, // CS_CRLLEV_Y_L_B : +{0x984C,0xFFCE,0x02}, // CS_CRLLEV_Y_L_C : + +//CNR°ü·Ã +{0x6C4A,0x07,0x01}, // MAIN_CONFIG5 : +{0x6C4C,0x190A,0x02}, // CNR_CTRL_TH_H : +{0x6C4E,0x1000,0x02}, // CNR_CTRL_TH_L : +{0x9866,0x40,0x01}, // CNR_PREHNR_GAIN_A : +{0x9867,0x00,0x01}, // CNR_PREHNR_GAIN_B : +{0x9868,0x00,0x01}, // CNR_PREHNR_GAIN_C : +{0x9869,0x32,0x01}, // CNR_NLM_TH_CR_H_A : +{0x986A,0x04,0x01}, // CNR_NLM_TH_CR_H_B : +{0x986B,0x0E,0x01}, // CNR_NLM_TH_CR_H_C : +{0x986C,0x32,0x01}, // CNR_NLM_TH_CR_L_A : +{0x986D,0x04,0x01}, // CNR_NLM_TH_CR_L_B : +{0x986E,0x0E,0x01}, // CNR_NLM_TH_CR_L_C : +{0x986F,0x32,0x01}, // CNR_NLM_TH_CR_M_H_A : +{0x9870,0x04,0x01}, // CNR_NLM_TH_CR_M_H_B : +{0x9871,0x0E,0x01}, // CNR_NLM_TH_CR_M_H_C : +{0x9872,0x32,0x01}, // CNR_NLM_TH_CR_M_L_A : +{0x9873,0x04,0x01}, // CNR_NLM_TH_CR_M_L_B : +{0x9874,0x0E,0x01}, // CNR_NLM_TH_CR_M_L_C : +{0x9875,0x32,0x01}, // CNR_NLM_TH_CB_H_A : +{0x9876,0x04,0x01}, // CNR_NLM_TH_CB_H_B : +{0x9877,0x0E,0x01}, // CNR_NLM_TH_CB_H_C : +{0x9878,0x32,0x01}, // CNR_NLM_TH_CB_L_A : +{0x9879,0x04,0x01}, // CNR_NLM_TH_CB_L_B : +{0x987A,0x0E,0x01}, // CNR_NLM_TH_CB_L_C : +{0x987B,0x32,0x01}, // CNR_NLM_TH_CB_M_H_A : +{0x987C,0x04,0x01}, // CNR_NLM_TH_CB_M_H_B : +{0x987D,0x0E,0x01}, // CNR_NLM_TH_CB_M_H_C : +{0x987E,0x32,0x01}, // CNR_NLM_TH_CB_M_L_A : +{0x987F,0x04,0x01}, // CNR_NLM_TH_CB_M_L_B : +{0x9880,0x0E,0x01}, // CNR_NLM_TH_CB_M_L_C : +{0x9881,0x7F,0x01}, // CNR_VE_TH_CR_H_A : +{0x9882,0x01,0x01}, // CNR_VE_TH_CR_H_B : +{0x9883,0x04,0x01}, // CNR_VE_TH_CR_H_C : +{0x9884,0x7F,0x01}, // CNR_VE_TH_CR_L_A : +{0x9885,0x01,0x01}, // CNR_VE_TH_CR_L_B : +{0x9886,0x04,0x01}, // CNR_VE_TH_CR_L_C : +{0x9887,0x7F,0x01}, // CNR_VE_TH_CR_M_H_A : +{0x9888,0x01,0x01}, // CNR_VE_TH_CR_M_H_B : +{0x9889,0x04,0x01}, // CNR_VE_TH_CR_M_H_C : +{0x988A,0x7F,0x01}, // CNR_VE_TH_CR_M_L_A : +{0x988B,0x01,0x01}, // CNR_VE_TH_CR_M_L_B : +{0x988C,0x04,0x01}, // CNR_VE_TH_CR_M_L_C : +{0x988D,0x7F,0x01}, // CNR_VE_TH_CB_H_A : +{0x988E,0x01,0x01}, // CNR_VE_TH_CB_H_B : +{0x988F,0x04,0x01}, // CNR_VE_TH_CB_H_C : +{0x9890,0x7F,0x01}, // CNR_VE_TH_CB_L_A : +{0x9891,0x01,0x01}, // CNR_VE_TH_CB_L_B : +{0x9892,0x04,0x01}, // CNR_VE_TH_CB_L_C : +{0x9893,0x7F,0x01}, // CNR_VE_TH_CB_M_H_A : +{0x9894,0x01,0x01}, // CNR_VE_TH_CB_M_H_B : +{0x9895,0x04,0x01}, // CNR_VE_TH_CB_M_H_C : +{0x9896,0x7F,0x01}, // CNR_VE_TH_CB_M_L_A : +{0x9897,0x01,0x01}, // CNR_VE_TH_CB_M_L_B : +{0x9898,0x04,0x01}, // CNR_VE_TH_CB_M_L_C : +{0x9881,0x7F,0x01}, // CNR_VE_TH_CR_H_A : +{0x9882,0x01,0x01}, // CNR_VE_TH_CR_H_B : +{0x9883,0x04,0x01}, // CNR_VE_TH_CR_H_C : +{0x9884,0x7F,0x01}, // CNR_VE_TH_CR_L_A : +{0x9885,0x01,0x01}, // CNR_VE_TH_CR_L_B : +{0x9886,0x04,0x01}, // CNR_VE_TH_CR_L_C : +{0x9887,0x7F,0x01}, // CNR_VE_TH_CR_M_H_A : +{0x9888,0x01,0x01}, // CNR_VE_TH_CR_M_H_B : +{0x9889,0x04,0x01}, // CNR_VE_TH_CR_M_H_C : +{0x988A,0x7F,0x01}, // CNR_VE_TH_CR_M_L_A : +{0x988B,0x01,0x01}, // CNR_VE_TH_CR_M_L_B : +{0x988C,0x04,0x01}, // CNR_VE_TH_CR_M_L_C : +{0x988D,0x7F,0x01}, // CNR_VE_TH_CB_H_A : +{0x988E,0x01,0x01}, // CNR_VE_TH_CB_H_B : +{0x988F,0x04,0x01}, // CNR_VE_TH_CB_H_C : +{0x9890,0x7F,0x01}, // CNR_VE_TH_CB_L_A : +{0x9891,0x01,0x01}, // CNR_VE_TH_CB_L_B : +{0x9892,0x04,0x01}, // CNR_VE_TH_CB_L_C : +{0x9893,0x7F,0x01}, // CNR_VE_TH_CB_M_H_A : +{0x9894,0x01,0x01}, // CNR_VE_TH_CB_M_H_B : +{0x9895,0x04,0x01}, // CNR_VE_TH_CB_M_H_C : +{0x9896,0x7F,0x01}, // CNR_VE_TH_CB_M_L_A : +{0x9897,0x01,0x01}, // CNR_VE_TH_CB_M_L_B : +{0x9898,0x04,0x01}, // CNR_VE_TH_CB_M_L_C : +{0x989A,0x0066,0x02}, // CNR_COEF_CR_H_A : +{0x989C,0x0100,0x02}, // CNR_COEF_CR_H_B : +{0x989E,0x0100,0x02}, // CNR_COEF_CR_H_C : +{0x98A0,0x0066,0x02}, // CNR_COEF_CR_L_A : +{0x98A2,0x0100,0x02}, // CNR_COEF_CR_L_B : +{0x98A4,0x0100,0x02}, // CNR_COEF_CR_L_C : +{0x98A6,0x0066,0x02}, // CNR_COEF_CR_M_H_A : +{0x98A8,0x0100,0x02}, // CNR_COEF_CR_M_H_B : +{0x98AA,0x0100,0x02}, // CNR_COEF_CR_M_H_C : +{0x98AC,0x0066,0x02}, // CNR_COEF_CR_M_L_A : +{0x98AE,0x0100,0x02}, // CNR_COEF_CR_M_L_B : +{0x98B0,0x0100,0x02}, // CNR_COEF_CR_M_L_C : +{0x98B2,0x0066,0x02}, // CNR_COEF_CB_H_A : +{0x98B4,0x0100,0x02}, // CNR_COEF_CB_H_B : +{0x98B6,0x0100,0x02}, // CNR_COEF_CB_H_C : +{0x98B8,0x0066,0x02}, // CNR_COEF_CB_L_A : +{0x98BA,0x0100,0x02}, // CNR_COEF_CB_L_B : +{0x98BC,0x0100,0x02}, // CNR_COEF_CB_L_C : +{0x98BE,0x0066,0x02}, // CNR_COEF_CB_M_H_A : +{0x98C0,0x0100,0x02}, // CNR_COEF_CB_M_H_B : +{0x98C2,0x0100,0x02}, // CNR_COEF_CB_M_H_C : +{0x98C4,0x0066,0x02}, // CNR_COEF_CB_M_L_A : +{0x98C6,0x0100,0x02}, // CNR_COEF_CB_M_L_B : +{0x98C8,0x0100,0x02}, // CNR_COEF_CB_M_L_C : +{0x98CA,0x1770,0x02}, // CNR_EDGE_GAIN_CR_H_A : +{0x98CC,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_H_B : +{0x98CE,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_H_C : +{0x98D0,0x1770,0x02}, // CNR_EDGE_GAIN_CR_L_A : +{0x98D2,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_L_B : +{0x98D4,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_L_C : +{0x98D6,0x1770,0x02}, // CNR_EDGE_GAIN_CR_M_H_A : +{0x98D8,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_M_H_B : +{0x98DA,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_M_H_C : +{0x98DC,0x1770,0x02}, // CNR_EDGE_GAIN_CR_M_L_A : +{0x98DE,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_M_L_B : +{0x98E0,0x07D0,0x02}, // CNR_EDGE_GAIN_CR_M_L_C : +{0x98E2,0x1770,0x02}, // CNR_EDGE_GAIN_CB_H_A : +{0x98E4,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_H_B : +{0x98E6,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_H_C : +{0x98E8,0x1770,0x02}, // CNR_EDGE_GAIN_CB_L_A : +{0x98EA,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_L_B : +{0x98EC,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_L_C : +{0x98EE,0x1770,0x02}, // CNR_EDGE_GAIN_CB_M_H_A : +{0x98F0,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_M_H_B : +{0x98F2,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_M_H_C : +{0x98F4,0x1770,0x02}, // CNR_EDGE_GAIN_CB_M_L_A : +{0x98F6,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_M_L_B : +{0x98F8,0x07D0,0x02}, // CNR_EDGE_GAIN_CB_M_L_C : +{0x98FA,0x7530,0x02}, // CNR_EDGE_TH_CR_H_A : +{0x98FC,0x0000,0x02}, // CNR_EDGE_TH_CR_H_B : +{0x98FE,0x0000,0x02}, // CNR_EDGE_TH_CR_H_C : +{0x9900,0x7530,0x02}, // CNR_EDGE_TH_CR_L_A : +{0x9902,0x0000,0x02}, // CNR_EDGE_TH_CR_L_B : +{0x9904,0x0000,0x02}, // CNR_EDGE_TH_CR_L_C : +{0x9906,0x7530,0x02}, // CNR_EDGE_TH_CR_M_H_A : +{0x9908,0x0000,0x02}, // CNR_EDGE_TH_CR_M_H_B : +{0x990A,0x0000,0x02}, // CNR_EDGE_TH_CR_M_H_C : +{0x990C,0x7530,0x02}, // CNR_EDGE_TH_CR_M_L_A : +{0x990E,0x0000,0x02}, // CNR_EDGE_TH_CR_M_L_B : +{0x9910,0x0000,0x02}, // CNR_EDGE_TH_CR_M_L_C : +{0x9912,0x7530,0x02}, // CNR_EDGE_TH_CB_H_A : +{0x9914,0x0000,0x02}, // CNR_EDGE_TH_CB_H_B : +{0x9916,0x0000,0x02}, // CNR_EDGE_TH_CB_H_C : +{0x9918,0x7530,0x02}, // CNR_EDGE_TH_CB_L_A : +{0x991A,0x0000,0x02}, // CNR_EDGE_TH_CB_L_B : +{0x991C,0x0000,0x02}, // CNR_EDGE_TH_CB_L_C : +{0x991E,0x7530,0x02}, // CNR_EDGE_TH_CB_M_H_A : +{0x9920,0x0000,0x02}, // CNR_EDGE_TH_CB_M_H_B : +{0x9922,0x0000,0x02}, // CNR_EDGE_TH_CB_M_H_C : +{0x9924,0x7530,0x02}, // CNR_EDGE_TH_CB_M_L_A : +{0x9926,0x0000,0x02}, // CNR_EDGE_TH_CB_M_L_B : +{0x9928,0x0000,0x02}, // CNR_EDGE_TH_CB_M_L_C : + +//ITP NR°ü·Ã +{0x5005,0xBB,0x01}, // DM_SW1 : +{0x5006,0x03,0x01}, // DM_SW2 : +{0x9608,0x0000,0x02}, // DS_GRADCORE_A : +{0x960A,0x0004,0x02}, // DS_GRADCORE_B : +{0x960C,0x0000,0x02}, // DS_GRADCORE_C1 : +{0x960E,0x0000,0x02}, // DS_GRADCORE_C2 : +{0x9610,0x000A,0x02}, // DS_GRADLIM_A : +{0x9612,0x0019,0x02}, // DS_GRADLIM_B : +{0x9614,0x0020,0x02}, // DS_GRADLIM_C1 : +{0x9616,0x0020,0x02}, // DS_GRADLIM_C2 : +{0x9600,0x0080,0x02}, // DS_NOISELVL_A : +{0x9602,0x0039,0x02}, // DS_NOISELVL_B : +{0x9604,0x0030,0x02}, // DS_NOISELVL_C1 : +{0x9606,0x0030,0x02}, // DS_NOISELVL_C2 +{0x9670,0x14,0x01}, // YN_SLOPELIMIT_A : +{0x9671,0x20,0x01}, // YN_SLOPELIMIT_B : +{0x9672,0x20,0x01}, // YN_SLOPELIMIT_C1 : +{0x9673,0x20,0x01}, // YN_SLOPELIMIT_C2 : +{0x9674,0x0032,0x02}, // YN_LNRTH_CORE_A : +{0x9676,0x0006,0x02}, // YN_LNRTH_CORE_B : +{0x9678,0x0003,0x02}, // YN_LNRTH_CORE_C1 : +{0x967A,0x0003,0x02}, // YN_LNRTH_CORE_C2 : +{0x967C,0x0032,0x02}, // YN_LNRTH_LIM_A : +{0x967E,0x0058,0x02}, // YN_LNRTH_LIM_B : +{0x9680,0x00A0,0x02}, // YN_LNRTH_LIM_C1 : +{0x9682,0x00A0,0x02}, // YN_LNRTH_LIM_C2 : +{0x9684,0x000F,0x02}, // LN_CNRTH_A : +{0x9686,0x0014,0x02}, // LN_CNRTH_B : +{0x9688,0x0014,0x02}, // LN_CNRTH_C1 : +{0x968A,0x0014,0x02}, // LN_CNRTH_C2 : +{0x968C,0x0100,0x02}, // CS_BLEND_LL_A : +{0x968E,0x0000,0x02}, // CS_BLEND_LL_B : +{0x9690,0x03FF,0x02}, // CS_BLEND_LL_C1 : +{0x9692,0x03FF,0x02}, // CS_BLEND_LL_C2 : +{0x9628,0x0008,0x02}, // DS_HLNLBLENDCORE_A : +{0x962A,0x0003,0x02}, // DS_HLNLBLENDCORE_B : +{0x962C,0x0000,0x02}, // DS_HLNLBLENDCORE_C1 : +{0x962E,0x0000,0x02}, // DS_HLNLBLENDCORE_C2 : +{0x9630,0x0018,0x02}, // DS_HLNLBLENDLIM_A : +{0x9632,0x0024,0x02}, // DS_HLNLBLENDLIM_B : +{0x9634,0x0028,0x02}, // DS_HLNLBLENDLIM_C1 : +{0x9636,0x0028,0x02}, // DS_HLNLBLENDLIM_C2 : +{0x9638,0x0000,0x02}, // DS_MNBLENDCORE_A : +{0x963A,0x000C,0x02}, // DS_MNBLENDCORE_B : +{0x963C,0x0000,0x02}, // DS_MNBLENDCORE_C1 : +{0x963E,0x0000,0x02}, // DS_MNBLENDCORE_C2 : +{0x9640,0x0020,0x02}, // DS_MNBLENDLIM_A : +{0x9642,0x0030,0x02}, // DS_MNBLENDLIM_B : +{0x9644,0x0080,0x02}, // DS_MNBLENDLIM_C1 : +{0x9646,0x0080,0x02}, // DS_MNBLENDLIM_C2 : +{0x9648,0x0008,0x02}, // DS_MHBLENDCORE_A : +{0x964A,0x0005,0x02}, // DS_MHBLENDCORE_B : +{0x964C,0x0001,0x02}, // DS_MHBLENDCORE_C1 : +{0x964E,0x0001,0x02}, // DS_MHBLENDCORE_C2 : +{0x9650,0x0018,0x02}, // DS_MHBLENDLIM_A : +{0x9652,0x0041,0x02}, // DS_MHBLENDLIM_B : +{0x9654,0x005A,0x02}, // DS_MHBLENDLIM_C1 : +{0x9656,0x0050,0x02}, // DS_MHBLENDLIM_C2 : +{0x9668,0x0008,0x02}, // DS_NAPMSKLIM_A : +{0x966A,0x0010,0x02}, // DS_NAPMSKLIM_B : +{0x966C,0x0018,0x02}, // DS_NAPMSKLIM_C1 : +{0x966E,0x0018,0x02}, // DS_NAPMSKLIM_C2 : +{0x9618,0x0018,0x02}, // DS_ZIPSUPCORE_A : +{0x961A,0x0018,0x02}, // DS_ZIPSUPCORE_B : +{0x961C,0x0004,0x02}, // DS_ZIPSUPCORE_C1 : +{0x961E,0x0004,0x02}, // DS_ZIPSUPCORE_C2 : +{0x9620,0x0010,0x02}, // DS_ZIPSUPLIM_A : +{0x9622,0x0010,0x02}, // DS_ZIPSUPLIM_B : +{0x9624,0x0010,0x02}, // DS_ZIPSUPLIM_C1 : +{0x9626,0x0010,0x02}, // DS_ZIPSUPLIM_C2 : +{0x9658,0x0020,0x02}, // DS_ICDCORE_A : +{0x965A,0x0010,0x02}, // DS_ICDCORE_B : +{0x965C,0x0000,0x02}, // DS_ICDCORE_C1 : +{0x965E,0x0000,0x02}, // DS_ICDCORE_C2 : +{0x9660,0x0020,0x02}, // DS_ICDLIM_A : +{0x9662,0x0040,0x02}, // DS_ICDLIM_B : +{0x9664,0x0040,0x02}, // DS_ICDLIM_C1 : +{0x9666,0x0040,0x02}, // DS_ICDLIM_C2 : +{0x9694,0x000C,0x02}, // CS_EDGE_CSUP_CORE_A : +{0x9696,0x000C,0x02}, // CS_EDGE_CSUP_CORE_B : +{0x9698,0x000C,0x02}, // CS_EDGE_CSUP_CORE_C1 : +{0x969A,0x0006,0x02}, // CS_EDGE_CSUP_CORE_C2 : +{0x969C,0x000C,0x02}, // CS_EDGE_CSUP_LIM_A : +{0x969E,0x000C,0x02}, // CS_EDGE_CSUP_LIM_B : +{0x96A0,0x0010,0x02}, // CS_EDGE_CSUP_LIM_C1 : +{0x96A2,0x0008,0x02}, // CS_EDGE_CSUP_LIM_C2 : +{0x96A4,0x0180,0x02}, // CS_SPOT_CSUP_CORE_A : +{0x96A6,0x0180,0x02}, // CS_SPOT_CSUP_CORE_B : +{0x96A8,0x0100,0x02}, // CS_SPOT_CSUP_CORE_C1 : +{0x96AA,0x0100,0x02}, // CS_SPOT_CSUP_CORE_C2 : +{0x96AC,0x000A,0x02}, // CS_SPOT_CSUP_LIM_A : +{0x96AE,0x000A,0x02}, // CS_SPOT_CSUP_LIM_B : +{0x96B0,0x0018,0x02}, // CS_SPOT_CSUP_LIM_C1 : +{0x96B2,0x0018,0x02}, // CS_SPOT_CSUP_LIM_C2 : + +//LMT Á¶µµ¿¬µ¿ Blend °ü·Ã +{0x9800,0x40,0x01}, // +{0x9801,0x80,0x01}, // + +//°ÔÀוּ¿ Type ¼³Á¤ °ü·Ã +{0x9217,0x3C,0x01}, // GAIN_TH_A_TYPE5 : +{0x9218,0x28,0x01}, // GAIN_TH_B_TYPE5 : +{0x9219,0x1E,0x01}, // GAIN_TH_C_TYPE5 : + +//CNR Á¶µµ¿¬µ¿ °ü·Ã +{0x928F,0x05,0x01}, // CNR_PREHNR_GAIN_SEL : +{0x9290,0x05,0x01}, // CNR_NLM_TH_CR_H_SEL : +{0x9291,0x05,0x01}, // CNR_NLM_TH_CR_L_SEL : +{0x9292,0x05,0x01}, // CNR_NLM_TH_CR_M_H_SEL : +{0x9293,0x05,0x01}, // CNR_NLM_TH_CR_M_L_SEL : +{0x9294,0x05,0x01}, // CNR_NLM_TH_CB_H_SEL : +{0x9295,0x05,0x01}, // CNR_NLM_TH_CB_L_SEL : +{0x9296,0x05,0x01}, // CNR_NLM_TH_CB_M_H_SEL : +{0x9297,0x05,0x01}, // CNR_NLM_TH_CB_M_L_SEL : +{0x9298,0x05,0x01}, // CNR_VE_TH_CR_H_SEL : +{0x9299,0x05,0x01}, // CNR_VE_TH_CR_L_SEL : +{0x929A,0x05,0x01}, // CNR_VE_TH_CR_M_H_SEL : +{0x929B,0x05,0x01}, // CNR_VE_TH_CR_M_L_SEL : +{0x929C,0x05,0x01}, // CNR_VE_TH_CB_H_SEL : +{0x929D,0x05,0x01}, // CNR_VE_TH_CB_L_SEL : +{0x929E,0x05,0x01}, // CNR_VE_TH_CB_M_H_SEL : +{0x929F,0x05,0x01}, // CNR_VE_TH_CB_M_L_SEL : +{0x92A0,0x05,0x01}, // CNR_COEF_CR_H_SEL : +{0x92A1,0x05,0x01}, // CNR_COEF_CR_L_SEL : +{0x92A2,0x05,0x01}, // CNR_COEF_CR_M_H_SEL : +{0x92A3,0x05,0x01}, // CNR_COEF_CR_M_L_SEL : +{0x92A4,0x05,0x01}, // CNR_COEF_CB_H_SEL : +{0x92A5,0x05,0x01}, // CNR_COEF_CB_L_SEL : +{0x92A6,0x05,0x01}, // CNR_COEF_CB_M_H_SEL : +{0x92A7,0x05,0x01}, // CNR_COEF_CB_M_L_SEL : +{0x92A8,0x05,0x01}, // CNR_EDGE_GAIN_CR_H_SEL : +{0x92A9,0x05,0x01}, // CNR_EDGE_GAIN_CR_L_SEL : +{0x92AA,0x05,0x01}, // CNR_EDGE_GAIN_CR_M_H_SEL : +{0x92AB,0x05,0x01}, // CNR_EDGE_GAIN_CR_M_L_SEL : +{0x92AC,0x05,0x01}, // CNR_EDGE_GAIN_CB_H_SEL : +{0x92AD,0x05,0x01}, // CNR_EDGE_GAIN_CB_L_SEL : +{0x92AE,0x05,0x01}, // CNR_EDGE_GAIN_CB_M_H_SEL : +{0x92AF,0x05,0x01}, // CNR_EDGE_GAIN_CB_M_L_SEL : +{0x92B0,0x05,0x01}, // CNR_EDGE_TH_CR_H_SEL : +{0x92B1,0x05,0x01}, // CNR_EDGE_TH_CR_L_SEL : +{0x92B2,0x05,0x01}, // CNR_EDGE_TH_CR_M_H_SEL : +{0x92B3,0x05,0x01}, // CNR_EDGE_TH_CR_M_L_SEL : +{0x92B4,0x05,0x01}, // CNR_EDGE_TH_CB_H_SEL : +{0x92B5,0x05,0x01}, // CNR_EDGE_TH_CB_L_SEL : +{0x92B6,0x05,0x01}, // CNR_EDGE_TH_CB_M_H_SEL : +{0x92B7,0x05,0x01}, // CNR_EDGE_TH_CB_M_L_SEL : + +////////////////MWB & AWB Æ©´×//////////// +{0x6244,0x0B81,0x02}, // USER0R : +{0x6246,0x1832,0x02}, // USER0B : +{0x6248,0x0C9E,0x02}, // USER1R : Daylight +{0x624A,0x1766,0x02}, // USER1B : +{0x624C,0x09C8,0x02}, // USER2R : Cloudy +{0x624E,0x1A06,0x02}, // USER2B : +{0x6250,0x0D61,0x02}, // USER3R : Fluorescent +{0x6252,0x1161,0x02}, // USER3B : +{0x6254,0x130B,0x02}, // USER4R : A +{0x6256,0x0E92,0x02}, // USER4B : + +{0x6270,0x0000,0x02}, // USER2_CONT_SHIFT_R : Cloudy cont shift +{0x6272,0x0000,0x02}, // USER2_CONT_SHIFT_B : +{0x62C6,0x1096,0x02}, // A_LIGHT_R : +{0x62C8,0x0F26,0x02}, // A_LIGHT_B : +{0x62CA,0x00B0,0x02}, // A_LIGHT_AIM_SHIFT_R : +{0x62CC,0x00C0,0x02}, // A_LIGHT_AIM_SHIFT_B : +{0x62CE,0x04,0x01}, // A_LIGHT_SCOPE_S_UP : +{0x62CF,0x04,0x01}, // A_LIGHT_SCOPE_S_DOWN : +{0x62D0,0x04,0x01}, // A_LIGHT_SCOPE_S_RIGHT : +{0x62D1,0x04,0x01}, // A_LIGHT_SCOPE_S_LEFT : +{0x62D2,0x14,0x01}, // A_LIGHT_SCOPE_L_UP : +{0x62D3,0x14,0x01}, // A_LIGHT_SCOPE_L_DOWN : +{0x62D4,0x14,0x01}, // A_LIGHT_SCOPE_L_RIGHT : +{0x62D5,0x14,0x01}, // A_LIGHT_SCOPE_L_LEFT : +{0x62D6,0x1217,0x02}, // H_LIGHT_R : +{0x62D8,0x0B95,0x02}, // H_LIGHT_B : +{0x62DA,0xFF7E,0x02}, // H_LIGHT_AIM_SHIFT_R : +{0x62DC,0xFF36,0x02}, // H_LIGHT_AIM_SHIFT_B : +{0x62DE,0x04,0x01}, // H_LIGHT_SCOPE_S_UP : +{0x62DF,0x04,0x01}, // H_LIGHT_SCOPE_S_DOWN : +{0x62E0,0x04,0x01}, // H_LIGHT_SCOPE_S_RIGHT : +{0x62E1,0x04,0x01}, // H_LIGHT_SCOPE_S_LEFT : +{0x62E2,0x14,0x01}, // H_LIGHT_SCOPE_L_UP : +{0x62E3,0x17,0x01}, // H_LIGHT_SCOPE_L_DOWN : +{0x62E4,0x26,0x01}, // H_LIGHT_SCOPE_L_RIGHT : +{0x62E5,0x19,0x01}, // H_LIGHT_SCOPE_L_LEFT : + +/////MC3 Setting///// +{0x7600,0x07,0x01}, // MC3_PXDEF0_SEL : +{0x7601,0x07,0x01}, // MC3_PYDEF0_SEL : +{0x7602,0x07,0x01}, // MC3_PXDEF1_SEL : +{0x7603,0x07,0x01}, // MC3_PYDEF1_SEL : +{0x7604,0x07,0x01}, // MC3_PXDEF2_SEL : +{0x7605,0x07,0x01}, // MC3_PYDEF2_SEL : +{0x7606,0x07,0x01}, // MC3_PXDEF3_SEL : +{0x7607,0x07,0x01}, // MC3_PYDEF3_SEL : +{0x7608,0x40,0x01}, // MC3_PXDEF0_A : +{0x7609,0x40,0x01}, // MC3_PXDEF0_B : +{0x760A,0x40,0x01}, // MC3_PXDEF0_C : +{0x760B,0x40,0x01}, // MC3_PYDEF0_A : +{0x760C,0x40,0x01}, // MC3_PYDEF0_B : +{0x760D,0x40,0x01}, // MC3_PYDEF0_C : +{0x760E,0x40,0x01}, // MC3_PXDEF1_A : +{0x760F,0x40,0x01}, // MC3_PXDEF1_B : +{0x7610,0x40,0x01}, // MC3_PXDEF1_C : +{0x7611,0x40,0x01}, // MC3_PYDEF1_A : +{0x7612,0x40,0x01}, // MC3_PYDEF1_B : +{0x7613,0x40,0x01}, // MC3_PYDEF1_C : +{0x7614,0x40,0x01}, // MC3_PXDEF2_A : +{0x7615,0x40,0x01}, // MC3_PXDEF2_B : +{0x7616,0x40,0x01}, // MC3_PXDEF2_C : +{0x7617,0x40,0x01}, // MC3_PYDEF2_A : +{0x7618,0x40,0x01}, // MC3_PYDEF2_B : +{0x7619,0x40,0x01}, // MC3_PYDEF2_C : +{0x761A,0x40,0x01}, // MC3_PXDEF3_A : +{0x761B,0x40,0x01}, // MC3_PXDEF3_B : +{0x761C,0x40,0x01}, // MC3_PXDEF3_C : +{0x761D,0x40,0x01}, // MC3_PYDEF3_A : +{0x761E,0x40,0x01}, // MC3_PYDEF3_B : +{0x761F,0x40,0x01}, // MC3_PYDEF3_C : +{0x7620,0x00,0x01}, // MC3_LUMSL0_IN : +{0x7621,0x06,0x01}, // MC3_LUMSL1_IN : +{0x7622,0x03,0x01}, // MC3_LUMSL2_IN : +{0x7623,0x06,0x01}, // MC3_LUMSL3_IN : +{0x7624,0x00,0x01}, // MC3_LUMSL0_OUT : +{0x7625,0x03,0x01}, // MC3_LUMSL1_OUT : +{0x7626,0x00,0x01}, // MC3_LUMSL2_OUT : +{0x7627,0x00,0x01}, // MC3_LUMSL3_OUT : +{0x7628,0x0000,0x02}, // MC3_L0DEF0_IN : +{0x762A,0x008C,0x02}, // MC3_L0DEF1_IN : +{0x762C,0x0078,0x02}, // MC3_L0DEF2_IN : +{0x762E,0x00E6,0x02}, // MC3_L0DEF3_IN : +{0x7630,0x0000,0x02}, // MC3_L0DEF0_OUT : +{0x7632,0x0082,0x02}, // MC3_L0DEF1_OUT : +{0x7634,0x0000,0x02}, // MC3_L0DEF2_OUT : +{0x7636,0x0000,0x02}, // MC3_L0DEF3_OUT : +{0x7638,0x41,0x01}, // MC3_RDEF0_POS1 : +{0x7639,0x10,0x01}, // MC3_RDEF1_POS1 : +{0x763A,0x15,0x01}, // MC3_RDEF2_POS1 : +{0x763B,0x71,0x01}, // MC3_RDEF3_POS1 : +{0x763C,0x41,0x01}, // MC3_RDEF0_POS2 : +{0x763D,0x10,0x01}, // MC3_RDEF1_POS2 : +{0x763E,0x15,0x01}, // MC3_RDEF2_POS2 : +{0x763F,0x71,0x01}, // MC3_RDEF3_POS2 : +{0x7640,0x3C,0x01}, // MC3_RDEF0_POS3 : +{0x7641,0x10,0x01}, // MC3_RDEF1_POS3 : +{0x7642,0x15,0x01}, // MC3_RDEF2_POS3 : +{0x7643,0x71,0x01}, // MC3_RDEF3_POS3 : +{0x7644,0x46,0x01}, // MC3_RDEF0_POS4 : +{0x7645,0x32,0x01}, // MC3_RDEF1_POS4 : +{0x7646,0x15,0x01}, // MC3_RDEF2_POS4 : +{0x7647,0x71,0x01}, // MC3_RDEF3_POS4 : +{0x7648,0x46,0x01}, // MC3_RDEF0_POS5 : +{0x7649,0x32,0x01}, // MC3_RDEF1_POS5 : +{0x764A,0x15,0x01}, // MC3_RDEF2_POS5 : +{0x764B,0x71,0x01}, // MC3_RDEF3_POS5 : +{0x764C,0x46,0x01}, // MC3_RDEF0_POS6 : +{0x764D,0x10,0x01}, // MC3_RDEF1_POS6 : +{0x764E,0x15,0x01}, // MC3_RDEF2_POS6 : +{0x764F,0x71,0x01}, // MC3_RDEF3_POS6 : +{0x7650,0x46,0x01}, // MC3_RDEF0_POS7 : +{0x7651,0x10,0x01}, // MC3_RDEF1_POS7 : +{0x7652,0x15,0x01}, // MC3_RDEF2_POS7 : +{0x7653,0x71,0x01}, // MC3_RDEF3_POS7 : +{0x7654,0x2D,0x01}, // MC3_RDEF0_OUT : +{0x7655,0x10,0x01}, // MC3_RDEF1_OUT : +{0x7656,0x15,0x01}, // MC3_RDEF2_OUT : +{0x7657,0x54,0x01}, // MC3_RDEF3_OUT : +{0x7658,0x46,0x01}, // MC3_RDEF0_R2_POS4 : +{0x7659,0x32,0x01}, // MC3_RDEF1_R2_POS4 : +{0x765A,0x15,0x01}, // MC3_RDEF2_R2_POS4 : +{0x765B,0x71,0x01}, // MC3_RDEF3_R2_POS4 : +{0x765C,0x46,0x01}, // MC3_RDEF0_R2_POS5 : +{0x765D,0x32,0x01}, // MC3_RDEF1_R2_POS5 : +{0x765E,0x15,0x01}, // MC3_RDEF2_R2_POS5 : +{0x765F,0x71,0x01}, // MC3_RDEF3_R2_POS5 : +{0x7660,0xFFBA,0x02}, // MC3_X0DEF0_POS1 : +{0x7662,0xFFBA,0x02}, // MC3_Y0DEF0_POS1 : +{0x7664,0xFFFE,0x02}, // MC3_X0DEF1_POS1 : +{0x7666,0x000D,0x02}, // MC3_Y0DEF1_POS1 : +{0x7668,0x0002,0x02}, // MC3_X0DEF2_POS1 : +{0x766A,0xFFF6,0x02}, // MC3_Y0DEF2_POS1 : +{0x766C,0x003B,0x02}, // MC3_X0DEF3_POS1 : +{0x766E,0xFFBB,0x02}, // MC3_Y0DEF3_POS1 : +{0x7670,0xFFBA,0x02}, // MC3_X0DEF0_POS2 : +{0x7672,0xFFBA,0x02}, // MC3_Y0DEF0_POS2 : +{0x7674,0xFFFE,0x02}, // MC3_X0DEF1_POS2 : +{0x7676,0x000D,0x02}, // MC3_Y0DEF1_POS2 : +{0x7678,0x0002,0x02}, // MC3_X0DEF2_POS2 : +{0x767A,0xFFF6,0x02}, // MC3_Y0DEF2_POS2 : +{0x767C,0x003B,0x02}, // MC3_X0DEF3_POS2 : +{0x767E,0xFFBB,0x02}, // MC3_Y0DEF3_POS2 : +{0x7680,0xFFCE,0x02}, // MC3_X0DEF0_POS3 : +{0x7682,0xFFBA,0x02}, // MC3_Y0DEF0_POS3 : +{0x7684,0xFFFE,0x02}, // MC3_X0DEF1_POS3 : +{0x7686,0x000D,0x02}, // MC3_Y0DEF1_POS3 : +{0x7688,0x0002,0x02}, // MC3_X0DEF2_POS3 : +{0x768A,0xFFF6,0x02}, // MC3_Y0DEF2_POS3 : +{0x768C,0x003B,0x02}, // MC3_X0DEF3_POS3 : +{0x768E,0xFFBB,0x02}, // MC3_Y0DEF3_POS3 : +{0x7690,0xFFCE,0x02}, // MC3_X0DEF0_POS4 : +{0x7692,0xFFC9,0x02}, // MC3_Y0DEF0_POS4 : +{0x7694,0xFFD0,0x02}, // MC3_X0DEF1_POS4 : +{0x7696,0x0037,0x02}, // MC3_Y0DEF1_POS4 : +{0x7698,0x0002,0x02}, // MC3_X0DEF2_POS4 : +{0x769A,0xFFF6,0x02}, // MC3_Y0DEF2_POS4 : +{0x769C,0x003B,0x02}, // MC3_X0DEF3_POS4 : +{0x769E,0xFFBB,0x02}, // MC3_Y0DEF3_POS4 : +{0x76A0,0xFFCE,0x02}, // MC3_X0DEF0_POS5 : +{0x76A2,0xFFC9,0x02}, // MC3_Y0DEF0_POS5 : +{0x76A4,0xFFD0,0x02}, // MC3_X0DEF1_POS5 : +{0x76A6,0x0037,0x02}, // MC3_Y0DEF1_POS5 : +{0x76A8,0x0002,0x02}, // MC3_X0DEF2_POS5 : +{0x76AA,0xFFF6,0x02}, // MC3_Y0DEF2_POS5 : +{0x76AC,0x003B,0x02}, // MC3_X0DEF3_POS5 : +{0x76AE,0xFFBB,0x02}, // MC3_Y0DEF3_POS5 : +{0x76B0,0xFFCE,0x02}, // MC3_X0DEF0_POS6 : +{0x76B2,0xFFC9,0x02}, // MC3_Y0DEF0_POS6 : +{0x76B4,0xFFFE,0x02}, // MC3_X0DEF1_POS6 : +{0x76B6,0x000D,0x02}, // MC3_Y0DEF1_POS6 : +{0x76B8,0x0002,0x02}, // MC3_X0DEF2_POS6 : +{0x76BA,0xFFF6,0x02}, // MC3_Y0DEF2_POS6 : +{0x76BC,0x003B,0x02}, // MC3_X0DEF3_POS6 : +{0x76BE,0xFFBB,0x02}, // MC3_Y0DEF3_POS6 : +{0x76C0,0xFFCE,0x02}, // MC3_X0DEF0_POS7 : +{0x76C2,0xFFC9,0x02}, // MC3_Y0DEF0_POS7 : +{0x76C4,0xFFFE,0x02}, // MC3_X0DEF1_POS7 : +{0x76C6,0x000D,0x02}, // MC3_Y0DEF1_POS7 : +{0x76C8,0x0002,0x02}, // MC3_X0DEF2_POS7 : +{0x76CA,0xFFF6,0x02}, // MC3_Y0DEF2_POS7 : +{0x76CC,0x003B,0x02}, // MC3_X0DEF3_POS7 : +{0x76CE,0xFFBB,0x02}, // MC3_Y0DEF3_POS7 : +{0x76D0,0xFF7E,0x02}, // MC3_X0DEF0_OUT : +{0x76D2,0xFFE2,0x02}, // MC3_Y0DEF0_OUT : +{0x76D4,0xFFFE,0x02}, // MC3_X0DEF1_OUT : +{0x76D6,0x000D,0x02}, // MC3_Y0DEF1_OUT : +{0x76D8,0x0002,0x02}, // MC3_X0DEF2_OUT : +{0x76DA,0xFFF6,0x02}, // MC3_Y0DEF2_OUT : +{0x76DC,0xFFC4,0x02}, // MC3_X0DEF3_OUT : +{0x76DE,0xFFEC,0x02}, // MC3_Y0DEF3_OUT : +{0x76E0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS4 : +{0x76E2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS4 : +{0x76E4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS4 : +{0x76E6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS4 : +{0x76E8,0x0002,0x02}, // MC3_X0DEF2_R2_POS4 : +{0x76EA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS4 : +{0x76EC,0x003B,0x02}, // MC3_X0DEF3_R2_POS4 : +{0x76EE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS4 : +{0x76F0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS5 : +{0x76F2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS5 : +{0x76F4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS5 : +{0x76F6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS5 : +{0x76F8,0x0002,0x02}, // MC3_X0DEF2_R2_POS5 : +{0x76FA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS5 : +{0x76FC,0x003B,0x02}, // MC3_X0DEF3_R2_POS5 : +{0x76FE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS5 : +{0x7700,0x0019,0x02}, // MC3_PXDEF0_POS1 : +{0x7702,0xFF66,0x02}, // MC3_PYDEF0_POS1 : +{0x7704,0x0000,0x02}, // MC3_PXDEF1_POS1 : +{0x7706,0x0000,0x02}, // MC3_PYDEF1_POS1 : +{0x7708,0x0000,0x02}, // MC3_PXDEF2_POS1 : +{0x770A,0x0000,0x02}, // MC3_PYDEF2_POS1 : +{0x770C,0xFFD7,0x02}, // MC3_PXDEF3_POS1 : +{0x770E,0x0068,0x02}, // MC3_PYDEF3_POS1 : +{0x7710,0x0000,0x02}, // MC3_PXDEF0_POS2 : +{0x7712,0xFF66,0x02}, // MC3_PYDEF0_POS2 : +{0x7714,0x0033,0x02}, // MC3_PXDEF1_POS2 : +{0x7716,0xFF4C,0x02}, // MC3_PYDEF1_POS2 : +{0x7718,0x0000,0x02}, // MC3_PXDEF2_POS2 : +{0x771A,0x00B3,0x02}, // MC3_PYDEF2_POS2 : +{0x771C,0xFFD7,0x02}, // MC3_PXDEF3_POS2 : +{0x771E,0x0068,0x02}, // MC3_PYDEF3_POS2 : +{0x7720,0x0000,0x02}, // MC3_PXDEF0_POS3 : +{0x7722,0xFF80,0x02}, // MC3_PYDEF0_POS3 : +{0x7724,0x0000,0x02}, // MC3_PXDEF1_POS3 : +{0x7726,0x0000,0x02}, // MC3_PYDEF1_POS3 : +{0x7728,0x0000,0x02}, // MC3_PXDEF2_POS3 : +{0x772A,0x0000,0x02}, // MC3_PYDEF2_POS3 : +{0x772C,0xFFD7,0x02}, // MC3_PXDEF3_POS3 : +{0x772E,0x0068,0x02}, // MC3_PYDEF3_POS3 : +{0x7730,0x0000,0x02}, // MC3_PXDEF0_POS4 : +{0x7732,0xFFCC,0x02}, // MC3_PYDEF0_POS4 : +{0x7734,0x0000,0x02}, // MC3_PXDEF1_POS4 : +{0x7736,0x0000,0x02}, // MC3_PYDEF1_POS4 : +{0x7738,0x0000,0x02}, // MC3_PXDEF2_POS4 : +{0x773A,0x0000,0x02}, // MC3_PYDEF2_POS4 : +{0x773C,0xFFD7,0x02}, // MC3_PXDEF3_POS4 : +{0x773E,0x0068,0x02}, // MC3_PYDEF3_POS4 : +{0x7740,0x0000,0x02}, // MC3_PXDEF0_POS5 : +{0x7742,0xFFCC,0x02}, // MC3_PYDEF0_POS5 : +{0x7744,0x0000,0x02}, // MC3_PXDEF1_POS5 : +{0x7746,0x0000,0x02}, // MC3_PYDEF1_POS5 : +{0x7748,0x0000,0x02}, // MC3_PXDEF2_POS5 : +{0x774A,0x0000,0x02}, // MC3_PYDEF2_POS5 : +{0x774C,0xFFD7,0x02}, // MC3_PXDEF3_POS5 : +{0x774E,0x0068,0x02}, // MC3_PYDEF3_POS5 : +{0x7750,0xFFB3,0x02}, // MC3_PXDEF0_POS6 : +{0x7752,0x0000,0x02}, // MC3_PYDEF0_POS6 : +{0x7754,0x0033,0x02}, // MC3_PXDEF1_POS6 : +{0x7756,0xFF4C,0x02}, // MC3_PYDEF1_POS6 : +{0x7758,0x0000,0x02}, // MC3_PXDEF2_POS6 : +{0x775A,0x00B3,0x02}, // MC3_PYDEF2_POS6 : +{0x775C,0xFFD7,0x02}, // MC3_PXDEF3_POS6 : +{0x775E,0x0068,0x02}, // MC3_PYDEF3_POS6 : +{0x7760,0xFFB3,0x02}, // MC3_PXDEF0_POS7 : +{0x7762,0x0000,0x02}, // MC3_PYDEF0_POS7 : +{0x7764,0x0000,0x02}, // MC3_PXDEF1_POS7 : +{0x7766,0x0000,0x02}, // MC3_PYDEF1_POS7 : +{0x7768,0x0000,0x02}, // MC3_PXDEF2_POS7 : +{0x776A,0x0000,0x02}, // MC3_PYDEF2_POS7 : +{0x776C,0xFFD7,0x02}, // MC3_PXDEF3_POS7 : +{0x776E,0x0068,0x02}, // MC3_PYDEF3_POS7 : +{0x7770,0x0019,0x02}, // MC3_PXDEF0_OUT : +{0x7772,0xFFE6,0x02}, // MC3_PYDEF0_OUT : +{0x7774,0x0000,0x02}, // MC3_PXDEF1_OUT : +{0x7776,0x0000,0x02}, // MC3_PYDEF1_OUT : +{0x7778,0x0000,0x02}, // MC3_PXDEF2_OUT : +{0x777A,0x0000,0x02}, // MC3_PYDEF2_OUT : +{0x777C,0xFFE1,0x02}, // MC3_PXDEF3_OUT : +{0x777E,0xFFEB,0x02}, // MC3_PYDEF3_OUT : +{0x7780,0x0000,0x02}, // MC3_PXDEF0_R2_POS4 : +{0x7782,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS4 : +{0x7784,0x0000,0x02}, // MC3_PXDEF1_R2_POS4 : +{0x7786,0x0000,0x02}, // MC3_PYDEF1_R2_POS4 : +{0x7788,0x0000,0x02}, // MC3_PXDEF2_R2_POS4 : +{0x778A,0x0000,0x02}, // MC3_PYDEF2_R2_POS4 : +{0x778C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS4 : +{0x778E,0x0068,0x02}, // MC3_PYDEF3_R2_POS4 : +{0x7790,0x0000,0x02}, // MC3_PXDEF0_R2_POS5 : +{0x7792,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS5 : +{0x7794,0x0000,0x02}, // MC3_PXDEF1_R2_POS5 : +{0x7796,0x0000,0x02}, // MC3_PYDEF1_R2_POS5 : +{0x7798,0x0000,0x02}, // MC3_PXDEF2_R2_POS5 : +{0x779A,0x0000,0x02}, // MC3_PYDEF2_R2_POS5 : +{0x779C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS5 : +{0x779E,0x0068,0x02}, // MC3_PYDEF3_R2_POS5 : + + +{0x6C44,0x13,0x01}, // G_CTRL_SEL : +{0x0363,0x95,0x01}, // PICT3_GAMMA_MONI1 : +{0x0366,0x95,0x01}, // PICT3_GAMMA_CAP1 : + + +///////Scene Mode Setting//////////// +{0x0282,0x20,0x01}, //AWB_SN1 : +{0x0283,0x20,0x01}, //AWB_SN2 : +{0x0284,0x20,0x01}, //AWB_SN3 : +{0x0285,0x20,0x01}, //AWB_SN4 : +{0x0286,0x20,0x01}, //AWB_SN5 : +{0x0287,0x25,0x01}, //AWB_SN6 : +{0x0288,0x20,0x01}, //AWB_SN7 : +{0x0289,0x20,0x01}, //AWB_SN8 : +{0x028A,0x20,0x01}, //AWB_SN9 : +{0x028B,0x20,0x01}, //AWB_SN10 : +{0x028C,0x20,0x01}, //AWB_SN11 : +{0x028D,0x20,0x01}, //AWB_SN12 : +{0x028E,0x00,0x01}, //AF_SN1_2 : +{0x028F,0x00,0x01}, //AF_SN3_4 : +{0x0290,0x00,0x01}, //AF_SN5_6 : +{0x0291,0x00,0x01}, //AF_SN7_8 : +{0x0292,0x00,0x01}, //AF_SN9_10 : +{0x0293,0x00,0x01}, //AF_SN11_12 : +{0x0294,0x00,0x01}, //AE_SN1 : +{0x0295,0x00,0x01}, //AE_SN2 : +{0x0296,0x00,0x01}, //AE_SN3 : +{0x0297,0x40,0x01}, //AE_SN4 : +{0x0298,0x20,0x01}, //AE_SN5 : +{0x0299,0x00,0x01}, //AE_SN6 : +{0x029A,0x00,0x01}, //AE_SN7 : +{0x029B,0x00,0x01}, //AE_SN8 : +{0x029C,0x60,0x01}, //AE_SN9 : +{0x029D,0x00,0x01}, //AE_SN10 : +{0x029E,0x00,0x01}, //AE_SN11 : +{0x029F,0x00,0x01}, //AE_SN12 : +{0x02A8,0x00,0x01}, //ISO_TYPE1 : AUTO +{0x02A9,0x04,0x01}, //ISO_TYPE2 : ISO50 +{0x02AA,0x0A,0x01}, //ISO_TYPE3 : ISO200 +{0x02AB,0x00,0x01}, //ISO_TYPE4 : AUTO +{0x02AC,0x01,0x01}, //AE_SUB_SN1 : +{0x02AD,0x00,0x01}, //AE_SUB_SN2 : +{0x02AE,0x01,0x01}, //AE_SUB_SN3 : +{0x02AF,0x01,0x01}, //AE_SUB_SN4 : +{0x02B0,0x01,0x01}, //AE_SUB_SN5 : +{0x02B1,0x01,0x01}, //AE_SUB_SN6 : +{0x02B2,0x01,0x01}, //AE_SUB_SN7 : +{0x02B3,0x01,0x01}, //AE_SUB_SN8 : +{0x02B4,0x01,0x01}, //AE_SUB_SN9 : +{0x02B5,0x01,0x01}, //AE_SUB_SN10 : +{0x02B6,0x02,0x01}, //AE_SUB_SN11 : +{0x02B7,0x01,0x01}, //AE_SUB_SN12 : +{0x02EA,0x00,0x01}, //EVREF_MONI_SN1_2 : +{0x02EB,0x00,0x01}, //EVREF_MONI_SN3_4 : +{0x02EC,0x03,0x01}, //EVREF_MONI_SN5_6 : +{0x02ED,0x00,0x01}, //EVREF_MONI_SN7_8 : +{0x02EE,0x00,0x01}, //EVREF_MONI_SN9_10 : +{0x02EF,0x00,0x01}, //EVREF_MONI_SN11_12 : +{0x02F0,0x01,0x01}, //EVREF_CAP_SN1_2 : +{0x02F1,0x00,0x01}, //EVREF_CAP_SN3_4 : +{0x02F2,0x03,0x01}, //EVREF_CAP_SN5_6 : +{0x02F3,0x00,0x01}, //EVREF_CAP_SN7_8 : +{0x02F4,0x00,0x01}, //EVREF_CAP_SN9_10 : +{0x02F5,0x00,0x01}, //EVREF_CAP_SN11_12 : +{0x02F6,0x00,0x01}, //EVREF_MOVIE_SN1_2 : +{0x02F7,0x00,0x01}, //EVREF_MOVIE_SN3_4 : +{0x02F8,0x03,0x01}, //EVREF_MOVIE_SN5_6 : +{0x02F9,0x00,0x01}, //EVREF_MOVIE_SN7_8 : +{0x02FA,0x00,0x01}, //EVREF_MOVIE_SN9_10 : +{0x02FB,0x00,0x01}, //EVREF_MOVIE_SN11_12 : +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x0390,0xA4,0x01}, //PICT1_SN2 : +{0x0391,0x00,0x01}, //PICT1_SN3 : +{0x0392,0x04,0x01}, //PICT1_SN4 : +{0x0393,0x04,0x01}, //PICT1_SN5 : +{0x0394,0x00,0x01}, //PICT1_SN6 : +{0x0395,0x50,0x01}, //PICT1_SN7 : +{0x0396,0x0A,0x01}, //PICT1_SN8 : +{0x0397,0x00,0x01}, //PICT1_SN9 : +{0x0398,0xA0,0x01}, //PICT1_SN10 : +{0x0399,0x00,0x01}, //PICT1_SN11 : +{0x039A,0x00,0x01}, //PICT1_SN12 : +{0x039B,0x00,0x01}, //UIHUE_TYPE1 : +{0x039C,0x00,0x01}, //UIHUE_TYPE2 : +{0x039D,0x00,0x01}, //UIHUE_TYPE3 : +{0x039E,0x80,0x01}, //UISATURATION_TYPE1 : +{0x039F,0x9E,0x01}, //UISATURATION_TYPE2 : +{0x03A0,0x80,0x01}, //UISATURATION_TYPE3 : +{0x03A1,0x20,0x01}, //UISHARPNESS_POS_TYPE1 : +{0x03A2,0x14,0x01}, //UISHARPNESS_POS_TYPE2 : +{0x03A3,0x2C,0x01}, //UISHARPNESS_POS_TYPE3 : +{0x03A4,0x20,0x01}, //UISHARPNESS_NEG_TYPE1 : +{0x03A5,0x14,0x01}, //UISHARPNESS_NEG_TYPE2 : +{0x03A6,0x2C,0x01}, //UISHARPNESS_NEG_TYPE3 : +{0x0308,0x11,0x01}, //AELINE_MONI_SN1_2 : +{0x0309,0x13,0x01}, //AELINE_MONI_SN3_4 : +{0x030A,0x11,0x01}, //AELINE_MONI_SN5_6 : +{0x030B,0x41,0x01}, //AELINE_MONI_SN7_8 : +{0x030C,0x19,0x01}, //AELINE_MONI_SN9_10 : +{0x030D,0x11,0x01}, //AELINE_MONI_SN11_12 : +{0x030E,0x11,0x01}, //AELINE_HALF_SN1_2 : +{0x030F,0x13,0x01}, //AELINE_HALF_SN3_4 : +{0x0310,0x11,0x01}, //AELINE_HALF_SN5_6 : +{0x0311,0x41,0x01}, //AELINE_HALF_SN7_8 : +{0x0312,0x19,0x01}, //AELINE_HALF_SN9_10 : +{0x0313,0x11,0x01}, //AELINE_HALF_SN11_12 : +{0x0314,0x11,0x01}, //AELINE_HALF_AFEND_SN1_2 : +{0x0315,0x13,0x01}, //AELINE_HALF_AFEND_SN3_4 : +{0x0316,0x11,0x01}, //AELINE_HALF_AFEND_SN5_6 : +{0x0317,0x41,0x01}, //AELINE_HALF_AFEND_SN7_8 : +{0x0318,0x19,0x01}, //AELINE_HALF_AFEND_SN9_10 : +{0x0319,0x11,0x01}, //AELINE_HALF_AFEND_SN11_12 : +{0x031A,0x00,0x01}, //AELINE_CAP_SN1_2 : +{0x031B,0x03,0x01}, //AELINE_CAP_SN3_4 : +{0x031C,0x00,0x01}, //AELINE_CAP_SN5_6 : +{0x031D,0x50,0x01}, //AELINE_CAP_SN7_8 : +{0x031E,0x08,0x01}, //AELINE_CAP_SN9_10 : +{0x031F,0x00,0x01}, //AELINE_CAP_SN11_12 : +{0x0320,0x22,0x01}, //AELINE_MOVIE_SN1_2 : +{0x0321,0x22,0x01}, //AELINE_MOVIE_SN3_4 : +{0x0322,0x22,0x01}, //AELINE_MOVIE_SN5_6 : +{0x0323,0x22,0x01}, //AELINE_MOVIE_SN7_8 : +{0x0324,0x22,0x01}, //AELINE_MOVIE_SN9_10 : +{0x0325,0x22,0x01}, //AELINE_MOVIE_SN11_12 : +{0x02DB,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN1_2 : +{0x02DC,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN3_4 : +{0x02DD,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN5_6 : +{0x02DE,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN7_8 : +{0x02DF,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN9_10 : +{0x02E0,0x33,0x01}, //VADD_SHTGAIN_CTRL_SN11_12 : +{0x0383,0x80,0x01}, // MC3_MODE_SN_1 : +{0x0384,0x80,0x01}, // MC3_MODE_SN_2 : +{0x0385,0x80,0x01}, // MC3_MODE_SN_3 : +{0x0386,0x80,0x01}, // MC3_MODE_SN_4 : +{0x0387,0x80,0x01}, // MC3_MODE_SN_5 : +{0x0388,0x80,0x01}, // MC3_MODE_SN_6 : +{0x0389,0x80,0x01}, // MC3_MODE_SN_7 : +{0x038A,0x80,0x01}, // MC3_MODE_SN_8 : +{0x038B,0x80,0x01}, // MC3_MODE_SN_9 : +{0x038C,0x80,0x01}, // MC3_MODE_SN_10 : +{0x038D,0x80,0x01}, // MC3_MODE_SN_11 : +{0x038E,0x80,0x01}, // MC3_MODE_SN_12 : + +///AWBÃʱâÁÂÇ¥ +{0x6238,0x0BE3,0x02}, // INIT_CONT_INR : +{0x623A,0x1718,0x02}, // INIT_CONT_INB : +{0x623C,0x0BBB,0x02}, // INIT_CONT_OUTR : +{0x623E,0x18B7,0x02}, // INIT_CONT_OUTB : + +//bluesky brightness setting +{0x6298,0xB0,0x01}, // SHADE_JUDGPOS : +{0x6299,0xB5,0x01}, // BLUESKY_JUDGPOS : + +//EV SEL gain step +{0x5E6B,0x04,0x01}, // EVSEL_GAIN_P1_3 : +{0x5E6C,0x08,0x01}, // EVSEL_GAIN_P2_3 : +{0x5E6D,0x0C,0x01}, // EVSEL_GAIN_P3_3 : +{0x5E6E,0x10,0x01}, // EVSEL_GAIN_P4_3 : +{0x5E6F,0x14,0x01}, // EVSEL_GAIN_P5_3 : +{0x5E70,0x18,0x01}, // EVSEL_GAIN_P6_3 : +{0x5E71,0x05,0x01}, // EVSEL_GAIN_M1_3 : +{0x5E72,0x0A,0x01}, // EVSEL_GAIN_M2_3 : +{0x5E73,0x0F,0x01}, // EVSEL_GAIN_M3_3 : +{0x5E74,0x16,0x01}, // EVSEL_GAIN_M4_3 : +{0x5E75,0x1B,0x01}, // EVSEL_GAIN_M5_3 : +{0x5E76,0x20,0x01}, // EVSEL_GAIN_M6_3 : + +//In, Out judge +{0x62A2,0x8C,0x01}, // INOUT_WEIGHT_AREA_ST : 140 +{0x6258,0xA0,0x01}, // IN_JUDGPOS : 160 +{0x6259,0xA1,0x01}, // OUT_JUDGPOS : 161 +{0x62A3,0xA4,0x01}, // INOUT_WEIGHT_AREA_ED : 164 +{0x62A4,0x92,0x01}, // IN_LUMST : 146 +{0x62A5,0x9C,0x01}, // OUT_LUMST : 156 + +//ISO output setting +{0x5E3F,0x00,0x01}, // ISOSENS_OUT_SEL : + +/* ++CONFIG_MACH_KONA */ +{0x008C,0x03,0x01}, +{0x008D,0x03,0x01}, +{0x008E,0x03,0x01}, +{0x0082,0x01,0x01}, +/* --CONFIG_MACH_KONA */ +}; + +// ISX012-0 +// MIPI 2LANE 648 +// PLL 648MHz +// DCK 81 +// inifile +// size address data +// +static const isx012_regset_t ISX012_Pll_Setting_2[] = +{ +{0x0007,0x01,0x01}, // PLL_CKSEL : PLL 648MHz +{0x0008,0x03,0x01}, // SRCCK_DIV : 1/8 frequency + +{0x0004,0x03,0x01}, //I2C_ADR_SEL 2: 0x3C MIPI selected, 3: 0x3D MIPI selected +{0x5008,0x00,0x01}, //ENDIAN_SEL : 0:Little Endian +{0x6DA8,0x01,0x01}, //SHD_CoEF (OTP shading ON flag) +{0x6DA9,0x09,0x01}, // WHITE_CTRL +{0x6DCB,0x22,0x01}, // YGAM_CONFIG2 : + +{0x00C4,0x11,0x01}, // VIF_CLKCONFIG1 : VIFSEL and VIFDIV setting value with full frame pixel setting for other then JPG +{0x00C5,0x11,0x01}, // VIF_CLKCONFIG2 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other then JPG +{0x00C6,0x11,0x01}, // VIF_CLKCONFIG3 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for other then JPG +{0x00C7,0x11,0x01}, // VIF_CLKCONFIG4 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for other then JPG +{0x00C8,0x11,0x01}, // VIF_CLKCONFIG5 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG mode +{0x00C9,0x11,0x01}, // VIF_CLKCONFIG6 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG mode +{0x00CA,0x11,0x01}, // VIF_CLKCONFIG7 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for JPG mode +{0x018C,0x0000,0x02}, // VADJ_SENS_1_1 : VMAX adjustment value for full frame pixel +{0x018E,0x0000,0x02}, // VADJ_SENS_1_2 : VMAX adjustment value for 1/2 sub-sampling +{0x0190,0x0000,0x02}, // VADJ_SENS_1_4 : VMAX adjustment value for 1/4 sub-sampling +{0x0192,0x0000,0x02}, // VADJ_SENS_1_8 : VMAX adjustment value for 1/8 sub-sampling +{0x0194,0x0000,0x02}, // VADJ_SENS_HD_1_1 : VMAX adjustment value for HD full frame pixel +{0x0196,0x0000,0x02}, // VADJ_SENS_HD_1_2 : VMAX adjustment value for HD 1/2 sub-sampling +{0x6A16,0x0400,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_1 : Detection window vertical size with all 32 windows for FLC full frame pixel +{0x6A18,0x03C0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_2 : Detection window vertical size with all 32 windows for FLC 1/2 sub-sampling +{0x6A1A,0x01E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_4 : Detection window vertical size with all 32 windows for FLC 1/4 sub-sampling +{0x6A1C,0x00E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_8 : Detection window vertical size with all 32 windows for FLC 1/8 sub-sampling +{0x6A1E,0x0400,0x02}, // FLC_OPD_HEIGHT_HD_1_1 : Detection window vertical size with all 32 windows for FLC HD full frame pixel +{0x6A20,0x02C0,0x02}, // FLC_OPD_HEIGHT_HD_1_2 : Detection window vertical size with all 32 windows for FLC HD 1/2 sub-sampling +{0x0016,0x0010,0x02}, // GPIO_FUNCSEL : GPIO setting +{0x5C01,0x00,0x01}, // RGLANESEL : Select 1Lane or 2Lane + +{0x5C04,0x06,0x01}, // RGTLPX : //0x5C04 0x4 -> 0x6 +{0x5C05,0x05,0x01}, // RGTCLKPREPARE : //0x5C05 0x3 -> 0x5 +{0x5C06,0x14,0x01}, // RGTCLKZERO : +{0x5C07,0x02,0x01}, // RGTCLKPRE : +{0x5C08,0x0D,0x01}, // RGTCLKPOST : //0x5C08 0x11 -> 0xD +{0x5C09,0x07,0x01}, // RGTCLKTRAIL : //0x5C09 0x5 -> 0x7 +{0x5C0A,0x0A,0x01}, // RGTHSEXIT : //0x5C0A 0x7 -> 0xA +{0x5C0B,0x05,0x01}, // RGTHSPREPARE : //0x5C0B 0x3 -> 0x5 +{0x5C0C,0x08,0x01}, // RGTHSZERO : //0x5C0C 0x7 -> 0x8 +{0x5C0D,0x07,0x01}, // RGTHSTRAIL : //0x5C0D 0x5 -> 0x7 + +{0x0009,0x01,0x01}, // EXT_PLL_CKSEL : PLL 648MHz +{0x00D0,0x11,0x01}, // VIF_CLKCONFIG_EXT1 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG and interleave mode +{0x00D1,0x11,0x01}, // VIF_CLKCONFIG_EXT2 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG and interleave mode +{0x00D4,0x11,0x01}, // VIF_CLKCONFIG_EXT5 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG mode +{0x00D5,0x11,0x01}, // VIF_CLKCONFIG_EXT6 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG mode +{0x00D8,0x11,0x01}, // VIF_CLKCONFIG_EXT9 : VIFSEL and VIFDIV setting value with full frame pixel setting for other than JPG +{0x00D9,0x11,0x01}, // VIF_CLKCONFIG_EXT10 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other than JPG + +//init Preview setting +{0x0089,0x00,0x01},//OUTFMT_MONI +{0x0090,0x0280,0x02},//HSIZE_MONI : 640 +{0x0096,0x01E0,0x02},//VSIZE_MONI : 480 +{0x0083,0x01,0x01},//SENSMODE_MONI +{0x0086,0x02,0x01},//FPSTYPE_MONI +{0x0081,0x00,0x01},//MODESEL +{0x0082,0x01,0x01},//MONI_REFRESH + +//jpeg setting +//Apex40 is not Jpeg Capture + +//Fast mode setting +{0x500A,0x00,0x01}, // FAST_MODECHG_EN +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x500C,0x00FA,0x02}, // FAST_SHT_LIMIT_COUNT + +//Select sensor inversion link control +{0x501A,0x00,0x01}, //SENS_REVERSE_CTRL + +//shading +{0x6DBC,0x03,0x01}, // WHITE_EDGE_MAX : +{0x6DF6,0xFF,0x01}, // WHITE_SHD_JUDGE_BODY_COLOR_RATIO : +{0x6DF7,0xF0,0x01}, // WHITE_SHD_JUDGE_RED_RATIO : +{0x6DAD,0x0C,0x01}, // WHITE_OFSET1_UP : +{0x6DAE,0x0C,0x01}, // WHITE_OFSET1_DOWN : +{0x6DAF,0x11,0x01}, // WHITE_OFSET1_RIGHT : +{0x6DB0,0x1B,0x01}, // WHITE_OFSET1_LEFT : +{0x6DB1,0x0D,0x01}, // WHITE_OFSET2_UP : +{0x6DB2,0x13,0x01}, // WHITE_OFSET2_DOWN : +{0x6DB3,0x11,0x01}, // WHITE_OFSET2_RIGHT : +{0x6DB4,0x17,0x01}, // WHITE_OFSET2_LEFT : + +//addtional code +{0xF200,0xB9B9,0x02}, +{0xF202,0x4E12,0x02}, +{0xF204,0x6055,0x02}, +{0xF206,0x008B,0x02}, +{0xF208,0xF177,0x02}, +{0xF20A,0xFA70,0x02}, +{0xF20C,0x0000,0x02}, +{0xF20E,0x0000,0x02}, +{0xF210,0x0000,0x02}, +{0xF212,0x0000,0x02}, +{0xF214,0x0000,0x02}, +{0xF216,0x0000,0x02}, +{0xF218,0x0000,0x02}, +{0xF21A,0x0000,0x02}, +{0xF21C,0x0000,0x02}, +{0xF21E,0x0000,0x02}, +{0xF220,0x0000,0x02}, +{0xF222,0x0000,0x02}, +{0xF224,0x0000,0x02}, +{0xF226,0x0000,0x02}, +{0xF228,0x0000,0x02}, +{0xF22A,0x0000,0x02}, +{0xF22C,0x0000,0x02}, +{0xF22E,0x0000,0x02}, +{0xF230,0x0000,0x02}, +{0xF232,0x0000,0x02}, +{0xF234,0x0000,0x02}, +{0xF236,0x0000,0x02}, +{0xF238,0x0000,0x02}, +{0xF23A,0x0000,0x02}, +{0xF23C,0x0000,0x02}, +{0xF23E,0x0000,0x02}, +{0xF240,0x0000,0x02}, +{0xF242,0x0000,0x02}, +{0xF244,0xB47E,0x02}, +{0xF246,0x4808,0x02}, +{0xF248,0x7800,0x02}, +{0xF24A,0x07C0,0x02}, +{0xF24C,0x0FC0,0x02}, +{0xF24E,0xF687,0x02}, +{0xF250,0xF8ED,0x02}, +{0xF252,0xF68E,0x02}, +{0xF254,0xFE2B,0x02}, +{0xF256,0xF688,0x02}, +{0xF258,0xFF6B,0x02}, +{0xF25A,0xF693,0x02}, +{0xF25C,0xFB6B,0x02}, +{0xF25E,0xF687,0x02}, +{0xF260,0xF947,0x02}, +{0xF262,0xBC7E,0x02}, +{0xF264,0xF688,0x02}, +{0xF266,0xFD8F,0x02}, +{0xF268,0x239C,0x02}, +{0xF26A,0x0018,0x02}, + + +{0x0006,0x16,0x01}, //INCK_SET : 24MHz +}; + +// ISX012-0 +// MIPI 2LANE 432/LANE +// PLL 432MHz +// DCK 54 +// inifile +// size address data +// +static const isx012_regset_t ISX012_Pll_Setting_3[] = +{ +{0x0007,0x00,0x01}, // PLL_CKSEL : PLL 432MHz +{0x0008,0x00,0x01}, // SRCCK_DIV : 1/5 frequency + +{0x0004,0x03,0x01}, //I2C_ADR_SEL 2: 0x3C MIPI selected, 3: 0x3D MIPI selected +{0x5008,0x00,0x01}, //ENDIAN_SEL : 0:Little Endian +{0x6DA8,0x01,0x01}, //SHD_CoEF (OTP shading ON flag) +{0x6DA9,0x09,0x01}, // WHITE_CTRL +{0x6DCB,0x22,0x01}, // YGAM_CONFIG2 : + +{0x00C4,0x11,0x01}, // VIF_CLKCONFIG1 : VIFSEL and VIFDIV setting value with full frame pixel setting for other then JPG +{0x00C5,0x11,0x01}, // VIF_CLKCONFIG2 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other then JPG +{0x00C6,0x11,0x01}, // VIF_CLKCONFIG3 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for other then JPG +{0x00C7,0x11,0x01}, // VIF_CLKCONFIG4 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for other then JPG +{0x00C8,0x11,0x01}, // VIF_CLKCONFIG5 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG mode +{0x00C9,0x11,0x01}, // VIF_CLKCONFIG6 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG mode +{0x00CA,0x11,0x01}, // VIF_CLKCONFIG7 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for JPG mode +{0x00CC,0x11,0x01}, // VIF_CLKCONFIG9 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG and interleave mode +{0x00CD,0x11,0x01}, // VIF_CLKCONFIG10 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG and interleave mode +{0x6A12,0x11,0x01}, // VIF_CLKCONFIG13 for RAW8 : VIFSEL and VIFDIV setting value with full frame pixel setting for RAW mode +{0x6A13,0x11,0x01}, // VIF_CLKCONFIG14 for RAW8 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for RAW mode +{0x6A14,0x11,0x01}, // VIF_CLKCONFIG15 for RAW8 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for RAW mode +{0x6A15,0x11,0x01}, // VIF_CLKCONFIG16 for RAW8 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for RAW mode +{0x018C,0x0000,0x02}, // VADJ_SENS_1_1 : VMAX adjustment value for full frame pixel +{0x018E,0x0012,0x02}, // VADJ_SENS_1_2 : VMAX adjustment value for 1/2 sub-sampling +{0x0190,0x0000,0x02}, // VADJ_SENS_1_4 : VMAX adjustment value for 1/4 sub-sampling +{0x0192,0x0000,0x02}, // VADJ_SENS_1_8 : VMAX adjustment value for 1/8 sub-sampling +{0x0194,0x0027,0x02}, // VADJ_SENS_HD_1_1 : VMAX adjustment value for HD full frame pixel +{0x0196,0x0015,0x02}, // VADJ_SENS_HD_1_2 : VMAX adjustment value for HD 1/2 sub-sampling +{0x6A16,0x0440,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_1 : Detection window vertical size with all 32 windows for FLC full frame pixel +{0x6A18,0x03C0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_2 : Detection window vertical size with all 32 windows for FLC 1/2 sub-sampling +{0x6A1A,0x01E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_4 : Detection window vertical size with all 32 windows for FLC 1/4 sub-sampling +{0x6A1C,0x00E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_8 : Detection window vertical size with all 32 windows for FLC 1/8 sub-sampling +{0x6A1E,0x0420,0x02}, // FLC_OPD_HEIGHT_HD_1_1 : Detection window vertical size with all 32 windows for FLC HD full frame pixel +{0x6A20,0x02C0,0x02}, // FLC_OPD_HEIGHT_HD_1_2 : Detection window vertical size with all 32 windows for FLC HD 1/2 sub-sampling +{0x0016,0x0010,0x02}, // GPIO_FUNCSEL : GPIO setting +{0x5C01,0x00,0x01}, // RGLANESEL : +{0x5C04,0x04,0x01}, // RGTLPX : +{0x5C05,0x03,0x01}, // RGTCLKPREPARE : +{0x5C06,0x0E,0x01}, // RGTCLKZERO : +{0x5C07,0x02,0x01}, // RGTCLKPRE : +{0x5C08,0x0B,0x01}, // RGTCLKPOST : +{0x5C09,0x05,0x01}, // RGTCLKTRAIL : +{0x5C0A,0x07,0x01}, // RGTHSEXIT : +{0x5C0B,0x03,0x01}, // RGTHSPREPARE : +{0x5C0C,0x07,0x01}, // RGTHSZERO : +{0x5C0D,0x05,0x01}, // RGTHSTRAIL : + +{0x0009,0x01,0x01}, // +{0x000A,0x03,0x01}, // EXT_SRCCK_DIV : 1/8 frequency +{0x00D8,0x11,0x01}, // VIF_CLKCONFIG_EXT9 : VIFSEL and VIFDIV setting value with full frame pixel setting for other than JPG +{0x00D9,0x11,0x01}, // VIF_CLKCONFIG_EXT10 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other than JPG +{0x00DA,0x11,0x01}, // VIF_CLKCONFIG_EXT11 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for other than JPG +{0x00DB,0x11,0x01}, // VIF_CLKCONFIG_EXT12 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for other than JPG +{0x00AC,0x02,0x01}, // + +//init Preview setting +{0x0089,0x00,0x01},//OUTFMT_MONI +{0x0090,0x0280,0x02},//HSIZE_MONI : 640 +{0x0096,0x01E0,0x02},//VSIZE_MONI : 480 +{0x0083,0x01,0x01},//SENSMODE_MONI +{0x0086,0x02,0x01},//FPSTYPE_MONI +{0x0081,0x00,0x01},//MODESEL +{0x0082,0x01,0x01},//MONI_REFRESH + +//jpeg setting +//Apex40 is not Jpeg Capture + +//Fast mode setting +{0x500A,0x00,0x01}, // FAST_MODECHG_EN +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x500C,0x00FA,0x02}, // FAST_SHT_LIMIT_COUNT + +//Select sensor inversion link control +{0x501A,0x00,0x01}, //SENS_REVERSE_CTRL + +//shading +{0x6DBC,0x03,0x01}, // WHITE_EDGE_MAX : +{0x6DF6,0xFF,0x01}, // WHITE_SHD_JUDGE_BODY_COLOR_RATIO : +{0x6DF7,0xF0,0x01}, // WHITE_SHD_JUDGE_RED_RATIO : +{0x6DAD,0x0C,0x01}, // WHITE_OFSET1_UP : +{0x6DAE,0x0C,0x01}, // WHITE_OFSET1_DOWN : +{0x6DAF,0x11,0x01}, // WHITE_OFSET1_RIGHT : +{0x6DB0,0x1B,0x01}, // WHITE_OFSET1_LEFT : +{0x6DB1,0x0D,0x01}, // WHITE_OFSET2_UP : +{0x6DB2,0x13,0x01}, // WHITE_OFSET2_DOWN : +{0x6DB3,0x11,0x01}, // WHITE_OFSET2_RIGHT : +{0x6DB4,0x17,0x01}, // WHITE_OFSET2_LEFT : + +//additional code +{0xF200,0xB9B9,0x02}, +{0xF202,0x4E12,0x02}, +{0xF204,0x6055,0x02}, +{0xF206,0x008B,0x02}, +{0xF208,0xF177,0x02}, +{0xF20A,0xFA70,0x02}, +{0xF20C,0x0000,0x02}, +{0xF20E,0x0000,0x02}, +{0xF210,0x0000,0x02}, +{0xF212,0x0000,0x02}, +{0xF214,0x0000,0x02}, +{0xF216,0x0000,0x02}, +{0xF218,0x0000,0x02}, +{0xF21A,0x0000,0x02}, +{0xF21C,0x0000,0x02}, +{0xF21E,0x0000,0x02}, +{0xF220,0x0000,0x02}, +{0xF222,0x0000,0x02}, +{0xF224,0x0000,0x02}, +{0xF226,0x0000,0x02}, +{0xF228,0x0000,0x02}, +{0xF22A,0x0000,0x02}, +{0xF22C,0x0000,0x02}, +{0xF22E,0x0000,0x02}, +{0xF230,0x0000,0x02}, +{0xF232,0x0000,0x02}, +{0xF234,0x0000,0x02}, +{0xF236,0x0000,0x02}, +{0xF238,0x0000,0x02}, +{0xF23A,0x0000,0x02}, +{0xF23C,0x0000,0x02}, +{0xF23E,0x0000,0x02}, +{0xF240,0x0000,0x02}, +{0xF242,0x0000,0x02}, +{0xF244,0xB47E,0x02}, +{0xF246,0x4808,0x02}, +{0xF248,0x7800,0x02}, +{0xF24A,0x07C0,0x02}, +{0xF24C,0x0FC0,0x02}, +{0xF24E,0xF687,0x02}, +{0xF250,0xF8ED,0x02}, +{0xF252,0xF68E,0x02}, +{0xF254,0xFE2B,0x02}, +{0xF256,0xF688,0x02}, +{0xF258,0xFF6B,0x02}, +{0xF25A,0xF693,0x02}, +{0xF25C,0xFB6B,0x02}, +{0xF25E,0xF687,0x02}, +{0xF260,0xF947,0x02}, +{0xF262,0xBC7E,0x02}, +{0xF264,0xF688,0x02}, +{0xF266,0xFD8F,0x02}, +{0xF268,0x239C,0x02}, +{0xF26A,0x0018,0x02}, + +{0x0006,0x16,0x01}, //INCK_SET : 24MHz +}; + +// ISX012-0 +// MIPI 2LANE 432/LANE +// PLL 432MHz +// DCK 54 +// inifile +// size address data +// +static const isx012_regset_t ISX012_Pll_Setting_4[] = +{ +{0x0007,0x00,0x01}, // PLL_CKSEL : PLL 432MHz +{0x0008,0x00,0x01}, // SRCCK_DIV : 1/5 frequency + +{0x0004,0x03,0x01}, //I2C_ADR_SEL 2: 0x3C MIPI selected, 3: 0x3D MIPI selected +{0x5008,0x00,0x01}, //ENDIAN_SEL : 0:Little Endian +{0x6DA8,0x01,0x01}, //SHD_CoEF (OTP shading ON flag) +{0x6DA9,0x09,0x01}, // WHITE_CTRL +{0x6DCB,0x22,0x01}, // YGAM_CONFIG2 : + +{0x00C4,0x11,0x01}, // VIF_CLKCONFIG1 : VIFSEL and VIFDIV setting value with full frame pixel setting for other then JPG +{0x00C5,0x11,0x01}, // VIF_CLKCONFIG2 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other then JPG +{0x00C6,0x11,0x01}, // VIF_CLKCONFIG3 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for other then JPG +{0x00C7,0x11,0x01}, // VIF_CLKCONFIG4 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for other then JPG +{0x00C8,0x11,0x01}, // VIF_CLKCONFIG5 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG mode +{0x00C9,0x11,0x01}, // VIF_CLKCONFIG6 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG mode +{0x00CA,0x11,0x01}, // VIF_CLKCONFIG7 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for JPG mode +{0x00CC,0x11,0x01}, // VIF_CLKCONFIG9 : VIFSEL and VIFDIV setting value with full frame pixel setting for JPG and interleave mode +{0x00CD,0x11,0x01}, // VIF_CLKCONFIG10 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for JPG and interleave mode +{0x6A12,0x11,0x01}, // VIF_CLKCONFIG13 for RAW8 : VIFSEL and VIFDIV setting value with full frame pixel setting for RAW mode +{0x6A13,0x11,0x01}, // VIF_CLKCONFIG14 for RAW8 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for RAW mode +{0x6A14,0x11,0x01}, // VIF_CLKCONFIG15 for RAW8 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for RAW mode +{0x6A15,0x11,0x01}, // VIF_CLKCONFIG16 for RAW8 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for RAW mode +{0x018C,0x0026,0x02}, // VADJ_SENS_1_1 : VMAX adjustment value for full frame pixel +{0x018E,0x0012,0x02}, // VADJ_SENS_1_2 : VMAX adjustment value for 1/2 sub-sampling +{0x0190,0x0000,0x02}, // VADJ_SENS_1_4 : VMAX adjustment value for 1/4 sub-sampling +{0x0192,0x0000,0x02}, // VADJ_SENS_1_8 : VMAX adjustment value for 1/8 sub-sampling +{0x0194,0x0027,0x02}, // VADJ_SENS_HD_1_1 : VMAX adjustment value for HD full frame pixel +{0x0196,0x0015,0x02}, // VADJ_SENS_HD_1_2 : VMAX adjustment value for HD 1/2 sub-sampling +{0x6A16,0x0440,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_1 : Detection window vertical size with all 32 windows for FLC full frame pixel +{0x6A18,0x03C0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_2 : Detection window vertical size with all 32 windows for FLC 1/2 sub-sampling +{0x6A1A,0x01E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_4 : Detection window vertical size with all 32 windows for FLC 1/4 sub-sampling +{0x6A1C,0x00E0,0x02}, // FLC_OPD_HEIGHT_NORMAL_1_8 : Detection window vertical size with all 32 windows for FLC 1/8 sub-sampling +{0x6A1E,0x0420,0x02}, // FLC_OPD_HEIGHT_HD_1_1 : Detection window vertical size with all 32 windows for FLC HD full frame pixel +{0x6A20,0x02C0,0x02}, // FLC_OPD_HEIGHT_HD_1_2 : Detection window vertical size with all 32 windows for FLC HD 1/2 sub-sampling +{0x0016,0x0010,0x02}, // GPIO_FUNCSEL : GPIO setting +{0x5C01,0x00,0x01}, // RGLANESEL : +{0x5C04,0x04,0x01}, // RGTLPX : +{0x5C05,0x03,0x01}, // RGTCLKPREPARE : +{0x5C06,0x0E,0x01}, // RGTCLKZERO : +{0x5C07,0x02,0x01}, // RGTCLKPRE : +{0x5C08,0x0B,0x01}, // RGTCLKPOST : +{0x5C09,0x05,0x01}, // RGTCLKTRAIL : +{0x5C0A,0x07,0x01}, // RGTHSEXIT : +{0x5C0B,0x03,0x01}, // RGTHSPREPARE : +{0x5C0C,0x07,0x01}, // RGTHSZERO : +{0x5C0D,0x05,0x01}, // RGTHSTRAIL : + +{0x6A9E,0x15C0,0x02}, //HMAX_1_1(0x6A9E)=0x15C0 + +{0x0009,0x01,0x01}, // +{0x000A,0x03,0x01}, // EXT_SRCCK_DIV : 1/8 frequency +{0x00D8,0x11,0x01}, // VIF_CLKCONFIG_EXT9 : VIFSEL and VIFDIV setting value with full frame pixel setting for other than JPG +{0x00D9,0x11,0x01}, // VIF_CLKCONFIG_EXT10 : VIFSEL and VIFDIV setting value with 1/2 sub-sampling setting for other than JPG +{0x00DA,0x11,0x01}, // VIF_CLKCONFIG_EXT11 : VIFSEL and VIFDIV setting value with 1/4 sub-sampling setting for other than JPG +{0x00DB,0x11,0x01}, // VIF_CLKCONFIG_EXT12 : VIFSEL and VIFDIV setting value with 1/8 sub-sampling setting for other than JPG +{0x00AC,0x00,0x01}, // + +//init Preview setting +{0x0089,0x00,0x01},//OUTFMT_MONI +{0x0090,0x0280,0x02},//HSIZE_MONI : 640 +{0x0096,0x01E0,0x02},//VSIZE_MONI : 480 +{0x0083,0x01,0x01},//SENSMODE_MONI +{0x0086,0x02,0x01},//FPSTYPE_MONI +{0x0081,0x00,0x01},//MODESEL +{0x0082,0x01,0x01},//MONI_REFRESH + +//jpeg setting +//Apex40 is not Jpeg Capture + +//Fast mode setting +{0x500A,0x00,0x01}, // FAST_MODECHG_EN +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x500C,0x00FA,0x02}, // FAST_SHT_LIMIT_COUNT + +//Select sensor inversion link control +{0x501A,0x00,0x01}, //SENS_REVERSE_CTRL + +//shading +{0x6DBC,0x03,0x01}, // WHITE_EDGE_MAX : +{0x6DF6,0xFF,0x01}, // WHITE_SHD_JUDGE_BODY_COLOR_RATIO : +{0x6DF7,0xF0,0x01}, // WHITE_SHD_JUDGE_RED_RATIO : +{0x6DAD,0x0C,0x01}, // WHITE_OFSET1_UP : +{0x6DAE,0x0C,0x01}, // WHITE_OFSET1_DOWN : +{0x6DAF,0x11,0x01}, // WHITE_OFSET1_RIGHT : +{0x6DB0,0x1B,0x01}, // WHITE_OFSET1_LEFT : +{0x6DB1,0x0D,0x01}, // WHITE_OFSET2_UP : +{0x6DB2,0x13,0x01}, // WHITE_OFSET2_DOWN : +{0x6DB3,0x11,0x01}, // WHITE_OFSET2_RIGHT : +{0x6DB4,0x17,0x01}, // WHITE_OFSET2_LEFT : + +//additional code +{0xF200,0xB9B9,0x02}, +{0xF202,0x4E12,0x02}, +{0xF204,0x6055,0x02}, +{0xF206,0x008B,0x02}, +{0xF208,0xF177,0x02}, +{0xF20A,0xFA70,0x02}, +{0xF20C,0x0000,0x02}, +{0xF20E,0x0000,0x02}, +{0xF210,0x0000,0x02}, +{0xF212,0x0000,0x02}, +{0xF214,0x0000,0x02}, +{0xF216,0x0000,0x02}, +{0xF218,0x0000,0x02}, +{0xF21A,0x0000,0x02}, +{0xF21C,0x0000,0x02}, +{0xF21E,0x0000,0x02}, +{0xF220,0x0000,0x02}, +{0xF222,0x0000,0x02}, +{0xF224,0x0000,0x02}, +{0xF226,0x0000,0x02}, +{0xF228,0x0000,0x02}, +{0xF22A,0x0000,0x02}, +{0xF22C,0x0000,0x02}, +{0xF22E,0x0000,0x02}, +{0xF230,0x0000,0x02}, +{0xF232,0x0000,0x02}, +{0xF234,0x0000,0x02}, +{0xF236,0x0000,0x02}, +{0xF238,0x0000,0x02}, +{0xF23A,0x0000,0x02}, +{0xF23C,0x0000,0x02}, +{0xF23E,0x0000,0x02}, +{0xF240,0x0000,0x02}, +{0xF242,0x0000,0x02}, +{0xF244,0xB47E,0x02}, +{0xF246,0x4808,0x02}, +{0xF248,0x7800,0x02}, +{0xF24A,0x07C0,0x02}, +{0xF24C,0x0FC0,0x02}, +{0xF24E,0xF687,0x02}, +{0xF250,0xF8ED,0x02}, +{0xF252,0xF68E,0x02}, +{0xF254,0xFE2B,0x02}, +{0xF256,0xF688,0x02}, +{0xF258,0xFF6B,0x02}, +{0xF25A,0xF693,0x02}, +{0xF25C,0xFB6B,0x02}, +{0xF25E,0xF687,0x02}, +{0xF260,0xF947,0x02}, +{0xF262,0xBC7E,0x02}, +{0xF264,0xF688,0x02}, +{0xF266,0xFD8F,0x02}, +{0xF268,0x239C,0x02}, +{0xF26A,0x0018,0x02}, + +{0x0006,0x16,0x01}, //INCK_SET : 24MHz +}; + +static const isx012_regset_t ISX012_Preview_SizeSetting[] = +{ +{0x0090,0x0280,0x02}, //HSIZE_MONI : 640 +{0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 +}; + +static const isx012_regset_t ISX012_Preview_Mode[] = +{ +{0x5000,0x00,0x01}, /* CPUEXT, added by SAMSUNG TN */ +{0x5E32,0x0F,0x01}, /* for Fast-AE reset */ +{0x5E3D,0x0A,0x01}, /* for Fast-AE reset */ +{0x0181,0x00,0x01}, // CAP_HALF_AE_CTRL + +{0x0089,0x00,0x01}, //OUTFMT_MONI +{0x0083,0x01,0x01}, //SENSMODE_MONI +{0x0086,0x02,0x01}, //FPSTYPE_MONI +{0x0012,0xFF,0x01}, //INTCLR0 +{0x00F7,0x52,0x01}, // INIT_QLTY0 : Standard 82 +{0x00F8,0x59,0x01}, // INIT_QLTY1 : Fine 89 +{0x00F9,0x5F,0x01}, // INIT_QLTY2 : SuperFine 95 +{0x0081,0x00,0x01}, //MODESEL +{0x0082,0x01,0x01}, //MONI_REFRESH +{0xFFFF,0x1E,0x01}, //$wait,30 +}; + +static const isx012_regset_t ISX012_Camcorder_Mode_ON[] = +{ +//SN setting +{0x0308,0x02,0x01}, // AELINE_MONI_SN1_2 : +{0x0320,0x02,0x01}, // AELINE_MONI_SN1_2 : +{0x00B2,0x02,0x01}, /* AFMODE_MONI : manual mode */ + +//BRIGHTNESS setting +{0x01C6,0x10,0x01}, //UIBRIGHTNESS + +//AE speed +{0x02AC,0x00,0x01}, // AE_SUB_SN1 : +{0x5E2D,0x0C,0x01}, // AEMOVECNT : +{0x5E2E,0x20,0x01}, // AEINDEADBAND : +{0x5E2F,0x08,0x01}, // AEOUTDEADBAND : +{0x5E30,0xA0,0x01}, // AESPEED : + +{0x5E31,0x0F,0x01}, // AESPEED_INIT : +{0x5E32,0x0F,0x01}, // AESPEED_FAST : + +{0x621E,0x18,0x01}, // AIM_NR_TH_UP : +{0x621F,0x18,0x01}, // AIM_NR_TH_DOWN : +{0x6220,0x18,0x01}, // AIM_NR_TH_RIGHT : +{0x6221,0x18,0x01}, // AIM_NR_TH_LEFT : + +//AWB speed +{0x6222,0x00,0x01}, // INIT_AIMW : +{0x6223,0x04,0x01}, // INIT_GAINS : +{0x6224,0x10,0x01}, // ATW_DELAY : +{0x6225,0x00,0x01}, // ATW_AIMW : + +{0x6226,0x20,0x01}, // ATW_GAINS_IN_NR : +{0x6227,0x30,0x01}, // ATW_GAINS_IN : +{0x6228,0x20,0x01}, // ATW_GAINS_OUT_NR : +{0x6229,0x30,0x01}, // ATW_GAINS_OUT : +{0x622A,0x0D,0x01}, // ALLWB_GAINS : + +//Gammma Table 0 +{0x7000,0x0000,0x02}, // G0_KNOT_G0 : +{0x7002,0x0000,0x02}, // G0_KNOT_G1 : +{0x7004,0x001E,0x02}, // G0_KNOT_G2 : +{0x7006,0x0038,0x02}, // G0_KNOT_G3 : +{0x7008,0x0046,0x02}, // G0_KNOT_G4 : +{0x700A,0x0053,0x02}, // G0_KNOT_G5 : +{0x700C,0x005A,0x02}, // G0_KNOT_G6 : +{0x700E,0x0063,0x02}, // G0_KNOT_G7 : +{0x7010,0x006D,0x02}, // G0_KNOT_G8 : +{0x7012,0x0076,0x02}, // G0_KNOT_G9 : +{0x7014,0x0055,0x02}, // G0_KNOT_G10 : +{0x7016,0x008E,0x02}, // G0_KNOT_G11 : +{0x7018,0x00B9,0x02}, // G0_KNOT_G12 : +{0x701A,0x00D5,0x02}, // G0_KNOT_G13 : +{0x701C,0x00E4,0x02}, // G0_KNOT_G14 : +{0x701E,0x00F0,0x02}, // G0_KNOT_G15 : +{0x7020,0x00F9,0x02}, // G0_KNOT_G16 : +{0x7022,0x0103,0x02}, // G0_KNOT_G17 : +{0x7024,0x010C,0x02}, // G0_KNOT_G18 : +{0x7026,0x00,0x01}, // G0_KNOT_R0_OFFSET : +{0x7027,0x00,0x01}, // G0_KNOT_R2_OFFSET : +{0x7028,0x00,0x01}, // G0_KNOT_R4_OFFSET : +{0x7029,0x00,0x01}, // G0_KNOT_R6_OFFSET : +{0x702A,0x00,0x01}, // G0_KNOT_R8_OFFSET : +{0x702B,0x00,0x01}, // G0_KNOT_R10_OFFSET : +{0x702C,0x00,0x01}, // G0_KNOT_R12_OFFSET : +{0x702D,0x00,0x01}, // G0_KNOT_R14_OFFSET : +{0x702E,0x00,0x01}, // G0_KNOT_R16_OFFSET : +{0x702F,0x00,0x01}, // G0_KNOT_R18_OFFSET : +{0x7030,0x00,0x01}, // G0_KNOT_B0_OFFSET : +{0x7031,0x00,0x01}, // G0_KNOT_B2_OFFSET : +{0x7032,0x00,0x01}, // G0_KNOT_B4_OFFSET : +{0x7033,0x00,0x01}, // G0_KNOT_B6_OFFSET : +{0x7034,0x00,0x01}, // G0_KNOT_B8_OFFSET : +{0x7035,0x00,0x01}, // G0_KNOT_B10_OFFSET : +{0x7036,0x00,0x01}, // G0_KNOT_B12_OFFSET : +{0x7037,0x00,0x01}, // G0_KNOT_B14_OFFSET : +{0x7038,0x00,0x01}, // G0_KNOT_B16_OFFSET : +{0x7039,0x00,0x01}, // G0_KNOT_B18_OFFSET : +{0x703A,0x0611,0x02}, // G0_LOWGM_ON_R : +{0x703C,0x1E0A,0x02}, // G0_0CLIP_R : +{0x703E,0x0611,0x02}, // G0_LOWGM_ON_G : +{0x7040,0x1E0A,0x02}, // G0_0CLIP_G : +{0x7042,0x0611,0x02}, // G0_LOWGM_ON_B : +{0x7044,0x1E0A,0x02}, // G0_0CLIP_B : +{0x7046,0x91,0x01}, // G0_KNOT_GAINCTRL_TH_L : +{0x7047,0x96,0x01}, // G0_KNOT_GAINCTRL_TH_H : +{0x7048,0x0000,0x02}, // G0_KNOT_L_G0 : +{0x704A,0x0000,0x02}, // G0_KNOT_L_G1 : +{0x704C,0x000E,0x02}, // G0_KNOT_L_G2 : +{0x704E,0x002F,0x02}, // G0_KNOT_L_G3 : +{0x7050,0x003D,0x02}, // G0_KNOT_L_G4 : +{0x7052,0x004A,0x02}, // G0_KNOT_L_G5 : +{0x7054,0x0051,0x02}, // G0_KNOT_L_G6 : +{0x7056,0x005A,0x02}, // G0_KNOT_L_G7 : +{0x7058,0x0061,0x02}, // G0_KNOT_L_G8 : +{0x705A,0x006A,0x02}, // G0_KNOT_L_G9 : +{0x705C,0x0049,0x02}, // G0_KNOT_L_G10 : +{0x705E,0x0082,0x02}, // G0_KNOT_L_G11 : +{0x7060,0x00AD,0x02}, // G0_KNOT_L_G12 : +{0x7062,0x00CC,0x02}, // G0_KNOT_L_G13 : +{0x7064,0x00E1,0x02}, // G0_KNOT_L_G14 : +{0x7066,0x00ED,0x02}, // G0_KNOT_L_G15 : +{0x7068,0x00F6,0x02}, // G0_KNOT_L_G16 : +{0x706A,0x0106,0x02}, // G0_KNOT_L_G17 : +{0x706C,0x010C,0x02}, // G0_KNOT_L_G18 : + + +{0x6400,0x00,0x01}, // INFRM_LEFT00 : +{0x6401,0x00,0x01}, // INFRM_LEFT01 : +{0x6402,0x00,0x01}, // INFRM_LEFT02 : +{0x6403,0x00,0x01}, // INFRM_LEFT03 : +{0x6404,0x00,0x01}, // INFRM_LEFT04 : +{0x6405,0x00,0x01}, // INFRM_LEFT05 : +{0x6406,0x00,0x01}, // INFRM_LEFT06 : +{0x6407,0x00,0x01}, // INFRM_LEFT07 : +{0x6408,0x00,0x01}, // INFRM_LEFT08 : +{0x6409,0x00,0x01}, // INFRM_LEFT09 : +{0x640A,0x00,0x01}, // INFRM_LEFT10 : +{0x640B,0x00,0x01}, // INFRM_LEFT11 : +{0x640C,0x00,0x01}, // INFRM_LEFT12 : +{0x640D,0x00,0x01}, // INFRM_LEFT13 : +{0x640E,0x00,0x01}, // INFRM_LEFT14 : +{0x640F,0x00,0x01}, // INFRM_LEFT15 : +{0x6410,0x00,0x01}, // INFRM_LEFT16 : +{0x6411,0x00,0x01}, // INFRM_LEFT17 : +{0x6412,0x00,0x01}, // INFRM_LEFT18 : +{0x6413,0x00,0x01}, // INFRM_LEFT19 : +{0x6414,0x00,0x01}, // INFRM_LEFT20 : +{0x6415,0x00,0x01}, // INFRM_LEFT21 : +{0x6416,0x00,0x01}, // INFRM_LEFT22 : +{0x6417,0x00,0x01}, // INFRM_LEFT23 : +{0x6418,0x00,0x01}, // INFRM_LEFT24 : +{0x6419,0x00,0x01}, // INFRM_LEFT25 : +{0x641A,0x00,0x01}, // INFRM_LEFT26 : +{0x641B,0x00,0x01}, // INFRM_LEFT27 : +{0x641C,0x00,0x01}, // INFRM_LEFT28 : +{0x641D,0x00,0x01}, // INFRM_LEFT29 : +{0x641E,0x00,0x01}, // INFRM_LEFT30 : +{0x641F,0x00,0x01}, // INFRM_LEFT31 : +{0x6420,0x00,0x01}, // INFRM_LEFT32 : +{0x6421,0x00,0x01}, // INFRM_LEFT33 : +{0x6422,0x00,0x01}, // INFRM_LEFT34 : +{0x6423,0x00,0x01}, // INFRM_LEFT35 : +{0x6424,0x00,0x01}, // INFRM_LEFT36 : +{0x6425,0x00,0x01}, // INFRM_LEFT37 : +{0x6426,0xFF,0x01}, // INFRM_RIGHT00 : +{0x6427,0xFF,0x01}, // INFRM_RIGHT01 : +{0x6428,0xFF,0x01}, // INFRM_RIGHT02 : +{0x6429,0xFF,0x01}, // INFRM_RIGHT03 : +{0x642A,0xFF,0x01}, // INFRM_RIGHT04 : +{0x642B,0xFF,0x01}, // INFRM_RIGHT05 : +{0x642C,0xFF,0x01}, // INFRM_RIGHT06 : +{0x642D,0xFF,0x01}, // INFRM_RIGHT07 : +{0x642E,0xFF,0x01}, // INFRM_RIGHT08 : +{0x642F,0xFF,0x01}, // INFRM_RIGHT09 : +{0x6430,0xFF,0x01}, // INFRM_RIGHT10 : +{0x6431,0xFF,0x01}, // INFRM_RIGHT11 : +{0x6432,0xFF,0x01}, // INFRM_RIGHT12 : +{0x6433,0xFF,0x01}, // INFRM_RIGHT13 : +{0x6434,0xFF,0x01}, // INFRM_RIGHT14 : +{0x6435,0xFF,0x01}, // INFRM_RIGHT15 : +{0x6436,0xFF,0x01}, // INFRM_RIGHT16 : +{0x6437,0xFF,0x01}, // INFRM_RIGHT17 : +{0x6438,0xFF,0x01}, // INFRM_RIGHT18 : +{0x6439,0xFF,0x01}, // INFRM_RIGHT19 : +{0x643A,0xFF,0x01}, // INFRM_RIGHT20 : +{0x643B,0xFF,0x01}, // INFRM_RIGHT21 : +{0x643C,0xFF,0x01}, // INFRM_RIGHT22 : +{0x643D,0xFF,0x01}, // INFRM_RIGHT23 : +{0x643E,0xFF,0x01}, // INFRM_RIGHT24 : +{0x643F,0xFF,0x01}, // INFRM_RIGHT25 : +{0x6440,0xFF,0x01}, // INFRM_RIGHT26 : +{0x6441,0xFF,0x01}, // INFRM_RIGHT27 : +{0x6442,0xFF,0x01}, // INFRM_RIGHT28 : +{0x6443,0xFF,0x01}, // INFRM_RIGHT29 : +{0x6444,0xFF,0x01}, // INFRM_RIGHT30 : +{0x6445,0xFF,0x01}, // INFRM_RIGHT31 : +{0x6446,0xFF,0x01}, // INFRM_RIGHT32 : +{0x6447,0xFF,0x01}, // INFRM_RIGHT33 : +{0x6448,0xFF,0x01}, // INFRM_RIGHT34 : +{0x6449,0xFF,0x01}, // INFRM_RIGHT35 : +{0x644A,0xFF,0x01}, // INFRM_RIGHT36 : +{0x644B,0xFF,0x01}, // INFRM_RIGHT37 : +{0x644C,0xFFFF,0x02}, // INFRM_TOP : +{0x644E,0x0000,0x02}, // INFRM_BOTM : +{0x6450,0x25,0x01}, // INFRM_FLTOP : +{0x6451,0x00,0x01}, // INFRM_FLBOTM : +{0x6452,0x91,0x01}, // INAIM_LEFT00 : +{0x6453,0x91,0x01}, // INAIM_LEFT01 : +{0x6454,0x91,0x01}, // INAIM_LEFT02 : +{0x6455,0x91,0x01}, // INAIM_LEFT03 : +{0x6456,0x91,0x01}, // INAIM_LEFT04 : +{0x6457,0x91,0x01}, // INAIM_LEFT05 : +{0x6458,0x91,0x01}, // INAIM_LEFT06 : +{0x6459,0x91,0x01}, // INAIM_LEFT07 : +{0x645A,0x91,0x01}, // INAIM_LEFT08 : +{0x645B,0x91,0x01}, // INAIM_LEFT09 : +{0x645C,0x91,0x01}, // INAIM_LEFT10 : +{0x645D,0x91,0x01}, // INAIM_LEFT11 : +{0x645E,0x91,0x01}, // INAIM_LEFT12 : +{0x645F,0x66,0x01}, // INAIM_LEFT13 : +{0x6460,0x5D,0x01}, // INAIM_LEFT14 : +{0x6461,0x69,0x01}, // INAIM_LEFT15 : +{0x6462,0x54,0x01}, // INAIM_LEFT16 : +{0x6463,0x4B,0x01}, // INAIM_LEFT17 : +{0x6464,0x42,0x01}, // INAIM_LEFT18 : +{0x6465,0x3C,0x01}, // INAIM_LEFT19 : +{0x6466,0x38,0x01}, // INAIM_LEFT20 : +{0x6467,0x36,0x01}, // INAIM_LEFT21 : +{0x6468,0x35,0x01}, // INAIM_LEFT22 : +{0x6469,0x33,0x01}, // INAIM_LEFT23 : +{0x646A,0x32,0x01}, // INAIM_LEFT24 : +{0x646B,0x30,0x01}, // INAIM_LEFT25 : +{0x646C,0x2F,0x01}, // INAIM_LEFT26 : +{0x646D,0x2D,0x01}, // INAIM_LEFT27 : +{0x646E,0x2C,0x01}, // INAIM_LEFT28 : +{0x646F,0x2B,0x01}, // INAIM_LEFT29 : +{0x6470,0x2A,0x01}, // INAIM_LEFT30 : +{0x6471,0x28,0x01}, // INAIM_LEFT31 : +{0x6472,0x26,0x01}, // INAIM_LEFT32 : +{0x6473,0x24,0x01}, // INAIM_LEFT33 : +{0x6474,0x29,0x01}, // INAIM_LEFT34 : +{0x6475,0x28,0x01}, // INAIM_LEFT35 : +{0x6476,0x29,0x01}, // INAIM_LEFT36 : +{0x6477,0x26,0x01}, // INAIM_LEFT37 : +{0x6478,0xFF,0x01}, // INAIM_RIGHT00 : +{0x6479,0xFF,0x01}, // INAIM_RIGHT01 : +{0x647A,0xFF,0x01}, // INAIM_RIGHT02 : +{0x647B,0xFF,0x01}, // INAIM_RIGHT03 : +{0x647C,0xFF,0x01}, // INAIM_RIGHT04 : +{0x647D,0xFF,0x01}, // INAIM_RIGHT05 : +{0x647E,0xFF,0x01}, // INAIM_RIGHT06 : +{0x647F,0xFF,0x01}, // INAIM_RIGHT07 : +{0x6480,0xFF,0x01}, // INAIM_RIGHT08 : +{0x6481,0xFF,0x01}, // INAIM_RIGHT09 : +{0x6482,0xD9,0x01}, // INAIM_RIGHT10 : +{0x6483,0xB7,0x01}, // INAIM_RIGHT11 : +{0x6484,0x96,0x01}, // INAIM_RIGHT12 : +{0x6485,0x68,0x01}, // INAIM_RIGHT13 : +{0x6486,0x70,0x01}, // INAIM_RIGHT14 : +{0x6487,0x72,0x01}, // INAIM_RIGHT15 : +{0x6488,0x71,0x01}, // INAIM_RIGHT16 : +{0x6489,0x6B,0x01}, // INAIM_RIGHT17 : +{0x648A,0x65,0x01}, // INAIM_RIGHT18 : +{0x648B,0x60,0x01}, // INAIM_RIGHT19 : +{0x648C,0x5B,0x01}, // INAIM_RIGHT20 : +{0x648D,0x56,0x01}, // INAIM_RIGHT21 : +{0x648E,0x51,0x01}, // INAIM_RIGHT22 : +{0x648F,0x4C,0x01}, // INAIM_RIGHT23 : +{0x6490,0x47,0x01}, // INAIM_RIGHT24 : +{0x6491,0x44,0x01}, // INAIM_RIGHT25 : +{0x6492,0x41,0x01}, // INAIM_RIGHT26 : +{0x6493,0x3E,0x01}, // INAIM_RIGHT27 : +{0x6494,0x3B,0x01}, // INAIM_RIGHT28 : +{0x6495,0x39,0x01}, // INAIM_RIGHT29 : +{0x6496,0x37,0x01}, // INAIM_RIGHT30 : +{0x6497,0x34,0x01}, // INAIM_RIGHT31 : +{0x6498,0x33,0x01}, // INAIM_RIGHT32 : +{0x6499,0x32,0x01}, // INAIM_RIGHT33 : +{0x649A,0x31,0x01}, // INAIM_RIGHT34 : +{0x649B,0x30,0x01}, // INAIM_RIGHT35 : +{0x649C,0x2F,0x01}, // INAIM_RIGHT36 : +{0x649D,0x2E,0x01}, // INAIM_RIGHT37 : +{0x649E,0x1E00,0x02}, // INAIM_TOP : +{0x64A0,0x0F48,0x02}, // INAIM_BOTM : +{0x64A2,0x18,0x01}, // INAIM_FLTOP : +{0x64A3,0x11,0x01}, // INAIM_FLBOTM : +{0x64A4,0x00,0x01}, // OUTFRM_LEFT00 : +{0x64A5,0x00,0x01}, // OUTFRM_LEFT01 : +{0x64A6,0x00,0x01}, // OUTFRM_LEFT02 : +{0x64A7,0x00,0x01}, // OUTFRM_LEFT03 : +{0x64A8,0x00,0x01}, // OUTFRM_LEFT04 : +{0x64A9,0x00,0x01}, // OUTFRM_LEFT05 : +{0x64AA,0x00,0x01}, // OUTFRM_LEFT06 : +{0x64AB,0x00,0x01}, // OUTFRM_LEFT07 : +{0x64AC,0x00,0x01}, // OUTFRM_LEFT08 : +{0x64AD,0x00,0x01}, // OUTFRM_LEFT09 : +{0x64AE,0x00,0x01}, // OUTFRM_LEFT10 : +{0x64AF,0x00,0x01}, // OUTFRM_LEFT11 : +{0x64B0,0x00,0x01}, // OUTFRM_LEFT12 : +{0x64B1,0x00,0x01}, // OUTFRM_LEFT13 : +{0x64B2,0x00,0x01}, // OUTFRM_LEFT14 : +{0x64B3,0x00,0x01}, // OUTFRM_LEFT15 : +{0x64B4,0x00,0x01}, // OUTFRM_LEFT16 : +{0x64B5,0x00,0x01}, // OUTFRM_LEFT17 : +{0x64B6,0x00,0x01}, // OUTFRM_LEFT18 : +{0x64B7,0x00,0x01}, // OUTFRM_LEFT19 : +{0x64B8,0x00,0x01}, // OUTFRM_LEFT20 : +{0x64B9,0x00,0x01}, // OUTFRM_LEFT21 : +{0x64BA,0x00,0x01}, // OUTFRM_LEFT22 : +{0x64BB,0x00,0x01}, // OUTFRM_LEFT23 : +{0x64BC,0x00,0x01}, // OUTFRM_LEFT24 : +{0x64BD,0x00,0x01}, // OUTFRM_LEFT25 : +{0x64BE,0x00,0x01}, // OUTFRM_LEFT26 : +{0x64BF,0x00,0x01}, // OUTFRM_LEFT27 : +{0x64C0,0x00,0x01}, // OUTFRM_LEFT28 : +{0x64C1,0x00,0x01}, // OUTFRM_LEFT29 : +{0x64C2,0x00,0x01}, // OUTFRM_LEFT30 : +{0x64C3,0x00,0x01}, // OUTFRM_LEFT31 : +{0x64C4,0x00,0x01}, // OUTFRM_LEFT32 : +{0x64C5,0x00,0x01}, // OUTFRM_LEFT33 : +{0x64C6,0x00,0x01}, // OUTFRM_LEFT34 : +{0x64C7,0x00,0x01}, // OUTFRM_LEFT35 : +{0x64C8,0x00,0x01}, // OUTFRM_LEFT36 : +{0x64C9,0x00,0x01}, // OUTFRM_LEFT37 : +{0x64CA,0xFF,0x01}, // OUTFRM_RIGHT00 : +{0x64CB,0xFF,0x01}, // OUTFRM_RIGHT01 : +{0x64CC,0xFF,0x01}, // OUTFRM_RIGHT02 : +{0x64CD,0xFF,0x01}, // OUTFRM_RIGHT03 : +{0x64CE,0xFF,0x01}, // OUTFRM_RIGHT04 : +{0x64CF,0xFF,0x01}, // OUTFRM_RIGHT05 : +{0x64D0,0xFF,0x01}, // OUTFRM_RIGHT06 : +{0x64D1,0xFF,0x01}, // OUTFRM_RIGHT07 : +{0x64D2,0xFF,0x01}, // OUTFRM_RIGHT08 : +{0x64D3,0xFF,0x01}, // OUTFRM_RIGHT09 : +{0x64D4,0xFF,0x01}, // OUTFRM_RIGHT10 : +{0x64D5,0xFF,0x01}, // OUTFRM_RIGHT11 : +{0x64D6,0xFF,0x01}, // OUTFRM_RIGHT12 : +{0x64D7,0xFF,0x01}, // OUTFRM_RIGHT13 : +{0x64D8,0xFF,0x01}, // OUTFRM_RIGHT14 : +{0x64D9,0xFF,0x01}, // OUTFRM_RIGHT15 : +{0x64DA,0xFF,0x01}, // OUTFRM_RIGHT16 : +{0x64DB,0xFF,0x01}, // OUTFRM_RIGHT17 : +{0x64DC,0xFF,0x01}, // OUTFRM_RIGHT18 : +{0x64DD,0xFF,0x01}, // OUTFRM_RIGHT19 : +{0x64DE,0xFF,0x01}, // OUTFRM_RIGHT20 : +{0x64DF,0xFF,0x01}, // OUTFRM_RIGHT21 : +{0x64E0,0xFF,0x01}, // OUTFRM_RIGHT22 : +{0x64E1,0xFF,0x01}, // OUTFRM_RIGHT23 : +{0x64E2,0xFF,0x01}, // OUTFRM_RIGHT24 : +{0x64E3,0xFF,0x01}, // OUTFRM_RIGHT25 : +{0x64E4,0xFF,0x01}, // OUTFRM_RIGHT26 : +{0x64E5,0xFF,0x01}, // OUTFRM_RIGHT27 : +{0x64E6,0xFF,0x01}, // OUTFRM_RIGHT28 : +{0x64E7,0xFF,0x01}, // OUTFRM_RIGHT29 : +{0x64E8,0xFF,0x01}, // OUTFRM_RIGHT30 : +{0x64E9,0xFF,0x01}, // OUTFRM_RIGHT31 : +{0x64EA,0xFF,0x01}, // OUTFRM_RIGHT32 : +{0x64EB,0xFF,0x01}, // OUTFRM_RIGHT33 : +{0x64EC,0xFF,0x01}, // OUTFRM_RIGHT34 : +{0x64ED,0xFF,0x01}, // OUTFRM_RIGHT35 : +{0x64EE,0xFF,0x01}, // OUTFRM_RIGHT36 : +{0x64EF,0xFF,0x01}, // OUTFRM_RIGHT37 : +{0x64F0,0x24F0,0x02}, // OUTFRM_TOP : +{0x64F2,0x1400,0x02}, // OUTFRM_BOTM : +{0x64F4,0x37,0x01}, // OUTFRM_FLTOP : +{0x64F5,0x00,0x01}, // OUTFRM_FLBOTM : + +//AWB +{0x6232,0x07,0x01},//ATW_SFTLMT_OUT_NR +{0x6234,0x05,0x01},//ATW_SFTLMT_OUT + +/////MC3 Setting///// +{0x7600,0x07,0x01}, // MC3_PXDEF0_SEL : +{0x7601,0x07,0x01}, // MC3_PYDEF0_SEL : +{0x7602,0x07,0x01}, // MC3_PXDEF1_SEL : +{0x7603,0x07,0x01}, // MC3_PYDEF1_SEL : +{0x7604,0x07,0x01}, // MC3_PXDEF2_SEL : +{0x7605,0x07,0x01}, // MC3_PYDEF2_SEL : +{0x7606,0x07,0x01}, // MC3_PXDEF3_SEL : +{0x7607,0x07,0x01}, // MC3_PYDEF3_SEL : +{0x7608,0x40,0x01}, // MC3_PXDEF0_A : +{0x7609,0x40,0x01}, // MC3_PXDEF0_B : +{0x760A,0x40,0x01}, // MC3_PXDEF0_C : +{0x760B,0x40,0x01}, // MC3_PYDEF0_A : +{0x760C,0x40,0x01}, // MC3_PYDEF0_B : +{0x760D,0x40,0x01}, // MC3_PYDEF0_C : +{0x760E,0x40,0x01}, // MC3_PXDEF1_A : +{0x760F,0x40,0x01}, // MC3_PXDEF1_B : +{0x7610,0x40,0x01}, // MC3_PXDEF1_C : +{0x7611,0x40,0x01}, // MC3_PYDEF1_A : +{0x7612,0x40,0x01}, // MC3_PYDEF1_B : +{0x7613,0x40,0x01}, // MC3_PYDEF1_C : +{0x7614,0x40,0x01}, // MC3_PXDEF2_A : +{0x7615,0x40,0x01}, // MC3_PXDEF2_B : +{0x7616,0x40,0x01}, // MC3_PXDEF2_C : +{0x7617,0x40,0x01}, // MC3_PYDEF2_A : +{0x7618,0x40,0x01}, // MC3_PYDEF2_B : +{0x7619,0x40,0x01}, // MC3_PYDEF2_C : +{0x761A,0x40,0x01}, // MC3_PXDEF3_A : +{0x761B,0x40,0x01}, // MC3_PXDEF3_B : +{0x761C,0x40,0x01}, // MC3_PXDEF3_C : +{0x761D,0x40,0x01}, // MC3_PYDEF3_A : +{0x761E,0x40,0x01}, // MC3_PYDEF3_B : +{0x761F,0x40,0x01}, // MC3_PYDEF3_C : +{0x7620,0x00,0x01}, // MC3_LUMSL0_IN : +{0x7621,0x06,0x01}, // MC3_LUMSL1_IN : +{0x7622,0x03,0x01}, // MC3_LUMSL2_IN : +{0x7623,0x06,0x01}, // MC3_LUMSL3_IN : +{0x7624,0x00,0x01}, // MC3_LUMSL0_OUT : +{0x7625,0x03,0x01}, // MC3_LUMSL1_OUT : +{0x7626,0x00,0x01}, // MC3_LUMSL2_OUT : +{0x7627,0x00,0x01}, // MC3_LUMSL3_OUT : +{0x7628,0x0000,0x02}, // MC3_L0DEF0_IN : +{0x762A,0x008C,0x02}, // MC3_L0DEF1_IN : +{0x762C,0x0078,0x02}, // MC3_L0DEF2_IN : +{0x762E,0x00E6,0x02}, // MC3_L0DEF3_IN : +{0x7630,0x0000,0x02}, // MC3_L0DEF0_OUT : +{0x7632,0x0082,0x02}, // MC3_L0DEF1_OUT : +{0x7634,0x0000,0x02}, // MC3_L0DEF2_OUT : +{0x7636,0x0000,0x02}, // MC3_L0DEF3_OUT : +{0x7638,0x41,0x01}, // MC3_RDEF0_POS1 : +{0x7639,0x10,0x01}, // MC3_RDEF1_POS1 : +{0x763A,0x15,0x01}, // MC3_RDEF2_POS1 : +{0x763B,0x71,0x01}, // MC3_RDEF3_POS1 : +{0x763C,0x41,0x01}, // MC3_RDEF0_POS2 : +{0x763D,0x10,0x01}, // MC3_RDEF1_POS2 : +{0x763E,0x15,0x01}, // MC3_RDEF2_POS2 : +{0x763F,0x71,0x01}, // MC3_RDEF3_POS2 : +{0x7640,0x3C,0x01}, // MC3_RDEF0_POS3 : +{0x7641,0x10,0x01}, // MC3_RDEF1_POS3 : +{0x7642,0x15,0x01}, // MC3_RDEF2_POS3 : +{0x7643,0x71,0x01}, // MC3_RDEF3_POS3 : +{0x7644,0x46,0x01}, // MC3_RDEF0_POS4 : +{0x7645,0x32,0x01}, // MC3_RDEF1_POS4 : +{0x7646,0x15,0x01}, // MC3_RDEF2_POS4 : +{0x7647,0x71,0x01}, // MC3_RDEF3_POS4 : +{0x7648,0x46,0x01}, // MC3_RDEF0_POS5 : +{0x7649,0x32,0x01}, // MC3_RDEF1_POS5 : +{0x764A,0x15,0x01}, // MC3_RDEF2_POS5 : +{0x764B,0x71,0x01}, // MC3_RDEF3_POS5 : +{0x764C,0x46,0x01}, // MC3_RDEF0_POS6 : +{0x764D,0x10,0x01}, // MC3_RDEF1_POS6 : +{0x764E,0x15,0x01}, // MC3_RDEF2_POS6 : +{0x764F,0x71,0x01}, // MC3_RDEF3_POS6 : +{0x7650,0x46,0x01}, // MC3_RDEF0_POS7 : +{0x7651,0x10,0x01}, // MC3_RDEF1_POS7 : +{0x7652,0x15,0x01}, // MC3_RDEF2_POS7 : +{0x7653,0x71,0x01}, // MC3_RDEF3_POS7 : +{0x7654,0x2D,0x01}, // MC3_RDEF0_OUT : +{0x7655,0x10,0x01}, // MC3_RDEF1_OUT : +{0x7656,0x15,0x01}, // MC3_RDEF2_OUT : +{0x7657,0x54,0x01}, // MC3_RDEF3_OUT : +{0x7658,0x46,0x01}, // MC3_RDEF0_R2_POS4 : +{0x7659,0x32,0x01}, // MC3_RDEF1_R2_POS4 : +{0x765A,0x15,0x01}, // MC3_RDEF2_R2_POS4 : +{0x765B,0x71,0x01}, // MC3_RDEF3_R2_POS4 : +{0x765C,0x46,0x01}, // MC3_RDEF0_R2_POS5 : +{0x765D,0x32,0x01}, // MC3_RDEF1_R2_POS5 : +{0x765E,0x15,0x01}, // MC3_RDEF2_R2_POS5 : +{0x765F,0x71,0x01}, // MC3_RDEF3_R2_POS5 : +{0x7660,0xFFBA,0x02}, // MC3_X0DEF0_POS1 : +{0x7662,0xFFBA,0x02}, // MC3_Y0DEF0_POS1 : +{0x7664,0xFFFE,0x02}, // MC3_X0DEF1_POS1 : +{0x7666,0x000D,0x02}, // MC3_Y0DEF1_POS1 : +{0x7668,0x0002,0x02}, // MC3_X0DEF2_POS1 : +{0x766A,0xFFF6,0x02}, // MC3_Y0DEF2_POS1 : +{0x766C,0x003B,0x02}, // MC3_X0DEF3_POS1 : +{0x766E,0xFFBB,0x02}, // MC3_Y0DEF3_POS1 : +{0x7670,0xFFBA,0x02}, // MC3_X0DEF0_POS2 : +{0x7672,0xFFBA,0x02}, // MC3_Y0DEF0_POS2 : +{0x7674,0xFFFE,0x02}, // MC3_X0DEF1_POS2 : +{0x7676,0x000D,0x02}, // MC3_Y0DEF1_POS2 : +{0x7678,0x0002,0x02}, // MC3_X0DEF2_POS2 : +{0x767A,0xFFF6,0x02}, // MC3_Y0DEF2_POS2 : +{0x767C,0x003B,0x02}, // MC3_X0DEF3_POS2 : +{0x767E,0xFFBB,0x02}, // MC3_Y0DEF3_POS2 : +{0x7680,0xFFCE,0x02}, // MC3_X0DEF0_POS3 : +{0x7682,0xFFBA,0x02}, // MC3_Y0DEF0_POS3 : +{0x7684,0xFFFE,0x02}, // MC3_X0DEF1_POS3 : +{0x7686,0x000D,0x02}, // MC3_Y0DEF1_POS3 : +{0x7688,0x0002,0x02}, // MC3_X0DEF2_POS3 : +{0x768A,0xFFF6,0x02}, // MC3_Y0DEF2_POS3 : +{0x768C,0x003B,0x02}, // MC3_X0DEF3_POS3 : +{0x768E,0xFFBB,0x02}, // MC3_Y0DEF3_POS3 : +{0x7690,0xFFCE,0x02}, // MC3_X0DEF0_POS4 : +{0x7692,0xFFC9,0x02}, // MC3_Y0DEF0_POS4 : +{0x7694,0xFFD0,0x02}, // MC3_X0DEF1_POS4 : +{0x7696,0x0037,0x02}, // MC3_Y0DEF1_POS4 : +{0x7698,0x0002,0x02}, // MC3_X0DEF2_POS4 : +{0x769A,0xFFF6,0x02}, // MC3_Y0DEF2_POS4 : +{0x769C,0x003B,0x02}, // MC3_X0DEF3_POS4 : +{0x769E,0xFFBB,0x02}, // MC3_Y0DEF3_POS4 : +{0x76A0,0xFFCE,0x02}, // MC3_X0DEF0_POS5 : +{0x76A2,0xFFC9,0x02}, // MC3_Y0DEF0_POS5 : +{0x76A4,0xFFD0,0x02}, // MC3_X0DEF1_POS5 : +{0x76A6,0x0037,0x02}, // MC3_Y0DEF1_POS5 : +{0x76A8,0x0002,0x02}, // MC3_X0DEF2_POS5 : +{0x76AA,0xFFF6,0x02}, // MC3_Y0DEF2_POS5 : +{0x76AC,0x003B,0x02}, // MC3_X0DEF3_POS5 : +{0x76AE,0xFFBB,0x02}, // MC3_Y0DEF3_POS5 : +{0x76B0,0xFFCE,0x02}, // MC3_X0DEF0_POS6 : +{0x76B2,0xFFC9,0x02}, // MC3_Y0DEF0_POS6 : +{0x76B4,0xFFFE,0x02}, // MC3_X0DEF1_POS6 : +{0x76B6,0x000D,0x02}, // MC3_Y0DEF1_POS6 : +{0x76B8,0x0002,0x02}, // MC3_X0DEF2_POS6 : +{0x76BA,0xFFF6,0x02}, // MC3_Y0DEF2_POS6 : +{0x76BC,0x003B,0x02}, // MC3_X0DEF3_POS6 : +{0x76BE,0xFFBB,0x02}, // MC3_Y0DEF3_POS6 : +{0x76C0,0xFFCE,0x02}, // MC3_X0DEF0_POS7 : +{0x76C2,0xFFC9,0x02}, // MC3_Y0DEF0_POS7 : +{0x76C4,0xFFFE,0x02}, // MC3_X0DEF1_POS7 : +{0x76C6,0x000D,0x02}, // MC3_Y0DEF1_POS7 : +{0x76C8,0x0002,0x02}, // MC3_X0DEF2_POS7 : +{0x76CA,0xFFF6,0x02}, // MC3_Y0DEF2_POS7 : +{0x76CC,0x003B,0x02}, // MC3_X0DEF3_POS7 : +{0x76CE,0xFFBB,0x02}, // MC3_Y0DEF3_POS7 : +{0x76D0,0xFF7E,0x02}, // MC3_X0DEF0_OUT : +{0x76D2,0xFFE2,0x02}, // MC3_Y0DEF0_OUT : +{0x76D4,0xFFFE,0x02}, // MC3_X0DEF1_OUT : +{0x76D6,0x000D,0x02}, // MC3_Y0DEF1_OUT : +{0x76D8,0x0002,0x02}, // MC3_X0DEF2_OUT : +{0x76DA,0xFFF6,0x02}, // MC3_Y0DEF2_OUT : +{0x76DC,0xFFC4,0x02}, // MC3_X0DEF3_OUT : +{0x76DE,0xFFEC,0x02}, // MC3_Y0DEF3_OUT : +{0x76E0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS4 : +{0x76E2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS4 : +{0x76E4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS4 : +{0x76E6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS4 : +{0x76E8,0x0002,0x02}, // MC3_X0DEF2_R2_POS4 : +{0x76EA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS4 : +{0x76EC,0x003B,0x02}, // MC3_X0DEF3_R2_POS4 : +{0x76EE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS4 : +{0x76F0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS5 : +{0x76F2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS5 : +{0x76F4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS5 : +{0x76F6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS5 : +{0x76F8,0x0002,0x02}, // MC3_X0DEF2_R2_POS5 : +{0x76FA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS5 : +{0x76FC,0x003B,0x02}, // MC3_X0DEF3_R2_POS5 : +{0x76FE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS5 : +{0x7700,0x0019,0x02}, // MC3_PXDEF0_POS1 : +{0x7702,0xFF66,0x02}, // MC3_PYDEF0_POS1 : +{0x7704,0x0000,0x02}, // MC3_PXDEF1_POS1 : +{0x7706,0x0000,0x02}, // MC3_PYDEF1_POS1 : +{0x7708,0x0000,0x02}, // MC3_PXDEF2_POS1 : +{0x770A,0x0000,0x02}, // MC3_PYDEF2_POS1 : +{0x770C,0xFFD7,0x02}, // MC3_PXDEF3_POS1 : +{0x770E,0x0068,0x02}, // MC3_PYDEF3_POS1 : +{0x7710,0x0000,0x02}, // MC3_PXDEF0_POS2 : +{0x7712,0xFF66,0x02}, // MC3_PYDEF0_POS2 : +{0x7714,0x0033,0x02}, // MC3_PXDEF1_POS2 : +{0x7716,0xFF4C,0x02}, // MC3_PYDEF1_POS2 : +{0x7718,0x0000,0x02}, // MC3_PXDEF2_POS2 : +{0x771A,0x00B3,0x02}, // MC3_PYDEF2_POS2 : +{0x771C,0xFFD7,0x02}, // MC3_PXDEF3_POS2 : +{0x771E,0x0068,0x02}, // MC3_PYDEF3_POS2 : +{0x7720,0x0000,0x02}, // MC3_PXDEF0_POS3 : +{0x7722,0xFF80,0x02}, // MC3_PYDEF0_POS3 : +{0x7724,0x0000,0x02}, // MC3_PXDEF1_POS3 : +{0x7726,0x0000,0x02}, // MC3_PYDEF1_POS3 : +{0x7728,0x0000,0x02}, // MC3_PXDEF2_POS3 : +{0x772A,0x0000,0x02}, // MC3_PYDEF2_POS3 : +{0x772C,0xFFD7,0x02}, // MC3_PXDEF3_POS3 : +{0x772E,0x0068,0x02}, // MC3_PYDEF3_POS3 : +{0x7730,0x0000,0x02}, // MC3_PXDEF0_POS4 : +{0x7732,0xFFCC,0x02}, // MC3_PYDEF0_POS4 : +{0x7734,0x0000,0x02}, // MC3_PXDEF1_POS4 : +{0x7736,0x0000,0x02}, // MC3_PYDEF1_POS4 : +{0x7738,0x0000,0x02}, // MC3_PXDEF2_POS4 : +{0x773A,0x0000,0x02}, // MC3_PYDEF2_POS4 : +{0x773C,0xFFD7,0x02}, // MC3_PXDEF3_POS4 : +{0x773E,0x0068,0x02}, // MC3_PYDEF3_POS4 : +{0x7740,0x0000,0x02}, // MC3_PXDEF0_POS5 : +{0x7742,0xFFCC,0x02}, // MC3_PYDEF0_POS5 : +{0x7744,0x0000,0x02}, // MC3_PXDEF1_POS5 : +{0x7746,0x0000,0x02}, // MC3_PYDEF1_POS5 : +{0x7748,0x0000,0x02}, // MC3_PXDEF2_POS5 : +{0x774A,0x0000,0x02}, // MC3_PYDEF2_POS5 : +{0x774C,0xFFD7,0x02}, // MC3_PXDEF3_POS5 : +{0x774E,0x0068,0x02}, // MC3_PYDEF3_POS5 : +{0x7750,0xFFB3,0x02}, // MC3_PXDEF0_POS6 : +{0x7752,0x0000,0x02}, // MC3_PYDEF0_POS6 : +{0x7754,0x0033,0x02}, // MC3_PXDEF1_POS6 : +{0x7756,0xFF4C,0x02}, // MC3_PYDEF1_POS6 : +{0x7758,0x0000,0x02}, // MC3_PXDEF2_POS6 : +{0x775A,0x00B3,0x02}, // MC3_PYDEF2_POS6 : +{0x775C,0xFFD7,0x02}, // MC3_PXDEF3_POS6 : +{0x775E,0x0068,0x02}, // MC3_PYDEF3_POS6 : +{0x7760,0xFFB3,0x02}, // MC3_PXDEF0_POS7 : +{0x7762,0x0000,0x02}, // MC3_PYDEF0_POS7 : +{0x7764,0x0000,0x02}, // MC3_PXDEF1_POS7 : +{0x7766,0x0000,0x02}, // MC3_PYDEF1_POS7 : +{0x7768,0x0000,0x02}, // MC3_PXDEF2_POS7 : +{0x776A,0x0000,0x02}, // MC3_PYDEF2_POS7 : +{0x776C,0xFFD7,0x02}, // MC3_PXDEF3_POS7 : +{0x776E,0x0068,0x02}, // MC3_PYDEF3_POS7 : +{0x7770,0x0019,0x02}, // MC3_PXDEF0_OUT : +{0x7772,0xFFE6,0x02}, // MC3_PYDEF0_OUT : +{0x7774,0x0000,0x02}, // MC3_PXDEF1_OUT : +{0x7776,0x0000,0x02}, // MC3_PYDEF1_OUT : +{0x7778,0x0000,0x02}, // MC3_PXDEF2_OUT : +{0x777A,0x0000,0x02}, // MC3_PYDEF2_OUT : +{0x777C,0xFFE1,0x02}, // MC3_PXDEF3_OUT : +{0x777E,0xFFEB,0x02}, // MC3_PYDEF3_OUT : +{0x7780,0x0000,0x02}, // MC3_PXDEF0_R2_POS4 : +{0x7782,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS4 : +{0x7784,0x0000,0x02}, // MC3_PXDEF1_R2_POS4 : +{0x7786,0x0000,0x02}, // MC3_PYDEF1_R2_POS4 : +{0x7788,0x0000,0x02}, // MC3_PXDEF2_R2_POS4 : +{0x778A,0x0000,0x02}, // MC3_PYDEF2_R2_POS4 : +{0x778C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS4 : +{0x778E,0x0068,0x02}, // MC3_PYDEF3_R2_POS4 : +{0x7790,0x0000,0x02}, // MC3_PXDEF0_R2_POS5 : +{0x7792,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS5 : +{0x7794,0x0000,0x02}, // MC3_PXDEF1_R2_POS5 : +{0x7796,0x0000,0x02}, // MC3_PYDEF1_R2_POS5 : +{0x7798,0x0000,0x02}, // MC3_PXDEF2_R2_POS5 : +{0x779A,0x0000,0x02}, // MC3_PYDEF2_R2_POS5 : +{0x779C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS5 : +{0x779E,0x0068,0x02}, // MC3_PYDEF3_R2_POS5 : + +}; + +static const isx012_regset_t ISX012_Camcorder_Mode_OFF[] = { +//SN setting +{0x0308,0x11,0x01}, // AELINE_MONI_SN1_2 : +{0x0320,0x22,0x01}, // AELINE_MONI_SN1_2 : +{0x00B2,0x02,0x01}, // AFMODE_MONI : +//BRIGHTNESS setting +{0x01C6,0x00,0x01}, // UIBRIGHTNESS +//AE speed +{0x02AC,0x01,0x01}, // AE_SUB_SN1 : +{0x5E2D,0x08,0x01}, // AEMOVECNT : +{0x5E2E,0x1A,0x01}, // AEINDEADBAND : +{0x5E2F,0x04,0x01}, // AEOUTDEADBAND : +{0x5E30,0x20,0x01}, // AESPEED : +{0x5E31,0x0F,0x01}, // AESPEED_INIT : +{0x5E32,0x0F,0x01}, // AESPEED_FAST : +{0x621E,0x20,0x01}, // AIM_NR_TH_UP : +{0x621F,0x20,0x01}, // AIM_NR_TH_DOWN : +{0x6220,0x20,0x01}, // AIM_NR_TH_RIGHT : +{0x6221,0x20,0x01}, // AIM_NR_TH_LEFT : +//AWB speed +{0x6222,0x00,0x01}, // INIT_AIMW : +{0x6223,0x04,0x01}, // INIT_GAINS : +{0x6224,0x04,0x01}, // ATW_DELAY : +{0x6225,0x00,0x01}, // ATW_AIMW : +{0x6226,0x08,0x01}, // ATW_GAINS_IN_NR : +{0x6227,0x04,0x01}, // ATW_GAINS_IN : +{0x6228,0x08,0x01}, // ATW_GAINS_OUT_NR : +{0x6229,0x04,0x01}, // ATW_GAINS_OUT : +{0x622A,0x02,0x01}, // ALLWB_GAINS : +//Gammma Table 0 +{0x7000,0x0000,0x02}, // G0_KNOT_G0 : +{0x7002,0x0015,0x02}, // G0_KNOT_G1 : +{0x7004,0x002C,0x02}, // G0_KNOT_G2 : +{0x7006,0x0041,0x02}, // G0_KNOT_G3 : +{0x7008,0x004D,0x02}, // G0_KNOT_G4 : +{0x700A,0x005B,0x02}, // G0_KNOT_G5 : +{0x700C,0x0060,0x02}, // G0_KNOT_G6 : +{0x700E,0x0068,0x02}, // G0_KNOT_G7 : +{0x7010,0x006F,0x02}, // G0_KNOT_G8 : +{0x7012,0x0078,0x02}, // G0_KNOT_G9 : +{0x7014,0x0057,0x02}, // G0_KNOT_G10 : +{0x7016,0x0090,0x02}, // G0_KNOT_G11 : +{0x7018,0x00BB,0x02}, // G0_KNOT_G12 : +{0x701A,0x00D6,0x02}, // G0_KNOT_G13 : +{0x701C,0x00E5,0x02}, // G0_KNOT_G14 : +{0x701E,0x00F0,0x02}, // G0_KNOT_G15 : +{0x7020,0x00F9,0x02}, // G0_KNOT_G16 : +{0x7022,0x0103,0x02}, // G0_KNOT_G17 : +{0x7024,0x010C,0x02}, // G0_KNOT_G18 : +{0x7026,0x00,0x01}, // G0_KNOT_R0_OFFSET : +{0x7027,0x00,0x01}, // G0_KNOT_R2_OFFSET : +{0x7028,0x00,0x01}, // G0_KNOT_R4_OFFSET : +{0x7029,0x00,0x01}, // G0_KNOT_R6_OFFSET : +{0x702A,0x00,0x01}, // G0_KNOT_R8_OFFSET : +{0x702B,0x00,0x01}, // G0_KNOT_R10_OFFSET : +{0x702C,0x00,0x01}, // G0_KNOT_R12_OFFSET : +{0x702D,0x00,0x01}, // G0_KNOT_R14_OFFSET : +{0x702E,0x00,0x01}, // G0_KNOT_R16_OFFSET : +{0x702F,0x00,0x01}, // G0_KNOT_R18_OFFSET : +{0x7030,0x00,0x01}, // G0_KNOT_B0_OFFSET : +{0x7031,0x00,0x01}, // G0_KNOT_B2_OFFSET : +{0x7032,0x00,0x01}, // G0_KNOT_B4_OFFSET : +{0x7033,0x00,0x01}, // G0_KNOT_B6_OFFSET : +{0x7034,0x00,0x01}, // G0_KNOT_B8_OFFSET : +{0x7035,0x00,0x01}, // G0_KNOT_B10_OFFSET : +{0x7036,0x00,0x01}, // G0_KNOT_B12_OFFSET : +{0x7037,0x00,0x01}, // G0_KNOT_B14_OFFSET : +{0x7038,0x00,0x01}, // G0_KNOT_B16_OFFSET : +{0x7039,0x00,0x01}, // G0_KNOT_B18_OFFSET : +{0x703A,0x0611,0x02}, // G0_LOWGM_ON_R : +{0x703C,0x1E0A,0x02}, // G0_0CLIP_R : +{0x703E,0x0611,0x02}, // G0_LOWGM_ON_G : +{0x7040,0x1E0A,0x02}, // G0_0CLIP_G : +{0x7042,0x0611,0x02}, // G0_LOWGM_ON_B : +{0x7044,0x1E0A,0x02}, // G0_0CLIP_B : +{0x7046,0x9C,0x01}, // G0_KNOT_GAINCTRL_TH_L : +{0x7047,0xA1,0x01}, // G0_KNOT_GAINCTRL_TH_H : +{0x7048,0x0000,0x02}, // G0_KNOT_L_G0 : +{0x704A,0x0007,0x02}, // G0_KNOT_L_G1 : +{0x704C,0x0016,0x02}, // G0_KNOT_L_G2 : +{0x704E,0x002A,0x02}, // G0_KNOT_L_G3 : +{0x7050,0x0039,0x02}, // G0_KNOT_L_G4 : +{0x7052,0x004A,0x02}, // G0_KNOT_L_G5 : +{0x7054,0x0051,0x02}, // G0_KNOT_L_G6 : +{0x7056,0x005D,0x02}, // G0_KNOT_L_G7 : +{0x7058,0x0065,0x02}, // G0_KNOT_L_G8 : +{0x705A,0x006C,0x02}, // G0_KNOT_L_G9 : +{0x705C,0x004E,0x02}, // G0_KNOT_L_G10 : +{0x705E,0x0083,0x02}, // G0_KNOT_L_G11 : +{0x7060,0x00AA,0x02}, // G0_KNOT_L_G12 : +{0x7062,0x00C8,0x02}, // G0_KNOT_L_G13 : +{0x7064,0x00E1,0x02}, // G0_KNOT_L_G14 : +{0x7066,0x00F5,0x02}, // G0_KNOT_L_G15 : +{0x7068,0x0100,0x02}, // G0_KNOT_L_G16 : +{0x706A,0x0106,0x02}, // G0_KNOT_L_G17 : +{0x706C,0x010C,0x02}, // G0_KNOT_L_G18 : +{0x6400,0xAA,0x01}, // INFRM_LEFT00 : +{0x6401,0xAA,0x01}, // INFRM_LEFT01 : +{0x6402,0xAA,0x01}, // INFRM_LEFT02 : +{0x6403,0xAA,0x01}, // INFRM_LEFT03 : +{0x6404,0xAA,0x01}, // INFRM_LEFT04 : +{0x6405,0xAA,0x01}, // INFRM_LEFT05 : +{0x6406,0xAA,0x01}, // INFRM_LEFT06 : +{0x6407,0xAA,0x01}, // INFRM_LEFT07 : +{0x6408,0xAA,0x01}, // INFRM_LEFT08 : +{0x6409,0xAE,0x01}, // INFRM_LEFT09 : +{0x640A,0xA0,0x01}, // INFRM_LEFT10 : +{0x640B,0x8C,0x01}, // INFRM_LEFT11 : +{0x640C,0x72,0x01}, // INFRM_LEFT12 : +{0x640D,0x64,0x01}, // INFRM_LEFT13 : +{0x640E,0x5A,0x01}, // INFRM_LEFT14 : +{0x640F,0x52,0x01}, // INFRM_LEFT15 : +{0x6410,0x48,0x01}, // INFRM_LEFT16 : +{0x6411,0x43,0x01}, // INFRM_LEFT17 : +{0x6412,0x3D,0x01}, // INFRM_LEFT18 : +{0x6413,0x37,0x01}, // INFRM_LEFT19 : +{0x6414,0x33,0x01}, // INFRM_LEFT20 : +{0x6415,0x30,0x01}, // INFRM_LEFT21 : +{0x6416,0x2E,0x01}, // INFRM_LEFT22 : +{0x6417,0x2B,0x01}, // INFRM_LEFT23 : +{0x6418,0x28,0x01}, // INFRM_LEFT24 : +{0x6419,0x26,0x01}, // INFRM_LEFT25 : +{0x641A,0x24,0x01}, // INFRM_LEFT26 : +{0x641B,0x23,0x01}, // INFRM_LEFT27 : +{0x641C,0x22,0x01}, // INFRM_LEFT28 : +{0x641D,0x22,0x01}, // INFRM_LEFT29 : +{0x641E,0x21,0x01}, // INFRM_LEFT30 : +{0x641F,0x20,0x01}, // INFRM_LEFT31 : +{0x6420,0x1D,0x01}, // INFRM_LEFT32 : +{0x6421,0x1A,0x01}, // INFRM_LEFT33 : +{0x6422,0x18,0x01}, // INFRM_LEFT34 : +{0x6423,0x17,0x01}, // INFRM_LEFT35 : +{0x6424,0x16,0x01}, // INFRM_LEFT36 : +{0x6425,0x17,0x01}, // INFRM_LEFT37 : +{0x6426,0xAF,0x01}, // INFRM_RIGHT00 : +{0x6427,0xAF,0x01}, // INFRM_RIGHT01 : +{0x6428,0xAF,0x01}, // INFRM_RIGHT02 : +{0x6429,0xAF,0x01}, // INFRM_RIGHT03 : +{0x642A,0xAF,0x01}, // INFRM_RIGHT04 : +{0x642B,0xAF,0x01}, // INFRM_RIGHT05 : +{0x642C,0xAF,0x01}, // INFRM_RIGHT06 : +{0x642D,0xAF,0x01}, // INFRM_RIGHT07 : +{0x642E,0xAF,0x01}, // INFRM_RIGHT08 : +{0x642F,0xAA,0x01}, // INFRM_RIGHT09 : +{0x6430,0xB2,0x01}, // INFRM_RIGHT10 : +{0x6431,0xB4,0x01}, // INFRM_RIGHT11 : +{0x6432,0xB6,0x01}, // INFRM_RIGHT12 : +{0x6433,0xB4,0x01}, // INFRM_RIGHT13 : +{0x6434,0x9B,0x01}, // INFRM_RIGHT14 : +{0x6435,0x8E,0x01}, // INFRM_RIGHT15 : +{0x6436,0x84,0x01}, // INFRM_RIGHT16 : +{0x6437,0x7A,0x01}, // INFRM_RIGHT17 : +{0x6438,0x72,0x01}, // INFRM_RIGHT18 : +{0x6439,0x6A,0x01}, // INFRM_RIGHT19 : +{0x643A,0x63,0x01}, // INFRM_RIGHT20 : +{0x643B,0x5E,0x01}, // INFRM_RIGHT21 : +{0x643C,0x58,0x01}, // INFRM_RIGHT22 : +{0x643D,0x53,0x01}, // INFRM_RIGHT23 : +{0x643E,0x4E,0x01}, // INFRM_RIGHT24 : +{0x643F,0x4A,0x01}, // INFRM_RIGHT25 : +{0x6440,0x46,0x01}, // INFRM_RIGHT26 : +{0x6441,0x42,0x01}, // INFRM_RIGHT27 : +{0x6442,0x3F,0x01}, // INFRM_RIGHT28 : +{0x6443,0x3C,0x01}, // INFRM_RIGHT29 : +{0x6444,0x3A,0x01}, // INFRM_RIGHT30 : +{0x6445,0x38,0x01}, // INFRM_RIGHT31 : +{0x6446,0x37,0x01}, // INFRM_RIGHT32 : +{0x6447,0x35,0x01}, // INFRM_RIGHT33 : +{0x6448,0x33,0x01}, // INFRM_RIGHT34 : +{0x6449,0x32,0x01}, // INFRM_RIGHT35 : +{0x644A,0x32,0x01}, // INFRM_RIGHT36 : +{0x644B,0x32,0x01}, // INFRM_RIGHT37 : +{0x644C,0x24FA,0x02}, // INFRM_TOP : +{0x644E,0x0940,0x02}, // INFRM_BOTM : +{0x6450,0x19,0x01}, // INFRM_FLTOP : +{0x6451,0x10,0x01}, // INFRM_FLBOTM : +{0x6452,0x91,0x01}, // INAIM_LEFT00 : +{0x6453,0x91,0x01}, // INAIM_LEFT01 : +{0x6454,0x91,0x01}, // INAIM_LEFT02 : +{0x6455,0x91,0x01}, // INAIM_LEFT03 : +{0x6456,0x91,0x01}, // INAIM_LEFT04 : +{0x6457,0x91,0x01}, // INAIM_LEFT05 : +{0x6458,0x91,0x01}, // INAIM_LEFT06 : +{0x6459,0x91,0x01}, // INAIM_LEFT07 : +{0x645A,0x91,0x01}, // INAIM_LEFT08 : +{0x645B,0x91,0x01}, // INAIM_LEFT09 : +{0x645C,0x91,0x01}, // INAIM_LEFT10 : +{0x645D,0x91,0x01}, // INAIM_LEFT11 : +{0x645E,0x91,0x01}, // INAIM_LEFT12 : +{0x645F,0x66,0x01}, // INAIM_LEFT13 : +{0x6460,0x71,0x01}, // INAIM_LEFT14 : +{0x6461,0x5A,0x01}, // INAIM_LEFT15 : +{0x6462,0x4E,0x01}, // INAIM_LEFT16 : +{0x6463,0x47,0x01}, // INAIM_LEFT17 : +{0x6464,0x42,0x01}, // INAIM_LEFT18 : +{0x6465,0x3C,0x01}, // INAIM_LEFT19 : +{0x6466,0x38,0x01}, // INAIM_LEFT20 : +{0x6467,0x36,0x01}, // INAIM_LEFT21 : +{0x6468,0x33,0x01}, // INAIM_LEFT22 : +{0x6469,0x30,0x01}, // INAIM_LEFT23 : +{0x646A,0x2F,0x01}, // INAIM_LEFT24 : +{0x646B,0x2B,0x01}, // INAIM_LEFT25 : +{0x646C,0x29,0x01}, // INAIM_LEFT26 : +{0x646D,0x27,0x01}, // INAIM_LEFT27 : +{0x646E,0x26,0x01}, // INAIM_LEFT28 : +{0x646F,0x28,0x01}, // INAIM_LEFT29 : +{0x6470,0x2A,0x01}, // INAIM_LEFT30 : +{0x6471,0x28,0x01}, // INAIM_LEFT31 : +{0x6472,0x26,0x01}, // INAIM_LEFT32 : +{0x6473,0x24,0x01}, // INAIM_LEFT33 : +{0x6474,0x29,0x01}, // INAIM_LEFT34 : +{0x6475,0x28,0x01}, // INAIM_LEFT35 : +{0x6476,0x29,0x01}, // INAIM_LEFT36 : +{0x6477,0x26,0x01}, // INAIM_LEFT37 : +{0x6478,0xFF,0x01}, // INAIM_RIGHT00 : +{0x6479,0xFF,0x01}, // INAIM_RIGHT01 : +{0x647A,0xFF,0x01}, // INAIM_RIGHT02 : +{0x647B,0xFF,0x01}, // INAIM_RIGHT03 : +{0x647C,0xFF,0x01}, // INAIM_RIGHT04 : +{0x647D,0xFF,0x01}, // INAIM_RIGHT05 : +{0x647E,0xFF,0x01}, // INAIM_RIGHT06 : +{0x647F,0xFF,0x01}, // INAIM_RIGHT07 : +{0x6480,0xFF,0x01}, // INAIM_RIGHT08 : +{0x6481,0xFF,0x01}, // INAIM_RIGHT09 : +{0x6482,0xD9,0x01}, // INAIM_RIGHT10 : +{0x6483,0xB7,0x01}, // INAIM_RIGHT11 : +{0x6484,0x96,0x01}, // INAIM_RIGHT12 : +{0x6485,0x68,0x01}, // INAIM_RIGHT13 : +{0x6486,0x72,0x01}, // INAIM_RIGHT14 : +{0x6487,0x71,0x01}, // INAIM_RIGHT15 : +{0x6488,0x6E,0x01}, // INAIM_RIGHT16 : +{0x6489,0x6A,0x01}, // INAIM_RIGHT17 : +{0x648A,0x65,0x01}, // INAIM_RIGHT18 : +{0x648B,0x60,0x01}, // INAIM_RIGHT19 : +{0x648C,0x5B,0x01}, // INAIM_RIGHT20 : +{0x648D,0x56,0x01}, // INAIM_RIGHT21 : +{0x648E,0x51,0x01}, // INAIM_RIGHT22 : +{0x648F,0x4C,0x01}, // INAIM_RIGHT23 : +{0x6490,0x47,0x01}, // INAIM_RIGHT24 : +{0x6491,0x44,0x01}, // INAIM_RIGHT25 : +{0x6492,0x41,0x01}, // INAIM_RIGHT26 : +{0x6493,0x3E,0x01}, // INAIM_RIGHT27 : +{0x6494,0x3B,0x01}, // INAIM_RIGHT28 : +{0x6495,0x39,0x01}, // INAIM_RIGHT29 : +{0x6496,0x37,0x01}, // INAIM_RIGHT30 : +{0x6497,0x34,0x01}, // INAIM_RIGHT31 : +{0x6498,0x33,0x01}, // INAIM_RIGHT32 : +{0x6499,0x32,0x01}, // INAIM_RIGHT33 : +{0x649A,0x31,0x01}, // INAIM_RIGHT34 : +{0x649B,0x30,0x01}, // INAIM_RIGHT35 : +{0x649C,0x2F,0x01}, // INAIM_RIGHT36 : +{0x649D,0x2E,0x01}, // INAIM_RIGHT37 : +{0x649E,0x1E00,0x02}, // INAIM_TOP : +{0x64A0,0x0DFF,0x02}, // INAIM_BOTM : +{0x64A2,0x18,0x01}, // INAIM_FLTOP : +{0x64A3,0x09,0x01}, // INAIM_FLBOTM : +{0x64A4,0xFF,0x01}, // OUTFRM_LEFT00 : +{0x64A5,0xFF,0x01}, // OUTFRM_LEFT01 : +{0x64A6,0xFF,0x01}, // OUTFRM_LEFT02 : +{0x64A7,0xFF,0x01}, // OUTFRM_LEFT03 : +{0x64A8,0xFF,0x01}, // OUTFRM_LEFT04 : +{0x64A9,0xFF,0x01}, // OUTFRM_LEFT05 : +{0x64AA,0xFF,0x01}, // OUTFRM_LEFT06 : +{0x64AB,0xFF,0x01}, // OUTFRM_LEFT07 : +{0x64AC,0xFF,0x01}, // OUTFRM_LEFT08 : +{0x64AD,0xFD,0x01}, // OUTFRM_LEFT09 : +{0x64AE,0xCB,0x01}, // OUTFRM_LEFT10 : +{0x64AF,0xA9,0x01}, // OUTFRM_LEFT11 : +{0x64B0,0x90,0x01}, // OUTFRM_LEFT12 : +{0x64B1,0x7D,0x01}, // OUTFRM_LEFT13 : +{0x64B2,0x70,0x01}, // OUTFRM_LEFT14 : +{0x64B3,0x65,0x01}, // OUTFRM_LEFT15 : +{0x64B4,0x5C,0x01}, // OUTFRM_LEFT16 : +{0x64B5,0x55,0x01}, // OUTFRM_LEFT17 : +{0x64B6,0x4F,0x01}, // OUTFRM_LEFT18 : +{0x64B7,0x32,0x01}, // OUTFRM_LEFT19 : +{0x64B8,0x4D,0x01}, // OUTFRM_LEFT20 : +{0x64B9,0x40,0x01}, // OUTFRM_LEFT21 : +{0x64BA,0x2D,0x01}, // OUTFRM_LEFT22 : +{0x64BB,0x2B,0x01}, // OUTFRM_LEFT23 : +{0x64BC,0x29,0x01}, // OUTFRM_LEFT24 : +{0x64BD,0x27,0x01}, // OUTFRM_LEFT25 : +{0x64BE,0x25,0x01}, // OUTFRM_LEFT26 : +{0x64BF,0x23,0x01}, // OUTFRM_LEFT27 : +{0x64C0,0x21,0x01}, // OUTFRM_LEFT28 : +{0x64C1,0x1F,0x01}, // OUTFRM_LEFT29 : +{0x64C2,0x1D,0x01}, // OUTFRM_LEFT30 : +{0x64C3,0x1B,0x01}, // OUTFRM_LEFT31 : +{0x64C4,0x1A,0x01}, // OUTFRM_LEFT32 : +{0x64C5,0x1A,0x01}, // OUTFRM_LEFT33 : +{0x64C6,0x1A,0x01}, // OUTFRM_LEFT34 : +{0x64C7,0x28,0x01}, // OUTFRM_LEFT35 : +{0x64C8,0x27,0x01}, // OUTFRM_LEFT36 : +{0x64C9,0x26,0x01}, // OUTFRM_LEFT37 : +{0x64CA,0xFF,0x01}, // OUTFRM_RIGHT00 : +{0x64CB,0xFF,0x01}, // OUTFRM_RIGHT01 : +{0x64CC,0xFF,0x01}, // OUTFRM_RIGHT02 : +{0x64CD,0xFF,0x01}, // OUTFRM_RIGHT03 : +{0x64CE,0xFF,0x01}, // OUTFRM_RIGHT04 : +{0x64CF,0xFF,0x01}, // OUTFRM_RIGHT05 : +{0x64D0,0xFF,0x01}, // OUTFRM_RIGHT06 : +{0x64D1,0xFF,0x01}, // OUTFRM_RIGHT07 : +{0x64D2,0xFF,0x01}, // OUTFRM_RIGHT08 : +{0x64D3,0xFF,0x01}, // OUTFRM_RIGHT09 : +{0x64D4,0xD3,0x01}, // OUTFRM_RIGHT10 : +{0x64D5,0xB1,0x01}, // OUTFRM_RIGHT11 : +{0x64D6,0x98,0x01}, // OUTFRM_RIGHT12 : +{0x64D7,0x85,0x01}, // OUTFRM_RIGHT13 : +{0x64D8,0x78,0x01}, // OUTFRM_RIGHT14 : +{0x64D9,0x6D,0x01}, // OUTFRM_RIGHT15 : +{0x64DA,0x64,0x01}, // OUTFRM_RIGHT16 : +{0x64DB,0x5D,0x01}, // OUTFRM_RIGHT17 : +{0x64DC,0x57,0x01}, // OUTFRM_RIGHT18 : +{0x64DD,0x63,0x01}, // OUTFRM_RIGHT19 : +{0x64DE,0x5E,0x01}, // OUTFRM_RIGHT20 : +{0x64DF,0x5A,0x01}, // OUTFRM_RIGHT21 : +{0x64E0,0x56,0x01}, // OUTFRM_RIGHT22 : +{0x64E1,0x52,0x01}, // OUTFRM_RIGHT23 : +{0x64E2,0x50,0x01}, // OUTFRM_RIGHT24 : +{0x64E3,0x4E,0x01}, // OUTFRM_RIGHT25 : +{0x64E4,0x4C,0x01}, // OUTFRM_RIGHT26 : +{0x64E5,0x4A,0x01}, // OUTFRM_RIGHT27 : +{0x64E6,0x48,0x01}, // OUTFRM_RIGHT28 : +{0x64E7,0x46,0x01}, // OUTFRM_RIGHT29 : +{0x64E8,0x44,0x01}, // OUTFRM_RIGHT30 : +{0x64E9,0x43,0x01}, // OUTFRM_RIGHT31 : +{0x64EA,0x42,0x01}, // OUTFRM_RIGHT32 : +{0x64EB,0x42,0x01}, // OUTFRM_RIGHT33 : +{0x64EC,0x42,0x01}, // OUTFRM_RIGHT34 : +{0x64ED,0x30,0x01}, // OUTFRM_RIGHT35 : +{0x64EE,0x2F,0x01}, // OUTFRM_RIGHT36 : +{0x64EF,0x2E,0x01}, // OUTFRM_RIGHT37 : +{0x64F0,0x2163,0x02}, // OUTFRM_TOP : +{0x64F2,0x1400,0x02}, // OUTFRM_BOTM : +{0x64F4,0x19,0x01}, // OUTFRM_FLTOP : +{0x64F5,0x14,0x01}, // OUTFRM_FLBOTM : +//AWB +{0x6232,0xFF,0x01}, // ATW_SFTLMT_OUT_NR +{0x6234,0xFF,0x01}, // ATW_SFTLMT_OUT +/////MC3 Setting///// +{0x7600,0x07,0x01}, // MC3_PXDEF0_SEL : +{0x7601,0x07,0x01}, // MC3_PYDEF0_SEL : +{0x7602,0x07,0x01}, // MC3_PXDEF1_SEL : +{0x7603,0x07,0x01}, // MC3_PYDEF1_SEL : +{0x7604,0x07,0x01}, // MC3_PXDEF2_SEL : +{0x7605,0x07,0x01}, // MC3_PYDEF2_SEL : +{0x7606,0x07,0x01}, // MC3_PXDEF3_SEL : +{0x7607,0x07,0x01}, // MC3_PYDEF3_SEL : +{0x7608,0x40,0x01}, // MC3_PXDEF0_A : +{0x7609,0x40,0x01}, // MC3_PXDEF0_B : +{0x760A,0x40,0x01}, // MC3_PXDEF0_C : +{0x760B,0x40,0x01}, // MC3_PYDEF0_A : +{0x760C,0x40,0x01}, // MC3_PYDEF0_B : +{0x760D,0x40,0x01}, // MC3_PYDEF0_C : +{0x760E,0x40,0x01}, // MC3_PXDEF1_A : +{0x760F,0x40,0x01}, // MC3_PXDEF1_B : +{0x7610,0x40,0x01}, // MC3_PXDEF1_C : +{0x7611,0x40,0x01}, // MC3_PYDEF1_A : +{0x7612,0x40,0x01}, // MC3_PYDEF1_B : +{0x7613,0x40,0x01}, // MC3_PYDEF1_C : +{0x7614,0x40,0x01}, // MC3_PXDEF2_A : +{0x7615,0x40,0x01}, // MC3_PXDEF2_B : +{0x7616,0x40,0x01}, // MC3_PXDEF2_C : +{0x7617,0x40,0x01}, // MC3_PYDEF2_A : +{0x7618,0x40,0x01}, // MC3_PYDEF2_B : +{0x7619,0x40,0x01}, // MC3_PYDEF2_C : +{0x761A,0x40,0x01}, // MC3_PXDEF3_A : +{0x761B,0x40,0x01}, // MC3_PXDEF3_B : +{0x761C,0x40,0x01}, // MC3_PXDEF3_C : +{0x761D,0x40,0x01}, // MC3_PYDEF3_A : +{0x761E,0x40,0x01}, // MC3_PYDEF3_B : +{0x761F,0x40,0x01}, // MC3_PYDEF3_C : +{0x7620,0x00,0x01}, // MC3_LUMSL0_IN : +{0x7621,0x06,0x01}, // MC3_LUMSL1_IN : +{0x7622,0x03,0x01}, // MC3_LUMSL2_IN : +{0x7623,0x06,0x01}, // MC3_LUMSL3_IN : +{0x7624,0x00,0x01}, // MC3_LUMSL0_OUT : +{0x7625,0x03,0x01}, // MC3_LUMSL1_OUT : +{0x7626,0x00,0x01}, // MC3_LUMSL2_OUT : +{0x7627,0x00,0x01}, // MC3_LUMSL3_OUT : +{0x7628,0x0000,0x02}, // MC3_L0DEF0_IN : +{0x762A,0x008C,0x02}, // MC3_L0DEF1_IN : +{0x762C,0x0078,0x02}, // MC3_L0DEF2_IN : +{0x762E,0x00E6,0x02}, // MC3_L0DEF3_IN : +{0x7630,0x0000,0x02}, // MC3_L0DEF0_OUT : +{0x7632,0x0082,0x02}, // MC3_L0DEF1_OUT : +{0x7634,0x0000,0x02}, // MC3_L0DEF2_OUT : +{0x7636,0x0000,0x02}, // MC3_L0DEF3_OUT : +{0x7638,0x41,0x01}, // MC3_RDEF0_POS1 : +{0x7639,0x10,0x01}, // MC3_RDEF1_POS1 : +{0x763A,0x15,0x01}, // MC3_RDEF2_POS1 : +{0x763B,0x71,0x01}, // MC3_RDEF3_POS1 : +{0x763C,0x41,0x01}, // MC3_RDEF0_POS2 : +{0x763D,0x10,0x01}, // MC3_RDEF1_POS2 : +{0x763E,0x15,0x01}, // MC3_RDEF2_POS2 : +{0x763F,0x71,0x01}, // MC3_RDEF3_POS2 : +{0x7640,0x3C,0x01}, // MC3_RDEF0_POS3 : +{0x7641,0x10,0x01}, // MC3_RDEF1_POS3 : +{0x7642,0x15,0x01}, // MC3_RDEF2_POS3 : +{0x7643,0x71,0x01}, // MC3_RDEF3_POS3 : +{0x7644,0x46,0x01}, // MC3_RDEF0_POS4 : +{0x7645,0x32,0x01}, // MC3_RDEF1_POS4 : +{0x7646,0x15,0x01}, // MC3_RDEF2_POS4 : +{0x7647,0x71,0x01}, // MC3_RDEF3_POS4 : +{0x7648,0x46,0x01}, // MC3_RDEF0_POS5 : +{0x7649,0x32,0x01}, // MC3_RDEF1_POS5 : +{0x764A,0x15,0x01}, // MC3_RDEF2_POS5 : +{0x764B,0x71,0x01}, // MC3_RDEF3_POS5 : +{0x764C,0x46,0x01}, // MC3_RDEF0_POS6 : +{0x764D,0x10,0x01}, // MC3_RDEF1_POS6 : +{0x764E,0x15,0x01}, // MC3_RDEF2_POS6 : +{0x764F,0x71,0x01}, // MC3_RDEF3_POS6 : +{0x7650,0x46,0x01}, // MC3_RDEF0_POS7 : +{0x7651,0x10,0x01}, // MC3_RDEF1_POS7 : +{0x7652,0x15,0x01}, // MC3_RDEF2_POS7 : +{0x7653,0x71,0x01}, // MC3_RDEF3_POS7 : +{0x7654,0x2D,0x01}, // MC3_RDEF0_OUT : +{0x7655,0x10,0x01}, // MC3_RDEF1_OUT : +{0x7656,0x15,0x01}, // MC3_RDEF2_OUT : +{0x7657,0x54,0x01}, // MC3_RDEF3_OUT : +{0x7658,0x46,0x01}, // MC3_RDEF0_R2_POS4 : +{0x7659,0x32,0x01}, // MC3_RDEF1_R2_POS4 : +{0x765A,0x15,0x01}, // MC3_RDEF2_R2_POS4 : +{0x765B,0x71,0x01}, // MC3_RDEF3_R2_POS4 : +{0x765C,0x46,0x01}, // MC3_RDEF0_R2_POS5 : +{0x765D,0x32,0x01}, // MC3_RDEF1_R2_POS5 : +{0x765E,0x15,0x01}, // MC3_RDEF2_R2_POS5 : +{0x765F,0x71,0x01}, // MC3_RDEF3_R2_POS5 : +{0x7660,0xFFBA,0x02}, // MC3_X0DEF0_POS1 : +{0x7662,0xFFBA,0x02}, // MC3_Y0DEF0_POS1 : +{0x7664,0xFFFE,0x02}, // MC3_X0DEF1_POS1 : +{0x7666,0x000D,0x02}, // MC3_Y0DEF1_POS1 : +{0x7668,0x0002,0x02}, // MC3_X0DEF2_POS1 : +{0x766A,0xFFF6,0x02}, // MC3_Y0DEF2_POS1 : +{0x766C,0x003B,0x02}, // MC3_X0DEF3_POS1 : +{0x766E,0xFFBB,0x02}, // MC3_Y0DEF3_POS1 : +{0x7670,0xFFBA,0x02}, // MC3_X0DEF0_POS2 : +{0x7672,0xFFBA,0x02}, // MC3_Y0DEF0_POS2 : +{0x7674,0xFFFE,0x02}, // MC3_X0DEF1_POS2 : +{0x7676,0x000D,0x02}, // MC3_Y0DEF1_POS2 : +{0x7678,0x0002,0x02}, // MC3_X0DEF2_POS2 : +{0x767A,0xFFF6,0x02}, // MC3_Y0DEF2_POS2 : +{0x767C,0x003B,0x02}, // MC3_X0DEF3_POS2 : +{0x767E,0xFFBB,0x02}, // MC3_Y0DEF3_POS2 : +{0x7680,0xFFCE,0x02}, // MC3_X0DEF0_POS3 : +{0x7682,0xFFBA,0x02}, // MC3_Y0DEF0_POS3 : +{0x7684,0xFFFE,0x02}, // MC3_X0DEF1_POS3 : +{0x7686,0x000D,0x02}, // MC3_Y0DEF1_POS3 : +{0x7688,0x0002,0x02}, // MC3_X0DEF2_POS3 : +{0x768A,0xFFF6,0x02}, // MC3_Y0DEF2_POS3 : +{0x768C,0x003B,0x02}, // MC3_X0DEF3_POS3 : +{0x768E,0xFFBB,0x02}, // MC3_Y0DEF3_POS3 : +{0x7690,0xFFCE,0x02}, // MC3_X0DEF0_POS4 : +{0x7692,0xFFC9,0x02}, // MC3_Y0DEF0_POS4 : +{0x7694,0xFFD0,0x02}, // MC3_X0DEF1_POS4 : +{0x7696,0x0037,0x02}, // MC3_Y0DEF1_POS4 : +{0x7698,0x0002,0x02}, // MC3_X0DEF2_POS4 : +{0x769A,0xFFF6,0x02}, // MC3_Y0DEF2_POS4 : +{0x769C,0x003B,0x02}, // MC3_X0DEF3_POS4 : +{0x769E,0xFFBB,0x02}, // MC3_Y0DEF3_POS4 : +{0x76A0,0xFFCE,0x02}, // MC3_X0DEF0_POS5 : +{0x76A2,0xFFC9,0x02}, // MC3_Y0DEF0_POS5 : +{0x76A4,0xFFD0,0x02}, // MC3_X0DEF1_POS5 : +{0x76A6,0x0037,0x02}, // MC3_Y0DEF1_POS5 : +{0x76A8,0x0002,0x02}, // MC3_X0DEF2_POS5 : +{0x76AA,0xFFF6,0x02}, // MC3_Y0DEF2_POS5 : +{0x76AC,0x003B,0x02}, // MC3_X0DEF3_POS5 : +{0x76AE,0xFFBB,0x02}, // MC3_Y0DEF3_POS5 : +{0x76B0,0xFFCE,0x02}, // MC3_X0DEF0_POS6 : +{0x76B2,0xFFC9,0x02}, // MC3_Y0DEF0_POS6 : +{0x76B4,0xFFFE,0x02}, // MC3_X0DEF1_POS6 : +{0x76B6,0x000D,0x02}, // MC3_Y0DEF1_POS6 : +{0x76B8,0x0002,0x02}, // MC3_X0DEF2_POS6 : +{0x76BA,0xFFF6,0x02}, // MC3_Y0DEF2_POS6 : +{0x76BC,0x003B,0x02}, // MC3_X0DEF3_POS6 : +{0x76BE,0xFFBB,0x02}, // MC3_Y0DEF3_POS6 : +{0x76C0,0xFFCE,0x02}, // MC3_X0DEF0_POS7 : +{0x76C2,0xFFC9,0x02}, // MC3_Y0DEF0_POS7 : +{0x76C4,0xFFFE,0x02}, // MC3_X0DEF1_POS7 : +{0x76C6,0x000D,0x02}, // MC3_Y0DEF1_POS7 : +{0x76C8,0x0002,0x02}, // MC3_X0DEF2_POS7 : +{0x76CA,0xFFF6,0x02}, // MC3_Y0DEF2_POS7 : +{0x76CC,0x003B,0x02}, // MC3_X0DEF3_POS7 : +{0x76CE,0xFFBB,0x02}, // MC3_Y0DEF3_POS7 : +{0x76D0,0xFF7E,0x02}, // MC3_X0DEF0_OUT : +{0x76D2,0xFFE2,0x02}, // MC3_Y0DEF0_OUT : +{0x76D4,0xFFFE,0x02}, // MC3_X0DEF1_OUT : +{0x76D6,0x000D,0x02}, // MC3_Y0DEF1_OUT : +{0x76D8,0x0002,0x02}, // MC3_X0DEF2_OUT : +{0x76DA,0xFFF6,0x02}, // MC3_Y0DEF2_OUT : +{0x76DC,0xFFC4,0x02}, // MC3_X0DEF3_OUT : +{0x76DE,0xFFEC,0x02}, // MC3_Y0DEF3_OUT : +{0x76E0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS4 : +{0x76E2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS4 : +{0x76E4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS4 : +{0x76E6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS4 : +{0x76E8,0x0002,0x02}, // MC3_X0DEF2_R2_POS4 : +{0x76EA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS4 : +{0x76EC,0x003B,0x02}, // MC3_X0DEF3_R2_POS4 : +{0x76EE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS4 : +{0x76F0,0xFFCE,0x02}, // MC3_X0DEF0_R2_POS5 : +{0x76F2,0xFFC9,0x02}, // MC3_Y0DEF0_R2_POS5 : +{0x76F4,0xFFD0,0x02}, // MC3_X0DEF1_R2_POS5 : +{0x76F6,0x0037,0x02}, // MC3_Y0DEF1_R2_POS5 : +{0x76F8,0x0002,0x02}, // MC3_X0DEF2_R2_POS5 : +{0x76FA,0xFFF6,0x02}, // MC3_Y0DEF2_R2_POS5 : +{0x76FC,0x003B,0x02}, // MC3_X0DEF3_R2_POS5 : +{0x76FE,0xFFBB,0x02}, // MC3_Y0DEF3_R2_POS5 : +{0x7700,0x0019,0x02}, // MC3_PXDEF0_POS1 : +{0x7702,0xFF66,0x02}, // MC3_PYDEF0_POS1 : +{0x7704,0x0000,0x02}, // MC3_PXDEF1_POS1 : +{0x7706,0x0000,0x02}, // MC3_PYDEF1_POS1 : +{0x7708,0x0000,0x02}, // MC3_PXDEF2_POS1 : +{0x770A,0x0000,0x02}, // MC3_PYDEF2_POS1 : +{0x770C,0xFFD7,0x02}, // MC3_PXDEF3_POS1 : +{0x770E,0x0068,0x02}, // MC3_PYDEF3_POS1 : +{0x7710,0x0000,0x02}, // MC3_PXDEF0_POS2 : +{0x7712,0xFF66,0x02}, // MC3_PYDEF0_POS2 : +{0x7714,0x0033,0x02}, // MC3_PXDEF1_POS2 : +{0x7716,0xFF4C,0x02}, // MC3_PYDEF1_POS2 : +{0x7718,0x0000,0x02}, // MC3_PXDEF2_POS2 : +{0x771A,0x00B3,0x02}, // MC3_PYDEF2_POS2 : +{0x771C,0xFFD7,0x02}, // MC3_PXDEF3_POS2 : +{0x771E,0x0068,0x02}, // MC3_PYDEF3_POS2 : +{0x7720,0x0000,0x02}, // MC3_PXDEF0_POS3 : +{0x7722,0xFF80,0x02}, // MC3_PYDEF0_POS3 : +{0x7724,0x0000,0x02}, // MC3_PXDEF1_POS3 : +{0x7726,0x0000,0x02}, // MC3_PYDEF1_POS3 : +{0x7728,0x0000,0x02}, // MC3_PXDEF2_POS3 : +{0x772A,0x0000,0x02}, // MC3_PYDEF2_POS3 : +{0x772C,0xFFD7,0x02}, // MC3_PXDEF3_POS3 : +{0x772E,0x0068,0x02}, // MC3_PYDEF3_POS3 : +{0x7730,0x0000,0x02}, // MC3_PXDEF0_POS4 : +{0x7732,0xFFCC,0x02}, // MC3_PYDEF0_POS4 : +{0x7734,0x0000,0x02}, // MC3_PXDEF1_POS4 : +{0x7736,0x0000,0x02}, // MC3_PYDEF1_POS4 : +{0x7738,0x0000,0x02}, // MC3_PXDEF2_POS4 : +{0x773A,0x0000,0x02}, // MC3_PYDEF2_POS4 : +{0x773C,0xFFD7,0x02}, // MC3_PXDEF3_POS4 : +{0x773E,0x0068,0x02}, // MC3_PYDEF3_POS4 : +{0x7740,0x0000,0x02}, // MC3_PXDEF0_POS5 : +{0x7742,0xFFCC,0x02}, // MC3_PYDEF0_POS5 : +{0x7744,0x0000,0x02}, // MC3_PXDEF1_POS5 : +{0x7746,0x0000,0x02}, // MC3_PYDEF1_POS5 : +{0x7748,0x0000,0x02}, // MC3_PXDEF2_POS5 : +{0x774A,0x0000,0x02}, // MC3_PYDEF2_POS5 : +{0x774C,0xFFD7,0x02}, // MC3_PXDEF3_POS5 : +{0x774E,0x0068,0x02}, // MC3_PYDEF3_POS5 : +{0x7750,0xFFB3,0x02}, // MC3_PXDEF0_POS6 : +{0x7752,0x0000,0x02}, // MC3_PYDEF0_POS6 : +{0x7754,0x0033,0x02}, // MC3_PXDEF1_POS6 : +{0x7756,0xFF4C,0x02}, // MC3_PYDEF1_POS6 : +{0x7758,0x0000,0x02}, // MC3_PXDEF2_POS6 : +{0x775A,0x00B3,0x02}, // MC3_PYDEF2_POS6 : +{0x775C,0xFFD7,0x02}, // MC3_PXDEF3_POS6 : +{0x775E,0x0068,0x02}, // MC3_PYDEF3_POS6 : +{0x7760,0xFFB3,0x02}, // MC3_PXDEF0_POS7 : +{0x7762,0x0000,0x02}, // MC3_PYDEF0_POS7 : +{0x7764,0x0000,0x02}, // MC3_PXDEF1_POS7 : +{0x7766,0x0000,0x02}, // MC3_PYDEF1_POS7 : +{0x7768,0x0000,0x02}, // MC3_PXDEF2_POS7 : +{0x776A,0x0000,0x02}, // MC3_PYDEF2_POS7 : +{0x776C,0xFFD7,0x02}, // MC3_PXDEF3_POS7 : +{0x776E,0x0068,0x02}, // MC3_PYDEF3_POS7 : +{0x7770,0x0019,0x02}, // MC3_PXDEF0_OUT : +{0x7772,0xFFE6,0x02}, // MC3_PYDEF0_OUT : +{0x7774,0x0000,0x02}, // MC3_PXDEF1_OUT : +{0x7776,0x0000,0x02}, // MC3_PYDEF1_OUT : +{0x7778,0x0000,0x02}, // MC3_PXDEF2_OUT : +{0x777A,0x0000,0x02}, // MC3_PYDEF2_OUT : +{0x777C,0xFFE1,0x02}, // MC3_PXDEF3_OUT : +{0x777E,0xFFEB,0x02}, // MC3_PYDEF3_OUT : +{0x7780,0x0000,0x02}, // MC3_PXDEF0_R2_POS4 : +{0x7782,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS4 : +{0x7784,0x0000,0x02}, // MC3_PXDEF1_R2_POS4 : +{0x7786,0x0000,0x02}, // MC3_PYDEF1_R2_POS4 : +{0x7788,0x0000,0x02}, // MC3_PXDEF2_R2_POS4 : +{0x778A,0x0000,0x02}, // MC3_PYDEF2_R2_POS4 : +{0x778C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS4 : +{0x778E,0x0068,0x02}, // MC3_PYDEF3_R2_POS4 : +{0x7790,0x0000,0x02}, // MC3_PXDEF0_R2_POS5 : +{0x7792,0xFFCC,0x02}, // MC3_PYDEF0_R2_POS5 : +{0x7794,0x0000,0x02}, // MC3_PXDEF1_R2_POS5 : +{0x7796,0x0000,0x02}, // MC3_PYDEF1_R2_POS5 : +{0x7798,0x0000,0x02}, // MC3_PXDEF2_R2_POS5 : +{0x779A,0x0000,0x02}, // MC3_PYDEF2_R2_POS5 : +{0x779C,0xFFD7,0x02}, // MC3_PXDEF3_R2_POS5 : +{0x779E,0x0068,0x02}, // MC3_PYDEF3_R2_POS5 : +}; + +static const isx012_regset_t ISX012_Halfrelease_Mode[] = +{ +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, //AF_RESTART_F : +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x00,0x01}, //AFMODE_HREL : +//{0xFFFF,0x42,0x01}, //$wait, 66 +{0x0081,0x01,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_Barcode_SAF[] = +{ +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, //AF_RESTART_F : +//{0xFFFF,0x21,0x01}, //$wait, 33 +{0x00B2,0x00,0x01}, //AFMODE_MONI : +}; + +static const isx012_regset_t ISX012_Lowlux_night_Halfrelease_Mode[] = +{ +{0x660E,0x04,0x01}, // AF_HBPF_PEAK_OPD_TH_MIN +{0x6610,0x04,0x01}, // AF_HBPF_PEAK_OPD_TH_MAX +{0x664A,0x01,0x01}, // AF_DROPN_ON_PEAK_DETECT : +{0x6640,0x01,0x01}, // AF_DROPN_ON_PEAK_DETECT_SECOND : +{0x0289,0x21,0x01}, //AWB_SN8 +{0x6674,0x01,0x01}, // AF_MONICHG_MOVE_F +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, //AF_RESTART_F +{0x00B3,0x00,0x01}, //AFMODE_HREL : +//{0xFFFF,0x42,0x01}, //$wait, 66 +{0x0081,0x01,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_AF_Cancel_Macro_ON[] = +{ +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode +{0x0081,0x00,0x01}, //MODESEL : Monitoring mode +{0x6648,0x02BC,0x02}, //AF_MANUAL_POS : MANUA AF search start position +{0x00B1,0x01,0x01}, //AF_RESTART_F +}; + +static const isx012_regset_t ISX012_AF_Cancel_Macro_OFF[] = +{ +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode +{0x0081,0x00,0x01}, //MODESEL : Monitoring mode +{0x6648,0x00C8,0x02}, //AF_MANUAL_POS : MANUA AF search start position +{0x00B1,0x01,0x01}, //AF_RESTART_F +}; + +static const isx012_regset_t ISX012_AF_ReStart[] = +{ +{0x00B1,0x01,0x01}, //AF_RESTART_F +{0x0082,0x01,0x01}, // MONI_REFRESH +}; + +static const isx012_regset_t ISX012_AF_Macro_OFF[] = +{ +{0x0081,0x00,0x01}, //MODESEL : Monitoring mode +{0x6648,0x00C8,0x02}, //AF_MANUAL_POS : MANUA AF search start position +{0x66DC,0x02BC,0x02}, //AF_JUDGE_MONO_POS_S +{0x665A,0x00C8,0x02}, // AF_LENSPOS_ON_AFNG : +{0x028E,0x00,0x01}, //AF_SEARCH_DIR : NEAR->FAR +{0x00B3,0x00,0x01}, //AFMODE_HREL : Manual AF mode +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode +//{0xFFFF,0x21,0x01}, //$wait, 33 +}; + +static const isx012_regset_t ISX012_AF_Macro_ON[] = +{ +{0x0081,0x00,0x01}, //MODESEL : Monitoring mode +{0x6648,0x02BC,0x02}, //AF_MANUAL_POS : MANUA AF search start position +{0x66DC,0x00C8,0x02}, //AF_JUDGE_MONO_POS_S +{0x665A,0x02BC,0x02}, // AF_LENSPOS_ON_AFNG : +{0x028E,0x01,0x01}, //AF_SEARCH_DIR : NEAR->FAR +{0x00B3,0x00,0x01}, //AFMODE_HREL : Manual AF mode +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode +//{0xFFFF,0x21,0x01}, //$wait, 33 +}; + +static const isx012_regset_t ISX012_AF_SAF[] = +{ +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, //AF_RESTART_F : +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x00,0x01}, //AFMODE_HREL : +//{0xFFFF,0x42,0x01}, //$wait, 66 +{0x0081,0x01,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_AF_SAF_OFF[] = +{ +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F +{0x0082,0x01,0x01}, // MONI_REFRESH +//{0xFFFF,0x42,0x01}, //$wait, 66 +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x03,0x01}, //AFMODE_HREL : AF OFF +}; + +static const isx012_regset_t ISX012_AF_TouchSAF_OFF[] = +{ +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F +{0x0082,0x01,0x01}, // MONI_REFRESH +//{0xFFFF,0x42,0x01}, //$wait, 66 +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x03,0x01}, //AFMODE_HREL : AF OFF +{0x0081,0x00,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_Camcorder_SAF_Start[] = +{ +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, /* AF_RESTART_F */ +//{0xFFFF,0x21,0x01}, /* $wait, 33 */ +{0x00B2,0x00,0x01}, /* AFMODE_MONI */ +}; + +static const isx012_regset_t ISX012_Camcorder_CAF_Start[] = +{ +{0x00B2,0x01,0x01}, /* AFMODE_MONI */ +}; + +static const isx012_regset_t ISX012_AF_Window_Reset[] = +{ +//AF opd window setting +{0x6A30,0x044E,0x02}, // AF_OPD0_HDELAY : +{0x6A32,0x02E5,0x02}, // AF_OPD0_VDELAY : +{0x6A34,0x01D8,0x02}, // AF_OPD0_HVALID : +{0x6A36,0x01D8,0x02}, // AF_OPD0_VVALID : +{0x6A38,0x0412,0x02}, // AF_OPD1_HDELAY : +{0x6A3A,0x02A9,0x02}, // AF_OPD1_VDELAY : +{0x6A3C,0x0251,0x02}, // AF_OPD1_HVALID : +{0x6A3E,0x0251,0x02}, // AF_OPD1_VVALID : +{0x6A40,0x04B4,0x02}, // AF_OPD2_HDELAY : +{0x6A42,0x0114,0x02}, // AF_OPD2_VDELAY : +{0x6A44,0x0118,0x02}, // AF_OPD2_HVALID : +{0x6A46,0x0118,0x02}, // AF_OPD2_VVALID : +{0x6A48,0x0469,0x02}, // AF_OPD3_HDELAY : +{0x6A4A,0x00C9,0x02}, // AF_OPD3_VDELAY : +{0x6A4C,0x01AE,0x02}, // AF_OPD3_HVALID : +{0x6A4E,0x01AE,0x02}, // AF_OPD3_VVALID : +{0x6A50,0x04C6,0x02}, // AF_OPD4_HDELAY : +{0x6A52,0x035D,0x02}, // AF_OPD4_VDELAY : +{0x6A54,0x00E6,0x02}, // AF_OPD4_HVALID : +{0x6A56,0x00E6,0x02}, // AF_OPD4_VVALID : +{0x6A58,0x048A,0x02}, // AF_OPD5_HDELAY : +{0x6A5A,0x0321,0x02}, // AF_OPD5_VDELAY : +{0x6A5C,0x015F,0x02}, // AF_OPD5_HVALID : +{0x6A5E,0x015F,0x02}, // AF_OPD5_VVALID : +{0x6A60,0x04B4,0x02}, // AF_OPD6_HDELAY : +{0x6A62,0x0579,0x02}, // AF_OPD6_VDELAY : +{0x6A64,0x0118,0x02}, // AF_OPD6_HVALID : +{0x6A66,0x0118,0x02}, // AF_OPD6_VVALID : +{0x6A68,0x0469,0x02}, // AF_OPD7_HDELAY : +{0x6A6A,0x052C,0x02}, // AF_OPD7_VDELAY : +{0x6A6C,0x01AE,0x02}, // AF_OPD7_HVALID : +{0x6A6E,0x01AE,0x02}, // AF_OPD7_VVALID : +{0x6A70,0x021D,0x02}, // AF_OPD8_HDELAY : +{0x6A72,0x02F5,0x02}, // AF_OPD8_VDELAY : +{0x6A74,0x01AE,0x02}, // AF_OPD8_HVALID : +{0x6A76,0x01AE,0x02}, // AF_OPD8_VVALID : +{0x6A78,0x06A4,0x02}, // AF_OPD9_HDELAY : +{0x6A7A,0x02F5,0x02}, // AF_OPD9_VDELAY : +{0x6A7C,0x01AE,0x02}, // AF_OPD9_HVALID : +{0x6A7E,0x01AE,0x02}, // AF_OPD9_VVALID : +{0x6A80,0x06,0x01}, // AF_OPD1A_WEIGHT : +{0x6A81,0x05,0x01}, // AF_OPD1B_WEIGHT : +{0x6A82,0x02,0x01}, // AF_OPD2A_WEIGHT : +{0x6A83,0x02,0x01}, // AF_OPD2B_WEIGHT : +{0x6A84,0x08,0x01}, // AF_OPD3A_WEIGHT : +{0x6A85,0x07,0x01}, // AF_OPD3B_WEIGHT : +{0x6A86,0x04,0x01}, // AF_OPD4A_WEIGHT : +{0x6A87,0x03,0x01}, // AF_OPD4B_WEIGHT : +{0x6A88,0x01,0x01}, // AF_OPD5A_WEIGHT : +{0x6A89,0x01,0x01}, // AF_OPD5B_WEIGHT : +{0x6646,0x08,0x01}, // AF_OPD_WEIGHT_TH : +}; + +/* Added by Samsung TN */ +static const isx012_regset_t ISX012_AF_Window_Set[] = +{ +{0x6A80,0x00,0x01}, +{0x6A81,0x00,0x01}, +{0x6A82,0x00,0x01}, +{0x6A83,0x00,0x01}, +{0x6A84,0x08,0x01}, +{0x6A85,0x00,0x01}, +{0x6A86,0x00,0x01}, +{0x6A87,0x00,0x01}, +{0x6A88,0x00,0x01}, +{0x6A89,0x00,0x01}, +{0x6646,0x08,0x01}, +}; + +static const isx012_regset_t isx012_Contrast_Minus_2[] = +{ +{0x01C7,0x58,0x01}, //UICONTRAST +}; + +static const isx012_regset_t isx012_Contrast_Minus_1[] = +{ +{0x01C7,0x6C,0x01}, //UICONTRAST +}; + +static const isx012_regset_t isx012_Contrast_Default[] = +{ +{0x01C7,0x80,0x01}, //UICONTRAST +}; + +static const isx012_regset_t isx012_Contrast_Plus_1[] = +{ +{0x01C7,0x94,0x01}, //UICONTRAST +}; + +static const isx012_regset_t isx012_Contrast_Plus_2[] = +{ +{0x01C7,0xA8,0x01}, //UICONTRAST +}; + +static const isx012_regset_t isx012_Effect_Sketch[] = +{ +{0x01C5,0x06,0x01}, /* FMODE */ +{0x6C5F,0x04,0x01}, /* SKETCH_APGAIN */ +}; + +static const isx012_regset_t isx012_Effect_Pastel[] = +{ +{0x01C5,0x05,0x01}, /* FMODE */ +}; + +static const isx012_regset_t isx012_Effect_Black_White[] = +{ +{0x01C5,0x04,0x01}, //FMODE +}; + +static const isx012_regset_t ISX012_Effect_Negative[] = +{ +{0x01C5,0x02,0x01}, //FMODE +}; + +static const isx012_regset_t isx012_Effect_Solar[] = +{ +{0x01C5,0x01,0x01}, /* FMODE */ +}; + +static const isx012_regset_t isx012_Effect_Normal[] = +{ +{0x01C5,0x00,0x01}, //FMODE +}; + +static const isx012_regset_t isx012_Effect_Sepia[] = +{ +{0x01C5,0x03,0x01}, //FMODE +}; + +static const isx012_regset_t isx012_Metering_Center[] = +{ +{0x02AC,0x01,0x01}, //AE_SUB_SN1 +{0x02B6,0x01,0x01}, //AE_SUB_SN11 +}; + +static const isx012_regset_t isx012_Metering_Matrix[] = +{ +{0x02AC,0x00,0x01}, //AE_SUB_SN1 +}; + +static const isx012_regset_t isx012_Metering_Spot[] = +{ +{0x02AC,0x02,0x01}, //AE_SUB_SN1 +{0x02B6,0x02,0x01}, //AE_SUB_SN11 +}; + +static const isx012_regset_t ISX012_ExpSetting_Default[] = +{ +{0x0180,0x00,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_M1Step[] = +{ +{0x0180,0xFF,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_M2Step[] = +{ +{0x0180,0xFE,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_M3Step[] = +{ +{0x0180,0xFD,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_M4Step[] = +{ +{0x0180,0xFC,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_P1Step[] = +{ +{0x0180,0x01,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_P2Step[] = +{ +{0x0180,0x02,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_P3Step[] = +{ +{0x0180,0x03,0x01}, //EVSEL +}; + +static const isx012_regset_t ISX012_ExpSetting_P4Step[] = +{ +{0x0180,0x04,0x01}, //EVSEL +}; + +static const isx012_regset_t isx012_ISO_50[] = +{ +{0x02A8,0x04,0x01}, //ISO_TYPE1 +{0x5E8A,0x00,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x00,0x01}, // EVREF_GAIN_B : +{0x0362,0x57,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x57,0x01}, // PICT3_GAMMA_CAP0 : +}; + +static const isx012_regset_t isx012_ISO_100[] = +{ +{0x02A8,0x07,0x01}, //ISO_TYPE1 +{0x5E8A,0x00,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x00,0x01}, // EVREF_GAIN_B : +{0x0362,0x57,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x57,0x01}, // PICT3_GAMMA_CAP0 : +}; + +static const isx012_regset_t isx012_ISO_200[] = +{ +{0x02A8,0x0A,0x01}, //ISO_TYPE1 +{0x5E8A,0x00,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x00,0x01}, // EVREF_GAIN_B : +{0x0362,0x57,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x57,0x01}, // PICT3_GAMMA_CAP0 : +}; + +static const isx012_regset_t isx012_ISO_400[] = +{ +{0x02A8,0x0D,0x01}, //ISO_TYPE1 +{0x5E8A,0x00,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x00,0x01}, // EVREF_GAIN_B : +{0x0362,0x57,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x57,0x01}, // PICT3_GAMMA_CAP0 : +}; + +#if 0 +static const isx012_regset_t ISX012_ISO_800[] = +{ +{0x02A8,0x10,0x01}, //ISO_TYPE1 +{0x5E8A,0x00,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x00,0x01}, // EVREF_GAIN_B : +{0x0362,0x57,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x57,0x01}, // PICT3_GAMMA_CAP0 : +}; +#endif + +static const isx012_regset_t isx012_ISO_Auto[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 +{0x5E8A,0x02,0x01}, // EVREF_GAIN_A : +{0x5E8B,0x02,0x01}, // EVREF_GAIN_B : +{0x0362,0x55,0x01}, // PICT3_GAMMA_MONI0 : +{0x0365,0x55,0x01}, // PICT3_GAMMA_CAP0 : +}; + +static const isx012_regset_t ISX012_Capture_SizeSetting[] = +{ +{0x0092,0x0A20,0x02}, //HSIZE_CAP : 2592 +{0x0098,0x0798,0x02}, //VSIZE_CAP : 1944 +}; + +static const isx012_regset_t ISX012_Capture_Mode[] = +{ +{0x008A,0x00,0x01}, //OUTFMT_CAP +{0x0084,0x00,0x01}, //SENSMODE_CAP +{0x0087,0x03,0x01}, //FPSTYPE_CAP +{0x0012,0xFF,0x01}, //INTCLR0 +{0x0081,0x02,0x01}, //MODESEL +{0x0082,0x01,0x01}, //MONI_REFRESH +}; + +static const isx012_regset_t ISX012_Lowlux_Night_Capture_Mode[] = +{ +{0x03A0,0xA0,0x01}, //UISATURATION_TYPE3 : +{0x039D,0xF4,0x01}, //UIHUE_TYPE3 : +{0x982A,0xFFD8,0x02}, // CS_CBLLEV_A : +{0x9830,0xFFD8,0x02}, // CS_CRLLEV_A : +{0x9805,0x06,0x01}, // CS_SLP_C_A : +{0x008A,0x00,0x01}, //OUTFMT_CAP +{0x0084,0x00,0x01}, //SENSMODE_CAP +{0x0087,0x03,0x01}, //FPSTYPE_CAP +{0x0012,0xFF,0x01}, //INTCLR0 +{0x0081,0x02,0x01}, //MODESEL +{0x0082,0x01,0x01}, //MONI_REFRESH +}; + +static const isx012_regset_t isx012_Saturation_Default[] = +{ +{0x039E,0x80,0x01}, //UISATURATION_TYPE1 +}; + +static const isx012_regset_t isx012_Saturation_Minus_1[] = +{ +{0x039E,0x62,0x01}, //UISATURATION_TYPE1 +}; + +static const isx012_regset_t isx012_Saturation_Minus_2[] = +{ +{0x039E,0x44,0x01}, //UISATURATION_TYPE1 +}; + +static const isx012_regset_t isx012_Saturation_Plus_1[] = +{ +{0x039E,0x9E,0x01}, //UISATURATION_TYPE1 +}; + +static const isx012_regset_t isx012_Saturation_Plus_2[] = +{ +{0x039E,0xBC,0x01}, //UISATURATION_TYPE1 +}; + +static const isx012_regset_t isx012_Scene_Default[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x00,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Landscape[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x039F,0x9E,0x01}, //UISATURATION_TYPE2 : +{0x03A3,0x2C,0x01}, //UISHARPNESS_POS_TYPE3 : +1 +{0x03A6,0x2C,0x01}, //UISHARPNESS_NEG_TYPE3 : +1 +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x01,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Sports[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x02,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Party_Indoor[] = +{ +{0x02A8,0x0A,0x01}, //ISO_TYPE1 : ISO200 +{0x039F,0x9E,0x01}, //UISATURATION_TYPE2 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x04,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x00,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Beach_Snow[] = +{ +{0x02A8,0x04,0x01}, //ISO_TYPE1 : ISO50 +{0x039F,0x9E,0x01}, //UISATURATION_TYPE2 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x04,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Sunset[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x0287,0x25,0x01}, //AWB_SN6 : daylight +{0x0394,0x00,0x01}, //PICT1_SN6 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x05,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Duskdawn[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x0287,0x27,0x01}, //AWB_SN6 : CWF +{0x0394,0x00,0x01}, //PICT1_SN6 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x05,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Candle_Light[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x0287,0x25,0x01}, //AWB_SN6 : daylight +{0x0394,0x00,0x01}, //PICT1_SN6 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x05,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Fall_Color[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x039F,0xBC,0x01}, //UISATURATION_TYPE2 : +{0x0287,0x20,0x01}, //AWB_SN6 : AWB +{0x0394,0x04,0x01}, //PICT1_SN6 : +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x05,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Portrait[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x50,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x00,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Nightshot[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x00,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x07,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Fireworks[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : AUTO +{0x5E06,0x04,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x00,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x08,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Text[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x03A3,0x38,0x01}, //UISHARPNESS_POS_TYPE3 : +2 +{0x03A6,0x38,0x01}, //UISHARPNESS_NEG_TYPE3 : +2 +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0xA0,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x00,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Scene_Backlight[] = +{ +{0x02A8,0x00,0x01}, //ISO_TYPE1 : Auto +{0x5E06,0x02,0x01}, //SHTCTRLMAG3 +{0x038F,0x00,0x01}, //PICT1_SN1 : +{0x6742,0x0012,0x02}, // AF_SEARCH_OFFSET_FAR : +{0x6744,0x0006,0x02}, // AF_SEARCH_OFFSET_NEAR : +{0x500B,0x01,0x01}, // FAST_SHT_MODE_SEL +{0x0280,0x00,0x01}, //SCENE_SELECT +}; + +static const isx012_regset_t isx012_Sharpness_Default[] = +{ +{0x00A1,0x20,0x01}, //UISHARPNESS_POS_TYPE1 +{0x00A4,0x20,0x01}, //UISHARPNESS_NEG_TYPE1 +}; + +static const isx012_regset_t isx012_Sharpness_Minus_1[] = +{ +{0x00A1,0x14,0x01}, //UISHARPNESS_POS_TYPE1 +{0x00A4,0x14,0x01}, //UISHARPNESS_NEG_TYPE1 +}; + +static const isx012_regset_t isx012_Sharpness_Minus_2[] = +{ +{0x00A1,0x08,0x01}, //UISHARPNESS_POS_TYPE1 +{0x00A4,0x08,0x01}, //UISHARPNESS_NEG_TYPE1 +}; + +static const isx012_regset_t isx012_Sharpness_Plus_1[] = +{ +{0x00A1,0x2C,0x01}, //UISHARPNESS_POS_TYPE1 +{0x00A4,0x2C,0x01}, //UISHARPNESS_NEG_TYPE1 +}; + +static const isx012_regset_t isx012_Sharpness_Plus_2[] = +{ +{0x00A1,0x38,0x01}, //UISHARPNESS_POS_TYPE1 +{0x00A4,0x38,0x01}, //UISHARPNESS_NEG_TYPE1 +}; + +static const isx012_regset_t isx012_WB_Auto[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_WB_Cloudy[] = +{ +{0x0282,0x26,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_WB_Sunny[] = +{ +{0x0282,0x25,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_WB_Fluorescent[] = +{ +{0x0282,0x27,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_WB_Tungsten[] = +{ +{0x0282,0x28,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t ISX012_Image_Quality_Standard[] = +{ +{0x00F6,0x00,0x01}, //JPG_QLTY +{0x0082,0x01,0x01}, //MONI_REFRESH +}; + +static const isx012_regset_t ISX012_Image_Quality_Fine[] = +{ +{0x00F6,0x01,0x01}, //JPG_QLTY +{0x0082,0x01,0x01}, //MONI_REFRESH +}; + +static const isx012_regset_t ISX012_Image_Quality_Super_Fine[] = +{ +{0x00F6,0x02,0x01}, //JPG_QLTY +{0x0082,0x01,0x01}, //MONI_REFRESH +}; + +static const isx012_regset_t ISX012_Image_Quality_Table[] = +{ +{0x00F7,0x52,0x01}, // INIT_QLTY0 : Standard 82 +{0x00F8,0x59,0x01}, // INIT_QLTY1 : Fine 89 +{0x00F9,0x5F,0x01}, // INIT_QLTY2 : SuperFine 95 +}; + +static const isx012_regset_t ISX012_Sensor_Off_VCM[] = +{ +{0x6674,0x00,0x01}, // AF_MONICHG_MOVE_F +{0x00B2,0x02,0x01}, //AFMODE_MONI : Manual AF mode +{0x0081,0x00,0x01}, //MODESEL : Monitoring mode +{0x6600,0x0000,0x02}, // AF_SEARCH_AREA_LOW +{0x6666,0x0000,0x02}, // AF_AREA_LOW_TYPE1 +{0x6648,0x00C8,0x02}, // AF_MANUAL_POS : +{0x00B1,0x01,0x01}, //AF_RESTART_F +{0xFFFF,0x64,0x01}, // $wait, 100 +{0x6648,0x0019,0x02}, // AF_MANUAL_POS : +{0x00B1,0x01,0x01}, // AF_RESTART_F +{0xFFFF,0x64,0x01}, // $wait, 100 +}; + +static const isx012_regset_t isx012_1280_Preview_E[] = +{ +{0x0090,0x0500,0x02}, //HSIZE_MONI : 1280 +{0x0096,0x02D0,0x02}, //VSIZE_MONI : 720 +}; + +static const isx012_regset_t isx012_1024_768_Preview[] = { +{0x0090,0x0400,0x02}, /* HSIZE_MONI : 1024 */ +{0x0096,0x0300,0x02}, /* VSIZE_MONI : 768 */ +}; + +static const isx012_regset_t isx012_800_Preview[] = +{ +{0x0090,0x0320,0x02}, //HSIZE_MONI : 800 +{0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 +}; + +static const isx012_regset_t isx012_720_Preview[] = +{ +{0x0090,0x02D0,0x02}, //HSIZE_MONI : 720 +{0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 +}; + +static const isx012_regset_t isx012_640_Preview[] = +{ +{0x0090,0x0280,0x02}, //HSIZE_MONI : 640 +{0x0096,0x01E0,0x02}, //VSIZE_MONI : 480 +}; + +#if defined(CONFIG_MACH_P4NOTELTE_KOR_SKT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_KT) \ + || defined(CONFIG_MACH_P4NOTELTE_KOR_LGT) /*For 4G VT call in Domestic*/ +static const isx012_regset_t isx012_480_Preview[] = { +{0x0090, 0x01E0, 0x02}, /* HSIZE_MONI : 480 */ +{0x0096, 0x0280, 0x02}, /* VSIZE_MONI : 640 */ +}; +#endif + +static const isx012_regset_t isx012_320_Preview[] = +{ +{0x0090,0x0140,0x02}, //HSIZE_MONI : 320 +{0x0096,0x00F0,0x02}, //VSIZE_MONI :240 + +}; +static const isx012_regset_t isx012_176_Preview[] = +{ +{0x0090,0x00B0,0x02}, //HSIZE_MONI : 176 +{0x0096,0x0090,0x02}, //VSIZE_MONI : 144 +}; + + +static const isx012_regset_t isx012_5M_Capture[] = { +{0x0092,0x0A00,0x02}, /* HSIZE_CAP: 2560 */ +{0x0098,0x0780,0x02}, /* VSIZE_CAP: 1920 */ +}; + +static const isx012_regset_t isx012_4M_WIDE_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_3M_Capture[] = { +{0x0092,0x0800,0x02}, /* HSIZE_CAP : 2048 */ +{0x0098,0x0600,0x02}, /* VSIZE_CAP : 1536 */ +}; + +static const isx012_regset_t isx012_2_4M_WIDE_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_1_5M_WIDE_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_960_720_Capture[] = { +{0x0092,0x03C0,0x02}, /* HSIZE_CAP : 960 */ +{0x0098,0x02D0,0x02}, /* VSIZE_CAP : 720 */ +}; + +static const isx012_regset_t isx012_1M_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_4K_WIDE_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_VGA_Capture[] = { +{0x0092,0x0280,0x02}, /* HSIZE_CAP : 640 */ +{0x0098,0x01E0,0x02}, /* VSIZE_CAP : 480 */ +}; + +static const isx012_regset_t isx012_QVGA_Capture[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_DTP_init[] = +{ +{0x01BC,0x50,0x01},//Shading Gain off +{0x5E00,0x07,0x01},//Flicker off + +// Pre-WB +{0x6804,0x1000,0x02}, // NORMR +{0x6806,0x1000,0x02}, // NORMB +{0x6808,0x0100,0x02}, // AWBPRER +{0x680A,0x0100,0x02}, // AWBPREB +{0x6818,0x00,0x01}, //REFERENCE SENSITIVITY RATIO OF SENSOR (R/G) +{0x6819,0x00,0x01}, //REFERENCE SENSITIVITY RATIO OF SENSOR (B/G) + +{0x036B,0x11,0x01}, +{0x0377,0x11,0x01}, +{0x0383,0x11,0x01}, + +// +{0x6C44,0x00,0x01}, // G_CTRL_SEL : + +//CNR +{0x6C4A,0x07,0x01}, // MAIN_CONFIG5 : + +//ITP NR +{0x5005,0xBB,0x01}, // DM_SW1 : +{0x5006,0x03,0x01}, // DM_SW2 : +{0x0362,0x00,0x01}, + +{0x6C0B,0x04,0x01}, // PICT_FLAG : +{0x9800,0x80,0x01}, // LMT_WEIGHT_A : +{0x9801,0x80,0x01}, // LMT_WEIGHT_B : + +{0x6C46,0x00,0x01}, // MAIN_CONFIG1 : +{0x6C47,0x00,0x01}, // MAIN_CONFIG2 : +{0x6C48,0x00,0x01}, // MAIN_CONFIG3 : +{0x6C49,0x00,0x01}, // MAIN_CONFIG4 : +{0x6C4A,0x00,0x01}, // MAIN_CONFIG5 : + + +{0x5001,0x04,0x01}, // MUTECNT : +{0x5002,0x00,0x01}, // WDT_EN : +{0x5003,0x07,0x01}, // Z1_SEL1 : +{0x5004,0x00,0x01}, // Z1_SEL2 : +{0x5005,0x00,0x01}, // DM_SW1 : +{0x5006,0x00,0x01}, // DM_SW2 : +{0x5007,0x00,0x01}, // CLMP_CTRL : +{0x5009,0x00,0x01}, // CPUSLEEP_EN : +{0x500A,0x00,0x01}, // FAST_MODECHG_EN : +{0x500B,0x00,0x01}, // FAST_SHT_MODE_SEL : +{0x500C,0x00FA,0x02}, // FAST_SHT_LIMIT_COUNT : +{0x500E,0x06D0,0x02}, // SYSINT3_VDLY_1_1 : +{0x5010,0x02F8,0x02}, // SYSINT3_VDLY_1_2 : +{0x5012,0x0118,0x02}, // SYSINT3_VDLY_1_4 : +{0x5014,0x0028,0x02}, // SYSINT3_VDLY_1_8 : +{0x5016,0x0370,0x02}, // SYSINT3_VDLY_1_1_HD : +{0x5018,0x0208,0x02}, // SYSINT3_VDLY_1_2_HD : +{0x501A,0x00,0x01}, // SENS_REVERSE_CTRL : +{0x501B,0x19,0x01}, // EEP_ADDRESS : +{0x501C,0x5180,0x02}, // SRCCK : +{0x501E,0x0001,0x02}, + +{0x6E86,0x0000,0x02}, // IBYHUE1_POS1 : +{0x6E88,0xFFF5,0x02}, // IRYHUE1_POS1 : +{0x6E8A,0xFFF8,0x02}, // IBYHUE2_POS1 : +{0x6E8C,0xFFF5,0x02}, // IRYHUE2_POS1 : +{0x6E8E,0xFFF8,0x02}, // IBYHUE3_POS1 : +{0x6E90,0xFFEE,0x02}, // IRYHUE3_POS1 : +{0x6E92,0x0000,0x02}, // IBYHUE4_POS1 : +{0x6E94,0xFFEC,0x02}, // IRYHUE4_POS1 : +{0x6F26,0x4E,0x01}, // IRYGAIN1_POS1 : +{0x6F27,0x50,0x01}, // IBYGAIN1_POS1 : +{0x6F28,0x4E,0x01}, // IRYGAIN2_POS1 : +{0x6F29,0x5A,0x01}, // IBYGAIN2_POS1 : +{0x6F2A,0x50,0x01}, // IRYGAIN3_POS1 : +{0x6F2B,0x5A,0x01}, // IBYGAIN3_POS1 : +{0x6F2C,0x50,0x01}, // IRYGAIN4_POS1 : +{0x6F2D,0x50,0x01}, // IBYGAIN4_POS1 : + +//ae +{0x5E12,0x0000,0x02}, +{0x5E14,0x0000,0x02}, +{0x0294,0x03,0x01}, + +//AWB +{0x625F,0x35,0x01},//CAT_AWB_1 +{0x0282,0x05,0x01},//AWB_SN1 +//S, 5000, 3F, 8, // CPUEXT : + + +{0x5021,0x00,0x01}, // PG_GAIN_SEL : +{0x5022,0x01,0x01}, // PG_WIDTH_SEL : +{0x5023,0x04,0x01}, // PG_MODE_SEL : +{0x5024,0x0000,0x02}, // PG_LEVEL_SEL : +{0x5026,0x00,0x01}, // PG_DATEN_OFF_SEL : +{0x5020,0x01,0x01}, // PGSEL : + +}; + +static const isx012_regset_t isx012_DTP_stop[] = +{ +{0x01BC,0x57,0x01}, // Shading Gain off +{0x5E00,0x00,0x01}, // Flicker off +{0x6804,0x11F0,0x02}, // NORMR +{0x6806,0x106F,0x02}, // NORMB +{0x6808,0x014C,0x02}, // AWBPRER +{0x680A,0x021E,0x02}, // AWBPREB +{0x6818,0x00,0x01}, // REFERENCE SENSITIVITY RATIO OF SENSOR (R/G) +{0x6819,0x00,0x01}, // REFERENCE SENSITIVITY RATIO OF SENSOR (B/G) +{0x036B,0x80,0x01}, // +{0x0377,0x80,0x01}, // +{0x0383,0x80,0x01}, // +{0x6C44,0x13,0x01}, // G_CTRL_SEL : +{0x6C4A,0x07,0x01}, // MAIN_CONFIG5 : +{0x5005,0xBB,0x01}, // DM_SW1 : +{0x5006,0x03,0x01}, // DM_SW2 : +{0x0362,0x55,0x01}, // +{0x6C0B,0x00,0x01}, // PICT_FLAG : +{0x9800,0x40,0x01}, // LMT_WEIGHT_A : +{0x9801,0x80,0x01}, // LMT_WEIGHT_B : +{0x6C46,0x1C,0x01}, // MAIN_CONFIG1 : +{0x6C47,0x0F,0x01}, // MAIN_CONFIG2 : +{0x6C48,0x03,0x01}, // MAIN_CONFIG3 : +{0x6C49,0xF5,0x01}, // MAIN_CONFIG4 : +{0x6C4A,0x07,0x01}, // MAIN_CONFIG5 : +{0x5001,0x04,0x01}, // MUTECNT : +{0x5002,0x01,0x01}, // WDT_EN : +{0x5003,0x04,0x01}, // Z1_SEL1 : +{0x5004,0x00,0x01}, // Z1_SEL2 : +{0x5005,0xBB,0x01}, // DM_SW1 : +{0x5006,0x03,0x01}, // DM_SW2 : +{0x5007,0x01,0x01}, // CLMP_CTRL : +{0x5009,0x00,0x01}, // CPUSLEEP_EN : +{0x500A,0x00,0x01}, // FAST_MODECHG_EN : +{0x500B,0x00,0x01}, // FAST_SHT_MODE_SEL : +{0x500C,0x00FA,0x02}, // FAST_SHT_LIMIT_COUNT : +{0x500E,0x06D0,0x02}, // SYSINT3_VDLY_1_1 : +{0x5010,0x02F8,0x02}, // SYSINT3_VDLY_1_2 : +{0x5012,0x0118,0x02}, // SYSINT3_VDLY_1_4 : +{0x5014,0x0028,0x02}, // SYSINT3_VDLY_1_8 : +{0x5016,0x0370,0x02}, // SYSINT3_VDLY_1_1_HD : +{0x5018,0x0208,0x02}, // SYSINT3_VDLY_1_2_HD : +{0x501A,0x00,0x01}, // SENS_REVERSE_CTRL : +{0x501B,0x50,0x01}, // EEP_ADDRESS : +{0x501C,0x5180,0x02}, // SRCCK : +{0x501E,0x0001,0x02}, +{0x6E86,0x0000,0x02}, // IBYHUE1_POS1 : +{0x6E88,0xFFF5,0x02}, // IRYHUE1_POS1 : +{0x6E8A,0xFFF8,0x02}, // IBYHUE2_POS1 : +{0x6E8C,0xFFF5,0x02}, // IRYHUE2_POS1 : +{0x6E8E,0xFFF8,0x02}, // IBYHUE3_POS1 : +{0x6E90,0xFFEE,0x02}, // IRYHUE3_POS1 : +{0x6E92,0x0000,0x02}, // IBYHUE4_POS1 : +{0x6E94,0xFFEC,0x02}, // IRYHUE4_POS1 : +{0x6F26,0x4E,0x01}, // IRYGAIN1_POS1 : +{0x6F27,0x50,0x01}, // IBYGAIN1_POS1 : +{0x6F28,0x4E,0x01}, // IRYGAIN2_POS1 : +{0x6F29,0x5A,0x01}, // IBYGAIN2_POS1 : +{0x6F2A,0x50,0x01}, // IRYGAIN3_POS1 : +{0x6F2B,0x5A,0x01}, // IBYGAIN3_POS1 : +{0x6F2C,0x50,0x01}, // IRYGAIN4_POS1 : +{0x6F2D,0x50,0x01}, // IBYGAIN4_POS1 : +{0x5E12,0x014A,0x02}, // +{0x5E14,0x000D,0x02}, // +{0x0294,0x00,0x01}, // +{0x625F,0x35,0x01}, // CAT_AWB_1 +{0x0282,0x20,0x01}, // AWB_SN1 +{0x5021,0x00,0x01}, // PG_GAIN_SEL : +{0x5022,0x00,0x01}, // PG_WIDTH_SEL : +{0x5023,0x00,0x01}, // PG_MODE_SEL : +{0x5024,0x0000,0x02}, // PG_LEVEL_SEL : +{0x5026,0x00,0x01}, // PG_DATEN_OFF_SEL : +{0x5020,0x00,0x01}, // PGSEL : + +}; + +static const isx012_regset_t isx012_Preview_Return[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 + +}; + +static const isx012_regset_t isx012_Capture_Start[] = +{ + {0x008A,0x00,0x01}, //OUTFMT_CAP + {0x0084,0x00,0x01}, //SENSMODE_CAP + {0x0087,0x03,0x01}, //FPSTYPE_CAP + {0x0012,0x06,0x01}, //INTCLR0 + {0x0081,0x02,0x01}, //MODESEL + {0x0082,0x01,0x01}, //MONI_REFRESH +}; +#if 0 +static const isx012_regset_t isx012_Preview_Return[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; +#endif + +static const isx012_regset_t isx012_fps_auto[] = +{ +{0x0308,0x11,0x01}, /* AELINE_MONI_SN1_2 */ +{0x018E,0x0012,0x02}, /* VADJ_SENS_1_2 */ +}; + +static const isx012_regset_t isx012_fps_7fix[] = +{ +{0x0308,0x02,0x01}, /* AELINE_MONI_SN1_2 */ +{0x018E,0x0D59,0x02}, /* VADJ_SENS_1_2 */ +}; + +static const isx012_regset_t isx012_fps_15fix[] = +{ +{0x0308,0x02,0x01}, /* AELINE_MONI_SN1_2 */ +{0x018E,0x041C,0x02}, /* VADJ_SENS_1_2 */ +}; + +static const isx012_regset_t isx012_fps_25fix[] = +{ +{0x0308,0x02,0x01}, /* AELINE_MONI_SN1_2 */ +{0x018E,0x00E1,0x02}, /* VADJ_SENS_1_2 */ +}; + +static const isx012_regset_t isx012_fps_30fix[] = +{ +{0x0308,0x02,0x01}, /* AELINE_MONI_SN1_2 */ +{0x018E,0x0012,0x02}, /* VADJ_SENS_1_2 */ +}; + +static const isx012_regset_t isx012_ae_lock[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_ae_unlock[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_awb_lock[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + +static const isx012_regset_t isx012_awb_unlock[] = +{ +{0x0282,0x20,0x01}, //AWB_SN1 +}; + + +static const isx012_regset_t ISX012_Shading_Nocal[] = +{ +{0x01BC,0x50,0x01}, // CXC OFF SHD OFF +{0xEB00,0x8282,0x02}, //valid_code +{0xEB02,0xFE,0x01}, +{0xEB03,0x84,0x01}, +{0xEB04,0x3F,0x01}, +{0xEB05,0x01,0x01}, +{0xEB06,0x50,0x01}, +{0xEB07,0x08,0x01}, +{0xEB08,0x14,0x01}, +{0xEB09,0xFF,0x01}, +{0xEB0A,0x45,0x01}, +{0xEB0B,0x80,0x01}, +{0xEB0C,0x01,0x01}, +{0xEB0D,0x68,0x01}, +{0xEB0E,0x04,0x01}, +{0xEB0F,0x1A,0x01}, +{0xEB10,0x81,0x01}, +{0xEB11,0x86,0x01}, +{0xEB12,0x3F,0x01}, +{0xEB13,0xE1,0x01}, +{0xEB14,0x4F,0x01}, +{0xEB15,0x00,0x01}, +{0xEB16,0x14,0x01}, +{0xEB17,0x02,0x01}, +{0xEB18,0xC5,0x01}, +{0xEB19,0x7F,0x01}, +{0xEB1A,0x11,0x01}, +{0xEB1B,0x60,0x01}, +{0xEB1C,0x00,0x01}, +{0xEB1D,0x1A,0x01}, +{0xEB1E,0x81,0x01}, +{0xEB1F,0x46,0x01}, +{0xEB20,0xA0,0x01}, +{0xEB21,0x01,0x01}, +{0xEB22,0x48,0x01}, +{0xEB23,0x00,0x01}, +{0xEB24,0x12,0x01}, +{0xEB25,0x81,0x01}, +{0xEB26,0x05,0x01}, +{0xEB27,0x20,0x01}, +{0xEB28,0xF1,0x01}, +{0xEB29,0x4F,0x01}, +{0xEB2A,0x00,0x01}, +{0xEB2B,0x14,0x01}, +{0xEB2C,0x82,0x01}, +{0xEB2D,0x85,0x01}, +{0xEB2E,0x80,0x01}, +{0xEB2F,0x21,0x01}, +{0xEB30,0x60,0x01}, +{0xEB31,0x04,0x01}, +{0xEB32,0x12,0x01}, +{0xEB33,0x81,0x01}, +{0xEB34,0x84,0x01}, +{0xEB35,0xE0,0x01}, +{0xEB36,0x00,0x01}, +{0xEB37,0x28,0x01}, +{0xEB38,0x04,0x01}, +{0xEB39,0x0C,0x01}, +{0xEB3A,0x82,0x01}, +{0xEB3B,0x43,0x01}, +{0xEB3C,0x20,0x01}, +{0xEB3D,0x11,0x01}, +{0xEB3E,0x68,0x01}, +{0xEB3F,0x04,0x01}, +{0xEB40,0x1A,0x01}, +{0xEB41,0x82,0x01}, +{0xEB42,0x83,0x01}, +{0xEB43,0xE0,0x01}, +{0xEB44,0x00,0x01}, +{0xEB45,0x20,0x01}, +{0xEB46,0x00,0x01}, +{0xEB47,0x06,0x01}, +{0xEB48,0xFF,0x01}, +{0xEB49,0x41,0x01}, +{0xEB4A,0x80,0x01}, +{0xEB4B,0x10,0x01}, +{0xEB4C,0x30,0x01}, +{0xEB4D,0x08,0x01}, +{0xEB4E,0x14,0x01}, +{0xEB4F,0x02,0x01}, +{0xEB50,0x45,0x01}, +{0xEB51,0xC0,0x01}, +{0xEB52,0x10,0x01}, +{0xEB53,0x30,0x01}, +{0xEB54,0x04,0x01}, +{0xEB55,0x04,0x01}, +{0xEB56,0x01,0x01}, +{0xEB57,0xC0,0x01}, +{0xEB58,0x3F,0x01}, +{0xEB59,0x10,0x01}, +{0xEB5A,0x10,0x01}, +{0xEB5B,0x04,0x01}, +{0xEB5C,0x0A,0x01}, +{0xEB5D,0x80,0x01}, +{0xEB5E,0x03,0x01}, +{0xEB5F,0xE0,0x01}, +{0xEB60,0x10,0x01}, +{0xEB61,0x28,0x01}, +{0xEB62,0x04,0x01}, +{0xEB63,0x0A,0x01}, +{0xEB64,0x81,0x01}, +{0xEB65,0x01,0x01}, +{0xEB66,0x00,0x01}, +{0xEB67,0x10,0x01}, +{0xEB68,0x00,0x01}, +{0xEB69,0x04,0x01}, +{0xEB6A,0x04,0x01}, +{0xEB6B,0x01,0x01}, +{0xEB6C,0x42,0x01}, +{0xEB6D,0xE0,0x01}, +{0xEB6E,0x10,0x01}, +{0xEB6F,0x38,0x01}, +{0xEB70,0xFC,0x01}, +{0xEB71,0x0D,0x01}, +{0xEB72,0x7F,0x01}, +{0xEB73,0x43,0x01}, +{0xEB74,0x60,0x01}, +{0xEB75,0x00,0x01}, +{0xEB76,0x08,0x01}, +{0xEB77,0x08,0x01}, +{0xEB78,0x02,0x01}, +{0xEB79,0x81,0x01}, +{0xEB7A,0x41,0x01}, +{0xEB7B,0x80,0x01}, +{0xEB7C,0x10,0x01}, +{0xEB7D,0x30,0x01}, +{0xEB7E,0x04,0x01}, +{0xEB7F,0x0C,0x01}, +{0xEB80,0x01,0x01}, +{0xEB81,0x43,0x01}, +{0xEB82,0xC0,0x01}, +{0xEB83,0x20,0x01}, +{0xEB84,0x28,0x01}, +{0xEB85,0x08,0x01}, +{0xEB86,0x06,0x01}, +{0xEB87,0x02,0x01}, +{0xEB88,0xC2,0x01}, +{0xEB89,0xA0,0x01}, +{0xEB8A,0x30,0x01}, +{0xEB8B,0x30,0x01}, +{0xEB8C,0x0C,0x01}, +{0xEB8D,0x12,0x01}, +{0xEB8E,0x83,0x01}, +{0xEB8F,0x84,0x01}, +{0xEB90,0x00,0x01}, +{0xEB91,0x21,0x01}, +{0xEB92,0x40,0x01}, +{0xEB93,0x0C,0x01}, +{0xEB94,0x0C,0x01}, +{0xEB95,0x82,0x01}, +{0xEB96,0x03,0x01}, +{0xEB97,0xC1,0x01}, +{0xEB98,0x40,0x01}, +{0xEB99,0x40,0x01}, +{0xEB9A,0x08,0x01}, +{0xEB9B,0x10,0x01}, +{0xEB9C,0x03,0x01}, +{0xEB9D,0xC4,0x01}, +{0xEB9E,0x00,0x01}, +{0xEB9F,0x21,0x01}, +{0xEBA0,0x38,0x01}, +{0xEBA1,0x08,0x01}, +{0xEBA2,0x0E,0x01}, +{0xEBA3,0x82,0x01}, +{0xEBA4,0xC3,0x01}, +{0xEBA5,0x20,0x01}, +{0xEBA6,0x41,0x01}, +{0xEBA7,0x48,0x01}, +{0xEBA8,0x00,0x01}, +{0xEBA9,0x14,0x01}, +{0xEBAA,0x83,0x01}, +{0xEBAB,0x44,0x01}, +{0xEBAC,0x20,0x01}, +{0xEBAD,0x11,0x01}, +{0xEBAE,0x48,0x01}, +{0xEBAF,0x08,0x01}, +{0xEBB0,0x0E,0x01}, +{0xEBB1,0x82,0x01}, +{0xEBB2,0x83,0x01}, +{0xEBB3,0xE0,0x01}, +{0xEBB4,0x30,0x01}, +{0xEBB5,0x48,0x01}, +{0xEBB6,0x10,0x01}, +{0xEBB7,0x12,0x01}, +{0xEBB8,0x00,0x01}, +{0xEBB9,0xC5,0x01}, +{0xEBBA,0x20,0x01}, +{0xEBBB,0x11,0x01}, +{0xEBBC,0x48,0x01}, +{0xEBBD,0x04,0x01}, +{0xEBBE,0x12,0x01}, +{0xEBBF,0x04,0x01}, +{0xEBC0,0x3B,0x01}, +{0xEBC1,0xC1,0x01}, +{0xEBC2,0x1E,0x01}, +{0xEBC3,0xC8,0x01}, +{0xEBC4,0x0F,0x01}, +{0xEBC5,0xF8,0x01}, +{0xEBC6,0x02,0x01}, +{0xEBC7,0xBB,0x01}, +{0xEBC8,0x60,0x01}, +{0xEBC9,0x0F,0x01}, +{0xEBCA,0xB8,0x01}, +{0xEBCB,0x0F,0x01}, +{0xEBCC,0xEA,0x01}, +{0xEBCD,0x83,0x01}, +{0xEBCE,0x3A,0x01}, +{0xEBCF,0xC1,0x01}, +{0xEBD0,0x4E,0x01}, +{0xEBD1,0xB0,0x01}, +{0xEBD2,0x07,0x01}, +{0xEBD3,0xF2,0x01}, +{0xEBD4,0x03,0x01}, +{0xEBD5,0xBE,0x01}, +{0xEBD6,0xC0,0x01}, +{0xEBD7,0x2E,0x01}, +{0xEBD8,0xD8,0x01}, +{0xEBD9,0x03,0x01}, +{0xEBDA,0xEE,0x01}, +{0xEBDB,0x83,0x01}, +{0xEBDC,0xFA,0x01}, +{0xEBDD,0xA0,0x01}, +{0xEBDE,0x2E,0x01}, +{0xEBDF,0xB0,0x01}, +{0xEBE0,0x0B,0x01}, +{0xEBE1,0xEC,0x01}, +{0xEBE2,0x05,0x01}, +{0xEBE3,0xBD,0x01}, +{0xEBE4,0x60,0x01}, +{0xEBE5,0x2F,0x01}, +{0xEBE6,0xD0,0x01}, +{0xEBE7,0x07,0x01}, +{0xEBE8,0xEC,0x01}, +{0xEBE9,0x02,0x01}, +{0xEBEA,0xBC,0x01}, +{0xEBEB,0x40,0x01}, +{0xEBEC,0x2F,0x01}, +{0xEBED,0xD0,0x01}, +{0xEBEE,0x13,0x01}, +{0xEBEF,0xEE,0x01}, +{0xEBF0,0x84,0x01}, +{0xEBF1,0xBB,0x01}, +{0xEBF2,0x00,0x01}, +{0xEBF3,0x1F,0x01}, +{0xEBF4,0xC8,0x01}, +{0xEBF5,0xFF,0x01}, +{0xEBF6,0xEF,0x01}, +{0xEBF7,0x00,0x01}, +{0xEBF8,0x7D,0x01}, +{0xEBF9,0x60,0x01}, +{0xEBFA,0x2F,0x01}, +{0xEBFB,0xD0,0x01}, +{0xEBFC,0x0B,0x01}, +{0xEBFD,0xF4,0x01}, +{0xEBFE,0x85,0x01}, +{0xEBFF,0x7D,0x01}, +{0xEC00,0x61,0x01}, +{0xEC01,0x0F,0x01}, +{0xEC02,0xC0,0x01}, +{0xEC03,0xFF,0x01}, +{0xEC04,0xF7,0x01}, +{0xEC05,0x7F,0x01}, +{0xEC06,0x3D,0x01}, +{0xEC07,0x40,0x01}, +{0xEC08,0xFF,0x01}, +{0xEC09,0xDF,0x01}, +{0xEC0A,0x07,0x01}, +{0xEC0B,0xFA,0x01}, +{0xEC0C,0x81,0x01}, +{0xEC0D,0x3E,0x01}, +{0xEC0E,0x61,0x01}, +{0xEC0F,0x4F,0x01}, +{0xEC10,0xD8,0x01}, +{0xEC11,0x0B,0x01}, +{0xEC12,0xFC,0x01}, +{0xEC13,0xFE,0x01}, +{0xEC14,0x3D,0x01}, +{0xEC15,0xC0,0x01}, +{0xEC16,0xFF,0x01}, +{0xEC17,0xFF,0x01}, +{0xEC18,0x03,0x01}, +{0xEC19,0xFC,0x01}, +{0xEC1A,0x82,0x01}, +{0xEC1B,0xBE,0x01}, +{0xEC1C,0xA0,0x01}, +{0xEC1D,0x6F,0x01}, +{0xEC1E,0xF8,0x01}, +{0xEC1F,0x1B,0x01}, +{0xEC20,0xFE,0x01}, +{0xEC21,0x83,0x01}, +{0xEC22,0xBF,0x01}, +{0xEC23,0xE0,0x01}, +{0xEC24,0x0F,0x01}, +{0xEC25,0x10,0x01}, +{0xEC26,0x00,0x01}, +{0xEC27,0x00,0x01}, +{0xEC28,0x82,0x01}, +{0xEC29,0xC0,0x01}, +{0xEC2A,0x60,0x01}, +{0xEC2B,0x30,0x01}, +{0xEC2C,0x18,0x01}, +{0xEC2D,0x20,0x01}, +{0xEC2E,0x04,0x01}, +{0xEC2F,0x08,0x01}, +{0xEC30,0x81,0x01}, +{0xEC31,0x21,0x01}, +{0xEC32,0x30,0x01}, +{0xEC33,0x08,0x01}, +{0xEC34,0x08,0x01}, +{0xEC35,0x08,0x01}, +{0xEC36,0x82,0x01}, +{0xEC37,0x01,0x01}, +{0xEC38,0x81,0x01}, +{0xEC39,0x50,0x01}, +{0xEC3A,0x08,0x01}, +{0xEC3B,0x14,0x01}, +{0xEC3C,0x02,0x01}, +{0xEC3D,0x09,0x01}, +{0xEC3E,0x41,0x01}, +{0xEC3F,0x42,0x01}, +{0xEC40,0x70,0x01}, +{0xEC41,0x20,0x01}, +{0xEC42,0x0C,0x01}, +{0xEC43,0x06,0x01}, +{0xEC44,0x84,0x01}, +{0xEC45,0x42,0x01}, +{0xEC46,0xE1,0x01}, +{0xEC47,0x40,0x01}, +{0xEC48,0x38,0x01}, +{0xEC49,0x1C,0x01}, +{0xEC4A,0x0C,0x01}, +{0xEC4B,0x07,0x01}, +{0xEC4C,0x03,0x01}, +{0xEC4D,0xA2,0x01}, +{0xEC4E,0x80,0x01}, +{0xEC4F,0x28,0x01}, +{0xEC50,0x18,0x01}, +{0xEC51,0x10,0x01}, +{0xEC52,0x87,0x01}, +{0xEC53,0x43,0x01}, +{0xEC54,0x61,0x01}, +{0xEC55,0x41,0x01}, +{0xEC56,0x48,0x01}, +{0xEC57,0x14,0x01}, +{0xEC58,0x10,0x01}, +{0xEC59,0x07,0x01}, +{0xEC5A,0xC2,0x01}, +{0xEC5B,0x81,0x01}, +{0xEC5C,0x80,0x01}, +{0xEC5D,0x30,0x01}, +{0xEC5E,0x20,0x01}, +{0xEC5F,0x0C,0x01}, +{0xEC60,0x87,0x01}, +{0xEC61,0x83,0x01}, +{0xEC62,0xC1,0x01}, +{0xEC63,0x40,0x01}, +{0xEC64,0x38,0x01}, +{0xEC65,0x14,0x01}, +{0xEC66,0x0A,0x01}, +{0xEC67,0x07,0x01}, +{0xEC68,0xC3,0x01}, +{0xEC69,0xC1,0x01}, +{0xEC6A,0x70,0x01}, +{0xEC6B,0x30,0x01}, +{0xEC6C,0x20,0x01}, +{0xEC6D,0x0C,0x01}, +{0xEC6E,0x08,0x01}, +{0xEC6F,0xC3,0x01}, +{0xEC70,0xE1,0x01}, +{0xEC71,0x60,0x01}, +{0xEC72,0x30,0x01}, +{0xEC73,0x10,0x01}, +{0xEC74,0x0E,0x01}, +{0xEC75,0x85,0x01}, +{0xEC76,0xC2,0x01}, +{0xEC77,0xC1,0x01}, +{0xEC78,0x70,0x01}, +{0xEC79,0x30,0x01}, +{0xEC7A,0x1C,0x01}, +{0xEC7B,0x0C,0x01}, + +//SHD1(from CO1) +{0xED02,0xE6,0x01}, +{0xED03,0x61,0x01}, +{0xED04,0x92,0x01}, +{0xED05,0x7C,0x01}, +{0xED06,0xBE,0x01}, +{0xED07,0xB4,0x01}, +{0xED08,0x9E,0x01}, +{0xED09,0x2C,0x01}, +{0xED0A,0x75,0x01}, +{0xED0B,0x47,0x01}, +{0xED0C,0x49,0x01}, +{0xED0D,0xD7,0x01}, +{0xED0E,0x61,0x01}, +{0xED0F,0x12,0x01}, +{0xED10,0x76,0x01}, +{0xED11,0xA8,0x01}, +{0xED12,0x34,0x01}, +{0xED13,0x1E,0x01}, +{0xED14,0x31,0x01}, +{0xED15,0xA1,0x01}, +{0xED16,0xC7,0x01}, +{0xED17,0x4C,0x01}, +{0xED18,0xDE,0x01}, +{0xED19,0xC1,0x01}, +{0xED1A,0xD2,0x01}, +{0xED1B,0x77,0x01}, +{0xED1C,0x76,0x01}, +{0xED1D,0x94,0x01}, +{0xED1E,0x9C,0x01}, +{0xED1F,0x10,0x01}, +{0xED20,0xC9,0x01}, +{0xED21,0xC6,0x01}, +{0xED22,0x40,0x01}, +{0xED23,0xA2,0x01}, +{0xED24,0x99,0x01}, +{0xED25,0x8F,0x01}, +{0xED26,0x66,0x01}, +{0xED27,0xDC,0x01}, +{0xED28,0xF3,0x01}, +{0xED29,0x19,0x01}, +{0xED2A,0xFC,0x01}, +{0xED2B,0xB0,0x01}, +{0xED2C,0xA6,0x01}, +{0xED2D,0x41,0x01}, +{0xED2E,0xC1,0x01}, +{0xED2F,0x49,0x01}, +{0xED30,0x91,0x01}, +{0xED31,0x75,0x01}, +{0xED32,0x8C,0x01}, +{0xED33,0x74,0x01}, +{0xED34,0x1C,0x01}, +{0xED35,0x0B,0x01}, +{0xED36,0x91,0x01}, +{0xED37,0x86,0x01}, +{0xED38,0x3D,0x01}, +{0xED39,0x87,0x01}, +{0xED3A,0x39,0x01}, +{0xED3B,0x4E,0x01}, +{0xED3C,0x5C,0x01}, +{0xED3D,0x50,0x01}, +{0xED3E,0x83,0x01}, +{0xED3F,0x16,0x01}, +{0xED40,0xCF,0x01}, +{0xED41,0xBC,0x01}, +{0xED42,0x45,0x01}, +{0xED43,0x35,0x01}, +{0xED44,0x83,0x01}, +{0xED45,0x41,0x01}, +{0xED46,0xCE,0x01}, +{0xED47,0x67,0x01}, +{0xED48,0xE8,0x01}, +{0xED49,0x33,0x01}, +{0xED4A,0x1C,0x01}, +{0xED4B,0x16,0x01}, +{0xED4C,0xC1,0x01}, +{0xED4D,0x86,0x01}, +{0xED4E,0x3E,0x01}, +{0xED4F,0x83,0x01}, +{0xED50,0xC1,0x01}, +{0xED51,0x0D,0x01}, +{0xED52,0x57,0x01}, +{0xED53,0x02,0x01}, +{0xED54,0x23,0x01}, +{0xED55,0x14,0x01}, +{0xED56,0xAE,0x01}, +{0xED57,0xE4,0x01}, +{0xED58,0x44,0x01}, +{0xED59,0x2A,0x01}, +{0xED5A,0x43,0x01}, +{0xED5B,0xF9,0x01}, +{0xED5C,0xCA,0x01}, +{0xED5D,0x56,0x01}, +{0xED5E,0x0C,0x01}, +{0xED5F,0x03,0x01}, +{0xED60,0x98,0x01}, +{0xED61,0xE2,0x01}, +{0xED62,0xA8,0x01}, +{0xED63,0x26,0x01}, +{0xED64,0x41,0x01}, +{0xED65,0x9E,0x01}, +{0xED66,0xC1,0x01}, +{0xED67,0xCE,0x01}, +{0xED68,0x59,0x01}, +{0xED69,0x1C,0x01}, +{0xED6A,0xB3,0x01}, +{0xED6B,0x93,0x01}, +{0xED6C,0xA7,0x01}, +{0xED6D,0x74,0x01}, +{0xED6E,0x04,0x01}, +{0xED6F,0x25,0x01}, +{0xED70,0x13,0x01}, +{0xED71,0xD9,0x01}, +{0xED72,0xC8,0x01}, +{0xED73,0x47,0x01}, +{0xED74,0x54,0x01}, +{0xED75,0xD2,0x01}, +{0xED76,0x93,0x01}, +{0xED77,0xAA,0x01}, +{0xED78,0x98,0x01}, +{0xED79,0xE5,0x01}, +{0xED7A,0x32,0x01}, +{0xED7B,0x9A,0x01}, +{0xED7C,0x29,0x01}, +{0xED7D,0xCF,0x01}, +{0xED7E,0x64,0x01}, +{0xED7F,0x8E,0x01}, +{0xED80,0x73,0x01}, +{0xED81,0x95,0x01}, +{0xED82,0xBB,0x01}, +{0xED83,0xA4,0x01}, +{0xED84,0xA4,0x01}, +{0xED85,0x26,0x01}, +{0xED86,0x0A,0x01}, +{0xED87,0x59,0x01}, +{0xED88,0x08,0x01}, +{0xED89,0x40,0x01}, +{0xED8A,0x00,0x01}, +{0xED8B,0xC2,0x01}, +{0xED8C,0x10,0x01}, +{0xED8D,0x88,0x01}, +{0xED8E,0xB0,0x01}, +{0xED8F,0x84,0x01}, +{0xED90,0x27,0x01}, +{0xED91,0x59,0x01}, +{0xED92,0xF1,0x01}, +{0xED93,0x0B,0x01}, +{0xED94,0x64,0x01}, +{0xED95,0xA2,0x01}, +{0xED96,0x43,0x01}, +{0xED97,0x99,0x01}, +{0xED98,0xE4,0x01}, +{0xED99,0x68,0x01}, +{0xED9A,0x25,0x01}, +{0xED9B,0x2F,0x01}, +{0xED9C,0x2B,0x01}, +{0xED9D,0xB1,0x01}, +{0xED9E,0xC9,0x01}, +{0xED9F,0x42,0x01}, +{0xEDA0,0x18,0x01}, +{0xEDA1,0x32,0x01}, +{0xEDA2,0x90,0x01}, +{0xEDA3,0x80,0x01}, +{0xEDA4,0x3C,0x01}, +{0xEDA5,0x24,0x01}, +{0xEDA6,0x22,0x01}, +{0xEDA7,0x2F,0x01}, +{0xEDA8,0xF1,0x01}, +{0xEDA9,0x09,0x01}, +{0xEDAA,0x57,0x01}, +{0xEDAB,0x00,0x01}, +{0xEDAC,0x53,0x01}, +{0xEDAD,0x99,0x01}, +{0xEDAE,0xEA,0x01}, +{0xEDAF,0x90,0x01}, +{0xEDB0,0xC6,0x01}, +{0xEDB1,0x3B,0x01}, +{0xEDB2,0x6D,0x01}, +{0xEDB3,0x99,0x01}, +{0xEDB4,0x4C,0x01}, +{0xEDB5,0x50,0x01}, +{0xEDB6,0xA4,0x01}, +{0xEDB7,0x32,0x01}, +{0xEDB8,0x12,0x01}, +{0xEDB9,0x94,0x01}, +{0xEDBA,0x64,0x01}, +{0xEDBB,0xA4,0x01}, +{0xEDBC,0x23,0x01}, +{0xEDBD,0x25,0x01}, +{0xEDBE,0x71,0x01}, +{0xEDBF,0x49,0x01}, +{0xEDC0,0x51,0x01}, +{0xEDC1,0xB2,0x01}, +{0xEDC2,0x02,0x01}, +{0xEDC3,0x17,0x01}, +{0xEDC4,0xCD,0x01}, +{0xEDC5,0x98,0x01}, +{0xEDC6,0x86,0x01}, +{0xEDC7,0x3D,0x01}, +{0xEDC8,0xBC,0x01}, +{0xEDC9,0x01,0x01}, +{0xEDCA,0x50,0x01}, +{0xEDCB,0x63,0x01}, +{0xEDCC,0x80,0x01}, +{0xEDCD,0x63,0x01}, +{0xEDCE,0x16,0x01}, +{0xEDCF,0xC3,0x01}, +{0xEDD0,0x2C,0x01}, +{0xEDD1,0x25,0x01}, +{0xEDD2,0x2C,0x01}, +{0xEDD3,0x43,0x01}, +{0xEDD4,0xB1,0x01}, +{0xEDD5,0x4A,0x01}, +{0xEDD6,0x53,0x01}, +{0xEDD7,0xCC,0x01}, +{0xEDD8,0x82,0x01}, +{0xEDD9,0x96,0x01}, +{0xEDDA,0xC7,0x01}, +{0xEDDB,0x40,0x01}, +{0xEDDC,0xA6,0x01}, +{0xEDDD,0x39,0x01}, +{0xEDDE,0xBE,0x01}, +{0xEDDF,0x91,0x01}, +{0xEDE0,0xD0,0x01}, +{0xEDE1,0x75,0x01}, +{0xEDE2,0x54,0x01}, +{0xEDE3,0x34,0x01}, +{0xEDE4,0x1B,0x01}, +{0xEDE5,0xFC,0x01}, +{0xEDE6,0x4C,0x01}, +{0xEDE7,0x46,0x01}, +{0xEDE8,0x39,0x01}, +{0xEDE9,0x7D,0x01}, +{0xEDEA,0x71,0x01}, +{0xEDEB,0x8D,0x01}, +{0xEDEC,0x5D,0x01}, +{0xEDED,0x46,0x01}, +{0xEDEE,0xE3,0x01}, +{0xEDEF,0x17,0x01}, +{0xEDF0,0xD9,0x01}, +{0xEDF1,0x50,0x01}, +{0xEDF2,0x86,0x01}, +{0xEDF3,0x3A,0x01}, +{0xEDF4,0xB3,0x01}, +{0xEDF5,0x09,0x01}, +{0xEDF6,0x50,0x01}, +{0xEDF7,0x76,0x01}, +{0xEDF8,0x6A,0x01}, +{0xEDF9,0xF4,0x01}, +{0xEDFA,0x1E,0x01}, +{0xEDFB,0x25,0x01}, +{0xEDFC,0x61,0x01}, +{0xEDFD,0x67,0x01}, +{0xEDFE,0x45,0x01}, +{0xEDFF,0xC0,0x01}, +{0xEE00,0x69,0x01}, +{0xEE01,0xD0,0x01}, +{0xEE02,0x6B,0x01}, +{0xEE03,0xF6,0x01}, +{0xEE04,0x93,0x01}, +{0xEE05,0x9A,0x01}, +{0xEE06,0xFA,0x01}, +{0xEE07,0xB8,0x01}, +{0xEE08,0x26,0x01}, +{0xEE09,0x40,0x01}, +{0xEE0A,0xC0,0x01}, +{0xEE0B,0xB9,0x01}, +{0xEE0C,0xD0,0x01}, +{0xEE0D,0x75,0x01}, +{0xEE0E,0x6E,0x01}, +{0xEE0F,0xE4,0x01}, +{0xEE10,0x9E,0x01}, +{0xEE11,0x2D,0x01}, +{0xEE12,0xE1,0x01}, +{0xEE13,0xA7,0x01}, +{0xEE14,0x49,0x01}, +{0xEE15,0xFD,0x01}, +{0xEE16,0xB9,0x01}, +{0xEE17,0x52,0x01}, +{0xEE18,0x7C,0x01}, +{0xEE19,0x98,0x01}, +{0xEE1A,0x64,0x01}, +{0xEE1B,0x1E,0x01}, +{0xEE1C,0x22,0x01}, +{0xEE1D,0x89,0x01}, +{0xEE1E,0xA7,0x01}, +{0xEE1F,0x48,0x01}, +{0xEE20,0xE4,0x01}, +{0xEE21,0x49,0x01}, +{0xEE22,0x12,0x01}, +{0xEE23,0x7D,0x01}, +{0xEE24,0xB4,0x01}, +{0xEE25,0xB4,0x01}, +{0xEE26,0x1F,0x01}, +{0xEE27,0x31,0x01}, +{0xEE28,0xC5,0x01}, +{0xEE29,0x47,0x01}, +{0xEE2A,0x4B,0x01}, +{0xEE2B,0xC2,0x01}, +{0xEE2C,0x19,0x01}, +{0xEE2D,0x0F,0x01}, +{0xEE2E,0x73,0x01}, +{0xEE2F,0xE2,0x01}, +{0xEE30,0x13,0x01}, +{0xEE31,0x1C,0x01}, +{0xEE32,0xF5,0x01}, +{0xEE33,0xE0,0x01}, +{0xEE34,0xC6,0x01}, +{0xEE35,0x3B,0x01}, +{0xEE36,0xB6,0x01}, +{0xEE37,0xB1,0x01}, +{0xEE38,0xCE,0x01}, +{0xEE39,0x6D,0x01}, +{0xEE3A,0xB8,0x01}, +{0xEE3B,0xF3,0x01}, +{0xEE3C,0x9B,0x01}, +{0xEE3D,0xF2,0x01}, +{0xEE3E,0x18,0x01}, +{0xEE3F,0x27,0x01}, +{0xEE40,0x3D,0x01}, +{0xEE41,0xBF,0x01}, +{0xEE42,0xE9,0x01}, +{0xEE43,0xCE,0x01}, +{0xEE44,0x6E,0x01}, +{0xEE45,0xBA,0x01}, +{0xEE46,0x83,0x01}, +{0xEE47,0x9A,0x01}, +{0xEE48,0xE4,0x01}, +{0xEE49,0x50,0x01}, +{0xEE4A,0x66,0x01}, +{0xEE4B,0x36,0x01}, +{0xEE4C,0x8A,0x01}, +{0xEE4D,0x29,0x01}, +{0xEE4E,0x4D,0x01}, +{0xEE4F,0x61,0x01}, +{0xEE50,0x3A,0x01}, +{0xEE51,0xA3,0x01}, +{0xEE52,0x18,0x01}, +{0xEE53,0xD2,0x01}, +{0xEE54,0x50,0x01}, +{0xEE55,0x26,0x01}, +{0xEE56,0x36,0x01}, +{0xEE57,0xA8,0x01}, +{0xEE58,0x21,0x01}, +{0xEE59,0xCE,0x01}, +{0xEE5A,0x6E,0x01}, +{0xEE5B,0xB2,0x01}, +{0xEE5C,0x03,0x01}, +{0xEE5D,0x9A,0x01}, +{0xEE5E,0xE0,0x01}, +{0xEE5F,0x1C,0x01}, +{0xEE60,0x46,0x01}, +{0xEE61,0x34,0x01}, +{0xEE62,0x72,0x01}, +{0xEE63,0x41,0x01}, +{0xEE64,0x8C,0x01}, +{0xEE65,0x58,0x01}, +{0xEE66,0xE8,0x01}, +{0xEE67,0xC2,0x01}, +{0xEE68,0x95,0x01}, +{0xEE69,0xB5,0x01}, +{0xEE6A,0x88,0x01}, +{0xEE6B,0x65,0x01}, +{0xEE6C,0x2E,0x01}, +{0xEE6D,0x72,0x01}, +{0xEE6E,0x39,0x01}, +{0xEE6F,0x8C,0x01}, +{0xEE70,0x62,0x01}, +{0xEE71,0x48,0x01}, +{0xEE72,0x83,0x01}, +{0xEE73,0x1A,0x01}, +{0xEE74,0xE4,0x01}, +{0xEE75,0x28,0x01}, +{0xEE76,0x06,0x01}, +{0xEE77,0x35,0x01}, +{0xEE78,0x6A,0x01}, +{0xEE79,0xF9,0x01}, +{0xEE7A,0x4B,0x01}, +{0xEE7B,0x53,0x01}, +{0xEE7C,0xB8,0x01}, +{0xEE7D,0x92,0x01}, +{0xEE7E,0x13,0x01}, +{0xEE7F,0xA2,0x01}, +{0xEE80,0xCC,0x01}, +{0xEE81,0x64,0x01}, +{0xEE82,0x27,0x01}, +{0xEE83,0x3B,0x01}, +{0xEE84,0x29,0x01}, +{0xEE85,0x0A,0x01}, +{0xEE86,0x54,0x01}, +{0xEE87,0xBC,0x01}, +{0xEE88,0xF2,0x01}, +{0xEE89,0x96,0x01}, +{0xEE8A,0xC1,0x01}, +{0xEE8B,0x40,0x01}, +{0xEE8C,0xA6,0x01}, +{0xEE8D,0x35,0x01}, +{0xEE8E,0x7A,0x01}, +{0xEE8F,0xB1,0x01}, +{0xEE90,0x8C,0x01}, +{0xEE91,0x54,0x01}, +{0xEE92,0xC8,0x01}, +{0xEE93,0xF2,0x01}, +{0xEE94,0x92,0x01}, +{0xEE95,0x9D,0x01}, +{0xEE96,0x64,0x01}, +{0xEE97,0xE4,0x01}, +{0xEE98,0x23,0x01}, +{0xEE99,0x13,0x01}, +{0xEE9A,0xA9,0x01}, +{0xEE9B,0x48,0x01}, +{0xEE9C,0x47,0x01}, +{0xEE9D,0x40,0x01}, +{0xEE9E,0x42,0x01}, +{0xEE9F,0x13,0x01}, +{0xEEA0,0x9F,0x01}, +{0xEEA1,0x58,0x01}, +{0xEEA2,0xE5,0x01}, +{0xEEA3,0x2C,0x01}, +{0xEEA4,0x7F,0x01}, +{0xEEA5,0xD9,0x01}, +{0xEEA6,0x8C,0x01}, +{0xEEA7,0x5B,0x01}, +{0xEEA8,0x12,0x01}, +{0xEEA9,0x43,0x01}, +{0xEEAA,0x14,0x01}, +{0xEEAB,0xAA,0x01}, +{0xEEAC,0x80,0x01}, +{0xEEAD,0x04,0x01}, +{0xEEAE,0x25,0x01}, +{0xEEAF,0x06,0x01}, +{0xEEB0,0x51,0x01}, +{0xEEB1,0x08,0x01}, +{0xEEB2,0x40,0x01}, +{0xEEB3,0x00,0x01}, +{0xEEB4,0xB2,0x01}, +{0xEEB5,0x10,0x01}, +{0xEEB6,0x86,0x01}, +{0xEEB7,0x98,0x01}, +{0xEEB8,0x64,0x01}, +{0xEEB9,0x25,0x01}, +{0xEEBA,0x4A,0x01}, +{0xEEBB,0xB9,0x01}, +{0xEEBC,0x0A,0x01}, +{0xEEBD,0x5D,0x01}, +{0xEEBE,0x1C,0x01}, +{0xEEBF,0x13,0x01}, +{0xEEC0,0x97,0x01}, +{0xEEC1,0xC4,0x01}, +{0xEEC2,0x18,0x01}, +{0xEEC3,0x85,0x01}, +{0xEEC4,0x2A,0x01}, +{0xEEC5,0x21,0x01}, +{0xEEC6,0x41,0x01}, +{0xEEC7,0xC9,0x01}, +{0xEEC8,0x41,0x01}, +{0xEEC9,0x12,0x01}, +{0xEECA,0x02,0x01}, +{0xEECB,0x10,0x01}, +{0xEECC,0x80,0x01}, +{0xEECD,0x2C,0x01}, +{0xEECE,0x64,0x01}, +{0xEECF,0x21,0x01}, +{0xEED0,0x27,0x01}, +{0xEED1,0x61,0x01}, +{0xEED2,0xC9,0x01}, +{0xEED3,0x52,0x01}, +{0xEED4,0xB0,0x01}, +{0xEED5,0x42,0x01}, +{0xEED6,0x17,0x01}, +{0xEED7,0xC8,0x01}, +{0xEED8,0x04,0x01}, +{0xEED9,0xE6,0x01}, +{0xEEDA,0x32,0x01}, +{0xEEDB,0x58,0x01}, +{0xEEDC,0x29,0x01}, +{0xEEDD,0xCB,0x01}, +{0xEEDE,0x4C,0x01}, +{0xEEDF,0x74,0x01}, +{0xEEE0,0x92,0x01}, +{0xEEE1,0x91,0x01}, +{0xEEE2,0x8E,0x01}, +{0xEEE3,0x48,0x01}, +{0xEEE4,0x84,0x01}, +{0xEEE5,0x22,0x01}, +{0xEEE6,0x1D,0x01}, +{0xEEE7,0x01,0x01}, +{0xEEE8,0xC9,0x01}, +{0xEEE9,0x4D,0x01}, +{0xEEEA,0x7E,0x01}, +{0xEEEB,0x82,0x01}, +{0xEEEC,0x15,0x01}, +{0xEEED,0xB5,0x01}, +{0xEEEE,0x04,0x01}, +{0xEEEF,0xE6,0x01}, +{0xEEF0,0x33,0x01}, +{0xEEF1,0x99,0x01}, +{0xEEF2,0x69,0x01}, +{0xEEF3,0x0D,0x01}, +{0xEEF4,0x5D,0x01}, +{0xEEF5,0x06,0x01}, +{0xEEF6,0x33,0x01}, +{0xEEF7,0x15,0x01}, +{0xEEF8,0xAF,0x01}, +{0xEEF9,0xEC,0x01}, +{0xEEFA,0xA4,0x01}, +{0xEEFB,0x28,0x01}, +{0xEEFC,0x35,0x01}, +{0xEEFD,0xE9,0x01}, +{0xEEFE,0x09,0x01}, +{0xEEFF,0x4F,0x01}, +{0xEF00,0x8E,0x01}, +{0xEF01,0x02,0x01}, +{0xEF02,0x95,0x01}, +{0xEF03,0xB1,0x01}, +{0xEF04,0xC4,0x01}, +{0xEF05,0x25,0x01}, +{0xEF06,0x31,0x01}, +{0xEF07,0x94,0x01}, +{0xEF08,0xB1,0x01}, +{0xEF09,0x4D,0x01}, +{0xEF0A,0x6C,0x01}, +{0xEF0B,0x94,0x01}, +{0xEF0C,0x43,0x01}, +{0xEF0D,0x99,0x01}, +{0xEF0E,0xD4,0x01}, +{0xEF0F,0xEC,0x01}, +{0xEF10,0xC5,0x01}, +{0xEF11,0x31,0x01}, +{0xEF12,0x69,0x01}, +{0xEF13,0xC9,0x01}, +{0xEF14,0x0B,0x01}, +{0xEF15,0x58,0x01}, +{0xEF16,0xE6,0x01}, +{0xEF17,0x52,0x01}, +{0xEF18,0x16,0x01}, +{0xEF19,0xBE,0x01}, +{0xEF1A,0xD4,0x01}, +{0xEF1B,0x45,0x01}, +{0xEF1C,0x32,0x01}, +{0xEF1D,0x8E,0x01}, +{0xEF1E,0x79,0x01}, +{0xEF1F,0x4D,0x01}, +{0xEF20,0x6A,0x01}, +{0xEF21,0xA4,0x01}, +{0xEF22,0x83,0x01}, +{0xEF23,0x1C,0x01}, +{0xEF24,0xF2,0x01}, +{0xEF25,0xDC,0x01}, +{0xEF26,0x26,0x01}, +{0xEF27,0x3A,0x01}, +{0xEF28,0xA3,0x01}, +{0xEF29,0xE1,0x01}, +{0xEF2A,0x4D,0x01}, +{0xEF2B,0x65,0x01}, +{0xEF2C,0x5C,0x01}, +{0xEF2D,0xC3,0x01}, +{0xEF2E,0x98,0x01}, +{0xEF2F,0xD4,0x01}, +{0xEF30,0x3C,0x01}, +{0xEF31,0xE6,0x01}, +{0xEF32,0x35,0x01}, +{0xEF33,0x9D,0x01}, +{0xEF34,0x09,0x01}, +{0xEF35,0x8E,0x01}, +{0xEF36,0x6B,0x01}, +{0xEF37,0xAC,0x01}, +{0xEF38,0xE3,0x01}, +{0xEF39,0x9B,0x01}, +{0xEF3A,0xF4,0x01}, +{0xEF3B,0x34,0x01}, +{0xEF3C,0x07,0x01}, +{0xEF3D,0x3E,0x01}, +{0xEF3E,0xDA,0x01}, +{0xEF3F,0xC1,0x01}, +{0xEF40,0x8F,0x01}, +{0xEF41,0x74,0x01}, +{0xEF42,0xEA,0x01}, +{0xEF43,0x13,0x01}, +{0xEF44,0x9C,0x01}, +{0xEF45,0xF4,0x01}, +{0xEF46,0xF0,0x01}, +{0xEF47,0xA6,0x01}, +{0xEF48,0x3C,0x01}, +{0xEF49,0xC0,0x01}, +{0xEF4A,0x49,0x01}, +{0xEF4B,0x0F,0x01}, +{0xEF4C,0x72,0x01}, +{0xEF4D,0xEA,0x01}, +{0xEF4E,0xD3,0x01}, +{0xEF4F,0x9C,0x01}, +{0xEF50,0xFE,0x01}, +{0xEF51,0x04,0x01}, +{0xEF52,0xA7,0x01}, +{0xEF53,0x3D,0x01}, + +//SHD2 CW+TL84 33:66 + +{0xED00,0x9191,0x02},// +{0xEF54,0x28,0x01}, +{0xEF55,0xC2,0x01}, +{0xEF56,0x11,0x01}, +{0xEF57,0x8C,0x01}, +{0xEF58,0x46,0x01}, +{0xEF59,0x34,0x01}, +{0xEF5A,0xA2,0x01}, +{0xEF5B,0x12,0x01}, +{0xEF5C,0xCD,0x01}, +{0xEF5D,0x08,0x01}, +{0xEF5E,0x47,0x01}, +{0xEF5F,0x27,0x01}, +{0xEF60,0xAA,0x01}, +{0xEF61,0x10,0x01}, +{0xEF62,0x7F,0x01}, +{0xEF63,0xC2,0x01}, +{0xEF64,0xF3,0x01}, +{0xEF65,0x1C,0x01}, +{0xEF66,0xE4,0x01}, +{0xEF67,0x40,0x01}, +{0xEF68,0x27,0x01}, +{0xEF69,0x3C,0x01}, +{0xEF6A,0xFB,0x01}, +{0xEF6B,0xA1,0x01}, +{0xEF6C,0x90,0x01}, +{0xEF6D,0x7C,0x01}, +{0xEF6E,0x92,0x01}, +{0xEF6F,0x63,0x01}, +{0xEF70,0x9A,0x01}, +{0xEF71,0xC5,0x01}, +{0xEF72,0x0C,0x01}, +{0xEF73,0x66,0x01}, +{0xEF74,0x31,0x01}, +{0xEF75,0xA4,0x01}, +{0xEF76,0x49,0x01}, +{0xEF77,0x0E,0x01}, +{0xEF78,0x7F,0x01}, +{0xEF79,0xA0,0x01}, +{0xEF7A,0xB3,0x01}, +{0xEF7B,0x19,0x01}, +{0xEF7C,0xB6,0x01}, +{0xEF7D,0x34,0x01}, +{0xEF7E,0x85,0x01}, +{0xEF7F,0x28,0x01}, +{0xEF80,0x4D,0x01}, +{0xEF81,0x61,0x01}, +{0xEF82,0x0B,0x01}, +{0xEF83,0x68,0x01}, +{0xEF84,0xB6,0x01}, +{0xEF85,0x73,0x01}, +{0xEF86,0x9B,0x01}, +{0xEF87,0xBB,0x01}, +{0xEF88,0x0C,0x01}, +{0xEF89,0x45,0x01}, +{0xEF8A,0x24,0x01}, +{0xEF8B,0x17,0x01}, +{0xEF8C,0x11,0x01}, +{0xEF8D,0x49,0x01}, +{0xEF8E,0x51,0x01}, +{0xEF8F,0xF4,0x01}, +{0xEF90,0xC2,0x01}, +{0xEF91,0x1B,0x01}, +{0xEF92,0xD4,0x01}, +{0xEF93,0x94,0x01}, +{0xEF94,0xC5,0x01}, +{0xEF95,0x25,0x01}, +{0xEF96,0x0B,0x01}, +{0xEF97,0x01,0x01}, +{0xEF98,0x48,0x01}, +{0xEF99,0x43,0x01}, +{0xEF9A,0x62,0x01}, +{0xEF9B,0x62,0x01}, +{0xEF9C,0x96,0x01}, +{0xEF9D,0xD5,0x01}, +{0xEF9E,0xA4,0x01}, +{0xEF9F,0xC6,0x01}, +{0xEFA0,0x2C,0x01}, +{0xEFA1,0x2F,0x01}, +{0xEFA2,0x51,0x01}, +{0xEFA3,0x48,0x01}, +{0xEFA4,0x40,0x01}, +{0xEFA5,0x1C,0x01}, +{0xEFA6,0x22,0x01}, +{0xEFA7,0x13,0x01}, +{0xEFA8,0xB4,0x01}, +{0xEFA9,0xC0,0x01}, +{0xEFAA,0x86,0x01}, +{0xEFAB,0x37,0x01}, +{0xEFAC,0x7B,0x01}, +{0xEFAD,0x29,0x01}, +{0xEFAE,0x8A,0x01}, +{0xEFAF,0x48,0x01}, +{0xEFB0,0x30,0x01}, +{0xEFB1,0x52,0x01}, +{0xEFB2,0x12,0x01}, +{0xEFB3,0xA4,0x01}, +{0xEFB4,0xF4,0x01}, +{0xEFB5,0x25,0x01}, +{0xEFB6,0x38,0x01}, +{0xEFB7,0xD9,0x01}, +{0xEFB8,0x01,0x01}, +{0xEFB9,0xCD,0x01}, +{0xEFBA,0x5B,0x01}, +{0xEFBB,0xA0,0x01}, +{0xEFBC,0x72,0x01}, +{0xEFBD,0x14,0x01}, +{0xEFBE,0xA9,0x01}, +{0xEFBF,0xCC,0x01}, +{0xEFC0,0xC5,0x01}, +{0xEFC1,0x34,0x01}, +{0xEFC2,0xE3,0x01}, +{0xEFC3,0xF1,0x01}, +{0xEFC4,0x0F,0x01}, +{0xEFC5,0x74,0x01}, +{0xEFC6,0x50,0x01}, +{0xEFC7,0xF3,0x01}, +{0xEFC8,0x98,0x01}, +{0xEFC9,0xC2,0x01}, +{0xEFCA,0x40,0x01}, +{0xEFCB,0x86,0x01}, +{0xEFCC,0x35,0x01}, +{0xEFCD,0xD4,0x01}, +{0xEFCE,0x29,0x01}, +{0xEFCF,0xD0,0x01}, +{0xEFD0,0x86,0x01}, +{0xEFD1,0xFE,0x01}, +{0xEFD2,0x23,0x01}, +{0xEFD3,0x9E,0x01}, +{0xEFD4,0xE8,0x01}, +{0xEFD5,0x28,0x01}, +{0xEFD6,0x87,0x01}, +{0xEFD7,0x3A,0x01}, +{0xEFD8,0xE7,0x01}, +{0xEFD9,0x21,0x01}, +{0xEFDA,0x10,0x01}, +{0xEFDB,0x89,0x01}, +{0xEFDC,0x3E,0x01}, +{0xEFDD,0x64,0x01}, +{0xEFDE,0xA2,0x01}, +{0xEFDF,0x0D,0x01}, +{0xEFE0,0x41,0x01}, +{0xEFE1,0xC8,0x01}, +{0xEFE2,0x41,0x01}, +{0xEFE3,0x14,0x01}, +{0xEFE4,0x02,0x01}, +{0xEFE5,0x11,0x01}, +{0xEFE6,0x8A,0x01}, +{0xEFE7,0x4C,0x01}, +{0xEFE8,0x04,0x01}, +{0xEFE9,0x00,0x01}, +{0xEFEA,0x00,0x01}, +{0xEFEB,0x00,0x01}, +{0xEFEC,0x00,0x01}, +{0xEFED,0x00,0x01}, + + +//SHD3 D65+TL84 C01// +{0xED00,0x9191,0x02},// +{0xEFEE,0x12,0x01}, +{0xEFEF,0x42,0x01}, +{0xEFF0,0x51,0x01}, +{0xEFF1,0x89,0x01}, +{0xEFF2,0x38,0x01}, +{0xEFF3,0xD4,0x01}, +{0xEFF4,0x21,0x01}, +{0xEFF5,0x10,0x01}, +{0xEFF6,0xAD,0x01}, +{0xEFF7,0xA8,0x01}, +{0xEFF8,0x45,0x01}, +{0xEFF9,0x18,0x01}, +{0xEFFA,0x4A,0x01}, +{0xEFFB,0x50,0x01}, +{0xEFFC,0x7D,0x01}, +{0xEFFD,0xBA,0x01}, +{0xEFFE,0xD3,0x01}, +{0xEFFF,0x1C,0x01}, +{0xF000,0xE4,0x01}, +{0xF001,0x40,0x01}, +{0xF002,0x27,0x01}, +{0xF003,0x3C,0x01}, +{0xF004,0xF8,0x01}, +{0xF005,0x69,0x01}, +{0xF006,0x10,0x01}, +{0xF007,0x7B,0x01}, +{0xF008,0x8E,0x01}, +{0xF009,0x63,0x01}, +{0xF00A,0x1A,0x01}, +{0xF00B,0xC6,0x01}, +{0xF00C,0x10,0x01}, +{0xF00D,0xA6,0x01}, +{0xF00E,0x31,0x01}, +{0xF00F,0xA6,0x01}, +{0xF010,0x59,0x01}, +{0xF011,0x8E,0x01}, +{0xF012,0x7E,0x01}, +{0xF013,0x9A,0x01}, +{0xF014,0xB3,0x01}, +{0xF015,0x19,0x01}, +{0xF016,0xB6,0x01}, +{0xF017,0x38,0x01}, +{0xF018,0xA5,0x01}, +{0xF019,0x28,0x01}, +{0xF01A,0x4F,0x01}, +{0xF01B,0x79,0x01}, +{0xF01C,0xCB,0x01}, +{0xF01D,0x68,0x01}, +{0xF01E,0xBA,0x01}, +{0xF01F,0x53,0x01}, +{0xF020,0x9B,0x01}, +{0xF021,0xBB,0x01}, +{0xF022,0x0C,0x01}, +{0xF023,0x65,0x01}, +{0xF024,0x24,0x01}, +{0xF025,0x17,0x01}, +{0xF026,0x21,0x01}, +{0xF027,0xC9,0x01}, +{0xF028,0x51,0x01}, +{0xF029,0xFC,0x01}, +{0xF02A,0xF2,0x01}, +{0xF02B,0x9B,0x01}, +{0xF02C,0xD3,0x01}, +{0xF02D,0x94,0x01}, +{0xF02E,0xC5,0x01}, +{0xF02F,0x25,0x01}, +{0xF030,0x0A,0x01}, +{0xF031,0x01,0x01}, +{0xF032,0x48,0x01}, +{0xF033,0x43,0x01}, +{0xF034,0x66,0x01}, +{0xF035,0x92,0x01}, +{0xF036,0x96,0x01}, +{0xF037,0xD7,0x01}, +{0xF038,0xA0,0x01}, +{0xF039,0xE6,0x01}, +{0xF03A,0x2C,0x01}, +{0xF03B,0x2F,0x01}, +{0xF03C,0x51,0x01}, +{0xF03D,0x48,0x01}, +{0xF03E,0x40,0x01}, +{0xF03F,0x1E,0x01}, +{0xF040,0x42,0x01}, +{0xF041,0x93,0x01}, +{0xF042,0xB5,0x01}, +{0xF043,0xCC,0x01}, +{0xF044,0x46,0x01}, +{0xF045,0x37,0x01}, +{0xF046,0x7C,0x01}, +{0xF047,0x29,0x01}, +{0xF048,0x8A,0x01}, +{0xF049,0x48,0x01}, +{0xF04A,0x32,0x01}, +{0xF04B,0x72,0x01}, +{0xF04C,0x12,0x01}, +{0xF04D,0xA5,0x01}, +{0xF04E,0x00,0x01}, +{0xF04F,0xA6,0x01}, +{0xF050,0x38,0x01}, +{0xF051,0xD7,0x01}, +{0xF052,0x01,0x01}, +{0xF053,0x0D,0x01}, +{0xF054,0x5C,0x01}, +{0xF055,0xA2,0x01}, +{0xF056,0x82,0x01}, +{0xF057,0x94,0x01}, +{0xF058,0xAA,0x01}, +{0xF059,0xD8,0x01}, +{0xF05A,0x45,0x01}, +{0xF05B,0x35,0x01}, +{0xF05C,0xE5,0x01}, +{0xF05D,0xC9,0x01}, +{0xF05E,0xCF,0x01}, +{0xF05F,0x73,0x01}, +{0xF060,0x50,0x01}, +{0xF061,0x03,0x01}, +{0xF062,0x99,0x01}, +{0xF063,0xC3,0x01}, +{0xF064,0x4C,0x01}, +{0xF065,0xE6,0x01}, +{0xF066,0x35,0x01}, +{0xF067,0xD7,0x01}, +{0xF068,0x21,0x01}, +{0xF069,0x10,0x01}, +{0xF06A,0x84,0x01}, +{0xF06B,0xF2,0x01}, +{0xF06C,0x03,0x01}, +{0xF06D,0x9E,0x01}, +{0xF06E,0xE8,0x01}, +{0xF06F,0x2C,0x01}, +{0xF070,0xA7,0x01}, +{0xF071,0x3A,0x01}, +{0xF072,0xE8,0x01}, +{0xF073,0x11,0x01}, +{0xF074,0x90,0x01}, +{0xF075,0x87,0x01}, +{0xF076,0x18,0x01}, +{0xF077,0x94,0x01}, +{0xF078,0x21,0x01}, +{0xF079,0x09,0x01}, +{0xF07A,0x2D,0x01}, +{0xF07B,0x68,0x01}, +{0xF07C,0x41,0x01}, +{0xF07D,0x11,0x01}, +{0xF07E,0xDA,0x01}, +{0xF07F,0x10,0x01}, +{0xF080,0x88,0x01}, +{0xF081,0x2A,0x01}, +{0xF082,0x04,0x01}, +{0xF083,0x00,0x01}, +{0xF084,0x00,0x01}, +{0xF085,0x00,0x01}, +{0xF086,0x00,0x01}, +{0xF087,0x00,0x01}, +{0xF088,0xBE,0x01}, +{0xF089,0x51,0x01}, +{0xF08A,0x4E,0x01}, +{0xF08B,0x6F,0x01}, +{0xF08C,0x6C,0x01}, +{0xF08D,0x43,0x01}, +{0xF08E,0x1B,0x01}, +{0xF08F,0xDA,0x01}, +{0xF090,0xEC,0x01}, +{0xF091,0x46,0x01}, +{0xF092,0x38,0x01}, +{0xF093,0xBB,0x01}, +{0xF094,0xC1,0x01}, +{0xF095,0xCD,0x01}, +{0xF096,0x69,0x01}, +{0xF097,0x26,0x01}, +{0xF098,0x93,0x01}, +{0xF099,0x98,0x01}, +{0xF09A,0xC1,0x01}, +{0xF09B,0x20,0x01}, +{0xF09C,0x26,0x01}, +{0xF09D,0x32,0x01}, +{0xF09E,0xA5,0x01}, +{0xF09F,0xB1,0x01}, +{0xF0A0,0x8D,0x01}, +{0xF0A1,0x67,0x01}, +{0xF0A2,0x0E,0x01}, +{0xF0A3,0x23,0x01}, +{0xF0A4,0x97,0x01}, +{0xF0A5,0xB0,0x01}, +{0xF0A6,0x6C,0x01}, +{0xF0A7,0x25,0x01}, +{0xF0A8,0x2C,0x01}, +{0xF0A9,0x71,0x01}, +{0xF0AA,0x41,0x01}, +{0xF0AB,0x0C,0x01}, +{0xF0AC,0x69,0x01}, +{0xF0AD,0x14,0x01}, +{0xF0AE,0xB3,0x01}, +{0xF0AF,0x96,0x01}, +{0xF0B0,0xA6,0x01}, +{0xF0B1,0xE8,0x01}, +{0xF0B2,0x64,0x01}, +{0xF0B3,0x26,0x01}, +{0xF0B4,0x3A,0x01}, +{0xF0B5,0x79,0x01}, +{0xF0B6,0x4A,0x01}, +{0xF0B7,0x5B,0x01}, +{0xF0B8,0x18,0x01}, +{0xF0B9,0xA3,0x01}, +{0xF0BA,0x97,0x01}, +{0xF0BB,0xA9,0x01}, +{0xF0BC,0xBC,0x01}, +{0xF0BD,0x24,0x01}, +{0xF0BE,0x23,0x01}, +{0xF0BF,0x13,0x01}, +{0xF0C0,0xE1,0x01}, +{0xF0C1,0xC8,0x01}, +{0xF0C2,0x4C,0x01}, +{0xF0C3,0xAA,0x01}, +{0xF0C4,0xA2,0x01}, +{0xF0C5,0x97,0x01}, +{0xF0C6,0xB6,0x01}, +{0xF0C7,0x14,0x01}, +{0xF0C8,0x05,0x01}, +{0xF0C9,0x24,0x01}, +{0xF0CA,0x06,0x01}, +{0xF0CB,0x09,0x01}, +{0xF0CC,0xC8,0x01}, +{0xF0CD,0x42,0x01}, +{0xF0CE,0x48,0x01}, +{0xF0CF,0x82,0x01}, +{0xF0D0,0x14,0x01}, +{0xF0D1,0xB8,0x01}, +{0xF0D2,0xC0,0x01}, +{0xF0D3,0xE5,0x01}, +{0xF0D4,0x28,0x01}, +{0xF0D5,0x21,0x01}, +{0xF0D6,0x39,0x01}, +{0xF0D7,0x08,0x01}, +{0xF0D8,0x40,0x01}, +{0xF0D9,0x14,0x01}, +{0xF0DA,0x62,0x01}, +{0xF0DB,0x92,0x01}, +{0xF0DC,0xA4,0x01}, +{0xF0DD,0xC4,0x01}, +{0xF0DE,0x05,0x01}, +{0xF0DF,0x30,0x01}, +{0xF0E0,0x58,0x01}, +{0xF0E1,0xA1,0x01}, +{0xF0E2,0x49,0x01}, +{0xF0E3,0x46,0x01}, +{0xF0E4,0x22,0x01}, +{0xF0E5,0xB2,0x01}, +{0xF0E6,0x91,0x01}, +{0xF0E7,0x9A,0x01}, +{0xF0E8,0x58,0x01}, +{0xF0E9,0xA5,0x01}, +{0xF0EA,0x2F,0x01}, +{0xF0EB,0x96,0x01}, +{0xF0EC,0x99,0x01}, +{0xF0ED,0x8B,0x01}, +{0xF0EE,0x54,0x01}, +{0xF0EF,0x74,0x01}, +{0xF0F0,0x32,0x01}, +{0xF0F1,0x13,0x01}, +{0xF0F2,0x9D,0x01}, +{0xF0F3,0x38,0x01}, +{0xF0F4,0xC5,0x01}, +{0xF0F5,0x2D,0x01}, +{0xF0F6,0x90,0x01}, +{0xF0F7,0x59,0x01}, +{0xF0F8,0x4D,0x01}, +{0xF0F9,0x64,0x01}, +{0xF0FA,0xEE,0x01}, +{0xF0FB,0x62,0x01}, +{0xF0FC,0x16,0x01}, +{0xF0FD,0xAE,0x01}, +{0xF0FE,0x84,0x01}, +{0xF0FF,0x25,0x01}, +{0xF100,0x2E,0x01}, +{0xF101,0x8B,0x01}, +{0xF102,0x31,0x01}, +{0xF103,0xCD,0x01}, +{0xF104,0x6F,0x01}, +{0xF105,0x60,0x01}, +{0xF106,0xC3,0x01}, +{0xF107,0x19,0x01}, +{0xF108,0xC7,0x01}, +{0xF109,0x14,0x01}, +{0xF10A,0x26,0x01}, +{0xF10B,0x31,0x01}, +{0xF10C,0x97,0x01}, +{0xF10D,0x41,0x01}, +{0xF10E,0x8D,0x01}, +{0xF10F,0x6D,0x01}, +{0xF110,0x86,0x01}, +{0xF111,0xE3,0x01}, +{0xF112,0x9C,0x01}, +{0xF113,0xE2,0x01}, +{0xF114,0xD8,0x01}, +{0xF115,0x06,0x01}, +{0xF116,0x36,0x01}, +{0xF117,0xB5,0x01}, +{0xF118,0xE9,0x01}, +{0xF119,0x4D,0x01}, +{0xF11A,0x70,0x01}, +{0xF11B,0x68,0x01}, +{0xF11C,0x03,0x01}, +{0xF11D,0x00,0x01}, +{0xF11E,0x00,0x01}, +{0xF11F,0x00,0x01}, +{0xF120,0x00,0x01}, +{0xF121,0x00,0x01}, + + +//SHD TH +{0x6C32,0x1964,0x02}, // SHD_INP_TH_HB_H_R2 +{0x6C34,0x18CE,0x02}, // SHD_INP_TH_HB_L_R2 +{0x6C36,0x10CC,0x02}, // SHD_INP_TH_LB_H_R2 +{0x6C38,0x1004,0x02}, // SHD_INP_TH_LB_L_R2 +{0x6C3C,0x10CC,0x02}, // SHD_INP_TH_HB_H_RB +{0x6C3E,0x1004,0x02}, // SHD_INP_TH_HB_L_RB +{0x6C40,0x0000,0x02}, // SHD_INP_TH_LB_H_RB +{0x6C42,0x0000,0x02}, // SHD_INP_TH_LB_L_RB + +//PreWB_offset (for SHD2) +{0x6828,0x0013,0x02}, // SHD_PRER_OFFSET_R2 : +//PreWB_offset (for SHD3) +{0x682C,0x000C,0x02}, // SHD_PRER_OFFSET_RB : +{0x6830,0xFFFF,0x02}, // SHD_PREB_OFFSET_RB : + +// CXC/SHD EN +{0x01BC,0x57,0x01}, // CXC ON SHD ON INP ON GAIN OFF +}; + +static const isx012_regset_t ISX012_Shading_0[] = +{ +{0x01BC,0x50,0x01}, // CXC OFF SHD OFF +{0xEB00,0x8282,0x02}, //valid_code +{0xEB02,0xFE,0x01}, +{0xEB03,0x84,0x01}, +{0xEB04,0x3F,0x01}, +{0xEB05,0x01,0x01}, +{0xEB06,0x50,0x01}, +{0xEB07,0x08,0x01}, +{0xEB08,0x14,0x01}, +{0xEB09,0xFF,0x01}, +{0xEB0A,0x45,0x01}, +{0xEB0B,0x80,0x01}, +{0xEB0C,0x01,0x01}, +{0xEB0D,0x68,0x01}, +{0xEB0E,0x04,0x01}, +{0xEB0F,0x1A,0x01}, +{0xEB10,0x81,0x01}, +{0xEB11,0x86,0x01}, +{0xEB12,0x3F,0x01}, +{0xEB13,0xE1,0x01}, +{0xEB14,0x4F,0x01}, +{0xEB15,0x00,0x01}, +{0xEB16,0x14,0x01}, +{0xEB17,0x02,0x01}, +{0xEB18,0xC5,0x01}, +{0xEB19,0x7F,0x01}, +{0xEB1A,0x11,0x01}, +{0xEB1B,0x60,0x01}, +{0xEB1C,0x00,0x01}, +{0xEB1D,0x1A,0x01}, +{0xEB1E,0x81,0x01}, +{0xEB1F,0x46,0x01}, +{0xEB20,0xA0,0x01}, +{0xEB21,0x01,0x01}, +{0xEB22,0x48,0x01}, +{0xEB23,0x00,0x01}, +{0xEB24,0x12,0x01}, +{0xEB25,0x81,0x01}, +{0xEB26,0x05,0x01}, +{0xEB27,0x20,0x01}, +{0xEB28,0xF1,0x01}, +{0xEB29,0x4F,0x01}, +{0xEB2A,0x00,0x01}, +{0xEB2B,0x14,0x01}, +{0xEB2C,0x82,0x01}, +{0xEB2D,0x85,0x01}, +{0xEB2E,0x80,0x01}, +{0xEB2F,0x21,0x01}, +{0xEB30,0x60,0x01}, +{0xEB31,0x04,0x01}, +{0xEB32,0x12,0x01}, +{0xEB33,0x81,0x01}, +{0xEB34,0x84,0x01}, +{0xEB35,0xE0,0x01}, +{0xEB36,0x00,0x01}, +{0xEB37,0x28,0x01}, +{0xEB38,0x04,0x01}, +{0xEB39,0x0C,0x01}, +{0xEB3A,0x82,0x01}, +{0xEB3B,0x43,0x01}, +{0xEB3C,0x20,0x01}, +{0xEB3D,0x11,0x01}, +{0xEB3E,0x68,0x01}, +{0xEB3F,0x04,0x01}, +{0xEB40,0x1A,0x01}, +{0xEB41,0x82,0x01}, +{0xEB42,0x83,0x01}, +{0xEB43,0xE0,0x01}, +{0xEB44,0x00,0x01}, +{0xEB45,0x20,0x01}, +{0xEB46,0x00,0x01}, +{0xEB47,0x06,0x01}, +{0xEB48,0xFF,0x01}, +{0xEB49,0x41,0x01}, +{0xEB4A,0x80,0x01}, +{0xEB4B,0x10,0x01}, +{0xEB4C,0x30,0x01}, +{0xEB4D,0x08,0x01}, +{0xEB4E,0x14,0x01}, +{0xEB4F,0x02,0x01}, +{0xEB50,0x45,0x01}, +{0xEB51,0xC0,0x01}, +{0xEB52,0x10,0x01}, +{0xEB53,0x30,0x01}, +{0xEB54,0x04,0x01}, +{0xEB55,0x04,0x01}, +{0xEB56,0x01,0x01}, +{0xEB57,0xC0,0x01}, +{0xEB58,0x3F,0x01}, +{0xEB59,0x10,0x01}, +{0xEB5A,0x10,0x01}, +{0xEB5B,0x04,0x01}, +{0xEB5C,0x0A,0x01}, +{0xEB5D,0x80,0x01}, +{0xEB5E,0x03,0x01}, +{0xEB5F,0xE0,0x01}, +{0xEB60,0x10,0x01}, +{0xEB61,0x28,0x01}, +{0xEB62,0x04,0x01}, +{0xEB63,0x0A,0x01}, +{0xEB64,0x81,0x01}, +{0xEB65,0x01,0x01}, +{0xEB66,0x00,0x01}, +{0xEB67,0x10,0x01}, +{0xEB68,0x00,0x01}, +{0xEB69,0x04,0x01}, +{0xEB6A,0x04,0x01}, +{0xEB6B,0x01,0x01}, +{0xEB6C,0x42,0x01}, +{0xEB6D,0xE0,0x01}, +{0xEB6E,0x10,0x01}, +{0xEB6F,0x38,0x01}, +{0xEB70,0xFC,0x01}, +{0xEB71,0x0D,0x01}, +{0xEB72,0x7F,0x01}, +{0xEB73,0x43,0x01}, +{0xEB74,0x60,0x01}, +{0xEB75,0x00,0x01}, +{0xEB76,0x08,0x01}, +{0xEB77,0x08,0x01}, +{0xEB78,0x02,0x01}, +{0xEB79,0x81,0x01}, +{0xEB7A,0x41,0x01}, +{0xEB7B,0x80,0x01}, +{0xEB7C,0x10,0x01}, +{0xEB7D,0x30,0x01}, +{0xEB7E,0x04,0x01}, +{0xEB7F,0x0C,0x01}, +{0xEB80,0x01,0x01}, +{0xEB81,0x43,0x01}, +{0xEB82,0xC0,0x01}, +{0xEB83,0x20,0x01}, +{0xEB84,0x28,0x01}, +{0xEB85,0x08,0x01}, +{0xEB86,0x06,0x01}, +{0xEB87,0x02,0x01}, +{0xEB88,0xC2,0x01}, +{0xEB89,0xA0,0x01}, +{0xEB8A,0x30,0x01}, +{0xEB8B,0x30,0x01}, +{0xEB8C,0x0C,0x01}, +{0xEB8D,0x12,0x01}, +{0xEB8E,0x83,0x01}, +{0xEB8F,0x84,0x01}, +{0xEB90,0x00,0x01}, +{0xEB91,0x21,0x01}, +{0xEB92,0x40,0x01}, +{0xEB93,0x0C,0x01}, +{0xEB94,0x0C,0x01}, +{0xEB95,0x82,0x01}, +{0xEB96,0x03,0x01}, +{0xEB97,0xC1,0x01}, +{0xEB98,0x40,0x01}, +{0xEB99,0x40,0x01}, +{0xEB9A,0x08,0x01}, +{0xEB9B,0x10,0x01}, +{0xEB9C,0x03,0x01}, +{0xEB9D,0xC4,0x01}, +{0xEB9E,0x00,0x01}, +{0xEB9F,0x21,0x01}, +{0xEBA0,0x38,0x01}, +{0xEBA1,0x08,0x01}, +{0xEBA2,0x0E,0x01}, +{0xEBA3,0x82,0x01}, +{0xEBA4,0xC3,0x01}, +{0xEBA5,0x20,0x01}, +{0xEBA6,0x41,0x01}, +{0xEBA7,0x48,0x01}, +{0xEBA8,0x00,0x01}, +{0xEBA9,0x14,0x01}, +{0xEBAA,0x83,0x01}, +{0xEBAB,0x44,0x01}, +{0xEBAC,0x20,0x01}, +{0xEBAD,0x11,0x01}, +{0xEBAE,0x48,0x01}, +{0xEBAF,0x08,0x01}, +{0xEBB0,0x0E,0x01}, +{0xEBB1,0x82,0x01}, +{0xEBB2,0x83,0x01}, +{0xEBB3,0xE0,0x01}, +{0xEBB4,0x30,0x01}, +{0xEBB5,0x48,0x01}, +{0xEBB6,0x10,0x01}, +{0xEBB7,0x12,0x01}, +{0xEBB8,0x00,0x01}, +{0xEBB9,0xC5,0x01}, +{0xEBBA,0x20,0x01}, +{0xEBBB,0x11,0x01}, +{0xEBBC,0x48,0x01}, +{0xEBBD,0x04,0x01}, +{0xEBBE,0x12,0x01}, +{0xEBBF,0x04,0x01}, +{0xEBC0,0x3B,0x01}, +{0xEBC1,0xC1,0x01}, +{0xEBC2,0x1E,0x01}, +{0xEBC3,0xC8,0x01}, +{0xEBC4,0x0F,0x01}, +{0xEBC5,0xF8,0x01}, +{0xEBC6,0x02,0x01}, +{0xEBC7,0xBB,0x01}, +{0xEBC8,0x60,0x01}, +{0xEBC9,0x0F,0x01}, +{0xEBCA,0xB8,0x01}, +{0xEBCB,0x0F,0x01}, +{0xEBCC,0xEA,0x01}, +{0xEBCD,0x83,0x01}, +{0xEBCE,0x3A,0x01}, +{0xEBCF,0xC1,0x01}, +{0xEBD0,0x4E,0x01}, +{0xEBD1,0xB0,0x01}, +{0xEBD2,0x07,0x01}, +{0xEBD3,0xF2,0x01}, +{0xEBD4,0x03,0x01}, +{0xEBD5,0xBE,0x01}, +{0xEBD6,0xC0,0x01}, +{0xEBD7,0x2E,0x01}, +{0xEBD8,0xD8,0x01}, +{0xEBD9,0x03,0x01}, +{0xEBDA,0xEE,0x01}, +{0xEBDB,0x83,0x01}, +{0xEBDC,0xFA,0x01}, +{0xEBDD,0xA0,0x01}, +{0xEBDE,0x2E,0x01}, +{0xEBDF,0xB0,0x01}, +{0xEBE0,0x0B,0x01}, +{0xEBE1,0xEC,0x01}, +{0xEBE2,0x05,0x01}, +{0xEBE3,0xBD,0x01}, +{0xEBE4,0x60,0x01}, +{0xEBE5,0x2F,0x01}, +{0xEBE6,0xD0,0x01}, +{0xEBE7,0x07,0x01}, +{0xEBE8,0xEC,0x01}, +{0xEBE9,0x02,0x01}, +{0xEBEA,0xBC,0x01}, +{0xEBEB,0x40,0x01}, +{0xEBEC,0x2F,0x01}, +{0xEBED,0xD0,0x01}, +{0xEBEE,0x13,0x01}, +{0xEBEF,0xEE,0x01}, +{0xEBF0,0x84,0x01}, +{0xEBF1,0xBB,0x01}, +{0xEBF2,0x00,0x01}, +{0xEBF3,0x1F,0x01}, +{0xEBF4,0xC8,0x01}, +{0xEBF5,0xFF,0x01}, +{0xEBF6,0xEF,0x01}, +{0xEBF7,0x00,0x01}, +{0xEBF8,0x7D,0x01}, +{0xEBF9,0x60,0x01}, +{0xEBFA,0x2F,0x01}, +{0xEBFB,0xD0,0x01}, +{0xEBFC,0x0B,0x01}, +{0xEBFD,0xF4,0x01}, +{0xEBFE,0x85,0x01}, +{0xEBFF,0x7D,0x01}, +{0xEC00,0x61,0x01}, +{0xEC01,0x0F,0x01}, +{0xEC02,0xC0,0x01}, +{0xEC03,0xFF,0x01}, +{0xEC04,0xF7,0x01}, +{0xEC05,0x7F,0x01}, +{0xEC06,0x3D,0x01}, +{0xEC07,0x40,0x01}, +{0xEC08,0xFF,0x01}, +{0xEC09,0xDF,0x01}, +{0xEC0A,0x07,0x01}, +{0xEC0B,0xFA,0x01}, +{0xEC0C,0x81,0x01}, +{0xEC0D,0x3E,0x01}, +{0xEC0E,0x61,0x01}, +{0xEC0F,0x4F,0x01}, +{0xEC10,0xD8,0x01}, +{0xEC11,0x0B,0x01}, +{0xEC12,0xFC,0x01}, +{0xEC13,0xFE,0x01}, +{0xEC14,0x3D,0x01}, +{0xEC15,0xC0,0x01}, +{0xEC16,0xFF,0x01}, +{0xEC17,0xFF,0x01}, +{0xEC18,0x03,0x01}, +{0xEC19,0xFC,0x01}, +{0xEC1A,0x82,0x01}, +{0xEC1B,0xBE,0x01}, +{0xEC1C,0xA0,0x01}, +{0xEC1D,0x6F,0x01}, +{0xEC1E,0xF8,0x01}, +{0xEC1F,0x1B,0x01}, +{0xEC20,0xFE,0x01}, +{0xEC21,0x83,0x01}, +{0xEC22,0xBF,0x01}, +{0xEC23,0xE0,0x01}, +{0xEC24,0x0F,0x01}, +{0xEC25,0x10,0x01}, +{0xEC26,0x00,0x01}, +{0xEC27,0x00,0x01}, +{0xEC28,0x82,0x01}, +{0xEC29,0xC0,0x01}, +{0xEC2A,0x60,0x01}, +{0xEC2B,0x30,0x01}, +{0xEC2C,0x18,0x01}, +{0xEC2D,0x20,0x01}, +{0xEC2E,0x04,0x01}, +{0xEC2F,0x08,0x01}, +{0xEC30,0x81,0x01}, +{0xEC31,0x21,0x01}, +{0xEC32,0x30,0x01}, +{0xEC33,0x08,0x01}, +{0xEC34,0x08,0x01}, +{0xEC35,0x08,0x01}, +{0xEC36,0x82,0x01}, +{0xEC37,0x01,0x01}, +{0xEC38,0x81,0x01}, +{0xEC39,0x50,0x01}, +{0xEC3A,0x08,0x01}, +{0xEC3B,0x14,0x01}, +{0xEC3C,0x02,0x01}, +{0xEC3D,0x09,0x01}, +{0xEC3E,0x41,0x01}, +{0xEC3F,0x42,0x01}, +{0xEC40,0x70,0x01}, +{0xEC41,0x20,0x01}, +{0xEC42,0x0C,0x01}, +{0xEC43,0x06,0x01}, +{0xEC44,0x84,0x01}, +{0xEC45,0x42,0x01}, +{0xEC46,0xE1,0x01}, +{0xEC47,0x40,0x01}, +{0xEC48,0x38,0x01}, +{0xEC49,0x1C,0x01}, +{0xEC4A,0x0C,0x01}, +{0xEC4B,0x07,0x01}, +{0xEC4C,0x03,0x01}, +{0xEC4D,0xA2,0x01}, +{0xEC4E,0x80,0x01}, +{0xEC4F,0x28,0x01}, +{0xEC50,0x18,0x01}, +{0xEC51,0x10,0x01}, +{0xEC52,0x87,0x01}, +{0xEC53,0x43,0x01}, +{0xEC54,0x61,0x01}, +{0xEC55,0x41,0x01}, +{0xEC56,0x48,0x01}, +{0xEC57,0x14,0x01}, +{0xEC58,0x10,0x01}, +{0xEC59,0x07,0x01}, +{0xEC5A,0xC2,0x01}, +{0xEC5B,0x81,0x01}, +{0xEC5C,0x80,0x01}, +{0xEC5D,0x30,0x01}, +{0xEC5E,0x20,0x01}, +{0xEC5F,0x0C,0x01}, +{0xEC60,0x87,0x01}, +{0xEC61,0x83,0x01}, +{0xEC62,0xC1,0x01}, +{0xEC63,0x40,0x01}, +{0xEC64,0x38,0x01}, +{0xEC65,0x14,0x01}, +{0xEC66,0x0A,0x01}, +{0xEC67,0x07,0x01}, +{0xEC68,0xC3,0x01}, +{0xEC69,0xC1,0x01}, +{0xEC6A,0x70,0x01}, +{0xEC6B,0x30,0x01}, +{0xEC6C,0x20,0x01}, +{0xEC6D,0x0C,0x01}, +{0xEC6E,0x08,0x01}, +{0xEC6F,0xC3,0x01}, +{0xEC70,0xE1,0x01}, +{0xEC71,0x60,0x01}, +{0xEC72,0x30,0x01}, +{0xEC73,0x10,0x01}, +{0xEC74,0x0E,0x01}, +{0xEC75,0x85,0x01}, +{0xEC76,0xC2,0x01}, +{0xEC77,0xC1,0x01}, +{0xEC78,0x70,0x01}, +{0xEC79,0x30,0x01}, +{0xEC7A,0x1C,0x01}, +{0xEC7B,0x0C,0x01}, + +//SHD1(from CO1) +{0xED02,0xE6,0x01}, +{0xED03,0x61,0x01}, +{0xED04,0x92,0x01}, +{0xED05,0x7C,0x01}, +{0xED06,0xBE,0x01}, +{0xED07,0xB4,0x01}, +{0xED08,0x9E,0x01}, +{0xED09,0x2C,0x01}, +{0xED0A,0x75,0x01}, +{0xED0B,0x47,0x01}, +{0xED0C,0x49,0x01}, +{0xED0D,0xD7,0x01}, +{0xED0E,0x61,0x01}, +{0xED0F,0x12,0x01}, +{0xED10,0x76,0x01}, +{0xED11,0xA8,0x01}, +{0xED12,0x34,0x01}, +{0xED13,0x1E,0x01}, +{0xED14,0x31,0x01}, +{0xED15,0xA1,0x01}, +{0xED16,0xC7,0x01}, +{0xED17,0x4C,0x01}, +{0xED18,0xDE,0x01}, +{0xED19,0xC1,0x01}, +{0xED1A,0xD2,0x01}, +{0xED1B,0x77,0x01}, +{0xED1C,0x76,0x01}, +{0xED1D,0x94,0x01}, +{0xED1E,0x9C,0x01}, +{0xED1F,0x10,0x01}, +{0xED20,0xC9,0x01}, +{0xED21,0xC6,0x01}, +{0xED22,0x40,0x01}, +{0xED23,0xA2,0x01}, +{0xED24,0x99,0x01}, +{0xED25,0x8F,0x01}, +{0xED26,0x66,0x01}, +{0xED27,0xDC,0x01}, +{0xED28,0xF3,0x01}, +{0xED29,0x19,0x01}, +{0xED2A,0xFC,0x01}, +{0xED2B,0xB0,0x01}, +{0xED2C,0xA6,0x01}, +{0xED2D,0x41,0x01}, +{0xED2E,0xC1,0x01}, +{0xED2F,0x49,0x01}, +{0xED30,0x91,0x01}, +{0xED31,0x75,0x01}, +{0xED32,0x8C,0x01}, +{0xED33,0x74,0x01}, +{0xED34,0x1C,0x01}, +{0xED35,0x0B,0x01}, +{0xED36,0x91,0x01}, +{0xED37,0x86,0x01}, +{0xED38,0x3D,0x01}, +{0xED39,0x87,0x01}, +{0xED3A,0x39,0x01}, +{0xED3B,0x4E,0x01}, +{0xED3C,0x5C,0x01}, +{0xED3D,0x50,0x01}, +{0xED3E,0x83,0x01}, +{0xED3F,0x16,0x01}, +{0xED40,0xCF,0x01}, +{0xED41,0xBC,0x01}, +{0xED42,0x45,0x01}, +{0xED43,0x35,0x01}, +{0xED44,0x83,0x01}, +{0xED45,0x41,0x01}, +{0xED46,0xCE,0x01}, +{0xED47,0x67,0x01}, +{0xED48,0xE8,0x01}, +{0xED49,0x33,0x01}, +{0xED4A,0x1C,0x01}, +{0xED4B,0x16,0x01}, +{0xED4C,0xC1,0x01}, +{0xED4D,0x86,0x01}, +{0xED4E,0x3E,0x01}, +{0xED4F,0x83,0x01}, +{0xED50,0xC1,0x01}, +{0xED51,0x0D,0x01}, +{0xED52,0x57,0x01}, +{0xED53,0x02,0x01}, +{0xED54,0x23,0x01}, +{0xED55,0x14,0x01}, +{0xED56,0xAE,0x01}, +{0xED57,0xE4,0x01}, +{0xED58,0x44,0x01}, +{0xED59,0x2A,0x01}, +{0xED5A,0x43,0x01}, +{0xED5B,0xF9,0x01}, +{0xED5C,0xCA,0x01}, +{0xED5D,0x56,0x01}, +{0xED5E,0x0C,0x01}, +{0xED5F,0x03,0x01}, +{0xED60,0x98,0x01}, +{0xED61,0xE2,0x01}, +{0xED62,0xA8,0x01}, +{0xED63,0x26,0x01}, +{0xED64,0x41,0x01}, +{0xED65,0x9E,0x01}, +{0xED66,0xC1,0x01}, +{0xED67,0xCE,0x01}, +{0xED68,0x59,0x01}, +{0xED69,0x1C,0x01}, +{0xED6A,0xB3,0x01}, +{0xED6B,0x93,0x01}, +{0xED6C,0xA7,0x01}, +{0xED6D,0x74,0x01}, +{0xED6E,0x04,0x01}, +{0xED6F,0x25,0x01}, +{0xED70,0x13,0x01}, +{0xED71,0xD9,0x01}, +{0xED72,0xC8,0x01}, +{0xED73,0x47,0x01}, +{0xED74,0x54,0x01}, +{0xED75,0xD2,0x01}, +{0xED76,0x93,0x01}, +{0xED77,0xAA,0x01}, +{0xED78,0x98,0x01}, +{0xED79,0xE5,0x01}, +{0xED7A,0x32,0x01}, +{0xED7B,0x9A,0x01}, +{0xED7C,0x29,0x01}, +{0xED7D,0xCF,0x01}, +{0xED7E,0x64,0x01}, +{0xED7F,0x8E,0x01}, +{0xED80,0x73,0x01}, +{0xED81,0x95,0x01}, +{0xED82,0xBB,0x01}, +{0xED83,0xA4,0x01}, +{0xED84,0xA4,0x01}, +{0xED85,0x26,0x01}, +{0xED86,0x0A,0x01}, +{0xED87,0x59,0x01}, +{0xED88,0x08,0x01}, +{0xED89,0x40,0x01}, +{0xED8A,0x00,0x01}, +{0xED8B,0xC2,0x01}, +{0xED8C,0x10,0x01}, +{0xED8D,0x88,0x01}, +{0xED8E,0xB0,0x01}, +{0xED8F,0x84,0x01}, +{0xED90,0x27,0x01}, +{0xED91,0x59,0x01}, +{0xED92,0xF1,0x01}, +{0xED93,0x0B,0x01}, +{0xED94,0x64,0x01}, +{0xED95,0xA2,0x01}, +{0xED96,0x43,0x01}, +{0xED97,0x99,0x01}, +{0xED98,0xE4,0x01}, +{0xED99,0x68,0x01}, +{0xED9A,0x25,0x01}, +{0xED9B,0x2F,0x01}, +{0xED9C,0x2B,0x01}, +{0xED9D,0xB1,0x01}, +{0xED9E,0xC9,0x01}, +{0xED9F,0x42,0x01}, +{0xEDA0,0x18,0x01}, +{0xEDA1,0x32,0x01}, +{0xEDA2,0x90,0x01}, +{0xEDA3,0x80,0x01}, +{0xEDA4,0x3C,0x01}, +{0xEDA5,0x24,0x01}, +{0xEDA6,0x22,0x01}, +{0xEDA7,0x2F,0x01}, +{0xEDA8,0xF1,0x01}, +{0xEDA9,0x09,0x01}, +{0xEDAA,0x57,0x01}, +{0xEDAB,0x00,0x01}, +{0xEDAC,0x53,0x01}, +{0xEDAD,0x99,0x01}, +{0xEDAE,0xEA,0x01}, +{0xEDAF,0x90,0x01}, +{0xEDB0,0xC6,0x01}, +{0xEDB1,0x3B,0x01}, +{0xEDB2,0x6D,0x01}, +{0xEDB3,0x99,0x01}, +{0xEDB4,0x4C,0x01}, +{0xEDB5,0x50,0x01}, +{0xEDB6,0xA4,0x01}, +{0xEDB7,0x32,0x01}, +{0xEDB8,0x12,0x01}, +{0xEDB9,0x94,0x01}, +{0xEDBA,0x64,0x01}, +{0xEDBB,0xA4,0x01}, +{0xEDBC,0x23,0x01}, +{0xEDBD,0x25,0x01}, +{0xEDBE,0x71,0x01}, +{0xEDBF,0x49,0x01}, +{0xEDC0,0x51,0x01}, +{0xEDC1,0xB2,0x01}, +{0xEDC2,0x02,0x01}, +{0xEDC3,0x17,0x01}, +{0xEDC4,0xCD,0x01}, +{0xEDC5,0x98,0x01}, +{0xEDC6,0x86,0x01}, +{0xEDC7,0x3D,0x01}, +{0xEDC8,0xBC,0x01}, +{0xEDC9,0x01,0x01}, +{0xEDCA,0x50,0x01}, +{0xEDCB,0x63,0x01}, +{0xEDCC,0x80,0x01}, +{0xEDCD,0x63,0x01}, +{0xEDCE,0x16,0x01}, +{0xEDCF,0xC3,0x01}, +{0xEDD0,0x2C,0x01}, +{0xEDD1,0x25,0x01}, +{0xEDD2,0x2C,0x01}, +{0xEDD3,0x43,0x01}, +{0xEDD4,0xB1,0x01}, +{0xEDD5,0x4A,0x01}, +{0xEDD6,0x53,0x01}, +{0xEDD7,0xCC,0x01}, +{0xEDD8,0x82,0x01}, +{0xEDD9,0x96,0x01}, +{0xEDDA,0xC7,0x01}, +{0xEDDB,0x40,0x01}, +{0xEDDC,0xA6,0x01}, +{0xEDDD,0x39,0x01}, +{0xEDDE,0xBE,0x01}, +{0xEDDF,0x91,0x01}, +{0xEDE0,0xD0,0x01}, +{0xEDE1,0x75,0x01}, +{0xEDE2,0x54,0x01}, +{0xEDE3,0x34,0x01}, +{0xEDE4,0x1B,0x01}, +{0xEDE5,0xFC,0x01}, +{0xEDE6,0x4C,0x01}, +{0xEDE7,0x46,0x01}, +{0xEDE8,0x39,0x01}, +{0xEDE9,0x7D,0x01}, +{0xEDEA,0x71,0x01}, +{0xEDEB,0x8D,0x01}, +{0xEDEC,0x5D,0x01}, +{0xEDED,0x46,0x01}, +{0xEDEE,0xE3,0x01}, +{0xEDEF,0x17,0x01}, +{0xEDF0,0xD9,0x01}, +{0xEDF1,0x50,0x01}, +{0xEDF2,0x86,0x01}, +{0xEDF3,0x3A,0x01}, +{0xEDF4,0xB3,0x01}, +{0xEDF5,0x09,0x01}, +{0xEDF6,0x50,0x01}, +{0xEDF7,0x76,0x01}, +{0xEDF8,0x6A,0x01}, +{0xEDF9,0xF4,0x01}, +{0xEDFA,0x1E,0x01}, +{0xEDFB,0x25,0x01}, +{0xEDFC,0x61,0x01}, +{0xEDFD,0x67,0x01}, +{0xEDFE,0x45,0x01}, +{0xEDFF,0xC0,0x01}, +{0xEE00,0x69,0x01}, +{0xEE01,0xD0,0x01}, +{0xEE02,0x6B,0x01}, +{0xEE03,0xF6,0x01}, +{0xEE04,0x93,0x01}, +{0xEE05,0x9A,0x01}, +{0xEE06,0xFA,0x01}, +{0xEE07,0xB8,0x01}, +{0xEE08,0x26,0x01}, +{0xEE09,0x40,0x01}, +{0xEE0A,0xC0,0x01}, +{0xEE0B,0xB9,0x01}, +{0xEE0C,0xD0,0x01}, +{0xEE0D,0x75,0x01}, +{0xEE0E,0x6E,0x01}, +{0xEE0F,0xE4,0x01}, +{0xEE10,0x9E,0x01}, +{0xEE11,0x2D,0x01}, +{0xEE12,0xE1,0x01}, +{0xEE13,0xA7,0x01}, +{0xEE14,0x49,0x01}, +{0xEE15,0xFD,0x01}, +{0xEE16,0xB9,0x01}, +{0xEE17,0x52,0x01}, +{0xEE18,0x7C,0x01}, +{0xEE19,0x98,0x01}, +{0xEE1A,0x64,0x01}, +{0xEE1B,0x1E,0x01}, +{0xEE1C,0x22,0x01}, +{0xEE1D,0x89,0x01}, +{0xEE1E,0xA7,0x01}, +{0xEE1F,0x48,0x01}, +{0xEE20,0xE4,0x01}, +{0xEE21,0x49,0x01}, +{0xEE22,0x12,0x01}, +{0xEE23,0x7D,0x01}, +{0xEE24,0xB4,0x01}, +{0xEE25,0xB4,0x01}, +{0xEE26,0x1F,0x01}, +{0xEE27,0x31,0x01}, +{0xEE28,0xC5,0x01}, +{0xEE29,0x47,0x01}, +{0xEE2A,0x4B,0x01}, +{0xEE2B,0xC2,0x01}, +{0xEE2C,0x19,0x01}, +{0xEE2D,0x0F,0x01}, +{0xEE2E,0x73,0x01}, +{0xEE2F,0xE2,0x01}, +{0xEE30,0x13,0x01}, +{0xEE31,0x1C,0x01}, +{0xEE32,0xF5,0x01}, +{0xEE33,0xE0,0x01}, +{0xEE34,0xC6,0x01}, +{0xEE35,0x3B,0x01}, +{0xEE36,0xB6,0x01}, +{0xEE37,0xB1,0x01}, +{0xEE38,0xCE,0x01}, +{0xEE39,0x6D,0x01}, +{0xEE3A,0xB8,0x01}, +{0xEE3B,0xF3,0x01}, +{0xEE3C,0x9B,0x01}, +{0xEE3D,0xF2,0x01}, +{0xEE3E,0x18,0x01}, +{0xEE3F,0x27,0x01}, +{0xEE40,0x3D,0x01}, +{0xEE41,0xBF,0x01}, +{0xEE42,0xE9,0x01}, +{0xEE43,0xCE,0x01}, +{0xEE44,0x6E,0x01}, +{0xEE45,0xBA,0x01}, +{0xEE46,0x83,0x01}, +{0xEE47,0x9A,0x01}, +{0xEE48,0xE4,0x01}, +{0xEE49,0x50,0x01}, +{0xEE4A,0x66,0x01}, +{0xEE4B,0x36,0x01}, +{0xEE4C,0x8A,0x01}, +{0xEE4D,0x29,0x01}, +{0xEE4E,0x4D,0x01}, +{0xEE4F,0x61,0x01}, +{0xEE50,0x3A,0x01}, +{0xEE51,0xA3,0x01}, +{0xEE52,0x18,0x01}, +{0xEE53,0xD2,0x01}, +{0xEE54,0x50,0x01}, +{0xEE55,0x26,0x01}, +{0xEE56,0x36,0x01}, +{0xEE57,0xA8,0x01}, +{0xEE58,0x21,0x01}, +{0xEE59,0xCE,0x01}, +{0xEE5A,0x6E,0x01}, +{0xEE5B,0xB2,0x01}, +{0xEE5C,0x03,0x01}, +{0xEE5D,0x9A,0x01}, +{0xEE5E,0xE0,0x01}, +{0xEE5F,0x1C,0x01}, +{0xEE60,0x46,0x01}, +{0xEE61,0x34,0x01}, +{0xEE62,0x72,0x01}, +{0xEE63,0x41,0x01}, +{0xEE64,0x8C,0x01}, +{0xEE65,0x58,0x01}, +{0xEE66,0xE8,0x01}, +{0xEE67,0xC2,0x01}, +{0xEE68,0x95,0x01}, +{0xEE69,0xB5,0x01}, +{0xEE6A,0x88,0x01}, +{0xEE6B,0x65,0x01}, +{0xEE6C,0x2E,0x01}, +{0xEE6D,0x72,0x01}, +{0xEE6E,0x39,0x01}, +{0xEE6F,0x8C,0x01}, +{0xEE70,0x62,0x01}, +{0xEE71,0x48,0x01}, +{0xEE72,0x83,0x01}, +{0xEE73,0x1A,0x01}, +{0xEE74,0xE4,0x01}, +{0xEE75,0x28,0x01}, +{0xEE76,0x06,0x01}, +{0xEE77,0x35,0x01}, +{0xEE78,0x6A,0x01}, +{0xEE79,0xF9,0x01}, +{0xEE7A,0x4B,0x01}, +{0xEE7B,0x53,0x01}, +{0xEE7C,0xB8,0x01}, +{0xEE7D,0x92,0x01}, +{0xEE7E,0x13,0x01}, +{0xEE7F,0xA2,0x01}, +{0xEE80,0xCC,0x01}, +{0xEE81,0x64,0x01}, +{0xEE82,0x27,0x01}, +{0xEE83,0x3B,0x01}, +{0xEE84,0x29,0x01}, +{0xEE85,0x0A,0x01}, +{0xEE86,0x54,0x01}, +{0xEE87,0xBC,0x01}, +{0xEE88,0xF2,0x01}, +{0xEE89,0x96,0x01}, +{0xEE8A,0xC1,0x01}, +{0xEE8B,0x40,0x01}, +{0xEE8C,0xA6,0x01}, +{0xEE8D,0x35,0x01}, +{0xEE8E,0x7A,0x01}, +{0xEE8F,0xB1,0x01}, +{0xEE90,0x8C,0x01}, +{0xEE91,0x54,0x01}, +{0xEE92,0xC8,0x01}, +{0xEE93,0xF2,0x01}, +{0xEE94,0x92,0x01}, +{0xEE95,0x9D,0x01}, +{0xEE96,0x64,0x01}, +{0xEE97,0xE4,0x01}, +{0xEE98,0x23,0x01}, +{0xEE99,0x13,0x01}, +{0xEE9A,0xA9,0x01}, +{0xEE9B,0x48,0x01}, +{0xEE9C,0x47,0x01}, +{0xEE9D,0x40,0x01}, +{0xEE9E,0x42,0x01}, +{0xEE9F,0x13,0x01}, +{0xEEA0,0x9F,0x01}, +{0xEEA1,0x58,0x01}, +{0xEEA2,0xE5,0x01}, +{0xEEA3,0x2C,0x01}, +{0xEEA4,0x7F,0x01}, +{0xEEA5,0xD9,0x01}, +{0xEEA6,0x8C,0x01}, +{0xEEA7,0x5B,0x01}, +{0xEEA8,0x12,0x01}, +{0xEEA9,0x43,0x01}, +{0xEEAA,0x14,0x01}, +{0xEEAB,0xAA,0x01}, +{0xEEAC,0x80,0x01}, +{0xEEAD,0x04,0x01}, +{0xEEAE,0x25,0x01}, +{0xEEAF,0x06,0x01}, +{0xEEB0,0x51,0x01}, +{0xEEB1,0x08,0x01}, +{0xEEB2,0x40,0x01}, +{0xEEB3,0x00,0x01}, +{0xEEB4,0xB2,0x01}, +{0xEEB5,0x10,0x01}, +{0xEEB6,0x86,0x01}, +{0xEEB7,0x98,0x01}, +{0xEEB8,0x64,0x01}, +{0xEEB9,0x25,0x01}, +{0xEEBA,0x4A,0x01}, +{0xEEBB,0xB9,0x01}, +{0xEEBC,0x0A,0x01}, +{0xEEBD,0x5D,0x01}, +{0xEEBE,0x1C,0x01}, +{0xEEBF,0x13,0x01}, +{0xEEC0,0x97,0x01}, +{0xEEC1,0xC4,0x01}, +{0xEEC2,0x18,0x01}, +{0xEEC3,0x85,0x01}, +{0xEEC4,0x2A,0x01}, +{0xEEC5,0x21,0x01}, +{0xEEC6,0x41,0x01}, +{0xEEC7,0xC9,0x01}, +{0xEEC8,0x41,0x01}, +{0xEEC9,0x12,0x01}, +{0xEECA,0x02,0x01}, +{0xEECB,0x10,0x01}, +{0xEECC,0x80,0x01}, +{0xEECD,0x2C,0x01}, +{0xEECE,0x64,0x01}, +{0xEECF,0x21,0x01}, +{0xEED0,0x27,0x01}, +{0xEED1,0x61,0x01}, +{0xEED2,0xC9,0x01}, +{0xEED3,0x52,0x01}, +{0xEED4,0xB0,0x01}, +{0xEED5,0x42,0x01}, +{0xEED6,0x17,0x01}, +{0xEED7,0xC8,0x01}, +{0xEED8,0x04,0x01}, +{0xEED9,0xE6,0x01}, +{0xEEDA,0x32,0x01}, +{0xEEDB,0x58,0x01}, +{0xEEDC,0x29,0x01}, +{0xEEDD,0xCB,0x01}, +{0xEEDE,0x4C,0x01}, +{0xEEDF,0x74,0x01}, +{0xEEE0,0x92,0x01}, +{0xEEE1,0x91,0x01}, +{0xEEE2,0x8E,0x01}, +{0xEEE3,0x48,0x01}, +{0xEEE4,0x84,0x01}, +{0xEEE5,0x22,0x01}, +{0xEEE6,0x1D,0x01}, +{0xEEE7,0x01,0x01}, +{0xEEE8,0xC9,0x01}, +{0xEEE9,0x4D,0x01}, +{0xEEEA,0x7E,0x01}, +{0xEEEB,0x82,0x01}, +{0xEEEC,0x15,0x01}, +{0xEEED,0xB5,0x01}, +{0xEEEE,0x04,0x01}, +{0xEEEF,0xE6,0x01}, +{0xEEF0,0x33,0x01}, +{0xEEF1,0x99,0x01}, +{0xEEF2,0x69,0x01}, +{0xEEF3,0x0D,0x01}, +{0xEEF4,0x5D,0x01}, +{0xEEF5,0x06,0x01}, +{0xEEF6,0x33,0x01}, +{0xEEF7,0x15,0x01}, +{0xEEF8,0xAF,0x01}, +{0xEEF9,0xEC,0x01}, +{0xEEFA,0xA4,0x01}, +{0xEEFB,0x28,0x01}, +{0xEEFC,0x35,0x01}, +{0xEEFD,0xE9,0x01}, +{0xEEFE,0x09,0x01}, +{0xEEFF,0x4F,0x01}, +{0xEF00,0x8E,0x01}, +{0xEF01,0x02,0x01}, +{0xEF02,0x95,0x01}, +{0xEF03,0xB1,0x01}, +{0xEF04,0xC4,0x01}, +{0xEF05,0x25,0x01}, +{0xEF06,0x31,0x01}, +{0xEF07,0x94,0x01}, +{0xEF08,0xB1,0x01}, +{0xEF09,0x4D,0x01}, +{0xEF0A,0x6C,0x01}, +{0xEF0B,0x94,0x01}, +{0xEF0C,0x43,0x01}, +{0xEF0D,0x99,0x01}, +{0xEF0E,0xD4,0x01}, +{0xEF0F,0xEC,0x01}, +{0xEF10,0xC5,0x01}, +{0xEF11,0x31,0x01}, +{0xEF12,0x69,0x01}, +{0xEF13,0xC9,0x01}, +{0xEF14,0x0B,0x01}, +{0xEF15,0x58,0x01}, +{0xEF16,0xE6,0x01}, +{0xEF17,0x52,0x01}, +{0xEF18,0x16,0x01}, +{0xEF19,0xBE,0x01}, +{0xEF1A,0xD4,0x01}, +{0xEF1B,0x45,0x01}, +{0xEF1C,0x32,0x01}, +{0xEF1D,0x8E,0x01}, +{0xEF1E,0x79,0x01}, +{0xEF1F,0x4D,0x01}, +{0xEF20,0x6A,0x01}, +{0xEF21,0xA4,0x01}, +{0xEF22,0x83,0x01}, +{0xEF23,0x1C,0x01}, +{0xEF24,0xF2,0x01}, +{0xEF25,0xDC,0x01}, +{0xEF26,0x26,0x01}, +{0xEF27,0x3A,0x01}, +{0xEF28,0xA3,0x01}, +{0xEF29,0xE1,0x01}, +{0xEF2A,0x4D,0x01}, +{0xEF2B,0x65,0x01}, +{0xEF2C,0x5C,0x01}, +{0xEF2D,0xC3,0x01}, +{0xEF2E,0x98,0x01}, +{0xEF2F,0xD4,0x01}, +{0xEF30,0x3C,0x01}, +{0xEF31,0xE6,0x01}, +{0xEF32,0x35,0x01}, +{0xEF33,0x9D,0x01}, +{0xEF34,0x09,0x01}, +{0xEF35,0x8E,0x01}, +{0xEF36,0x6B,0x01}, +{0xEF37,0xAC,0x01}, +{0xEF38,0xE3,0x01}, +{0xEF39,0x9B,0x01}, +{0xEF3A,0xF4,0x01}, +{0xEF3B,0x34,0x01}, +{0xEF3C,0x07,0x01}, +{0xEF3D,0x3E,0x01}, +{0xEF3E,0xDA,0x01}, +{0xEF3F,0xC1,0x01}, +{0xEF40,0x8F,0x01}, +{0xEF41,0x74,0x01}, +{0xEF42,0xEA,0x01}, +{0xEF43,0x13,0x01}, +{0xEF44,0x9C,0x01}, +{0xEF45,0xF4,0x01}, +{0xEF46,0xF0,0x01}, +{0xEF47,0xA6,0x01}, +{0xEF48,0x3C,0x01}, +{0xEF49,0xC0,0x01}, +{0xEF4A,0x49,0x01}, +{0xEF4B,0x0F,0x01}, +{0xEF4C,0x72,0x01}, +{0xEF4D,0xEA,0x01}, +{0xEF4E,0xD3,0x01}, +{0xEF4F,0x9C,0x01}, +{0xEF50,0xFE,0x01}, +{0xEF51,0x04,0x01}, +{0xEF52,0xA7,0x01}, +{0xEF53,0x3D,0x01}, + +//SHD2 CW+TL84 33:66 + +{0xED00,0x9191,0x02},// +{0xEF54,0x28,0x01}, +{0xEF55,0xC2,0x01}, +{0xEF56,0x11,0x01}, +{0xEF57,0x8C,0x01}, +{0xEF58,0x46,0x01}, +{0xEF59,0x34,0x01}, +{0xEF5A,0xA2,0x01}, +{0xEF5B,0x12,0x01}, +{0xEF5C,0xCD,0x01}, +{0xEF5D,0x08,0x01}, +{0xEF5E,0x47,0x01}, +{0xEF5F,0x27,0x01}, +{0xEF60,0xAA,0x01}, +{0xEF61,0x10,0x01}, +{0xEF62,0x7F,0x01}, +{0xEF63,0xC2,0x01}, +{0xEF64,0xF3,0x01}, +{0xEF65,0x1C,0x01}, +{0xEF66,0xE4,0x01}, +{0xEF67,0x40,0x01}, +{0xEF68,0x27,0x01}, +{0xEF69,0x3C,0x01}, +{0xEF6A,0xFB,0x01}, +{0xEF6B,0xA1,0x01}, +{0xEF6C,0x90,0x01}, +{0xEF6D,0x7C,0x01}, +{0xEF6E,0x92,0x01}, +{0xEF6F,0x63,0x01}, +{0xEF70,0x9A,0x01}, +{0xEF71,0xC5,0x01}, +{0xEF72,0x0C,0x01}, +{0xEF73,0x66,0x01}, +{0xEF74,0x31,0x01}, +{0xEF75,0xA4,0x01}, +{0xEF76,0x49,0x01}, +{0xEF77,0x0E,0x01}, +{0xEF78,0x7F,0x01}, +{0xEF79,0xA0,0x01}, +{0xEF7A,0xB3,0x01}, +{0xEF7B,0x19,0x01}, +{0xEF7C,0xB6,0x01}, +{0xEF7D,0x34,0x01}, +{0xEF7E,0x85,0x01}, +{0xEF7F,0x28,0x01}, +{0xEF80,0x4D,0x01}, +{0xEF81,0x61,0x01}, +{0xEF82,0x0B,0x01}, +{0xEF83,0x68,0x01}, +{0xEF84,0xB6,0x01}, +{0xEF85,0x73,0x01}, +{0xEF86,0x9B,0x01}, +{0xEF87,0xBB,0x01}, +{0xEF88,0x0C,0x01}, +{0xEF89,0x45,0x01}, +{0xEF8A,0x24,0x01}, +{0xEF8B,0x17,0x01}, +{0xEF8C,0x11,0x01}, +{0xEF8D,0x49,0x01}, +{0xEF8E,0x51,0x01}, +{0xEF8F,0xF4,0x01}, +{0xEF90,0xC2,0x01}, +{0xEF91,0x1B,0x01}, +{0xEF92,0xD4,0x01}, +{0xEF93,0x94,0x01}, +{0xEF94,0xC5,0x01}, +{0xEF95,0x25,0x01}, +{0xEF96,0x0B,0x01}, +{0xEF97,0x01,0x01}, +{0xEF98,0x48,0x01}, +{0xEF99,0x43,0x01}, +{0xEF9A,0x62,0x01}, +{0xEF9B,0x62,0x01}, +{0xEF9C,0x96,0x01}, +{0xEF9D,0xD5,0x01}, +{0xEF9E,0xA4,0x01}, +{0xEF9F,0xC6,0x01}, +{0xEFA0,0x2C,0x01}, +{0xEFA1,0x2F,0x01}, +{0xEFA2,0x51,0x01}, +{0xEFA3,0x48,0x01}, +{0xEFA4,0x40,0x01}, +{0xEFA5,0x1C,0x01}, +{0xEFA6,0x22,0x01}, +{0xEFA7,0x13,0x01}, +{0xEFA8,0xB4,0x01}, +{0xEFA9,0xC0,0x01}, +{0xEFAA,0x86,0x01}, +{0xEFAB,0x37,0x01}, +{0xEFAC,0x7B,0x01}, +{0xEFAD,0x29,0x01}, +{0xEFAE,0x8A,0x01}, +{0xEFAF,0x48,0x01}, +{0xEFB0,0x30,0x01}, +{0xEFB1,0x52,0x01}, +{0xEFB2,0x12,0x01}, +{0xEFB3,0xA4,0x01}, +{0xEFB4,0xF4,0x01}, +{0xEFB5,0x25,0x01}, +{0xEFB6,0x38,0x01}, +{0xEFB7,0xD9,0x01}, +{0xEFB8,0x01,0x01}, +{0xEFB9,0xCD,0x01}, +{0xEFBA,0x5B,0x01}, +{0xEFBB,0xA0,0x01}, +{0xEFBC,0x72,0x01}, +{0xEFBD,0x14,0x01}, +{0xEFBE,0xA9,0x01}, +{0xEFBF,0xCC,0x01}, +{0xEFC0,0xC5,0x01}, +{0xEFC1,0x34,0x01}, +{0xEFC2,0xE3,0x01}, +{0xEFC3,0xF1,0x01}, +{0xEFC4,0x0F,0x01}, +{0xEFC5,0x74,0x01}, +{0xEFC6,0x50,0x01}, +{0xEFC7,0xF3,0x01}, +{0xEFC8,0x98,0x01}, +{0xEFC9,0xC2,0x01}, +{0xEFCA,0x40,0x01}, +{0xEFCB,0x86,0x01}, +{0xEFCC,0x35,0x01}, +{0xEFCD,0xD4,0x01}, +{0xEFCE,0x29,0x01}, +{0xEFCF,0xD0,0x01}, +{0xEFD0,0x86,0x01}, +{0xEFD1,0xFE,0x01}, +{0xEFD2,0x23,0x01}, +{0xEFD3,0x9E,0x01}, +{0xEFD4,0xE8,0x01}, +{0xEFD5,0x28,0x01}, +{0xEFD6,0x87,0x01}, +{0xEFD7,0x3A,0x01}, +{0xEFD8,0xE7,0x01}, +{0xEFD9,0x21,0x01}, +{0xEFDA,0x10,0x01}, +{0xEFDB,0x89,0x01}, +{0xEFDC,0x3E,0x01}, +{0xEFDD,0x64,0x01}, +{0xEFDE,0xA2,0x01}, +{0xEFDF,0x0D,0x01}, +{0xEFE0,0x41,0x01}, +{0xEFE1,0xC8,0x01}, +{0xEFE2,0x41,0x01}, +{0xEFE3,0x14,0x01}, +{0xEFE4,0x02,0x01}, +{0xEFE5,0x11,0x01}, +{0xEFE6,0x8A,0x01}, +{0xEFE7,0x4C,0x01}, +{0xEFE8,0x04,0x01}, +{0xEFE9,0x00,0x01}, +{0xEFEA,0x00,0x01}, +{0xEFEB,0x00,0x01}, +{0xEFEC,0x00,0x01}, +{0xEFED,0x00,0x01}, + + +//SHD3 D65+TL84 C01// +{0xED00,0x9191,0x02},// +{0xEFEE,0x12,0x01}, +{0xEFEF,0x42,0x01}, +{0xEFF0,0x51,0x01}, +{0xEFF1,0x89,0x01}, +{0xEFF2,0x38,0x01}, +{0xEFF3,0xD4,0x01}, +{0xEFF4,0x21,0x01}, +{0xEFF5,0x10,0x01}, +{0xEFF6,0xAD,0x01}, +{0xEFF7,0xA8,0x01}, +{0xEFF8,0x45,0x01}, +{0xEFF9,0x18,0x01}, +{0xEFFA,0x4A,0x01}, +{0xEFFB,0x50,0x01}, +{0xEFFC,0x7D,0x01}, +{0xEFFD,0xBA,0x01}, +{0xEFFE,0xD3,0x01}, +{0xEFFF,0x1C,0x01}, +{0xF000,0xE4,0x01}, +{0xF001,0x40,0x01}, +{0xF002,0x27,0x01}, +{0xF003,0x3C,0x01}, +{0xF004,0xF8,0x01}, +{0xF005,0x69,0x01}, +{0xF006,0x10,0x01}, +{0xF007,0x7B,0x01}, +{0xF008,0x8E,0x01}, +{0xF009,0x63,0x01}, +{0xF00A,0x1A,0x01}, +{0xF00B,0xC6,0x01}, +{0xF00C,0x10,0x01}, +{0xF00D,0xA6,0x01}, +{0xF00E,0x31,0x01}, +{0xF00F,0xA6,0x01}, +{0xF010,0x59,0x01}, +{0xF011,0x8E,0x01}, +{0xF012,0x7E,0x01}, +{0xF013,0x9A,0x01}, +{0xF014,0xB3,0x01}, +{0xF015,0x19,0x01}, +{0xF016,0xB6,0x01}, +{0xF017,0x38,0x01}, +{0xF018,0xA5,0x01}, +{0xF019,0x28,0x01}, +{0xF01A,0x4F,0x01}, +{0xF01B,0x79,0x01}, +{0xF01C,0xCB,0x01}, +{0xF01D,0x68,0x01}, +{0xF01E,0xBA,0x01}, +{0xF01F,0x53,0x01}, +{0xF020,0x9B,0x01}, +{0xF021,0xBB,0x01}, +{0xF022,0x0C,0x01}, +{0xF023,0x65,0x01}, +{0xF024,0x24,0x01}, +{0xF025,0x17,0x01}, +{0xF026,0x21,0x01}, +{0xF027,0xC9,0x01}, +{0xF028,0x51,0x01}, +{0xF029,0xFC,0x01}, +{0xF02A,0xF2,0x01}, +{0xF02B,0x9B,0x01}, +{0xF02C,0xD3,0x01}, +{0xF02D,0x94,0x01}, +{0xF02E,0xC5,0x01}, +{0xF02F,0x25,0x01}, +{0xF030,0x0A,0x01}, +{0xF031,0x01,0x01}, +{0xF032,0x48,0x01}, +{0xF033,0x43,0x01}, +{0xF034,0x66,0x01}, +{0xF035,0x92,0x01}, +{0xF036,0x96,0x01}, +{0xF037,0xD7,0x01}, +{0xF038,0xA0,0x01}, +{0xF039,0xE6,0x01}, +{0xF03A,0x2C,0x01}, +{0xF03B,0x2F,0x01}, +{0xF03C,0x51,0x01}, +{0xF03D,0x48,0x01}, +{0xF03E,0x40,0x01}, +{0xF03F,0x1E,0x01}, +{0xF040,0x42,0x01}, +{0xF041,0x93,0x01}, +{0xF042,0xB5,0x01}, +{0xF043,0xCC,0x01}, +{0xF044,0x46,0x01}, +{0xF045,0x37,0x01}, +{0xF046,0x7C,0x01}, +{0xF047,0x29,0x01}, +{0xF048,0x8A,0x01}, +{0xF049,0x48,0x01}, +{0xF04A,0x32,0x01}, +{0xF04B,0x72,0x01}, +{0xF04C,0x12,0x01}, +{0xF04D,0xA5,0x01}, +{0xF04E,0x00,0x01}, +{0xF04F,0xA6,0x01}, +{0xF050,0x38,0x01}, +{0xF051,0xD7,0x01}, +{0xF052,0x01,0x01}, +{0xF053,0x0D,0x01}, +{0xF054,0x5C,0x01}, +{0xF055,0xA2,0x01}, +{0xF056,0x82,0x01}, +{0xF057,0x94,0x01}, +{0xF058,0xAA,0x01}, +{0xF059,0xD8,0x01}, +{0xF05A,0x45,0x01}, +{0xF05B,0x35,0x01}, +{0xF05C,0xE5,0x01}, +{0xF05D,0xC9,0x01}, +{0xF05E,0xCF,0x01}, +{0xF05F,0x73,0x01}, +{0xF060,0x50,0x01}, +{0xF061,0x03,0x01}, +{0xF062,0x99,0x01}, +{0xF063,0xC3,0x01}, +{0xF064,0x4C,0x01}, +{0xF065,0xE6,0x01}, +{0xF066,0x35,0x01}, +{0xF067,0xD7,0x01}, +{0xF068,0x21,0x01}, +{0xF069,0x10,0x01}, +{0xF06A,0x84,0x01}, +{0xF06B,0xF2,0x01}, +{0xF06C,0x03,0x01}, +{0xF06D,0x9E,0x01}, +{0xF06E,0xE8,0x01}, +{0xF06F,0x2C,0x01}, +{0xF070,0xA7,0x01}, +{0xF071,0x3A,0x01}, +{0xF072,0xE8,0x01}, +{0xF073,0x11,0x01}, +{0xF074,0x90,0x01}, +{0xF075,0x87,0x01}, +{0xF076,0x18,0x01}, +{0xF077,0x94,0x01}, +{0xF078,0x21,0x01}, +{0xF079,0x09,0x01}, +{0xF07A,0x2D,0x01}, +{0xF07B,0x68,0x01}, +{0xF07C,0x41,0x01}, +{0xF07D,0x11,0x01}, +{0xF07E,0xDA,0x01}, +{0xF07F,0x10,0x01}, +{0xF080,0x88,0x01}, +{0xF081,0x2A,0x01}, +{0xF082,0x04,0x01}, +{0xF083,0x00,0x01}, +{0xF084,0x00,0x01}, +{0xF085,0x00,0x01}, +{0xF086,0x00,0x01}, +{0xF087,0x00,0x01}, +{0xF088,0xBE,0x01}, +{0xF089,0x51,0x01}, +{0xF08A,0x4E,0x01}, +{0xF08B,0x6F,0x01}, +{0xF08C,0x6C,0x01}, +{0xF08D,0x43,0x01}, +{0xF08E,0x1B,0x01}, +{0xF08F,0xDA,0x01}, +{0xF090,0xEC,0x01}, +{0xF091,0x46,0x01}, +{0xF092,0x38,0x01}, +{0xF093,0xBB,0x01}, +{0xF094,0xC1,0x01}, +{0xF095,0xCD,0x01}, +{0xF096,0x69,0x01}, +{0xF097,0x26,0x01}, +{0xF098,0x93,0x01}, +{0xF099,0x98,0x01}, +{0xF09A,0xC1,0x01}, +{0xF09B,0x20,0x01}, +{0xF09C,0x26,0x01}, +{0xF09D,0x32,0x01}, +{0xF09E,0xA5,0x01}, +{0xF09F,0xB1,0x01}, +{0xF0A0,0x8D,0x01}, +{0xF0A1,0x67,0x01}, +{0xF0A2,0x0E,0x01}, +{0xF0A3,0x23,0x01}, +{0xF0A4,0x97,0x01}, +{0xF0A5,0xB0,0x01}, +{0xF0A6,0x6C,0x01}, +{0xF0A7,0x25,0x01}, +{0xF0A8,0x2C,0x01}, +{0xF0A9,0x71,0x01}, +{0xF0AA,0x41,0x01}, +{0xF0AB,0x0C,0x01}, +{0xF0AC,0x69,0x01}, +{0xF0AD,0x14,0x01}, +{0xF0AE,0xB3,0x01}, +{0xF0AF,0x96,0x01}, +{0xF0B0,0xA6,0x01}, +{0xF0B1,0xE8,0x01}, +{0xF0B2,0x64,0x01}, +{0xF0B3,0x26,0x01}, +{0xF0B4,0x3A,0x01}, +{0xF0B5,0x79,0x01}, +{0xF0B6,0x4A,0x01}, +{0xF0B7,0x5B,0x01}, +{0xF0B8,0x18,0x01}, +{0xF0B9,0xA3,0x01}, +{0xF0BA,0x97,0x01}, +{0xF0BB,0xA9,0x01}, +{0xF0BC,0xBC,0x01}, +{0xF0BD,0x24,0x01}, +{0xF0BE,0x23,0x01}, +{0xF0BF,0x13,0x01}, +{0xF0C0,0xE1,0x01}, +{0xF0C1,0xC8,0x01}, +{0xF0C2,0x4C,0x01}, +{0xF0C3,0xAA,0x01}, +{0xF0C4,0xA2,0x01}, +{0xF0C5,0x97,0x01}, +{0xF0C6,0xB6,0x01}, +{0xF0C7,0x14,0x01}, +{0xF0C8,0x05,0x01}, +{0xF0C9,0x24,0x01}, +{0xF0CA,0x06,0x01}, +{0xF0CB,0x09,0x01}, +{0xF0CC,0xC8,0x01}, +{0xF0CD,0x42,0x01}, +{0xF0CE,0x48,0x01}, +{0xF0CF,0x82,0x01}, +{0xF0D0,0x14,0x01}, +{0xF0D1,0xB8,0x01}, +{0xF0D2,0xC0,0x01}, +{0xF0D3,0xE5,0x01}, +{0xF0D4,0x28,0x01}, +{0xF0D5,0x21,0x01}, +{0xF0D6,0x39,0x01}, +{0xF0D7,0x08,0x01}, +{0xF0D8,0x40,0x01}, +{0xF0D9,0x14,0x01}, +{0xF0DA,0x62,0x01}, +{0xF0DB,0x92,0x01}, +{0xF0DC,0xA4,0x01}, +{0xF0DD,0xC4,0x01}, +{0xF0DE,0x05,0x01}, +{0xF0DF,0x30,0x01}, +{0xF0E0,0x58,0x01}, +{0xF0E1,0xA1,0x01}, +{0xF0E2,0x49,0x01}, +{0xF0E3,0x46,0x01}, +{0xF0E4,0x22,0x01}, +{0xF0E5,0xB2,0x01}, +{0xF0E6,0x91,0x01}, +{0xF0E7,0x9A,0x01}, +{0xF0E8,0x58,0x01}, +{0xF0E9,0xA5,0x01}, +{0xF0EA,0x2F,0x01}, +{0xF0EB,0x96,0x01}, +{0xF0EC,0x99,0x01}, +{0xF0ED,0x8B,0x01}, +{0xF0EE,0x54,0x01}, +{0xF0EF,0x74,0x01}, +{0xF0F0,0x32,0x01}, +{0xF0F1,0x13,0x01}, +{0xF0F2,0x9D,0x01}, +{0xF0F3,0x38,0x01}, +{0xF0F4,0xC5,0x01}, +{0xF0F5,0x2D,0x01}, +{0xF0F6,0x90,0x01}, +{0xF0F7,0x59,0x01}, +{0xF0F8,0x4D,0x01}, +{0xF0F9,0x64,0x01}, +{0xF0FA,0xEE,0x01}, +{0xF0FB,0x62,0x01}, +{0xF0FC,0x16,0x01}, +{0xF0FD,0xAE,0x01}, +{0xF0FE,0x84,0x01}, +{0xF0FF,0x25,0x01}, +{0xF100,0x2E,0x01}, +{0xF101,0x8B,0x01}, +{0xF102,0x31,0x01}, +{0xF103,0xCD,0x01}, +{0xF104,0x6F,0x01}, +{0xF105,0x60,0x01}, +{0xF106,0xC3,0x01}, +{0xF107,0x19,0x01}, +{0xF108,0xC7,0x01}, +{0xF109,0x14,0x01}, +{0xF10A,0x26,0x01}, +{0xF10B,0x31,0x01}, +{0xF10C,0x97,0x01}, +{0xF10D,0x41,0x01}, +{0xF10E,0x8D,0x01}, +{0xF10F,0x6D,0x01}, +{0xF110,0x86,0x01}, +{0xF111,0xE3,0x01}, +{0xF112,0x9C,0x01}, +{0xF113,0xE2,0x01}, +{0xF114,0xD8,0x01}, +{0xF115,0x06,0x01}, +{0xF116,0x36,0x01}, +{0xF117,0xB5,0x01}, +{0xF118,0xE9,0x01}, +{0xF119,0x4D,0x01}, +{0xF11A,0x70,0x01}, +{0xF11B,0x68,0x01}, +{0xF11C,0x03,0x01}, +{0xF11D,0x00,0x01}, +{0xF11E,0x00,0x01}, +{0xF11F,0x00,0x01}, +{0xF120,0x00,0x01}, +{0xF121,0x00,0x01}, + + +//SHD TH +{0x6C32,0x1964,0x02}, // SHD_INP_TH_HB_H_R2 +{0x6C34,0x18CE,0x02}, // SHD_INP_TH_HB_L_R2 +{0x6C36,0x10CC,0x02}, // SHD_INP_TH_LB_H_R2 +{0x6C38,0x1004,0x02}, // SHD_INP_TH_LB_L_R2 +{0x6C3C,0x10CC,0x02}, // SHD_INP_TH_HB_H_RB +{0x6C3E,0x1004,0x02}, // SHD_INP_TH_HB_L_RB +{0x6C40,0x0000,0x02}, // SHD_INP_TH_LB_H_RB +{0x6C42,0x0000,0x02}, // SHD_INP_TH_LB_L_RB + +//PreWB_offset (for SHD2) +{0x6828,0x0013,0x02}, // SHD_PRER_OFFSET_R2 : +//PreWB_offset (for SHD3) +{0x682C,0x000C,0x02}, // SHD_PRER_OFFSET_RB : +{0x6830,0xFFFF,0x02}, // SHD_PREB_OFFSET_RB : + +// CXC/SHD EN +{0x01BC,0x57,0x01}, // CXC ON SHD ON INP ON GAIN OFF +}; + +static const isx012_regset_t ISX012_Shading_1[] = +{ +{0x01BC,0x50,0x01}, // CXC OFF SHD OFF +{0xEB00,0x8282,0x02}, //valid_code +{0xEB02,0xFE,0x01}, +{0xEB03,0x84,0x01}, +{0xEB04,0x3F,0x01}, +{0xEB05,0x01,0x01}, +{0xEB06,0x50,0x01}, +{0xEB07,0x08,0x01}, +{0xEB08,0x14,0x01}, +{0xEB09,0xFF,0x01}, +{0xEB0A,0x45,0x01}, +{0xEB0B,0x80,0x01}, +{0xEB0C,0x01,0x01}, +{0xEB0D,0x68,0x01}, +{0xEB0E,0x04,0x01}, +{0xEB0F,0x1A,0x01}, +{0xEB10,0x81,0x01}, +{0xEB11,0x86,0x01}, +{0xEB12,0x3F,0x01}, +{0xEB13,0xE1,0x01}, +{0xEB14,0x4F,0x01}, +{0xEB15,0x00,0x01}, +{0xEB16,0x14,0x01}, +{0xEB17,0x02,0x01}, +{0xEB18,0xC5,0x01}, +{0xEB19,0x7F,0x01}, +{0xEB1A,0x11,0x01}, +{0xEB1B,0x60,0x01}, +{0xEB1C,0x00,0x01}, +{0xEB1D,0x1A,0x01}, +{0xEB1E,0x81,0x01}, +{0xEB1F,0x46,0x01}, +{0xEB20,0xA0,0x01}, +{0xEB21,0x01,0x01}, +{0xEB22,0x48,0x01}, +{0xEB23,0x00,0x01}, +{0xEB24,0x12,0x01}, +{0xEB25,0x81,0x01}, +{0xEB26,0x05,0x01}, +{0xEB27,0x20,0x01}, +{0xEB28,0xF1,0x01}, +{0xEB29,0x4F,0x01}, +{0xEB2A,0x00,0x01}, +{0xEB2B,0x14,0x01}, +{0xEB2C,0x82,0x01}, +{0xEB2D,0x85,0x01}, +{0xEB2E,0x80,0x01}, +{0xEB2F,0x21,0x01}, +{0xEB30,0x60,0x01}, +{0xEB31,0x04,0x01}, +{0xEB32,0x12,0x01}, +{0xEB33,0x81,0x01}, +{0xEB34,0x84,0x01}, +{0xEB35,0xE0,0x01}, +{0xEB36,0x00,0x01}, +{0xEB37,0x28,0x01}, +{0xEB38,0x04,0x01}, +{0xEB39,0x0C,0x01}, +{0xEB3A,0x82,0x01}, +{0xEB3B,0x43,0x01}, +{0xEB3C,0x20,0x01}, +{0xEB3D,0x11,0x01}, +{0xEB3E,0x68,0x01}, +{0xEB3F,0x04,0x01}, +{0xEB40,0x1A,0x01}, +{0xEB41,0x82,0x01}, +{0xEB42,0x83,0x01}, +{0xEB43,0xE0,0x01}, +{0xEB44,0x00,0x01}, +{0xEB45,0x20,0x01}, +{0xEB46,0x00,0x01}, +{0xEB47,0x06,0x01}, +{0xEB48,0xFF,0x01}, +{0xEB49,0x41,0x01}, +{0xEB4A,0x80,0x01}, +{0xEB4B,0x10,0x01}, +{0xEB4C,0x30,0x01}, +{0xEB4D,0x08,0x01}, +{0xEB4E,0x14,0x01}, +{0xEB4F,0x02,0x01}, +{0xEB50,0x45,0x01}, +{0xEB51,0xC0,0x01}, +{0xEB52,0x10,0x01}, +{0xEB53,0x30,0x01}, +{0xEB54,0x04,0x01}, +{0xEB55,0x04,0x01}, +{0xEB56,0x01,0x01}, +{0xEB57,0xC0,0x01}, +{0xEB58,0x3F,0x01}, +{0xEB59,0x10,0x01}, +{0xEB5A,0x10,0x01}, +{0xEB5B,0x04,0x01}, +{0xEB5C,0x0A,0x01}, +{0xEB5D,0x80,0x01}, +{0xEB5E,0x03,0x01}, +{0xEB5F,0xE0,0x01}, +{0xEB60,0x10,0x01}, +{0xEB61,0x28,0x01}, +{0xEB62,0x04,0x01}, +{0xEB63,0x0A,0x01}, +{0xEB64,0x81,0x01}, +{0xEB65,0x01,0x01}, +{0xEB66,0x00,0x01}, +{0xEB67,0x10,0x01}, +{0xEB68,0x00,0x01}, +{0xEB69,0x04,0x01}, +{0xEB6A,0x04,0x01}, +{0xEB6B,0x01,0x01}, +{0xEB6C,0x42,0x01}, +{0xEB6D,0xE0,0x01}, +{0xEB6E,0x10,0x01}, +{0xEB6F,0x38,0x01}, +{0xEB70,0xFC,0x01}, +{0xEB71,0x0D,0x01}, +{0xEB72,0x7F,0x01}, +{0xEB73,0x43,0x01}, +{0xEB74,0x60,0x01}, +{0xEB75,0x00,0x01}, +{0xEB76,0x08,0x01}, +{0xEB77,0x08,0x01}, +{0xEB78,0x02,0x01}, +{0xEB79,0x81,0x01}, +{0xEB7A,0x41,0x01}, +{0xEB7B,0x80,0x01}, +{0xEB7C,0x10,0x01}, +{0xEB7D,0x30,0x01}, +{0xEB7E,0x04,0x01}, +{0xEB7F,0x0C,0x01}, +{0xEB80,0x01,0x01}, +{0xEB81,0x43,0x01}, +{0xEB82,0xC0,0x01}, +{0xEB83,0x20,0x01}, +{0xEB84,0x28,0x01}, +{0xEB85,0x08,0x01}, +{0xEB86,0x06,0x01}, +{0xEB87,0x02,0x01}, +{0xEB88,0xC2,0x01}, +{0xEB89,0xA0,0x01}, +{0xEB8A,0x30,0x01}, +{0xEB8B,0x30,0x01}, +{0xEB8C,0x0C,0x01}, +{0xEB8D,0x12,0x01}, +{0xEB8E,0x83,0x01}, +{0xEB8F,0x84,0x01}, +{0xEB90,0x00,0x01}, +{0xEB91,0x21,0x01}, +{0xEB92,0x40,0x01}, +{0xEB93,0x0C,0x01}, +{0xEB94,0x0C,0x01}, +{0xEB95,0x82,0x01}, +{0xEB96,0x03,0x01}, +{0xEB97,0xC1,0x01}, +{0xEB98,0x40,0x01}, +{0xEB99,0x40,0x01}, +{0xEB9A,0x08,0x01}, +{0xEB9B,0x10,0x01}, +{0xEB9C,0x03,0x01}, +{0xEB9D,0xC4,0x01}, +{0xEB9E,0x00,0x01}, +{0xEB9F,0x21,0x01}, +{0xEBA0,0x38,0x01}, +{0xEBA1,0x08,0x01}, +{0xEBA2,0x0E,0x01}, +{0xEBA3,0x82,0x01}, +{0xEBA4,0xC3,0x01}, +{0xEBA5,0x20,0x01}, +{0xEBA6,0x41,0x01}, +{0xEBA7,0x48,0x01}, +{0xEBA8,0x00,0x01}, +{0xEBA9,0x14,0x01}, +{0xEBAA,0x83,0x01}, +{0xEBAB,0x44,0x01}, +{0xEBAC,0x20,0x01}, +{0xEBAD,0x11,0x01}, +{0xEBAE,0x48,0x01}, +{0xEBAF,0x08,0x01}, +{0xEBB0,0x0E,0x01}, +{0xEBB1,0x82,0x01}, +{0xEBB2,0x83,0x01}, +{0xEBB3,0xE0,0x01}, +{0xEBB4,0x30,0x01}, +{0xEBB5,0x48,0x01}, +{0xEBB6,0x10,0x01}, +{0xEBB7,0x12,0x01}, +{0xEBB8,0x00,0x01}, +{0xEBB9,0xC5,0x01}, +{0xEBBA,0x20,0x01}, +{0xEBBB,0x11,0x01}, +{0xEBBC,0x48,0x01}, +{0xEBBD,0x04,0x01}, +{0xEBBE,0x12,0x01}, +{0xEBBF,0x04,0x01}, +{0xEBC0,0x3B,0x01}, +{0xEBC1,0xC1,0x01}, +{0xEBC2,0x1E,0x01}, +{0xEBC3,0xC8,0x01}, +{0xEBC4,0x0F,0x01}, +{0xEBC5,0xF8,0x01}, +{0xEBC6,0x02,0x01}, +{0xEBC7,0xBB,0x01}, +{0xEBC8,0x60,0x01}, +{0xEBC9,0x0F,0x01}, +{0xEBCA,0xB8,0x01}, +{0xEBCB,0x0F,0x01}, +{0xEBCC,0xEA,0x01}, +{0xEBCD,0x83,0x01}, +{0xEBCE,0x3A,0x01}, +{0xEBCF,0xC1,0x01}, +{0xEBD0,0x4E,0x01}, +{0xEBD1,0xB0,0x01}, +{0xEBD2,0x07,0x01}, +{0xEBD3,0xF2,0x01}, +{0xEBD4,0x03,0x01}, +{0xEBD5,0xBE,0x01}, +{0xEBD6,0xC0,0x01}, +{0xEBD7,0x2E,0x01}, +{0xEBD8,0xD8,0x01}, +{0xEBD9,0x03,0x01}, +{0xEBDA,0xEE,0x01}, +{0xEBDB,0x83,0x01}, +{0xEBDC,0xFA,0x01}, +{0xEBDD,0xA0,0x01}, +{0xEBDE,0x2E,0x01}, +{0xEBDF,0xB0,0x01}, +{0xEBE0,0x0B,0x01}, +{0xEBE1,0xEC,0x01}, +{0xEBE2,0x05,0x01}, +{0xEBE3,0xBD,0x01}, +{0xEBE4,0x60,0x01}, +{0xEBE5,0x2F,0x01}, +{0xEBE6,0xD0,0x01}, +{0xEBE7,0x07,0x01}, +{0xEBE8,0xEC,0x01}, +{0xEBE9,0x02,0x01}, +{0xEBEA,0xBC,0x01}, +{0xEBEB,0x40,0x01}, +{0xEBEC,0x2F,0x01}, +{0xEBED,0xD0,0x01}, +{0xEBEE,0x13,0x01}, +{0xEBEF,0xEE,0x01}, +{0xEBF0,0x84,0x01}, +{0xEBF1,0xBB,0x01}, +{0xEBF2,0x00,0x01}, +{0xEBF3,0x1F,0x01}, +{0xEBF4,0xC8,0x01}, +{0xEBF5,0xFF,0x01}, +{0xEBF6,0xEF,0x01}, +{0xEBF7,0x00,0x01}, +{0xEBF8,0x7D,0x01}, +{0xEBF9,0x60,0x01}, +{0xEBFA,0x2F,0x01}, +{0xEBFB,0xD0,0x01}, +{0xEBFC,0x0B,0x01}, +{0xEBFD,0xF4,0x01}, +{0xEBFE,0x85,0x01}, +{0xEBFF,0x7D,0x01}, +{0xEC00,0x61,0x01}, +{0xEC01,0x0F,0x01}, +{0xEC02,0xC0,0x01}, +{0xEC03,0xFF,0x01}, +{0xEC04,0xF7,0x01}, +{0xEC05,0x7F,0x01}, +{0xEC06,0x3D,0x01}, +{0xEC07,0x40,0x01}, +{0xEC08,0xFF,0x01}, +{0xEC09,0xDF,0x01}, +{0xEC0A,0x07,0x01}, +{0xEC0B,0xFA,0x01}, +{0xEC0C,0x81,0x01}, +{0xEC0D,0x3E,0x01}, +{0xEC0E,0x61,0x01}, +{0xEC0F,0x4F,0x01}, +{0xEC10,0xD8,0x01}, +{0xEC11,0x0B,0x01}, +{0xEC12,0xFC,0x01}, +{0xEC13,0xFE,0x01}, +{0xEC14,0x3D,0x01}, +{0xEC15,0xC0,0x01}, +{0xEC16,0xFF,0x01}, +{0xEC17,0xFF,0x01}, +{0xEC18,0x03,0x01}, +{0xEC19,0xFC,0x01}, +{0xEC1A,0x82,0x01}, +{0xEC1B,0xBE,0x01}, +{0xEC1C,0xA0,0x01}, +{0xEC1D,0x6F,0x01}, +{0xEC1E,0xF8,0x01}, +{0xEC1F,0x1B,0x01}, +{0xEC20,0xFE,0x01}, +{0xEC21,0x83,0x01}, +{0xEC22,0xBF,0x01}, +{0xEC23,0xE0,0x01}, +{0xEC24,0x0F,0x01}, +{0xEC25,0x10,0x01}, +{0xEC26,0x00,0x01}, +{0xEC27,0x00,0x01}, +{0xEC28,0x82,0x01}, +{0xEC29,0xC0,0x01}, +{0xEC2A,0x60,0x01}, +{0xEC2B,0x30,0x01}, +{0xEC2C,0x18,0x01}, +{0xEC2D,0x20,0x01}, +{0xEC2E,0x04,0x01}, +{0xEC2F,0x08,0x01}, +{0xEC30,0x81,0x01}, +{0xEC31,0x21,0x01}, +{0xEC32,0x30,0x01}, +{0xEC33,0x08,0x01}, +{0xEC34,0x08,0x01}, +{0xEC35,0x08,0x01}, +{0xEC36,0x82,0x01}, +{0xEC37,0x01,0x01}, +{0xEC38,0x81,0x01}, +{0xEC39,0x50,0x01}, +{0xEC3A,0x08,0x01}, +{0xEC3B,0x14,0x01}, +{0xEC3C,0x02,0x01}, +{0xEC3D,0x09,0x01}, +{0xEC3E,0x41,0x01}, +{0xEC3F,0x42,0x01}, +{0xEC40,0x70,0x01}, +{0xEC41,0x20,0x01}, +{0xEC42,0x0C,0x01}, +{0xEC43,0x06,0x01}, +{0xEC44,0x84,0x01}, +{0xEC45,0x42,0x01}, +{0xEC46,0xE1,0x01}, +{0xEC47,0x40,0x01}, +{0xEC48,0x38,0x01}, +{0xEC49,0x1C,0x01}, +{0xEC4A,0x0C,0x01}, +{0xEC4B,0x07,0x01}, +{0xEC4C,0x03,0x01}, +{0xEC4D,0xA2,0x01}, +{0xEC4E,0x80,0x01}, +{0xEC4F,0x28,0x01}, +{0xEC50,0x18,0x01}, +{0xEC51,0x10,0x01}, +{0xEC52,0x87,0x01}, +{0xEC53,0x43,0x01}, +{0xEC54,0x61,0x01}, +{0xEC55,0x41,0x01}, +{0xEC56,0x48,0x01}, +{0xEC57,0x14,0x01}, +{0xEC58,0x10,0x01}, +{0xEC59,0x07,0x01}, +{0xEC5A,0xC2,0x01}, +{0xEC5B,0x81,0x01}, +{0xEC5C,0x80,0x01}, +{0xEC5D,0x30,0x01}, +{0xEC5E,0x20,0x01}, +{0xEC5F,0x0C,0x01}, +{0xEC60,0x87,0x01}, +{0xEC61,0x83,0x01}, +{0xEC62,0xC1,0x01}, +{0xEC63,0x40,0x01}, +{0xEC64,0x38,0x01}, +{0xEC65,0x14,0x01}, +{0xEC66,0x0A,0x01}, +{0xEC67,0x07,0x01}, +{0xEC68,0xC3,0x01}, +{0xEC69,0xC1,0x01}, +{0xEC6A,0x70,0x01}, +{0xEC6B,0x30,0x01}, +{0xEC6C,0x20,0x01}, +{0xEC6D,0x0C,0x01}, +{0xEC6E,0x08,0x01}, +{0xEC6F,0xC3,0x01}, +{0xEC70,0xE1,0x01}, +{0xEC71,0x60,0x01}, +{0xEC72,0x30,0x01}, +{0xEC73,0x10,0x01}, +{0xEC74,0x0E,0x01}, +{0xEC75,0x85,0x01}, +{0xEC76,0xC2,0x01}, +{0xEC77,0xC1,0x01}, +{0xEC78,0x70,0x01}, +{0xEC79,0x30,0x01}, +{0xEC7A,0x1C,0x01}, +{0xEC7B,0x0C,0x01}, + +//SHD1(from CO1) +{0xED02,0xE6,0x01}, +{0xED03,0x61,0x01}, +{0xED04,0x92,0x01}, +{0xED05,0x7C,0x01}, +{0xED06,0xBE,0x01}, +{0xED07,0xB4,0x01}, +{0xED08,0x9E,0x01}, +{0xED09,0x2C,0x01}, +{0xED0A,0x75,0x01}, +{0xED0B,0x47,0x01}, +{0xED0C,0x49,0x01}, +{0xED0D,0xD7,0x01}, +{0xED0E,0x61,0x01}, +{0xED0F,0x12,0x01}, +{0xED10,0x76,0x01}, +{0xED11,0xA8,0x01}, +{0xED12,0x34,0x01}, +{0xED13,0x1E,0x01}, +{0xED14,0x31,0x01}, +{0xED15,0xA1,0x01}, +{0xED16,0xC7,0x01}, +{0xED17,0x4C,0x01}, +{0xED18,0xDE,0x01}, +{0xED19,0xC1,0x01}, +{0xED1A,0xD2,0x01}, +{0xED1B,0x77,0x01}, +{0xED1C,0x76,0x01}, +{0xED1D,0x94,0x01}, +{0xED1E,0x9C,0x01}, +{0xED1F,0x10,0x01}, +{0xED20,0xC9,0x01}, +{0xED21,0xC6,0x01}, +{0xED22,0x40,0x01}, +{0xED23,0xA2,0x01}, +{0xED24,0x99,0x01}, +{0xED25,0x8F,0x01}, +{0xED26,0x66,0x01}, +{0xED27,0xDC,0x01}, +{0xED28,0xF3,0x01}, +{0xED29,0x19,0x01}, +{0xED2A,0xFC,0x01}, +{0xED2B,0xB0,0x01}, +{0xED2C,0xA6,0x01}, +{0xED2D,0x41,0x01}, +{0xED2E,0xC1,0x01}, +{0xED2F,0x49,0x01}, +{0xED30,0x91,0x01}, +{0xED31,0x75,0x01}, +{0xED32,0x8C,0x01}, +{0xED33,0x74,0x01}, +{0xED34,0x1C,0x01}, +{0xED35,0x0B,0x01}, +{0xED36,0x91,0x01}, +{0xED37,0x86,0x01}, +{0xED38,0x3D,0x01}, +{0xED39,0x87,0x01}, +{0xED3A,0x39,0x01}, +{0xED3B,0x4E,0x01}, +{0xED3C,0x5C,0x01}, +{0xED3D,0x50,0x01}, +{0xED3E,0x83,0x01}, +{0xED3F,0x16,0x01}, +{0xED40,0xCF,0x01}, +{0xED41,0xBC,0x01}, +{0xED42,0x45,0x01}, +{0xED43,0x35,0x01}, +{0xED44,0x83,0x01}, +{0xED45,0x41,0x01}, +{0xED46,0xCE,0x01}, +{0xED47,0x67,0x01}, +{0xED48,0xE8,0x01}, +{0xED49,0x33,0x01}, +{0xED4A,0x1C,0x01}, +{0xED4B,0x16,0x01}, +{0xED4C,0xC1,0x01}, +{0xED4D,0x86,0x01}, +{0xED4E,0x3E,0x01}, +{0xED4F,0x83,0x01}, +{0xED50,0xC1,0x01}, +{0xED51,0x0D,0x01}, +{0xED52,0x57,0x01}, +{0xED53,0x02,0x01}, +{0xED54,0x23,0x01}, +{0xED55,0x14,0x01}, +{0xED56,0xAE,0x01}, +{0xED57,0xE4,0x01}, +{0xED58,0x44,0x01}, +{0xED59,0x2A,0x01}, +{0xED5A,0x43,0x01}, +{0xED5B,0xF9,0x01}, +{0xED5C,0xCA,0x01}, +{0xED5D,0x56,0x01}, +{0xED5E,0x0C,0x01}, +{0xED5F,0x03,0x01}, +{0xED60,0x98,0x01}, +{0xED61,0xE2,0x01}, +{0xED62,0xA8,0x01}, +{0xED63,0x26,0x01}, +{0xED64,0x41,0x01}, +{0xED65,0x9E,0x01}, +{0xED66,0xC1,0x01}, +{0xED67,0xCE,0x01}, +{0xED68,0x59,0x01}, +{0xED69,0x1C,0x01}, +{0xED6A,0xB3,0x01}, +{0xED6B,0x93,0x01}, +{0xED6C,0xA7,0x01}, +{0xED6D,0x74,0x01}, +{0xED6E,0x04,0x01}, +{0xED6F,0x25,0x01}, +{0xED70,0x13,0x01}, +{0xED71,0xD9,0x01}, +{0xED72,0xC8,0x01}, +{0xED73,0x47,0x01}, +{0xED74,0x54,0x01}, +{0xED75,0xD2,0x01}, +{0xED76,0x93,0x01}, +{0xED77,0xAA,0x01}, +{0xED78,0x98,0x01}, +{0xED79,0xE5,0x01}, +{0xED7A,0x32,0x01}, +{0xED7B,0x9A,0x01}, +{0xED7C,0x29,0x01}, +{0xED7D,0xCF,0x01}, +{0xED7E,0x64,0x01}, +{0xED7F,0x8E,0x01}, +{0xED80,0x73,0x01}, +{0xED81,0x95,0x01}, +{0xED82,0xBB,0x01}, +{0xED83,0xA4,0x01}, +{0xED84,0xA4,0x01}, +{0xED85,0x26,0x01}, +{0xED86,0x0A,0x01}, +{0xED87,0x59,0x01}, +{0xED88,0x08,0x01}, +{0xED89,0x40,0x01}, +{0xED8A,0x00,0x01}, +{0xED8B,0xC2,0x01}, +{0xED8C,0x10,0x01}, +{0xED8D,0x88,0x01}, +{0xED8E,0xB0,0x01}, +{0xED8F,0x84,0x01}, +{0xED90,0x27,0x01}, +{0xED91,0x59,0x01}, +{0xED92,0xF1,0x01}, +{0xED93,0x0B,0x01}, +{0xED94,0x64,0x01}, +{0xED95,0xA2,0x01}, +{0xED96,0x43,0x01}, +{0xED97,0x99,0x01}, +{0xED98,0xE4,0x01}, +{0xED99,0x68,0x01}, +{0xED9A,0x25,0x01}, +{0xED9B,0x2F,0x01}, +{0xED9C,0x2B,0x01}, +{0xED9D,0xB1,0x01}, +{0xED9E,0xC9,0x01}, +{0xED9F,0x42,0x01}, +{0xEDA0,0x18,0x01}, +{0xEDA1,0x32,0x01}, +{0xEDA2,0x90,0x01}, +{0xEDA3,0x80,0x01}, +{0xEDA4,0x3C,0x01}, +{0xEDA5,0x24,0x01}, +{0xEDA6,0x22,0x01}, +{0xEDA7,0x2F,0x01}, +{0xEDA8,0xF1,0x01}, +{0xEDA9,0x09,0x01}, +{0xEDAA,0x57,0x01}, +{0xEDAB,0x00,0x01}, +{0xEDAC,0x53,0x01}, +{0xEDAD,0x99,0x01}, +{0xEDAE,0xEA,0x01}, +{0xEDAF,0x90,0x01}, +{0xEDB0,0xC6,0x01}, +{0xEDB1,0x3B,0x01}, +{0xEDB2,0x6D,0x01}, +{0xEDB3,0x99,0x01}, +{0xEDB4,0x4C,0x01}, +{0xEDB5,0x50,0x01}, +{0xEDB6,0xA4,0x01}, +{0xEDB7,0x32,0x01}, +{0xEDB8,0x12,0x01}, +{0xEDB9,0x94,0x01}, +{0xEDBA,0x64,0x01}, +{0xEDBB,0xA4,0x01}, +{0xEDBC,0x23,0x01}, +{0xEDBD,0x25,0x01}, +{0xEDBE,0x71,0x01}, +{0xEDBF,0x49,0x01}, +{0xEDC0,0x51,0x01}, +{0xEDC1,0xB2,0x01}, +{0xEDC2,0x02,0x01}, +{0xEDC3,0x17,0x01}, +{0xEDC4,0xCD,0x01}, +{0xEDC5,0x98,0x01}, +{0xEDC6,0x86,0x01}, +{0xEDC7,0x3D,0x01}, +{0xEDC8,0xBC,0x01}, +{0xEDC9,0x01,0x01}, +{0xEDCA,0x50,0x01}, +{0xEDCB,0x63,0x01}, +{0xEDCC,0x80,0x01}, +{0xEDCD,0x63,0x01}, +{0xEDCE,0x16,0x01}, +{0xEDCF,0xC3,0x01}, +{0xEDD0,0x2C,0x01}, +{0xEDD1,0x25,0x01}, +{0xEDD2,0x2C,0x01}, +{0xEDD3,0x43,0x01}, +{0xEDD4,0xB1,0x01}, +{0xEDD5,0x4A,0x01}, +{0xEDD6,0x53,0x01}, +{0xEDD7,0xCC,0x01}, +{0xEDD8,0x82,0x01}, +{0xEDD9,0x96,0x01}, +{0xEDDA,0xC7,0x01}, +{0xEDDB,0x40,0x01}, +{0xEDDC,0xA6,0x01}, +{0xEDDD,0x39,0x01}, +{0xEDDE,0xBE,0x01}, +{0xEDDF,0x91,0x01}, +{0xEDE0,0xD0,0x01}, +{0xEDE1,0x75,0x01}, +{0xEDE2,0x54,0x01}, +{0xEDE3,0x34,0x01}, +{0xEDE4,0x1B,0x01}, +{0xEDE5,0xFC,0x01}, +{0xEDE6,0x4C,0x01}, +{0xEDE7,0x46,0x01}, +{0xEDE8,0x39,0x01}, +{0xEDE9,0x7D,0x01}, +{0xEDEA,0x71,0x01}, +{0xEDEB,0x8D,0x01}, +{0xEDEC,0x5D,0x01}, +{0xEDED,0x46,0x01}, +{0xEDEE,0xE3,0x01}, +{0xEDEF,0x17,0x01}, +{0xEDF0,0xD9,0x01}, +{0xEDF1,0x50,0x01}, +{0xEDF2,0x86,0x01}, +{0xEDF3,0x3A,0x01}, +{0xEDF4,0xB3,0x01}, +{0xEDF5,0x09,0x01}, +{0xEDF6,0x50,0x01}, +{0xEDF7,0x76,0x01}, +{0xEDF8,0x6A,0x01}, +{0xEDF9,0xF4,0x01}, +{0xEDFA,0x1E,0x01}, +{0xEDFB,0x25,0x01}, +{0xEDFC,0x61,0x01}, +{0xEDFD,0x67,0x01}, +{0xEDFE,0x45,0x01}, +{0xEDFF,0xC0,0x01}, +{0xEE00,0x69,0x01}, +{0xEE01,0xD0,0x01}, +{0xEE02,0x6B,0x01}, +{0xEE03,0xF6,0x01}, +{0xEE04,0x93,0x01}, +{0xEE05,0x9A,0x01}, +{0xEE06,0xFA,0x01}, +{0xEE07,0xB8,0x01}, +{0xEE08,0x26,0x01}, +{0xEE09,0x40,0x01}, +{0xEE0A,0xC0,0x01}, +{0xEE0B,0xB9,0x01}, +{0xEE0C,0xD0,0x01}, +{0xEE0D,0x75,0x01}, +{0xEE0E,0x6E,0x01}, +{0xEE0F,0xE4,0x01}, +{0xEE10,0x9E,0x01}, +{0xEE11,0x2D,0x01}, +{0xEE12,0xE1,0x01}, +{0xEE13,0xA7,0x01}, +{0xEE14,0x49,0x01}, +{0xEE15,0xFD,0x01}, +{0xEE16,0xB9,0x01}, +{0xEE17,0x52,0x01}, +{0xEE18,0x7C,0x01}, +{0xEE19,0x98,0x01}, +{0xEE1A,0x64,0x01}, +{0xEE1B,0x1E,0x01}, +{0xEE1C,0x22,0x01}, +{0xEE1D,0x89,0x01}, +{0xEE1E,0xA7,0x01}, +{0xEE1F,0x48,0x01}, +{0xEE20,0xE4,0x01}, +{0xEE21,0x49,0x01}, +{0xEE22,0x12,0x01}, +{0xEE23,0x7D,0x01}, +{0xEE24,0xB4,0x01}, +{0xEE25,0xB4,0x01}, +{0xEE26,0x1F,0x01}, +{0xEE27,0x31,0x01}, +{0xEE28,0xC5,0x01}, +{0xEE29,0x47,0x01}, +{0xEE2A,0x4B,0x01}, +{0xEE2B,0xC2,0x01}, +{0xEE2C,0x19,0x01}, +{0xEE2D,0x0F,0x01}, +{0xEE2E,0x73,0x01}, +{0xEE2F,0xE2,0x01}, +{0xEE30,0x13,0x01}, +{0xEE31,0x1C,0x01}, +{0xEE32,0xF5,0x01}, +{0xEE33,0xE0,0x01}, +{0xEE34,0xC6,0x01}, +{0xEE35,0x3B,0x01}, +{0xEE36,0xB6,0x01}, +{0xEE37,0xB1,0x01}, +{0xEE38,0xCE,0x01}, +{0xEE39,0x6D,0x01}, +{0xEE3A,0xB8,0x01}, +{0xEE3B,0xF3,0x01}, +{0xEE3C,0x9B,0x01}, +{0xEE3D,0xF2,0x01}, +{0xEE3E,0x18,0x01}, +{0xEE3F,0x27,0x01}, +{0xEE40,0x3D,0x01}, +{0xEE41,0xBF,0x01}, +{0xEE42,0xE9,0x01}, +{0xEE43,0xCE,0x01}, +{0xEE44,0x6E,0x01}, +{0xEE45,0xBA,0x01}, +{0xEE46,0x83,0x01}, +{0xEE47,0x9A,0x01}, +{0xEE48,0xE4,0x01}, +{0xEE49,0x50,0x01}, +{0xEE4A,0x66,0x01}, +{0xEE4B,0x36,0x01}, +{0xEE4C,0x8A,0x01}, +{0xEE4D,0x29,0x01}, +{0xEE4E,0x4D,0x01}, +{0xEE4F,0x61,0x01}, +{0xEE50,0x3A,0x01}, +{0xEE51,0xA3,0x01}, +{0xEE52,0x18,0x01}, +{0xEE53,0xD2,0x01}, +{0xEE54,0x50,0x01}, +{0xEE55,0x26,0x01}, +{0xEE56,0x36,0x01}, +{0xEE57,0xA8,0x01}, +{0xEE58,0x21,0x01}, +{0xEE59,0xCE,0x01}, +{0xEE5A,0x6E,0x01}, +{0xEE5B,0xB2,0x01}, +{0xEE5C,0x03,0x01}, +{0xEE5D,0x9A,0x01}, +{0xEE5E,0xE0,0x01}, +{0xEE5F,0x1C,0x01}, +{0xEE60,0x46,0x01}, +{0xEE61,0x34,0x01}, +{0xEE62,0x72,0x01}, +{0xEE63,0x41,0x01}, +{0xEE64,0x8C,0x01}, +{0xEE65,0x58,0x01}, +{0xEE66,0xE8,0x01}, +{0xEE67,0xC2,0x01}, +{0xEE68,0x95,0x01}, +{0xEE69,0xB5,0x01}, +{0xEE6A,0x88,0x01}, +{0xEE6B,0x65,0x01}, +{0xEE6C,0x2E,0x01}, +{0xEE6D,0x72,0x01}, +{0xEE6E,0x39,0x01}, +{0xEE6F,0x8C,0x01}, +{0xEE70,0x62,0x01}, +{0xEE71,0x48,0x01}, +{0xEE72,0x83,0x01}, +{0xEE73,0x1A,0x01}, +{0xEE74,0xE4,0x01}, +{0xEE75,0x28,0x01}, +{0xEE76,0x06,0x01}, +{0xEE77,0x35,0x01}, +{0xEE78,0x6A,0x01}, +{0xEE79,0xF9,0x01}, +{0xEE7A,0x4B,0x01}, +{0xEE7B,0x53,0x01}, +{0xEE7C,0xB8,0x01}, +{0xEE7D,0x92,0x01}, +{0xEE7E,0x13,0x01}, +{0xEE7F,0xA2,0x01}, +{0xEE80,0xCC,0x01}, +{0xEE81,0x64,0x01}, +{0xEE82,0x27,0x01}, +{0xEE83,0x3B,0x01}, +{0xEE84,0x29,0x01}, +{0xEE85,0x0A,0x01}, +{0xEE86,0x54,0x01}, +{0xEE87,0xBC,0x01}, +{0xEE88,0xF2,0x01}, +{0xEE89,0x96,0x01}, +{0xEE8A,0xC1,0x01}, +{0xEE8B,0x40,0x01}, +{0xEE8C,0xA6,0x01}, +{0xEE8D,0x35,0x01}, +{0xEE8E,0x7A,0x01}, +{0xEE8F,0xB1,0x01}, +{0xEE90,0x8C,0x01}, +{0xEE91,0x54,0x01}, +{0xEE92,0xC8,0x01}, +{0xEE93,0xF2,0x01}, +{0xEE94,0x92,0x01}, +{0xEE95,0x9D,0x01}, +{0xEE96,0x64,0x01}, +{0xEE97,0xE4,0x01}, +{0xEE98,0x23,0x01}, +{0xEE99,0x13,0x01}, +{0xEE9A,0xA9,0x01}, +{0xEE9B,0x48,0x01}, +{0xEE9C,0x47,0x01}, +{0xEE9D,0x40,0x01}, +{0xEE9E,0x42,0x01}, +{0xEE9F,0x13,0x01}, +{0xEEA0,0x9F,0x01}, +{0xEEA1,0x58,0x01}, +{0xEEA2,0xE5,0x01}, +{0xEEA3,0x2C,0x01}, +{0xEEA4,0x7F,0x01}, +{0xEEA5,0xD9,0x01}, +{0xEEA6,0x8C,0x01}, +{0xEEA7,0x5B,0x01}, +{0xEEA8,0x12,0x01}, +{0xEEA9,0x43,0x01}, +{0xEEAA,0x14,0x01}, +{0xEEAB,0xAA,0x01}, +{0xEEAC,0x80,0x01}, +{0xEEAD,0x04,0x01}, +{0xEEAE,0x25,0x01}, +{0xEEAF,0x06,0x01}, +{0xEEB0,0x51,0x01}, +{0xEEB1,0x08,0x01}, +{0xEEB2,0x40,0x01}, +{0xEEB3,0x00,0x01}, +{0xEEB4,0xB2,0x01}, +{0xEEB5,0x10,0x01}, +{0xEEB6,0x86,0x01}, +{0xEEB7,0x98,0x01}, +{0xEEB8,0x64,0x01}, +{0xEEB9,0x25,0x01}, +{0xEEBA,0x4A,0x01}, +{0xEEBB,0xB9,0x01}, +{0xEEBC,0x0A,0x01}, +{0xEEBD,0x5D,0x01}, +{0xEEBE,0x1C,0x01}, +{0xEEBF,0x13,0x01}, +{0xEEC0,0x97,0x01}, +{0xEEC1,0xC4,0x01}, +{0xEEC2,0x18,0x01}, +{0xEEC3,0x85,0x01}, +{0xEEC4,0x2A,0x01}, +{0xEEC5,0x21,0x01}, +{0xEEC6,0x41,0x01}, +{0xEEC7,0xC9,0x01}, +{0xEEC8,0x41,0x01}, +{0xEEC9,0x12,0x01}, +{0xEECA,0x02,0x01}, +{0xEECB,0x10,0x01}, +{0xEECC,0x80,0x01}, +{0xEECD,0x2C,0x01}, +{0xEECE,0x64,0x01}, +{0xEECF,0x21,0x01}, +{0xEED0,0x27,0x01}, +{0xEED1,0x61,0x01}, +{0xEED2,0xC9,0x01}, +{0xEED3,0x52,0x01}, +{0xEED4,0xB0,0x01}, +{0xEED5,0x42,0x01}, +{0xEED6,0x17,0x01}, +{0xEED7,0xC8,0x01}, +{0xEED8,0x04,0x01}, +{0xEED9,0xE6,0x01}, +{0xEEDA,0x32,0x01}, +{0xEEDB,0x58,0x01}, +{0xEEDC,0x29,0x01}, +{0xEEDD,0xCB,0x01}, +{0xEEDE,0x4C,0x01}, +{0xEEDF,0x74,0x01}, +{0xEEE0,0x92,0x01}, +{0xEEE1,0x91,0x01}, +{0xEEE2,0x8E,0x01}, +{0xEEE3,0x48,0x01}, +{0xEEE4,0x84,0x01}, +{0xEEE5,0x22,0x01}, +{0xEEE6,0x1D,0x01}, +{0xEEE7,0x01,0x01}, +{0xEEE8,0xC9,0x01}, +{0xEEE9,0x4D,0x01}, +{0xEEEA,0x7E,0x01}, +{0xEEEB,0x82,0x01}, +{0xEEEC,0x15,0x01}, +{0xEEED,0xB5,0x01}, +{0xEEEE,0x04,0x01}, +{0xEEEF,0xE6,0x01}, +{0xEEF0,0x33,0x01}, +{0xEEF1,0x99,0x01}, +{0xEEF2,0x69,0x01}, +{0xEEF3,0x0D,0x01}, +{0xEEF4,0x5D,0x01}, +{0xEEF5,0x06,0x01}, +{0xEEF6,0x33,0x01}, +{0xEEF7,0x15,0x01}, +{0xEEF8,0xAF,0x01}, +{0xEEF9,0xEC,0x01}, +{0xEEFA,0xA4,0x01}, +{0xEEFB,0x28,0x01}, +{0xEEFC,0x35,0x01}, +{0xEEFD,0xE9,0x01}, +{0xEEFE,0x09,0x01}, +{0xEEFF,0x4F,0x01}, +{0xEF00,0x8E,0x01}, +{0xEF01,0x02,0x01}, +{0xEF02,0x95,0x01}, +{0xEF03,0xB1,0x01}, +{0xEF04,0xC4,0x01}, +{0xEF05,0x25,0x01}, +{0xEF06,0x31,0x01}, +{0xEF07,0x94,0x01}, +{0xEF08,0xB1,0x01}, +{0xEF09,0x4D,0x01}, +{0xEF0A,0x6C,0x01}, +{0xEF0B,0x94,0x01}, +{0xEF0C,0x43,0x01}, +{0xEF0D,0x99,0x01}, +{0xEF0E,0xD4,0x01}, +{0xEF0F,0xEC,0x01}, +{0xEF10,0xC5,0x01}, +{0xEF11,0x31,0x01}, +{0xEF12,0x69,0x01}, +{0xEF13,0xC9,0x01}, +{0xEF14,0x0B,0x01}, +{0xEF15,0x58,0x01}, +{0xEF16,0xE6,0x01}, +{0xEF17,0x52,0x01}, +{0xEF18,0x16,0x01}, +{0xEF19,0xBE,0x01}, +{0xEF1A,0xD4,0x01}, +{0xEF1B,0x45,0x01}, +{0xEF1C,0x32,0x01}, +{0xEF1D,0x8E,0x01}, +{0xEF1E,0x79,0x01}, +{0xEF1F,0x4D,0x01}, +{0xEF20,0x6A,0x01}, +{0xEF21,0xA4,0x01}, +{0xEF22,0x83,0x01}, +{0xEF23,0x1C,0x01}, +{0xEF24,0xF2,0x01}, +{0xEF25,0xDC,0x01}, +{0xEF26,0x26,0x01}, +{0xEF27,0x3A,0x01}, +{0xEF28,0xA3,0x01}, +{0xEF29,0xE1,0x01}, +{0xEF2A,0x4D,0x01}, +{0xEF2B,0x65,0x01}, +{0xEF2C,0x5C,0x01}, +{0xEF2D,0xC3,0x01}, +{0xEF2E,0x98,0x01}, +{0xEF2F,0xD4,0x01}, +{0xEF30,0x3C,0x01}, +{0xEF31,0xE6,0x01}, +{0xEF32,0x35,0x01}, +{0xEF33,0x9D,0x01}, +{0xEF34,0x09,0x01}, +{0xEF35,0x8E,0x01}, +{0xEF36,0x6B,0x01}, +{0xEF37,0xAC,0x01}, +{0xEF38,0xE3,0x01}, +{0xEF39,0x9B,0x01}, +{0xEF3A,0xF4,0x01}, +{0xEF3B,0x34,0x01}, +{0xEF3C,0x07,0x01}, +{0xEF3D,0x3E,0x01}, +{0xEF3E,0xDA,0x01}, +{0xEF3F,0xC1,0x01}, +{0xEF40,0x8F,0x01}, +{0xEF41,0x74,0x01}, +{0xEF42,0xEA,0x01}, +{0xEF43,0x13,0x01}, +{0xEF44,0x9C,0x01}, +{0xEF45,0xF4,0x01}, +{0xEF46,0xF0,0x01}, +{0xEF47,0xA6,0x01}, +{0xEF48,0x3C,0x01}, +{0xEF49,0xC0,0x01}, +{0xEF4A,0x49,0x01}, +{0xEF4B,0x0F,0x01}, +{0xEF4C,0x72,0x01}, +{0xEF4D,0xEA,0x01}, +{0xEF4E,0xD3,0x01}, +{0xEF4F,0x9C,0x01}, +{0xEF50,0xFE,0x01}, +{0xEF51,0x04,0x01}, +{0xEF52,0xA7,0x01}, +{0xEF53,0x3D,0x01}, + +//SHD2 CW+TL84 33:66 + +{0xED00,0x9191,0x02},// +{0xEF54,0x0B,0x01}, +{0xEF55,0xFA,0x01}, +{0xEF56,0x10,0x01}, +{0xEF57,0x87,0x01}, +{0xEF58,0x24,0x01}, +{0xEF59,0x24,0x01}, +{0xEF5A,0xA1,0x01}, +{0xEF5B,0x09,0x01}, +{0xEF5C,0x7D,0x01}, +{0xEF5D,0x08,0x01}, +{0xEF5E,0x44,0x01}, +{0xEF5F,0x0A,0x01}, +{0xEF60,0x0A,0x01}, +{0xEF61,0x50,0x01}, +{0xEF62,0x7B,0x01}, +{0xEF63,0xAA,0x01}, +{0xEF64,0x53,0x01}, +{0xEF65,0x9C,0x01}, +{0xEF66,0xDF,0x01}, +{0xEF67,0x18,0x01}, +{0xEF68,0xC7,0x01}, +{0xEF69,0x3A,0x01}, +{0xEF6A,0xEC,0x01}, +{0xEF6B,0xF9,0x01}, +{0xEF6C,0x0F,0x01}, +{0xEF6D,0x79,0x01}, +{0xEF6E,0x80,0x01}, +{0xEF6F,0x03,0x01}, +{0xEF70,0x9A,0x01}, +{0xEF71,0xC3,0x01}, +{0xEF72,0xF8,0x01}, +{0xEF73,0xE5,0x01}, +{0xEF74,0x30,0x01}, +{0xEF75,0x9D,0x01}, +{0xEF76,0x01,0x01}, +{0xEF77,0x4E,0x01}, +{0xEF78,0x7B,0x01}, +{0xEF79,0x8C,0x01}, +{0xEF7A,0x53,0x01}, +{0xEF7B,0x19,0x01}, +{0xEF7C,0xB4,0x01}, +{0xEF7D,0x2C,0x01}, +{0xEF7E,0x45,0x01}, +{0xEF7F,0x28,0x01}, +{0xEF80,0x4B,0x01}, +{0xEF81,0x49,0x01}, +{0xEF82,0x8B,0x01}, +{0xEF83,0x66,0x01}, +{0xEF84,0xA0,0x01}, +{0xEF85,0xF3,0x01}, +{0xEF86,0x9A,0x01}, +{0xEF87,0xB9,0x01}, +{0xEF88,0x04,0x01}, +{0xEF89,0x45,0x01}, +{0xEF8A,0x24,0x01}, +{0xEF8B,0x16,0x01}, +{0xEF8C,0x09,0x01}, +{0xEF8D,0xC9,0x01}, +{0xEF8E,0x50,0x01}, +{0xEF8F,0xEC,0x01}, +{0xEF90,0x42,0x01}, +{0xEF91,0x1B,0x01}, +{0xEF92,0xD1,0x01}, +{0xEF93,0x88,0x01}, +{0xEF94,0xA5,0x01}, +{0xEF95,0x25,0x01}, +{0xEF96,0x0A,0x01}, +{0xEF97,0x01,0x01}, +{0xEF98,0x48,0x01}, +{0xEF99,0x43,0x01}, +{0xEF9A,0x60,0x01}, +{0xEF9B,0x32,0x01}, +{0xEF9C,0x96,0x01}, +{0xEF9D,0xD2,0x01}, +{0xEF9E,0x88,0x01}, +{0xEF9F,0x66,0x01}, +{0xEFA0,0x2C,0x01}, +{0xEFA1,0x2E,0x01}, +{0xEFA2,0x51,0x01}, +{0xEFA3,0x48,0x01}, +{0xEFA4,0x40,0x01}, +{0xEFA5,0x1C,0x01}, +{0xEFA6,0x12,0x01}, +{0xEFA7,0x93,0x01}, +{0xEFA8,0xB2,0x01}, +{0xEFA9,0xA4,0x01}, +{0xEFAA,0x86,0x01}, +{0xEFAB,0x36,0x01}, +{0xEFAC,0x77,0x01}, +{0xEFAD,0x19,0x01}, +{0xEFAE,0x4A,0x01}, +{0xEFAF,0x48,0x01}, +{0xEFB0,0x30,0x01}, +{0xEFB1,0x52,0x01}, +{0xEFB2,0x12,0x01}, +{0xEFB3,0xA3,0x01}, +{0xEFB4,0xE4,0x01}, +{0xEFB5,0x25,0x01}, +{0xEFB6,0x37,0x01}, +{0xEFB7,0xCF,0x01}, +{0xEFB8,0xD1,0x01}, +{0xEFB9,0xCC,0x01}, +{0xEFBA,0x5A,0x01}, +{0xEFBB,0x9A,0x01}, +{0xEFBC,0x52,0x01}, +{0xEFBD,0x14,0x01}, +{0xEFBE,0xA8,0x01}, +{0xEFBF,0xC0,0x01}, +{0xEFC0,0x05,0x01}, +{0xEFC1,0x34,0x01}, +{0xEFC2,0xD8,0x01}, +{0xEFC3,0x79,0x01}, +{0xEFC4,0xCF,0x01}, +{0xEFC5,0x71,0x01}, +{0xEFC6,0x42,0x01}, +{0xEFC7,0xA3,0x01}, +{0xEFC8,0x98,0x01}, +{0xEFC9,0xC0,0x01}, +{0xEFCA,0x30,0x01}, +{0xEFCB,0xA6,0x01}, +{0xEFCC,0x34,0x01}, +{0xEFCD,0xCA,0x01}, +{0xEFCE,0xB1,0x01}, +{0xEFCF,0x8F,0x01}, +{0xEFD0,0x81,0x01}, +{0xEFD1,0xE0,0x01}, +{0xEFD2,0x73,0x01}, +{0xEFD3,0x9D,0x01}, +{0xEFD4,0xE3,0x01}, +{0xEFD5,0x04,0x01}, +{0xEFD6,0x47,0x01}, +{0xEFD7,0x39,0x01}, +{0xEFD8,0xDB,0x01}, +{0xEFD9,0xA9,0x01}, +{0xEFDA,0x8F,0x01}, +{0xEFDB,0x83,0x01}, +{0xEFDC,0x06,0x01}, +{0xEFDD,0xE4,0x01}, +{0xEFDE,0xA0,0x01}, +{0xEFDF,0x03,0x01}, +{0xEFE0,0xFD,0x01}, +{0xEFE1,0xA7,0x01}, +{0xEFE2,0x3F,0x01}, +{0xEFE3,0x03,0x01}, +{0xEFE4,0x62,0x01}, +{0xEFE5,0x10,0x01}, +{0xEFE6,0x84,0x01}, +{0xEFE7,0x12,0x01}, +{0xEFE8,0x04,0x01}, +{0xEFE9,0x00,0x01}, +{0xEFEA,0x00,0x01}, +{0xEFEB,0x00,0x01}, +{0xEFEC,0x00,0x01}, +{0xEFED,0x00,0x01}, + + + +//SHD3 D65+TL84 C01// +{0xED00,0x9191,0x02},// +{0xEFEE,0x0B,0x01}, +{0xEFEF,0x12,0x01}, +{0xEFF0,0x11,0x01}, +{0xEFF1,0x88,0x01}, +{0xEFF2,0x2E,0x01}, +{0xEFF3,0x94,0x01}, +{0xEFF4,0x21,0x01}, +{0xEFF5,0x0E,0x01}, +{0xEFF6,0x99,0x01}, +{0xEFF7,0xE8,0x01}, +{0xEFF8,0x44,0x01}, +{0xEFF9,0x10,0x01}, +{0xEFFA,0x22,0x01}, +{0xEFFB,0x50,0x01}, +{0xEFFC,0x7C,0x01}, +{0xEFFD,0xB6,0x01}, +{0xEFFE,0xB3,0x01}, +{0xEFFF,0x1C,0x01}, +{0xF000,0xE3,0x01}, +{0xF001,0x38,0x01}, +{0xF002,0xC7,0x01}, +{0xF003,0x3B,0x01}, +{0xF004,0xF4,0x01}, +{0xF005,0x39,0x01}, +{0xF006,0x10,0x01}, +{0xF007,0x7A,0x01}, +{0xF008,0x8A,0x01}, +{0xF009,0x53,0x01}, +{0xF00A,0x9A,0x01}, +{0xF00B,0xC5,0x01}, +{0xF00C,0x0C,0x01}, +{0xF00D,0x86,0x01}, +{0xF00E,0x31,0x01}, +{0xF00F,0xA5,0x01}, +{0xF010,0x49,0x01}, +{0xF011,0xCE,0x01}, +{0xF012,0x7D,0x01}, +{0xF013,0x94,0x01}, +{0xF014,0xA3,0x01}, +{0xF015,0x19,0x01}, +{0xF016,0xB6,0x01}, +{0xF017,0x38,0x01}, +{0xF018,0xA5,0x01}, +{0xF019,0x28,0x01}, +{0xF01A,0x4F,0x01}, +{0xF01B,0x79,0x01}, +{0xF01C,0x8B,0x01}, +{0xF01D,0x68,0x01}, +{0xF01E,0xB4,0x01}, +{0xF01F,0x43,0x01}, +{0xF020,0x1B,0x01}, +{0xF021,0xBB,0x01}, +{0xF022,0x0C,0x01}, +{0xF023,0x45,0x01}, +{0xF024,0x24,0x01}, +{0xF025,0x17,0x01}, +{0xF026,0x19,0x01}, +{0xF027,0xC9,0x01}, +{0xF028,0x51,0x01}, +{0xF029,0xFA,0x01}, +{0xF02A,0xD2,0x01}, +{0xF02B,0x1B,0x01}, +{0xF02C,0xD3,0x01}, +{0xF02D,0x94,0x01}, +{0xF02E,0xC5,0x01}, +{0xF02F,0x25,0x01}, +{0xF030,0x0A,0x01}, +{0xF031,0x01,0x01}, +{0xF032,0x48,0x01}, +{0xF033,0x43,0x01}, +{0xF034,0x66,0x01}, +{0xF035,0x82,0x01}, +{0xF036,0x96,0x01}, +{0xF037,0xD6,0x01}, +{0xF038,0x98,0x01}, +{0xF039,0xC6,0x01}, +{0xF03A,0x2C,0x01}, +{0xF03B,0x2F,0x01}, +{0xF03C,0x51,0x01}, +{0xF03D,0x48,0x01}, +{0xF03E,0x40,0x01}, +{0xF03F,0x1E,0x01}, +{0xF040,0x42,0x01}, +{0xF041,0x13,0x01}, +{0xF042,0xB5,0x01}, +{0xF043,0xC8,0x01}, +{0xF044,0x06,0x01}, +{0xF045,0x37,0x01}, +{0xF046,0x7B,0x01}, +{0xF047,0x29,0x01}, +{0xF048,0x8A,0x01}, +{0xF049,0x48,0x01}, +{0xF04A,0x32,0x01}, +{0xF04B,0x72,0x01}, +{0xF04C,0x12,0x01}, +{0xF04D,0xA5,0x01}, +{0xF04E,0xFC,0x01}, +{0xF04F,0x65,0x01}, +{0xF050,0x38,0x01}, +{0xF051,0xD4,0x01}, +{0xF052,0xF9,0x01}, +{0xF053,0xCC,0x01}, +{0xF054,0x5B,0x01}, +{0xF055,0xA0,0x01}, +{0xF056,0x82,0x01}, +{0xF057,0x14,0x01}, +{0xF058,0xAA,0x01}, +{0xF059,0xD4,0x01}, +{0xF05A,0x05,0x01}, +{0xF05B,0x35,0x01}, +{0xF05C,0xE2,0x01}, +{0xF05D,0xA9,0x01}, +{0xF05E,0x4F,0x01}, +{0xF05F,0x73,0x01}, +{0xF060,0x4E,0x01}, +{0xF061,0xF3,0x01}, +{0xF062,0x18,0x01}, +{0xF063,0xC3,0x01}, +{0xF064,0x48,0x01}, +{0xF065,0xC6,0x01}, +{0xF066,0x35,0x01}, +{0xF067,0xD4,0x01}, +{0xF068,0x01,0x01}, +{0xF069,0xD0,0x01}, +{0xF06A,0x82,0x01}, +{0xF06B,0xEA,0x01}, +{0xF06C,0xD3,0x01}, +{0xF06D,0x1D,0x01}, +{0xF06E,0xE7,0x01}, +{0xF06F,0x24,0x01}, +{0xF070,0x47,0x01}, +{0xF071,0x3A,0x01}, +{0xF072,0xE5,0x01}, +{0xF073,0xF1,0x01}, +{0xF074,0x0F,0x01}, +{0xF075,0x86,0x01}, +{0xF076,0x0A,0x01}, +{0xF077,0x34,0x01}, +{0xF078,0xA1,0x01}, +{0xF079,0x06,0x01}, +{0xF07A,0x19,0x01}, +{0xF07B,0xE8,0x01}, +{0xF07C,0x40,0x01}, +{0xF07D,0x0D,0x01}, +{0xF07E,0xB2,0x01}, +{0xF07F,0x90,0x01}, +{0xF080,0x86,0x01}, +{0xF081,0x1C,0x01}, +{0xF082,0x04,0x01}, +{0xF083,0x00,0x01}, +{0xF084,0x00,0x01}, +{0xF085,0x00,0x01}, +{0xF086,0x00,0x01}, +{0xF087,0x00,0x01}, +{0xF088,0xBE,0x01}, +{0xF089,0x51,0x01}, +{0xF08A,0x4E,0x01}, +{0xF08B,0x6F,0x01}, +{0xF08C,0x6C,0x01}, +{0xF08D,0x43,0x01}, +{0xF08E,0x1B,0x01}, +{0xF08F,0xDA,0x01}, +{0xF090,0xEC,0x01}, +{0xF091,0x46,0x01}, +{0xF092,0x38,0x01}, +{0xF093,0xBB,0x01}, +{0xF094,0xC1,0x01}, +{0xF095,0xCD,0x01}, +{0xF096,0x69,0x01}, +{0xF097,0x26,0x01}, +{0xF098,0x93,0x01}, +{0xF099,0x98,0x01}, +{0xF09A,0xC1,0x01}, +{0xF09B,0x20,0x01}, +{0xF09C,0x26,0x01}, +{0xF09D,0x32,0x01}, +{0xF09E,0xA5,0x01}, +{0xF09F,0xB1,0x01}, +{0xF0A0,0x8D,0x01}, +{0xF0A1,0x67,0x01}, +{0xF0A2,0x0E,0x01}, +{0xF0A3,0x23,0x01}, +{0xF0A4,0x97,0x01}, +{0xF0A5,0xB0,0x01}, +{0xF0A6,0x6C,0x01}, +{0xF0A7,0x25,0x01}, +{0xF0A8,0x2C,0x01}, +{0xF0A9,0x71,0x01}, +{0xF0AA,0x41,0x01}, +{0xF0AB,0x0C,0x01}, +{0xF0AC,0x69,0x01}, +{0xF0AD,0x14,0x01}, +{0xF0AE,0xB3,0x01}, +{0xF0AF,0x96,0x01}, +{0xF0B0,0xA6,0x01}, +{0xF0B1,0xE8,0x01}, +{0xF0B2,0x64,0x01}, +{0xF0B3,0x26,0x01}, +{0xF0B4,0x3A,0x01}, +{0xF0B5,0x79,0x01}, +{0xF0B6,0x4A,0x01}, +{0xF0B7,0x5B,0x01}, +{0xF0B8,0x18,0x01}, +{0xF0B9,0xA3,0x01}, +{0xF0BA,0x97,0x01}, +{0xF0BB,0xA9,0x01}, +{0xF0BC,0xBC,0x01}, +{0xF0BD,0x24,0x01}, +{0xF0BE,0x23,0x01}, +{0xF0BF,0x13,0x01}, +{0xF0C0,0xE1,0x01}, +{0xF0C1,0xC8,0x01}, +{0xF0C2,0x4C,0x01}, +{0xF0C3,0xAA,0x01}, +{0xF0C4,0xA2,0x01}, +{0xF0C5,0x97,0x01}, +{0xF0C6,0xB6,0x01}, +{0xF0C7,0x14,0x01}, +{0xF0C8,0x05,0x01}, +{0xF0C9,0x24,0x01}, +{0xF0CA,0x06,0x01}, +{0xF0CB,0x09,0x01}, +{0xF0CC,0xC8,0x01}, +{0xF0CD,0x42,0x01}, +{0xF0CE,0x48,0x01}, +{0xF0CF,0x82,0x01}, +{0xF0D0,0x14,0x01}, +{0xF0D1,0xB8,0x01}, +{0xF0D2,0xC0,0x01}, +{0xF0D3,0xE5,0x01}, +{0xF0D4,0x28,0x01}, +{0xF0D5,0x21,0x01}, +{0xF0D6,0x39,0x01}, +{0xF0D7,0x08,0x01}, +{0xF0D8,0x40,0x01}, +{0xF0D9,0x14,0x01}, +{0xF0DA,0x62,0x01}, +{0xF0DB,0x92,0x01}, +{0xF0DC,0xA4,0x01}, +{0xF0DD,0xC4,0x01}, +{0xF0DE,0x05,0x01}, +{0xF0DF,0x30,0x01}, +{0xF0E0,0x58,0x01}, +{0xF0E1,0xA1,0x01}, +{0xF0E2,0x49,0x01}, +{0xF0E3,0x46,0x01}, +{0xF0E4,0x22,0x01}, +{0xF0E5,0xB2,0x01}, +{0xF0E6,0x91,0x01}, +{0xF0E7,0x9A,0x01}, +{0xF0E8,0x58,0x01}, +{0xF0E9,0xA5,0x01}, +{0xF0EA,0x2F,0x01}, +{0xF0EB,0x96,0x01}, +{0xF0EC,0x99,0x01}, +{0xF0ED,0x8B,0x01}, +{0xF0EE,0x54,0x01}, +{0xF0EF,0x74,0x01}, +{0xF0F0,0x32,0x01}, +{0xF0F1,0x13,0x01}, +{0xF0F2,0x9D,0x01}, +{0xF0F3,0x38,0x01}, +{0xF0F4,0xC5,0x01}, +{0xF0F5,0x2D,0x01}, +{0xF0F6,0x90,0x01}, +{0xF0F7,0x59,0x01}, +{0xF0F8,0x4D,0x01}, +{0xF0F9,0x64,0x01}, +{0xF0FA,0xEE,0x01}, +{0xF0FB,0x62,0x01}, +{0xF0FC,0x16,0x01}, +{0xF0FD,0xAE,0x01}, +{0xF0FE,0x84,0x01}, +{0xF0FF,0x25,0x01}, +{0xF100,0x2E,0x01}, +{0xF101,0x8B,0x01}, +{0xF102,0x31,0x01}, +{0xF103,0xCD,0x01}, +{0xF104,0x6F,0x01}, +{0xF105,0x60,0x01}, +{0xF106,0xC3,0x01}, +{0xF107,0x19,0x01}, +{0xF108,0xC7,0x01}, +{0xF109,0x14,0x01}, +{0xF10A,0x26,0x01}, +{0xF10B,0x31,0x01}, +{0xF10C,0x97,0x01}, +{0xF10D,0x41,0x01}, +{0xF10E,0x8D,0x01}, +{0xF10F,0x6D,0x01}, +{0xF110,0x86,0x01}, +{0xF111,0xE3,0x01}, +{0xF112,0x9C,0x01}, +{0xF113,0xE2,0x01}, +{0xF114,0xD8,0x01}, +{0xF115,0x06,0x01}, +{0xF116,0x36,0x01}, +{0xF117,0xB5,0x01}, +{0xF118,0xE9,0x01}, +{0xF119,0x4D,0x01}, +{0xF11A,0x70,0x01}, +{0xF11B,0x68,0x01}, +{0xF11C,0x03,0x01}, +{0xF11D,0x00,0x01}, +{0xF11E,0x00,0x01}, +{0xF11F,0x00,0x01}, +{0xF120,0x00,0x01}, +{0xF121,0x00,0x01}, + + +//SHD TH +{0x6C32,0x1964,0x02}, // SHD_INP_TH_HB_H_R2 +{0x6C34,0x18CE,0x02}, // SHD_INP_TH_HB_L_R2 +{0x6C36,0x10CC,0x02}, // SHD_INP_TH_LB_H_R2 +{0x6C38,0x1004,0x02}, // SHD_INP_TH_LB_L_R2 +{0x6C3C,0x10CC,0x02}, // SHD_INP_TH_HB_H_RB +{0x6C3E,0x1004,0x02}, // SHD_INP_TH_HB_L_RB +{0x6C40,0x0000,0x02}, // SHD_INP_TH_LB_H_RB +{0x6C42,0x0000,0x02}, // SHD_INP_TH_LB_L_RB + +//PreWB_offset (for SHD2) +{0x6828,0x0013,0x02}, // SHD_PRER_OFFSET_R2 : +//PreWB_offset (for SHD3) +{0x682C,0x000D,0x02}, // SHD_PRER_OFFSET_RB : +{0x6830,0xFFFE,0x02}, // SHD_PREB_OFFSET_RB : + +// CXC/SHD EN +{0x01BC,0x57,0x01}, // CXC ON SHD ON INP ON GAIN OFF +}; + +static const isx012_regset_t ISX012_Shading_2[] = +{ +{0x01BC,0x50,0x01}, // CXC OFF SHD OFF +{0xEB00,0x8282,0x02}, //valid_code +{0xEB02,0xFE,0x01}, +{0xEB03,0x84,0x01}, +{0xEB04,0x3F,0x01}, +{0xEB05,0x01,0x01}, +{0xEB06,0x50,0x01}, +{0xEB07,0x08,0x01}, +{0xEB08,0x14,0x01}, +{0xEB09,0xFF,0x01}, +{0xEB0A,0x45,0x01}, +{0xEB0B,0x80,0x01}, +{0xEB0C,0x01,0x01}, +{0xEB0D,0x68,0x01}, +{0xEB0E,0x04,0x01}, +{0xEB0F,0x1A,0x01}, +{0xEB10,0x81,0x01}, +{0xEB11,0x86,0x01}, +{0xEB12,0x3F,0x01}, +{0xEB13,0xE1,0x01}, +{0xEB14,0x4F,0x01}, +{0xEB15,0x00,0x01}, +{0xEB16,0x14,0x01}, +{0xEB17,0x02,0x01}, +{0xEB18,0xC5,0x01}, +{0xEB19,0x7F,0x01}, +{0xEB1A,0x11,0x01}, +{0xEB1B,0x60,0x01}, +{0xEB1C,0x00,0x01}, +{0xEB1D,0x1A,0x01}, +{0xEB1E,0x81,0x01}, +{0xEB1F,0x46,0x01}, +{0xEB20,0xA0,0x01}, +{0xEB21,0x01,0x01}, +{0xEB22,0x48,0x01}, +{0xEB23,0x00,0x01}, +{0xEB24,0x12,0x01}, +{0xEB25,0x81,0x01}, +{0xEB26,0x05,0x01}, +{0xEB27,0x20,0x01}, +{0xEB28,0xF1,0x01}, +{0xEB29,0x4F,0x01}, +{0xEB2A,0x00,0x01}, +{0xEB2B,0x14,0x01}, +{0xEB2C,0x82,0x01}, +{0xEB2D,0x85,0x01}, +{0xEB2E,0x80,0x01}, +{0xEB2F,0x21,0x01}, +{0xEB30,0x60,0x01}, +{0xEB31,0x04,0x01}, +{0xEB32,0x12,0x01}, +{0xEB33,0x81,0x01}, +{0xEB34,0x84,0x01}, +{0xEB35,0xE0,0x01}, +{0xEB36,0x00,0x01}, +{0xEB37,0x28,0x01}, +{0xEB38,0x04,0x01}, +{0xEB39,0x0C,0x01}, +{0xEB3A,0x82,0x01}, +{0xEB3B,0x43,0x01}, +{0xEB3C,0x20,0x01}, +{0xEB3D,0x11,0x01}, +{0xEB3E,0x68,0x01}, +{0xEB3F,0x04,0x01}, +{0xEB40,0x1A,0x01}, +{0xEB41,0x82,0x01}, +{0xEB42,0x83,0x01}, +{0xEB43,0xE0,0x01}, +{0xEB44,0x00,0x01}, +{0xEB45,0x20,0x01}, +{0xEB46,0x00,0x01}, +{0xEB47,0x06,0x01}, +{0xEB48,0xFF,0x01}, +{0xEB49,0x41,0x01}, +{0xEB4A,0x80,0x01}, +{0xEB4B,0x10,0x01}, +{0xEB4C,0x30,0x01}, +{0xEB4D,0x08,0x01}, +{0xEB4E,0x14,0x01}, +{0xEB4F,0x02,0x01}, +{0xEB50,0x45,0x01}, +{0xEB51,0xC0,0x01}, +{0xEB52,0x10,0x01}, +{0xEB53,0x30,0x01}, +{0xEB54,0x04,0x01}, +{0xEB55,0x04,0x01}, +{0xEB56,0x01,0x01}, +{0xEB57,0xC0,0x01}, +{0xEB58,0x3F,0x01}, +{0xEB59,0x10,0x01}, +{0xEB5A,0x10,0x01}, +{0xEB5B,0x04,0x01}, +{0xEB5C,0x0A,0x01}, +{0xEB5D,0x80,0x01}, +{0xEB5E,0x03,0x01}, +{0xEB5F,0xE0,0x01}, +{0xEB60,0x10,0x01}, +{0xEB61,0x28,0x01}, +{0xEB62,0x04,0x01}, +{0xEB63,0x0A,0x01}, +{0xEB64,0x81,0x01}, +{0xEB65,0x01,0x01}, +{0xEB66,0x00,0x01}, +{0xEB67,0x10,0x01}, +{0xEB68,0x00,0x01}, +{0xEB69,0x04,0x01}, +{0xEB6A,0x04,0x01}, +{0xEB6B,0x01,0x01}, +{0xEB6C,0x42,0x01}, +{0xEB6D,0xE0,0x01}, +{0xEB6E,0x10,0x01}, +{0xEB6F,0x38,0x01}, +{0xEB70,0xFC,0x01}, +{0xEB71,0x0D,0x01}, +{0xEB72,0x7F,0x01}, +{0xEB73,0x43,0x01}, +{0xEB74,0x60,0x01}, +{0xEB75,0x00,0x01}, +{0xEB76,0x08,0x01}, +{0xEB77,0x08,0x01}, +{0xEB78,0x02,0x01}, +{0xEB79,0x81,0x01}, +{0xEB7A,0x41,0x01}, +{0xEB7B,0x80,0x01}, +{0xEB7C,0x10,0x01}, +{0xEB7D,0x30,0x01}, +{0xEB7E,0x04,0x01}, +{0xEB7F,0x0C,0x01}, +{0xEB80,0x01,0x01}, +{0xEB81,0x43,0x01}, +{0xEB82,0xC0,0x01}, +{0xEB83,0x20,0x01}, +{0xEB84,0x28,0x01}, +{0xEB85,0x08,0x01}, +{0xEB86,0x06,0x01}, +{0xEB87,0x02,0x01}, +{0xEB88,0xC2,0x01}, +{0xEB89,0xA0,0x01}, +{0xEB8A,0x30,0x01}, +{0xEB8B,0x30,0x01}, +{0xEB8C,0x0C,0x01}, +{0xEB8D,0x12,0x01}, +{0xEB8E,0x83,0x01}, +{0xEB8F,0x84,0x01}, +{0xEB90,0x00,0x01}, +{0xEB91,0x21,0x01}, +{0xEB92,0x40,0x01}, +{0xEB93,0x0C,0x01}, +{0xEB94,0x0C,0x01}, +{0xEB95,0x82,0x01}, +{0xEB96,0x03,0x01}, +{0xEB97,0xC1,0x01}, +{0xEB98,0x40,0x01}, +{0xEB99,0x40,0x01}, +{0xEB9A,0x08,0x01}, +{0xEB9B,0x10,0x01}, +{0xEB9C,0x03,0x01}, +{0xEB9D,0xC4,0x01}, +{0xEB9E,0x00,0x01}, +{0xEB9F,0x21,0x01}, +{0xEBA0,0x38,0x01}, +{0xEBA1,0x08,0x01}, +{0xEBA2,0x0E,0x01}, +{0xEBA3,0x82,0x01}, +{0xEBA4,0xC3,0x01}, +{0xEBA5,0x20,0x01}, +{0xEBA6,0x41,0x01}, +{0xEBA7,0x48,0x01}, +{0xEBA8,0x00,0x01}, +{0xEBA9,0x14,0x01}, +{0xEBAA,0x83,0x01}, +{0xEBAB,0x44,0x01}, +{0xEBAC,0x20,0x01}, +{0xEBAD,0x11,0x01}, +{0xEBAE,0x48,0x01}, +{0xEBAF,0x08,0x01}, +{0xEBB0,0x0E,0x01}, +{0xEBB1,0x82,0x01}, +{0xEBB2,0x83,0x01}, +{0xEBB3,0xE0,0x01}, +{0xEBB4,0x30,0x01}, +{0xEBB5,0x48,0x01}, +{0xEBB6,0x10,0x01}, +{0xEBB7,0x12,0x01}, +{0xEBB8,0x00,0x01}, +{0xEBB9,0xC5,0x01}, +{0xEBBA,0x20,0x01}, +{0xEBBB,0x11,0x01}, +{0xEBBC,0x48,0x01}, +{0xEBBD,0x04,0x01}, +{0xEBBE,0x12,0x01}, +{0xEBBF,0x04,0x01}, +{0xEBC0,0x3B,0x01}, +{0xEBC1,0xC1,0x01}, +{0xEBC2,0x1E,0x01}, +{0xEBC3,0xC8,0x01}, +{0xEBC4,0x0F,0x01}, +{0xEBC5,0xF8,0x01}, +{0xEBC6,0x02,0x01}, +{0xEBC7,0xBB,0x01}, +{0xEBC8,0x60,0x01}, +{0xEBC9,0x0F,0x01}, +{0xEBCA,0xB8,0x01}, +{0xEBCB,0x0F,0x01}, +{0xEBCC,0xEA,0x01}, +{0xEBCD,0x83,0x01}, +{0xEBCE,0x3A,0x01}, +{0xEBCF,0xC1,0x01}, +{0xEBD0,0x4E,0x01}, +{0xEBD1,0xB0,0x01}, +{0xEBD2,0x07,0x01}, +{0xEBD3,0xF2,0x01}, +{0xEBD4,0x03,0x01}, +{0xEBD5,0xBE,0x01}, +{0xEBD6,0xC0,0x01}, +{0xEBD7,0x2E,0x01}, +{0xEBD8,0xD8,0x01}, +{0xEBD9,0x03,0x01}, +{0xEBDA,0xEE,0x01}, +{0xEBDB,0x83,0x01}, +{0xEBDC,0xFA,0x01}, +{0xEBDD,0xA0,0x01}, +{0xEBDE,0x2E,0x01}, +{0xEBDF,0xB0,0x01}, +{0xEBE0,0x0B,0x01}, +{0xEBE1,0xEC,0x01}, +{0xEBE2,0x05,0x01}, +{0xEBE3,0xBD,0x01}, +{0xEBE4,0x60,0x01}, +{0xEBE5,0x2F,0x01}, +{0xEBE6,0xD0,0x01}, +{0xEBE7,0x07,0x01}, +{0xEBE8,0xEC,0x01}, +{0xEBE9,0x02,0x01}, +{0xEBEA,0xBC,0x01}, +{0xEBEB,0x40,0x01}, +{0xEBEC,0x2F,0x01}, +{0xEBED,0xD0,0x01}, +{0xEBEE,0x13,0x01}, +{0xEBEF,0xEE,0x01}, +{0xEBF0,0x84,0x01}, +{0xEBF1,0xBB,0x01}, +{0xEBF2,0x00,0x01}, +{0xEBF3,0x1F,0x01}, +{0xEBF4,0xC8,0x01}, +{0xEBF5,0xFF,0x01}, +{0xEBF6,0xEF,0x01}, +{0xEBF7,0x00,0x01}, +{0xEBF8,0x7D,0x01}, +{0xEBF9,0x60,0x01}, +{0xEBFA,0x2F,0x01}, +{0xEBFB,0xD0,0x01}, +{0xEBFC,0x0B,0x01}, +{0xEBFD,0xF4,0x01}, +{0xEBFE,0x85,0x01}, +{0xEBFF,0x7D,0x01}, +{0xEC00,0x61,0x01}, +{0xEC01,0x0F,0x01}, +{0xEC02,0xC0,0x01}, +{0xEC03,0xFF,0x01}, +{0xEC04,0xF7,0x01}, +{0xEC05,0x7F,0x01}, +{0xEC06,0x3D,0x01}, +{0xEC07,0x40,0x01}, +{0xEC08,0xFF,0x01}, +{0xEC09,0xDF,0x01}, +{0xEC0A,0x07,0x01}, +{0xEC0B,0xFA,0x01}, +{0xEC0C,0x81,0x01}, +{0xEC0D,0x3E,0x01}, +{0xEC0E,0x61,0x01}, +{0xEC0F,0x4F,0x01}, +{0xEC10,0xD8,0x01}, +{0xEC11,0x0B,0x01}, +{0xEC12,0xFC,0x01}, +{0xEC13,0xFE,0x01}, +{0xEC14,0x3D,0x01}, +{0xEC15,0xC0,0x01}, +{0xEC16,0xFF,0x01}, +{0xEC17,0xFF,0x01}, +{0xEC18,0x03,0x01}, +{0xEC19,0xFC,0x01}, +{0xEC1A,0x82,0x01}, +{0xEC1B,0xBE,0x01}, +{0xEC1C,0xA0,0x01}, +{0xEC1D,0x6F,0x01}, +{0xEC1E,0xF8,0x01}, +{0xEC1F,0x1B,0x01}, +{0xEC20,0xFE,0x01}, +{0xEC21,0x83,0x01}, +{0xEC22,0xBF,0x01}, +{0xEC23,0xE0,0x01}, +{0xEC24,0x0F,0x01}, +{0xEC25,0x10,0x01}, +{0xEC26,0x00,0x01}, +{0xEC27,0x00,0x01}, +{0xEC28,0x82,0x01}, +{0xEC29,0xC0,0x01}, +{0xEC2A,0x60,0x01}, +{0xEC2B,0x30,0x01}, +{0xEC2C,0x18,0x01}, +{0xEC2D,0x20,0x01}, +{0xEC2E,0x04,0x01}, +{0xEC2F,0x08,0x01}, +{0xEC30,0x81,0x01}, +{0xEC31,0x21,0x01}, +{0xEC32,0x30,0x01}, +{0xEC33,0x08,0x01}, +{0xEC34,0x08,0x01}, +{0xEC35,0x08,0x01}, +{0xEC36,0x82,0x01}, +{0xEC37,0x01,0x01}, +{0xEC38,0x81,0x01}, +{0xEC39,0x50,0x01}, +{0xEC3A,0x08,0x01}, +{0xEC3B,0x14,0x01}, +{0xEC3C,0x02,0x01}, +{0xEC3D,0x09,0x01}, +{0xEC3E,0x41,0x01}, +{0xEC3F,0x42,0x01}, +{0xEC40,0x70,0x01}, +{0xEC41,0x20,0x01}, +{0xEC42,0x0C,0x01}, +{0xEC43,0x06,0x01}, +{0xEC44,0x84,0x01}, +{0xEC45,0x42,0x01}, +{0xEC46,0xE1,0x01}, +{0xEC47,0x40,0x01}, +{0xEC48,0x38,0x01}, +{0xEC49,0x1C,0x01}, +{0xEC4A,0x0C,0x01}, +{0xEC4B,0x07,0x01}, +{0xEC4C,0x03,0x01}, +{0xEC4D,0xA2,0x01}, +{0xEC4E,0x80,0x01}, +{0xEC4F,0x28,0x01}, +{0xEC50,0x18,0x01}, +{0xEC51,0x10,0x01}, +{0xEC52,0x87,0x01}, +{0xEC53,0x43,0x01}, +{0xEC54,0x61,0x01}, +{0xEC55,0x41,0x01}, +{0xEC56,0x48,0x01}, +{0xEC57,0x14,0x01}, +{0xEC58,0x10,0x01}, +{0xEC59,0x07,0x01}, +{0xEC5A,0xC2,0x01}, +{0xEC5B,0x81,0x01}, +{0xEC5C,0x80,0x01}, +{0xEC5D,0x30,0x01}, +{0xEC5E,0x20,0x01}, +{0xEC5F,0x0C,0x01}, +{0xEC60,0x87,0x01}, +{0xEC61,0x83,0x01}, +{0xEC62,0xC1,0x01}, +{0xEC63,0x40,0x01}, +{0xEC64,0x38,0x01}, +{0xEC65,0x14,0x01}, +{0xEC66,0x0A,0x01}, +{0xEC67,0x07,0x01}, +{0xEC68,0xC3,0x01}, +{0xEC69,0xC1,0x01}, +{0xEC6A,0x70,0x01}, +{0xEC6B,0x30,0x01}, +{0xEC6C,0x20,0x01}, +{0xEC6D,0x0C,0x01}, +{0xEC6E,0x08,0x01}, +{0xEC6F,0xC3,0x01}, +{0xEC70,0xE1,0x01}, +{0xEC71,0x60,0x01}, +{0xEC72,0x30,0x01}, +{0xEC73,0x10,0x01}, +{0xEC74,0x0E,0x01}, +{0xEC75,0x85,0x01}, +{0xEC76,0xC2,0x01}, +{0xEC77,0xC1,0x01}, +{0xEC78,0x70,0x01}, +{0xEC79,0x30,0x01}, +{0xEC7A,0x1C,0x01}, +{0xEC7B,0x0C,0x01}, + +//SHD1(from CO1) +{0xED02,0xE6,0x01}, +{0xED03,0xD9,0x01}, +{0xED04,0x92,0x01}, +{0xED05,0x7C,0x01}, +{0xED06,0xD8,0x01}, +{0xED07,0xB4,0x01}, +{0xED08,0x1E,0x01}, +{0xED09,0x32,0x01}, +{0xED0A,0x75,0x01}, +{0xED0B,0x67,0x01}, +{0xED0C,0x4A,0x01}, +{0xED0D,0xD7,0x01}, +{0xED0E,0xA9,0x01}, +{0xED0F,0x12,0x01}, +{0xED10,0x76,0x01}, +{0xED11,0xBC,0x01}, +{0xED12,0x34,0x01}, +{0xED13,0x1E,0x01}, +{0xED14,0x37,0x01}, +{0xED15,0xA1,0x01}, +{0xED16,0x87,0x01}, +{0xED17,0x4E,0x01}, +{0xED18,0xDE,0x01}, +{0xED19,0x41,0x01}, +{0xED1A,0xD3,0x01}, +{0xED1B,0x77,0x01}, +{0xED1C,0x8C,0x01}, +{0xED1D,0x94,0x01}, +{0xED1E,0x9C,0x01}, +{0xED1F,0x14,0x01}, +{0xED20,0xC9,0x01}, +{0xED21,0xA6,0x01}, +{0xED22,0x41,0x01}, +{0xED23,0xA2,0x01}, +{0xED24,0xC1,0x01}, +{0xED25,0x8F,0x01}, +{0xED26,0x66,0x01}, +{0xED27,0xE6,0x01}, +{0xED28,0xF3,0x01}, +{0xED29,0x19,0x01}, +{0xED2A,0xFF,0x01}, +{0xED2B,0xB0,0x01}, +{0xED2C,0x66,0x01}, +{0xED2D,0x42,0x01}, +{0xED2E,0xC1,0x01}, +{0xED2F,0x91,0x01}, +{0xED30,0x91,0x01}, +{0xED31,0x75,0x01}, +{0xED32,0xA2,0x01}, +{0xED33,0x74,0x01}, +{0xED34,0x1C,0x01}, +{0xED35,0x0F,0x01}, +{0xED36,0x91,0x01}, +{0xED37,0x26,0x01}, +{0xED38,0x3E,0x01}, +{0xED39,0x87,0x01}, +{0xED3A,0x51,0x01}, +{0xED3B,0x4E,0x01}, +{0xED3C,0x5C,0x01}, +{0xED3D,0x54,0x01}, +{0xED3E,0x83,0x01}, +{0xED3F,0x96,0x01}, +{0xED40,0xD0,0x01}, +{0xED41,0xBC,0x01}, +{0xED42,0xA5,0x01}, +{0xED43,0x35,0x01}, +{0xED44,0x83,0x01}, +{0xED45,0x61,0x01}, +{0xED46,0xCE,0x01}, +{0xED47,0x67,0x01}, +{0xED48,0xF2,0x01}, +{0xED49,0x33,0x01}, +{0xED4A,0x1C,0x01}, +{0xED4B,0x1A,0x01}, +{0xED4C,0xC1,0x01}, +{0xED4D,0x46,0x01}, +{0xED4E,0x3F,0x01}, +{0xED4F,0x83,0x01}, +{0xED50,0xD9,0x01}, +{0xED51,0x0D,0x01}, +{0xED52,0x57,0x01}, +{0xED53,0x06,0x01}, +{0xED54,0x23,0x01}, +{0xED55,0x14,0x01}, +{0xED56,0xAF,0x01}, +{0xED57,0xE4,0x01}, +{0xED58,0x64,0x01}, +{0xED59,0x2A,0x01}, +{0xED5A,0x43,0x01}, +{0xED5B,0x01,0x01}, +{0xED5C,0xCB,0x01}, +{0xED5D,0x56,0x01}, +{0xED5E,0x10,0x01}, +{0xED5F,0x03,0x01}, +{0xED60,0x18,0x01}, +{0xED61,0xE4,0x01}, +{0xED62,0xA8,0x01}, +{0xED63,0xE6,0x01}, +{0xED64,0x41,0x01}, +{0xED65,0x9E,0x01}, +{0xED66,0xE1,0x01}, +{0xED67,0xCE,0x01}, +{0xED68,0x59,0x01}, +{0xED69,0x20,0x01}, +{0xED6A,0xB3,0x01}, +{0xED6B,0x13,0x01}, +{0xED6C,0xA8,0x01}, +{0xED6D,0x74,0x01}, +{0xED6E,0x04,0x01}, +{0xED6F,0x25,0x01}, +{0xED70,0x13,0x01}, +{0xED71,0xE1,0x01}, +{0xED72,0xC8,0x01}, +{0xED73,0x47,0x01}, +{0xED74,0x56,0x01}, +{0xED75,0xD2,0x01}, +{0xED76,0x13,0x01}, +{0xED77,0xAB,0x01}, +{0xED78,0x98,0x01}, +{0xED79,0x25,0x01}, +{0xED7A,0x33,0x01}, +{0xED7B,0x9A,0x01}, +{0xED7C,0x49,0x01}, +{0xED7D,0xCF,0x01}, +{0xED7E,0x64,0x01}, +{0xED7F,0x96,0x01}, +{0xED80,0x73,0x01}, +{0xED81,0x95,0x01}, +{0xED82,0xBC,0x01}, +{0xED83,0xA4,0x01}, +{0xED84,0xC4,0x01}, +{0xED85,0x26,0x01}, +{0xED86,0x0A,0x01}, +{0xED87,0x59,0x01}, +{0xED88,0x08,0x01}, +{0xED89,0x40,0x01}, +{0xED8A,0x00,0x01}, +{0xED8B,0xC2,0x01}, +{0xED8C,0x10,0x01}, +{0xED8D,0x88,0x01}, +{0xED8E,0xB0,0x01}, +{0xED8F,0xA4,0x01}, +{0xED90,0x27,0x01}, +{0xED91,0x59,0x01}, +{0xED92,0xF9,0x01}, +{0xED93,0x0B,0x01}, +{0xED94,0x64,0x01}, +{0xED95,0xA8,0x01}, +{0xED96,0x43,0x01}, +{0xED97,0x19,0x01}, +{0xED98,0xE6,0x01}, +{0xED99,0x68,0x01}, +{0xED9A,0x45,0x01}, +{0xED9B,0x2F,0x01}, +{0xED9C,0x2B,0x01}, +{0xED9D,0xB9,0x01}, +{0xED9E,0xC9,0x01}, +{0xED9F,0x42,0x01}, +{0xEDA0,0x18,0x01}, +{0xEDA1,0x32,0x01}, +{0xEDA2,0x90,0x01}, +{0xEDA3,0x80,0x01}, +{0xEDA4,0x3C,0x01}, +{0xEDA5,0x44,0x01}, +{0xEDA6,0x22,0x01}, +{0xEDA7,0x2F,0x01}, +{0xEDA8,0xF1,0x01}, +{0xEDA9,0x09,0x01}, +{0xEDAA,0x57,0x01}, +{0xEDAB,0x04,0x01}, +{0xEDAC,0x53,0x01}, +{0xEDAD,0x99,0x01}, +{0xEDAE,0xEC,0x01}, +{0xEDAF,0x90,0x01}, +{0xEDB0,0x66,0x01}, +{0xEDB1,0x3C,0x01}, +{0xEDB2,0x6D,0x01}, +{0xEDB3,0xA9,0x01}, +{0xEDB4,0x4C,0x01}, +{0xEDB5,0x50,0x01}, +{0xEDB6,0xA6,0x01}, +{0xEDB7,0x32,0x01}, +{0xEDB8,0x12,0x01}, +{0xEDB9,0x94,0x01}, +{0xEDBA,0x64,0x01}, +{0xEDBB,0xA4,0x01}, +{0xEDBC,0x23,0x01}, +{0xEDBD,0x25,0x01}, +{0xEDBE,0x71,0x01}, +{0xEDBF,0x49,0x01}, +{0xEDC0,0x51,0x01}, +{0xEDC1,0xB4,0x01}, +{0xEDC2,0x02,0x01}, +{0xEDC3,0x17,0x01}, +{0xEDC4,0xCE,0x01}, +{0xEDC5,0x98,0x01}, +{0xEDC6,0x06,0x01}, +{0xEDC7,0x3E,0x01}, +{0xEDC8,0xBC,0x01}, +{0xEDC9,0x31,0x01}, +{0xEDCA,0x50,0x01}, +{0xEDCB,0x63,0x01}, +{0xEDCC,0x86,0x01}, +{0xEDCD,0x63,0x01}, +{0xEDCE,0x16,0x01}, +{0xEDCF,0xC4,0x01}, +{0xEDD0,0x2C,0x01}, +{0xEDD1,0x45,0x01}, +{0xEDD2,0x2C,0x01}, +{0xEDD3,0x43,0x01}, +{0xEDD4,0xB9,0x01}, +{0xEDD5,0x4A,0x01}, +{0xEDD6,0x53,0x01}, +{0xEDD7,0xCE,0x01}, +{0xEDD8,0x82,0x01}, +{0xEDD9,0x96,0x01}, +{0xEDDA,0xC8,0x01}, +{0xEDDB,0x40,0x01}, +{0xEDDC,0x06,0x01}, +{0xEDDD,0x3A,0x01}, +{0xEDDE,0xBE,0x01}, +{0xEDDF,0xC1,0x01}, +{0xEDE0,0xD0,0x01}, +{0xEDE1,0x75,0x01}, +{0xEDE2,0x64,0x01}, +{0xEDE3,0x34,0x01}, +{0xEDE4,0x9B,0x01}, +{0xEDE5,0xFE,0x01}, +{0xEDE6,0x4C,0x01}, +{0xEDE7,0xA6,0x01}, +{0xEDE8,0x39,0x01}, +{0xEDE9,0x7D,0x01}, +{0xEDEA,0x89,0x01}, +{0xEDEB,0x8D,0x01}, +{0xEDEC,0x5D,0x01}, +{0xEDED,0x4A,0x01}, +{0xEDEE,0xE3,0x01}, +{0xEDEF,0x97,0x01}, +{0xEDF0,0xDA,0x01}, +{0xEDF1,0x50,0x01}, +{0xEDF2,0xE6,0x01}, +{0xEDF3,0x3A,0x01}, +{0xEDF4,0xB3,0x01}, +{0xEDF5,0x39,0x01}, +{0xEDF6,0x50,0x01}, +{0xEDF7,0x76,0x01}, +{0xEDF8,0x7A,0x01}, +{0xEDF9,0xF4,0x01}, +{0xEDFA,0x9E,0x01}, +{0xEDFB,0x2A,0x01}, +{0xEDFC,0x61,0x01}, +{0xEDFD,0x87,0x01}, +{0xEDFE,0x46,0x01}, +{0xEDFF,0xC0,0x01}, +{0xEE00,0x99,0x01}, +{0xEE01,0xD0,0x01}, +{0xEE02,0x6B,0x01}, +{0xEE03,0x02,0x01}, +{0xEE04,0x94,0x01}, +{0xEE05,0x1A,0x01}, +{0xEE06,0xFD,0x01}, +{0xEE07,0xB8,0x01}, +{0xEE08,0xE6,0x01}, +{0xEE09,0x40,0x01}, +{0xEE0A,0xC0,0x01}, +{0xEE0B,0xF1,0x01}, +{0xEE0C,0xD0,0x01}, +{0xEE0D,0x75,0x01}, +{0xEE0E,0x80,0x01}, +{0xEE0F,0xE4,0x01}, +{0xEE10,0x9E,0x01}, +{0xEE11,0x33,0x01}, +{0xEE12,0xE1,0x01}, +{0xEE13,0xA7,0x01}, +{0xEE14,0x4B,0x01}, +{0xEE15,0xFD,0x01}, +{0xEE16,0x21,0x01}, +{0xEE17,0x53,0x01}, +{0xEE18,0x7C,0x01}, +{0xEE19,0xAE,0x01}, +{0xEE1A,0x64,0x01}, +{0xEE1B,0x9E,0x01}, +{0xEE1C,0x26,0x01}, +{0xEE1D,0x89,0x01}, +{0xEE1E,0xC7,0x01}, +{0xEE1F,0x49,0x01}, +{0xEE20,0xE4,0x01}, +{0xEE21,0x99,0x01}, +{0xEE22,0x12,0x01}, +{0xEE23,0x7D,0x01}, +{0xEE24,0xCA,0x01}, +{0xEE25,0xB4,0x01}, +{0xEE26,0x9F,0x01}, +{0xEE27,0x37,0x01}, +{0xEE28,0xC5,0x01}, +{0xEE29,0x47,0x01}, +{0xEE2A,0x4D,0x01}, +{0xEE2B,0xC2,0x01}, +{0xEE2C,0x19,0x01}, +{0xEE2D,0x0F,0x01}, +{0xEE2E,0x73,0x01}, +{0xEE2F,0xE2,0x01}, +{0xEE30,0x13,0x01}, +{0xEE31,0x1C,0x01}, +{0xEE32,0xF5,0x01}, +{0xEE33,0xE0,0x01}, +{0xEE34,0xC6,0x01}, +{0xEE35,0x3B,0x01}, +{0xEE36,0xB6,0x01}, +{0xEE37,0xB1,0x01}, +{0xEE38,0xCE,0x01}, +{0xEE39,0x6D,0x01}, +{0xEE3A,0xB8,0x01}, +{0xEE3B,0xF3,0x01}, +{0xEE3C,0x9B,0x01}, +{0xEE3D,0xF2,0x01}, +{0xEE3E,0x18,0x01}, +{0xEE3F,0x27,0x01}, +{0xEE40,0x3D,0x01}, +{0xEE41,0xBF,0x01}, +{0xEE42,0xE9,0x01}, +{0xEE43,0xCE,0x01}, +{0xEE44,0x6E,0x01}, +{0xEE45,0xBA,0x01}, +{0xEE46,0x83,0x01}, +{0xEE47,0x9A,0x01}, +{0xEE48,0xE4,0x01}, +{0xEE49,0x50,0x01}, +{0xEE4A,0x66,0x01}, +{0xEE4B,0x36,0x01}, +{0xEE4C,0x8A,0x01}, +{0xEE4D,0x29,0x01}, +{0xEE4E,0x4D,0x01}, +{0xEE4F,0x61,0x01}, +{0xEE50,0x3A,0x01}, +{0xEE51,0xA3,0x01}, +{0xEE52,0x18,0x01}, +{0xEE53,0xD2,0x01}, +{0xEE54,0x50,0x01}, +{0xEE55,0x26,0x01}, +{0xEE56,0x36,0x01}, +{0xEE57,0xA8,0x01}, +{0xEE58,0x21,0x01}, +{0xEE59,0xCE,0x01}, +{0xEE5A,0x6E,0x01}, +{0xEE5B,0xB2,0x01}, +{0xEE5C,0x03,0x01}, +{0xEE5D,0x9A,0x01}, +{0xEE5E,0xE0,0x01}, +{0xEE5F,0x1C,0x01}, +{0xEE60,0x46,0x01}, +{0xEE61,0x34,0x01}, +{0xEE62,0x72,0x01}, +{0xEE63,0x41,0x01}, +{0xEE64,0x8C,0x01}, +{0xEE65,0x58,0x01}, +{0xEE66,0xE8,0x01}, +{0xEE67,0xC2,0x01}, +{0xEE68,0x95,0x01}, +{0xEE69,0xB5,0x01}, +{0xEE6A,0x88,0x01}, +{0xEE6B,0x65,0x01}, +{0xEE6C,0x2E,0x01}, +{0xEE6D,0x72,0x01}, +{0xEE6E,0x39,0x01}, +{0xEE6F,0x8C,0x01}, +{0xEE70,0x62,0x01}, +{0xEE71,0x48,0x01}, +{0xEE72,0x83,0x01}, +{0xEE73,0x1A,0x01}, +{0xEE74,0xE4,0x01}, +{0xEE75,0x28,0x01}, +{0xEE76,0x06,0x01}, +{0xEE77,0x35,0x01}, +{0xEE78,0x6A,0x01}, +{0xEE79,0xF9,0x01}, +{0xEE7A,0x4B,0x01}, +{0xEE7B,0x53,0x01}, +{0xEE7C,0xB8,0x01}, +{0xEE7D,0x92,0x01}, +{0xEE7E,0x13,0x01}, +{0xEE7F,0xA2,0x01}, +{0xEE80,0xCC,0x01}, +{0xEE81,0x64,0x01}, +{0xEE82,0x27,0x01}, +{0xEE83,0x3B,0x01}, +{0xEE84,0x29,0x01}, +{0xEE85,0x0A,0x01}, +{0xEE86,0x54,0x01}, +{0xEE87,0xBC,0x01}, +{0xEE88,0xF2,0x01}, +{0xEE89,0x96,0x01}, +{0xEE8A,0xC1,0x01}, +{0xEE8B,0x40,0x01}, +{0xEE8C,0xA6,0x01}, +{0xEE8D,0x35,0x01}, +{0xEE8E,0x7A,0x01}, +{0xEE8F,0xB1,0x01}, +{0xEE90,0x8C,0x01}, +{0xEE91,0x54,0x01}, +{0xEE92,0xC8,0x01}, +{0xEE93,0xF2,0x01}, +{0xEE94,0x92,0x01}, +{0xEE95,0x9D,0x01}, +{0xEE96,0x64,0x01}, +{0xEE97,0xE4,0x01}, +{0xEE98,0x23,0x01}, +{0xEE99,0x13,0x01}, +{0xEE9A,0xA9,0x01}, +{0xEE9B,0x48,0x01}, +{0xEE9C,0x47,0x01}, +{0xEE9D,0x40,0x01}, +{0xEE9E,0x42,0x01}, +{0xEE9F,0x13,0x01}, +{0xEEA0,0x9F,0x01}, +{0xEEA1,0x58,0x01}, +{0xEEA2,0xE5,0x01}, +{0xEEA3,0x2C,0x01}, +{0xEEA4,0x7F,0x01}, +{0xEEA5,0xD9,0x01}, +{0xEEA6,0x8C,0x01}, +{0xEEA7,0x5B,0x01}, +{0xEEA8,0x12,0x01}, +{0xEEA9,0x43,0x01}, +{0xEEAA,0x14,0x01}, +{0xEEAB,0xAA,0x01}, +{0xEEAC,0x80,0x01}, +{0xEEAD,0x04,0x01}, +{0xEEAE,0x25,0x01}, +{0xEEAF,0x06,0x01}, +{0xEEB0,0x51,0x01}, +{0xEEB1,0x08,0x01}, +{0xEEB2,0x40,0x01}, +{0xEEB3,0x00,0x01}, +{0xEEB4,0xB2,0x01}, +{0xEEB5,0x10,0x01}, +{0xEEB6,0x86,0x01}, +{0xEEB7,0x98,0x01}, +{0xEEB8,0x64,0x01}, +{0xEEB9,0x25,0x01}, +{0xEEBA,0x4A,0x01}, +{0xEEBB,0xB9,0x01}, +{0xEEBC,0x0A,0x01}, +{0xEEBD,0x5D,0x01}, +{0xEEBE,0x1C,0x01}, +{0xEEBF,0x13,0x01}, +{0xEEC0,0x97,0x01}, +{0xEEC1,0xC4,0x01}, +{0xEEC2,0x18,0x01}, +{0xEEC3,0x85,0x01}, +{0xEEC4,0x2A,0x01}, +{0xEEC5,0x21,0x01}, +{0xEEC6,0x41,0x01}, +{0xEEC7,0xC9,0x01}, +{0xEEC8,0x41,0x01}, +{0xEEC9,0x12,0x01}, +{0xEECA,0x02,0x01}, +{0xEECB,0x10,0x01}, +{0xEECC,0x80,0x01}, +{0xEECD,0x2C,0x01}, +{0xEECE,0x64,0x01}, +{0xEECF,0x21,0x01}, +{0xEED0,0x27,0x01}, +{0xEED1,0x61,0x01}, +{0xEED2,0xC9,0x01}, +{0xEED3,0x52,0x01}, +{0xEED4,0xB0,0x01}, +{0xEED5,0x42,0x01}, +{0xEED6,0x17,0x01}, +{0xEED7,0xC8,0x01}, +{0xEED8,0x04,0x01}, +{0xEED9,0xE6,0x01}, +{0xEEDA,0x32,0x01}, +{0xEEDB,0x58,0x01}, +{0xEEDC,0x29,0x01}, +{0xEEDD,0xCB,0x01}, +{0xEEDE,0x4C,0x01}, +{0xEEDF,0x74,0x01}, +{0xEEE0,0x92,0x01}, +{0xEEE1,0x91,0x01}, +{0xEEE2,0x8E,0x01}, +{0xEEE3,0x48,0x01}, +{0xEEE4,0x84,0x01}, +{0xEEE5,0x22,0x01}, +{0xEEE6,0x1D,0x01}, +{0xEEE7,0x01,0x01}, +{0xEEE8,0xC9,0x01}, +{0xEEE9,0x4D,0x01}, +{0xEEEA,0x7E,0x01}, +{0xEEEB,0x82,0x01}, +{0xEEEC,0x15,0x01}, +{0xEEED,0xB5,0x01}, +{0xEEEE,0x04,0x01}, +{0xEEEF,0xE6,0x01}, +{0xEEF0,0x33,0x01}, +{0xEEF1,0x99,0x01}, +{0xEEF2,0x69,0x01}, +{0xEEF3,0x0D,0x01}, +{0xEEF4,0x5D,0x01}, +{0xEEF5,0x06,0x01}, +{0xEEF6,0x33,0x01}, +{0xEEF7,0x15,0x01}, +{0xEEF8,0xAF,0x01}, +{0xEEF9,0xEC,0x01}, +{0xEEFA,0xA4,0x01}, +{0xEEFB,0x28,0x01}, +{0xEEFC,0x35,0x01}, +{0xEEFD,0xE9,0x01}, +{0xEEFE,0x09,0x01}, +{0xEEFF,0x4F,0x01}, +{0xEF00,0x8E,0x01}, +{0xEF01,0x02,0x01}, +{0xEF02,0x95,0x01}, +{0xEF03,0xB1,0x01}, +{0xEF04,0xC4,0x01}, +{0xEF05,0x25,0x01}, +{0xEF06,0x31,0x01}, +{0xEF07,0x94,0x01}, +{0xEF08,0xB1,0x01}, +{0xEF09,0x4D,0x01}, +{0xEF0A,0x6C,0x01}, +{0xEF0B,0x94,0x01}, +{0xEF0C,0x43,0x01}, +{0xEF0D,0x99,0x01}, +{0xEF0E,0xD4,0x01}, +{0xEF0F,0xEC,0x01}, +{0xEF10,0xC5,0x01}, +{0xEF11,0x31,0x01}, +{0xEF12,0x69,0x01}, +{0xEF13,0xC9,0x01}, +{0xEF14,0x0B,0x01}, +{0xEF15,0x58,0x01}, +{0xEF16,0xE6,0x01}, +{0xEF17,0x52,0x01}, +{0xEF18,0x16,0x01}, +{0xEF19,0xBE,0x01}, +{0xEF1A,0xD4,0x01}, +{0xEF1B,0x45,0x01}, +{0xEF1C,0x32,0x01}, +{0xEF1D,0x8E,0x01}, +{0xEF1E,0x79,0x01}, +{0xEF1F,0x4D,0x01}, +{0xEF20,0x6A,0x01}, +{0xEF21,0xA4,0x01}, +{0xEF22,0x83,0x01}, +{0xEF23,0x1C,0x01}, +{0xEF24,0xF2,0x01}, +{0xEF25,0xDC,0x01}, +{0xEF26,0x26,0x01}, +{0xEF27,0x3A,0x01}, +{0xEF28,0xA3,0x01}, +{0xEF29,0xE1,0x01}, +{0xEF2A,0x4D,0x01}, +{0xEF2B,0x65,0x01}, +{0xEF2C,0x5C,0x01}, +{0xEF2D,0xC3,0x01}, +{0xEF2E,0x98,0x01}, +{0xEF2F,0xD4,0x01}, +{0xEF30,0x3C,0x01}, +{0xEF31,0xE6,0x01}, +{0xEF32,0x35,0x01}, +{0xEF33,0x9D,0x01}, +{0xEF34,0x09,0x01}, +{0xEF35,0x8E,0x01}, +{0xEF36,0x6B,0x01}, +{0xEF37,0xAC,0x01}, +{0xEF38,0xE3,0x01}, +{0xEF39,0x9B,0x01}, +{0xEF3A,0xF4,0x01}, +{0xEF3B,0x34,0x01}, +{0xEF3C,0x07,0x01}, +{0xEF3D,0x3E,0x01}, +{0xEF3E,0xDA,0x01}, +{0xEF3F,0xC1,0x01}, +{0xEF40,0x8F,0x01}, +{0xEF41,0x74,0x01}, +{0xEF42,0xEA,0x01}, +{0xEF43,0x13,0x01}, +{0xEF44,0x9C,0x01}, +{0xEF45,0xF4,0x01}, +{0xEF46,0xF0,0x01}, +{0xEF47,0xA6,0x01}, +{0xEF48,0x3C,0x01}, +{0xEF49,0xC0,0x01}, +{0xEF4A,0x49,0x01}, +{0xEF4B,0x0F,0x01}, +{0xEF4C,0x72,0x01}, +{0xEF4D,0xEA,0x01}, +{0xEF4E,0xD3,0x01}, +{0xEF4F,0x9C,0x01}, +{0xEF50,0xFE,0x01}, +{0xEF51,0x04,0x01}, +{0xEF52,0xA7,0x01}, +{0xEF53,0x3D,0x01}, + +//SHD2 CW+TL84 33:66 + +{0xED00,0x9191,0x02},// +{0xEF54,0x2F,0x01}, +{0xEF55,0xF2,0x01}, +{0xEF56,0x51,0x01}, +{0xEF57,0x8D,0x01}, +{0xEF58,0x50,0x01}, +{0xEF59,0x74,0x01}, +{0xEF5A,0xA2,0x01}, +{0xEF5B,0x14,0x01}, +{0xEF5C,0xE1,0x01}, +{0xEF5D,0xC8,0x01}, +{0xEF5E,0x47,0x01}, +{0xEF5F,0x2E,0x01}, +{0xEF60,0xD2,0x01}, +{0xEF61,0x10,0x01}, +{0xEF62,0x80,0x01}, +{0xEF63,0xC8,0x01}, +{0xEF64,0x13,0x01}, +{0xEF65,0x9D,0x01}, +{0xEF66,0xE5,0x01}, +{0xEF67,0x48,0x01}, +{0xEF68,0x87,0x01}, +{0xEF69,0x3C,0x01}, +{0xEF6A,0xFE,0x01}, +{0xEF6B,0xC9,0x01}, +{0xEF6C,0x50,0x01}, +{0xEF6D,0x7D,0x01}, +{0xEF6E,0x96,0x01}, +{0xEF6F,0x83,0x01}, +{0xEF70,0x9A,0x01}, +{0xEF71,0xC6,0x01}, +{0xEF72,0x10,0x01}, +{0xEF73,0xA6,0x01}, +{0xEF74,0x31,0x01}, +{0xEF75,0xA5,0x01}, +{0xEF76,0x61,0x01}, +{0xEF77,0xCE,0x01}, +{0xEF78,0x7F,0x01}, +{0xEF79,0xA4,0x01}, +{0xEF7A,0xD3,0x01}, +{0xEF7B,0x19,0x01}, +{0xEF7C,0xB6,0x01}, +{0xEF7D,0x38,0x01}, +{0xEF7E,0xA5,0x01}, +{0xEF7F,0x28,0x01}, +{0xEF80,0x4E,0x01}, +{0xEF81,0x69,0x01}, +{0xEF82,0x4B,0x01}, +{0xEF83,0x68,0x01}, +{0xEF84,0xBA,0x01}, +{0xEF85,0x93,0x01}, +{0xEF86,0x1B,0x01}, +{0xEF87,0xBC,0x01}, +{0xEF88,0x0C,0x01}, +{0xEF89,0x65,0x01}, +{0xEF8A,0x24,0x01}, +{0xEF8B,0x17,0x01}, +{0xEF8C,0x19,0x01}, +{0xEF8D,0x49,0x01}, +{0xEF8E,0x51,0x01}, +{0xEF8F,0xF6,0x01}, +{0xEF90,0xE2,0x01}, +{0xEF91,0x1B,0x01}, +{0xEF92,0xD5,0x01}, +{0xEF93,0x98,0x01}, +{0xEF94,0xC5,0x01}, +{0xEF95,0x25,0x01}, +{0xEF96,0x0B,0x01}, +{0xEF97,0x01,0x01}, +{0xEF98,0x48,0x01}, +{0xEF99,0x43,0x01}, +{0xEF9A,0x64,0x01}, +{0xEF9B,0x72,0x01}, +{0xEF9C,0x96,0x01}, +{0xEF9D,0xD6,0x01}, +{0xEF9E,0xA8,0x01}, +{0xEF9F,0xE6,0x01}, +{0xEFA0,0x2C,0x01}, +{0xEFA1,0x30,0x01}, +{0xEFA2,0x51,0x01}, +{0xEFA3,0x48,0x01}, +{0xEFA4,0x40,0x01}, +{0xEFA5,0x1C,0x01}, +{0xEFA6,0x22,0x01}, +{0xEFA7,0x93,0x01}, +{0xEFA8,0xB4,0x01}, +{0xEFA9,0xC8,0x01}, +{0xEFAA,0xA6,0x01}, +{0xEFAB,0x37,0x01}, +{0xEFAC,0x7C,0x01}, +{0xEFAD,0x29,0x01}, +{0xEFAE,0x8A,0x01}, +{0xEFAF,0x48,0x01}, +{0xEFB0,0x30,0x01}, +{0xEFB1,0x62,0x01}, +{0xEFB2,0x12,0x01}, +{0xEFB3,0xA4,0x01}, +{0xEFB4,0xF8,0x01}, +{0xEFB5,0x65,0x01}, +{0xEFB6,0x38,0x01}, +{0xEFB7,0xDB,0x01}, +{0xEFB8,0x11,0x01}, +{0xEFB9,0x0D,0x01}, +{0xEFBA,0x5C,0x01}, +{0xEFBB,0xA0,0x01}, +{0xEFBC,0x72,0x01}, +{0xEFBD,0x94,0x01}, +{0xEFBE,0xA9,0x01}, +{0xEFBF,0xD0,0x01}, +{0xEFC0,0x05,0x01}, +{0xEFC1,0x35,0x01}, +{0xEFC2,0xE5,0x01}, +{0xEFC3,0x11,0x01}, +{0xEFC4,0xD0,0x01}, +{0xEFC5,0x74,0x01}, +{0xEFC6,0x52,0x01}, +{0xEFC7,0x03,0x01}, +{0xEFC8,0x19,0x01}, +{0xEFC9,0xC3,0x01}, +{0xEFCA,0x48,0x01}, +{0xEFCB,0xC6,0x01}, +{0xEFCC,0x35,0x01}, +{0xEFCD,0xD7,0x01}, +{0xEFCE,0x41,0x01}, +{0xEFCF,0x10,0x01}, +{0xEFD0,0x88,0x01}, +{0xEFD1,0x06,0x01}, +{0xEFD2,0x54,0x01}, +{0xEFD3,0x9E,0x01}, +{0xEFD4,0xE9,0x01}, +{0xEFD5,0x30,0x01}, +{0xEFD6,0xC7,0x01}, +{0xEFD7,0x3A,0x01}, +{0xEFD8,0xEA,0x01}, +{0xEFD9,0x41,0x01}, +{0xEFDA,0x50,0x01}, +{0xEFDB,0x8A,0x01}, +{0xEFDC,0x4E,0x01}, +{0xEFDD,0xB4,0x01}, +{0xEFDE,0x22,0x01}, +{0xEFDF,0x10,0x01}, +{0xEFE0,0x51,0x01}, +{0xEFE1,0x48,0x01}, +{0xEFE2,0x42,0x01}, +{0xEFE3,0x19,0x01}, +{0xEFE4,0x2A,0x01}, +{0xEFE5,0x91,0x01}, +{0xEFE6,0x8B,0x01}, +{0xEFE7,0x5A,0x01}, +{0xEFE8,0x04,0x01}, +{0xEFE9,0x00,0x01}, +{0xEFEA,0x00,0x01}, +{0xEFEB,0x00,0x01}, +{0xEFEC,0x00,0x01}, +{0xEFED,0x00,0x01}, + + + +//SHD3 D65+TL84 C01// +{0xED00,0x9191,0x02},// +{0xEFEE,0x21,0x01}, +{0xEFEF,0xAA,0x01}, +{0xEFF0,0xD1,0x01}, +{0xEFF1,0x8B,0x01}, +{0xEFF2,0x4A,0x01}, +{0xEFF3,0x64,0x01}, +{0xEFF4,0x22,0x01}, +{0xEFF5,0x15,0x01}, +{0xEFF6,0xD9,0x01}, +{0xEFF7,0x28,0x01}, +{0xEFF8,0x47,0x01}, +{0xEFF9,0x26,0x01}, +{0xEFFA,0xA2,0x01}, +{0xEFFB,0x50,0x01}, +{0xEFFC,0x7F,0x01}, +{0xEFFD,0xC6,0x01}, +{0xEFFE,0x23,0x01}, +{0xEFFF,0x9D,0x01}, +{0xF000,0xE6,0x01}, +{0xF001,0x54,0x01}, +{0xF002,0xE7,0x01}, +{0xF003,0x3C,0x01}, +{0xF004,0x00,0x01}, +{0xF005,0xBA,0x01}, +{0xF006,0xD0,0x01}, +{0xF007,0x7C,0x01}, +{0xF008,0x98,0x01}, +{0xF009,0xA3,0x01}, +{0xF00A,0x9A,0x01}, +{0xF00B,0xC7,0x01}, +{0xF00C,0x18,0x01}, +{0xF00D,0x06,0x01}, +{0xF00E,0x32,0x01}, +{0xF00F,0xAA,0x01}, +{0xF010,0x81,0x01}, +{0xF011,0x8E,0x01}, +{0xF012,0x80,0x01}, +{0xF013,0xA4,0x01}, +{0xF014,0xE3,0x01}, +{0xF015,0x19,0x01}, +{0xF016,0xB7,0x01}, +{0xF017,0x3C,0x01}, +{0xF018,0xC5,0x01}, +{0xF019,0x28,0x01}, +{0xF01A,0x51,0x01}, +{0xF01B,0x89,0x01}, +{0xF01C,0x8B,0x01}, +{0xF01D,0x69,0x01}, +{0xF01E,0xC4,0x01}, +{0xF01F,0x93,0x01}, +{0xF020,0x9B,0x01}, +{0xF021,0xBC,0x01}, +{0xF022,0x10,0x01}, +{0xF023,0x65,0x01}, +{0xF024,0x24,0x01}, +{0xF025,0x18,0x01}, +{0xF026,0x21,0x01}, +{0xF027,0x09,0x01}, +{0xF028,0x52,0x01}, +{0xF029,0x00,0x01}, +{0xF02A,0x33,0x01}, +{0xF02B,0x9C,0x01}, +{0xF02C,0xD5,0x01}, +{0xF02D,0x9C,0x01}, +{0xF02E,0xE5,0x01}, +{0xF02F,0x25,0x01}, +{0xF030,0x0A,0x01}, +{0xF031,0x01,0x01}, +{0xF032,0x88,0x01}, +{0xF033,0x43,0x01}, +{0xF034,0x68,0x01}, +{0xF035,0xA2,0x01}, +{0xF036,0x16,0x01}, +{0xF037,0xD9,0x01}, +{0xF038,0xAC,0x01}, +{0xF039,0x06,0x01}, +{0xF03A,0x2D,0x01}, +{0xF03B,0x30,0x01}, +{0xF03C,0x51,0x01}, +{0xF03D,0x48,0x01}, +{0xF03E,0x40,0x01}, +{0xF03F,0x1E,0x01}, +{0xF040,0x42,0x01}, +{0xF041,0x93,0x01}, +{0xF042,0xB6,0x01}, +{0xF043,0xDC,0x01}, +{0xF044,0xC6,0x01}, +{0xF045,0x37,0x01}, +{0xF046,0x7E,0x01}, +{0xF047,0x31,0x01}, +{0xF048,0xCA,0x01}, +{0xF049,0x48,0x01}, +{0xF04A,0x32,0x01}, +{0xF04B,0x72,0x01}, +{0xF04C,0x92,0x01}, +{0xF04D,0xA5,0x01}, +{0xF04E,0x08,0x01}, +{0xF04F,0x26,0x01}, +{0xF050,0x39,0x01}, +{0xF051,0xDC,0x01}, +{0xF052,0x19,0x01}, +{0xF053,0x8D,0x01}, +{0xF054,0x5C,0x01}, +{0xF055,0xA4,0x01}, +{0xF056,0x92,0x01}, +{0xF057,0x14,0x01}, +{0xF058,0xAB,0x01}, +{0xF059,0xE0,0x01}, +{0xF05A,0xA5,0x01}, +{0xF05B,0x35,0x01}, +{0xF05C,0xEA,0x01}, +{0xF05D,0x09,0x01}, +{0xF05E,0x10,0x01}, +{0xF05F,0x75,0x01}, +{0xF060,0x58,0x01}, +{0xF061,0x33,0x01}, +{0xF062,0x99,0x01}, +{0xF063,0xC4,0x01}, +{0xF064,0x58,0x01}, +{0xF065,0x66,0x01}, +{0xF066,0x36,0x01}, +{0xF067,0xDB,0x01}, +{0xF068,0x61,0x01}, +{0xF069,0xD0,0x01}, +{0xF06A,0x86,0x01}, +{0xF06B,0x02,0x01}, +{0xF06C,0x64,0x01}, +{0xF06D,0x1E,0x01}, +{0xF06E,0xEB,0x01}, +{0xF06F,0x40,0x01}, +{0xF070,0x47,0x01}, +{0xF071,0x3B,0x01}, +{0xF072,0xEE,0x01}, +{0xF073,0x51,0x01}, +{0xF074,0x10,0x01}, +{0xF075,0x8A,0x01}, +{0xF076,0x36,0x01}, +{0xF077,0x54,0x01}, +{0xF078,0x22,0x01}, +{0xF079,0x0E,0x01}, +{0xF07A,0x51,0x01}, +{0xF07B,0x88,0x01}, +{0xF07C,0x42,0x01}, +{0xF07D,0x1A,0x01}, +{0xF07E,0x2A,0x01}, +{0xF07F,0x11,0x01}, +{0xF080,0x8B,0x01}, +{0xF081,0x48,0x01}, +{0xF082,0x04,0x01}, +{0xF083,0x00,0x01}, +{0xF084,0x00,0x01}, +{0xF085,0x00,0x01}, +{0xF086,0x00,0x01}, +{0xF087,0x00,0x01}, +{0xF088,0xBE,0x01}, +{0xF089,0x51,0x01}, +{0xF08A,0x4E,0x01}, +{0xF08B,0x6F,0x01}, +{0xF08C,0x6C,0x01}, +{0xF08D,0x43,0x01}, +{0xF08E,0x1B,0x01}, +{0xF08F,0xDA,0x01}, +{0xF090,0xEC,0x01}, +{0xF091,0x46,0x01}, +{0xF092,0x38,0x01}, +{0xF093,0xBB,0x01}, +{0xF094,0xC1,0x01}, +{0xF095,0xCD,0x01}, +{0xF096,0x69,0x01}, +{0xF097,0x26,0x01}, +{0xF098,0x93,0x01}, +{0xF099,0x98,0x01}, +{0xF09A,0xC1,0x01}, +{0xF09B,0x20,0x01}, +{0xF09C,0x26,0x01}, +{0xF09D,0x32,0x01}, +{0xF09E,0xA5,0x01}, +{0xF09F,0xB1,0x01}, +{0xF0A0,0x8D,0x01}, +{0xF0A1,0x67,0x01}, +{0xF0A2,0x0E,0x01}, +{0xF0A3,0x23,0x01}, +{0xF0A4,0x97,0x01}, +{0xF0A5,0xB0,0x01}, +{0xF0A6,0x6C,0x01}, +{0xF0A7,0x25,0x01}, +{0xF0A8,0x2C,0x01}, +{0xF0A9,0x71,0x01}, +{0xF0AA,0x41,0x01}, +{0xF0AB,0x0C,0x01}, +{0xF0AC,0x69,0x01}, +{0xF0AD,0x14,0x01}, +{0xF0AE,0xB3,0x01}, +{0xF0AF,0x96,0x01}, +{0xF0B0,0xA6,0x01}, +{0xF0B1,0xE8,0x01}, +{0xF0B2,0x64,0x01}, +{0xF0B3,0x26,0x01}, +{0xF0B4,0x3A,0x01}, +{0xF0B5,0x79,0x01}, +{0xF0B6,0x4A,0x01}, +{0xF0B7,0x5B,0x01}, +{0xF0B8,0x18,0x01}, +{0xF0B9,0xA3,0x01}, +{0xF0BA,0x97,0x01}, +{0xF0BB,0xA9,0x01}, +{0xF0BC,0xBC,0x01}, +{0xF0BD,0x24,0x01}, +{0xF0BE,0x23,0x01}, +{0xF0BF,0x13,0x01}, +{0xF0C0,0xE1,0x01}, +{0xF0C1,0xC8,0x01}, +{0xF0C2,0x4C,0x01}, +{0xF0C3,0xAA,0x01}, +{0xF0C4,0xA2,0x01}, +{0xF0C5,0x97,0x01}, +{0xF0C6,0xB6,0x01}, +{0xF0C7,0x14,0x01}, +{0xF0C8,0x05,0x01}, +{0xF0C9,0x24,0x01}, +{0xF0CA,0x06,0x01}, +{0xF0CB,0x09,0x01}, +{0xF0CC,0xC8,0x01}, +{0xF0CD,0x42,0x01}, +{0xF0CE,0x48,0x01}, +{0xF0CF,0x82,0x01}, +{0xF0D0,0x14,0x01}, +{0xF0D1,0xB8,0x01}, +{0xF0D2,0xC0,0x01}, +{0xF0D3,0xE5,0x01}, +{0xF0D4,0x28,0x01}, +{0xF0D5,0x21,0x01}, +{0xF0D6,0x39,0x01}, +{0xF0D7,0x08,0x01}, +{0xF0D8,0x40,0x01}, +{0xF0D9,0x14,0x01}, +{0xF0DA,0x62,0x01}, +{0xF0DB,0x92,0x01}, +{0xF0DC,0xA4,0x01}, +{0xF0DD,0xC4,0x01}, +{0xF0DE,0x05,0x01}, +{0xF0DF,0x30,0x01}, +{0xF0E0,0x58,0x01}, +{0xF0E1,0xA1,0x01}, +{0xF0E2,0x49,0x01}, +{0xF0E3,0x46,0x01}, +{0xF0E4,0x22,0x01}, +{0xF0E5,0xB2,0x01}, +{0xF0E6,0x91,0x01}, +{0xF0E7,0x9A,0x01}, +{0xF0E8,0x58,0x01}, +{0xF0E9,0xA5,0x01}, +{0xF0EA,0x2F,0x01}, +{0xF0EB,0x96,0x01}, +{0xF0EC,0x99,0x01}, +{0xF0ED,0x8B,0x01}, +{0xF0EE,0x54,0x01}, +{0xF0EF,0x74,0x01}, +{0xF0F0,0x32,0x01}, +{0xF0F1,0x13,0x01}, +{0xF0F2,0x9D,0x01}, +{0xF0F3,0x38,0x01}, +{0xF0F4,0xC5,0x01}, +{0xF0F5,0x2D,0x01}, +{0xF0F6,0x90,0x01}, +{0xF0F7,0x59,0x01}, +{0xF0F8,0x4D,0x01}, +{0xF0F9,0x64,0x01}, +{0xF0FA,0xEE,0x01}, +{0xF0FB,0x62,0x01}, +{0xF0FC,0x16,0x01}, +{0xF0FD,0xAE,0x01}, +{0xF0FE,0x84,0x01}, +{0xF0FF,0x25,0x01}, +{0xF100,0x2E,0x01}, +{0xF101,0x8B,0x01}, +{0xF102,0x31,0x01}, +{0xF103,0xCD,0x01}, +{0xF104,0x6F,0x01}, +{0xF105,0x60,0x01}, +{0xF106,0xC3,0x01}, +{0xF107,0x19,0x01}, +{0xF108,0xC7,0x01}, +{0xF109,0x14,0x01}, +{0xF10A,0x26,0x01}, +{0xF10B,0x31,0x01}, +{0xF10C,0x97,0x01}, +{0xF10D,0x41,0x01}, +{0xF10E,0x8D,0x01}, +{0xF10F,0x6D,0x01}, +{0xF110,0x86,0x01}, +{0xF111,0xE3,0x01}, +{0xF112,0x9C,0x01}, +{0xF113,0xE2,0x01}, +{0xF114,0xD8,0x01}, +{0xF115,0x06,0x01}, +{0xF116,0x36,0x01}, +{0xF117,0xB5,0x01}, +{0xF118,0xE9,0x01}, +{0xF119,0x4D,0x01}, +{0xF11A,0x70,0x01}, +{0xF11B,0x68,0x01}, +{0xF11C,0x03,0x01}, +{0xF11D,0x00,0x01}, +{0xF11E,0x00,0x01}, +{0xF11F,0x00,0x01}, +{0xF120,0x00,0x01}, +{0xF121,0x00,0x01}, + + +//SHD TH +{0x6C32,0x1964,0x02}, // SHD_INP_TH_HB_H_R2 +{0x6C34,0x18CE,0x02}, // SHD_INP_TH_HB_L_R2 +{0x6C36,0x10CC,0x02}, // SHD_INP_TH_LB_H_R2 +{0x6C38,0x1004,0x02}, // SHD_INP_TH_LB_L_R2 +{0x6C3C,0x10CC,0x02}, // SHD_INP_TH_HB_H_RB +{0x6C3E,0x1004,0x02}, // SHD_INP_TH_HB_L_RB +{0x6C40,0x0000,0x02}, // SHD_INP_TH_LB_H_RB +{0x6C42,0x0000,0x02}, // SHD_INP_TH_LB_L_RB + +//PreWB_offset (for SHD2) +{0x6828,0x0013,0x02}, // SHD_PRER_OFFSET_R2 : +//PreWB_offset (for SHD3) +{0x682C,0x000B,0x02}, // SHD_PRER_OFFSET_RB : +{0x6830,0xFFFD,0x02}, // SHD_PREB_OFFSET_RB : + +// CXC/SHD EN +{0x01BC,0x57,0x01}, // CXC ON SHD ON INP ON GAIN OFF +}; + +static const isx012_regset_t ISX012_Flash_ON[] = +{ +//Flash_ON_SET +{0x00B7,0x15,0x01}, // LED_ON +{0x0016,0x10,0x01}, // GPIO_FUNCSEL +{0x0181,0x05,0x01}, // CAP_HALF_AE_CTRL +{0x01AE,0x01,0x01}, // HALF_AWB_CTRL +{0x6223,0x01,0x01}, // INIT_GAINS +{0x6226,0x01,0x01}, // ATW_GAINS_IN_NR +{0x6227,0x01,0x01}, // ATW_GAINS_IN +{0x6228,0x01,0x01}, // ATW_GAINS_OUT_NR +{0x6229,0x01,0x01}, // ATW_GAINS_OUT +{0x5E3D,0x0F,0x01}, // FASTMOVE_TIMEOUT +{0x5E32,0x0F,0x01}, // AESPEED_FAST +{0x5E2E,0x1A,0x01}, // AEIINDEADBAND +{0x500A,0x00,0x01}, // FAST_MODECHG_EN +{0x01AF,0x01,0x01}, // CAP_AWB_CTRL +{0x6224,0x01,0x01}, // ATW_DELAY +//AWB boundary set +{0x6400,0x00,0x01}, // INFRM_LEFT00 : +{0x6401,0x00,0x01}, // INFRM_LEFT01 : +{0x6402,0x00,0x01}, // INFRM_LEFT02 : +{0x6403,0x00,0x01}, // INFRM_LEFT03 : +{0x6404,0x00,0x01}, // INFRM_LEFT04 : +{0x6405,0x00,0x01}, // INFRM_LEFT05 : +{0x6406,0x00,0x01}, // INFRM_LEFT06 : +{0x6407,0x00,0x01}, // INFRM_LEFT07 : +{0x6408,0x00,0x01}, // INFRM_LEFT08 : +{0x6409,0x00,0x01}, // INFRM_LEFT09 : +{0x640A,0x00,0x01}, // INFRM_LEFT10 : +{0x640B,0x00,0x01}, // INFRM_LEFT11 : +{0x640C,0x00,0x01}, // INFRM_LEFT12 : +{0x640D,0x00,0x01}, // INFRM_LEFT13 : +{0x640E,0x00,0x01}, // INFRM_LEFT14 : +{0x640F,0x00,0x01}, // INFRM_LEFT15 : +{0x6410,0x00,0x01}, // INFRM_LEFT16 : +{0x6411,0x00,0x01}, // INFRM_LEFT17 : +{0x6412,0x00,0x01}, // INFRM_LEFT18 : +{0x6413,0x00,0x01}, // INFRM_LEFT19 : +{0x6414,0x00,0x01}, // INFRM_LEFT20 : +{0x6415,0x00,0x01}, // INFRM_LEFT21 : +{0x6416,0x00,0x01}, // INFRM_LEFT22 : +{0x6417,0x00,0x01}, // INFRM_LEFT23 : +{0x6418,0x00,0x01}, // INFRM_LEFT24 : +{0x6419,0x00,0x01}, // INFRM_LEFT25 : +{0x641A,0x00,0x01}, // INFRM_LEFT26 : +{0x641B,0x00,0x01}, // INFRM_LEFT27 : +{0x641C,0x00,0x01}, // INFRM_LEFT28 : +{0x641D,0x00,0x01}, // INFRM_LEFT29 : +{0x641E,0x00,0x01}, // INFRM_LEFT30 : +{0x641F,0x00,0x01}, // INFRM_LEFT31 : +{0x6420,0x00,0x01}, // INFRM_LEFT32 : +{0x6421,0x00,0x01}, // INFRM_LEFT33 : +{0x6422,0x00,0x01}, // INFRM_LEFT34 : +{0x6423,0x00,0x01}, // INFRM_LEFT35 : +{0x6424,0x00,0x01}, // INFRM_LEFT36 : +{0x6425,0x00,0x01}, // INFRM_LEFT37 : +{0x6426,0xFF,0x01}, // INFRM_RIGHT00 : +{0x6427,0xFF,0x01}, // INFRM_RIGHT01 : +{0x6428,0xFF,0x01}, // INFRM_RIGHT02 : +{0x6429,0xFF,0x01}, // INFRM_RIGHT03 : +{0x642A,0xFF,0x01}, // INFRM_RIGHT04 : +{0x642B,0xFF,0x01}, // INFRM_RIGHT05 : +{0x642C,0xFF,0x01}, // INFRM_RIGHT06 : +{0x642D,0xFF,0x01}, // INFRM_RIGHT07 : +{0x642E,0xFF,0x01}, // INFRM_RIGHT08 : +{0x642F,0xFF,0x01}, // INFRM_RIGHT09 : +{0x6430,0xFF,0x01}, // INFRM_RIGHT10 : +{0x6431,0xFF,0x01}, // INFRM_RIGHT11 : +{0x6432,0xFF,0x01}, // INFRM_RIGHT12 : +{0x6433,0xFF,0x01}, // INFRM_RIGHT13 : +{0x6434,0xFF,0x01}, // INFRM_RIGHT14 : +{0x6435,0xFF,0x01}, // INFRM_RIGHT15 : +{0x6436,0xFF,0x01}, // INFRM_RIGHT16 : +{0x6437,0xFF,0x01}, // INFRM_RIGHT17 : +{0x6438,0xFF,0x01}, // INFRM_RIGHT18 : +{0x6439,0xFF,0x01}, // INFRM_RIGHT19 : +{0x643A,0xFF,0x01}, // INFRM_RIGHT20 : +{0x643B,0xFF,0x01}, // INFRM_RIGHT21 : +{0x643C,0xFF,0x01}, // INFRM_RIGHT22 : +{0x643D,0xFF,0x01}, // INFRM_RIGHT23 : +{0x643E,0xFF,0x01}, // INFRM_RIGHT24 : +{0x643F,0xFF,0x01}, // INFRM_RIGHT25 : +{0x6440,0xFF,0x01}, // INFRM_RIGHT26 : +{0x6441,0xFF,0x01}, // INFRM_RIGHT27 : +{0x6442,0xFF,0x01}, // INFRM_RIGHT28 : +{0x6443,0xFF,0x01}, // INFRM_RIGHT29 : +{0x6444,0xFF,0x01}, // INFRM_RIGHT30 : +{0x6445,0xFF,0x01}, // INFRM_RIGHT31 : +{0x6446,0xFF,0x01}, // INFRM_RIGHT32 : +{0x6447,0xFF,0x01}, // INFRM_RIGHT33 : +{0x6448,0xFF,0x01}, // INFRM_RIGHT34 : +{0x6449,0xFF,0x01}, // INFRM_RIGHT35 : +{0x644A,0xFF,0x01}, // INFRM_RIGHT36 : +{0x644B,0xFF,0x01}, // INFRM_RIGHT37 : +{0x644C,0x25C2,0x02}, // INFRM_TOP : +{0x644E,0x0348,0x02}, // INFRM_BOTM : +{0x6450,0x1D,0x01}, // INFRM_FLTOP : +{0x6451,0x00,0x01}, // INFRM_FLBOTM : +//halfrelease_mode value +{0x0082,0x01,0x01}, // MONI_REFRESH +{0x00B1,0x01,0x01}, //AF_RESTART_F : +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x00,0x01}, //AFMODE_HREL : +{0xFFFF,0x42,0x01},//$wait, 66 +{0x0081,0x01,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_Flash_OFF[] = +{ +//Flash_OFF_RESET +{0x00B7,0x00,0x01}, // LED_ON +{0x0016,0x10,0x01}, // GPIO_FUNCSEL +{0x0181,0x00,0x01}, // CAP_HALF_AE_CTRL +{0x01AE,0x00,0x01}, // HALF_AWB_CTRL +{0x6223,0x04,0x01}, // INIT_GAINS +{0x6226,0x08,0x01}, // ATW_GAINS_IN_NR +{0x6227,0x04,0x01}, // ATW_GAINS_IN +{0x6228,0x08,0x01}, // ATW_GAINS_OUT_NR +{0x6229,0x04,0x01}, // ATW_GAINS_OUT +{0x5E3D,0x0A,0x01}, // FASTMOVE_TIMEOUT +{0x5E32,0x0F,0x01}, // AESPEED_FAST +{0x5E2E,0x1A,0x01}, // AEIINDEADBAND +{0x500A,0x00,0x01}, // FAST_MODECHG_EN +{0x01AF,0x00,0x01}, // CAP_AWB_CTRL +{0x6224,0x04,0x01}, // ATW_DELAY +//AWB boundary reset +{0x6400,0xAA,0x01}, // INFRM_LEFT00 : +{0x6401,0xAA,0x01}, // INFRM_LEFT01 : +{0x6402,0xAA,0x01}, // INFRM_LEFT02 : +{0x6403,0xAA,0x01}, // INFRM_LEFT03 : +{0x6404,0xAA,0x01}, // INFRM_LEFT04 : +{0x6405,0xAA,0x01}, // INFRM_LEFT05 : +{0x6406,0xAA,0x01}, // INFRM_LEFT06 : +{0x6407,0xAA,0x01}, // INFRM_LEFT07 : +{0x6408,0xAA,0x01}, // INFRM_LEFT08 : +{0x6409,0xAE,0x01}, // INFRM_LEFT09 : +{0x640A,0xA0,0x01}, // INFRM_LEFT10 : +{0x640B,0x8C,0x01}, // INFRM_LEFT11 : +{0x640C,0x72,0x01}, // INFRM_LEFT12 : +{0x640D,0x64,0x01}, // INFRM_LEFT13 : +{0x640E,0x5A,0x01}, // INFRM_LEFT14 : +{0x640F,0x52,0x01}, // INFRM_LEFT15 : +{0x6410,0x48,0x01}, // INFRM_LEFT16 : +{0x6411,0x43,0x01}, // INFRM_LEFT17 : +{0x6412,0x3D,0x01}, // INFRM_LEFT18 : +{0x6413,0x37,0x01}, // INFRM_LEFT19 : +{0x6414,0x33,0x01}, // INFRM_LEFT20 : +{0x6415,0x30,0x01}, // INFRM_LEFT21 : +{0x6416,0x2E,0x01}, // INFRM_LEFT22 : +{0x6417,0x2B,0x01}, // INFRM_LEFT23 : +{0x6418,0x28,0x01}, // INFRM_LEFT24 : +{0x6419,0x26,0x01}, // INFRM_LEFT25 : +{0x641A,0x24,0x01}, // INFRM_LEFT26 : +{0x641B,0x23,0x01}, // INFRM_LEFT27 : +{0x641C,0x22,0x01}, // INFRM_LEFT28 : +{0x641D,0x22,0x01}, // INFRM_LEFT29 : +{0x641E,0x21,0x01}, // INFRM_LEFT30 : +{0x641F,0x20,0x01}, // INFRM_LEFT31 : +{0x6420,0x1D,0x01}, // INFRM_LEFT32 : +{0x6421,0x1A,0x01}, // INFRM_LEFT33 : +{0x6422,0x18,0x01}, // INFRM_LEFT34 : +{0x6423,0x17,0x01}, // INFRM_LEFT35 : +{0x6424,0x16,0x01}, // INFRM_LEFT36 : +{0x6425,0x17,0x01}, // INFRM_LEFT37 : +{0x6426,0xAF,0x01}, // INFRM_RIGHT00 : +{0x6427,0xAF,0x01}, // INFRM_RIGHT01 : +{0x6428,0xAF,0x01}, // INFRM_RIGHT02 : +{0x6429,0xAF,0x01}, // INFRM_RIGHT03 : +{0x642A,0xAF,0x01}, // INFRM_RIGHT04 : +{0x642B,0xAF,0x01}, // INFRM_RIGHT05 : +{0x642C,0xAF,0x01}, // INFRM_RIGHT06 : +{0x642D,0xAF,0x01}, // INFRM_RIGHT07 : +{0x642E,0xAF,0x01}, // INFRM_RIGHT08 : +{0x642F,0xAA,0x01}, // INFRM_RIGHT09 : +{0x6430,0xB2,0x01}, // INFRM_RIGHT10 : +{0x6431,0xB4,0x01}, // INFRM_RIGHT11 : +{0x6432,0xB6,0x01}, // INFRM_RIGHT12 : +{0x6433,0xB4,0x01}, // INFRM_RIGHT13 : +{0x6434,0x9B,0x01}, // INFRM_RIGHT14 : +{0x6435,0x8E,0x01}, // INFRM_RIGHT15 : +{0x6436,0x84,0x01}, // INFRM_RIGHT16 : +{0x6437,0x7A,0x01}, // INFRM_RIGHT17 : +{0x6438,0x72,0x01}, // INFRM_RIGHT18 : +{0x6439,0x6A,0x01}, // INFRM_RIGHT19 : +{0x643A,0x63,0x01}, // INFRM_RIGHT20 : +{0x643B,0x5E,0x01}, // INFRM_RIGHT21 : +{0x643C,0x58,0x01}, // INFRM_RIGHT22 : +{0x643D,0x53,0x01}, // INFRM_RIGHT23 : +{0x643E,0x4E,0x01}, // INFRM_RIGHT24 : +{0x643F,0x4A,0x01}, // INFRM_RIGHT25 : +{0x6440,0x46,0x01}, // INFRM_RIGHT26 : +{0x6441,0x42,0x01}, // INFRM_RIGHT27 : +{0x6442,0x3F,0x01}, // INFRM_RIGHT28 : +{0x6443,0x3C,0x01}, // INFRM_RIGHT29 : +{0x6444,0x3A,0x01}, // INFRM_RIGHT30 : +{0x6445,0x38,0x01}, // INFRM_RIGHT31 : +{0x6446,0x37,0x01}, // INFRM_RIGHT32 : +{0x6447,0x35,0x01}, // INFRM_RIGHT33 : +{0x6448,0x33,0x01}, // INFRM_RIGHT34 : +{0x6449,0x32,0x01}, // INFRM_RIGHT35 : +{0x644A,0x32,0x01}, // INFRM_RIGHT36 : +{0x644B,0x32,0x01}, // INFRM_RIGHT37 : +{0x644C,0x24FA,0x02}, // INFRM_TOP : +{0x644E,0x0940,0x02}, // INFRM_BOTM : +{0x6450,0x19,0x01}, // INFRM_FLTOP : +{0x6451,0x10,0x01}, // INFRM_FLBOTM : +////Flash_ON_RESET +{0x0308,0x11,0x01}, // AELINE_MONI_SN1_2 : +{0x0309,0x13,0x01}, // AELINE_MONI_SN3_4 : +{0x030B,0x41,0x01}, // AELINE_MONI_SN7_8 : +{0x030D,0x11,0x01}, // AELINE_MONI_SN11_12 : +{0x030E,0x11,0x01}, // AELINE_HALF_SN1_2 : +{0x030F,0x13,0x01}, // AELINE_HALF_SN3_4 : +{0x0311,0x41,0x01}, // AELINE_HALF_SN7_8 : +{0x0313,0x11,0x01}, // AELINE_HALF_SN11_12 : +{0x0314,0x11,0x01}, // AELINE_HALF_AFEND_SN1_2 : +{0x0315,0x13,0x01}, // AELINE_HALF_AFEND_SN3_4 : +{0x0317,0x41,0x01}, // AELINE_HALF_AFEND_SN7_8 : +{0x0319,0x11,0x01}, // AELINE_HALF_AFEND_SN11_12 : +{0x031A,0x00,0x01}, // AELINE_CAP_SN1_2 : +{0x031B,0x03,0x01}, // AELINE_CAP_SN3_4 : +{0x031D,0x50,0x01}, // AELINE_CAP_SN7_8 : +{0x031F,0x00,0x01}, // AELINE_CAP_SN11_12 : +{0x0294,0x00,0x01}, // AE_SN1 +{0x0297,0x00,0x01}, // AE_SN4 +{0x029A,0x00,0x01}, // AE_SN7 +{0x029E,0x00,0x01}, // AE_SN11 +}; + +static const isx012_regset_t ISX012_Flash_AELINE[] = +{ +//Flash_ON_SET +{0x0308,0x12,0x01}, // AELINE_MONI_SN1_2 : +{0x0309,0x23,0x01}, // AELINE_MONI_SN3_4 : +{0x030B,0x42,0x01}, // AELINE_MONI_SN7_8 : +{0x030D,0x12,0x01}, // AELINE_MONI_SN11_12 : +{0x030E,0x12,0x01}, // AELINE_HALF_SN1_2 : +{0x030F,0x23,0x01}, // AELINE_HALF_SN3_4 : +{0x0311,0x42,0x01}, // AELINE_HALF_SN7_8 : +{0x0313,0x12,0x01}, // AELINE_HALF_SN11_12 : +{0x0314,0x12,0x01}, // AELINE_HALF_AFEND_SN1_2 : +{0x0315,0x23,0x01}, // AELINE_HALF_AFEND_SN3_4 : +{0x0317,0x42,0x01}, // AELINE_HALF_AFEND_SN7_8 : +{0x0319,0x12,0x01}, // AELINE_HALF_AFEND_SN11_12 : +{0x031A,0x02,0x01}, // AELINE_CAP_SN1_2 : +{0x031B,0x23,0x01}, // AELINE_CAP_SN3_4 : +{0x031D,0x52,0x01}, // AELINE_CAP_SN7_8 : +{0x031F,0x02,0x01}, // AELINE_CAP_SN11_12 : +}; + +static const isx012_regset_t ISX012_ae_manual_mode[] = +{ +{0x0294,0x02,0x01}, /* AE_SN1 */ +{0x0297,0x02,0x01}, /* AE_SN4 */ +{0x029A,0x02,0x01}, /* AE_SN7 */ +{0x029E,0x02,0x01}, /* AE_SN11 */ +{0xFFFF,0x42,0x01}, /* $wait, 66 */ +}; + +static const isx012_regset_t ISX012_flash_fast_ae_awb[] = +{ +{0x5E32,0x0A,0x01}, +{0x5E3D,0x05,0x01}, /* Don't fix me. 0x05 */ + +{0x0181,0x01,0x01}, // CAP_HALF_AE_CTRL +{0x00B2,0x03,0x01}, //AFMODE_MONI : AF OFF +{0x00B3,0x03,0x01}, //AFMODE_HREL : AF OFF +{0x0081,0x01,0x01}, //MODESEL +}; + +static const isx012_regset_t ISX012_Lowlux_Night_Reset[] = +{ +{0x039D,0x00,0x01}, //UIHUE_TYPE3 : +{0x03A0,0x80,0x01}, //UISATURATION_TYPE3 : +{0x982A,0xFFEC,0x02}, // CS_CBLLEV_A : +{0x9830,0xFFEC,0x02}, // CS_CRLLEV_A : +{0x9805,0x0A,0x01}, // CS_SLP_C_A : +{0x6A9E,0x15C0,0x02}, //HMAX_1_1(0x6A9E)=0x15C0 +{0x00AC,0x00,0x01}, // +{0x660E,0x5A,0x01}, // AF_HBPF_PEAK_OPD_TH_MIN +{0x6610,0x5A,0x01}, // AF_HBPF_PEAK_OPD_TH_MAX +{0x664A,0x04,0x01}, // AF_DROPN_ON_PEAK_DETECT : +{0x6640,0x02,0x01}, // AF_DROPN_ON_PEAK_DETECT_SECOND : +{0x0289,0x20,0x01}, //AWB_SN8 +}; + +#endif /* __ISX012_REGS_H__ */ diff --git a/drivers/media/video/samsung/fimc/fimc_capture.c b/drivers/media/video/samsung/fimc/fimc_capture.c index 7d00c8b..75928ed 100644 --- a/drivers/media/video/samsung/fimc/fimc_capture.c +++ b/drivers/media/video/samsung/fimc/fimc_capture.c @@ -1435,7 +1435,7 @@ int fimc_s_fmt_vid_private(struct file *file, void *fh, struct v4l2_format *f) mbus_fmt = &ctrl->cap->mbus_fmt; mbus_fmt->width = pix->width; mbus_fmt->height = pix->height; -#ifdef CONFIG_MACH_P4NOTE +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) /* Unfortuntely, we have to use pix->field (not pix->priv) since * pix.field is already used in the below else condtion statement * (in case that sub-devices are not registered) @@ -1927,12 +1927,16 @@ int fimc_reqbufs_capture_mmap(void *fh, struct v4l2_requestbuffers *b) case V4L2_PIX_FMT_YVYU: /* fall through */ case V4L2_PIX_FMT_NV16: /* fall through */ case V4L2_PIX_FMT_NV61: /* fall through */ + fimc_err("%s : V4L2_PIX_FMT_YUYV - SBRISSEN\n", __func__); + fimc_err("%s : w %d h %d \n",__func__, + cap->fmt.width, cap->fmt.height); fimc_info1("%s : 1plane\n", __func__); ret = fimc_alloc_buffers(ctrl, 1, cap->fmt.width * cap->fmt.height, SZ_4K, bpp, cap->pktdata_enable, cap->pktdata_size); break; case V4L2_PIX_FMT_NV21: + fimc_err("%s : V4L2_PIX_FMT_NV12 - SBRISSEN\n", __func__); fimc_info1("%s : 2plane for NV21 w %d h %d\n", __func__, cap->fmt.width, cap->fmt.height); ret = fimc_alloc_buffers(ctrl, 2, @@ -1940,6 +1944,7 @@ int fimc_reqbufs_capture_mmap(void *fh, struct v4l2_requestbuffers *b) break; case V4L2_PIX_FMT_NV12: + fimc_info1("%s : 2plane for NV12\n", __func__); ret = fimc_alloc_buffers(ctrl, 2, cap->fmt.width * cap->fmt.height, SZ_64K, bpp, cap->pktdata_enable, cap->pktdata_size); @@ -1961,18 +1966,21 @@ int fimc_reqbufs_capture_mmap(void *fh, struct v4l2_requestbuffers *b) break; case V4L2_PIX_FMT_JPEG: + fimc_err("%s : V4L2_PIX_FMT_JPEG - SBRISSEN\n", __func__); fimc_info1("%s : JPEG 1plane\n", __func__); size = fimc_camera_get_jpeg_memsize(ctrl); fimc_info2("%s : JPEG 1plane size = %x\n", __func__, size); ret = fimc_alloc_buffers(ctrl, 1, size, 0, 8, cap->pktdata_enable, cap->pktdata_size); break; case V4L2_PIX_FMT_INTERLEAVED: + fimc_err("%s : V4L2_PIX_FMT_INTERLEAVED - SBRISSEN\n", __func__); fimc_info1("%s : Interleaved Format\n", __func__); size = fimc_camera_get_jpeg_memsize(ctrl); /*0xA00000*/ fimc_info2("%s : Interleaved size = %x\n", __func__, size); ret = fimc_alloc_buffers(ctrl, 1, size, 0, 8, cap->pktdata_enable, cap->pktdata_size); break; default: + fimc_err("%s : default - SBRISSEN\n", __func__); break; } @@ -1982,6 +1990,7 @@ int fimc_reqbufs_capture_mmap(void *fh, struct v4l2_requestbuffers *b) return -ENOMEM; } + fimc_err("%s : SBRISSEN - done\n", __func__); mutex_unlock(&ctrl->v4l2_lock); return 0; @@ -2248,7 +2257,7 @@ int fimc_s_ctrl_capture(void *fh, struct v4l2_control *c) clk_disable(ctrl->cam->clk); fimc->mclk_status = CAM_MCLK_OFF; ctrl->cam->initialized = 0; -#ifdef CONFIG_MACH_P4NOTE +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) /* 100ms: increase delay. * There are cases that sensor doesn't get revived * inspite of doing power reset.*/ @@ -2723,7 +2732,7 @@ int fimc_streamon_capture(void *fh) } } -#ifdef CONFIG_MACH_P4NOTE +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) #ifdef CONFIG_VIDEO_IMPROVE_STREAMOFF v4l2_subdev_call(cam->sd, video, s_stream, STREAM_MODE_WAIT_OFF); @@ -2753,7 +2762,7 @@ int fimc_streamon_capture(void *fh) cap->fmt.pixelformat); } } -#ifdef CONFIG_MACH_P4NOTE +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) if (1) { #else if (cap->fmt.priv != V4L2_PIX_FMT_MODE_CAPTURE) { diff --git a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c index 7fbea2a..8ff3d37 100644 --- a/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c +++ b/drivers/media/video/samsung/mali/common/mali_kernel_mem_os.c @@ -243,7 +243,15 @@ static void os_allocator_release(void * ctx, void * handle) static mali_physical_memory_allocation_result os_allocator_allocate_page_table_block(void * ctx, mali_page_table_block * block) { - int allocation_order = 11; /* _MALI_OSK_CPU_PAGE_SIZE << 11 */ +#if defined(CONFIG_MACH_KONA) +#ifndef CONFIG_FORCE_MAX_ZONEORDER + int allocation_order = 10; +#else + int allocation_order = CONFIG_FORCE_MAX_ZONEORDER - 1; +#endif +#else + int allocation_order = 11; /* _MALI_OSK_CPU_PAGE_SIZE << 6 */ +#endif void *virt = NULL; u32 size = _MALI_OSK_CPU_PAGE_SIZE << allocation_order; os_allocator * info; diff --git a/drivers/media/video/sr130pc20.c b/drivers/media/video/sr130pc20.c new file mode 100644 index 0000000..ab2b8d5 --- /dev/null +++ b/drivers/media/video/sr130pc20.c @@ -0,0 +1,1999 @@ +/* drivers/media/video/sr130pc20.c + * + * Copyright (c) 2010, Samsung Electronics. All rights reserved + * Author: dongseong.lim + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * 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. + * + * - change date: 2012.06.28 + */ +#include "sr130pc20.h" +#include <linux/gpio.h> + +#define i2c_read_nop() \ + (cam_err("error, not used read function, line %d\n", __LINE__)) +#define i2c_write_nop() \ + (cam_err("error, not used write function, line %d\n", __LINE__)) + +#define isx012_readb(sd, addr, data) i2c_read_nop() +#define isx012_writeb(sd, addr, data) i2c_write_nop() + +#define sr130pc20_readb(sd, addr, data) sr130pc20_i2c_read(sd, addr, data) +#define sr130pc20_readw(sd, addr, data) i2c_read_nop() +#define sr130pc20_readl(sd, addr, data) i2c_read_nop() +#define sr130pc20_writeb(sd, addr, data) sr130pc20_i2c_write(sd, addr, data) +#define sr130pc20_writew(sd, addr, data) i2c_write_nop() +#define sr130pc20_writel(sd, addr, data) i2c_write_nop() + +static int dbg_level; + +static const struct sr130pc20_fps sr130pc20_framerates[] = { + { I_FPS_0, FRAME_RATE_AUTO }, + { I_FPS_7, FRAME_RATE_7}, + { I_FPS_15, FRAME_RATE_15 }, + { I_FPS_25, FRAME_RATE_25 }, + { I_FPS_30, FRAME_RATE_30 }, +}; + +static const struct sr130pc20_framesize sr130pc20_preview_frmsizes[] = { + { PREVIEW_SZ_320x240, 320, 240 }, + { PREVIEW_SZ_CIF, 352, 288 }, + { PREVIEW_SZ_VGA, 640, 480 }, +}; + +static const struct sr130pc20_framesize sr130pc20_capture_frmsizes[] = { +/* { CAPTURE_SZ_VGA, 640, 480 },*/ + { CAPTURE_SZ_1MP, 1280, 960 }, +}; + +static struct sr130pc20_control sr130pc20_ctrls[] = { + SR130PC20_INIT_CONTROL(V4L2_CID_CAMERA_FLASH_MODE, \ + FLASH_MODE_OFF), + + SR130PC20_INIT_CONTROL(V4L2_CID_CAMERA_BRIGHTNESS, \ + EV_DEFAULT), + + SR130PC20_INIT_CONTROL(V4L2_CID_CAMERA_METERING, \ + METERING_MATRIX), + + SR130PC20_INIT_CONTROL(V4L2_CID_CAMERA_WHITE_BALANCE, \ + WHITE_BALANCE_AUTO), + + SR130PC20_INIT_CONTROL(V4L2_CID_CAMERA_EFFECT, \ + IMAGE_EFFECT_NONE), +}; + +static const struct sr130pc20_regs reg_datas = { + .ev = { + SR130PC20_REGSET(GET_EV_INDEX(EV_MINUS_4), + SR130PC20_ExpSetting_M4Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_MINUS_3), + SR130PC20_ExpSetting_M3Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_MINUS_2), + SR130PC20_ExpSetting_M2Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_MINUS_1), + SR130PC20_ExpSetting_M1Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_DEFAULT), + SR130PC20_ExpSetting_Default, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_PLUS_1), + SR130PC20_ExpSetting_P1Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_PLUS_2), + SR130PC20_ExpSetting_P2Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_PLUS_3), + SR130PC20_ExpSetting_P3Step, 0), + SR130PC20_REGSET(GET_EV_INDEX(EV_PLUS_4), + SR130PC20_ExpSetting_P4Step, 0), + }, + .metering = { + SR130PC20_REGSET(METERING_MATRIX, sr130pc20_Metering_Matrix, 0), + SR130PC20_REGSET(METERING_CENTER, sr130pc20_Metering_Center, 0), + SR130PC20_REGSET(METERING_SPOT, sr130pc20_Metering_Spot, 0), + }, + .iso = { + SR130PC20_REGSET(ISO_AUTO, sr130pc20_ISO_Auto, 0), + SR130PC20_REGSET(ISO_50, sr130pc20_ISO_50, 0), + SR130PC20_REGSET(ISO_100, sr130pc20_ISO_100, 0), + SR130PC20_REGSET(ISO_200, sr130pc20_ISO_200, 0), + SR130PC20_REGSET(ISO_400, sr130pc20_ISO_400, 0), + }, + .effect = { + SR130PC20_REGSET(IMAGE_EFFECT_NONE, sr130pc20_Effect_Normal, 0), + SR130PC20_REGSET(IMAGE_EFFECT_BNW, sr130pc20_Effect_Black_White, 0), + SR130PC20_REGSET(IMAGE_EFFECT_SEPIA, sr130pc20_Effect_Sepia, 0), + SR130PC20_REGSET(IMAGE_EFFECT_NEGATIVE, + SR130PC20_Effect_Negative, 0), + SR130PC20_REGSET(IMAGE_EFFECT_SOLARIZE, sr130pc20_Effect_Solar, 0), + SR130PC20_REGSET(IMAGE_EFFECT_SKETCH, sr130pc20_Effect_Sketch, 0), + SR130PC20_REGSET(IMAGE_EFFECT_POINT_COLOR_3, + sr130pc20_Effect_Pastel, 0), + }, + .white_balance = { + SR130PC20_REGSET(WHITE_BALANCE_AUTO, sr130pc20_WB_Auto, 0), + SR130PC20_REGSET(WHITE_BALANCE_SUNNY, sr130pc20_WB_Sunny, 0), + SR130PC20_REGSET(WHITE_BALANCE_CLOUDY, sr130pc20_WB_Cloudy, 0), + SR130PC20_REGSET(WHITE_BALANCE_TUNGSTEN, + sr130pc20_WB_Tungsten, 0), + SR130PC20_REGSET(WHITE_BALANCE_FLUORESCENT, + sr130pc20_WB_Fluorescent, 0), + }, + .scene_mode = { + SR130PC20_REGSET(SCENE_MODE_NONE, sr130pc20_Scene_Default, 0), + SR130PC20_REGSET(SCENE_MODE_PORTRAIT, sr130pc20_Scene_Portrait, 0), + SR130PC20_REGSET(SCENE_MODE_NIGHTSHOT, sr130pc20_Scene_Nightshot, 0), + SR130PC20_REGSET(SCENE_MODE_BACK_LIGHT, sr130pc20_Scene_Backlight, 0), + SR130PC20_REGSET(SCENE_MODE_LANDSCAPE, sr130pc20_Scene_Landscape, 0), + SR130PC20_REGSET(SCENE_MODE_SPORTS, sr130pc20_Scene_Sports, 0), + SR130PC20_REGSET(SCENE_MODE_PARTY_INDOOR, + sr130pc20_Scene_Party_Indoor, 0), + SR130PC20_REGSET(SCENE_MODE_BEACH_SNOW, + sr130pc20_Scene_Beach_Snow, 0), + SR130PC20_REGSET(SCENE_MODE_SUNSET, sr130pc20_Scene_Sunset, 0), + SR130PC20_REGSET(SCENE_MODE_DUSK_DAWN, sr130pc20_Scene_Duskdawn, 0), + SR130PC20_REGSET(SCENE_MODE_FALL_COLOR, + sr130pc20_Scene_Fall_Color, 0), + SR130PC20_REGSET(SCENE_MODE_FIREWORKS, sr130pc20_Scene_Fireworks, 0), + SR130PC20_REGSET(SCENE_MODE_TEXT, sr130pc20_Scene_Text, 0), + SR130PC20_REGSET(SCENE_MODE_CANDLE_LIGHT, + sr130pc20_Scene_Candle_Light, 0), + }, + .fps = { + SR130PC20_REGSET(I_FPS_0, sr130pc20_fps_auto, 0), + SR130PC20_REGSET(I_FPS_7, sr130pc20_fps_7fix, 0), + SR130PC20_REGSET(I_FPS_15, sr130pc20_fps_15fix, 0), + SR130PC20_REGSET(I_FPS_25, sr130pc20_fps_25fix, 0), + SR130PC20_REGSET(I_FPS_30, sr130pc20_fps_30fix, 0), + }, + .preview_size = { + SR130PC20_REGSET(PREVIEW_SZ_320x240, + sr130pc20_320_240_Preview, 0), + SR130PC20_REGSET(PREVIEW_SZ_CIF, sr130pc20_352_288_Preview, 0), + SR130PC20_REGSET(PREVIEW_SZ_VGA, sr130pc20_640_480_Preview, 0), + }, + .capture_size = { + /*SR130PC20_REGSET(CAPTURE_SZ_VGA, sr130pc20_VGA_Capture, 0),*/ + SR130PC20_REGSET(CAPTURE_SZ_1MP, sr130pc20_1280_960_Capture, 0), + }, + + .init_reg = SR130PC20_REGSET_TABLE(SR130PC20_Init_Reg, 0), + .VT_init_reg = SR130PC20_REGSET_TABLE(sr130pc20_VT_Init_Reg, 0), + .SS_init_reg = SR130PC20_REGSET_TABLE(sr130pc20_SmartStay_Init_Reg, 0), + /* Camera mode */ + .preview_mode = SR130PC20_REGSET_TABLE(SR130PC20_Preview_Mode, 0), + .capture_mode = SR130PC20_REGSET_TABLE(SR130PC20_Capture_Mode, 0), + .capture_mode_night = + SR130PC20_REGSET_TABLE(SR130PC20_Lowlux_Night_Capture_Mode, 0), + .stream_stop = SR130PC20_REGSET_TABLE(sr130pc20_stop_stream, 0), +}; + +static const struct v4l2_mbus_framefmt capture_fmts[] = { + { + .code = V4L2_MBUS_FMT_FIXED, + .colorspace = V4L2_COLORSPACE_JPEG, + }, +}; + +/** + * msleep_debug: wrapper function calling proper sleep() + * @msecs: time to be sleep (in milli-seconds unit) + * @dbg_on: whether enable log or not. + */ +static void msleep_debug(u32 msecs, bool dbg_on) +{ + u32 delta_halfrange; /* in us unit */ + + if (unlikely(!msecs)) + return; + + if (dbg_on) + cam_dbg("delay for %dms\n", msecs); + + if (msecs <= 7) + delta_halfrange = 100; + else + delta_halfrange = 300; + + if (msecs <= 20) + usleep_range((msecs * 1000 - delta_halfrange), + (msecs * 1000 + delta_halfrange)); + else + msleep(msecs); +} + +#ifdef CONFIG_LOAD_FILE +#define TABLE_MAX_NUM 500 +static char *sr130pc20_regs_table; +static int sr130pc20_regs_table_size; +static int gtable_buf[TABLE_MAX_NUM]; +static int sr130pc20_i2c_write(struct v4l2_subdev *sd, + u8 subaddr, u8 data); + +int sr130pc20_regs_table_init(void) +{ + struct file *filp; + char *dp; + long l; + loff_t pos; + int ret; + mm_segment_t fs = get_fs(); + + cam_info("%s %d\n", __func__, __LINE__); + + set_fs(get_ds()); + + filp = filp_open("/mnt/sdcard/sr130pc20_regs.h", O_RDONLY, 0); + + if (IS_ERR_OR_NULL(filp)) { + cam_err("file open error\n"); + return PTR_ERR(filp); + } + + l = filp->f_path.dentry->d_inode->i_size; + cam_trace("l = %ld\n", l); + //dp = kmalloc(l, GFP_KERNEL); + dp = vmalloc(l); + if (dp == NULL) { + cam_err("Out of Memory\n"); + filp_close(filp, current->files); + return -EINVAL; + } + + pos = 0; + memset(dp, 0, l); + ret = vfs_read(filp, (char __user *)dp, l, &pos); + + if (ret != l) { + cam_err("Failed to read file ret = %d\n", ret); + /*kfree(dp);*/ + vfree(dp); + filp_close(filp, current->files); + return -EINVAL; + } + + filp_close(filp, current->files); + + set_fs(fs); + + sr130pc20_regs_table = dp; + + sr130pc20_regs_table_size = l; + + *((sr130pc20_regs_table + sr130pc20_regs_table_size) - 1) = '\0'; + + printk("sr130pc20_reg_table_init end\n"); + return 0; +} + +void sr130pc20_regs_table_exit(void) +{ + printk(KERN_DEBUG "%s %d\n", __func__, __LINE__); + + if (sr130pc20_regs_table) { + vfree(sr130pc20_regs_table); + sr130pc20_regs_table = NULL; + } +} + +static int sr130pc20_is_hexnum(char *num) +{ + int i = 0; + for (i = 2; num[i] != '\0'; i++) { + if (!((num[i] >= '0' && num[5] <= '9') + || (num[5] >= 'a' && num[5] <= 'f') || (num[5] >= 'A' + && num[5] <= + 'F'))) { + return 0; + } + } + return 1; +} + +static int sr130pc20_write_regs_from_sd(struct v4l2_subdev *sd, + const char *name) +{ + char *start = NULL, *end = NULL, *reg = NULL, *temp = NULL; + unsigned char addr = 0, value = 0; + unsigned short data = 0; + char data_buf[7] = { 0 }; + int err = 0; + + cam_info("Enter!!\n"); + + addr = value = 0; + + *(data_buf + 6) = '\0'; + + start = strnstr(sr130pc20_regs_table, name, sr130pc20_regs_table_size); + if (start == NULL) { + cam_err("[%s : %d] start is NULL\n", __func__, __LINE__); + err = -EIO; + return err; + } + + end = strnstr(start, "};", sr130pc20_regs_table_size); + if (end == NULL) { + cam_err("[%s : %d] end is NULL\n", __func__, __LINE__); + err = -EIO; + return err; + } + + while (1) { + /* Find Address */ + reg = strnstr(start, "0x", sr130pc20_regs_table_size); + if (reg) + start = (reg + 6); + + if ((reg == NULL) || (reg > end)) { + cam_err("[%s : %d] write end of %s\n", + __func__, __LINE__, name); + break; + } + /* Write Value to Address */ + memcpy(data_buf, reg, 6); + + if (sr130pc20_is_hexnum(data_buf) == 0) { + cam_err("[%s : %d] it's not hex number %s\n", + __func__, __LINE__, data_buf); + continue; + } + + err = kstrtou16(data_buf, 16, &data); + if (err < 0) { + cam_err("[%s : %d] kstrtou16 failed\n", + __func__, __LINE__); + } + addr = (data >> 8); + value = (data & 0xff); + + if (addr == 0xff) { + msleep(value * 10); /*one step is 10ms */ + cam_trace("delay %d msec\n", value * 10); + } else { + if (sr130pc20_i2c_write(sd, addr, value) < 0) { + cam_err + ("[%s : %d] fail on sensor_write :" + "addr[0x%04x], value[0x%04x]\n", + __func__, __LINE__, addr, value); + err = -EIO; + return err; + } + cam_trace + ("success on sensor_write :" + "addr[0x%04x], value[0x%04x]\n", addr, value); + } + } + + cam_info("Exit!!\n"); + + return err; +} +#endif + +/** + * sr130pc20_read: read data from sensor with I2C + * Note the data-store way(Big or Little) + */ +static int sr130pc20_i2c_read(struct v4l2_subdev *sd, + u8 subaddr, u8 *data) +{ + int err = -EIO; + struct i2c_client *client = v4l2_get_subdevdata(sd); + struct i2c_msg msg[2]; + u8 buf[16] = {0,}; + int retry = 5; + + + CHECK_ERR_COND_MSG(!client->adapter, -ENODEV, + "can't search i2c client adapter\n"); + + msg[0].addr = client->addr; + msg[0].flags = 0; + msg[0].len = sizeof(subaddr); + msg[0].buf = &subaddr; + + msg[1].addr = client->addr; + msg[1].flags = I2C_M_RD; + msg[1].len = 1; + msg[1].buf = buf; + + while (retry-- > 0) { + err = i2c_transfer(client->adapter, msg, 2); + if (likely(err == 2)) + break; + cam_err("i2c read: error, read register(0x%X). cnt %d\n", + subaddr, retry); + msleep_debug(POLL_TIME_MS, false); + } + + CHECK_ERR_COND_MSG(err != 2, -EIO, "I2C does not work\n"); + + *data = buf[0]; + + return 0; +} + +/** + * sr130pc20_write: write data with I2C + * Note the data-store way(Big or Little) + */ +static inline int sr130pc20_i2c_write(struct v4l2_subdev *sd, + u8 subaddr, u8 data) +{ + u8 buf[2]; + int err = 0, retry = 5; + struct i2c_client *client = v4l2_get_subdevdata(sd); + struct i2c_msg msg = { + .addr = client->addr, + .flags = 0, + .buf = buf, + .len = 2, + }; + + CHECK_ERR_COND_MSG(!client->adapter, -ENODEV, + "can't search i2c client adapter\n"); + + buf[0] = subaddr; + buf[1] = data; + + while (retry-- > 0) { + err = i2c_transfer(client->adapter, &msg, 1); + if (likely(err == 1)) + break; + cam_err("i2c write: error %d, write 0x%04X, retry %d\n", + err, ((subaddr << 8) | data), retry); + msleep_debug(POLL_TIME_MS, false); + } + + CHECK_ERR_COND_MSG(err != 1, -EIO, "I2C does not work\n"); + return 0; +} + +static int sr130pc20_i2c_burst_write_list(struct v4l2_subdev *sd, + const sr130pc20_regset_t regs[], int size, const char *name) +{ + + cam_err("burst write: not implemented\n"); + + return 0; +} + +static inline int sr130pc20_write_regs(struct v4l2_subdev *sd, + const sr130pc20_regset_t regs[], int size) +{ + int err = 0, i; + u8 subaddr, value; + + cam_trace("size %d\n", size); + + for (i = 0; i < size; i++) { + subaddr = (u8)(regs[i] >> 8); + value = (u8)(regs[i]); + if (unlikely(DELAY_SEQ == subaddr)) + msleep_debug(value * 10, true); + else { + err = sr130pc20_writeb(sd, subaddr, value); + CHECK_ERR_MSG(err, "register set failed\n") + } + } + + return 0; +} + +/* PX: */ +static int sr130pc20_set_from_table(struct v4l2_subdev *sd, + const char *setting_name, + const struct regset_table *table, + u32 table_size, s32 index) +{ + int err = 0; + + cam_trace("set %s index %d\n", setting_name, index); + + CHECK_ERR_COND_MSG(((index < 0) || (index >= table_size)), + -EINVAL, "index(%d) out of range[0:%d] for table for %s\n", + index, table_size, setting_name); + + table += index; + +#ifdef CONFIG_LOAD_FILE + cam_dbg("%s: \"%s\", reg_name=%s\n", __func__, + setting_name, table->name); + return sr130pc20_write_regs_from_sd(sd, table->name); + +#else /* !CONFIG_LOAD_FILE */ + CHECK_ERR_COND_MSG(!table->reg, -EFAULT, \ + "table=%s, index=%d, reg = NULL\n", setting_name, index); +# ifdef DEBUG_WRITE_REGS + cam_dbg("write_regtable: \"%s\", reg_name=%s\n", setting_name, + table->name); +# endif /* DEBUG_WRITE_REGS */ + + if (table->burst) { + err = sr130pc20_i2c_burst_write_list(sd, + table->reg, table->array_size, setting_name); + } else + err = sr130pc20_write_regs(sd, table->reg, table->array_size); + + CHECK_ERR_MSG(err, "write regs(%s), err=%d\n", setting_name, err); + + return 0; +#endif /* CONFIG_LOAD_FILE */ +} + +static inline int sr130pc20_transit_preview_mode(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + if (state->exposure.ae_lock || state->wb.awb_lock) + cam_info("Restore user ae(awb)-lock...\n"); + + err = sr130pc20_set_from_table(sd, "preview_mode", + &state->regs->preview_mode, 1, 0); + + return err; +} + +static inline int sr130pc20_transit_capture_mode(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -EIO; + + if (state->capture.lowlux_night) { + cam_info("capture_mode: night lowlux\n"); + err = sr130pc20_set_from_table(sd, "capture_mode_night", + &state->regs->capture_mode_night, 1, 0); + } else + err = sr130pc20_set_from_table(sd, "capture_mode", + &state->regs->capture_mode, 1, 0); + + return err; +} + +/** + * sr130pc20_transit_movie_mode: switch camera mode if needed. + * Note that this fuction should be called from start_preview(). + */ +static inline int sr130pc20_transit_movie_mode(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + + /* we'll go from the below modes to RUNNING or RECORDING */ + switch (state->runmode) { + case RUNMODE_INIT: + /* case of entering camcorder firstly */ + break; + case RUNMODE_RUNNING_STOP: + /* case of switching from camera to camcorder */ + break; + case RUNMODE_RECORDING_STOP: + /* case of switching from camcorder to camera */ + break; + + default: + break; + } + + return 0; +} + +/** + * sr130pc20_is_hwflash_on - check whether flash device is on + * + * Refer to state->flash.on to check whether flash is in use in driver. + */ +static inline int sr130pc20_is_hwflash_on(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + +#ifdef SR130PC20_SUPPORT_FLASH + return state->pdata->is_flash_on(); +#else + return 0; +#endif +} + +/** + * sr130pc20_flash_en - contro Flash LED + * @mode: SR130PC20_FLASH_MODE_NORMAL or SR130PC20_FLASH_MODE_MOVIE + * @onoff: SR130PC20_FLASH_ON or SR130PC20_FLASH_OFF + */ +static int sr130pc20_flash_en(struct v4l2_subdev *sd, s32 mode, s32 onoff) +{ + struct sr130pc20_state *state = to_state(sd); + + if (unlikely(state->flash.ignore_flash)) { + cam_warn("WARNING, we ignore flash command.\n"); + return 0; + } + +#ifdef SR130PC20_SUPPORT_FLASH + return state->pdata->flash_en(mode, onoff); +#else + return 0; +#endif +} + +/** + * sr130pc20_flash_torch - turn flash on/off as torch for preflash, recording + * @onoff: SR130PC20_FLASH_ON or SR130PC20_FLASH_OFF + * + * This func set state->flash.on properly. + */ +static inline int sr130pc20_flash_torch(struct v4l2_subdev *sd, s32 onoff) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + err = sr130pc20_flash_en(sd, SR130PC20_FLASH_MODE_MOVIE, onoff); + state->flash.on = (onoff == SR130PC20_FLASH_ON) ? 1 : 0; + + return err; +} + +/** + * sr130pc20_flash_oneshot - turn main flash on for capture + * @onoff: SR130PC20_FLASH_ON or SR130PC20_FLASH_OFF + * + * Main flash is turn off automatically in some milliseconds. + */ +static inline int sr130pc20_flash_oneshot(struct v4l2_subdev *sd, s32 onoff) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + err = sr130pc20_flash_en(sd, SR130PC20_FLASH_MODE_NORMAL, onoff); + state->flash.on = (onoff == SR130PC20_FLASH_ON) ? 1 : 0; + + return err; +} + +static const struct sr130pc20_framesize *sr130pc20_get_framesize + (const struct sr130pc20_framesize *frmsizes, + u32 frmsize_count, u32 index) +{ + int i = 0; + + for (i = 0; i < frmsize_count; i++) { + if (frmsizes[i].index == index) + return &frmsizes[i]; + } + + return NULL; +} + +/* This function is called from the g_ctrl api + * + * This function should be called only after the s_fmt call, + * which sets the required width/height value. + * + * It checks a list of available frame sizes and sets the + * most appropriate frame size. + * + * The list is stored in an increasing order (as far as possible). + * Hence the first entry (searching from the beginning) where both the + * width and height is more than the required value is returned. + * In case of no perfect match, we set the last entry (which is supposed + * to be the largest resolution supported.) + */ +static void sr130pc20_set_framesize(struct v4l2_subdev *sd, + const struct sr130pc20_framesize *frmsizes, + u32 num_frmsize, bool preview) +{ + struct sr130pc20_state *state = to_state(sd); + const struct sr130pc20_framesize **found_frmsize = NULL; + u32 width = state->req_fmt.width; + u32 height = state->req_fmt.height; + int i = 0; + + cam_dbg("%s: Requested Res %dx%d\n", __func__, + width, height); + + found_frmsize = preview ? + &state->preview.frmsize : &state->capture.frmsize; + + for (i = 0; i < num_frmsize; i++) { + if ((frmsizes[i].width == width) && + (frmsizes[i].height == height)) { + *found_frmsize = &frmsizes[i]; + break; + } + } + + if (*found_frmsize == NULL) { + cam_err("%s: error, invalid frame size %dx%d\n", + __func__, width, height); + *found_frmsize = preview ? + sr130pc20_get_framesize(frmsizes, num_frmsize, + PREVIEW_SZ_VGA) : + sr130pc20_get_framesize(frmsizes, num_frmsize, + CAPTURE_SZ_1MP); + BUG_ON(!(*found_frmsize)); + } + + if (preview) + cam_info("Preview Res Set: %dx%d, index %d\n", + (*found_frmsize)->width, (*found_frmsize)->height, + (*found_frmsize)->index); + else + cam_info("Capture Res Set: %dx%d, index %d\n", + (*found_frmsize)->width, (*found_frmsize)->height, + (*found_frmsize)->index); +} + +/* PX: Set scene mode */ +static int sr130pc20_set_scene_mode(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + + cam_trace("E, value %d\n", val); + +retry: + switch (val) { + case SCENE_MODE_NONE: + case SCENE_MODE_PORTRAIT: + case SCENE_MODE_NIGHTSHOT: + case SCENE_MODE_BACK_LIGHT: + case SCENE_MODE_LANDSCAPE: + case SCENE_MODE_SPORTS: + case SCENE_MODE_PARTY_INDOOR: + case SCENE_MODE_BEACH_SNOW: + case SCENE_MODE_SUNSET: + case SCENE_MODE_DUSK_DAWN: + case SCENE_MODE_FALL_COLOR: + case SCENE_MODE_FIREWORKS: + case SCENE_MODE_TEXT: + case SCENE_MODE_CANDLE_LIGHT: + sr130pc20_set_from_table(sd, "scene_mode", + state->regs->scene_mode, + ARRAY_SIZE(state->regs->scene_mode), val); + break; + + default: + cam_err("set_scene: error, not supported (%d)\n", val); + val = SCENE_MODE_NONE; + goto retry; + } + + state->scene_mode = val; + + cam_trace("X\n"); + return 0; +} + +/* PX: Set brightness */ +static int sr130pc20_set_exposure(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + if ((val < EV_MINUS_4) || (val > EV_PLUS_4)) { + cam_err("%s: error, invalid value(%d)\n", __func__, val); + return -EINVAL; + } + + sr130pc20_set_from_table(sd, "brightness", state->regs->ev, + ARRAY_SIZE(state->regs->ev), GET_EV_INDEX(val)); + + state->exposure.val = val; + + return err; +} + +static int sr130pc20_set_vt_mode(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + if (val == PREVIEW_VIDEOCALL) { + err = sr130pc20_set_from_table(sd, "VT_init_reg", + &state->regs->VT_init_reg, 1, 0); + cam_info("VT Mode\n"); + } else if (val == PREVIEW_SMARTSTAY) { + err = sr130pc20_set_from_table(sd, "SS_init_reg", + &state->regs->SS_init_reg, 1, 0); + cam_info("SMART STAY Mode\n"); + } + + state->vt_mode = val; + + return err; +} + +/* PX(NEW) */ +static int sr130pc20_set_capture_size(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + u32 width, height; + + if (unlikely(!state->capture.frmsize)) { + cam_warn("warning, capture resolution not set\n"); + state->capture.frmsize = sr130pc20_get_framesize( + sr130pc20_capture_frmsizes, + ARRAY_SIZE(sr130pc20_capture_frmsizes), + CAPTURE_SZ_1MP); + } + + width = state->capture.frmsize->width; + height = state->capture.frmsize->height; + + state->preview.update_frmsize = 1; + + cam_dbg("set capture size(%dx%d)\n", width, height); + + return 0; +} + +/* PX: Set sensor mode */ +static int sr130pc20_set_sensor_mode(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + + cam_trace("mode=%d\n", val); + + switch (val) { + case SENSOR_MOVIE: + /* We does not support movie mode when in VT. */ + if (state->vt_mode) { + state->sensor_mode = SENSOR_CAMERA; + cam_err("%s: error, Not support movie\n", __func__); + break; + } + /* We do not break. */ + + case SENSOR_CAMERA: + state->sensor_mode = val; + break; + + default: + cam_err("%s: error, Not support.(%d)\n", __func__, val); + state->sensor_mode = SENSOR_CAMERA; + WARN_ON(1); + break; + } + + return 0; +} + +/* PX: Set framerate */ +static int sr130pc20_set_frame_rate(struct v4l2_subdev *sd, s32 fps) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -EIO; + int i = 0, fps_index = -1; + + if (!state->initialized || (state->req_fps < 0)) + return 0; + + cam_info("set frame rate %d\n", fps); + + if (fps > 25) + fps = 25; /* sensor limitation */ + + for (i = 0; i < ARRAY_SIZE(sr130pc20_framerates); i++) { + if (fps == sr130pc20_framerates[i].fps) { + fps_index = sr130pc20_framerates[i].index; + state->fps = fps; + state->req_fps = -1; + break; + } + } + + if (unlikely(fps_index < 0)) { + cam_err("set_fps: warning, not supported fps %d\n", fps); + return 0; + } + + err = sr130pc20_set_from_table(sd, "fps", state->regs->fps, + ARRAY_SIZE(state->regs->fps), fps_index); + CHECK_ERR_MSG(err, "fail to set framerate\n"); + + /*sr130pc20_control_stream(sd, STREAM_STOP);*/ + + return 0; +} + +static int sr130pc20_control_stream(struct v4l2_subdev *sd, u32 cmd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -EINVAL; + + if (cmd == STREAM_STOP) { + if (!((state->runmode == RUNMODE_RUNNING) + && state->capture.pre_req)) { + cam_info("STREAM STOP!!\n"); + // [ W/A : Skip stream off sr130pc20 to prevent I2C behavior (P130301-0098) + // - DPM timeout (kernel Panic) happen by I2C behavior during system suspending + // ] + if (state->vt_mode != PREVIEW_SMARTSTAY) { + err = sr130pc20_set_from_table(sd, "stream_stop", + &state->regs->stream_stop, 1, 0); + CHECK_ERR_MSG(err, "failed to stop stream\n"); + } + state->preview.update_frmsize = 1; + } + } else { + cam_info("STREAM START\n"); + return 0; + } + + switch (state->runmode) { + case RUNMODE_CAPTURING: + cam_dbg("Capture Stop!\n"); + state->runmode = RUNMODE_CAPTURING_STOP; + state->capture.ready = 0; + state->capture.lowlux_night = 0; + break; + + case RUNMODE_RUNNING: + cam_dbg("Preview Stop!\n"); + state->runmode = RUNMODE_RUNNING_STOP; + if (state->capture.pre_req) { + sr130pc20_prepare_fast_capture(sd); + state->capture.pre_req = 0; + } + break; + + case RUNMODE_RECORDING: + state->runmode = RUNMODE_RECORDING_STOP; + break; + + default: + break; + } + + /*msleep_debug(state->pdata->streamoff_delay, true);*/ + + return 0; +} + +/* PX: Set flash mode */ +static int sr130pc20_set_flash_mode(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + + /* movie flash mode should be set when recording is started */ +/* if (state->sensor_mode == SENSOR_MOVIE && !state->recording) + return 0;*/ + + if (state->flash.mode == val) { + cam_dbg("the same flash mode=%d\n", val); + return 0; + } + + if (val == FLASH_MODE_TORCH) + sr130pc20_flash_torch(sd, SR130PC20_FLASH_ON); + + if ((state->flash.mode == FLASH_MODE_TORCH) + && (val == FLASH_MODE_OFF)) + sr130pc20_flash_torch(sd, SR130PC20_FLASH_OFF); + + state->flash.mode = val; + cam_dbg("Flash mode = %d\n", val); + return 0; +} + +static int sr130pc20_check_esd(struct v4l2_subdev *sd, s32 val) +{ + u32 data = 0, size_h = 0, size_v = 0; + +/* To do */ + return 0; + +esd_out: + cam_err("Check ESD(%d): ESD Shock detected! val=0x%X\n\n", data, val); + return -ERESTART; +} + +/* returns the real iso currently used by sensor due to lighting + * conditions, not the requested iso we sent using s_ctrl. + */ +static inline int sr130pc20_get_exif_iso(struct v4l2_subdev *sd, u16 *iso) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + u8 read_value = 0; + unsigned short gain_value = 0; + + err = sr130pc20_writeb(sd, 0x03, 0x20); + CHECK_ERR_COND(err < 0, -ENODEV); + sr130pc20_readb(sd, 0xb0, &read_value); + + gain_value = ((read_value * 100) / 32) + 50; + cam_dbg("gain_value=%d, read_value=%d\n", gain_value, read_value); + + if (gain_value < 114) + *iso = 50; + else if (gain_value < 214) + *iso = 100; + else if (gain_value < 264) + *iso = 200; + else if (gain_value < 825) + *iso = 400; + else + *iso = 800; + + cam_dbg("gain_value=%d, ISO=%d\n", gain_value, *iso); + return 0; +} + +/* PX: Set ISO */ +static int __used sr130pc20_set_iso(struct v4l2_subdev *sd, s32 val) +{ + struct sr130pc20_state *state = to_state(sd); + + sr130pc20_set_from_table(sd, "iso", state->regs->iso, + ARRAY_SIZE(state->regs->iso), val); + + state->iso = val; + + cam_trace("X\n"); + return 0; +} + +/* PX: Return exposure time (ms) */ +static inline int sr130pc20_get_exif_exptime(struct v4l2_subdev *sd, + u32 *exp_time) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + u8 read_value1 = 0; + u8 read_value2 = 0; + u8 read_value3 = 0; + + err = sr130pc20_writeb(sd, 0x03, 0x20); + CHECK_ERR_COND(err < 0, -ENODEV); + + sr130pc20_readb(sd, 0x80, &read_value1); + sr130pc20_readb(sd, 0x81, &read_value2); + sr130pc20_readb(sd, 0x82, &read_value3); + + cam_dbg("exposure time read_value %d, %d, %d\n", + read_value1, read_value2, read_value3); + *exp_time = (read_value1 << 19) + + (read_value2 << 11) + (read_value3 << 3); + + cam_dbg("exposure time %dus\n", *exp_time); + return 0; +} + +static inline void sr130pc20_get_exif_flash(struct v4l2_subdev *sd, + u16 *flash) +{ + struct sr130pc20_state *state = to_state(sd); + + *flash = 0; + + switch (state->flash.mode) { + case FLASH_MODE_OFF: + *flash |= EXIF_FLASH_MODE_SUPPRESSION; + break; + + case FLASH_MODE_AUTO: + *flash |= EXIF_FLASH_MODE_AUTO; + break; + + case FLASH_MODE_ON: + case FLASH_MODE_TORCH: + *flash |= EXIF_FLASH_MODE_FIRING; + break; + + default: + break; + } + + if (state->flash.on) + *flash |= EXIF_FLASH_FIRED; +} + +/* PX: */ +static int sr130pc20_get_exif(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + u32 exposure_time = 0; + u32 int_dec, integer; + int OPCLK = 24000000; + + /* exposure time */ + state->exif.exp_time_den = 0; + sr130pc20_get_exif_exptime(sd, &exposure_time); + if (exposure_time) { + state->exif.exp_time_den = OPCLK / exposure_time; + } else { + state->exif.exp_time_den = 0; + } + + /* iso */ + state->exif.iso = 0; + sr130pc20_get_exif_iso(sd, &state->exif.iso); + + /* flash */ + sr130pc20_get_exif_flash(sd, &state->exif.flash); + + cam_dbg("EXIF: ex_time_den=%d, iso=%d, flash=0x%02X\n", + state->exif.exp_time_den, state->exif.iso, state->exif.flash); + + return 0; +} + +static int sr130pc20_set_preview_size(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + u32 width, height; + int err = -EINVAL; + + if (!state->preview.update_frmsize) + return 0; + + if (unlikely(!state->preview.frmsize)) { + cam_warn("warning, preview resolution not set\n"); + state->preview.frmsize = sr130pc20_get_framesize( + sr130pc20_preview_frmsizes, + ARRAY_SIZE(sr130pc20_preview_frmsizes), + PREVIEW_SZ_VGA); + } + + width = state->preview.frmsize->width; + height = state->preview.frmsize->height; + + cam_dbg("set preview size(%dx%d)\n", width, height); + + err = sr130pc20_set_from_table(sd, "preview_size", + state->regs->preview_size, ARRAY_SIZE(state->regs->preview_size), + state->preview.frmsize->index); + CHECK_ERR_MSG(err, "fail to set preview size\n"); + + state->preview.update_frmsize = 0; + + return 0; +} + +static int sr130pc20_start_preview(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -EINVAL; + + cam_info("Camera Preview start, runmode = %d\n", state->runmode); + + if ((state->runmode == RUNMODE_NOTREADY) || + (state->runmode == RUNMODE_CAPTURING)) { + cam_err("%s: error - Invalid runmode\n", __func__); + return -EPERM; + } + + state->focus.status = AF_RESULT_SUCCESS; + + /* Transit preview mode */ + err = sr130pc20_transit_preview_mode(sd); + CHECK_ERR_MSG(err, "preview_mode(%d)\n", err); + + /* Set preview size */ + sr130pc20_set_preview_size(sd); + + sr130pc20_control_stream(sd, STREAM_START); + + state->runmode = (state->sensor_mode == SENSOR_CAMERA) ? + RUNMODE_RUNNING : RUNMODE_RECORDING; + return 0; +} + +static int sr130pc20_set_capture(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + cam_info("set_capture\n"); + + /* Set capture size */ + sr130pc20_set_capture_size(sd); + + /* Transit to capture mode */ + err = sr130pc20_transit_capture_mode(sd); + CHECK_ERR_MSG(err, "fail to capture_mode (%d)\n", err); + return 0; +} + +static int sr130pc20_prepare_fast_capture(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + cam_info("prepare_fast_capture\n"); + + state->req_fmt.width = (state->capture.pre_req >> 16); + state->req_fmt.height = (state->capture.pre_req & 0xFFFF); + sr130pc20_set_framesize(sd, sr130pc20_capture_frmsizes, + ARRAY_SIZE(sr130pc20_capture_frmsizes), false); + + err = sr130pc20_set_capture(sd); + CHECK_ERR(err); + + state->capture.ready = 1; + + return 0; +} + +static int sr130pc20_start_capture(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -ENODEV, count; + u32 val = 0; + u32 night_delay; + + cam_info("start_capture\n"); + + if (!state->capture.ready) { + err = sr130pc20_set_capture(sd); + CHECK_ERR(err); + + sr130pc20_control_stream(sd, STREAM_START); + night_delay = 500; + } else + night_delay = 700; /* for completely skipping 1 frame. */ + + state->runmode = RUNMODE_CAPTURING; + + if (state->capture.lowlux_night) + msleep_debug(night_delay, true); + + /* Get EXIF */ + sr130pc20_get_exif(sd); + + return 0; +} + +/** + * sr200pc20_init_regs: Indentify chip and get pointer to reg table + * @ + */ +static int sr130pc20_init_regs(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -ENODEV; + u8 read_value = 0; + + err = sr130pc20_writeb(sd, 0x03, 0x00); + CHECK_ERR_COND(err < 0, -ENODEV); + + sr130pc20_readb(sd, 0x04, &read_value); + if (SR130PC20_CHIP_ID == read_value) + cam_info("Sensor ChipID: 0x%02X\n", SR130PC20_CHIP_ID); + else + cam_info("Sensor ChipID: 0x%02X, unknown chipID\n", read_value); + + state->regs = ®_datas; + + return 0; +} + + +/* PX(NEW) */ +static int sr130pc20_s_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + struct sr130pc20_state *state = to_state(sd); + s32 previous_index = 0; + + cam_dbg("%s: pixelformat = 0x%x, colorspace = 0x%x, width = %d, height = %d\n", + __func__, fmt->code, fmt->colorspace, fmt->width, fmt->height); + + v4l2_fill_pix_format(&state->req_fmt, fmt); + if (fmt->field < IS_MODE_CAPTURE_STILL) + state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW; + else + state->format_mode = V4L2_PIX_FMT_MODE_CAPTURE; + + if (state->format_mode != V4L2_PIX_FMT_MODE_CAPTURE) { + previous_index = state->preview.frmsize ? + state->preview.frmsize->index : -1; + sr130pc20_set_framesize(sd, sr130pc20_preview_frmsizes, + ARRAY_SIZE(sr130pc20_preview_frmsizes), true); + + if (previous_index != state->preview.frmsize->index) + state->preview.update_frmsize = 1; + } else { + /* + * In case of image capture mode, + * if the given image resolution is not supported, + * use the next higher image resolution. */ + sr130pc20_set_framesize(sd, sr130pc20_capture_frmsizes, + ARRAY_SIZE(sr130pc20_capture_frmsizes), false); + + /* for maket app. + * Samsung camera app does not use unmatched ratio.*/ + if (unlikely(NULL == state->preview.frmsize)) { + cam_warn("warning, capture without preview resolution\n"); + } else if (unlikely(FRM_RATIO(state->preview.frmsize) + != FRM_RATIO(state->capture.frmsize))) { + cam_warn("warning, capture ratio " \ + "is different with preview ratio\n"); + } + } + + return 0; +} + +static int sr130pc20_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index, + enum v4l2_mbus_pixelcode *code) +{ + cam_dbg("%s: index = %d\n", __func__, index); + + if (index >= ARRAY_SIZE(capture_fmts)) + return -EINVAL; + + *code = capture_fmts[index].code; + + return 0; +} + +static int sr130pc20_try_mbus_fmt(struct v4l2_subdev *sd, + struct v4l2_mbus_framefmt *fmt) +{ + int num_entries; + int i; + + num_entries = ARRAY_SIZE(capture_fmts); + + cam_dbg("%s: code = 0x%x , colorspace = 0x%x, num_entries = %d\n", + __func__, fmt->code, fmt->colorspace, num_entries); + + for (i = 0; i < num_entries; i++) { + if (capture_fmts[i].code == fmt->code && + capture_fmts[i].colorspace == fmt->colorspace) { + cam_info("%s: match found, returning 0\n", __func__); + return 0; + } + } + + cam_err("%s: no match found, returning -EINVAL\n", __func__); + return -EINVAL; +} + + +static int sr130pc20_enum_framesizes(struct v4l2_subdev *sd, + struct v4l2_frmsizeenum *fsize) +{ + struct sr130pc20_state *state = to_state(sd); + + /* + * The camera interface should read this value, this is the resolution + * at which the sensor would provide framedata to the camera i/f + * In case of image capture, + * this returns the default camera resolution (VGA) + */ + if (state->format_mode != V4L2_PIX_FMT_MODE_CAPTURE) { + if (unlikely(state->preview.frmsize == NULL)) { + cam_err("%s: error\n", __func__); + return -EFAULT; + } + + fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; + fsize->discrete.width = state->preview.frmsize->width; + fsize->discrete.height = state->preview.frmsize->height; + } else { + if (unlikely(state->capture.frmsize == NULL)) { + cam_err("%s: error\n", __func__); + return -EFAULT; + } + + fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; + fsize->discrete.width = state->capture.frmsize->width; + fsize->discrete.height = state->capture.frmsize->height; + } + + return 0; +} + +static int sr130pc20_g_parm(struct v4l2_subdev *sd, + struct v4l2_streamparm *param) +{ + return 0; +} + +static int sr130pc20_s_parm(struct v4l2_subdev *sd, + struct v4l2_streamparm *param) +{ + struct sr130pc20_state *state = to_state(sd); + + state->req_fps = param->parm.capture.timeperframe.denominator / + param->parm.capture.timeperframe.numerator; + + cam_dbg("s_parm state->fps=%d, state->req_fps=%d\n", + state->fps, state->req_fps); + + if ((state->req_fps < 0) || (state->req_fps > 30)) { + cam_err("%s: error, invalid frame rate %d. we'll set to 30\n", + __func__, state->req_fps); + state->req_fps = 0; + } + + return sr130pc20_set_frame_rate(sd, state->req_fps); +} + +static int sr130pc20_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + if (!state->initialized) { + cam_err("%s: WARNING, camera not initialized\n", __func__); + return 0; + } + + mutex_lock(&state->ctrl_lock); + + switch (ctrl->id) { + case V4L2_CID_CAMERA_EXIF_EXPTIME: + if (state->sensor_mode == SENSOR_CAMERA) + ctrl->value = state->exif.exp_time_den; + else + ctrl->value = 24; + break; + + case V4L2_CID_CAMERA_EXIF_ISO: + if (state->sensor_mode == SENSOR_CAMERA) + ctrl->value = state->exif.iso; + else + ctrl->value = 100; + break; + + case V4L2_CID_CAMERA_EXIF_FLASH: + if (state->sensor_mode == SENSOR_CAMERA) + ctrl->value = state->exif.flash; + else + sr130pc20_get_exif_flash(sd, (u16 *)ctrl->value); + break; + +#if !defined(CONFIG_CAM_YUV_CAPTURE) + case V4L2_CID_CAM_JPEG_MAIN_SIZE: + ctrl->value = state->jpeg.main_size; + break; + + case V4L2_CID_CAM_JPEG_MAIN_OFFSET: + ctrl->value = state->jpeg.main_offset; + break; + + case V4L2_CID_CAM_JPEG_THUMB_SIZE: + ctrl->value = state->jpeg.thumb_size; + break; + + case V4L2_CID_CAM_JPEG_THUMB_OFFSET: + ctrl->value = state->jpeg.thumb_offset; + break; + + case V4L2_CID_CAM_JPEG_QUALITY: + ctrl->value = state->jpeg.quality; + break; + + case V4L2_CID_CAM_JPEG_MEMSIZE: + ctrl->value = SENSOR_JPEG_SNAPSHOT_MEMSIZE; + break; +#endif + + case V4L2_CID_CAMERA_AUTO_FOCUS_RESULT: + ctrl->value = state->focus.status; + break; + + case V4L2_CID_CAMERA_WHITE_BALANCE: + case V4L2_CID_CAMERA_EFFECT: + case V4L2_CID_CAMERA_CONTRAST: + case V4L2_CID_CAMERA_SATURATION: + case V4L2_CID_CAMERA_SHARPNESS: + case V4L2_CID_CAMERA_OBJ_TRACKING_STATUS: + case V4L2_CID_CAMERA_SMART_AUTO_STATUS: + default: + cam_err("%s: WARNING, unknown Ctrl-ID 0x%x\n", + __func__, ctrl->id); + err = 0; /* we return no error. */ + break; + } + + mutex_unlock(&state->ctrl_lock); + + return err; +} + +static int sr130pc20_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + if (!state->initialized && ctrl->id != V4L2_CID_CAMERA_SENSOR_MODE + && ctrl->id != V4L2_CID_CAMERA_VT_MODE) { + cam_warn("%s: WARNING, camera not initialized. ID = %d(0x%X)\n", + __func__, ctrl->id - V4L2_CID_PRIVATE_BASE, + ctrl->id - V4L2_CID_PRIVATE_BASE); + return 0; + } + + cam_dbg("%s: ID =%d, val = %d\n", + __func__, ctrl->id - V4L2_CID_PRIVATE_BASE, ctrl->value); + + mutex_lock(&state->ctrl_lock); + + switch (ctrl->id) { + case V4L2_CID_CAMERA_SENSOR_MODE: + err = sr130pc20_set_sensor_mode(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_BRIGHTNESS: + err = sr130pc20_set_exposure(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_WHITE_BALANCE: + err = sr130pc20_set_from_table(sd, "white balance", + state->regs->white_balance, + ARRAY_SIZE(state->regs->white_balance), ctrl->value); + state->wb.mode = ctrl->value; + break; + + case V4L2_CID_CAMERA_EFFECT: + err = sr130pc20_set_from_table(sd, "effects", + state->regs->effect, + ARRAY_SIZE(state->regs->effect), ctrl->value); + break; + + case V4L2_CID_CAMERA_METERING: + err = sr130pc20_set_from_table(sd, "metering", + state->regs->metering, + ARRAY_SIZE(state->regs->metering), ctrl->value); + break; + + case V4L2_CID_CAMERA_SCENE_MODE: + err = sr130pc20_set_scene_mode(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_CHECK_ESD: + err = sr130pc20_check_esd(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_ISO: + err = sr130pc20_set_iso(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_CAPTURE_MODE: + if (RUNMODE_RUNNING == state->runmode) + state->capture.pre_req = ctrl->value; + break; + + case V4L2_CID_CAMERA_VT_MODE: + err = sr130pc20_set_vt_mode(sd, ctrl->value); + break; + + case V4L2_CID_CAMERA_ANTI_BANDING: + break; + + case V4L2_CID_CAMERA_OBJECT_POSITION_X: + case V4L2_CID_CAMERA_OBJECT_POSITION_Y: + case V4L2_CID_CAMERA_TOUCH_AF_START_STOP: + case V4L2_CID_CAMERA_FOCUS_MODE: + case V4L2_CID_CAMERA_SET_AUTO_FOCUS: + case V4L2_CID_CAMERA_FLASH_MODE: + case V4L2_CID_CAMERA_CONTRAST: + case V4L2_CID_CAMERA_SATURATION: + case V4L2_CID_CAMERA_SHARPNESS: + case V4L2_CID_CAMERA_FRAME_RATE: + case V4L2_CID_CAMERA_AE_LOCK_UNLOCK: + case V4L2_CID_CAMERA_AWB_LOCK_UNLOCK: + default: + cam_err("%s: WARNING, unknown Ctrl-ID 0x%x\n", + __func__, ctrl->id); + /* we return no error. */ + break; + } + + mutex_unlock(&state->ctrl_lock); + CHECK_ERR_MSG(err, "s_ctrl failed %d\n", err) + + return 0; +} + +static int sr130pc20_s_ext_ctrl(struct v4l2_subdev *sd, + struct v4l2_ext_control *ctrl) +{ + return 0; +} + +static int sr130pc20_s_ext_ctrls(struct v4l2_subdev *sd, + struct v4l2_ext_controls *ctrls) +{ + struct v4l2_ext_control *ctrl = ctrls->controls; + int ret; + int i; + + for (i = 0; i < ctrls->count; i++, ctrl++) { + ret = sr130pc20_s_ext_ctrl(sd, ctrl); + + if (ret) { + ctrls->error_idx = i; + break; + } + } + + return ret; +} + +static int sr130pc20_s_stream(struct v4l2_subdev *sd, int enable) +{ + struct sr130pc20_state *state = to_state(sd); + int err = 0; + + cam_info("stream mode = %d\n", enable); + + BUG_ON(!state->initialized); + + switch (enable) { + case STREAM_MODE_CAM_OFF: + if (state->pdata->is_mipi) + err = sr130pc20_control_stream(sd, STREAM_STOP); + break; + + case STREAM_MODE_CAM_ON: + switch (state->sensor_mode) { + case SENSOR_CAMERA: + if (state->format_mode == V4L2_PIX_FMT_MODE_CAPTURE) + err = sr130pc20_start_capture(sd); + else + err = sr130pc20_start_preview(sd); + break; + + case SENSOR_MOVIE: + err = sr130pc20_start_preview(sd); + break; + + default: + break; + } + break; + + case STREAM_MODE_MOVIE_OFF: + cam_info("movie off"); + state->recording = 0; + break; + + case STREAM_MODE_MOVIE_ON: + cam_info("movie on"); + state->recording = 1; + break; + + default: + cam_err("%s: error - Invalid stream mode\n", __func__); + break; + } + + CHECK_ERR_MSG(err, "failed\n"); + + return 0; +} + +static inline int sr130pc20_check_i2c(struct v4l2_subdev *sd, u16 data) +{ + int err; + u32 val = 0; + + err = sr130pc20_readw(sd, 0x0000, &val); + if (unlikely(err)) + return err; + + cam_dbg("version: 0x%04X is 0x6017?\n", val); + return 0; +} + +static void sr130pc20_init_parameter(struct v4l2_subdev *sd) +{ + struct sr130pc20_state *state = to_state(sd); + + state->runmode = RUNMODE_INIT; + + /* Default state values */ + state->scene_mode = SCENE_MODE_NONE; + state->wb.mode = WHITE_BALANCE_AUTO; + state->light_level = LUX_LEVEL_MAX; + + /* Set update_frmsize to 1 for case of power reset */ + state->preview.update_frmsize = 1; + + /* Initialize focus field for case of init after power reset. */ + memset(&state->focus, 0, sizeof(state->focus)); + + state->lux_level_flash = LUX_LEVEL_FLASH_ON; + state->shutter_level_flash = 0x0; + +} + +static int sr130pc20_init(struct v4l2_subdev *sd, u32 val) +{ + struct sr130pc20_state *state = to_state(sd); + int err = -EINVAL; + + cam_info("init: start (%s)\n", __DATE__); + +#ifdef CONFIG_LOAD_FILE + err = sr130pc20_regs_table_init(); + CHECK_ERR_MSG(err, "loading setfile fail!\n"); +#endif + err = sr130pc20_init_regs(sd); + CHECK_ERR_MSG(err, "failed to indentify sensor chip\n"); + + err = sr130pc20_set_from_table(sd, "init_reg", + &state->regs->init_reg, 1, 0); + + CHECK_ERR_MSG(err, "failed to initialize camera device\n"); + sr130pc20_init_parameter(sd); + state->initialized = 1; + + return 0; +} + +/* + * s_config subdev ops + * With camera device, we need to re-initialize + * every single opening time therefor, + * it is not necessary to be initialized on probe time. + * except for version checking + * NOTE: version checking is optional + */ +static int sr130pc20_s_config(struct v4l2_subdev *sd, + int irq, void *platform_data) +{ + struct sr130pc20_state *state = to_state(sd); + int i; + + if (!platform_data) { + cam_err("%s: error, no platform data\n", __func__); + return -ENODEV; + } + state->pdata = platform_data; + state->dbg_level = &state->pdata->dbg_level; + + /* + * Assign default format and resolution + * Use configured default information in platform data + * or without them, use default information in driver + */ + state->req_fmt.width = state->pdata->default_width; + state->req_fmt.height = state->pdata->default_height; + + if (!state->pdata->pixelformat) + state->req_fmt.pixelformat = DEFAULT_PIX_FMT; + else + state->req_fmt.pixelformat = state->pdata->pixelformat; + + if (!state->pdata->freq) + state->freq = DEFAULT_MCLK; /* 24MHz default */ + else + state->freq = state->pdata->freq; + + state->preview.frmsize = state->capture.frmsize = NULL; + state->sensor_mode = SENSOR_CAMERA; + state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW; + state->fps = 0; + state->req_fps = -1; + + /* Initialize the independant HW module like flash here */ + state->flash.mode = FLASH_MODE_OFF; + state->flash.on = 0; + + for (i = 0; i < ARRAY_SIZE(sr130pc20_ctrls); i++) + sr130pc20_ctrls[i].value = sr130pc20_ctrls[i].default_value; + +#ifdef SR130PC20_SUPPORT_FLASH + if (sr130pc20_is_hwflash_on(sd)) + state->flash.ignore_flash = 1; +#endif + + state->regs = ®_datas; + + return 0; +} + +static const struct v4l2_subdev_core_ops sr130pc20_core_ops = { + .init = sr130pc20_init, /* initializing API */ + .g_ctrl = sr130pc20_g_ctrl, + .s_ctrl = sr130pc20_s_ctrl, + .s_ext_ctrls = sr130pc20_s_ext_ctrls, + /*eset = sr130pc20_reset, */ +}; + +static const struct v4l2_subdev_video_ops sr130pc20_video_ops = { + .s_mbus_fmt = sr130pc20_s_mbus_fmt, + .enum_framesizes = sr130pc20_enum_framesizes, + .enum_mbus_fmt = sr130pc20_enum_mbus_fmt, + .try_mbus_fmt = sr130pc20_try_mbus_fmt, + .g_parm = sr130pc20_g_parm, + .s_parm = sr130pc20_s_parm, + .s_stream = sr130pc20_s_stream, +}; + +static const struct v4l2_subdev_ops sr130pc20_ops = { + .core = &sr130pc20_core_ops, + .video = &sr130pc20_video_ops, +}; + + +/* + * sr130pc20_probe + * Fetching platform data is being done with s_config subdev call. + * In probe routine, we just register subdev device + */ +static int sr130pc20_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct v4l2_subdev *sd; + struct sr130pc20_state *state; + int err = -EINVAL; + + state = kzalloc(sizeof(struct sr130pc20_state), GFP_KERNEL); + if (unlikely(!state)) { + dev_err(&client->dev, "probe, fail to get memory\n"); + return -ENOMEM; + } + + mutex_init(&state->ctrl_lock); + + state->runmode = RUNMODE_NOTREADY; + sd = &state->sd; + strcpy(sd->name, SR130PC20_DRIVER_NAME); + + /* Registering subdev */ + v4l2_i2c_subdev_init(sd, client, &sr130pc20_ops); + + state->workqueue = create_workqueue("cam_workqueue"); + if (unlikely(!state->workqueue)) { + dev_err(&client->dev, "probe, fail to create workqueue\n"); + goto err_out; + } + + err = sr130pc20_s_config(sd, 0, client->dev.platform_data); + CHECK_ERR_MSG(err, "fail to s_config\n"); + + printk(KERN_DEBUG "%s %s: driver probed!!\n", + dev_driver_string(&client->dev), dev_name(&client->dev)); + + return 0; + +err_out: + kfree(state); + return -ENOMEM; +} + +static int sr130pc20_remove(struct i2c_client *client) +{ + struct v4l2_subdev *sd = i2c_get_clientdata(client); + struct sr130pc20_state *state = to_state(sd); + + destroy_workqueue(state->workqueue); + + /* Check whether flash is on when unlolading driver, + * to preventing Market App from controlling improperly flash. + * It isn't necessary in case that you power flash down + * in power routine to turn camera off.*/ + if (unlikely(state->flash.on && !state->flash.ignore_flash)) + sr130pc20_flash_torch(sd, SR130PC20_FLASH_OFF); + + v4l2_device_unregister_subdev(sd); + mutex_destroy(&state->ctrl_lock); + kfree(state); + + printk(KERN_DEBUG "%s %s: driver removed!!\n", + dev_driver_string(&client->dev), dev_name(&client->dev)); + return 0; +} + +static int is_sysdev(struct device *dev, void *str) +{ + return !strcmp(dev_name(dev), (char *)str) ? 1 : 0; +} + +static ssize_t cam_loglevel_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + char temp_buf[60] = {0,}; + + sprintf(buf, "Log Level: "); + if (dbg_level & CAMDBG_LEVEL_TRACE) { + sprintf(temp_buf, "trace "); + strcat(buf, temp_buf); + } + + if (dbg_level & CAMDBG_LEVEL_DEBUG) { + sprintf(temp_buf, "debug "); + strcat(buf, temp_buf); + } + + if (dbg_level & CAMDBG_LEVEL_INFO) { + sprintf(temp_buf, "info "); + strcat(buf, temp_buf); + } + + sprintf(temp_buf, "\n - warn and error level is always on\n\n"); + strcat(buf, temp_buf); + + return strlen(buf); +} + +static ssize_t cam_loglevel_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + printk(KERN_DEBUG "CAM buf=%s, count=%d\n", buf, count); + + if (strstr(buf, "trace")) + dbg_level |= CAMDBG_LEVEL_TRACE; + else + dbg_level &= ~CAMDBG_LEVEL_TRACE; + + if (strstr(buf, "debug")) + dbg_level |= CAMDBG_LEVEL_DEBUG; + else + dbg_level &= ~CAMDBG_LEVEL_DEBUG; + + if (strstr(buf, "info")) + dbg_level |= CAMDBG_LEVEL_INFO; + + return count; +} + +static DEVICE_ATTR(loglevel, 0664, cam_loglevel_show, cam_loglevel_store); + +static int sr130pc20_create_dbglogfile(struct class *cls) +{ + struct device *dev; + int err; + + dbg_level |= CAMDBG_LEVEL_DEFAULT; + + dev = class_find_device(cls, NULL, "front", is_sysdev); + if (unlikely(!dev)) { + pr_info("[SR130PC20] can not find front device\n"); + return 0; + } + + err = device_create_file(dev, &dev_attr_loglevel); + if (unlikely(err < 0)) { + pr_err("cam_init: failed to create device file, %s\n", + dev_attr_loglevel.attr.name); + } + + return 0; +} + +static const struct i2c_device_id sr130pc20_id[] = { + { SR130PC20_DRIVER_NAME, 0 }, + {} +}; + +MODULE_DEVICE_TABLE(i2c, sr130pc20_id); + +static struct i2c_driver v4l2_i2c_driver = { + .driver.name = SR130PC20_DRIVER_NAME, + .probe = sr130pc20_probe, + .remove = sr130pc20_remove, + .id_table = sr130pc20_id, +}; + +static int __init v4l2_i2c_drv_init(void) +{ + pr_info("%s: %s called\n", __func__, SR130PC20_DRIVER_NAME); /* dslim*/ + sr130pc20_create_file(camera_class); + sr130pc20_create_dbglogfile(camera_class); + return i2c_add_driver(&v4l2_i2c_driver); +} + +static void __exit v4l2_i2c_drv_cleanup(void) +{ + pr_info("%s: %s called\n", __func__, SR130PC20_DRIVER_NAME); /* dslim*/ + i2c_del_driver(&v4l2_i2c_driver); +} + +module_init(v4l2_i2c_drv_init); +module_exit(v4l2_i2c_drv_cleanup); + +MODULE_DESCRIPTION("SILICONFILE SR130PC20 1.3MP SOC camera driver"); +MODULE_AUTHOR("Dong-Seong Lim <dongseong.lim@samsung.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/media/video/sr130pc20.h b/drivers/media/video/sr130pc20.h new file mode 100755 index 0000000..a831007 --- /dev/null +++ b/drivers/media/video/sr130pc20.h @@ -0,0 +1,646 @@ +/* drivers/media/video/sr130pc20.h + * + * Driver for sr130pc20 (1.5MP Camera) from siliconfile + * + * Copyright (C) 2010, SAMSUNG ELECTRONICS + * + * 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. + * + * - change date: 2012.06.28 + */ + +#ifndef __SR130PC20_H__ +#define __SR130PC20_H__ +#include <linux/i2c.h> +#include <linux/delay.h> +#include <linux/version.h> +#include <linux/vmalloc.h> +#include <linux/completion.h> +#include <media/v4l2-device.h> +#include <media/v4l2-subdev.h> +#include <media/sr130pc20_platform.h> +#include <linux/videodev2_exynos_camera.h> +#include <linux/workqueue.h> + +#define SR130PC20_DRIVER_NAME "SR130PC20" + +#define SR130PC20_DELAY 0xFFFF0000 + +/************************************ + * FEATURE DEFINITIONS + ************************************/ +#define CONFIG_CAM_YUV_CAPTURE +#define CONFIG_CAM_I2C_LITTLE_ENDIAN +/* #define CONFIG_LOAD_FILE *//* for tuning */ +/* #define CONFIG_DEBUG_NO_FRAME */ + +/** Debuging Feature **/ +// #define CONFIG_CAM_DEBUG */ +// #define CONFIG_CAM_TRACE *//* Enable it with CONFIG_CAM_DEBUG */ +// #define CONFIG_CAM_AF_DEBUG *//* Enable it with CONFIG_CAM_DEBUG */ +#define DEBUG_WRITE_REGS +/***********************************/ + +#ifdef CONFIG_VIDEO_SR130PC20_DEBUG +enum { + SR130PC20_DEBUG_I2C = 1U << 0, + SR130PC20_DEBUG_I2C_BURSTS = 1U << 1, +}; +static uint32_t sr130pc20_debug_mask = SR130PC20_DEBUG_I2C_BURSTS; +module_param_named(debug_mask, sr130pc20_debug_mask, uint, S_IWUSR | S_IRUGO); + +#define sr130pc20_debug(mask, x...) \ + do { \ + if (sr130pc20_debug_mask & mask) \ + pr_info(x); \ + } while (0) +#else +#define sr130pc20_debug(mask, x...) +#endif + +#define TAG_NAME "["SR130PC20_DRIVER_NAME"]"" " + +/* Define debug level */ +#define CAMDBG_LEVEL_ERR (1 << 0) +#define CAMDBG_LEVEL_WARN (1 << 1) +#define CAMDBG_LEVEL_INFO (1 << 2) +#define CAMDBG_LEVEL_DEBUG (1 << 3) +#define CAMDBG_LEVEL_TRACE (1 << 4) +#define CAMDBG_LEVEL_DEFAULT \ + (CAMDBG_LEVEL_ERR | CAMDBG_LEVEL_WARN | CAMDBG_LEVEL_INFO) + +#define cam_err(fmt, ...) \ + printk(KERN_ERR TAG_NAME fmt, ##__VA_ARGS__) +#define cam_warn(fmt, ...) \ + printk(KERN_WARNING TAG_NAME fmt, ##__VA_ARGS__) +#define cam_info(fmt, ...) \ + printk(KERN_INFO TAG_NAME fmt, ##__VA_ARGS__) + +#if defined(CONFIG_CAM_DEBUG) +#define cam_dbg(fmt, ...) \ + printk(KERN_DEBUG TAG_NAME fmt, ##__VA_ARGS__) +#else +#define cam_dbg(fmt, ...) \ + do { \ + if (dbg_level & CAMDBG_LEVEL_DEBUG) \ + printk(KERN_DEBUG TAG_NAME fmt, ##__VA_ARGS__); \ + } while (0) +#endif + +#if defined(CONFIG_CAM_DEBUG) && defined(CONFIG_CAM_TRACE) +#define cam_trace(fmt, ...) cam_dbg("%s: " fmt, __func__, ##__VA_ARGS__); +#else +#define cam_trace(fmt, ...) \ + do { \ + if (dbg_level & CAMDBG_LEVEL_TRACE) \ + printk(KERN_DEBUG TAG_NAME "%s: " fmt, \ + __func__, ##__VA_ARGS__); \ + } while (0) +#endif + +#if defined(CONFIG_CAM_DEBUG) && defined(CONFIG_CAM_AF_DEBUG) +#define af_dbg(fmt, ...) cam_dbg(fmt, ##__VA_ARGS__); +#else +#define af_dbg(fmt, ...) +#endif +#if defined(CONFIG_CAM_DEBUG) && defined(CONFIG_CAM_BOOT_DEBUG) +#define boot_dbg(fmt, ...) cam_dbg(fmt, ##__VA_ARGS__); +#else +#define boot_dbg(fmt, ...) +#endif + +#if 0 +#define cam_bug_on(arg...) \ + do { cam_err(arg); BUG_ON(1); } while (0) +#else +#define cam_bug_on(arg...) +#endif + +#define CHECK_ERR_COND(condition, ret) \ + do { if (unlikely(condition)) return ret; } while (0) +#define CHECK_ERR_COND_MSG(condition, ret, fmt, ...) \ + if (unlikely(condition)) { \ + cam_err("%s: error, " fmt, __func__, ##__VA_ARGS__); \ + return ret; \ + } + +#define CHECK_ERR(x) CHECK_ERR_COND(((x) < 0), (x)) +#define CHECK_ERR_MSG(x, fmt, ...) \ + CHECK_ERR_COND_MSG(((x) < 0), (x), fmt, ##__VA_ARGS__) + +/* result values returned to HAL */ +enum af_result_status { + AF_RESULT_NONE = 0x00, + AF_RESULT_FAILED = 0x01, + AF_RESULT_SUCCESS = 0x02, + AF_RESULT_CANCELLED = 0x04, + AF_RESULT_DOING = 0x08 +}; + +enum af_operation_status { + AF_NONE = 0, + AF_START, + AF_CANCEL, +}; + +enum preflash_status { + PREFLASH_NONE = 0, + PREFLASH_OFF, + PREFLASH_ON, +}; + +enum sr130pc20_oprmode { + SR130PC20_OPRMODE_VIDEO = 0, + SR130PC20_OPRMODE_IMAGE = 1, +}; + +enum stream_cmd { + STREAM_STOP, + STREAM_START, +}; + +enum wide_req_cmd { + WIDE_REQ_NONE, + WIDE_REQ_CHANGE, + WIDE_REQ_RESTORE, +}; + +/* Preview Size List: refer to the belows. */ +enum sr130pc20_preview_frame_size { + PREVIEW_SZ_QCIF = 0, /* 176x144 */ + PREVIEW_SZ_320x240, /* 320x240 */ + PREVIEW_SZ_CIF, /* 352x288 */ + PREVIEW_SZ_528x432, /* 528x432 */ + PREVIEW_SZ_VGA, /* 640x480 */ + PREVIEW_SZ_D1, /* 720x480 */ + PREVIEW_SZ_880x720, /* 880x720 */ + PREVIEW_SZ_SVGA, /* 800x600 */ + PREVIEW_SZ_1024x576, /* 1024x576, 16:9 */ + PREVIEW_SZ_1024x616, /* 1024x616, ? */ + PREVIEW_SZ_XGA, /* 1024x768 */ + PREVIEW_SZ_PVGA, /* 1280x720 */ + PREVIEW_SZ_SXGA, /* 1280x1024 */ + PREVIEW_SZ_MAX, +}; + +/* Capture Size List: Capture size is defined as below. + * + * CAPTURE_SZ_VGA: 640x480 + * CAPTURE_SZ_WVGA: 800x480 + * CAPTURE_SZ_SVGA: 800x600 + * CAPTURE_SZ_WSVGA: 1024x600 + * CAPTURE_SZ_1MP: 1280x960 + * CAPTURE_SZ_W1MP: 1600x960 + * CAPTURE_SZ_2MP: UXGA - 1600x1200 + * CAPTURE_SZ_W2MP: 35mm Academy Offset Standard 1.66 + * 2048x1232, 2.4MP + * CAPTURE_SZ_3MP: QXGA - 2048x1536 + * CAPTURE_SZ_W4MP: WQXGA - 2560x1536 + * CAPTURE_SZ_5MP: 2560x1920 + */ + +enum sr130pc20_capture_frame_size { + /*CAPTURE_SZ_VGA = 0,*/ /* 640x480 */ + /*CAPTURE_SZ_960_720,*/ + CAPTURE_SZ_1MP,/* 1280x960 */ + CAPTURE_SZ_MAX, +}; + +#define PREVIEW_WIDE_SIZE PREVIEW_SZ_1024x576 +#define CAPTURE_WIDE_SIZE CAPTURE_SZ_W2MP + +enum frame_ratio { + FRMRATIO_QCIF = 12, /* 11 : 9 */ + FRMRATIO_VGA = 13, /* 4 : 3 */ + FRMRATIO_D1 = 15, /* 3 : 2 */ + FRMRATIO_WVGA = 16, /* 5 : 3 */ + FRMRATIO_HD = 17, /* 16 : 9 */ +}; + +enum sr130pc20_fps_index { + I_FPS_0, + I_FPS_7, + I_FPS_10, + I_FPS_12, + I_FPS_15, + I_FPS_25, + I_FPS_30, + I_FPS_MAX, +}; + +enum ae_awb_lock { + AEAWB_UNLOCK = 0, + AEAWB_LOCK, + AEAWB_LOCK_MAX, +}; + +enum runmode { + RUNMODE_NOTREADY, + RUNMODE_INIT, + /*RUNMODE_IDLE,*/ + RUNMODE_RUNNING, /* previewing */ + RUNMODE_RUNNING_STOP, + RUNMODE_CAPTURING, + RUNMODE_CAPTURING_STOP, + RUNMODE_RECORDING, /* camcorder mode */ + RUNMODE_RECORDING_STOP, +}; + +enum sr130pc20_stby_type { + SR130PC20_STBY_HW, + SR130PC20_STBY_SW, +}; + +enum sr130_pc20_preview_mode { + PREVIEW_CAMERA = 1, + PREVIEW_VIDEOCALL, + PREVIEW_SMARTSTAY, +}; + +struct sr130pc20_control { + u32 id; + s32 value; + s32 default_value; +}; + +#define SR130PC20_INIT_CONTROL(ctrl_id, default_val) \ + { \ + .id = ctrl_id, \ + .value = default_val, \ + .default_value = default_val, \ + } + +struct sr130pc20_framesize { + s32 index; + u32 width; + u32 height; +}; + +#define FRM_RATIO(framesize) \ + (((framesize)->width) * 10 / ((framesize)->height)) + +struct sr130pc20_fps { + u32 index; + u32 fps; +}; + +struct sr130pc20_version { + u32 major; + u32 minor; +}; + +struct sr130pc20_date_info { + u32 year; + u32 month; + u32 date; +}; + +struct sr130pc20_firmware { + u32 addr; + u32 size; +}; + +struct sr130pc20_jpeg_param { + u32 enable; + u32 quality; + u32 main_size; /* Main JPEG file size */ + u32 thumb_size; /* Thumbnail file size */ + u32 main_offset; + u32 thumb_offset; + /* u32 postview_offset; */ +}; + +struct sr130pc20_position { + s32 x; + s32 y; +}; + +struct sr130pc20_rect { + s32 x; + s32 y; + u32 width; + u32 height; +}; + +struct gps_info_common { + u32 direction; + u32 dgree; + u32 minute; + u32 second; +}; + +struct sr130pc20_gps_info { + u8 gps_buf[8]; + u8 altitude_buf[4]; + s32 gps_timeStamp; +}; + +struct sr130pc20_preview { + const struct sr130pc20_framesize *frmsize; + u32 update_frmsize:1; + u32 fast_ae:1; +}; + +struct sr130pc20_capture { + const struct sr130pc20_framesize *frmsize; + u32 pre_req; /* for fast capture */ + u32 ae_manual_mode:1; + u32 lowlux_night:1; + u32 ready:1; /* for fast capture */ +}; + +/* Focus struct */ +struct sr130pc20_focus { + enum v4l2_focusmode mode; + enum af_result_status status; + + u32 pos_x; + u32 pos_y; + + u32 start:1; /* enum v4l2_auto_focus*/ + u32 touch:1; + u32 lock:1; /* set if single AF is done */ +}; + +/* struct for sensor specific data */ +struct sr130pc20_ae_gain_offset { + u32 ae_auto; + u32 ae_now; + u32 ersc_auto; + u32 ersc_now; + + u32 ae_ofsetval; + u32 ae_maxdiff; +}; + +/* Flash struct */ +struct sr130pc20_flash { + struct sr130pc20_ae_gain_offset ae_offset; + enum v4l2_flash_mode mode; + enum preflash_status preflash; + u32 awb_delay; + u32 ae_scl; /* for back-up */ + u32 on:1; /* flash on/off */ + u32 ignore_flash:1; + u32 ae_flash_lock:1; +}; + +/* Exposure struct */ +struct sr130pc20_exposure { + s32 val; /* exposure value */ + u32 ae_lock:1; +}; + +/* White Balance struct */ +struct sr130pc20_whitebalance { + enum v4l2_wb_mode mode; /* wb mode */ + u32 awb_lock:1; +}; + +struct sr130pc20_exif { + u16 exp_time_den; + u16 iso; + u16 flash; + + /*int bv;*/ /* brightness */ + /*int ebv;*/ /* exposure bias */ +}; + +/* EXIF - flash filed */ +#define EXIF_FLASH_FIRED (0x01) +#define EXIF_FLASH_MODE_FIRING (0x01 << 3) +#define EXIF_FLASH_MODE_SUPPRESSION (0x02 << 3) +#define EXIF_FLASH_MODE_AUTO (0x03 << 3) + +struct sr130pc20_stream_time { + struct timeval curr_time; + struct timeval before_time; +}; + +#define GET_ELAPSED_TIME(cur, before) \ + (((cur).tv_sec - (before).tv_sec) * USEC_PER_SEC \ + + ((cur).tv_usec - (before).tv_usec)) + +typedef u16 sr130pc20_regset_t; + +typedef struct isx012_regset { + u16 subaddr; + u32 value; + u32 len; +} isx012_regset_t; + +#ifdef CONFIG_LOAD_FILE +#define DEBUG_WRITE_REGS +struct regset_table { + const char *const name; +}; + +#define SR130PC20_REGSET(x, y, z) \ + [(x)] = { \ + .name = #y, \ + } + +#define SR130PC20_REGSET_TABLE(y, z) \ + { \ + .name = #y, \ + } + +#else /* !CONFIG_LOAD_FILE */ + +struct regset_table { + const sr130pc20_regset_t * const reg; + const u32 array_size; +#ifdef DEBUG_WRITE_REGS + const char * const name; +#endif + const u32 burst; /* on/off */ +}; + +#ifdef DEBUG_WRITE_REGS +#define SR130PC20_REGSET(x, y, z) \ + [(x)] = { \ + .reg = (y), \ + .array_size = ARRAY_SIZE((y)), \ + .name = #y, \ + .burst = z, \ + } +#define SR130PC20_REGSET_TABLE(y, z) \ + { \ + .reg = (y), \ + .array_size = ARRAY_SIZE((y)), \ + .name = #y, \ + .burst = z, \ + } +#else /* !DEBUG_WRITE_REGS */ +#define SR130PC20_REGSET(x, y, z) \ + [(x)] = { \ + .reg = (y), \ + .array_size = ARRAY_SIZE((y)), \ + .burst = z, \ + } +#define SR130PC20_REGSET_TABLE(y, z) \ + { \ + .reg = (y), \ + .array_size = ARRAY_SIZE((y)), \ + .burst = z, \ + } +#endif /* DEBUG_WRITE_REGS */ + +#endif /* CONFIG_LOAD_FILE */ + +#define EV_MIN_VLAUE EV_MINUS_4 +#define GET_EV_INDEX(EV) ((EV) - (EV_MIN_VLAUE)) + +struct sr130pc20_regs { + struct regset_table ev[GET_EV_INDEX(EV_MAX_V4L2)]; + struct regset_table metering[METERING_MAX]; + struct regset_table iso[ISO_MAX]; + struct regset_table effect[IMAGE_EFFECT_MAX]; + struct regset_table white_balance[WHITE_BALANCE_MAX]; + struct regset_table preview_size[PREVIEW_SZ_MAX]; + struct regset_table capture_size[CAPTURE_SZ_MAX]; + struct regset_table scene_mode[SCENE_MODE_MAX]; + struct regset_table fps[I_FPS_MAX]; + /* camera mode */ + struct regset_table preview_mode; + struct regset_table capture_mode; + struct regset_table capture_mode_night; + struct regset_table stream_stop; + struct regset_table init_reg; + struct regset_table VT_init_reg; + struct regset_table SS_init_reg; +}; + +struct sr130pc20_state { + struct sr130pc20_platform_data *pdata; + struct v4l2_subdev sd; + struct v4l2_pix_format req_fmt; + struct sr130pc20_preview preview; + struct sr130pc20_capture capture; + struct sr130pc20_focus focus; + struct sr130pc20_flash flash; + struct sr130pc20_exposure exposure; + struct sr130pc20_whitebalance wb; + struct sr130pc20_exif exif; +#if !defined(CONFIG_CAM_YUV_CAPTURE) + struct sr130pc20_jpeg_param jpeg; +#endif + struct sr130pc20_stream_time stream_time; + const struct sr130pc20_regs *regs; + struct mutex ctrl_lock; + struct mutex af_lock; + struct workqueue_struct *workqueue; + struct work_struct af_work; + struct work_struct af_win_work; +#ifdef CONFIG_DEBUG_NO_FRAME + struct work_struct frame_work; +#endif + enum runmode runmode; + enum v4l2_sensor_mode sensor_mode; + enum v4l2_pix_format_mode format_mode; + enum v4l2_scene_mode scene_mode; + enum v4l2_iso_mode iso; + + s32 vt_mode; + s32 req_fps; + s32 fps; + s32 freq; /* MCLK in Hz */ + u32 one_frame_delay_ms; + u32 light_level; /* light level */ + u32 lux_level_flash; + u32 shutter_level_flash; + u8 *dbg_level; +#ifdef CONFIG_DEBUG_NO_FRAME + bool frame_check; +#endif + u32 recording:1; + u32 hd_videomode:1; + u32 need_wait_streamoff:1; + u32 initialized:1; +}; + +static inline struct sr130pc20_state *to_state(struct v4l2_subdev *sd) +{ + return container_of(sd, struct sr130pc20_state, sd); +} + +static inline int sr130pc20_restore_sensor_flash(struct v4l2_subdev *sd); +static int sr130pc20_set_capture(struct v4l2_subdev *sd); +static int sr130pc20_prepare_fast_capture(struct v4l2_subdev *sd); +static int sr130pc20_control_stream(struct v4l2_subdev *sd, u32 cmd); + +extern struct class *camera_class; +extern int sr130pc20_create_file(struct class *cls); + +#if !defined(CONFIG_CAM_YUV_CAPTURE) +/* JPEG MEMORY SIZE */ +#define SENSOR_JPEG_OUTPUT_MAXSIZE 0x29999A /*2726298bytes, 2.6M */ +#define EXTRA_MEMSIZE (0 * SZ_1K) +#define SENSOR_JPEG_SNAPSHOT_MEMSIZE \ + (((SENSOR_JPEG_OUTPUT_MAXSIZE + EXTRA_MEMSIZE + SZ_16K-1) / SZ_16K) * SZ_16K) +#endif + +/*********** Sensor specific ************/ +#define DELAY_SEQ 0xFF +#define SR130PC20_CHIP_ID 0xC1 + +#define SR130PC20_INTSRC_VINT (0x01 << 5) + +#define POLL_TIME_MS 10 +#define CAPTURE_POLL_TIME_MS 1000 + +/* maximum time for one frame in norma light */ +#define ONE_FRAME_DELAY_MS_NORMAL 66 +/* maximum time for one frame in low light: minimum 10fps. */ +#define ONE_FRAME_DELAY_MS_LOW 100 +/* maximum time for one frame in night mode: 6fps */ +#define ONE_FRAME_DELAY_MS_NIGHTMODE 166 + +/* level at or below which we need to enable flash when in auto mode */ +#define LUX_LEVEL_MAX 0x00 /* the brightest */ +#define LUX_LEVEL_LOW 0x3D /* low light */ +#define LUX_LEVEL_FLASH_ON 0x2B + +/* Count for loop */ +#define SR130PC20_CNT_CAPTURE_FRM 330 +#define SR130PC20_CNT_CLEAR_VINT 20 +#define SR130PC20_CNT_AE_STABLE 100 /* for checking MODESEL_FIX */ +#define SR130PC20_CNT_CAPTURE_AWB 3 /* 8 -> 3 */ +#define SR130PC20_CNT_OM_CHECK 30 +#define SR130PC20_CNT_CM_CHECK 280 /* 160 -> 180 */ +#define SR130PC20_CNT_STREAMOFF 300 + +#define AF_SEARCH_COUNT 550 /* about 6s */ +#define AE_STABLE_SEARCH_COUNT 7 + +/* Sensor AF first,second window size. + * we use constant values intead of reading sensor register */ +#define DEFAULT_WINDOW_WIDTH 80 +#define DEFAULT_WINDOW_HEIGHT 80 +#define AF_PRECISION 100 + +/* diff value fior fast AE in preview */ +#define AESCL_DIFF_FASTAE 1000 + + +/* + * Register Address Definition + */ + +/* The Path of Setfile */ +#ifdef CONFIG_LOAD_FILE +#include <linux/vmalloc.h> +#include <linux/fs.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/uaccess.h> + +#define TUNING_FILE_PATH "/mnt/sdcard/sr130pc20_regs.h" +#endif /* CONFIG_LOAD_FILE*/ + +#include "sr130pc20_regs.h" + +#endif /* __SR130PC20_H__ */ diff --git a/drivers/media/video/sr130pc20_regs.h b/drivers/media/video/sr130pc20_regs.h new file mode 100644 index 0000000..ebc578b --- /dev/null +++ b/drivers/media/video/sr130pc20_regs.h @@ -0,0 +1,4229 @@ +/* sr130pc20_regs.h + * + * Driver for s5k5ccgx (5MP Camera) from siliconfile + * + * Copyright (C) 2010, SAMSUNG ELECTRONICS + * + * 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. + * + * Change Date: 2012.06.28 + */ + +#ifndef __SR130PC20_REGS_H__ +#define __SR130PC20_REGS_H__ + +/* PV 1st */ + +static const sr130pc20_regset_t SR130PC20_Init_Reg[] = { + +/*0 Page*/ +0x0300, +0x0101, /*sleep*/ +0x0103, /*s/w reset*/ +0x0101, /*sleep*/ + +0x0800,/*Don't touch*/ +0x0937,/*Don't touch*/ +0x0a33,/*Don't touch*/ + +/*PLL Setting*/ +0xd005, +0xd130, +0xd201, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x1011, +0x1190, /*xy flip*/ +0x1200, +0x1488, + +0x0300, +0x2000, +0x2104, +0x2200, +0x2304, +0x2403, +0x25C0, +0x2605, +0x2700, + +0x4001, /*Hblank_280*/ +0x4118, +0x4200, /*Vblank 100*/ +0x4364, + +/*--------------- BLC*/ +0x8008, /*Don't touch */ +0x8197, /*Don't touch */ +0x8290, /*Don't touch */ +0x8330, /*Don't touch */ +0x84cc, /*Don't touch*/ +0x8500, /*Don't touch*/ +0x86d4, /*Don' t touch*/ +0x870f, /*Don't touch*/ +0x8834, /*Don't touch*/ + +0x900c, /*BLC_TIME_TH_ON*/ +0x910c, /*BLC_TIME_TH_OFF */ +0x92f0, /*BLC_AG_TH_ON*/ +0x93e8, /*BLC_AG_TH_OFF*/ + +0x9495, /*091202*/ +0x9590, /*091202 */ +0x9838, /*Don't touch*/ + +/*Dark BLC*/ +0xa001, /* 20100309*/ +0xa201, /* 20100309*/ +0xa401, /* 20100309*/ +0xa601, /* 20100309*/ + +/*Normal BLC*/ +0xa800, +0xaa00, +0xac00, +0xae00, + +/*Out BLC*/ +0x9900, +0x9a00, +0x9b00, +0x9c00, + +/*2 Page*/ +0x0302, +0x1200, /*Don't touch*/ +0x1400, /*Don't touch*/ +0x1500, /*Don't touch*/ +0x184C, /*Don't touch*/ +0x1900, /*Don't touch*/ +0x1A39, /*Don't touch*/ +0x1B00,/*Don't touch*/ +0x1C1a, /*Don't touch*/ +0x1D14, /*Don't touch*/ +0x1E30,/*Don't touch*/ +0x1F10,/*Don't touch*/ + +0x2077, +0x21de, +0x22a7, +0x2330, +0x2477, +0x2510, +0x2610, +0x273c, +0x2b80, +0x2c02, +0x2da0, +0x2e00, +0x2fa7, + +0x3000, +0x3199, +0x3200, +0x3300, +0x3422, +0x3601, +0x3701, +0x3888, +0x3988, +0x3d03, +0x3e0d, +0x3f02, + +0x49d1, +0x4a14, + +0x5021, +0x5201, +0x5381, +0x5410, +0x551c, +0x5611, +0x5818, +0x5916, +0x5da2, +0x5e5a, + +0x6093, /* 20120517 modify*/ +0x61a4, /* 20120517 modify*/ +0x6294, /* 20120517 modify*/ +0x63a3, /* 20120517 modify*/ +0x6494, /* 20120517 modify*/ +0x65a3, /* 20120517 modify*/ +0x670c, +0x680c, +0x690c, +0x6ab4, +0x6bc4, +0x6cb5, +0x6dc2, +0x6eb5, +0x6fc0, + +0x70b6, +0x71b8, +0x7295, /* 20120517 modify*/ +0x73a2, /* 20120517 modify*/ +0x7495, /* 20120517 modify*/ +0x75a2, /* 20120517 modify*/ +0x7695, /* 20120517 modify*/ +0x77a2, /* 20120517 modify*/ +0x7C92, /* 20120517 modify*/ +0x7Dff, /* 20120517 modify*/ + +0x8001, /* 20120517 modify*/ +0x818a, /* 20120517 modify*/ +0x821e, /* 20120517 modify*/ +0x8336, /* 20120517 modify*/ +0x8489, /* 20120517 modify*/ +0x858b, /* 20120517 modify*/ +0x8689, /* 20120517 modify*/ +0x878b, /* 20120517 modify*/ +0x88ab, +0x89bc, +0x8aac, +0x8bba, +0x8cad, +0x8db8, +0x8eae, +0x8fb2, + +0x90b3, +0x91b7, +0x9252, /* 20120517 modify*/ +0x936a, /* 20120517 modify*/ +0x9489, /* 20120517 modify*/ +0x958b, /* 20120517 modify*/ +0x9689, /* 20120517 modify*/ +0x978b, /* 20120517 modify*/ + +0xA002, +0xA186, /* 20120517 modify*/ +0xA202, +0xA386, /* 20120517 modify*/ +0xA486, /* 20120517 modify*/ +0xA502, +0xA686, /* 20120517 modify*/ +0xA702, +0xA892, /* 20120517 modify*/ +0xA994, /* 20120517 modify*/ +0xAA92, /* 20120517 modify*/ +0xAB94, /* 20120517 modify*/ +0xAC1c, +0xAD22, +0xAE1c, +0xAF22, + +0xB0a4, /* 20120517 modify*/ +0xB1ae, /* 20120517 modify*/ +0xB2a4, /* 20120517 modify*/ +0xB3ae, /* 20120517 modify*/ +0xB4a6, /* 20120517 modify*/ +0xB5ac, /* 20120517 modify*/ +0xB6a6, /* 20120517 modify*/ +0xB7ac, /* 20120517 modify*/ +0xB8a6, /* 20120517 modify*/ +0xB9ab, /* 20120517 modify*/ +0xBAa6, /* 20120517 modify*/ +0xBBab, /* 20120517 modify*/ +0xBCa6, /* 20120517 modify*/ +0xBDab, /* 20120517 modify*/ +0xBEa6, /* 20120517 modify*/ +0xBFab, /* 20120517 modify*/ + +0xc437, +0xc552, +0xc66b, +0xc786, +0xc838, /* 20120517 modify*/ +0xc950, /* 20120517 modify*/ +0xca38, /* 20120517 modify*/ +0xcb50, /* 20120517 modify*/ +0xcc6c, /* 20120517 modify*/ +0xcd84, /* 20120517 modify*/ +0xce6c, /* 20120517 modify*/ +0xcf84, /* 20120517 modify*/ + +/*0xd4a6,*/ +/*0xd5ac,*/ +/*0xd6a6,*/ +/*0xd7ac,*/ +/*add 20120517*/ +0xdc00, /* Added*/ +0xddaf, /* Added*/ +0xde00, /* Added*/ +0xdf90, /* Added*/ + +0xd010, +0xd114, +0xd220, +0xd300, +/*DCDC */ +0xd40c, /*DCDC_TIME_TH_ON*/ +0xd50c, /*DCDC_TIME_TH_OFF */ +0xd6f0, /*DCDC_AG_TH_ON*/ +0xd7e8, /*DCDC_AG_TH_OFF*/ + +0xea8a, + +0xF001, /* clock inversion*/ +0xF101, +0xF201, +0xF301, +0xF401, +0xF500, + +/*----------------------------------------------*/ +0x0310, /*page 10*/ +0x1001, /*Ycbcr422_bit Order: YUYV*/ +0x1103, +0x1230, /*y offset[4], dif_offset[5]*/ +0x1302, /*contrast effet enable : 0x02*/ +0x3400, /*hidden 10->00 100209*/ +0x3701, /*yc2d power save */ +0x3f04, /*100825*/ +0x4080, /*Y offset */ +0x4880, +0x5300, /*dif_offset option */ +0x5530, /*dif_offset option diff_offset max */ + +0x604f, /*out color sat en[7] | auto color decrement en[1] / + | manual color sat en[0]*/ + +0x6183, /*blue saturation_C0*/ +0x6280, /*red saturation_B0*/ + +0x63ff, /*auto decresment on AG th*/ +0x64c0, /*auto decresment on DG th*/ +0x66e4, /*Outdoor saturation step 137fps apply out th */ +0x6703, /*Outdoor saturation B/R*/ +0x7601, /* ADD 20121031 */ +0x7904, /* ADD 20121031 */ + +/* Hi 163 */ +/* PAGE 10 START*/ +0x0310, +0x8000, /* dsshin --> color enhance*/ +0xf500, /* dsshin --> h blank option*/ + +0x0311, /*page 11 D_LPF */ +0x103f, /*B[6]:Blue En Dlpf on[4:0] Sky over off : 0x7f->3f*/ +0x1120, /* Uniform Full GbGr/OV-Nr*/ + +0x1280, /*Blue MaxOpt blue sky max filter optoin rate : 0 0xc0->80*/ +0x13b8, /*dark2[7] | ratio[6:4] | dark3[3] | dark3 maxfilter ratio[2:0] */ + +0x30ba, /*Outdoor2 H th*/ +0x3110, /*Outdoor2 L th*/ +0x3250, /*Outdoor2 gain ratio*/ +0x331d, /*Outdoor2 H lum*/ +0x3420, /*Outdoor2 M lum*/ +0x351f, /*Outdoor2 L lum*/ + +0x36b0, /*Outdoor1 H th*/ +0x3718, /*Outdoor1 L th*/ +0x3850, /*Outdoor1 gain ratio 0x80->40*/ +0x391d, /*Outdoor1 H lum 0x28->1e*/ +0x3a20, /*Outdoor1 M lum 0x10->15*/ +0x3b1f, /*Outdoor1 L lum 0x08->20*/ + +0x3c3f, /*indoor H th*/ +0x3d16, /*indoor L th*/ +0x3e30, /*indoor gain ratio 0x44 6a */ +0x3f1a, /*indoor H lum 0x12 18 */ +0x4060, /*indoor M lum 0x18 1c*/ +0x411a, /*indoor L lum 0x18 3e*/ + +0x4298, /*dark1 H th*/ +0x4328, /*dark1 L th*/ +0x4465, /*dark1 gain ratio*/ +0x4516, /*dark1 H lum 0x38->0x28 */ +0x4630, /*dark1 M lum 0x27->0x17*/ +0x4734, /*dark1 L lum 0x20->0x1a */ + +0x4890, /*dark2 H th*/ +0x492a, /*dark2 L th*/ +0x4a65, /*dark2 gain ratio*/ +0x4b18, /*dark2 H lum */ +0x4c31, /*dark2 M lum*/ +0x4d36, /*dark2 L lum */ + +0x4e80, /*dark3 H th*/ +0x4f30, /*dark3 L th*/ +0x5065, /*dark3 gain ratio*/ +0x5119, /*dark3 H lum */ +0x5231, /*dark3 M lum */ +0x5336, /*dark3 L lum */ + +0x5a3f, /*blue sky mode out1/2 enable 0x27->3f */ +0x5b00, /*Impulse pixel enable dark123,in,out123 :: must be 0x07*/ +0x5c9f, /*Indoor maxfilter rate[7:5] | Uncertain onoff[4:0] 0x1f ->0x9f*/ + +0x603f, /*GbGr all enable*/ +0x620f, /*GbGr offset*/ + +0x650c, /*Outdoor GbGr rate H 100% M 25% L 100%*/ +0x660c, /*Indoor GbGr rate H 100% M 25% L 100%*/ +0x6700, /*dark GbGr rate H/M/L 100%*/ + +0x700c, /* Abberation On/Off B[1]: Outdoor B[0]: Indoor 07>>c*/ +0x75a0, /* Outdoor2 Abberation Luminance lvl */ +0x7db4, /* Indoor Abberation Luminance lvl*/ + +0x9608, /*indoor/Dark1 edgeoffset1*/ +0x9714, /*indoor/Dark1 center G value*/ +0x98f5, /*slope indoor :: left/right graph polarity, slope*/ +0x992a, /*indoor uncertain ratio control*/ +0x9a20, /*Edgeoffset_dark*/ + +/*DPC_CTRL*/ +0x0312, /*Preview DPC off[0x5c] on[0x5d]*/ +0x200f, +0x210f, + +0x2500, /* 0x30*/ + +0x2a01, +0x2e00, /*2010.8.25*/ + +0x3035, /*Texture region(most detail)*/ +0x31a0, /*STD uniform1 most blur region*/ +0x32b0, /*STD uniform2 2nd blur*/ +0x33c0, /*STD uniform3 3rd blur*/ +0x34d0, /*STD normal noise1 4th blur */ +0x35e0, /*STD normal noise2 5th blur*/ +0x36ff, /*STD normal noise3 6th blur*/ + +0x4083, /*Outdoor2 H th*/ +0x4120, /*Outdoor2 L th */ +0x4208, /*Outdoor2 H luminance */ +0x4310, /*Outdoor2 M luminance */ +0x4410, /*Outdoor2 l luminance */ +0x4550, /*Outdoor2 ratio*/ + +0x4683, /*Outdoor1 H th*/ +0x4720, /*Outdoor1 L th */ +0x4808, /*Outdoor1 H luminance*/ +0x4910, /*Outdoor1 M luminance*/ +0x4a10, /*Outdoor1 L luminance*/ +0x4b50, /*Outdoor1 ratio*/ + +0x4c80, /*Indoor H th*/ +0x4d48, /*Indoor L th*/ +0x4e30, /*indoor H lum*/ +0x4f30, /*indoor M lum*/ +0x5012, /*indoor L lum */ +0x5170, /*indoor ratio 0x10 -> 0x45*/ + +0x52a8, /*dark1 H th*/ +0x5330, /*dark1 L th */ +0x5428, /*dark1 H lum */ +0x553e, /*dark1 M lum*/ +0x5667, /*dark1 L lum*/ +0x576a, /*dark1 ratio*/ + +0x58a0, /*dark2 H th*/ +0x5940, /*dark2 L th*/ +0x5a28, /*dark2 H lum*/ +0x5b3f, /*dark2 M lum*/ +0x5c68, /*dark2 L lum*/ +0x5d70, /*dark2 ratio*/ + +0x5ea0, /*dark3 H th*/ +0x5f40, /*dark3 L th*/ +0x6029, /*dark3 H lum*/ +0x613f, /*dark3 M lum*/ +0x6269, /*dark3 L lum*/ +0x636a, /*dark3 ratio*/ + +/*C-filter(Out2&Out1)*/ +0x7010, +0x710a, + +/*C-filter(Indoor&Dark3)*/ +0x7210, +0x730a, + +/*C-filter(Dark2&Dark1)*/ +0x7418, +0x7512, + +0x8020, +0x8140, +0x8265, +0x851a, +0x8800, +0x8900, +0x905d, /*Preview DPC off[0x5c] on[0x5d]*/ + +/*DPC-Dark1,2,3*/ +0xad07, /*10825*/ +0xae07, /*10825*/ +0xaf07, /*10825*/ + +/*Blue Det..*/ +0xc558, /*BlueRange 2010.8.25 0x40->23 */ +0xc620, /*GreenRange 2010.8.25 0x3b->20 */ + +0xd088, /*2010.8.25*/ +0xd180, +0xd217,/*preview 17, full 67*/ +0xd300, +0xd400, +0xd50f,/*preview 0f, full 02*/ +0xd6ff, +0xd7ff,/*preview ff, full 18*/ +0xd800, +0xd904, + +/*interpolated with average*/ +0xdb38, /*resolution issue 0x00->0x18->0x38 */ +0xd904, /*strong_edge detect ratio*/ +0xe001, /*strong_edge detect ratio*/ + +0x0313, /*page 13 sharpness 1D*/ +0x10c5, +0x117b, +0x120e, +0x1400, + +0x1511, /*added option 1.3M*/ +0x1830, /*added option 1.3M*/ + +0x2015, +0x2113, +0x2233, +0x2308, /*hi_clip th1*/ +0x241a, /*hi_clip th2*/ +0x2506, /*low clip th*/ + +0x2618, +0x2730, +0x2910, /*time th*/ +0x2a30, /*pga th*/ + +0x2b03, /*lpf out2*/ +0x2c03, /*lpf out1*/ +0x2d0c, +0x2e12, +0x2f12, + +/*1D Edge*/ +0x500a, /*out2 hi nega*/ +0x5307, /* hi pos*/ +0x510c, /* mi nega*/ +0x5407, /* mi pos*/ +0x520b, /* lo nega*/ +0x5508, /* lo pos*/ + +0x560a, /*out1 hi nega*/ +0x5907, /* hi pos */ +0x570c, /* mi nega*/ +0x5a07, /* mi pos */ +0x580b, /* lo nega*/ +0x5b08, /* lo pos */ + +/*Indoor Edge*/ +0x5c08, /*indoor hi nega*/ +0x5f07, /* hi pos*/ +0x5d14, +0x6012, +0x5e0a, +0x6108, /* low pos*/ + +0x6208, /*dark1 hi nega*/ +0x6506, /* hi pos */ +0x6308, /* mid nega */ +0x6606, /* mid pos */ +0x6408, /* low nega */ +0x6706, /* low pos */ + +0x6807, /*dark2 hi nega*/ +0x6b05, /* hi pos */ +0x6907, /* mid nega */ +0x6c05, /* mid pos */ +0x6a07, /* low nega */ +0x6d05, /* low pos */ + +0x6e0a, /*dark3 hi nega*/ +0x7109, /* hi pos */ +0x6f0a, /* mid nega */ +0x7209, /* mid pos */ +0x700a, /* low nega */ +0x7309, /* low pos */ + + /* 2DY*/ +0x80c1, +0x811f, +0x82e1, +0x8333, + +0x9005, +0x9105, +0x9233, +0x9330, +0x9403, +0x9514, +0x9730, +0x9930, + +0xa002, /*2d lclp out2 nega*/ +0xa103, /*2d lclp out2 pos*/ +0xa202, /*2d lclp out1 nega*/ +0xa303, /*2d lclp out1 pos*/ +0xa403, /*2d lclp in nega*/ +0xa504, /*2d lclp in pos*/ +0xa607, /*2d lclp dark1 nega*/ +0xa708, /*2d lclp dark1 pos*/ +0xa807, /*2d lclp dark2 nega*/ +0xa908, /*2d lclp dark2 pos*/ +0xaa07, /*2d lclp dark3 nega*/ +0xab08, /*2d lclp dark3 pos*/ + +0xb010, /*out2 H Ne*/ +0xb310, /* H Po*/ +0xb11e, /* M Ne*/ +0xb41e, /* M Po*/ +0xb21f, /* L Ne*/ +0xb51e, /* L Po*/ + +0xb610, /*out1 H Ne */ +0xb910, /* H Po */ +0xb71e, /* M Ne */ +0xba1e, /* M Po */ +0xb81f, /* L Ne */ +0xbb1e, /* L Po */ + +0xbc20, /*indoor H Ne*/ +0xbf1e, /* H Po*/ +0xbd25, /* M Ne*/ +0xc023, /* M Po*/ +0xbe24, /* L Ne*/ +0xc122, /* L Po*/ + +0xc223, /*dark1 H Ne*/ +0xc523, /* H Po*/ +0xc329, /* M Ne*/ +0xc629, /* M Po*/ +0xc425, /* L Ne*/ +0xc725, /* L Po*/ + +0xc81c, /*dark2 H Ne*/ +0xcb1c, /* H Po*/ +0xc925, /* M Ne*/ +0xcc25, /* M Po*/ +0xca23, /* L Ne*/ +0xcd23, /* L Po*/ + +0xce1c, /*dark3 H Ne*/ +0xd11c, /* H Po*/ +0xcf25, /* M Ne*/ +0xd225, /* M Po*/ +0xd023, /* L Ne*/ +0xd323, /* L Po*/ + +/* PAGE 14 START*/ +0x0314, +0x1031, + +0x1480, /* GX*/ +0x1580, /* GY*/ +0x1680, /* RX*/ +0x1780, /* RY*/ +0x1880, /* BX*/ +0x1980, /* BY*/ + +0x2060, /* X Center*/ +0x2180, /* Y Center*/ + +0x2280, +0x2380, +0x2480, + +0x30c8, +0x312b, +0x3200, +0x3300, +0x3490, + +0x4056, /*R min's set 4e*/ +0x413a, /*Gr*/ +0x4237, /*B*/ +0x433a, /*Gb*/ + +0x0315, +0x1021, +0x1444, /*49*/ +0x1534, /*38*/ +0x1626, /*2b*/ +0x172f, + +0x30dd, +0x3162, +0x3205, +0x3326, +0x34bd, +0x3517, +0x3618, +0x3738, +0x38d0, + +0x40b0, +0x4130, +0x4200, +0x4300, +0x4400, +0x4500, +0x4699, +0x4719, +0x4800, + +0x5016, +0x51b2, +0x521c, +0x5306, +0x5420, +0x55a6, +0x560e, +0x57b2, +0x5824, + +0x0316, +0x1031, /*GMA_CTL*/ +0x187e, /*AG_ON*/ +0x197d, /*AG_OFF*/ +0x1a0e, /*TIME_ON*/ +0x1b01, /*TIME_OFF*/ +0x1Cdc, /*OUT_ON*/ +0x1Dfe, /*OUT_OFF*/ + +/*GMA Indoor*/ +0x3000, +0x3107, +0x321a, +0x3335, +0x345a, +0x357c, +0x3696, +0x37a9, +0x38b7, +0x39c6, +0x3ad2, +0x3bdc, +0x3ce4, +0x3deb, +0x3ef1, +0x3ff5, +0x40f9, +0x41fd, +0x42ff, + +/*RGMA Outdoor*/ +0x5000, +0x5103, +0x5213, +0x532e, +0x5459, +0x5579, +0x5690, +0x57a3, +0x58b4, +0x59c2, +0x5acd, +0x5bd7, +0x5ce0, +0x5de5, +0x5ee9, +0x5fee, +0x60f1, +0x61f3, +0x62f6, + +/*BGMA Dark*/ +0x7003, +0x7111, +0x721f, +0x7337, +0x7452, +0x756c, +0x7685, +0x779a, +0x78ad, +0x79bd, +0x7acb, +0x7bd6, +0x7ce0, +0x7de8, +0x7eef, +0x7ff4, +0x80f8, +0x81fb, +0x82fe, + +0x0324, /*Resol control */ +0x60c5, /*edge even frame | 16bit resol | white edge cnt | scene resol enable*/ +0x6104, /*even frame update */ +0x6408, +0x6500, +0x6626, /*edge th2 H */ +0x6700, /*edge th2 L */ + +0x0313, +0x1831, /*flat center Gb/Gr*/ +0x7402, /*det slope en | gausian filter*/ +0x750d, /*1D negative gain det 09 */ +0x760d, /*1D postive gain det 08*/ +0x7710, /*1D hclp2 det*/ +0x7808, /*outdoor flat threshold*/ +0x7910, /*indoor flat threshold*/ + +0x81df, /*det gain controler*/ +0x8690, /*2D negative gain det */ +0x8790, /*2D postive gain det */ +0x962a, /*2D hclp2 det*/ + +0x0312, /*0x12 page*/ +0xd088, +0xd9e4, + +/* PAGE 18 START*/ +0x0318, +0x1400, + +/* PAGE 20 START*/ +0x0320, +0x111c, +0x1830, +0x1a08, +0x2045,/*weight*/ +0x2130, +0x2210, +0x2300, +0x2400, + +0x28e7, /* add 20120223*/ +0x290d, /* 20100305 ad -> 0d*/ +0x2afd, +0x2bf8, + +0x2cc3, +0x2d5f, /* add 20120223*/ +0x2e33, +0x30f8, +0x3203, +0x332e, +0x3430, +0x35d4, +0x36ff, /*fe*/ +0x3732, +0x3804, +0x3922, +0x3ade, +0x3b22, +0x3cde, +0x3de1, + +0x5045, +0x5188, + +0x561a, +0x5780, +0x580e, +0x596a, +0x5a04, + +0x5e9d, /*AE_AWB_start*/ +0x5f76, /*AE_AWB_start*/ + +0x7033, /* 6c*/ +0x7182, /* 82(+8)*/ + +0x7621, +0x7771, +0x7822, /* 24*/ +0x7923, /* Y Target 70 => 25, 72 => 26*/ +0x7a23, /* 23*/ +0x7b22, /* 22*/ +0x7d23, + +0x8301, /*EXP Normal 33.33 fps */ +0x845f, +0x8590, +0x8601, /*EXPMin 7500.00 fps*/ +0x8790, +0x8805, /*EXP Max(120Hz) 8.00 fps */ +0x89b8, +0x8ad8, +0xa505, /*EXP Max(100Hz) 8.33 fps */ +0xa67e, +0xa740, +0x8B75, /*EXP100 */ +0x8C30, +0x8D61, /*EXP120 */ +0x8Ea8, +0x9c09, /*EXP Limit 1250.00 fps */ +0x9d60, +0x9e01, /*EXP Unit */ +0x9f90, +0x989d, + +0xb016, +0xb114, +0xb2f8, +0xb314, +0xb41b, +0xb546, +0xb631, +0xb729, +0xb826, +0xb924, +0xba22, +0xbb42, +0xbc41, +0xbd40, + +0xc010, +0xc138, +0xc238, +0xc338, +0xc407, + +0xc880, +0xc980, +0x109c, /* ae enable*/ +/* PAGE 20 END*/ + +/*AE_Weight*/ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2412, +0x2522, +0x2622, +0x2721, +0x2812, +0x2922, +0x2a22, +0x2b21, +0x2c12, +0x2d23, +0x2e32, +0x2f21, +0x3012, +0x3123, +0x3232, +0x3321, +0x3412, +0x3522, +0x3622, +0x3721, +0x3812, +0x3922, +0x3a22, +0x3b21, +0x3c11, +0x3d11, +0x3e11, +0x3f11, + +/* PAGE 22 START*/ +0x0322, +0x10fd, +0x112e, +0x1901, /* Low On*/ +0x2030, /* for wb speed*/ +0x2140, +0x2401, +0x257e, /* for tracking 20120314 */ + +0x3080, /* 20120224 test*/ +0x3180, +0x3811, +0x3934, + +0x40e8, +0x4143, /* 33*/ +0x4222, /* 22*/ + +0x43f3, /* f6*/ +0x4454, /* 44*/ +0x4522, /* 33*/ + +0x4600, +0x480a, +0x50b2, +0x5181, +0x5298, + +0x8038, +0x8120, +0x8238, /* 3a*/ + +0x8356, /* R Max*/ +0x8420, /* R Min*/ +0x8552, /* B Max*/ +0x8620, /* B Min*/ + +0x8745, +0x883a, +0x8933, +0x8a2c, + +0x8b42, +0x8c3d, +0x8d30, +0x8e2c, + +0x8f5a, +0x9059, +0x9155, +0x924e, +0x9344, +0x943a, +0x9534, +0x962c, +0x9723, +0x9820, +0x991f, +0x9a1f, + +0x9b77, +0x9c77, +0x9d48, +0x9e38, +0x9f30, + +0xa040, +0xa121, +0xa26f, +0xa3ff, + +0xa414, /* 1500fps*/ +0xa544, /* 700fps*/ +0xa6cf, + +0xad40, +0xae4a, + +0xaf2a, /* low temp Rgain*/ +0xb028, /* low temp Rgain*/ + +0xb100, /* 0x20 -> 0x00 0405 modify*/ +0xb4bf, /* for tracking 20120314*/ +0xb8a1, /* a2: b-2, R+2 b4 B-3, R+4 lowtemp b0 a1 Spec AWB A modify*/ +0xb900, +/* PAGE 22 END*/ + +/* PAGE 48 (MiPi 1600x1200)*/ +0x0300, + +/* PLL Setting */ +0xd005, +0xd130, +0xd205, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x0348, +/* MIPI TX Setting */ +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +0x1d0e, +0x1e07, +0x1f08, + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2b40,*/ + +0x3005, +0x3100, + +0x3207, +0x3309, +0x3401, +0x3501, + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_VT_Init_Reg[] = { +/*0 Page*/ +0x0300, +0x0101, /*sleep*/ +0x0103, /*s/w reset*/ +0x0101, /*sleep*/ + +0x0800,/*Don't touch*/ +0x0937,/*Don't touch*/ +0x0a33,/*Don't touch*/ + +/*PLL Setting*/ +0xd005, +0xd130, +0xd201, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x1011, +0x1194, /*xy flip*/ +0x1200, /*Sync type default:0x00 PCLK[2] 0 falling, 1 rising*/ +0x1488, + +/*--------------- windowing */ +0x0300, +0x2000, +0x2104, +0x2200, +0x2304, +0x2403, +0x25C0, +0x2605, +0x2700, + +0x4001, /*Hblank 280*/ +0x4118, +0x4200, /*Vblank 20*/ +0x4314, + +/*--------------- BLC*/ +0x8008, /*Don't touch */ +0x8197, /*Don't touch */ +0x8290, /*Don't touch */ +0x8330, /*Don't touch */ +0x84cc, /*Don't touch*/ +0x8500, /*Don't touch*/ +0x86d4, /*Don' t touch*/ +0x870f, /*Don't touch*/ +0x8834, /*Don't touch*/ + +0x9009, /*BLC_TIME_TH_ON*/ +0x9109, /*BLC_TIME_TH_OFF */ +0x92f0, /*BLC_AG_TH_ON*/ +0x93e8, /*BLC_AG_TH_OFF*/ + +0x9495, /*091202*/ +0x9590, /*091202 */ +0x9838, /*Don't touch*/ + +/*Dark BLC*/ +0xa001, /* 20100309*/ +0xa201, /* 20100309*/ +0xa401, /* 20100309*/ +0xa601, /* 20100309*/ + +/*Normal BLC*/ +0xa800, +0xaa00, +0xac00, +0xae00, + +/*Out BLC*/ +0x9900, +0x9a00, +0x9b00, +0x9c00, + +/*2 Page*/ +0x0302, +0x1200, /*Don't touch*/ +0x1400, /*Don't touch*/ +0x1500, /*Don't touch*/ +0x184C, /*Don't touch*/ +0x1900, /*Don't touch*/ +0x1A39, /*Don't touch*/ +0x1B00,/*Don't touch*/ +0x1C1a, /*Don't touch*/ +0x1D14, /*Don't touch*/ +0x1E30,/*Don't touch*/ +0x1F10,/*Don't touch*/ + +0x2077, +0x21de, +0x22a7, +0x2330, +0x2477, +0x2510, +0x2610, +0x273c, +0x2b80, +0x2c02, +0x2da0, +0x2e00, +0x2fa7, + +0x3000, +0x3199, +0x3200, +0x3300, +0x3422, +0x3601, +0x3701, +0x3888, +0x3988, +0x3d03, +0x3e0d, +0x3f02, + +0x49d1, +0x4a14, + +0x5021, +0x5201, +0x5381, +0x5410, +0x551c, +0x5611, +0x5818, +0x5916, +0x5da2, +0x5e5a, + +0x6093, /* 20120517 modify*/ +0x61a4, /* 20120517 modify*/ +0x6294, /* 20120517 modify*/ +0x63a3, /* 20120517 modify*/ +0x6494, /* 20120517 modify*/ +0x65a3, /* 20120517 modify*/ +0x670c, +0x680c, +0x690c, +0x6ab4, +0x6bc4, +0x6cb5, +0x6dc2, +0x6eb5, +0x6fc0, + +0x70b6, +0x71b8, +0x7295, /* 20120517 modify*/ +0x73a2, /* 20120517 modify*/ +0x7495, /* 20120517 modify*/ +0x75a2, /* 20120517 modify*/ +0x7695, /* 20120517 modify*/ +0x77a2, /* 20120517 modify*/ +0x7C92, /* 20120517 modify*/ +0x7Dff, /* 20120517 modify*/ + +0x8001, /* 20120517 modify*/ +0x818a, /* 20120517 modify*/ +0x821e, /* 20120517 modify*/ +0x8336, /* 20120517 modify*/ +0x8489, /* 20120517 modify*/ +0x858b, /* 20120517 modify*/ +0x8689, /* 20120517 modify*/ +0x878b, /* 20120517 modify*/ +0x88ab, +0x89bc, +0x8aac, +0x8bba, +0x8cad, +0x8db8, +0x8eae, +0x8fb2, + +0x90b3, +0x91b7, +0x9252, /* 20120517 modify*/ +0x936a, /* 20120517 modify*/ +0x9489, /* 20120517 modify*/ +0x958b, /* 20120517 modify*/ +0x9689, /* 20120517 modify*/ +0x978b, /* 20120517 modify*/ + +0xA002, +0xA186, /* 20120517 modify*/ +0xA202, +0xA386, /* 20120517 modify*/ +0xA486, /* 20120517 modify*/ +0xA502, +0xA686, /* 20120517 modify*/ +0xA702, +0xA892, /* 20120517 modify*/ +0xA994, /* 20120517 modify*/ +0xAA92, /* 20120517 modify*/ +0xAB94, /* 20120517 modify*/ +0xAC1c, +0xAD22, +0xAE1c, +0xAF22, + +0xB0a4, /* 20120517 modify*/ +0xB1ae, /* 20120517 modify*/ +0xB2a4, /* 20120517 modify*/ +0xB3ae, /* 20120517 modify*/ +0xB4a6, /* 20120517 modify*/ +0xB5ac, /* 20120517 modify*/ +0xB6a6, /* 20120517 modify*/ +0xB7ac, /* 20120517 modify*/ +0xB8a6, /* 20120517 modify*/ +0xB9ab, /* 20120517 modify*/ +0xBAa6, /* 20120517 modify*/ +0xBBab, /* 20120517 modify*/ +0xBCa6, /* 20120517 modify*/ +0xBDab, /* 20120517 modify*/ +0xBEa6, /* 20120517 modify*/ +0xBFab, /* 20120517 modify*/ + +0xc437, +0xc552, +0xc66b, +0xc786, +0xc838, /* 20120517 modify*/ +0xc950, /* 20120517 modify*/ +0xca38, /* 20120517 modify*/ +0xcb50, /* 20120517 modify*/ +0xcc6c, /* 20120517 modify*/ +0xcd84, /* 20120517 modify*/ +0xce6c, /* 20120517 modify*/ +0xcf84, /* 20120517 modify*/ + +/*0xd4a6,*/ +/*0xd5ac,*/ +/*0xd6a6,*/ +/*0xd7ac,*/ +/*add 20120517*/ +0xdc00, /* Added*/ +0xddaf, /* Added*/ +0xde00, /* Added*/ +0xdf90, /* Added*/ + +0xd010, +0xd114, +0xd220, +0xd300, +/*DCDC */ +0xd409, /*DCDC_TIME_TH_ON*/ +0xd509, /*DCDC_TIME_TH_OFF */ +0xd6f0, /*DCDC_AG_TH_ON*/ +0xd7e8, /*DCDC_AG_TH_OFF*/ + +0xea8a, + +0xF001, /* clock inversion*/ +0xF101, +0xF201, +0xF301, +0xF401, +0xF500, + +/*----------------------------------------------*/ +0x0310, /*page 10*/ +0x1001, /*Ycbcr422_bit Order: YUYV*/ +0x1230, /*y offset[4], dif_offset[5]*/ +0x1302, /*contrast effet enable : 0x02*/ +0x3400, /*hidden 10->00 100209*/ +0x3701, /*yc2d power save */ +0x3f04, /*100825*/ +0x4080, /*Y offset */ +0x4138, +0x4880, /*Contrast (Y = constrast * (Y - 128) + 128)*//*86 */ +0x50f0, +0x5300, /*dif_offset option */ +0x5530, /*dif_offset option diff_offset max */ + +0x6003, /*out color sat en[7] | auto color decrement en[1] / + | manual color sat en[0]*/ + + +0x6183, /*blue saturation_C0*/ +0x6280, /*red saturation_B0*/ + +0x63ff, /*auto decresment on AG th*/ +0x64ff, /*auto decresment on DG th*/ +0x66e4, /*Outdoor saturation step 137fps apply out th */ +0x6700, /*Outdoor saturation B/R*/ +0x7601, /* ADD 20121031 */ +0x7904, /* ADD 20121031 */ + +/* Hi 163 */ +/* PAGE 10 START*/ +0x0310, +0x8000, /* dsshin --> color enhance*/ +0xf500, /* dsshin --> h blank option*/ + +0x0311, /*page 11 D_LPF */ +0x103f, /*B[6]:Blue En Dlpf on[4:0] Sky over off : 0x7f->3f*/ +0x1120, /* Uniform Full GbGr/OV-Nr*/ + +0x1280, /*Blue MaxOpt blue sky max filter optoin rate : 0 0xc0->80*/ +0x13b8, /*dark2[7] | dark2 maxfilter ratio[6:4] + | dark3[3] | dark3 maxfilter ratio[2:0] */ + +0x30ba, /*Outdoor2 H th*/ +0x3110, /*Outdoor2 L th*/ +0x3250, /*Outdoor2 gain ratio*/ +0x331d, /*Outdoor2 H lum*/ +0x3420, /*Outdoor2 M lum*/ +0x351f, /*Outdoor2 L lum*/ + +0x36b0, /*Outdoor1 H th*/ +0x3718, /*Outdoor1 L th*/ +0x3850, /*Outdoor1 gain ratio 0x80->40*/ +0x391d, /*Outdoor1 H lum 0x28->1e*/ +0x3a20, /*Outdoor1 M lum 0x10->15*/ +0x3b1f, /*Outdoor1 L lum 0x08->20*/ + +0x3c3f, /*indoor H th*/ +0x3d16, /*indoor L th*/ +0x3e30, /*indoor gain ratio 0x44 6a */ +0x3f1a, /*indoor H lum 0x12 18 */ +0x4060, /*indoor M lum 0x18 1c*/ +0x411a, /*indoor L lum 0x18 3e*/ + +0x4298, /*dark1 H th*/ +0x4328, /*dark1 L th*/ +0x4465, /*dark1 gain ratio*/ +0x4516, /*dark1 H lum 0x38->0x28 */ +0x4630, /*dark1 M lum 0x27->0x17*/ +0x4734, /*dark1 L lum 0x20->0x1a */ + +0x4890, /*dark2 H th*/ +0x492a, /*dark2 L th*/ +0x4a65, /*dark2 gain ratio*/ +0x4b18, /*dark2 H lum */ +0x4c31, /*dark2 M lum*/ +0x4d36, /*dark2 L lum */ + +0x4e80, /*dark3 H th*/ +0x4f30, /*dark3 L th*/ +0x5065, /*dark3 gain ratio*/ +0x5119, /*dark3 H lum */ +0x5231, /*dark3 M lum */ +0x5336, /*dark3 L lum */ + +0x5a3f, /*blue sky mode out1/2 enable 0x27->3f */ +0x5b00, /*Impulse pixel enable dark123,in,out123 + :: must be 0x07 fix setting use!*/ +0x5c9f, /*Indoor maxfilter rate[7:5] | Uncertain onoff[4:0] 0x1f ->0x9f*/ + +0x603f, /*GbGr all enable*/ +0x620f, /*GbGr offset*/ +/*0x6325,*/ /*GbGr max_20120605_off*/ +/*0x6410,*/ /*GbGr min_20120605_off*/ + +0x650c, /*Outdoor GbGr rate H 100% M 25% L 100%*/ +0x660c, /*Indoor GbGr rate H 100% M 25% L 100%*/ +0x6700, /*dark GbGr rate H/M/L 100%*/ + +0x700c, /* Abberation On/Off B[1]: Outdoor B[0]: Indoor 07>>c*/ +0x75a0, /* Outdoor2 Abberation Luminance lvl */ +0x7db4, /* Indoor Abberation Luminance lvl*/ + +0x9608, /*indoor/Dark1 edgeoffset1*/ +0x9714, /*indoor/Dark1 center G value*/ +0x98f5, /*slope indoor :: left/right graph polarity, slope*/ +0x992a, /*indoor uncertain ratio control*/ +0x9a20, /*Edgeoffset_dark*/ + +/*DPC_CTRL*/ +0x0312, /*Preview DPC off[0x5c] on[0x5d]*/ +0x200e, +0x210e, + +0x2500, /* 0x30*/ + +0x2a01, +0x2e00, /*2010.8.25*/ + +0x3035, /*Texture region(most detail)*/ +0x31a0, /*STD uniform1 most blur region*/ +0x32b0, /*STD uniform2 2nd blur*/ +0x33c0, /*STD uniform3 3rd blur*/ +0x34d0, /*STD normal noise1 4th blur */ +0x35e0, /*STD normal noise2 5th blur*/ +0x36ff, /*STD normal noise3 6th blur*/ + +0x4083, /*Outdoor2 H th*/ +0x4120, /*Outdoor2 L th */ +0x4208, /*Outdoor2 H luminance */ +0x4310, /*Outdoor2 M luminance */ +0x4410, /*Outdoor2 l luminance */ +0x4550, /*Outdoor2 ratio*/ + +0x4683, /*Outdoor1 H th*/ +0x4720, /*Outdoor1 L th */ +0x4808, /*Outdoor1 H luminance*/ +0x4910, /*Outdoor1 M luminance*/ +0x4a10, /*Outdoor1 L luminance*/ +0x4b50, /*Outdoor1 ratio*/ + +0x4c80, /*Indoor H th*/ +0x4d48, /*Indoor L th*/ +0x4e30, /*indoor H lum*/ +0x4f30, /*indoor M lum*/ +0x5012, /*indoor L lum */ +0x5170, /*indoor ratio 0x10 -> 0x45*/ + +0x52a8, /*dark1 H th*/ +0x5330, /*dark1 L th */ +0x5428, /*dark1 H lum */ +0x553e, /*dark1 M lum*/ +0x5667, /*dark1 L lum*/ +0x576a, /*dark1 ratio*/ + +0x58a0, /*dark2 H th*/ +0x5940, /*dark2 L th*/ +0x5a28, /*dark2 H lum*/ +0x5b3f, /*dark2 M lum*/ +0x5c68, /*dark2 L lum*/ +0x5d70, /*dark2 ratio*/ + +0x5ea0, /*dark3 H th*/ +0x5f40, /*dark3 L th*/ +0x6029, /*dark3 H lum*/ +0x613f, /*dark3 M lum*/ +0x6269, /*dark3 L lum*/ +0x636a, /*dark3 ratio*/ + +/*C-filter(Out2&Out1)*/ +0x7010, +0x710a, + +/*C-filter(Indoor&Dark3)*/ +0x7210, +0x730a, + +/*C-filter(Dark2&Dark1)*/ +0x7418, +0x7512, + +0x8020, +0x8140, +0x8265, +0x851a, +0x8800, +0x8900, +0x905d, /*Preview DPC off[0x5c] on[0x5d]*/ + +/*DPC-Dark1,2,3*/ +0xad07, /*10825*/ +0xae07, /*10825*/ +0xaf07, /*10825*/ + +/*Blue Det..*/ +0xc558, /*BlueRange 2010.8.25 0x40->23 */ +0xc620, /*GreenRange 2010.8.25 0x3b->20 */ + +0xd088, /*2010.8.25*/ +0xd180, +0xd217,/*preview 17, full 67*/ +0xd300, +0xd400, +0xd50f,/*preview 0f, full 02*/ +0xd6ff, +0xd7ff,/*preview ff, full 18*/ +0xd800, +0xd904, + +/*interpolated with average*/ +0xdb38, /*resolution issue 0x00->0x18->0x38 */ +0xd904, /*strong_edge detect ratio*/ +0xe001, /*strong_edge detect ratio*/ + +0x0313, /*page 13 sharpness 1D*/ +0x10c5, +0x117b, +0x120e, +0x1400, + +0x1511, /*added option 1.3M*/ +0x1830, /*added option 1.3M*/ + +0x2015, +0x2113, +0x2233, +0x2308, /*hi_clip th1*/ +0x241a, /*hi_clip th2*/ +0x2506, /*low clip th*/ + +0x2618, +0x2730, +0x2910, /*time th*/ +0x2a30, /*pga th*/ + +0x2b03, /*lpf out2*/ +0x2c03, /*lpf out1*/ +0x2d0c, +0x2e12, +0x2f12, + +/*1D Edge*/ +0x500a, /*out2 hi nega*/ +0x5307, /* hi pos*/ +0x510c, /* mi nega*/ +0x5407, /* mi pos*/ +0x520b, /* lo nega*/ +0x5508, /* lo pos*/ + +0x560a, /*out1 hi nega*/ +0x5907, /* hi pos */ +0x570c, /* mi nega*/ +0x5a07, /* mi pos */ +0x580b, /* lo nega*/ +0x5b08, /* lo pos */ + +/*Indoor Edge*/ +0x5c08, /*indoor hi nega*/ +0x5f07, /* hi pos*/ +0x5d14, /* mid nega ,11*/ +0x6012, /* mid pos ,0*/ +0x5e0a, /* low nega */ +0x6108, /* low pos*/ + +0x6208, /*dark1 hi nega*/ +0x6506, /* hi pos */ +0x6308, /* mid nega */ +0x6606, /* mid pos */ +0x6408, /* low nega */ +0x6706, /* low pos */ + +0x6807, /*dark2 hi nega*/ +0x6b05, /* hi pos */ +0x6907, /* mid nega */ +0x6c05, /* mid pos */ +0x6a07, /* low nega */ +0x6d05, /* low pos */ + +0x6e0a, /*dark3 hi nega*/ +0x7109, /* hi pos */ +0x6f0a, /* mid nega */ +0x7209, /* mid pos */ +0x700a, /* low nega */ +0x7309, /* low pos */ + + /* 2DY*/ +0x80c1, +0x811f, +0x82e1, +0x8333, + +0x9005, +0x9105, +0x9233, +0x9330, +0x9403, +0x9514, +0x9730, +0x9930, + +0xa002, /*2d lclp out2 nega*/ +0xa103, /*2d lclp out2 pos*/ +0xa202, /*2d lclp out1 nega*/ +0xa303, /*2d lclp out1 pos*/ +0xa403, /*2d lclp in nega*/ +0xa504, /*2d lclp in pos*/ +0xa607, /*2d lclp dark1 nega*/ +0xa708, /*2d lclp dark1 pos*/ +0xa807, /*2d lclp dark2 nega*/ +0xa908, /*2d lclp dark2 pos*/ +0xaa07, /*2d lclp dark3 nega*/ +0xab08, /*2d lclp dark3 pos*/ + +0xb010, /*out2 H Ne*/ +0xb310, /* H Po*/ +0xb11e, /* M Ne*/ +0xb41e, /* M Po*/ +0xb21f, /* L Ne*/ +0xb51e, /* L Po*/ + +0xb610, /*out1 H Ne */ +0xb910, /* H Po */ +0xb71e, /* M Ne */ +0xba1e, /* M Po */ +0xb81f, /* L Ne */ +0xbb1e, /* L Po */ + +0xbc20, /*indoor H Ne*/ +0xbf1e, /* H Po*/ +0xbd25, /* M Ne*/ +0xc023, /* M Po*/ +0xbe24, /* L Ne*/ +0xc122, /* L Po*/ + +0xc223, /*dark1 H Ne*/ +0xc523, /* H Po*/ +0xc329, /* M Ne*/ +0xc629, /* M Po*/ +0xc425, /* L Ne*/ +0xc725, /* L Po*/ + +0xc81c, /*dark2 H Ne*/ +0xcb1c, /* H Po*/ +0xc925, /* M Ne*/ +0xcc25, /* M Po*/ +0xca23, /* L Ne*/ +0xcd23, /* L Po*/ + +0xce1c, /*dark3 H Ne*/ +0xd11c, /* H Po*/ +0xcf25, /* M Ne*/ +0xd225, /* M Po*/ +0xd023, /* L Ne*/ +0xd323, /* L Po*/ + +/* PAGE 14 START*/ +0x0314, +0x1031, + +0x1480, /* GX*/ +0x1580, /* GY*/ +0x1680, /* RX*/ +0x1780, /* RY*/ +0x1880, /* BX*/ +0x1980, /* BY*/ + +0x2060, /* X Center*/ +0x2180, /* Y Center*/ + +0x2280, +0x2380, +0x2480, + +0x30c8, +0x312b, +0x3200, +0x3300, +0x3490, + +0x4056, /*R min's set 4e*/ +0x413a, /*Gr*/ +0x4237, /*B*/ +0x433a, /*Gb*/ + +0x0315, +0x1021, +0x1444, /*49*/ +0x1534, /*38*/ +0x1626, /*2b*/ +0x172f, + +0x30dd, +0x3162, +0x3205, +0x3326, +0x34bd, +0x3517, +0x3618, +0x3738, +0x38d0, + +0x40b0, +0x4130, +0x4200, +0x4300, +0x4400, +0x4500, +0x4699, +0x4719, +0x4800, + +0x5016, +0x51b2, +0x521c, +0x5306, +0x5420, +0x55a6, +0x560e, +0x57b2, +0x5824, + +0x0316, +0x1031, /*GMA_CTL*/ +0x187e, /*AG_ON*/ +0x197d, /*AG_OFF*/ +0x1a0e, /*TIME_ON*/ +0x1b01, /*TIME_OFF*/ +0x1Cdc, /*OUT_ON*/ +0x1Dfe, /*OUT_OFF*/ + +/*GMA, Indoor*/ +0x3000, +0x3107, +0x321a, +0x3335, +0x345a, +0x357c, +0x3696, +0x37a9, +0x38b7, +0x39c6, +0x3ad2, +0x3bdc, +0x3ce4, +0x3deb, +0x3ef1, +0x3ff5, +0x40f9, +0x41fd, +0x42ff, + +/*RGMA, Outdoor*/ +0x5000, +0x5103, +0x5213, +0x532e, +0x5459, +0x5579, +0x5690, +0x57a3, +0x58b4, +0x59c2, +0x5acd, +0x5bd7, +0x5ce0, +0x5de5, +0x5ee9, +0x5fee, +0x60f1, +0x61f3, +0x62f6, + +/*BGMA Dark*/ +0x7000, +0x7107, +0x721a, +0x7335, +0x745a, +0x757c, +0x7696, +0x77a9, +0x78b7, +0x79c6, +0x7ad2, +0x7bdc, +0x7ce4, +0x7deb, +0x7ef1, +0x7ff5, +0x80f9, +0x81fd, +0x82ff, + +0x0324, /*Resol control */ +0x60c5, /*edge even frame | 16bit resol | white edge cnt | scene resol enable*/ +0x6104, /*even frame update */ +0x6408, /* 0x6435, edge th1 H*/ +0x6500, /*edge th1 L*/ +0x6626, /*edge th2 H */ +0x6700, /*edge th2 L */ + +0x0313, +0x1831, /*flat center Gb/Gr*/ +0x7402, /*det slope en | gausian filter*/ +0x750d, /*1D negative gain det 09 */ +0x760d, /*1D postive gain det 08*/ +0x7710, /*1D hclp2 det*/ +0x7808, /*outdoor flat threshold*/ +0x7910, /*indoor flat threshold*/ + +0x81df, /*det gain controler*/ +0x8690, /*2D negative gain det */ +0x8790, /*2D postive gain det */ +0x962a, /*2D hclp2 det*/ + +0x0312, /*0x12 page*/ +0xd088, +0xd9e4, + +/* PAGE 20 START*/ +0x0320, +0x111c, +0x1830, +0x1a08, +0x2045,/*weight*/ +0x2130, +0x2210, +0x2300, +0x2400, + +0x28e7, /* add 20120223*/ +0x290d, /* 20100305 ad -> 0d*/ +0x2afd, +0x2bf8, + +0x2cc3, +0x2d5f, /* add 20120223*/ +0x2e33, +0x30f8, +0x3203, +0x332e, +0x3430, +0x35d4, +0x36fe, +0x3732, +0x3804, +0x3922, +0x3ade, +0x3b22, +0x3cde, +0x3de1, + +0x5045, +0x5188, + +0x561a, +0x5780, +0x580e, +0x596a, +0x5a04, + +0x5e9d, /*AE_AWB_start*/ +0x5f76, /*AE_AWB_start*/ + +0x7040, /* 6c*/ +0x7182, /* 82(+8)*/ + +0x7621, +0x7791, +0x7822, /* 24*/ +0x792b, /* Y Target 70 => 25, 72 => 26*/ +0x7a23, /* 23*/ +0x7b22, /* 22*/ +0x7d23, + +0x8301, /*EXP Normal 33.33 fps */ +0x845f, +0x8590, + +0x8601, /*EXPMin 7500.00 fps*/ +0x8790, + +0x8803, /*EXP Max(120Hz) 12.00 fps*/ +0x89d0, +0x8a90, + +0xa504, /*EXP Max(100Hz) 11.11 fps*/ +0xa61e, +0xa7b0, + +0x8B75, /*EXP100 */ +0x8C30, +0x8D61, /*EXP120 */ +0x8Ea8, + +0x9104, /*EXP Fix 10.00 fps*/ +0x9293, +0x93e0, + +0x9c0a, /*EXP Limit 1071.43 fps*/ +0x9df0, +0x9e01, /*EXP Unit */ +0x9f90, +0x989d, + +0xb016, +0xb114, +0xb2f8, +0xb314, +0xb41b, +0xb546, +0xb631, +0xb729, +0xb826, +0xb924, +0xba22, +0xbb42, +0xbc41, +0xbd40, + +0xc010, +0xc138, +0xc238, +0xc338, +0xc407, + +0xc880, +0xc980, +0x109c, /* ae enable*/ +/* PAGE 20 END*/ + +/*AE_Weight*/ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2412, +0x2522, +0x2622, +0x2721, +0x2812, +0x2922, +0x2a22, +0x2b21, +0x2c12, +0x2d23, +0x2e32, +0x2f21, +0x3012, +0x3123, +0x3232, +0x3321, +0x3412, +0x3522, +0x3622, +0x3721, +0x3812, +0x3922, +0x3a22, +0x3b21, +0x3c11, +0x3d11, +0x3e11, +0x3f11, + +/* PAGE 22 START*/ +0x0322, +0x10fd, +0x112e, +0x1901, /* Low On*/ +0x2030, /* for wb speed*/ +0x2140, +0x2401, +0x257e, /* for tracking 20120314 */ + +0x3080, /* 20120224 test*/ +0x3180, +0x3811, +0x3934, + +0x40e8, +0x4143, /* 33*/ +0x4222, /* 22*/ + +0x43f3, /* f6*/ +0x4454, /* 44*/ +0x4522, /* 33*/ + +0x4600, +0x480a, +0x50b2, +0x5181, +0x5298, + +0x8038, +0x8120, +0x8238, /* 3a*/ + +0x8356, /* R Max*/ +0x8420, /* R Min*/ +0x8554, /* B Max*/ +0x8620, /* B Min*/ + +0x8746, +0x8836, +0x893a, +0x8a2f, + +0x8b3d, +0x8c37, +0x8d35, +0x8e32, + +0x8f5a, +0x9059, +0x9155, +0x924e, +0x9344, +0x943a, +0x9534, +0x962c, +0x9723, +0x9820, +0x991f, +0x9a1f, + +0x9b77, +0x9c77, +0x9d48, +0x9e38, +0x9f30, + +0xa040, +0xa121, +0xa26f, +0xa3ff, + +0xa414, /* 1500fps*/ +0xa544, /* 700fps*/ +0xa6cf, + +0xad40, +0xae4a, + +0xaf2a, /* low temp Rgain*/ +0xb028, /* low temp Rgain*/ + +0xb100, /* 0x20 -> 0x00 0405 modify*/ +0xb4bf, /* for tracking 20120314*/ +0xb8a1, /* a2: b-2, R+2 b4 B-3, R+4 lowtemp b0 a1 Spec AWB A modify*/ +0xb900, +/* PAGE 22 END*/ + +/* PAGE 48 (MiPi 1600x1200)*/ +0x0300, + +/* PLL Setting */ +0xd005, +0xd130, +0xd205, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +/* MIPI TX Setting */ +0x0348, +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +0x1d0e, +0x1e07, +0x1f08, +/*0x2000,*/ + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2a06,*/ +/*0x2b40,*/ +/*0x2c04,*/ +/*0x2db0,*/ + +0x3005, +0x3100, + +0x3207, +0x3309, +0x3401, +0x3501, +/*0x3601,*/ +/*0x3707,*/ +/*0x3802,*/ +/*0x3902,*/ + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_SmartStay_Init_Reg[] = { +/*0 Page*/ +0x0300, +0x0101, /*sleep*/ +0x0103, /*s/w reset*/ +0x0101, /*sleep*/ + +0x0800,/*Don't touch*/ +0x0937,/*Don't touch*/ +0x0a33,/*Don't touch*/ + +/*PLL Setting*/ +0xd005, +0xd130, +0xd201, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x1011, +0x1190, /*xy flip*/ +0x1200, +0x1488, + +0x0300, +0x2000, +0x2104, +0x2200, +0x2304, +0x2403, +0x25C0, +0x2605, +0x2700, + +0x4001, /*Hblank_280*/ +0x4118, +0x4201, /*Vblank 400*/ +0x4390, + +/*--------------- BLC*/ +0x8008, /*Don't touch */ +0x8197, /*Don't touch */ +0x8290, /*Don't touch */ +0x8330, /*Don't touch */ +0x84cc, /*Don't touch*/ +0x8500, /*Don't touch*/ +0x86d4, /*Don' t touch*/ +0x870f, /*Don't touch*/ +0x8834, /*Don't touch*/ + +0x900c, /*BLC_TIME_TH_ON*/ +0x910c, /*BLC_TIME_TH_OFF */ +0x92f7, /*BLC_AG_TH_ON*/ +0x93ef, /*BLC_AG_TH_OFF*/ + +0x9495, /*091202*/ +0x9590, /*091202 */ +0x9838, /*Don't touch*/ + +/*Dark BLC*/ +0xa000, /* 20100309*/ +0xa200, /* 20100309*/ +0xa400, /* 20100309*/ +0xa600, /* 20100309*/ + +/*Normal BLC*/ +0xa800, +0xaa00, +0xac00, +0xae00, + +/*Out BLC*/ +0x9900, +0x9a00, +0x9b00, +0x9c00, + +/*2 Page*/ +0x0302, +0x1200, /*Don't touch*/ +0x1400, /*Don't touch*/ +0x1500, /*Don't touch*/ +0x184C, /*Don't touch*/ +0x1900, /*Don't touch*/ +0x1A39, /*Don't touch*/ +0x1B00,/*Don't touch*/ +0x1C1a, /*Don't touch*/ +0x1D14, /*Don't touch*/ +0x1E30,/*Don't touch*/ +0x1F10,/*Don't touch*/ + +0x2077, +0x21de, +0x22a7, +0x2330, +0x2477, +0x2510, +0x2610, +0x273c, +0x2b80, +0x2c02, +0x2da0, +0x2e00, +0x2fa7, + +0x3000, +0x3199, +0x3200, +0x3300, +0x3422, +0x3601, +0x3701, +0x3888, +0x3988, +0x3d03, +0x3e0d, +0x3f02, + +0x49d1, +0x4a14, + +0x5021, +0x5201, +0x5381, +0x5410, +0x551c, +0x5611, +0x5818, +0x5916, +0x5da2, +0x5e5a, + +0x6093, /* 20120517 modify*/ +0x61a4, /* 20120517 modify*/ +0x6294, /* 20120517 modify*/ +0x63a3, /* 20120517 modify*/ +0x6494, /* 20120517 modify*/ +0x65a3, /* 20120517 modify*/ +0x670c, +0x680c, +0x690c, +0x6ab4, +0x6bc4, +0x6cb5, +0x6dc2, +0x6eb5, +0x6fc0, + +0x70b6, +0x71b8, +0x7295, /* 20120517 modify*/ +0x73a2, /* 20120517 modify*/ +0x7495, /* 20120517 modify*/ +0x75a2, /* 20120517 modify*/ +0x7695, /* 20120517 modify*/ +0x77a2, /* 20120517 modify*/ +0x7C92, /* 20120517 modify*/ +0x7Dff, /* 20120517 modify*/ + +0x8001, /* 20120517 modify*/ +0x818a, /* 20120517 modify*/ +0x821e, /* 20120517 modify*/ +0x8336, /* 20120517 modify*/ +0x8489, /* 20120517 modify*/ +0x858b, /* 20120517 modify*/ +0x8689, /* 20120517 modify*/ +0x878b, /* 20120517 modify*/ +0x88ab, +0x89bc, +0x8aac, +0x8bba, +0x8cad, +0x8db8, +0x8eae, +0x8fb2, + +0x90b3, +0x91b7, +0x9252, /* 20120517 modify*/ +0x936a, /* 20120517 modify*/ +0x9489, /* 20120517 modify*/ +0x958b, /* 20120517 modify*/ +0x9689, /* 20120517 modify*/ +0x978b, /* 20120517 modify*/ + +0xA002, +0xA186, /* 20120517 modify*/ +0xA202, +0xA386, /* 20120517 modify*/ +0xA486, /* 20120517 modify*/ +0xA502, +0xA686, /* 20120517 modify*/ +0xA702, +0xA892, /* 20120517 modify*/ +0xA994, /* 20120517 modify*/ +0xAA92, /* 20120517 modify*/ +0xAB94, /* 20120517 modify*/ +0xAC1c, +0xAD22, +0xAE1c, +0xAF22, + +0xB0a4, /* 20120517 modify*/ +0xB1ae, /* 20120517 modify*/ +0xB2a4, /* 20120517 modify*/ +0xB3ae, /* 20120517 modify*/ +0xB4a6, /* 20120517 modify*/ +0xB5ac, /* 20120517 modify*/ +0xB6a6, /* 20120517 modify*/ +0xB7ac, /* 20120517 modify*/ +0xB8a6, /* 20120517 modify*/ +0xB9ab, /* 20120517 modify*/ +0xBAa6, /* 20120517 modify*/ +0xBBab, /* 20120517 modify*/ +0xBCa6, /* 20120517 modify*/ +0xBDab, /* 20120517 modify*/ +0xBEa6, /* 20120517 modify*/ +0xBFab, /* 20120517 modify*/ + +0xc437, +0xc552, +0xc66b, +0xc786, +0xc838, /* 20120517 modify*/ +0xc950, /* 20120517 modify*/ +0xca38, /* 20120517 modify*/ +0xcb50, /* 20120517 modify*/ +0xcc6c, /* 20120517 modify*/ +0xcd84, /* 20120517 modify*/ +0xce6c, /* 20120517 modify*/ +0xcf84, /* 20120517 modify*/ + +/*0xd4a6,*/ +/*0xd5ac,*/ +/*0xd6a6,*/ +/*0xd7ac,*/ +/*add 20120517*/ +0xdc00, /* Added*/ +0xddaf, /* Added*/ +0xde00, /* Added*/ +0xdf90, /* Added*/ + +0xd010, +0xd114, +0xd220, +0xd300, +/*DCDC */ +0xd40c, /*DCDC_TIME_TH_ON*/ +0xd50c, /*DCDC_TIME_TH_OFF */ +0xd6f7, /*DCDC_AG_TH_ON*/ +0xd7ef, /*DCDC_AG_TH_OFF*/ + +0xea8a, + +0xF001, /* clock inversion*/ +0xF101, +0xF201, +0xF301, +0xF401, +0xF500, + +/*----------------------------------------------*/ +0x0310, /*page 10*/ +0x1001, /*Ycbcr422_bit Order: YUYV*/ +0x1103, +0x1230, /*y offset[4], dif_offset[5]*/ +0x1302, /*contrast effet enable : 0x02*/ +0x3400, /*hidden 10->00 100209*/ +0x3701, /*yc2d power save */ +0x3f04, /*100825*/ +0x4080, /*Y offset */ +0x4128, +0x4880, +0x5300, /*dif_offset option */ +0x5530, /*dif_offset option diff_offset max */ + +0x606b, /*out color sat en[7] | auto color decrement en[1] / + | manual color sat en[0]*/ + +0x6183, /*blue saturation_C0*/ +0x6280, /*red saturation_B0*/ + +0x63b0, /*auto decresment on AG th*/ +0x64ff, /*auto decresment on DG th*/ +0x66e4, /*Outdoor saturation step 137fps apply out th */ +0x6700, /*Outdoor saturation B/R*/ +0x7601, /* ADD 20121031 */ +0x7904, /* ADD 20121031 */ + +/* Hi 163 */ +/* PAGE 10 START*/ +0x0310, +0x8000, /* dsshin --> color enhance*/ +0xf500, /* dsshin --> h blank option*/ + +0x0311, /*page 11 D_LPF */ +0x103f, /*B[6]:Blue En Dlpf on[4:0] Sky over off : 0x7f->3f*/ +0x1120, /* Uniform Full GbGr/OV-Nr*/ + +0x1280, /*Blue MaxOpt blue sky max filter optoin rate : 0 0xc0->80*/ +0x13b8, /*dark2[7] | ratio[6:4] | dark3[3] | dark3 maxfilter ratio[2:0] */ + +0x30ba, /*Outdoor2 H th*/ +0x3110, /*Outdoor2 L th*/ +0x3250, /*Outdoor2 gain ratio*/ +0x331d, /*Outdoor2 H lum*/ +0x3420, /*Outdoor2 M lum*/ +0x351f, /*Outdoor2 L lum*/ + +0x36b0, /*Outdoor1 H th*/ +0x3718, /*Outdoor1 L th*/ +0x3850, /*Outdoor1 gain ratio 0x80->40*/ +0x391d, /*Outdoor1 H lum 0x28->1e*/ +0x3a20, /*Outdoor1 M lum 0x10->15*/ +0x3b1f, /*Outdoor1 L lum 0x08->20*/ + +0x3c3f, /*indoor H th*/ +0x3d16, /*indoor L th*/ +0x3e30, /*indoor gain ratio 0x44 6a */ +0x3f1a, /*indoor H lum 0x12 18 */ +0x4060, /*indoor M lum 0x18 1c*/ +0x411a, /*indoor L lum 0x18 3e*/ + +0x4280, /*dark1 H th*/ +0x4318, /*dark1 L th*/ +0x4480, /*dark1 gain ratio*/ +0x450f, /*dark1 H lum 0x38->0x28 */ +0x460c, /*dark1 M lum 0x27->0x17*/ +0x470b, /*dark1 L lum 0x20->0x1a */ + +0x4880, /*dark2 H th*/ +0x4918, /*dark2 L th*/ +0x4a80, /*dark2 gain ratio*/ +0x4b0f, /*dark2 H lum */ +0x4c0c, /*dark2 M lum*/ +0x4d0b, /*dark2 L lum */ + +0x4e80, /*dark3 H th*/ +0x4f23, /*dark3 L th*/ +0x5080, /*dark3 gain ratio*/ +0x511d, /*dark3 H lum */ +0x521f, /*dark3 M lum */ +0x531f, /*dark3 L lum */ + +0x5a3f, /*blue sky mode out1/2 enable 0x27->3f */ +0x5b00, /*Impulse pixel enable dark123,in,out123 :: must be 0x07*/ +0x5c9f, /*Indoor maxfilter rate[7:5] | Uncertain onoff[4:0] 0x1f ->0x9f*/ + +0x603f, /*GbGr all enable*/ +0x620f, /*GbGr offset*/ + +0x650c, /*Outdoor GbGr rate H 100% M 25% L 100%*/ +0x660c, /*Indoor GbGr rate H 100% M 25% L 100%*/ +0x6700, /*dark GbGr rate H/M/L 100%*/ + +0x700c, /* Abberation On/Off B[1]: Outdoor B[0]: Indoor 07>>c*/ +0x75a0, /* Outdoor2 Abberation Luminance lvl */ +0x7db4, /* Indoor Abberation Luminance lvl*/ + +0x9608, /*indoor/Dark1 edgeoffset1*/ +0x9714, /*indoor/Dark1 center G value*/ +0x98f5, /*slope indoor :: left/right graph polarity, slope*/ +0x992a, /*indoor uncertain ratio control*/ +0x9a20, /*Edgeoffset_dark*/ + +/*DPC_CTRL*/ +0x0312, /*Preview DPC off[0x5c] on[0x5d]*/ +0x200f, +0x210f, + +0x2500, /* 0x30*/ + +0x2a01, +0x2e00, /*2010.8.25*/ + +0x3035, /*Texture region(most detail)*/ +0x31a0, /*STD uniform1 most blur region*/ +0x32b0, /*STD uniform2 2nd blur*/ +0x33c0, /*STD uniform3 3rd blur*/ +0x34d0, /*STD normal noise1 4th blur */ +0x35e0, /*STD normal noise2 5th blur*/ +0x36ff, /*STD normal noise3 6th blur*/ + +0x4083, /*Outdoor2 H th*/ +0x4120, /*Outdoor2 L th */ +0x4208, /*Outdoor2 H luminance */ +0x4310, /*Outdoor2 M luminance */ +0x4410, /*Outdoor2 l luminance */ +0x4550, /*Outdoor2 ratio*/ + +0x4683, /*Outdoor1 H th*/ +0x4720, /*Outdoor1 L th */ +0x4808, /*Outdoor1 H luminance*/ +0x4910, /*Outdoor1 M luminance*/ +0x4a10, /*Outdoor1 L luminance*/ +0x4b50, /*Outdoor1 ratio*/ + +0x4c80, /*Indoor H th*/ +0x4d48, /*Indoor L th*/ +0x4e30, /*indoor H lum*/ +0x4f30, /*indoor M lum*/ +0x5012, /*indoor L lum */ +0x5170, /*indoor ratio 0x10 -> 0x45*/ + +0x52a8, /*dark1 H th*/ +0x5330, /*dark1 L th */ +0x5428, /*dark1 H lum */ +0x553e, /*dark1 M lum*/ +0x5667, /*dark1 L lum*/ +0x576a, /*dark1 ratio*/ + +0x58a0, /*dark2 H th*/ +0x5940, /*dark2 L th*/ +0x5a28, /*dark2 H lum*/ +0x5b3f, /*dark2 M lum*/ +0x5c68, /*dark2 L lum*/ +0x5d70, /*dark2 ratio*/ + +0x5ea0, /*dark3 H th*/ +0x5f1c, /*dark3 L th*/ +0x6029, /*dark3 H lum*/ +0x614a, /*dark3 M lum*/ +0x62ff, /*dark3 L lum*/ +0x63ff, /*dark3 ratio*/ + +/*C-filter(Out2&Out1)*/ +0x7010, +0x710a, + +/*C-filter(Indoor&Dark3)*/ +0x7210, +0x730a, + +/*C-filter(Dark2&Dark1)*/ +0x7418, +0x7512, + +0x8020, +0x8140, +0x8265, +0x851a, +0x8800, +0x8900, +0x905d, /*Preview DPC off[0x5c] on[0x5d]*/ + +/*DPC-Dark1,2,3*/ +0xad07, /*10825*/ +0xae07, /*10825*/ +0xaf07, /*10825*/ + +/*Blue Det..*/ +0xc558, /*BlueRange 2010.8.25 0x40->23 */ +0xc620, /*GreenRange 2010.8.25 0x3b->20 */ + +0xd088, /*2010.8.25*/ +0xd180, +0xd217,/*preview 17, full 67*/ +0xd300, +0xd400, +0xd50f,/*preview 0f, full 02*/ +0xd6ff, +0xd7ff,/*preview ff, full 18*/ +0xd800, +0xd904, + +/*interpolated with average*/ +0xdb38, /*resolution issue 0x00->0x18->0x38 */ +0xd904, /*strong_edge detect ratio*/ +0xe001, /*strong_edge detect ratio*/ + +0x0313, /*page 13 sharpness 1D*/ +0x10c5, +0x117b, +0x120e, +0x1400, + +0x1511, /*added option 1.3M*/ +0x1830, /*added option 1.3M*/ + +0x2015, +0x2113, +0x2233, +0x2308, /*hi_clip th1*/ +0x241a, /*hi_clip th2*/ +0x2506, /*low clip th*/ + +0x2618, +0x2730, +0x2910, /*time th*/ +0x2a30, /*pga th*/ + +0x2b03, /*lpf out2*/ +0x2c03, /*lpf out1*/ +0x2d0c, +0x2e12, +0x2f12, + +/*1D Edge*/ +0x500a, /*out2 hi nega*/ +0x5307, /* hi pos*/ +0x510c, /* mi nega*/ +0x5407, /* mi pos*/ +0x520b, /* lo nega*/ +0x5508, /* lo pos*/ + +0x560a, /*out1 hi nega*/ +0x5907, /* hi pos */ +0x570c, /* mi nega*/ +0x5a07, /* mi pos */ +0x580b, /* lo nega*/ +0x5b08, /* lo pos */ + +/*Indoor Edge*/ +0x5c08, /*indoor hi nega*/ +0x5f07, /* hi pos*/ +0x5d14, +0x6012, +0x5e0a, +0x6108, /* low pos*/ + +0x6208, /*dark1 hi nega*/ +0x6506, /* hi pos */ +0x6308, /* mid nega */ +0x6606, /* mid pos */ +0x6408, /* low nega */ +0x6706, /* low pos */ + +0x6807, /*dark2 hi nega*/ +0x6b05, /* hi pos */ +0x6907, /* mid nega */ +0x6c05, /* mid pos */ +0x6a07, /* low nega */ +0x6d05, /* low pos */ + +0x6e0a, /*dark3 hi nega*/ +0x7109, /* hi pos */ +0x6f0d, /* mid nega */ +0x720c, /* mid pos */ +0x700d, /* low nega */ +0x730c, /* low pos */ + + /* 2DY*/ +0x80c1, +0x811f, +0x82e1, +0x8333, + +0x9005, +0x9105, +0x9233, +0x9330, +0x9403, +0x9514, +0x9730, +0x9930, + +0xa002, /*2d lclp out2 nega*/ +0xa103, /*2d lclp out2 pos*/ +0xa202, /*2d lclp out1 nega*/ +0xa303, /*2d lclp out1 pos*/ +0xa403, /*2d lclp in nega*/ +0xa504, /*2d lclp in pos*/ +0xa607, /*2d lclp dark1 nega*/ +0xa708, /*2d lclp dark1 pos*/ +0xa807, /*2d lclp dark2 nega*/ +0xa908, /*2d lclp dark2 pos*/ +0xaa07, /*2d lclp dark3 nega*/ +0xab08, /*2d lclp dark3 pos*/ + +0xb010, /*out2 H Ne*/ +0xb310, /* H Po*/ +0xb11e, /* M Ne*/ +0xb41e, /* M Po*/ +0xb21f, /* L Ne*/ +0xb51e, /* L Po*/ + +0xb610, /*out1 H Ne */ +0xb910, /* H Po */ +0xb71e, /* M Ne */ +0xba1e, /* M Po */ +0xb81f, /* L Ne */ +0xbb1e, /* L Po */ + +0xbc20, /*indoor H Ne*/ +0xbf1e, /* H Po*/ +0xbd25, /* M Ne*/ +0xc023, /* M Po*/ +0xbe24, /* L Ne*/ +0xc122, /* L Po*/ + +0xc223, /*dark1 H Ne*/ +0xc523, /* H Po*/ +0xc329, /* M Ne*/ +0xc629, /* M Po*/ +0xc425, /* L Ne*/ +0xc725, /* L Po*/ + +0xc81c, /*dark2 H Ne*/ +0xcb1c, /* H Po*/ +0xc925, /* M Ne*/ +0xcc25, /* M Po*/ +0xca23, /* L Ne*/ +0xcd23, /* L Po*/ + +0xce1c, /*dark3 H Ne*/ +0xd11c, /* H Po*/ +0xcf29, /* M Ne*/ +0xd229, /* M Po*/ +0xd027, /* L Ne*/ +0xd327, /* L Po*/ + +/* PAGE 14 START*/ +0x0314, +0x1031, + +0x1480, /* GX*/ +0x1580, /* GY*/ +0x1680, /* RX*/ +0x1780, /* RY*/ +0x1880, /* BX*/ +0x1980, /* BY*/ + +0x2060, /* X Center*/ +0x2180, /* Y Center*/ + +0x2280, +0x2380, +0x2480, + +0x30c8, +0x312b, +0x3200, +0x3300, +0x3490, + +0x4056, /*R min's set 4e*/ +0x413a, /*Gr*/ +0x4237, /*B*/ +0x433a, /*Gb*/ + +0x0315, +0x1021, +0x1444, /*49*/ +0x1534, /*38*/ +0x1626, /*2b*/ +0x172f, + +0x30dd, +0x3162, +0x3205, +0x3326, +0x34bd, +0x3517, +0x3618, +0x3738, +0x38d0, + +0x40b0, +0x4130, +0x4200, +0x4300, +0x4400, +0x4500, +0x4699, +0x4719, +0x4800, + +0x5016, +0x51b2, +0x521c, +0x5306, +0x5420, +0x55a6, +0x560e, +0x57b2, +0x5824, + +0x0316, +0x1031, /*GMA_CTL*/ +0x187e, /*AG_ON*/ +0x197d, /*AG_OFF*/ +0x1a0e, /*TIME_ON*/ +0x1b01, /*TIME_OFF*/ +0x1Cdc, /*OUT_ON*/ +0x1Dfe, /*OUT_OFF*/ + +/*GMA Indoor*/ +0x3000, +0x3126, +0x3238, +0x3355, +0x347e, +0x3597, +0x36a9, +0x37ba, +0x38c7, +0x39d2, +0x3adb, +0x3be3, +0x3cea, +0x3dee, +0x3ef5, +0x3ff9, +0x40fc, +0x41fe, +0x42ff, + +/*RGMA Outdoor*/ +0x5000, +0x5126, +0x5238, +0x5355, +0x547e, +0x5597, +0x56a9, +0x57ba, +0x58c7, +0x59d2, +0x5adb, +0x5be3, +0x5cea, +0x5dee, +0x5ef5, +0x5ff9, +0x60fc, +0x61fe, +0x62ff, + +/*BGMA Dark*/ +0x7002, +0x712a, +0x723b, +0x7359, +0x7481, +0x759b, +0x76ac, +0x77be, +0x78ca, +0x79d4, +0x7adb, +0x7be4, +0x7ceb, +0x7def, +0x7ef6, +0x7ffa, +0x80fc, +0x81fe, +0x82ff, + +0x0324, /*Resol control */ +0x60c5, /*edge even frame | 16bit resol | white edge cnt | scene resol enable*/ +0x6104, /*even frame update */ +0x6408, +0x6500, +0x6626, /*edge th2 H */ +0x6700, /*edge th2 L */ + +0x0313, +0x1831, /*flat center Gb/Gr*/ +0x7402, /*det slope en | gausian filter*/ +0x750d, /*1D negative gain det 09 */ +0x760d, /*1D postive gain det 08*/ +0x7710, /*1D hclp2 det*/ +0x7808, /*outdoor flat threshold*/ +0x7910, /*indoor flat threshold*/ + +0x81df, /*det gain controler*/ +0x8690, /*2D negative gain det */ +0x8790, /*2D postive gain det */ +0x962a, /*2D hclp2 det*/ + +0x0312, /*0x12 page*/ +0xd088, +0xd9e4, + +/* PAGE 18 START*/ +0x0318, +0x1400, + +/* PAGE 20 START*/ +0x0320, +0x111c, +0x1830, +0x1a08, +0x2045,/*weight*/ +0x2130, +0x2210, +0x2300, +0x2400, + +0x28e7, /* add 20120223*/ +0x290d, /* 20100305 ad -> 0d*/ +0x2afd, +0x2bf8, + +0x2cc3, +0x2d5f, /* add 20120223*/ +0x2e33, +0x30f8, +0x3203, +0x332e, +0x3430, +0x35d4, +0x36ff, /*fe*/ +0x3732, +0x3804, +0x3922, +0x3ade, +0x3b22, +0x3cde, +0x3de1, + +0x5045, +0x5188, + +0x561a, +0x5780, +0x580e, +0x596a, +0x5a04, + +0x5e9d, /*AE_AWB_start*/ +0x5f76, /*AE_AWB_start*/ + +0x703f, /* 6c*/ +0x7180, /* 82(+8)*/ + +0x7621, +0x7781, +0x7822, /* 24*/ +0x7925, /* Y Target 70 => 25, 72 => 26*/ +0x7a23, /* 23*/ +0x7b22, /* 22*/ +0x7d23, + +0x8301, /*EXP Normal 30.00 fps */ +0x845f, +0x8590, +0x8601, /*EXPMin 7500.00 fps*/ +0x8790, +0x8805, /*EXP Max(120Hz) 8.00 fps */ +0x89b8, +0x8ad8, +0xa505, /*EXP Max(100Hz) 8.33 fps */ +0xa67e, +0xa740, +0x8B75, /*EXP100 */ +0x8C30, +0x8D61, /*EXP120 */ +0x8Ea8, +0x9c09, /*EXP Limit 1250.00 fps */ +0x9d60, +0x9e01, /*EXP Unit */ +0x9f90, +0x989d, + +0xb016, +0xb114, +0xb2f0, +0xb314, +0xb41b, +0xb546, +0xb631, +0xb729, +0xb826, +0xb924, +0xba22, +0xbb42, +0xbc41, +0xbd40, + +0xc010, +0xc138, +0xc238, +0xc338, +0xc407, + +0xc880, +0xc980, +0x109c, /* ae enable*/ +/* PAGE 20 END*/ + +/*AE_Weight*/ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2422, +0x2522, +0x2622, +0x2721, +0x2823, +0x2933, +0x2a32, +0x2b21, +0x2c23, +0x2d44, +0x2e32, +0x2f21, +0x3023, +0x3144, +0x3232, +0x3311, +0x3423, +0x3533, +0x3632, +0x3721, +0x3822, +0x3922, +0x3a22, +0x3b21, +0x3c11, +0x3d11, +0x3e11, +0x3f11, + +/* PAGE 22 START*/ +0x0322, +0x10fd, +0x112e, +0x1901, /* Low On*/ +0x2030, /* for wb speed*/ +0x2140, +0x2401, +0x257e, /* for tracking 20120314 */ + +0x3080, /* 20120224 test*/ +0x3180, +0x3811, +0x3934, + +0x40e8, +0x4143, /* 33*/ +0x4222, /* 22*/ + +0x43f3, /* f6*/ +0x4454, /* 44*/ +0x4522, /* 33*/ + +0x4600, +0x480a, +0x50b2, +0x5181, +0x5298, + +0x8038, +0x8120, +0x8238, /* 3a*/ + +0x8356, /* R Max*/ +0x8420, /* R Min*/ +0x8552, /* B Max*/ +0x8620, /* B Min*/ + +0x8746, +0x8836, +0x8939, +0x8a2d, + +0x8b3c, +0x8c36, +0x8d34, +0x8e31, + +0x8f5a, +0x9059, +0x9154, +0x924d, +0x9342, +0x943a, +0x9534, +0x962c, +0x9723, +0x9820, +0x991f, +0x9a1f, + +0x9b77, +0x9c77, +0x9d48, +0x9e38, +0x9f30, + +0xa040, +0xa122, +0xa26f, +0xa3ff, + +0xa414, /* 1500fps*/ +0xa544, /* 700fps*/ +0xa6cf, + +0xad40, +0xae4a, + +0xaf2a, /* low temp Rgain*/ +0xb028, /* low temp Rgain*/ + +0xb100, /* 0x20 -> 0x00 0405 modify*/ +0xb4bf, /* for tracking 20120314*/ +0xb8a1, /* a2: b-2, R+2 b4 B-3, R+4 lowtemp b0 a1 Spec AWB A modify*/ +0xb900, +/* PAGE 22 END*/ + +/* PAGE 48 (MiPi 1600x1200)*/ +0x0300, + +/* PLL Setting */ +0xd005, +0xd130, +0xd205, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x0348, +/* MIPI TX Setting */ +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +0x1d0e, +0x1e07, +0x1f08, + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2b40,*/ + +0x3005, +0x3100, + +0x3207, +0x3309, +0x3401, +0x3501, + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_stop_stream[] = { +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t SR130PC20_Preview_Mode[] = +{ +0x0300, +0x0101,/*sleep*/ + +0xd005,/*Pll Off*/ + +0x0320, +0x101c,/*AE off (0x0c:60Hz 0x1c:50Hz)*/ +0x0322, +0x107d,/*AWB off*/ + +0x0300, +0x1011, +/* 0x1190, *//*0x91 : mirror mode*/ + +/* page 11 yc_lpf */ +0x0311, +0x5b00,/*don't touch*/ + +/* PAGE 12 YC_LPF */ +0x0312, +0x200f, +0x210f, + +/*preview DPC*/ +0xd217, +0xd50f, +0xd7ff, + + +/* PAGE13 Sharpness 1D/2D */ +0x0313, +0x10c4, +0x80c0, + +/* PAGE 18 START*/ +0x0318, +0x1443, /*83*/ + +0x0320, +0x109c, /*AE ON (0x8c:60Hz 0x9c:50Hz)*/ +0x0322, +0x10fd, /*AWB ON*/ + +0x0300, /*Page 0 PLL on*/ +0xd005, +0xd130, +0xd205, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +/* MIPI TX Setting */ +0x0348, +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +/*0x1d09,*/ +0x1d0e, +0x1e07, +0x1f08, +/*0x2000,*/ + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2a06,*/ +/*0x2b40,*/ +/*0x2c04,*/ +/*0x2db0,*/ + +0x3005, +0x3100, + +0x3207, +0x3309, +0x3401, +0x3501, +/*0x3601,*/ +/*0x3707,*/ +/*0x3802,*/ +/*0x3902,*/ + +0x0300, +0x0100, + +}; + +static const sr130pc20_regset_t SR130PC20_Capture_Mode[] = +{ +0x0300, +0x0101,/*sleep*/ + +0xd005,/*Pll off*/ + +0x0322, +0x107d,/*AWB off*/ + +0x0300, +0x1000, +/* 0x1190, */ + +0x0302, +0x2faa, + +0x0311, +0x5b00,/*don't touch*/ + +0x0312, +0x200f, +0x210f, + +/*preview DPC*/ +0xd267, +0xd502, +0xd718, + +0x0313, +0x10c5, +0x80c1,/*Sharpness 2D On[0xc1] Off[0xc0]*/ + +/* PAGE 18 START*/ +0x0318, +0x1400, + +0x0300, +0xd005,/*pll on*/ +0xd130, +0xd201, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x0348, +/* MIPI TX Setting */ +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +0x1d0d, /* 0c:90ns , 0b:110ns */ +0x1e0f, +0x1f0a, +/*0x2000,*/ + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2a06,*/ +/*0x2b40,*/ +/*0x2c04,*/ +/*0x2db0,*/ + +0x300a, +0x3100, + +0x320d, +0x330b, +0x3402, +0x3504, +0x3601, +0x3709, +/*0x3802,*/ +/*0x3902,*/ + +0x0300, +0x0100,/*sleep off*/ + +}; + +static const sr130pc20_regset_t SR130PC20_Lowlux_Night_Capture_Mode[] = +{ +0x0300, +0x0101,/*sleep*/ + +0xd005,/*Pll off*/ + +0x0322, +0x107d,/*AWB off*/ + +0x0300, +0x1000, +/* 0x1190, */ + +0x0302, +0x2faa, + +0x0311, +0x5b00,/*don't touch*/ + +0x0312, +0x200f, +0x210f, + +/*preview DPC*/ +0xd267, +0xd502, +0xd718, + +0x0313, +0x10c5, +0x80c1,/*Sharpness 2D On[0xc1] Off[0xc0]*/ + +/* PAGE 18 START*/ +0x0318, +0x1400, + +0x0300, +0xd005,/*pll on*/ +0xd130, +0xd201, +0xd320, +0xd085, +0xd085, +0xd085, +0xd095, + +0x0348, +/* MIPI TX Setting */ +0x101c, +0x1100, +0x1200, +0x1400, +0x1604, +0x1700, +0x1880, +0x1900, +0x1aa0, +/*0x1b0d,*/ +0x1c02, +0x1d0d, /* 0c:90ns , 0b:110ns */ +0x1e0f, +0x1f0a, +/*0x2000,*/ + +0x2200, +0x2301, +0x241e, +0x2500, +0x2600, +0x2708, +0x2800, +/*0x2a06,*/ +/*0x2b40,*/ +/*0x2c04,*/ +/*0x2db0,*/ + +0x300a, +0x3100, + +0x320d, +0x330b, +0x3402, +0x3504, +0x3601, +0x3709, +/*0x3802,*/ +/*0x3902,*/ + +0x0300, +0x0100,/*sleep off*/ + +0xff03, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Sketch[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Pastel[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Black_White[] = +{ +0x0310, +0x1103, +0x1233, +0x1302, +0x4080, +0x4480, +0x4580, +}; + +static const sr130pc20_regset_t SR130PC20_Effect_Negative[] = +{ +0x0310, +0x1103, +0x1238, +0x1302, +0x4080, +0x4480, +0x4580, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Solar[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Normal[] = +{ +0x0310, +0x1103, +0x1230, +0x1302, +0x4080, +0x4480, +0x4580, +}; + +static const sr130pc20_regset_t sr130pc20_Effect_Sepia[] = +{ +0x0310, +0x1103, +0x1233, +0x1302, +0x4080, +0x4470, +0x4598, +}; + +static const sr130pc20_regset_t sr130pc20_Metering_Center[] = +{ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2412, +0x2522, +0x2622, +0x2721, +0x2812, +0x2922, +0x2a22, +0x2b21, +0x2c12, +0x2d23, +0x2e32, +0x2f21, +0x3012, +0x3123, +0x3232, +0x3321, +0x3412, +0x3522, +0x3622, +0x3721, +0x3812, +0x3922, +0x3a22, +0x3b21, +0x3c11, +0x3d11, +0x3e11, +0x3f11, +}; + +static const sr130pc20_regset_t sr130pc20_Metering_Matrix[] = +{ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2411, +0x2511, +0x2611, +0x2711, +0x2811, +0x2911, +0x2a11, +0x2b11, +0x2c11, +0x2d11, +0x2e11, +0x2f11, +0x3011, +0x3111, +0x3211, +0x3311, +0x3411, +0x3511, +0x3611, +0x3711, +0x3811, +0x3911, +0x3a11, +0x3b11, +0x3c11, +0x3d11, +0x3e11, +0x3f11, +}; + +static const sr130pc20_regset_t sr130pc20_Metering_Spot[] = +{ +0x0321, +0x2011, +0x2111, +0x2211, +0x2311, +0x2411, +0x2511, +0x2611, +0x2711, +0x2811, +0x2911, +0x2a11, +0x2b11, +0x2c11, +0x2d13, +0x2e31, +0x2f11, +0x3011, +0x3113, +0x3231, +0x3311, +0x3411, +0x3511, +0x3611, +0x3711, +0x3811, +0x3911, +0x3a11, +0x3b11, +0x3c11, +0x3d11, +0x3e11, +0x3f11, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_Default[] = +{ +0x0310, +0x4080, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_M1Step[] = +{ +0x0310, +0x4090, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_M2Step[] = +{ +0x0310, +0x40A0, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_M3Step[] = +{ +0x0310, +0x40B0, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_M4Step[] = +{ +0x0310, +0x40d0, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_P1Step[] = +{ +0x0310, +0x4010, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_P2Step[] = +{ +0x0310, +0x4020, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_P3Step[] = +{ +0x0310, +0x4030, +}; + +static const sr130pc20_regset_t SR130PC20_ExpSetting_P4Step[] = +{ +0x0310, +0x4050, +}; + +static const sr130pc20_regset_t sr130pc20_ISO_50[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_ISO_100[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_ISO_200[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_ISO_400[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_ISO_Auto[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Default[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Landscape[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Sports[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Party_Indoor[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Beach_Snow[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Sunset[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Duskdawn[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Candle_Light[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Fall_Color[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Portrait[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Nightshot[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Fireworks[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Text[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Scene_Backlight[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_Sharpness_Default[] = +{ +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_WB_Auto[] = +{ +0x0322, +0x106b, +0x112e, +0x8038, +0x8120, +0x8238, +0x8356, +0x8420, +0x8552, +0x8620, +0x10eb, +}; + +static const sr130pc20_regset_t sr130pc20_WB_Cloudy[] = +{ +0x0322, +0x106b, +0x112c, +0x8050, +0x8120, +0x8228, +0x8352, +0x844c, +0x852c, +0x8622, +0x10eb, +}; + +static const sr130pc20_regset_t sr130pc20_WB_Sunny[] = +{ +0x0322, +0x106b, +0x112c, +0x8038, +0x8120, +0x8235, +0x833b, +0x8434, +0x8538, +0x8631, +0x10eb, +}; + +static const sr130pc20_regset_t sr130pc20_WB_Fluorescent[] = +{ +0x0322, +0x106b, +0x112c, +0x8037, +0x8120, +0x8248, +0x8339, +0x8434, +0x854a, +0x8645, +0x10eb, +}; + +static const sr130pc20_regset_t sr130pc20_WB_Tungsten[] = +{ +0x0322, +0x106b, +0x112c, +0x8021, +0x8120, +0x824f, +0x8327, +0x841b, +0x8559, +0x8650, +0x10eb, +}; + +static const sr130pc20_regset_t sr130pc20_640_480_Preview[] = { +0x0300, +0x0101, + +0x0300, +0x1011, + +0x0318, +0x1000, + +0x0348, +0x3005, +0x3100, + +0x0300, +0x0100, + +0xff0a, +}; + +static const sr130pc20_regset_t sr130pc20_352_288_Preview[] = { +0x0300, +0x0101, +0x0300, +0x1011, + +0x0318, +0x1007, +0x1200, +0x2003, +0x2100, +0x2201, +0x2320, +0x2400, +0x2520, +0x2600, +0x2700, +0x2802, +0x29e0, +0x2a01, +0x2b20, +0x2c0d, +0x2d55, +0x2e0d, +0x2f55, +0x3051, + +0x0348, +0x3002, +0x31c0, + +0x0300, +0x0100, + +0xff28, +}; + +static const sr130pc20_regset_t sr130pc20_320_240_Preview[] = { +0x0300, +0x0101, + +0x0300, +0x1023, + +0x0318, +0x1000, + +0x0348, +0x3002, +0x3180, + +0x0300, +0x0100, + +0xff28, +}; + +static const sr130pc20_regset_t sr130pc20_176_144_Preview[] = { +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_1280_960_Capture[] = { +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_960_720_Capture[] = { +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_VGA_Capture[] = { +0xff00 +}; + +static const sr130pc20_regset_t sr130pc20_fps_auto[] = { +0xff00, +}; + +static const sr130pc20_regset_t sr130pc20_fps_7fix[] = { +0x0300, +0x0101, + +0x1190, + +0x4200, +0x4314, + +0x0320, +0x101C, + +0x0322, +0x107d, + +0x0320, +0x2af3, +0x2bf5, + +0x8301, /*EXP Normal 33.33 fps */ +0x845f, +0x8590, + +0x8806, /*EXP Max(120Hz) 7.50 fps */ +0x8968, +0x8aa0, + +0xa506, /*EXP Max(100Hz) 7.14 fps */ +0xa668, +0xa7a0, + +0x9106, /*EXP Fix 7.00 fps*/ +0x9289, +0x9370, + +0x0320, +0x109C, + +0x0322, +0x10fd, + +0x0300, +0x1194, + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_fps_15fix[] = { +0x0300, +0x0101, + +0x1190, + +0x4200, +0x4314, + +0x0320, +0x101C, + +0x0322, +0x107d, + +0x0310, /*page 10*/ +0x6007, +0x6380, /*auto decresment on AG th*/ + +0x0316, +0x7007, +0x711a, +0x722d, +0x7346, +0x746a, +0x7586, +0x769c, +0x77ad, +0x78bc, +0x79c9, +0x7ad4, +0x7bde, +0x7ce4, +0x7deb, +0x7ef1, +0x7ff5, +0x80f9, +0x81fd, +0x82ff, + +0x0322, +0x8f5d, +0x905a, +0x9156, +0x9250, +0x9348, +0x943f, + +0x0320, +0x2afd, +0x2bf8, + +0x8301, /*EXP Normal 33.33 fps */ +0x845f, +0x8590, + +0x8802, /*EXP Max(120Hz) 17.14 fps */ +0x89bf, +0x8a20, + +0xa502, /*EXP Max(100Hz) 16.67 fps */ +0xa6bf, +0xa720, + +0x9103, /*EXP Fix 15.00 fps*/ +0x920d, +0x9340, + +0x0320, +0x109C, + +0x0322, +0x10fd, + +0x0300, +0x1194, + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_fps_25fix[] = { +0x0300, +0x0101, + +0x1190, + +0x4200, +0x4362, + +0x0320, +0x101C, + +0x0322, +0x107d, + +0x0310, /*page 10*/ + +0x410a, +0x6007, +0x6380, /*auto decresment on AG th*/ + +0x0316, +0x7007, +0x711a, +0x722d, +0x7346, +0x746a, +0x7586, +0x769c, +0x77ad, +0x78bc, +0x79c9, +0x7ad4, +0x7bde, +0x7ce4, +0x7deb, +0x7ef1, +0x7ff5, +0x80f9, +0x81fd, +0x82ff, + +0x0322, +0x8f5d, +0x905a, +0x9156, +0x9250, +0x9348, +0x943f, + +0x0320, +0x2afd, +0x2bf8, + +0x8301, /*EXP Normal 33.33 fps */ +0x845d, +0x8538, + +0x8801, /*EXP Max(120Hz) 40.00 fps */ +0x895f, +0x8a90, + +0xa501, /*EXP Max(100Hz) 25.xx fps */ +0xa6d1, +0xa7a0, + +0x8b74, /*EXP100 */ +0x8c68, +0x8d60, /*EXP120 */ +0x8ee0, + +0x9101, /*EXP Fix 25.00 fps*/ +0x92d4, +0x93c0, + +0x0320, +0x109C, + +0x0322, +0x10fd, + +0x0300, +0x1194, + +0x0300, +0x0101, +}; + +static const sr130pc20_regset_t sr130pc20_fps_30fix[] = +{ +/* sensor limitation, use 25fps */ +0xff00, +}; + +#endif /* __SR130PC20_REGS_H__ */ diff --git a/drivers/misc/max77693-muic.c b/drivers/misc/max77693-muic.c index 9a78d76..082777d 100644 --- a/drivers/misc/max77693-muic.c +++ b/drivers/misc/max77693-muic.c @@ -473,7 +473,7 @@ static ssize_t max77693_muic_show_manualsw(struct device *dev, struct max77693_muic_info *info = dev_get_drvdata(dev); #if !defined(CONFIG_MACH_T0) && !defined(CONFIG_MACH_M3) \ - && !defined(CONFIG_MACH_SLP_T0_LTE) + && !defined(CONFIG_MACH_SLP_T0_LTE) && !defined(CONFIG_MACH_KONA) dev_info(info->dev, "func:%s ap(0),cp(1),vps(2)sw_path:%d(%d)\n", __func__, info->muic_data->sw_path, gpio_get_value(GPIO_USB_SEL));/*For debuging*/ @@ -716,7 +716,7 @@ static ssize_t max77693_muic_set_uart_sel(struct device *dev, if (info->max77693->pmic_rev < MAX77693_REV_PASS2) { #if !defined(CONFIG_MACH_T0) && !defined(CONFIG_MACH_M3) \ - && !defined(CONFIG_MACH_SLP_T0_LTE) + && !defined(CONFIG_MACH_SLP_T0_LTE) && !defined(CONFIG_MACH_KONA) if (!strncasecmp(buf, "AP", 2)) { info->muic_data->uart_path = UART_PATH_AP; if (gpio_is_valid(GPIO_UART_SEL)) { @@ -845,7 +845,7 @@ static ssize_t max77693_muic_show_uart_sel(struct device *dev, struct max77693_muic_info *info = dev_get_drvdata(dev); if (info->max77693->pmic_rev < MAX77693_REV_PASS2) { #if !defined(CONFIG_MACH_T0) && !defined(CONFIG_MACH_M3) \ - && !defined(CONFIG_MACH_SLP_T0_LTE) + && !defined(CONFIG_MACH_SLP_T0_LTE) && !defined(CONFIG_MACH_KONA) switch (info->muic_data->uart_path) { case UART_PATH_AP: if (gpio_get_value(GPIO_UART_SEL) == GPIO_LEVEL_HIGH) @@ -3112,7 +3112,7 @@ static int uart_switch_init(struct max77693_muic_info *info) int ret, val; #if !defined(CONFIG_MACH_T0) && !defined(CONFIG_MACH_M3) \ - && !defined(CONFIG_MACH_SLP_T0_LTE) + && !defined(CONFIG_MACH_SLP_T0_LTE) && !defined(CONFIG_MACH_KONA) if (info->max77693->pmic_rev < MAX77693_REV_PASS2) { ret = gpio_request(GPIO_UART_SEL, "UART_SEL"); if (ret < 0) { diff --git a/drivers/net/wireless/bcmdhd/dhd_sec_feature.h b/drivers/net/wireless/bcmdhd/dhd_sec_feature.h index 933a78a..98a41a0 100755 --- a/drivers/net/wireless/bcmdhd/dhd_sec_feature.h +++ b/drivers/net/wireless/bcmdhd/dhd_sec_feature.h @@ -49,7 +49,8 @@ #define READ_MACADDR #endif /* CONFIG_ARCH_MSM7X30 */ -#if defined(CONFIG_MACH_GC1) || defined(CONFIG_MACH_U1_NA_SPR) || defined(CONFIG_MACH_V1) +#if defined(CONFIG_MACH_GC1) || defined(CONFIG_MACH_U1_NA_SPR) || defined(CONFIG_MACH_V1)\ + || defined(CONFIG_MACH_KONA) #undef USE_CID_CHECK #define READ_MACADDR #endif /* CONFIG_MACH_GC1 || CONFIG_MACH_U1_NA_SPR || CONFIG_MACH_V1 */ diff --git a/drivers/power/sec_battery_px.c b/drivers/power/sec_battery_px.c index 0a31772..f039c17 100644 --- a/drivers/power/sec_battery_px.c +++ b/drivers/power/sec_battery_px.c @@ -60,7 +60,7 @@ enum { #define P2_CHARGING_FEATURE_02 /* SMB136 + MAX17042, Cable detect by TA_nCon */ #endif -#if defined(CONFIG_MACH_P4NOTE) +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) #define P4_CHARGING_FEATURE_01 /* SMB347 + MAX17042, use TA_nCON */ #endif diff --git a/drivers/sensor/Kconfig b/drivers/sensor/Kconfig index f7888b9..36464eb 100644 --- a/drivers/sensor/Kconfig +++ b/drivers/sensor/Kconfig @@ -112,6 +112,17 @@ config SENSORS_AL3201 Say N here if you do not use AL3201. +config SENSORS_K2DH + tristate "K2DH acceleration sensor support" + depends on I2C + default n + help + Say Y here if you use K2DH. + This option enables accelerometer sensors using + STM K2DH in K2DH device driver. + + Say N here if you do not use K2DH. + config SENSORS_K3DH tristate "K3DH acceleration sensor support" depends on I2C @@ -119,6 +130,17 @@ config SENSORS_K3DH help Driver for STMicroelectronic K3DH accelerometer. +config SENSOR_K3DH_INPUTDEV + bool "K3DH acceleration sensor input dev support" + depends on SENSORS_K3DH + default n + help + Say Y here if you use K3DH. + This option enables accelerometer sensor using + K3DH device driver. + + Say N here if you do not use K3DH. + config SENSORS_K3G tristate "K3G driver for s5pc210" depends on I2C @@ -139,4 +161,36 @@ config SENSORS_LPS331 depends on I2C help Driver for STMicro LPS331 + +config SENSORS_YAS532 + depends on I2C + tristate "yas532 Sensor Support" + default n + help + Say Y to enable YAS532 Magnetic Sensor support. + This allows control of supported Magnetic Sensor. + +config SENSORS_YAS_ORI + depends on I2C + tristate "yas orientation Sensor Support" + default n + help + Say Y to enable YAS532 Magnetic Sensor support. + This allows control of supported Magnetic Sensor. + +config INPUT_YAS_MAGNETOMETER_POSITION + int "YAS Geomagnetic Sensor Mounting Position on Board" + depends on I2C + default "0" + help + Chip mounting position (pin 1). + 0: top, upper-left + 1: top, upper-right + 2: top, lower-right + 3: top, lower-left + 4: bottom, upper-left + 5: bottom, upper-right + 6: bottom, lower-right + 7: bottom, lower-left + endif diff --git a/drivers/sensor/Makefile b/drivers/sensor/Makefile index 44adf31..195f0f9 100644 --- a/drivers/sensor/Makefile +++ b/drivers/sensor/Makefile @@ -6,7 +6,11 @@ obj-$(CONFIG_SENSORS_CORE) += sensors_core.o # accelerometer_sensor +ifeq ($(CONFIG_MACH_KONA_SENSOR),y) +obj-$(CONFIG_SENSORS_K3DH) += k3dh_kona.o +else obj-$(CONFIG_SENSORS_K3DH) += k3dh.o +endif obj-$(CONFIG_SENSORS_BMA254) += bma254_driver.o # gyro_sensor obj-$(CONFIG_SENSORS_K3G) += k3g.o @@ -15,6 +19,8 @@ obj-$(CONFIG_SENSORS_LSM330DLC) += lsm330dlc_accel.o lsm330dlc_gyro.o # magnetic_sensor obj-$(CONFIG_SENSORS_AK8975C) += ak8975.o obj-$(CONFIG_SENSORS_AK8963C) += ak8963.o +obj-$(CONFIG_SENSORS_YAS532) += yas_mag_kernel_driver.o +obj-$(CONFIG_SENSORS_YAS_ORI) += yas_ori_kernel_driver.o # optical_sensor obj-$(CONFIG_SENSORS_CM3663) += cm3663.o obj-$(CONFIG_SENSORS_TAOS) += taos.o diff --git a/drivers/sensor/al3201.c b/drivers/sensor/al3201.c index a225b1a..df21515 100644 --- a/drivers/sensor/al3201.c +++ b/drivers/sensor/al3201.c @@ -304,10 +304,35 @@ static ssize_t get_chip_name(struct device *dev, { return sprintf(buf, "%s\n", CHIP_NAME); } +#if defined(CONFIG_MACH_KONA) +static ssize_t al3201_lux_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + int result; + struct input_dev *input = to_input_dev(dev); + struct al3201_data *data = input_get_drvdata(input); + + /* No LUX data if not operational */ + if (data->state == OFF) { + al3201_set_power_state(data->client, ON); + msleep(180); + } + + result = al3201_get_adc_value(data->client); + + if (data->state == OFF) + al3201_set_power_state(data->client, OFF); + + return sprintf(buf, "%d\n", result); +} +#endif static DEVICE_ATTR(raw_data, 0644, al3201_raw_data_show, NULL); static DEVICE_ATTR(vendor, 0644, get_vendor_name, NULL); static DEVICE_ATTR(name, 0644, get_chip_name, NULL); +#if defined(CONFIG_MACH_KONA) +static DEVICE_ATTR(lux, 0644, al3201_lux_show, NULL); +#endif /* factory test*/ #ifdef LSC_DBG @@ -582,26 +607,38 @@ static int __devinit al3201_probe(struct i2c_client *client, dev_attr_name.attr.name); goto err_light_device_create_file3; } + +#if defined(CONFIG_MACH_KONA) + if (device_create_file(data->light_dev, &dev_attr_lux) < 0) { + pr_err("%s: could not create device file(%s)!\n", __func__, + dev_attr_lux.attr.name); + goto err_light_device_create_file4; + } +#endif dev_set_drvdata(data->light_dev, data); pr_info("%s: success!\n", __func__); goto done; - err_light_device_create_file3: +#if defined(CONFIG_MACH_KONA) +err_light_device_create_file4: + device_remove_file(data->light_dev, &dev_attr_lux); +#endif +err_light_device_create_file3: device_remove_file(data->light_dev, &dev_attr_vendor); err_light_device_create_file2: device_remove_file(data->light_dev, &dev_attr_raw_data); err_light_device_create_file1: sensors_classdev_unregister(data->light_dev); - err_light_device_create: +err_light_device_create: sysfs_remove_group(&data->input->dev.kobj, &al3201_attribute_group); - err_sysfs_create_group_light: +err_sysfs_create_group_light: input_unregister_device(data->input); - err_input_register_device_light: - err_input_allocate_device_light: +err_input_register_device_light: +err_input_allocate_device_light: destroy_workqueue(data->wq); - err_create_workqueue: - err_initializ_chip: +err_create_workqueue: +err_initializ_chip: mutex_destroy(&data->lock); kfree(data); done: diff --git a/drivers/sensor/k3dh_kona.c b/drivers/sensor/k3dh_kona.c new file mode 100644 index 0000000..04e1f8b --- /dev/null +++ b/drivers/sensor/k3dh_kona.c @@ -0,0 +1,1080 @@ +/* + * STMicroelectronics k3dh acceleration sensor driver + * + * Copyright (C) 2010 Samsung Electronics Co.Ltd + * + * 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. + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/fs.h> +#include <linux/slab.h> +#include <linux/i2c.h> +#include <linux/miscdevice.h> +#include <linux/uaccess.h> +#include <linux/sensor/sensors_core.h> +#include <linux/sensor/k3dh.h> +#include "k3dh_reg.h" +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV +#include <linux/input.h> +#endif + +/* For Debugging */ +#if 1 +#define k3dh_dbgmsg(str, args...) pr_debug("%s: " str, __func__, ##args) +#endif +#define k3dh_infomsg(str, args...) pr_info("%s: " str, __func__, ##args) + +#define VENDOR "STM" +#define CHIP_ID "K3DH" + +/* The default settings when sensor is on is for all 3 axis to be enabled + * and output data rate set to 400Hz. Output is via a ioctl read call. + */ +#define DEFAULT_POWER_ON_SETTING (ODR400 | ENABLE_ALL_AXES) +#define ACC_DEV_MAJOR 241 + +#define CALIBRATION_FILE_PATH "/efs/calibration_data" +#define CAL_DATA_AMOUNT 20 + +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV +/* ABS axes parameter range [um/s^2] (for input event) */ +#define GRAVITY_EARTH 9806550 +#define ABSMAX_2G (GRAVITY_EARTH * 2) +#define ABSMIN_2G (-GRAVITY_EARTH * 2) +#define MIN_DELAY 5 +#define MAX_DELAY 200 +#endif + +static const struct odr_delay { + u8 odr; /* odr reg setting */ + s64 delay_ns; /* odr in ns */ +} odr_delay_table[] = { + { ODR1344, 744047LL }, /* 1344Hz */ + { ODR400, 2500000LL }, /* 400Hz */ + { ODR200, 5000000LL }, /* 200Hz */ + { ODR100, 10000000LL }, /* 100Hz */ + { ODR50, 20000000LL }, /* 50Hz */ + { ODR25, 40000000LL }, /* 25Hz */ + { ODR10, 100000000LL }, /* 10Hz */ + { ODR1, 1000000000LL }, /* 1Hz */ +}; + +/* K3DH acceleration data */ +struct k3dh_acc { + s16 x; + s16 y; + s16 z; +}; + +struct k3dh_data { + struct i2c_client *client; + struct miscdevice k3dh_device; + struct mutex read_lock; + struct mutex write_lock; + struct completion data_ready; +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) + struct class *acc_class; +#else + struct device *dev; +#endif + struct k3dh_acc cal_data; + struct k3dh_acc acc_xyz; + u8 ctrl_reg1_shadow; + atomic_t opened; /* opened implies enabled */ +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + struct input_dev *input; + struct delayed_work work; + atomic_t delay; + atomic_t enable; +#endif + bool axis_adjust; + int position; +}; + +static struct k3dh_data *g_k3dh; + + +static void k3dh_xyz_position_adjust(struct k3dh_acc *acc, + int position) +{ + const int position_map[][3][3] = { + {{ 0, 1, 0}, {-1, 0, 0}, { 0, 0, 1} }, /* 0 top/upper-left */ + {{-1, 0, 0}, { 0, -1, 0}, { 0, 0, 1} }, /* 1 top/upper-right */ + {{ 0, -1, 0}, { 1, 0, 0}, { 0, 0, 1} }, /* 2 top/lower-right */ + {{ 1, 0, 0}, { 0, 1, 0}, { 0, 0, 1} }, /* 3 top/lower-left */ + {{ 0, -1, 0}, {-1, 0, 0}, { 0, 0, -1} }, /* 4 bottom/upper-left */ + {{ 1, 0, 0}, { 0, -1, 0}, { 0, 0, -1} }, /* 5 bottom/upper-right */ + {{ 0, 1, 0}, { 1, 0, 0}, { 0, 0, -1} }, /* 6 bottom/lower-right */ + {{-1, 0, 0}, { 0, 1, 0}, { 0, 0, -1} }, /* 7 bottom/lower-left*/ + }; + + struct k3dh_acc xyz_adjusted = {0,}; + s16 raw[3] = {0,}; + int j; + raw[0] = acc->x; + raw[1] = acc->y; + raw[2] = acc->z; + for (j = 0; j < 3; j++) { + xyz_adjusted.x += + (position_map[position][0][j] * raw[j]); + xyz_adjusted.y += + (position_map[position][1][j] * raw[j]); + xyz_adjusted.z += + (position_map[position][2][j] * raw[j]); + } + acc->x = xyz_adjusted.x; + acc->y = xyz_adjusted.y; + acc->z = xyz_adjusted.z; +} + +/* Read X,Y and Z-axis acceleration raw data */ +static int k3dh_read_accel_raw_xyz(struct k3dh_data *data, + struct k3dh_acc *acc) +{ + int err; + s8 reg = OUT_X_L | AC; /* read from OUT_X_L to OUT_Z_H by auto-inc */ + u8 acc_data[6]; + + err = i2c_smbus_read_i2c_block_data(data->client, reg, + sizeof(acc_data), acc_data); + if (err != sizeof(acc_data)) { + pr_err("%s : failed to read 6 bytes for getting x/y/z\n", + __func__); + return -EIO; + } + + acc->x = (acc_data[1] << 8) | acc_data[0]; + acc->y = (acc_data[3] << 8) | acc_data[2]; + acc->z = (acc_data[5] << 8) | acc_data[4]; + + acc->x = acc->x >> 4; + acc->y = acc->y >> 4; + +#if defined(CONFIG_MACH_U1_NA_SPR_REV05) \ + || defined(CONFIG_MACH_U1_NA_SPR_EPIC2_REV00) \ + || defined(CONFIG_MACH_U1_NA_USCC_REV05) \ + || defined(CONFIG_MACH_Q1_BD) \ + || defined(CONFIG_MACH_U1_NA_USCC) \ + || defined(CONFIG_MACH_U1_NA_SPR) + acc->z = -acc->z >> 4; +#else + acc->z = acc->z >> 4; +#endif + + if (data->axis_adjust) + k3dh_xyz_position_adjust(acc, data->position); + return 0; +} + +static int k3dh_read_accel_xyz(struct k3dh_data *data, + struct k3dh_acc *acc) +{ + int err = 0; + + mutex_lock(&data->read_lock); + err = k3dh_read_accel_raw_xyz(data, acc); + mutex_unlock(&data->read_lock); + if (err < 0) { + pr_err("%s: k3dh_read_accel_raw_xyz() failed\n", __func__); + return err; + } + + acc->x -= data->cal_data.x; + acc->y -= data->cal_data.y; + acc->z -= data->cal_data.z; + + return err; +} + +static int k3dh_open_calibration(struct k3dh_data *data) +{ + struct file *cal_filp = NULL; + int err = 0; + mm_segment_t old_fs; + + old_fs = get_fs(); + set_fs(KERNEL_DS); + + cal_filp = filp_open(CALIBRATION_FILE_PATH, O_RDONLY, 0666); + if (IS_ERR(cal_filp)) { + err = PTR_ERR(cal_filp); + if (err != -ENOENT) + pr_err("%s: Can't open calibration file\n", __func__); + set_fs(old_fs); + return err; + } + + err = cal_filp->f_op->read(cal_filp, + (char *)&data->cal_data, 3 * sizeof(s16), &cal_filp->f_pos); + if (err != 3 * sizeof(s16)) { + pr_err("%s: Can't read the cal data from file\n", __func__); + err = -EIO; + } + + k3dh_dbgmsg("%s: (%u,%u,%u)\n", __func__, + data->cal_data.x, data->cal_data.y, data->cal_data.z); + + filp_close(cal_filp, current->files); + set_fs(old_fs); + + return err; +} + +static int k3dh_do_calibrate(struct device *dev, bool do_calib) +{ + struct k3dh_data *acc_data = dev_get_drvdata(dev); + struct k3dh_acc data = { 0, }; + struct file *cal_filp = NULL; + int sum[3] = { 0, }; + int err = 0; + int i; + mm_segment_t old_fs; + + if (do_calib) { + for (i = 0; i < CAL_DATA_AMOUNT; i++) { + mutex_lock(&acc_data->read_lock); + err = k3dh_read_accel_raw_xyz(acc_data, &data); + mutex_unlock(&acc_data->read_lock); + if (err < 0) { + pr_err("%s: k3dh_read_accel_raw_xyz() " + "failed in the %dth loop\n", + __func__, i); + return err; + } + + sum[0] += data.x; + sum[1] += data.y; + sum[2] += data.z; + } + + acc_data->cal_data.x = sum[0] / CAL_DATA_AMOUNT; + acc_data->cal_data.y = sum[1] / CAL_DATA_AMOUNT; + if (sum[2] >= 0) + acc_data->cal_data.z = (sum[2] / CAL_DATA_AMOUNT)-1024; + else + acc_data->cal_data.z = (sum[2] / CAL_DATA_AMOUNT)+1024; + } else { + acc_data->cal_data.x = 0; + acc_data->cal_data.y = 0; + acc_data->cal_data.z = 0; + } + + printk(KERN_INFO "%s: cal data (%d,%d,%d)\n", __func__, + acc_data->cal_data.x, acc_data->cal_data.y, acc_data->cal_data.z); + + old_fs = get_fs(); + set_fs(KERNEL_DS); + + cal_filp = filp_open(CALIBRATION_FILE_PATH, + O_CREAT | O_TRUNC | O_WRONLY, 0666); + if (IS_ERR(cal_filp)) { + pr_err("%s: Can't open calibration file\n", __func__); + set_fs(old_fs); + err = PTR_ERR(cal_filp); + return err; + } + + err = cal_filp->f_op->write(cal_filp, + (char *)&acc_data->cal_data, 3 * sizeof(s16), &cal_filp->f_pos); + if (err != 3 * sizeof(s16)) { + pr_err("%s: Can't write the cal data to file\n", __func__); + err = -EIO; + } + + filp_close(cal_filp, current->files); + set_fs(old_fs); + + return err; +} + +static int k3dh_accel_enable(struct k3dh_data *data) +{ + int err = 0; + + if (atomic_read(&data->opened) == 0) { + err = k3dh_open_calibration(data); + if (err < 0 && err != -ENOENT) + pr_err("%s: k3dh_open_calibration() failed\n", + __func__); + data->ctrl_reg1_shadow = DEFAULT_POWER_ON_SETTING; + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + DEFAULT_POWER_ON_SETTING); + if (err) + pr_err("%s: i2c write ctrl_reg1 failed\n", __func__); + +#if defined(CONFIG_SENSORS_K2DH) + err = i2c_smbus_write_byte_data(data->client, CTRL_REG4, + CTRL_REG4_HR | CTRL_REG4_BDU); +#else + err = i2c_smbus_write_byte_data(data->client, CTRL_REG4, + CTRL_REG4_HR); +#endif + if (err) + pr_err("%s: i2c write ctrl_reg4 failed\n", __func__); + } + + atomic_add(1, &data->opened); + + return err; +} + +static int k3dh_accel_disable(struct k3dh_data *data) +{ + int err = 0; + + atomic_sub(1, &data->opened); + if (atomic_read(&data->opened) == 0) { + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + PM_OFF); + data->ctrl_reg1_shadow = PM_OFF; + } + + return err; +} + +/* open command for K3DH device file */ +static int k3dh_open(struct inode *inode, struct file *file) +{ + k3dh_infomsg("is called.\n"); + return 0; +} + +/* release command for K3DH device file */ +static int k3dh_close(struct inode *inode, struct file *file) +{ + k3dh_infomsg("is called.\n"); + return 0; +} + +static s64 k3dh_get_delay(struct k3dh_data *data) +{ + int i; + u8 odr; + s64 delay = -1; + + odr = data->ctrl_reg1_shadow & ODR_MASK; + for (i = 0; i < ARRAY_SIZE(odr_delay_table); i++) { + if (odr == odr_delay_table[i].odr) { + delay = odr_delay_table[i].delay_ns; + break; + } + } + return delay; +} + +static int k3dh_set_delay(struct k3dh_data *data, s64 delay_ns) +{ + int odr_value = ODR1; + int res = 0; + int i; + + /* round to the nearest delay that is less than + * the requested value (next highest freq) + */ + for (i = 0; i < ARRAY_SIZE(odr_delay_table); i++) { + if (delay_ns < odr_delay_table[i].delay_ns) + break; + } + if (i > 0) + i--; + odr_value = odr_delay_table[i].odr; + delay_ns = odr_delay_table[i].delay_ns; + + k3dh_infomsg("old=%lldns, new=%lldns, odr=0x%x/0x%x\n", + k3dh_get_delay(data), delay_ns, odr_value, + data->ctrl_reg1_shadow); + mutex_lock(&data->write_lock); + if (odr_value != (data->ctrl_reg1_shadow & ODR_MASK)) { + u8 ctrl = (data->ctrl_reg1_shadow & ~ODR_MASK); + ctrl |= odr_value; + data->ctrl_reg1_shadow = ctrl; + res = i2c_smbus_write_byte_data(data->client, CTRL_REG1, ctrl); + } + mutex_unlock(&data->write_lock); + return res; +} + +/* ioctl command for K3DH device file */ +static long k3dh_ioctl(struct file *file, + unsigned int cmd, unsigned long arg) +{ + int err = 0; + struct k3dh_data *data = container_of(file->private_data, + struct k3dh_data, k3dh_device); + s64 delay_ns; + int enable = 0; + + /* cmd mapping */ + switch (cmd) { + case K3DH_IOCTL_SET_ENABLE: + if (copy_from_user(&enable, (void __user *)arg, + sizeof(enable))) + return -EFAULT; + k3dh_infomsg("opened = %d, enable = %d\n", + atomic_read(&data->opened), enable); + if (enable) + err = k3dh_accel_enable(data); + else + err = k3dh_accel_disable(data); + break; + case K3DH_IOCTL_SET_DELAY: + if (copy_from_user(&delay_ns, (void __user *)arg, + sizeof(delay_ns))) + return -EFAULT; + err = k3dh_set_delay(data, delay_ns); + break; + case K3DH_IOCTL_GET_DELAY: + delay_ns = k3dh_get_delay(data); + if (put_user(delay_ns, (s64 __user *)arg)) + return -EFAULT; + break; + case K3DH_IOCTL_READ_ACCEL_XYZ: + err = k3dh_read_accel_xyz(data, &data->acc_xyz); + if (err) + break; + if (copy_to_user((void __user *)arg, + &data->acc_xyz, sizeof(data->acc_xyz))) + return -EFAULT; + break; + default: + err = -EINVAL; + break; + } + + return err; +} + +static int k3dh_suspend(struct device *dev) +{ + int res = 0; + struct k3dh_data *data = dev_get_drvdata(dev); +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + if (atomic_read(&data->enable)) + cancel_delayed_work_sync(&data->work); +#endif + if (atomic_read(&data->opened) > 0) + res = i2c_smbus_write_byte_data(data->client, + CTRL_REG1, PM_OFF); + + return res; +} + +static int k3dh_resume(struct device *dev) +{ + int res = 0; + struct k3dh_data *data = dev_get_drvdata(dev); + + if (atomic_read(&data->opened) > 0) + res = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + data->ctrl_reg1_shadow); +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + if (atomic_read(&data->enable)) + schedule_delayed_work(&data->work, + msecs_to_jiffies(5)); +#endif + return res; +} + +static const struct dev_pm_ops k3dh_pm_ops = { + .suspend = k3dh_suspend, + .resume = k3dh_resume, +}; + +static const struct file_operations k3dh_fops = { + .owner = THIS_MODULE, + .open = k3dh_open, + .release = k3dh_close, + .unlocked_ioctl = k3dh_ioctl, +}; + +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV +static ssize_t k3dh_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input = to_input_dev(dev); + struct k3dh_data *data = input_get_drvdata(input); + + return sprintf(buf, "%d\n", atomic_read(&data->enable)); +} + +static ssize_t k3dh_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input = to_input_dev(dev); + struct k3dh_data *data = input_get_drvdata(input); + unsigned long enable = 0; + int err; + + if (strict_strtoul(buf, 10, &enable)) + return -EINVAL; + k3dh_open_calibration(data); + + if (enable) { + err = k3dh_accel_enable(data); + if (err < 0) + goto done; + schedule_delayed_work(&data->work, + msecs_to_jiffies(5)); + } else { + cancel_delayed_work_sync(&data->work); + err = k3dh_accel_disable(data); + if (err < 0) + goto done; + } + atomic_set(&data->enable, enable); + pr_info("%s, enable = %ld\n", __func__, enable); +done: + return count; +} +static DEVICE_ATTR(enable, + S_IRUGO | S_IWUSR | S_IWGRP, + k3dh_enable_show, k3dh_enable_store); + +static ssize_t k3dh_delay_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input = to_input_dev(dev); + struct k3dh_data *data = input_get_drvdata(input); + + return sprintf(buf, "%d\n", atomic_read(&data->delay)); +} + +static ssize_t k3dh_delay_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input = to_input_dev(dev); + struct k3dh_data *data = input_get_drvdata(input); + unsigned long delay = 0; + if (strict_strtoul(buf, 10, &delay)) + return -EINVAL; + + if (delay > MAX_DELAY) + delay = MAX_DELAY; + if (delay < MIN_DELAY) + delay = MIN_DELAY; + atomic_set(&data->delay, delay); + k3dh_set_delay(data, delay * 1000000); + pr_info("%s, delay = %ld\n", __func__, delay); + return count; +} +static DEVICE_ATTR(poll_delay, + S_IRUGO | S_IWUSR | S_IWGRP, + k3dh_delay_show, k3dh_delay_store); + +static struct attribute *k3dh_attributes[] = { + &dev_attr_enable.attr, + &dev_attr_poll_delay.attr, + NULL +}; + +static struct attribute_group k3dh_attribute_group = { + .attrs = k3dh_attributes +}; +#endif + +static ssize_t k3dh_fs_read(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct k3dh_data *data = dev_get_drvdata(dev); + +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) + int err = 0; + int on; + + mutex_lock(&data->write_lock); + on = atomic_read(&data->opened); + if (on == 0) { + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + DEFAULT_POWER_ON_SETTING); + } + mutex_unlock(&data->write_lock); + + if (err < 0) { + pr_err("%s: i2c write ctrl_reg1 failed\n", __func__); + return err; + } + + err = k3dh_read_accel_xyz(data, &data->acc_xyz); + if (err < 0) { + pr_err("%s: k3dh_read_accel_xyz failed\n", __func__); + return err; + } + + if (on == 0) { + mutex_lock(&data->write_lock); + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + PM_OFF); + mutex_unlock(&data->write_lock); + if (err) + pr_err("%s: i2c write ctrl_reg1 failed\n", __func__); + } +#endif + return sprintf(buf, "%d,%d,%d\n", + data->acc_xyz.x, data->acc_xyz.y, data->acc_xyz.z); +} + +static ssize_t k3dh_calibration_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + int err; + struct k3dh_data *data = dev_get_drvdata(dev); + + err = k3dh_open_calibration(data); + if (err < 0) + pr_err("%s: k3dh_open_calibration() failed\n", __func__); + + if (!data->cal_data.x && !data->cal_data.y && !data->cal_data.z) + err = -1; + + return sprintf(buf, "%d %d %d %d\n", + err, data->cal_data.x, data->cal_data.y, data->cal_data.z); +} + +static ssize_t k3dh_calibration_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct k3dh_data *data = dev_get_drvdata(dev); + bool do_calib; + int err; + + if (sysfs_streq(buf, "1")) + do_calib = true; + else if (sysfs_streq(buf, "0")) + do_calib = false; + else { + pr_debug("%s: invalid value %d\n", __func__, *buf); + return -EINVAL; + } + + if (atomic_read(&data->opened) == 0) { + /* if off, turn on the device.*/ + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + DEFAULT_POWER_ON_SETTING); + if (err) { + pr_err("%s: i2c write ctrl_reg1 failed(err=%d)\n", + __func__, err); + } + } + + err = k3dh_do_calibrate(dev, do_calib); + if (err < 0) { + pr_err("%s: k3dh_do_calibrate() failed\n", __func__); + return err; + } + + if (atomic_read(&data->opened) == 0) { + /* if off, turn on the device.*/ + err = i2c_smbus_write_byte_data(data->client, CTRL_REG1, + PM_OFF); + if (err) { + pr_err("%s: i2c write ctrl_reg1 failed(err=%d)\n", + __func__, err); + } + } + + return count; +} + +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) +static DEVICE_ATTR(acc_file, 0664, k3dh_fs_read, NULL); +#else +static ssize_t +k3dh_accel_position_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct k3dh_data *data = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", data->position); +} + +static ssize_t +k3dh_accel_position_store(struct device *dev, + struct device_attribute *attr, + const char *buf, + size_t count) +{ + struct k3dh_data *data = dev_get_drvdata(dev); + int err = 0; + + err = kstrtoint(buf, 10, &data->position); + if (err < 0) + pr_err("%s, kstrtoint failed.", __func__); + + return count; +} + +static ssize_t k3dh_accel_vendor_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + return sprintf(buf, "%s\n", VENDOR); +} + +static ssize_t k3dh_accel_name_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + return sprintf(buf, "%s\n", CHIP_ID); +} + +static DEVICE_ATTR(name, 0664, k3dh_accel_name_show, NULL); +static DEVICE_ATTR(vendor, 0664, k3dh_accel_vendor_show, NULL); +static DEVICE_ATTR(raw_data, 0664, k3dh_fs_read, NULL); +static DEVICE_ATTR(position, 0664, + k3dh_accel_position_show, k3dh_accel_position_store); +#endif +static DEVICE_ATTR(calibration, 0664, + k3dh_calibration_show, k3dh_calibration_store); + +void k3dh_shutdown(struct i2c_client *client) +{ + int res = 0; + struct k3dh_data *data = i2c_get_clientdata(client); + + k3dh_infomsg("is called.\n"); + +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + if (atomic_read(&data->enable)) + cancel_delayed_work_sync(&data->work); +#endif + res = i2c_smbus_write_byte_data(data->client, + CTRL_REG1, PM_OFF); + if (res < 0) + pr_err("%s: pm_off failed %d\n", __func__, res); +} + +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV +static void k3dh_work_func(struct work_struct *work) +{ + k3dh_read_accel_xyz(g_k3dh, &g_k3dh->acc_xyz); + pr_debug("%s: x: %d, y: %d, z: %d\n", __func__, + g_k3dh->acc_xyz.x, g_k3dh->acc_xyz.y, g_k3dh->acc_xyz.z); + input_report_abs(g_k3dh->input, ABS_X, g_k3dh->acc_xyz.x); + input_report_abs(g_k3dh->input, ABS_Y, g_k3dh->acc_xyz.y); + input_report_abs(g_k3dh->input, ABS_Z, g_k3dh->acc_xyz.z); + input_sync(g_k3dh->input); + schedule_delayed_work(&g_k3dh->work, msecs_to_jiffies( + atomic_read(&g_k3dh->delay))); +} + +/* ----------------- * + Input device interface + * ------------------ */ +static int k3dh_input_init(struct k3dh_data *data) +{ + struct input_dev *dev; + int err = 0; + + dev = input_allocate_device(); + if (!dev) + return -ENOMEM; + dev->name = "accelerometer"; + dev->id.bustype = BUS_I2C; + + input_set_capability(dev, EV_ABS, ABS_MISC); + input_set_abs_params(dev, ABS_X, ABSMIN_2G, ABSMAX_2G, 0, 0); + input_set_abs_params(dev, ABS_Y, ABSMIN_2G, ABSMAX_2G, 0, 0); + input_set_abs_params(dev, ABS_Z, ABSMIN_2G, ABSMAX_2G, 0, 0); + input_set_drvdata(dev, data); + + err = input_register_device(dev); + if (err < 0) + goto done; + data->input = dev; +done: + return 0; +} +#endif +static int k3dh_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct k3dh_data *data; +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) + struct device *dev_t, *dev_cal; +#endif + struct accel_platform_data *pdata; + int err; + + k3dh_infomsg("is started.\n"); + + if (!i2c_check_functionality(client->adapter, + I2C_FUNC_SMBUS_WRITE_BYTE_DATA | + I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { + pr_err("%s: i2c functionality check failed!\n", __func__); + err = -ENODEV; + goto exit; + } + + data = kzalloc(sizeof(struct k3dh_data), GFP_KERNEL); + if (data == NULL) { + dev_err(&client->dev, + "failed to allocate memory for module data\n"); + err = -ENOMEM; + goto exit; + } + + /* Checking device */ + err = i2c_smbus_write_byte_data(client, CTRL_REG1, + PM_OFF); + if (err) { + pr_err("%s: there is no such device, err = %d\n", + __func__, err); + goto err_read_reg; + } + + data->client = client; + g_k3dh = data; + i2c_set_clientdata(client, data); + + init_completion(&data->data_ready); + mutex_init(&data->read_lock); + mutex_init(&data->write_lock); + atomic_set(&data->opened, 0); + + /* sensor HAL expects to find /dev/accelerometer */ + data->k3dh_device.minor = MISC_DYNAMIC_MINOR; + data->k3dh_device.name = ACC_DEV_NAME; + data->k3dh_device.fops = &k3dh_fops; + + err = misc_register(&data->k3dh_device); + if (err) { + pr_err("%s: misc_register failed\n", __FILE__); + goto err_misc_register; + } + + pdata = client->dev.platform_data; + if (!pdata) { + /*Set by default position 3, it doesn't adjust raw value*/ + data->position = 3; + data->axis_adjust = false; + pr_err("using defualt position = %d\n", data->position); + } else { + if (pdata->accel_get_position) + data->position = pdata->accel_get_position(); + data->axis_adjust = pdata->axis_adjust; + pr_info("successful, position = %d\n", data->position); + } +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + atomic_set(&data->enable, 0); + atomic_set(&data->delay, 200); + k3dh_input_init(data); + + /* Setup sysfs */ + err = + sysfs_create_group(&data->input->dev.kobj, + &k3dh_attribute_group); + if (err < 0) + goto err_sysfs_create_group; + + /* Setup driver interface */ + INIT_DELAYED_WORK(&data->work, k3dh_work_func); +#endif +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) + /* creating class/device for test */ + data->acc_class = class_create(THIS_MODULE, "accelerometer"); + if (IS_ERR(data->acc_class)) { + pr_err("%s: class create failed(accelerometer)\n", __func__); + err = PTR_ERR(data->acc_class); + goto err_class_create; + } + + dev_t = device_create(data->acc_class, NULL, + MKDEV(ACC_DEV_MAJOR, 0), "%s", "accelerometer"); + if (IS_ERR(dev_t)) { + pr_err("%s: class create failed(accelerometer)\n", __func__); + err = PTR_ERR(dev_t); + goto err_acc_device_create; + } + + err = device_create_file(dev_t, &dev_attr_acc_file); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_acc_file.attr.name); + goto err_acc_device_create_file; + } + dev_set_drvdata(dev_t, data); + + /* creating device for calibration */ + dev_cal = device_create(sec_class, NULL, 0, NULL, "gsensorcal"); + if (IS_ERR(dev_cal)) { + pr_err("%s: class create failed(gsensorcal)\n", __func__); + err = PTR_ERR(dev_cal); + goto err_cal_device_create; + } + + err = device_create_file(dev_cal, &dev_attr_calibration); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_calibration.attr.name); + goto err_cal_device_create_file; + } + dev_set_drvdata(dev_cal, data); +#else + /* creating device for test & calibration */ + data->dev = sensors_classdev_register("accelerometer_sensor"); + if (IS_ERR(data->dev)) { + pr_err("%s: class create failed(accelerometer_sensor)\n", + __func__); + err = PTR_ERR(data->dev); + goto err_acc_device_create; + } + + err = device_create_file(data->dev, &dev_attr_position); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_position.attr.name); + goto err_position_device_create_file; + } + + err = device_create_file(data->dev, &dev_attr_raw_data); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_raw_data.attr.name); + goto err_acc_device_create_file; + } + + err = device_create_file(data->dev, &dev_attr_calibration); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_calibration.attr.name); + goto err_cal_device_create_file; + } + + err = device_create_file(data->dev, &dev_attr_vendor); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_vendor.attr.name); + goto err_vendor_device_create_file; + } + + err = device_create_file(data->dev, &dev_attr_name); + if (err < 0) { + pr_err("%s: Failed to create device file(%s)\n", + __func__, dev_attr_name.attr.name); + goto err_name_device_create_file; + } + + dev_set_drvdata(data->dev, data); +#endif + + k3dh_infomsg("is successful.\n"); + + return 0; + +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) +err_cal_device_create_file: + device_destroy(sec_class, 0); +err_cal_device_create: + device_remove_file(dev_t, &dev_attr_acc_file); +err_acc_device_create_file: + device_destroy(data->acc_class, MKDEV(ACC_DEV_MAJOR, 0)); +err_acc_device_create: + class_destroy(data->acc_class); +err_class_create: +#else +err_name_device_create_file: + device_remove_file(data->dev, &dev_attr_vendor); +err_vendor_device_create_file: + device_remove_file(data->dev, &dev_attr_calibration); +err_cal_device_create_file: + device_remove_file(data->dev, &dev_attr_raw_data); +err_acc_device_create_file: + device_remove_file(data->dev, &dev_attr_position); +err_position_device_create_file: + sensors_classdev_unregister(data->dev); + +err_acc_device_create: +#endif +#ifdef CONFIG_SENSOR_K3DH_INPUTDEV + input_free_device(data->input); +err_sysfs_create_group: +#endif +misc_deregister(&data->k3dh_device); +err_misc_register: + mutex_destroy(&data->read_lock); + mutex_destroy(&data->write_lock); +err_read_reg: + kfree(data); +exit: + return err; +} + +static int k3dh_remove(struct i2c_client *client) +{ + struct k3dh_data *data = i2c_get_clientdata(client); + int err = 0; + + if (atomic_read(&data->opened) > 0) { + err = i2c_smbus_write_byte_data(data->client, + CTRL_REG1, PM_OFF); + if (err < 0) + pr_err("%s: pm_off failed %d\n", __func__, err); + } + +#if defined(CONFIG_MACH_U1) || defined(CONFIG_MACH_TRATS) + device_destroy(sec_class, 0); + device_destroy(data->acc_class, MKDEV(ACC_DEV_MAJOR, 0)); + class_destroy(data->acc_class); +#else + device_remove_file(data->dev, &dev_attr_name); + device_remove_file(data->dev, &dev_attr_vendor); + device_remove_file(data->dev, &dev_attr_calibration); + device_remove_file(data->dev, &dev_attr_raw_data); + device_remove_file(data->dev, &dev_attr_position); + sensors_classdev_unregister(data->dev); +#endif + misc_deregister(&data->k3dh_device); + mutex_destroy(&data->read_lock); + mutex_destroy(&data->write_lock); + kfree(data); + + return 0; +} + +static const struct i2c_device_id k3dh_id[] = { + { "k3dh", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, k3dh_id); + +static struct i2c_driver k3dh_driver = { + .probe = k3dh_probe, + .shutdown = k3dh_shutdown, + .remove = __devexit_p(k3dh_remove), + .id_table = k3dh_id, + .driver = { + .pm = &k3dh_pm_ops, + .owner = THIS_MODULE, + .name = "k3dh", + }, +}; + +static int __init k3dh_init(void) +{ + return i2c_add_driver(&k3dh_driver); +} + +static void __exit k3dh_exit(void) +{ + i2c_del_driver(&k3dh_driver); +} + +module_init(k3dh_init); +module_exit(k3dh_exit); + +MODULE_DESCRIPTION("k3dh accelerometer driver"); +MODULE_AUTHOR("Samsung Electronics"); +MODULE_LICENSE("GPL"); diff --git a/drivers/sensor/k3dh_reg.h b/drivers/sensor/k3dh_reg.h index 846d0d7..e6c9fa4 100644 --- a/drivers/sensor/k3dh_reg.h +++ b/drivers/sensor/k3dh_reg.h @@ -102,6 +102,7 @@ #define I1_OVERRUN (1 << 1) /* CTRL_REG4 */ +#define CTRL_REG4_BDU (1 << 7) #define CTRL_REG4_BLE (1 << 6) #define CTRL_REG4_FS1 (1 << 5) #define CTRL_REG4_FS0 (1 << 4) diff --git a/drivers/sensor/yas_mag_driver-yas532.c b/drivers/sensor/yas_mag_driver-yas532.c new file mode 100644 index 0000000..14259b8 --- /dev/null +++ b/drivers/sensor/yas_mag_driver-yas532.c @@ -0,0 +1,2909 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + */ + +#include <linux/sensor/yas.h> + +struct utimeval { + int32_t tv_sec; + int32_t tv_msec; +}; + +struct utimer { + struct utimeval prev_time; + struct utimeval total_time; + struct utimeval delay_ms; +}; + +static int utimeval_init(struct utimeval *val); +static int utimeval_is_initial(struct utimeval *val); +static int utimeval_is_overflow(struct utimeval *val); +static struct utimeval utimeval_plus(struct utimeval *first, + struct utimeval *second); +static struct utimeval utimeval_minus(struct utimeval *first, + struct utimeval *second); +static int utimeval_greater_than(struct utimeval *first, + struct utimeval *second); +static int utimeval_greater_or_equal(struct utimeval *first, + struct utimeval *second); +static int utimeval_greater_than_zero(struct utimeval *val); +static int utimeval_less_than_zero(struct utimeval *val); +static struct utimeval *msec_to_utimeval(struct utimeval *result, + uint32_t msec); +static uint32_t utimeval_to_msec(struct utimeval *val); + +static struct utimeval utimer_calc_next_time(struct utimer *ut, + struct utimeval *cur); +static struct utimeval utimer_current_time(void); +static int utimer_is_timeout(struct utimer *ut); +static int utimer_clear_timeout(struct utimer *ut); +static uint32_t utimer_get_total_time(struct utimer *ut); +static uint32_t utimer_get_delay(struct utimer *ut); +static int utimer_set_delay(struct utimer *ut, uint32_t delay_ms); +static int utimer_update(struct utimer *ut); +static int utimer_update_with_curtime(struct utimer *ut, struct utimeval *cur); +static uint32_t utimer_sleep_time(struct utimer *ut); +static uint32_t utimer_sleep_time_with_curtime(struct utimer *ut, + struct utimeval *cur); +static int utimer_init(struct utimer *ut, uint32_t delay_ms); +static int utimer_clear(struct utimer *ut); +static void utimer_lib_init(void (*func) (int *sec, int *msec)); + +#define YAS_REGADDR_DEVICE_ID (0x80) +#define YAS_REGADDR_ACTUATE_INIT_COIL (0x81) +#define YAS_REGADDR_MEASURE_COMMAND (0x82) +#define YAS_REGADDR_CONFIG (0x83) +#define YAS_REGADDR_MEASURE_INTERVAL (0x84) +#define YAS_REGADDR_OFFSET_X (0x85) +#define YAS_REGADDR_OFFSET_Y1 (0x86) +#define YAS_REGADDR_OFFSET_Y2 (0x87) +#define YAS_REGADDR_TEST1 (0x88) +#define YAS_REGADDR_TEST2 (0x89) +#define YAS_REGADDR_CAL (0x90) +#define YAS_REGADDR_MEASURE_DATA (0xb0) +#define YAS_YAS530_DEVICE_ID (0x01) /* YAS530 (MS-3E) */ +#define YAS_YAS530_VERSION_A (0) /* YAS530 (MS-3E Aver) */ +#define YAS_YAS530_VERSION_B (1) /* YAS530B (MS-3E Bver) */ +#define YAS_YAS530_VERSION_A_COEF (380) +#define YAS_YAS530_VERSION_B_COEF (550) +#define YAS_YAS530_DATA_CENTER (2048) +#define YAS_YAS530_DATA_OVERFLOW (4095) + +#define YAS_YAS532_DEVICE_ID (0x02) /* YAS532 (MS-3R) */ +#define YAS_YAS532_VERSION_AB (0) /* YAS532AB (MS-3R ABver) */ +#define YAS_YAS532_VERSION_AC (1) /* YAS532AC (MS-3R ACver) */ +#define YAS_YAS532_VERSION_AB_COEF (1800) +#define YAS_YAS532_VERSION_AC_COEF (900) +#define YAS_YAS532_DATA_CENTER (4096) +#define YAS_YAS532_DATA_OVERFLOW (8190) + +#undef YAS_YAS530_CAL_SINGLE_READ + +struct yas_machdep_func { + int (*device_open) (void); + int (*device_close) (void); + int (*device_write) (uint8_t addr, const uint8_t *buf, int len); + int (*device_read) (uint8_t addr, uint8_t *buf, int len); + void (*msleep) (int msec); +}; + +static int yas_cdrv_actuate_initcoil(void); +static int yas_cdrv_set_offset(const int8_t *offset); +static int yas_cdrv_recalc_calib_offset(int32_t *prev_calib_offset, + int32_t *new_calib_offset, + int8_t *prev_offset, + int8_t *new_offset); +static int yas_cdrv_set_transformatiom_matrix(const int8_t *transform); +static int yas_cdrv_measure_and_set_offset(int8_t *offset); +static int yas_cdrv_measure(int32_t *msens, int32_t *raw, int16_t *t); +static int yas_cdrv_init(const int8_t *transform, + struct yas_machdep_func *func); +static int yas_cdrv_term(void); + +static void (*current_time) (int *sec, int *msec) = { +0}; + +static int utimeval_init(struct utimeval *val) +{ + if (unlikely(!val)) + return -1; + val->tv_sec = val->tv_msec = 0; + return 0; +} + +static int utimeval_is_initial(struct utimeval *val) +{ + if (unlikely(!val)) + return 0; + return val->tv_sec == 0 && val->tv_msec == 0; +} + +static int utimeval_is_overflow(struct utimeval *val) +{ + int32_t max; + + if (unlikely(!val)) + return 0; + + max = (int32_t) (0xffffffff / 1000); + if (val->tv_sec > max) { + return 1; /* overflow */ + } else if (val->tv_sec == max) { + if (val->tv_msec > + (int32_t) (0xffffffff % 1000)) { + return 1; /* overflow */ + } + } + + return 0; +} + +static struct utimeval +utimeval_plus(struct utimeval *first, struct utimeval *second) +{ + struct utimeval result = { 0, 0 }; + int32_t tmp; + + if (unlikely(!first || !second)) + return result; + + tmp = first->tv_sec + second->tv_sec; + if (first->tv_sec >= 0 && second->tv_sec >= 0 && tmp < 0) + goto overflow; + if (first->tv_sec < 0 && second->tv_sec < 0 && tmp >= 0) + goto underflow; + + result.tv_sec = tmp; + result.tv_msec = first->tv_msec + second->tv_msec; + if (1000 <= result.tv_msec) { + tmp = result.tv_sec + result.tv_msec / 1000; + if (result.tv_sec >= 0 && result.tv_msec >= 0 && tmp < 0) + goto overflow; + result.tv_sec = tmp; + result.tv_msec = result.tv_msec % 1000; + } + if (result.tv_msec < 0) { + tmp = result.tv_sec + result.tv_msec / 1000 - 1; + if (result.tv_sec < 0 && result.tv_msec < 0 && tmp >= 0) + goto underflow; + result.tv_sec = tmp; + result.tv_msec = result.tv_msec % 1000 + 1000; + } + + return result; + +overflow: + result.tv_sec = 0x7fffffff; + result.tv_msec = 999; + return result; + +underflow: + result.tv_sec = 0x80000000; + result.tv_msec = 0; + return result; +} + +static struct utimeval +utimeval_minus(struct utimeval *first, struct utimeval *second) +{ + struct utimeval result = { 0, 0 }, tmp; + + if (first == NULL || second == NULL + || second->tv_sec == (int)0x80000000) + return result; + + tmp.tv_sec = -second->tv_sec; + tmp.tv_msec = -second->tv_msec; + return utimeval_plus(first, &tmp); +} + +static int utimeval_less_than(struct utimeval *first, struct utimeval *second) +{ + if (unlikely(!first || !second)) + return 0; + + if (first->tv_sec > second->tv_sec) + return 1; + else if (first->tv_sec < second->tv_sec) + return 0; + else + if (first->tv_msec > second->tv_msec) + return 1; + else + return 0; +} + +static int +utimeval_greater_than(struct utimeval *first, struct utimeval *second) +{ + if (unlikely(!first || !second)) + return 0; + + if (first->tv_sec < second->tv_sec) + return 1; + else if (first->tv_sec > second->tv_sec) + return 0; + else + if (first->tv_msec < second->tv_msec) + return 1; + else + return 0; +} + +static int +utimeval_greater_or_equal(struct utimeval *first, struct utimeval *second) +{ + return !utimeval_less_than(first, second); +} + +static int utimeval_greater_than_zero(struct utimeval *val) +{ + struct utimeval zero = { 0, 0 }; + return utimeval_greater_than(&zero, val); +} + +static int utimeval_less_than_zero(struct utimeval *val) +{ + struct utimeval zero = { 0, 0 }; + return utimeval_less_than(&zero, val); +} + +static struct utimeval *msec_to_utimeval(struct utimeval *result, uint32_t msec) +{ + if (unlikely(!result)) + return result; + result->tv_sec = msec / 1000; + result->tv_msec = msec % 1000; + + return result; +} + +static uint32_t utimeval_to_msec(struct utimeval *val) +{ + if (unlikely(!val)) + return 0; + if (utimeval_less_than_zero(val)) + return 0; + + if (utimeval_is_overflow(val)) + return 0xffffffff; + + return val->tv_sec * 1000 + val->tv_msec; +} + +static struct utimeval +utimer_calc_next_time(struct utimer *ut, struct utimeval *cur) +{ + struct utimeval result = { 0, 0 }, delay; + + if (ut == NULL || cur == NULL) + return result; + utimer_update_with_curtime(ut, cur); + if (utimer_is_timeout(ut)) { + result = *cur; + } else { + delay = utimeval_minus(&ut->delay_ms, &ut->total_time); + result = utimeval_plus(cur, &delay); + } + + return result; +} + +static struct utimeval utimer_current_time(void) +{ + struct utimeval tv; + int sec, msec; + + if (current_time != NULL) + current_time(&sec, &msec); + else + sec = 0, msec = 0; + tv.tv_sec = sec; + tv.tv_msec = msec; + + return tv; +} + +static int utimer_clear(struct utimer *ut) +{ + if (unlikely(!ut)) + return -1; + utimeval_init(&ut->prev_time); + utimeval_init(&ut->total_time); + + return 0; +} + +static int utimer_update_with_curtime(struct utimer *ut, struct utimeval *cur) +{ + struct utimeval tmp; + + if (unlikely(!ut || !cur)) + return -1; + if (utimeval_is_initial(&ut->prev_time)) + ut->prev_time = *cur; + if (utimeval_greater_than_zero(&ut->delay_ms)) { + tmp = utimeval_minus(cur, &ut->prev_time); + if (utimeval_less_than_zero(&tmp)) + utimeval_init(&ut->total_time); + else { + ut->total_time = utimeval_plus(&tmp, &ut->total_time); + if (utimeval_is_overflow(&ut->total_time)) + utimeval_init(&ut->total_time); + } + ut->prev_time = *cur; + } + + return 0; +} + +static int utimer_update(struct utimer *ut) +{ + struct utimeval cur; + + if (unlikely(!ut)) + return -1; + + cur = utimer_current_time(); + utimer_update_with_curtime(ut, &cur); + return 0; +} + +static int utimer_is_timeout(struct utimer *ut) +{ + if (unlikely(!ut)) + return 0; + + if (utimeval_greater_than_zero(&ut->delay_ms)) + return utimeval_greater_or_equal(&ut->delay_ms, + &ut->total_time); + else + return 1; +} + +static int utimer_clear_timeout(struct utimer *ut) +{ + uint32_t delay, total; + + if (unlikely(!ut)) + return -1; + + delay = utimeval_to_msec(&ut->delay_ms); + if (delay == 0 || utimeval_is_overflow(&ut->total_time)) + total = 0; + else + if (utimeval_is_overflow(&ut->total_time)) + total = 0; + else { + total = utimeval_to_msec(&ut->total_time); + total = total % delay; + } + msec_to_utimeval(&ut->total_time, total); + + return 0; +} + +static uint32_t +utimer_sleep_time_with_curtime(struct utimer *ut, struct utimeval *cur) +{ + struct utimeval tv; + + if (unlikely(!ut || !cur)) + return 0; + + tv = utimer_calc_next_time(ut, cur); + tv = utimeval_minus(&tv, cur); + if (utimeval_less_than_zero(&tv)) + return 0; + + return utimeval_to_msec(&tv); +} + +static uint32_t utimer_sleep_time(struct utimer *ut) +{ + struct utimeval cur; + + if (unlikely(!ut)) + return 0; + + cur = utimer_current_time(); + return utimer_sleep_time_with_curtime(ut, &cur); +} + +static int utimer_init(struct utimer *ut, uint32_t delay_ms) +{ + if (unlikely(!ut)) + return -1; + utimer_clear(ut); + msec_to_utimeval(&ut->delay_ms, delay_ms); + + return 0; +} + +static uint32_t utimer_get_total_time(struct utimer *ut) +{ + return utimeval_to_msec(&ut->total_time); +} + +static uint32_t utimer_get_delay(struct utimer *ut) +{ + if (unlikely(!ut)) + return -1; + return utimeval_to_msec(&ut->delay_ms); +} + +static int utimer_set_delay(struct utimer *ut, uint32_t delay_ms) +{ + return utimer_init(ut, delay_ms); +} + +static void utimer_lib_init(void (*func) (int *sec, int *msec)) +{ + current_time = func; +} + +struct yas_cal_data { + uint8_t dx, dy1, dy2; + uint8_t d2, d3, d4, d5, d6, d7, d8, d9, d0; + uint8_t dck; + uint8_t ver; +}; +struct yas_correction_data { + int32_t Cx, Cy1, Cy2; + int32_t a2, a3, a4, a5, a6, a7, a8, a9, k; +}; +struct yas_cdriver { + struct yas_cal_data cal; + struct yas_correction_data correct; + struct yas_machdep_func func; + int8_t transform[9]; + int16_t temperature; + uint8_t dev_id; + int32_t coef; + int16_t center; + int16_t overflow; +}; +static struct yas_cdriver cdriver; + +static int device_open(void) +{ + if (cdriver.func.device_open == NULL) + return -1; + return cdriver.func.device_open(); +} + +static int device_close(void) +{ + if (cdriver.func.device_close == NULL) + return -1; + return cdriver.func.device_close(); +} + +static int device_write(uint8_t addr, const uint8_t *buf, int len) +{ + if (cdriver.func.device_write == NULL) + return -1; + return cdriver.func.device_write(addr, buf, len); +} + +static int device_read(uint8_t addr, uint8_t *buf, int len) +{ + if (cdriver.func.device_read == NULL) + return -1; + return cdriver.func.device_read(addr, buf, len); +} + +static void sleep(int millisec) +{ + if (cdriver.func.msleep == NULL) + return; + cdriver.func.msleep(millisec); +} + +static int init_test_register(void) +{ + uint8_t data; + + data = 0x00; + if (device_write(YAS_REGADDR_TEST1, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + data = 0x00; + if (device_write(YAS_REGADDR_TEST2, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + return YAS_NO_ERROR; +} + +static int get_device_id(uint8_t *id) +{ + uint8_t data = 0; + + if (device_read(YAS_REGADDR_DEVICE_ID, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + *id = data; + + return YAS_NO_ERROR; +} + +static int get_cal_data_yas530(struct yas_cal_data *cal) +{ + uint8_t data[16]; +#ifdef YAS_YAS530_CAL_SINGLE_READ + int i; + + for (i = 0; i < 16; i++) { /* dummy read */ + if (device_read(YAS_REGADDR_CAL + i, &data[i], 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + for (i = 0; i < 16; i++) { + if (device_read(YAS_REGADDR_CAL + i, &data[i], 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } +#else + if (device_read(YAS_REGADDR_CAL, data, 16) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (device_read(YAS_REGADDR_CAL, data, 16) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; +#endif + + cal->dx = data[0]; + cal->dy1 = data[1]; + cal->dy2 = data[2]; + cal->d2 = (data[3] >> 2) & 0x03f; + cal->d3 = ((data[3] << 2) & 0x0c) | ((data[4] >> 6) & 0x03); + cal->d4 = data[4] & 0x3f; + cal->d5 = (data[5] >> 2) & 0x3f; + cal->d6 = ((data[5] << 4) & 0x30) | ((data[6] >> 4) & 0x0f); + cal->d7 = ((data[6] << 3) & 0x78) | ((data[7] >> 5) & 0x07); + cal->d8 = ((data[7] << 1) & 0x3e) | ((data[8] >> 7) & 0x01); + cal->d9 = ((data[8] << 1) & 0xfe) | ((data[9] >> 7) & 0x01); + cal->d0 = (data[9] >> 2) & 0x1f; + cal->dck = ((data[9] << 1) & 0x06) | ((data[10] >> 7) & 0x01); + cal->ver = (data[15]) & 0x03; + + return YAS_NO_ERROR; +} + +static void +get_correction_value_yas530(struct yas_cal_data *cal, + struct yas_correction_data *correct) +{ + correct->Cx = cal->dx * 6 - 768; + correct->Cy1 = cal->dy1 * 6 - 768; + correct->Cy2 = cal->dy2 * 6 - 768; + correct->a2 = cal->d2 - 32; + correct->a3 = cal->d3 - 8; + correct->a4 = cal->d4 - 32; + correct->a5 = cal->d5 + 38; + correct->a6 = cal->d6 - 32; + correct->a7 = cal->d7 - 64; + correct->a8 = cal->d8 - 32; + correct->a9 = cal->d9; + correct->k = cal->d0 + 10; +} + +static int get_cal_data_yas532(struct yas_cal_data *cal) +{ + uint8_t data[14]; +#ifdef YAS_YAS530_CAL_SINGLE_READ + int i; + + for (i = 0; i < 14; i++) { /* dummy read */ + if (device_read(YAS_REGADDR_CAL + i, &data[i], 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + for (i = 0; i < 14; i++) { + if (device_read(YAS_REGADDR_CAL + i, &data[i], 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } +#else + if (device_read(YAS_REGADDR_CAL, data, 14) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (device_read(YAS_REGADDR_CAL, data, 14) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; +#endif + + cal->dx = data[0]; + cal->dy1 = data[1]; + cal->dy2 = data[2]; + cal->d2 = (data[3] >> 2) & 0x03f; + cal->d3 = ((data[3] << 2) & 0x0c) | ((data[4] >> 6) & 0x03); + cal->d4 = data[4] & 0x3f; + cal->d5 = (data[5] >> 2) & 0x3f; + cal->d6 = ((data[5] << 4) & 0x30) | ((data[6] >> 4) & 0x0f); + cal->d7 = ((data[6] << 3) & 0x78) | ((data[7] >> 5) & 0x07); + cal->d8 = ((data[7] << 1) & 0x3e) | ((data[8] >> 7) & 0x01); + cal->d9 = ((data[8] << 1) & 0xfe) | ((data[9] >> 7) & 0x01); + cal->d0 = (data[9] >> 2) & 0x1f; + cal->dck = ((data[9] << 1) & 0x06) | ((data[10] >> 7) & 0x01); + cal->ver = (data[13]) & 0x01; + + return YAS_NO_ERROR; +} + +static void +get_correction_value_yas532(struct yas_cal_data *cal, + struct yas_correction_data *correct) +{ + correct->Cx = cal->dx * 10 - 1280; + correct->Cy1 = cal->dy1 * 10 - 1280; + correct->Cy2 = cal->dy2 * 10 - 1280; + correct->a2 = cal->d2 - 32; + correct->a3 = cal->d3 - 8; + correct->a4 = cal->d4 - 32; + correct->a5 = cal->d5 + 38; + correct->a6 = cal->d6 - 32; + correct->a7 = cal->d7 - 64; + correct->a8 = cal->d8 - 32; + correct->a9 = cal->d9; + correct->k = cal->d0; +} + +static int set_configuration(int inton, int inthact, int cck) +{ + uint8_t data = 0; + + data |= (!!inton) & 0x01; + data |= ((!!inthact) << 1) & 0x02; + data |= (cck << 2) & 0x1c; + + if (device_write(YAS_REGADDR_CONFIG, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + return YAS_NO_ERROR; +} + +static int get_measure_interval(int32_t *msec) +{ + uint8_t data; + int mult = 7; + + if (device_read(YAS_REGADDR_MEASURE_INTERVAL, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + switch (cdriver.dev_id) { + case YAS_YAS532_DEVICE_ID: + mult = 4; + break; + case YAS_YAS530_DEVICE_ID: + default: + mult = 7; + break; + } + + *msec = data * mult; + + return YAS_NO_ERROR; +} + +static int set_measure_interval(int32_t msec) +{ + uint8_t data = 0; + int mult = 7; + + switch (cdriver.dev_id) { + case YAS_YAS532_DEVICE_ID: + mult = 4; + break; + case YAS_YAS530_DEVICE_ID: + default: + mult = 7; + break; + } + + if (msec > mult*0xff) + data = 0xff; + else + if (msec % mult == 0) + data = (uint8_t)(msec / mult); + else + data = (uint8_t)(msec / mult + 1); + if (device_write(YAS_REGADDR_MEASURE_INTERVAL, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + return YAS_NO_ERROR; +} + +static int set_measure_command(int ldtc, int fors, int dlymes) +{ + uint8_t data = 0; + + data |= 0x01; /* bit 0 must be 1 */ + data |= ((!(!ldtc)) << 1) & 0x02; + data |= ((!(!fors)) << 2) & 0x04; + data |= ((!(!dlymes)) << 4) & 0x10; + + if (device_write(YAS_REGADDR_MEASURE_COMMAND, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + return YAS_NO_ERROR; +} + +static int +measure_normal_yas530(int *busy, int16_t *t, int16_t *x, int16_t *y1, + int16_t *y2) +{ + uint8_t data[8]; + + if (set_measure_command(0, 0, 0) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + sleep(2); + + if (device_read(YAS_REGADDR_MEASURE_DATA, data, 8) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + *busy = (data[0] >> 7) & 0x01; + *t = (((int32_t) data[0] << 2) & 0x1fc) | ((data[1] >> 6) & 0x03); + *x = (((int32_t) data[2] << 5) & 0xfe0) | ((data[3] >> 3) & 0x1f); + *y1 = (((int32_t) data[4] << 5) & 0xfe0) | ((data[5] >> 3) & 0x1f); + *y2 = (((int32_t) data[6] << 5) & 0xfe0) | ((data[7] >> 3) & 0x1f); + /*YLOGD(("f[%d] t[%d] x[%d] y1[%d] y2[%d]\n", + *busy, *t, *x, *y1, *y2)); */ + + return YAS_NO_ERROR; +} + +static int +measure_normal_yas532(int *busy, int16_t *t, int16_t *x, int16_t *y1, + int16_t *y2) +{ + uint8_t data[8]; + + if (set_measure_command(0, 0, 0) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + sleep(2); + + if (device_read(YAS_REGADDR_MEASURE_DATA, data, 8) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + *busy = (data[0] >> 7) & 0x01; + *t = (((int32_t) data[0] << 3) & 0x3f8) | ((data[1] >> 5) & 0x07); + *x = (((int32_t) data[2] << 6) & 0x1fc0) | ((data[3] >> 2) & 0x3f); + *y1 = (((int32_t) data[4] << 6) & 0x1fc0) | ((data[5] >> 2) & 0x3f); + *y2 = (((int32_t) data[6] << 6) & 0x1fc0) | ((data[7] >> 2) & 0x3f); + /*YLOGD(("f[%d] t[%d] x[%d] y1[%d] y2[%d]\n", + *busy, *t, *x, *y1, *y2)); */ + + return YAS_NO_ERROR; +} + +static int +measure_normal(int *busy, int16_t *t, int16_t *x, int16_t *y1, int16_t *y2) +{ + int result; + + switch (cdriver.dev_id) { + case YAS_YAS532_DEVICE_ID: + result = measure_normal_yas532(busy, t, x, y1, y2); + break; + case YAS_YAS530_DEVICE_ID: + default: + result = measure_normal_yas530(busy, t, x, y1, y2); + break; + } + + return result; +} + +static int +coordinate_conversion(int32_t x, int32_t y1, int32_t y2, int16_t t, + int32_t *xo, int32_t *yo, int32_t *zo, + struct yas_correction_data *c) +{ + int32_t sx, sy1, sy2, sy, sz; + int32_t hx, hy, hz; + + sx = x - (c->Cx * t) / 100; + sy1 = y1 - (c->Cy1 * t) / 100; + sy2 = y2 - (c->Cy2 * t) / 100; + + sy = sy1 - sy2; + sz = -sy1 - sy2; + + hx = c->k * ((100 * sx + c->a2 * sy + c->a3 * sz) / 10); + hy = c->k * ((c->a4 * sx + c->a5 * sy + c->a6 * sz) / 10); + hz = c->k * ((c->a7 * sx + c->a8 * sy + c->a9 * sz) / 10); + + *xo = cdriver.transform[0] * hx + + cdriver.transform[1] * hy + cdriver.transform[2] * hz; + *yo = cdriver.transform[3] * hx + + cdriver.transform[4] * hy + cdriver.transform[5] * hz; + *zo = cdriver.transform[6] * hx + + cdriver.transform[7] * hy + cdriver.transform[8] * hz; + + return YAS_NO_ERROR; +} + +static int +set_hardware_offset(int8_t offset_x, int8_t offset_y1, int8_t offset_y2) +{ + uint8_t data; + + data = offset_x & 0x3f; + if (device_write(YAS_REGADDR_OFFSET_X, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + data = offset_y1 & 0x3f; + if (device_write(YAS_REGADDR_OFFSET_Y1, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + data = offset_y2 & 0x3f; + if (device_write(YAS_REGADDR_OFFSET_Y2, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + return YAS_NO_ERROR; +} + +static int yas_cdrv_actuate_initcoil(void) +{ + uint8_t data = 0; + + if (device_write(YAS_REGADDR_ACTUATE_INIT_COIL, &data, 1) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + return YAS_NO_ERROR; +} + +static int +check_offset(int8_t offset_x, int8_t offset_y1, int8_t offset_y2, + int *flag_x, int *flag_y1, int *flag_y2) +{ + int busy; + int16_t t, x, y1, y2; + + if (set_hardware_offset(offset_x, offset_y1, offset_y2) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (measure_normal(&busy, &t, &x, &y1, &y2) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + *flag_x = *flag_y1 = *flag_y2 = 0; + if (x > cdriver.center) + *flag_x = 1; + if (y1 > cdriver.center) + *flag_y1 = 1; + if (y2 > cdriver.center) + *flag_y2 = 1; + if (x < cdriver.center) + *flag_x = -1; + if (y1 < cdriver.center) + *flag_y1 = -1; + if (y2 < cdriver.center) + *flag_y2 = -1; + + return YAS_NO_ERROR; +} + +static int yas_cdrv_measure_and_set_offset(int8_t *offset) +{ + int i; + int8_t offset_x = 0, offset_y1 = 0, offset_y2 = 0; + int flag_x = 0, flag_y1 = 0, flag_y2 = 0; + static const int correct[5] = { 16, 8, 4, 2, 1 }; + + for (i = 0; i < 5; i++) { + if (check_offset(offset_x, offset_y1, offset_y2, + &flag_x, &flag_y1, &flag_y2) < 0) { + return YAS_ERROR_DEVICE_COMMUNICATION; + } + YLOGD(("offset[%d][%d][%d] flag[%d][%d][%d]\n", + offset_x, offset_y1, offset_y2, + flag_x, flag_y1, flag_y2)); + if (flag_x) + offset_x += flag_x * correct[i]; + if (flag_y1) + offset_y1 += flag_y1 * correct[i]; + if (flag_y2) + offset_y2 += flag_y2 * correct[i]; + } + if (set_hardware_offset(offset_x, offset_y1, offset_y2) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + offset[0] = offset_x; + offset[1] = offset_y1; + offset[2] = offset_y2; + + return YAS_NO_ERROR; +} + +static int yas_cdrv_set_offset(const int8_t *offset) +{ + if (set_hardware_offset(offset[0], offset[1], offset[2]) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + return YAS_NO_ERROR; +} + +static int +yas_cdrv_measure(int32_t *data, int32_t *raw, int16_t *temperature) +{ + int busy; + int16_t x, y1, y2, t; + int32_t xx, yy1, yy2; + int result = 0; + + if (measure_normal(&busy, &t, &x, &y1, &y2) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + if (x == 0) + result |= 0x01; + if (x == cdriver.overflow) + result |= 0x02; + if (y1 == 0) + result |= 0x04; + if (y1 == cdriver.overflow) + result |= 0x08; + if (y2 == 0) + result |= 0x10; + if (y2 == cdriver.overflow) + result |= 0x20; + + xx = x; + yy1 = y1; + yy2 = y2; + + if (coordinate_conversion(xx, yy1, yy2, t, &data[0], &data[1], + &data[2], &cdriver.correct) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + cdriver.temperature = t; + + if (raw != NULL) + raw[0] = xx, raw[1] = yy1, raw[2] = yy2; + if (temperature != NULL) + *temperature = t; + + return result; +} + +static int +yas_cdrv_recalc_calib_offset(int32_t *prev_calib_offset, + int32_t *new_calib_offset, + int8_t *prev_offset, int8_t *new_offset) +{ + int32_t tmp[3], resolution[9], base[3]; + int32_t raw[3]; + int32_t diff, i; + + if (prev_calib_offset == NULL || new_calib_offset == NULL + || prev_offset == NULL || new_offset == NULL) + return YAS_ERROR_ARG; + + raw[0] = raw[1] = raw[2] = 0; + if (coordinate_conversion(raw[0], raw[1], raw[2], cdriver.temperature, + &base[0], &base[1], &base[2], + &cdriver.correct) < 0) + return YAS_ERROR_ERROR; + for (i = 0; i < 3; i++) { + raw[0] = raw[1] = raw[2] = 0; + raw[i] = cdriver.coef; + if (coordinate_conversion(raw[0], raw[1], raw[2], + cdriver.temperature, + &resolution[i * 3 + 0], + &resolution[i * 3 + 1], + &resolution[i * 3 + 2], + &cdriver.correct) < 0) + return YAS_ERROR_ERROR; + resolution[i * 3 + 0] -= base[0]; + resolution[i * 3 + 1] -= base[1]; + resolution[i * 3 + 2] -= base[2]; + } + + for (i = 0; i < 3; i++) + tmp[i] = prev_calib_offset[i]; + + for (i = 0; i < 3; i++) { + diff = (int32_t) new_offset[i] - (int32_t) prev_offset[i]; + while (diff > 0) { + tmp[0] -= resolution[i * 3 + 0]; + tmp[1] -= resolution[i * 3 + 1]; + tmp[2] -= resolution[i * 3 + 2]; + diff--; + } + while (diff < 0) { + tmp[0] += resolution[i * 3 + 0]; + tmp[1] += resolution[i * 3 + 1]; + tmp[2] += resolution[i * 3 + 2]; + diff++; + } + } + for (i = 0; i < 3; i++) + new_calib_offset[i] = tmp[i]; + + return YAS_NO_ERROR; +} + +static int yas_cdrv_set_transformatiom_matrix(const int8_t *transform) +{ + int i; + + if (transform == NULL) + return YAS_ERROR_ARG; + for (i = 0; i < 9; i++) + cdriver.transform[i] = transform[i]; + + return YAS_NO_ERROR; +} + +static int +yas_cdrv_init(const int8_t *transform, struct yas_machdep_func *func) +{ + int interval, i; + uint8_t id; + + if (transform == NULL || func == NULL) + return YAS_ERROR_ARG; + + for (i = 0; i < 9; i++) + cdriver.transform[i] = transform[i]; + + cdriver.func = *func; + + if (device_open() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + if (init_test_register() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + if (get_device_id(&id) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + YLOGD(("device id:%02x\n", id)); + + switch (id) { + case YAS_YAS530_DEVICE_ID: + if (get_cal_data_yas530(&cdriver.cal) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + + get_correction_value_yas530(&cdriver.cal, &cdriver.correct); + cdriver.center = YAS_YAS530_DATA_CENTER; + cdriver.overflow = YAS_YAS530_DATA_OVERFLOW; + switch (cdriver.cal.ver) { + case YAS_YAS530_VERSION_B: + cdriver.coef = YAS_YAS530_VERSION_B_COEF; + break; + case YAS_YAS530_VERSION_A: + default: + cdriver.coef = YAS_YAS530_VERSION_A_COEF; + break; + } + break; + + case YAS_YAS532_DEVICE_ID: + if (get_cal_data_yas532(&cdriver.cal) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + get_correction_value_yas532(&cdriver.cal, &cdriver.correct); + cdriver.center = YAS_YAS532_DATA_CENTER; + cdriver.overflow = YAS_YAS532_DATA_OVERFLOW; + switch (cdriver.cal.ver) { + case YAS_YAS532_VERSION_AC: + cdriver.coef = YAS_YAS532_VERSION_AC_COEF; + break; + case YAS_YAS532_VERSION_AB: + default: + cdriver.coef = YAS_YAS532_VERSION_AB_COEF; + break; + } + break; + + default: + return YAS_ERROR_DEVICE_COMMUNICATION; + } + cdriver.dev_id = id; + + if (set_configuration(0, 0, cdriver.cal.dck) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (set_measure_interval(0) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (get_measure_interval(&interval) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + YLOGD(("interval[%d]\n", interval)); + + return YAS_NO_ERROR; +} + +static int yas_cdrv_term(void) +{ + device_close(); + return YAS_NO_ERROR; +} + +#define YAS_DEFAULT_CALIB_INTERVAL (50) /* 50 msecs */ +#define YAS_DEFAULT_DATA_INTERVAL (200) /* 200 msecs */ +#define YAS_INITCOIL_INTERVAL (200) /* 200 msec */ +#define YAS_INITCOIL_GIVEUP_INTERVAL (180000) /* 180 seconds */ +#define YAS_DETECT_OVERFLOW_INTERVAL (0) /* 0 second */ + +#define YAS_MAG_ERROR_DELAY (200) +#define YAS_MAG_STATE_NORMAL (0) +#define YAS_MAG_STATE_INIT_COIL (1) +#define YAS_MAG_STATE_MEASURE_OFFSET (2) + +static const int8_t YAS_TRANSFORMATION[][9] = { + {0, 1, 0, -1, 0, 0, 0, 0, 1}, + {-1, 0, 0, 0, -1, 0, 0, 0, 1}, + {0, -1, 0, 1, 0, 0, 0, 0, 1}, + {1, 0, 0, 0, 1, 0, 0, 0, 1}, + {0, -1, 0, -1, 0, 0, 0, 0, -1}, + {1, 0, 0, 0, -1, 0, 0, 0, -1}, + {0, 1, 0, 1, 0, 0, 0, 0, -1}, + {-1, 0, 0, 0, 1, 0, 0, 0, -1}, +}; + +static const int supported_data_interval[] = { 10, 20, 50, 60, 100, 200, 1000 }; +static const int supported_calib_interval[] = { 60, 60, 50, 60, 50, 50, 50 }; +static const int32_t INVALID_CALIB_OFFSET[] = { 0x7fffffff, + 0x7fffffff, 0x7fffffff }; +static const int8_t INVALID_OFFSET[] = { 0x7f, 0x7f, 0x7f }; + +struct yas_adaptive_filter { + int num; + int index; + int filter_len; + int filter_noise; + int32_t sequence[YAS_MAG_MAX_FILTER_LEN]; +}; + +struct yas_thresh_filter { + int32_t threshold; + int32_t last; +}; + +struct yas_driver { + int initialized; + struct yas_mag_driver_callback callback; + struct utimer data_timer; + struct utimer initcoil_timer; + struct utimer initcoil_giveup_timer; + struct utimer detect_overflow_timer; + int32_t prev_mag[3]; + int32_t prev_xy1y2[3]; + int32_t prev_mag_w_offset[3]; + int16_t prev_temperature; + int measure_state; + int active; + int overflow; + int initcoil_gaveup; + int position; + int delay_timer_use_data; + int delay_timer_interval; + int delay_timer_counter; + int filter_enable; + int filter_len; + int filter_thresh; + int filter_noise[3]; + struct yas_adaptive_filter adap_filter[3]; + struct yas_thresh_filter thresh_filter[3]; + struct yas_mag_offset offset; +#ifdef YAS_MAG_MANUAL_OFFSET + struct yas_vector manual_offset; +#endif + struct yas_matrix static_matrix; + struct yas_matrix dynamic_matrix; +}; + +static struct yas_driver this_driver; + +static int lock(void) +{ + if (this_driver.callback.lock != NULL) { + if (this_driver.callback.lock() < 0) + return YAS_ERROR_RESTARTSYS; + } + return 0; +} + +static int unlock(void) +{ + if (this_driver.callback.unlock != NULL) { + if (this_driver.callback.unlock() < 0) + return YAS_ERROR_RESTARTSYS; + } + return 0; +} + +static int32_t square(int32_t data) +{ + return data * data; +} + +static void +adaptive_filter_init(struct yas_adaptive_filter *adap_filter, int len, + int noise) +{ + int i; + + adap_filter->num = 0; + adap_filter->index = 0; + adap_filter->filter_noise = noise; + adap_filter->filter_len = len; + + for (i = 0; i < adap_filter->filter_len; ++i) + adap_filter->sequence[i] = 0; +} + +static int32_t +adaptive_filter_filter(struct yas_adaptive_filter *adap_filter, int32_t in) +{ + int32_t avg, sum; + int i; + + if (adap_filter->filter_len == 0) + return in; + + if (adap_filter->num < adap_filter->filter_len) { + adap_filter->sequence[adap_filter->index++] = in / 100; + adap_filter->num++; + return in; + } + if (adap_filter->filter_len <= adap_filter->index) + adap_filter->index = 0; + + adap_filter->sequence[adap_filter->index++] = in / 100; + + avg = 0; + for (i = 0; i < adap_filter->filter_len; i++) + avg += adap_filter->sequence[i]; + + avg /= adap_filter->filter_len; + + sum = 0; + for (i = 0; i < adap_filter->filter_len; i++) + sum += square(avg - adap_filter->sequence[i]); + + sum /= adap_filter->filter_len; + + if (sum <= adap_filter->filter_noise) + return avg * 100; + + return ((in / 100 - avg) * (sum - adap_filter->filter_noise) / sum + + avg) * 100; +} + +static void +thresh_filter_init(struct yas_thresh_filter *thresh_filter, int threshold) +{ + thresh_filter->threshold = threshold; + thresh_filter->last = 0; +} + +static int32_t +thresh_filter_filter(struct yas_thresh_filter *thresh_filter, int32_t in) +{ + if (in < thresh_filter->last - thresh_filter->threshold + || thresh_filter->last + thresh_filter->threshold < in) { + thresh_filter->last = in; + return in; + } else + return thresh_filter->last; +} + +static void filter_init(struct yas_driver *d) +{ + int i; + + for (i = 0; i < 3; i++) { + adaptive_filter_init(&d->adap_filter[i], d->filter_len, + d->filter_noise[i]); + thresh_filter_init(&d->thresh_filter[i], d->filter_thresh); + } +} + +static void +filter_filter(struct yas_driver *d, int32_t *orig, int32_t *filtered) +{ + int i; + + for (i = 0; i < 3; i++) { + filtered[i] = + adaptive_filter_filter(&d->adap_filter[i], orig[i]); + filtered[i] = + thresh_filter_filter(&d->thresh_filter[i], filtered[i]); + } +} + +static int is_valid_offset(const int8_t *p) +{ + return (p != NULL && (p[0] <= 31) && (p[1] <= 31) && (p[2] <= 31) + && (-31 <= p[0]) && (-31 <= p[1]) && (-31 <= p[2])); +} + +static int is_valid_calib_offset(const int32_t *p) +{ + int i; + for (i = 0; i < 3; i++) { + if (p[i] != INVALID_CALIB_OFFSET[i]) + return 1; + } + return 0; +} + +static int is_offset_differ(const int8_t *p0, const int8_t *p1) +{ + if (p0[0] != p1[0] || p0[1] != p1[1] || p0[2] != p1[2]) + return 1; + else + return 0; +} + +static int is_calib_offset_differ(const int32_t *p0, const int32_t *p1) +{ + if (p0[0] != p1[0] || p0[1] != p1[1] || p0[2] != p1[2]) + return 1; + else + return 0; +} + +static int get_overflow(struct yas_driver *d) +{ + return d->overflow; +} + +static void set_overflow(struct yas_driver *d, const int overflow) +{ + if (d->overflow != overflow) + d->overflow = overflow; +} + +static int get_initcoil_gaveup(struct yas_driver *d) +{ + return d->initcoil_gaveup; +} + +static void set_initcoil_gaveup(struct yas_driver *d, const int initcoil_gaveup) +{ + d->initcoil_gaveup = initcoil_gaveup; +} + +static int32_t *get_calib_offset(struct yas_driver *d) +{ + return d->offset.calib_offset.v; +} + +static void set_calib_offset(struct yas_driver *d, const int32_t *offset) +{ + int i; + + if (is_calib_offset_differ(d->offset.calib_offset.v, offset)) { + for (i = 0; i < 3; i++) + d->offset.calib_offset.v[i] = offset[i]; + } +} + +#ifdef YAS_MAG_MANUAL_OFFSET +static int32_t *get_manual_offset(struct yas_driver *d) +{ + return d->manual_offset.v; +} + +static void set_manual_offset(struct yas_driver *d, const int32_t *offset) +{ + int i; + + for (i = 0; i < 3; i++) + d->manual_offset.v[i] = offset[i]; +} +#endif + +static int32_t *get_static_matrix(struct yas_driver *d) +{ + return d->static_matrix.matrix; +} + +static void set_static_matrix(struct yas_driver *d, const int32_t *matrix) +{ + int i; + + for (i = 0; i < 9; i++) + d->static_matrix.matrix[i] = matrix[i]; +} + +static int32_t *get_dynamic_matrix(struct yas_driver *d) +{ + return d->dynamic_matrix.matrix; +} + +static void set_dynamic_matrix(struct yas_driver *d, const int32_t *matrix) +{ + int i; + + for (i = 0; i < 9; i++) + d->dynamic_matrix.matrix[i] = matrix[i]; +} + +static int8_t *get_offset(struct yas_driver *d) +{ + return d->offset.hard_offset; +} + +static void set_offset(struct yas_driver *d, const int8_t *offset) +{ + int i; + + if (is_offset_differ(d->offset.hard_offset, offset)) { + for (i = 0; i < 3; i++) + d->offset.hard_offset[i] = offset[i]; + } +} + +static int get_active(struct yas_driver *d) +{ + return d->active; +} + +static void set_active(struct yas_driver *d, const int active) +{ + d->active = active; +} + +static int get_position(struct yas_driver *d) +{ + return d->position; +} + +static void set_position(struct yas_driver *d, const int position) +{ + d->position = position; +} + +static int get_measure_state(struct yas_driver *d) +{ + return d->measure_state; +} + +static void set_measure_state(struct yas_driver *d, const int state) +{ + d->measure_state = state; +} + +static struct utimer *get_data_timer(struct yas_driver *d) +{ + return &d->data_timer; +} + +static struct utimer *get_initcoil_timer(struct yas_driver *d) +{ + return &d->initcoil_timer; +} + +static struct utimer *get_initcoil_giveup_timer(struct yas_driver *d) +{ + return &d->initcoil_giveup_timer; +} + +static struct utimer *get_detect_overflow_timer(struct yas_driver *d) +{ + return &d->detect_overflow_timer; +} + +static int get_delay_timer_use_data(struct yas_driver *d) +{ + return d->delay_timer_use_data; +} + +static void set_delay_timer_use_data(struct yas_driver *d, int flag) +{ + d->delay_timer_use_data = !(!flag); +} + +static int get_delay_timer_interval(struct yas_driver *d) +{ + return d->delay_timer_interval; +} + +static void set_delay_timer_interval(struct yas_driver *d, int interval) +{ + d->delay_timer_interval = interval; +} + +static int get_delay_timer_counter(struct yas_driver *d) +{ + return d->delay_timer_counter; +} + +static void set_delay_timer_counter(struct yas_driver *d, int counter) +{ + d->delay_timer_counter = counter; +} + +static int get_filter_enable(struct yas_driver *d) +{ + return d->filter_enable; +} + +static void set_filter_enable(struct yas_driver *d, int enable) +{ + if (enable) + filter_init(d); + + d->filter_enable = !(!enable); +} + +static int get_filter_len(struct yas_driver *d) +{ + return d->filter_len; +} + +static void set_filter_len(struct yas_driver *d, int len) +{ + if (len < 0) + return; + + if (len > YAS_MAG_MAX_FILTER_LEN) + return; + + d->filter_len = len; + filter_init(d); +} + +static int get_filter_noise(struct yas_driver *d, int *noise) +{ + int i; + + for (i = 0; i < 3; i++) + noise[i] = d->filter_noise[i]; + + return 0; +} + +static void set_filter_noise(struct yas_driver *d, int *noise) +{ + int i; + + if (noise == NULL) + return; + + for (i = 0; i < 3; i++) { + if (noise[i] < 0) + noise[i] = 0; + + d->filter_noise[i] = noise[i]; + } + filter_init(d); +} + +static int get_filter_thresh(struct yas_driver *d) +{ + return d->filter_thresh; +} + +static void set_filter_thresh(struct yas_driver *d, int threshold) +{ + if (threshold < 0) + return; + + d->filter_thresh = threshold; + filter_init(d); +} + +static int32_t *get_previous_mag(struct yas_driver *d) +{ + return d->prev_mag; +} + +static void set_previous_mag(struct yas_driver *d, int32_t *data) +{ + int i; + for (i = 0; i < 3; i++) + d->prev_mag[i] = data[i]; +} + +static int32_t *get_previous_xy1y2(struct yas_driver *d) +{ + return d->prev_xy1y2; +} + +static void set_previous_xy1y2(struct yas_driver *d, int32_t *data) +{ + int i; + for (i = 0; i < 3; i++) + d->prev_xy1y2[i] = data[i]; +} + +static int32_t *get_previous_mag_w_offset(struct yas_driver *d) +{ + return d->prev_mag_w_offset; +} + +static void set_previous_mag_w_offset(struct yas_driver *d, int32_t *data) +{ + int i; + for (i = 0; i < 3; i++) + d->prev_mag_w_offset[i] = data[i]; +} + +static int16_t get_previous_temperature(struct yas_driver *d) +{ + return d->prev_temperature; +} + +static void set_previous_temperature(struct yas_driver *d, int16_t temperature) +{ + d->prev_temperature = temperature; +} + +static int init_coil(struct yas_driver *d) +{ + int rt; + + YLOGD(("init_coil IN\n")); + + utimer_update(get_initcoil_timer(d)); + if (!get_initcoil_gaveup(d)) { + utimer_update(get_initcoil_giveup_timer(d)); + if (utimer_is_timeout(get_initcoil_giveup_timer(d))) { + utimer_clear_timeout(get_initcoil_giveup_timer(d)); + set_initcoil_gaveup(d, TRUE); + } + } + if (utimer_is_timeout(get_initcoil_timer(d)) && + !get_initcoil_gaveup(d)) { + utimer_clear_timeout(get_initcoil_timer(d)); + YLOGI(("init_coil!\n")); + rt = yas_cdrv_actuate_initcoil(); + if (rt < 0) { + YLOGE(("yas_cdrv_actuate_initcoil failed[%d]\n", rt)); + return rt; + } + if (get_overflow(d) || !is_valid_offset(get_offset(d))) + set_measure_state(d, YAS_MAG_STATE_MEASURE_OFFSET); + else + set_measure_state(d, YAS_MAG_STATE_NORMAL); + } + + YLOGD(("init_coil OUT\n")); + + return 0; +} + +static int measure_offset(struct yas_driver *d) +{ + int8_t offset[3]; + int32_t moffset[3]; + int rt, result = 0, i; + + YLOGI(("measure_offset IN\n")); + rt = yas_cdrv_measure_and_set_offset(offset); + if (rt < 0) { + YLOGE(("yas_cdrv_measure_offset failed[%d]\n", rt)); + return rt; + } + + YLOGI(("offset[%d][%d][%d]\n", offset[0], offset[1], offset[2])); + + for (i = 0; i < 3; i++) + moffset[i] = get_calib_offset(d)[i]; + + if (is_offset_differ(get_offset(d), offset)) { + if (is_valid_offset(get_offset(d)) + && is_valid_calib_offset(get_calib_offset(d))) { + yas_cdrv_recalc_calib_offset(get_calib_offset(d), + moffset, + get_offset(d), offset); + result |= YAS_REPORT_CALIB_OFFSET_CHANGED; + } + } + result |= YAS_REPORT_HARD_OFFSET_CHANGED; + + set_offset(d, offset); + if (is_valid_calib_offset(moffset)) + set_calib_offset(d, moffset); + + set_measure_state(d, YAS_MAG_STATE_NORMAL); + + YLOGI(("measure_offset OUT\n")); + + return result; +} + +static int +measure_msensor_normal(struct yas_driver *d, int32_t *magnetic, + int32_t *mag_w_offset, int32_t * xy1y2, + int16_t *temperature) +{ + int rt = 0, result, i; + int32_t tmp[3]; + + YLOGD(("measure_msensor_normal IN\n")); + + result = 0; + rt = yas_cdrv_measure(mag_w_offset, tmp, temperature); + if (rt < 0) { + YLOGE(("yas_cdrv_measure failed[%d]\n", rt)); + return rt; + } + for (i = 0; i < 3; i++) + xy1y2[i] = tmp[i]; + +#ifdef YAS_MAG_MANUAL_OFFSET + for (i = 0; i < 3; i++) + mag_w_offset[i] -= get_manual_offset(d)[i]; +#endif + if (rt > 0) { + utimer_update(get_detect_overflow_timer(d)); + set_overflow(d, TRUE); + if (utimer_is_timeout(get_detect_overflow_timer(d))) { + utimer_clear_timeout(get_detect_overflow_timer(d)); + result |= YAS_REPORT_OVERFLOW_OCCURED; + } + if (get_measure_state(d) == YAS_MAG_STATE_NORMAL) + set_measure_state(d, YAS_MAG_STATE_INIT_COIL); + + } else { + utimer_clear(get_detect_overflow_timer(d)); + set_overflow(d, FALSE); + if (get_measure_state(d) == YAS_MAG_STATE_NORMAL) { + utimer_clear(get_initcoil_timer(d)); + utimer_clear(get_initcoil_giveup_timer(d)); + } + } + + for (i = 0; i < 3; i++) { + tmp[i] + = (get_static_matrix(d)[i * 3 + 0] / 10 * + (mag_w_offset[0] / 10)) / 100 + + (get_static_matrix(d)[i * 3 + 1] / 10 * + (mag_w_offset[1] / 10)) / 100 + + (get_static_matrix(d)[i * 3 + 2] / 10 * + (mag_w_offset[2] / 10)) / 100; + } + for (i = 0; i < 3; i++) + magnetic[i] = mag_w_offset[i] = tmp[i]; + if (is_valid_calib_offset(get_calib_offset(d))) { + for (i = 0; i < 3; i++) + magnetic[i] -= get_calib_offset(d)[i]; + } + for (i = 0; i < 3; i++) { + tmp[i] + = (get_dynamic_matrix(d)[i * 3 + 0] / 10 * + (magnetic[0] / 10)) / 100 + + (get_dynamic_matrix(d)[i * 3 + 1] / 10 * + (magnetic[1] / 10)) / 100 + (get_dynamic_matrix(d)[i * 3 + + 2] / + 10 * (magnetic[2] / 10)) / + 100; + } + for (i = 0; i < 3; i++) + magnetic[i] = tmp[i]; + + if (get_filter_enable(d)) + filter_filter(d, magnetic, magnetic); + + YLOGD(("measure_msensor_normal OUT\n")); + + return result; +} + +static int +measure_msensor(struct yas_driver *d, int32_t *magnetic, + int32_t *mag_w_offset, int32_t *xy1y2, int16_t *temperature) +{ + int result, i; + + YLOGD(("measure_msensor IN\n")); + + for (i = 0; i < 3; i++) { + magnetic[i] = get_previous_mag(d)[i]; + mag_w_offset[i] = get_previous_mag_w_offset(d)[i]; + xy1y2[i] = get_previous_xy1y2(d)[i]; + *temperature = get_previous_temperature(d); + } + + result = 0; + switch (get_measure_state(d)) { + case YAS_MAG_STATE_INIT_COIL: + result = init_coil(d); + break; + case YAS_MAG_STATE_MEASURE_OFFSET: + result = measure_offset(d); + break; + case YAS_MAG_STATE_NORMAL: + result = 0; + break; + default: + result = -1; + break; + } + + if (result < 0) + return result; + + if (!(result & YAS_REPORT_OVERFLOW_OCCURED)) + result |= + measure_msensor_normal(d, magnetic, mag_w_offset, xy1y2, + temperature); + set_previous_mag(d, magnetic); + set_previous_xy1y2(d, xy1y2); + set_previous_mag_w_offset(d, mag_w_offset); + set_previous_temperature(d, *temperature); + + YLOGD(("measure_msensor OUT\n")); + + return result; +} + +static int +measure(struct yas_driver *d, int32_t *magnetic, int32_t *mag_w_offset, + int32_t *xy1y2, int16_t *temperature, uint32_t *time_delay) +{ + int result; + int counter; + uint32_t total = 0; + + YLOGD(("measure IN\n")); + + utimer_update(get_data_timer(d)); + result = measure_msensor(d, magnetic, mag_w_offset, xy1y2, + temperature); + if (result < 0) + return result; + + counter = get_delay_timer_counter(d); + total = utimer_get_total_time(get_data_timer(d)); + if (utimer_get_delay(get_data_timer(d)) > 0) + counter -= total / utimer_get_delay(get_data_timer(d)); + else + counter = 0; + + if (utimer_is_timeout(get_data_timer(d))) { + utimer_clear_timeout(get_data_timer(d)); + + if (get_delay_timer_use_data(d)) { + result |= YAS_REPORT_DATA; + if (counter <= 0) + result |= YAS_REPORT_CALIB; + } else { + result |= YAS_REPORT_CALIB; + if (counter <= 0) + result |= YAS_REPORT_DATA; + } + } + + if (counter <= 0) + set_delay_timer_counter(d, get_delay_timer_interval(d)); + else + set_delay_timer_counter(d, counter); + + *time_delay = utimer_sleep_time(get_data_timer(d)); + + YLOGD(("measure OUT [%d]\n", result)); + + return result; +} + +static int resume(struct yas_driver *d) +{ + int32_t zero[] = { 0, 0, 0 }; + struct yas_machdep_func func; + int rt; + + YLOGI(("resume IN\n")); + + func.device_open = d->callback.device_open; + func.device_close = d->callback.device_close; + func.device_write = d->callback.device_write; + func.device_read = d->callback.device_read; + func.msleep = d->callback.msleep; + + rt = + yas_cdrv_init(YAS_TRANSFORMATION[get_position(d)], &func); + + if (rt < 0) { + YLOGE(("yas_cdrv_init failed[%d]\n", rt)); + return rt; + } + + utimer_clear(get_data_timer(d)); + utimer_clear(get_initcoil_giveup_timer(d)); + utimer_clear(get_initcoil_timer(d)); + utimer_clear(get_detect_overflow_timer(d)); + + set_previous_mag(d, zero); + set_previous_xy1y2(d, zero); + set_previous_mag_w_offset(d, zero); + set_previous_temperature(d, 0); + set_overflow(d, FALSE); + set_initcoil_gaveup(d, FALSE); + + filter_init(d); + + if (is_valid_offset(d->offset.hard_offset)) { + yas_cdrv_set_offset(d->offset.hard_offset); + rt = yas_cdrv_actuate_initcoil(); + if (rt < 0) { + YLOGE(("yas_cdrv_actuate_initcoil failed[%d]\n", rt)); + set_measure_state(d, YAS_MAG_STATE_INIT_COIL); + } else + set_measure_state(d, YAS_MAG_STATE_NORMAL); + } else { + rt = yas_cdrv_actuate_initcoil(); + if (rt < 0) { + YLOGE(("yas_cdrv_actuate_initcoil failed[%d]\n", rt)); + set_measure_state(d, YAS_MAG_STATE_INIT_COIL); + } else + set_measure_state(d, YAS_MAG_STATE_MEASURE_OFFSET); + } + + YLOGI(("resume OUT\n")); + return 0; +} + +static int suspend(struct yas_driver *d) +{ + YLOGI(("suspend IN\n")); + + (void)d; + yas_cdrv_term(); + + YLOGI(("suspend OUT\n")); + return 0; +} + +static int check_interval(int ms) +{ + int index = -1; + + if (ms <= supported_data_interval[0]) + ms = supported_data_interval[0]; + for (index = 0; index < NELEMS(supported_data_interval); index++) { + if (ms == supported_data_interval[index]) + goto done; + else if (ms < supported_data_interval[index]) { + if (index != 0) + index -= 1; + goto done; + } + } +done: + return index; +} + +static int yas_get_delay_nolock(struct yas_driver *d, int *ms) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + if (get_delay_timer_use_data(d)) + *ms = utimer_get_delay(get_data_timer(d)); + else { + *ms = + utimer_get_delay(get_data_timer(d)) * + get_delay_timer_interval(d); + } + return YAS_NO_ERROR; +} + +static int yas_set_delay_nolock(struct yas_driver *d, int ms) +{ + int index; + uint32_t delay_data, delay_calib; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + index = check_interval(ms); + if (index < 0) + return YAS_ERROR_ARG; + delay_data = supported_data_interval[index]; + delay_calib = supported_calib_interval[index]; + set_delay_timer_use_data(d, delay_data < delay_calib); + if (delay_data < delay_calib) { + set_delay_timer_interval(d, delay_calib / delay_data); + set_delay_timer_counter(d, delay_calib / delay_data); + utimer_set_delay(get_data_timer(d), + supported_data_interval[index]); + } else { + set_delay_timer_interval(d, delay_data / delay_calib); + set_delay_timer_counter(d, delay_data / delay_calib); + utimer_set_delay(get_data_timer(d), + supported_calib_interval[index]); + } + + return YAS_NO_ERROR; +} + +static int +yas_get_offset_nolock(struct yas_driver *d, struct yas_mag_offset *offset) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + *offset = d->offset; + return YAS_NO_ERROR; +} + +static int +yas_set_offset_nolock(struct yas_driver *d, struct yas_mag_offset *offset) +{ + int32_t zero[] = { 0, 0, 0 }; + int rt; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + if (!get_active(d)) { + d->offset = *offset; + return YAS_NO_ERROR; + } + + if (!is_valid_offset(offset->hard_offset) + || is_offset_differ(offset->hard_offset, d->offset.hard_offset)) { + filter_init(d); + + utimer_clear(get_data_timer(d)); + utimer_clear(get_initcoil_giveup_timer(d)); + utimer_clear(get_initcoil_timer(d)); + utimer_clear(get_detect_overflow_timer(d)); + + set_previous_mag(d, zero); + set_previous_xy1y2(d, zero); + set_previous_mag_w_offset(d, zero); + set_previous_temperature(d, 0); + set_overflow(d, FALSE); + set_initcoil_gaveup(d, FALSE); + } + d->offset = *offset; + + if (is_valid_offset(d->offset.hard_offset)) + yas_cdrv_set_offset(d->offset.hard_offset); + else { + rt = yas_cdrv_actuate_initcoil(); + if (rt < 0) { + YLOGE(("yas_cdrv_actuate_initcoil failed[%d]\n", rt)); + set_measure_state(d, YAS_MAG_STATE_INIT_COIL); + } else + set_measure_state(d, YAS_MAG_STATE_MEASURE_OFFSET); + } + + return YAS_NO_ERROR; +} + +#ifdef YAS_MAG_MANUAL_OFFSET + +static int +yas_get_manual_offset_nolock(struct yas_driver *d, struct yas_vector *offset) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + *offset = d->manual_offset; + + return YAS_NO_ERROR; +} + +static int +yas_set_manual_offset_nolock(struct yas_driver *d, struct yas_vector *offset) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + set_manual_offset(d, offset->v); + + return YAS_NO_ERROR; +} + +#endif + +static int +yas_get_static_matrix_nolock(struct yas_driver *d, struct yas_matrix *matrix) +{ + int i; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + for (i = 0; i < 9; i++) + matrix->matrix[i] = get_static_matrix(d)[i]; + + return YAS_NO_ERROR; +} + +static int +yas_set_static_matrix_nolock(struct yas_driver *d, struct yas_matrix *matrix) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + set_static_matrix(d, matrix->matrix); + + return YAS_NO_ERROR; +} + +static int +yas_get_dynamic_matrix_nolock(struct yas_driver *d, struct yas_matrix *matrix) +{ + int i; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + for (i = 0; i < 9; i++) + matrix->matrix[i] = get_dynamic_matrix(d)[i]; + + return YAS_NO_ERROR; +} + +static int +yas_set_dynamic_matrix_nolock(struct yas_driver *d, struct yas_matrix *matrix) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + set_dynamic_matrix(d, matrix->matrix); + + return YAS_NO_ERROR; +} + +static int yas_get_enable_nolock(struct yas_driver *d) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + return get_active(d); +} + +static int yas_set_enable_nolock(struct yas_driver *d, int active) +{ + int rt; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + if (active) { + if (get_active(d)) + return YAS_NO_ERROR; + rt = resume(d); + if (rt < 0) + return rt; + set_active(d, TRUE); + } else { + if (!get_active(d)) + return YAS_NO_ERROR; + rt = suspend(d); + if (rt < 0) + return rt; + set_active(d, FALSE); + } + return YAS_NO_ERROR; +} + +static int +yas_get_filter_nolock(struct yas_driver *d, struct yas_mag_filter *filter) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + filter->len = get_filter_len(d); + get_filter_noise(d, filter->noise); + filter->threshold = get_filter_thresh(d); + return YAS_NO_ERROR; +} + +static int +yas_set_filter_nolock(struct yas_driver *d, struct yas_mag_filter *filter) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + set_filter_len(d, filter->len); + set_filter_noise(d, filter->noise); + set_filter_thresh(d, filter->threshold); + return YAS_NO_ERROR; +} + +static int yas_get_filter_enable_nolock(struct yas_driver *d) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + return get_filter_enable(d); +} + +static int yas_set_filter_enable_nolock(struct yas_driver *d, int enable) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + set_filter_enable(d, enable); + return YAS_NO_ERROR; +} + +static int yas_get_position_nolock(struct yas_driver *d, int *position) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + *position = get_position(d); + return YAS_NO_ERROR; +} + +static int yas_set_position_nolock(struct yas_driver *d, int position) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + if (get_active(d)) + yas_cdrv_set_transformatiom_matrix(YAS_TRANSFORMATION + [position]); + set_position(d, position); + filter_init(d); + return YAS_NO_ERROR; +} + +static int +yas_read_reg_nolock(struct yas_driver *d, uint8_t addr, uint8_t * buf, int len) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + if (!get_active(d)) { + if (d->callback.device_open() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + if (d->callback.device_read(addr, buf, len) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (!get_active(d)) { + if (d->callback.device_close() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + + return YAS_NO_ERROR; +} + +static int +yas_write_reg_nolock(struct yas_driver *d, uint8_t addr, const uint8_t * buf, + int len) +{ + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + if (!get_active(d)) { + if (d->callback.device_open() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + if (d->callback.device_write(addr, buf, len) < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + if (!get_active(d)) { + if (d->callback.device_close() < 0) + return YAS_ERROR_DEVICE_COMMUNICATION; + } + + return YAS_NO_ERROR; +} + +static int +yas_measure_nolock(struct yas_driver *d, struct yas_mag_data *data, + int *time_delay_ms) +{ + uint32_t time_delay = YAS_MAG_ERROR_DELAY; + int rt, i; + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + *time_delay_ms = YAS_MAG_ERROR_DELAY; + + if (!get_active(d)) { + for (i = 0; i < 3; i++) { + data->xyz.v[i] = get_previous_mag(d)[i]; + data->raw.v[i] = get_previous_mag_w_offset(d)[i]; + data->xy1y2.v[i] = get_previous_xy1y2(d)[i]; + } + data->temperature = get_previous_temperature(d); + return YAS_NO_ERROR; + } + + rt = measure(d, data->xyz.v, data->raw.v, data->xy1y2.v, + &data->temperature, &time_delay); + if (rt >= 0) { + *time_delay_ms = time_delay; + if (*time_delay_ms > 0) + *time_delay_ms += 1; + } + + return rt; +} + +static int yas_init_nolock(struct yas_driver *d) +{ +#ifdef YAS_MAG_MANUAL_OFFSET + int32_t zero[] = { 0, 0, 0 }; +#endif + int32_t notransform[] = { 10000, 0, 0, 0, 10000, 0, 0, 0, 10000 }; + int noise[] = { + YAS_MAG_DEFAULT_FILTER_NOISE_X, + YAS_MAG_DEFAULT_FILTER_NOISE_Y, + YAS_MAG_DEFAULT_FILTER_NOISE_Z + }; + + YLOGI(("yas_init_nolock IN\n")); + + utimer_lib_init(this_driver.callback.current_time); + utimer_init(get_data_timer(d), 50); + utimer_init(get_initcoil_timer(d), YAS_INITCOIL_INTERVAL); + utimer_init(get_initcoil_giveup_timer(d), YAS_INITCOIL_GIVEUP_INTERVAL); + utimer_init(get_detect_overflow_timer(d), YAS_DETECT_OVERFLOW_INTERVAL); + + set_delay_timer_use_data(d, 0); + set_delay_timer_interval(d, + YAS_DEFAULT_DATA_INTERVAL / + YAS_DEFAULT_CALIB_INTERVAL); + set_delay_timer_counter(d, + YAS_DEFAULT_DATA_INTERVAL / + YAS_DEFAULT_CALIB_INTERVAL); + + set_filter_enable(d, FALSE); + set_filter_len(d, YAS_MAG_DEFAULT_FILTER_LEN); + set_filter_thresh(d, YAS_MAG_DEFAULT_FILTER_THRESH); + set_filter_noise(d, noise); + filter_init(d); + set_calib_offset(d, INVALID_CALIB_OFFSET); +#ifdef YAS_MAG_MANUAL_OFFSET + set_manual_offset(d, zero); +#endif + set_static_matrix(d, notransform); + set_dynamic_matrix(d, notransform); + set_offset(d, INVALID_OFFSET); + set_active(d, FALSE); + set_position(d, 0); + + d->initialized = 1; + + YLOGI(("yas_init_nolock OUT\n")); + + return YAS_NO_ERROR; +} + +static int yas_term_nolock(struct yas_driver *d) +{ + YLOGI(("yas_term_nolock\n")); + + if (unlikely(!d->initialized)) + return YAS_ERROR_NOT_INITIALIZED; + + if (get_active(d)) + suspend(d); + d->initialized = 0; + + YLOGI(("yas_term_nolock out\n")); + return YAS_NO_ERROR; +} + +static int yas_get_delay(void) +{ + int ms = 0, rt; + + YLOGI(("yas_get_delay\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_delay_nolock(&this_driver, &ms); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_delay[%d] OUT\n", ms)); + + return (rt < 0 ? rt : ms); +} + +static int yas_set_delay(int delay) +{ + int rt; + + YLOGI(("yas_set_delay\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_delay_nolock(&this_driver, delay); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_delay OUT\n")); + + return rt; +} + +static int yas_get_offset(struct yas_mag_offset *offset) +{ + int rt; + + YLOGI(("yas_get_offset\n")); + + if (offset == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_offset_nolock(&this_driver, offset); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_offset[%d] OUT\n", rt)); + + return rt; +} + +static int yas_set_offset(struct yas_mag_offset *offset) +{ + int rt; + + YLOGI(("yas_set_offset IN\n")); + + if (offset == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_offset_nolock(&this_driver, offset); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_offset OUT\n")); + + return rt; +} + +#ifdef YAS_MAG_MANUAL_OFFSET + +static int yas_get_manual_offset(struct yas_vector *offset) +{ + int rt; + + YLOGI(("yas_get_manual_offset\n")); + + if (offset == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_manual_offset_nolock(&this_driver, offset); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_manual_offset[%d] OUT\n", rt)); + + return rt; +} + +static int yas_set_manual_offset(struct yas_vector *offset) +{ + int rt; + + YLOGI(("yas_set_manual_offset IN\n")); + + if (offset == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_manual_offset_nolock(&this_driver, offset); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_manual_offset OUT\n")); + + return rt; +} + +#endif + +static int yas_get_static_matrix(struct yas_matrix *matrix) +{ + int rt; + + YLOGI(("yas_get_static_matrix\n")); + + if (matrix == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_static_matrix_nolock(&this_driver, matrix); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_static_matrix[%d] OUT\n", rt)); + + return rt; +} + +static int yas_set_static_matrix(struct yas_matrix *matrix) +{ + int rt; + + YLOGI(("yas_set_static_matrix IN\n")); + + if (matrix == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_static_matrix_nolock(&this_driver, matrix); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_static_matrix OUT\n")); + + return rt; +} + +static int yas_get_dynamic_matrix(struct yas_matrix *matrix) +{ + int rt; + + YLOGI(("yas_get_dynamic_matrix\n")); + + if (matrix == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_dynamic_matrix_nolock(&this_driver, matrix); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_dynamic_matrix[%d] OUT\n", rt)); + + return rt; +} + +static int yas_set_dynamic_matrix(struct yas_matrix *matrix) +{ + int rt; + + YLOGI(("yas_set_dynamic_matrix IN\n")); + + if (matrix == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_dynamic_matrix_nolock(&this_driver, matrix); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_dynamic_matrix OUT\n")); + + return rt; +} + +static int yas_get_enable(void) +{ + int rt; + + YLOGI(("yas_get_enable\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_enable_nolock(&this_driver); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_enable OUT[%d]\n", rt)); + + return rt; +} + +static int yas_set_enable(int enable) +{ + int rt; + + YLOGI(("yas_set_enable IN\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_enable_nolock(&this_driver, enable); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_enable OUT\n")); + + return rt; +} + +static int yas_get_filter(struct yas_mag_filter *filter) +{ + int rt; + + YLOGI(("yas_get_filter\n")); + + if (filter == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_filter_nolock(&this_driver, filter); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_filter[%d] OUT\n", rt)); + + return rt; +} + +static int yas_set_filter(struct yas_mag_filter *filter) +{ + int rt, i; + + YLOGI(("yas_set_filter IN\n")); + + if (filter == NULL + || filter->len < 0 + || YAS_MAG_MAX_FILTER_LEN < filter->len || filter->threshold < 0) { + return YAS_ERROR_ARG; + } + for (i = 0; i < 3; i++) { + if (filter->noise[i] < 0) + return YAS_ERROR_ARG; + } + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_filter_nolock(&this_driver, filter); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_filter OUT\n")); + + return rt; +} + +static int yas_get_filter_enable(void) +{ + int rt; + + YLOGI(("yas_get_filter_enable\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_filter_enable_nolock(&this_driver); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_filter_enable OUT[%d]\n", rt)); + + return rt; +} + +static int yas_set_filter_enable(int enable) +{ + int rt; + + YLOGI(("yas_set_filter_enable IN\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_filter_enable_nolock(&this_driver, enable); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_filter_enable OUT\n")); + + return rt; +} + +static int yas_get_position(void) +{ + int position = 0; + int rt; + + YLOGI(("yas_get_position\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_get_position_nolock(&this_driver, &position); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_get_position[%d] OUT\n", position)); + + return (rt < 0 ? rt : position); +} + +static int yas_set_position(int position) +{ + int rt; + + YLOGI(("yas_set_position\n")); + + if (position < 0 || 7 < position) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_set_position_nolock(&this_driver, position); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_set_position[%d] OUT\n", position)); + + return rt; +} + +static int yas_read_reg(uint8_t addr, uint8_t *buf, int len) +{ + int rt; + + YLOGI(("yas_read_reg\n")); + + if (buf == NULL || len <= 0) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_read_reg_nolock(&this_driver, addr, buf, len); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_read_reg[%d] OUT\n", rt)); + + return rt; +} + +static int yas_write_reg(uint8_t addr, const uint8_t *buf, int len) +{ + int rt; + + YLOGI(("yas_write_reg\n")); + + if (buf == NULL || len <= 0) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_write_reg_nolock(&this_driver, addr, buf, len); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGI(("yas_write_reg[%d] OUT\n", rt)); + + return rt; +} + +static int yas_measure(struct yas_mag_data *data, int *time_delay_ms) +{ + int rt; + + YLOGD(("yas_measure IN\n")); + + if (data == NULL || time_delay_ms == NULL) + return YAS_ERROR_ARG; + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_measure_nolock(&this_driver, data, time_delay_ms); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + YLOGD(("yas_measure OUT[%d]\n", rt)); + + return rt; +} + +static int yas_init(void) +{ + int rt; + + YLOGI(("yas_init\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_init_nolock(&this_driver); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + return rt; +} + +static int yas_term(void) +{ + int rt; + YLOGI(("yas_term\n")); + + if (lock() < 0) + return YAS_ERROR_RESTARTSYS; + + rt = yas_term_nolock(&this_driver); + + if (unlock() < 0) + return YAS_ERROR_RESTARTSYS; + + return rt; +} + +int yas_mag_driver_init(struct yas_mag_driver *f) +{ + if (f == NULL) + return YAS_ERROR_ARG; + if (f->callback.device_open == NULL + || f->callback.device_close == NULL + || f->callback.device_read == NULL + || f->callback.device_write == NULL + || f->callback.msleep == NULL || f->callback.current_time == NULL) + return YAS_ERROR_ARG; + + f->init = yas_init; + f->term = yas_term; + f->get_delay = yas_get_delay; + f->set_delay = yas_set_delay; + f->get_offset = yas_get_offset; + f->set_offset = yas_set_offset; +#ifdef YAS_MAG_MANUAL_OFFSET + f->get_manual_offset = yas_get_manual_offset; + f->set_manual_offset = yas_set_manual_offset; +#endif + f->get_static_matrix = yas_get_static_matrix; + f->set_static_matrix = yas_set_static_matrix; + f->get_dynamic_matrix = yas_get_dynamic_matrix; + f->set_dynamic_matrix = yas_set_dynamic_matrix; + f->get_enable = yas_get_enable; + f->set_enable = yas_set_enable; + f->get_filter = yas_get_filter; + f->set_filter = yas_set_filter; + f->get_filter_enable = yas_get_filter_enable; + f->set_filter_enable = yas_set_filter_enable; + f->get_position = yas_get_position; + f->set_position = yas_set_position; + f->read_reg = yas_read_reg; + f->write_reg = yas_write_reg; + f->measure = yas_measure; + + if ((f->callback.lock == NULL && f->callback.unlock != NULL) + || (f->callback.lock != NULL && f->callback.unlock == NULL)) { + this_driver.callback.lock = NULL; + this_driver.callback.unlock = NULL; + } else { + this_driver.callback.lock = f->callback.lock; + this_driver.callback.unlock = f->callback.unlock; + } + this_driver.callback.device_open = f->callback.device_open; + this_driver.callback.device_close = f->callback.device_close; + this_driver.callback.device_write = f->callback.device_write; + this_driver.callback.device_read = f->callback.device_read; + this_driver.callback.msleep = f->callback.msleep; + this_driver.callback.current_time = f->callback.current_time; + yas_term(); + + return YAS_NO_ERROR; +} diff --git a/drivers/sensor/yas_mag_driver.c b/drivers/sensor/yas_mag_driver.c new file mode 100644 index 0000000..805ec32 --- /dev/null +++ b/drivers/sensor/yas_mag_driver.c @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2010 Yamaha Corporation + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + */ + +#include <linux/sensor/yas.h> + +#if CONFIG_SENSORS_YAS532 +#include "yas_mag_driver-yas532.c" +#else +#include "yas_mag_driver-none.c" +#endif diff --git a/drivers/sensor/yas_mag_kernel_driver.c b/drivers/sensor/yas_mag_kernel_driver.c new file mode 100644 index 0000000..0106958 --- /dev/null +++ b/drivers/sensor/yas_mag_kernel_driver.c @@ -0,0 +1,2192 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * 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., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#include <linux/atomic.h> +#include <linux/types.h> +#include <linux/i2c.h> +#include <linux/errno.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/input.h> +#include <linux/mutex.h> +#include <linux/delay.h> +#include <linux/poll.h> +#include <linux/slab.h> +#include <linux/uaccess.h> +#include <linux/workqueue.h> + +#define __LINUX_KERNEL_DRIVER__ +#include <linux/sensor/yas.h> +#include <linux/sensor/sensors_core.h> +#include "yas_mag_driver.c" + +#define SYSFS_PCBTEST +#ifdef SYSFS_PCBTEST +#include "yas_pcb_test.h" +#include "yas_pcb_test.c" +#endif + +#define GEOMAGNETIC_I2C_DEVICE_NAME "yas532" +#define GEOMAGNETIC_INPUT_NAME "geomagnetic" +#define GEOMAGNETIC_INPUT_RAW_NAME "geomagnetic_raw" +#undef GEOMAGNETIC_PLATFORM_API + +#define ABS_STATUS (ABS_BRAKE) +#define ABS_WAKE (ABS_MISC) + +#define ABS_RAW_DISTORTION (ABS_THROTTLE) +#define ABS_RAW_THRESHOLD (ABS_RUDDER) +#define ABS_RAW_SHAPE (ABS_WHEEL) +#define ABS_RAW_MODE (ABS_HAT0X) +#define ABS_RAW_REPORT (ABS_GAS) + +struct geomagnetic_data { + struct input_dev *input_data; + struct input_dev *input_raw; + struct delayed_work work; + struct semaphore driver_lock; + struct semaphore multi_lock; + atomic_t last_data[3]; + atomic_t last_status; + atomic_t enable; + int filter_enable; + int filter_len; + int32_t filter_noise[3]; + int32_t filter_threshold; + int delay; + int32_t threshold; + int32_t distortion[3]; + int32_t shape; + int32_t ellipsoid_mode; + struct yas_mag_offset driver_offset; +#if DEBUG + int suspend; +#endif +#ifdef YAS_MAG_MANUAL_OFFSET + struct yas_vector manual_offset; +#endif + struct yas_matrix static_matrix; + struct yas_matrix dynamic_matrix; +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct list_head devfile_list; + struct list_head raw_devfile_list; +#endif + struct device *magnetic_sensor_device; + struct mag_platform_data *mag_pdata; + uint8_t dev_id; + int noise_test_init; +}; + +static struct i2c_client *this_client; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + +#include <linux/miscdevice.h> +#define MAX_COUNT (64) +#define SENSOR_NAME "geomagnetic" +#define SENSOR_RAW_NAME "geomagnetic_raw" + +struct sensor_device { + struct list_head list; + struct mutex lock; + wait_queue_head_t waitq; + struct input_event events[MAX_COUNT]; + int head, num_event; +}; + +static void get_time_stamp(struct timeval *tv) +{ + struct timespec ts; + ktime_get_ts(&ts); + tv->tv_sec = ts.tv_sec; + tv->tv_usec = ts.tv_nsec / 1000; +} + +static void make_event(struct input_event *ev, int type, int code, int value) +{ + struct timeval tv; + get_time_stamp(&tv); + ev->type = type; + ev->code = code; + ev->value = value; + ev->time = tv; +} + +static void +make_event_w_time(struct input_event *ev, int type, int code, int value, + struct timeval *tv) +{ + ev->type = type; + ev->code = code; + ev->value = value; + ev->time = *tv; +} + +static void sensor_enq(struct sensor_device *kdev, struct input_event *ev) +{ + int idx; + + idx = kdev->head + kdev->num_event; + if (MAX_COUNT <= idx) + idx -= MAX_COUNT; + kdev->events[idx] = *ev; + kdev->num_event++; + if (MAX_COUNT < kdev->num_event) { + kdev->num_event = MAX_COUNT; + kdev->head++; + if (MAX_COUNT <= kdev->head) + kdev->head -= MAX_COUNT; + } +} + +static int sensor_deq(struct sensor_device *kdev, struct input_event *ev) +{ + if (kdev->num_event == 0) + return 0; + + *ev = kdev->events[kdev->head]; + kdev->num_event--; + kdev->head++; + if (MAX_COUNT <= kdev->head) + kdev->head -= MAX_COUNT; + return 1; +} + +static void +sensor_event(struct list_head *devlist, struct input_event *ev, int num) +{ + struct sensor_device *kdev; + int i; + + list_for_each_entry(kdev, devlist, list) { + mutex_lock(&kdev->lock); + for (i = 0; i < num; i++) + sensor_enq(kdev, &ev[i]); + mutex_unlock(&kdev->lock); + wake_up_interruptible(&kdev->waitq); + } +} + +static ssize_t +sensor_write(struct file *f, const char __user *buf, size_t count, + loff_t *pos) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + struct sensor_device *kdev; + struct input_event ev[MAX_COUNT]; + int num, i; + + if (count < sizeof(struct input_event)) + return -EINVAL; + num = count / sizeof(struct input_event); + if (MAX_COUNT < num) + num = MAX_COUNT; + + if (copy_from_user(ev, buf, num * sizeof(struct input_event))) + return -EFAULT; + + list_for_each_entry(kdev, &data->devfile_list, list) { + mutex_lock(&kdev->lock); + for (i = 0; i < num; i++) + sensor_enq(kdev, &ev[i]); + mutex_unlock(&kdev->lock); + wake_up_interruptible(&kdev->waitq); + } + + return count; +} + +static ssize_t +sensor_read(struct file *f, char __user *buf, size_t count, loff_t *pos) +{ + struct sensor_device *kdev = f->private_data; + int rt, num; + struct input_event ev[MAX_COUNT]; + + if (count < sizeof(struct input_event)) + return -EINVAL; + + rt = wait_event_interruptible(kdev->waitq, kdev->num_event != 0); + if (rt) + return rt; + + mutex_lock(&kdev->lock); + for (num = 0; num < count / sizeof(struct input_event); num++) { + if (!sensor_deq(kdev, &ev[num])) + break; + } + mutex_unlock(&kdev->lock); + + if (copy_to_user(buf, ev, num * sizeof(struct input_event))) + return -EFAULT; + + return num * sizeof(struct input_event); +} + +static unsigned int sensor_poll(struct file *f, struct poll_table_struct *wait) +{ + struct sensor_device *kdev = f->private_data; + + poll_wait(f, &kdev->waitq, wait); + if (kdev->num_event != 0) + return POLLIN | POLLRDNORM; + + return 0; +} + +static int sensor_open(struct inode *inode, struct file *f) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + struct sensor_device *kdev; + + kdev = kzalloc(sizeof(struct sensor_device), GFP_KERNEL); + if (!kdev) + return -ENOMEM; + + mutex_init(&kdev->lock); + init_waitqueue_head(&kdev->waitq); + f->private_data = kdev; + kdev->head = 0; + kdev->num_event = 0; + list_add(&kdev->list, &data->devfile_list); + + return 0; +} + +static int sensor_release(struct inode *inode, struct file *f) +{ + struct sensor_device *kdev = f->private_data; + + list_del(&kdev->list); + kfree(kdev); + + return 0; +} + +static int sensor_raw_open(struct inode *inode, struct file *f) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + struct sensor_device *kdev; + + kdev = kzalloc(sizeof(struct sensor_device), GFP_KERNEL); + if (!kdev) + return -ENOMEM; + + mutex_init(&kdev->lock); + init_waitqueue_head(&kdev->waitq); + f->private_data = kdev; + kdev->head = 0; + kdev->num_event = 0; + list_add(&kdev->list, &data->raw_devfile_list); + + return 0; +} + +const struct file_operations sensor_fops = { + .owner = THIS_MODULE, + .open = sensor_open, + .release = sensor_release, + .write = sensor_write, + .read = sensor_read, + .poll = sensor_poll, +}; + +static struct miscdevice sensor_devfile = { + .name = SENSOR_NAME, + .fops = &sensor_fops, + .minor = MISC_DYNAMIC_MINOR, +}; + +const struct file_operations sensor_raw_fops = { + .owner = THIS_MODULE, + .open = sensor_raw_open, + .release = sensor_release, + .write = sensor_write, + .read = sensor_read, + .poll = sensor_poll, +}; + +static struct miscdevice sensor_raw_devfile = { + .name = SENSOR_RAW_NAME, + .fops = &sensor_raw_fops, + .minor = MISC_DYNAMIC_MINOR, +}; + +#endif + +static int geomagnetic_i2c_open(void) +{ + return 0; +} + +static int geomagnetic_i2c_close(void) +{ + return 0; +} + +#if YAS_MAG_DRIVER == YAS_MAG_DRIVER_YAS529 +static int geomagnetic_i2c_write(const uint8_t *buf, int len) +{ + if (i2c_master_send(this_client, buf, len) < 0) + return -1; +#if DEBUG + YLOGD(("[W] [%02x]\n", buf[0])); +#endif + + return 0; +} + +static int geomagnetic_i2c_read(uint8_t *buf, int len) +{ + if (i2c_master_recv(this_client, buf, len) < 0) + return -1; + return 0; +} + +#else + +static int geomagnetic_i2c_write(uint8_t addr, const uint8_t *buf, int len) +{ + uint8_t tmp[16]; + + if (sizeof(tmp) - 1 < len) + return -1; + + tmp[0] = addr; + memcpy(&tmp[1], buf, len); + + if (i2c_master_send(this_client, tmp, len + 1) < 0) + return -1; +#if DEBUG + YLOGD(("[W] addr[%02x] [%02x]\n", addr, buf[0])); +#endif + + return 0; +} + +static int geomagnetic_i2c_read(uint8_t addr, uint8_t *buf, int len) +{ + struct i2c_msg msg[2]; + int err; + + msg[0].addr = this_client->addr; + msg[0].flags = 0; + msg[0].len = 1; + msg[0].buf = &addr; + msg[1].addr = this_client->addr; + msg[1].flags = I2C_M_RD; + msg[1].len = len; + msg[1].buf = buf; + + err = i2c_transfer(this_client->adapter, msg, 2); + if (err != 2) { + dev_err(&this_client->dev, + "i2c_transfer() read error: slave_addr=%02x, reg_addr=%02x, err=%d\n", + this_client->addr, addr, err); + return err; + } + + return 0; +} + +#endif + +static int geomagnetic_lock(void) +{ + struct geomagnetic_data *data = NULL; + int rt; + + if (this_client == NULL) + return -1; + + data = i2c_get_clientdata(this_client); + rt = down_interruptible(&data->driver_lock); + if (rt < 0) + up(&data->driver_lock); + return rt; +} + +static int geomagnetic_unlock(void) +{ + struct geomagnetic_data *data = NULL; + + if (this_client == NULL) + return -1; + + data = i2c_get_clientdata(this_client); + up(&data->driver_lock); + return 0; +} + +static void geomagnetic_msleep(int ms) +{ + usleep_range(ms * 999, ms * 1000); +} + +static void geomagnetic_current_time(int32_t *sec, int32_t *msec) +{ + struct timeval tv; + + do_gettimeofday(&tv); + + *sec = tv.tv_sec; + *msec = tv.tv_usec / 1000; +} + +static struct yas_mag_driver hwdep_driver = { + .callback = { + .lock = geomagnetic_lock, + .unlock = geomagnetic_unlock, + .device_open = geomagnetic_i2c_open, + .device_close = geomagnetic_i2c_close, + .device_read = geomagnetic_i2c_read, + .device_write = geomagnetic_i2c_write, + .msleep = geomagnetic_msleep, + .current_time = geomagnetic_current_time, + }, +}; + +static int geomagnetic_multi_lock(void) +{ + struct geomagnetic_data *data = NULL; + int rt; + + if (this_client == NULL) + return -1; + + data = i2c_get_clientdata(this_client); + rt = down_interruptible(&data->multi_lock); + if (rt < 0) + up(&data->multi_lock); + return rt; +} + +static int geomagnetic_multi_unlock(void) +{ + struct geomagnetic_data *data = NULL; + + if (this_client == NULL) + return -1; + + data = i2c_get_clientdata(this_client); + up(&data->multi_lock); + return 0; +} + +static int geomagnetic_enable(struct geomagnetic_data *data) +{ + if (!atomic_cmpxchg(&data->enable, 0, 1)) + schedule_delayed_work(&data->work, 0); + + return 0; +} + +static int geomagnetic_disable(struct geomagnetic_data *data) +{ + if (atomic_cmpxchg(&data->enable, 1, 0)) + cancel_delayed_work_sync(&data->work); + + return 0; +} + +/* Sysfs interface */ +static ssize_t +geomagnetic_delay_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int delay; + + geomagnetic_multi_lock(); + + delay = data->delay; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", delay); +} + +static ssize_t +geomagnetic_delay_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + if (hwdep_driver.set_delay == NULL) + return -ENOTTY; + + geomagnetic_multi_lock(); + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + if (hwdep_driver.set_delay(value) == 0) + data->delay = value; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + + return sprintf(buf, "%d\n", atomic_read(&data->enable)); +} + +static ssize_t +geomagnetic_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + value = !(!value); + + if (hwdep_driver.set_enable == NULL) + return -ENOTTY; + + if (geomagnetic_multi_lock() < 0) + return count; + + if (hwdep_driver.set_enable(value) == 0) { + if (value) + geomagnetic_enable(data); + else + geomagnetic_disable(data); + } + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_filter_enable_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int filter_enable; + + geomagnetic_multi_lock(); + + filter_enable = data->filter_enable; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", filter_enable); +} + +static ssize_t +geomagnetic_filter_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + unsigned long value; + int error; + + if (hwdep_driver.set_filter_enable == NULL) + return -ENOTTY; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + if (geomagnetic_multi_lock() < 0) + return count; + + if (hwdep_driver.set_filter_enable(value) == 0) + data->filter_enable = !!value; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_filter_len_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int filter_len; + + geomagnetic_multi_lock(); + + filter_len = data->filter_len; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", filter_len); +} + +static ssize_t +geomagnetic_filter_len_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + struct yas_mag_filter filter; + unsigned long value; + int error; + + if (hwdep_driver.get_filter == NULL || hwdep_driver.set_filter == NULL) + return -ENOTTY; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + if (geomagnetic_multi_lock() < 0) + return count; + + hwdep_driver.get_filter(&filter); + filter.len = value; + if (hwdep_driver.set_filter(&filter) == 0) + data->filter_len = value; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_filter_noise_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int rt; + + geomagnetic_multi_lock(); + + rt = sprintf(buf, "%d %d %d\n", + data->filter_noise[0], + data->filter_noise[1], data->filter_noise[2]); + + geomagnetic_multi_unlock(); + + return rt; +} + +static ssize_t +geomagnetic_filter_noise_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct yas_mag_filter filter; + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int32_t filter_noise[3]; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d", + &filter_noise[0], &filter_noise[1], &filter_noise[2]); + hwdep_driver.get_filter(&filter); + memcpy(filter.noise, filter_noise, sizeof(filter.noise)); + if (hwdep_driver.set_filter(&filter) == 0) + memcpy(data->filter_noise, filter_noise, + sizeof(data->filter_noise)); + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_filter_threshold_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int32_t filter_threshold; + + geomagnetic_multi_lock(); + + filter_threshold = data->filter_threshold; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", filter_threshold); +} + +static ssize_t +geomagnetic_filter_threshold_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + struct yas_mag_filter filter; + unsigned long value; + int error; + + if (hwdep_driver.get_filter == NULL || hwdep_driver.set_filter == NULL) + return -ENOTTY; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + if (geomagnetic_multi_lock() < 0) + return count; + + hwdep_driver.get_filter(&filter); + filter.threshold = value; + if (hwdep_driver.set_filter(&filter) == 0) + data->filter_threshold = value; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_position_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + if (hwdep_driver.get_position == NULL) + return -ENOTTY; + return sprintf(buf, "%d\n", hwdep_driver.get_position()); +} + +static ssize_t +geomagnetic_position_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + if (hwdep_driver.set_position == NULL) + return -ENOTTY; + hwdep_driver.set_position(value); + + return count; +} + +static ssize_t +geomagnetic_data_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int rt; + + rt = sprintf(buf, "%d %d %d\n", + atomic_read(&data->last_data[0]), + atomic_read(&data->last_data[1]), + atomic_read(&data->last_data[2])); + + return rt; +} + +static ssize_t +geomagnetic_status_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + int rt; + + rt = sprintf(buf, "%d\n", atomic_read(&data->last_status)); + + return rt; +} + +static ssize_t +geomagnetic_status_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + static int16_t cnt = 1; +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev; +#endif + int accuracy = 0; + int code = 0; + int value = 0; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d", &accuracy); + if (0 <= accuracy && accuracy <= 3) + atomic_set(&data->last_status, accuracy); + code |= YAS_REPORT_CALIB_OFFSET_CHANGED; + value = (cnt++ << 16) | (code); + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + mkev(&ev, EV_ABS, ABS_RAW_REPORT, value); + sensor_event(&data->raw_devfile_list, &ev, 1); +#else + input_report_abs(data->input_raw, ABS_RAW_REPORT, value); + input_sync(data->input_raw); +#endif + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_wake_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_data); + static int16_t cnt = 1; +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_WAKE, cnt++); + sensor_event(&data->devfile_list, ev, 1); +#else + input_report_abs(data->input_data, ABS_WAKE, cnt++); + input_sync(data->input_data); +#endif + + return count; +} + +#if DEBUG + +static int geomagnetic_suspend(struct i2c_client *client, pm_message_t mesg); +static int geomagnetic_resume(struct i2c_client *client); + +static ssize_t +geomagnetic_debug_suspend_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input); + + return sprintf(buf, "%d\n", data->suspend); +} + +static ssize_t +geomagnetic_debug_suspend_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + unsigned long suspend; + int error; + + error = strict_strtoul(buf, 10, &suspend); + if (unlikely(error)) + return error; + + if (suspend) { + pm_message_t msg; + memset(&msg, 0, sizeof(msg)); + geomagnetic_suspend(this_client, msg); + } else + geomagnetic_resume(this_client); + + return count; +} + +#endif /* DEBUG */ + +static DEVICE_ATTR(delay, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_delay_show, geomagnetic_delay_store); +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_enable_show, geomagnetic_enable_store); +static DEVICE_ATTR(filter_enable, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_filter_enable_show, + geomagnetic_filter_enable_store); +static DEVICE_ATTR(filter_len, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_filter_len_show, geomagnetic_filter_len_store); +static DEVICE_ATTR(filter_threshold, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_filter_threshold_show, + geomagnetic_filter_threshold_store); +static DEVICE_ATTR(filter_noise, S_IRUGO | S_IWUSR | S_IWGRP, + geomagnetic_filter_noise_show, + geomagnetic_filter_noise_store); +static DEVICE_ATTR(data, S_IRUGO, geomagnetic_data_show, NULL); +static DEVICE_ATTR(status, S_IRUGO|S_IWUSR|S_IWGRP, geomagnetic_status_show, + geomagnetic_status_store); +static DEVICE_ATTR(wake, S_IWUSR | S_IWGRP, NULL, geomagnetic_wake_store); +static DEVICE_ATTR(position, S_IRUGO | S_IWUSR, + geomagnetic_position_show, geomagnetic_position_store); +#if DEBUG +static DEVICE_ATTR(debug_suspend, S_IRUGO | S_IWUSR, + geomagnetic_debug_suspend_show, + geomagnetic_debug_suspend_store); +#endif /* DEBUG */ + +static struct attribute *geomagnetic_attributes[] = { + &dev_attr_delay.attr, + &dev_attr_enable.attr, + &dev_attr_filter_enable.attr, + &dev_attr_filter_len.attr, + &dev_attr_filter_threshold.attr, + &dev_attr_filter_noise.attr, + &dev_attr_data.attr, + &dev_attr_status.attr, + &dev_attr_wake.attr, + &dev_attr_position.attr, +#if DEBUG + &dev_attr_debug_suspend.attr, +#endif /* DEBUG */ + NULL +}; + +static struct attribute_group geomagnetic_attribute_group = { + .attrs = geomagnetic_attributes +}; + +static ssize_t +geomagnetic_raw_threshold_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int threshold; + + geomagnetic_multi_lock(); + + threshold = data->threshold; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", threshold); +} + +static ssize_t +geomagnetic_raw_threshold_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + geomagnetic_multi_lock(); + + if (0 <= value && value <= 2) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_RAW_THRESHOLD, value); + sensor_event(&data->raw_devfile_list, ev, 1); +#endif + data->threshold = value; +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(data->input_raw, ABS_RAW_THRESHOLD, value); + input_sync(data->input_raw); +#endif + } + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_raw_distortion_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int rt; + + geomagnetic_multi_lock(); + + rt = sprintf(buf, "%d %d %d\n", + data->distortion[0], + data->distortion[1], data->distortion[2]); + + geomagnetic_multi_unlock(); + + return rt; +} + +static ssize_t +geomagnetic_raw_distortion_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int32_t distortion[3]; + static int32_t val = 1; + int i; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d", &distortion[0], &distortion[1], &distortion[2]); + if (distortion[0] > 0 && distortion[1] > 0 && distortion[2] > 0) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_RAW_DISTORTION, val++); + sensor_event(&data->raw_devfile_list, ev, 1); +#endif + for (i = 0; i < 3; i++) + data->distortion[i] = distortion[i]; +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(data->input_raw, ABS_RAW_DISTORTION, val++); + input_sync(data->input_raw); +#endif + } + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_raw_shape_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int shape; + + geomagnetic_multi_lock(); + + shape = data->shape; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", shape); +} + +static ssize_t +geomagnetic_raw_shape_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + + geomagnetic_multi_lock(); + + if (0 == value || value == 1) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_RAW_SHAPE, value); + sensor_event(&data->raw_devfile_list, ev, 1); +#endif + data->shape = value; +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(data->input_raw, ABS_RAW_SHAPE, value); + input_sync(data->input_raw); +#endif + } + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_raw_offsets_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_mag_offset offset; + int accuracy; + + geomagnetic_multi_lock(); + + offset = data->driver_offset; + accuracy = atomic_read(&data->last_status); + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d %d %d %d %d %d %d\n", + offset.hard_offset[0], + offset.hard_offset[1], + offset.hard_offset[2], + offset.calib_offset.v[0], + offset.calib_offset.v[1], + offset.calib_offset.v[2], accuracy); +} + +static ssize_t +geomagnetic_raw_offsets_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_mag_offset offset; + int32_t hard_offset[3]; + int i, accuracy; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d %d %d %d %d", + &hard_offset[0], + &hard_offset[1], + &hard_offset[2], + &offset.calib_offset.v[0], + &offset.calib_offset.v[1], &offset.calib_offset.v[2], &accuracy); + if (0 <= accuracy && accuracy <= 3) { + for (i = 0; i < 3; i++) + offset.hard_offset[i] = (int8_t) hard_offset[i]; + + if (hwdep_driver.set_offset(&offset) == 0) { + atomic_set(&data->last_status, accuracy); + data->driver_offset = offset; + } + } + + geomagnetic_multi_unlock(); + + return count; +} + +#ifdef YAS_MAG_MANUAL_OFFSET +static ssize_t +geomagnetic_raw_manual_offsets_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_vector offset; + + geomagnetic_multi_lock(); + + offset = data->manual_offset; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d %d %d\n", offset.v[0], offset.v[1], + offset.v[2]); +} + +static ssize_t +geomagnetic_raw_manual_offsets_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_vector offset; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d", &offset.v[0], &offset.v[1], &offset.v[2]); + if (hwdep_driver.set_manual_offset(&offset) == 0) + data->manual_offset = offset; + + geomagnetic_multi_unlock(); + + return count; +} +#endif + +static ssize_t +geomagnetic_raw_static_matrix_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_matrix matrix; + + geomagnetic_multi_lock(); + + matrix = data->static_matrix; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d %d %d %d %d %d %d %d %d\n", + matrix.matrix[0], matrix.matrix[1], matrix.matrix[2], + matrix.matrix[3], matrix.matrix[4], matrix.matrix[5], + matrix.matrix[6], matrix.matrix[7], matrix.matrix[8]); +} + +static ssize_t +geomagnetic_raw_static_matrix_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_matrix matrix; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d %d %d %d %d %d %d", + &matrix.matrix[0], &matrix.matrix[1], &matrix.matrix[2], + &matrix.matrix[3], &matrix.matrix[4], &matrix.matrix[5], + &matrix.matrix[6], &matrix.matrix[7], &matrix.matrix[8]); + if (hwdep_driver.set_static_matrix(&matrix) == 0) + data->static_matrix = matrix; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_raw_dynamic_matrix_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_matrix matrix; + + geomagnetic_multi_lock(); + + matrix = data->dynamic_matrix; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d %d %d %d %d %d %d %d %d\n", + matrix.matrix[0], matrix.matrix[1], matrix.matrix[2], + matrix.matrix[3], matrix.matrix[4], matrix.matrix[5], + matrix.matrix[6], matrix.matrix[7], matrix.matrix[8]); +} + +static ssize_t +geomagnetic_raw_dynamic_matrix_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + struct yas_matrix matrix; + + geomagnetic_multi_lock(); + + sscanf(buf, "%d %d %d %d %d %d %d %d %d", + &matrix.matrix[0], &matrix.matrix[1], &matrix.matrix[2], + &matrix.matrix[3], &matrix.matrix[4], &matrix.matrix[5], + &matrix.matrix[6], &matrix.matrix[7], &matrix.matrix[8]); + if (hwdep_driver.set_dynamic_matrix(&matrix) == 0) + data->dynamic_matrix = matrix; + + geomagnetic_multi_unlock(); + + return count; +} + +static ssize_t +geomagnetic_raw_ellipsoid_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + int ellipsoid_mode; + + geomagnetic_multi_lock(); + + ellipsoid_mode = data->ellipsoid_mode; + + geomagnetic_multi_unlock(); + + return sprintf(buf, "%d\n", ellipsoid_mode); +} + +static ssize_t +geomagnetic_raw_ellipsoid_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_raw = to_input_dev(dev); + struct geomagnetic_data *data = input_get_drvdata(input_raw); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + value = !(!value); +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; +#endif + + geomagnetic_multi_lock(); + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + make_event(ev, EV_ABS, ABS_RAW_MODE, value); + sensor_event(&data->raw_devfile_list, ev, 1); +#endif + data->ellipsoid_mode = value; +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(data->input_raw, ABS_RAW_MODE, value); + input_sync(data->input_raw); +#endif + + geomagnetic_multi_unlock(); + + return count; +} + +#ifdef SYSFS_PCBTEST + +static int +pcbtest_i2c_write(uint8_t slave, uint8_t addr, const uint8_t *buf, int len) +{ + return geomagnetic_i2c_write(addr, buf, len); +} + +static int +pcbtest_i2c_read(uint8_t slave, uint8_t addr, uint8_t *buf, int len) +{ + return geomagnetic_i2c_read(addr, buf, len); +} + +static struct yas_pcb_test pcbtest = { + .callback = { + .power_on = NULL, + .power_off = NULL, + .i2c_open = geomagnetic_i2c_open, + .i2c_close = geomagnetic_i2c_close, + .i2c_read = pcbtest_i2c_read, + .i2c_write = pcbtest_i2c_write, + .msleep = geomagnetic_msleep, + .read_intpin = NULL, + }, +}; + + +static ssize_t +geomagnetic_raw_self_test_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + int id, x, y1, y2, dir, sx, sy, ohx, ohy, ohz; + int err1, err2, err3, err4, err5, err6, err7; + + if (data->noise_test_init) + pcbtest.power_off(); + err1 = pcbtest.power_on_and_device_check(&id); + err3 = pcbtest.initialization(); + err4 = + pcbtest.offset_control_measurement_and_set_offset_register( + &x, &y1, &y2); + err5 = pcbtest.direction_measurement(&dir); + err6 = + pcbtest.sensitivity_measurement_of_magnetic_sensor_by_test_coil( + &sx, &sy); + err7 = pcbtest.magnetic_field_level_check(&ohx, &ohy, &ohz); + err2 = pcbtest.power_off(); + data->noise_test_init = 0; + if (unlikely(id != 0x2)) + err1 = -1; + if (unlikely(x < -30 || x > 30)) + err4 = -1; + if (unlikely(y1 < -30 || y1 > 30)) + err4 = -1; + if (unlikely(y2 < -30 || y2 > 30)) + err4 = -1; + if (unlikely(sx < 17 || sy < 22)) + err6 = -1; + if (unlikely(ohx < -600 || ohx > 600)) + err7 = -1; + if (unlikely(ohy < -600 || ohy > 600)) + err7 = -1; + if (unlikely(ohz < -600 || ohz > 600)) + err7 = -1; + + pr_info("%s\n" + "Test1 - err = %d, id = %d\n" + "Test3 - err = %d\n" + "Test4 - err = %d, offset = %d,%d,%d\n" + "Test5 - err = %d, direction = %d\n" + "Test6 - err = %d, sensitivity = %d,%d\n" + "Test7 - err = %d, offset = %d,%d,%d\n" + "Test2 - err = %d\n", __func__, + err1, id, err3, err4, x, y1, y2, err5, dir, err6, sx, sy, + err7, ohx, ohy, ohz, err2); + + return sprintf(buf, + "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n", + err1, id, err3, err4, x, y1, y2, err5, dir, err6, sx, + sy, err7, ohx, ohy, ohz, err2); +} + +static ssize_t +geomagnetic_raw_self_test_noise_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + int id, x, y1, y2, dir, hx0, hy0, hz0; + int err8; +#if CONFIG_MACH_KONA_SENSOR + pcbtest.power_on_and_device_check(&id); + pcbtest.initialization(); + pcbtest.offset_control_measurement_and_set_offset_register( + &x, &y1, &y2); +#else + if (!data->noise_test_init) { + pcbtest.power_on_and_device_check(&id); + pcbtest.initialization(); + pcbtest.offset_control_measurement_and_set_offset_register( + &x, &y1, &y2); + } +#endif + pcbtest.direction_measurement(&dir); + err8 = pcbtest.noise_level_check(&hx0, &hy0, &hz0); + if (err8 < 0) { + pr_err("%s: err8=%d\n", __func__, err8); + hx0 = 0; + hy0 = 0; + hz0 = 0; + } + usleep_range(3000, 3100); + data->noise_test_init = 1; + pr_debug("%s: %d, %d, %d\n", __func__, hx0, hy0, hz0); + return snprintf(buf, PAGE_SIZE, "%d,%d,%d\n", hx0, hy0, hz0); +} + +static DEVICE_ATTR(self_test, S_IRUSR, geomagnetic_raw_self_test_show, NULL); +static DEVICE_ATTR(self_test_noise, S_IRUSR, + geomagnetic_raw_self_test_noise_show, NULL); + +#endif + + +static DEVICE_ATTR(threshold, S_IRUGO | S_IWUSR, + geomagnetic_raw_threshold_show, + geomagnetic_raw_threshold_store); +static DEVICE_ATTR(distortion, S_IRUGO | S_IWUSR, + geomagnetic_raw_distortion_show, + geomagnetic_raw_distortion_store); +static DEVICE_ATTR(shape, S_IRUGO | S_IWUSR, geomagnetic_raw_shape_show, + geomagnetic_raw_shape_store); +static DEVICE_ATTR(offsets, S_IRUGO | S_IWUSR, geomagnetic_raw_offsets_show, + geomagnetic_raw_offsets_store); +#ifdef YAS_MAG_MANUAL_OFFSET +static DEVICE_ATTR(manual_offsets, S_IRUGO | S_IWUSR, + geomagnetic_raw_manual_offsets_show, + geomagnetic_raw_manual_offsets_store); +#endif +static DEVICE_ATTR(static_matrix, S_IRUGO | S_IWUSR, + geomagnetic_raw_static_matrix_show, + geomagnetic_raw_static_matrix_store); +static DEVICE_ATTR(dynamic_matrix, S_IRUGO | S_IWUSR, + geomagnetic_raw_dynamic_matrix_show, + geomagnetic_raw_dynamic_matrix_store); +static DEVICE_ATTR(ellipsoid_mode, S_IRUGO | S_IWUSR, + geomagnetic_raw_ellipsoid_mode_show, + geomagnetic_raw_ellipsoid_mode_store); +static struct attribute *geomagnetic_raw_attributes[] = { +#ifdef SYSFS_PCBTEST + &dev_attr_self_test.attr, + &dev_attr_self_test_noise.attr, +#endif + &dev_attr_threshold.attr, + &dev_attr_distortion.attr, + &dev_attr_shape.attr, + &dev_attr_offsets.attr, +#ifdef YAS_MAG_MANUAL_OFFSET + &dev_attr_manual_offsets.attr, +#endif + &dev_attr_static_matrix.attr, + &dev_attr_dynamic_matrix.attr, + &dev_attr_ellipsoid_mode.attr, + NULL +}; + +static struct attribute_group geomagnetic_raw_attribute_group = { + .attrs = geomagnetic_raw_attributes +}; +static struct device_attribute dev_attr_magnetic_sensor_selftest = + __ATTR(selftest, S_IRUSR | S_IRGRP, + geomagnetic_raw_self_test_show, NULL); + +static struct device_attribute dev_attr_magnetic_sensor_raw_data = + __ATTR(raw_data, S_IRUSR | S_IRGRP, + geomagnetic_raw_self_test_noise_show, NULL); + +static ssize_t magnetic_vendor_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + return sprintf(buf, "%s\n", "YAMAHA"); +} +static struct device_attribute dev_attr_magnetic_sensor_vendor = + __ATTR(vendor, S_IRUSR | S_IRGRP, magnetic_vendor_show, NULL); + +static ssize_t magnetic_name_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + int ret; + if (data->dev_id == YAS_YAS532_DEVICE_ID) + ret = sprintf(buf, "%s\n", "YAS532"); + else + ret = sprintf(buf, "%s\n", "YAS530C"); + return ret; +} +static struct device_attribute dev_attr_magnetic_sensor_name = + __ATTR(name, S_IRUSR | S_IRGRP, magnetic_name_show, NULL); + +static struct device_attribute *magnetic_sensor_attrs[] = { + &dev_attr_magnetic_sensor_selftest, + &dev_attr_magnetic_sensor_raw_data, + &dev_attr_magnetic_sensor_vendor, + &dev_attr_magnetic_sensor_name, + NULL, +}; + + +/* Interface Functions for Lower Layer */ +#ifdef YAS_MAG_MANUAL_OFFSET +void geomagnetic_manual_offset(void) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + struct yas_vector offset; + if (data->mag_pdata->chg_status == CABLE_TYPE_NONE) { + offset = data->mag_pdata->full_offset; + if (hwdep_driver.set_manual_offset(&offset) == 0) + data->manual_offset = offset; + } else if (data->mag_pdata->chg_status == CABLE_TYPE_USB) { + offset = data->mag_pdata->usb_offset; + if (hwdep_driver.set_manual_offset(&offset) == 0) + data->manual_offset = offset; + } else if (data->mag_pdata->chg_status == CABLE_TYPE_AC) { + offset = data->mag_pdata->ta_offset; + if (hwdep_driver.set_manual_offset(&offset) == 0) + data->manual_offset = offset; + } else { + offset = data->mag_pdata->full_offset; + if (hwdep_driver.set_manual_offset(&offset) == 0) + data->manual_offset = offset; + } + data->mag_pdata->offset_enable = 0; +} +#endif + +static int geomagnetic_work(struct yas_mag_data *magdata) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + uint32_t time_delay_ms = 100; + static int cnt; + int rt, i, accuracy; +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[5]; + struct timeval tv; +#endif + +#ifdef YAS_MAG_MANUAL_OFFSET + if (data->mag_pdata) { + if (data->mag_pdata->offset_enable) + geomagnetic_manual_offset(); + } +#endif + + if (hwdep_driver.measure == NULL || hwdep_driver.get_offset == NULL) + return time_delay_ms; + + rt = hwdep_driver.measure(magdata, &time_delay_ms); + if (rt < 0) + YLOGE(("measure failed[%d]\n", rt)); + YLOGD(("xy1y2 [%d][%d][%d] raw[%d][%d][%d]\n", + magdata->xy1y2.v[0], magdata->xy1y2.v[1], magdata->xy1y2.v[2], + magdata->xyz.v[0], magdata->xyz.v[1], magdata->xyz.v[2])); + + if (rt >= 0) { + accuracy = atomic_read(&data->last_status); + + if ((rt & YAS_REPORT_OVERFLOW_OCCURED) + || (rt & YAS_REPORT_HARD_OFFSET_CHANGED) + || (rt & YAS_REPORT_CALIB_OFFSET_CHANGED)) { + static uint16_t count = 1; + int code = 0; + int value = 0; + + hwdep_driver.get_offset(&data->driver_offset); + if (rt & YAS_REPORT_OVERFLOW_OCCURED) { + atomic_set(&data->last_status, 0); + accuracy = 0; + } + + /* report event */ + code |= (rt & YAS_REPORT_OVERFLOW_OCCURED); + code |= (rt & YAS_REPORT_HARD_OFFSET_CHANGED); + code |= (rt & YAS_REPORT_CALIB_OFFSET_CHANGED); + value = (count++ << 16) | (code); +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + make_event(ev, EV_ABS, ABS_RAW_REPORT, value); + sensor_event(&data->raw_devfile_list, ev, 1); +#else + input_report_abs(data->input_raw, ABS_RAW_REPORT, + value); + input_sync(data->input_raw); +#endif + } + + if (rt & YAS_REPORT_DATA) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + get_time_stamp(&tv); + make_event_w_time(&ev[0], EV_ABS, ABS_X, + magdata->xyz.v[0], &tv); + make_event_w_time(&ev[1], EV_ABS, ABS_Y, + magdata->xyz.v[1], &tv); + make_event_w_time(&ev[2], EV_ABS, ABS_Z, + magdata->xyz.v[2], &tv); + make_event_w_time(&ev[3], EV_ABS, ABS_STATUS, accuracy, + &tv); + make_event_w_time(&ev[4], EV_SYN, 0, 0, &tv); + sensor_event(&data->devfile_list, ev, 5); +#else + /* report magnetic data in [nT] */ + input_report_abs(data->input_data, ABS_X, + magdata->xyz.v[0]); + input_report_abs(data->input_data, ABS_Y, + magdata->xyz.v[1]); + input_report_abs(data->input_data, ABS_Z, + magdata->xyz.v[2]); + if (atomic_read(&data->last_data[0]) == + magdata->xyz.v[0] + && atomic_read(&data->last_data[1]) == + magdata->xyz.v[1] + && atomic_read(&data->last_data[2]) == + magdata->xyz.v[2]) { + input_report_abs(data->input_data, ABS_RUDDER, + cnt++); + } + input_report_abs(data->input_data, ABS_STATUS, + accuracy); + input_sync(data->input_data); +#endif + + for (i = 0; i < 3; i++) + atomic_set(&data->last_data[i], + magdata->xyz.v[i]); + } + + if (rt & YAS_REPORT_CALIB) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + get_time_stamp(&tv); + make_event_w_time(&ev[0], EV_ABS, ABS_X, + magdata->raw.v[0], &tv); + make_event_w_time(&ev[1], EV_ABS, ABS_Y, + magdata->raw.v[1], &tv); + make_event_w_time(&ev[2], EV_ABS, ABS_Z, + magdata->raw.v[2], &tv); + make_event_w_time(&ev[3], EV_SYN, 0, 0, &tv); + sensor_event(&data->raw_devfile_list, ev, 4); +#else + /* report raw magnetic data */ + input_report_abs(data->input_raw, ABS_X, + magdata->raw.v[0]); + input_report_abs(data->input_raw, ABS_Y, + magdata->raw.v[1]); + input_report_abs(data->input_raw, ABS_Z, + magdata->raw.v[2]); + input_sync(data->input_raw); +#endif + } + } else { + time_delay_ms = 100; + } + + return time_delay_ms; + +} + +static void geomagnetic_input_work_func(struct work_struct *work) +{ + struct geomagnetic_data *data = + container_of((struct delayed_work *)work, + struct geomagnetic_data, work); + uint32_t time_delay_ms; + struct yas_mag_data magdata; + + time_delay_ms = geomagnetic_work(&magdata); + + if (time_delay_ms > 60) + schedule_delayed_work(&data->work, + msecs_to_jiffies(time_delay_ms)); + else { + if (time_delay_ms > 0) + usleep_range(time_delay_ms * 1000, + time_delay_ms * 1100); + schedule_delayed_work(&data->work, 0); + } +} + +static int geomagnetic_suspend(struct i2c_client *client, pm_message_t mesg) +{ + struct geomagnetic_data *data = i2c_get_clientdata(client); + + if (atomic_read(&data->enable)) + cancel_delayed_work_sync(&data->work); +#if DEBUG + data->suspend = 1; +#endif + + return 0; +} + +static int geomagnetic_resume(struct i2c_client *client) +{ + struct geomagnetic_data *data = i2c_get_clientdata(client); + + if (atomic_read(&data->enable)) + schedule_delayed_work(&data->work, 0); +#if DEBUG + data->suspend = 0; +#endif + + return 0; +} + +static int +geomagnetic_probe(struct i2c_client *client, const struct i2c_device_id *id) +{ + struct geomagnetic_data *data = NULL; + struct input_dev *input_data = NULL, *input_raw = NULL; + int rt, sysfs_created = 0, sysfs_raw_created = 0; + int data_registered = 0, raw_registered = 0, i; + struct yas_mag_filter filter; + struct mag_platform_data *pdata; + + pr_err("%s, is called\n", __func__); + + i2c_set_clientdata(client, NULL); + data = kzalloc(sizeof(struct geomagnetic_data), GFP_KERNEL); + if (data == NULL) { + rt = -ENOMEM; + goto err; + } + + pdata = (struct mag_platform_data *) client->dev.platform_data; + data->mag_pdata = pdata; + + if (pdata) { + if (pdata->power_on) + pdata->power_on(true); + } + data->threshold = YAS_DEFAULT_MAGCALIB_THRESHOLD; + for (i = 0; i < 3; i++) + data->distortion[i] = YAS_DEFAULT_MAGCALIB_DISTORTION; + data->shape = 0; + atomic_set(&data->enable, 0); + for (i = 0; i < 3; i++) + atomic_set(&data->last_data[i], 0); + atomic_set(&data->last_status, 0); + INIT_DELAYED_WORK(&data->work, geomagnetic_input_work_func); + sema_init(&data->driver_lock, 1); + sema_init(&data->multi_lock, 1); + + input_data = input_allocate_device(); + if (input_data == NULL) { + rt = -ENOMEM; + YLOGE(("mag Failed to allocate input_data device\n")); + goto err; + } + + input_data->name = GEOMAGNETIC_INPUT_NAME; + input_data->id.bustype = BUS_I2C; + set_bit(EV_ABS, input_data->evbit); + input_set_abs_params(input_data, ABS_X, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_Y, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_Z, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_RUDDER, 0x80000000, 0x7fffffff, 0, + 0); + input_set_abs_params(input_data, ABS_STATUS, 0, 3, 0, 0); + input_set_abs_params(input_data, ABS_WAKE, 0x80000000, 0x7fffffff, 0, + 0); + input_data->dev.parent = &client->dev; + + rt = input_register_device(input_data); + if (rt) { + YLOGE(("mag: Unable to reg input_data %s\n", input_data->name)); + goto err; + } + data_registered = 1; + + rt = sysfs_create_group(&input_data->dev.kobj, + &geomagnetic_attribute_group); + if (rt) { + YLOGE(("mag sysfs_create failed[%s]\n", input_data->name)); + goto err; + } + sysfs_created = 1; + + input_raw = input_allocate_device(); + if (input_raw == NULL) { + rt = -ENOMEM; + YLOGE(("mag Failed to alloc input_raw dev\n")); + goto err; + } + + input_raw->name = GEOMAGNETIC_INPUT_RAW_NAME; + input_raw->id.bustype = BUS_I2C; + set_bit(EV_ABS, input_raw->evbit); + input_set_abs_params(input_raw, ABS_X, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_raw, ABS_Y, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_raw, ABS_Z, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_raw, ABS_RAW_DISTORTION, 0, 0x7fffffff, 0, + 0); + input_set_abs_params(input_raw, ABS_RAW_THRESHOLD, 0, 2, 0, 0); + input_set_abs_params(input_raw, ABS_RAW_SHAPE, 0, 1, 0, 0); + input_set_abs_params(input_raw, ABS_RAW_MODE, 0, 1, 0, 0); + input_set_abs_params(input_raw, ABS_RAW_REPORT, 0x80000000, 0x7fffffff, + 0, 0); + input_raw->dev.parent = &client->dev; + + rt = input_register_device(input_raw); + if (rt) { + YLOGE(("mag: Unable to reg input_raw dev\n")); + goto err; + } + raw_registered = 1; + + rt = sysfs_create_group(&input_raw->dev.kobj, + &geomagnetic_raw_attribute_group); + if (rt) { + YLOGE(("geomagnetic_probe: sysfs_create_group failed[%s]\n", + input_data->name)); + goto err; + } + sysfs_raw_created = 1; + + this_client = client; + data->input_raw = input_raw; + data->input_data = input_data; + input_set_drvdata(input_data, data); + input_set_drvdata(input_raw, data); + i2c_set_clientdata(client, data); + rt = yas_mag_driver_init(&hwdep_driver); + if (rt < 0) { + YLOGE(("yas_mag_driver_init failed[%d]\n", rt)); + goto err; + } + if (hwdep_driver.init != NULL) { + rt = hwdep_driver.init(); + if (rt < 0) { + YLOGE(("hwdep_driver.init() failed[%d]\n", rt)); + goto err; + } + } + if (hwdep_driver.set_position != NULL) { + if (pdata) { + if (pdata->orientation) { + pr_info("%s: set from board file.\n", __func__); + if (hwdep_driver. + set_position(pdata->orientation + - YAS532_POSITION_OFFSET) < 0) { + pr_err("set_position failed %d\n", rt); + goto err; + } + } else { + pr_info("%s: set from defconfig.\n", __func__); + if (hwdep_driver. + set_position( + CONFIG_INPUT_YAS_MAGNETOMETER_POSITION) + < 0) { + pr_err("set_position failed %d\n", rt); + goto err; + } + } + } else { + if (hwdep_driver. + set_position( + CONFIG_INPUT_YAS_MAGNETOMETER_POSITION) + < 0) { + pr_err("set_position() failed[%d]\n", rt); + goto err; + } + } + pr_info("%s: yas magnetic position is %d\n", __func__, + hwdep_driver.get_position()); + } + if (hwdep_driver.get_offset != NULL) { + if (hwdep_driver.get_offset(&data->driver_offset) < 0) { + YLOGE(("hwdep_driver get_driver_state failed\n")); + goto err; + } + } + if (hwdep_driver.get_delay != NULL) + data->delay = hwdep_driver.get_delay(); + + if (hwdep_driver.set_filter_enable != NULL) { + /* default to enable */ + if (hwdep_driver.set_filter_enable(1) == 0) + data->filter_enable = 1; + } + if (hwdep_driver.get_filter != NULL) { + if (hwdep_driver.get_filter(&filter) < 0) { + YLOGE(("hwdep_driver get_filter failed\n")); + goto err; + } + data->filter_len = filter.len; + for (i = 0; i < 3; i++) + data->filter_noise[i] = filter.noise[i]; + data->filter_threshold = filter.threshold; + } + if (hwdep_driver.get_static_matrix != NULL) + hwdep_driver.get_static_matrix(&data->static_matrix); + if (hwdep_driver.get_dynamic_matrix != NULL) + hwdep_driver.get_dynamic_matrix(&data->dynamic_matrix); +#ifdef SYSFS_PCBTEST + rt = yas_pcb_test_init(&pcbtest); + if (rt < 0) { + YLOGE(("yas_pcb_test_init failed[%d]\n", rt)); + goto err; + } +#endif +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + INIT_LIST_HEAD(&data->devfile_list); + INIT_LIST_HEAD(&data->raw_devfile_list); + if (misc_register(&sensor_devfile) < 0) + goto err; + if (misc_register(&sensor_raw_devfile) < 0) { + misc_deregister(&sensor_devfile); + goto err; + } +#endif + + rt = + geomagnetic_i2c_read(YAS_REGADDR_DEVICE_ID, &data->dev_id, 1); + if (rt) { + pr_err("%s: cound not read device id(%d).\n", + __func__, rt); + goto err; + } else + pr_info("%s: yamaha magnetic sensor id = %x\n", + __func__, data->dev_id); + + rt = sensors_register(data->magnetic_sensor_device, + NULL, magnetic_sensor_attrs, + "magnetic_sensor"); + if (rt) { + pr_err("%s: cound not register magnetic sensor device(%d).\n", + __func__, rt); + goto out_sensor_register_failed; + } + + return 0; + +out_sensor_register_failed: +err: + if (data != NULL) { + if (input_raw != NULL) { + if (sysfs_raw_created) + sysfs_remove_group(&input_raw->dev.kobj, + &geomagnetic_raw_attribute_group); + + if (raw_registered) + input_unregister_device(input_raw); + else + input_free_device(input_raw); + } + if (input_data != NULL) { + if (sysfs_created) + sysfs_remove_group(&input_data->dev.kobj, + &geomagnetic_attribute_group); + if (data_registered) + input_unregister_device(input_data); + else + input_free_device(input_data); + } + if (pdata) { + if (pdata->power_on) + pdata->power_on(false); + } + kfree(data); + } + + return rt; +} + +static int geomagnetic_remove(struct i2c_client *client) +{ + struct geomagnetic_data *data = i2c_get_clientdata(client); + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + misc_deregister(&sensor_devfile); + misc_deregister(&sensor_raw_devfile); +#endif + if (data != NULL) { + geomagnetic_disable(data); + if (hwdep_driver.term != NULL) + hwdep_driver.term(); + + input_unregister_device(data->input_raw); + sysfs_remove_group(&data->input_data->dev.kobj, + &geomagnetic_attribute_group); + sysfs_remove_group(&data->input_raw->dev.kobj, + &geomagnetic_raw_attribute_group); + input_unregister_device(data->input_data); + kfree(data); + } + + return 0; +} + +static void geomagnetic_shutdown(struct i2c_client *client) +{ + struct geomagnetic_data *data = i2c_get_clientdata(client); + + if (data != NULL) { + geomagnetic_disable(data); + if (data->mag_pdata) { + if (data->mag_pdata->power_on) + data->mag_pdata->power_on(false); + } + } +} + +/* I2C Device Driver */ +static struct i2c_device_id geomagnetic_idtable[] = { + {GEOMAGNETIC_I2C_DEVICE_NAME, 0}, + {} +}; + +MODULE_DEVICE_TABLE(i2c, geomagnetic_idtable); + +static struct i2c_driver geomagnetic_i2c_driver = { + .driver = { + .name = GEOMAGNETIC_I2C_DEVICE_NAME, + .owner = THIS_MODULE, + }, + + .id_table = geomagnetic_idtable, + .probe = geomagnetic_probe, + .remove = geomagnetic_remove, + .suspend = geomagnetic_suspend, + .resume = geomagnetic_resume, + .shutdown = geomagnetic_shutdown, +}; + +static int __init geomagnetic_init(void) +{ + return i2c_add_driver(&geomagnetic_i2c_driver); +} + +static void __exit geomagnetic_term(void) +{ + i2c_del_driver(&geomagnetic_i2c_driver); +} + +#ifdef GEOMAGNETIC_PLATFORM_API +static int geomagnetic_api_enable(int enable) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + int rt; + + if (geomagnetic_multi_lock() < 0) + return -1; + enable = !!enable; + rt = hwdep_driver.set_enable(enable); + if (rt == 0) { + atomic_set(&data->enable, enable); + if (enable) + rt = hwdep_driver.set_delay(20); + } + + geomagnetic_multi_unlock(); + + return rt; +} + +int geomagnetic_api_resume(void) +{ + return geomagnetic_api_enable(1); +} +EXPORT_SYMBOL(geomagnetic_api_resume); + +int geomagnetic_api_suspend(void) +{ + return geomagnetic_api_enable(0); +} +EXPORT_SYMBOL(geomagnetic_api_suspend); + +int geomagnetic_api_read(int *xyz, int *raw, int *xy1y2, int *accuracy) +{ + struct geomagnetic_data *data = i2c_get_clientdata(this_client); + struct yas_mag_data magdata; + int i; + + geomagnetic_work(&magdata); + if (xyz != NULL) { + for (i = 0; i < 3; i++) + xyz[i] = magdata.xyz.v[i]; + } + if (raw != NULL) { + for (i = 0; i < 3; i++) + raw[i] = magdata.raw.v[i]; + } + if (xy1y2 != NULL) { + for (i = 0; i < 3; i++) + xy1y2[i] = magdata.xy1y2.v[i]; + } + if (accuracy != NULL) + *accuracy = atomic_read(&data->last_status); + + return 0; +} +EXPORT_SYMBOL(geomagnetic_api_read); +#endif + +module_init(geomagnetic_init); +module_exit(geomagnetic_term); + +MODULE_AUTHOR("Yamaha Corporation"); +#if YAS_MAG_DRIVER == YAS_MAG_DRIVER_YAS529 +MODULE_DESCRIPTION("YAS529 Geomagnetic Sensor Driver"); +#elif YAS_MAG_DRIVER == YAS_MAG_DRIVER_YAS530 +MODULE_DESCRIPTION("YAS530 Geomagnetic Sensor Driver"); +#elif CONFIG_SENSORS_YAS532 +MODULE_DESCRIPTION("YAS532 Geomagnetic Sensor Driver"); +#endif +MODULE_LICENSE("GPL"); +MODULE_VERSION("4.4.702a"); diff --git a/drivers/sensor/yas_ori_kernel_driver.c b/drivers/sensor/yas_ori_kernel_driver.c new file mode 100644 index 0000000..20003aa --- /dev/null +++ b/drivers/sensor/yas_ori_kernel_driver.c @@ -0,0 +1,695 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * 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., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +#include <linux/delay.h> +#include <linux/errno.h> +#include <linux/i2c.h> +#include <linux/init.h> +#include <linux/input.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/poll.h> +#include <linux/slab.h> +#include <linux/types.h> +#include <linux/uaccess.h> +#include <linux/version.h> +#include <linux/workqueue.h> + +#define __LINUX_KERNEL_DRIVER__ +#include <linux/sensor/yas.h> + +#define SENSOR_NAME "orientation" +#define SENSOR_DEFAULT_DELAY (200) /* 200 ms */ +#define SENSOR_MAX_DELAY (2000) /* 2000 ms */ +#define ABS_STATUS (ABS_BRAKE) +#define ABS_WAKE (ABS_MISC) +#define ABS_CONTROL_REPORT (ABS_THROTTLE) + +static int suspend(void); +static int resume(void); + +struct sensor_data { + struct mutex mutex; + int enabled; + int delay; +#if DEBUG + int suspend; +#endif +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct list_head devfile_list; +#endif +}; + +static struct platform_device *sensor_pdev; +static struct input_dev *this_data; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE +#include <linux/miscdevice.h> +#define MAX_COUNT (64) + +struct sensor_device { + struct list_head list; + struct mutex lock; + wait_queue_head_t waitq; + struct input_event events[MAX_COUNT]; + int head, num_event; +}; + +static void get_time_stamp(struct timeval *tv) +{ + struct timespec ts; + ktime_get_ts(&ts); + tv->tv_sec = ts.tv_sec; + tv->tv_usec = ts.tv_nsec / 1000; +} + +static void make_event(struct input_event *ev, int type, int code, int value) +{ + struct timeval tv; + get_time_stamp(&tv); + ev->type = type; + ev->code = code; + ev->value = value; + ev->time = tv; +} + +static void +make_event_w_time(struct input_event *ev, int type, int code, int value, + struct timeval *tv) +{ + ev->type = type; + ev->code = code; + ev->value = value; + ev->time = *tv; +} + +static void sensor_enq(struct sensor_device *kdev, struct input_event *ev) +{ + int idx; + + idx = kdev->head + kdev->num_event; + if (MAX_COUNT <= idx) + idx -= MAX_COUNT; + kdev->events[idx] = *ev; + kdev->num_event++; + if (MAX_COUNT < kdev->num_event) { + kdev->num_event = MAX_COUNT; + kdev->head++; + if (MAX_COUNT <= kdev->head) + kdev->head -= MAX_COUNT; + } +} + +static int sensor_deq(struct sensor_device *kdev, struct input_event *ev) +{ + if (kdev->num_event == 0) + return 0; + + *ev = kdev->events[kdev->head]; + kdev->num_event--; + kdev->head++; + if (MAX_COUNT <= kdev->head) + kdev->head -= MAX_COUNT; + return 1; +} + +static void +sensor_event(struct list_head *devlist, struct input_event *ev, int num) +{ + struct sensor_device *kdev; + int i; + + list_for_each_entry(kdev, devlist, list) { + mutex_lock(&kdev->lock); + for (i = 0; i < num; i++) + sensor_enq(kdev, &ev[i]); + + mutex_unlock(&kdev->lock); + wake_up_interruptible(&kdev->waitq); + } +} + +static ssize_t +sensor_write(struct file *f, const char __user *buf, size_t count, + loff_t *pos) +{ + struct sensor_data *data = input_get_drvdata(this_data); + struct sensor_device *kdev; + struct input_event ev[MAX_COUNT]; + int num, i; + + if (count < sizeof(struct input_event)) + return -EINVAL; + + num = count / sizeof(struct input_event); + if (MAX_COUNT < num) + num = MAX_COUNT; + + if (copy_from_user(ev, buf, num * sizeof(struct input_event))) + return -EFAULT; + + list_for_each_entry(kdev, &data->devfile_list, list) { + mutex_lock(&kdev->lock); + for (i = 0; i < num; i++) + sensor_enq(kdev, &ev[i]); + mutex_unlock(&kdev->lock); + wake_up_interruptible(&kdev->waitq); + } + + return count; +} + +static ssize_t +sensor_read(struct file *f, char __user *buf, size_t count, loff_t *pos) +{ + struct sensor_device *kdev = f->private_data; + int rt, num; + struct input_event ev[MAX_COUNT]; + + if (count < sizeof(struct input_event)) + return -EINVAL; + + rt = wait_event_interruptible(kdev->waitq, kdev->num_event != 0); + if (rt) + return rt; + + mutex_lock(&kdev->lock); + for (num = 0; num < count / sizeof(struct input_event); num++) { + if (!sensor_deq(kdev, &ev[num])) + break; + } + mutex_unlock(&kdev->lock); + + if (copy_to_user(buf, ev, num * sizeof(struct input_event))) + return -EFAULT; + + return num * sizeof(struct input_event); +} + +static unsigned int sensor_poll(struct file *f, struct poll_table_struct *wait) +{ + struct sensor_device *kdev = f->private_data; + + poll_wait(f, &kdev->waitq, wait); + if (kdev->num_event != 0) + return POLLIN | POLLRDNORM; + + return 0; +} + +static int sensor_open(struct inode *inode, struct file *f) +{ + struct sensor_data *data = input_get_drvdata(this_data); + struct sensor_device *kdev; + + kdev = kzalloc(sizeof(struct sensor_device), GFP_KERNEL); + if (!kdev) + return -ENOMEM; + + mutex_init(&kdev->lock); + init_waitqueue_head(&kdev->waitq); + f->private_data = kdev; + kdev->head = 0; + kdev->num_event = 0; + list_add(&kdev->list, &data->devfile_list); + + return 0; +} + +static int sensor_release(struct inode *inode, struct file *f) +{ + struct sensor_device *kdev = f->private_data; + + list_del(&kdev->list); + kfree(kdev); + + return 0; +} + +const struct file_operations sensor_fops = { + .owner = THIS_MODULE, + .open = sensor_open, + .release = sensor_release, + .write = sensor_write, + .read = sensor_read, + .poll = sensor_poll, +}; + +static struct miscdevice sensor_devfile = { + .name = SENSOR_NAME, + .fops = &sensor_fops, + .minor = MISC_DYNAMIC_MINOR, +}; + +#endif + +static int suspend(void) +{ + /* implement suspend of the sensor */ + YLOGD(("%s: suspend\n", SENSOR_NAME)); + + return 0; +} + +static int resume(void) +{ + /* implement resume of the sensor */ + YLOGD(("%s: resume\n", SENSOR_NAME)); + + return 0; +} + +/* Sysfs interface */ +static ssize_t +sensor_delay_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct sensor_data *data = input_get_drvdata(input_data); + int delay; + + mutex_lock(&data->mutex); + + delay = data->delay; + + mutex_unlock(&data->mutex); + + return sprintf(buf, "%d\n", delay); +} + +static ssize_t +sensor_delay_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct sensor_data *data = input_get_drvdata(input_data); + long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; +#endif + + if (value < 0) + return count; + + if (SENSOR_MAX_DELAY < value) + value = SENSOR_MAX_DELAY; + + mutex_lock(&data->mutex); + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + make_event(ev, EV_ABS, ABS_CONTROL_REPORT, + (data->enabled << 16) | value); + sensor_event(&data->devfile_list, ev, 1); +#endif + data->delay = value; +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(input_data, ABS_CONTROL_REPORT, + (data->enabled << 16) | value); +#endif + + mutex_unlock(&data->mutex); + + return count; +} + +static ssize_t +sensor_enable_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + struct sensor_data *data = input_get_drvdata(input_data); + int enabled; + + mutex_lock(&data->mutex); + + enabled = data->enabled; + + mutex_unlock(&data->mutex); + + return sprintf(buf, "%d\n", enabled); +} + +static ssize_t +sensor_enable_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + struct sensor_data *data = input_get_drvdata(input_data); + unsigned long value; + int error; + + error = strict_strtoul(buf, 10, &value); + if (unlikely(error)) + return error; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; +#endif + + value = !(!value); + + mutex_lock(&data->mutex); + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + make_event(ev, EV_ABS, ABS_CONTROL_REPORT, (value << 16) | data->delay); + sensor_event(&data->devfile_list, ev, 1); +#else + input_report_abs(input_data, ABS_CONTROL_REPORT, + (value << 16) | data->delay); + input_sync(input_data); +#endif + + if (data->enabled && !value) + suspend(); + if (!data->enabled && value) + resume(); + data->enabled = value; + + mutex_unlock(&data->mutex); + + return count; +} + +static ssize_t +sensor_wake_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct input_dev *input_data = to_input_dev(dev); + static int cnt = 1; +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct sensor_data *data = input_get_drvdata(input_data); + struct input_event ev[2]; + struct timeval tv; + get_time_stamp(&tv); + make_event_w_time(&ev[0], EV_ABS, ABS_WAKE, cnt++, &tv); + make_event_w_time(&ev[1], EV_SYN, 0, 0, &tv); + sensor_event(&data->devfile_list, ev, 2); +#else + input_report_abs(input_data, ABS_WAKE, cnt++); + input_sync(input_data); +#endif + + return count; +} + +#if DEBUG + +static int sensor_suspend(struct platform_device *pdev, pm_message_t state); +static int sensor_resume(struct platform_device *pdev); + +static ssize_t +sensor_debug_suspend_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct input_dev *input = to_input_dev(dev); + struct sensor_data *data = input_get_drvdata(input); + + return sprintf(buf, "%d\n", data->suspend); +} + +static ssize_t +sensor_debug_suspend_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + unsigned long suspend; + int error; + + error = strict_strtoul(buf, 10, &suspend); + if (unlikely(error)) + return error; + + + if (suspend) { + pm_message_t msg; + memset(&msg, 0, sizeof(msg)); + sensor_suspend(sensor_pdev, msg); + } else + sensor_resume(sensor_pdev); + + return count; +} + +#endif /* DEBUG */ + +static ssize_t +sensor_data_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + int x, y, z; + + x = input_abs_get_val(input_data, ABS_X); + y = input_abs_get_val(input_data, ABS_Y); + z = input_abs_get_val(input_data, ABS_Z); + + return sprintf(buf, "%d %d %d\n", x, y, z); +} + +static ssize_t +sensor_status_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + struct input_dev *input_data = to_input_dev(dev); + int status; + + status = input_abs_get_val(input_data, ABS_STATUS); + + return sprintf(buf, "%d\n", status); +} + +static DEVICE_ATTR(delay, S_IRUGO | S_IWUSR | S_IWGRP, + sensor_delay_show, sensor_delay_store); +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP, + sensor_enable_show, sensor_enable_store); +static DEVICE_ATTR(wake, S_IWUSR | S_IWGRP, NULL, sensor_wake_store); +static DEVICE_ATTR(data, S_IRUGO, sensor_data_show, NULL); +static DEVICE_ATTR(status, S_IRUGO, sensor_status_show, NULL); + +#if DEBUG +static DEVICE_ATTR(debug_suspend, S_IRUGO | S_IWUSR, + sensor_debug_suspend_show, sensor_debug_suspend_store); +#endif /* DEBUG */ + +static struct attribute *sensor_attributes[] = { + &dev_attr_delay.attr, + &dev_attr_enable.attr, + &dev_attr_wake.attr, + &dev_attr_data.attr, + &dev_attr_status.attr, +#if DEBUG + &dev_attr_debug_suspend.attr, +#endif /* DEBUG */ + NULL +}; + +static struct attribute_group sensor_attribute_group = { + .attrs = sensor_attributes +}; + +static int sensor_suspend(struct platform_device *pdev, pm_message_t state) +{ + struct sensor_data *data = input_get_drvdata(this_data); + int rt = 0; + + mutex_lock(&data->mutex); + + if (data->enabled) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_CONTROL_REPORT, + (0 << 16) | data->delay); + sensor_event(&data->devfile_list, ev, 1); +#else + input_report_abs(this_data, ABS_CONTROL_REPORT, + (0 << 16) | data->delay); +#endif + rt = suspend(); + } + + mutex_unlock(&data->mutex); + + return rt; +} + +static int sensor_resume(struct platform_device *pdev) +{ + struct sensor_data *data = input_get_drvdata(this_data); + int rt = 0; + + mutex_lock(&data->mutex); + + if (data->enabled) { +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + struct input_event ev[1]; + make_event(ev, EV_ABS, ABS_CONTROL_REPORT, + (1 << 16) | data->delay); + sensor_event(&data->devfile_list, ev, 1); +#endif + rt = resume(); +#ifndef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + input_report_abs(this_data, ABS_CONTROL_REPORT, + (1 << 16) | data->delay); +#endif + } + + mutex_unlock(&data->mutex); + + return rt; +} + +static int sensor_probe(struct platform_device *pdev) +{ + struct sensor_data *data = NULL; + struct input_dev *input_data = NULL; + int input_registered = 0, sysfs_created = 0; + int rt; + + data = kzalloc(sizeof(struct sensor_data), GFP_KERNEL); + if (!data) { + rt = -ENOMEM; + goto err; + } + data->enabled = 0; + data->delay = SENSOR_DEFAULT_DELAY; + + input_data = input_allocate_device(); + if (!input_data) { + rt = -ENOMEM; + YLOGE(("sensor_probe: Failed to allocate input_data device\n")); + goto err; + } + + set_bit(EV_ABS, input_data->evbit); + input_set_abs_params(input_data, ABS_X, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_Y, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_Z, 0x80000000, 0x7fffffff, 0, 0); + input_set_abs_params(input_data, ABS_RUDDER, 0x80000000, 0x7fffffff, 0, + 0); + input_set_abs_params(input_data, ABS_STATUS, 0, 3, 0, 0); + input_set_abs_params(input_data, ABS_WAKE, 0x80000000, 0x7fffffff, 0, + 0); + input_set_abs_params(input_data, ABS_CONTROL_REPORT, 0x80000000, + 0x7fffffff, 0, 0); + input_data->name = SENSOR_NAME; + + rt = input_register_device(input_data); + if (rt) { + YLOGE(("ori Unable to reg input_data %s\n", input_data->name)); + goto err; + } + input_set_drvdata(input_data, data); + input_registered = 1; + + rt = sysfs_create_group(&input_data->dev.kobj, &sensor_attribute_group); + if (rt) { + YLOGE(("sensor_probe: sysfs_create_group failed[%s]\n", + input_data->name)); + goto err; + } + sysfs_created = 1; + mutex_init(&data->mutex); + this_data = input_data; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + INIT_LIST_HEAD(&data->devfile_list); + if (misc_register(&sensor_devfile) < 0) + goto err; +#endif + + return 0; + +err: + if (data != NULL) { + if (input_data != NULL) { + if (sysfs_created) + sysfs_remove_group(&input_data->dev.kobj, + &sensor_attribute_group); + if (input_registered) + input_unregister_device(input_data); + else + input_free_device(input_data); + input_data = NULL; + } + kfree(data); + } + + return rt; +} + +static int sensor_remove(struct platform_device *pdev) +{ + struct sensor_data *data; + +#ifdef YAS_SENSOR_KERNEL_DEVFILE_INTERFACE + misc_deregister(&sensor_devfile); +#endif + if (this_data != NULL) { + data = input_get_drvdata(this_data); + sysfs_remove_group(&this_data->dev.kobj, + &sensor_attribute_group); + input_unregister_device(this_data); + if (data != NULL) + kfree(data); + } + + return 0; +} + +/* + * Module init and exit + */ +static struct platform_driver sensor_driver = { + .probe = sensor_probe, + .remove = sensor_remove, + .suspend = sensor_suspend, + .resume = sensor_resume, + .driver = { + .name = SENSOR_NAME, + .owner = THIS_MODULE, + }, +}; + +static int __init sensor_init(void) +{ + sensor_pdev = platform_device_register_simple(SENSOR_NAME, 0, NULL, 0); + if (IS_ERR(sensor_pdev)) + return -1; + return platform_driver_register(&sensor_driver); +} + +module_init(sensor_init); + +static void __exit sensor_exit(void) +{ + platform_driver_unregister(&sensor_driver); + platform_device_unregister(sensor_pdev); +} + +module_exit(sensor_exit); + +MODULE_AUTHOR("Yamaha Corporation"); +MODULE_LICENSE("GPL"); +MODULE_VERSION("4.4.702a"); diff --git a/drivers/sensor/yas_pcb_test.c b/drivers/sensor/yas_pcb_test.c new file mode 100644 index 0000000..686c8c6 --- /dev/null +++ b/drivers/sensor/yas_pcb_test.c @@ -0,0 +1,1282 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * 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., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +/* + * File yas_pcb_test.c + * Brief pcb test program for yas530/yas532 + * Date 2013/1/22 + * Revision 1.4.3 + */ +#include "yas_pcb_test.h" + +/* define */ +/* reg num */ +#define YAS530_CAL_REG_NUM (16) +#define YAS532_CAL_REG_NUM (14) +#define YAS_PCB_MEASURE_DATA_REG_NUM (8) + +/* default value */ +#define YAS_PCB_TEST1_DEFAULT (0x00) +#define YAS_PCB_TEST2_DEFAULT (0x00) +#define YAS_PCB_INTERVAL_DEFAULT (0x00) +#define YAS_PCB_CONFIG_DEFAULT (0x01) /* INTON = 1 */ +#define YAS_PCB_COIL_DEFAULT (0x00) + +/* measure command */ +#define YAS_PCB_MEASURE_COMMAND_START (0x01) +#define YAS_PCB_MEASURE_COMMAND_LDTC (0x02) +#define YAS_PCB_MEASURE_COMMAND_FORS (0x04) + +#define YAS_PCB_MEASURE_BUSY (0x80) + +#define YAS_PCB_MEASURE_WAIT_TIME (2) /* ms */ +#define YAS_PCB_HARD_OFFSET_CORRECT (16) +#define YAS_PCB_COIL_INIT_CALC_NUM (5) + +#define YAS_PCB_HARD_OFFSET_MASK (0x3F) + +#define YAS_PCB_INT_CHECK (1) +#define YAS_PCB_INT_NOTCHECK (0) +#define YAS_PCB_INT_HIGH (1) +#define YAS_PCB_INT_LOW (0) + +#define YAS_PCB_ACC_Z (9806550L) /* m/s2 */ + +#define YAS530_DEVICE_ID (0x01) /* MS-3E */ +#define YAS532_DEVICE_ID (0x02) /* MS-3R */ + +#define YAS530_VERSION_A (0) /* MS-3E Aver */ +#define YAS530_VERSION_B (1) /* MS-3E Bver */ +/*#define YAS530_VERSION_AB (0)*/ /* MS-3R ABver */ +#define YAS532_VERSION_AC (1) /* MS-3R ACver */ + +#define YAS530_COEF_VERSION_A (380) +#define YAS530_COEF_VERSION_B (550) +/*#define YAS532_COEF_VERSION_AB (1800)*/ +/*#define YAS532_COEF_VERSION_AC (900)*/ +#define YAS532_COEFX_VERSION_AC (850) +#define YAS532_COEFY1_VERSION_AC (750) +#define YAS532_COEFY2_VERSION_AC (750) + +#define YAS530_RAWDATA_CENTER (2048) +#define YAS530_RAWDATA_OVERFLOW (4095) +#define YAS532_RAWDATA_CENTER (4096) +#define YAS532_RAWDATA_OVERFLOW (8190) + +#define YAS_PCB_DIR_DIVIDER (400) + +#define YAS_PCB_TEST1 (0) +#define YAS_PCB_TEST3 (1) +#define YAS_PCB_TEST4 (2) +#define YAS_PCB_TEST5 (3) +#define YAS_PCB_TEST6 (4) +#define YAS_PCB_TEST7 (5) +#define YAS_PCB_TEST8 (6) +#define YAS_PCB_TEST2 (7) +#define YAS_PCB_TEST_NUM (8) + +/* typedef */ +struct yas_pcb_vector { + int32_t v[3]; +}; + +struct yas_pcb_correction { + int32_t s32Cx, s32Cy1, s32Cy2; + int32_t s32A2, s32A3, s32A4, s32A5, s32A6, s32A7, s32A8, s32A9, s32K; + int32_t s32ZFlag; + int32_t s32Rx, s32Ry1, s32Ry2; + int32_t s32Fx, s32Fy1, s32Fy2; + int32_t s32Ver; +}; + +struct yas_pcb_sensitivity { + int32_t s32Sx, s32Sy, s32Sz; +}; + +/* values */ +static uint16_t gu16State; +static struct yas_pcb_test_callback g_callback; +static struct yas_pcb_vector gstXy1y2; +static int8_t gs08HardOffset[3]; +static struct yas_pcb_correction gstCorrect; +static uint8_t gu08DevId; +static int32_t gs32Center; +static int32_t gs32Overflow; +#ifdef YAS_PCBTEST_EXTRA +static uint8_t gu08Recalc; +static int32_t gs32RecalcWait; +#endif + +/* functions */ +static int Ms3AxesLibAtan8(int, int, short *); +static int Ms3AxesLibDir8(int, int, unsigned short *); +static int yas_pcb_check_state(int); +static void yas_pcb_update_state(int); +static int yas_pcb_power_on(void); +static int yas_pcb_power_off(void); +static int yas_pcb_reset_coil(void); +static int yas530_read_cal(uint8_t *); +static int yas532_read_cal(uint8_t *); +static void yas530_calc_correction(const uint8_t *); +static void yas532_calc_correction(const uint8_t *); +static int yas_pcb_set_offset(const int8_t *); +static int yas_pcb_measure(struct yas_pcb_vector *, int *, uint8_t, uint8_t); +static int yas_pcb_is_flow_occued(struct yas_pcb_vector *, int32_t, int32_t); +static void yas_pcb_calc_sensitivity(struct yas_pcb_vector *, + int, struct yas_pcb_sensitivity *); +static void yas_pcb_calc_position(struct yas_pcb_vector *, + struct yas_pcb_vector *, int); +static int yas_pcb_calc_magnetic_field(struct yas_pcb_vector *, + struct yas_pcb_vector *); +static int yas_pcb_test1(int *); +static int yas_pcb_test2(void); +static int yas_pcb_test3(void); +static int yas_pcb_test4(int *, int *, int *); +static int yas_pcb_test5(int *); +static int yas_pcb_test6(int *, int *); +#ifdef YAS_PCBTEST_EXTRA +static int yas_pcb_test7(int *, int *, int *); +#endif + +static int Ms3AxesLibAtan8(int ss, int cc, short *ans) +{ + static const unsigned char AtanTable[] = { + 0, 1, 3, 5, 6, 8, 11, 13, + 15, 18, 21, 24, 27, 31, 34, 39, + 43, 48, 53, 58, 63, 69, 75, 82, + 89, 96, 103, 110, 118, 126, 134, 143, + 152 + }; + + unsigned char idx; + unsigned short idx_mul64; + signed char sign = 1; + unsigned int ucc; + unsigned int uss; + unsigned short ans_mul8; + unsigned char idx_mod64; + unsigned short ans_diff8; + + if (cc < 0) { + sign = -sign; + ucc = -cc; + } else { + ucc = cc; + } + + if (ss < 0) { + sign = -sign; + uss = -ss; + } else { + uss = ss; + } + + while (ucc >= 0x400) { + ucc >>= 1; + uss >>= 1; + } + + if (ucc == 0) + return -1; + + idx_mul64 = (uss << 11) / ucc; + + idx = idx_mul64 >> 6; + ans_mul8 = (idx << 4) - AtanTable[idx]; + + idx_mod64 = (unsigned char)idx_mul64 & 0x3f; + + if (idx < 32) { + idx++; + ans_diff8 = (idx << 4) - AtanTable[idx] - ans_mul8; + ans_mul8 += (ans_diff8 * idx_mod64) >> 6; + } + + *ans = (sign == 1) ? ans_mul8 : (-ans_mul8); + + return 0; +} + +static int Ms3AxesLibDir8(int ss, int cc, unsigned short *ans) +{ + short temp_ans = 0; + int ucc = cc; + int uss = ss; + int ret = 0; + + if (cc < -2147483647) + cc++; + if (ss < -2147483647) + ss++; + + if (cc < 0) + ucc = -cc; + + if (ss < 0) + uss = -ss; + + if (uss <= ucc) { + ret = Ms3AxesLibAtan8(ss, cc, &temp_ans); + if (ret < 0) + return 1; + + if (cc > 0) { + if (temp_ans < 0) + temp_ans += 2880; + } else + temp_ans += 1440; + } else { + ret = Ms3AxesLibAtan8(cc, ss, &temp_ans); + if (ret < 0) + return 1; + + if (ss > 0) + temp_ans = 720 - temp_ans; + else + temp_ans = 2160 - temp_ans; + } + + *ans = temp_ans; + + return 0; +} + +static int yas_pcb_check_state(int id) +{ + int result = YAS_PCB_ERROR_TEST_ORDER; + uint16_t u16Mask; + const uint16_t u16TestTable[] = { + 0x0000, /* 1 */ + 0x0000, /* 3 */ + (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3), /* 4 */ + (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3) + | (1 << YAS_PCB_TEST4), /* 5 */ + (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3) + | (1 << YAS_PCB_TEST4), /* 6 */ + (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3) + | (1 << YAS_PCB_TEST4) /* 7 */ + | (1 << YAS_PCB_TEST5), + (1 << YAS_PCB_TEST1) | (1 << YAS_PCB_TEST3) + | (1 << YAS_PCB_TEST4), /* 8 */ + (1 << YAS_PCB_TEST1), /* 2 */ + }; + + if ((YAS_PCB_TEST1 <= id) && (id < YAS_PCB_TEST_NUM)) { + u16Mask = u16TestTable[id]; + if (u16Mask == 0) { + switch (id) { + case YAS_PCB_TEST1: + if ((gu16State == 0) + || (gu16State == (1 << YAS_PCB_TEST1))) + result = YAS_PCB_NO_ERROR; + break; + + case YAS_PCB_TEST3: + if ((gu16State == (1 << YAS_PCB_TEST1)) + || (gu16State == + ((1 << YAS_PCB_TEST1) + | (1 << YAS_PCB_TEST3)))) + result = YAS_PCB_NO_ERROR; + break; + + default: + break; + } + } else { + if ((gu16State & u16Mask) == u16Mask) + result = YAS_PCB_NO_ERROR; + } + } + + return result; +} + +static void yas_pcb_update_state(int id) +{ + if ((YAS_PCB_TEST1 <= id) && (id < YAS_PCB_TEST2)) + gu16State |= (uint16_t)(1 << id); + else + gu16State = 0; +} + +static int yas_pcb_power_on(void) +{ + int result = YAS_PCB_NO_ERROR; + int ret; + + if (NULL != g_callback.power_on) { + ret = g_callback.power_on(); + if (0 != ret) + result = YAS_PCB_ERROR_POWER; + } + + return result; +} + +static int yas_pcb_power_off(void) +{ + int result = YAS_PCB_NO_ERROR; + int ret; + + if (NULL != g_callback.power_off) { + ret = g_callback.power_off(); + if (0 != ret) + result = YAS_PCB_ERROR_POWER; + } + + return result; +} + +static int yas_pcb_reset_coil(void) +{ + int ret; + uint8_t u08Data; + u08Data = YAS_PCB_COIL_DEFAULT; + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_COIL, + &u08Data, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + return YAS_PCB_NO_ERROR; +} +static int yas530_read_cal(uint8_t *pu08Buf) +{ + int i; + int ret; + int size = YAS530_CAL_REG_NUM; + + /* Dummy read */ + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL, + pu08Buf, size); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL, + pu08Buf, size); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + /* cal register is all 0 */ + for (i = 0; i < size; i++) { + if (pu08Buf[i] != 0x00) + return YAS_PCB_NO_ERROR; + } + + return YAS_PCB_ERROR_CALREG; +} + + +static int yas532_read_cal(uint8_t *pu08Buf) +{ + int i; + int ret; + int size = YAS532_CAL_REG_NUM; + int len = size - 1; + + /* Dummy read */ + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL, + pu08Buf, size); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_CAL, + pu08Buf, size); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + /* cal register is all 0 */ + for (i = 0; i < len; i++) { + if (pu08Buf[i] != 0x00) + return YAS_PCB_NO_ERROR; + } + + /* MSB is not 0 */ + if (pu08Buf[len] & 0x80) + return YAS_PCB_NO_ERROR; + + return YAS_PCB_ERROR_CALREG; +} + +static void yas530_calc_correction(const uint8_t *pu08Data) +{ + uint8_t u08Dx = pu08Data[0]; + uint8_t u08Dy1 = pu08Data[1]; + uint8_t u08Dy2 = pu08Data[2]; + uint8_t u08D2 = (uint8_t)((pu08Data[3] >> 2) & 0x3F); + uint8_t u08D3 = (uint8_t)(((pu08Data[3] << 2) & 0x0C) + | ((pu08Data[4] >> 6) & 0x03)); + uint8_t u08D4 = (uint8_t)(pu08Data[4] & 0x3F); + uint8_t u08D5 = (uint8_t)((pu08Data[5] >> 2) & 0x3f); + uint8_t u08D6 = (uint8_t)(((pu08Data[5] << 4) & 0x30) + | ((pu08Data[6] >> 4) & 0x0F)); + uint8_t u08D7 = (uint8_t)(((pu08Data[6] << 3) & 0x78) + | ((pu08Data[7] >> 5) & 0x07)); + uint8_t u08D8 = (uint8_t)(((pu08Data[7] << 1) & 0x3E) + | ((pu08Data[8] >> 7) & 0x01)); + uint8_t u08D9 = (uint8_t)(((pu08Data[8] << 1) & 0xFE) + | ((pu08Data[9] >> 7) & 0x01)); + uint8_t u08D0 = (uint8_t)((pu08Data[9] >> 2) & 0x1F); + uint8_t u08ZFlag = (uint8_t)((pu08Data[11] >> 5) & 0x01); + uint8_t u08Rx = (uint8_t)(((pu08Data[11] << 1) & 0x3E) + | ((pu08Data[12] >> 7) & 0x01)); + uint8_t u08Fx = (uint8_t)((pu08Data[12] >> 5) & 0x03); + uint8_t u08Ry1 = (uint8_t)(((pu08Data[12] << 1) & 0x3E) + | ((pu08Data[13] >> 7) & 0x01)); + uint8_t u08Fy1 = (uint8_t)((pu08Data[13] >> 5) & 0x03); + uint8_t u08Ry2 = (uint8_t)(((pu08Data[13] << 1) & 0x3E) + | ((pu08Data[14] >> 7) & 0x01)); + uint8_t u08Fy2 = (uint8_t)((pu08Data[14] >> 5) & 0x03); + uint8_t u08Ver = pu08Data[15] & 0x07; + + gstCorrect.s32Cx = (int32_t)((u08Dx * 6) - 768); + gstCorrect.s32Cy1 = (int32_t)((u08Dy1 * 6) - 768); + gstCorrect.s32Cy2 = (int32_t)((u08Dy2 * 6) - 768); + gstCorrect.s32A2 = (int32_t)(u08D2 - 32); + gstCorrect.s32A3 = (int32_t)(u08D3 - 8); + gstCorrect.s32A4 = (int32_t)(u08D4 - 32); + gstCorrect.s32A5 = (int32_t)(u08D5 + 38); + gstCorrect.s32A6 = (int32_t)(u08D6 - 32); + gstCorrect.s32A7 = (int32_t)(u08D7 - 64); + gstCorrect.s32A8 = (int32_t)(u08D8 - 32); + gstCorrect.s32A9 = (int32_t)u08D9; + gstCorrect.s32K = (int32_t)(u08D0) + 10; + gstCorrect.s32ZFlag = (int32_t)u08ZFlag; + gstCorrect.s32Rx = (int32_t)((int8_t)(u08Rx << 2) >> 2); + gstCorrect.s32Fx = (int32_t)u08Fx; + gstCorrect.s32Ry1 = (int32_t)((int8_t)(u08Ry1 << 2) >> 2); + gstCorrect.s32Fy1 = (int32_t)u08Fy1; + gstCorrect.s32Ry2 = (int32_t)((int8_t)(u08Ry2 << 2) >> 2); + gstCorrect.s32Fy2 = (int32_t)u08Fy2; + gstCorrect.s32Ver = (int32_t)u08Ver; +} + +static void yas532_calc_correction(const uint8_t *pu08Data) +{ + uint8_t u08Dx = pu08Data[0]; + uint8_t u08Dy1 = pu08Data[1]; + uint8_t u08Dy2 = pu08Data[2]; + uint8_t u08D2 = (uint8_t)((pu08Data[3] >> 2) & 0x3F); + uint8_t u08D3 = (uint8_t)(((pu08Data[3] << 2) & 0x0C) + | ((pu08Data[4] >> 6) & 0x03)); + uint8_t u08D4 = (uint8_t)(pu08Data[4] & 0x3F); + uint8_t u08D5 = (uint8_t)((pu08Data[5] >> 2) & 0x3f); + uint8_t u08D6 = (uint8_t)(((pu08Data[5] << 4) & 0x30) + | ((pu08Data[6] >> 4) & 0x0F)); + uint8_t u08D7 = (uint8_t)(((pu08Data[6] << 3) & 0x78) + | ((pu08Data[7] >> 5) & 0x07)); + uint8_t u08D8 = (uint8_t)(((pu08Data[7] << 1) & 0x3E) + | ((pu08Data[8] >> 7) & 0x01)); + uint8_t u08D9 = (uint8_t)(((pu08Data[8] << 1) & 0xFE) + | ((pu08Data[9] >> 7) & 0x01)); + uint8_t u08D0 = (uint8_t)((pu08Data[9] >> 2) & 0x1F); + uint8_t u08Rx = (uint8_t)((pu08Data[10] >> 1) & 0x3F); + uint8_t u08Fx = (uint8_t)(((pu08Data[10] & 0x01) << 1) + | ((pu08Data[11] >> 7) & 0x01)); + uint8_t u08Ry1 = (uint8_t)((pu08Data[11] >> 1) & 0x3F); + uint8_t u08Fy1 = (uint8_t)(((pu08Data[11] & 0x01) << 1) + | ((pu08Data[12] >> 7) & 0x01)); + uint8_t u08Ry2 = (uint8_t)((pu08Data[12] >> 1) & 0x3F); + uint8_t u08Fy2 = (uint8_t)(((pu08Data[12] & 0x01) << 1) + | ((pu08Data[13] >> 7) & 0x01)); + uint8_t u08Ver = pu08Data[13] & 0x01; + + gstCorrect.s32Cx = (int32_t)((u08Dx * 10) - 1280); + gstCorrect.s32Cy1 = (int32_t)((u08Dy1 * 10) - 1280); + gstCorrect.s32Cy2 = (int32_t)((u08Dy2 * 10) - 1280); + gstCorrect.s32A2 = (int32_t)(u08D2 - 32); + gstCorrect.s32A3 = (int32_t)(u08D3 - 8); + gstCorrect.s32A4 = (int32_t)(u08D4 - 32); + gstCorrect.s32A5 = (int32_t)(u08D5 + 38); + gstCorrect.s32A6 = (int32_t)(u08D6 - 32); + gstCorrect.s32A7 = (int32_t)(u08D7 - 64); + gstCorrect.s32A8 = (int32_t)(u08D8 - 32); + gstCorrect.s32A9 = (int32_t)u08D9; + gstCorrect.s32K = (int32_t)u08D0; + gstCorrect.s32ZFlag = (int32_t)1; + gstCorrect.s32Rx = (int32_t)((int8_t)(u08Rx << 2) >> 2); + gstCorrect.s32Fx = (int32_t)u08Fx; + gstCorrect.s32Ry1 = (int32_t)((int8_t)(u08Ry1 << 2) >> 2); + gstCorrect.s32Fy1 = (int32_t)u08Fy1; + gstCorrect.s32Ry2 = (int32_t)((int8_t)(u08Ry2 << 2) >> 2); + gstCorrect.s32Fy2 = (int32_t)u08Fy2; + gstCorrect.s32Ver = (int32_t)u08Ver; +} + +static int yas_pcb_set_offset(const int8_t *ps08Offset) +{ + int result = YAS_PCB_NO_ERROR; + int ret; + uint8_t u08Addr; + uint8_t u08Data; + uint8_t i; + + for (i = 0; i < 3; i++) { + u08Addr = (uint8_t)(YAS_PCB_ADDR_OFFSET + i); + u08Data = (uint8_t)ps08Offset[i] & YAS_PCB_HARD_OFFSET_MASK; + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, + u08Addr, &u08Data, 1); + if (0 != ret) { + result = YAS_PCB_ERROR_I2C; + break; + } + } + + return result; +} + +static int yas_pcb_measure(struct yas_pcb_vector *pstXy1y2, int *temperature, + uint8_t u08Command, uint8_t u08CheckIni) +{ + int ret; + uint8_t u08Buf[YAS_PCB_MEASURE_DATA_REG_NUM]; + int low_or_high; + + if ((YAS_PCB_INT_CHECK == u08CheckIni) + && (NULL != g_callback.read_intpin)) { + ret = g_callback.read_intpin(&low_or_high); + if ((0 != ret) || (YAS_PCB_INT_HIGH != low_or_high)) + return YAS_PCB_ERROR_INTERRUPT; + } + + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, + YAS_PCB_ADDR_MEASURE_COMMAND, + &u08Command, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + g_callback.msleep(YAS_PCB_MEASURE_WAIT_TIME); + + if ((YAS_PCB_INT_CHECK == u08CheckIni) + && (NULL != g_callback.read_intpin)) { + ret = g_callback.read_intpin(&low_or_high); + if ((0 != ret) || (YAS_PCB_INT_LOW != low_or_high)) + return YAS_PCB_ERROR_INTERRUPT; + } + + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_MEASURE_DATA, + u08Buf, YAS_PCB_MEASURE_DATA_REG_NUM); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + /* calc measure data */ + if (YAS532_DEVICE_ID == gu08DevId) { + *temperature = (((int32_t)(u08Buf[0] & 0x7F) << 3) + | ((u08Buf[1] >> 5) & 0x07)); + pstXy1y2->v[0] = (int32_t)(((int32_t)(u08Buf[2] & 0x7F) << 6) + | ((u08Buf[3] >> 2) & 0x3F)); + pstXy1y2->v[1] = (int32_t)(((int32_t)(u08Buf[4] & 0x7F) << 6) + | ((u08Buf[5] >> 2) & 0x3F)); + pstXy1y2->v[2] = (int32_t)(((int32_t)(u08Buf[6] & 0x7F) << 6) + | ((u08Buf[7] >> 2) & 0x3F)); + } else { + *temperature = (((int32_t)(u08Buf[0] & 0x7F) << 2) + | ((u08Buf[1] >> 6) & 0x03)); + pstXy1y2->v[0] = (int32_t)(((int32_t)(u08Buf[2] & 0x7F) << 5) + | ((u08Buf[3] >> 3) & 0x1F)); + pstXy1y2->v[1] = (int32_t)(((int32_t)(u08Buf[4] & 0x7F) << 5) + | ((u08Buf[5] >> 3) & 0x1F)); + pstXy1y2->v[2] = (int32_t)(((int32_t)(u08Buf[6] & 0x7F) << 5) + | ((u08Buf[7] >> 3) & 0x1F)); + } + + if (YAS_PCB_MEASURE_BUSY == (u08Buf[0] & YAS_PCB_MEASURE_BUSY)) + return YAS_PCB_ERROR_BUSY; + + return YAS_PCB_NO_ERROR; +} + +static int yas_pcb_is_flow_occued(struct yas_pcb_vector *pstXy1y2, + int32_t underflow, int32_t overflow) +{ + int result = YAS_PCB_NO_ERROR; + int32_t s32Tmp; + uint8_t i; + + for (i = 0; i < 3; i++) { + s32Tmp = pstXy1y2->v[i]; + if (s32Tmp <= underflow) + result = YAS_PCB_ERROR_UNDERFLOW; + else + if (overflow <= s32Tmp) + result = YAS_PCB_ERROR_OVERFLOW; + } + + return result; +} + +static void yas_pcb_calc_sensitivity(struct yas_pcb_vector *pstXy1y2, + int temperature, struct yas_pcb_sensitivity *pstYasSensitivity) +{ + /* calc XYZ data from xy1y2 data */ + int32_t s32Sx = pstXy1y2->v[0] + - ((gstCorrect.s32Cx * temperature) / 100); + int32_t s32Sy1 = pstXy1y2->v[1] + - ((gstCorrect.s32Cy1 * temperature) / 100); + int32_t s32Sy2 = pstXy1y2->v[2] + - ((gstCorrect.s32Cy2 * temperature) / 100); + int32_t s32Sy = s32Sy1 - s32Sy2; + int32_t s32Sz = -s32Sy1 - s32Sy2; + + pstYasSensitivity->s32Sx = s32Sx; + pstYasSensitivity->s32Sy = s32Sy; + pstYasSensitivity->s32Sz = s32Sz; +} + +static void yas_pcb_calc_position(struct yas_pcb_vector *pstXy1y2, + struct yas_pcb_vector *pstXyz, int temperature) +{ + struct yas_pcb_sensitivity stSensitivity; + struct yas_pcb_sensitivity *pst; + + yas_pcb_calc_sensitivity(pstXy1y2, temperature, &stSensitivity); + + pst = &stSensitivity; + pstXyz->v[0] = (gstCorrect.s32K + * ((100 * pst->s32Sx) + (gstCorrect.s32A2 * pst->s32Sy) + + (gstCorrect.s32A3 * pst->s32Sz))) / 10; + pstXyz->v[1] = (gstCorrect.s32K * ((gstCorrect.s32A4 * pst->s32Sx) + + (gstCorrect.s32A5 * pst->s32Sy) + + (gstCorrect.s32A6 * pst->s32Sz))) / 10; + pstXyz->v[2] = (gstCorrect.s32K * ((gstCorrect.s32A7 * pst->s32Sx) + + (gstCorrect.s32A8 * pst->s32Sy) + + (gstCorrect.s32A9 * pst->s32Sz))) / 10; +} + +static void yas530_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2, + struct yas_pcb_vector *pstXyz, int32_t s32Coef) +{ + int32_t s32Oy; + int32_t s32Oz; + static const int32_t s32HTbl[] = { + 1748, 1948, 2148, 2348 + }; + + pstXy1y2->v[0] = gstXy1y2.v[0] - s32HTbl[gstCorrect.s32Fx] + + (gs08HardOffset[0] - gstCorrect.s32Rx) * s32Coef; + pstXy1y2->v[1] = gstXy1y2.v[1] - s32HTbl[gstCorrect.s32Fy1] + + (gs08HardOffset[1] - gstCorrect.s32Ry1) * s32Coef; + pstXy1y2->v[2] = gstXy1y2.v[2] - s32HTbl[gstCorrect.s32Fy2] + + (gs08HardOffset[2] - gstCorrect.s32Ry2) * s32Coef; + s32Oy = pstXy1y2->v[1] - pstXy1y2->v[2]; + s32Oz = -pstXy1y2->v[1] - pstXy1y2->v[2]; + + pstXyz->v[0] = (gstCorrect.s32K + * ((100 * pstXy1y2->v[0]) + + (gstCorrect.s32A2 * s32Oy) + + (gstCorrect.s32A3 * s32Oz))) / 10; + pstXyz->v[1] = (gstCorrect.s32K + * ((gstCorrect.s32A4 * pstXy1y2->v[0]) + + (gstCorrect.s32A5 * s32Oy) + + (gstCorrect.s32A6 * s32Oz))) / 10; + pstXyz->v[2] = (gstCorrect.s32K + * ((gstCorrect.s32A7 * pstXy1y2->v[0]) + + (gstCorrect.s32A8 * s32Oy) + + (gstCorrect.s32A9 * s32Oz))) / 10; +} + +static void yas532_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2, + struct yas_pcb_vector *pstXyz, + int32_t s32CoefX, int32_t s32CoefY1, int32_t s32CoefY2) +{ + int32_t s32Oy; + int32_t s32Oz; + static const int32_t s32HTbl[] = { + 3721, 3971, 4221, 4471 + }; + + pstXy1y2->v[0] = gstXy1y2.v[0] - s32HTbl[gstCorrect.s32Fx] + + (gs08HardOffset[0] - gstCorrect.s32Rx) * s32CoefX; + pstXy1y2->v[1] = gstXy1y2.v[1] - s32HTbl[gstCorrect.s32Fy1] + + (gs08HardOffset[1] - gstCorrect.s32Ry1) * s32CoefY1; + pstXy1y2->v[2] = gstXy1y2.v[2] - s32HTbl[gstCorrect.s32Fy2] + + (gs08HardOffset[2] - gstCorrect.s32Ry2) * s32CoefY2; + s32Oy = pstXy1y2->v[1] - pstXy1y2->v[2]; + s32Oz = -pstXy1y2->v[1] - pstXy1y2->v[2]; + + pstXyz->v[0] = (gstCorrect.s32K + * ((100 * pstXy1y2->v[0]) + + (gstCorrect.s32A2 * s32Oy) + + (gstCorrect.s32A3 * s32Oz))) / 10; + pstXyz->v[1] = (gstCorrect.s32K + * ((gstCorrect.s32A4 * pstXy1y2->v[0]) + + (gstCorrect.s32A5 * s32Oy) + + (gstCorrect.s32A6 * s32Oz))) / 10; + pstXyz->v[2] = (gstCorrect.s32K + * ((gstCorrect.s32A7 * pstXy1y2->v[0]) + + (gstCorrect.s32A8 * s32Oy) + + (gstCorrect.s32A9 * s32Oz))) / 10; +} + +static int yas_pcb_calc_magnetic_field(struct yas_pcb_vector *pstXy1y2, + struct yas_pcb_vector *pstXyz) +{ + int32_t s32Coef; + + if (YAS532_DEVICE_ID == gu08DevId) { + switch (gstCorrect.s32Ver) { + case YAS532_VERSION_AC: + break; + + default: + return YAS_PCB_ERROR_I2C; + /* break; */ + } + + /* calculate Ohx/y/z[nT] */ + yas532_calc_magnetic_field(pstXy1y2, pstXyz, + YAS532_COEFX_VERSION_AC, + YAS532_COEFY1_VERSION_AC, + YAS532_COEFY2_VERSION_AC); + } else { + switch (gstCorrect.s32Ver) { + case YAS530_VERSION_A: + s32Coef = YAS530_COEF_VERSION_A; + break; + + case YAS530_VERSION_B: + s32Coef = YAS530_COEF_VERSION_B; + break; + + default: + return YAS_PCB_ERROR_I2C; + /* break; */ + } + + /* calculate Ohx/y/z[nT] */ + yas530_calc_magnetic_field(pstXy1y2, pstXyz, s32Coef); + } + + return YAS_PCB_NO_ERROR; +} + +static int yas_pcb_test1(int *id) +{ + int result; + int ret; + + result = yas_pcb_power_on(); + if (YAS_PCB_NO_ERROR == result) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_read(YAS_PCB_ADDR_SLAVE, + YAS_PCB_ADDR_ID, &gu08DevId, 1); + if (0 == ret) { + *id = (int)gu08DevId; + result = YAS_PCB_NO_ERROR; + } + } + + return result; +} + +static int yas_pcb_test2(void) +{ + return yas_pcb_power_off(); +} + +static int yas_pcb_test3(void) +{ + int result; + int ret; + uint8_t u08Data; + uint8_t pu08Buf[YAS530_CAL_REG_NUM]; + + u08Data = YAS_PCB_TEST1_DEFAULT; + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_TEST1, + &u08Data, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + u08Data = YAS_PCB_TEST2_DEFAULT; + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, YAS_PCB_ADDR_TEST2, + &u08Data, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + u08Data = YAS_PCB_INTERVAL_DEFAULT; + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, + YAS_PCB_ADDR_MEASURE_INTERVAL, &u08Data, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + if (YAS532_DEVICE_ID == gu08DevId) { + gs32Center = YAS532_RAWDATA_CENTER; + gs32Overflow = YAS532_RAWDATA_OVERFLOW; + result = yas532_read_cal(pu08Buf); + if (YAS_PCB_NO_ERROR == result) + yas532_calc_correction(pu08Buf); + } else { + gs32Center = YAS530_RAWDATA_CENTER; + gs32Overflow = YAS530_RAWDATA_OVERFLOW; + result = yas530_read_cal(pu08Buf); + if (YAS_PCB_NO_ERROR == result) + yas530_calc_correction(pu08Buf); + } + + if (YAS_PCB_NO_ERROR != result) + return result; + + u08Data = (uint8_t)(YAS_PCB_CONFIG_DEFAULT + | (uint8_t)((pu08Buf[9] & 0x03) << 3) + | (uint8_t)((pu08Buf[10] & 0x80) >> 5)); + ret = g_callback.i2c_write(YAS_PCB_ADDR_SLAVE, + YAS_PCB_ADDR_CONFIG, &u08Data, 1); + if (0 != ret) + return YAS_PCB_ERROR_I2C; + + ret = yas_pcb_reset_coil(); + if (YAS_PCB_NO_ERROR != ret) + return ret; + return YAS_PCB_NO_ERROR; +} + +static int yas_pcb_test4(int *x, int *y1, int *y2) +{ + int result; + struct yas_pcb_vector stXy1y2; + int temperature; + int32_t s32Tmp; + int8_t s08Correct = YAS_PCB_HARD_OFFSET_CORRECT; + uint8_t i; + uint8_t k; + + gs08HardOffset[0] = 0; + gs08HardOffset[1] = 0; + gs08HardOffset[2] = 0; + result = yas_pcb_set_offset(&gs08HardOffset[0]); + if (YAS_PCB_NO_ERROR == result) { + /* calc hard offset */ + for (i = 0; i < YAS_PCB_COIL_INIT_CALC_NUM; i++) { + result = yas_pcb_measure(&stXy1y2, &temperature, + YAS_PCB_MEASURE_COMMAND_START, + YAS_PCB_INT_NOTCHECK); + if (YAS_PCB_NO_ERROR != result) + break; + + for (k = 0; k < 3; k++) { + s32Tmp = stXy1y2.v[k]; + if (gs32Center < s32Tmp) + gs08HardOffset[k] += s08Correct; + else { + if (s32Tmp < gs32Center) + gs08HardOffset[k] -= s08Correct; + } + } + + result = yas_pcb_set_offset(&gs08HardOffset[0]); + if (YAS_PCB_NO_ERROR != result) + break; + + s08Correct = (int8_t)((uint8_t)s08Correct >> 1); + } + + if (YAS_PCB_NO_ERROR == result) { + *x = (int)gs08HardOffset[0]; + *y1 = (int)gs08HardOffset[1]; + *y2 = (int)gs08HardOffset[2]; + result = yas_pcb_is_flow_occued(&stXy1y2, + 0, gs32Overflow); + } + } + + return result; +} + +static int yas_pcb_test5(int *direction) +{ + uint16_t dir; + int result; + int ret; + int x; + int y; + int nTemp; + struct yas_pcb_vector stXyz; + + result = yas_pcb_measure(&gstXy1y2, &nTemp, + YAS_PCB_MEASURE_COMMAND_START, YAS_PCB_INT_NOTCHECK); + if (YAS_PCB_NO_ERROR == result) { + result = YAS_PCB_ERROR_DIRCALC; + yas_pcb_calc_position(&gstXy1y2, &stXyz, nTemp); + + x = -stXyz.v[0] / YAS_PCB_DIR_DIVIDER; + y = stXyz.v[1] / YAS_PCB_DIR_DIVIDER; + ret = Ms3AxesLibDir8(x, y, &dir); + if (0 == ret) { + *direction = (int)(dir / 8); + result = yas_pcb_is_flow_occued(&gstXy1y2, + 0, gs32Overflow); + } + } + + return result; +} + +static int yas_pcb_test6(int *sx, int *sy) +{ + int result; + struct yas_pcb_vector stXy1y2P; + struct yas_pcb_vector stXy1y2N; + int temperature; + uint8_t u08Command; + struct yas_pcb_vector *pP = &stXy1y2P; + struct yas_pcb_vector *pN = &stXy1y2N; + struct yas_pcb_correction *pC = &gstCorrect; + + u08Command = YAS_PCB_MEASURE_COMMAND_START + | YAS_PCB_MEASURE_COMMAND_LDTC; + result = yas_pcb_measure(pP, &temperature, + u08Command, YAS_PCB_INT_CHECK); + + if (YAS_PCB_NO_ERROR == result) { + u08Command = YAS_PCB_MEASURE_COMMAND_START + | YAS_PCB_MEASURE_COMMAND_LDTC + | YAS_PCB_MEASURE_COMMAND_FORS; + result = yas_pcb_measure(pN, &temperature, u08Command, + YAS_PCB_INT_NOTCHECK); + + if (YAS_PCB_NO_ERROR == result) { + if (YAS532_DEVICE_ID == gu08DevId) { + *sx = (int)(pC->s32K * 100 + * (pP->v[0] - pN->v[0])); + *sx /= 1000; + *sx /= YAS_VCORE; + *sy = (int)(pC->s32K * pC->s32A5 + * ((pP->v[1] - pN->v[1]) + - (pP->v[2] - pN->v[2]))); + *sy /= 1000; + *sy /= YAS_VCORE; + } else { + *sx = (int)(pN->v[0] - pP->v[0]); + *sy = (int)((pN->v[1] - pP->v[1]) + - (pN->v[2] - pP->v[2])); + } + + result = yas_pcb_is_flow_occued(pP, 0, gs32Overflow); + if (YAS_PCB_NO_ERROR == result) + result = yas_pcb_is_flow_occued(pN, + 0, gs32Overflow); + } + } + + return result; +} + +#ifdef YAS_PCBTEST_EXTRA +static int yas_pcb_test7(int *ohx, int *ohy, int *ohz) +{ + int nRet = YAS_PCB_ERROR_NOT_SUPPORTED; + struct yas_pcb_vector stOhxy1y2, stOhxyz; + + if (0 != gstCorrect.s32ZFlag) { + nRet = yas_pcb_calc_magnetic_field(&stOhxy1y2, &stOhxyz); + if (YAS_PCB_NO_ERROR == nRet) { + /* [nT]->[uT] */ + *ohx = stOhxyz.v[0] / 1000; + *ohy = stOhxyz.v[1] / 1000; + *ohz = stOhxyz.v[2] / 1000; + } + } + + return nRet; +} + +static int yas_pcb_test8(int *hx0, int *hy0, int *hz0) +{ + int nRet; + int nTemp; + int nX, nY1, nY2; + int32_t s32Underflow = 0; + int32_t s32Overflow = gs32Overflow; + struct yas_pcb_vector stOhxy1y2, stOhxyz; + + if (YAS532_DEVICE_ID == gu08DevId) { + s32Underflow = YAS_PCB_NOISE_UNDERFLOW; + s32Overflow = YAS_PCB_NOISE_OVERFLOW; + } + + if (gu08Recalc != 0) { + gs32RecalcWait++; + if (YAS_PCB_NOISE_INTERVAL <= gs32RecalcWait) { + nRet = yas_pcb_reset_coil(); + if (YAS_PCB_NO_ERROR == nRet) + nRet = yas_pcb_test4(&nX, &nY1, &nY2); + + if (YAS_PCB_NO_ERROR == nRet) + gu08Recalc = 0; + + gs32RecalcWait = 0; + } + } + + if (0 != gstCorrect.s32ZFlag) { + nRet = yas_pcb_measure(&gstXy1y2, &nTemp, + YAS_PCB_MEASURE_COMMAND_START, + YAS_PCB_INT_NOTCHECK); + if (YAS_PCB_NO_ERROR == nRet) { + nRet = yas_pcb_calc_magnetic_field(&stOhxy1y2, + &stOhxyz); + if (YAS_PCB_NO_ERROR == nRet) { + *hx0 = stOhxy1y2.v[0]; + *hy0 = stOhxy1y2.v[1] - stOhxy1y2.v[2]; + *hz0 = -stOhxy1y2.v[1] - stOhxy1y2.v[2]; + nRet = yas_pcb_is_flow_occued(&gstXy1y2, + s32Underflow, s32Overflow); + if (YAS_PCB_NO_ERROR != nRet) { + if (gu08Recalc == 0) { + gu08Recalc++; + gs32RecalcWait = 0; + } + } + } + } + } else + nRet = YAS_PCB_ERROR_NOT_SUPPORTED; + + return nRet; +} + +#endif + +/* test 1 */ +static int power_on_and_device_check(int *id) +{ + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST1); + + if (YAS_PCB_NO_ERROR == result) { + if (id != NULL) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test1(id); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST1); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +} + +/* test 2 */ +static int power_off(void) +{ + int result = yas_pcb_check_state(YAS_PCB_TEST2); + + if (YAS_PCB_NO_ERROR == result) { + result = yas_pcb_test2(); + + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST2); + } + + return result; +} + +/* test 3 */ +static int initialization(void) +{ + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST3); + + if (YAS_PCB_NO_ERROR == result) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test3(); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST3); + } + + return result; +} + +/* test 4 */ +static int offset_control_measurement_and_set_offset_register(int *x, + int *y1, int *y2) +{ + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST4); + + if (YAS_PCB_NO_ERROR == result) { + if ((x != NULL) && (y1 != NULL) && (y2 != NULL)) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test4(x, y1, y2); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST4); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +} + +/* test 5 */ +static int direction_measurement(int *direction) +{ + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST5); + + if (YAS_PCB_NO_ERROR == result) { + if (direction != NULL) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test5(direction); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST5); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +} + +/* test 6 */ +static int sensitivity_measurement_of_magnetic_sensor_by_test_coil( + int *sx, int *sy) +{ + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST6); + + if (YAS_PCB_NO_ERROR == result) { + if ((sx != NULL) && (sy != NULL)) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test6(sx, sy); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST6); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +} + +/* test 7 */ +static int magnetic_field_level_check(int *ohx, int *ohy, int *ohz) +{ +#ifdef YAS_PCBTEST_EXTRA + int result = yas_pcb_check_state(YAS_PCB_TEST7); + + if (YAS_PCB_NO_ERROR == result) { + if ((ohx != NULL) && (ohy != NULL) && (ohz != NULL)) { + result = yas_pcb_test7(ohx, ohy, ohz); + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST7); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +#else + return YAS_PCB_ERROR_NOT_SUPPORTED; +#endif +} + +/* test 8 */ +static int noise_level_check(int *hx0, int *hy0, int *hz0) +{ +#ifdef YAS_PCBTEST_EXTRA + int ret; + int result = yas_pcb_check_state(YAS_PCB_TEST8); + + if (YAS_PCB_NO_ERROR == result) { + if ((hx0 != NULL) && (hy0 != NULL) && (hz0 != NULL)) { + result = YAS_PCB_ERROR_I2C; + ret = g_callback.i2c_open(); + if (0 == ret) { + result = yas_pcb_test8(hx0, hy0, hz0); + ret = g_callback.i2c_close(); + if (0 != ret) + result = YAS_PCB_ERROR_I2C; + } + if (YAS_PCB_NO_ERROR == result) + yas_pcb_update_state(YAS_PCB_TEST8); + } else + result = YAS_PCB_ERROR_ARG; + } + + return result; +#else + return YAS_PCB_ERROR_NOT_SUPPORTED; +#endif +} + +/* pcb test module initialize */ +int yas_pcb_test_init(struct yas_pcb_test *func) +{ + int result = YAS_PCB_ERROR_ARG; + + if ((NULL != func) + && (NULL != func->callback.i2c_open) + && (NULL != func->callback.i2c_close) + && (NULL != func->callback.i2c_write) + && (NULL != func->callback.i2c_read) + && (NULL != func->callback.msleep)) { + func->power_on_and_device_check = power_on_and_device_check; + func->initialization = initialization; + func->offset_control_measurement_and_set_offset_register + = offset_control_measurement_and_set_offset_register; + func->direction_measurement = direction_measurement; + func->sensitivity_measurement_of_magnetic_sensor_by_test_coil + = sensitivity_measurement_of_magnetic_sensor_by_test_coil; + func->magnetic_field_level_check = magnetic_field_level_check; + func->noise_level_check = noise_level_check; + func->power_off = power_off; + + g_callback = func->callback; + + if (0 != gu16State) { + gu16State = 0; + yas_pcb_power_off(); + } +#ifdef YAS_PCBTEST_EXTRA + gu08Recalc = 0; + gs32RecalcWait = 0; +#endif + result = YAS_PCB_NO_ERROR; + } + + return result; +} +/* end of file */ diff --git a/drivers/sensor/yas_pcb_test.h b/drivers/sensor/yas_pcb_test.h new file mode 100644 index 0000000..40d9dbd --- /dev/null +++ b/drivers/sensor/yas_pcb_test.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * 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., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +/* + * File yas_pcb_test.h + * Date 2013/1/22 + * Revision 1.4.3 + */ + +#ifndef __YAS_PCB_TEST_H__ +#define __YAS_PCB_TEST_H__ + +#include "yas_types.h" + +/* extra */ +#define YAS_PCBTEST_EXTRA + +/* error code */ +#define YAS_PCB_NO_ERROR (0) +#define YAS_PCB_ERROR_I2C (-1) +#define YAS_PCB_ERROR_POWER (-2) +#define YAS_PCB_ERROR_TEST_ORDER (-3) +#define YAS_PCB_ERROR_INTERRUPT (-4) +#define YAS_PCB_ERROR_BUSY (-5) +#define YAS_PCB_ERROR_OVERFLOW (-6) +#define YAS_PCB_ERROR_UNDERFLOW (-7) +#define YAS_PCB_ERROR_DIRCALC (-8) +#define YAS_PCB_ERROR_NOT_SUPPORTED (-9) +#define YAS_PCB_ERROR_CALREG (-10) +#define YAS_PCB_ERROR_ARG (-128) + +/* addr */ +#define YAS_PCB_ADDR_SLAVE (0x2E) + +#define YAS_PCB_ADDR_ID (0x80) +#define YAS_PCB_ADDR_COIL (0x81) +#define YAS_PCB_ADDR_MEASURE_COMMAND (0x82) +#define YAS_PCB_ADDR_CONFIG (0x83) +#define YAS_PCB_ADDR_MEASURE_INTERVAL (0x84) +#define YAS_PCB_ADDR_OFFSET (0x85) +#define YAS_PCB_ADDR_TEST1 (0x88) +#define YAS_PCB_ADDR_TEST2 (0x89) +#define YAS_PCB_ADDR_CAL (0x90) +#define YAS_PCB_ADDR_MEASURE_DATA (0xB0) + +/* V Core */ +#define YAS_VCORE (18) +#define YAS_PCB_NOISE_OVERFLOW (6000) +#define YAS_PCB_NOISE_UNDERFLOW (2000) +#define YAS_PCB_NOISE_INTERVAL (50) + +struct yas_pcb_test_callback { + int (*power_on)(void); + int (*power_off)(void); + int (*i2c_open)(void); + int (*i2c_close)(void); + int (*i2c_write)(uint8_t, uint8_t, const uint8_t *, int); + int (*i2c_read)(uint8_t, uint8_t, uint8_t *, int); + void (*msleep)(int); + int (*read_intpin)(int *); +}; + +struct yas_pcb_test { + int (*power_on_and_device_check)(int *); + int (*initialization)(void); + int (*offset_control_measurement_and_set_offset_register) + (int *, int *, int *); + int (*direction_measurement)(int *); + int (*sensitivity_measurement_of_magnetic_sensor_by_test_coil) + (int *, int *); + int (*magnetic_field_level_check)(int *, int *, int *); + int (*noise_level_check)(int *, int *, int *); + int (*power_off)(void); + struct yas_pcb_test_callback callback; +}; + +/* prototype functions */ +#ifdef __cplusplus +extern "C" { +#endif + +int yas_pcb_test_init(struct yas_pcb_test *); + +#ifdef __cplusplus +} +#endif + +#endif /* ! __YAS_PCB_TEST_H__ */ + +/* end of file */ diff --git a/drivers/sensor/yas_types.h b/drivers/sensor/yas_types.h new file mode 100644 index 0000000..97aa3f3 --- /dev/null +++ b/drivers/sensor/yas_types.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2010-2011 Yamaha Corporation + * + * 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., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + */ + +/* + * File yas_types.h + * Date 2012/10/05 + * Revision 1.4.1 + */ + +#ifndef __YAS_TYPES_H__ +#define __YAS_TYPES_H__ + +/* macro */ +#ifndef NULL +#define NULL ((void *)0) +#endif + +#if defined(__KERNEL__) +#include <linux/types.h> +#else +#include <stdint.h> +/*typedef signed char int8_t;*/ +/*typedef unsigned char uint8_t;*/ +/*typedef signed short int16_t;*/ +/*typedef unsigned short uint16_t;*/ +/*typedef signed int int32_t;*/ +/*typedef unsigned int uint32_t;*/ +#endif + +#endif /* __YASTYPES_H__ */ + +/* end of file */ diff --git a/drivers/staging/android/binder.c b/drivers/staging/android/binder.c index 8cf2cee..8a37cbd 100644 --- a/drivers/staging/android/binder.c +++ b/drivers/staging/android/binder.c @@ -1543,7 +1543,7 @@ static void binder_transaction(struct binder_proc *proc, t->from = thread; else t->from = NULL; -#ifdef CONFIG_MACH_P4NOTE +#if defined(CONFIG_MACH_P4NOTE) || defined(CONFIG_MACH_KONA) /* workaround code for invalid binder proc */ if (!proc->tsk) { binder_debug(BINDER_DEBUG_FAILED_TRANSACTION, diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig index 29c581f..d82a55b 100644 --- a/drivers/video/backlight/Kconfig +++ b/drivers/video/backlight/Kconfig @@ -424,6 +424,13 @@ config BACKLIGHT_SMART_DIMMING help Say Y to enable the Smart Dimming Feature. +config BACKLIGHT_LP855X + tristate "Backlight driver for TI LP855X" + depends on BACKLIGHT_CLASS_DEVICE && I2C + help + This supports TI LP8550, LP8551, LP8552, LP8553 and LP8556 + backlight driver. + endif # BACKLIGHT_CLASS_DEVICE endif # BACKLIGHT_LCD_SUPPORT diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile index 9d8d82f..658e9a1 100644 --- a/drivers/video/backlight/Makefile +++ b/drivers/video/backlight/Makefile @@ -30,6 +30,7 @@ obj-$(CONFIG_BACKLIGHT_GENERIC) += generic_bl.o obj-$(CONFIG_BACKLIGHT_HP700) += jornada720_bl.o obj-$(CONFIG_BACKLIGHT_HP680) += hp680_bl.o obj-$(CONFIG_BACKLIGHT_LOCOMO) += locomolcd.o +obj-$(CONFIG_BACKLIGHT_LP855X) += lp855x_bl.o obj-$(CONFIG_BACKLIGHT_OMAP1) += omap1_bl.o obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c new file mode 100644 index 0000000..bbedab5 --- /dev/null +++ b/drivers/video/backlight/lp855x_bl.c @@ -0,0 +1,466 @@ +/* + * TI LP855x Backlight Driver + * + * Copyright (C) 2011 Texas Instruments + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/i2c.h> +#include <linux/backlight.h> +#include <linux/err.h> +#include <linux/delay.h> +#include <linux/gpio.h> +#include <linux/platform_data/lp855x.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +/* Registers */ +#define BRIGHTNESS_CTRL 0x00 +#define DEVICE_CTRL 0x01 +#define EEPROM_START 0xA0 +#define EEPROM_END 0xA7 +#define EPROM_START 0xA0 +#define EPROM_END 0xAF + +#if defined(CONFIG_MACH_KONA) +#define EEPROM_CFG3 0xA3 +#define EEPROM_CFG5 0xA5 +#endif + +#define BUF_SIZE 20 +#define DEFAULT_BL_NAME "lcd-backlight" +#define MAX_BRIGHTNESS 255 + +struct lp855x { + const char *chipname; + enum lp855x_chip_id chip_id; + struct i2c_client *client; + struct backlight_device *bl; + struct device *dev; + struct mutex xfer_lock; + struct lp855x_platform_data *pdata; + int enabled; +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif +}; + +static int lp855x_read_byte(struct lp855x *lp, u8 reg, u8 *data) +{ + int ret; + + mutex_lock(&lp->xfer_lock); + ret = i2c_smbus_read_byte_data(lp->client, reg); + if (ret < 0) { + mutex_unlock(&lp->xfer_lock); + dev_err(lp->dev, "failed to read 0x%.2x\n", reg); + return ret; + } + mutex_unlock(&lp->xfer_lock); + + *data = (u8)ret; + return 0; +} + +static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data) +{ + int ret; + + mutex_lock(&lp->xfer_lock); + ret = i2c_smbus_write_byte_data(lp->client, reg, data); + mutex_unlock(&lp->xfer_lock); + + return ret; +} + +static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr) +{ + u8 start, end; + + switch (lp->chip_id) { + case LP8550: + case LP8551: + case LP8552: + case LP8553: + start = EEPROM_START; + end = EEPROM_END; + break; + case LP8556: + start = EPROM_START; + end = EPROM_END; + break; + default: + return false; + } + + return (addr >= start && addr <= end); +} + +static int lp855x_init_registers(struct lp855x *lp) +{ + u8 val, addr, mask; + int i, ret; + struct lp855x_platform_data *pd = lp->pdata; + + val = pd->initial_brightness; + ret = lp855x_write_byte(lp, BRIGHTNESS_CTRL, val); + if (ret) + return ret; + + val = pd->device_control; + ret = lp855x_write_byte(lp, DEVICE_CTRL, val); + if (ret) + return ret; + + if (pd->load_new_rom_data && pd->size_program) { + for (i = 0; i < pd->size_program; i++) { + addr = pd->rom_data[i].addr; + val = pd->rom_data[i].val; + mask = pd->rom_data[i].mask; + if (!lp855x_is_valid_rom_area(lp, addr)) + continue; + + if (mask) { + u8 reg_val; + + ret = lp855x_read_byte(lp, addr, ®_val); + if (ret) + return ret; + val = (val & ~mask) | (reg_val & mask); + } + + ret = lp855x_write_byte(lp, addr, val); + if (ret) + return ret; + } + } + + return ret; +} + +static int lp855x_bl_update_status(struct backlight_device *bl) +{ + struct lp855x *lp = bl_get_data(bl); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + int ret; + + if (bl->props.state & BL_CORE_SUSPENDED) + bl->props.brightness = 0; + + if (mode == PWM_BASED) { + struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; + int br = bl->props.brightness; + int max_br = bl->props.max_brightness; + + if (pd->pwm_set_intensity) + pd->pwm_set_intensity(br, max_br); + + } else if (mode == REGISTER_BASED) { + u8 val = bl->props.brightness; + ret = lp855x_write_byte(lp, BRIGHTNESS_CTRL, val); + if (ret) + return ret; + } + + return 0; +} + +static int lp855x_bl_get_brightness(struct backlight_device *bl) +{ + struct lp855x *lp = bl_get_data(bl); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + + if (mode == PWM_BASED) { + struct lp855x_pwm_data *pd = &lp->pdata->pwm_data; + int max_br = bl->props.max_brightness; + + if (pd->pwm_get_intensity) + bl->props.brightness = pd->pwm_get_intensity(max_br); + + } else if (mode == REGISTER_BASED) { + u8 val = 0; + + lp855x_read_byte(lp, BRIGHTNESS_CTRL, &val); + bl->props.brightness = val; + } + + return bl->props.brightness; +} + +static const struct backlight_ops lp855x_bl_ops = { + .options = BL_CORE_SUSPENDRESUME, + .update_status = lp855x_bl_update_status, + .get_brightness = lp855x_bl_get_brightness, +}; + +static int lp855x_backlight_register(struct lp855x *lp) +{ + struct backlight_device *bl; + struct backlight_properties props; + struct lp855x_platform_data *pdata = lp->pdata; + char *name = pdata->name ? : DEFAULT_BL_NAME; + + props.type = BACKLIGHT_PLATFORM; + props.max_brightness = MAX_BRIGHTNESS; + + if (pdata->initial_brightness > props.max_brightness) + pdata->initial_brightness = props.max_brightness; + + props.brightness = pdata->initial_brightness; + + bl = backlight_device_register(name, lp->dev, lp, + &lp855x_bl_ops, &props); + if (IS_ERR(bl)) + return PTR_ERR(bl); + + lp->bl = bl; + + return 0; +} + +static void lp855x_backlight_unregister(struct lp855x *lp) +{ + if (lp->bl) + backlight_device_unregister(lp->bl); +} + +static ssize_t lp855x_get_chip_id(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct lp855x *lp = dev_get_drvdata(dev); + return scnprintf(buf, BUF_SIZE, "%s\n", lp->chipname); +} + +static ssize_t lp855x_get_bl_ctl_mode(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct lp855x *lp = dev_get_drvdata(dev); + enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode; + char *strmode = NULL; + + if (mode == PWM_BASED) + strmode = "pwm based"; + else if (mode == REGISTER_BASED) + strmode = "register based"; + + return scnprintf(buf, BUF_SIZE, "%s\n", strmode); +} + +static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL); +static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL); + +static struct attribute *lp855x_attributes[] = { + &dev_attr_chip_id.attr, + &dev_attr_bl_ctl_mode.attr, + NULL, +}; + +static const struct attribute_group lp855x_attr_group = { + .attrs = lp855x_attributes, +}; + +static int lp855x_set_power(struct lp855x *lp, int on) +{ + unsigned long on_udelay = lp->pdata->power_on_udelay; + + pr_info("%s : %d\n", __func__, on); + + if (on) { + int ret = 0; + + gpio_set_value(lp->pdata->gpio_en, GPIO_LEVEL_HIGH); + usleep_range(on_udelay, on_udelay); + + ret = lp855x_init_registers(lp); + if (ret) + return ret; + } else { + gpio_set_value(lp->pdata->gpio_en, GPIO_LEVEL_LOW); + } + + lp->enabled = on; + + return 0; +} + +#if defined(CONFIG_MACH_KONA) +static int lp855x_config(struct lp855x *lp) +{ + u8 val; + int ret; + + /* DEVICE CONTROL: No FAST bit to prevent LP8556 register reset */ + ret = lp855x_write_byte(lp, DEVICE_CTRL, 0x81); + if (ret) + return ret; + + /* CFG3: SCURVE_EN is linear transitions, SLOPE = 200ms, + * FILTER = heavy smoothing, + * PWM_INPUT_HYSTERESIS = 1-bit hysteresis with 12-bit resolution + */ + ret = lp855x_write_byte(lp, EEPROM_CFG3, 0x5E); + if (ret) + return ret; + + /* CFG5: No PWM_DIRECT, PS_MODE from platform data, PWM_FREQ = 9616Hz */ + val = 0x2 << 4 | 0x04; + ret = lp855x_write_byte(lp, EEPROM_CFG5, val); + + if (ret) + return ret; + + return 0; + +} +#endif + +#ifdef CONFIG_HAS_EARLYSUSPEND +static void lp855x_early_suspend(struct early_suspend *h) +{ + struct lp855x *lp = + container_of(h, struct lp855x, early_suspend); + + lp855x_set_power(lp, 0); +} + +static void lp855x_late_resume(struct early_suspend *h) +{ + struct lp855x *lp = + container_of(h, struct lp855x, early_suspend); + + lp855x_set_power(lp, 1); + backlight_update_status(lp->bl); +#if defined(CONFIG_MACH_KONA) + lp855x_config(lp); +#endif + +} +#endif + +static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id) +{ + struct lp855x *lp; + struct lp855x_platform_data *pdata = cl->dev.platform_data; + enum lp855x_brightness_ctrl_mode mode; + int ret; + + if (!pdata) { + dev_err(&cl->dev, "no platform data supplied\n"); + return -EINVAL; + } + + if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) + return -EIO; + + lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL); + if (!lp) + return -ENOMEM; + + mode = pdata->mode; + lp->client = cl; + lp->dev = &cl->dev; + lp->pdata = pdata; + lp->chipname = id->name; + lp->chip_id = id->driver_data; + i2c_set_clientdata(cl, lp); + + mutex_init(&lp->xfer_lock); + + ret = lp855x_init_registers(lp); + if (ret) { + dev_err(lp->dev, "i2c communication err: %d", ret); + if (mode == REGISTER_BASED) + goto err_dev; + } + + lp->enabled = 1; +#ifdef CONFIG_HAS_EARLYSUSPEND + if (lp->pdata->use_gpio_en) { + lp->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 2; + lp->early_suspend.suspend = lp855x_early_suspend; + lp->early_suspend.resume = lp855x_late_resume; + register_early_suspend(&lp->early_suspend); + } +#endif + + ret = lp855x_backlight_register(lp); + if (ret) { + dev_err(lp->dev, + "failed to register backlight. err: %d\n", ret); + goto err_dev; + } + + ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group); + if (ret) { + dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret); + goto err_sysfs; + } + + backlight_update_status(lp->bl); + +#if defined(CONFIG_MACH_KONA) + lp855x_config(lp); +#endif + + return 0; + +err_sysfs: + lp855x_backlight_unregister(lp); +err_dev: + return ret; +} + +static int __devexit lp855x_remove(struct i2c_client *cl) +{ + struct lp855x *lp = i2c_get_clientdata(cl); + + lp->bl->props.brightness = 0; + backlight_update_status(lp->bl); + sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group); + lp855x_backlight_unregister(lp); + + return 0; +} + +static const struct i2c_device_id lp855x_ids[] = { + {"lp8550", LP8550}, + {"lp8551", LP8551}, + {"lp8552", LP8552}, + {"lp8553", LP8553}, + {"lp8556", LP8556}, + { } +}; +MODULE_DEVICE_TABLE(i2c, lp855x_ids); + +static struct i2c_driver lp855x_driver = { + .driver = { + .name = "lp855x", + }, + .probe = lp855x_probe, + .remove = __devexit_p(lp855x_remove), + .id_table = lp855x_ids, +}; + +static int __init lp855x_init(void) +{ + return i2c_add_driver(&lp855x_driver); +} + +static void __exit lp855x_exit(void) +{ + i2c_del_driver(&lp855x_driver); +} + +module_init(lp855x_init); +module_exit(lp855x_exit); + +MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver"); +MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>"); +MODULE_LICENSE("GPL"); diff --git a/drivers/video/samsung/Kconfig b/drivers/video/samsung/Kconfig index 0234465..80f6a0a 100644 --- a/drivers/video/samsung/Kconfig +++ b/drivers/video/samsung/Kconfig @@ -273,6 +273,12 @@ config FB_S5P_S6E63M0 ---help--- This enables support for Samsung S6E63M0 MIPI LCD +config FB_S5P_NT71391 + bool "NT71391 MIPI LCD" + depends on FB_S5P_MIPI_DSIM + ---help--- + This enables support for Novatek NT71391 MIPI LCD + endchoice choice diff --git a/drivers/video/samsung/Makefile b/drivers/video/samsung/Makefile index 75995be..8934e35 100644 --- a/drivers/video/samsung/Makefile +++ b/drivers/video/samsung/Makefile @@ -15,11 +15,16 @@ obj-$(CONFIG_FB_S5P_WA101S) += s3cfb_wa101s.o obj-$(CONFIG_FB_S5P_AMS369FG06) += s3cfb_ams369fg06.o obj-$(CONFIG_FB_S5P_LD9040) += ld9040.o smart_dimming_ld9042.o obj-$(CONFIG_FB_S5P_NT35560) += nt35560.o +ifeq ($(CONFIG_MACH_KONA),y) +obj-$(CONFIG_FB_S5P_MDNIE) += s3cfb_mdnie_kona.o s3cfb_ielcd_kona.o mdnie_kona.o mdnie_tuning_kona.o +else obj-$(CONFIG_FB_S5P_MDNIE) += s3cfb_mdnie.o s3cfb_ielcd.o mdnie.o mdnie_tunning.o +endif obj-$(CONFIG_FB_S5P_LMS501KF03) += s3cfb_lms501kf03.o obj-$(CONFIG_FB_S5P_LMS501XX) += s3cfb_lms501xx.o obj-$(CONFIG_FB_S5P_DUMMY_MIPI_LCD) += s3cfb_dummymipilcd.o obj-$(CONFIG_FB_S5P_S6E8AA0) += s3cfb_s6e8aa0.o smart_dimming.o +obj-$(CONFIG_FB_S5P_NT71391) += s3cfb_nt71391.o obj-$(CONFIG_FB_S5P_EA8061) += s3cfb_ea8061.o smart_dimming_ea8061.o obj-$(CONFIG_FB_S5P_S6EVR02) += s3cfb_s6evr02.o smart_dimming_s6evr02.o s3cfb_ea8061.o smart_dimming_ea8061.o obj-$(CONFIG_FB_S5P_S6E8AB0) += s3cfb_s6e8ab0.o smart_dimming_s6e8ab0.o diff --git a/drivers/video/samsung/mdnie_color_tone_4412.h b/drivers/video/samsung/mdnie_color_tone_4412.h new file mode 100644 index 0000000..7a34444 --- /dev/null +++ b/drivers/video/samsung/mdnie_color_tone_4412.h @@ -0,0 +1,239 @@ +#ifndef __MDNIE_COLOR_TONE_H__ +#define __MDNIE_COLOR_TONE_H__ + +#include "mdnie_kona.h" + +static const unsigned short tune_scr_setting[9][3] = { + {0xff, 0xf9, 0xf9}, + {0xff, 0xf9, 0xfe}, + {0xfc, 0xfa, 0xff}, + {0xff, 0xfc, 0xf8}, + {0xff, 0xff, 0xff}, + {0xfb, 0xfb, 0xff}, + {0xfb, 0xff, 0xf5}, + {0xfa, 0xff, 0xf9}, + {0xf8, 0xff, 0xfc}, +}; + +static unsigned short tune_color_tone_1[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0xaf00, /*SCR RrCr*/ + 0x00e2, 0x00b7, /*SCR RgCg*/ + 0x00e3, 0x00bc, /*SCR RbCb*/ + 0x00e4, 0x00af, /*SCR GrMr*/ + 0x00e5, 0xb700, /*SCR GgMg*/ + 0x00e6, 0x00bc, /*SCR GbMb*/ + 0x00e7, 0x00af, /*SCR BrYr*/ + 0x00e8, 0x00b7, /*SCR BgYg*/ + 0x00e9, 0xbc00, /*SCR BbYb*/ + 0x00ea, 0x00af, /*SCR KrWr*/ + 0x00eb, 0x00b7, /*SCR KgWg*/ + 0x00ec, 0x00bc, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, + +}; + +static unsigned short tune_color_tone_2[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0xa000, /*SCR RrCr*/ + 0x00e2, 0x00a8, /*SCR RgCg*/ + 0x00e3, 0x00b2, /*SCR RbCb*/ + 0x00e4, 0x00a0, /*SCR GrMr*/ + 0x00e5, 0xa800, /*SCR GgMg*/ + 0x00e6, 0x00b2, /*SCR GbMb*/ + 0x00e7, 0x00a0, /*SCR BrYr*/ + 0x00e8, 0x00a8, /*SCR BgYg*/ + 0x00e9, 0xb200, /*SCR BbYb*/ + 0x00ea, 0x00a0, /*SCR KrWr*/ + 0x00eb, 0x00a8, /*SCR KgWg*/ + 0x00ec, 0x00b2, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_tone_3[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x9100, /*SCR RrCr*/ + 0x00e2, 0x0099, /*SCR RgCg*/ + 0x00e3, 0x00a3, /*SCR RbCb*/ + 0x00e4, 0x0091, /*SCR GrMr*/ + 0x00e5, 0x9900, /*SCR GgMg*/ + 0x00e6, 0x00a3, /*SCR GbMb*/ + 0x00e7, 0x0091, /*SCR BrYr*/ + 0x00e8, 0x0099, /*SCR BgYg*/ + 0x00e9, 0xa300, /*SCR BbYb*/ + 0x00ea, 0x0091, /*SCR KrWr*/ + 0x00eb, 0x0099, /*SCR KgWg*/ + 0x00ec, 0x00a3, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +#if defined(CONFIG_FB_MDNIE_PWM) +static unsigned short tune_negative[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_negative_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWrv*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0075, 0x0000, /*CABC dgain*/ + 0x0076, 0x0000, + 0x0077, 0x0000, + 0x0078, 0x0000, + 0x007f, 0x0002, /*dynamic lcd*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030, 0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWrv*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0075, 0x0000, /*CABC dgain*/ + 0x0076, 0x0000, + 0x0077, 0x0000, + 0x0078, 0x0000, + 0x007f, 0x0002, /*dynamic lcd*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#else +static unsigned short tune_negative[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*SCR*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0xff00, /*SCR KrWr*/ + 0x00eb, 0xff00, /*SCR KgWg*/ + 0x00ec, 0xff00, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_color_blind[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x0020, /*SCR*/ + 0x00e1, 0x00ff, /*SCR RrCr*/ + 0x00e2, 0xff00, /*SCR RgCg*/ + 0x00e3, 0xff00, /*SCR RbCb*/ + 0x00e4, 0xff00, /*SCR GrMr*/ + 0x00e5, 0x00ff, /*SCR GgMg*/ + 0x00e6, 0xff00, /*SCR GbMb*/ + 0x00e7, 0xff00, /*SCR BrYr*/ + 0x00e8, 0xff00, /*SCR BgYg*/ + 0x00e9, 0x00ff, /*SCR BbYb*/ + 0x00ea, 0x00ff, /*SCR KrWr*/ + 0x00eb, 0x00ff, /*SCR KgWg*/ + 0x00ec, 0x00ff, /*SCR KbWb*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#endif + +struct mdnie_tuning_info negative_table[CABC_MAX] = { + {"negative", tune_negative}, +#if defined(CONFIG_FB_MDNIE_PWM) + {"negative_cabc", tune_negative_cabc}, +#endif +}; + +struct mdnie_tuning_info accessibility_table[CABC_MAX][ACCESSIBILITY_MAX] = { + { + {NULL, NULL}, + {"negative", tune_negative}, + {"color_blind", tune_color_blind}, + }, +#if defined(CONFIG_FB_MDNIE_PWM) + { + {NULL, NULL}, + {"negative_cabc", tune_negative_cabc}, + {"color_blind_cabc", tune_color_blind_cabc}, + } +#endif +}; + +struct mdnie_tuning_info color_tone_table[COLOR_TONE_MAX - COLOR_TONE_1] = { + {"color_tone_1", tune_color_tone_1}, + {"color_tone_2", tune_color_tone_2}, + {"color_tone_3", tune_color_tone_3}, +}; + +#endif /* __MDNIE_COLOR_TONE_H__ */ diff --git a/drivers/video/samsung/mdnie_kona.c b/drivers/video/samsung/mdnie_kona.c new file mode 100644 index 0000000..d44aa0e --- /dev/null +++ b/drivers/video/samsung/mdnie_kona.c @@ -0,0 +1,1171 @@ +/* linux/drivers/video/samsung/mdnie.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/mutex.h> +#include <linux/mm.h> +#include <linux/device.h> +#include <linux/backlight.h> +#include <linux/platform_device.h> +#include <linux/mdnie.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif +#include <linux/delay.h> +#include <linux/lcd.h> + +#include "s3cfb.h" +#include "s3cfb_mdnie_kona.h" + +#if defined(CONFIG_FB_S5P_NT71391) +#include "mdnie_table_kona.h" +#endif +#include "mdnie_color_tone_4412.h" + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +#include "mdnie_table_ebook.h" +#endif + +#if defined(CONFIG_FB_MDNIE_PWM) +#define MIN_BRIGHTNESS 0 +#define DEFAULT_BRIGHTNESS 150 +#if defined(CONFIG_FB_S5P_S6F1202A) +#define CABC_CUTOFF_BACKLIGHT_VALUE 40 /* 2.5% */ +#elif defined(CONFIG_FB_S5P_S6C1372) +#define CABC_CUTOFF_BACKLIGHT_VALUE 34 +#elif defined(CONFIG_FB_S5P_NT71391) +#define CABC_CUTOFF_BACKLIGHT_VALUE 31 +#endif +#define MAX_BRIGHTNESS_LEVEL 255 +#define MID_BRIGHTNESS_LEVEL 150 +#define LOW_BRIGHTNESS_LEVEL 30 +#define DIM_BRIGHTNESS_LEVEL 20 +#endif + +#define MDNIE_SYSFS_PREFIX "/sdcard/mdnie/" +#define PANEL_COLOR_OFFSET_PATH "/sys/class/lcd/panel/color_offset" + +#if defined(CONFIG_TDMB) || defined(CONFIG_TARGET_LOCALE_NTT) +#define SCENARIO_IS_DMB(scenario) ((scenario >= DMB_NORMAL_MODE) && (scenario < DMB_MODE_MAX)) +#else +#define SCENARIO_IS_DMB(scenario) NULL +#endif + +#define SCENARIO_IS_COLOR(scenario) ((scenario >= COLOR_TONE_1) && (scenario < COLOR_TONE_MAX)) +#define SCENARIO_IS_VIDEO(scenario) ((scenario >= VIDEO_MODE) && (scenario <= VIDEO_COLD_MODE)) +#define SCENARIO_IS_VALID(scenario) (SCENARIO_IS_COLOR(scenario) || SCENARIO_IS_DMB(scenario) || scenario < SCENARIO_MAX) + +#define ACCESSIBILITY_IS_VALID(accessibility) (accessibility && (accessibility < ACCESSIBILITY_MAX)) + +#define ADDRESS_IS_SCR_BLACK(address) (address >= MDNIE_REG_BLACK_R && address <= MDNIE_REG_BLACK_B) +#define ADDRESS_IS_SCR_RGB(address) (address >= MDNIE_REG_RED_R && address <= MDNIE_REG_GREEN_B) + +#define SCR_BLACK_MASK(value) (value % MDNIE_REG_BLACK_R) +#define SCR_RGB_MASK(value) (value % MDNIE_REG_RED_R) + +struct class *mdnie_class; +struct mdnie_info *g_mdnie; + +static int mdnie_send_sequence(struct mdnie_info *mdnie, const unsigned short *seq) +{ + int ret = 0, i = 0; + const unsigned short *wbuf = NULL; + + if (IS_ERR_OR_NULL(seq)) { + dev_err(mdnie->dev, "mdnie sequence is null\n"); + return -EPERM; + } + + mutex_lock(&mdnie->dev_lock); + + wbuf = seq; + + mdnie_mask(); + + while (wbuf[i] != END_SEQ) { + ret += mdnie_write(wbuf[i], wbuf[i+1]); + i += 2; + } + + mdnie_unmask(); + + mutex_unlock(&mdnie->dev_lock); + + return ret; +} + +static struct mdnie_tuning_info *mdnie_request_table(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + mutex_lock(&mdnie->lock); + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + if (mdnie->ebook == EBOOK_ON) { + table = &ebook_table[mdnie->cabc]; + goto exit; + } +#endif + + /* it will be removed next year */ + if (mdnie->negative == NEGATIVE_ON) { + table = &negative_table[mdnie->cabc]; + goto exit; + } + + if (ACCESSIBILITY_IS_VALID(mdnie->accessibility)) { + table = &accessibility_table[mdnie->cabc][mdnie->accessibility]; + goto exit; + } else if (SCENARIO_IS_DMB(mdnie->scenario)) { +#if defined(CONFIG_TDMB) || defined(CONFIG_TARGET_LOCALE_NTT) + table = &tune_dmb[mdnie->mode]; +#endif + goto exit; + } else if (SCENARIO_IS_COLOR(mdnie->scenario)) { + table = &color_tone_table[mdnie->scenario % COLOR_TONE_1]; + goto exit; + } else if (mdnie->scenario == CAMERA_MODE) { + table = &camera_table[mdnie->outdoor]; + goto exit; + } else if (mdnie->scenario < SCENARIO_MAX) { + table = &tuning_table[mdnie->cabc][mdnie->mode][mdnie->scenario]; + goto exit; + } + +exit: + mutex_unlock(&mdnie->lock); + + return table; +} + +static struct mdnie_tuning_info *mdnie_request_etc_table(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + mutex_lock(&mdnie->lock); + + if (SCENARIO_IS_VIDEO(mdnie->scenario)) + mdnie->tone = mdnie->scenario - VIDEO_MODE; + else if (SCENARIO_IS_DMB(mdnie->scenario)) + mdnie->tone = mdnie->scenario % DMB_NORMAL_MODE; + + table = &etc_table[mdnie->cabc][mdnie->outdoor][mdnie->tone]; + + mutex_unlock(&mdnie->lock); + + return table; +} + +static void mdnie_update_sequence(struct mdnie_info *mdnie, struct mdnie_tuning_info *table) +{ + unsigned short *wbuf = NULL; + int ret; + + if (unlikely(mdnie->tuning)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + if (ret < 0 && IS_ERR_OR_NULL(wbuf)) + goto exit; + mdnie_send_sequence(mdnie, wbuf); + kfree(wbuf); + } else + mdnie_send_sequence(mdnie, table->sequence); + +exit: + return; +} + +static void mdnie_update(struct mdnie_info *mdnie) +{ + struct mdnie_tuning_info *table = NULL; + + if (!mdnie->enable) { + dev_err(mdnie->dev, "mdnie state is off\n"); + return; + } + + table = mdnie_request_table(mdnie); + if (!IS_ERR_OR_NULL(table) && !IS_ERR_OR_NULL(table->sequence)) { + mdnie_update_sequence(mdnie, table); + dev_info(mdnie->dev, "%s\n", table->name); + } + + if (!(SCENARIO_IS_VIDEO(mdnie->scenario) || SCENARIO_IS_DMB(mdnie->scenario))) + goto exit; + + table = mdnie_request_etc_table(mdnie); + if (!IS_ERR_OR_NULL(table) && !IS_ERR_OR_NULL(table->sequence)) { + mdnie_update_sequence(mdnie, table); + dev_info(mdnie->dev, "%s\n", table->name); + } + +exit: + return; +} + +#if defined(CONFIG_FB_MDNIE_PWM) +static int get_backlight_level_from_brightness(struct mdnie_info *mdnie, unsigned int brightness) +{ + unsigned int value; + struct mdnie_backlight_value *pwm = mdnie->backlight; + + /* brightness tuning*/ + if (brightness >= MID_BRIGHTNESS_LEVEL) { + value = (brightness - MID_BRIGHTNESS_LEVEL) * + (pwm->max - pwm->mid) / (MAX_BRIGHTNESS_LEVEL-MID_BRIGHTNESS_LEVEL) + pwm->mid; + } else if (brightness >= LOW_BRIGHTNESS_LEVEL) { + value = (brightness - LOW_BRIGHTNESS_LEVEL) * + (pwm->mid - pwm->low) / (MID_BRIGHTNESS_LEVEL-LOW_BRIGHTNESS_LEVEL) + pwm->low; + } else if (brightness >= DIM_BRIGHTNESS_LEVEL) { + value = (brightness - DIM_BRIGHTNESS_LEVEL) * + (pwm->low - pwm->dim) / (LOW_BRIGHTNESS_LEVEL-DIM_BRIGHTNESS_LEVEL) + pwm->dim; + } else if (brightness > 0) + value = pwm->dim; + else + return 0; + + if (value > 1600) + value = 1600; + + if (value < 16) + value = 1; + else + value = value >> 4; + + return value; +} + +static void mdnie_pwm_control(struct mdnie_info *mdnie, int value) +{ + mutex_lock(&mdnie->dev_lock); + mdnie_write(MDNIE_REG_BANK_SEL, MDNIE_PWM_BANK); + mdnie_write(MDNIE_REG_PWM_CONTROL, 0xC000 | value); + mdnie_write(MDNIE_REG_MASK, 0); + mutex_unlock(&mdnie->dev_lock); +} + +static void mdnie_pwm_control_cabc(struct mdnie_info *mdnie, int value) +{ + int reg; + const unsigned char *p_plut; + u16 min_duty; + unsigned idx; + + mutex_lock(&mdnie->dev_lock); + + idx = SCENARIO_IS_VIDEO(mdnie->scenario) ? LUT_VIDEO : LUT_DEFAULT; + p_plut = power_lut[mdnie->power_lut_idx][idx]; + min_duty = p_plut[7] * value / 100; + + mdnie_write(MDNIE_REG_BANK_SEL, MDNIE_PWM_BANK); + + if (min_duty < 4) + reg = 0xC000 | (max(1, (value * p_plut[3] / 100))); + else { + /*PowerLUT*/ + mdnie_write(MDNIE_REG_POWER_LUT0, (p_plut[0] * value / 100) << 8 | (p_plut[1] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT2, (p_plut[2] * value / 100) << 8 | (p_plut[3] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT4, (p_plut[4] * value / 100) << 8 | (p_plut[5] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT6, (p_plut[6] * value / 100) << 8 | (p_plut[7] * value / 100)); + mdnie_write(MDNIE_REG_POWER_LUT8, (p_plut[8] * value / 100) << 8); + + reg = 0x5000 | (value << 4); + } + + mdnie_write(MDNIE_REG_PWM_CONTROL, reg); + mdnie_write(MDNIE_REG_MASK, 0); + + mutex_unlock(&mdnie->dev_lock); +} + +void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value) +{ + mdnie_pwm_control(mdnie, value); +} + +static int update_brightness(struct mdnie_info *mdnie) +{ + unsigned int value; + unsigned int brightness = mdnie->bd->props.brightness; + + value = get_backlight_level_from_brightness(mdnie, brightness); + + if (!mdnie->enable) { + dev_err(mdnie->dev, "mdnie states is off\n"); + return 0; + } + + if (brightness <= CABC_CUTOFF_BACKLIGHT_VALUE) { + mdnie_pwm_control(mdnie, value); + } else { + if ((mdnie->cabc) && (mdnie->scenario != CAMERA_MODE) && !(mdnie->tuning)) + mdnie_pwm_control_cabc(mdnie, value); + else + mdnie_pwm_control(mdnie, value); + } + return 0; +} + +static int mdnie_set_brightness(struct backlight_device *bd) +{ + struct mdnie_info *mdnie = bl_get_data(bd); + int ret = 0; + unsigned int brightness = bd->props.brightness; + + if (brightness < MIN_BRIGHTNESS || + brightness > bd->props.max_brightness) { + dev_err(&bd->dev, "lcd brightness should be %d to %d. now %d\n", + MIN_BRIGHTNESS, bd->props.max_brightness, brightness); + brightness = bd->props.max_brightness; + } + + if ((mdnie->enable) && (mdnie->bd_enable)) { + ret = update_brightness(mdnie); + dev_info(&bd->dev, "brightness=%d\n", bd->props.brightness); + if (ret < 0) + return -EINVAL; + } + + return ret; +} + +static int mdnie_get_brightness(struct backlight_device *bd) +{ + return bd->props.brightness; +} + +static const struct backlight_ops mdnie_backlight_ops = { + .get_brightness = mdnie_get_brightness, + .update_status = mdnie_set_brightness, +}; +#endif + +static void update_color_position(struct mdnie_info *mdnie, u16 idx) +{ + u8 cabc, mode, scenario, outdoor, i; + unsigned short *wbuf; + + dev_info(mdnie->dev, "%s: idx=%d\n", __func__, idx); + + mutex_lock(&mdnie->lock); + + for (cabc = 0; cabc < CABC_MAX; cabc++) { + for (mode = 0; mode <= STANDARD; mode++) { + for (scenario = 0; scenario < SCENARIO_MAX; scenario++) { + wbuf = tuning_table[cabc][mode][scenario].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_BLACK(wbuf[i])) + wbuf[i+1] = tune_scr_setting[idx][SCR_BLACK_MASK(wbuf[i])]; + i += 2; + } + } + } + } + + for (outdoor = 0; outdoor < OUTDOOR_MAX; outdoor++) { + wbuf = camera_table[outdoor].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_BLACK(wbuf[i])) + wbuf[i+1] = tune_scr_setting[idx][SCR_BLACK_MASK(wbuf[i])]; + i += 2; + } + } + + mutex_unlock(&mdnie->lock); +} + +static int get_panel_color_position(struct mdnie_info *mdnie, int *result) +{ + int ret = 0; + char *fp = NULL; + unsigned int offset[2] = {0,}; + + if (likely(mdnie->color_correction)) + goto skip_color_correction; + + ret = mdnie_open_file(PANEL_COLOR_OFFSET_PATH, &fp); + if (IS_ERR_OR_NULL(fp) || ret <= 0) { + dev_info(mdnie->dev, "%s: open fail: %s, %d\n", __func__, PANEL_COLOR_OFFSET_PATH, ret); + ret = -EINVAL; + goto skip_color_correction; + } + + ret = sscanf(fp, "0x%x, 0x%x", &offset[0], &offset[1]); + if (!(offset[0] + offset[1]) || ret != 2) { + dev_info(mdnie->dev, "%s: 0x%x, 0x%x\n", __func__, offset[0], offset[1]); + ret = -EINVAL; + goto skip_color_correction; + } + + ret = mdnie_calibration(offset[0], offset[1], result); + dev_info(mdnie->dev, "%s: %x, %x, idx=%d\n", __func__, offset[0], offset[1], ret - 1); + +skip_color_correction: + mdnie->color_correction = 1; + if (!IS_ERR_OR_NULL(fp)) + kfree(fp); + + return ret; +} + +static ssize_t mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->mode); +} + +static ssize_t mode_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value = 0; + int result[5] = {0,}; + int ret; + + ret = kstrtoul(buf, 0, (unsigned long *)&value); + if (ret) + return -EINVAL; + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (value >= MODE_MAX) { + value = STANDARD; + return -EINVAL; + } + + mutex_lock(&mdnie->lock); + mdnie->mode = value; + mutex_unlock(&mdnie->lock); + + if (!mdnie->color_correction) { + ret = get_panel_color_position(mdnie, result); + if (ret > 0) + update_color_position(mdnie, ret - 1); + } + + mdnie_update(mdnie); +#if defined(CONFIG_FB_MDNIE_PWM) + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); +#endif + + return count; +} + + +static ssize_t scenario_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->scenario); +} + +static ssize_t scenario_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value; + int ret; + + ret = kstrtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (!SCENARIO_IS_VALID(value)) + value = UI_MODE; + +#if defined(CONFIG_FB_MDNIE_PWM) + if (value >= SCENARIO_MAX) + value = UI_MODE; +#endif + + mutex_lock(&mdnie->lock); + mdnie->scenario = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); +#if defined(CONFIG_FB_MDNIE_PWM) + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); +#endif + + return count; +} + + +static ssize_t outdoor_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->outdoor); +} + +static ssize_t outdoor_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value; + int ret; + + ret = kstrtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (value >= OUTDOOR_MAX) + value = OUTDOOR_OFF; + + value = (value) ? OUTDOOR_ON : OUTDOOR_OFF; + + mutex_lock(&mdnie->lock); + mdnie->outdoor = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + + return count; +} + + +#if defined(CONFIG_FB_MDNIE_PWM) +static ssize_t cabc_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->cabc); +} + +static ssize_t cabc_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value; + int ret; + +#if defined(CONFIG_FB_S5P_S6C1372) + if (mdnie->auto_brightness) + return -EINVAL; +#endif + + ret = strict_strtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (value >= CABC_MAX) + value = CABC_OFF; + + value = (value) ? CABC_ON : CABC_OFF; + + mutex_lock(&mdnie->lock); + mdnie->cabc = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + if ((mdnie->enable) && (mdnie->bd_enable)) + update_brightness(mdnie); + + return count; +} + +static ssize_t auto_brightness_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + int i; + + pos += sprintf(pos, "%d, %d, ", mdnie->auto_brightness, mdnie->power_lut_idx); + for (i = 0; i < 5; i++) + pos += sprintf(pos, "0x%02x, ", power_lut[mdnie->power_lut_idx][0][i]); + pos += sprintf(pos, "\n"); + + return pos - buf; +} + +static ssize_t auto_brightness_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + int value; + int rc; + + rc = strict_strtoul(buf, (unsigned int)0, (unsigned long *)&value); + if (rc < 0) + return rc; + else { + if (mdnie->auto_brightness != value) { + dev_info(dev, "%s - %d -> %d\n", __func__, mdnie->auto_brightness, value); + mutex_lock(&mdnie->dev_lock); + mdnie->auto_brightness = value; +#if defined(CONFIG_FB_S5P_S6C1372) + mutex_lock(&mdnie->lock); + mdnie->cabc = (value) ? CABC_ON : CABC_OFF; + mutex_unlock(&mdnie->lock); +#endif + if (mdnie->auto_brightness >= 5) + mdnie->power_lut_idx = LUT_LEVEL_OUTDOOR_2; + else if (mdnie->auto_brightness == 4) + mdnie->power_lut_idx = LUT_LEVEL_OUTDOOR_1; + else + mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR; + mutex_unlock(&mdnie->dev_lock); + mdnie_update(mdnie); + if (mdnie->bd_enable) + update_brightness(mdnie); + } + } + return size; +} + +static DEVICE_ATTR(auto_brightness, 0644, auto_brightness_show, auto_brightness_store); +#endif + +static ssize_t tuning_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + struct mdnie_tuning_info *table; + int ret, i; + unsigned short *wbuf; + + pos += sprintf(pos, "++ %s: %s\n", __func__, mdnie->path); + + if (!mdnie->tuning) { + pos += sprintf(pos, "tunning mode is off\n"); + goto exit; + } + + if (strncmp(mdnie->path, MDNIE_SYSFS_PREFIX, sizeof(MDNIE_SYSFS_PREFIX) - 1)) { + pos += sprintf(pos, "file path is invalid, %s\n", mdnie->path); + goto exit; + } + + table = mdnie_request_table(mdnie); + if (!IS_ERR_OR_NULL(table)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + i = 0; + while (wbuf[i] != END_SEQ) { + pos += sprintf(pos, "0x%04x, 0x%04x\n", wbuf[i], wbuf[i+1]); + i += 2; + } + if (!IS_ERR_OR_NULL(wbuf)) + kfree(wbuf); + pos += sprintf(pos, "%s\n", table->name); + } + + if (!(SCENARIO_IS_VIDEO(mdnie->scenario) || SCENARIO_IS_DMB(mdnie->scenario))) + goto exit; + + table = mdnie_request_etc_table(mdnie); + if (!IS_ERR_OR_NULL(table)) { + ret = mdnie_request_firmware(mdnie->path, &wbuf, table->name); + i = 0; + while (wbuf[i] != END_SEQ) { + pos += sprintf(pos, "0x%04x, 0x%04x\n", wbuf[i], wbuf[i+1]); + i += 2; + } + if (!IS_ERR_OR_NULL(wbuf)) + kfree(wbuf); + pos += sprintf(pos, "%s\n", table->name); + } + +exit: + pos += sprintf(pos, "-- %s\n", __func__); + + return pos - buf; +} + +static ssize_t tuning_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + int ret; + + if (sysfs_streq(buf, "0") || sysfs_streq(buf, "1")) { + ret = kstrtoul(buf, 0, (unsigned long *)&mdnie->tuning); + if (!mdnie->tuning) + memset(mdnie->path, 0, sizeof(mdnie->path)); + dev_info(dev, "%s :: %s\n", __func__, mdnie->tuning ? "enable" : "disable"); + } else { + if (!mdnie->tuning) + return count; + + if (count > (sizeof(mdnie->path) - sizeof(MDNIE_SYSFS_PREFIX))) { + dev_err(dev, "file name %s is too long\n", mdnie->path); + return -ENOMEM; + } + + memset(mdnie->path, 0, sizeof(mdnie->path)); + snprintf(mdnie->path, sizeof(MDNIE_SYSFS_PREFIX) + count-1, "%s%s", MDNIE_SYSFS_PREFIX, buf); + dev_info(dev, "%s :: %s\n", __func__, mdnie->path); + + mdnie_update(mdnie); + } + + return count; +} + +static ssize_t negative_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->negative); +} + +static ssize_t negative_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value; + int ret; + + ret = kstrtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (ret < 0) + return ret; + else { + if (mdnie->negative == value) + return count; + + if (value >= NEGATIVE_MAX) + value = NEGATIVE_OFF; + + value = (value) ? NEGATIVE_ON : NEGATIVE_OFF; + + mutex_lock(&mdnie->lock); + mdnie->negative = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + } + return count; +} + +static ssize_t accessibility_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + unsigned short *wbuf; + int i = 0; + + pos += sprintf(pos, "%d, ", mdnie->accessibility); + if (mdnie->accessibility == COLOR_BLIND) { + if (!IS_ERR_OR_NULL(accessibility_table[mdnie->cabc][COLOR_BLIND].sequence)) { + wbuf = accessibility_table[mdnie->cabc][COLOR_BLIND].sequence; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_RGB(wbuf[i])) + pos += sprintf(pos, "0x%04x, ", wbuf[i+1]); + i += 2; + } + } + } + pos += sprintf(pos, "\n"); + + return pos - buf; +} + +static ssize_t accessibility_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value, s[9], cabc, i, len = 0; + int ret; + unsigned short *wbuf; + char str[100] = {0,}; + + ret = sscanf(buf, "%d %x %x %x %x %x %x %x %x %x", + &value, &s[0], &s[1], &s[2], &s[3], + &s[4], &s[5], &s[6], &s[7], &s[8]); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (ret < 0) + return ret; + else { + if (value >= ACCESSIBILITY_MAX) + value = ACCESSIBILITY_OFF; + + mutex_lock(&mdnie->lock); + mdnie->accessibility = value; + if (value == COLOR_BLIND) { + if (ret != 10) { + mutex_unlock(&mdnie->lock); + return -EINVAL; + } + + for (cabc = 0; cabc < CABC_MAX; cabc++) { + wbuf = accessibility_table[cabc][COLOR_BLIND].sequence; + if (IS_ERR_OR_NULL(wbuf)) + continue; + i = 0; + while (wbuf[i] != END_SEQ) { + if (ADDRESS_IS_SCR_RGB(wbuf[i])) + wbuf[i+1] = s[SCR_RGB_MASK(wbuf[i])]; + i += 2; + } + } + + i = 0; + len = sprintf(str + len, "%s :: ", __func__); + while (len < sizeof(str) && i < ARRAY_SIZE(s)) { + len += sprintf(str + len, "0x%04x, ", s[i]); + i++; + } + dev_info(dev, "%s\n", str); + } + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + } + return count; +} + +static ssize_t color_correct_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + char *pos = buf; + int i; + int result[5] = {0,}; + + if (!mdnie->color_correction) + return -EINVAL; + + for (i = 1; i < ARRAY_SIZE(result); i++) + pos += sprintf(pos, "F%d= %d, ", i, result[i]); + pos += sprintf(pos, "idx=%d\n", get_panel_color_position(mdnie, result)); + + return pos - buf; +} + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +static ssize_t ebook_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + + return sprintf(buf, "%d\n", mdnie->ebook); +} + +static ssize_t ebook_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t count) +{ + struct mdnie_info *mdnie = dev_get_drvdata(dev); + unsigned int value; + int ret; + + ret = strict_strtoul(buf, 0, (unsigned long *)&value); + + dev_info(dev, "%s :: value=%d\n", __func__, value); + + if (ret < 0) + return ret; + else { + if (mdnie->ebook == value) + return count; + + if (value >= EBOOK_MAX) + value = EBOOK_OFF; + + value = (value) ? EBOOK_ON : EBOOK_OFF; + + mutex_lock(&mdnie->lock); + mdnie->ebook = value; + mutex_unlock(&mdnie->lock); + + mdnie_update(mdnie); + } + return count; +} +#endif + +static struct device_attribute mdnie_attributes[] = { + __ATTR(mode, 0664, mode_show, mode_store), + __ATTR(scenario, 0664, scenario_show, scenario_store), + __ATTR(outdoor, 0664, outdoor_show, outdoor_store), +#if defined(CONFIG_FB_MDNIE_PWM) + __ATTR(cabc, 0664, cabc_show, cabc_store), +#endif + __ATTR(tuning, 0664, tuning_show, tuning_store), + __ATTR(negative, 0664, negative_show, negative_store), + __ATTR(accessibility, 0664, accessibility_show, accessibility_store), + __ATTR(color_correct, 0444, color_correct_show, NULL), +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + __ATTR(ebook, 0664, ebook_show, ebook_store), +#endif + __ATTR_NULL, +}; + +#ifdef CONFIG_PM +#if defined(CONFIG_HAS_EARLYSUSPEND) +#if defined(CONFIG_FB_MDNIE_PWM) +static void mdnie_early_suspend(struct early_suspend *h) +{ + struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend); + struct lcd_platform_data *pd = mdnie->lcd_pd; + + dev_info(mdnie->dev, "+%s\n", __func__); + + mdnie->bd_enable = FALSE; + + if (mdnie->enable) + mdnie_pwm_control(mdnie, 0); + + if (pd && pd->power_on) + pd->power_on(NULL, 0); + + dev_info(mdnie->dev, "-%s\n", __func__); + + return; +} +#endif + +static void mdnie_late_resume(struct early_suspend *h) +{ + struct mdnie_info *mdnie = container_of(h, struct mdnie_info, early_suspend); +#if defined(CONFIG_FB_MDNIE_PWM) + struct lcd_platform_data *pd = mdnie->lcd_pd; +#endif + + dev_info(mdnie->dev, "+%s\n", __func__); + +#if defined(CONFIG_FB_MDNIE_PWM) + if (mdnie->enable) + mdnie_pwm_control(mdnie, 0); + + if (pd && pd->power_on) + pd->power_on(NULL, 1); + + if (mdnie->enable) { + dev_info(&mdnie->bd->dev, "brightness=%d\n", mdnie->bd->props.brightness); + update_brightness(mdnie); + } + + mdnie->bd_enable = TRUE; +#endif + + mdnie_update(mdnie); + + dev_info(mdnie->dev, "-%s\n", __func__); + + return; +} +#endif +#endif + +static int mdnie_probe(struct platform_device *pdev) +{ +#if defined(CONFIG_FB_MDNIE_PWM) + struct platform_mdnie_data *pdata = pdev->dev.platform_data; +#endif + struct mdnie_info *mdnie; + int ret = 0; + + mdnie_class = class_create(THIS_MODULE, dev_name(&pdev->dev)); + if (IS_ERR_OR_NULL(mdnie_class)) { + pr_err("failed to create mdnie class\n"); + ret = -EINVAL; + goto error0; + } + + mdnie_class->dev_attrs = mdnie_attributes; + + mdnie = kzalloc(sizeof(struct mdnie_info), GFP_KERNEL); + if (!mdnie) { + pr_err("failed to allocate mdnie\n"); + ret = -ENOMEM; + goto error1; + } + + mdnie->dev = device_create(mdnie_class, &pdev->dev, 0, &mdnie, "mdnie"); + if (IS_ERR_OR_NULL(mdnie->dev)) { + pr_err("failed to create mdnie device\n"); + ret = -EINVAL; + goto error2; + } + +#if defined(CONFIG_FB_MDNIE_PWM) + if (!pdata) { + pr_err("no platform data specified\n"); + ret = -EINVAL; + goto error2; + } + + mdnie->bd = backlight_device_register("panel", mdnie->dev, + mdnie, &mdnie_backlight_ops, NULL); + mdnie->bd->props.max_brightness = MAX_BRIGHTNESS_LEVEL; + mdnie->bd->props.brightness = DEFAULT_BRIGHTNESS; + mdnie->bd_enable = TRUE; + mdnie->lcd_pd = pdata->lcd_pd; + + ret = device_create_file(&mdnie->bd->dev, &dev_attr_auto_brightness); + if (ret < 0) + dev_err(&mdnie->bd->dev, "failed to add sysfs entries, %d\n", __LINE__); +#endif + + mdnie->scenario = UI_MODE; + mdnie->mode = STANDARD; + mdnie->tone = TONE_NORMAL; + mdnie->outdoor = OUTDOOR_OFF; + mdnie->enable = TRUE; + mdnie->tuning = FALSE; + mdnie->negative = NEGATIVE_OFF; + mdnie->accessibility = ACCESSIBILITY_OFF; + mdnie->cabc = CABC_OFF; + +#if defined(CONFIG_FB_MDNIE_PWM) +#if defined(CONFIG_FB_S5P_S6F1202A) + mdnie->cabc = CABC_ON; +#endif + mdnie->power_lut_idx = LUT_LEVEL_MANUAL_AND_INDOOR; + mdnie->auto_brightness = 0; +#endif + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + mdnie->ebook = EBOOK_OFF; +#endif + + mutex_init(&mdnie->lock); + mutex_init(&mdnie->dev_lock); + + platform_set_drvdata(pdev, mdnie); + dev_set_drvdata(mdnie->dev, mdnie); + +#ifdef CONFIG_HAS_EARLYSUSPEND +#if defined(CONFIG_FB_MDNIE_PWM) + mdnie->early_suspend.suspend = mdnie_early_suspend; +#endif + mdnie->early_suspend.resume = mdnie_late_resume; + mdnie->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1; + register_early_suspend(&mdnie->early_suspend); +#endif + + +#if defined(CONFIG_FB_MDNIE_PWM) + dev_info(mdnie->dev, "lcdtype = %d\n", pdata->display_type); + if (pdata->display_type > ARRAY_SIZE(backlight_table)) + pdata->display_type = 0; + mdnie->backlight = &backlight_table[pdata->display_type]; +#endif + +#if defined(CONFIG_FB_S5P_S6F1202A) + if (pdata->display_type == 0) { + memcpy(tuning_table, tuning_table_hydis, sizeof(tuning_table)); + memcpy(etc_table, etc_table_hydis, sizeof(etc_table)); + memcpy(camera_table, camera_table_hydis, sizeof(camera_table)); + } else if (pdata->display_type == 1) { + memcpy(tuning_table, tuning_table_sec, sizeof(tuning_table)); + memcpy(etc_table, etc_table_sec, sizeof(etc_table)); + memcpy(camera_table, camera_table_sec, sizeof(camera_table)); + } else if (pdata->display_type == 2) { + memcpy(tuning_table, tuning_table_boe, sizeof(tuning_table)); + memcpy(etc_table, etc_table_boe, sizeof(etc_table)); + memcpy(camera_table, camera_table_boe, sizeof(camera_table)); + } +#endif + + g_mdnie = mdnie; + + mdnie_update(mdnie); + + dev_info(mdnie->dev, "registered successfully\n"); + + return 0; + +error2: + kfree(mdnie); +error1: + class_destroy(mdnie_class); +error0: + return ret; +} + +static int mdnie_remove(struct platform_device *pdev) +{ + struct mdnie_info *mdnie = dev_get_drvdata(&pdev->dev); + +#if defined(CONFIG_FB_MDNIE_PWM) + backlight_device_unregister(mdnie->bd); +#endif + class_destroy(mdnie_class); + kfree(mdnie); + + return 0; +} + +static void mdnie_shutdown(struct platform_device *pdev) +{ +#if defined(CONFIG_FB_MDNIE_PWM) + struct mdnie_info *mdnie = dev_get_drvdata(&pdev->dev); + struct lcd_platform_data *pd = NULL; + pd = mdnie->lcd_pd; + + dev_info(mdnie->dev, "+%s\n", __func__); + + mdnie->bd_enable = FALSE; + + if (mdnie->enable) + mdnie_pwm_control(mdnie, 0); + + if (pd && pd->power_on) + pd->power_on(NULL, 0); + + dev_info(mdnie->dev, "-%s\n", __func__); +#endif +} + + +static struct platform_driver mdnie_driver = { + .driver = { + .name = "mdnie", + .owner = THIS_MODULE, + }, + .probe = mdnie_probe, + .remove = mdnie_remove, +#ifndef CONFIG_HAS_EARLYSUSPEND + .suspend = mdnie_suspend, + .resume = mdnie_resume, +#endif + .shutdown = mdnie_shutdown, +}; + +static int __init mdnie_init(void) +{ + return platform_driver_register(&mdnie_driver); +} +module_init(mdnie_init); + +static void __exit mdnie_exit(void) +{ + platform_driver_unregister(&mdnie_driver); +} +module_exit(mdnie_exit); + +MODULE_DESCRIPTION("mDNIe Driver"); +MODULE_LICENSE("GPL"); + diff --git a/drivers/video/samsung/mdnie_kona.h b/drivers/video/samsung/mdnie_kona.h new file mode 100644 index 0000000..b5c95ab --- /dev/null +++ b/drivers/video/samsung/mdnie_kona.h @@ -0,0 +1,148 @@ +#ifndef __MDNIE_H__ +#define __MDNIE_H__ + +#define END_SEQ 0xffff + +enum MODE { + DYNAMIC, + STANDARD, +#if !defined(CONFIG_FB_MDNIE_PWM) + NATURAL, +#endif + MOVIE, + MODE_MAX, +}; + +enum SCENARIO { + CYANOGENMOD_MODE, + UI_MODE, + VIDEO_MODE, + VIDEO_WARM_MODE, + VIDEO_COLD_MODE, + CAMERA_MODE, + NAVI_MODE, + GALLERY_MODE, + VT_MODE, + SCENARIO_MAX, + COLOR_TONE_1 = 40, + COLOR_TONE_2, + COLOR_TONE_3, + COLOR_TONE_MAX, +}; + +enum SCENARIO_DMB { + DMB_NORMAL_MODE = 20, + DMB_WARM_MODE, + DMB_COLD_MODE, + DMB_MODE_MAX, +}; + +enum OUTDOOR { + OUTDOOR_OFF, + OUTDOOR_ON, + OUTDOOR_MAX, +}; + +enum TONE { + TONE_NORMAL, + TONE_WARM, + TONE_COLD, + TONE_MAX, +}; + +enum CABC { + CABC_OFF, +#if defined(CONFIG_FB_MDNIE_PWM) + CABC_ON, +#endif + CABC_MAX, +}; + +enum POWER_LUT { + LUT_DEFAULT, + LUT_VIDEO, + LUT_MAX, +}; + +enum POWER_LUT_LEVEL { + LUT_LEVEL_MANUAL_AND_INDOOR, + LUT_LEVEL_OUTDOOR_1, + LUT_LEVEL_OUTDOOR_2, + LUT_LEVEL_MAX, +}; + +enum NEGATIVE { + NEGATIVE_OFF, + NEGATIVE_ON, + NEGATIVE_MAX, +}; + +enum ACCESSIBILITY { + ACCESSIBILITY_OFF, + NEGATIVE, + COLOR_BLIND, + ACCESSIBILITY_MAX, +}; + +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) +enum EBOOK { + EBOOK_OFF, + EBOOK_ON, + EBOOK_MAX, +}; +#endif + +struct mdnie_tuning_info { + char *name; + unsigned short * const sequence; +}; + +struct mdnie_backlight_value { + const unsigned int max; + const unsigned int mid; + const unsigned char low; + const unsigned char dim; +}; + +struct mdnie_info { + struct device *dev; +#if defined(CONFIG_FB_MDNIE_PWM) + struct lcd_platform_data *lcd_pd; + struct backlight_device *bd; + unsigned int bd_enable; + unsigned int auto_brightness; + unsigned int power_lut_idx; + struct mdnie_backlight_value *backlight; +#endif + struct mutex lock; + struct mutex dev_lock; + + unsigned int enable; + enum SCENARIO scenario; + enum MODE mode; + enum TONE tone; + enum OUTDOOR outdoor; + enum CABC cabc; + unsigned int tuning; + unsigned int negative; + unsigned int accessibility; + unsigned int color_correction; + char path[50]; +#if defined(CONFIG_FB_EBOOK_PANEL_SCENARIO) + unsigned int ebook; +#endif +#ifdef CONFIG_HAS_EARLYSUSPEND + struct early_suspend early_suspend; +#endif +}; + +extern struct mdnie_info *g_mdnie; + +#if defined(CONFIG_FB_MDNIE_PWM) +extern void set_mdnie_pwm_value(struct mdnie_info *mdnie, int value); +#endif +extern int mdnie_calibration(unsigned short x, unsigned short y, int *r); +extern int mdnie_request_firmware(const char *path, u16 **buf, char *name); +extern int mdnie_open_file(const char *path, char **fp); + +#endif /* __MDNIE_H__ */ diff --git a/drivers/video/samsung/mdnie_table_4412_kona.h b/drivers/video/samsung/mdnie_table_4412_kona.h new file mode 100644 index 0000000..40e7c07 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_4412_kona.h @@ -0,0 +1,319 @@ +#ifndef __MDNIE_TABLE_H__ +#define __MDNIE_TABLE_H__ + +#include "mdnie_kona.h" + + +static unsigned short tune_dynamic_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_gallery[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_ui[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_video[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_natural_vt[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_camera[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ +}; + +static unsigned short tune_camera_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ +}; + +static unsigned short tune_cold[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x008c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +#if defined(CONFIG_FB_MDNIE_PWM) +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + }, + { + { + {"normal_cabc", NULL}, + {"warm_cabc", tune_warm}, + {"cold_cabc", tune_cold}, + }, + { + {"normal_outdoor_cabc", tune_normal_outdoor}, + {"warm_outdoor_cabc", tune_warm_outdoor}, + {"cold_outdoor_cabc", tune_cold_outdoor}, + }, + }, +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + }, { + { + {"dynamic_ui_cabc", tune_dynamic_ui}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"dynamic_video_cabc", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui_cabc", tune_dynamic_ui}, + {"dynamic_gallery_cabc", tune_dynamic_gallery}, + {"dynamic_vt_cabc", tune_dynamic_vt}, + }, { + {"standard_ui_cabc", tune_standard_ui}, + {"standard_video_cabc", tune_standard_video}, + {"standard_video_cabc", tune_standard_video}, + {"standard_video_cabc", tune_standard_video}, + {"camera", NULL}, + {"standard_ui_cabc", tune_standard_ui}, + {"standard_gallery_cabc", tune_standard_gallery}, + {"standard_vt_cabc", tune_standard_vt}, + }, { + {"movie_ui_cabc", tune_movie_ui}, + {"movie_video_cabc", tune_movie_video}, + {"movie_video_cabc", tune_movie_video}, + {"movie_video_cabc", tune_movie_video}, + {"camera", NULL}, + {"movie_ui_cabc", tune_movie_ui}, + {"movie_gallery_cabc", tune_movie_gallery}, + {"movie_vt_cabc", tune_movie_vt}, + }, + }, +}; +#else +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + } +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL/*tune_camera*/}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL/*tune_camera*/}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"natural_ui", tune_natural_ui}, + {"natural_video", tune_natural_video}, + {"natural_video", tune_natural_video}, + {"natural_video", tune_natural_video}, + {"camera", NULL/*tune_camera*/}, + {"natural_ui", tune_natural_ui}, + {"natural_gallery", tune_natural_gallery}, + {"natural_vt", tune_natural_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL/*tune_camera*/}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + } +}; +#endif + +struct mdnie_tuning_info camera_table[OUTDOOR_MAX] = { + {"camera", tune_camera}, + {"camera_outdoor", tune_camera_outdoor}, +}; + +#endif /* __MDNIE_TABLE_H__ */ diff --git a/drivers/video/samsung/mdnie_table_ebook.h b/drivers/video/samsung/mdnie_table_ebook.h new file mode 100644 index 0000000..2f75fa4 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_ebook.h @@ -0,0 +1,153 @@ +#ifndef __MDNIE_TABLE_EBOOK_H__ +#define __MDNIE_TABLE_EBOOK_H__ + +#include "mdnie_kona.h" + +#if defined(CONFIG_FB_MDNIE_PWM) +static unsigned short tune_ebook[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_ebook_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#else +static unsigned short tune_ebook[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a0, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00ff, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ef, /*SCR KgWg*/ + 0x00ec,0x00e4, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x1090, /*CC lut r 16 144*/ + 0x0022,0x20a0, /*CC lut r 32 160*/ + 0x0023,0x30b0, /*CC lut r 48 176*/ + 0x0024,0x40c0, /*CC lut r 64 192*/ + 0x0025,0x50d0, /*CC lut r 80 208*/ + 0x0026,0x60e0, /*CC lut r 96 224*/ + 0x0027,0x70f0, /*CC lut r 112 240*/ + 0x0028,0x80ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; +#endif + +struct mdnie_tuning_info ebook_table[CABC_MAX] = { +#if defined(CONFIG_FB_MDNIE_PWM) + {"EBOOK", tune_ebook}, + {"EBOOK_CABC", tune_ebook_cabc}, +#else + {"EBOOK", tune_ebook}, +#endif +}; +#endif /* __MDNIE_TABLE_EBOOK_H__ */ diff --git a/drivers/video/samsung/mdnie_table_kona.h b/drivers/video/samsung/mdnie_table_kona.h new file mode 100644 index 0000000..8b3b283 --- /dev/null +++ b/drivers/video/samsung/mdnie_table_kona.h @@ -0,0 +1,1304 @@ +#ifndef __MDNIE_TABLE_H__ +#define __MDNIE_TABLE_H__ + +#include "mdnie_kona.h" + + +static struct mdnie_backlight_value backlight_table[4] = { + { + .max = 977, /*3G/WIFI BOE LCD SYS REV <= 0x03*/ + .mid = 531, /*LTE BOE LCD SYS REV <= 0x02*/ + .low = 16, + .dim = 16, + }, { + .max = 1280, /*3G/WIFI BOE LCD SYS REV >= 0x04*/ + .mid = 700, /*LTE BOE LCD SYS REV >= 0x03*/ + .low = 16, + .dim = 16, + }, { + .max = 1056, /*3G/WIFI SDC LCD SYS REV <= 0x03*/ + .mid = 574, /*LTE SDC LCD SYS REV <= 0x02*/ + .low = 16, + .dim = 16, + }, { + .max = 1435, /* 3G/WIFI SDC LCD SYS REV >= 0x04*/ + .mid = 780, /* LTE SDC LCD SYS REV >= 0x03*/ + .low = 17, + .dim = 17, + } +}; + +static const unsigned char power_lut[LUT_LEVEL_MAX][LUT_MAX][9] = { + /* Indoor power look up table */ + { + {0x42, 0x3d, 0x3E, 0x48, 0x42, 0x3F, 0x3A, 0x37, 0x3F}, + {0x38, 0x3d, 0x34, 0x48, 0x38, 0x35, 0x30, 0x2d, 0x35}, + }, + /* Outdoor power look up table for outdoor 1 (1k~15k) */ + { + {0x42, 0x47, 0x3E, 0x52, 0x42, 0x3F, 0x3A, 0x37, 0x3F}, + {0x38, 0x3d, 0x34, 0x48, 0x38, 0x35, 0x30, 0x2d, 0x35}, + }, + /* Outdoor power look up table (15k ~) */ + { + {100, 100, 100, 100, 100, 100, 100, 100, 100}, + {100, 100, 100, 100, 100, 100, 100, 100, 100}, + }, +}; + +static unsigned short tune_camera[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x002c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_camera_outdoor[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x042c, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x00d0,0x01a0, /*UC y*/ + 0x00d1,0x01ff, /*UC cs*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0080, /*DE pf*/ + 0x0094,0x0080, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0080, /*DE nf*/ + 0x0097,0x0080, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_gallery[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0050, /*DE pf*/ + 0x0094,0x0050, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0050, /*DE nf*/ + 0x0097,0x0050, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00e0, /*DE pe*/ + 0x0093,0x00e0, /*DE pf*/ + 0x0094,0x00e0, /*DE pb*/ + 0x0095,0x00e0, /*DE ne*/ + 0x0096,0x00e0, /*DE nf*/ + 0x0097,0x00e0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui[] = { + /*start KONA standard ui cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video[] = { + /*start KONA standard video cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0060, /*DE pf*/ + 0x0094,0x0060, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0060, /*DE nf*/ + 0x0097,0x0060, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery[] = { + /*start KONA standard gallery cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt[] = { + /*start KONA standard vtcall cabcoff*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x00ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00c0, /*DE pe*/ + 0x0093,0x00c0, /*DE pf*/ + 0x0094,0x00c0, /*DE pb*/ + 0x0095,0x00c0, /*DE ne*/ + 0x0096,0x00c0, /*DE nf*/ + 0x0097,0x00c0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0000, /*DE pf*/ + 0x0094,0x0000, /*DE pb*/ + 0x0095,0x0000, /*DE ne*/ + 0x0096,0x0000, /*DE nf*/ + 0x0097,0x0000, /*DE nb*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1004, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0020, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x002e, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x0040, /*DE pe*/ + 0x0093,0x0040, /*DE pf*/ + 0x0094,0x0040, /*DE pb*/ + 0x0095,0x0040, /*DE ne*/ + 0x0096,0x0040, /*DE nf*/ + 0x0097,0x0040, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1204, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_ui_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_video_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0080, /*DE pf*/ + 0x0094,0x0080, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0080, /*DE nf*/ + 0x0097,0x0080, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_gallery_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0050, /*DE pf*/ + 0x0094,0x0050, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0050, /*DE nf*/ + 0x0097,0x0050, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_dynamic_vt_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00e0, /*DE pe*/ + 0x0093,0x00e0, /*DE pf*/ + 0x0094,0x00e0, /*DE pb*/ + 0x0095,0x00e0, /*DE ne*/ + 0x0096,0x00e0, /*DE nf*/ + 0x0097,0x00e0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1a04, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0b94, /*CC lut r 16 144*/ + 0x0022,0x18a6, /*CC lut r 32 160*/ + 0x0023,0x28b8, /*CC lut r 48 176*/ + 0x0024,0x3ac9, /*CC lut r 64 192*/ + 0x0025,0x4cd9, /*CC lut r 80 208*/ + 0x0026,0x5ee7, /*CC lut r 96 224*/ + 0x0027,0x70f4, /*CC lut r 112 240*/ + 0x0028,0x82ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_ui_cabc[] = { + /*start KONA standard ui cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02a8, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_video_cabc[] = { + /*start KONA standard video cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0030, /*DE pe*/ + 0x0093,0x0060, /*DE pf*/ + 0x0094,0x0060, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0060, /*DE nf*/ + 0x0097,0x0060, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_gallery_cabc[] = { + /*start KONA standard gallery cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0090,0x0080, /*DE egth*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0030, /*DE pf*/ + 0x0094,0x0030, /*DE pb*/ + 0x0095,0x0030, /*DE ne*/ + 0x0096,0x0030, /*DE nf*/ + 0x0097,0x0030, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_standard_vt_cabc[] = { + /*start KONA standard vtcall cabcon*/ + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x02ae, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x00c0, /*DE pe*/ + 0x0093,0x00c0, /*DE pf*/ + 0x0094,0x00c0, /*DE pb*/ + 0x0095,0x00c0, /*DE ne*/ + 0x0096,0x00c0, /*DE nf*/ + 0x0097,0x00c0, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1804, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00ff, /*SCR KgWg*/ + 0x00ec,0x00ff, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x001f,0x0080, /*CC chsel strength*/ + 0x0020,0x0000, /*CC lut r 0*/ + 0x0021,0x0a82, /*CC lut r 16 144*/ + 0x0022,0x1693, /*CC lut r 32 160*/ + 0x0023,0x23a4, /*CC lut r 48 176*/ + 0x0024,0x32b6, /*CC lut r 64 192*/ + 0x0025,0x41c8, /*CC lut r 80 208*/ + 0x0026,0x50da, /*CC lut r 96 224*/ + 0x0027,0x60ed, /*CC lut r 112 240*/ + 0x0028,0x71ff, /*CC lut r 128 255*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + /*end*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_ui_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_video_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x0092,0x0000, /*DE pe*/ + 0x0093,0x0000, /*DE pf*/ + 0x0094,0x0000, /*DE pb*/ + 0x0095,0x0000, /*DE ne*/ + 0x0096,0x0000, /*DE nf*/ + 0x0097,0x0000, /*DE nb*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1004, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_gallery_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x0220, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0000, /*FA cs1 de8 hdr2 fa1*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_movie_vt_cabc[] = { + 0x0000,0x0000, /*BANK 0*/ + 0x0008,0x022e, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0030,0x0005, /*FA cs1 de8 hdr2 fa1*/ + 0x0039,0x0080, /*FA dnrWeight*/ + 0x0080,0x0fff, /*DNR dirTh*/ + 0x0081,0x19ff, /*DNR dirnumTh decon7Th*/ + 0x0082,0xff16, /*DNR decon5Th maskTh*/ + 0x0083,0x0000, /*DNR blTh*/ + 0x0092,0x0040, /*DE pe*/ + 0x0093,0x0040, /*DE pf*/ + 0x0094,0x0040, /*DE pb*/ + 0x0095,0x0040, /*DE ne*/ + 0x0096,0x0040, /*DE nf*/ + 0x0097,0x0040, /*DE nb*/ + 0x0098,0x1000, /*DE max ratio*/ + 0x0099,0x0100, /*DE min ratio*/ + 0x00b0,0x1010, /*CS hg ry*/ + 0x00b1,0x1010, /*CS hg gc*/ + 0x00b2,0x1010, /*CS hg bm*/ + 0x00b3,0x1204, /*CS weight grayTH*/ + 0x00e1,0xff00, /*SCR RrCr*/ + 0x00e2,0x00ff, /*SCR RgCg*/ + 0x00e3,0x00ff, /*SCR RbCb*/ + 0x00e4,0x00ff, /*SCR GrMr*/ + 0x00e5,0xff00, /*SCR GgMg*/ + 0x00e6,0x00ff, /*SCR GbMb*/ + 0x00e7,0x00ff, /*SCR BrYr*/ + 0x00e8,0x00f0, /*SCR BgYg*/ + 0x00e9,0xff00, /*SCR BbYb*/ + 0x00ea,0x00ff, /*SCR KrWr*/ + 0x00eb,0x00f6, /*SCR KgWg*/ + 0x00ec,0x00f2, /*SCR KbWb*/ + 0x0000,0x0001, /*BANK 1*/ + 0x0075,0x0000, /*CABC dgain*/ + 0x0076,0x0000, + 0x0077,0x0000, + 0x0078,0x0000, + 0x007f,0x0002, /*dynamic lcd*/ + 0x00ff,0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x00ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x00ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00d0, 0x01c0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x04ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x02ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x02ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_normal_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ac, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_warm_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0028, /*MCM 4000K*/ + 0x0007, 0x7575, /*MCM 1cb 2cb W*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x00d0, 0x01c0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +static unsigned short tune_cold_outdoor_cabc[] = { + 0x0000, 0x0000, /*BANK 0*/ + 0x0008, 0x06ec, /*Dither8 UC4 ABC2 CP1 | CC8 MCM4 SCR2 SCC1 | CS8 DE4 DNR2 HDR1*/ + 0x0000, 0x0001, /*BANK 1*/ + 0x0001, 0x0064, /*MCM 10000K*/ + 0x0009, 0xa08e, /*MCM 5cb 1cr W*/ + 0x000b, 0x7979, /*MCM 4cr 5cr W*/ + 0x00d0, 0x01a0, /*UC y*/ + 0x00d1, 0x01ff, /*UC cs*/ + 0x00ff, 0x0000, /*Mask Release*/ + END_SEQ, 0x0000, +}; + +struct mdnie_tuning_info etc_table[CABC_MAX][OUTDOOR_MAX][TONE_MAX] = { + { + { + {"normal", NULL}, + {"warm", tune_warm}, + {"cold", tune_cold}, + }, + { + {"normal_outdoor", tune_normal_outdoor}, + {"warm_outdoor", tune_warm_outdoor}, + {"cold_outdoor", tune_cold_outdoor}, + }, + }, + { + { + {"normal_cabc", NULL}, + {"warm_cabc", tune_warm_cabc}, + {"cold_cabc", tune_cold_cabc}, + }, + { + {"normal_outdoor_cabc", tune_normal_outdoor_cabc}, + {"warm_outdoor_cabc", tune_warm_outdoor_cabc}, + {"cold_outdoor_cabc", tune_cold_outdoor_cabc}, + }, + }, +}; + +struct mdnie_tuning_info tuning_table[CABC_MAX][MODE_MAX][SCENARIO_MAX] = { + { + { + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"dynamic_video", tune_dynamic_video}, + {"camera", NULL}, + {"dynamic_ui", tune_dynamic_ui}, + {"dynamic_gallery", tune_dynamic_gallery}, + {"dynamic_vt", tune_dynamic_vt}, + }, { + {"standard_ui", tune_standard_ui}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"standard_video", tune_standard_video}, + {"camera", NULL}, + {"standard_ui", tune_standard_ui}, + {"standard_gallery", tune_standard_gallery}, + {"standard_vt", tune_standard_vt}, + }, { + {"movie_ui", tune_movie_ui}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"movie_video", tune_movie_video}, + {"camera", NULL}, + {"movie_ui", tune_movie_ui}, + {"movie_gallery", tune_movie_gallery}, + {"movie_vt", tune_movie_vt}, + }, + }, { + { + {"dynamic_ui_cabc", tune_dynamic_ui_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"dynamic_video_cabc", tune_dynamic_video_cabc}, + {"camera", NULL}, + {"dynamic_ui_cabc", tune_dynamic_ui_cabc}, + {"dynamic_gallery_cabc", tune_dynamic_gallery_cabc}, + {"dynamic_vt_cabc", tune_dynamic_vt_cabc}, + }, { + {"standard_ui_cabc", tune_standard_ui_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"standard_video_cabc", tune_standard_video_cabc}, + {"camera", NULL}, + {"standard_ui_cabc", tune_standard_ui_cabc}, + {"standard_gallery_cabc", tune_standard_gallery_cabc}, + {"standard_vt_cabc", tune_standard_vt_cabc}, + }, { + {"movie_ui_cabc", tune_movie_ui_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"movie_video_cabc", tune_movie_video_cabc}, + {"camera", NULL}, + {"movie_ui_cabc", tune_movie_ui_cabc}, + {"movie_gallery_cabc", tune_movie_gallery_cabc}, + {"movie_vt_cabc", tune_movie_vt_cabc}, + }, + }, +}; + +struct mdnie_tuning_info camera_table[OUTDOOR_MAX] = { + {"camera", tune_camera}, + {"camera_outdoor", tune_camera_outdoor}, +}; + +#endif /* __MDNIE_TABLE_H__ */ diff --git a/drivers/video/samsung/mdnie_tuning_kona.c b/drivers/video/samsung/mdnie_tuning_kona.c new file mode 100644 index 0000000..e198a85 --- /dev/null +++ b/drivers/video/samsung/mdnie_tuning_kona.c @@ -0,0 +1,294 @@ +/* linux/drivers/video/samsung/mdnie_tuning.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2011 Samsung Electronics + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/errno.h> +#include <linux/fs.h> +#include <linux/ctype.h> +#include <linux/uaccess.h> +#include <linux/magic.h> + +#include "s3cfb.h" +#include "mdnie_kona.h" + +#define KFREE(ptr) do { if (ptr) kfree(ptr); (ptr) = NULL; } while (0) +#define CONSTANT_F1 ((23<<10)/21) +#define CONSTANT_F2 ((19<<10)/18) +#define CONSTANT_F3 (5<<10) +#define CONSTANT_F4 ((21<<10)/8) + +int mdnie_calibration(unsigned short x, unsigned short y, int *result) +{ + u8 ret = 0; + + result[1] = ((y << 10) - (CONSTANT_F1 * x) + (12 << 10)) >> 10; + result[2] = ((y << 10) - (CONSTANT_F2 * x) + (44 << 10)) >> 10; + result[3] = ((y << 10) + (CONSTANT_F3 * x) - (18365 << 10)) >> 10; + result[4] = ((y << 10) + (CONSTANT_F4 * x) - (10814 << 10)) >> 10; + + pr_info("%d, %d, %d, %d\n", result[1], result[2], result[3], result[4]); + + if (result[1] > 0) { + if (result[3] > 0) + ret = 3; + else + ret = (result[4] < 0) ? 1 : 2; + } else { + if (result[2] < 0) { + if (result[3] > 0) + ret = 9; + else + ret = (result[4] < 0) ? 7 : 8; + } else { + if (result[3] > 0) + ret = 6; + else + ret = (result[4] < 0) ? 4 : 5; + } + } + + ret = (ret > 0) ? ret : 1; + ret = (ret > 9) ? 1 : ret; + + return ret; +} + +static int parse_text(char *src, int len, u16 *buf, char *name) +{ + int i, count, ret; + int index = 0; + char *str_line[100]; + char *sstart; + char *c; + unsigned int data1, data2; + + c = src; + count = 0; + sstart = c; + + for (i = 0; i < len; i++, c++) { + char a = *c; + if (a == '\r' || a == '\n') { + if (c > sstart) { + str_line[count] = sstart; + count++; + } + *c = '\0'; + sstart = c+1; + } + } + + if (c > sstart) { + str_line[count] = sstart; + count++; + } + + /* printk(KERN_INFO "----------------------------- Total number of lines:%d\n", count); */ + + for (i = 0; i < count; i++) { + /* printk(KERN_INFO "line:%d, [start]%s[end]\n", i, str_line[i]); */ + ret = sscanf(str_line[i], "0x%x, 0x%x\n", &data1, &data2); + /* printk(KERN_INFO "Result => [0x%2x 0x%4x] %s\n", data1, data2, (ret == 2) ? "Ok" : "Not available"); */ + if (ret == 2) { + buf[index++] = (unsigned short)data1; + buf[index++] = (unsigned short)data2; + } + } + + buf[index] = END_SEQ; + + return index; +} + +int mdnie_txtbuf_to_parsing(char *path, u16 size, u16 *buf, char *name) +{ + struct file *filp; + char *dp; + long l; + loff_t pos; + int ret, num; + mm_segment_t fs; + + fs = get_fs(); + set_fs(get_ds()); + + if (!path) { + pr_err("%s: invalid filepath\n", __func__); + goto parse_err; + } + + filp = filp_open(path, O_RDONLY, 0); + + if (IS_ERR(filp)) { + pr_err("file open error: %s\n", path); + goto parse_err; + } + + l = filp->f_path.dentry->d_inode->i_size; + dp = kmalloc(l, GFP_KERNEL); + if (dp == NULL) { + pr_err("Out of Memory!\n"); + filp_close(filp, current->files); + goto parse_err; + } + pos = 0; + memset(dp, 0, l); + ret = vfs_read(filp, (char __user *)dp, l, &pos); + + if (ret != l) { + pr_info("read size = %d, l = %ld, size=%d\n", ret, l, size); + l = (l > ret) ? ret : l; + if (size < l) { + KFREE(dp); + filp_close(filp, current->files); + goto parse_err; + } + } + + filp_close(filp, current->files); + set_fs(fs); + + num = parse_text(dp, l, buf, name); + + if (!num) { + pr_err("Nothing to parse!\n"); + KFREE(dp); + goto parse_err; + } + + KFREE(dp); + + return num; + +parse_err: + return -EPERM; +} + +int mdnie_open_file(const char *path, char **fp) +{ + struct file *filp; + char *dp; + long length; + int ret; + struct super_block *sb; + loff_t pos = 0; + + if (!path) { + pr_err("%s: path is invalid\n", __func__); + return -EPERM; + } + + filp = filp_open(path, O_RDONLY, 0); + if (IS_ERR(filp)) { + pr_err("%s: file open err: %s\n", __func__, path); + return -EPERM; + } + + length = i_size_read(filp->f_path.dentry->d_inode); + if (length <= 0) { + pr_err("%s: file size %ld error\n", __func__, length); + return -EPERM; + } + + dp = kzalloc(length, GFP_KERNEL); + if (dp == NULL) { + pr_err("%s: Out of Memory\n", __func__); + filp_close(filp, current->files); + return -EPERM; + } + + ret = kernel_read(filp, pos, dp, length); + if (ret != length) { + /* check node is sysfs, bus this way is not safe */ + sb = filp->f_path.dentry->d_inode->i_sb; + if ((sb->s_magic != SYSFS_MAGIC) && (length != sb->s_blocksize)) { + pr_err("%s: read size= %d, length= %ld\n", __func__, ret, length); + KFREE(dp); + filp_close(filp, current->files); + return -EPERM; + } + } + + filp_close(filp, current->files); + + *fp = dp; + + return ret; +} + +int mdnie_check_firmware(const char *path, char *name) +{ + char *ptr = NULL; + int ret = 0, size; + + size = mdnie_open_file(path, &ptr); + if (IS_ERR_OR_NULL(ptr) || size <= 0) { + pr_err("%s: file open fail %s\n", __func__, path); + KFREE(ptr); + return 0; + } + + ret = (strstr(ptr, name) != NULL) ? 1 : 0; + + KFREE(ptr); + + return ret; +} + +int mdnie_request_firmware(const char *path, u16 **buf, char *name) +{ + char *token, *ptr = NULL; + unsigned short *dp; + int ret = 0, size, i = 0; + unsigned int data1, data2; + + size = mdnie_open_file(path, &ptr); + if (IS_ERR_OR_NULL(ptr) || size <= 0) { + pr_err("%s: file open fail %s\n", __func__, path); + KFREE(ptr); + return ret; + } + + dp = kzalloc(size, GFP_KERNEL); + if (dp == NULL) { + pr_err("%s: Out of Memory\n", __func__); + KFREE(ptr); + return -ENOMEM; + } + + if (name) { + if (strstr(ptr, name) != NULL) { + pr_info("found %s in %s\n", name, path); + ptr = strstr(ptr, name); + } + } + + while ((token = strsep(&ptr, "\r\n")) != NULL) { + if ((name) && (!strncmp(token, "};", 2))) { + pr_info("found %s end in local, stop searching\n", name); + break; + } + ret = sscanf(token, "%x, %x", &data1, &data2); + if (ret == 2) { + dp[i] = (u16)data1; + dp[i+1] = (u16)data2; + i += 2; + } + } + + dp[i] = END_SEQ; + + *buf = dp; + + KFREE(ptr); + + return i; +} + diff --git a/drivers/video/samsung/s3cfb_ielcd_kona.c b/drivers/video/samsung/s3cfb_ielcd_kona.c new file mode 100644 index 0000000..7eadd5f --- /dev/null +++ b/drivers/video/samsung/s3cfb_ielcd_kona.c @@ -0,0 +1,136 @@ +/* linux/drivers/video/samsung/s3cfb_mdnie.c + * + * Register interface file for Samsung IELCD driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/clk.h> +#include <linux/mutex.h> +#include <linux/poll.h> +#include <linux/wait.h> +#include <linux/fs.h> +#include <linux/irq.h> +#include <linux/mm.h> +#include <linux/fb.h> +#include <linux/ctype.h> +#include <linux/miscdevice.h> +#include <linux/dma-mapping.h> +#include <linux/delay.h> +#include <linux/device.h> + +#include <linux/io.h> +#include <mach/map.h> +#include <plat/clock.h> +#include <plat/regs-fb-s5p.h> + +#include "s3cfb.h" +#include "s3cfb_mdnie_kona.h" +#include "s3cfb_ielcd_kona.h" + +static struct resource *s3c_ielcd_mem; +static void __iomem *s3c_ielcd_base; + +#define s3c_ielcd_readl(addr) __raw_readl(s3c_ielcd_base + addr) +#define s3c_ielcd_writel(addr, val) writel(val, s3c_ielcd_base + addr) + +static struct s3cfb_global ielcd_fb; +static struct s3cfb_global *ielcd_fbdev; + +int ielcd_hw_init(void) +{ + s3c_ielcd_mem = request_mem_region(S3C_IELCD_PHY_BASE, S3C_IELCD_MAP_SIZE, "ielcd"); + if (IS_ERR_OR_NULL(s3c_ielcd_mem)) { + pr_err("%s: fail to request_mem_region\n", __func__); + return -ENOENT; + } + + s3c_ielcd_base = ioremap(S3C_IELCD_PHY_BASE, S3C_IELCD_MAP_SIZE); + if (IS_ERR_OR_NULL(s3c_ielcd_base)) { + pr_err("%s: fail to ioremap\n", __func__); + return -ENOENT; + } + + ielcd_fbdev = &ielcd_fb; + + return 0; +} + +int ielcd_display_on(void) +{ + unsigned int cfg; + + cfg = s3c_ielcd_readl(S3C_VIDCON0); + cfg |= (S3C_VIDCON0_ENVID_ENABLE | S3C_VIDCON0_ENVID_F_ENABLE); + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + return 0; +} + +int ielcd_display_off(void) +{ + unsigned int cfg, ielcd_count = 0; + + cfg = s3c_ielcd_readl(S3C_VIDCON0); + cfg |= S3C_VIDCON0_ENVID_ENABLE; + cfg &= ~(S3C_VIDCON0_ENVID_F_ENABLE); + + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + do { + if (++ielcd_count > 2000000) { + printk(KERN_ERR "ielcd off fail\n"); + return 1; + } + + if (!(s3c_ielcd_readl(S3C_VIDCON1) & 0xffff0000)) + return 0; + } while (1); +} + +void ielcd_init_global(struct s3cfb_global *ctrl) +{ + unsigned int cfg; + + *ielcd_fbdev = *ctrl; + ctrl->ielcd_regs = ielcd_fbdev->regs = s3c_ielcd_base; + + s3c_ielcd_writel(S3C_IELCD_GPOUTCON0, S3C_IELCD_MAGIC_KEY); + + s3cfb_set_polarity_only(ielcd_fbdev); + s3cfb_set_timing(ielcd_fbdev); + s3cfb_set_lcd_size(ielcd_fbdev); + + /* vclock divider setting , same as FIMD */ + cfg = readl(ctrl->regs + S3C_VIDCON0); + cfg &= ~(S3C_VIDCON0_VIDOUT_MASK | S3C_VIDCON0_VCLKEN_MASK); + cfg |= S3C_VIDCON0_VIDOUT_RGB; + cfg |= S3C_VIDCON0_VCLKEN_NORMAL; + s3c_ielcd_writel(S3C_VIDCON0, cfg); + + /* window0 position setting , fixed */ + s3c_ielcd_writel(S3C_VIDOSD0A, 0); + + /* window0 position setting */ + cfg = S3C_VIDOSD_RIGHT_X(ctrl->lcd->width - 1); + cfg |= S3C_VIDOSD_BOTTOM_Y(ctrl->lcd->height - 1); + s3c_ielcd_writel(S3C_VIDOSD0B, cfg); + + /* window0 osd size setting */ + s3c_ielcd_writel(S3C_VIDOSD0C, ctrl->lcd->width * ctrl->lcd->height); + + /* window0 setting , fixed */ + cfg = S3C_WINCON_DATAPATH_LOCAL | S3C_WINCON_BPPMODE_32BPP | S3C_WINCON_INRGB_RGB; + s3c_ielcd_writel(S3C_WINCON0, cfg); + + s3cfb_window_on(ielcd_fbdev, 0); +} + diff --git a/drivers/video/samsung/s3cfb_ielcd_kona.h b/drivers/video/samsung/s3cfb_ielcd_kona.h new file mode 100644 index 0000000..4c89643 --- /dev/null +++ b/drivers/video/samsung/s3cfb_ielcd_kona.h @@ -0,0 +1,28 @@ +/* linux/drivers/video/samsung/s3cfb_ielcd.h + * + * Header file for Samsung (IELCD) driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#ifndef __S3CFB_IELCD_H__ +#define __S3CFB_IELCD_H__ + +#define S3C_IELCD_MAGIC_KEY 0x2ff47 + +#define S3C_IELCD_PHY_BASE 0x11C40000 +#define S3C_IELCD_MAP_SIZE 0x00008000 + +#define S3C_IELCD_GPOUTCON0 0x0278 + +int ielcd_hw_init(void); +int ielcd_display_on(void); +int ielcd_display_off(void); +void ielcd_init_global(struct s3cfb_global *ctrl); + +#endif diff --git a/drivers/video/samsung/s3cfb_main.c b/drivers/video/samsung/s3cfb_main.c index fadea40..191c68e 100644 --- a/drivers/video/samsung/s3cfb_main.c +++ b/drivers/video/samsung/s3cfb_main.c @@ -41,9 +41,14 @@ #endif #ifdef CONFIG_FB_S5P_MDNIE +#ifdef CONFIG_MACH_KONA +#include "s3cfb_mdnie_kona.h" +#include "mdnie_kona.h" +#else #include "s3cfb_mdnie.h" #include "mdnie.h" #endif +#endif #ifdef CONFIG_HAS_WAKELOCK #include <linux/wakelock.h> #include <linux/earlysuspend.h> @@ -604,8 +609,12 @@ static int s3cfb_probe(struct platform_device *pdev) #ifdef CONFIG_FB_S5P_MDNIE /* only FIMD0 is supported */ if (i == 0) +#ifdef CONFIG_MACH_KONA + mdnie_setup(); +#else s3c_mdnie_setup(); #endif +#endif /* hw setting */ s3cfb_init_global(fbdev[i]); @@ -636,8 +645,12 @@ static int s3cfb_probe(struct platform_device *pdev) pdata->set_display_path(); s3cfb_set_dualrgb(fbdev[i], S3C_DUALRGB_MDNIE); +#ifdef CONFIG_MACH_KONA + mdnie_display_on(fbdev[i]); +#else s3c_mdnie_init_global(fbdev[i]); s3c_mdnie_display_on(fbdev[i]); +#endif } #endif s3cfb_enable_window(fbdev[0], pdata->default_win); @@ -916,8 +929,12 @@ void s3cfb_early_suspend(struct early_suspend *h) ret = s3cfb_display_off(fbdev[i]); #ifdef CONFIG_FB_S5P_MDNIE +#ifdef CONFIG_MACH_KONA + ret += mdnie_display_off(); +#else ret += s3c_mdnie_display_off(); #endif +#endif if (ret > 0) s3cfb_lcd0_pmu_off(); @@ -1023,10 +1040,14 @@ void s3cfb_late_resume(struct early_suspend *h) #if defined(CONFIG_FB_S5P_S6C1372) || defined(CONFIG_FB_S5P_S6F1202A) s5c1372_ldi_enable(); #endif +#ifdef CONFIG_MACH_KONA + mdnie_display_on(fbdev[i]); +#else s3c_mdnie_init_global(fbdev[i]); set_mdnie_value(g_mdnie, 1); s3c_mdnie_display_on(fbdev[i]); #endif +#endif s3cfb_display_on(fbdev[i]); /* Set alpha value width to 8-bit */ diff --git a/drivers/video/samsung/s3cfb_mdnie_kona.c b/drivers/video/samsung/s3cfb_mdnie_kona.c new file mode 100644 index 0000000..1fc7fcd --- /dev/null +++ b/drivers/video/samsung/s3cfb_mdnie_kona.c @@ -0,0 +1,120 @@ +/* linux/drivers/video/samsung/s3cfb_mdnie.c + * + * Register interface file for Samsung mDNIe driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + + +#include "s3cfb.h" +#include "s3cfb_ielcd_kona.h" +#include "s3cfb_mdnie_kona.h" +#include "mdnie_kona.h" + + +#define s3c_mdnie_read(addr) __raw_readl(s3c_mdnie_base + addr*4) +#define s3c_mdnie_write(addr, val) __raw_writel(val, s3c_mdnie_base + addr*4) + + +static struct resource *s3c_mdnie_mem; +static void __iomem *s3c_mdnie_base; + + +int mdnie_write(unsigned int addr, unsigned int val) +{ + return s3c_mdnie_write(addr, val); +} + +int mdnie_mask(void) +{ + return s3c_mdnie_write(MDNIE_REG_MASK, 0x9FFF); +} + +int mdnie_unmask(void) +{ + return s3c_mdnie_write(MDNIE_REG_MASK, 0); +} + +int mdnie_set_size(unsigned int hsize, unsigned int vsize) +{ + unsigned int reg; + + /* Bank0 Select : DO NOT REMOVE THIS LINE */ + s3c_mdnie_write(MDNIE_REG_BANK_SEL, 0); + +#if defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) + /* Input Data Unmask */ + reg = s3c_mdnie_read(S3C_MDNIE_rR1); + reg &= ~S3C_MDNIE_INPUT_DATA_ENABLE; + s3c_mdnie_write(S3C_MDNIE_rR1, reg); +#endif + + /* LCD width */ + reg = s3c_mdnie_read(MDNIE_REG_WIDTH); + reg &= ~S3C_MDNIE_SIZE_MASK; + reg |= S3C_MDNIE_HSIZE(hsize); + s3c_mdnie_write(MDNIE_REG_WIDTH, reg); + + /* LCD height */ + reg = s3c_mdnie_read(MDNIE_REG_HEIGHT); + reg &= ~S3C_MDNIE_SIZE_MASK; + reg |= S3C_MDNIE_VSIZE(vsize); + s3c_mdnie_write(MDNIE_REG_HEIGHT, reg); + + mdnie_unmask(); + + return 0; +} + +int mdnie_display_on(struct s3cfb_global *ctrl) +{ + mdnie_set_size(ctrl->lcd->width, ctrl->lcd->height); + + ielcd_init_global(ctrl); + + ielcd_display_on(); + + if (!IS_ERR_OR_NULL(g_mdnie)) + g_mdnie->enable = TRUE; + + return 0; +} + +int mdnie_display_off(void) +{ + if (!IS_ERR_OR_NULL(g_mdnie)) + g_mdnie->enable = FALSE; + + return ielcd_display_off(); +} + +static int mdnie_hw_init(void) +{ + s3c_mdnie_mem = request_mem_region(S3C_MDNIE_PHY_BASE, S3C_MDNIE_MAP_SIZE, "mdnie"); + if (IS_ERR_OR_NULL(s3c_mdnie_mem)) { + pr_err("%s: fail to request_mem_region\n", __func__); + return -ENOENT; + } + + s3c_mdnie_base = ioremap(S3C_MDNIE_PHY_BASE, S3C_MDNIE_MAP_SIZE); + if (IS_ERR_OR_NULL(s3c_mdnie_base)) { + pr_err("%s: fail to ioremap\n", __func__); + return -ENOENT; + } + + return 0; +} + +void mdnie_setup(void) +{ + mdnie_hw_init(); + ielcd_hw_init(); +} + +MODULE_DESCRIPTION("EXYNOS mDNIe Device Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/video/samsung/s3cfb_mdnie_kona.h b/drivers/video/samsung/s3cfb_mdnie_kona.h new file mode 100644 index 0000000..4a91691 --- /dev/null +++ b/drivers/video/samsung/s3cfb_mdnie_kona.h @@ -0,0 +1,88 @@ + +/* linux/drivers/video/samsung/s3cfb_mdnie.h + * + * Header file for Samsung (MDNIE) driver + * + * Copyright (c) 2009 Samsung Electronics + * http://www.samsungsemi.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#ifndef __S3CFB_MDNIE_H__ +#define __S3CFB_MDNIE_H__ + +#define S3C_MDNIE_PHY_BASE 0x11CA0000 +#define S3C_MDNIE_MAP_SIZE 0x00001000 + +/* Register Address */ +#if defined(CONFIG_CPU_EXYNOS4210) +#define MDNIE_REG_BANK_SEL 0x0000 +#define MDNIE_REG_WIDTH 0x0022 +#define MDNIE_REG_HEIGHT 0x0023 +#define MDNIE_REG_MASK 0x0028 + +#define MDNIE_REG_PWM_CONTROL 0x00B4 +#define MDNIE_REG_POWER_LUT0 0x0076 +#define MDNIE_REG_POWER_LUT2 0x0077 +#define MDNIE_REG_POWER_LUT4 0x0078 +#define MDNIE_REG_POWER_LUT6 0x0079 +#define MDNIE_REG_POWER_LUT8 0x007A + +#elif defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) +#define MDNIE_REG_BANK_SEL 0x0000 +#define MDNIE_REG_WIDTH 0x0003 +#define MDNIE_REG_HEIGHT 0x0004 +#define MDNIE_REG_MASK 0x00FF + +#define S3C_MDNIE_rR1 0x0001 + +#define MDNIE_REG_PWM_CONTROL 0x00B6 +#define MDNIE_REG_POWER_LUT0 0x0079 +#define MDNIE_REG_POWER_LUT2 0x007A +#define MDNIE_REG_POWER_LUT4 0x007B +#define MDNIE_REG_POWER_LUT6 0x007C +#define MDNIE_REG_POWER_LUT8 0x007D +#endif + +#define MDNIE_REG_RED_R 0x00E1 /*SCR RrCr*/ +#define MDNIE_REG_RED_G 0x00E2 /*SCR RgCg*/ +#define MDNIE_REG_RED_B 0x00E3 /*SCR RbCb*/ +#define MDNIE_REG_BLUE_R 0x00E4 /*SCR GrMr*/ +#define MDNIE_REG_BLUE_G 0x00E5 /*SCR GgMg*/ +#define MDNIE_REG_BLUE_B 0x00E6 /*SCR GbMb*/ +#define MDNIE_REG_GREEN_R 0x00E7 /*SCR BrYr*/ +#define MDNIE_REG_GREEN_G 0x00E8 /*SCR BgYg*/ +#define MDNIE_REG_GREEN_B 0x00E9 /*SCR BbYb*/ +#define MDNIE_REG_BLACK_R 0x00EA /*SCR KrWr*/ +#define MDNIE_REG_BLACK_G 0x00EB /*SCR KgWg*/ +#define MDNIE_REG_BLACK_B 0x00EC /*SCR KbWb*/ + +/* Register Value */ +#if defined(CONFIG_CPU_EXYNOS4210) +#define MDNIE_PWM_BANK 0x0000 +#elif defined(CONFIG_CPU_EXYNOS4212) || defined(CONFIG_CPU_EXYNOS4412) +#define MDNIE_PWM_BANK 0x0001 /* CMC624's PWM CTL is in BANK1 */ +#endif + +#define S3C_MDNIE_INPUT_DATA_ENABLE (1 << 10) + +#define S3C_MDNIE_SIZE_MASK 0x7FF +#define S3C_MDNIE_HSIZE(n) (n & S3C_MDNIE_SIZE_MASK) +#define S3C_MDNIE_VSIZE(n) (n & S3C_MDNIE_SIZE_MASK) + + +#define TRUE 1 +#define FALSE 0 + +void mdnie_setup(void); +int mdnie_display_on(struct s3cfb_global *ctrl); +int mdnie_display_off(void); + +int mdnie_write(unsigned int addr, unsigned int val); +int mdnie_mask(void); +int mdnie_unmask(void); + +#endif diff --git a/drivers/video/samsung/s3cfb_nt71391.c b/drivers/video/samsung/s3cfb_nt71391.c new file mode 100644 index 0000000..921544a --- /dev/null +++ b/drivers/video/samsung/s3cfb_nt71391.c @@ -0,0 +1,415 @@ +/* linux/drivers/video/samsung/s3cfb_nt71391.c + * + * Copyright (c) 2012 Samsung Electronics Co., Ltd. + * http://www.samsung.com/ + * + * NT71391 : 8" WXGA Landscape LCD module driver + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/delay.h> +#include <linux/errno.h> +#include <linux/gpio.h> +#include <linux/kernel.h> +#include <linux/lcd.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/wait.h> +#include <plat/regs-dsim.h> +#include <mach/dsim.h> +#include <mach/mipi_ddi.h> +#ifdef CONFIG_HAS_EARLYSUSPEND +#include <linux/earlysuspend.h> +#endif + +#include "s3cfb.h" +#include "s5p-dsim.h" + +#define NT71391_CHANGE_MINI_LVDS_FREQ_MIPI 1 + +#define POWER_IS_ON(pwr) ((pwr) <= FB_BLANK_NORMAL) + +struct lcd_info { + struct device *dev; + unsigned int ldi_enable; + unsigned int power; + unsigned int connected; + struct mutex lock; + struct lcd_device *ld; + struct lcd_platform_data *lcd_pd; + struct dsim_global *dsim; +}; + +#ifdef NT71391_CHANGE_MINI_LVDS_FREQ_MIPI + +#define NT71391_TCON_REG_ADD 0xAC +#define NT71391_TCON_REG_CHECKSUM 0xFF +#define NT71931_N_16 0x18 +#define NT71931_N_17 0x19 +#define NT71931_N_18 0x1A +#define NT71931_N_19 0x1B +#define NT71931_N_20 0x1C +#define NT71931_N_21 0x1D +#define NT71931_N_22 0x1E +#define NT71931_N_23 0x1F +#define NT71931_N_24 0x10 +#define NT71931_N_25 0x11 + + +enum NT71391_COMMAND_TYPE { + NT71391_LOCK_CMD2 = 0x03, + NT71391_READ = 0x14, + NT71391_WRITE = 0x23, +}; + + +static const unsigned char NT71391_UNLOCK_PAGE0[] = { + 0xF3,0xA0 +}; + +static const unsigned char NT71391_UNLOCK_PAGE1[] = { + 0xF3,0xA1 +}; + +static const unsigned char NT71391_FREQ_SETTING[] = { + NT71391_TCON_REG_ADD,NT71931_N_16 +}; + +static const unsigned char TESTA[] = { + 0x2B,0xC0 +}; + +static int _nt71391_write(struct lcd_info *lcd, const unsigned char *seq, enum NT71391_COMMAND_TYPE cmd_type) +{ + const unsigned char *wbuf; + int ret = 0; + + if (!lcd->connected) + return 0; + + mutex_lock(&lcd->lock); + + wbuf = seq; + + switch (cmd_type) { + case NT71391_LOCK_CMD2: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_LOCK_CMD2,0x0,0x0); + break; + case NT71391_READ: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_READ,wbuf[0],0x0); + break; + case NT71391_WRITE: + ret = lcd->dsim->ops->cmd_write(lcd->dsim, NT71391_WRITE, wbuf[0], wbuf[1]); + break; + default: + dev_dbg(&lcd->ld->dev, "%s :: Invalid cmd type \n", __func__); + break; + } + + mutex_unlock(&lcd->lock); + + return ret; +} + +static int nt71391_write(struct lcd_info *lcd, const unsigned char *seq, enum NT71391_COMMAND_TYPE cmd_type) +{ + int ret = 0; + int retry_cnt = 1; + +retry: + ret = _nt71391_write(lcd, seq, cmd_type); + if (!ret) { + if (retry_cnt) { + dev_dbg(&lcd->ld->dev, "%s :: retry: %d\n", __func__, retry_cnt); + retry_cnt--; + goto retry; + } else + dev_dbg(&lcd->ld->dev, "%s :: 0x%02x\n", __func__, seq[0]); + } + + return ret; +} + +static int _nt71391_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf) +{ + int ret = 0; + + if (!lcd->connected) + return ret; + + mutex_lock(&lcd->lock); + + if (lcd->dsim->ops->cmd_read) + ret = lcd->dsim->ops->cmd_dcs_read(lcd->dsim, addr, count, buf); + + mutex_unlock(&lcd->lock); + + return ret; +} + +static int nt71391_read(struct lcd_info *lcd, const u8 addr, u16 count, u8 *buf, u8 retry_cnt) +{ + int ret = 0; + +read_retry: + ret = _nt71391_read(lcd, addr, count, buf); + if (!ret) { + if (retry_cnt) { + printk(KERN_WARNING "[WARN:LCD] %s : retry cnt : %d\n", __func__, retry_cnt); + retry_cnt--; + goto read_retry; + } else + printk(KERN_ERR "[ERROR:LCD] %s : 0x%02x read failed\n", __func__, addr); + } + + return ret; +} +#endif +static ssize_t lcdtype_show(struct device *dev, struct device_attribute *attr, char *buf) +{ + char temp[15]; + sprintf(temp, "BOE_BP080WX7\n"); + strcat(buf, temp); + return strlen(buf); +} + +static DEVICE_ATTR(lcd_type, 0664, + lcdtype_show, NULL); + +static ssize_t window_type_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + char temp[15]; + + sprintf(temp, "%x %x %x\n", 0x0, 0x0, 0x0); + + strcat(buf, temp); + return strlen(buf); +} + +static DEVICE_ATTR(window_type, 0444, + window_type_show, NULL); + +static int nt71391_power_on(struct lcd_info *lcd) +{ + +#ifdef NT71391_CHANGE_MINI_LVDS_FREQ_MIPI + int ret = 0; + struct lcd_platform_data *pd = NULL; + pd = lcd->lcd_pd; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + msleep(120); /* power on 50ms, i2c 70ms */ + nt71391_write(lcd, NT71391_UNLOCK_PAGE0, NT71391_WRITE); + nt71391_write(lcd, NT71391_FREQ_SETTING, NT71391_WRITE); + nt71391_write(lcd, NULL, NT71391_LOCK_CMD2); + + + lcd->dsim->ops->cmd_write(lcd->dsim, TURN_ON, 0, 0); +#else + int ret = 0; + struct lcd_platform_data *pd = NULL; + pd = lcd->lcd_pd; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + msleep(120); /* power on 50ms, i2c 70ms */ + + lcd->dsim->ops->cmd_write(lcd->dsim, TURN_ON, 0, 0); +#endif + + lcd->ldi_enable = 1; + + return ret; +} + +static int nt71391_power_off(struct lcd_info *lcd) +{ + int ret = 0; + + dev_info(&lcd->ld->dev, "%s\n", __func__); + + lcd->ldi_enable = 0; + + msleep(135); + + return ret; +} + +static int nt71391_power(struct lcd_info *lcd, int power) +{ + int ret = 0; + + if (POWER_IS_ON(power) && !POWER_IS_ON(lcd->power)) + ret = nt71391_power_on(lcd); + else if (!POWER_IS_ON(power) && POWER_IS_ON(lcd->power)) + ret = nt71391_power_off(lcd); + + if (!ret) + lcd->power = power; + + return ret; +} + +static int nt71391_set_power(struct lcd_device *ld, int power) +{ + struct lcd_info *lcd = lcd_get_data(ld); + + if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN && + power != FB_BLANK_NORMAL) { + dev_err(&lcd->ld->dev, "power value should be 0, 1 or 4.\n"); + return -EINVAL; + } + + return nt71391_power(lcd, power); +} + +static int nt71391_get_power(struct lcd_device *ld) +{ + struct lcd_info *lcd = lcd_get_data(ld); + + return lcd->power; +} + +static struct lcd_ops nt71391_lcd_ops = { + .set_power = nt71391_set_power, + .get_power = nt71391_get_power, +}; + +#ifdef CONFIG_HAS_EARLYSUSPEND +extern void (*lcd_early_suspend)(void); +extern void (*lcd_late_resume)(void); + +struct lcd_info *g_lcd; + +void nt71391_early_suspend(void) +{ + struct lcd_info *lcd = g_lcd; + int err = 0; + + set_dsim_lcd_enabled(0); + + dev_info(&lcd->ld->dev, "+%s\n", __func__); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); + + dev_info(&lcd->ld->dev, "-%s\n", __func__); + + return ; +} + +void nt71391_late_resume(void) +{ + struct lcd_info *lcd = g_lcd; + + dev_info(&lcd->ld->dev, "+%s\n", __func__); + + nt71391_power(lcd, FB_BLANK_UNBLANK); + + dev_info(&lcd->ld->dev, "-%s\n", __func__); + + set_dsim_lcd_enabled(1); + + return ; +} +#endif + + +static int __init nt71391_probe(struct device *dev) +{ + struct lcd_info *lcd; + int ret = 0; + + lcd = kzalloc(sizeof(struct lcd_info), GFP_KERNEL); + if (!lcd) { + pr_err("failed to allocate for lcd\n"); + ret = -ENOMEM; + goto err_alloc; + } + + g_lcd = lcd; + + lcd->ld = lcd_device_register("panel", dev, lcd, &nt71391_lcd_ops); + if (IS_ERR(lcd->ld)) { + pr_err("failed to register lcd device\n"); + ret = PTR_ERR(lcd->ld); + goto out_free_lcd; + } + + lcd->dev = dev; + lcd->connected = 1; + lcd->dsim = (struct dsim_global *)dev_get_drvdata(dev->parent); + lcd->power = FB_BLANK_UNBLANK; + + mutex_init(&lcd->lock); + + dev_set_drvdata(dev, lcd); + + dev_info(dev, "lcd panel driver has been probed.\n"); + +#ifdef CONFIG_HAS_EARLYSUSPEND + lcd_early_suspend = nt71391_early_suspend; + lcd_late_resume = nt71391_late_resume; +#endif + + ret = device_create_file(&lcd->ld->dev, &dev_attr_lcd_type); + if (ret < 0) + dev_err(&lcd->ld->dev, "failed to add sysfs entries\n"); + + ret = device_create_file(&lcd->ld->dev, &dev_attr_window_type); + if (ret < 0) + dev_err(&lcd->ld->dev, "failed to add window_type entries\n"); + + return 0; + +out_free_lcd: + kfree(lcd); +err_alloc: + return ret; +} + +static int __devexit nt71391_remove(struct device *dev) +{ + struct lcd_info *lcd = dev_get_drvdata(dev); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); + lcd_device_unregister(lcd->ld); + kfree(lcd); + + return 0; +} + +static void nt71391_shutdown(struct device *dev) +{ + struct lcd_info *lcd = dev_get_drvdata(dev); + + nt71391_power(lcd, FB_BLANK_POWERDOWN); +} + +static struct mipi_lcd_driver nt71391_mipi_driver = { + .name = "nt71391", + .probe = nt71391_probe, + .remove = __devexit_p(nt71391_remove), + .shutdown = nt71391_shutdown, +}; + +static int __init nt71391_init(void) +{ + return s5p_dsim_register_lcd_driver(&nt71391_mipi_driver); +} + +static void __exit nt71391_exit(void) +{ + return; +} + +module_init(nt71391_init); +module_exit(nt71391_exit); + +MODULE_AUTHOR("SAMSUNG"); +MODULE_DESCRIPTION("NT71391 LCD driver"); +MODULE_LICENSE("GPL"); |