From afcbdfe85cfaeae5cf8590ea09d944f6636ea569 Mon Sep 17 00:00:00 2001 From: Wang Jie Date: Sat, 12 Oct 2019 17:34:19 +0800 Subject: [PATCH] drivers: input: touchscreen: add gslx6801 driver. This driver is for the new rk3368 evb board. static global variable,solve compilation problems. There are two ways to speed up system startup: a.replace msleep() with usleep_range(). b.enable asynchronous probing. Modify delay time. - modify GSLX680_I2C_NAME: before: gslx680 driver and gslx6801 driver have the same name, causing the kernel to register gslx680 driver failed. - add power control: in gsl_ts_probe() enable power; in gsl_ts_remove disable power. - fix for none pinctrl - fix gslX680_ts_worker() error: buffer overflow 'key_x' 512 <= 512 Change-Id: I7d7ae9879397d1850e5cd1092fb2730f6d1fdf18 Signed-off-by: Wang Jie Signed-off-by: Jianqun Xu --- drivers/input/touchscreen/Kconfig | 5 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/gslx6801.c | 1680 +++++++++ drivers/input/touchscreen/gslx6801.h | 4955 ++++++++++++++++++++++++++ 4 files changed, 6641 insertions(+) create mode 100644 drivers/input/touchscreen/gslx6801.c create mode 100644 drivers/input/touchscreen/gslx6801.h diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index 215907ad72cf..4c211a7aea2d 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -399,6 +399,11 @@ config TOUCHSCREEN_GOODIX To compile this driver as a module, choose M here: the module will be called goodix. +config TOUCHSCREEN_GSLX6801 + tristate "gslx 6801" + help + gslX6801 touchpad driver for pad + config TOUCHSCREEN_GSLX680A tristate "gslx 680a" help diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 5daa3d4a4403..7702703ca23a 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -45,6 +45,7 @@ obj-$(CONFIG_TOUCHSCREEN_EGALAX_SERIAL) += egalax_ts_serial.o obj-$(CONFIG_TOUCHSCREEN_EXC3000) += exc3000.o obj-$(CONFIG_TOUCHSCREEN_FUJITSU) += fujitsu_ts.o obj-$(CONFIG_TOUCHSCREEN_GOODIX) += goodix.o +obj-$(CONFIG_TOUCHSCREEN_GSLX6801) += gslx6801.o gsl_point_id.o obj-$(CONFIG_TOUCHSCREEN_GSLX680A) += gslx680a.o gsl_point_id.o obj-$(CONFIG_TOUCHSCREEN_GSLX680_D708) += gslx680_d708/ gsl_point_id.o obj-$(CONFIG_TOUCHSCREEN_GSLX680_PAD) += gslx680_pad.o gsl_point_id.o diff --git a/drivers/input/touchscreen/gslx6801.c b/drivers/input/touchscreen/gslx6801.c new file mode 100644 index 000000000000..3c1e1655c0a8 --- /dev/null +++ b/drivers/input/touchscreen/gslx6801.c @@ -0,0 +1,1680 @@ +/* + * drivers/input/touchscreen/gslx6801.c + * + * Copyright (c) 2012 Shanghai Basewin + * Guan Yuwei + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "tp_suspend.h" +#include "gslx6801.h" +#include +#include + +#include + +#define GSL_DEBUG +#define REPORT_DATA_ANDROID_4_0 +#define HAVE_TOUCH_KEY +#ifdef FILTER_POINT +#define FILTER_MAX 9 +#endif + +#define GSLX680_I2C_NAME "gslX6801" +#define GSLX680_I2C_ADDR 0x40 +#define GSL_DATA_REG 0x80 +#define GSL_STATUS_REG 0xe0 +#define GSL_PAGE_REG 0xf0 +#define GSL_MONITOR +#define PRESS_MAX 255 +#define MAX_FINGERS 5 +#define MAX_CONTACTS 10 +#define DMA_TRANS_LEN 0x20 +#ifdef GSL_MONITOR +#define TPD_PROC_DEBUG +#ifdef TPD_PROC_DEBUG +#include +#include +#include +#define GSL_CONFIG_PROC_FILE "gsl_config" +#define CONFIG_LEN 31 +static char gsl_read[CONFIG_LEN]; +static u8 gsl_data_proc[8] = { 0 }; +static u8 gsl_proc_flag; +static struct i2c_client *i2c_client; +#endif + +#ifdef RK_GEAR_TOUCH +static int g_istouch; +#endif + +static struct workqueue_struct *gsl_monitor_workqueue; +static u8 int_1st[4] = { 0 }; +static u8 int_2nd[4] = { 0 }; +static char b0_counter; +static char bc_counter; +static char i2c_lock_flag; +#endif + +#define WRITE_I2C_SPEED (350 * 1000) +#define I2C_SPEED (200 * 1000) +#define CLOSE_TP_POWER 0 +#ifdef HAVE_CLICK_TIMER +static struct workqueue_struct *gsl_timer_workqueue; +bool send_key; +struct semaphore my_sem; +#endif + +#ifdef HAVE_TOUCH_KEY +static u16 key; +static int key_state_flag; +struct key_data { + u16 key; + u16 x_min; + u16 x_max; + u16 y_min; + u16 y_max; +}; + +static const u16 key_array[] = { + KEY_LEFT, + KEY_RIGHT, + KEY_UP, + KEY_DOWN, + KEY_ENTER, +}; + +#define MAX_KEY_NUM ARRAY_SIZE(key_array) +static int key_x[512]; +static int key_y[512]; +static int key_count; +static const struct key_data gsl_key_data[MAX_KEY_NUM] = { + {KEY_BACK, 550, 650, 1400, 1600}, + {KEY_HOMEPAGE, 350, 450, 1400, 1600}, + {KEY_MENU, 150, 250, 1400, 1600}, + {KEY_SEARCH, 2048, 2048, 2048, 2048}, +}; +#endif + +struct gsl_ts_data { + u8 x_index; + u8 y_index; + u8 z_index; + u8 id_index; + u8 touch_index; + u8 data_reg; + u8 status_reg; + u8 data_size; + u8 touch_bytes; + u8 update_data; + u8 touch_meta_data; + u8 finger_size; +}; + +static struct gsl_ts_data devices[] = { + { + .x_index = 6, + .y_index = 4, + .z_index = 5, + .id_index = 7, + .data_reg = GSL_DATA_REG, + .status_reg = GSL_STATUS_REG, + .update_data = 0x4, + .touch_bytes = 4, + .touch_meta_data = 4, + .finger_size = 70, + }, +}; + +struct gsl_ts { + struct i2c_client *client; + struct input_dev *input; + struct work_struct work; + struct workqueue_struct *wq; + struct gsl_ts_data *dd; + struct regulator *regulator; + int flag_irq_is_disable; + spinlock_t irq_lock; + u8 *touch_data; + u8 device_id; + + struct regulator *tp_regulator; + + int irq; + int rst; + struct delayed_work gsl_monitor_work; +#if defined(CONFIG_HAS_EARLYSUSPEND) + struct early_suspend early_suspend; +#endif + +#if defined(HAVE_CLICK_TIMER) + struct work_struct click_work; +#endif + + struct tp_device tp; + struct pinctrl *pinctrl; + struct pinctrl_state *pins_default; + struct pinctrl_state *pins_sleep; + struct pinctrl_state *pins_inactive; +}; + +static u32 id_sign[MAX_CONTACTS + 1] = { 0 }; +static u8 id_state_flag[MAX_CONTACTS + 1] = { 0 }; +static u8 id_state_old_flag[MAX_CONTACTS + 1] = { 0 }; +static u16 x_old[MAX_CONTACTS + 1] = { 0 }; +static u16 y_old[MAX_CONTACTS + 1] = { 0 }; +static u16 x_new; +static u16 y_new; + +static int gslx680_set_pinctrl_state(struct gsl_ts *ts, + struct pinctrl_state *state) +{ + int ret = 0; + + if (!IS_ERR(ts->pinctrl)) + return PTR_ERR(ts->pinctrl); + + if (!IS_ERR(state)) { + ret = pinctrl_select_state(ts->pinctrl, state); + if (ret) + pr_err("could not set pins\n"); + } + + return ret; +} + +static int gslX680_init(struct gsl_ts *ts) +{ + struct device_node *np = ts->client->dev.of_node; + int err = 0; + + ts->irq = of_get_named_gpio_flags(np, "touch-gpio", 0, NULL); + ts->rst = of_get_named_gpio_flags(np, "reset-gpio", 0, NULL); + + /* pinctrl */ + ts->pinctrl = devm_pinctrl_get(&ts->client->dev); + if (!IS_ERR(ts->pinctrl)) { + ts->pins_default = + pinctrl_lookup_state(ts->pinctrl, PINCTRL_STATE_DEFAULT); + ts->pins_sleep = + pinctrl_lookup_state(ts->pinctrl, PINCTRL_STATE_SLEEP); + ts->pins_inactive = + pinctrl_lookup_state(ts->pinctrl, "inactive"); + gslx680_set_pinctrl_state(ts, ts->pins_default); + } + + err = gpio_request(ts->rst, "tp reset"); + if (err) { + pr_err("gslx680 reset gpio request failed.\n"); + return -1; + } + + gpio_direction_output(ts->rst, 1); + gpio_set_value(ts->rst, 1); + + return 0; +} + +static int gslX680_shutdown_low(struct gsl_ts *ts) +{ + pr_info("gsl gslX680_shutdown_low\n"); + gpio_direction_output(ts->rst, 0); + gpio_set_value(ts->rst, 0); + + return 0; +} + +static int gslX680_shutdown_high(struct gsl_ts *ts) +{ + pr_info("gsl gslX680_shutdown_high\n"); + gpio_direction_output(ts->rst, 1); + gpio_set_value(ts->rst, 1); + + return 0; +} + +static inline u16 join_bytes(u8 a, u8 b) +{ + u16 ab = 0; + + ab = ab | a; + ab = ab << 8 | b; + + return ab; +} + +static u32 gsl_write_interface(struct i2c_client *client, + const u8 reg, u8 *buf, u32 num) +{ + struct i2c_msg xfer_msg[1]; + + buf[0] = reg; + + xfer_msg[0].addr = client->addr; + xfer_msg[0].len = num + 1; + xfer_msg[0].flags = client->flags & I2C_M_TEN; + xfer_msg[0].buf = buf; + + return i2c_transfer(client->adapter, xfer_msg, 1) == 1 ? 0 : -EFAULT; +} + +static int gsl_ts_write(struct i2c_client *client, + u8 addr, u8 *pdata, int datalen) +{ + int ret = 0; + u8 tmp_buf[128]; + unsigned int bytelen = 0; + + if (datalen > 125) { + dev_err(&client->dev, "%s big datalen = %d!\n", + __func__, datalen); + return -1; + } + + tmp_buf[0] = addr; + bytelen++; + + if (datalen != 0 && pdata != NULL) { + memcpy(&tmp_buf[bytelen], pdata, datalen); + bytelen += datalen; + } + + ret = i2c_master_send(client, tmp_buf, bytelen); + return ret; +} + +static int gsl_ts_read(struct i2c_client *client, u8 addr, + u8 *pdata, unsigned int datalen) +{ + int ret = 0; + + if (datalen > 126) { + dev_err(&client->dev, "%s too big datalen = %d!\n", + __func__, datalen); + return -1; + } + + ret = gsl_ts_write(client, addr, NULL, 0); + if (ret < 0) { + dev_err(&client->dev, "%s set data address fail!\n", __func__); + return ret; + } + + return i2c_master_recv(client, pdata, datalen); +} + +static void fw2buf(u8 *buf, const u32 *fw) +{ + u32 *u32_buf = (int *)buf; + *u32_buf = *fw; +} + +static void gsl_load_fw(struct i2c_client *client) +{ + u8 buf[DMA_TRANS_LEN * 4 + 1] = { 0 }; + u8 send_flag = 1; + u8 *cur = buf + 1; + u32 source_line = 0; + u32 source_len; + struct fw_data const *ptr_fw; + + ptr_fw = GSLX680_FW; + source_len = ARRAY_SIZE(GSLX680_FW); + + for (source_line = 0; source_line < source_len; source_line++) { + /* init page trans, set the page val */ + if (ptr_fw[source_line].offset == GSL_PAGE_REG) { + fw2buf(cur, &ptr_fw[source_line].val); + gsl_write_interface(client, GSL_PAGE_REG, buf, 4); + send_flag = 1; + } else { + if (1 == + send_flag % (DMA_TRANS_LEN < + 0x20 ? DMA_TRANS_LEN : 0x20)) + buf[0] = (u8)ptr_fw[source_line].offset; + + fw2buf(cur, &ptr_fw[source_line].val); + cur += 4; + + if (0 == + send_flag % (DMA_TRANS_LEN < + 0x20 ? DMA_TRANS_LEN : 0x20)) { + gsl_write_interface(client, buf[0], buf, + cur - buf - 1); + cur = buf + 1; + } + + send_flag++; + } + } +} + +static int test_i2c(struct i2c_client *client) +{ + u8 read_buf = 0; + u8 write_buf = 0x12; + int ret, rc = 1; + + ret = gsl_ts_read(client, 0xf0, &read_buf, sizeof(read_buf)); + if (ret < 0) + rc--; + else + dev_info(&client->dev, "gsl I read reg 0xf0 is %x\n", read_buf); + + usleep_range(2000, 3000); + ret = gsl_ts_write(client, 0xf0, &write_buf, sizeof(write_buf)); + if (ret >= 0) + dev_info(&client->dev, "gsl I write reg 0xf0 0x12\n"); + + usleep_range(2000, 3000); + ret = gsl_ts_read(client, 0xf0, &read_buf, sizeof(read_buf)); + if (ret < 0) + rc--; + else + dev_info(&client->dev, + "gsl I read reg 0xf0 is 0x%x\n", read_buf); + + return rc; +} + +static void startup_chip(struct i2c_client *client) +{ + u8 tmp = 0x00; + +#ifdef GSL_NOID_VERSION + gsl_DataInit(gsl_config_data_id); +#endif + gsl_ts_write(client, 0xe0, &tmp, 1); + mdelay(10); +} + +static void reset_chip(struct i2c_client *client) +{ + u8 tmp = 0x88; + u8 buf[4] = { 0x00 }; + + gsl_ts_write(client, 0xe0, &tmp, sizeof(tmp)); + mdelay(20); + tmp = 0x04; + gsl_ts_write(client, 0xe4, &tmp, sizeof(tmp)); + mdelay(10); + gsl_ts_write(client, 0xbc, buf, sizeof(buf)); + mdelay(10); +} + +static void clr_reg(struct i2c_client *client) +{ + u8 write_buf[4] = { 0 }; + + write_buf[0] = 0x88; + gsl_ts_write(client, 0xe0, &write_buf[0], 1); + mdelay(20); + write_buf[0] = 0x03; + gsl_ts_write(client, 0x80, &write_buf[0], 1); + mdelay(5); + write_buf[0] = 0x04; + gsl_ts_write(client, 0xe4, &write_buf[0], 1); + mdelay(5); + write_buf[0] = 0x00; + gsl_ts_write(client, 0xe0, &write_buf[0], 1); + mdelay(20); +} + +#ifdef PEN_ADJUST_FREQ +static int gsl_adjust_freq(struct i2c_client *client) +{ + static u32 cpu_start, cpu_end, ret, real_time; + u8 buf[4]; + struct timeval time_start, time_end; + + dev_info(&client->dev, "gsl pen test\n"); + buf[3] = 0x01; + buf[2] = 0xfe; + buf[1] = 0x02; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0xf0, 4, buf); + buf[3] = 0x00; + buf[2] = 0x00; + buf[1] = 0x00; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0x0c, 4, buf); + buf[3] = 0x01; + buf[2] = 0xfe; + buf[1] = 0x02; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0xf0, 4, buf); + buf[3] = 0xff; + buf[2] = 0xff; + buf[1] = 0xff; + buf[0] = 0xff; + i2c_smbus_write_i2c_block_data(client, 0x04, 4, buf); + buf[3] = 0x01; + buf[2] = 0xfe; + buf[1] = 0x02; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0xf0, 4, buf); + buf[3] = 0x00; + buf[2] = 0x00; + buf[1] = 0x00; + buf[0] = 0x09; + i2c_smbus_write_i2c_block_data(client, 0x08, 4, buf); + + mdelay(200); + buf[3] = 0x01; + buf[2] = 0xfe; + buf[1] = 0x02; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0xf0, 4, buf); + i2c_smbus_read_i2c_block_data(client, 0, 4, buf); + i2c_smbus_read_i2c_block_data(client, 0, 4, buf); + cpu_start = (buf[3] << 24) + (buf[2] << 16) + + (buf[1] << 8) + buf[0]; + do_gettimeofday(&time_start); + /* start count time */ + mdelay(1200); + buf[3] = 0x01; + buf[2] = 0xfe; + buf[1] = 0x02; + buf[0] = 0x00; + i2c_smbus_write_i2c_block_data(client, 0xf0, 4, buf); + i2c_smbus_read_i2c_block_data(client, 0, 4, buf); + i2c_smbus_read_i2c_block_data(client, 0, 4, buf); + cpu_end = (buf[3] << 24) + + (buf[2] << 16) + (buf[1] << 8) + buf[0]; + do_gettimeofday(&time_end); + + real_time = ((time_end.tv_sec - time_start.tv_sec) * 10000 + + (time_end.tv_usec - time_start.tv_usec) / 100); + if (real_time > 10000) { + ret = (u32)((cpu_start - cpu_end) * 100 / real_time) + * 0x1000 / 9245; + if (ret >= 0x1000 / 2 && ret <= 0x1000 * 2) { + buf[3] = 0x00; + buf[2] = 0x00; + buf[1] = 0x00; + buf[0] = 0x03; + i2c_smbus_write_i2c_block_data(client, + 0xf0, 4, buf); + buf[3] = (u8)((ret >> 24) & 0xff); + buf[2] = (u8)((ret >> 16) & 0xff); + buf[1] = (u8)((ret >> 8) & 0xff); + buf[0] = (u8)(ret & 0xff); + i2c_smbus_write_i2c_block_data(client, + 0x7c, 4, buf); + } else { + return -1; + } + } + return 0; +} +#endif + +static void init_chip(struct i2c_client *client, struct gsl_ts *ts) +{ + int rc; +#ifdef PEN_ADJUST_FREQ + int rc1; +#endif + dev_info(&client->dev, "gsl init_chip\n"); + + gslX680_shutdown_low(ts); + mdelay(20); + gslX680_shutdown_high(ts); + mdelay(20); + rc = test_i2c(client); + if (rc < 0) { + dev_err(&client->dev, "gslX680 test_i2c error\n"); + return; + } + clr_reg(client); + reset_chip(client); + gsl_load_fw(client); + startup_chip(client); + +#ifdef PEN_ADJUST_FREQ + rc1 = gsl_adjust_freq(client); + if (rc1 < 0) { + dev_info(&client->dev, "SL_Adjust_Freq error\n"); + gsl_adjust_freq(client); + } + +#endif + reset_chip(client); + startup_chip(client); +} + +static void check_mem_data(struct i2c_client *client, struct gsl_ts *ts) +{ + u8 read_buf[4] = { 0 }; + + mdelay(30); + gsl_ts_read(client, 0xb0, read_buf, sizeof(read_buf)); + dev_info(&client->dev, "check mem read 0xb0 = %x %x %x %x\n", + read_buf[3], read_buf[2], read_buf[1], read_buf[0]); + if (read_buf[3] != 0x5a || read_buf[2] != 0x5a || + read_buf[1] != 0x5a || read_buf[0] != 0x5a) { + init_chip(client, ts); + } +} + +#ifdef TPD_PROC_DEBUG +static int char_to_int(char ch) +{ + if (ch >= '0' && ch <= '9') + return (ch - '0'); + else + return (ch - 'a' + 10); +} + +static int gsl_config_read_proc(struct seq_file *m, void *v) +{ + char temp_data[5] = { 0 }; + unsigned int tmp = 0; + + if ('v' == gsl_read[0] && 's' == gsl_read[1]) { +#ifdef GSL_NOID_VERSION + tmp = gsl_version_id(); +#else + tmp = 0x20121215; +#endif + seq_printf(m, "version:%x\n", tmp); + } else if ('r' == gsl_read[0] && 'e' == gsl_read[1]) { + if ('i' == gsl_read[3]) { +#ifdef GSL_NOID_VERSION + tmp = (gsl_data_proc[5] << 8) | gsl_data_proc[4]; + seq_printf(m, "gsl_config_data_id[%d] = ", tmp); + if (tmp >= 0 && tmp < 512) + seq_printf(m, "%d\n", gsl_config_data_id[tmp]); +#endif + } else { + i2c_smbus_write_i2c_block_data(i2c_client, 0xf0, 4, + &gsl_data_proc[4]); + if (gsl_data_proc[0] < 0x80) + i2c_smbus_read_i2c_block_data(i2c_client, + gsl_data_proc[0], + 4, temp_data); + i2c_smbus_read_i2c_block_data(i2c_client, + gsl_data_proc[0], + 4, temp_data); + + seq_printf(m, "offset : {0x%02x,0x", gsl_data_proc[0]); + seq_printf(m, "%02x", temp_data[3]); + seq_printf(m, "%02x", temp_data[2]); + seq_printf(m, "%02x", temp_data[1]); + seq_printf(m, "%02x};\n", temp_data[0]); + } + } + + return 0; +} + +static ssize_t gsl_config_write_proc(struct file *file, const char *buffer, + size_t count, loff_t *data) +{ + u8 buf[8] = { 0 }; + char temp_buf[CONFIG_LEN]; + char *path_buf; + int tmp = 0; + int tmp1 = 0; + + if (count > 512) + return -EFAULT; + + path_buf = kzalloc(count, GFP_KERNEL); + if (!path_buf) { + pr_err("alloc path_buf memory error\n"); + return -ENOMEM; + } + + if (copy_from_user(path_buf, buffer, count)) { + pr_err("copy from user fail\n"); + goto exit_write_proc_out; + } + memcpy(temp_buf, path_buf, (count < CONFIG_LEN ? count : CONFIG_LEN)); + pr_debug("[tp-gsl][%s][%s]\n", __func__, temp_buf); + + buf[3] = char_to_int(temp_buf[14]) << 4 | char_to_int(temp_buf[15]); + buf[2] = char_to_int(temp_buf[16]) << 4 | char_to_int(temp_buf[17]); + buf[1] = char_to_int(temp_buf[18]) << 4 | char_to_int(temp_buf[19]); + buf[0] = char_to_int(temp_buf[20]) << 4 | char_to_int(temp_buf[21]); + + buf[7] = char_to_int(temp_buf[5]) << 4 | char_to_int(temp_buf[6]); + buf[6] = char_to_int(temp_buf[7]) << 4 | char_to_int(temp_buf[8]); + buf[5] = char_to_int(temp_buf[9]) << 4 | char_to_int(temp_buf[10]); + buf[4] = char_to_int(temp_buf[11]) << 4 | char_to_int(temp_buf[12]); + if ('v' == temp_buf[0] && 's' == temp_buf[1]) { + memcpy(gsl_read, temp_buf, 4); + pr_info("gsl version\n"); + } else if ('s' == temp_buf[0] && 't' == temp_buf[1]) { + gsl_proc_flag = 1; + reset_chip(i2c_client); + } else if ('e' == temp_buf[0] && 'n' == temp_buf[1]) { + mdelay(20); + reset_chip(i2c_client); + startup_chip(i2c_client); + gsl_proc_flag = 0; + } else if ('r' == temp_buf[0] && 'e' == temp_buf[1]) { + memcpy(gsl_read, temp_buf, 4); + memcpy(gsl_data_proc, buf, 8); + } else if ('w' == temp_buf[0] && 'r' == temp_buf[1]) { + i2c_smbus_write_i2c_block_data(i2c_client, buf[4], 4, buf); + } +#ifdef GSL_NOID_VERSION + else if ('i' == temp_buf[0] && 'd' == temp_buf[1]) { + tmp1 = (buf[7] << 24) | (buf[6] << 16) | (buf[5] << 8) | buf[4]; + tmp = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]; + + if (tmp1 >= 0 && tmp1 < 512) + gsl_config_data_id[tmp1] = tmp; + } +#endif + +exit_write_proc_out: + kfree(path_buf); + return count; +} + +static int gsl_server_list_open(struct inode *inode, struct file *file) +{ + return single_open(file, gsl_config_read_proc, NULL); +} + +static const struct file_operations gsl_seq_fops = { + .open = gsl_server_list_open, + .read = seq_read, + .release = single_release, + .write = gsl_config_write_proc, + .owner = THIS_MODULE, +}; + +#endif + +#ifdef FILTER_POINT +static void filter_point(u16 x, u16 y, u8 id) +{ + u16 x_err = 0; + u16 y_err = 0; + u16 filter_step_x = 0, filter_step_y = 0; + + id_sign[id] = id_sign[id] + 1; + if (id_sign[id] == 1) { + x_old[id] = x; + y_old[id] = y; + } + + x_err = x > x_old[id] ? (x - x_old[id]) : (x_old[id] - x); + y_err = y > y_old[id] ? (y - y_old[id]) : (y_old[id] - y); + + if ((x_err > FILTER_MAX && y_err > FILTER_MAX / 3) || + (x_err > FILTER_MAX / 3 && y_err > FILTER_MAX)) { + filter_step_x = x_err; + filter_step_y = y_err; + } else { + if (x_err > FILTER_MAX) + filter_step_x = x_err; + if (y_err > FILTER_MAX) + filter_step_y = y_err; + } + + if (x_err <= 2 * FILTER_MAX && y_err <= 2 * FILTER_MAX) { + filter_step_x >>= 2; + filter_step_y >>= 2; + } else if (x_err <= 3 * FILTER_MAX && y_err <= 3 * FILTER_MAX) { + filter_step_x >>= 1; + filter_step_y >>= 1; + } else if (x_err <= 4 * FILTER_MAX && y_err <= 4 * FILTER_MAX) { + filter_step_x = filter_step_x * 3 / 4; + filter_step_y = filter_step_y * 3 / 4; + } + + x_new = + x > + x_old[id] ? (x_old[id] + filter_step_x) : (x_old[id] - + filter_step_x); + y_new = + y > + y_old[id] ? (y_old[id] + filter_step_y) : (y_old[id] - + filter_step_y); + + x_old[id] = x_new; + y_old[id] = y_new; +} +#else +static void record_point(u16 x, u16 y, u8 id) +{ + u16 x_err = 0; + u16 y_err = 0; + + id_sign[id] = id_sign[id] + 1; + + if (id_sign[id] == 1) { + x_old[id] = x; + y_old[id] = y; + } + + x = (x_old[id] + x) / 2; + y = (y_old[id] + y) / 2; + + if (x > x_old[id]) + x_err = x - x_old[id]; + else + x_err = x_old[id] - x; + + if (y > y_old[id]) + y_err = y - y_old[id]; + else + y_err = y_old[id] - y; + + if ((x_err > 3 && y_err > 1) || (x_err > 1 && y_err > 3)) { + x_new = x; + x_old[id] = x; + y_new = y; + y_old[id] = y; + } else { + if (x_err > 3) { + x_new = x; + x_old[id] = x; + } else { + x_new = x_old[id]; + } + + if (y_err > 3) { + y_new = y; + y_old[id] = y; + } else { + y_new = y_old[id]; + } + } + + if (id_sign[id] == 1) { + x_new = x_old[id]; + y_new = y_old[id]; + } +} +#endif + +#ifdef SLEEP_CLEAR_POINT +#ifdef HAVE_TOUCH_KEY +static void report_key(struct gsl_ts *ts, u16 x, u16 y) +{ + u16 i = 0; + + for (i = 0; i < MAX_KEY_NUM; i++) { + if ((gsl_key_data[i].x_min < x) && + (x < gsl_key_data[i].x_max) && + (gsl_key_data[i].y_min < y) && + (y < gsl_key_data[i].y_max)) { + key = gsl_key_data[i].key; + input_report_key(ts->input, key, 1); + input_sync(ts->input); + key_state_flag = 1; + break; + } + } +} +#endif +#endif + +static void report_data(struct gsl_ts *ts, u16 x, u16 y, u8 pressure, u8 id) +{ +#ifdef RK_GEAR_TOUCH + int delt_x; + int delt_y; + static int old_x; + static int old_y; +#endif + +#ifdef RK_GEAR_TOUCH + if (g_istouch == 0) { + g_istouch = 1; + input_event(ts->input, EV_MSC, MSC_SCAN, 0x90001); + input_report_key(ts->input, 0x110, 1); + input_sync(ts->input); + } + delt_x = (int)x - old_x; + delt_y = (int)y - old_y; + delt_x /= 10; + delt_y /= 10; + input_report_rel(ts->input, REL_Y, -delt_x); + input_report_rel(ts->input, REL_X, -delt_y); + input_sync(ts->input); + old_x = x; + old_y = y; + return; +#endif + +#ifdef REPORT_DATA_ANDROID_4_0 + y = 1920 - y; + swap(x, y); + + input_mt_slot(ts->input, id); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, id); + input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, pressure); + input_report_abs(ts->input, ABS_MT_POSITION_X, x); + input_report_abs(ts->input, ABS_MT_POSITION_Y, y); + input_report_abs(ts->input, ABS_MT_WIDTH_MAJOR, 1); +#else + input_report_abs(ts->input, ABS_MT_TRACKING_ID, id); + input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, pressure); + input_report_abs(ts->input, ABS_MT_POSITION_X, x); + input_report_abs(ts->input, ABS_MT_POSITION_Y, y); + input_report_abs(ts->input, ABS_MT_WIDTH_MAJOR, 1); + input_mt_sync(ts->input); +#endif +} + +static void glsx680_ts_irq_disable(struct gsl_ts *ts) +{ + unsigned long irqflags; + + spin_lock_irqsave(&ts->irq_lock, irqflags); + if (!ts->flag_irq_is_disable) { + disable_irq_nosync(ts->client->irq); + ts->flag_irq_is_disable = 1; + } + spin_unlock_irqrestore(&ts->irq_lock, irqflags); +} + +static void glsx680_ts_irq_enable(struct gsl_ts *ts) +{ + unsigned long irqflags = 0; + + spin_lock_irqsave(&ts->irq_lock, irqflags); + if (ts->flag_irq_is_disable) { + enable_irq(ts->client->irq); + ts->flag_irq_is_disable = 0; + } + spin_unlock_irqrestore(&ts->irq_lock, irqflags); +} + +static void gslX680_ts_worker(struct work_struct *work) +{ + int rc, i; + u8 id, touches; + u16 x, y; + +#ifdef GSL_NOID_VERSION + u32 tmp1; + u8 buf[4] = { 0 }; + struct gsl_touch_info cinfo; +#endif + + struct gsl_ts *ts = container_of(work, struct gsl_ts, work); + +#ifdef TPD_PROC_DEBUG + if (gsl_proc_flag == 1) + goto schedule; +#endif + +#ifdef GSL_MONITOR + if (i2c_lock_flag != 0) + goto i2c_lock_schedule; + else + i2c_lock_flag = 1; +#endif + + rc = gsl_ts_read(ts->client, 0x80, ts->touch_data, ts->dd->data_size); + if (rc < 0) { + dev_err(&ts->client->dev, "read failed\n"); + goto schedule; + } + + touches = ts->touch_data[ts->dd->touch_index]; +#ifdef GSL_NOID_VERSION + + cinfo.finger_num = touches; + for + (i = 0; i < (touches < MAX_CONTACTS ? touches : MAX_CONTACTS); i++) { + cinfo.x[i] = + join_bytes((ts-> + touch_data[ts->dd->x_index + 4 * i + 1] & 0xf), + ts->touch_data[ts->dd->x_index + 4 * i]); + cinfo.y[i] = + join_bytes(ts->touch_data[ts->dd->y_index + 4 * i + 1], + ts->touch_data[ts->dd->y_index + 4 * i]); + cinfo.id[i] = + ((ts->touch_data[ts->dd->x_index + 4 * i + 1] & 0xf0) >> 4); + } + + cinfo.finger_num = (ts->touch_data[3] << 24) | (ts->touch_data[2] << 16) + | (ts->touch_data[1] << 8) | (ts->touch_data[0]); + gsl_alg_id_main(&cinfo); + tmp1 = gsl_mask_tiaoping(); + if (tmp1 > 0 && tmp1 < 0xffffffff) { + buf[0] = 0xa; + buf[1] = 0; + buf[2] = 0; + buf[3] = 0; + gsl_ts_write(ts->client, 0xf0, buf, 4); + buf[0] = (u8)(tmp1 & 0xff); + buf[1] = (u8)((tmp1 >> 8) & 0xff); + buf[2] = (u8)((tmp1 >> 16) & 0xff); + buf[3] = (u8)((tmp1 >> 24) & 0xff); + gsl_ts_write(ts->client, 0x8, buf, 4); + } + touches = cinfo.finger_num; +#endif + + for (i = 1; i <= MAX_CONTACTS; i++) { + if (touches == 0) + id_sign[i] = 0; + id_state_flag[i] = 0; + } + for (i = 0; i < (touches > MAX_FINGERS ? MAX_FINGERS : touches); i++) { +#ifdef GSL_NOID_VERSION + id = cinfo.id[i]; + x = cinfo.x[i]; + y = cinfo.y[i]; +#else + x = join_bytes((ts-> + touch_data[ts->dd->x_index + 4 * i + 1] & 0xf), + ts->touch_data[ts->dd->x_index + 4 * i]); + y = join_bytes(ts->touch_data[ts->dd->y_index + 4 * i + 1], + ts->touch_data[ts->dd->y_index + 4 * i]); + id = ts->touch_data[ts->dd->id_index + 4 * i] >> 4; +#endif + + if (id >= i && id <= MAX_CONTACTS) { +#ifdef FILTER_POINT + filter_point(x, y, id); +#else + record_point(x, y, id); +#endif + report_data(ts, x, y, 10, id); + if (key_count < 512) { + key_x[key_count] = x_new; + key_y[key_count] = y_new; + key_count++; + } + id_state_flag[id] = 1; + } + } + for (i = 1; i <= MAX_CONTACTS; i++) { + if ((touches == 0) || ((id_state_old_flag[i] != 0) && + (id_state_flag[i] == 0))) { +#ifdef RK_GEAR_TOUCH + if (g_istouch == 1) { + g_istouch = 0; + input_event(ts->input, EV_MSC, + MSC_SCAN, 0x90001); + input_report_key(ts->input, 0x110, 0); + input_sync(ts->input); + } + g_istouch = 0; +#endif + +#ifdef REPORT_DATA_ANDROID_4_0 + input_mt_slot(ts->input, i); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1); + input_mt_report_slot_state(ts->input, + MT_TOOL_FINGER, false); +#endif + id_sign[i] = 0; + } + + id_state_old_flag[i] = id_state_flag[i]; + } + + if (touches == 0) { +#ifndef REPORT_DATA_ANDROID_4_0 + input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, 0); + input_report_abs(ts->input, ABS_MT_WIDTH_MAJOR, 0); + input_mt_sync(ts->input); + + int temp_x = 0; + int temp_y = 0; + + temp_x = + (((key_x[key_count - 1] - key_x[0]) > + 0) ? (key_x[key_count - 1] - key_x[0]) + : (key_x[0] - key_x[key_count - 1])); + temp_y = + (((key_y[key_count - 1] - key_y[0]) > + 0) ? (key_y[key_count - 1] - key_y[0]) + : (key_y[0] - key_y[key_count - 1])); + if (key_count <= 512) { + if (temp_x > temp_y) { + if ((key_x[key_count - 1] - key_x[0]) > 100) { + pr_debug("send up key\n"); + input_report_key(ts->input, + key_array[2], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[2], 0); + input_sync(ts->input); + } else if ((key_x[0] - key_x[key_count - 1]) > + 100) { + pr_debug("send down key\n"); + input_report_key(ts->input, + key_array[3], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[3], 0); + input_sync(ts->input); + } + } else if (temp_x <= temp_y) { + if ((key_y[key_count - 1] - key_y[0]) > 100) { + pr_debug("send left key\n"); + input_report_key(ts->input, + key_array[0], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[0], 0); + input_sync(ts->input); + } else if ((key_y[0] - key_y[key_count - 1]) > + 100) { + pr_debug("send right key\n"); + input_report_key(ts->input, + key_array[1], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[1], 0); + input_sync(ts->input); + } + } + + if ((key_x[key_count - 1] - key_x[0] < 50) && + (key_x[key_count - 1] - key_x[0] >= -50) && + (key_y[key_count - 1] - key_y[0] < 50) && + (key_y[key_count - 1] - key_y[0] >= -50) && + (key_x[0] != 0) && (key_y[0] != 0)) { + queue_work(gsl_timer_workqueue, + &ts->click_work); + pr_debug("send enter2 key by yuandan\n"); + if (send_key) { + pr_debug("send enter key\n"); + input_report_key(ts->input, + key_array[4], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[4], 0); + input_sync(ts->input); + } else { + down(&my_sem); + send_key = true; + up(&my_sem); + } + } + } else if (key_count > 512) { + if (temp_x > temp_y) { + if ((key_x[511] - key_x[0]) > 100) { + pr_debug("send up key\n"); + input_report_key(ts->input, + key_array[2], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[2], 0); + input_sync(ts->input); + } else if ((key_x[0] - key_x[511]) > 100) { + pr_debug("send down key\n"); + input_report_key(ts->input, + key_array[3], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[3], 0); + input_sync(ts->input); + } + } else if (temp_x <= temp_y) { + if ((key_y[511] - key_y[0]) > 100) { + pr_debug("send left key\n"); + input_report_key(ts->input, + key_array[0], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[0], 0); + input_sync(ts->input); + } else if ((key_y[0] - key_y[511]) > 100) { + pr_debug("send right key\n"); + input_report_key(ts->input, + key_array[1], 1); + input_sync(ts->input); + input_report_key(ts->input, + key_array[1], 0); + input_sync(ts->input); + } + } + } + memset(key_y, 0, sizeof(int) * 512); + memset(key_x, 0, sizeof(int) * 512); + key_count = 0; +#endif + +#ifdef HAVE_TOUCH_KEY + if (key_state_flag) { + input_report_key(ts->input, key, 0); + input_sync(ts->input); + key_state_flag = 0; + } +#endif + } + + input_sync(ts->input); + +schedule: +#ifdef GSL_MONITOR + i2c_lock_flag = 0; +i2c_lock_schedule: +#endif + glsx680_ts_irq_enable(ts); +} + +#ifdef HAVE_CLICK_TIMER + +static void click_timer_worker(struct work_struct *work) +{ + while (true) { + mdelay(500); + send_key = false; + } +} + +#endif + +#ifdef GSL_MONITOR +static void gsl_monitor_worker(struct work_struct *work) +{ + u8 read_buf[4] = { 0 }; + char init_chip_flag = 0; + + struct gsl_ts *ts = + container_of(work, struct gsl_ts, gsl_monitor_work.work); + if (i2c_lock_flag != 0) + i2c_lock_flag = 1; + else + i2c_lock_flag = 1; + + gsl_ts_read(ts->client, 0xb0, read_buf, 4); + if (read_buf[3] != 0x5a || read_buf[2] != 0x5a || + read_buf[1] != 0x5a || read_buf[0] != 0x5a) + b0_counter++; + else + b0_counter = 0; + + if (b0_counter > 1) { + init_chip_flag = 1; + b0_counter = 0; + } + + gsl_ts_read(ts->client, 0xb4, read_buf, 4); + int_2nd[3] = int_1st[3]; + int_2nd[2] = int_1st[2]; + int_2nd[1] = int_1st[1]; + int_2nd[0] = int_1st[0]; + int_1st[3] = read_buf[3]; + int_1st[2] = read_buf[2]; + int_1st[1] = read_buf[1]; + int_1st[0] = read_buf[0]; + + if (int_1st[3] == int_2nd[3] && int_1st[2] == int_2nd[2] && + int_1st[1] == int_2nd[1] && int_1st[0] == int_2nd[0]) { + pr_info("int_1st: %x %x %x %x , int_2nd: %x %x %x %x\n", + int_1st[3], int_1st[2], int_1st[1], int_1st[0], + int_2nd[3], int_2nd[2], int_2nd[1], int_2nd[0]); + init_chip_flag = 1; + } + + gsl_ts_read(ts->client, 0xbc, read_buf, 4); + if (read_buf[3] != 0 || read_buf[2] != 0 || + read_buf[1] != 0 || read_buf[0] != 0) + bc_counter++; + else + bc_counter = 0; + if (bc_counter > 1) { + pr_info("======read 0xbc: %x %x %x %x======\n", + read_buf[3], read_buf[2], read_buf[1], read_buf[0]); + init_chip_flag = 1; + bc_counter = 0; + } + + if (init_chip_flag) + init_chip(ts->client, ts); + + i2c_lock_flag = 0; +} +#endif + +static irqreturn_t gsl_ts_irq(int irq, void *dev_id) +{ + struct gsl_ts *ts = (struct gsl_ts *)dev_id; + + glsx680_ts_irq_disable(ts); + + if (!work_pending(&ts->work)) + queue_work(ts->wq, &ts->work); + + return IRQ_HANDLED; +} + +static int gslX680_ts_init(struct i2c_client *client, struct gsl_ts *ts) +{ + struct input_dev *input_device; + int rc = 0; + int i = 0; + + pr_info("[GSLX680] Enter %s\n", __func__); + + ts->dd = &devices[ts->device_id]; + + if (ts->device_id == 0) { + ts->dd->data_size = + MAX_FINGERS * ts->dd->touch_bytes + ts->dd->touch_meta_data; + ts->dd->touch_index = 0; + } + + ts->touch_data = + devm_kzalloc(&client->dev, ts->dd->data_size, GFP_KERNEL); + if (!ts->touch_data) { + pr_err("%s: Unable to allocate memory\n", __func__); + return -ENOMEM; + } + + input_device = devm_input_allocate_device(&ts->client->dev); + if (!input_device) { + rc = -ENOMEM; + goto init_err_ret; + } + + ts->input = input_device; + input_device->name = GSLX680_I2C_NAME; + input_device->id.bustype = BUS_I2C; + input_device->dev.parent = &client->dev; + input_set_drvdata(input_device, ts); + +#ifdef REPORT_DATA_ANDROID_4_0 + __set_bit(EV_ABS, input_device->evbit); + __set_bit(EV_KEY, input_device->evbit); + __set_bit(EV_REP, input_device->evbit); + __set_bit(EV_SYN, input_device->evbit); + __set_bit(INPUT_PROP_DIRECT, input_device->propbit); + __set_bit(MT_TOOL_FINGER, input_device->keybit); + input_mt_init_slots(input_device, (MAX_CONTACTS + 1), 0); +#else + input_set_abs_params(input_device, ABS_MT_TRACKING_ID, 0, + (MAX_CONTACTS + 1), 0, 0); + set_bit(EV_ABS, input_device->evbit); + set_bit(EV_KEY, input_device->evbit); + __set_bit(INPUT_PROP_DIRECT, input_device->propbit); + input_device->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); +#endif + +#ifdef HAVE_TOUCH_KEY + input_device->evbit[0] = BIT_MASK(EV_KEY); + for (i = 0; i < MAX_KEY_NUM; i++) + set_bit(key_array[i], input_device->keybit); +#endif + +#ifdef RK_GEAR_TOUCH + set_bit(EV_REL, input_device->evbit); + input_set_capability(input_device, EV_REL, REL_X); + input_set_capability(input_device, EV_REL, REL_Y); + input_set_capability(input_device, EV_MSC, MSC_SCAN); + input_set_capability(input_device, EV_KEY, 0x110); +#endif + + set_bit(ABS_MT_POSITION_X, input_device->absbit); + set_bit(ABS_MT_POSITION_Y, input_device->absbit); + set_bit(ABS_MT_TOUCH_MAJOR, input_device->absbit); + set_bit(ABS_MT_WIDTH_MAJOR, input_device->absbit); + + input_set_abs_params(input_device, ABS_MT_POSITION_X, 0, SCREEN_MAX_X, + 0, 0); + input_set_abs_params(input_device, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, + 0, 0); + input_set_abs_params(input_device, ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, + 0); + input_set_abs_params(input_device, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0); + + /* ts->irq = client->irq; */ + + ts->wq = create_singlethread_workqueue("kworkqueue_ts"); + if (!ts->wq) { + dev_err(&client->dev, "gsl Could not create workqueue\n"); + goto init_err_ret; + } + flush_workqueue(ts->wq); + + INIT_WORK(&ts->work, gslX680_ts_worker); + + rc = input_register_device(input_device); + if (rc) + goto error_unreg_device; + + return 0; + +error_unreg_device: + destroy_workqueue(ts->wq); +init_err_ret: + return rc; +} + +static int gsl_ts_early_suspend(struct tp_device *tp_d) +{ + struct gsl_ts *ts = container_of(tp_d, struct gsl_ts, tp); +#ifdef GSL_MONITOR + pr_info("gsl_ts_suspend () : cancel gsl_monitor_work\n"); + cancel_delayed_work_sync(&ts->gsl_monitor_work); + int_1st[0] = 0; + int_1st[1] = 0; + int_1st[2] = 0; + int_1st[3] = 0; +#endif + + glsx680_ts_irq_disable(ts); + cancel_work_sync(&ts->work); + +#ifdef SLEEP_CLEAR_POINT + usleep_range(5000, 10000); +#ifdef REPORT_DATA_ANDROID_4_0 + for (i = 1; i <= MAX_CONTACTS; i++) { + input_mt_slot(ts->input, i); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1); + input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false); + } +#else + input_mt_sync(ts->input); +#endif + input_sync(ts->input); + usleep_range(5000, 10000); + report_data(ts, 1, 1, 10, 1); + input_sync(ts->input); +#endif + gslX680_shutdown_low(ts); + return 0; +} + +static int gsl_ts_late_resume(struct tp_device *tp_d) +{ + struct gsl_ts *ts = container_of(tp_d, struct gsl_ts, tp); + + pr_debug("I'am in gsl_ts_resume() start\n"); + gslX680_shutdown_high(ts); + msleep(20); + reset_chip(ts->client); + startup_chip(ts->client); + check_mem_data(ts->client, ts); + +#ifdef SLEEP_CLEAR_POINT +#ifdef REPORT_DATA_ANDROID_4_0 + for (i = 1; i <= MAX_CONTACTS; i++) { + input_mt_slot(ts->input, i); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1); + input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false); + } +#else + input_mt_sync(ts->input); +#endif + input_sync(ts->input); +#endif +#ifdef GSL_MONITOR + pr_info("gsl_ts_resume () : queue gsl_monitor_work\n"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 300); +#endif + glsx680_ts_irq_enable(ts); + + return 0; +} + +#ifdef CONFIG_HAS_EARLYSUSPEND + +static void gsl_ts_early_suspend(struct early_suspend *h) +{ + struct gsl_ts *ts = container_of(h, struct gsl_ts, early_suspend); +#ifdef GSL_MONITOR + pr_info("gsl_ts_suspend () : cancel gsl_monitor_work\n"); + cancel_delayed_work_sync(&ts->gsl_monitor_work); +#endif + + glsx680_ts_irq_disable(ts); + cancel_work_sync(&ts->work); + +#ifdef SLEEP_CLEAR_POINT + usleep_range(5000, 10000); +#ifdef REPORT_DATA_ANDROID_4_0 + for (i = 1; i <= MAX_CONTACTS; i++) { + input_mt_slot(ts->input, i); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1); + input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false); + } +#else + input_mt_sync(ts->input); +#endif + input_sync(ts->input); + usleep_range(5000, 10000); + report_data(ts, 1, 1, 10, 1); + input_sync(ts->input); +#endif + gslX680_shutdown_low(ts); + msleep(20); + return 0; +} + +static void gsl_ts_late_resume(struct early_suspend *h) +{ + struct gsl_ts *ts = container_of(h, struct gsl_ts, early_suspend); + int i; + + pr_debug("I'am in gsl_ts_resume() start\n"); + + gslX680_shutdown_high(ts); + msleep(20); + reset_chip(ts->client); + startup_chip(ts->client); + check_mem_data(ts->client, ts); + +#ifdef SLEEP_CLEAR_POINT +#ifdef REPORT_DATA_ANDROID_4_0 + for (i = 1; i <= MAX_CONTACTS; i++) { + input_mt_slot(ts->input, i); + input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1); + input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false); + } +#else + input_mt_sync(ts->input); +#endif + input_sync(ts->input); +#endif +#ifdef GSL_MONITOR + pr_info("gsl_ts_resume () : queue gsl_monitor_work\n"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 300); +#endif + glsx680_ts_irq_enable(ts); +} +#endif + +static void gsl_ts_power_on(struct gsl_ts *ts, bool enable) +{ + int ret = 0; + + if (enable) { + ret = regulator_enable(ts->regulator); + if (ret) + dev_err(&ts->client->dev, + "%s failed to enable touch regulator\n", + __func__); + } else { + ret = regulator_disable(ts->regulator); + if (ret) + dev_err(&ts->client->dev, + "%s failed to disable touch regulator", + __func__); + } +} + +static int gsl_ts_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct gsl_ts *ts; + int rc; + + pr_info("GSLX680 Enter %s\n", __func__); + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { + dev_err(&client->dev, "gsl I2C functionality not supported\n"); + return -ENODEV; + } + ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); + if (!ts) + return -ENOMEM; + msleep(20); + + /* get touch for regulator */ + ts->regulator = devm_regulator_get_optional(&client->dev, "power"); + if (IS_ERR(ts->regulator)) { + if (PTR_ERR(ts->regulator) == -EPROBE_DEFER) + dev_err(&client->dev, + "get touch regulator is fail, may no need.\n"); + ts->regulator = NULL; + } else { + gsl_ts_power_on(ts, true); + } + + ts->tp.tp_suspend = gsl_ts_early_suspend; + ts->tp.tp_resume = gsl_ts_late_resume; + tp_register_fb(&ts->tp); + ts->client = client; + i2c_set_clientdata(client, ts); + /* ts->device_id = id->driver_data; */ + + gslX680_init(ts); + rc = gslX680_ts_init(client, ts); + if (rc < 0) { + dev_err(&client->dev, "gsl GSLX680 init failed\n"); + goto porbe_err_ret; + } + + init_chip(ts->client, ts); + check_mem_data(ts->client, ts); + spin_lock_init(&ts->irq_lock); + client->irq = gpio_to_irq(ts->irq); + rc = request_irq(client->irq, gsl_ts_irq, IRQF_TRIGGER_RISING, + client->name, ts); + if (rc < 0) { + pr_err("gsl_probe: request irq failed\n"); + goto porbe_err_ret; + } + glsx680_ts_irq_enable(ts); + +#ifdef CONFIG_HAS_EARLYSUSPEND + + ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + ts->early_suspend.suspend = gsl_ts_early_suspend; + ts->early_suspend.resume = gsl_ts_late_resume; + register_early_suspend(&ts->early_suspend); +#endif + +#ifdef GSL_MONITOR + + INIT_DELAYED_WORK(&ts->gsl_monitor_work, gsl_monitor_worker); + gsl_monitor_workqueue = + create_singlethread_workqueue("gsl_monitor_workqueue"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 1000); +#endif + +#ifdef HAVE_CLICK_TIMER + sema_init(&my_sem, 1); + INIT_WORK(&ts->click_work, click_timer_worker); + gsl_timer_workqueue = create_singlethread_workqueue("click_timer"); + queue_work(gsl_timer_workqueue, &ts->click_work); +#endif + +#ifdef TPD_PROC_DEBUG + i2c_client = client; + /* proc_create(GSL_CONFIG_PROC_FILE, 0666, NULL, &gsl_seq_fops); */ +#endif + gsl_proc_flag = 0; + pr_info("[GSLX680] End %s\n", __func__); + + return 0; + +porbe_err_ret: + return rc; +} + +static int gsl_ts_remove(struct i2c_client *client) +{ + struct gsl_ts *ts = i2c_get_clientdata(client); + +#ifdef CONFIG_HAS_EARLYSUSPEND + unregister_early_suspend(&ts->early_suspend); +#endif + +#ifdef GSL_MONITOR + cancel_delayed_work_sync(&ts->gsl_monitor_work); + destroy_workqueue(gsl_monitor_workqueue); +#endif + +#ifdef HAVE_CLICK_TIMER + cancel_work_sync(&ts->click_work); + destroy_workqueue(gsl_timer_workqueue); +#endif + + device_init_wakeup(&client->dev, 0); + cancel_work_sync(&ts->work); + free_irq(ts->client->irq, ts); + destroy_workqueue(ts->wq); + gsl_ts_power_on(ts, false); + + return 0; +} + +static const struct of_device_id gsl_ts_ids[] = { + {.compatible = "gslX6801"}, + {} +}; + +static const struct i2c_device_id gsl_ts_id[] = { + {GSLX680_I2C_NAME, 0}, + {} +}; + +MODULE_DEVICE_TABLE(i2c, gsl_ts_id); + +static struct i2c_driver gsl_ts_driver = { + .driver = { + .name = GSLX680_I2C_NAME, + .owner = THIS_MODULE, + .of_match_table = of_match_ptr(gsl_ts_ids), + .probe_type = PROBE_PREFER_ASYNCHRONOUS, + }, + .probe = gsl_ts_probe, + .remove = gsl_ts_remove, + .id_table = gsl_ts_id, +}; + +static int __init gsl_ts_init(void) +{ + int ret; + + ret = i2c_add_driver(&gsl_ts_driver); + return ret; +} + +static void __exit gsl_ts_exit(void) +{ + i2c_del_driver(&gsl_ts_driver); +} + +module_init(gsl_ts_init); +module_exit(gsl_ts_exit); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("GSLX680 touchscreen controller driver"); +MODULE_AUTHOR("Guan Yuwei, guanyuwei@basewin.com"); +MODULE_ALIAS("platform:gsl_ts"); diff --git a/drivers/input/touchscreen/gslx6801.h b/drivers/input/touchscreen/gslx6801.h new file mode 100644 index 000000000000..45bb3469d2ea --- /dev/null +++ b/drivers/input/touchscreen/gslx6801.h @@ -0,0 +1,4955 @@ +/* + * drivers/input/touchscreen/gslX680.h + * + * Copyright (c) 2012 Shanghai Basewin + * Guan Yuwei + * + * 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 _GSLX680_H_ +#define _GSLX680_H_ +#define SCREEN_MAX_X 1920 +#define SCREEN_MAX_Y 1200 + +struct fw_data { + u32 offset:8; + u32:0; + u32 val; +}; + +#define GSL_NOID_VERSION +#ifdef GSL_NOID_VERSION +struct gsl_touch_info { + int x[10]; + int y[10]; + int id[10]; + int finger_num; +}; + +extern unsigned int gsl_mask_tiaoping(void); +extern unsigned int gsl_version_id(void); +extern void gsl_alg_id_main(struct gsl_touch_info *cinfo); +extern void gsl_DataInit(int *ret); + +static unsigned int gsl_config_data_id[] = { + 0x9eca05, + 0x200, + 0, 0, + 0, + 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0xd36c69b2, + 0xd0b, 0x5, 0x12001c, 0x12001c, 0x78004b0, 0, 0x5100, 0x8e00, + 0, 0x320014, 0, 0, 0, 0, 0, 0, + 0x8, 0x4000, 0x1000, 0x10000000, 0x10000000, 0, 0, 0, + 0x1b6db688, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0x804000, 0x90040, 0x90001, 0, 0, 0, + 0, 0, 0, 0x14012c, 0xa003c, 0xa0078, 0x400, 0x1081, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, + 0x3200384, 0x64, 0x503e8, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x220, + 0, 0, 0, 0, 0, 0, 0, 0, + 0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f, + 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f, + 0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f, + 0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f, + 0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f, 0x10111213, + 0x14151617, 0x18191a1b, 0x1c1d1e1f, + 0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f, + 0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f, + + 0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f, + 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f, + 0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f, + 0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f, + + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f, + 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f, + 0x20212223, 0x24252627, 0x28292a2b, 0x2c2d2e2f, + 0x30313233, 0x34353637, 0x38393a3b, 0x3c3d3e3f, + + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, + + 0x3, + 0x101, 0, 0x100, 0, + 0x20, 0x10, 0x8, 0x4, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + + 0x4, 0, 0, 0, 0, 0, 0, 0, + 0x4800700, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, +}; +#endif + +static const struct fw_data GSLX680_FW[] = { + {0xf0, 0x2}, + {0x00, 0x00000000}, + {0x04, 0x00000000}, + {0x08, 0x00000000}, + {0x0c, 0x00000000}, + {0x10, 0x00000000}, + {0x14, 0x00000000}, + {0x18, 0x00000000}, + {0x1c, 0x00000000}, + {0x20, 0x00000000}, + {0x24, 0x00000000}, + {0x28, 0x00000000}, + {0x2c, 0x00000000}, + {0x30, 0x00000000}, + {0x34, 0x00000000}, + {0x38, 0x00000000}, + {0x3c, 0x00000000}, + {0x40, 0x00000000}, + {0x44, 0x00000000}, + {0x48, 0x00000000}, + {0x4c, 0x00000000}, + {0x50, 0x00000000}, + {0x54, 0x00000000}, + {0x58, 0x00000000}, + {0x5c, 0x00000020}, + {0x60, 0x00000000}, + {0x64, 0xf801000c}, + {0x68, 0x00066414}, + {0x6c, 0x1001020a}, + {0x70, 0x00000fff}, + {0x74, 0x00000000}, + {0x78, 0x00000000}, + {0x7c, 0x121c121c}, + {0xf0, 0x3}, + {0x00, 0xb91325af}, + {0x04, 0x00000000}, + {0x08, 0x00000000}, + {0x0c, 0x00000000}, + {0x10, 0x00000000}, + {0x14, 0x00000000}, + {0x18, 0x00000000}, + {0x1c, 0x00000000}, + {0x20, 0x00000000}, + {0x24, 0x00005100}, + {0x28, 0x00008e00}, + {0x2c, 0x00000000}, + {0x30, 0x00000000}, + {0x34, 0x00000000}, + {0x38, 0x00000000}, + {0x3c, 0x00000000}, + {0x40, 0x00000000}, + {0x44, 0x00000000}, + {0x48, 0x00000000}, + {0x4c, 0x00000000}, + {0x50, 0x00000000}, + {0x54, 0x00000000}, + {0x58, 0x00000000}, + {0x5c, 0x00000014}, + {0x60, 0x00000000}, + {0x64, 0x1a0ac00a}, + {0x68, 0x00000002}, + {0x6c, 0x0000000f}, + {0x70, 0x00000000}, + {0x74, 0xffffffff}, + {0x78, 0xffffffec}, + {0x7c, 0x00000000}, + {0xf0, 0x4}, + {0x00, 0x00000000}, + {0x04, 0x0001660b}, + {0x08, 0x00000064}, + {0x0c, 0x00000000}, + {0x10, 0xfe0cff06}, + {0x14, 0x00000000}, + {0x18, 0x00000000}, + {0x1c, 0x00000000}, + {0x20, 0x00000000}, + {0x24, 0x00000000}, + {0x28, 0x00000000}, + {0x2c, 0x00000000}, + {0x30, 0x00010000}, + {0x34, 0x00000fff}, + {0x38, 0x0000000a}, + {0x3c, 0x00000258}, + {0x40, 0x00000000}, + {0x44, 0x04020a00}, + {0x48, 0x0014012c}, + {0x4c, 0x9a000000}, + {0x50, 0x00000000}, + {0x54, 0x00010203}, + {0x58, 0x04050607}, + {0x5c, 0x08090a0b}, + {0x60, 0x0c0d0e0f}, + {0x64, 0x10111213}, + {0x68, 0x14151617}, + {0x6c, 0x18191a1b}, + {0x70, 0x1c1d1e1f}, + {0x74, 0x0014000a}, + {0x78, 0x80808080}, + {0x7c, 0xcba981f4}, + {0xf0, 0x5}, + {0x00, 0x00000000}, + {0x04, 0x00000005}, + {0x08, 0x000000b4}, + {0x0c, 0x66666666}, + {0x10, 0x0000000a}, + {0x14, 0x00000000}, + {0x18, 0x00000fff}, + {0x1c, 0x10000000}, + {0x20, 0x10000000}, + {0x24, 0x00000000}, + {0x28, 0x00000000}, + {0x2c, 0x00000400}, + {0x30, 0x80808080}, + {0x34, 0x80808080}, + {0x38, 0x80808080}, + {0x3c, 0x80808080}, + {0x40, 0x80808080}, + {0x44, 0x80808080}, + {0x48, 0x80808080}, + {0x4c, 0x80808000}, + {0x50, 0xffffffff}, + {0x54, 0x00000000}, + {0x58, 0x00000000}, + {0x5c, 0x00000000}, + {0x60, 0x00000000}, + {0x64, 0x00000000}, + {0x68, 0x00000000}, + {0x6c, 0x00000000}, + {0x70, 0x00000000}, + {0x74, 0x00000220}, + {0x78, 0x0000001c}, + {0x7c, 0x00000012}, + {0xf0, 0x6}, + {0x00, 0x0000001c}, + {0x04, 0x00000000}, + {0x08, 0x00000012}, + {0x0c, 0x04030402}, + {0x10, 0x00000032}, + {0x14, 0x1414010a}, + {0x18, 0x00000000}, + {0x1c, 0x00000001}, + {0x20, 0x00002904}, + {0x24, 0x00000780}, + {0x28, 0x000004b0}, + {0x2c, 0xf801000c}, + {0x30, 0xf8010005}, + {0x34, 0x00000003}, + {0x38, 0x00000003}, + {0x3c, 0x00000fff}, + {0x40, 0x80000000}, + {0x44, 0x00180018}, + {0x48, 0x00000fff}, + {0x4c, 0x04040402}, + {0x50, 0x00030002}, + {0x54, 0x00000e10}, + {0x58, 0x000a012c}, + {0x5c, 0x00806408}, + {0x60, 0x10100800}, + {0x64, 0x00000000}, + {0x68, 0x00000000}, + {0x6c, 0x00000000}, + {0x70, 0x00000000}, + {0x74, 0x000000fa}, + {0x78, 0x000a003c}, + {0x7c, 0x00000000}, + {0xf0, 0x7}, + {0x00, 0x0108000b}, + {0x04, 0x030a020d}, + {0x08, 0x050c040f}, + {0x0c, 0x070e0611}, + {0x10, 0x09100814}, + {0x14, 0x0b170a16}, + {0x18, 0x00000000}, + {0x1c, 0x000a0078}, + {0x20, 0x00001081}, + {0x24, 0xff080010}, + {0x28, 0xff080120}, + {0x2c, 0xff080140}, + {0x30, 0xff080160}, + {0x34, 0x0000012c}, + {0x38, 0x00000104}, + {0x3c, 0x000000dc}, + {0x40, 0x00000000}, + {0x44, 0x00000000}, + {0x48, 0x00000d0b}, + {0x4c, 0x320f0f03}, + {0x50, 0x00000000}, + {0x54, 0x00000001}, + {0x58, 0x001b0000}, + {0x5c, 0x00000000}, + {0x60, 0x00000000}, + {0x64, 0x00000000}, + {0x68, 0x000c0002}, + {0x6c, 0x00000000}, + {0x70, 0x00000000}, + {0x74, 0x00000000}, + {0x78, 0x00023456}, + {0x7c, 0x0078a19b}, + {0xf0, 0x8}, + {0x00, 0x01ff01fe}, + {0x04, 0x01fd01fc}, + {0x08, 0x01fb01fa}, + {0x0c, 0x01f901f8}, + {0x10, 0x01f701f6}, + {0x14, 0x01f501f3}, + {0x18, 0x01f2020f}, + {0x1c, 0x022f024f}, + {0x20, 0x026f02af}, + {0x24, 0x02cf02ef}, + {0x28, 0x030f032f}, + {0x2c, 0x034f036f}, + {0x30, 0x038f03af}, + {0x34, 0x03cf13ef}, + {0x38, 0x01fc01fd}, + {0x3c, 0x01fe11ff}, + {0x40, 0x01030507}, + {0x44, 0x090b0d0f}, + {0x48, 0x11000000}, + {0x4c, 0x02040608}, + {0x50, 0x0a0c0e10}, + {0x54, 0x12000000}, + {0x58, 0x00040003}, + {0x5c, 0x00000008}, + {0x60, 0x00000000}, + {0x64, 0x00000201}, + {0x68, 0x00000804}, + {0x6c, 0x006600cd}, + {0x70, 0x000000cd}, + {0x74, 0x0000008c}, + {0x78, 0x00000000}, + {0x7c, 0x00000012}, + {0xf0, 0x9}, + {0x00, 0xff080094}, + {0x04, 0x00070011}, + {0x08, 0xff080090}, + {0x0c, 0x00040000}, + {0x10, 0xff080068}, + {0x14, 0x00030000}, + {0x18, 0xff080064}, + {0x1c, 0x01002582}, + {0x20, 0xff080060}, + {0x24, 0x00000000}, + {0x28, 0xff08004c}, + {0x2c, 0x00197fff}, + {0x30, 0xfffffff0}, + {0x34, 0x00000000}, + {0x38, 0xfffffff0}, + {0x3c, 0x00000000}, + {0x40, 0xfffffff0}, + {0x44, 0x00000000}, + {0x48, 0xfffffff0}, + {0x4c, 0x00000000}, + {0x50, 0xfffffff0}, + {0x54, 0x00000000}, + {0x58, 0xfffffff0}, + {0x5c, 0x00000000}, + {0x60, 0xfffffff0}, + {0x64, 0x00000000}, + {0x68, 0xfffffff0}, + {0x6c, 0x00000000}, + {0x70, 0xfffffff0}, + {0x74, 0x00000000}, + {0x78, 0xfffffff0}, + {0x7c, 0x00000000}, + + {0xf0, 0x1e}, + {0x00, 0x5a5a0f00}, + {0x04, 0x00002ae4}, + {0x08, 0x00002b6c}, + {0x0c, 0x00002bec}, + {0x10, 0x00002d2c}, + {0x14, 0x00002e28}, + {0x18, 0x00002fdc}, + {0x1c, 0x00003170}, + {0x20, 0x000032d0}, + {0x24, 0x0000349c}, + {0x28, 0x0000360c}, + {0x2c, 0x00003628}, + {0x30, 0x000037f0}, + {0x34, 0x00003a18}, + {0x38, 0x00003c0c}, + {0x3c, 0x00003f8c}, + {0x40, 0x00004094}, + {0x44, 0x0000430c}, + {0x48, 0x00004420}, + {0x4c, 0x00004498}, + {0x50, 0x00004510}, + {0x54, 0x000046a8}, + {0x58, 0x00004990}, + {0x5c, 0x00004d48}, + {0x60, 0x00004ddc}, + {0x64, 0x00004e40}, + {0x68, 0x00004fb4}, + {0x6c, 0x00000000}, + {0x70, 0x00000000}, + {0x74, 0x00000000}, + {0x78, 0x00000000}, + {0x7c, 0x00000000}, + {0xf0, 0x1f}, + {0x00, 0x00000000}, + {0x04, 0x00000000}, + {0x08, 0x00000000}, + {0x0c, 0x00000000}, + {0x10, 0x00000000}, + {0x14, 0x00000000}, + {0x18, 0x00000000}, + {0x1c, 0x00000000}, + {0x20, 0x00000000}, + {0x24, 0x00000000}, + {0x28, 0x00000000}, + {0x2c, 0x00000000}, + {0x30, 0x00000000}, + {0x34, 0x00000000}, + {0x38, 0x00000000}, + {0x3c, 0x0000248c}, + {0x40, 0x0000263c}, + {0x44, 0x00000000}, + {0x48, 0x00000000}, + {0x4c, 0x000026bc}, + {0x50, 0x0000277c}, + {0x54, 0x00000000}, + {0x58, 0x0000282c}, + {0x5c, 0x00000000}, + {0x60, 0x00000000}, + {0x64, 0x00002960}, + {0x68, 0x00000000}, + {0x6c, 0x00000000}, + {0x70, 0x00002a44}, + {0x74, 0x00000000}, + {0x78, 0x0000507c}, + {0x7c, 0x5a5a0ffc}, + {0xf0, 0x0}, + {0x00, 0x01000000}, + {0x04, 0x01000000}, + {0x08, 0x01000000}, + {0x0c, 0x233fc0c0}, + {0x10, 0xa2146004}, + {0x14, 0xa4102000}, + {0x18, 0xe4244000}, + {0x1c, 0x233fc0c0}, + {0x20, 0xa2146010}, + {0x24, 0x2500003f}, + {0x28, 0xa414a3ff}, + {0x2c, 0xe4244000}, + {0x30, 0x01000000}, + {0x34, 0x821020e0}, + {0x38, 0x81880001}, + {0x3c, 0x01000000}, + {0x40, 0x01000000}, + {0x44, 0xa410200f}, + {0x48, 0xe4a00040}, + {0x4c, 0x01000000}, + {0x50, 0xa0100000}, + {0x54, 0xa2100000}, + {0x58, 0xa4100000}, + {0x5c, 0xa6100000}, + {0x60, 0xa8100000}, + {0x64, 0xaa100000}, + {0x68, 0xac100000}, + {0x6c, 0xae100000}, + {0x70, 0x90100000}, + {0x74, 0x92100000}, + {0x78, 0x94100000}, + {0x7c, 0x96100000}, + {0xf0, 0x1}, + {0x00, 0x98100000}, + {0x04, 0x9a100000}, + {0x08, 0x9c100000}, + {0x0c, 0x9e100000}, + {0x10, 0x84100000}, + {0x14, 0x01000000}, + {0x18, 0x01000000}, + {0x1c, 0x82100000}, + {0x20, 0x81900001}, + {0x24, 0x82100000}, + {0x28, 0x81980001}, + {0x2c, 0x81800000}, + {0x30, 0x01000000}, + {0x34, 0x01000000}, + {0x38, 0x01000000}, + {0x3c, 0xbc102cfc}, + {0x40, 0x9c102cf8}, + {0x44, 0x01000000}, + {0x48, 0x01000000}, + {0x4c, 0x27001040}, + {0x50, 0xa614e00f}, + {0x54, 0xe6a00040}, + {0x58, 0x01000000}, + {0x5c, 0x40000309}, + {0x60, 0x01000000}, + {0x64, 0x01000000}, + {0x68, 0x10bfffff}, + {0x6c, 0x01000000}, + {0x70, 0x03169684}, + {0x74, 0x82106053}, + {0x78, 0x0329694d}, + {0x7c, 0x82106228}, + {0xf0, 0x1a}, + {0x00, 0x9de3bf98}, + {0x04, 0x40000010}, + {0x08, 0x01000000}, + {0x0c, 0x40000007}, + {0x10, 0x01000000}, + {0x14, 0x40000334}, + {0x18, 0x01000000}, + {0x1c, 0x40000015}, + {0x20, 0x01000000}, + {0x24, 0x30bffffe}, + {0x28, 0x82102001}, + {0x2c, 0x81904000}, + {0x30, 0x01000000}, + {0x34, 0x01000000}, + {0x38, 0x01000000}, + {0x3c, 0x81c3e008}, + {0x40, 0x01000000}, + {0x44, 0x03000008}, + {0x48, 0x82106342}, + {0x4c, 0xa3804000}, + {0x50, 0x03000004}, + {0x54, 0x82106000}, + {0x58, 0x81984000}, + {0x5c, 0x01000000}, + {0x60, 0x01000000}, + {0x64, 0x01000000}, + {0x68, 0x81c3e008}, + {0x6c, 0x01000000}, + {0x70, 0x01000000}, + {0x74, 0x01000000}, + {0x78, 0x01000000}, + {0x7c, 0xa7800000}, + {0xf0, 0x1b}, + {0x00, 0x01000000}, + {0x04, 0x01000000}, + {0x08, 0x01000000}, + {0x0c, 0x81c3e008}, + {0x10, 0x01000000}, + {0x14, 0x80a22000}, + {0x18, 0x02800006}, + {0x1c, 0x01000000}, + {0x20, 0x01000000}, + {0x24, 0x90823fff}, + {0x28, 0x12bffffe}, + {0x2c, 0x01000000}, + {0x30, 0x81c3e008}, + {0x34, 0x01000000}, + {0x38, 0x01000000}, + {0x3c, 0x05001040}, + {0x40, 0x8410a00f}, + {0x44, 0xc4a00040}, + {0x48, 0x01000000}, + {0x4c, 0x81c3e008}, + {0x50, 0x01000000}, + {0x54, 0x9de3beb8}, + {0x58, 0xb2067fff}, + {0x5c, 0x96100018}, + {0x60, 0xf227bf1c}, + {0x64, 0xc027bf18}, + {0x68, 0x98102000}, + {0x6c, 0xb007bff8}, + {0x70, 0xd4063f20}, + {0x74, 0xda063f24}, + {0x78, 0xb810000a}, + {0x7c, 0x98033fff}, + {0xf0, 0x1c}, + {0x00, 0xb0063ff8}, + {0x04, 0x80a2800d}, + {0x08, 0x16800031}, + {0x0c, 0xb610000d}, + {0x10, 0xbb2aa002}, + {0x14, 0x832b6002}, + {0x18, 0xb207400b}, + {0x1c, 0xb400400b}, + {0x20, 0xde02c01d}, + {0x24, 0x80a7001b}, + {0x28, 0x1680001c}, + {0x2c, 0x01000000}, + {0x30, 0xc2068000}, + {0x34, 0x80a0400f}, + {0x38, 0x04800005}, + {0x3c, 0x80a7001b}, + {0x40, 0xb606ffff}, + {0x44, 0x10bffff8}, + {0x48, 0xb406bffc}, + {0x4c, 0x16800013}, + {0x50, 0x80a7001b}, + {0x54, 0xc2068000}, + {0x58, 0xc2264000}, + {0x5c, 0xb8072001}, + {0x60, 0x80a7001b}, + {0x64, 0x1680000d}, + {0x68, 0xb2066004}, + {0x6c, 0xc2064000}, + {0x70, 0x80a0400f}, + {0x74, 0x26bffffb}, + {0x78, 0xb8072001}, + {0x7c, 0x80a7001b}, + {0xf0, 0x1d}, + {0x00, 0x16800006}, + {0x04, 0x01000000}, + {0x08, 0xc2268000}, + {0x0c, 0xb606ffff}, + {0x10, 0xb406bffc}, + {0x14, 0x80a7001b}, + {0x18, 0x12bfffe4}, + {0x1c, 0x80a7001b}, + {0x20, 0xb0062008}, + {0x24, 0x82073fff}, + {0x28, 0xc2263f24}, + {0x2c, 0xd4263f20}, + {0x30, 0x832f2002}, + {0x34, 0xb0062008}, + {0x38, 0xde22c001}, + {0x3c, 0xba072001}, + {0x40, 0xfa263f20}, + {0x44, 0xda263f24}, + {0x48, 0x98032002}, + {0x4c, 0x80a33fff}, + {0x50, 0x34bfffc9}, + {0x54, 0xd4063f20}, + {0x58, 0x81c7e008}, + {0x5c, 0x81e80000}, + {0x60, 0x00000000}, + {0x64, 0x00000000}, + {0x68, 0x00000000}, + {0x6c, 0x00000000}, + {0x70, 0x00000000}, + {0x74, 0x00000000}, + {0x78, 0x00000000}, + {0x7c, 0x00000000}, + {0xf0, 0x20}, + {0x00, 0x83580000}, + {0x04, 0x82086ff0}, + {0x08, 0x83306004}, + {0x0c, 0x80a06005}, + {0x10, 0x02800027}, + {0x14, 0x01000000}, + {0x18, 0x80a06006}, + {0x1c, 0x0280003c}, + {0x20, 0x01000000}, + {0x24, 0x80a06015}, + {0x28, 0x02800054}, + {0x2c, 0x01000000}, + {0x30, 0x80a0602a}, + {0x34, 0x02800090}, + {0x38, 0x01000000}, + {0x3c, 0x80a06018}, + {0x40, 0x02800085}, + {0x44, 0x01000000}, + {0x48, 0x073fc180}, + {0x4c, 0x8610e03c}, + {0x50, 0x05169680}, + {0x54, 0x84004002}, + {0x58, 0xc420c000}, + {0x5c, 0x073fc000}, + {0x60, 0x8610e020}, + {0x64, 0x84102001}, + {0x68, 0xc420c000}, + {0x6c, 0x0500000c}, + {0x70, 0x01000000}, + {0x74, 0x01000000}, + {0x78, 0x8480bfff}, + {0x7c, 0x12bffffe}, + {0xf0, 0x21}, + {0x00, 0x01000000}, + {0x04, 0x01000000}, + {0x08, 0x073fc000}, + {0x0c, 0x8610e020}, + {0x10, 0x84102000}, + {0x14, 0xc420c000}, + {0x18, 0x01000000}, + {0x1c, 0x01000000}, + {0x20, 0x81c44000}, + {0x24, 0x81cc8000}, + {0x28, 0x01000000}, + {0x2c, 0xa7500000}, + {0x30, 0xa92ce002}, + {0x34, 0xa734e001}, + {0x38, 0xa614c014}, + {0x3c, 0xa60ce007}, + {0x40, 0x81900000}, + {0x44, 0x01000000}, + {0x48, 0x01000000}, + {0x4c, 0x81e00000}, + {0x50, 0xe03ba000}, + {0x54, 0xe43ba008}, + {0x58, 0xe83ba010}, + {0x5c, 0xec3ba018}, + {0x60, 0xf03ba020}, + {0x64, 0xf43ba028}, + {0x68, 0xf83ba030}, + {0x6c, 0xfc3ba038}, + {0x70, 0x81e80000}, + {0x74, 0x8194c000}, + {0x78, 0x01000000}, + {0x7c, 0x01000000}, + {0xf0, 0x22}, + {0x00, 0x81c44000}, + {0x04, 0x81cc8000}, + {0x08, 0x01000000}, + {0x0c, 0xa7500000}, + {0x10, 0xa934e002}, + {0x14, 0xa72ce001}, + {0x18, 0xa614c014}, + {0x1c, 0xa60ce007}, + {0x20, 0x81900000}, + {0x24, 0x01000000}, + {0x28, 0x01000000}, + {0x2c, 0x81e80000}, + {0x30, 0x81e80000}, + {0x34, 0xe01ba000}, + {0x38, 0xe41ba008}, + {0x3c, 0xe81ba010}, + {0x40, 0xec1ba018}, + {0x44, 0xf01ba020}, + {0x48, 0xf41ba028}, + {0x4c, 0xf81ba030}, + {0x50, 0xfc1ba038}, + {0x54, 0x81e00000}, + {0x58, 0x81e00000}, + {0x5c, 0x8194c000}, + {0x60, 0x01000000}, + {0x64, 0x01000000}, + {0x68, 0x81c44000}, + {0x6c, 0x81cc8000}, + {0x70, 0x01000000}, + {0x74, 0x01000000}, + {0x78, 0x82102010}, + {0x7c, 0x273fc0c0}, + {0xf0, 0x23}, + {0x00, 0xa614e010}, + {0x04, 0xc224c000}, + {0x08, 0x01000000}, + {0x0c, 0x033fc0c0}, + {0x10, 0x82106004}, + {0x14, 0xa6102000}, + {0x18, 0xe6204000}, + {0x1c, 0x01000000}, + {0x20, 0x01000000}, + {0x24, 0x01000000}, + {0x28, 0xa6102020}, + {0x2c, 0x83480000}, + {0x30, 0x82104013}, + {0x34, 0x81884000}, + {0x38, 0x01000000}, + {0x3c, 0x40000441}, + {0x40, 0x01000000}, + {0x44, 0x01000000}, + {0x48, 0x01000000}, + {0x4c, 0xa7500000}, + {0x50, 0xa934e002}, + {0x54, 0xa72ce001}, + {0x58, 0xa614c014}, + {0x5c, 0xa60ce007}, + {0x60, 0x81900000}, + {0x64, 0x01000000}, + {0x68, 0x81e80000}, + {0x6c, 0xe01ba000}, + {0x70, 0xe41ba008}, + {0x74, 0xe81ba010}, + {0x78, 0xec1ba018}, + {0x7c, 0xf01ba020}, + {0xf0, 0x24}, + {0x00, 0xf41ba028}, + {0x04, 0xf81ba030}, + {0x08, 0xfc1ba038}, + {0x0c, 0x81e00000}, + {0x10, 0x8194c000}, + {0x14, 0x01000000}, + {0x18, 0xa6102020}, + {0x1c, 0x83480000}, + {0x20, 0x82284013}, + {0x24, 0x81884000}, + {0x28, 0x01000000}, + {0x2c, 0x033fc0c0}, + {0x30, 0x82106004}, + {0x34, 0xa6103fff}, + {0x38, 0xe6204000}, + {0x3c, 0x01000000}, + {0x40, 0x01000000}, + {0x44, 0x01000000}, + {0x48, 0x81c44000}, + {0x4c, 0x81cc8000}, + {0x50, 0x01000000}, + {0x54, 0x82102080}, + {0x58, 0x273fc0c0}, + {0x5c, 0xa614e010}, + {0x60, 0xc224c000}, + {0x64, 0x01000000}, + {0x68, 0x81c44000}, + {0x6c, 0x81cc8000}, + {0x70, 0x01000000}, + {0x74, 0x81c48000}, + {0x78, 0x81cca004}, + {0x7c, 0x01000000}, + {0xf0, 0x25}, + {0x00, 0x033fc200}, + {0x04, 0xda0021fc}, + {0x08, 0x9210608c}, + {0x0c, 0x96106084}, + {0x10, 0x94106088}, + {0x14, 0x825a000d}, + {0x18, 0x80a36000}, + {0x1c, 0x02800003}, + {0x20, 0x82006800}, + {0x24, 0x9130600c}, + {0x28, 0x992a2010}, + {0x2c, 0x82022001}, + {0x30, 0x9b2a2004}, + {0x34, 0x83286010}, + {0x38, 0x9a03000d}, + {0x3c, 0xda22c000}, + {0x40, 0x82004008}, + {0x44, 0x82006002}, + {0x48, 0xd8228000}, + {0x4c, 0x81c3e008}, + {0x50, 0xc2224000}, + {0x54, 0x1b3fc140}, + {0x58, 0x82136048}, + {0x5c, 0xc2104000}, + {0x60, 0x82006003}, + {0x64, 0x82086003}, + {0x68, 0x83286002}, + {0x6c, 0x9a136080}, + {0x70, 0x81c3e008}, + {0x74, 0xd000400d}, + {0x78, 0x94102000}, + {0x7c, 0x96102000}, + {0xf0, 0x26}, + {0x00, 0x832ae002}, + {0x04, 0xd20063a4}, + {0x08, 0x98102000}, + {0x0c, 0x832b2002}, + {0x10, 0x9b2aa002}, + {0x14, 0xda02000d}, + {0x18, 0x98032001}, + {0x1c, 0xda224001}, + {0x20, 0x80a32005}, + {0x24, 0x04bffffa}, + {0x28, 0x9402a001}, + {0x2c, 0x9602e001}, + {0x30, 0x80a2e003}, + {0x34, 0x04bffff4}, + {0x38, 0x832ae002}, + {0x3c, 0x81c3e008}, + {0x40, 0x01000000}, + {0x44, 0x82020008}, + {0x48, 0x82004008}, + {0x4c, 0x9b326002}, + {0x50, 0x82004001}, + {0x54, 0x8200400d}, + {0x58, 0x83286002}, + {0x5c, 0x920a6003}, + {0x60, 0x932a6003}, + {0x64, 0xd00065b0}, + {0x68, 0x91320009}, + {0x6c, 0x81c3e008}, + {0x70, 0x900a20ff}, + {0x74, 0x9a020008}, + {0x78, 0x9a034008}, + {0x7c, 0x97326002}, + {0xf0, 0x27}, + {0x00, 0x9a03400d}, + {0x04, 0x9a03400b}, + {0x08, 0x920a6003}, + {0x0c, 0x9b2b6002}, + {0x10, 0x932a6003}, + {0x14, 0x821020ff}, + {0x18, 0xd80365b0}, + {0x1c, 0x83284009}, + {0x20, 0x822b0001}, + {0x24, 0x952a8009}, + {0x28, 0x8210400a}, + {0x2c, 0xc22365b0}, + {0x30, 0x912a2002}, + {0x34, 0xda0223a4}, + {0x38, 0x972ae002}, + {0x3c, 0x81c3e008}, + {0x40, 0xc223400b}, + {0x44, 0x9a102005}, + {0x48, 0x8210200b}, + {0x4c, 0x9a234008}, + {0x50, 0x82204008}, + {0x54, 0x9b2b6002}, + {0x58, 0x80a22005}, + {0x5c, 0x14800007}, + {0x60, 0x99286002}, + {0x64, 0x033fc200}, + {0x68, 0x8210600c}, + {0x6c, 0xc2004000}, + {0x70, 0x10800006}, + {0x74, 0x8330400d}, + {0x78, 0x033fc200}, + {0x7c, 0x82106008}, + {0xf0, 0x28}, + {0x00, 0xc2004000}, + {0x04, 0x8330400c}, + {0x08, 0x81c3e008}, + {0x0c, 0x9008600f}, + {0x10, 0x9de3bf28}, + {0x14, 0xa12e2002}, + {0x18, 0xda1423da}, + {0x1c, 0xd61423d8}, + {0x20, 0xc200247c}, + {0x24, 0xb022c00d}, + {0x28, 0x825b4001}, + {0x2c, 0xb21e6001}, + {0x30, 0x92862001}, + {0x34, 0x0280000c}, + {0x38, 0x9a004019}, + {0x3c, 0xb0100009}, + {0x40, 0x9807bf88}, + {0x44, 0x8203400d}, + {0x48, 0xc2168001}, + {0x4c, 0xc2230000}, + {0x50, 0xc200247c}, + {0x54, 0x9a034001}, + {0x58, 0xb0863fff}, + {0x5c, 0x12bffffa}, + {0x60, 0x98032004}, + {0x64, 0x7ffffe5c}, + {0x68, 0x9007bf88}, + {0x6c, 0xda1423ea}, + {0x70, 0xd61423e8}, + {0x74, 0x80a3400b}, + {0x78, 0x92102000}, + {0x7c, 0x1880000b}, + {0xf0, 0x29}, + {0x00, 0xb010000d}, + {0x04, 0x832b6002}, + {0x08, 0x8200401e}, + {0x0c, 0x98007f88}, + {0x10, 0xc2030000}, + {0x14, 0xb0062001}, + {0x18, 0x92024001}, + {0x1c, 0x80a6000b}, + {0x20, 0x08bffffc}, + {0x24, 0x98032004}, + {0x28, 0xb022c00d}, + {0x2c, 0xb0062001}, + {0x30, 0x81800000}, + {0x34, 0x01000000}, + {0x38, 0x01000000}, + {0x3c, 0x01000000}, + {0x40, 0xb0724018}, + {0x44, 0x81c7e008}, + {0x48, 0x81e80000}, + {0x4c, 0x033fc200}, + {0x50, 0x961060a0}, + {0x54, 0x98102000}, + {0x58, 0x832b2002}, + {0x5c, 0x9a03000c}, + {0x60, 0xda136400}, + {0x64, 0x98032001}, + {0x68, 0x80a3201b}, + {0x6c, 0x04bffffb}, + {0x70, 0xda20400b}, + {0x74, 0x81c3e008}, + {0x78, 0x01000000}, + {0x7c, 0x9de3bf98}, + {0xf0, 0x2a}, + {0x00, 0xc200247c}, + {0x04, 0x83306001}, + {0x08, 0x80a60001}, + {0x0c, 0x1a800006}, + {0x10, 0x90100018}, + {0x14, 0x7fffffac}, + {0x18, 0x01000000}, + {0x1c, 0x10800006}, + {0x20, 0xb0020008}, + {0x24, 0x7fffffa8}, + {0x28, 0x90260001}, + {0x2c, 0x90020008}, + {0x30, 0xb0022001}, + {0x34, 0x81c7e008}, + {0x38, 0x81e80000}, + {0x3c, 0x9de3bf98}, + {0x40, 0xa6102000}, + {0x44, 0xc20023d4}, + {0x48, 0x80a4c001}, + {0x4c, 0x1a800059}, + {0x50, 0xe2002348}, + {0x54, 0xaa102000}, + {0x58, 0xc200247c}, + {0x5c, 0x80a54001}, + {0x60, 0x3a800050}, + {0x64, 0xa604e001}, + {0x68, 0xa92ce002}, + {0x6c, 0x0300001d}, + {0x70, 0x821062a0}, + {0x74, 0xae050001}, + {0x78, 0x7fffffe1}, + {0x7c, 0x90100015}, + {0xf0, 0x2b}, + {0x00, 0xac100008}, + {0x04, 0x90100013}, + {0x08, 0x7fffff6f}, + {0x0c, 0x92100016}, + {0x10, 0x80a62000}, + {0x14, 0x12800004}, + {0x18, 0xa0100008}, + {0x1c, 0x1080000b}, + {0x20, 0xa0102000}, + {0x24, 0x7fffff4c}, + {0x28, 0x01000000}, + {0x2c, 0x94100008}, + {0x30, 0x90100013}, + {0x34, 0x7fffff97}, + {0x38, 0x92100015}, + {0x3c, 0x80a62007}, + {0x40, 0x1880000f}, + {0x44, 0xa4100008}, + {0x48, 0x80a48011}, + {0x4c, 0x04800008}, + {0x50, 0x9a102007}, + {0x54, 0x9a102008}, + {0x58, 0x9a234018}, + {0x5c, 0x82102001}, + {0x60, 0x8328400d}, + {0x64, 0xa02c0001}, + {0x68, 0x9a102007}, + {0x6c, 0x9a234018}, + {0x70, 0x82102001}, + {0x74, 0x8328400d}, + {0x78, 0xa0140001}, + {0x7c, 0x80a62009}, + {0xf0, 0x2c}, + {0x00, 0x0280000b}, + {0x04, 0x821e2008}, + {0x08, 0x80a00001}, + {0x0c, 0x9a603fff}, + {0x10, 0x80a48011}, + {0x14, 0x14800003}, + {0x18, 0x82102001}, + {0x1c, 0x82102000}, + {0x20, 0x808b4001}, + {0x24, 0x0280000f}, + {0x28, 0x80a62008}, + {0x2c, 0xc205c000}, + {0x30, 0x80a04011}, + {0x34, 0x18800003}, + {0x38, 0x9a204011}, + {0x3c, 0x9a244001}, + {0x40, 0x80a48011}, + {0x44, 0x14800003}, + {0x48, 0x82248011}, + {0x4c, 0x82244012}, + {0x50, 0x80a34001}, + {0x54, 0xa0642000}, + {0x58, 0x10800007}, + {0x5c, 0xa4102000}, + {0x60, 0x32800006}, + {0x64, 0xe425c000}, + {0x68, 0x80a420fe}, + {0x6c, 0x24800002}, + {0x70, 0xa0042001}, + {0x74, 0xe425c000}, + {0x78, 0x92100016}, + {0x7c, 0x94100010}, + {0xf0, 0x2d}, + {0x00, 0x7fffff3d}, + {0x04, 0x90100013}, + {0x08, 0xaa056001}, + {0x0c, 0xc200247c}, + {0x10, 0x80a54001}, + {0x14, 0x0abfffb6}, + {0x18, 0xa8052010}, + {0x1c, 0xa604e001}, + {0x20, 0xc20023d4}, + {0x24, 0x80a4c001}, + {0x28, 0x0abfffac}, + {0x2c, 0xaa102000}, + {0x30, 0x81c7e008}, + {0x34, 0x81e80000}, + {0x38, 0x98102000}, + {0x3c, 0x9610201e}, + {0x40, 0x80a22000}, + {0x44, 0x12800003}, + {0x48, 0x8210000c}, + {0x4c, 0x8222c00c}, + {0x50, 0x83286002}, + {0x54, 0xda006480}, + {0x58, 0x80a37ff0}, + {0x5c, 0x02800006}, + {0x60, 0x98032002}, + {0x64, 0xc2006484}, + {0x68, 0x80a3201f}, + {0x6c, 0x04bffff5}, + {0x70, 0xc2234000}, + {0x74, 0x81c3e008}, + {0x78, 0x01000000}, + {0x7c, 0x9de3bf98}, + {0xf0, 0x2e}, + {0x00, 0xda002508}, + {0x04, 0x033fc000}, + {0x08, 0x9a0b4001}, + {0x0c, 0x173fc180}, + {0x10, 0x03202020}, + {0x14, 0x82106080}, + {0x18, 0x9812e038}, + {0x1c, 0xc2230000}, + {0x20, 0x03168000}, + {0x24, 0x80a34001}, + {0x28, 0xc022c000}, + {0x2c, 0xa6102000}, + {0x30, 0x1280000b}, + {0x34, 0xa8102000}, + {0x38, 0x0300003f}, + {0x3c, 0xda002548}, + {0x40, 0x821063ff}, + {0x44, 0x9a0b4001}, + {0x48, 0xd8002508}, + {0x4c, 0x033fffc0}, + {0x50, 0x980b0001}, + {0x54, 0x9a13400c}, + {0x58, 0xda202548}, + {0x5c, 0x80a62000}, + {0x60, 0x1680002b}, + {0x64, 0x1b296956}, + {0x68, 0x1b3fc040}, + {0x6c, 0xc2002548}, + {0x70, 0x8208400d}, + {0x74, 0x1b168040}, + {0x78, 0x80a0400d}, + {0x7c, 0x22800002}, + {0xf0, 0x2f}, + {0x00, 0xa6102001}, + {0x04, 0xda002654}, + {0x08, 0xc20021dc}, + {0x0c, 0x80a34001}, + {0x10, 0x1a80001f}, + {0x14, 0x1b296956}, + {0x18, 0x031696a9}, + {0x1c, 0xda00250c}, + {0x20, 0x821061a5}, + {0x24, 0x80a34001}, + {0x28, 0x02800006}, + {0x2c, 0x03296956}, + {0x30, 0x8210625a}, + {0x34, 0x80a34001}, + {0x38, 0x12800015}, + {0x3c, 0x1b296956}, + {0x40, 0xc200254c}, + {0x44, 0x80886004}, + {0x48, 0x32800002}, + {0x4c, 0xa8102001}, + {0x50, 0x1100001b}, + {0x54, 0x1300001c}, + {0x58, 0x901222c0}, + {0x5c, 0x40000156}, + {0x60, 0x921262b0}, + {0x64, 0x0300001e}, + {0x68, 0x96106020}, + {0x6c, 0x98102000}, + {0x70, 0x9b2b2002}, + {0x74, 0x98032001}, + {0x78, 0xc20365b0}, + {0x7c, 0x80a32017}, + {0xf0, 0x30}, + {0x00, 0x08bffffc}, + {0x04, 0xc223400b}, + {0x08, 0x1b296956}, + {0x0c, 0x80a00013}, + {0x10, 0x82380018}, + {0x14, 0xa413625a}, + {0x18, 0x92402000}, + {0x1c, 0x8330601f}, + {0x20, 0x1b1696a9}, + {0x24, 0xa21361a5}, + {0x28, 0x90104009}, + {0x2c, 0xde00254c}, + {0x30, 0xe0002548}, + {0x34, 0x98102500}, + {0x38, 0xc200250c}, + {0x3c, 0x96033a50}, + {0x40, 0x941b250c}, + {0x44, 0x80a04012}, + {0x48, 0x02800007}, + {0x4c, 0x9a184011}, + {0x50, 0x80a0000d}, + {0x54, 0x82603fff}, + {0x58, 0x80904009}, + {0x5c, 0x0280000a}, + {0x60, 0x80a22000}, + {0x64, 0x80a2e0e0}, + {0x68, 0x9a402000}, + {0x6c, 0x80a0000a}, + {0x70, 0x82603fff}, + {0x74, 0x80934001}, + {0x78, 0x3280000a}, + {0x7c, 0x98032004}, + {0xf0, 0x31}, + {0x00, 0x80a22000}, + {0x04, 0x02800005}, + {0x08, 0x82033970}, + {0x0c, 0x80a0603f}, + {0x10, 0x28800004}, + {0x14, 0x98032004}, + {0x18, 0xc0230000}, + {0x1c, 0x98032004}, + {0x20, 0x80a32867}, + {0x24, 0x28bfffe6}, + {0x28, 0xc200250c}, + {0x2c, 0x80a62000}, + {0x30, 0x06800006}, + {0x34, 0x0300003f}, + {0x38, 0x821063ff}, + {0x3c, 0x820bc001}, + {0x40, 0x10800006}, + {0x44, 0xc220254c}, + {0x48, 0xc21022d4}, + {0x4c, 0x83286010}, + {0x50, 0xc2202690}, + {0x54, 0x80a62000}, + {0x58, 0x36800008}, + {0x5c, 0xc2002548}, + {0x60, 0xc200254c}, + {0x64, 0x9a050014}, + {0x68, 0x82087ffd}, + {0x6c, 0x8210400d}, + {0x70, 0xc220254c}, + {0x74, 0xc2002548}, + {0x78, 0xd8002334}, + {0x7c, 0xda0023c8}, + {0xf0, 0x32}, + {0x00, 0x98032001}, + {0x04, 0x92087dff}, + {0x08, 0x9b336012}, + {0x0c, 0x9a0b6200}, + {0x10, 0x83332001}, + {0x14, 0x9212400d}, + {0x18, 0x113fc200}, + {0x1c, 0x82030001}, + {0x20, 0xda002344}, + {0x24, 0x96122030}, + {0x28, 0xc220258c}, + {0x2c, 0xda22c000}, + {0x30, 0x95342018}, + {0x34, 0xda20257c}, + {0x38, 0x80a2a05a}, + {0x3c, 0xd8202554}, + {0x40, 0xd8202588}, + {0x44, 0xd2202548}, + {0x48, 0x12800009}, + {0x4c, 0xda202570}, + {0x50, 0x0300003f}, + {0x54, 0x821063ff}, + {0x58, 0x1b3fffc0}, + {0x5c, 0x820a4001}, + {0x60, 0x9a0c000d}, + {0x64, 0x8210400d}, + {0x68, 0xc2202548}, + {0x6c, 0x80a4e001}, + {0x70, 0x1280000c}, + {0x74, 0x03296956}, + {0x78, 0xc2002548}, + {0x7c, 0x83306012}, + {0xf0, 0x33}, + {0x00, 0x80886001}, + {0x04, 0x32800010}, + {0x08, 0x82102029}, + {0x0c, 0x9a122074}, + {0x10, 0xc2002330}, + {0x14, 0xc2234000}, + {0x18, 0x1080000b}, + {0x1c, 0x82102029}, + {0x20, 0xda00250c}, + {0x24, 0x8210625a}, + {0x28, 0x80a34001}, + {0x2c, 0x1280000b}, + {0x30, 0x01000000}, + {0x34, 0xc200254c}, + {0x38, 0x80886002}, + {0x3c, 0x12800007}, + {0x40, 0x82102015}, + {0x44, 0xc2202500}, + {0x48, 0x7ffffe4c}, + {0x4c, 0x901025b0}, + {0x50, 0x7ffffebf}, + {0x54, 0x81e80000}, + {0x58, 0x01000000}, + {0x5c, 0x81c7e008}, + {0x60, 0x81e80000}, + {0x64, 0x9de3bf98}, + {0x68, 0x4000021a}, + {0x6c, 0x90102000}, + {0x70, 0x213fc140}, + {0x74, 0xda00247c}, + {0x78, 0x98142040}, + {0x7c, 0xfa030000}, + {0xf0, 0x34}, + {0x00, 0xc20022f8}, + {0x04, 0x9b336001}, + {0x08, 0x825b4001}, + {0x0c, 0xba0f7800}, + {0x10, 0xba174001}, + {0x14, 0xfa230000}, + {0x18, 0x82142004}, + {0x1c, 0xfa004000}, + {0x20, 0xba0f7fe0}, + {0x24, 0x393fc200}, + {0x28, 0xba17400d}, + {0x2c, 0xfa204000}, + {0x30, 0x94172080}, + {0x34, 0xfa028000}, + {0x38, 0xba0f7fe0}, + {0x3c, 0xba17400d}, + {0x40, 0x033fc0c0}, + {0x44, 0xfa228000}, + {0x48, 0xb6106004}, + {0x4c, 0xc2002298}, + {0x50, 0x9a172070}, + {0x54, 0xc2234000}, + {0x58, 0x033fc000}, + {0x5c, 0xda002338}, + {0x60, 0x82106030}, + {0x64, 0xda204000}, + {0x68, 0xc200232c}, + {0x6c, 0x9e172074}, + {0x70, 0xc223c000}, + {0x74, 0x0300003f}, + {0x78, 0xa6142058}, + {0x7c, 0x821063ff}, + {0xf0, 0x35}, + {0x00, 0x17000019}, + {0x04, 0xc224c000}, + {0x08, 0x9612e2e0}, + {0x0c, 0x92142088}, + {0x10, 0x1900001a}, + {0x14, 0xd6224000}, + {0x18, 0x981322d0}, + {0x1c, 0x9014208c}, + {0x20, 0xd8220000}, + {0x24, 0xc20023f8}, + {0x28, 0xa217200c}, + {0x2c, 0xc2244000}, + {0x30, 0xc20023fc}, + {0x34, 0x35200040}, + {0x38, 0xa4172008}, + {0x3c, 0xc2248000}, + {0x40, 0xae16a101}, + {0x44, 0xee270000}, + {0x48, 0xa814205c}, + {0x4c, 0xc0250000}, + {0x50, 0xaa142080}, + {0x54, 0xd6254000}, + {0x58, 0xac142084}, + {0x5c, 0xd8258000}, + {0x60, 0x7ffffe7b}, + {0x64, 0xc026c000}, + {0x68, 0x9a17207c}, + {0x6c, 0xfa034000}, + {0x70, 0x033ff000}, + {0x74, 0xba2f4001}, + {0x78, 0xfa234000}, + {0x7c, 0x033fc1c0}, + {0xf0, 0x36}, + {0x00, 0xda002340}, + {0x04, 0x82106064}, + {0x08, 0xda204000}, + {0x0c, 0x0300007f}, + {0x10, 0x96142010}, + {0x14, 0x821063ff}, + {0x18, 0xc222c000}, + {0x1c, 0x1907ffc0}, + {0x20, 0x94142030}, + {0x24, 0xd8228000}, + {0x28, 0xa0142014}, + {0x2c, 0xd8240000}, + {0x30, 0x7ffffdd4}, + {0x34, 0xd0002374}, + {0x38, 0x173fc080}, + {0x3c, 0xc2002174}, + {0x40, 0x90103fff}, + {0x44, 0x80a06000}, + {0x48, 0x02800006}, + {0x4c, 0x9812e008}, + {0x50, 0xc2082174}, + {0x54, 0xda082177}, + {0x58, 0xc2230000}, + {0x5c, 0xda22c000}, + {0x60, 0x7ffffee7}, + {0x64, 0x01000000}, + {0x68, 0x7ffffed4}, + {0x6c, 0x90102001}, + {0x70, 0x82103fff}, + {0x74, 0xc226c000}, + {0x78, 0xf4270000}, + {0x7c, 0x81c7e008}, + {0xf0, 0x37}, + {0x00, 0x81e80000}, + {0x04, 0x9de3bf98}, + {0x08, 0xc2002508}, + {0x0c, 0x808860ff}, + {0x10, 0x0280001c}, + {0x14, 0x01000000}, + {0x18, 0xc2002508}, + {0x1c, 0x820860ff}, + {0x20, 0x80a04018}, + {0x24, 0x213c0000}, + {0x28, 0x12800014}, + {0x2c, 0x033fc180}, + {0x30, 0x7ffffc82}, + {0x34, 0x01000000}, + {0x38, 0x1b002000}, + {0x3c, 0x033fc180}, + {0x40, 0x9a2c000d}, + {0x44, 0x82106034}, + {0x48, 0xda204000}, + {0x4c, 0x033fc040}, + {0x50, 0x8210600c}, + {0x54, 0x1100000a}, + {0x58, 0xc0204000}, + {0x5c, 0x7ffffc6e}, + {0x60, 0x90122104}, + {0x64, 0xc2002508}, + {0x68, 0x820860ff}, + {0x6c, 0x80a04018}, + {0x70, 0x10bfffee}, + {0x74, 0xa0042001}, + {0x78, 0x8210603c}, + {0x7c, 0xc0204000}, + {0xf0, 0x38}, + {0x00, 0x81c7e008}, + {0x04, 0x81e80000}, + {0x08, 0x9a102000}, + {0x0c, 0x832b6002}, + {0x10, 0x9a036001}, + {0x14, 0x80a360fb}, + {0x18, 0x08bffffd}, + {0x1c, 0xc0220001}, + {0x20, 0x81c3e008}, + {0x24, 0x01000000}, + {0x28, 0xc20022f8}, + {0x2c, 0xda00247c}, + {0x30, 0x8258400d}, + {0x34, 0x83306001}, + {0x38, 0x96102000}, + {0x3c, 0x80a2c001}, + {0x40, 0x1a80003b}, + {0x44, 0x0300003f}, + {0x48, 0x941063ff}, + {0x4c, 0x98102000}, + {0x50, 0x80a26001}, + {0x54, 0x0280002e}, + {0x58, 0x80a26004}, + {0x5c, 0x12800008}, + {0x60, 0x80a26008}, + {0x64, 0xc2030008}, + {0x68, 0x9a08400a}, + {0x6c, 0x83306012}, + {0x70, 0x83286010}, + {0x74, 0x10800014}, + {0x78, 0x9b336002}, + {0x7c, 0x28800015}, + {0xf0, 0x39}, + {0x00, 0xda02000c}, + {0x04, 0xda030008}, + {0x08, 0x83336010}, + {0x0c, 0x82004001}, + {0x10, 0x9a0b400a}, + {0x14, 0x81800000}, + {0x18, 0x01000000}, + {0x1c, 0x01000000}, + {0x20, 0x01000000}, + {0x24, 0x82704009}, + {0x28, 0x9a03400d}, + {0x2c, 0x83286010}, + {0x30, 0x81800000}, + {0x34, 0x01000000}, + {0x38, 0x01000000}, + {0x3c, 0x01000000}, + {0x40, 0x9a734009}, + {0x44, 0x8200400d}, + {0x48, 0x10800011}, + {0x4c, 0xc2230008}, + {0x50, 0x83336010}, + {0x54, 0x81800000}, + {0x58, 0x01000000}, + {0x5c, 0x01000000}, + {0x60, 0x01000000}, + {0x64, 0x82704009}, + {0x68, 0x9a0b400a}, + {0x6c, 0x83286010}, + {0x70, 0x81800000}, + {0x74, 0x01000000}, + {0x78, 0x01000000}, + {0x7c, 0x01000000}, + {0xf0, 0x3a}, + {0x00, 0x9a734009}, + {0x04, 0x8200400d}, + {0x08, 0xc222000c}, + {0x0c, 0xc20022f8}, + {0x10, 0xda00247c}, + {0x14, 0x8258400d}, + {0x18, 0x9602e001}, + {0x1c, 0x83306001}, + {0x20, 0x80a2c001}, + {0x24, 0x0abfffcb}, + {0x28, 0x98032004}, + {0x2c, 0x81c3e008}, + {0x30, 0x01000000}, + {0x34, 0x98102000}, + {0x38, 0x9b2b2002}, + {0x3c, 0x98032001}, + {0x40, 0xc202000d}, + {0x44, 0x80a320fb}, + {0x48, 0x04bffffc}, + {0x4c, 0xc222400d}, + {0x50, 0x81c3e008}, + {0x54, 0x01000000}, + {0x58, 0xd6020000}, + {0x5c, 0xd8024000}, + {0x60, 0x9132e010}, + {0x64, 0x95332010}, + {0x68, 0x900a2fff}, + {0x6c, 0x940aafff}, + {0x70, 0x03000007}, + {0x74, 0x9a22000a}, + {0x78, 0x821063ff}, + {0x7c, 0x940b0001}, + {0xf0, 0x3b}, + {0x00, 0x900ac001}, + {0x04, 0x9022000a}, + {0x08, 0x9a5b400d}, + {0x0c, 0x905a0008}, + {0x10, 0x81c3e008}, + {0x14, 0x90034008}, + {0x18, 0x9de3bf88}, + {0x1c, 0x832e6002}, + {0x20, 0x82004019}, + {0x24, 0x83286002}, + {0x28, 0x82004018}, + {0x2c, 0x3b00001d}, + {0x30, 0xba1762a0}, + {0x34, 0x83286002}, + {0x38, 0xf400401d}, + {0x3c, 0x033fc000}, + {0x40, 0x82106001}, + {0x44, 0xc227bfe8}, + {0x48, 0x03000040}, + {0x4c, 0xc227bfec}, + {0x50, 0x033fc040}, + {0x54, 0x821061fe}, + {0x58, 0xc227bff0}, + {0x5c, 0x0300bf80}, + {0x60, 0x82106101}, + {0x64, 0xc227bff4}, + {0x68, 0x9e10001d}, + {0x6c, 0xb6102000}, + {0x70, 0x9a07bff8}, + {0x74, 0xba06c00d}, + {0x78, 0xc24f7ff0}, + {0x7c, 0xb0060001}, + {0xf0, 0x3c}, + {0x00, 0xc24f7ff8}, + {0x04, 0xb2064001}, + {0x08, 0x82067fff}, + {0x0c, 0x82164001}, + {0x10, 0x80a62000}, + {0x14, 0x0480001e}, + {0x18, 0xbb30601f}, + {0x1c, 0xc2002308}, + {0x20, 0x80a04018}, + {0x24, 0x82402000}, + {0x28, 0x8090401d}, + {0x2c, 0x32800019}, + {0x30, 0xb606e001}, + {0x34, 0xc2002300}, + {0x38, 0x80a64001}, + {0x3c, 0x18800014}, + {0x40, 0xbb2e6002}, + {0x44, 0x82074019}, + {0x48, 0x83286002}, + {0x4c, 0x82004018}, + {0x50, 0x80a6e003}, + {0x54, 0x14800008}, + {0x58, 0xb9286002}, + {0x5c, 0xc207000f}, + {0x60, 0x80a0401a}, + {0x64, 0x2680000b}, + {0x68, 0xb606e001}, + {0x6c, 0x1080000d}, + {0x70, 0xb0102000}, + {0x74, 0xc207000f}, + {0x78, 0x80a0401a}, + {0x7c, 0x24800005}, + {0xf0, 0x3d}, + {0x00, 0xb606e001}, + {0x04, 0x10800007}, + {0x08, 0xb0102000}, + {0x0c, 0xb606e001}, + {0x10, 0x80a6e007}, + {0x14, 0x04bfffd9}, + {0x18, 0xba06c00d}, + {0x1c, 0xb0102001}, + {0x20, 0x81c7e008}, + {0x24, 0x81e80000}, + {0x28, 0xc020255c}, + {0x2c, 0xc0202514}, + {0x30, 0x9a102000}, + {0x34, 0x832b6002}, + {0x38, 0x9a036001}, + {0x3c, 0xc0206738}, + {0x40, 0x80a36009}, + {0x44, 0x04bffffc}, + {0x48, 0xc0206710}, + {0x4c, 0x81c3e008}, + {0x50, 0x01000000}, + {0x54, 0x9de3bf88}, + {0x58, 0x82063fff}, + {0x5c, 0xb8067fff}, + {0x60, 0x82160001}, + {0x64, 0xba16401c}, + {0x68, 0x80974001}, + {0x6c, 0xa610001a}, + {0x70, 0x0680007f}, + {0x74, 0xa410001b}, + {0x78, 0xc2002308}, + {0x7c, 0x80a60001}, + {0xf0, 0x3e}, + {0x00, 0x3880007c}, + {0x04, 0xb0102000}, + {0x08, 0xc2002300}, + {0x0c, 0x80a64001}, + {0x10, 0x38800078}, + {0x14, 0xb0102000}, + {0x18, 0x94062001}, + {0x1c, 0x96066001}, + {0x20, 0xa207bff8}, + {0x24, 0x8207bfe8}, + {0x28, 0xb0102003}, + {0x2c, 0xc0204000}, + {0x30, 0xb0863fff}, + {0x34, 0x1cbffffe}, + {0x38, 0x82006004}, + {0x3c, 0xc2002160}, + {0x40, 0x80886004}, + {0x44, 0x0280000f}, + {0x48, 0xb0102004}, + {0x4c, 0x80a66001}, + {0x50, 0x0280000b}, + {0x54, 0x821021ff}, + {0x58, 0xc2002308}, + {0x5c, 0x80a60001}, + {0x60, 0x02800007}, + {0x64, 0x821021ff}, + {0x68, 0xc2002300}, + {0x6c, 0x80a64001}, + {0x70, 0x12800005}, + {0x74, 0x80a7000b}, + {0x78, 0x821021ff}, + {0x7c, 0xc227bff4}, + {0xf0, 0x3f}, + {0x00, 0x80a7000b}, + {0x04, 0x14800033}, + {0x08, 0xb210001c}, + {0x0c, 0xba07001c}, + {0x10, 0x8202c00b}, + {0x14, 0xba07401c}, + {0x18, 0x8200400b}, + {0x1c, 0xba274001}, + {0x20, 0xb92f2002}, + {0x24, 0xb8070019}, + {0x28, 0x0300001d}, + {0x2c, 0xa01062a0}, + {0x30, 0x9827400a}, + {0x34, 0x9b2f2002}, + {0x38, 0xb002bffe}, + {0x3c, 0x82034018}, + {0x40, 0x83286002}, + {0x44, 0xba06000c}, + {0x48, 0xb4004010}, + {0x4c, 0xb6076008}, + {0x50, 0x90102001}, + {0x54, 0x932a001b}, + {0x58, 0x9e102000}, + {0x5c, 0xb92be002}, + {0x60, 0xfa072520}, + {0x64, 0xba5f4012}, + {0x68, 0x833f601f}, + {0x6c, 0x83306018}, + {0x70, 0xba074001}, + {0x74, 0xc2068000}, + {0x78, 0x82204013}, + {0x7c, 0xbb3f6008}, + {0xf0, 0x40}, + {0x00, 0x9e03e001}, + {0x04, 0x80a0401d}, + {0x08, 0x04800005}, + {0x0c, 0xb8070011}, + {0x10, 0xc2073ff0}, + {0x14, 0x82104009}, + {0x18, 0xc2273ff0}, + {0x1c, 0x80a3e003}, + {0x20, 0x08bffff0}, + {0x24, 0xb92be002}, + {0x28, 0xb0062001}, + {0x2c, 0xb606e001}, + {0x30, 0x80a6000a}, + {0x34, 0x04bfffe8}, + {0x38, 0xb406a004}, + {0x3c, 0xb2066001}, + {0x40, 0x9a036014}, + {0x44, 0x80a6400b}, + {0x48, 0x04bfffdc}, + {0x4c, 0x98032003}, + {0x50, 0xc207bfe8}, + {0x54, 0x80886010}, + {0x58, 0x0280000a}, + {0x5c, 0xfa07bfec}, + {0x60, 0xc207bff4}, + {0x64, 0x80886082}, + {0x68, 0x02800007}, + {0x6c, 0x808f6010}, + {0x70, 0x80886028}, + {0x74, 0x1280001f}, + {0x78, 0xb0102003}, + {0x7c, 0xfa07bfec}, + {0xf0, 0x41}, + {0x00, 0x808f6010}, + {0x04, 0x02800012}, + {0x08, 0xc207bff0}, + {0x0c, 0x808f6082}, + {0x10, 0x02800007}, + {0x14, 0x808f6028}, + {0x18, 0xc207bff4}, + {0x1c, 0x80886028}, + {0x20, 0x32800014}, + {0x24, 0xb0102002}, + {0x28, 0x808f6028}, + {0x2c, 0x02800008}, + {0x30, 0xc207bff0}, + {0x34, 0xc207bff4}, + {0x38, 0x80886082}, + {0x3c, 0x02800004}, + {0x40, 0xc207bff0}, + {0x44, 0x1080000b}, + {0x48, 0xb0102002}, + {0x4c, 0x80886010}, + {0x50, 0x02800008}, + {0x54, 0xb0102000}, + {0x58, 0x80886082}, + {0x5c, 0x02800005}, + {0x60, 0x80886028}, + {0x64, 0x12800003}, + {0x68, 0xb0102001}, + {0x6c, 0xb0102000}, + {0x70, 0x81c7e008}, + {0x74, 0x81e80000}, + {0x78, 0x94102000}, + {0x7c, 0xc2002514}, + {0xf0, 0x42}, + {0x00, 0x80a28001}, + {0x04, 0x96102000}, + {0x08, 0x1a80000e}, + {0x0c, 0x9b2ae002}, + {0x10, 0xc2036710}, + {0x14, 0x9602e001}, + {0x18, 0x80a06000}, + {0x1c, 0x02800006}, + {0x20, 0x992aa002}, + {0x24, 0xc2232710}, + {0x28, 0xc2036738}, + {0x2c, 0x9402a001}, + {0x30, 0xc2232738}, + {0x34, 0xc2002514}, + {0x38, 0x10bffff4}, + {0x3c, 0x80a2c001}, + {0x40, 0x81c3e008}, + {0x44, 0xd4202514}, + {0x48, 0xd4020000}, + {0x4c, 0x0300001b}, + {0x50, 0x9802800a}, + {0x54, 0x821062c0}, + {0x58, 0xda530001}, + {0x5c, 0xc2002590}, + {0x60, 0xc250400c}, + {0x64, 0x96a0400d}, + {0x68, 0x02800016}, + {0x6c, 0x0300001b}, + {0x70, 0x80a2e000}, + {0x74, 0x04800009}, + {0x78, 0x82102001}, + {0x7c, 0xda022004}, + {0xf0, 0x43}, + {0x00, 0x8328400d}, + {0x04, 0x80a2c001}, + {0x08, 0x3480000d}, + {0x0c, 0x973ac00d}, + {0x10, 0x1080000b}, + {0x14, 0x96102001}, + {0x18, 0x1680000a}, + {0x1c, 0x0300001b}, + {0x20, 0xda022008}, + {0x24, 0x82103fff}, + {0x28, 0x8328400d}, + {0x2c, 0x80a2c001}, + {0x30, 0x36800003}, + {0x34, 0x96103fff}, + {0x38, 0x973ac00d}, + {0x3c, 0x0300001b}, + {0x40, 0x921062c0}, + {0x44, 0x8202800a}, + {0x48, 0xc2504009}, + {0x4c, 0x9602c001}, + {0x50, 0x808aa001}, + {0x54, 0x0280000f}, + {0x58, 0x9b3aa01f}, + {0x5c, 0x9b33601f}, + {0x60, 0x9a02800d}, + {0x64, 0x9b3b6001}, + {0x68, 0x9b2b6002}, + {0x6c, 0xd8034009}, + {0x70, 0x033fffc0}, + {0x74, 0x980b0001}, + {0x78, 0x0300003f}, + {0x7c, 0x821063ff}, + {0xf0, 0x44}, + {0x00, 0x820ac001}, + {0x04, 0x98030001}, + {0x08, 0x1080000d}, + {0x0c, 0xd8234009}, + {0x10, 0x9b33601f}, + {0x14, 0x9a02800d}, + {0x18, 0x9b3b6001}, + {0x1c, 0x9b2b6002}, + {0x20, 0x0300003f}, + {0x24, 0xd8034009}, + {0x28, 0x821063ff}, + {0x2c, 0x980b0001}, + {0x30, 0x832ae010}, + {0x34, 0x8200400c}, + {0x38, 0xc2234009}, + {0x3c, 0xc2020000}, + {0x40, 0xda00247c}, + {0x44, 0x8200400d}, + {0x48, 0x81c3e008}, + {0x4c, 0xc2220000}, + {0x50, 0x9de3bf98}, + {0x54, 0x833e201f}, + {0x58, 0xd0002320}, + {0x5c, 0x82204018}, + {0x60, 0x80a22000}, + {0x64, 0x02800015}, + {0x68, 0x9b30601f}, + {0x6c, 0x033fc000}, + {0x70, 0xa0106020}, + {0x74, 0xc200231c}, + {0x78, 0x80a00001}, + {0x7c, 0x82402000}, + {0xf0, 0x45}, + {0x00, 0x8088400d}, + {0x04, 0xc2002318}, + {0x08, 0x02800009}, + {0x0c, 0xb01e0001}, + {0x10, 0x80a00001}, + {0x14, 0x82603fff}, + {0x18, 0x7ffffabf}, + {0x1c, 0xc2240000}, + {0x20, 0xc2002318}, + {0x24, 0x10800005}, + {0x28, 0xc2240000}, + {0x2c, 0x033fc000}, + {0x30, 0x82106020}, + {0x34, 0xf0204000}, + {0x38, 0x81c7e008}, + {0x3c, 0x81e80000}, + {0x40, 0x9de3bf98}, + {0x44, 0x7ffffabd}, + {0x48, 0x01000000}, + {0x4c, 0xe0002500}, + {0x50, 0x80a42028}, + {0x54, 0x08800013}, + {0x58, 0x80a42000}, + {0x5c, 0xc0202584}, + {0x60, 0xa2102000}, + {0x64, 0x832c6002}, + {0x68, 0xc2006f04}, + {0x6c, 0x80a06000}, + {0x70, 0x02800056}, + {0x74, 0xa2046001}, + {0x78, 0x9fc04000}, + {0x7c, 0x01000000}, + {0xf0, 0x46}, + {0x00, 0xc2002584}, + {0x04, 0x80a06000}, + {0x08, 0x12800050}, + {0x0c, 0x80a4603b}, + {0x10, 0x24bffff6}, + {0x14, 0x832c6002}, + {0x18, 0x1080004d}, + {0x1c, 0xc2002500}, + {0x20, 0x1280000d}, + {0x24, 0x80a42014}, + {0x28, 0xc2002fcc}, + {0x2c, 0x9fc04000}, + {0x30, 0x01000000}, + {0x34, 0x7ffffcf2}, + {0x38, 0x90102000}, + {0x3c, 0x7ffffcdf}, + {0x40, 0x90102001}, + {0x44, 0xc200254c}, + {0x48, 0x82087ffb}, + {0x4c, 0x1080003f}, + {0x50, 0xc220254c}, + {0x54, 0x1880000c}, + {0x58, 0x80a42015}, + {0x5c, 0x808c2001}, + {0x60, 0x3280003b}, + {0x64, 0xc2002500}, + {0x68, 0x90043ffe}, + {0x6c, 0x7ffffc74}, + {0x70, 0x91322001}, + {0x74, 0x7ffffc56}, + {0x78, 0x01000000}, + {0x7c, 0x10800034}, + {0xf0, 0x47}, + {0x00, 0xc2002500}, + {0x04, 0x18800011}, + {0x08, 0x80a42018}, + {0x0c, 0x033fc180}, + {0x10, 0xda0025b0}, + {0x14, 0x82106038}, + {0x18, 0xda204000}, + {0x1c, 0x033fc200}, + {0x20, 0x82106074}, + {0x24, 0xda00232c}, + {0x28, 0xda204000}, + {0x2c, 0x7ffffcc3}, + {0x30, 0x90102000}, + {0x34, 0xc200254c}, + {0x38, 0x82106004}, + {0x3c, 0xc220254c}, + {0x40, 0x10800020}, + {0x44, 0xc2002fcc}, + {0x48, 0x1880000c}, + {0x4c, 0x80a42028}, + {0x50, 0x90102000}, + {0x54, 0x92102000}, + {0x58, 0xc2002fc0}, + {0x5c, 0x9fc04000}, + {0x60, 0x94102000}, + {0x64, 0x1100001b}, + {0x68, 0x7ffffe08}, + {0x6c, 0x901222c0}, + {0x70, 0x10800017}, + {0x74, 0xc2002500}, + {0x78, 0x38800015}, + {0x7c, 0xc2002500}, + {0xf0, 0x48}, + {0x00, 0x7ffffbb5}, + {0x04, 0x2300001b}, + {0x08, 0x921462c0}, + {0x0c, 0xc2002fc0}, + {0x10, 0x9fc04000}, + {0x14, 0x94043fe8}, + {0x18, 0x80a42028}, + {0x1c, 0x3280000c}, + {0x20, 0xc2002500}, + {0x24, 0x901462c0}, + {0x28, 0x7ffffe00}, + {0x2c, 0x92102008}, + {0x30, 0xc2002fd8}, + {0x34, 0x80a06000}, + {0x38, 0x22800005}, + {0x3c, 0xc2002500}, + {0x40, 0x9fc04000}, + {0x44, 0x01000000}, + {0x48, 0xc2002500}, + {0x4c, 0x80a40001}, + {0x50, 0x1280000b}, + {0x54, 0x031fffff}, + {0x58, 0x821063f0}, + {0x5c, 0x80a40001}, + {0x60, 0x38800003}, + {0x64, 0x21040000}, + {0x68, 0xa0042001}, + {0x6c, 0x033fc180}, + {0x70, 0x82106034}, + {0x74, 0xe0204000}, + {0x78, 0xe0202500}, + {0x7c, 0x81c7e008}, + {0xf0, 0x49}, + {0x00, 0x81e80000}, + {0x04, 0x81c3e008}, + {0x08, 0x01000000}, + {0x0c, 0x9de3bf50}, + {0x10, 0x1b00003f}, + {0x14, 0xc2002350}, + {0x18, 0x9a1363ff}, + {0x1c, 0xae08400d}, + {0x20, 0xa6102001}, + {0x24, 0xda002300}, + {0x28, 0x80a4c00d}, + {0x2c, 0x18800062}, + {0x30, 0xa3306010}, + {0x34, 0xa4102014}, + {0x38, 0xac102000}, + {0x3c, 0xaa102000}, + {0x40, 0xa8102000}, + {0x44, 0x80a46000}, + {0x48, 0x0280002c}, + {0x4c, 0xa0102000}, + {0x50, 0x0300001d}, + {0x54, 0x961062a0}, + {0x58, 0x92102000}, + {0x5c, 0x9807bfb0}, + {0x60, 0x82050009}, + {0x64, 0xda086440}, + {0x68, 0x8204800d}, + {0x6c, 0x80a36000}, + {0x70, 0x02800008}, + {0x74, 0x83286002}, + {0x78, 0xc200400b}, + {0x7c, 0xc2230000}, + {0xf0, 0x4a}, + {0x00, 0x92026001}, + {0x04, 0x80a2600b}, + {0x08, 0x04bffff6}, + {0x0c, 0x98032004}, + {0x10, 0x7ffffa31}, + {0x14, 0x9007bfb0}, + {0x18, 0x80a5c011}, + {0x1c, 0x1480000b}, + {0x20, 0x92100017}, + {0x24, 0x832de002}, + {0x28, 0x8200401e}, + {0x2c, 0x9a007fb0}, + {0x30, 0xc2034000}, + {0x34, 0x92026001}, + {0x38, 0xa0040001}, + {0x3c, 0x80a24011}, + {0x40, 0x04bffffc}, + {0x44, 0x9a036004}, + {0x48, 0x82244017}, + {0x4c, 0x82006001}, + {0x50, 0x9b3c201f}, + {0x54, 0x81836000}, + {0x58, 0x01000000}, + {0x5c, 0x01000000}, + {0x60, 0x01000000}, + {0x64, 0xa07c0001}, + {0x68, 0xc25021ae}, + {0x6c, 0x80a40001}, + {0x70, 0x26800002}, + {0x74, 0xa0100001}, + {0x78, 0x0300001d}, + {0x7c, 0x941062a0}, + {0xf0, 0x4b}, + {0x00, 0x92102000}, + {0x04, 0x82054009}, + {0x08, 0xda086440}, + {0x0c, 0x8204800d}, + {0x10, 0x99286002}, + {0x14, 0x80a36000}, + {0x18, 0x0280001d}, + {0x1c, 0x9610000c}, + {0x20, 0x80a42000}, + {0x24, 0x2480000c}, + {0x28, 0xc202c00a}, + {0x2c, 0xc203000a}, + {0x30, 0x80a04010}, + {0x34, 0x16800007}, + {0x38, 0x98102000}, + {0x3c, 0x80a06000}, + {0x40, 0x24800006}, + {0x44, 0x98100001}, + {0x48, 0x10800005}, + {0x4c, 0x8204800d}, + {0x50, 0xc202c00a}, + {0x54, 0x98204010}, + {0x58, 0x8204800d}, + {0x5c, 0x9b286002}, + {0x60, 0xc20023c8}, + {0x64, 0x83306011}, + {0x68, 0x80886001}, + {0x6c, 0x02800005}, + {0x70, 0x92026001}, + {0x74, 0xc20ce2af}, + {0x78, 0x825b0001}, + {0x7c, 0x99386007}, + {0xf0, 0x4c}, + {0x00, 0x80a2600b}, + {0x04, 0x04bfffe0}, + {0x08, 0xd823400a}, + {0x0c, 0xac05a001}, + {0x10, 0xa805200c}, + {0x14, 0x80a5a001}, + {0x18, 0x04bfffab}, + {0x1c, 0xaa05600c}, + {0x20, 0xa604e001}, + {0x24, 0xc2002300}, + {0x28, 0x80a4c001}, + {0x2c, 0x08bfffa3}, + {0x30, 0xa404a014}, + {0x34, 0x81c7e008}, + {0x38, 0x81e80000}, + {0x3c, 0x9de3bf98}, + {0x40, 0x9e100018}, + {0x44, 0x80a66000}, + {0x48, 0x0280001b}, + {0x4c, 0xb010001a}, + {0x50, 0x031fffdf}, + {0x54, 0xb41063ff}, + {0x58, 0x82102000}, + {0x5c, 0xbb286002}, + {0x60, 0x80a62009}, + {0x64, 0xb6006001}, + {0x68, 0x12800006}, + {0x6c, 0xb810001d}, + {0x70, 0xc206401d}, + {0x74, 0x83306001}, + {0x78, 0x8208401a}, + {0x7c, 0xc226401d}, + {0xf0, 0x4d}, + {0x00, 0x80a62008}, + {0x04, 0x08800006}, + {0x08, 0xc206401c}, + {0x0c, 0xfa03c01c}, + {0x10, 0xbb376001}, + {0x14, 0x10800003}, + {0x18, 0xba0f401a}, + {0x1c, 0xfa03c01c}, + {0x20, 0x8200401d}, + {0x24, 0xc226401c}, + {0x28, 0x80a6e0fb}, + {0x2c, 0x08bfffec}, + {0x30, 0x8210001b}, + {0x34, 0x81c7e008}, + {0x38, 0x81e80000}, + {0x3c, 0x03169696}, + {0x40, 0xda002180}, + {0x44, 0x8210625a}, + {0x48, 0x80a34001}, + {0x4c, 0x94102000}, + {0x50, 0x12800006}, + {0x54, 0x96102000}, + {0x58, 0x033fc180}, + {0x5c, 0x82106030}, + {0x60, 0x10800024}, + {0x64, 0xda204000}, + {0x68, 0xc202c000}, + {0x6c, 0x9602e004}, + {0x70, 0x80a2e4ff}, + {0x74, 0x08bffffd}, + {0x78, 0x94028001}, + {0x7c, 0x96102d00}, + {0xf0, 0x4e}, + {0x00, 0xd2002ff8}, + {0x04, 0x03000019}, + {0x08, 0x80a2c009}, + {0x0c, 0x1a80000b}, + {0x10, 0x901063ff}, + {0x14, 0xd802c000}, + {0x18, 0x9602e004}, + {0x1c, 0x80a2c009}, + {0x20, 0x9a402000}, + {0x24, 0x80a2000b}, + {0x28, 0x82603fff}, + {0x2c, 0x808b4001}, + {0x30, 0x12bffff9}, + {0x34, 0x9402800c}, + {0x38, 0xc20021fc}, + {0x3c, 0x94228001}, + {0x40, 0xc2002200}, + {0x44, 0x94228001}, + {0x48, 0x03169696}, + {0x4c, 0x8210625a}, + {0x50, 0x80a28001}, + {0x54, 0x033fc180}, + {0x58, 0x82106030}, + {0x5c, 0x02800005}, + {0x60, 0xd4204000}, + {0x64, 0x03000008}, + {0x68, 0x81c06250}, + {0x6c, 0x90102001}, + {0x70, 0x01000000}, + {0x74, 0x81c3e008}, + {0x78, 0x01000000}, + {0x7c, 0x9de3bf98}, + {0xf0, 0x4f}, + {0x00, 0x9e100018}, + {0x04, 0x0300001d}, + {0x08, 0xb0100019}, + {0x0c, 0xba1062a0}, + {0x10, 0xb6102000}, + {0x14, 0x832ee002}, + {0x18, 0xb606e001}, + {0x1c, 0x80a6e257}, + {0x20, 0x08bffffd}, + {0x24, 0xc020401d}, + {0x28, 0xb6102000}, + {0x2c, 0xc20022fc}, + {0x30, 0x80a6c001}, + {0x34, 0x1a80001c}, + {0x38, 0x0300001d}, + {0x3c, 0xb21062f4}, + {0x40, 0xb4102000}, + {0x44, 0xc20022f8}, + {0x48, 0x80a68001}, + {0x4c, 0x1a800011}, + {0x50, 0x832ee002}, + {0x54, 0xb8004019}, + {0x58, 0xc200247c}, + {0x5c, 0xfa0ee380}, + {0x60, 0x825e8001}, + {0x64, 0x8200401d}, + {0x68, 0x82004001}, + {0x6c, 0xfa160001}, + {0x70, 0xc213c001}, + {0x74, 0x8220401d}, + {0x78, 0xc2270000}, + {0x7c, 0xb406a001}, + {0xf0, 0x50}, + {0x00, 0xc20022f8}, + {0x04, 0x80a68001}, + {0x08, 0x0abffff4}, + {0x0c, 0xb8072050}, + {0x10, 0xb606e001}, + {0x14, 0xc20022fc}, + {0x18, 0x80a6c001}, + {0x1c, 0x0abfffea}, + {0x20, 0xb4102000}, + {0x24, 0x81c7e008}, + {0x28, 0x81e80000}, + {0x2c, 0x9de3bf98}, + {0x30, 0x1100001b}, + {0x34, 0xc2002fe4}, + {0x38, 0x9fc04000}, + {0x3c, 0x901222c0}, + {0x40, 0xc200259c}, + {0x44, 0xd800254c}, + {0x48, 0x808b2002}, + {0x4c, 0x02800034}, + {0x50, 0xc2202550}, + {0x54, 0xda002654}, + {0x58, 0x8203400d}, + {0x5c, 0x8200400d}, + {0x60, 0xda00259c}, + {0x64, 0xb20363f0}, + {0x68, 0x82004001}, + {0x6c, 0x9a102061}, + {0x70, 0x9a234001}, + {0x74, 0x832e6007}, + {0x78, 0x9738601f}, + {0x7c, 0x8182e000}, + {0xf0, 0x51}, + {0x00, 0x01000000}, + {0x04, 0x01000000}, + {0x08, 0x01000000}, + {0x0c, 0xb278400d}, + {0x10, 0x980b3ffd}, + {0x14, 0x1100001c}, + {0x18, 0xd820254c}, + {0x1c, 0xc2002fe4}, + {0x20, 0x9fc04000}, + {0x24, 0x901222b0}, + {0x28, 0x11000018}, + {0x2c, 0xe000259c}, + {0x30, 0xc2002fe4}, + {0x34, 0x9fc04000}, + {0x38, 0x901222f0}, + {0x3c, 0x80a64010}, + {0x40, 0x9a603fff}, + {0x44, 0xc200259c}, + {0x48, 0x80a64001}, + {0x4c, 0x82603fff}, + {0x50, 0x80934001}, + {0x54, 0x22800012}, + {0x58, 0xc020250c}, + {0x5c, 0x2100001e}, + {0x60, 0x7ffffa86}, + {0x64, 0x90142020}, + {0x68, 0xa0142020}, + {0x6c, 0xb2102000}, + {0x70, 0x9b2e6002}, + {0x74, 0xb2066001}, + {0x78, 0xc2034010}, + {0x7c, 0x80a66017}, + {0xf0, 0x52}, + {0x00, 0x04bffffc}, + {0x04, 0xc22365b0}, + {0x08, 0x7ffffaf1}, + {0x0c, 0x01000000}, + {0x10, 0x82102015}, + {0x14, 0x10800010}, + {0x18, 0xc2202500}, + {0x1c, 0xc200250c}, + {0x20, 0x80a06000}, + {0x24, 0x1280000c}, + {0x28, 0x031696a9}, + {0x2c, 0x821061a5}, + {0x30, 0x3100001b}, + {0x34, 0x33000018}, + {0x38, 0xc220250c}, + {0x3c, 0xc0202658}, + {0x40, 0xc0202654}, + {0x44, 0xb01622c0}, + {0x48, 0xb21662f0}, + {0x4c, 0x7ffffcfa}, + {0x50, 0x81e80000}, + {0x54, 0x01000000}, + {0x58, 0x81c7e008}, + {0x5c, 0x81e80000}, + {0x60, 0x9de3bf28}, + {0x64, 0xc2102548}, + {0x68, 0x80886001}, + {0x6c, 0x94100018}, + {0x70, 0x9a102000}, + {0x74, 0x96102000}, + {0x78, 0x02800004}, + {0x7c, 0x98102000}, + {0xf0, 0x53}, + {0x00, 0xc020259c}, + {0x04, 0x3080002e}, + {0x08, 0x9e102000}, + {0x0c, 0x8203000f}, + {0x10, 0xf6086441}, + {0x14, 0x80a6e000}, + {0x18, 0x02800024}, + {0x1c, 0xf4086440}, + {0x20, 0xc208217d}, + {0x24, 0x80807fff}, + {0x28, 0xf40ea37f}, + {0x2c, 0xf60ee37f}, + {0x30, 0x0c80001a}, + {0x34, 0xb2102000}, + {0x38, 0xb007bff8}, + {0x3c, 0xc200247c}, + {0x40, 0x82584019}, + {0x44, 0xba06c001}, + {0x48, 0x82068001}, + {0x4c, 0x82004001}, + {0x50, 0xf8528001}, + {0x54, 0xba07401d}, + {0x58, 0xc252801d}, + {0x5c, 0xb8270001}, + {0x60, 0x80a66000}, + {0x64, 0x02800007}, + {0x68, 0xf8263f90}, + {0x6c, 0xc2063f8c}, + {0x70, 0x82a70001}, + {0x74, 0x2c800003}, + {0x78, 0x9a234001}, + {0x7c, 0x9a034001}, + {0xf0, 0x54}, + {0x00, 0xc208217d}, + {0x04, 0xb2066001}, + {0x08, 0x82007fff}, + {0x0c, 0x80a64001}, + {0x10, 0x04bfffeb}, + {0x14, 0xb0062004}, + {0x18, 0x9e03e001}, + {0x1c, 0x80a3e00a}, + {0x20, 0x04bfffdc}, + {0x24, 0x8203000f}, + {0x28, 0x9602e001}, + {0x2c, 0x80a2e001}, + {0x30, 0x04bfffd6}, + {0x34, 0x9803200c}, + {0x38, 0xda20259c}, + {0x3c, 0x81c7e008}, + {0x40, 0x81e80000}, + {0x44, 0x9de3bf98}, + {0x48, 0xc2002304}, + {0x4c, 0x80a06000}, + {0x50, 0x02800022}, + {0x54, 0x01000000}, + {0x58, 0xf80021d8}, + {0x5c, 0x80a72000}, + {0x60, 0x0280001e}, + {0x64, 0x832e6002}, + {0x68, 0x82004019}, + {0x6c, 0x83286002}, + {0x70, 0x82004018}, + {0x74, 0xb1286002}, + {0x78, 0x3b00001d}, + {0x7c, 0xc2002300}, + {0xf0, 0x55}, + {0x00, 0xb617633c}, + {0x04, 0xb4176340}, + {0x08, 0x9e176344}, + {0x0c, 0x80a64001}, + {0x10, 0x12800012}, + {0x14, 0x9a1762a0}, + {0x18, 0xc206001a}, + {0x1c, 0xfa06001b}, + {0x20, 0xba074001}, + {0x24, 0xc206000f}, + {0x28, 0xba074001}, + {0x2c, 0xba5f401c}, + {0x30, 0x833f601f}, + {0x34, 0x83306019}, + {0x38, 0xba074001}, + {0x3c, 0xc206000d}, + {0x40, 0xbb3f6007}, + {0x44, 0x80a0401d}, + {0x48, 0x16800004}, + {0x4c, 0x82102001}, + {0x50, 0xc220259c}, + {0x54, 0x30800002}, + {0x58, 0xc020259c}, + {0x5c, 0x81c7e008}, + {0x60, 0x81e80000}, + {0x64, 0x9de3bf98}, + {0x68, 0xc2002548}, + {0x6c, 0x8330600d}, + {0x70, 0x80886001}, + {0x74, 0x1280001b}, + {0x78, 0x01000000}, + {0x7c, 0xc2002540}, + {0xf0, 0x56}, + {0x00, 0x82006001}, + {0x04, 0xc2202540}, + {0x08, 0xc2002588}, + {0x0c, 0x80a06000}, + {0x10, 0x02800014}, + {0x14, 0x1100001c}, + {0x18, 0xc2002594}, + {0x1c, 0x80a06000}, + {0x20, 0x12800004}, + {0x24, 0x901222b0}, + {0x28, 0x7ffffc38}, + {0x2c, 0x01000000}, + {0x30, 0xda002588}, + {0x34, 0xc2002594}, + {0x38, 0x82006001}, + {0x3c, 0x9a037fff}, + {0x40, 0xc2202594}, + {0x44, 0x7ffff9e4}, + {0x48, 0xda202588}, + {0x4c, 0x1300001c}, + {0x50, 0x921262b0}, + {0x54, 0xc2002fc0}, + {0x58, 0x9fc04000}, + {0x5c, 0xd4002594}, + {0x60, 0x01000000}, + {0x64, 0x81c7e008}, + {0x68, 0x81e80000}, + {0x6c, 0xc2002588}, + {0x70, 0x80a06001}, + {0x74, 0x1280001a}, + {0x78, 0xda002298}, + {0x7c, 0xc2102548}, + {0xf0, 0x57}, + {0x00, 0x80886001}, + {0x04, 0x22800009}, + {0x08, 0xc2002208}, + {0x0c, 0xc2002170}, + {0x10, 0x80a06000}, + {0x14, 0x22800005}, + {0x18, 0xc2002208}, + {0x1c, 0xc0202598}, + {0x20, 0x1080000f}, + {0x24, 0x9a100001}, + {0x28, 0x80a06000}, + {0x2c, 0x22800009}, + {0x30, 0xc2002598}, + {0x34, 0xc2002558}, + {0x38, 0x80a06000}, + {0x3c, 0x32800005}, + {0x40, 0xc2002598}, + {0x44, 0xc0202598}, + {0x48, 0x10800005}, + {0x4c, 0xda002234}, + {0x50, 0x80a06000}, + {0x54, 0x22800002}, + {0x58, 0xda00233c}, + {0x5c, 0x033fc200}, + {0x60, 0x82106070}, + {0x64, 0x81c3e008}, + {0x68, 0xda204000}, + {0x6c, 0x9de3bf98}, + {0x70, 0xc2002588}, + {0x74, 0x80a06000}, + {0x78, 0x02800010}, + {0x7c, 0x1100001c}, + {0xf0, 0x58}, + {0x00, 0xd8002548}, + {0x04, 0x83332010}, + {0x08, 0x80886001}, + {0x0c, 0x22800010}, + {0x10, 0xc200258c}, + {0x14, 0xc2002558}, + {0x18, 0x80a06000}, + {0x1c, 0x3280000c}, + {0x20, 0xc200258c}, + {0x24, 0xc2002594}, + {0x28, 0x80a06001}, + {0x2c, 0x32800008}, + {0x30, 0xc200258c}, + {0x34, 0x1100001c}, + {0x38, 0x901222b0}, + {0x3c, 0xd0202590}, + {0x40, 0xc0202588}, + {0x44, 0x1080001a}, + {0x48, 0xd2002594}, + {0x4c, 0x80a06000}, + {0x50, 0x12800015}, + {0x54, 0x82102001}, + {0x58, 0xda002554}, + {0x5c, 0xc2002598}, + {0x60, 0x80a0400d}, + {0x64, 0x1a800007}, + {0x68, 0x03000018}, + {0x6c, 0x82102001}, + {0x70, 0xda20258c}, + {0x74, 0xc2202584}, + {0x78, 0x1080002b}, + {0x7c, 0xc0202598}, + {0xf0, 0x59}, + {0x00, 0x808b2400}, + {0x04, 0x12800004}, + {0x08, 0x821062f0}, + {0x0c, 0x03000017}, + {0x10, 0x82106300}, + {0x14, 0xc2202590}, + {0x18, 0xd2002598}, + {0x1c, 0x10800004}, + {0x20, 0xd0002590}, + {0x24, 0x10800020}, + {0x28, 0xc2202584}, + {0x2c, 0x7ffffbdf}, + {0x30, 0x01000000}, + {0x34, 0x1300001b}, + {0x38, 0xc2002fd0}, + {0x3c, 0x921262c0}, + {0x40, 0x9fc04000}, + {0x44, 0xd0002590}, + {0x48, 0xc2002690}, + {0x4c, 0x82087dff}, + {0x50, 0xc2202690}, + {0x54, 0x82102080}, + {0x58, 0xc220256c}, + {0x5c, 0xc2002200}, + {0x60, 0x80a06000}, + {0x64, 0x32800008}, + {0x68, 0xc2002548}, + {0x6c, 0xda002548}, + {0x70, 0x83336010}, + {0x74, 0x80886001}, + {0x78, 0x22800006}, + {0x7c, 0x03000004}, + {0xf0, 0x5a}, + {0x00, 0xc2002548}, + {0x04, 0x1b000004}, + {0x08, 0x10800003}, + {0x0c, 0x8210400d}, + {0x10, 0x822b4001}, + {0x14, 0xc2202548}, + {0x18, 0xc2002548}, + {0x1c, 0x82087fbf}, + {0x20, 0xc2202548}, + {0x24, 0x81c7e008}, + {0x28, 0x81e80000}, + {0x2c, 0xda002508}, + {0x30, 0x033fc000}, + {0x34, 0x960b4001}, + {0x38, 0x808b7f00}, + {0x3c, 0x0280001a}, + {0x40, 0x901020a5}, + {0x44, 0x1500003f}, + {0x48, 0x8212a300}, + {0x4c, 0x980b4001}, + {0x50, 0x03294000}, + {0x54, 0x80a2c001}, + {0x58, 0x02800013}, + {0x5c, 0x01000000}, + {0x60, 0xc200254c}, + {0x64, 0x8210400c}, + {0x68, 0xc220254c}, + {0x6c, 0xc2002500}, + {0x70, 0x80a06028}, + {0x74, 0xc0202508}, + {0x78, 0x0880000b}, + {0x7c, 0x033fffc0}, + {0xf0, 0x5b}, + {0x00, 0x9a0b4001}, + {0x04, 0x03168000}, + {0x08, 0x80a2c001}, + {0x0c, 0x12800006}, + {0x10, 0x9812a3ff}, + {0x14, 0xc2002548}, + {0x18, 0x8208400c}, + {0x1c, 0x8210400d}, + {0x20, 0xc2202548}, + {0x24, 0x03000006}, + {0x28, 0x81c06384}, + {0x2c, 0x01000000}, + {0x30, 0x01000000}, + {0x34, 0xda00247c}, + {0x38, 0xc20022f8}, + {0x3c, 0x8258400d}, + {0x40, 0x83306001}, + {0x44, 0x9a102000}, + {0x48, 0x80a34001}, + {0x4c, 0x1a800015}, + {0x50, 0x031fffdf}, + {0x54, 0x961063ff}, + {0x58, 0x98036001}, + {0x5c, 0x80a26008}, + {0x60, 0x04800006}, + {0x64, 0x9b2b6002}, + {0x68, 0xc202000d}, + {0x6c, 0x83306001}, + {0x70, 0x10800003}, + {0x74, 0x8208400b}, + {0x78, 0xc202000d}, + {0x7c, 0x82584009}, + {0xf0, 0x5c}, + {0x00, 0xc222000d}, + {0x04, 0xda00247c}, + {0x08, 0xc20022f8}, + {0x0c, 0x8258400d}, + {0x10, 0x83306001}, + {0x14, 0x80a30001}, + {0x18, 0x0abffff0}, + {0x1c, 0x9a10000c}, + {0x20, 0x81c3e008}, + {0x24, 0x01000000}, + {0x28, 0x9de3bf98}, + {0x2c, 0xc2102548}, + {0x30, 0x80886001}, + {0x34, 0x12800068}, + {0x38, 0x01000000}, + {0x3c, 0xe6002460}, + {0x40, 0x80a4e000}, + {0x44, 0x02800064}, + {0x48, 0x01000000}, + {0x4c, 0xc2002588}, + {0x50, 0xda002594}, + {0x54, 0x9800400d}, + {0x58, 0xc2002554}, + {0x5c, 0x80a30001}, + {0x60, 0x1280005d}, + {0x64, 0x01000000}, + {0x68, 0xda002598}, + {0x6c, 0xc200258c}, + {0x70, 0x8200400d}, + {0x74, 0x80a0400c}, + {0x78, 0x02800004}, + {0x7c, 0x80a36000}, + {0xf0, 0x5d}, + {0x00, 0x12800055}, + {0x04, 0x01000000}, + {0x08, 0xe208217e}, + {0x0c, 0x808c60ff}, + {0x10, 0x9e102000}, + {0x14, 0x0280002e}, + {0x18, 0x96102001}, + {0x1c, 0xe408217f}, + {0x20, 0x1300001d}, + {0x24, 0x94102001}, + {0x28, 0x80a28012}, + {0x2c, 0x14800020}, + {0x30, 0xa0102000}, + {0x34, 0x832ae002}, + {0x38, 0x98006050}, + {0x3c, 0xac1262a0}, + {0x40, 0xaa126250}, + {0x44, 0xa81262f0}, + {0x48, 0xd008217f}, + {0x4c, 0xda030016}, + {0x50, 0x80a34013}, + {0x54, 0x26800013}, + {0x58, 0x9402a001}, + {0x5c, 0x80a2a001}, + {0x60, 0x22800007}, + {0x64, 0xc208217f}, + {0x68, 0xc2030015}, + {0x6c, 0x80a34001}, + {0x70, 0x2480000c}, + {0x74, 0x9402a001}, + {0x78, 0xc208217f}, + {0x7c, 0x80a28001}, + {0xf0, 0x5e}, + {0x00, 0x22800007}, + {0x04, 0xa0042001}, + {0x08, 0xc2030014}, + {0x0c, 0x80a34001}, + {0x10, 0x26800004}, + {0x14, 0x9402a001}, + {0x18, 0xa0042001}, + {0x1c, 0x9402a001}, + {0x20, 0x80a28008}, + {0x24, 0x04bfffea}, + {0x28, 0x98032050}, + {0x2c, 0x80a4000f}, + {0x30, 0x34800002}, + {0x34, 0x9e100010}, + {0x38, 0x9602e001}, + {0x3c, 0x820c60ff}, + {0x40, 0x80a2c001}, + {0x44, 0x24bfffd9}, + {0x48, 0x94102001}, + {0x4c, 0x96102000}, + {0x50, 0xc20ae464}, + {0x54, 0x80a06000}, + {0x58, 0x22800006}, + {0x5c, 0x9602e001}, + {0x60, 0x80a3c001}, + {0x64, 0x34800007}, + {0x68, 0xc20ae278}, + {0x6c, 0x9602e001}, + {0x70, 0x80a2e003}, + {0x74, 0x24bffff8}, + {0x78, 0xc20ae464}, + {0x7c, 0x30800016}, + {0xf0, 0x5f}, + {0x00, 0xda00256c}, + {0x04, 0x8258400d}, + {0x08, 0x83306007}, + {0x0c, 0xc220256c}, + {0x10, 0xe00ae468}, + {0x14, 0x80a42000}, + {0x18, 0x0280000f}, + {0x1c, 0x82102001}, + {0x20, 0xc2202584}, + {0x24, 0xd0002590}, + {0x28, 0x7fffff83}, + {0x2c, 0xd2002554}, + {0x30, 0xc2002588}, + {0x34, 0x82004010}, + {0x38, 0xc2202588}, + {0x3c, 0xda00258c}, + {0x40, 0xc2002554}, + {0x44, 0x80a34001}, + {0x48, 0x18800003}, + {0x4c, 0x82034010}, + {0x50, 0xc220258c}, + {0x54, 0x81c7e008}, + {0x58, 0x81e80000}, + {0x5c, 0x9de3bf98}, + {0x60, 0xc2002588}, + {0x64, 0x80a06000}, + {0x68, 0x12800060}, + {0x6c, 0x01000000}, + {0x70, 0xc20026f4}, + {0x74, 0x82006001}, + {0x78, 0xda002310}, + {0x7c, 0x80a0400d}, + {0xf0, 0x60}, + {0x00, 0x0a80005a}, + {0x04, 0xc22026f4}, + {0x08, 0xd800227c}, + {0x0c, 0x80a32000}, + {0x10, 0x02800032}, + {0x14, 0xc02026f4}, + {0x18, 0xda0022f8}, + {0x1c, 0xc200247c}, + {0x20, 0x965b4001}, + {0x24, 0x03000007}, + {0x28, 0x821063ff}, + {0x2c, 0x9b33200d}, + {0x30, 0xa2102000}, + {0x34, 0x920b4001}, + {0x38, 0x80a4400b}, + {0x3c, 0x900b0001}, + {0x40, 0x94102000}, + {0x44, 0x1a800015}, + {0x48, 0xa0102000}, + {0x4c, 0x0300001c}, + {0x50, 0xa41062b0}, + {0x54, 0x82007c00}, + {0x58, 0x9e1062c0}, + {0x5c, 0x9a040010}, + {0x60, 0xc2134012}, + {0x64, 0x80a24001}, + {0x68, 0xa2400011}, + {0x6c, 0xc253400f}, + {0x70, 0x80a04008}, + {0x74, 0x0a800005}, + {0x78, 0xa0042001}, + {0x7c, 0x80a04009}, + {0xf0, 0x61}, + {0x00, 0x08800004}, + {0x04, 0x80a4000b}, + {0x08, 0x9402a001}, + {0x0c, 0x80a4000b}, + {0x10, 0x0abffff4}, + {0x14, 0x9a040010}, + {0x18, 0xa133201a}, + {0x1c, 0x80a44010}, + {0x20, 0x14800003}, + {0x24, 0x9a102001}, + {0x28, 0x9a102000}, + {0x2c, 0x80a28010}, + {0x30, 0x14800003}, + {0x34, 0x82102001}, + {0x38, 0x82102000}, + {0x3c, 0x80934001}, + {0x40, 0x22800007}, + {0x44, 0xc2002274}, + {0x48, 0x033fc180}, + {0x4c, 0x1b008000}, + {0x50, 0x8210603c}, + {0x54, 0xda204000}, + {0x58, 0xc2002274}, + {0x5c, 0x80a06000}, + {0x60, 0x02800022}, + {0x64, 0xa2102000}, + {0x68, 0xc20023d4}, + {0x6c, 0x80a44001}, + {0x70, 0xa4102000}, + {0x74, 0x1a800016}, + {0x78, 0xa0102000}, + {0x7c, 0xc200247c}, + {0xf0, 0x62}, + {0x00, 0x80a40001}, + {0x04, 0x3a80000f}, + {0x08, 0xa404a001}, + {0x0c, 0x7ffff8fc}, + {0x10, 0x90100010}, + {0x14, 0x92100008}, + {0x18, 0x7ffff88b}, + {0x1c, 0x90100012}, + {0x20, 0x0300003f}, + {0x24, 0xda002274}, + {0x28, 0x821063ff}, + {0x2c, 0x9a0b4001}, + {0x30, 0x80a2000d}, + {0x34, 0xa2400011}, + {0x38, 0x10bffff1}, + {0x3c, 0xa0042001}, + {0x40, 0xc20023d4}, + {0x44, 0x10bfffec}, + {0x48, 0x80a48001}, + {0x4c, 0xc2102274}, + {0x50, 0x80a44001}, + {0x54, 0x08800005}, + {0x58, 0x033fc180}, + {0x5c, 0x1b004000}, + {0x60, 0x8210603c}, + {0x64, 0xda204000}, + {0x68, 0x81c7e008}, + {0x6c, 0x81e80000}, + {0x70, 0x9de3bf98}, + {0x74, 0xc2102548}, + {0x78, 0x80886001}, + {0x7c, 0x12800053}, + {0xf0, 0x63}, + {0x00, 0x01000000}, + {0x04, 0xda002310}, + {0x08, 0x80a36000}, + {0x0c, 0x0280004f}, + {0x10, 0x01000000}, + {0x14, 0xc200254c}, + {0x18, 0x80886100}, + {0x1c, 0x1280004b}, + {0x20, 0x01000000}, + {0x24, 0xc20026f0}, + {0x28, 0x82006001}, + {0x2c, 0x80a0400d}, + {0x30, 0x0a800046}, + {0x34, 0xc22026f0}, + {0x38, 0xa4102000}, + {0x3c, 0xc20023d4}, + {0x40, 0x80a48001}, + {0x44, 0xc02026f0}, + {0x48, 0xa2102000}, + {0x4c, 0x1a800027}, + {0x50, 0xa72c6002}, + {0x54, 0xc204e364}, + {0x58, 0x80a06000}, + {0x5c, 0x0280001f}, + {0x60, 0xa0102000}, + {0x64, 0xc208217e}, + {0x68, 0x80a40001}, + {0x6c, 0x1680001b}, + {0x70, 0x1500001c}, + {0x74, 0xc2002548}, + {0x78, 0x80886020}, + {0x7c, 0xc20c2380}, + {0xf0, 0x64}, + {0x00, 0x9412a2b0}, + {0x04, 0x90100011}, + {0x08, 0x12800006}, + {0x0c, 0x920860ff}, + {0x10, 0x1500001b}, + {0x14, 0x920860ff}, + {0x18, 0x9412a2c0}, + {0x1c, 0x90100011}, + {0x20, 0x7ffff87c}, + {0x24, 0xa0042001}, + {0x28, 0xc204e364}, + {0x2c, 0xda002348}, + {0x30, 0x98020001}, + {0x34, 0x82034001}, + {0x38, 0x80a20001}, + {0x3c, 0x38bfffea}, + {0x40, 0xa404a001}, + {0x44, 0x80a3000d}, + {0x48, 0x3abfffe8}, + {0x4c, 0xc208217e}, + {0x50, 0x10bfffe5}, + {0x54, 0xa404a001}, + {0x58, 0xa2046001}, + {0x5c, 0xc20023d4}, + {0x60, 0x10bfffdb}, + {0x64, 0x80a44001}, + {0x68, 0xd80026ec}, + {0x6c, 0x80930012}, + {0x70, 0x1280000a}, + {0x74, 0x80a4a000}, + {0x78, 0xda002548}, + {0x7c, 0x83336005}, + {0xf0, 0x65}, + {0x00, 0x82086001}, + {0x04, 0x82186001}, + {0x08, 0x83286005}, + {0x0c, 0x9a0b7fdf}, + {0x10, 0x9a134001}, + {0x14, 0xda202548}, + {0x18, 0x12800004}, + {0x1c, 0x82032001}, + {0x20, 0x10800003}, + {0x24, 0xc02026ec}, + {0x28, 0xc22026ec}, + {0x2c, 0xc20026ec}, + {0x30, 0x80a06002}, + {0x34, 0x04800005}, + {0x38, 0x1b000040}, + {0x3c, 0xc200254c}, + {0x40, 0x8210400d}, + {0x44, 0xc220254c}, + {0x48, 0x81c7e008}, + {0x4c, 0x81e80000}, + {0x50, 0x9de3bf58}, + {0x54, 0xc2002548}, + {0x58, 0x8330600c}, + {0x5c, 0x80886001}, + {0x60, 0x1280006d}, + {0x64, 0x01000000}, + {0x68, 0xfa002500}, + {0x6c, 0xc20021f4}, + {0x70, 0x80a74001}, + {0x74, 0x18800068}, + {0x78, 0x01000000}, + {0x7c, 0xc200254c}, + {0xf0, 0x66}, + {0x00, 0x8330600b}, + {0x04, 0x82086001}, + {0x08, 0x80a00001}, + {0x0c, 0x9a603fff}, + {0x10, 0x9403400d}, + {0x14, 0xc252a210}, + {0x18, 0x80a06000}, + {0x1c, 0x0280005e}, + {0x20, 0x8207bfb8}, + {0x24, 0xb810200f}, + {0x28, 0xc0204000}, + {0x2c, 0xb8873fff}, + {0x30, 0x1cbffffe}, + {0x34, 0x82006004}, + {0x38, 0xb0102001}, + {0x3c, 0xc2002300}, + {0x40, 0x80a60001}, + {0x44, 0x1880003b}, + {0x48, 0x0300001d}, + {0x4c, 0x821062a0}, + {0x50, 0x96006050}, + {0x54, 0xb4102001}, + {0x58, 0xc2002308}, + {0x5c, 0x80a68001}, + {0x60, 0x38800030}, + {0x64, 0xb0062001}, + {0x68, 0xb202e004}, + {0x6c, 0xfa52a210}, + {0x70, 0xc2064000}, + {0x74, 0x80a0401d}, + {0x78, 0x36800025}, + {0x7c, 0xb406a001}, + {0xf0, 0x67}, + {0x00, 0x832ea018}, + {0x04, 0xbb2e2010}, + {0x08, 0x8200401d}, + {0x0c, 0x9e006001}, + {0x10, 0xb8102000}, + {0x14, 0x98102001}, + {0x18, 0xb607bfb8}, + {0x1c, 0xbb2f2002}, + {0x20, 0xc20f6828}, + {0x24, 0x80a68001}, + {0x28, 0x1280000f}, + {0x2c, 0xb8072001}, + {0x30, 0xc20f6829}, + {0x34, 0x80a60001}, + {0x38, 0x3280000c}, + {0x3c, 0xc2176828}, + {0x40, 0xd826c000}, + {0x44, 0xc217682a}, + {0x48, 0x80a061fe}, + {0x4c, 0x38800010}, + {0x50, 0xb406a001}, + {0x54, 0xc2076828}, + {0x58, 0x82006001}, + {0x5c, 0x1080000b}, + {0x60, 0xc2276828}, + {0x64, 0xc2176828}, + {0x68, 0x80a06000}, + {0x6c, 0x12800005}, + {0x70, 0x80a7200f}, + {0x74, 0xd826c000}, + {0x78, 0x10800004}, + {0x7c, 0xde276828}, + {0xf0, 0x68}, + {0x00, 0x08bfffe7}, + {0x04, 0xb606e004}, + {0x08, 0xb406a001}, + {0x0c, 0xc2002308}, + {0x10, 0x80a68001}, + {0x14, 0x08bfffd6}, + {0x18, 0xb2066004}, + {0x1c, 0xb0062001}, + {0x20, 0xc2002300}, + {0x24, 0x80a60001}, + {0x28, 0x08bfffcb}, + {0x2c, 0x9602e050}, + {0x30, 0xb4102000}, + {0x34, 0xb8102000}, + {0x38, 0xb607bff8}, + {0x3c, 0xbb2f2002}, + {0x40, 0x8207401b}, + {0x44, 0xc2007fc0}, + {0x48, 0x80a06000}, + {0x4c, 0x32800004}, + {0x50, 0xfa17682a}, + {0x54, 0x10800005}, + {0x58, 0xc0276828}, + {0x5c, 0xc20b63cc}, + {0x60, 0x80a74001}, + {0x64, 0xb466bfff}, + {0x68, 0xb8072001}, + {0x6c, 0x80a7200f}, + {0x70, 0x08bffff4}, + {0x74, 0xbb2f2002}, + {0x78, 0xc20b63ce}, + {0x7c, 0x80a68001}, + {0xf0, 0x69}, + {0x00, 0x08800005}, + {0x04, 0x3b000200}, + {0x08, 0xc200254c}, + {0x0c, 0x8210401d}, + {0x10, 0xc220254c}, + {0x14, 0x81c7e008}, + {0x18, 0x81e80000}, + {0x1c, 0x9de3bf98}, + {0x20, 0xd8002200}, + {0x24, 0x80a32000}, + {0x28, 0x1280000a}, + {0x2c, 0x0300001d}, + {0x30, 0xc2002548}, + {0x34, 0x82087ffb}, + {0x38, 0xc2202548}, + {0x3c, 0x033fc180}, + {0x40, 0x8210602c}, + {0x44, 0xc0204000}, + {0x48, 0x1080004f}, + {0x4c, 0xc02026d8}, + {0x50, 0x821062a0}, + {0x54, 0xc0202504}, + {0x58, 0x9e006050}, + {0x5c, 0xb2102001}, + {0x60, 0x10800016}, + {0x64, 0xda102238}, + {0x68, 0xf0002308}, + {0x6c, 0x80a6c018}, + {0x70, 0x38800011}, + {0x74, 0xb2066001}, + {0x78, 0xf410223a}, + {0x7c, 0xba03e004}, + {0xf0, 0x6a}, + {0x00, 0xc2074000}, + {0x04, 0xb606e001}, + {0x08, 0xba076004}, + {0x0c, 0x80a0401a}, + {0x10, 0x04800005}, + {0x14, 0xb820401a}, + {0x18, 0xc2002504}, + {0x1c, 0x8200401c}, + {0x20, 0xc2202504}, + {0x24, 0x80a6c018}, + {0x28, 0x28bffff7}, + {0x2c, 0xc2074000}, + {0x30, 0xb2066001}, + {0x34, 0x9e03e050}, + {0x38, 0x80a36000}, + {0x3c, 0x32800003}, + {0x40, 0x80a6400d}, + {0x44, 0x80a6400c}, + {0x48, 0x18800004}, + {0x4c, 0x80a6601c}, + {0x50, 0x08bfffe6}, + {0x54, 0xb6102001}, + {0x58, 0xfa10223e}, + {0x5c, 0xc2002504}, + {0x60, 0x80a0401d}, + {0x64, 0x3480000a}, + {0x68, 0xc2002548}, + {0x6c, 0xfa10223c}, + {0x70, 0x80a76000}, + {0x74, 0x2280000b}, + {0x78, 0xc2002548}, + {0x7c, 0xc2082517}, + {0xf0, 0x6b}, + {0x00, 0x80a0401d}, + {0x04, 0x0a800007}, + {0x08, 0xc2002548}, + {0x0c, 0x80886008}, + {0x10, 0x22800008}, + {0x14, 0xc20026d8}, + {0x18, 0x10800008}, + {0x1c, 0xc02026d8}, + {0x20, 0x80886008}, + {0x24, 0x22800005}, + {0x28, 0xc02026d8}, + {0x2c, 0xc20026d8}, + {0x30, 0x82006001}, + {0x34, 0xc22026d8}, + {0x38, 0xfa0026d8}, + {0x3c, 0xc2002290}, + {0x40, 0x80a74001}, + {0x44, 0x0880000b}, + {0x48, 0xfa002548}, + {0x4c, 0x83376003}, + {0x50, 0x82086001}, + {0x54, 0x82186001}, + {0x58, 0x83286002}, + {0x5c, 0xba0f7ffb}, + {0x60, 0xba174001}, + {0x64, 0xfa202548}, + {0x68, 0xc02026d8}, + {0x6c, 0xfa002548}, + {0x70, 0xbb376002}, + {0x74, 0x033fc180}, + {0x78, 0xba0f6001}, + {0x7c, 0x8210602c}, + {0xf0, 0x6c}, + {0x00, 0xfa204000}, + {0x04, 0x81c7e008}, + {0x08, 0x81e80000}, + {0x0c, 0x9de3bf98}, + {0x10, 0xc2002fbc}, + {0x14, 0x9fc04000}, + {0x18, 0x01000000}, + {0x1c, 0x01000000}, + {0x20, 0x81c7e008}, + {0x24, 0x81e80000}, + {0x28, 0x9de3bf28}, + {0x2c, 0xe2502458}, + {0x30, 0x80a46000}, + {0x34, 0x0280006d}, + {0x38, 0x01000000}, + {0x3c, 0xc208217f}, + {0x40, 0x80a44001}, + {0x44, 0x16800069}, + {0x48, 0x01000000}, + {0x4c, 0xc2102548}, + {0x50, 0x80886001}, + {0x54, 0x02800006}, + {0x58, 0xa0102001}, + {0x5c, 0xc2002558}, + {0x60, 0x80a06000}, + {0x64, 0x02800061}, + {0x68, 0x01000000}, + {0x6c, 0xc208217e}, + {0x70, 0x80a40001}, + {0x74, 0x1480005d}, + {0x78, 0xe450245a}, + {0x7c, 0x96102001}, + {0xf0, 0x6d}, + {0x00, 0xc208217f}, + {0x04, 0x80a2c001}, + {0x08, 0x1480000f}, + {0x0c, 0x0300001d}, + {0x10, 0x9b2c2002}, + {0x14, 0x821062a0}, + {0x18, 0x9a034001}, + {0x1c, 0x9a036050}, + {0x20, 0x9807bf88}, + {0x24, 0xc2034000}, + {0x28, 0xc2230000}, + {0x2c, 0x9602e001}, + {0x30, 0xc208217f}, + {0x34, 0x80a2c001}, + {0x38, 0x98032004}, + {0x3c, 0x04bffffa}, + {0x40, 0x9a036050}, + {0x44, 0x9007bf88}, + {0x48, 0x7ffff5c3}, + {0x4c, 0xd208217f}, + {0x50, 0x96100012}, + {0x54, 0x80a48011}, + {0x58, 0x1480000b}, + {0x5c, 0x94102000}, + {0x60, 0x832ca002}, + {0x64, 0x8200401e}, + {0x68, 0x9a007f88}, + {0x6c, 0xc2034000}, + {0x70, 0x9602e001}, + {0x74, 0x94028001}, + {0x78, 0x80a2c011}, + {0x7c, 0x04bffffc}, + {0xf0, 0x6e}, + {0x00, 0x9a036004}, + {0x04, 0x82244012}, + {0x08, 0x82006001}, + {0x0c, 0x9b3aa01f}, + {0x10, 0x81836000}, + {0x14, 0x01000000}, + {0x18, 0x01000000}, + {0x1c, 0x01000000}, + {0x20, 0x947a8001}, + {0x24, 0xc25021ac}, + {0x28, 0x80a28001}, + {0x2c, 0x26800002}, + {0x30, 0x94100001}, + {0x34, 0x96102001}, + {0x38, 0xc208217f}, + {0x3c, 0x80a2c001}, + {0x40, 0x14800025}, + {0x44, 0x832c2002}, + {0x48, 0x1100001d}, + {0x4c, 0x98006050}, + {0x50, 0x921222a0}, + {0x54, 0x80a2a000}, + {0x58, 0x0480000b}, + {0x5c, 0x9a1222a0}, + {0x60, 0xc203000d}, + {0x64, 0x80a0400a}, + {0x68, 0x36800008}, + {0x6c, 0xc2030009}, + {0x70, 0x80a06000}, + {0x74, 0x34800007}, + {0x78, 0xc023000d}, + {0x7c, 0x10800006}, + {0xf0, 0x6f}, + {0x00, 0xc20023c8}, + {0x04, 0xc2030009}, + {0x08, 0x8220400a}, + {0x0c, 0xc2230009}, + {0x10, 0xc20023c8}, + {0x14, 0x83306012}, + {0x18, 0x80886001}, + {0x1c, 0x0280000a}, + {0x20, 0x9602e001}, + {0x24, 0xda0c22af}, + {0x28, 0xc2030009}, + {0x2c, 0x8258400d}, + {0x30, 0x9b38601f}, + {0x34, 0x9b336019}, + {0x38, 0x8200400d}, + {0x3c, 0x83386007}, + {0x40, 0xc2230009}, + {0x44, 0xc208217f}, + {0x48, 0x80a2c001}, + {0x4c, 0x04bfffe2}, + {0x50, 0x98032050}, + {0x54, 0xa0042001}, + {0x58, 0xc208217e}, + {0x5c, 0x80a40001}, + {0x60, 0x04bfffa8}, + {0x64, 0x96102001}, + {0x68, 0x81c7e008}, + {0x6c, 0x81e80000}, + {0x70, 0xc2082573}, + {0x74, 0xda00256c}, + {0x78, 0x82006001}, + {0x7c, 0xd808257f}, + {0xf0, 0x70}, + {0x00, 0x9a5b4001}, + {0x04, 0x98032001}, + {0x08, 0x81800000}, + {0x0c, 0x01000000}, + {0x10, 0x01000000}, + {0x14, 0x01000000}, + {0x18, 0x9a73400c}, + {0x1c, 0xda20256c}, + {0x20, 0x96102000}, + {0x24, 0x832ae002}, + {0x28, 0xd800256c}, + {0x2c, 0xda1063b6}, + {0x30, 0x9a5b400c}, + {0x34, 0x9b336007}, + {0x38, 0x9602e001}, + {0x3c, 0x80a2e003}, + {0x40, 0x04bffff9}, + {0x44, 0xda206520}, + {0x48, 0xc20023c0}, + {0x4c, 0x80a06000}, + {0x50, 0x02800007}, + {0x54, 0x82103000}, + {0x58, 0xc2002200}, + {0x5c, 0x80a06000}, + {0x60, 0x22800005}, + {0x64, 0xc200255c}, + {0x68, 0x82103000}, + {0x6c, 0xc220252c}, + {0x70, 0xc200255c}, + {0x74, 0x80a06000}, + {0x78, 0x02800005}, + {0x7c, 0xc2002288}, + {0xf0, 0x71}, + {0x00, 0x9b306001}, + {0x04, 0x83306002}, + {0x08, 0x8200400d}, + {0x0c, 0xc220251c}, + {0x10, 0x03000007}, + {0x14, 0x81c062a8}, + {0x18, 0x01000000}, + {0x1c, 0x01000000}, + {0x20, 0x9de3bf98}, + {0x24, 0xc20021cc}, + {0x28, 0x80a06000}, + {0x2c, 0x22800025}, + {0x30, 0xc20026e4}, + {0x34, 0x832e6002}, + {0x38, 0x82004019}, + {0x3c, 0x83286002}, + {0x40, 0x82004018}, + {0x44, 0x9f286002}, + {0x48, 0xb92e2010}, + {0x4c, 0x3b003fc0}, + {0x50, 0x0300001d}, + {0x54, 0x9a1760ff}, + {0x58, 0xb8070019}, + {0x5c, 0x981062a0}, + {0x60, 0xb4102007}, + {0x64, 0xbb2ea002}, + {0x68, 0xc20761b0}, + {0x6c, 0x80a06000}, + {0x70, 0x02800030}, + {0x74, 0xb608400d}, + {0x78, 0x80a6c01c}, + {0x7c, 0x3280000e}, + {0xf0, 0x72}, + {0x00, 0xb486bfff}, + {0x04, 0xfa0f61b0}, + {0x08, 0x80a76000}, + {0x0c, 0x2280000d}, + {0x10, 0xc20026e4}, + {0x14, 0xc203c00c}, + {0x18, 0x8258401d}, + {0x1c, 0xbb38601f}, + {0x20, 0xbb376019}, + {0x24, 0x8200401d}, + {0x28, 0x83386007}, + {0x2c, 0x10800004}, + {0x30, 0xc223c00c}, + {0x34, 0x1cbfffed}, + {0x38, 0xbb2ea002}, + {0x3c, 0xc20026e4}, + {0x40, 0x80a06000}, + {0x44, 0x12800033}, + {0x48, 0xb72e6002}, + {0x4c, 0x8206c019}, + {0x50, 0x83286002}, + {0x54, 0x82004018}, + {0x58, 0x3b00001d}, + {0x5c, 0x83286002}, + {0x60, 0xba1762a0}, + {0x64, 0xf800401d}, + {0x68, 0xc200251c}, + {0x6c, 0x80a70001}, + {0x70, 0x04800028}, + {0x74, 0x01000000}, + {0x78, 0xfa00255c}, + {0x7c, 0x80a76000}, + {0xf0, 0x73}, + {0x00, 0x02800015}, + {0x04, 0x832e2010}, + {0x08, 0xc20023c8}, + {0x0c, 0x80886100}, + {0x10, 0x02800011}, + {0x14, 0x832e2010}, + {0x18, 0x80a7001d}, + {0x1c, 0x0880001d}, + {0x20, 0x82004019}, + {0x24, 0x82207000}, + {0x28, 0x10800012}, + {0x2c, 0xc2202710}, + {0x30, 0x832e6002}, + {0x34, 0x82004019}, + {0x38, 0x83286002}, + {0x3c, 0x82004018}, + {0x40, 0x3b00001d}, + {0x44, 0x83286002}, + {0x48, 0xba1762a0}, + {0x4c, 0x10bfffdc}, + {0x50, 0xc020401d}, + {0x54, 0xfa002514}, + {0x58, 0x82004019}, + {0x5c, 0xb92f6002}, + {0x60, 0x82207000}, + {0x64, 0xc2272710}, + {0x68, 0xba076001}, + {0x6c, 0xfa202514}, + {0x70, 0x8206c019}, + {0x74, 0x83286002}, + {0x78, 0x82004018}, + {0x7c, 0x3b00001d}, + {0xf0, 0x74}, + {0x00, 0x83286002}, + {0x04, 0xba1762a0}, + {0x08, 0xc200401d}, + {0x0c, 0xc220255c}, + {0x10, 0x81c7e008}, + {0x14, 0x81e80000}, + {0x18, 0x9de3bf98}, + {0x1c, 0xc2102548}, + {0x20, 0x80886001}, + {0x24, 0x22800007}, + {0x28, 0xc2002308}, + {0x2c, 0xc2002160}, + {0x30, 0x80886100}, + {0x34, 0x02800074}, + {0x38, 0x01000000}, + {0x3c, 0xc2002308}, + {0x40, 0x82006001}, + {0x44, 0xe208217e}, + {0x48, 0x80a44001}, + {0x4c, 0x0a80001a}, + {0x50, 0xa4102001}, + {0x54, 0xc208217f}, + {0x58, 0x80a48001}, + {0x5c, 0x38800013}, + {0x60, 0xc2002308}, + {0x64, 0x832c6002}, + {0x68, 0xa0006050}, + {0x6c, 0x92100012}, + {0x70, 0x7fffff8c}, + {0x74, 0x90100011}, + {0x78, 0x0300001d}, + {0x7c, 0x981062a0}, + {0xf0, 0x75}, + {0x00, 0xda04000c}, + {0x04, 0x821062a4}, + {0x08, 0xda240001}, + {0x0c, 0xc024000c}, + {0x10, 0xa404a001}, + {0x14, 0xc208217f}, + {0x18, 0x80a48001}, + {0x1c, 0x08bffff4}, + {0x20, 0xa0042050}, + {0x24, 0xc2002308}, + {0x28, 0xa2047fff}, + {0x2c, 0x10bfffe7}, + {0x30, 0x82006001}, + {0x34, 0xc2002300}, + {0x38, 0x82006001}, + {0x3c, 0xe408217f}, + {0x40, 0x80a48001}, + {0x44, 0x0a80001e}, + {0x48, 0x832ca002}, + {0x4c, 0x82004012}, + {0x50, 0xa7286002}, + {0x54, 0xa2102001}, + {0x58, 0xc2002308}, + {0x5c, 0x80a44001}, + {0x60, 0x18800011}, + {0x64, 0x832ce002}, + {0x68, 0xa0006004}, + {0x6c, 0x90100011}, + {0x70, 0x7fffff6c}, + {0x74, 0x92100012}, + {0x78, 0x0300001d}, + {0x7c, 0x981062a0}, + {0xf0, 0x76}, + {0x00, 0xda04000c}, + {0x04, 0x821062f0}, + {0x08, 0xda240001}, + {0x0c, 0xc024000c}, + {0x10, 0xa2046001}, + {0x14, 0xc2002308}, + {0x18, 0x80a44001}, + {0x1c, 0x08bffff4}, + {0x20, 0xa0042004}, + {0x24, 0xc2002300}, + {0x28, 0xa404bfff}, + {0x2c, 0x82006001}, + {0x30, 0x80a48001}, + {0x34, 0x1abfffe8}, + {0x38, 0xa604ffec}, + {0x3c, 0xa2102000}, + {0x40, 0xc2002514}, + {0x44, 0x80a44001}, + {0x48, 0x1a80002f}, + {0x4c, 0x94102000}, + {0x50, 0xc200237c}, + {0x54, 0x80a06000}, + {0x58, 0x2280000a}, + {0x5c, 0xc20023c8}, + {0x60, 0xc202a710}, + {0x64, 0x99306010}, + {0x68, 0x82086fff}, + {0x6c, 0x980b2fff}, + {0x70, 0x97286010}, + {0x74, 0x83286018}, + {0x78, 0x1080000d}, + {0x7c, 0x9a032001}, + {0xf0, 0x77}, + {0x00, 0x80886200}, + {0x04, 0x22800010}, + {0x08, 0xda02a710}, + {0x0c, 0xc202a710}, + {0x10, 0x99306010}, + {0x14, 0x82086fff}, + {0x18, 0x82006001}, + {0x1c, 0x980b2fff}, + {0x20, 0x97286010}, + {0x24, 0x83286018}, + {0x28, 0x9a033fff}, + {0x2c, 0x8200400b}, + {0x30, 0x9b2b6008}, + {0x34, 0x8200400d}, + {0x38, 0x8200400c}, + {0x3c, 0x1080000c}, + {0x40, 0x82006001}, + {0x44, 0x820b6fff}, + {0x48, 0x82006001}, + {0x4c, 0x99286010}, + {0x50, 0x9b336010}, + {0x54, 0x83286018}, + {0x58, 0x9a0b6fff}, + {0x5c, 0x8200400c}, + {0x60, 0x992b6008}, + {0x64, 0x8200400c}, + {0x68, 0x8200400d}, + {0x6c, 0xc222a738}, + {0x70, 0xa2046001}, + {0x74, 0xc2002514}, + {0x78, 0x80a44001}, + {0x7c, 0x0abfffd5}, + {0xf0, 0x78}, + {0x00, 0x9402a004}, + {0x04, 0x81c7e008}, + {0x08, 0x81e80000}, + {0x0c, 0x9de3bf98}, + {0x10, 0xc2002548}, + {0x14, 0x80886100}, + {0x18, 0xac102000}, + {0x1c, 0x128000cf}, + {0x20, 0xa6102000}, + {0x24, 0xc20026e4}, + {0x28, 0x80a06000}, + {0x2c, 0x02800004}, + {0x30, 0xa2102001}, + {0x34, 0x82007fff}, + {0x38, 0xc22026e4}, + {0x3c, 0xc2002300}, + {0x40, 0x80a44001}, + {0x44, 0x388000a9}, + {0x48, 0xda002530}, + {0x4c, 0xae102014}, + {0x50, 0xa4102001}, + {0x54, 0xc2002308}, + {0x58, 0x80a48001}, + {0x5c, 0x18800092}, + {0x60, 0x9b2de002}, + {0x64, 0x03000050}, + {0x68, 0xaa044001}, + {0x6c, 0xa8036004}, + {0x70, 0xc2002514}, + {0x74, 0x80a06009}, + {0x78, 0x1880009b}, + {0x7c, 0x0300001d}, + {0xf0, 0x79}, + {0x00, 0x821062a0}, + {0x04, 0xda050001}, + {0x08, 0xc2002474}, + {0x0c, 0x80a34001}, + {0x10, 0x0680007f}, + {0x14, 0x03000040}, + {0x18, 0x90100012}, + {0x1c, 0x7ffff83f}, + {0x20, 0x92100011}, + {0x24, 0x80a22000}, + {0x28, 0x02800079}, + {0x2c, 0x03000040}, + {0x30, 0xc2002ff0}, + {0x34, 0x80a06000}, + {0x38, 0x2280000a}, + {0x3c, 0xc2002fe0}, + {0x40, 0x90100012}, + {0x44, 0x9fc04000}, + {0x48, 0x92100011}, + {0x4c, 0xc200259c}, + {0x50, 0x80a06000}, + {0x54, 0x1280006e}, + {0x58, 0x03000040}, + {0x5c, 0xc2002fe0}, + {0x60, 0x80a06000}, + {0x64, 0x2280000b}, + {0x68, 0xc2002ff4}, + {0x6c, 0x90100012}, + {0x70, 0x92100011}, + {0x74, 0x9fc04000}, + {0x78, 0xd4082473}, + {0x7c, 0xc200259c}, + {0xf0, 0x7a}, + {0x00, 0x80a06000}, + {0x04, 0x12800062}, + {0x08, 0x03000040}, + {0x0c, 0xc2002ff4}, + {0x10, 0x80a06000}, + {0x14, 0x02800006}, + {0x18, 0xa0102000}, + {0x1c, 0x90100012}, + {0x20, 0x9fc04000}, + {0x24, 0x92100011}, + {0x28, 0xe000259c}, + {0x2c, 0x90100012}, + {0x30, 0x92100011}, + {0x34, 0x94100010}, + {0x38, 0x7ffff867}, + {0x3c, 0xd6082473}, + {0x40, 0x80a22000}, + {0x44, 0x02800052}, + {0x48, 0x03000040}, + {0x4c, 0xc2002fe0}, + {0x50, 0x80a06000}, + {0x54, 0x02800007}, + {0x58, 0x90100012}, + {0x5c, 0x92100011}, + {0x60, 0x9fc04000}, + {0x64, 0x94102100}, + {0x68, 0x10800004}, + {0x6c, 0x94100010}, + {0x70, 0xc020259c}, + {0x74, 0x94100010}, + {0x78, 0x90100012}, + {0x7c, 0x92100011}, + {0xf0, 0x7b}, + {0x00, 0x7ffff855}, + {0x04, 0x96102100}, + {0x08, 0x80a22000}, + {0x0c, 0x22800011}, + {0x10, 0xc2002514}, + {0x14, 0xc200259c}, + {0x18, 0x80a06000}, + {0x1c, 0x3280000d}, + {0x20, 0xc2002514}, + {0x24, 0xc2002280}, + {0x28, 0xd8002514}, + {0x2c, 0xc22026e4}, + {0x30, 0x9b2ca010}, + {0x34, 0x832b2002}, + {0x38, 0x9a034011}, + {0x3c, 0xda206710}, + {0x40, 0x98032001}, + {0x44, 0xd8202514}, + {0x48, 0x10800006}, + {0x4c, 0xac05a001}, + {0x50, 0x9b286002}, + {0x54, 0xea236710}, + {0x58, 0x82006001}, + {0x5c, 0xc2202514}, + {0x60, 0xc2002514}, + {0x64, 0x80a0600a}, + {0x68, 0x12800029}, + {0x6c, 0x03000040}, + {0x70, 0x0300001d}, + {0x74, 0x9e1062a0}, + {0x78, 0xe6002710}, + {0x7c, 0x90102001}, + {0xf0, 0x7c}, + {0x00, 0x932a2002}, + {0x04, 0xd4026710}, + {0x08, 0x980aafff}, + {0x0c, 0x960cefff}, + {0x10, 0x832b2002}, + {0x14, 0x9b2ae002}, + {0x18, 0x8200400c}, + {0x1c, 0x9a03400b}, + {0x20, 0x9932a010}, + {0x24, 0x980b2fff}, + {0x28, 0x9734e010}, + {0x2c, 0x83286002}, + {0x30, 0x8200400c}, + {0x34, 0x960aefff}, + {0x38, 0x9b2b6002}, + {0x3c, 0x83286002}, + {0x40, 0x9a03400b}, + {0x44, 0xd800400f}, + {0x48, 0x9b2b6002}, + {0x4c, 0xc203400f}, + {0x50, 0x80a30001}, + {0x54, 0x36800004}, + {0x58, 0xd422670c}, + {0x5c, 0xe622670c}, + {0x60, 0xa610000a}, + {0x64, 0x90022001}, + {0x68, 0xc2002514}, + {0x6c, 0x80a20001}, + {0x70, 0x2abfffe5}, + {0x74, 0x932a2002}, + {0x78, 0x82007fff}, + {0x7c, 0xc2202514}, + {0xf0, 0x7d}, + {0x00, 0x83286002}, + {0x04, 0xc0206710}, + {0x08, 0x03000040}, + {0x0c, 0xaa054001}, + {0x10, 0xa404a001}, + {0x14, 0xc2002308}, + {0x18, 0x80a48001}, + {0x1c, 0x08bfff75}, + {0x20, 0xa8052004}, + {0x24, 0xa2046001}, + {0x28, 0xc2002300}, + {0x2c, 0x80a44001}, + {0x30, 0x08bfff68}, + {0x34, 0xae05e014}, + {0x38, 0x80a4e000}, + {0x3c, 0x2280000b}, + {0x40, 0xda002530}, + {0x44, 0xda002514}, + {0x48, 0x80a36009}, + {0x4c, 0x38800007}, + {0x50, 0xda002530}, + {0x54, 0x832b6002}, + {0x58, 0xe6206710}, + {0x5c, 0x82036001}, + {0x60, 0xc2202514}, + {0x64, 0xda002530}, + {0x68, 0x80a5800d}, + {0x6c, 0x14800006}, + {0x70, 0x82100016}, + {0x74, 0xc2002514}, + {0x78, 0x80a34001}, + {0x7c, 0x28800002}, + {0xf0, 0x7e}, + {0x00, 0x8210000d}, + {0x04, 0x80a5a000}, + {0x08, 0x02800004}, + {0x0c, 0xc2202530}, + {0x10, 0x1080000a}, + {0x14, 0xc20021f8}, + {0x18, 0x80a06000}, + {0x1c, 0x22800009}, + {0x20, 0xc2002530}, + {0x24, 0xc20026f8}, + {0x28, 0x80a06000}, + {0x2c, 0x22800004}, + {0x30, 0xc0202530}, + {0x34, 0x82006001}, + {0x38, 0xc22026f8}, + {0x3c, 0xc2002530}, + {0x40, 0x80a06000}, + {0x44, 0x02800005}, + {0x48, 0x01000000}, + {0x4c, 0xc2002548}, + {0x50, 0x82106040}, + {0x54, 0xc2202548}, + {0x58, 0x81c7e008}, + {0x5c, 0x81e80000}, + {0x60, 0x82220009}, + {0x64, 0x9a58400a}, + {0x68, 0x833b601f}, + {0x6c, 0x80a20009}, + {0x70, 0x83306019}, + {0x74, 0x04800004}, + {0x78, 0x90102000}, + {0x7c, 0x82034001}, + {0xf0, 0x7f}, + {0x00, 0x91386007}, + {0x04, 0x81c3e008}, + {0x08, 0x01000000}, + {0x0c, 0x9de3bf98}, + {0x10, 0x7ffff85a}, + {0x14, 0xa8102001}, + {0x18, 0xc208217f}, + {0x1c, 0x80a07fff}, + {0x20, 0x0280001c}, + {0x24, 0xa6102005}, + {0x28, 0x2300001d}, + {0x2c, 0xa12ce004}, + {0x30, 0x821462a8}, + {0x34, 0xa41462a4}, + {0x38, 0xd2040001}, + {0x3c, 0xd408228c}, + {0x40, 0x7fffffe8}, + {0x44, 0xd0040012}, + {0x48, 0x9a1462a0}, + {0x4c, 0xd024000d}, + {0x50, 0xc2002308}, + {0x54, 0xa12ce002}, + {0x58, 0xa0040001}, + {0x5c, 0xa12c2002}, + {0x60, 0xa214629c}, + {0x64, 0xd004000d}, + {0x68, 0xd2040011}, + {0x6c, 0x7fffffdd}, + {0x70, 0xd408228d}, + {0x74, 0xd0240012}, + {0x78, 0xc208217f}, + {0x7c, 0xa8052001}, + {0xf0, 0x80}, + {0x00, 0x82006001}, + {0x04, 0x80a50001}, + {0x08, 0x08bfffe8}, + {0x0c, 0xa604e005}, + {0x10, 0xa6102001}, + {0x14, 0xc2002308}, + {0x18, 0x80a4c001}, + {0x1c, 0x1880001c}, + {0x20, 0x2300001d}, + {0x24, 0xa12ce002}, + {0x28, 0x82146340}, + {0x2c, 0xa41462f0}, + {0x30, 0xd2040001}, + {0x34, 0xd408228e}, + {0x38, 0x7fffffca}, + {0x3c, 0xd0040012}, + {0x40, 0x9a1462a0}, + {0x44, 0xd024000d}, + {0x48, 0xc2002300}, + {0x4c, 0xa1286002}, + {0x50, 0xa0040001}, + {0x54, 0xa12c2002}, + {0x58, 0xa0040013}, + {0x5c, 0xa12c2002}, + {0x60, 0xa2146250}, + {0x64, 0xd004000d}, + {0x68, 0xd2040011}, + {0x6c, 0x7fffffbd}, + {0x70, 0xd408228f}, + {0x74, 0xd0240012}, + {0x78, 0xa604e001}, + {0x7c, 0xc2002308}, + {0xf0, 0x81}, + {0x00, 0x80a4c001}, + {0x04, 0x08bfffe8}, + {0x08, 0x2300001d}, + {0x0c, 0x81c7e008}, + {0x10, 0x81e80000}, + {0x14, 0x9de3bf88}, + {0x18, 0xc2002fe4}, + {0x1c, 0x9fc04000}, + {0x20, 0xd0002590}, + {0x24, 0xda002550}, + {0x28, 0x832b6004}, + {0x2c, 0x8220400d}, + {0x30, 0xe000259c}, + {0x34, 0x82040001}, + {0x38, 0x83306004}, + {0x3c, 0xc2202550}, + {0x40, 0x1100001b}, + {0x44, 0xc2002fe4}, + {0x48, 0x9fc04000}, + {0x4c, 0x901222c0}, + {0x50, 0xc208217c}, + {0x54, 0xda08217d}, + {0x58, 0x9a5b4001}, + {0x5c, 0xc200259c}, + {0x60, 0x8200400d}, + {0x64, 0xc220259c}, + {0x68, 0xda00259c}, + {0x6c, 0xc2002550}, + {0x70, 0x80a34001}, + {0x74, 0x28800011}, + {0x78, 0xc2002548}, + {0x7c, 0xc200259c}, + {0xf0, 0x82}, + {0x00, 0x80a04010}, + {0x04, 0x0880000d}, + {0x08, 0xc2002548}, + {0x0c, 0x80a42000}, + {0x10, 0x0280000a}, + {0x14, 0x01000000}, + {0x18, 0x82087f7f}, + {0x1c, 0xc2202548}, + {0x20, 0xc2002658}, + {0x24, 0x80a06000}, + {0x28, 0x26800006}, + {0x2c, 0xc0202658}, + {0x30, 0x10800005}, + {0x34, 0xc208254e}, + {0x38, 0x82106080}, + {0x3c, 0xc2202548}, + {0x40, 0xc208254e}, + {0x44, 0x80a00001}, + {0x48, 0x82602000}, + {0x4c, 0xa0087ffe}, + {0x50, 0xd8002548}, + {0x54, 0x83332010}, + {0x58, 0x80886001}, + {0x5c, 0x02800012}, + {0x60, 0xa0042003}, + {0x64, 0x03000180}, + {0x68, 0x820b0001}, + {0x6c, 0x1b000080}, + {0x70, 0x80a0400d}, + {0x74, 0x22800064}, + {0x78, 0xc02026d4}, + {0x7c, 0xc2002160}, + {0xf0, 0x83}, + {0x00, 0x80886040}, + {0x04, 0x0280002f}, + {0x08, 0xa0102000}, + {0x0c, 0xc2002558}, + {0x10, 0x80a06000}, + {0x14, 0x0280002b}, + {0x18, 0xa0102002}, + {0x1c, 0x10800029}, + {0x20, 0xa0102000}, + {0x24, 0x033fc200}, + {0x28, 0x82106030}, + {0x2c, 0xda004000}, + {0x30, 0xc2002570}, + {0x34, 0x80a34001}, + {0x38, 0x32800053}, + {0x3c, 0xc02026d4}, + {0x40, 0xc2002200}, + {0x44, 0x80a06000}, + {0x48, 0x3280004f}, + {0x4c, 0xc02026d4}, + {0x50, 0xda002690}, + {0x54, 0x03000007}, + {0x58, 0x808b4001}, + {0x5c, 0x3280004a}, + {0x60, 0xc02026d4}, + {0x64, 0x808b2001}, + {0x68, 0x32800047}, + {0x6c, 0xc02026d4}, + {0x70, 0xda002654}, + {0x74, 0xc20021dc}, + {0x78, 0x80a34001}, + {0x7c, 0x2a800008}, + {0xf0, 0x84}, + {0x00, 0xc2002514}, + {0x04, 0xc200254c}, + {0x08, 0x8330600e}, + {0x0c, 0x80886001}, + {0x10, 0x1280000a}, + {0x14, 0x808b2040}, + {0x18, 0xc2002514}, + {0x1c, 0x80a06000}, + {0x20, 0x22800009}, + {0x24, 0xc20c2314}, + {0x28, 0x808b2080}, + {0x2c, 0x22800006}, + {0x30, 0xc20c2314}, + {0x34, 0x808b2040}, + {0x38, 0x32800033}, + {0x3c, 0xc02026d4}, + {0x40, 0xc20c2314}, + {0x44, 0x80a06000}, + {0x48, 0x2280002f}, + {0x4c, 0xc02026d4}, + {0x50, 0xc20026d4}, + {0x54, 0x98006001}, + {0x58, 0xc2002700}, + {0x5c, 0xda082169}, + {0x60, 0xd82026d4}, + {0x64, 0x80a0400d}, + {0x68, 0x0480000a}, + {0x6c, 0xc20c2314}, + {0x70, 0x820860ff}, + {0x74, 0xda082168}, + {0x78, 0x8258400d}, + {0x7c, 0x80a30001}, + {0xf0, 0x85}, + {0x00, 0x06800021}, + {0x04, 0x01000000}, + {0x08, 0x10800007}, + {0x0c, 0xc02026d4}, + {0x10, 0x820860ff}, + {0x14, 0x80a30001}, + {0x18, 0x0680001b}, + {0x1c, 0x01000000}, + {0x20, 0xc02026d4}, + {0x24, 0xc20c234c}, + {0x28, 0xc227bfec}, + {0x2c, 0xc20c230c}, + {0x30, 0xc227bff0}, + {0x34, 0xa0102000}, + {0x38, 0xc208217c}, + {0x3c, 0x80a40001}, + {0x40, 0x1a800011}, + {0x44, 0x01000000}, + {0x48, 0xc20c2380}, + {0x4c, 0xc227bfe8}, + {0x50, 0xa2102000}, + {0x54, 0xc208217d}, + {0x58, 0x80a44001}, + {0x5c, 0x3a800006}, + {0x60, 0xa0042001}, + {0x64, 0x7ffff799}, + {0x68, 0x9007bfe8}, + {0x6c, 0x10bffffa}, + {0x70, 0xa2046001}, + {0x74, 0xc208217c}, + {0x78, 0x80a40001}, + {0x7c, 0x2abffff4}, + {0xf0, 0x86}, + {0x00, 0xc20c2380}, + {0x04, 0x81c7e008}, + {0x08, 0x81e80000}, + {0x0c, 0x9de3bf88}, + {0x10, 0xd8082246}, + {0x14, 0x80a32000}, + {0x18, 0x22800040}, + {0x1c, 0xc02026e0}, + {0x20, 0xda00254c}, + {0x24, 0x83336018}, + {0x28, 0x80886001}, + {0x2c, 0x12800007}, + {0x30, 0x03004000}, + {0x34, 0xc20026e4}, + {0x38, 0x80a06000}, + {0x3c, 0x22800008}, + {0x40, 0xc200255c}, + {0x44, 0x03004000}, + {0x48, 0x822b4001}, + {0x4c, 0xc220254c}, + {0x50, 0xc027bfec}, + {0x54, 0x1080000e}, + {0x58, 0xc027bff0}, + {0x5c, 0x80a06000}, + {0x60, 0x3280002e}, + {0x64, 0xc02026e0}, + {0x68, 0xc20026e0}, + {0x6c, 0x82006001}, + {0x70, 0x80a0400c}, + {0x74, 0x06800029}, + {0x78, 0xc22026e0}, + {0x7c, 0xc2082244}, + {0xf0, 0x87}, + {0x00, 0xc227bfec}, + {0x04, 0xc2082245}, + {0x08, 0xc227bff0}, + {0x0c, 0xe008217c}, + {0x10, 0xc20022fc}, + {0x14, 0x80a40001}, + {0x18, 0x1a80000c}, + {0x1c, 0xa2102001}, + {0x20, 0xc20c2380}, + {0x24, 0xc227bfe8}, + {0x28, 0xc20022f8}, + {0x2c, 0x80a44001}, + {0x30, 0x38bffff8}, + {0x34, 0xa0042001}, + {0x38, 0x7ffff764}, + {0x3c, 0x9007bfe8}, + {0x40, 0x10bffffa}, + {0x44, 0xa2046001}, + {0x48, 0xa0102001}, + {0x4c, 0xc208217c}, + {0x50, 0x80a40001}, + {0x54, 0x14800010}, + {0x58, 0xa2102000}, + {0x5c, 0xc208217d}, + {0x60, 0xda00247c}, + {0x64, 0x9a5b4001}, + {0x68, 0xc20c237f}, + {0x6c, 0x8200400d}, + {0x70, 0xc227bfe8}, + {0x74, 0xc2002304}, + {0x78, 0x80a44001}, + {0x7c, 0x3abffff4}, + {0xf0, 0x88}, + {0x00, 0xa0042001}, + {0x04, 0x7ffff751}, + {0x08, 0x9007bfe8}, + {0x0c, 0x10bffffa}, + {0x10, 0xa2046001}, + {0x14, 0xc02026e0}, + {0x18, 0x81c7e008}, + {0x1c, 0x81e80000}, + {0x20, 0xd2002208}, + {0x24, 0x80a26000}, + {0x28, 0x0280001a}, + {0x2c, 0x01000000}, + {0x30, 0xc2102548}, + {0x34, 0x80886001}, + {0x38, 0x12800016}, + {0x3c, 0x01000000}, + {0x40, 0xc2002514}, + {0x44, 0x80a06000}, + {0x48, 0x12800007}, + {0x4c, 0xc2002558}, + {0x50, 0x80a06000}, + {0x54, 0x0280000f}, + {0x58, 0x9a007fff}, + {0x5c, 0x1080000d}, + {0x60, 0xda202558}, + {0x64, 0x15200040}, + {0x68, 0x1b3fc200}, + {0x6c, 0x9812a001}, + {0x70, 0x80a06000}, + {0x74, 0x12800006}, + {0x78, 0x96136070}, + {0x7c, 0xd8234000}, + {0xf0, 0x89}, + {0x00, 0xc2002298}, + {0x04, 0xc222c000}, + {0x08, 0xd4234000}, + {0x0c, 0xd2202558}, + {0x10, 0x81c3e008}, + {0x14, 0x01000000}, + {0x18, 0x92102000}, + {0x1c, 0xc2002514}, + {0x20, 0x80a24001}, + {0x24, 0x1a800019}, + {0x28, 0x912a6002}, + {0x2c, 0xd4022710}, + {0x30, 0x820aafff}, + {0x34, 0x9732a010}, + {0x38, 0x98006001}, + {0x3c, 0x960aefff}, + {0x40, 0x82007fff}, + {0x44, 0x83286018}, + {0x48, 0x992b2010}, + {0x4c, 0x9a02ffff}, + {0x50, 0x8200400c}, + {0x54, 0x9b2b6008}, + {0x58, 0x8200400d}, + {0x5c, 0x8200400b}, + {0x60, 0x9532a00c}, + {0x64, 0x92026001}, + {0x68, 0x808aa001}, + {0x6c, 0x12800003}, + {0x70, 0x82006001}, + {0x74, 0xc2222738}, + {0x78, 0xc2002514}, + {0x7c, 0x80a24001}, + {0xf0, 0x8a}, + {0x00, 0x0abfffeb}, + {0x04, 0x912a6002}, + {0x08, 0x81c3e008}, + {0x0c, 0x01000000}, + {0x10, 0x9de3bf98}, + {0x14, 0x92102000}, + {0x18, 0xc2002514}, + {0x1c, 0x80a24001}, + {0x20, 0x1a80005f}, + {0x24, 0x94102000}, + {0x28, 0xb72a6002}, + {0x2c, 0xf20ee738}, + {0x30, 0xc20ee739}, + {0x34, 0x80a64001}, + {0x38, 0x96102000}, + {0x3c, 0x9e102000}, + {0x40, 0x14800022}, + {0x44, 0x9a102000}, + {0x48, 0x832e6002}, + {0x4c, 0x82004019}, + {0x50, 0x3b00001d}, + {0x54, 0x901762a0}, + {0x58, 0xb9286002}, + {0x5c, 0xc20ee73b}, + {0x60, 0xf40ee73a}, + {0x64, 0x80a68001}, + {0x68, 0x14800012}, + {0x6c, 0x8207001a}, + {0x70, 0x83286002}, + {0x74, 0x82004008}, + {0x78, 0xd80aa73b}, + {0x7c, 0xf6004000}, + {0xf0, 0x8b}, + {0x00, 0xba5ec01a}, + {0x04, 0x82006004}, + {0x08, 0xb406a001}, + {0x0c, 0x80a6e000}, + {0x10, 0x04800005}, + {0x14, 0xb05ec019}, + {0x18, 0x9e03c018}, + {0x1c, 0x9a03401d}, + {0x20, 0x9602c01b}, + {0x24, 0x80a6800c}, + {0x28, 0x24bffff6}, + {0x2c, 0xf6004000}, + {0x30, 0xb72a6002}, + {0x34, 0xb2066001}, + {0x38, 0xc20ee739}, + {0x3c, 0x80a64001}, + {0x40, 0x04bfffe7}, + {0x44, 0xb8072014}, + {0x48, 0xbb2b6006}, + {0x4c, 0xb92be006}, + {0x50, 0xc202a710}, + {0x54, 0x9b3f201f}, + {0x58, 0x81836000}, + {0x5c, 0x01000000}, + {0x60, 0x01000000}, + {0x64, 0x01000000}, + {0x68, 0xb87f000b}, + {0x6c, 0x9b3f601f}, + {0x70, 0x81836000}, + {0x74, 0x01000000}, + {0x78, 0x01000000}, + {0x7c, 0x01000000}, + {0xf0, 0x8c}, + {0x00, 0xba7f400b}, + {0x04, 0x8330600c}, + {0x08, 0x80886001}, + {0x0c, 0x9e073fe0}, + {0x10, 0x02800007}, + {0x14, 0x9a077fe0}, + {0x18, 0xc200237c}, + {0x1c, 0x80a06000}, + {0x20, 0x22800003}, + {0x24, 0x9e073fa0}, + {0x28, 0x9a077fa0}, + {0x2c, 0x80a3e000}, + {0x30, 0x24800002}, + {0x34, 0x9e102001}, + {0x38, 0x80a36000}, + {0x3c, 0x24800002}, + {0x40, 0x9a102001}, + {0x44, 0xc208217f}, + {0x48, 0x83286006}, + {0x4c, 0x80a3c001}, + {0x50, 0x36800002}, + {0x54, 0x9e007fff}, + {0x58, 0xc208217e}, + {0x5c, 0x83286006}, + {0x60, 0x80a34001}, + {0x64, 0x36800002}, + {0x68, 0x9a007fff}, + {0x6c, 0xfa02a710}, + {0x70, 0x832be010}, + {0x74, 0x393c003c}, + {0x78, 0x8200400d}, + {0x7c, 0xba0f401c}, + {0xf0, 0x8d}, + {0x00, 0x8200401d}, + {0x04, 0xc222a710}, + {0x08, 0x92026001}, + {0x0c, 0xc2002514}, + {0x10, 0x80a24001}, + {0x14, 0x0abfffa5}, + {0x18, 0x9402a004}, + {0x1c, 0x7ffff53a}, + {0x20, 0x91e8205a}, + {0x24, 0x01000000}, + {0x28, 0x9de3bf98}, + {0x2c, 0xd8002548}, + {0x30, 0x8333200c}, + {0x34, 0x80886001}, + {0x38, 0x12800081}, + {0x3c, 0x01000000}, + {0x40, 0xc208254d}, + {0x44, 0x80a06000}, + {0x48, 0x1280007d}, + {0x4c, 0x01000000}, + {0x50, 0xc208254e}, + {0x54, 0x80a06000}, + {0x58, 0x02800079}, + {0x5c, 0x01000000}, + {0x60, 0xc2002554}, + {0x64, 0x825860fa}, + {0x68, 0xda002500}, + {0x6c, 0x80a34001}, + {0x70, 0x0a800073}, + {0x74, 0x01000000}, + {0x78, 0xd6002658}, + {0x7c, 0x80a2e000}, + {0xf0, 0x8e}, + {0x00, 0x1480001c}, + {0x04, 0x8202ffff}, + {0x08, 0xc2002514}, + {0x0c, 0x80a06001}, + {0x10, 0x3280006b}, + {0x14, 0xc0202658}, + {0x18, 0xc2002710}, + {0x1c, 0x80a06000}, + {0x20, 0x12800004}, + {0x24, 0x808b2040}, + {0x28, 0x10800065}, + {0x2c, 0xc0202658}, + {0x30, 0x32800006}, + {0x34, 0xd800239c}, + {0x38, 0x80a2e000}, + {0x3c, 0x0680000d}, + {0x40, 0x8202e001}, + {0x44, 0xd800239c}, + {0x48, 0x0300003f}, + {0x4c, 0x9b332010}, + {0x50, 0x821063ff}, + {0x54, 0x980b0001}, + {0x58, 0x9a38000d}, + {0x5c, 0x9a23400c}, + {0x60, 0x80a2c00d}, + {0x64, 0x06800005}, + {0x68, 0x03296956}, + {0x6c, 0x8202ffff}, + {0x70, 0x10800053}, + {0x74, 0xc2202658}, + {0x78, 0x9a10625a}, + {0x7c, 0xc200250c}, + {0xf0, 0x8f}, + {0x00, 0x80a0400d}, + {0x04, 0x02800004}, + {0x08, 0xa0102000}, + {0x0c, 0xda20250c}, + {0x10, 0xc0202654}, + {0x14, 0x832c2002}, + {0x18, 0x92006610}, + {0x1c, 0xc2006610}, + {0x20, 0x90102710}, + {0x24, 0x80a06000}, + {0x28, 0x0280000d}, + {0x2c, 0xa0042001}, + {0x30, 0x7ffff56a}, + {0x34, 0x01000000}, + {0x38, 0xc2002300}, + {0x3c, 0xda002308}, + {0x40, 0x82584001}, + {0x44, 0x9a5b400d}, + {0x48, 0x8200400d}, + {0x4c, 0x83286006}, + {0x50, 0x80a20001}, + {0x54, 0x0a80003a}, + {0x58, 0x01000000}, + {0x5c, 0x80a4200f}, + {0x60, 0x08bfffee}, + {0x64, 0x832c2002}, + {0x68, 0x030041eb}, + {0x6c, 0xc2202658}, + {0x70, 0xa010200f}, + {0x74, 0x9b2c2002}, + {0x78, 0xc203660c}, + {0x7c, 0xa0843fff}, + {0xf0, 0x90}, + {0x00, 0x12bffffd}, + {0x04, 0xc2236610}, + {0x08, 0xda002654}, + {0x0c, 0xc2002710}, + {0x10, 0xc2202610}, + {0x14, 0x80a3600f}, + {0x18, 0x14800003}, + {0x1c, 0x9010200f}, + {0x20, 0x9010000d}, + {0x24, 0x03000018}, + {0x28, 0x9e1062f0}, + {0x2c, 0x82006c00}, + {0x30, 0xa21062c0}, + {0x34, 0x0300003f}, + {0x38, 0xa61063ff}, + {0x3c, 0x92022001}, + {0x40, 0xa0102000}, + {0x44, 0xa410000f}, + {0x48, 0x972c2002}, + {0x4c, 0x8203c00b}, + {0x50, 0xda106002}, + {0x54, 0x9804400b}, + {0x58, 0xd4132002}, + {0x5c, 0xc213c00b}, + {0x60, 0xd814400b}, + {0x64, 0x82584008}, + {0x68, 0x9a5b4008}, + {0x6c, 0x8200400c}, + {0x70, 0x9a03400a}, + {0x74, 0x81800000}, + {0x78, 0x01000000}, + {0x7c, 0x01000000}, + {0xf0, 0x91}, + {0x00, 0x01000000}, + {0x04, 0x82704009}, + {0x08, 0x81800000}, + {0x0c, 0x01000000}, + {0x10, 0x01000000}, + {0x14, 0x01000000}, + {0x18, 0x9a734009}, + {0x1c, 0x83286010}, + {0x20, 0x9a0b4013}, + {0x24, 0x8200400d}, + {0x28, 0xa0042001}, + {0x2c, 0x80a420fb}, + {0x30, 0x08bfffe6}, + {0x34, 0xc222c012}, + {0x38, 0xd2202654}, + {0x3c, 0x81c7e008}, + {0x40, 0x81e80000}, + {0x44, 0x9de3bf98}, + {0x48, 0xa2102000}, + {0x4c, 0xc2002514}, + {0x50, 0x80a44001}, + {0x54, 0xa0102000}, + {0x58, 0x1a800012}, + {0x5c, 0x832c2002}, + {0x60, 0x92006710}, + {0x64, 0xc2006710}, + {0x68, 0x80a06000}, + {0x6c, 0x02800009}, + {0x70, 0x90100018}, + {0x74, 0x7ffff519}, + {0x78, 0x01000000}, + {0x7c, 0x82102001}, + {0xf0, 0x92}, + {0x00, 0x80a20019}, + {0x04, 0x1a800003}, + {0x08, 0x83284010}, + {0x0c, 0xa2144001}, + {0x10, 0xa0042001}, + {0x14, 0xc2002514}, + {0x18, 0x10bffff0}, + {0x1c, 0x80a40001}, + {0x20, 0x81c7e008}, + {0x24, 0x91e80011}, + {0x28, 0x9de3bf90}, + {0x2c, 0x03003fc0}, + {0x30, 0x82106001}, + {0x34, 0xc227bff0}, + {0x38, 0xc027bff4}, + {0x3c, 0xa0102000}, + {0x40, 0x8207bff8}, + {0x44, 0x82040001}, + {0x48, 0xd2487ff9}, + {0x4c, 0xd0487ff8}, + {0x50, 0x90060008}, + {0x54, 0x92064009}, + {0x58, 0x94102000}, + {0x5c, 0x7ffff55e}, + {0x60, 0x9610001a}, + {0x64, 0x80a22000}, + {0x68, 0x02800004}, + {0x6c, 0xa0042001}, + {0x70, 0x10800006}, + {0x74, 0xb0102001}, + {0x78, 0x80a42004}, + {0x7c, 0x04bffff2}, + {0xf0, 0x93}, + {0x00, 0x8207bff8}, + {0x04, 0xb0102000}, + {0x08, 0x81c7e008}, + {0x0c, 0x81e80000}, + {0x10, 0x9de3bf98}, + {0x14, 0xc2102548}, + {0x18, 0x80886001}, + {0x1c, 0xb8102000}, + {0x20, 0xba102000}, + {0x24, 0x02800004}, + {0x28, 0xae102000}, + {0x2c, 0x10800029}, + {0x30, 0xec002354}, + {0x34, 0xc200254c}, + {0x38, 0x80886200}, + {0x3c, 0x32800010}, + {0x40, 0xc2002690}, + {0x44, 0x03296956}, + {0x48, 0xda00250c}, + {0x4c, 0x8210625a}, + {0x50, 0x80a34001}, + {0x54, 0x12800006}, + {0x58, 0xc20023c8}, + {0x5c, 0x80886800}, + {0x60, 0x32800007}, + {0x64, 0xc2002690}, + {0x68, 0xc20023c8}, + {0x6c, 0x80886400}, + {0x70, 0x22800018}, + {0x74, 0xec0022ac}, + {0x78, 0xc2002690}, + {0x7c, 0x80886200}, + {0xf0, 0x94}, + {0x00, 0x1280000d}, + {0x04, 0xb8102001}, + {0x08, 0x13000018}, + {0x0c, 0x921262f0}, + {0x10, 0xc2002fd0}, + {0x14, 0x9fc04000}, + {0x18, 0xd0002590}, + {0x1c, 0xc2002fbc}, + {0x20, 0x9fc04000}, + {0x24, 0x01000000}, + {0x28, 0xc2002690}, + {0x2c, 0x82106200}, + {0x30, 0xc2202690}, + {0x34, 0x10800007}, + {0x38, 0xec0023a0}, + {0x3c, 0xc200254c}, + {0x40, 0x1b000080}, + {0x44, 0x8210400d}, + {0x48, 0x10800084}, + {0x4c, 0xc220254c}, + {0x50, 0x7ffff44d}, + {0x54, 0x901020aa}, + {0x58, 0xda002500}, + {0x5c, 0xc20022d0}, + {0x60, 0x80a34001}, + {0x64, 0x3880000f}, + {0x68, 0xba102001}, + {0x6c, 0xc2002200}, + {0x70, 0x80a00001}, + {0x74, 0x9a402000}, + {0x78, 0x80a00016}, + {0x7c, 0x82603fff}, + {0xf0, 0x95}, + {0x00, 0x80934001}, + {0x04, 0x32800007}, + {0x08, 0xba102001}, + {0x0c, 0xc2002548}, + {0x10, 0x80886001}, + {0x14, 0x02800004}, + {0x18, 0xaa102000}, + {0x1c, 0xba102001}, + {0x20, 0xaa102000}, + {0x24, 0xa52d6003}, + {0x28, 0xc204a760}, + {0x2c, 0x80a06000}, + {0x30, 0x22800067}, + {0x34, 0xaa056001}, + {0x38, 0x80a56000}, + {0x3c, 0x12800008}, + {0x40, 0x80a76000}, + {0x44, 0xc200255c}, + {0x48, 0x80a06000}, + {0x4c, 0x1280000c}, + {0x50, 0x29200000}, + {0x54, 0x1080000a}, + {0x58, 0xa8102000}, + {0x5c, 0x02800005}, + {0x60, 0x9004a760}, + {0x64, 0xc024a764}, + {0x68, 0x10800058}, + {0x6c, 0xc024a760}, + {0x70, 0x7fffff75}, + {0x74, 0x92100016}, + {0x78, 0xa8100008}, + {0x7c, 0x80a52000}, + {0xf0, 0x96}, + {0x00, 0x02800050}, + {0x04, 0xae15c014}, + {0x08, 0xc214a766}, + {0x0c, 0x80a06000}, + {0x10, 0x0280000a}, + {0x14, 0x80a56000}, + {0x18, 0xc204a764}, + {0x1c, 0x82007fff}, + {0x20, 0xc224a764}, + {0x24, 0xc214a766}, + {0x28, 0x80a06000}, + {0x2c, 0x32800048}, + {0x30, 0xaa056001}, + {0x34, 0x80a56000}, + {0x38, 0x12800006}, + {0x3c, 0x1b004000}, + {0x40, 0xc200254c}, + {0x44, 0x8210400d}, + {0x48, 0x10800040}, + {0x4c, 0xc220254c}, + {0x50, 0xc2102548}, + {0x54, 0x80886001}, + {0x58, 0x02800006}, + {0x5c, 0x82103fff}, + {0x60, 0xc024a764}, + {0x64, 0xc024a760}, + {0x68, 0x10800038}, + {0x6c, 0xc2202700}, + {0x70, 0x80a72000}, + {0x74, 0x02bfffb2}, + {0x78, 0xa6102000}, + {0x7c, 0xc2002514}, + {0xf0, 0x97}, + {0x00, 0x80a4c001}, + {0x04, 0x1a80002c}, + {0x08, 0x83350013}, + {0x0c, 0x80886001}, + {0x10, 0x02800027}, + {0x14, 0x9b2ce002}, + {0x18, 0xe0036710}, + {0x1c, 0xa3342016}, + {0x20, 0xa00c2fff}, + {0x24, 0xa13c2006}, + {0x28, 0xa20c603f}, + {0x2c, 0xa0042001}, + {0x30, 0xa2046001}, + {0x34, 0x92100011}, + {0x38, 0xd410246e}, + {0x3c, 0x7fffff5b}, + {0x40, 0x90100010}, + {0x44, 0x80a22000}, + {0x48, 0x92100011}, + {0x4c, 0x1280000f}, + {0x50, 0x90100010}, + {0x54, 0xc210246c}, + {0x58, 0x94906000}, + {0x5c, 0x2280000f}, + {0x60, 0xc200254c}, + {0x64, 0xc2002548}, + {0x68, 0x80886080}, + {0x6c, 0x2280000b}, + {0x70, 0xc200254c}, + {0x74, 0x7fffff4d}, + {0x78, 0x01000000}, + {0x7c, 0x80a22000}, + {0xf0, 0x98}, + {0x00, 0x22800006}, + {0x04, 0xc200254c}, + {0x08, 0x82102001}, + {0x0c, 0x83284013}, + {0x10, 0x10800007}, + {0x14, 0xa82d0001}, + {0x18, 0x1b000080}, + {0x1c, 0x8210400d}, + {0x20, 0xc220254c}, + {0x24, 0x10800004}, + {0x28, 0xc02026e8}, + {0x2c, 0x10bfffd4}, + {0x30, 0xa604e001}, + {0x34, 0x80a52000}, + {0x38, 0x32800005}, + {0x3c, 0xaa056001}, + {0x40, 0xc024a764}, + {0x44, 0xc024a760}, + {0x48, 0xaa056001}, + {0x4c, 0x80a56013}, + {0x50, 0x04bfff96}, + {0x54, 0xa52d6003}, + {0x58, 0x80a5e000}, + {0x5c, 0x22800002}, + {0x60, 0xc02026e8}, + {0x64, 0xc200255c}, + {0x68, 0x80a06000}, + {0x6c, 0x0280000a}, + {0x70, 0x80a76000}, + {0x74, 0xc2002760}, + {0x78, 0x80a06000}, + {0x7c, 0x12800006}, + {0xf0, 0x99}, + {0x00, 0x80a76000}, + {0x04, 0x03000004}, + {0x08, 0xc2202760}, + {0x0c, 0xc2002248}, + {0x10, 0xc2202764}, + {0x14, 0x1280002b}, + {0x18, 0xaa102000}, + {0x1c, 0xc2002514}, + {0x20, 0x80a54001}, + {0x24, 0x1a800027}, + {0x28, 0x96102001}, + {0x2c, 0x992d6002}, + {0x30, 0xc2032710}, + {0x34, 0x8330600c}, + {0x38, 0x80886001}, + {0x3c, 0x3280001d}, + {0x40, 0xaa056001}, + {0x44, 0x832ac015}, + {0x48, 0x808dc001}, + {0x4c, 0x32800019}, + {0x50, 0xaa056001}, + {0x54, 0xa6102001}, + {0x58, 0x9b2ce003}, + {0x5c, 0xc2036760}, + {0x60, 0x80a06000}, + {0x64, 0x1280000f}, + {0x68, 0xa604e001}, + {0x6c, 0xc2032710}, + {0x70, 0xc2236760}, + {0x74, 0xc2102548}, + {0x78, 0x80886001}, + {0x7c, 0x02800004}, + {0xf0, 0x9a}, + {0x00, 0x80a72000}, + {0x04, 0x10800005}, + {0x08, 0xc2002358}, + {0x0c, 0x22800003}, + {0x10, 0xc2002378}, + {0x14, 0xc200239c}, + {0x18, 0x10800005}, + {0x1c, 0xc2236764}, + {0x20, 0x80a4e013}, + {0x24, 0x04bfffee}, + {0x28, 0x9b2ce003}, + {0x2c, 0xaa056001}, + {0x30, 0xc2002514}, + {0x34, 0x80a54001}, + {0x38, 0x0abfffde}, + {0x3c, 0x992d6002}, + {0x40, 0x81c7e008}, + {0x44, 0x81e80000}, + {0x48, 0x9de3bf98}, + {0x4c, 0x7ffff4eb}, + {0x50, 0x01000000}, + {0x54, 0xda002548}, + {0x58, 0x83336010}, + {0x5c, 0x80886001}, + {0x60, 0x1280001d}, + {0x64, 0x8333600c}, + {0x68, 0x80886001}, + {0x6c, 0x1280001a}, + {0x70, 0x01000000}, + {0x74, 0xc208254d}, + {0x78, 0x80a06000}, + {0x7c, 0x02800016}, + {0xf0, 0x9b}, + {0x00, 0x033fc180}, + {0x04, 0xc0204000}, + {0x08, 0xa0102002}, + {0x0c, 0x7ffff531}, + {0x10, 0x90102001}, + {0x14, 0x11000099}, + {0x18, 0x7fffefff}, + {0x1c, 0x9012233c}, + {0x20, 0xa0843fff}, + {0x24, 0x1cbffffa}, + {0x28, 0x01000000}, + {0x2c, 0x7ffff529}, + {0x30, 0x90102000}, + {0x34, 0xc210254c}, + {0x38, 0x80886001}, + {0x3c, 0x32800002}, + {0x40, 0xc020250c}, + {0x44, 0x7ffff24e}, + {0x48, 0x90102015}, + {0x4c, 0x82102001}, + {0x50, 0xc2202584}, + {0x54, 0x81c7e008}, + {0x58, 0x81e80000}, + {0x5c, 0xc2002588}, + {0x60, 0x80a06000}, + {0x64, 0x32800006}, + {0x68, 0xc200258c}, + {0x6c, 0xc2002554}, + {0x70, 0xc2202588}, + {0x74, 0xc0202594}, + {0x78, 0xc200258c}, + {0x7c, 0x80a06000}, + {0xf0, 0x9c}, + {0x00, 0x32800006}, + {0x04, 0xc2102548}, + {0x08, 0xc2002554}, + {0x0c, 0xc220258c}, + {0x10, 0xc0202598}, + {0x14, 0xc2102548}, + {0x18, 0x80886001}, + {0x1c, 0x02800007}, + {0x20, 0x01000000}, + {0x24, 0xc2002558}, + {0x28, 0x80a06001}, + {0x2c, 0x18800003}, + {0x30, 0x82102001}, + {0x34, 0xc2202584}, + {0x38, 0x81c3e008}, + {0x3c, 0x01000000}, + {0x40, 0xc2002548}, + {0x44, 0x8330600e}, + {0x48, 0x80886001}, + {0x4c, 0x12800058}, + {0x50, 0x98102000}, + {0x54, 0xc2002514}, + {0x58, 0x80a30001}, + {0x5c, 0x1a80000b}, + {0x60, 0x033fc180}, + {0x64, 0x96106004}, + {0x68, 0x832b2002}, + {0x6c, 0xda006710}, + {0x70, 0xda20400b}, + {0x74, 0x98032001}, + {0x78, 0xc2002514}, + {0x7c, 0x80a30001}, + {0xf0, 0x9d}, + {0x00, 0x0abffffb}, + {0x04, 0x832b2002}, + {0x08, 0xda00254c}, + {0x0c, 0x808b6001}, + {0x10, 0x32800008}, + {0x14, 0xc208254e}, + {0x18, 0xc2002514}, + {0x1c, 0x9a136001}, + {0x20, 0x82106100}, + {0x24, 0xda20254c}, + {0x28, 0xc2202514}, + {0x2c, 0xc208254e}, + {0x30, 0x80a06000}, + {0x34, 0x3280000b}, + {0x38, 0xc2082517}, + {0x3c, 0xc20023c8}, + {0x40, 0x83306016}, + {0x44, 0x80886001}, + {0x48, 0x22800006}, + {0x4c, 0xc2082517}, + {0x50, 0xc2002514}, + {0x54, 0x82106200}, + {0x58, 0xc2202514}, + {0x5c, 0xc2082517}, + {0x60, 0x80a06000}, + {0x64, 0x2280001d}, + {0x68, 0xda002514}, + {0x6c, 0xc2002548}, + {0x70, 0x80886800}, + {0x74, 0x22800006}, + {0x78, 0xd80023c8}, + {0x7c, 0xc2002514}, + {0xf0, 0x9e}, + {0x00, 0x82106400}, + {0x04, 0xc2202514}, + {0x08, 0xd80023c8}, + {0x0c, 0x80a32000}, + {0x10, 0x16800007}, + {0x14, 0x8333200c}, + {0x18, 0xc2002514}, + {0x1c, 0x1b000004}, + {0x20, 0x8210400d}, + {0x24, 0xc2202514}, + {0x28, 0x8333200c}, + {0x2c, 0x80886001}, + {0x30, 0x2280000a}, + {0x34, 0xda002514}, + {0x38, 0xc2002540}, + {0x3c, 0x1b164020}, + {0x40, 0x83286010}, + {0x44, 0x8200400d}, + {0x48, 0xda002514}, + {0x4c, 0x9a134001}, + {0x50, 0xda202514}, + {0x54, 0xda002514}, + {0x58, 0x03000020}, + {0x5c, 0x808b4001}, + {0x60, 0x1280000e}, + {0x64, 0xc0202540}, + {0x68, 0xc2082517}, + {0x6c, 0x80a06000}, + {0x70, 0x32800007}, + {0x74, 0xc2002500}, + {0x78, 0xc2002560}, + {0x7c, 0x80a06000}, + {0xf0, 0x9f}, + {0x00, 0x22800007}, + {0x04, 0xd8082517}, + {0x08, 0xc2002500}, + {0x0c, 0x83286010}, + {0x10, 0x82134001}, + {0x14, 0xc2202514}, + {0x18, 0xd8082517}, + {0x1c, 0xda002514}, + {0x20, 0x033fc180}, + {0x24, 0xda204000}, + {0x28, 0xd8202568}, + {0x2c, 0x81c3e008}, + {0x30, 0x01000000}, + {0x34, 0x9de3bf98}, + {0x38, 0xd8002548}, + {0x3c, 0x8333200e}, + {0x40, 0x80886001}, + {0x44, 0x22800006}, + {0x48, 0xc2102516}, + {0x4c, 0x03000010}, + {0x50, 0x822b0001}, + {0x54, 0x10800022}, + {0x58, 0xc2202548}, + {0x5c, 0x80a06000}, + {0x60, 0x0280000a}, + {0x64, 0x9b332003}, + {0x68, 0x808b2004}, + {0x6c, 0x2280000e}, + {0x70, 0xc200231c}, + {0x74, 0xc2002160}, + {0x78, 0x80886400}, + {0x7c, 0x3280000a}, + {0xf0, 0xa0}, + {0x00, 0xc200231c}, + {0x04, 0x9b332003}, + {0x08, 0x83332002}, + {0x0c, 0x82086001}, + {0x10, 0x9a0b6001}, + {0x14, 0x80a0400d}, + {0x18, 0x2280000a}, + {0x1c, 0xc2002560}, + {0x20, 0xc200231c}, + {0x24, 0x80a06000}, + {0x28, 0x22800003}, + {0x2c, 0xc2082360}, + {0x30, 0x82102005}, + {0x34, 0xc2202560}, + {0x38, 0x10800007}, + {0x3c, 0x90102001}, + {0x40, 0x80a06000}, + {0x44, 0x02800004}, + {0x48, 0x90102000}, + {0x4c, 0x10bffffa}, + {0x50, 0x82007fff}, + {0x54, 0x7ffff47f}, + {0x58, 0x01000000}, + {0x5c, 0xc2002548}, + {0x60, 0x9a004001}, + {0x64, 0x9a0b6008}, + {0x68, 0x82087ff7}, + {0x6c, 0x8210400d}, + {0x70, 0xc2202548}, + {0x74, 0x81c7e008}, + {0x78, 0x81e80000}, + {0x7c, 0x00000000}, + {0xf0, 0xa1}, + {0x00, 0x00003628}, + {0x04, 0xa5010503}, + {0x08, 0xa5000022}, + {0x0c, 0x00000000}, + {0x10, 0x4c494348}, + {0x14, 0x49444449}, + {0x18, 0x80cb88ec}, + {0x1c, 0xbdae39cf}, + {0x20, 0x8648a980}, + {0x24, 0xc96fbe71}, + {0x28, 0x9243c641}, + {0x2c, 0xc654cc4d}, + {0x30, 0x80d1cce5}, + {0x34, 0xa898c9e5}, + {0x38, 0xc400bc0d}, + {0x3c, 0xbc43c643}, + {0x40, 0xbd130000}, + {0x44, 0x00000000}, + {0x48, 0x00000000}, + {0x4c, 0x00000000}, + {0x50, 0x00000000}, + {0x54, 0x00000000}, + {0x58, 0x00000000}, + {0x5c, 0x00000000}, + {0x60, 0x00000000}, + {0x64, 0x00000000}, + {0x68, 0x4a616e20}, + {0x6c, 0x20382032}, + {0x70, 0x30313800}, + {0x74, 0x00000000}, + {0x78, 0x31343a32}, + {0x7c, 0x363a3133}, + +}; +#endif