From 4a1212fde9128c3f5e16e14202bb2b4ae5f76e14 Mon Sep 17 00:00:00 2001 From: "jerry.zhang" Date: Mon, 18 Jul 2016 17:35:52 +0800 Subject: [PATCH] Input: add gslx680 touch panel for 3399 VR Change-Id: I89c3dd181324f6b39e50c40fd404743eab43fe52 Signed-off-by: jerry.zhang --- drivers/input/touchscreen/Kconfig | 5 + drivers/input/touchscreen/Makefile | 1 + drivers/input/touchscreen/gsl_point_id.c | 3100 +++++++++++++ drivers/input/touchscreen/gslx680.c | 1821 ++++++++ drivers/input/touchscreen/gslx680.h | 5403 ++++++++++++++++++++++ 5 files changed, 10330 insertions(+) create mode 100644 drivers/input/touchscreen/gsl_point_id.c create mode 100644 drivers/input/touchscreen/gslx680.c create mode 100644 drivers/input/touchscreen/gslx680.h diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig index e705afd4d866..3d99037f120b 100644 --- a/drivers/input/touchscreen/Kconfig +++ b/drivers/input/touchscreen/Kconfig @@ -335,6 +335,11 @@ config TOUCHSCREEN_GOODIX To compile this driver as a module, choose M here: the module will be called goodix. +config TOUCHSCREEN_GSLX680_VR + tristate "gslX680 touchpad driver for VR" + help + gslX680 touchpad driver for VR + config TOUCHSCREEN_GT9XX tristate "Goodix gt9xx support for rockchip platform" depends on I2C && ARCH_ROCKCHIP diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile index 922becb12d0e..e51c7dac2f30 100644 --- a/drivers/input/touchscreen/Makefile +++ b/drivers/input/touchscreen/Makefile @@ -38,6 +38,7 @@ obj-$(CONFIG_TOUCHSCREEN_EGALAX) += egalax_ts.o obj-$(CONFIG_TOUCHSCREEN_FT6236) += ft6236.o obj-$(CONFIG_TOUCHSCREEN_FUJITSU) += fujitsu_ts.o obj-$(CONFIG_TOUCHSCREEN_GOODIX) += goodix.o +obj-$(CONFIG_TOUCHSCREEN_GSLX680_VR) += gslx680.o gsl_point_id.o obj-$(CONFIG_TOUCHSCREEN_GT9XX) += gt9xx/ obj-$(CONFIG_TOUCHSCREEN_ILI210X) += ili210x.o obj-$(CONFIG_TOUCHSCREEN_IMX6UL_TSC) += imx6ul_tsc.o diff --git a/drivers/input/touchscreen/gsl_point_id.c b/drivers/input/touchscreen/gsl_point_id.c new file mode 100644 index 000000000000..624502b6bacc --- /dev/null +++ b/drivers/input/touchscreen/gsl_point_id.c @@ -0,0 +1,3100 @@ +/* + * drivers/input/touchscreen/gsl_point_id.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 "linux/module.h" +//#include +/* +NTSTATUS +DriverEntry( + IN PDRIVER_OBJECT DriverObject, + IN PUNICODE_STRING RegistryPath +); + +#ifdef ALLOC_PRAGMA +#pragma alloc_text(INIT, DriverEntry) +#endif + +NTSTATUS +DllInitialize( IN PUNICODE_STRING pus ) +{ + DbgPrint("GSL_POINT_ID: DllInitialize(%S)\n", pus->Buffer ); + return STATUS_SUCCESS; +} + +NTSTATUS +DllUnload( ) +{ + DbgPrint("GSL_POINT_ID: DllUnload\n"); + return STATUS_SUCCESS; +} +*/ +//#define GESTURE_ABLE 1 +#define GESTURE_LICH 1 + +#define GSL_VERSION 0x20140421 +#ifndef NULL +#define NULL ((void*)0) +#endif +#ifndef UINT +#define UINT unsigned int +#endif + +#define POINT_MAX 10 +#define PP_DEEP 10 +#define PS_DEEP 10 +#define PR_DEEP 10 +#define POINT_DEEP (PP_DEEP + PS_DEEP + PR_DEEP) +#define PRESSURE_DEEP 8 +#define CONFIG_LENGTH 512 +#define TRUE 1 +#define FALSE 0 +#define FLAG_ABLE (0x4<<12) +#define FLAG_FILL (0x2<<12) +#define FLAG_KEY (0x1<<12) +#define FLAG_COOR (0x0fff0fff) +#define FLAG_COOR_EX (0xffff0fff) +#define FLAG_ID (0xf0000000) + +struct gsl_touch_info +{ + int x[10]; + int y[10]; + int id[10]; + int finger_num; +}; + +typedef struct +{ + unsigned int i; + unsigned int j; + unsigned int min;//distance min + unsigned int d[POINT_MAX][POINT_MAX];//distance; +}gsl_DISTANCE_TYPE; + +typedef union +{ + struct + { + unsigned y:12; + unsigned key:1; + unsigned fill:1; + unsigned able:1; + unsigned predict:1; + unsigned x:16; + }other; + struct + { + unsigned y:13; + unsigned rev_2:3; + unsigned x:16; + }dis; + unsigned int all; +}gsl_POINT_TYPE; + +typedef union +{ + struct + { + unsigned delay:8; + unsigned report:8; + unsigned rev_1:14; + unsigned able:1; + unsigned init:1; + }other; + unsigned int all; +}gsl_DELAY_TYPE; + +typedef union +{ + struct + { + unsigned rev_0:8; + unsigned rev_1:8; + + unsigned rev_2:7; + unsigned ex:1; + + unsigned interpolation:4; + unsigned rev_3:1; + unsigned only:1; + unsigned mask:1; + unsigned reset:1; + }other; + unsigned int all; +}gsl_STATE_TYPE; + +typedef struct +{ + unsigned int rate; + unsigned int dis; + gsl_POINT_TYPE coor; +}gsl_EDGE_TYPE; + +typedef union +{ + struct + { + short y; + short x; + }other; + unsigned int all; +}gsl_DECIMAL_TYPE; + +typedef union +{ + struct + { + unsigned over_report_mask:1; + unsigned opposite_x:1; + unsigned opposite_y:1; + unsigned opposite_xy:1; + unsigned line:1; + unsigned line_neg:1; + unsigned line_half:1; + unsigned middle_drv:1; + + unsigned key_only_one:1; + unsigned key_line:1; + unsigned refe_rt:1; + unsigned refe_var:1; + unsigned base_median:1; + unsigned key_rt:1; + unsigned refe_reset:1; + unsigned sub_cross:1; + + unsigned row_neg:1; + unsigned sub_line_coe:1; + unsigned sub_row_coe:1; + unsigned c2f_able:1; + unsigned thumb:1; + unsigned graph_h:1; + unsigned init_repeat:1; + unsigned near_reset_able:1; + + unsigned emb_dead:1; + unsigned emb_point_mask:1; + unsigned interpolation:1; + unsigned sum2_able:1; + unsigned reduce_pin:1; + unsigned drv_order_ex:1; + unsigned id_over:1; + unsigned rev_1:1; + }other; + unsigned int all; +}gsl_FLAG_TYPE; + +static gsl_POINT_TYPE point_array[POINT_DEEP][POINT_MAX]; +static gsl_POINT_TYPE *point_pointer[PP_DEEP]; +static gsl_POINT_TYPE *point_stretch[PS_DEEP]; +static gsl_POINT_TYPE *point_report[PR_DEEP]; +static gsl_POINT_TYPE point_now[POINT_MAX]; +static gsl_DELAY_TYPE point_delay[POINT_MAX]; +static int filter_deep[POINT_MAX]; +static gsl_EDGE_TYPE point_edge; +static gsl_DECIMAL_TYPE point_decimal[POINT_MAX]; + +static unsigned int pressure_now[POINT_MAX]; +static unsigned int pressure_array[PRESSURE_DEEP][POINT_MAX]; +static unsigned int pressure_report[POINT_MAX]; +static unsigned int *pressure_pointer[PRESSURE_DEEP]; + +#define pp point_pointer +#define ps point_stretch +#define pr point_report +#define point_predict pp[0] +#define pa pressure_pointer + +static gsl_STATE_TYPE global_state; +static int inte_count; +static unsigned int csensor_count; +static unsigned int click_count[4]; +static gsl_POINT_TYPE point_click[4]; +static unsigned int double_click; +static int point_n; +static int point_num; +static int prev_num; +static int point_near; +static unsigned int point_shake; +static unsigned int reset_mask_send; +static unsigned int reset_mask_max; +static unsigned int reset_mask_count; +static gsl_FLAG_TYPE global_flag; +static unsigned int id_first_coe; +static unsigned int id_speed_coe; +static unsigned int id_static_coe; +static unsigned int average; +static unsigned int soft_average; +static unsigned int report_delay; +static unsigned int report_ahead; +static unsigned char median_dis[4]; +static unsigned int shake_min; +static int match_y[2]; +static int match_x[2]; +static int ignore_y[2]; +static int ignore_x[2]; +static int screen_y_max; +static int screen_x_max; +static int point_num_max; +static unsigned int drv_num; +static unsigned int sen_num; +static unsigned int drv_num_nokey; +static unsigned int sen_num_nokey; +static unsigned int coordinate_correct_able; +static unsigned int coordinate_correct_coe_x[64]; +static unsigned int coordinate_correct_coe_y[64]; +static unsigned int edge_cut[4]; +static unsigned int stretch_array[4*4*2]; +static unsigned int shake_all_array[2*8]; +static unsigned int reset_mask_dis; +static unsigned int reset_mask_type; +static unsigned int key_map_able; +static unsigned int key_range_array[8*3]; +static int filter_able; +static unsigned int filter_coe[4]; +static unsigned int multi_x_array[4],multi_y_array[4]; +static unsigned int multi_group[4][64]; +static int ps_coe[4][8],pr_coe[4][8]; +static int point_repeat[2]; +static int near_set[2]; +static int diagonal; +// unsigned int key_dead_time ; +// unsigned int point_dead_time ; +// unsigned int point_dead_time2 ; +// unsigned int point_dead_distance ; +// unsigned int point_dead_distance2 ; +// unsigned int pressure_able; +// unsigned int pressure_save[POINT_MAX]; +static unsigned int edge_first; +static unsigned int edge_first_coe; + +static unsigned int point_corner; +//------------------------------------------------- +static unsigned int config_static[CONFIG_LENGTH]; +//------------------------------------------------- +#ifdef GESTURE_ABLE + +#define MAXSTACK 200 +#define GesturePtNum 15 +typedef union +{ + + struct + { + unsigned y:16; + unsigned x:12; + unsigned id:4; + } point_data; + unsigned int data_int; +}POINT_TYPE_DEFINE; + +typedef struct +{ + int top; + POINT_TYPE_DEFINE point_buff[MAXSTACK]; +}TouchFinger; + +static struct +{ + int num[10]; + int flag; + int position; +}vector_x_y[2]; +static TouchFinger point_stack; +static int qushi_x[10]; +static int qushi_y[10]; +static int vector_change_x[MAXSTACK]; +static int vector_change_y[MAXSTACK]; +static int rate_weight[MAXSTACK]; +static POINT_TYPE_DEFINE top,bottom,left,right; +static int Letter_width; +static int Letter_height; +static unsigned int max_x,min_x,max_y,min_y; +static char gesture_letter; +#endif +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++ +#ifdef GESTURE_LICH +#define GESTURE_BUF_SIZE 256 +#define GESTURE_SIZE_REFE 255 +#define GESTURE_SIZE_NUM 32 +#define GESTURE_XY 0x1 +#define GESTURE_DEAL 0x2 +#define GESTURE_LRUD 0x4 +#define GESTURE_ALL 0x7fffffff +typedef union +{ + struct + { + unsigned y:12; + unsigned rev:4; + unsigned x:16; + }other; + unsigned int all; +}GESTURE_POINT_TYPE; +typedef struct +{ + int coe; + int out; + unsigned int coor[GESTURE_SIZE_NUM/2]; +}GESTURE_MODEL_TYPE; +//GESTURE_POINT_TYPE gesture_buf[GESTURE_BUF_SIZE];//gesture_buf +#define gesture_buf ((GESTURE_POINT_TYPE*)config_static) +#define gesture_standard ((GESTURE_POINT_TYPE*)(&config_static[GESTURE_BUF_SIZE])) +static int gesture_num,gesture_num_last;//gesture_num +static int gesture_dis_min; +static int gesture_deal; +static int gesture_last; +static int gesture_threshold[2]; +static int x_scale; +static int y_scale; +static int double_down,double_up; +static const GESTURE_MODEL_TYPE * model_extern = NULL; +static int model_extern_len = 0; +static int GestureSqrt(int d); +static int GestureDistance(GESTURE_POINT_TYPE* d1,GESTURE_POINT_TYPE* d2,int sqrt_able); +static int GesturePush(GESTURE_POINT_TYPE* data); +static int GestureStretch(void); +static int GestureLength(void); +static int GestureDeal(void); +static int GestureModel(const GESTURE_MODEL_TYPE * model,int len,int threshold,int *out); +static int GestureMain(unsigned int data[],unsigned int pn); +static void GestureStandard(void); +static void GestureInit(void); +static void ChangeXY(void); +static int GestureLRUD(void); +static void GestureSet(unsigned int conf[]); +static const GESTURE_MODEL_TYPE model_default[] +={ + {0x10,'3',{ + 0x37170105,0x78580000,0xba990a03,0xedd92e14,0xb9d85347,0x7798655b,0x3657716b,0x1f156d74, + 0x60406969,0xa2816f69,0xe3c28075,0xf9fbb899,0xc3e3e0d2,0x83a4f6ee,0x4262fffc,0x0021f7fd,}}, + {0x10,'6',{ + 0xa2be0400,0x70881f10,0x4258402e,0x1d2e6c54,0x040ea084,0x0a01d6bc,0x381df9ec,0x7054fffd, + 0xa88cfafe,0xdac2ddef,0xfff0b2cb,0xe2f78497,0xaac7747a,0x728e7472,0x3b56817b,0x0420968b,}}, + {0x10,'7',{ + 0x12000001,0x37240000,0x5b490000,0x806e0000,0xa5930000,0xcab70000,0xefdc0300,0xf9fd1f0e, + 0xe2ee3d30,0xc5d4564a,0xa7b76c61,0x8c9a8579,0x717e9f93,0x5863bbad,0x434cdbc9,0x3c3dffec,}}, + {0x10,'8',{ + 0xdaff030c,0x8eb40000,0x41670c06,0x001c3116,0x431e5448,0x8f69635d,0xd1b58a6f,0xcedfd0af, + 0x88acf5e6,0x3c62fffd,0x0718cdf1,0x341493aa,0x7a556d7d,0xc19e4f60,0xf9e51c3c,0xb5dc0005,}}, + {0x10,'8',{ + 0x627d231e,0x2f49382c,0x03175a48,0x21098172,0x563c958c,0x856eb0a2,0x8f99dac4,0x5b76eee5, + 0x243ffdf5,0x090ddbf4,0x2918acc2,0x4d3a8497,0x78636172,0xa38e4050,0xd0ba1f2e,0xffe7000f,}}, + {0x10,'9',{ + 0xe8ff0715,0xb4ce0001,0x819a0500,0x4f68150c,0x1e362a1e,0x000c543c,0x270d7169,0x5b417273, + 0x9076666d,0xbda74a5a,0xddcf1e36,0xc8d7321b,0xb4be634b,0xa4ac967d,0x959ccab0,0x898fffe4,}}, + {0x10,'A',{ + 0xaeca000b,0x74900e02,0x41582d1b,0x182a5942,0x02099375,0x0600cfb1,0x2c15fcea,0x664af1fe, + 0x957ec8dd,0xb5a894b0,0xc9bf5876,0xd7d31c3a,0xd4d75134,0xd3d38d6f,0xdbd4c9ab,0xffe9fce6,}}, + {0x10,'A',{ + 0x8eab0102,0x56711307,0x2c3f3a25,0x0e1b6b51,0x0004a689,0x0e02ddc2,0x3e22fbf2,0x725be8fa, + 0x9284b6d0,0xa69d7f9b,0xb3ae4562,0xb7b80b28,0xa7a6290c,0xb1aa6346,0xd0be947d,0xffe7bba7,}}, + {0x10,'B',{ + 0x56591a00,0x474e4e35,0x343f8168,0x242cb59c,0x0f1be7ce,0x170ddbf4,0x3c25b4c4,0x6e549ca6, + 0xa3889799,0xd8bd9d96,0xfcf1bea8,0xd3e9e4d4,0xa0baf6f0,0x6b85fcfa,0x3650fffd,0x001bfbff,}}, + {0x10,'C',{ + 0xfaff2337,0xdaec0913,0xb0c50003,0x879c0500,0x5f720f09,0x3b4c271a,0x1d2b4534,0x08116a56, + 0x0003937f,0x0a03bca8,0x2515ddce,0x4b38f2e8,0x7560fff9,0x9e89f7fd,0xc6b2e8f0,0xeed9d7df,}}, + {0x10,'C',{ + 0xacbf0100,0x86990a04,0x64751b12,0x45533225,0x2b375141,0x17217160,0x080f9582,0x0103bba8, + 0x0200e2cf,0x200ff9f1,0x4633fefc,0x6c59ffff,0x9380fcfd,0xb9a6f4f9,0xdccbe4ed,0xffeeceda,}}, + {0x10,'C',{ + 0x57670a00,0x3a492116,0x222d3d2e,0x0f175e4d,0x0408816f,0x0001a693,0x0300cab8,0x0e07eddc, + 0x2f1dfefb,0x5241f5fc,0x7362e2ec,0x8e80c9d6,0xa89bafbc,0xc3b594a1,0xe1d27e89,0xfff06673,}}, + {0x10,'D',{ + 0x99b5858f,0x5f7c8883,0x28429c8f,0x010fc6ab,0x240cf4e1,0x5d41fefb,0x957af1fc,0xc1adcbe0, + 0xd2cc92af,0xd3d25875,0xd7d71f3b,0xd7d71b02,0xd4d75538,0xd4d48f72,0xe1d9c9ac,0xffe6f4e6,}}, + {0x10,'E',{ + 0x391c948f,0x73569595,0xad908a92,0xddc8677e,0xf1ee304d,0xc3dd0d1b,0x89a70002,0x536d1304, + 0x233b3a25,0x08137053,0x0301aa8d,0x220edcc6,0x573af7ee,0x9174fffc,0xcaaef6ff,0xffe5dbeb,}}, + {0x10,'G',{ + 0xaaca0000,0x698a0000,0x2a491106,0x000f4226,0x23067061,0x64437674,0xa3836874,0xdac04759, + 0xfaec0b2a,0xfefb401f,0xffff8160,0xf5fdc0a1,0xc9e9eedf,0x89a9fff9,0x4869faff,0x0928e3f3,}}, + {0x10,'G',{ + 0xeaff1421,0xb9d20308,0x88a00000,0x57700f05,0x2b3f2618,0x09174d37,0x00037f66,0x0d05af97, + 0x2a1adac7,0x5940ede5,0x8b72f2f3,0xbca4e9ee,0xe4d2cbde,0xfbf09cb3,0xf5f8ceb5,0xe9f1ffe6,}}, + {0x10,'H',{ + 0x03021300,0x06053a26,0x0b0a604d,0x0b0b8774,0x0a0bae9a,0x0506d4c1,0x0002fbe8,0x1104e0f0, + 0x2e1ec3d1,0x503dadb5,0x7764a5a7,0x9e8aa1a2,0xc4b1a3a0,0xead8ada8,0xfff8d1bd,0xfffff8e4,}}, + {0x10,'K',{ + 0x1d1a2000,0x171a6040,0x1114a080,0x060edfc0,0x1100e2ff,0x3420a8c5,0x6f4f8b95,0xaf8f8285, + 0xefcf8683,0xe1fcb3a0,0xa0c1c2bb,0x6080c6c5,0x2c40c9c7,0x6c4cd8d1,0xac8ceadf,0xedccfef3,}}, + {0x10,'K',{ + 0x22341900,0x15185436,0x0e119072,0x0c0cccae,0x0709f6ea,0x0a07b9d8,0x2918859e,0x5b406170, + 0x90796658,0x627c8b7c,0x2a47a79a,0x110db8b1,0x4d2fbfbc,0x896bcac4,0xc3a6d9d1,0xffe1ede2,}}, + {0x10,'L',{ + 0x3f4a0c00,0x35372c1c,0x2c314d3d,0x26296e5d,0x1b218e7e,0x1316af9f,0x0910cfc0,0x0004f1e0, + 0x1605ffff,0x3727ffff,0x5848ffff,0x7a69fdff,0x9b8afcfd,0xbcabfcfc,0xddcdfafb,0xffeef9f9,}}, + {0x10,'M',{ + 0x0900e0ff,0x2017a0c0,0x3a296381,0x4e442443,0x5a583010,0x6b5f6f4f,0x7471ae8f,0x7977eece, + 0x8c80c5e5,0xa19886a5,0xbaad4766,0xd3c70a29,0xddda3516,0xe7e17555,0xf4f0b494,0xfffaf4d4,}}, + {0x10,'N',{ + 0x0400e7ff,0x130bb8cf,0x281e89a1,0x38305a71,0x51452c43,0x675d1d13,0x68684e36,0x6b697f66, + 0x726fb097,0x7875e0c8,0x907ee8f8,0xa79ebbd2,0xbfb38fa4,0xd1c95f77,0xe6da3148,0xfff20019,}}, + {0x10,'O',{ + 0x2e3f311f,0x101e5c46,0x03088f76,0x0001c2a8,0x1e08e7da,0x4f35fdf4,0x8168fcff,0xb39beef5, + 0xdac7cedf,0xf3e9a0b8,0xfef96d87,0xf9ff3c54,0xdaec1326,0xaac30108,0x77900100,0x465e1407,}}, + {0x10,'O',{ + 0xd0e30213,0x9cb60000,0x68820c05,0x384f2416,0x17254c36,0x040c8066,0x0001b49a,0x1305e4ce, + 0x442bfaf0,0x785efffe,0xab92f1f9,0xd3c1cfe3,0xf1e3a1b9,0xfffa6e88,0xf8ff3b54,0xd5e81024,}}, + {0x10,'O',{ + 0x000f768a,0x0900455d,0x2b171e30,0x5a420611,0x8d740100,0xbca5170b,0xe3d23824,0xfcf2644c, + 0xfaff977e,0xe3f0c4af,0xbdd2e6d7,0x8ea7faf2,0x5b74fefe,0x2e44e9f6,0x0a1bc2d6,0x02028fa9,}}, + {0x10,'O',{ + 0x829c0900,0x4e682315,0x24384a34,0x08157c61,0x0002b598,0x0d03edd1,0x4326fffd,0x7a5feef8, + 0xab93cfe0,0xd5c1a7bd,0xf4e67690,0xfbff3d5a,0xcfec1b26,0x96b31818,0x5e7a251d,0x28433b2f,}}, + {0x10,'O',{ + 0x381e5e68,0x6e535156,0xa388504f,0xd8be5e56,0xf9ed876d,0xf9fcbaa1,0xd8ece5d2,0xa5c0f9f2, + 0x708bfffd,0x3b55fbfe,0x1423d7ed,0x0006a4bf,0x09027089,0x26154157,0x50391e2e,0x7e670010,}}, + {0x10,'O',{ + 0x8670020b,0xb8a01307,0xe3ce3423,0xf8f0664c,0xfffc9b81,0xf1faceb5,0xcee4f4e5,0x9ab4fffb, + 0x657fffff,0x364ceaf8,0x1623c0d7,0x00098ea7,0x06015973,0x24122e41,0x4d380c1c,0x82670104,}}, + {0x10,'S',{ + 0xb7cf0001,0x869e0301,0x556d0905,0x273e1f12,0x0311442c,0x2009665a,0x5138726b,0x826a7876, + 0xb39b807b,0xdfcb998b,0xfff5bea7,0xdcf2ded0,0xadc6f1e8,0x7c94fbf7,0x4b63fffd,0x1932ffff,}}, + {0x10,'S',{ + 0xcbde0200,0xa8ba1209,0x8597241a,0x6a753f2f,0x806c5751,0xa6935e5b,0xccb96662,0xf2e0746b, + 0xfcff9482,0xe0f0b2a6,0xbdcfc2bb,0x97abd1c9,0x7385ddd7,0x4c60e8e3,0x273af4ee,0x0014fff9,}}, + {0x10,'U',{ + 0x050d2209,0x0001573c,0x03008c71,0x1106bfa6,0x2f1bebda,0x604ae1f0,0x8873bccd,0xa59990a8, + 0xbcb05f78,0xcdc72c46,0xd0d00911,0xc9cb3e24,0xc6c87359,0xc9c6a88d,0xd8d2ddc2,0xffe4fff6,}}, + {0x10,'V',{ + 0x09000f00,0x1911301f,0x27205240,0x342d7563,0x413a9785,0x4f47b9a8,0x6057d9c9,0x7569f9ea, + 0x9486f4ff,0xa99fd5e5,0xb8b0b4c5,0xc9c093a3,0xdbd17484,0xe9e35263,0xf5ef2f41,0xfff90b1d,}}, + {0x10,'V',{ + 0x08001908,0x160f3b2b,0x251d5d4c,0x312b806f,0x3e37a392,0x4843c6b5,0x524de9d8,0x5b58f2fb, + 0x6560cfe0,0x776dafbf,0x8a8090a0,0x9d947080,0xb4a85361,0xccc03745,0xe6d91d2a,0xfff2000e,}}, + {0x10,'W',{ + 0x06001f00,0x110c5f3f,0x1c189f7f,0x2822debe,0x4131e3fd,0x554ba4c3,0x655c6484,0x786f2444, + 0x847f2f0f,0x8a866f4f,0x928eae8f,0x9e99eece,0xbaacd0ee,0xd5c893b3,0xebe05373,0xfff61333,}}, + {0x10,'W',{ + 0xf7ff2000,0xe4ed6040,0xd5dba181,0xbdcbe0c0,0xa0aad3f3,0x909892b3,0x848a5272,0x80811131, + 0x777d3d1d,0x636d7e5e,0x535bbf9e,0x3c48fdde,0x272fc1e2,0x121a82a2,0x030a4161,0x00020021,}}, + {0x10,'Y',{ + 0x16000b13,0x442d0303,0x4b48341b,0x61505e4b,0x91795c62,0xbca74551,0xe1d02637,0xfcf40c14, + 0xe8f13922,0xdbe16951,0xd6d99a82,0xced3cbb2,0xb0c4f0e1,0x7f98fbf7,0x4e67fefd,0x1d36fdff,}}, + {0x10,'Z',{ + 0x30160200,0x644a0403,0x997f0303,0xcdb30202,0xe7e80d00,0xc4d63622,0x9bb05c4a,0x73857f6c, + 0x5061a893,0x293eccbb,0x0013f2dd,0x2d13fcfd,0x6248f6f8,0x967cf1f3,0xcbb1edef,0xffe5f1ec,}}, + //-------------------------------------------------------------------------------------------- + {0x10,0x1001,{ + 0x0003ecff,0x0502c6d9,0x0b099fb2,0x1410788c,0x221b5265,0x362b2f40,0x5341121d,0x7966020a, + 0xa08d0100,0xc3b3170b,0xd9ce3a28,0xede25f4d,0xf4f28672,0xfaf6ac99,0xfffdd3c0,0xfffffae6,}}, + {0x10,0x1002,{ + 0x1900847d,0x4c328785,0x7f658b88,0xb198898b,0xe3cb7f88,0xf8f24f68,0xecf81d35,0xbfd9010b, + 0x90a61504,0x8186462d,0x7c7d7960,0x7f7bac93,0x8883dfc6,0xaf97fff4,0xdcc7eafa,0xffeec1d7,}}, + {0x10,0x1003,{ + 0x7543141a,0xd7a82e17,0xf8f78f5c,0xc6e6e9bf,0x6497f8fa,0x1338b3db,0x03024f82,0x4a1c0620, + 0xaf7c1001,0xf8da582b,0xeafebc8b,0x9acbfbe6,0x3868eeff,0x0a1892c4,0x2712305f,0x85520e11,}}, + {0x10,0x1004,{ + 0x04003204,0x120b8e60,0x1714ebbd,0x2f27b8e6,0x43385b89,0x5b4c032d,0x6a666032,0x7770bc8e, + 0x8c82b8e6,0x9b945c8a,0xaea2012d,0xbbb75d2f,0xc9c1ba8c,0xe3d5bce7,0xf1ea5f8d,0xfff50231,}}, + {0x10,0x1005,{ + 0x1900020a,0x4d330400,0x7c65180a,0xa18f3f2b,0xb3ac7258,0xbcb8a58b,0xb0b9d7bf,0x8aa0fcec, + 0x5971f2fd,0x414bc2db,0x433f8ea8,0x534a5d76,0x71613246,0x9d85101e,0xd0b60609,0xffea1409,}}, + {0x10,0x1006,{ + 0xdeff0714,0x9abc0002,0x57790a02,0x1d373018,0x01076d4b,0x2f0f988a,0x72519c9c,0xb2948b9c, + 0xa3bc576b,0x60815653,0x26417963,0x020eb191,0x2005e7d3,0x6442fbf4,0xa785fbff,0xebc9e7f3,}}, + {0x10,0x1007,{ + 0xf6ff0600,0xe4ed140c,0xd5dd261d,0xc5cd362e,0xb3bc463e,0xa2aa574e,0x939a6860,0x83897970, + 0x747c8a82,0x646c9c93,0x525baca4,0x434abdb4,0x333bcfc6,0x222addd5,0x121beee6,0x0009fff6,}}, + {0x10,0x1008,{ + 0x09000900,0x19111b13,0x28202d24,0x39303d35,0x49424e45,0x5a515d56,0x6b626d65,0x7d747b74, + 0x8e868b82,0x9d969c93,0xaca4aea5,0xbcb4bfb6,0xcac4d1c7,0xdbd2e1d9,0xece3f1e9,0xfff5fff8,}}, + {0x10,0x1009,{ + 0x0a00faff,0x1d14edf4,0x2e25dce5,0x3e36cbd4,0x4e44bac2,0x5f57aab2,0x6f679aa2,0x7f778890, + 0x8c85757e,0x9c94636b,0xaba3515a,0xbbb2414a,0xcbc33039,0xddd31f28,0xeee51119,0xfff7000a,}}, + {0x10,0x100a,{ + 0xf4fffaff,0xe1eaeff6,0xd1d9dde6,0xc1cacdd5,0xb4bbbac3,0xa2aca8b0,0x929a99a1,0x83888791, + 0x767d747d,0x666e636b,0x535c545e,0x444d424b,0x333d323a,0x242b212a,0x141c0f18,0x000a0008,}}, + {0x10,0x100b,{ + 0x30000208,0x90600200,0xf1c11e0c,0xb5e64d3f,0x55855653,0x32245556,0x93625756,0xf1c3745e, + 0xbaeaa997,0x598ab2b0,0x0f29aab1,0x7040a8a7,0xd1a0b8ae,0xd0f8ecd0,0x6f9ffcf5,0x0e3ffcff,}}, + {0x10,0x100c,{ + 0x2600140c,0x66494226,0x827c8d66,0x6d80d8b4,0x284ffaf4,0x0a0ab9e0,0x411f8097,0x8e689182, + 0xd6b47f94,0xf9f23960,0xd5f80012,0x91af270a,0x7e83734c,0x7e7dc19a,0xb490fae5,0xffdbe9fe,}}, + {0x10,0x100d,{ + 0x768e0c00,0x465e2619,0x192f4635,0x0107745a,0x32178a85,0x674d858a,0x9b81747d,0xccb45c69, + 0xf7e33b4d,0xebfd0d21,0xb6d00004,0x939e270d,0x888d5d42,0x83859378,0x7c80c9ae,0x6c75ffe4,}}, + {0x10,0x100e,{ + 0xb3bd1000,0x9ea82d1e,0x87924a3b,0x6f7b6658,0x56628375,0x3e4a9e91,0x2934bcad,0x1720ddcd, + 0x010bfced,0x2513ffff,0x4937fdff,0x6d5bf9fa,0x9280f4f7,0xb6a4f0f1,0xdac8eeef,0xffececed,}}, +}; +#endif +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++ +static void SortBubble(int t[],int size) +{ + int temp = 0; + int m,n; + for(m=0;mt[n]) + { + t[m] = t[n]; + t[n] = temp; + } + } + } +} +int abs(int i){ + if(i<0) + return ~(--i); + return i; +} +static int Sqrt(int d) +{ + int ret = 0; + int i; + for(i=14;i>=0;i--) + { + if((ret + (0x1< point_num) + point_near = 8; + if(point_repeat[0]==0 || point_repeat[1]==0) + { + if(point_near) + pn = 96; + else + pn = 32; + } + else + { + if(point_near) + pn = point_repeat[1]; + else + pn = point_repeat[0]; + } + for(i=0;ix_min && xy_min && y= PP_DEEP * PS_DEEP * PR_DEEP * PRESSURE_DEEP) + point_n = 0; + pn = point_n % PP_DEEP; + for(i=0;i>4)&0xf; + ky = (coordinate_correct_able>>8)&0xf; + px[0] = coordinate_correct_coe_x; + py[0] = coordinate_correct_coe_y; + for(i=0;i>4)&0xf) == 3) + px[1] = multi_group[i++]; + if(((coordinate_correct_able>>8)&0xf) == 3) + py[1] = multi_group[i++]; + } + else + { + for(i=0;i> 16; + multi_y[i].range = multi_y_array[i] & 0xffff; + multi_y[i].group = multi_y_array[i] >> 16; + } + j=1; + for(i=0;i= edge_size && + point_now[i].other.x <= drv_num_nokey * 64 - edge_size) + { + if(kx == 3) + { + if (point_now[i].other.x & 64) + point_now[i].other.x = CCO(point_now[i].other.x, px[0], 2); + else + point_now[i].other.x = CCO(point_now[i].other.x, px[1], 2); + } + else + { + for(j=0;j= LINE_SIZE || + px[j + 1] == NULL || + multi_x[j].range == 0 || + point_now[i].other.x < multi_x[j].range)) + continue; + point_now[i].other.x = CCO(point_now[i].other.x, px[j], kx); + break; + } + } + } + if (point_now[i].other.y >= edge_size && + point_now[i].other.y <= sen_num_nokey * 64 - edge_size) + { + if(ky == 3) + { + if (point_now[i].other.y & 64) + point_now[i].other.y = CCO(point_now[i].other.y, py[0], 2); + else + point_now[i].other.y = CCO(point_now[i].other.y, py[1], 2); + } + else + { + for(j=0;j= LINE_SIZE || + py[j + 1] == NULL || + multi_y[j].range == 0 || + point_now[i].other.y < multi_y[j].range)) + continue; + point_now[i].other.y = CCO(point_now[i].other.y, py[j], ky); + break; + } + } + } + } +#undef LINE_SIZE +} + +static void PointPredictOne(unsigned int n) +{ + pp[0][n].all = pp[1][n].all & FLAG_COOR; + pp[0][n].other.predict = 0; +} + +static void PointPredictTwo(unsigned int n) +{ + unsigned int t; + pp[0][n].all = 0; + t = pp[1][n].other.x * 2; + if (t > pp[2][n].other.x) + t -= pp[2][n].other.x; + else + t = 0; + if(t > 0xffff) + pp[0][n].other.x = 0xffff; + else + pp[0][n].other.x = t; + t = pp[1][n].other.y * 2; + if (t > pp[2][n].other.y) + t -= pp[2][n].other.y; + else + t = 0; + if(t > 0xfff) + pp[0][n].other.y = 0xfff; + else + pp[0][n].other.y = t; + pp[0][n].other.predict = 1; +} + +static void PointPredictThree(unsigned int n) +{ + unsigned int t,t2; + pp[0][n].all = 0; + t = pp[1][n].other.x * 5 + pp[3][n].other.x; + t2 = pp[2][n].other.x * 4; + if(t > t2) + t -= t2; + else + t = 0; + t /= 2; + if(t > 0xffff) + pp[0][n].other.x = 0xffff; + else + pp[0][n].other.x = t; + t = pp[1][n].other.y * 5 + pp[3][n].other.y; + t2 = pp[2][n].other.y * 4; + if(t > t2) + t -= t2; + else + t = 0; + t /= 2; + if(t > 0xfff) + pp[0][n].other.y = 0xfff; + else + pp[0][n].other.y = t; + pp[0][n].other.predict = 1; +} + +static void PointPredict(void) +{ + int i; + for(i=0;idis.x; + b = p2->dis.x; + ret = (a-b)*(a-b); + a = p1->dis.y; + b = p2->dis.y; + ret += (a-b)*(a-b); + return ret; +} + +static void DistanceInit(gsl_DISTANCE_TYPE *p) +{ + int i; + unsigned int *p_int = &(p->d[0][0]); + for(i=0;imin = 0x7fffffff; + for(j=0;jd[j][i] < p->min) + { + p->i = i; + p->j = j; + p->min = p->d[j][i]; + } + } + } + if(p->min == 0x7fffffff) + return 0; + return 1; +} + +static void DistanceIgnore(gsl_DISTANCE_TYPE *p) +{ + int i,j; + for(i=0;id[p->j][i] = 0x7fffffff; + for(j=0;jd[j][p->i] = 0x7fffffff; +} + +static int SpeedGet(int d) +{ + int i; + for(i=8;i>0;i--) + { + if(d > 0x100<= (id_static_coe + + id_speed[distance.i] * id_speed_coe) /**average/(soft_average+1)*/) + { + //point_now[distance.j].id = 0xf;//new id + continue; + } + pp[0][distance.i].all = point_now[distance.j].all; + pa[0][distance.i] = pressure_now[distance.j]; + point_now[distance.j].all = 0; + DistanceIgnore(&distance); + } + } +} + +static int ClearLenPP(int i) +{ + int n; + for(n=0;n (int)(1+1)) + { + pp[0][id-1].all = point_now[j].all; + pa[0][id-1] = pressure_now[j]; + point_now[j].all = 0; + break; + } + } + } + } +} + +static void PointOrder(void) +{ + int i; + for(i=0;i pp[1][i].other.x) + || (pp[0][j].other.x > pp[0][i].other.x && pp[1][j].other.x < pp[1][i].other.x)) + && ((pp[0][j].other.y < pp[0][i].other.y && pp[1][j].other.y > pp[1][i].other.y) + || (pp[0][j].other.y > pp[0][i].other.y && pp[1][j].other.y < pp[1][i].other.y))) + { + t = pp[0][i].other.x; + pp[0][i].other.x = pp[0][j].other.x; + pp[0][j].other.x = t; + t = pp[0][i].other.y; + pp[0][i].other.y = pp[0][j].other.y; + pp[0][j].other.y = t; + } + } + } +} + +static void GetPointNum(gsl_POINT_TYPE *pt) +{ + int i; + point_num = 0; + for(i=0;i> 3 * + ((point_num>10 ? 10 : point_num) - 1)) & 0x7; + point_delay[i].other.report = (report_ahead >> 3 * + ((point_num>10 ? 10 : point_num) - 1)) & 0x7; + if (point_delay[i].other.report > point_delay[i].other.delay) + point_delay[i].other.report = point_delay[i].other.delay; + point_delay[i].other.init = 1; + } + if(pp[0][i].all == 0) + { + point_delay[i].other.init = 0; + } + if (point_delay[i].other.able == 0 && point_delay[i].other.init != 0) + { + for (j = 0; j <= (int)point_delay[i].other.delay; j++) + if (pp[j][i].all == 0 || + pp[j][i].other.fill != 0 || + pp[j][i].other.able != 0) + break; + if (j <= (int)point_delay[i].other.delay) + continue; + point_delay[i].other.able = 1; + } + if (pp[point_delay[i].other.report][i].all == 0) + { + point_delay[i].other.able = 0; + continue; + } + if (point_delay[i].other.able == 0) + continue; + if (point_delay[i].other.report) + { + if (PointDistance(&pp[point_delay[i].other.report][i], + &pp[point_delay[i].other.report - 1][i]) < 3 * 3) + point_delay[i].other.report--; + } + } +} + +static void FilterOne(int i,int *ps_c,int *pr_c,int denominator) +{ + int j; + int x=0,y=0; + pr[0][i].all = ps[0][i].all; + if(pr[0][i].all == 0) + return; + if(denominator <= 0) + return; + for(j=0;j<8;j++) + { + x += (int)pr[j][i].other.x * (int)pr_c[j] + + (int)ps[j][i].other.x * (int)ps_c[j]; + y += (int)pr[j][i].other.y * (int)pr_c[j] + + (int)ps[j][i].other.y * (int)ps_c[j]; + } + x = (x + denominator/2) / denominator; + y = (y + denominator/2) / denominator; + if(x < 0) + x = 0; + if(x > 0xffff) + x = 0xffff; + if(y < 0) + y = 0; + if(y > 0xfff) + y = 0xfff; + pr[0][i].other.x = x; + pr[0][i].other.y = y; +} + +static unsigned int FilterSpeed(int i) +{ + return (Sqrt(PointDistance(&ps[0][i],&ps[1][i])) + + Sqrt(PointDistance(&ps[1][i],&ps[2][i])))/2; +} + +static int MedianSpeedOver(int id,int deep) +{ + int i; + unsigned int dis; + int speed_over = 0; + deep = deep/2 - 1; + if(deep < 0 || deep > 3) + return TRUE; + dis = median_dis[deep] * median_dis[deep]; + for(i=0;i<=deep && i dis) + speed_over ++; + } + if(speed_over >= 2) + return TRUE; + return FALSE; +} + +static void PointMedian(void) +{ + int i,j; + int deep; + int buf_x[PS_DEEP],buf_y[PS_DEEP]; + for(i=0;i= PS_DEEP) + deep = PS_DEEP-1; + deep |= 1; + for(;deep>=3;deep-=2) + { + if(MedianSpeedOver(i,deep)) + continue; + for(j=0;j=0 && filter_able <= 1) + return; + if(filter_able > 1) + { + for(i=0;i<8;i++) + { + ps_c[i] = (filter_coe[i/4] >> ((i%4)*8)) & 0xff; + pr_c[i] = (filter_coe[i/4+2] >> ((i%4)*8)) & 0xff; + if(ps_c[i] >= 0x80) + ps_c[i] |= 0xffffff00; + if(pr_c[i] >= 0x80) + pr_c[i] |= 0xffffff00; + } + for(i=0;i 0 && + speed_now > filter_speed[filter_deep[i]+1 - 2]) + filter_deep[i] --; + else if(filter_deep[i] < 3 && + speed_now < filter_speed[filter_deep[i]+1 + 2]) + filter_deep[i] ++; + + FilterOne(i,ps_coe[filter_deep[i]], + pr_coe[filter_deep[i]],0-filter_able); + } + } +} +static unsigned int KeyMap(int *drv,int *sen) +{ + typedef struct + { + unsigned int up_down,left_right; + unsigned int coor; + }KEY_TYPE_RANGE; + KEY_TYPE_RANGE *key_range = (KEY_TYPE_RANGE * )key_range_array; + int i; + for(i=0;i<8;i++) + { + if((unsigned int)*drv >= (key_range[i].up_down >> 16) + && (unsigned int)*drv <= (key_range[i].up_down & 0xffff) + && (unsigned int)*sen >= (key_range[i].left_right >> 16) + && (unsigned int)*sen <= (key_range[i].left_right & 0xffff)) + { + *sen = key_range[i].coor >> 16; + *drv = key_range[i].coor & 0xffff; + return key_range[i].coor; + } + } + return 0; +} + +static unsigned int ScreenResolution(gsl_POINT_TYPE *p) +{ + int x,y; + x = p->other.x; + y = p->other.y; + if (p->other.key == FALSE) + { + y = ((y - match_y[1]) * match_y[0] + 2048)/4096; + x = ((x - match_x[1]) * match_x[0] + 2048)/4096 ; + } + y = y * (int)screen_y_max / ((int)sen_num_nokey * 64); + x = x * (int)screen_x_max / ((int)drv_num_nokey * 64); + if (p->other.key == FALSE) + { + if((ignore_y[0]!=0 || ignore_y[1]!=0)) + { + if(y < ignore_y[0]) + return 0; + if(ignore_y[1] <= screen_y_max/2 && y > screen_y_max - ignore_y[1]) + return 0; + if(ignore_y[1] >= screen_y_max/2 && y > ignore_y[1]) + return 0; + } + if(ignore_x[0]!=0 || ignore_x[1]!=0) + { + if(x < ignore_x[0]) + return 0; + if(ignore_x[1] <= screen_y_max/2 && x > screen_x_max - ignore_x[1]) + return 0; + if(ignore_x[1] >= screen_y_max/2 && x > ignore_x[1]) + return 0; + } + if(y <= (int)edge_cut[2]) + y = (int)edge_cut[2] + 1; + if(y >= screen_y_max - (int)edge_cut[3]) + y = screen_y_max - (int)edge_cut[3] - 1; + if(x <= (int)edge_cut[0]) + x = (int)edge_cut[0] + 1; + if(x >= screen_x_max - (int)edge_cut[1]) + x = screen_x_max - (int)edge_cut[1] - 1; + if (global_flag.other.opposite_x) + y = screen_y_max - y; + if (global_flag.other.opposite_y) + x = screen_x_max - x; + if (global_flag.other.opposite_xy) + { + y ^= x; + x ^= y; + y ^= x; + } + } + else + { + if(y < 0) + y = 0; + if(x < 0) + x = 0; + if((key_map_able & 0x1) != FALSE && KeyMap(&x,&y) == 0) + return 0; + } + return ((y<<16) & 0x0fff0000) + (x & 0x0000ffff); +} + +static void PointReport(struct gsl_touch_info *cinfo) +{ + int i; + unsigned int data[POINT_MAX]; + int num = 0; + if (point_num > point_num_max && global_flag.other.over_report_mask != 0) + { + point_num = 0; + cinfo->finger_num = 0; + return; + } + for(i=0;i= PR_DEEP - 1) + continue; + if (pr[point_delay[i].other.report + 1][i].other.able == 0) + continue; + if (pr[point_delay[i].other.report][i].all) + { + pr[point_delay[i].other.report][i].other.able = 1; + data[i] = ScreenResolution(&pr[point_delay[i].other.report][i]); + if(data[i]) + { + data[i] |= (i+1)<<28; + num++; + } + } + } + for(i=0;i= PR_DEEP) + continue; + if (pr[point_delay[i].other.report][i].all == 0) + continue; + if (pr[point_delay[i].other.report][i].other.able == 0) + { + pr[point_delay[i].other.report][i].other.able = 1; + data[i] = ScreenResolution(&pr[point_delay[i].other.report][i]); + if(data[i]) + { + data[i] |= (i+1)<<28; + num++; + } + } + } + } + else + { + num=0; + for(i=0;i= PR_DEEP) + continue; + data[num] = ScreenResolution(&pr[point_delay[i].other.report][i]); + if(data[num]) + data[num++] |= (i+1)<<28; + } + } + num = 0; + for(i=0;ix[num] = (data[i] >> 16) & 0xfff; + cinfo->y[num] = data[i] & 0xfff; + cinfo->id[num] = data[i] >> 28; + pressure_now[num] = pressure_report[i]; + num ++; + } + point_num = num; + cinfo->finger_num = num; +} + + + +static void PointEdge(void) +{ + typedef struct + { + int range; + int coe; + }STRETCH_TYPE; + typedef struct + { + STRETCH_TYPE up[4]; + STRETCH_TYPE down[4]; + STRETCH_TYPE left[4]; + STRETCH_TYPE right[4]; + }STRETCH_TYPE_ALL; + STRETCH_TYPE_ALL *stretch; + int i,id; + int data[2]; + int x,y; + int sac[4*4*2]; + if(screen_x_max == 0 || screen_y_max == 0) + return; + id = 0; + for(i=0;i<4*4*2;i++) + { + sac[i] = stretch_array[i]; + if(sac[i]) + id++; + } + if(id == 0) + return; + stretch = (STRETCH_TYPE_ALL *)sac; + for(i=0;i<4;i++) + { + if(stretch->right[i].range > screen_y_max * 64 / 128 + || stretch->down [i].range > screen_x_max * 64 / 128) + { + for(i=0;i<4;i++) + { + if(stretch->up[i].range) + stretch->up[i].range = + stretch->up[i].range * + drv_num_nokey * 64 / screen_x_max; + if(stretch->down[i].range) + stretch->down[i].range = + (screen_x_max - + stretch->down[i].range) * + drv_num_nokey * 64 / screen_x_max; + if(stretch->left[i].range) + stretch->left[i].range = + stretch->left[i].range * + sen_num_nokey * 64 / screen_y_max; + if(stretch->right[i].range) + stretch->right[i].range = + (screen_y_max - + stretch->right[i].range) * + sen_num_nokey * 64 / screen_y_max; + } + break; + } + } + for(id=0;idleft[i].range == 0) + break; + if(data[1] < stretch->left[i].range) + { + data[0] += (stretch->left[i].range - data[1]) * + stretch->left[i].coe/128; + data[1] = stretch->left[i].range; + } + } + y = data[1] - data[0]; + if(y <= 0) + y = 1; + if(y >= (int)sen_num_nokey*64) + y = sen_num_nokey*64 - 1; + + data[0] = 0; + data[1] = sen_num_nokey * 64 - y; + for(i=0;i<4;i++) + { + if(stretch->right[i].range == 0) + break; + if(data[1] < stretch->right[i].range) + { + data[0] += (stretch->right[i].range - data[1]) * + stretch->right[i].coe/128; + data[1] = stretch->right[i].range; + } + } + y = sen_num_nokey * 64 - (data[1] - data[0]); + if(y <= 0) + y = 1; + if(y >= (int)sen_num_nokey*64) + y = sen_num_nokey*64 - 1; + + data[0] = 0; + data[1] = x; + for(i=0;i<4;i++) + { + if(stretch->up[i].range == 0) + break; + if(data[1] < stretch->up[i].range) + { + data[0] += (stretch->up[i].range - data[1]) * + stretch->up[i].coe/128; + data[1] = stretch->up[i].range; + } + } + x = data[1] - data[0]; + if(x <= 0) + x = 1; + if(x >= (int)drv_num_nokey*64) + x = drv_num_nokey*64 - 1; + + data[0] = 0; + data[1] = drv_num_nokey * 64 - x; + for(i=0;i<4;i++) + { + if(stretch->down[i].range == 0) + break; + if(data[1] < stretch->down[i].range) + { + data[0] += (stretch->down[i].range - data[1]) * + stretch->down[i].coe/128; + data[1] = stretch->down[i].range; + } + } + x = drv_num_nokey * 64 - (data[1] - data[0]); + if(x <= 0) + x = 1; + if(x >= (int)drv_num_nokey*64) + x = drv_num_nokey*64 - 1; + + point_now[id].other.x = x; + point_now[id].other.y = y; + } +} + +static void PointStretch(void) +{ + static int save_dr[POINT_MAX],save_dn[POINT_MAX]; + typedef struct + { + int dis; + int coe; + }SHAKE_TYPE; + SHAKE_TYPE * shake_all = (SHAKE_TYPE *) shake_all_array; + int i,j; + int dn; + int dr; + int dc[9],ds[9]; + int len = 8; + unsigned int temp; + for(i=0;i> 24) & 0xff)) + point_edge.coor.other.x = ((edge_first >> 24) & 0xff); + if (point_edge.coor.other.x > drv_num_nokey * 64 - ((edge_first >> 16) & 0xff)) + point_edge.coor.other.x = drv_num_nokey * 64 - ((edge_first >> 16) & 0xff); + if (point_edge.coor.other.y < (unsigned int)((edge_first >> 8) & 0xff)) + point_edge.coor.other.y = ((edge_first >> 8) & 0xff); + if (point_edge.coor.other.y > sen_num_nokey * 64 - ((edge_first >> 0) & 0xff)) + point_edge.coor.other.y = sen_num_nokey * 64 - ((edge_first >> 0) & 0xff); + if(point_edge.coor.all != ps[0][i].all) + { + point_edge.dis = PointDistance(&ps[0][i],&point_edge.coor); + if(point_edge.dis) + point_edge.rate = 0x1000; + } + } + if(point_edge.rate!=0 && point_edge.dis!=0) + { + temp = PointDistance(&ps[0][i],&point_edge.coor); + if(temp >= point_edge.dis * edge_first_coe / 0x80) + { + point_edge.rate = 0; + } + else if(temp > point_edge.dis) + { + temp = (point_edge.dis * edge_first_coe / 0x80 - temp) * + 0x1000 / point_edge.dis; + if(temp < point_edge.rate) + point_edge.rate = temp; + } + ps[0][i].other.x = point_edge.coor.other.x + + (ps[0][i].other.x - point_edge.coor.other.x) * + (0x1000 - point_edge.rate) / 0x1000; + ps[0][i].other.y = point_edge.coor.other.y + + (ps[0][i].other.y - point_edge.coor.other.y) * + (0x1000 - point_edge.rate) / 0x1000; + } + } + if(ps[1][i].all == 0) + { + continue; + } + else if((point_shake & (0x1<ds[0] ? dn-ds[0] : 0; + temp = ps[0][i].all; + if(dn == 0 || dr == 0) + { + ps[0][i].other.x = ps[1][i].other.x; + ps[0][i].other.y = ps[1][i].other.y; + } + else + { + ps[0][i].other.x = (int)ps[1][i].other.x + + ((int)pp[0][i].other.x - + (int)ps[1][i].other.x) * dr / dn; + ps[0][i].other.y = (int)ps[1][i].other.y + + ((int)pp[0][i].other.y - + (int)ps[1][i].other.y) * dr / dn; + } + if(dc[0] > 0) + { + if(ps[0][i].all == ps[1][i].all && temp != ps[0][i].all) + { + ps[0][i].all = temp; + point_decimal[i].other.x += + (short)ps[0][i].other.x - + (short)ps[1][i].other.x; + point_decimal[i].other.y += + (short)ps[0][i].other.y - + (short)ps[1][i].other.y; + ps[0][i].other.x = ps[1][i].other.x; + ps[0][i].other.y = ps[1][i].other.y; + if (point_decimal[i].other.x > dc[0] && ps[1][i].other.x < 0xffff) + { + ps[0][i].other.x += 1; + point_decimal[i].other.x = 0; + } + if (point_decimal[i].other.x < -dc[0] && ps[1][i].other.x > 0) + { + ps[0][i].other.x -= 1; + point_decimal[i].other.x = 0; + } + if (point_decimal[i].other.y > dc[0] && ps[1][i].other.y < 0xffff) + { + ps[0][i].other.y += 1; + point_decimal[i].other.y = 0; + } + if (point_decimal[i].other.y < -dc[0] && ps[1][i].other.y > 0) + { + ps[0][i].other.y -= 1; + point_decimal[i].other.y = 0; + } + } + else + { + point_decimal[i].other.x = 0; + point_decimal[i].other.y = 0; + } + } + } + + } + else if(len >= 2) + { + for(i=0;i<8 && i= 128 || shake_all[0].coe <= shake_all[1].coe) + { + ds[0] = ds[1]; + dc[0] = dc[1]; + } + else + { + ds[0] = ds[1] + (128 - shake_all[0].coe) * + (ds[1]-ds[2])/(shake_all[0].coe - shake_all[1].coe); + dc[0] = 128; + } + for(i=0;i= ds[0]) + { + continue; + } + if(dn < save_dn[i]) + { + dr = save_dr[i]; + save_dn[i] = dn; + ps[0][i].other.x = (int)ps[1][i].other.x + + (((int)pp[0][i].other.x - + (int)ps[1][i].other.x) * dr) / 128; + ps[0][i].other.y = (int)ps[1][i].other.y + + (((int)pp[0][i].other.y - + (int)ps[1][i].other.y) * dr) / 128; + continue; + } + for(j=0;j<=len;j++) + { + if(j == len || dn == 0) + { + ps[0][i].other.x = ps[1][i].other.x; + ps[0][i].other.y = ps[1][i].other.y; + break; + } + else if(ds[j] > dn && dn >=ds[j+1]) + { + dr = dc[j+1] + ((dn - ds[j+1]) * (dc[j] - dc[j+1])) / (ds[j] - ds[j+1]); + save_dr[i] = dr; + save_dn[i] = dn; +// ps[0][i].x = (int)ps[1][i].x + ((int)pp[0][i].x - (int)ps[1][i].x) * dr / dn / 128; +// ps[0][i].y = (int)ps[1][i].y + ((int)pp[0][i].y - (int)ps[1][i].y) * dr / dn / 128; + ps[0][i].other.x = (int)ps[1][i].other.x + + (((int)pp[0][i].other.x - + (int)ps[1][i].other.x) * dr + 64) / 128; + ps[0][i].other.y = (int)ps[1][i].other.y + + (((int)pp[0][i].other.y - + (int)ps[1][i].other.y) * dr + 64) / 128; + break; + } + } + } + } + else + { + return; + } +} + +static void ResetMask(void) +{ + if(reset_mask_send) + { + reset_mask_send = 0; + } + if (global_state.other.mask) + return; + if(reset_mask_dis ==0 || reset_mask_type == 0) + return; + if(reset_mask_max == 0xfffffff1) + { + if(point_num == 0) + reset_mask_max = 0xf0000000 + 1; + return; + } + if(reset_mask_max > 0xf0000000) + { + reset_mask_max --; + if(reset_mask_max == 0xf0000000) + { + reset_mask_send = reset_mask_type; + global_state.other.mask = 1; + } + return; + } + if(point_num > 1 || pp[0][0].all == 0) + { + reset_mask_count = 0; + reset_mask_max = 0; + reset_mask_count = 0; + return; + } + reset_mask_count ++; + if(reset_mask_max == 0) + reset_mask_max = pp[0][0].all; + else + if(PointDistance((gsl_POINT_TYPE*)(&reset_mask_max),pp[0]) > + (((unsigned int)reset_mask_dis) & 0xffffff) && + reset_mask_count > (((unsigned int)reset_mask_dis) >> 24)) + reset_mask_max = 0xfffffff1; +} + +static int ConfigCoorMulti(int data[]) +{ + int i,j; + int n = 0; + for(i=0;i<4;i++) + { + if(data[247+i]!=0) + { + if((data[247+i]&63)==0 && (data[247+i]>>16)<4) + n++; + else + return FALSE; + } + if(data[251+i]!=0) + { + if((data[251+i]&63)==0 && (data[251+i]>>16)<4) + n++; + else + return FALSE; + } + } + if(n == 0 || n > 4) + return FALSE; + for(j=0;j= 64) + return FALSE; + if(i) + { + if(data[256+j*64+i] < data[256+j*64+i-1]) + return FALSE; + } + } + } + return TRUE; +} + +static int ConfigFilter(unsigned int data[]) +{ + int i; + unsigned int ps_c[8]; + unsigned int pr_c[8]; + unsigned int sum = 0; + //if(data[242]>1 && (data[255]>=0 && data[255]<=256)) + if (data[242]>1 && (data[255] <= 256)) + { + for(i=0;i<8;i++) + { + ps_c[i] = (data[243+i/4] >> ((i%4)*8)) & 0xff; + pr_c[i] = (data[243+i/4+2] >> ((i%4)*8)) & 0xff; + if(ps_c[i] >= 0x80) + ps_c[i] |= 0xffffff00; + if(pr_c[i] >= 0x80) + pr_c[i] |= 0xffffff00; + sum += ps_c[i]; + sum += pr_c[i]; + } + if(sum == data[242] || sum + data[242] == 0) + return TRUE; + } + return FALSE; +} + +static int ConfigKeyMap(int data[]) +{ + int i; + if(data[217] != 1) + return FALSE; + for(i=0;i<8;i++) + { + if(data[218+2] == 0) + return FALSE; + if((data[218+i*3+0]>>16) > (data[218+i*3+0]&0xffff)) + return FALSE; + if((data[218+i*3+1]>>16) > (data[218+i*3+1]&0xffff)) + return FALSE; + } + return TRUE; +} + +static int DiagonalDistance(gsl_POINT_TYPE *p,int type) +{ + int divisor,square; + divisor = ((int)sen_num_nokey * (int)sen_num_nokey + + (int)drv_num_nokey * (int)drv_num_nokey)/16; + if(divisor == 0) + divisor = 1; + if(type == 0) + square = ((int)sen_num_nokey*(int)(p->other.x) - + (int)drv_num_nokey*(int)(p->other.y)) / 4; + else + square = ((int)sen_num_nokey*(int)(p->other.x) + + (int)drv_num_nokey*(int)(p->other.y) - + (int)sen_num_nokey*(int)drv_num_nokey * 64) / 4; + return square * square / divisor; +} + +static void DiagonalCompress(gsl_POINT_TYPE *p,int type,int dis,int dis_max) +{ + int x,y; + int tx,ty; + int cp_ceof; + if(dis_max == 0) + return; + if(dis > dis_max) + cp_ceof = (dis - dis_max)*128/(3*dis_max) + 128; + else + cp_ceof = 128; + if(cp_ceof > 256) + cp_ceof = 256; + x = p->other.x; + y = p->other.y; + if(type) + y = (int)sen_num_nokey*64 - y; + x *= (int)sen_num_nokey; + y *= (int)drv_num_nokey; + tx = x; + ty = y; + x = ((tx+ty)+(tx-ty)*cp_ceof/256)/2; + y = ((tx+ty)+(ty-tx)*cp_ceof/256)/2; + x /= (int)sen_num_nokey; + y /= (int)drv_num_nokey; + if(type) + y = sen_num_nokey*64 - y; + if(x < 1) + x = 1; + if(y < 1) + y = 1; + if(x >= (int)drv_num_nokey*64) + x = drv_num_nokey*64 - 1; + if(y >= (int)sen_num_nokey*64) + y = (int)sen_num_nokey*64 - 1; + p->other.x = x; + p->other.y = y; +} + +static void PointDiagonal(void) +{ + int i; + int diagonal_size; + int dis; + unsigned int diagonal_start; + if(diagonal == 0) + return; + diagonal_size = diagonal * diagonal; + diagonal_start = diagonal * 3/2; + for(i=0;i= drv_num_nokey * 64 - diagonal_start && + ps[0][i].other.y >= sen_num_nokey * 64 - diagonal_start)) + point_corner |= 0x2<= sen_num_nokey * 64 - diagonal_start) || + (ps[0][i].other.x >= drv_num_nokey * 64 - diagonal_start && + ps[0][i].other.y <= diagonal_start)) + point_corner |= 0x3< diagonal_size*4) + { + point_corner &= ~(0x3<> 28; + point_now[i].all &= ~(0xf<<28); + } +} + +static void PointPressure(void) +{ + int i,j; + for(i=0;i= 2) + j -= 2; + else if(j <= -2) + j += 2; + else + j = 0; + pressure_report[i] = pressure_report[i]+j; + } +} + +void gsl_ReportPressure(unsigned int *p) +{ + int i; + for(i=0;i 63+7) + p[i] = 63; + else + p[i] = pressure_now[i] - 7; + } + else + p[i] = 0; + } +} +//EXPORT_SYMBOL(gsl_ReportPressure); + +int gsl_TouchNear(void) +{ + return 0; +} +//EXPORT_SYMBOL(gsl_TouchNear); + +static void DoubleClick(void) +{ + int i; + unsigned int width[3]; + double_click = 0; +// printk("sileadinc DoubleClick c = %08x , %08x\n",csensor_count,pp[0][0].all); + if (point_num >= 2 || (point_num == 1 && pp[0][0].all == 0) || pp[0][0].other.key) + { +// printk("sileadinc DoubleClick return\n"); + for(i=0;i0;i--) + click_count[i] = click_count[i-1]; + click_count[0] = csensor_count; + for(i=sizeof(point_click)/sizeof(point_click[0])-1;i>1;i--) + point_click[i].all = point_click[i-2].all; + point_click[0].all = pp[0][0].all; + point_click[1].all = pp[0][0].all; + } + if(point_num!=0 && prev_num!=0) + { + if(PointDistance(&point_click[1],&pp[0][0]) > PointDistance(&point_click[1],&point_click[0])) + point_click[0].all = pp[0][0].all; + } + if(point_num==0 && prev_num!=0) + { +// printk("sileadinc DoubleClick point_click %08x %08x %08x %08x\n",point_click[0],point_click[1],point_click[2],point_click[3]); + for(i=sizeof(click_count)/sizeof(click_count[0])-1;i>0;i--) + click_count[i] = click_count[i-1]; + click_count[0] = csensor_count; + for(i=0;i=double_down*average && width[2]>=double_down*average && width[1]<=double_up*average)) + { +// printk("sileadinc DoubleClick width %08x %08x %08x\n",width[0],width[1],width[2]); + return; + } + if(PointDistance(&point_click[0],&point_click[1]) > 64*64 + || PointDistance(&point_click[2],&point_click[3]) > 64*64 + || PointDistance(&point_click[1],&point_click[3]) > 128*128) + { +// printk("sileadinc DoubleClick distance %08x %08x %08x\n", +// PointDistance(&point_click[0],&point_click[1]), +// PointDistance(&point_click[2],&point_click[3]), +// PointDistance(&point_click[1],&point_click[3])); + return; + } + for(i=0;i>16; + drv_num_nokey = conf[0x13]&0xffff; + sen_num_nokey = conf[0x13]>>16; + screen_x_max = conf[0x14]&0xffff; + screen_y_max = conf[0x14]>>16; + average = conf[0x15]; + reset_mask_dis = conf[0x16]; + reset_mask_type = conf[0x17]; + point_repeat[0] = conf[0x18]>>16; + point_repeat[1] = conf[0x18]&0xffff; + //conf[0x19~0x1f] + near_set[0] = conf[0x19]>>16; + near_set[1] = conf[0x19]&0xffff; + diagonal = conf[0x1a]; + //------------------------- + + id_first_coe = conf[0x20]; + id_speed_coe = conf[0x21]; + id_static_coe = conf[0x22]; + match_y[0] = conf[0x23]>>16; + match_y[1] = conf[0x23]&0xffff; + match_x[0] = conf[0x24]>>16; + match_x[1] = conf[0x24]&0xffff; + ignore_y[0] = conf[0x25]>>16; + ignore_y[1] = conf[0x25]&0xffff; + ignore_x[0] = conf[0x26]>>16; + ignore_x[1] = conf[0x26]&0xffff; + edge_cut[0] = (conf[0x27]>>24) & 0xff; + edge_cut[1] = (conf[0x27]>>16) & 0xff; + edge_cut[2] = (conf[0x27]>> 8) & 0xff; + edge_cut[3] = (conf[0x27]>> 0) & 0xff; + report_delay = conf[0x28]; + shake_min = conf[0x29]; + for(i=0;i<16;i++) + { + stretch_array[i*2+0] = conf[0x2a+i] & 0xffff; + stretch_array[i*2+1] = conf[0x2a+i] >> 16; + } + for(i=0;i<8;i++) + { + shake_all_array[i*2+0] = conf[0x3a+i] & 0xffff; + shake_all_array[i*2+1] = conf[0x3a+i] >> 16; + } + report_ahead = conf[0x42]; +// key_dead_time = conf[0x43]; +// point_dead_time = conf[0x44]; +// point_dead_time2 = conf[0x45]; +// point_dead_distance = conf[0x46]; +// point_dead_distance2 = conf[0x47]; + edge_first = conf[0x48]; + edge_first_coe = conf[0x49]; + //goto_test + + key_map_able = conf[0x60]; + for(i=0;i<8*3;i++) + key_range_array[i] = conf[0x61+i]; + + coordinate_correct_able = conf[0x100]; + for(i=0;i<4;i++) + { + multi_x_array[i] = conf[0x101+i]; + multi_y_array[i] = conf[0x105+i]; + } + for(i=0;i<64;i++) + { + coordinate_correct_coe_x[i] = (conf[0x109+i/4]>>(i%4*8)) & 0xff; + coordinate_correct_coe_y[i] = (conf[0x109+64/4+i/4]>>(i%4*8)) & 0xff; + } + for(i=0;i<4;i++) + { + for(j=0;j<64;j++) + multi_group[i][j] = (conf[0x109+64/4*2+(64*i+j)/4]>>((64*i+j)%4*8)) & 0xff; + } + + filter_able = conf[0x180]; + for(i=0;i<4;i++) + filter_coe[i] = conf[0x181+i]; + for(i=0;i<4;i++) + median_dis[i] = (unsigned char)conf[0x185+i]; + for(i=0;i<4;i++) + { + for(j=0;j<8;j++) + { + ps_coe[i][j] = conf[0x189 + 8*i+j]; + pr_coe[i][j] = conf[0x189 + 8*i+j + 32]; + } + } +#ifdef GESTURE_LICH + GestureSet(&conf[0x189 + 64]); +#endif + } + //--------------------------------------------- + if(average == 0) + average = 4; + for(i=0;i<8;i++) + { + if(shake_all_array[i*2] & 0x8000) + shake_all_array[i*2] = shake_all_array[i*2] & ~0x8000; + else + shake_all_array[i*2] = Sqrt(shake_all_array[i*2]); + } + for(i=0;i<2;i++) + { + if(match_x[i] & 0x8000) + match_x[i] |= 0xffff0000; + if(match_y[i] & 0x8000) + match_y[i] |= 0xffff0000; + if(ignore_x[i] & 0x8000) + ignore_x[i] |= 0xffff0000; + if(ignore_y[i] & 0x8000) + ignore_y[i] |= 0xffff0000; + } + for(i=0;i>16; + num_save = point_num & 0xff; + if(num_save > POINT_MAX) + num_save = POINT_MAX; + for(i=0;i= num_save) + point_now[i].all = 0; + } + point_num = (point_num & (~0xff)) + num_save; +} + +void gsl_alg_id_main(struct gsl_touch_info *cinfo) +{ + int i; + point_num = cinfo->finger_num; + for(i=0;iid[i]<<28) | + (cinfo->x[i]<<16) | cinfo->y[i]; + } + + GetFlag(); + if(DataCheck() == 0) + { + point_num = 0; + cinfo->finger_num = 0; + return; + } + PressureSave(); + PointCoor(); + CoordinateCorrect(); + PointEdge(); + PointRepeat(); + GetPointNum(point_now); + PointPointer(); + PointPredict(); + PointId(); + PointNewId(); + PointOrder(); + PointCross(); + GetPointNum(pp[0]); + DoubleClick(); + prev_num = point_num; + ResetMask(); + PointStretch(); + PointDiagonal(); + PointFilter(); + GetPointNum(pr[0]); +#ifdef GESTURE_LICH + GestureMain(&(pr[0][0].all),point_num); +#endif + PointDelay(); + PointPressure(); + PointReport(cinfo); +} +//EXPORT_SYMBOL(gsl_alg_id_main); + + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +#ifdef GESTURE_LICH + +int gsl_obtain_gesture(void) +{ + return GestureDeal(); +} +//EXPORT_SYMBOL(gsl_obtain_gesture); + +static int GestureMain(unsigned int data_coor[],unsigned int num) +{ + gesture_deal = FALSE; + if(gesture_dis_min == 0) + return FALSE; + if(num == 0) + { + if(gesture_num == 0) + return FALSE; + if(gesture_num <= 8) + { + GestureInit(); + return FALSE; + } + gesture_deal = GESTURE_ALL; + return TRUE; + } + else if(gesture_num < 0) + { + return FALSE; + } + else if(num == 1 && data_coor[0] != 0) + { + GesturePush((GESTURE_POINT_TYPE*) data_coor); + return FALSE; + } + else// if(num > 1) + { + gesture_num = -1; + return FALSE; + } +// return TRUE; +} + +static int GestureSqrt(int d) +{ + int ret = 0; + int i; + for(i=14;i>=0;i--) + { + if((ret + (0x1<other.x - d2->other.x) * + (d1->other.x - d2->other.x) + + (d1->other.y - d2->other.y) * + (d1->other.y - d2->other.y)); + else + return (d1->other.x - d2->other.x) * + (d1->other.x - d2->other.x) + + (d1->other.y - d2->other.y) * + (d1->other.y - d2->other.y); +} + +static int GesturePush(GESTURE_POINT_TYPE* data) +{ + if(gesture_num >= GESTURE_BUF_SIZE) + return FALSE; + if(gesture_num == 0) + { + gesture_buf[gesture_num ++].all = data->all & 0xffff0fff; + return TRUE; + } + if(GestureDistance(data,&gesture_buf[gesture_num-1],TRUE) <= gesture_dis_min) + return FALSE; + gesture_buf[gesture_num ++].all = data->all & 0xffff0fff; + return TRUE; +} + +static void GestureInit(void) +{ + gesture_num_last = gesture_num; + gesture_num = 0; + gesture_deal = FALSE; + if(gesture_dis_min < 0 || gesture_dis_min > 64) + gesture_dis_min = 2; +} + +static int GestureStretch(void) +{ + unsigned int x_max=0,x_min=0xffff,y_max=0,y_min=0xffff; + int i; +// if(gesture_num <= GESTURE_SIZE_NUM/2) +// return FALSE; + if(gesture_num >= GESTURE_BUF_SIZE) + return FALSE; + for(i=0;i x_max) + x_max = gesture_buf[i].other.x; + if (gesture_buf[i].other.x < x_min) + x_min = gesture_buf[i].other.x; + if (gesture_buf[i].other.y > y_max) + y_max = gesture_buf[i].other.y; + if (gesture_buf[i].other.y < y_min) + y_min = gesture_buf[i].other.y; + } + if(x_max < x_min+64*2 || y_max < y_min+64*3) + return FALSE; + for(i=0;i= len_total*i) + break; + } + if(n >= gesture_num || len_now == 0) + break; + gesture_standard[i].all = 0; + t = (int)gesture_buf[n - 1].other.x + + ((int)gesture_buf[n].other.x - (int)gesture_buf[n - 1].other.x) + * ((int)len_total*i/(GESTURE_SIZE_NUM-1) - (int)len_his + (int)len_now) + / (int)len_now + ; + if(t < 0) + t = 0; + gesture_standard[i].other.x = t; + t = (int)gesture_buf[n - 1].other.y + + ((int)gesture_buf[n].other.y - (int)gesture_buf[n - 1].other.y) + * ((int)len_total*i/(GESTURE_SIZE_NUM-1) - (int)len_his + (int)len_now) + / (int)len_now + ; + if(t < 0) + t = 0; + gesture_standard[i].other.y = t; + n--; + len_his -= len_now; + } +} + +static int GestureModel(const GESTURE_MODEL_TYPE * model,int len,int threshold,int *out) +{ + int offset[] = {-2,-1,0,1,2}; + int ret_offset; + int i,j,k,n; + int min,min_n; + GESTURE_POINT_TYPE model_coor; + if(model == NULL || threshold <= 0) + { + *out = 0x7fffffff; + return 0x7fffffff; + } + min=0x7fffffff; + min_n = 0; + for(j=0;j= GESTURE_SIZE_NUM) + continue; + if((i&1)==0) + model_coor.all = model[j].coor[i/2] & 0x00ff00ff; + else + model_coor.all = (model[j].coor[i/2]>>8) & 0x00ff00ff; + ret_offset += GestureDistance(&gesture_standard[i+offset[k]],&model_coor,FALSE); + n ++; + } + if(n == 0) + continue; + ret_offset = ret_offset / n * model[j].coe / 0x10;//coe <0x3fff + if(ret_offset < min) + { + min_n = j; + min = ret_offset; + } + } + } + if(min < threshold) + *out = model[min_n].out; + else + *out = 0x7fffffff; + return min; +} + +static void ChangeXY(void) +{ + int i; + for(i=0;i>16) & 0xffff); +} + +static void GestureSet(unsigned int conf[]) +{ + if(conf == NULL) + return; + //if(conf[0] >= 0 && conf[0] <= 64) + if (conf[0] <= 64) + gesture_dis_min = conf[0]; + else + gesture_dis_min = 0; + if(conf[1] != 0) + gesture_threshold[0] = conf[1]; + else + gesture_threshold[0] = 0xfff; + gesture_threshold[1] = conf[2]; + x_scale = (conf[3]==0) ? 4 : conf[3]; + y_scale = (conf[4]==0) ? 4 : conf[4]; + if(conf[5] == 0) + { + double_down = 2; + double_up = 30; + } + else + { + double_down = conf[5] & 0xffff; + double_up = conf[5] >> 16; + } +} + +static int GestureDeal(void) +{ + int i; + int gesture_out[2]; + int gesture_val[2]; + + //while(1) + for (;;) + { + gesture_last = double_click; + if(gesture_last) + break; + if(gesture_deal & GESTURE_XY) + { + gesture_deal &= ~GESTURE_XY; + ChangeXY(); + } + if((gesture_deal & GESTURE_DEAL) == 0) + return FALSE; + gesture_deal &= ~GESTURE_DEAL; + gesture_last = GestureLRUD(); + if(gesture_last) + break; + if(GestureStretch() == FALSE) + break; + GestureStandard(); + gesture_val[0] = GestureModel(model_default, + sizeof(model_default)/sizeof(model_default[0]), + gesture_threshold[0],&gesture_out[0]); + gesture_val[1] = GestureModel(model_extern, + model_extern_len,gesture_threshold[1],&gesture_out[1]); + gesture_last = 0x7fffffff; + for(i=0;i<2;i++) + { + if(gesture_val[i] <= gesture_last) + { +// gesture_value = gesture_val[i]; + gesture_last = gesture_out[i]; + } + } + break; + } + GestureInit(); + return gesture_last; +} + +void gsl_GestureExtern(const GESTURE_MODEL_TYPE *model,int len) +{ + model_extern = model; + model_extern_len = len; +} +//EXPORT_SYMBOL(gsl_GestureExtern); + +static int GestureLRUD(void) +{ + int x1=0,y1=0,x2=0,y2=0,i=0; + int flag3=0; + int middle_x; + int middle_y; + int min_scale=5; +// printk("flag3,gesture_deal=%x\n",gesture_deal); + if(gesture_deal & GESTURE_XY) + { + gesture_deal &= ~GESTURE_XY; + ChangeXY(); +// printk("flag3,ChangeXY_GestureLRUD,gesture_deal=%x\n",gesture_deal); + } + if((gesture_deal & GESTURE_LRUD) == 0) + return FALSE; + gesture_deal &= ~GESTURE_LRUD; +// int screen_x_max=0,screen_y_max=0; + x1 = gesture_buf[0].other.x;//480 + y1 = gesture_buf[0].other.y;//800 + x2 = gesture_buf[gesture_num - 1].other.x; + y2 = gesture_buf[gesture_num - 1].other.y; +// if(!x1&&!y1&&!x2&&!y2) +// return '6'; + middle_x =( x1 + x2)/2; + middle_y = (y1 + y2)/2; + for(i=1;imin_scale) + flag3|=(0x1<<8); + else if ((int)gesture_buf[i].other.x - (int)gesture_buf[i - 1].other.x<-min_scale) + flag3|=(0x2<<8); + if ((int)gesture_buf[i].other.y - (int)gesture_buf[i - 1].other.y>min_scale) + flag3|=(0x1<<12); + else if ((int)gesture_buf[i].other.y - (int)gesture_buf[i - 1].other.y<-min_scale) + flag3|=(0x2<<12); + } +// printk("flag3_____flag3=%x,x_scale=%d,y_scale=%d\n",flag3,x_scale,y_scale); +// if(flag3&&!point_num) +// { +// printk("flag3,x1=%d,y1=%d,x2=%d,y2=%d,screen_x_max=%d,screen_y_max=%d\n",x1,y1,x2,y2,screen_x_max,screen_y_max); +// printk("flag3====== %x,x1-x2=%d,x2-x1=%d,y1-y2=%d,y2-y1=%d\n",flag3,x1-x2,x2-x1,y1-y2,y2-y1); +// } +// if(!point_num) +// if(1) + { + if((flag3==0x2031||flag3==0x2131||flag3==0x2231||flag3==0x2331))//&&(y2-y1>screen_x_max/3)) + return 0xa1fc;//up(a1,fc) + else if((flag3==0x1031||flag3==0x1131||flag3==0x1231||flag3==0x1331))//&&(y1-y2>screen_x_max/3)) + return 0xa1fd;//down + else if((flag3==0x213||flag3==0x1213||flag3==0x2213||flag3==0x2213))//&&(x2-x1>screen_y_max/3)) + return 0xa1fb;//left + else if((flag3==0x113||flag3==0x1113||flag3==0x2113||flag3==0x3113))//&&(x1-x2>screen_y_max/3)) + return 0xa1fa;//right +// if(abs(x2-x1)<64*4&&abs(y2-y1)<64*6) +// return (int)'5'; + } + return FALSE; +} + +unsigned int gsl_GestureBuffer(unsigned int **buf) +{ + int i; + if(gesture_num_last >= GESTURE_BUF_SIZE) + gesture_num_last = GESTURE_BUF_SIZE - 1; + for(i=0;i + * + * 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 "rockchip_gslX680_rk3168.h" +#include "tp_suspend.h" +#include "gslx680.h" +#include +#include + +#define GSL_DEBUG + +/* +struct fw_data +{ + u32 offset : 8; + u32 : 0; + u32 val; +}; +*/ + +//#define RK_GEAR_TOUCH +#define REPORT_DATA_ANDROID_4_0 +#define HAVE_TOUCH_KEY +//#define SLEEP_CLEAR_POINT + +//#define FILTER_POINT + +#ifdef FILTER_POINT +#define FILTER_MAX 9 //6 +#endif + +#define GSLX680_I2C_NAME "gslX680" +#define GSLX680_I2C_ADDR 0x40 + +//#define IRQ_PORT RK2928_PIN1_PB0//RK30_PIN1_PB7 +//#define WAKE_PORT RK30_PIN0_PA1//RK30_PIN0_PB6 + +#define GSL_DATA_REG 0x80 +#define GSL_STATUS_REG 0xe0 +#define GSL_PAGE_REG 0xf0 + +#define TPD_PROC_DEBUG +#ifdef TPD_PROC_DEBUG +#include +#include +#include +//static struct proc_dir_entry *gsl_config_proc = NULL; +#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 = 0; +static struct i2c_client *i2c_client = NULL; +#endif +#define GSL_MONITOR +#define PRESS_MAX 255 +#define MAX_FINGERS 10 +#define MAX_CONTACTS 10 +#define DMA_TRANS_LEN 0x20 +#ifdef GSL_MONITOR + +#ifdef RK_GEAR_TOUCH +static int g_istouch=0; +#endif + +static struct workqueue_struct *gsl_monitor_workqueue = NULL; +static u8 int_1st[4] = { 0 }; +static u8 int_2nd[4] = { 0 }; +//static char dac_counter = 0; +static char b0_counter = 0; +static char bc_counter = 0; +static char i2c_lock_flag = 0; +#endif + +#define WRITE_I2C_SPEED (350*1000) +#define I2C_SPEED (200*1000) +#define CLOSE_TP_POWER 0 +//add by yuandan +//#define HAVE_CLICK_TIMER + +#ifdef HAVE_CLICK_TIMER + +static struct workqueue_struct *gsl_timer_workqueue = NULL; +bool send_key = false; +struct semaphore my_sem; +#endif + +#ifdef HAVE_TOUCH_KEY +static u16 key = 0; +static int key_state_flag = 0; +struct key_data { + u16 key; + u16 x_min; + u16 x_max; + u16 y_min; + u16 y_max; +}; + +const u16 key_array[] = { + KEY_LEFT, + KEY_RIGHT, + KEY_UP, + KEY_DOWN, + KEY_ENTER, +}; + +#define MAX_KEY_NUM (sizeof(key_array)/sizeof(key_array[0])) +//add by yuandan +int key_x[512]; +int key_y[512]; +int key_count = 0; +int key_repeat; +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; + u8 *touch_data; + u8 device_id; + 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; +}; + +#ifdef GSL_DEBUG +#define print_info(fmt, args...) printk(fmt, ##args); +#else +#define print_info(fmt, args...) +#endif + +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 = 0; +static u16 y_new = 0; + +int gslx680_set_pinctrl_state(struct gsl_ts *ts, struct pinctrl_state *state) +{ + int ret = 0; + + if (!IS_ERR(state)) { + ret = pinctrl_select_state(ts->pinctrl, state); + if (ret) + printk("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; + int ret = 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); + + //msleep(20); +#if 0 //#if defined (CONFIG_BOARD_ZM71C)||defined (CONFIG_BOARD_ZM72CP) || + defined(CONFIG_BOARD_ZM726C) || defined(CONFIG_BOARD_ZM726CE) + if (gpio_request(ts->rst, NULL) != 0) { + gpio_free(ts->rst); + printk("gslX680_init gpio_request error\n"); + return -EIO; + } +#endif + + /* pinctrl */ + ts->pinctrl = devm_pinctrl_get(&ts->client->dev); + if (IS_ERR(ts->pinctrl)) { + ret = PTR_ERR(ts->pinctrl); + //goto out; + } + + ts->pins_default = + pinctrl_lookup_state(ts->pinctrl, PINCTRL_STATE_DEFAULT); + //if (IS_ERR(ts->pins_default)) + // dev_err(&client->dev, "could not get default pinstate\n"); + + ts->pins_sleep = pinctrl_lookup_state(ts->pinctrl, PINCTRL_STATE_SLEEP); + //if (IS_ERR(ts->pins_sleep)) + // dev_err(&client->dev, "could not get sleep pinstate\n"); + + ts->pins_inactive = pinctrl_lookup_state(ts->pinctrl, "inactive"); + //if (IS_ERR(ts->pins_inactive)) + // dev_err(&client->dev, "could not get inactive pinstate\n"); + + err = gpio_request(ts->rst, "tp reset"); + if (err) { + printk("gslx680 reset gpio request failed.\n"); + return -1; + } + + gslx680_set_pinctrl_state(ts, ts->pins_default); + gpio_direction_output(ts->rst, 1); + gpio_set_value(ts->rst, 1); + + return 0; +} + +static int gslX680_shutdown_low(struct gsl_ts *ts) +{ + printk("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) +{ + printk("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_read_interface(struct i2c_client *client, + u8 reg, u8 *buf, u32 num) +{ + struct i2c_msg xfer_msg[2]; + + xfer_msg[0].addr = client->addr; + xfer_msg[0].len = 1; + xfer_msg[0].flags = client->flags & I2C_M_TEN; + xfer_msg[0].buf = ® + xfer_msg[0].scl_rate=300*1000; + + xfer_msg[1].addr = client->addr; + xfer_msg[1].len = num; + xfer_msg[1].flags |= I2C_M_RD; + xfer_msg[1].buf = buf; + xfer_msg[1].scl_rate=300*1000; + + if (reg < 0x80) { + i2c_transfer(client->adapter, xfer_msg, ARRAY_SIZE(xfer_msg)); + msleep(5); + } + + return i2c_transfer(client->adapter, xfer_msg, ARRAY_SIZE(xfer_msg)) \ + == ARRAY_SIZE(xfer_msg) ? 0 : -EFAULT; +} + */ + +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; + //xfer_msg[0].scl_rate = 100 * 1000; + + 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) { + printk("%s too 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) { + printk("%s too big datalen = %d!\n", __func__, datalen); + return -1; + } + + ret = gsl_ts_write(client, addr, NULL, 0); + if (ret < 0) { + printk("%s set data address fail!\n", __func__); + return ret; + } + + return i2c_master_recv(client, pdata, datalen); +} + +static __inline__ 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; + //u8 read_buf[4] = {0}; + 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 (GSL_PAGE_REG == ptr_fw[source_line].offset) { + 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 + printk("gsl I read reg 0xf0 is %x\n", read_buf); + + msleep(2); + ret = gsl_ts_write(client, 0xf0, &write_buf, sizeof(write_buf)); + if (ret >= 0) + printk("gsl I write reg 0xf0 0x12\n"); + + msleep(2); + ret = gsl_ts_read(client, 0xf0, &read_buf, sizeof(read_buf)); + if (ret < 0) + rc--; + else + printk("gsl I read reg 0xf0 is 0x%x\n", read_buf); + + return rc; +} +static void startup_chip(struct i2c_client *client) +{ + u8 tmp = 0x00; + + printk("gsl startup_chip\n"); + +#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 }; + + printk("gsl reset_chip\n"); + + 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); +} + +static void init_chip(struct i2c_client *client, struct gsl_ts *ts) +{ + int rc; + + printk("gsl init_chip\n"); + + gslX680_shutdown_low(ts); + mdelay(20); + gslX680_shutdown_high(ts); + mdelay(20); + rc = test_i2c(client); + if (rc < 0) { + printk("gslX680 test_i2c error\n"); + return; + } + clr_reg(client); + reset_chip(client); + gsl_load_fw(client); + startup_chip(client); + 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)); + 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 *ptr = page; + char temp_data[5] = { 0 }; + unsigned int tmp = 0; + //unsigned int *ptr_fw; + + 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) { + //print_info("size not match [%d:%d]\n", CONFIG_LEN, count); + return -EFAULT; + } + path_buf = kzalloc(count, GFP_KERNEL); + if (!path_buf) { + printk("alloc path_buf memory error \n"); + } + if (copy_from_user(path_buf, buffer, count)) { + print_info("copy from user fail\n"); + goto exit_write_proc_out; + } + memcpy(temp_buf, path_buf, (count < CONFIG_LEN ? count : CONFIG_LEN)); + print_info("[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]) { + //version //vs + memcpy(gsl_read, temp_buf, 4); + printk("gsl version\n"); + } else if ('s' == temp_buf[0] && 't' == temp_buf[1]) { + //start //st + gsl_proc_flag = 1; + reset_chip(i2c_client); + } else if ('e' == temp_buf[0] && 'n' == temp_buf[1]) { + //end //en + mdelay(20); + reset_chip(i2c_client); + startup_chip(i2c_client); + gsl_proc_flag = 0; + } else if ('r' == temp_buf[0] && 'e' == temp_buf[1]) { + //read buf // + memcpy(gsl_read, temp_buf, 4); + memcpy(gsl_data_proc, buf, 8); + } else if ('w' == temp_buf[0] && 'r' == temp_buf[1]) { + //write buf + 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]) { + //write id config // + 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 + +#ifdef RK_GEAR_TOUCH +static void report_data(struct gsl_ts *ts, u16 x, u16 y, u8 pressure, u8 id) +{ +#ifdef RK_GEAR_TOUCH + int delt_x,delt_y; + static int old_x=0, old_y=0; +#endif + //#ifndef SWAP_XY + // swap(x, y); + //#endif + //printk("#####id=%d,x=%d,y=%d######\n",id,x,y); + + if (x > SCREEN_MAX_X || y > SCREEN_MAX_Y) { +#ifdef HAVE_TOUCH_KEY + //report_key(ts, x, y); + //printk("#####report_key x=%d,y=%d######\n",x,y); +#endif + return; + } + + /* + input_mt_slot(ts->input_dev, id); + input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, id); + input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x); + input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y); + input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, w); + input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w); + */ +#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 + //printk("#####REPORT_DATA_ANDROID_4_0######\n"); + input_mt_slot(ts->input, id); + //input_report_abs(ts->input, ABS_MT_TRACKING_ID, id); + input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 1); + input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, pressure); +#ifdef X_POL + input_report_abs(ts->input, ABS_MT_POSITION_X, SCREEN_MAX_X - x); +#else + input_report_abs(ts->input, ABS_MT_POSITION_X, x); +#endif +#ifdef Y_POL + input_report_abs(ts->input, ABS_MT_POSITION_Y, (SCREEN_MAX_Y - y)); +#else + input_report_abs(ts->input, ABS_MT_POSITION_Y, (y)); +#endif + input_report_abs(ts->input, ABS_MT_WIDTH_MAJOR, 1); +#else + //printk("#####nonono REPORT_DATA_ANDROID_4_0######\n"); + 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 +} +#endif + +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]; + //print_info("-----touches: %d -----\n", touches); +#ifdef GSL_NOID_VERSION + + cinfo.finger_num = touches; + //print_info("tp-gsl finger_num = %d\n",cinfo.finger_num); + 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); + /*print_info("tp-gsl before: x[%d] = %d, y[%d] = %d, + id[%d] = %d \n",i,cinfo.x[i],i,cinfo.y[i],i,cinfo.id[i]);*/ + } + 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(); + //print_info("[tp-gsl] tmp1 = %x\n", tmp1); + 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); + print_info("tmp1=%08x,buf[0]=%02x,buf[1]=%02x,buf[2]=%02x, \ + buf[3]=%02x\n", tmp1, buf[0], buf[1], buf[2], buf[3]); + 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 (1 <= id && id <= MAX_CONTACTS) { +#ifdef FILTER_POINT + filter_point(x, y, id); +#else + record_point(x, y, id); +#endif +#ifdef RK_GEAR_TOUCH + report_data(ts, x_new, y_new, 10, id); +#endif + if (key_count <= 512) { + key_x[key_count] = x_new; + key_y[key_count] = y_new; + key_count++; + /*printk("test in key store in here, + x_new is %d , y_new is %d , + key_count is %d \n", x_new ,y_new,key_count);*/ + } + id_state_flag[id] = 1; + } + } + for (i = 1; i <= MAX_CONTACTS; i++) { + if ((0 == touches) + || ((0 != id_state_old_flag[i]) + && (0 == id_state_flag[i]))) { +#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 (0 == touches) { +#ifdef REPORT_DATA_ANDROID_4_0 +#ifndef RK_GEAR_TOUCH + //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) { + printk(" 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) { + printk(" 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) { + printk(" 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) { + printk(" 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); + } + } + /*printk(" key_x[key_count -1], key_x[0], + key_y[key_count -1], key_y[0] is %d ,%d , %d , %d\n", + key_x[key_count -1], key_x[0], key_y[key_count -1], + key_y[0]);*/ + 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); + //printk(" send enter2 key by yuandan \n"); + //if(send_key) + // { + printk(" 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) { + printk(" 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) { + printk(" 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) { + printk(" 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) { + printk(" 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 +#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 + enable_irq(ts->irq); + +} + +#ifdef HAVE_CLICK_TIMER + +static void click_timer_worker(struct work_struct *work) +{ + while (true) { + mdelay(500); + //down(&my_sem); + send_key = false; + //up(&my_sem); + } +} + +#endif + +#ifdef GSL_MONITOR +static void gsl_monitor_worker(struct work_struct *work) +{ + //u8 write_buf[4] = {0}; + u8 read_buf[4] = { 0 }; + char init_chip_flag = 0; + + //print_info("gsl_monitor_worker\n"); + struct gsl_ts *ts = + container_of(work, struct gsl_ts, gsl_monitor_work.work); + if (i2c_lock_flag != 0) { + i2c_lock_flag = 1; + } + //goto queue_monitor_work; + else + i2c_lock_flag = 1; + + //gsl_ts_read(ts->client, 0x80, read_buf, 4); + /*printk("======read 0x80: %x %x %x %x ======tony0geshu\n", + read_buf[3], read_buf[2], read_buf[1], read_buf[0]);*/ + + 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) { + /*printk("======read 0xb0: %x %x %x %x ======\n", + read_buf[3], read_buf[2], read_buf[1], read_buf[0]);*/ + 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]; + + /*printk("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]);*/ + + 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]) { + /*printk("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; + //goto queue_monitor_init_chip; + } + + 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) { + /*printk("======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; + } + + /* + write_buf[3] = 0x01; + write_buf[2] = 0xfe; + write_buf[1] = 0x10; + write_buf[0] = 0x00; + gsl_ts_write(ts->client, 0xf0, write_buf, 4); + gsl_ts_read(ts->client, 0x10, read_buf, 4); + gsl_ts_read(ts->client, 0x10, read_buf, 4); + + if(read_buf[3] < 10 + && read_buf[2] < 10 + && read_buf[1] < 10 + && read_buf[0] < 10) + dac_counter ++; + else + dac_counter = 0; + + if(dac_counter > 1) + { + printk("read DAC1_0: %x %x %x %x\n", + read_buf[3], read_buf[2], read_buf[1], read_buf[0]); + init_chip_flag = 1; + dac_counter = 0; + } + */ + //queue_monitor_init_chip: + if (init_chip_flag) + init_chip(ts->client, ts); + + i2c_lock_flag = 0; + + //queue_monitor_work: + //queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 100); +} +#endif + +static irqreturn_t gsl_ts_irq(int irq, void *dev_id) +{ + ///struct gsl_ts *ts = dev_id; + struct gsl_ts *ts = (struct gsl_ts *)dev_id; + //print_info("========gslX680 Interrupt=========\n"); + + disable_irq_nosync(ts->irq); + + 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; + + printk("[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); + /*input_device->evbit[0] = BIT_MASK(EV_SYN) + | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);*/ + 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); + + //client->irq = IRQ_PORT; + //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; +} + +#if 0 +static int gsl_ts_suspend(struct i2c_client *dev, pm_message_t mesg) +{ +#if 0 + struct gsl_ts *ts = dev_get_drvdata(dev); + + printk("I'am in gsl_ts_suspend() start\n"); + +#ifdef GSL_MONITOR + printk("gsl_ts_suspend () : cancel gsl_monitor_work\n"); + cancel_delayed_work_sync(&ts->gsl_monitor_work); +#endif + +#ifdef HAVE_CLICK_TIMER + //cancel_work_sync(&ts->click_work); +#endif + disable_irq_nosync(ts->irq); + + gslX680_shutdown_low(ts); + +#ifdef SLEEP_CLEAR_POINT + mdelay(10); +#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); + mdelay(10); + report_data(ts, 1, 1, 10, 1); + input_sync(ts->input); +#endif + +#endif + return 0; +} +#endif + +#if 0 +static int gsl_ts_resume(struct i2c_client *dev) +{ +#if 0 + struct gsl_ts *ts = dev_get_drvdata(dev); + + printk("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 + printk("gsl_ts_resume () : queue gsl_monitor_work\n"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 300); +#endif + +#ifdef HAVE_CLICK_TIMER + //queue_work(gsl_timer_workqueue,&ts->click_work); +#endif + + disable_irq_nosync(ts->irq); + enable_irq(ts->irq); +#endif + + return 0; +} +#endif + +static int gsl_ts_early_suspend(struct tp_device *tp_d) +{ + struct gsl_ts *ts = container_of(tp_d, struct gsl_ts, tp); + printk("[GSLX680] Enter %s\n", __func__); + //gsl_ts_suspend(&ts->client->dev); +#ifdef GSL_MONITOR + printk("gsl_ts_suspend () : cancel gsl_monitor_work\n"); + cancel_delayed_work_sync(&ts->gsl_monitor_work); +#endif + + disable_irq_nosync(ts->irq); + +#ifdef SLEEP_CLEAR_POINT + msleep(10); +#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); + msleep(10); + 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); + printk("[GSLX680] Enter %s\n", __func__); + //gsl_ts_resume(&ts->client->dev); + + printk("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 + printk("gsl_ts_resume () : queue gsl_monitor_work\n"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 300); +#endif + disable_irq_nosync(ts->irq); + enable_irq(ts->irq); + + 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); + printk("[GSLX680] Enter %s\n", __func__); + //gsl_ts_suspend(&ts->client->dev); +#ifdef GSL_MONITOR + printk("gsl_ts_suspend () : cancel gsl_monitor_work\n"); + cancel_delayed_work_sync(&ts->gsl_monitor_work); +#endif + + disable_irq_nosync(ts->irq); + +#ifdef SLEEP_CLEAR_POINT + msleep(10); +#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); + msleep(10); + report_data(ts, 1, 1, 10, 1); + input_sync(ts->input); +#endif + gslX680_shutdown_low(ts); + return 0; +} + +static void gsl_ts_late_resume(struct early_suspend *h) +{ + struct gsl_ts *ts = container_of(h, struct gsl_ts, early_suspend); + printk("[GSLX680] Enter %s\n", __func__); + //gsl_ts_resume(&ts->client->dev); + int i; + + printk("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 + printk("gsl_ts_resume () : queue gsl_monitor_work\n"); + queue_delayed_work(gsl_monitor_workqueue, &ts->gsl_monitor_work, 300); +#endif + disable_irq_nosync(ts->irq); + enable_irq(ts->irq); +} +#endif + +//static struct wake_lock touch_wakelock; + +static int gsl_ts_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct gsl_ts *ts; + int rc; + + printk("GSLX680 Enter %s\n", __func__); + //wake_lock_init(&touch_wakelock, WAKE_LOCK_SUSPEND, "touch"); + //wake_lock(&touch_wakelock); //system do not enter deep sleep + 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; + + 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; + } + //#ifdef GSLX680_COMPATIBLE + // judge_chip_type(client); + //#endif + //printk("##################### probe [2]chip_type=%c .\n",chip_type); + init_chip(ts->client, ts); + check_mem_data(ts->client, ts); + + client->irq = gpio_to_irq(ts->irq); + rc = request_irq(client->irq, gsl_ts_irq, IRQF_TRIGGER_RISING, + client->name, ts); + if (rc < 0) { + printk("gsl_probe: request irq failed\n"); + goto porbe_err_ret; + } + + /* create debug attribute */ + //rc = device_create_file(&ts->input->dev, &dev_attr_debug_enable); + +#ifdef CONFIG_HAS_EARLYSUSPEND + + ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; + //ts->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 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 +#if 0 + gsl_config_proc = create_proc_entry(GSL_CONFIG_PROC_FILE, 0666, NULL); + printk("[tp-gsl] [%s] gsl_config_proc = %x \n", __func__, + gsl_config_proc); + if (gsl_config_proc == NULL) { + print_info("create_proc_entry %s failed\n", + GSL_CONFIG_PROC_FILE); + } else { + gsl_config_proc->read_proc = gsl_config_read_proc; + gsl_config_proc->write_proc = gsl_config_write_proc; + } +#else + i2c_client = client; + proc_create(GSL_CONFIG_PROC_FILE, 0666, NULL, &gsl_seq_fops); +#endif + gsl_proc_flag = 0; +#endif + //disable_irq_nosync(->irq); + printk("[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->irq, ts); + destroy_workqueue(ts->wq); + //device_remove_file(&ts->input->dev, &dev_attr_debug_enable); + + return 0; +} + +static struct of_device_id gsl_ts_ids[] = { + {.compatible = "gslX680"}, + {} +}; + +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), + }, +#if 0 //ndef CONFIG_HAS_EARLYSUSPEND + .suspend = gsl_ts_suspend, + .resume = gsl_ts_resume, +#endif + .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); + return; +} + +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/gslx680.h b/drivers/input/touchscreen/gslx680.h new file mode 100644 index 000000000000..45339e5ba2ce --- /dev/null +++ b/drivers/input/touchscreen/gslx680.h @@ -0,0 +1,5403 @@ +/* + * 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 1080 + +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); + +/* + unsigned int gsl_config_versions[]= + { + 0xa55a0003,//°æ±¾ + 0x168045,//оƬÐͺŠ+ 0,//¿Õ + 0,0,0,0,//·½°¸¹«Ë¾0-3 + 0,0,0,0,//ÏîÄ¿Ãû³Æ4-7 + 0,0,0,0,//ƽ̨8-11 + 0,0,0,0,//TP³§12-15 + 0,//TP³ß´ç16 + + 0,0,0,0,//°æ±¾£¬ÐÕÃû1£¬ÐÕÃû2£¬ÈÕÆÚ17-20 + 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, + } + */ + +unsigned int gsl_config_data_id[] = +{ + 0x852b6a, + 0x200, + 0,0, + 0, + 0,0,0, + 0,0,0,0,0,0,0,0xd2c687c4, + + + 0x100,0x5,0x70007,0x70007,0x7800438,0,0x5100,0x8e00, + 0,0x320014,0,0,0,0,0,0, + 0x4,0x4000,0x4000,0x10120001,0x101c0002,0,0,0x2020000, + 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,//key_map + 0x3200384,0x64,0x503e8,//0 + 0,0,0,//1 + 0,0,0,//2 + 0,0,0,//3 + 0,0,0,//4 + 0,0,0,//5 + 0,0,0,//6 + 0,0,0,//7 + + 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, + 0x1c001c0,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,0x00000000}, + {0x60,0x00000000}, + {0x64,0xf8010023}, + {0x68,0x00066414}, + {0x6c,0x1001020a}, + {0x70,0x00000fff}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x07070707}, + {0xf0,0x3}, + {0x00,0x0e42ee0e}, + {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,0x00000000}, + {0x78,0xffffffec}, + {0x7c,0x00000000}, + {0xf0,0x4}, + {0x00,0x00000000}, + {0x04,0x0001660b}, + {0x08,0x00000064}, + {0x0c,0x00000000}, + {0x10,0x0000ff06}, + {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,0x80808080}, + {0x10,0x0000000a}, + {0x14,0x00000000}, + {0x18,0x00000fff}, + {0x1c,0x10120001}, + {0x20,0x101c0002}, + {0x24,0x00000000}, + {0x28,0x00000000}, + {0x2c,0x00000000}, + {0x30,0x80808080}, + {0x34,0x80808080}, + {0x38,0x80808080}, + {0x3c,0x80808080}, + {0x40,0x80808080}, + {0x44,0x80808080}, + {0x48,0x80808080}, + {0x4c,0x80808000}, + {0x50,0x00000000}, + {0x54,0x00000000}, + {0x58,0x00000000}, + {0x5c,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000220}, + {0x78,0x00000007}, + {0x7c,0x00000007}, + {0xf0,0x6}, + {0x00,0x00000007}, + {0x04,0x00000000}, + {0x08,0x00000007}, + {0x0c,0x04030402}, + {0x10,0x00000032}, + {0x14,0x1414010a}, + {0x18,0x00000000}, + {0x1c,0x00000001}, + {0x20,0x00002904}, + {0x24,0x00000780}, + {0x28,0x00000438}, + {0x2c,0xf8010023}, + {0x30,0xf8010005}, + {0x34,0x00000007}, + {0x38,0x00000003}, + {0x3c,0x00000fff}, + {0x40,0x80000000}, + {0x44,0x00030003}, + {0x48,0x00000fff}, + {0x4c,0x04040402}, + {0x50,0x00030002}, + {0x54,0x00000e10}, + {0x58,0x000a012c}, + {0x5c,0x1b6db688}, + {0x60,0x20100804}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x000000c8}, + {0x78,0x000a003c}, + {0x7c,0x00000000}, + {0xf0,0x7}, + {0x00,0x05000403}, + {0x04,0x07020601}, + {0x08,0x0508040a}, + {0x0c,0x07110610}, + {0x10,0x09130812}, + {0x14,0x00123456}, + {0x18,0x00000000}, + {0x1c,0x000a0078}, + {0x20,0x00001081}, + {0x24,0xff080010}, + {0x28,0xff080120}, + {0x2c,0xff080140}, + {0x30,0xff080160}, + {0x34,0x000000dc}, + {0x38,0x000000b7}, + {0x3c,0x00000092}, + {0x40,0x00000000}, + {0x44,0x00780078}, + {0x48,0x00000100}, + {0x4c,0x320f0f03}, + {0x50,0x00000000}, + {0x54,0x00000003}, + {0x58,0x00020000}, + {0x5c,0x00040003}, + {0x60,0x00060005}, + {0x64,0x00000000}, + {0x68,0x00020000}, + {0x6c,0x00010000}, + {0x70,0x00010000}, + {0x74,0x00000000}, + {0x78,0x00012345}, + {0x7c,0x006789ab}, + {0xf0,0x8}, + {0x00,0x026f028f}, + {0x04,0x02af22cf}, + {0x08,0x22ef430f}, + {0x0c,0x532f034f}, + {0x10,0x01f301f4}, + {0x14,0x01f501f6}, + {0x18,0x01f701f8}, + {0x1c,0x01f901fa}, + {0x20,0x01f401f5}, + {0x24,0x01f601f7}, + {0x28,0x01f801f9}, + {0x2c,0x01fa0000}, + {0x30,0x00000000}, + {0x34,0x00000000}, + {0x38,0x00000000}, + {0x3c,0x00000000}, + {0x40,0x02040600}, + {0x44,0x00000000}, + {0x48,0x00000000}, + {0x4c,0x01030507}, + {0x50,0x00000000}, + {0x54,0x00000000}, + {0x58,0x00040003}, + {0x5c,0x00000006}, + {0x60,0x0000012c}, + {0x64,0x00000201}, + {0x68,0x00000808}, + {0x6c,0x006600cd}, + {0x70,0x000000cd}, + {0x74,0x0000005d}, + {0x78,0x00000000}, + {0x7c,0x00000008}, + {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,0xe0}, + {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,0x00640190}, + {0x44,0x00640064}, + {0x48,0x012c0064}, + {0x4c,0x0050012c}, + {0x50,0x00500050}, + {0x54,0x00c80050}, + {0x58,0x00c800c8}, + {0x5c,0x003700c8}, + {0x60,0x00640000}, + {0x64,0x00640064}, + {0x68,0x00000032}, + {0x6c,0x00500000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe1}, + {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,0x00000002}, + {0x54,0x00000000}, + {0x58,0x00000000}, + {0x5c,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe2}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe3}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe4}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe5}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xe6}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + */ + + + + {0xf0,0x1e}, + {0x00,0x5a5a0f00}, + {0x04,0x00002b08}, + {0x08,0x00002b7c}, + {0x0c,0x00002bfc}, + {0x10,0x00002d30}, + {0x14,0x00002e2c}, + {0x18,0x00002fe0}, + {0x1c,0x00003170}, + {0x20,0x000032c0}, + {0x24,0x0000348c}, + {0x28,0x000035fc}, + {0x2c,0x000037ac}, + {0x30,0x00003954}, + {0x34,0x00003a58}, + {0x38,0x00003c80}, + {0x3c,0x00003e54}, + {0x40,0x000041d4}, + {0x44,0x000042dc}, + {0x48,0x00004548}, + {0x4c,0x0000465c}, + {0x50,0x000046d4}, + {0x54,0x0000474c}, + {0x58,0x000048e4}, + {0x5c,0x00004bcc}, + {0x60,0x00004f68}, + {0x64,0x00005050}, + {0x68,0x000050b4}, + {0x6c,0x000051e8}, + {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,0x00000000}, + {0x40,0x000024b0}, + {0x44,0x00000000}, + {0x48,0x00000000}, + {0x4c,0x00002530}, + {0x50,0x000025f0}, + {0x54,0x00000000}, + {0x58,0x000026a0}, + {0x5c,0x00000000}, + {0x60,0x00000000}, + {0x64,0x000027d0}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x000028a0}, + {0x74,0x00002940}, + {0x78,0x000052a0}, + {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,0x03296945}, + {0x7c,0x82106288}, + {0xf0,0x1a}, + {0x00,0x9de3bf98}, + {0x04,0x40000010}, + {0x08,0x01000000}, + {0x0c,0x40000007}, + {0x10,0x01000000}, + {0x14,0x4000031b}, + {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,0x9de3bf18}, + {0x58,0xb2067fff}, + {0x5c,0x96100018}, + {0x60,0xf227bf7c}, + {0x64,0xc027bf78}, + {0x68,0x98102000}, + {0x6c,0xb007bff8}, + {0x70,0xd4063f80}, + {0x74,0xda063f84}, + {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,0xc2263f84}, + {0x2c,0xd4263f80}, + {0x30,0x832f2002}, + {0x34,0xb0062008}, + {0x38,0xde22c001}, + {0x3c,0xba072001}, + {0x40,0xfa263f80}, + {0x44,0xda263f84}, + {0x48,0x98032002}, + {0x4c,0x80a33fff}, + {0x50,0x34bfffc9}, + {0x54,0xd4063f80}, + {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,0x4000044d}, + {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,0x1b3fc140}, + {0x04,0x82136048}, + {0x08,0xc2104000}, + {0x0c,0x82006003}, + {0x10,0x82086003}, + {0x14,0x83286002}, + {0x18,0x9a136080}, + {0x1c,0x81c3e008}, + {0x20,0xd000400d}, + {0x24,0x94102000}, + {0x28,0x96102000}, + {0x2c,0x832ae002}, + {0x30,0xd20063a4}, + {0x34,0x98102000}, + {0x38,0x832b2002}, + {0x3c,0x9b2aa002}, + {0x40,0xda02000d}, + {0x44,0x98032001}, + {0x48,0xda224001}, + {0x4c,0x80a32005}, + {0x50,0x04bffffa}, + {0x54,0x9402a001}, + {0x58,0x9602e001}, + {0x5c,0x80a2e003}, + {0x60,0x04bffff4}, + {0x64,0x832ae002}, + {0x68,0x81c3e008}, + {0x6c,0x01000000}, + {0x70,0x82020008}, + {0x74,0x82004008}, + {0x78,0x9b326002}, + {0x7c,0x82004001}, + {0xf0,0x26}, + {0x00,0x8200400d}, + {0x04,0x83286002}, + {0x08,0x920a6003}, + {0x0c,0x932a6003}, + {0x10,0xd00065b0}, + {0x14,0x91320009}, + {0x18,0x81c3e008}, + {0x1c,0x900a20ff}, + {0x20,0x9a020008}, + {0x24,0x9a034008}, + {0x28,0x97326002}, + {0x2c,0x9a03400d}, + {0x30,0x9a03400b}, + {0x34,0x920a6003}, + {0x38,0x9b2b6002}, + {0x3c,0x932a6003}, + {0x40,0x821020ff}, + {0x44,0xd80365b0}, + {0x48,0x83284009}, + {0x4c,0x822b0001}, + {0x50,0x952a8009}, + {0x54,0x8210400a}, + {0x58,0xc22365b0}, + {0x5c,0x912a2002}, + {0x60,0xda0223a4}, + {0x64,0x972ae002}, + {0x68,0x81c3e008}, + {0x6c,0xc223400b}, + {0x70,0x82102005}, + {0x74,0x1b3fc200}, + {0x78,0x82204008}, + {0x7c,0x9a136008}, + {0xf0,0x27}, + {0x00,0x83286002}, + {0x04,0xd0034000}, + {0x08,0x91320001}, + {0x0c,0x81c3e008}, + {0x10,0x900a200f}, + {0x14,0x9de3bf58}, + {0x18,0xa12e2002}, + {0x1c,0xda1423da}, + {0x20,0xd61423d8}, + {0x24,0xc200247c}, + {0x28,0xb022c00d}, + {0x2c,0x825b4001}, + {0x30,0xb21e6001}, + {0x34,0x92862001}, + {0x38,0x0280000c}, + {0x3c,0x9a004019}, + {0x40,0xb0100009}, + {0x44,0x9807bfb8}, + {0x48,0x8203400d}, + {0x4c,0xc2168001}, + {0x50,0xc2230000}, + {0x54,0xc200247c}, + {0x58,0x9a034001}, + {0x5c,0xb0863fff}, + {0x60,0x12bffffa}, + {0x64,0x98032004}, + {0x68,0x7ffffe7b}, + {0x6c,0x9007bfb8}, + {0x70,0xda1423ea}, + {0x74,0xd61423e8}, + {0x78,0x80a3400b}, + {0x7c,0x92102000}, + {0xf0,0x28}, + {0x00,0x1880000b}, + {0x04,0xb010000d}, + {0x08,0x832b6002}, + {0x0c,0x8200401e}, + {0x10,0x98007fb8}, + {0x14,0xc2030000}, + {0x18,0xb0062001}, + {0x1c,0x92024001}, + {0x20,0x80a6000b}, + {0x24,0x08bffffc}, + {0x28,0x98032004}, + {0x2c,0xb022c00d}, + {0x30,0xb0062001}, + {0x34,0x81800000}, + {0x38,0x01000000}, + {0x3c,0x01000000}, + {0x40,0x01000000}, + {0x44,0xb0724018}, + {0x48,0x81c7e008}, + {0x4c,0x81e80000}, + {0x50,0x033fc200}, + {0x54,0x961060a0}, + {0x58,0x98102000}, + {0x5c,0x832b2002}, + {0x60,0x9a03000c}, + {0x64,0xda136400}, + {0x68,0x98032001}, + {0x6c,0x80a3200f}, + {0x70,0x04bffffb}, + {0x74,0xda20400b}, + {0x78,0x81c3e008}, + {0x7c,0x01000000}, + {0xf0,0x29}, + {0x00,0x9de3bf98}, + {0x04,0xc200247c}, + {0x08,0x83306001}, + {0x0c,0x80a60001}, + {0x10,0x1a800006}, + {0x14,0x90100018}, + {0x18,0x7fffffb6}, + {0x1c,0x01000000}, + {0x20,0x10800006}, + {0x24,0xb0020008}, + {0x28,0x7fffffb2}, + {0x2c,0x90260001}, + {0x30,0x90020008}, + {0x34,0xb0022001}, + {0x38,0x81c7e008}, + {0x3c,0x81e80000}, + {0x40,0x9de3bf98}, + {0x44,0xa8102000}, + {0x48,0xc20023d4}, + {0x4c,0x80a50001}, + {0x50,0x1a800057}, + {0x54,0xe2002348}, + {0x58,0xa4102000}, + {0x5c,0xc200247c}, + {0x60,0x80a48001}, + {0x64,0x3a80004e}, + {0x68,0xa8052001}, + {0x6c,0x7fffffe5}, + {0x70,0x90100012}, + {0x74,0xaa100008}, + {0x78,0x90100014}, + {0x7c,0x7fffff7d}, + {0xf0,0x2a}, + {0x00,0x92100015}, + {0x04,0x80a62000}, + {0x08,0x12800004}, + {0x0c,0xa0100008}, + {0x10,0x10800016}, + {0x14,0xa0102000}, + {0x18,0x80a62009}, + {0x1c,0x18800011}, + {0x20,0x80a62007}, + {0x24,0x7fffff57}, + {0x28,0x01000000}, + {0x2c,0x94100008}, + {0x30,0x90100014}, + {0x34,0x7fffff98}, + {0x38,0x92100012}, + {0x3c,0x80a20011}, + {0x40,0x04800007}, + {0x44,0xa6100008}, + {0x48,0x9a102008}, + {0x4c,0x9a234018}, + {0x50,0x82102001}, + {0x54,0x8328400d}, + {0x58,0xa02c0001}, + {0x5c,0x80a62007}, + {0x60,0x18800008}, + {0x64,0x80a62008}, + {0x68,0x9a102007}, + {0x6c,0x9a234018}, + {0x70,0x82102001}, + {0x74,0x8328400d}, + {0x78,0x10800023}, + {0x7c,0xa0140001}, + {0xf0,0x2b}, + {0x00,0x1280000a}, + {0x04,0x821e2009}, + {0x08,0x80a420fe}, + {0x0c,0x24800002}, + {0x10,0xa0042001}, + {0x14,0x03000019}, + {0x18,0x9b2ca002}, + {0x1c,0x82106080}, + {0x20,0x10800019}, + {0x24,0xe6234001}, + {0x28,0x80a00001}, + {0x2c,0x9a603fff}, + {0x30,0x80a420fe}, + {0x34,0x04800003}, + {0x38,0x82102001}, + {0x3c,0x82102000}, + {0x40,0x808b4001}, + {0x44,0x02800011}, + {0x48,0x92100015}, + {0x4c,0x03000019}, + {0x50,0x9b2ca002}, + {0x54,0x82106080}, + {0x58,0xc2034001}, + {0x5c,0x80a04011}, + {0x60,0x18800003}, + {0x64,0x9a204011}, + {0x68,0x9a244001}, + {0x6c,0x80a4c011}, + {0x70,0x14800003}, + {0x74,0x8224c011}, + {0x78,0x82244013}, + {0x7c,0x80a34001}, + {0xf0,0x2c}, + {0x00,0xa0642000}, + {0x04,0x92100015}, + {0x08,0x94100010}, + {0x0c,0x7fffff45}, + {0x10,0x90100014}, + {0x14,0x10bfffb2}, + {0x18,0xa404a001}, + {0x1c,0xc20023d4}, + {0x20,0x80a50001}, + {0x24,0x0abfffae}, + {0x28,0xa4102000}, + {0x2c,0x81c7e008}, + {0x30,0x81e80000}, + {0x34,0x98102000}, + {0x38,0x9610201e}, + {0x3c,0x80a22000}, + {0x40,0x12800003}, + {0x44,0x8210000c}, + {0x48,0x8222c00c}, + {0x4c,0x83286002}, + {0x50,0xda006480}, + {0x54,0x80a37ff0}, + {0x58,0x02800006}, + {0x5c,0x98032002}, + {0x60,0xc2006484}, + {0x64,0x80a3201f}, + {0x68,0x04bffff5}, + {0x6c,0xc2234000}, + {0x70,0x81c3e008}, + {0x74,0x01000000}, + {0x78,0x9de3bf98}, + {0x7c,0xda002508}, + {0xf0,0x2d}, + {0x00,0x033fc000}, + {0x04,0x9a0b4001}, + {0x08,0x173fc180}, + {0x0c,0x03202020}, + {0x10,0x82106080}, + {0x14,0x9812e038}, + {0x18,0xc2230000}, + {0x1c,0x03168000}, + {0x20,0x80a34001}, + {0x24,0xc022c000}, + {0x28,0xa6102000}, + {0x2c,0x1280000b}, + {0x30,0xa8102000}, + {0x34,0x0300003f}, + {0x38,0xda002548}, + {0x3c,0x821063ff}, + {0x40,0x9a0b4001}, + {0x44,0xd8002508}, + {0x48,0x033fffc0}, + {0x4c,0x980b0001}, + {0x50,0x9a13400c}, + {0x54,0xda202548}, + {0x58,0x80a62000}, + {0x5c,0x16800027}, + {0x60,0x1b296956}, + {0x64,0x1b3fc040}, + {0x68,0xc2002548}, + {0x6c,0x8208400d}, + {0x70,0x1b168040}, + {0x74,0x80a0400d}, + {0x78,0x22800002}, + {0x7c,0xa6102001}, + {0xf0,0x2e}, + {0x00,0xda002654}, + {0x04,0xc20021dc}, + {0x08,0x80a34001}, + {0x0c,0x1a80001b}, + {0x10,0x1b296956}, + {0x14,0x031696a9}, + {0x18,0xda00250c}, + {0x1c,0x821061a5}, + {0x20,0x80a34001}, + {0x24,0x02800006}, + {0x28,0x03296956}, + {0x2c,0x8210625a}, + {0x30,0x80a34001}, + {0x34,0x12800011}, + {0x38,0x1b296956}, + {0x3c,0x11000018}, + {0x40,0x92122340}, + {0x44,0x40000187}, + {0x48,0x90122200}, + {0x4c,0x03000019}, + {0x50,0x96106200}, + {0x54,0xa8102001}, + {0x58,0x98102000}, + {0x5c,0x9b2b2002}, + {0x60,0x98032001}, + {0x64,0xc20365b0}, + {0x68,0x80a32017}, + {0x6c,0x08bffffc}, + {0x70,0xc223400b}, + {0x74,0x1b296956}, + {0x78,0x80a00013}, + {0x7c,0x82380018}, + {0xf0,0x2f}, + {0x00,0xa413625a}, + {0x04,0x90402000}, + {0x08,0x8330601f}, + {0x0c,0x1b1696a9}, + {0x10,0xa21361a5}, + {0x14,0x9e104008}, + {0x18,0xd200254c}, + {0x1c,0xe0002548}, + {0x20,0x98102500}, + {0x24,0xc200250c}, + {0x28,0x96033a50}, + {0x2c,0x941b250c}, + {0x30,0x80a04012}, + {0x34,0x02800007}, + {0x38,0x9a184011}, + {0x3c,0x80a0000d}, + {0x40,0x82603fff}, + {0x44,0x80904008}, + {0x48,0x0280000a}, + {0x4c,0x80a3e000}, + {0x50,0x80a2e0e0}, + {0x54,0x9a402000}, + {0x58,0x80a0000a}, + {0x5c,0x82603fff}, + {0x60,0x80934001}, + {0x64,0x3280000a}, + {0x68,0x98032004}, + {0x6c,0x80a3e000}, + {0x70,0x02800005}, + {0x74,0x82033970}, + {0x78,0x80a0603f}, + {0x7c,0x28800004}, + {0xf0,0x30}, + {0x00,0x98032004}, + {0x04,0xc0230000}, + {0x08,0x98032004}, + {0x0c,0x80a32867}, + {0x10,0x28bfffe6}, + {0x14,0xc200250c}, + {0x18,0x80a62000}, + {0x1c,0x06800006}, + {0x20,0x0300003f}, + {0x24,0x821063ff}, + {0x28,0x820a4001}, + {0x2c,0x10800005}, + {0x30,0xc220254c}, + {0x34,0xc21022d4}, + {0x38,0x83286010}, + {0x3c,0xc2202690}, + {0x40,0xc20023c8}, + {0x44,0xda002548}, + {0x48,0x83306012}, + {0x4c,0x82086200}, + {0x50,0x9a0b7dff}, + {0x54,0x9a134001}, + {0x58,0xd800254c}, + {0x5c,0xd4002334}, + {0x60,0x033fc200}, + {0x64,0x9402a001}, + {0x68,0x92050014}, + {0x6c,0x980b3ffd}, + {0x70,0x82106054}, + {0x74,0xc2004000}, + {0x78,0x98130009}, + {0x7c,0x9732a001}, + {0xf0,0x31}, + {0x00,0x9602800b}, + {0x04,0xd820254c}, + {0x08,0x80a06114}, + {0x0c,0xd620258c}, + {0x10,0xda202548}, + {0x14,0xd4202554}, + {0x18,0xd4202588}, + {0x1c,0xc2002344}, + {0x20,0x1280000a}, + {0x24,0x99342018}, + {0x28,0x820860ff}, + {0x2c,0x8258605a}, + {0x30,0x82006040}, + {0x34,0x83306007}, + {0x38,0x9b286010}, + {0x3c,0x9a034001}, + {0x40,0x10800003}, + {0x44,0xda202570}, + {0x48,0xc2202570}, + {0x4c,0x173fc200}, + {0x50,0xda002570}, + {0x54,0x8212e030}, + {0x58,0xda204000}, + {0x5c,0x80a3205a}, + {0x60,0x1280000a}, + {0x64,0xda20257c}, + {0x68,0x1b00003f}, + {0x6c,0xc2002548}, + {0x70,0x9a1363ff}, + {0x74,0x8208400d}, + {0x78,0x1b3fffc0}, + {0x7c,0x9a0c000d}, + {0xf0,0x32}, + {0x00,0x8210400d}, + {0x04,0xc2202548}, + {0x08,0x80a4e001}, + {0x0c,0x1280000c}, + {0x10,0x03296956}, + {0x14,0xc2002548}, + {0x18,0x83306012}, + {0x1c,0x80886001}, + {0x20,0x32800010}, + {0x24,0x82102029}, + {0x28,0x9a12e074}, + {0x2c,0xc2002330}, + {0x30,0xc2234000}, + {0x34,0x1080000b}, + {0x38,0x82102029}, + {0x3c,0xda00250c}, + {0x40,0x8210625a}, + {0x44,0x80a34001}, + {0x48,0x1280000b}, + {0x4c,0x01000000}, + {0x50,0xc200254c}, + {0x54,0x80886002}, + {0x58,0x12800007}, + {0x5c,0x82102015}, + {0x60,0xc2202500}, + {0x64,0x7ffffe50}, + {0x68,0x901025b0}, + {0x6c,0x7ffffeb9}, + {0x70,0x81e80000}, + {0x74,0x01000000}, + {0x78,0x81c7e008}, + {0x7c,0x81e80000}, + {0xf0,0x33}, + {0x00,0x9de3bf98}, + {0x04,0x4000023f}, + {0x08,0x90102000}, + {0x0c,0x133fc200}, + {0x10,0xe80021fc}, + {0x14,0xc2002298}, + {0x18,0x98126070}, + {0x1c,0xc2230000}, + {0x20,0x033fc000}, + {0x24,0xd8002338}, + {0x28,0x82106030}, + {0x2c,0xd8204000}, + {0x30,0xc200232c}, + {0x34,0x90126074}, + {0x38,0xc2220000}, + {0x3c,0x1b3fc140}, + {0x40,0x0300003f}, + {0x44,0xa013608c}, + {0x48,0x9e136058}, + {0x4c,0xa213605c}, + {0x50,0xa4136080}, + {0x54,0xa6136084}, + {0x58,0x821063ff}, + {0x5c,0x15000017}, + {0x60,0xc223c000}, + {0x64,0x9412a380}, + {0x68,0x17000018}, + {0x6c,0x9a136088}, + {0x70,0xd4234000}, + {0x74,0x9612e0c0}, + {0x78,0x03200040}, + {0x7c,0xd6240000}, + {0xf0,0x34}, + {0x00,0x82106101}, + {0x04,0xc2224000}, + {0x08,0x033fc0c0}, + {0x0c,0x82106004}, + {0x10,0xc0204000}, + {0x14,0xc0244000}, + {0x18,0xd4248000}, + {0x1c,0xd624c000}, + {0x20,0x80a52000}, + {0x24,0xc2002374}, + {0x28,0xd600247c}, + {0x2c,0x02800006}, + {0x30,0xd40022f8}, + {0x34,0x82584014}, + {0x38,0x82006800}, + {0x3c,0x10800003}, + {0x40,0xa130600c}, + {0x44,0xa0100001}, + {0x48,0x1b3fc140}, + {0x4c,0x98136040}, + {0x50,0xd0030000}, + {0x54,0x9732e001}, + {0x58,0x825ac00a}, + {0x5c,0x900a3800}, + {0x60,0x90120001}, + {0x64,0xd0230000}, + {0x68,0x9a136004}, + {0x6c,0xd0034000}, + {0x70,0x900a3fe0}, + {0x74,0x9012000b}, + {0x78,0x193fc200}, + {0x7c,0xd0234000}, + {0xf0,0x35}, + {0x00,0x94132080}, + {0x04,0xd0028000}, + {0x08,0x92132054}, + {0x0c,0x900a3fe0}, + {0x10,0xc2024000}, + {0x14,0x9012000b}, + {0x18,0x960861ff}, + {0x1c,0x80a2e114}, + {0x20,0x1280000d}, + {0x24,0xd0228000}, + {0x28,0x82102006}, + {0x2c,0xc2228000}, + {0x30,0x03009051}, + {0x34,0x9a132058}, + {0x38,0x82106040}, + {0x3c,0xc2234000}, + {0x40,0x80a52000}, + {0x44,0x12800004}, + {0x48,0xd6224000}, + {0x4c,0x825c2349}, + {0x50,0xa130600a}, + {0x54,0x233fc200}, + {0x58,0xda0023f8}, + {0x5c,0x82146008}, + {0x60,0xda204000}, + {0x64,0x9814600c}, + {0x68,0x7ffffe5a}, + {0x6c,0xda230000}, + {0x70,0x9814607c}, + {0x74,0xd0030000}, + {0x78,0x033ff000}, + {0x7c,0x902a0001}, + {0xf0,0x36}, + {0x00,0xd0230000}, + {0x04,0x033fc1c0}, + {0x08,0xd8002340}, + {0x0c,0x82106064}, + {0x10,0xd8204000}, + {0x14,0x1b3fc140}, + {0x18,0x0300007f}, + {0x1c,0x94136010}, + {0x20,0x821063ff}, + {0x24,0x92136030}, + {0x28,0x1707ffc0}, + {0x2c,0xc2228000}, + {0x30,0x9a136014}, + {0x34,0xd6224000}, + {0x38,0x80a42000}, + {0x3c,0x0280000f}, + {0x40,0xd6234000}, + {0x44,0x932c2010}, + {0x48,0x82042001}, + {0x4c,0x9b2c2004}, + {0x50,0x83286010}, + {0x54,0x9a02400d}, + {0x58,0x98146084}, + {0x5c,0xda230000}, + {0x60,0x82004010}, + {0x64,0x96146088}, + {0x68,0x82006002}, + {0x6c,0x9414608c}, + {0x70,0xd222c000}, + {0x74,0xc2228000}, + {0x78,0xc2002174}, + {0x7c,0x80a06000}, + {0xf0,0x37}, + {0x00,0x02800007}, + {0x04,0x173fc080}, + {0x08,0xc2082174}, + {0x0c,0xda082177}, + {0x10,0x9812e008}, + {0x14,0xc2230000}, + {0x18,0xda22c000}, + {0x1c,0x7ffffeb7}, + {0x20,0x90103fff}, + {0x24,0x7ffffea4}, + {0x28,0x90102001}, + {0x2c,0x1b3fc0c0}, + {0x30,0x82103fff}, + {0x34,0x9a136004}, + {0x38,0xc2234000}, + {0x3c,0x03200040}, + {0x40,0xc2244000}, + {0x44,0x81c7e008}, + {0x48,0x81e80000}, + {0x4c,0x9de3bf98}, + {0x50,0xc2002508}, + {0x54,0x808860ff}, + {0x58,0x02800015}, + {0x5c,0x1b3fc180}, + {0x60,0x82102001}, + {0x64,0x9a13603c}, + {0x68,0xc2234000}, + {0x6c,0xc2002508}, + {0x70,0x820860ff}, + {0x74,0x80a04018}, + {0x78,0x1280000b}, + {0x7c,0x033fc180}, + {0xf0,0x38}, + {0x00,0x7ffffc6e}, + {0x04,0x01000000}, + {0x08,0xda002508}, + {0x0c,0x033fc040}, + {0x10,0x9a0b60ff}, + {0x14,0x8210600c}, + {0x18,0xc0204000}, + {0x1c,0x10bffff7}, + {0x20,0x80a34018}, + {0x24,0x8210603c}, + {0x28,0xc0204000}, + {0x2c,0x81c7e008}, + {0x30,0x81e80000}, + {0x34,0x9a102000}, + {0x38,0x832b6002}, + {0x3c,0x9a036001}, + {0x40,0x80a3604f}, + {0x44,0x08bffffd}, + {0x48,0xc0220001}, + {0x4c,0x81c3e008}, + {0x50,0x01000000}, + {0x54,0xc20022f8}, + {0x58,0xda00247c}, + {0x5c,0x8258400d}, + {0x60,0x83306001}, + {0x64,0x96102000}, + {0x68,0x80a2c001}, + {0x6c,0x1a80003b}, + {0x70,0x0300003f}, + {0x74,0x941063ff}, + {0x78,0x98102000}, + {0x7c,0x80a26001}, + {0xf0,0x39}, + {0x00,0x0280002e}, + {0x04,0x80a26004}, + {0x08,0x12800008}, + {0x0c,0x80a26008}, + {0x10,0xc2030008}, + {0x14,0x9a08400a}, + {0x18,0x83306012}, + {0x1c,0x83286010}, + {0x20,0x10800014}, + {0x24,0x9b336002}, + {0x28,0x28800015}, + {0x2c,0xda02000c}, + {0x30,0xda030008}, + {0x34,0x83336010}, + {0x38,0x82004001}, + {0x3c,0x9a0b400a}, + {0x40,0x81800000}, + {0x44,0x01000000}, + {0x48,0x01000000}, + {0x4c,0x01000000}, + {0x50,0x82704009}, + {0x54,0x9a03400d}, + {0x58,0x83286010}, + {0x5c,0x81800000}, + {0x60,0x01000000}, + {0x64,0x01000000}, + {0x68,0x01000000}, + {0x6c,0x9a734009}, + {0x70,0x8200400d}, + {0x74,0x10800011}, + {0x78,0xc2230008}, + {0x7c,0x83336010}, + {0xf0,0x3a}, + {0x00,0x81800000}, + {0x04,0x01000000}, + {0x08,0x01000000}, + {0x0c,0x01000000}, + {0x10,0x82704009}, + {0x14,0x9a0b400a}, + {0x18,0x83286010}, + {0x1c,0x81800000}, + {0x20,0x01000000}, + {0x24,0x01000000}, + {0x28,0x01000000}, + {0x2c,0x9a734009}, + {0x30,0x8200400d}, + {0x34,0xc222000c}, + {0x38,0xc20022f8}, + {0x3c,0xda00247c}, + {0x40,0x8258400d}, + {0x44,0x9602e001}, + {0x48,0x83306001}, + {0x4c,0x80a2c001}, + {0x50,0x0abfffcb}, + {0x54,0x98032004}, + {0x58,0x81c3e008}, + {0x5c,0x01000000}, + {0x60,0x98102000}, + {0x64,0x9b2b2002}, + {0x68,0x98032001}, + {0x6c,0xc202000d}, + {0x70,0x80a3204f}, + {0x74,0x04bffffc}, + {0x78,0xc222400d}, + {0x7c,0x81c3e008}, + {0xf0,0x3b}, + {0x00,0x01000000}, + {0x04,0xd6020000}, + {0x08,0xd8024000}, + {0x0c,0x9132e010}, + {0x10,0x95332010}, + {0x14,0x900a2fff}, + {0x18,0x940aafff}, + {0x1c,0x03000007}, + {0x20,0x9a22000a}, + {0x24,0x821063ff}, + {0x28,0x940b0001}, + {0x2c,0x900ac001}, + {0x30,0x9022000a}, + {0x34,0x9a5b400d}, + {0x38,0x905a0008}, + {0x3c,0x81c3e008}, + {0x40,0x90034008}, + {0x44,0x9de3bf88}, + {0x48,0x82064019}, + {0x4c,0x82004019}, + {0x50,0x83286002}, + {0x54,0x82004018}, + {0x58,0x3b000019}, + {0x5c,0xba176080}, + {0x60,0x83286002}, + {0x64,0xf400401d}, + {0x68,0x033fc000}, + {0x6c,0x82106001}, + {0x70,0xc227bfe8}, + {0x74,0x03000040}, + {0x78,0xc227bfec}, + {0x7c,0x033fc040}, + {0xf0,0x3c}, + {0x00,0x821061fe}, + {0x04,0xc227bff0}, + {0x08,0x0300bf80}, + {0x0c,0x82106101}, + {0x10,0xc227bff4}, + {0x14,0x9e10001d}, + {0x18,0xb6102000}, + {0x1c,0x9a07bff8}, + {0x20,0xba06c00d}, + {0x24,0xc24f7ff0}, + {0x28,0xb0060001}, + {0x2c,0xc24f7ff8}, + {0x30,0xb2064001}, + {0x34,0x82067fff}, + {0x38,0x82164001}, + {0x3c,0x80a62000}, + {0x40,0x0480001e}, + {0x44,0xbb30601f}, + {0x48,0xc2002308}, + {0x4c,0x80a04018}, + {0x50,0x82402000}, + {0x54,0x8090401d}, + {0x58,0x32800019}, + {0x5c,0xb606e001}, + {0x60,0xc2002300}, + {0x64,0x80a64001}, + {0x68,0x18800014}, + {0x6c,0xba064019}, + {0x70,0x82074019}, + {0x74,0x83286002}, + {0x78,0x82004018}, + {0x7c,0x80a6e003}, + {0xf0,0x3d}, + {0x00,0x14800008}, + {0x04,0xb9286002}, + {0x08,0xc207000f}, + {0x0c,0x80a0401a}, + {0x10,0x2680000b}, + {0x14,0xb606e001}, + {0x18,0x1080000d}, + {0x1c,0xb0102000}, + {0x20,0xc207000f}, + {0x24,0x80a0401a}, + {0x28,0x24800005}, + {0x2c,0xb606e001}, + {0x30,0x10800007}, + {0x34,0xb0102000}, + {0x38,0xb606e001}, + {0x3c,0x80a6e007}, + {0x40,0x04bfffd9}, + {0x44,0xba06c00d}, + {0x48,0xb0102001}, + {0x4c,0x81c7e008}, + {0x50,0x81e80000}, + {0x54,0xc2002548}, + {0x58,0x82087fbf}, + {0x5c,0xc2202548}, + {0x60,0xc020255c}, + {0x64,0xc0202514}, + {0x68,0x9a102000}, + {0x6c,0x832b6002}, + {0x70,0x9a036001}, + {0x74,0xc0206738}, + {0x78,0x80a36009}, + {0x7c,0x04bffffc}, + {0xf0,0x3e}, + {0x00,0xc0206710}, + {0x04,0x81c3e008}, + {0x08,0x01000000}, + {0x0c,0x9de3bf88}, + {0x10,0x82063fff}, + {0x14,0xb8067fff}, + {0x18,0x82160001}, + {0x1c,0xba16401c}, + {0x20,0x80974001}, + {0x24,0xa610001a}, + {0x28,0x0680007d}, + {0x2c,0xa410001b}, + {0x30,0xc2002308}, + {0x34,0x80a60001}, + {0x38,0x3880007a}, + {0x3c,0xb0102000}, + {0x40,0xc2002300}, + {0x44,0x80a64001}, + {0x48,0x38800076}, + {0x4c,0xb0102000}, + {0x50,0x94062001}, + {0x54,0x96066001}, + {0x58,0xa207bff8}, + {0x5c,0x8207bfe8}, + {0x60,0xb0102003}, + {0x64,0xc0204000}, + {0x68,0xb0863fff}, + {0x6c,0x1cbffffe}, + {0x70,0x82006004}, + {0x74,0xc2002160}, + {0x78,0x80886004}, + {0x7c,0x0280000f}, + {0xf0,0x3f}, + {0x00,0xb0102004}, + {0x04,0x80a66001}, + {0x08,0x0280000b}, + {0x0c,0x821021ff}, + {0x10,0xc2002308}, + {0x14,0x80a60001}, + {0x18,0x02800007}, + {0x1c,0x821021ff}, + {0x20,0xc2002300}, + {0x24,0x80a64001}, + {0x28,0x12800005}, + {0x2c,0x80a7000b}, + {0x30,0x821021ff}, + {0x34,0xc227bff4}, + {0x38,0x80a7000b}, + {0x3c,0x14800031}, + {0x40,0xb210001c}, + {0x44,0x8207001c}, + {0x48,0xba02c00b}, + {0x4c,0x8200401c}, + {0x50,0xba07400b}, + {0x54,0xba20401d}, + {0x58,0x39000019}, + {0x5c,0xa0172080}, + {0x60,0x9827400a}, + {0x64,0x9b286002}, + {0x68,0xb002bffe}, + {0x6c,0x82034018}, + {0x70,0x83286002}, + {0x74,0xba06000c}, + {0x78,0xb4004010}, + {0x7c,0xb6076008}, + {0xf0,0x40}, + {0x00,0x90102001}, + {0x04,0x932a001b}, + {0x08,0x9e102000}, + {0x0c,0xb92be002}, + {0x10,0xfa072520}, + {0x14,0xba5f4012}, + {0x18,0x833f601f}, + {0x1c,0x83306018}, + {0x20,0xba074001}, + {0x24,0xc2068000}, + {0x28,0x82204013}, + {0x2c,0xbb3f6008}, + {0x30,0x9e03e001}, + {0x34,0x80a0401d}, + {0x38,0x04800005}, + {0x3c,0xb8070011}, + {0x40,0xc2073ff0}, + {0x44,0x82104009}, + {0x48,0xc2273ff0}, + {0x4c,0x80a3e003}, + {0x50,0x08bffff0}, + {0x54,0xb92be002}, + {0x58,0xb0062001}, + {0x5c,0xb606e001}, + {0x60,0x80a6000a}, + {0x64,0x04bfffe8}, + {0x68,0xb406a004}, + {0x6c,0xb2066001}, + {0x70,0x9a03600c}, + {0x74,0x80a6400b}, + {0x78,0x04bfffdc}, + {0x7c,0x98032003}, + {0xf0,0x41}, + {0x00,0xc207bfe8}, + {0x04,0x80886010}, + {0x08,0x0280000a}, + {0x0c,0xfa07bfec}, + {0x10,0xc207bff4}, + {0x14,0x80886082}, + {0x18,0x02800007}, + {0x1c,0x808f6010}, + {0x20,0x80886028}, + {0x24,0x1280001f}, + {0x28,0xb0102003}, + {0x2c,0xfa07bfec}, + {0x30,0x808f6010}, + {0x34,0x02800012}, + {0x38,0xc207bff0}, + {0x3c,0x808f6082}, + {0x40,0x02800007}, + {0x44,0x808f6028}, + {0x48,0xc207bff4}, + {0x4c,0x80886028}, + {0x50,0x32800014}, + {0x54,0xb0102002}, + {0x58,0x808f6028}, + {0x5c,0x02800008}, + {0x60,0xc207bff0}, + {0x64,0xc207bff4}, + {0x68,0x80886082}, + {0x6c,0x02800004}, + {0x70,0xc207bff0}, + {0x74,0x1080000b}, + {0x78,0xb0102002}, + {0x7c,0x80886010}, + {0xf0,0x42}, + {0x00,0x02800008}, + {0x04,0xb0102000}, + {0x08,0x80886082}, + {0x0c,0x02800005}, + {0x10,0x80886028}, + {0x14,0x12800003}, + {0x18,0xb0102001}, + {0x1c,0xb0102000}, + {0x20,0x81c7e008}, + {0x24,0x81e80000}, + {0x28,0x94102000}, + {0x2c,0xc2002514}, + {0x30,0x80a28001}, + {0x34,0x96102000}, + {0x38,0x1a80000e}, + {0x3c,0x9b2ae002}, + {0x40,0xc2036710}, + {0x44,0x9602e001}, + {0x48,0x80a06000}, + {0x4c,0x02800006}, + {0x50,0x992aa002}, + {0x54,0xc2232710}, + {0x58,0xc2036738}, + {0x5c,0x9402a001}, + {0x60,0xc2232738}, + {0x64,0xc2002514}, + {0x68,0x10bffff4}, + {0x6c,0x80a2c001}, + {0x70,0x81c3e008}, + {0x74,0xd4202514}, + {0x78,0xd4020000}, + {0x7c,0x03000018}, + {0xf0,0x43}, + {0x00,0x9802800a}, + {0x04,0x82106200}, + {0x08,0xda530001}, + {0x0c,0xc2002590}, + {0x10,0xc250400c}, + {0x14,0x96a0400d}, + {0x18,0x02800016}, + {0x1c,0x03000018}, + {0x20,0x80a2e000}, + {0x24,0x04800009}, + {0x28,0x82102001}, + {0x2c,0xda022004}, + {0x30,0x8328400d}, + {0x34,0x80a2c001}, + {0x38,0x3480000d}, + {0x3c,0x973ac00d}, + {0x40,0x1080000b}, + {0x44,0x96102001}, + {0x48,0x1680000a}, + {0x4c,0x03000018}, + {0x50,0xda022008}, + {0x54,0x82103fff}, + {0x58,0x8328400d}, + {0x5c,0x80a2c001}, + {0x60,0x36800003}, + {0x64,0x96103fff}, + {0x68,0x973ac00d}, + {0x6c,0x03000018}, + {0x70,0x92106200}, + {0x74,0x8202800a}, + {0x78,0xc2504009}, + {0x7c,0x9602c001}, + {0xf0,0x44}, + {0x00,0x808aa001}, + {0x04,0x0280000f}, + {0x08,0x9b3aa01f}, + {0x0c,0x9b33601f}, + {0x10,0x9a02800d}, + {0x14,0x9b3b6001}, + {0x18,0x9b2b6002}, + {0x1c,0xd8034009}, + {0x20,0x033fffc0}, + {0x24,0x980b0001}, + {0x28,0x0300003f}, + {0x2c,0x821063ff}, + {0x30,0x820ac001}, + {0x34,0x98030001}, + {0x38,0x1080000d}, + {0x3c,0xd8234009}, + {0x40,0x9b33601f}, + {0x44,0x9a02800d}, + {0x48,0x9b3b6001}, + {0x4c,0x9b2b6002}, + {0x50,0x0300003f}, + {0x54,0xd8034009}, + {0x58,0x821063ff}, + {0x5c,0x980b0001}, + {0x60,0x832ae010}, + {0x64,0x8200400c}, + {0x68,0xc2234009}, + {0x6c,0xc2020000}, + {0x70,0xda00247c}, + {0x74,0x8200400d}, + {0x78,0x81c3e008}, + {0x7c,0xc2220000}, + {0xf0,0x45}, + {0x00,0x9de3bf98}, + {0x04,0x833e201f}, + {0x08,0xd0002320}, + {0x0c,0x82204018}, + {0x10,0x80a22000}, + {0x14,0x02800015}, + {0x18,0x9b30601f}, + {0x1c,0x033fc000}, + {0x20,0xa0106020}, + {0x24,0xc200231c}, + {0x28,0x80a00001}, + {0x2c,0x82402000}, + {0x30,0x8088400d}, + {0x34,0xc2002318}, + {0x38,0x02800009}, + {0x3c,0xb01e0001}, + {0x40,0x80a00001}, + {0x44,0x82603fff}, + {0x48,0x7ffffab3}, + {0x4c,0xc2240000}, + {0x50,0xc2002318}, + {0x54,0x10800005}, + {0x58,0xc2240000}, + {0x5c,0x033fc000}, + {0x60,0x82106020}, + {0x64,0xf0204000}, + {0x68,0x81c7e008}, + {0x6c,0x81e80000}, + {0x70,0x9de3bf98}, + {0x74,0x7ffffab1}, + {0x78,0x01000000}, + {0x7c,0xe0002500}, + {0xf0,0x46}, + {0x00,0x80a42028}, + {0x04,0x08800013}, + {0x08,0x80a42000}, + {0x0c,0xc0202584}, + {0x10,0xa2102000}, + {0x14,0x832c6002}, + {0x18,0xc2006f04}, + {0x1c,0x80a06000}, + {0x20,0x02800053}, + {0x24,0xa2046001}, + {0x28,0x9fc04000}, + {0x2c,0x01000000}, + {0x30,0xc2002584}, + {0x34,0x80a06000}, + {0x38,0x1280004d}, + {0x3c,0x80a4603b}, + {0x40,0x24bffff6}, + {0x44,0x832c6002}, + {0x48,0x1080004a}, + {0x4c,0xc2002500}, + {0x50,0x1280000b}, + {0x54,0x80a42014}, + {0x58,0xc2002fcc}, + {0x5c,0x9fc04000}, + {0x60,0x01000000}, + {0x64,0x7ffffcc5}, + {0x68,0x90102000}, + {0x6c,0x7ffffcb2}, + {0x70,0x90102001}, + {0x74,0x1080003f}, + {0x78,0xc2002500}, + {0x7c,0x1880000c}, + {0xf0,0x47}, + {0x00,0x80a42015}, + {0x04,0x808c2001}, + {0x08,0x3280003a}, + {0x0c,0xc2002500}, + {0x10,0x90043ffe}, + {0x14,0x7ffffc4b}, + {0x18,0x91322001}, + {0x1c,0x7ffffc2d}, + {0x20,0x01000000}, + {0x24,0x10800033}, + {0x28,0xc2002500}, + {0x2c,0x18800010}, + {0x30,0x80a42018}, + {0x34,0x033fc180}, + {0x38,0xda0025b0}, + {0x3c,0x82106038}, + {0x40,0xda204000}, + {0x44,0x033fc200}, + {0x48,0x82106074}, + {0x4c,0xda00232c}, + {0x50,0xda204000}, + {0x54,0x7ffffc98}, + {0x58,0x90102000}, + {0x5c,0xc200265c}, + {0x60,0xc2202538}, + {0x64,0x10800020}, + {0x68,0xc2002fcc}, + {0x6c,0x1880000c}, + {0x70,0x80a42028}, + {0x74,0x90102000}, + {0x78,0x92102000}, + {0x7c,0xc2002fc0}, + {0xf0,0x48}, + {0x00,0x9fc04000}, + {0x04,0x94102000}, + {0x08,0x11000018}, + {0x0c,0x7ffffe0a}, + {0x10,0x90122200}, + {0x14,0x10800017}, + {0x18,0xc2002500}, + {0x1c,0x38800015}, + {0x20,0xc2002500}, + {0x24,0x7ffffb97}, + {0x28,0x23000018}, + {0x2c,0x92146200}, + {0x30,0xc2002fc0}, + {0x34,0x9fc04000}, + {0x38,0x94043fe8}, + {0x3c,0x80a42028}, + {0x40,0x3280000c}, + {0x44,0xc2002500}, + {0x48,0x90146200}, + {0x4c,0x7ffffe02}, + {0x50,0x92102008}, + {0x54,0xc2002fd8}, + {0x58,0x80a06000}, + {0x5c,0x22800005}, + {0x60,0xc2002500}, + {0x64,0x9fc04000}, + {0x68,0x01000000}, + {0x6c,0xc2002500}, + {0x70,0x80a40001}, + {0x74,0x1280000b}, + {0x78,0x031fffff}, + {0x7c,0x821063f0}, + {0xf0,0x49}, + {0x00,0x80a40001}, + {0x04,0x38800003}, + {0x08,0x21040000}, + {0x0c,0xa0042001}, + {0x10,0x033fc180}, + {0x14,0x82106034}, + {0x18,0xe0204000}, + {0x1c,0xe0202500}, + {0x20,0x81c7e008}, + {0x24,0x81e80000}, + {0x28,0x81c3e008}, + {0x2c,0x01000000}, + {0x30,0x9de3bf98}, + {0x34,0x9e100018}, + {0x38,0x80a66000}, + {0x3c,0x0280001b}, + {0x40,0xb010001a}, + {0x44,0x031fffdf}, + {0x48,0xb41063ff}, + {0x4c,0x82102000}, + {0x50,0xbb286002}, + {0x54,0x80a62009}, + {0x58,0xb6006001}, + {0x5c,0x12800006}, + {0x60,0xb810001d}, + {0x64,0xc206401d}, + {0x68,0x83306001}, + {0x6c,0x8208401a}, + {0x70,0xc226401d}, + {0x74,0x80a62008}, + {0x78,0x08800006}, + {0x7c,0xc206401c}, + {0xf0,0x4a}, + {0x00,0xfa03c01c}, + {0x04,0xbb376001}, + {0x08,0x10800003}, + {0x0c,0xba0f401a}, + {0x10,0xfa03c01c}, + {0x14,0x8200401d}, + {0x18,0xc226401c}, + {0x1c,0x80a6e04f}, + {0x20,0x08bfffec}, + {0x24,0x8210001b}, + {0x28,0x81c7e008}, + {0x2c,0x81e80000}, + {0x30,0x03169696}, + {0x34,0xda002180}, + {0x38,0x8210625a}, + {0x3c,0x80a34001}, + {0x40,0x94102000}, + {0x44,0x12800006}, + {0x48,0x96102000}, + {0x4c,0x033fc180}, + {0x50,0x82106030}, + {0x54,0x10800024}, + {0x58,0xda204000}, + {0x5c,0xc202c000}, + {0x60,0x9602e004}, + {0x64,0x80a2e4ff}, + {0x68,0x08bffffd}, + {0x6c,0x94028001}, + {0x70,0x96102d00}, + {0x74,0xd2002ff8}, + {0x78,0x03000019}, + {0x7c,0x80a2c009}, + {0xf0,0x4b}, + {0x00,0x1a80000b}, + {0x04,0x901063ff}, + {0x08,0xd802c000}, + {0x0c,0x9602e004}, + {0x10,0x80a2c009}, + {0x14,0x9a402000}, + {0x18,0x80a2000b}, + {0x1c,0x82603fff}, + {0x20,0x808b4001}, + {0x24,0x12bffff9}, + {0x28,0x9402800c}, + {0x2c,0xc20021fc}, + {0x30,0x94228001}, + {0x34,0xc2002200}, + {0x38,0x94228001}, + {0x3c,0x03169696}, + {0x40,0x8210625a}, + {0x44,0x80a28001}, + {0x48,0x033fc180}, + {0x4c,0x82106030}, + {0x50,0x02800005}, + {0x54,0xd4204000}, + {0x58,0x03000008}, + {0x5c,0x81c06280}, + {0x60,0x90102001}, + {0x64,0x01000000}, + {0x68,0x81c3e008}, + {0x6c,0x01000000}, + {0x70,0x9de3bf98}, + {0x74,0x9e100018}, + {0x78,0x03000019}, + {0x7c,0xb0100019}, + {0xf0,0x4c}, + {0x00,0xba106080}, + {0x04,0xb6102000}, + {0x08,0x832ee002}, + {0x0c,0xb606e001}, + {0x10,0x80a6e0d7}, + {0x14,0x08bffffd}, + {0x18,0xc020401d}, + {0x1c,0xb6102000}, + {0x20,0xc20022fc}, + {0x24,0x80a6c001}, + {0x28,0x1a80001c}, + {0x2c,0x03000019}, + {0x30,0xb21060b4}, + {0x34,0xb4102000}, + {0x38,0xc20022f8}, + {0x3c,0x80a68001}, + {0x40,0x1a800011}, + {0x44,0x832ee002}, + {0x48,0xb8004019}, + {0x4c,0xc200247c}, + {0x50,0xfa0ee380}, + {0x54,0x825e8001}, + {0x58,0x8200401d}, + {0x5c,0x82004001}, + {0x60,0xfa160001}, + {0x64,0xc213c001}, + {0x68,0x8220401d}, + {0x6c,0xc2270000}, + {0x70,0xb406a001}, + {0x74,0xc20022f8}, + {0x78,0x80a68001}, + {0x7c,0x0abffff4}, + {0xf0,0x4d}, + {0x00,0xb8072030}, + {0x04,0xb606e001}, + {0x08,0xc20022fc}, + {0x0c,0x80a6c001}, + {0x10,0x0abfffea}, + {0x14,0xb4102000}, + {0x18,0x81c7e008}, + {0x1c,0x81e80000}, + {0x20,0x9de3bf98}, + {0x24,0x21000018}, + {0x28,0xc2002fe4}, + {0x2c,0x9fc04000}, + {0x30,0x90142200}, + {0x34,0xc200259c}, + {0x38,0xd800254c}, + {0x3c,0x808b2002}, + {0x40,0x02800033}, + {0x44,0xc2202550}, + {0x48,0xda002654}, + {0x4c,0x8203400d}, + {0x50,0x8200400d}, + {0x54,0xda00259c}, + {0x58,0xb2036140}, + {0x5c,0x82004001}, + {0x60,0x9a102061}, + {0x64,0x9a234001}, + {0x68,0x832e6007}, + {0x6c,0x9738601f}, + {0x70,0x8182e000}, + {0x74,0x01000000}, + {0x78,0x01000000}, + {0x7c,0x01000000}, + {0xf0,0x4e}, + {0x00,0xb278400d}, + {0x04,0x980b3ffd}, + {0x08,0xd820254c}, + {0x0c,0xc2002fe4}, + {0x10,0x9fc04000}, + {0x14,0x90142340}, + {0x18,0x11000017}, + {0x1c,0xe000259c}, + {0x20,0xc2002fe4}, + {0x24,0x9fc04000}, + {0x28,0x90122240}, + {0x2c,0x80a64010}, + {0x30,0x9a603fff}, + {0x34,0xc200259c}, + {0x38,0x80a64001}, + {0x3c,0x82603fff}, + {0x40,0x80934001}, + {0x44,0x22800012}, + {0x48,0xc020250c}, + {0x4c,0x21000019}, + {0x50,0x7ffffad5}, + {0x54,0x90142200}, + {0x58,0xa0142200}, + {0x5c,0xb2102000}, + {0x60,0x9b2e6002}, + {0x64,0xb2066001}, + {0x68,0xc2034010}, + {0x6c,0x80a66017}, + {0x70,0x04bffffc}, + {0x74,0xc22365b0}, + {0x78,0x7ffffb36}, + {0x7c,0x01000000}, + {0xf0,0x4f}, + {0x00,0x82102015}, + {0x04,0x10800010}, + {0x08,0xc2202500}, + {0x0c,0xc200250c}, + {0x10,0x80a06000}, + {0x14,0x1280000c}, + {0x18,0x031696a9}, + {0x1c,0x821061a5}, + {0x20,0x31000018}, + {0x24,0x33000017}, + {0x28,0xc220250c}, + {0x2c,0xc0202658}, + {0x30,0xc0202654}, + {0x34,0xb0162200}, + {0x38,0xb2166240}, + {0x3c,0x7ffffd69}, + {0x40,0x81e80000}, + {0x44,0x01000000}, + {0x48,0x81c7e008}, + {0x4c,0x81e80000}, + {0x50,0x9de3bf58}, + {0x54,0x94100018}, + {0x58,0x9a102000}, + {0x5c,0x96102000}, + {0x60,0x98102000}, + {0x64,0x9e102000}, + {0x68,0x8203000f}, + {0x6c,0xf6086441}, + {0x70,0x80a6e000}, + {0x74,0x02800024}, + {0x78,0xf4086440}, + {0x7c,0xc208217d}, + {0xf0,0x50}, + {0x00,0x80807fff}, + {0x04,0xf40ea37f}, + {0x08,0xf60ee37f}, + {0x0c,0x0c80001a}, + {0x10,0xb2102000}, + {0x14,0xb007bff8}, + {0x18,0xc200247c}, + {0x1c,0x82584019}, + {0x20,0xba06c001}, + {0x24,0x82068001}, + {0x28,0x82004001}, + {0x2c,0xf8528001}, + {0x30,0xba07401d}, + {0x34,0xc252801d}, + {0x38,0xb8270001}, + {0x3c,0x80a66000}, + {0x40,0x02800007}, + {0x44,0xf8263fc0}, + {0x48,0xc2063fbc}, + {0x4c,0x82a70001}, + {0x50,0x2c800003}, + {0x54,0x9a234001}, + {0x58,0x9a034001}, + {0x5c,0xc208217d}, + {0x60,0xb2066001}, + {0x64,0x82007fff}, + {0x68,0x80a64001}, + {0x6c,0x04bfffeb}, + {0x70,0xb0062004}, + {0x74,0x9e03e001}, + {0x78,0x80a3e00a}, + {0x7c,0x04bfffdc}, + {0xf0,0x51}, + {0x00,0x8203000f}, + {0x04,0x9602e001}, + {0x08,0x80a2e001}, + {0x0c,0x04bfffd6}, + {0x10,0x9803200c}, + {0x14,0xda20259c}, + {0x18,0x81c7e008}, + {0x1c,0x81e80000}, + {0x20,0x9de3bf98}, + {0x24,0xc2002304}, + {0x28,0x80a06000}, + {0x2c,0x02800022}, + {0x30,0x01000000}, + {0x34,0xf80021d8}, + {0x38,0x80a72000}, + {0x3c,0x0280001e}, + {0x40,0x82064019}, + {0x44,0x82004019}, + {0x48,0x83286002}, + {0x4c,0x82004018}, + {0x50,0xb1286002}, + {0x54,0x3b000019}, + {0x58,0xc2002300}, + {0x5c,0xb61760dc}, + {0x60,0xb41760e0}, + {0x64,0x9e1760e4}, + {0x68,0x80a64001}, + {0x6c,0x12800012}, + {0x70,0x9a176080}, + {0x74,0xc206001a}, + {0x78,0xfa06001b}, + {0x7c,0xba074001}, + {0xf0,0x52}, + {0x00,0xc206000f}, + {0x04,0xba074001}, + {0x08,0xba5f401c}, + {0x0c,0x833f601f}, + {0x10,0x83306019}, + {0x14,0xba074001}, + {0x18,0xc206000d}, + {0x1c,0xbb3f6007}, + {0x20,0x80a0401d}, + {0x24,0x16800004}, + {0x28,0x82102001}, + {0x2c,0xc220259c}, + {0x30,0x30800002}, + {0x34,0xc020259c}, + {0x38,0x81c7e008}, + {0x3c,0x81e80000}, + {0x40,0x9de3bf58}, + {0x44,0xc208224d}, + {0x48,0x80a06000}, + {0x4c,0x12800004}, + {0x50,0x90067ffe}, + {0x54,0xc020259c}, + {0x58,0x3080006a}, + {0x5c,0xac066002}, + {0x60,0x80a20016}, + {0x64,0x14800044}, + {0x68,0x9e102000}, + {0x6c,0x82020008}, + {0x70,0x82004008}, + {0x74,0xa1286002}, + {0x78,0xa8062002}, + {0x7c,0x92063ffe}, + {0xf0,0x53}, + {0x00,0x80a24014}, + {0x04,0x14800038}, + {0x08,0x82064019}, + {0x0c,0x82204008}, + {0x10,0x98004001}, + {0x14,0x98030001}, + {0x18,0x9b3a201f}, + {0x1c,0x96040009}, + {0x20,0x952be002}, + {0x24,0x03000019}, + {0x28,0x9a234008}, + {0x2c,0xae106080}, + {0x30,0x972ae002}, + {0x34,0x9402801e}, + {0x38,0xa72b2002}, + {0x3c,0xab33601f}, + {0x40,0x9602c017}, + {0x44,0x9402bfb8}, + {0x48,0xa4063fff}, + {0x4c,0xa2062001}, + {0x50,0x98067fff}, + {0x54,0x82060018}, + {0x58,0x82204009}, + {0x5c,0x8204c001}, + {0x60,0x80a24012}, + {0x64,0x0680000b}, + {0x68,0x9b286002}, + {0x6c,0x80a24011}, + {0x70,0x14800009}, + {0x74,0x80a26000}, + {0x78,0x80a2000c}, + {0x7c,0x06800005}, + {0xf0,0x54}, + {0x00,0x82066001}, + {0x04,0x80a20001}, + {0x08,0x24800014}, + {0x0c,0x92026001}, + {0x10,0x80a26000}, + {0x14,0x2480000d}, + {0x18,0xc2034017}, + {0x1c,0xc2002308}, + {0x20,0x80a04009}, + {0x24,0x82603fff}, + {0x28,0x80884015}, + {0x2c,0x22800007}, + {0x30,0xc2034017}, + {0x34,0xc2002300}, + {0x38,0x80a20001}, + {0x3c,0x38800003}, + {0x40,0xc2034017}, + {0x44,0xc202c000}, + {0x48,0xc2228000}, + {0x4c,0x9e03e001}, + {0x50,0x9402a004}, + {0x54,0x92026001}, + {0x58,0x80a24014}, + {0x5c,0x04bfffde}, + {0x60,0x9602e004}, + {0x64,0x90022001}, + {0x68,0x80a20016}, + {0x6c,0x04bfffc4}, + {0x70,0xa004200c}, + {0x74,0x9007bfb8}, + {0x78,0x7ffff8d7}, + {0x7c,0x92102010}, + {0xf0,0x55}, + {0x00,0xd608224f}, + {0x04,0xb00ae0ff}, + {0x08,0xd808224d}, + {0x0c,0x80a6000c}, + {0x10,0x1480000b}, + {0x14,0x9e102000}, + {0x18,0x832e2002}, + {0x1c,0x8200401e}, + {0x20,0x9a007fb8}, + {0x24,0xc2034000}, + {0x28,0xb0062001}, + {0x2c,0x9e03c001}, + {0x30,0x80a6000c}, + {0x34,0x04bffffc}, + {0x38,0x9a036004}, + {0x3c,0x820ae0ff}, + {0x40,0xda08224d}, + {0x44,0x9a234001}, + {0x48,0xc208224c}, + {0x4c,0x9a036001}, + {0x50,0x825bc001}, + {0x54,0x9938601f}, + {0x58,0x81832000}, + {0x5c,0x01000000}, + {0x60,0x01000000}, + {0x64,0x01000000}, + {0x68,0x8278400d}, + {0x6c,0x9b38601f}, + {0x70,0x9b336019}, + {0x74,0x8200400d}, + {0x78,0x83386007}, + {0x7c,0xc220259c}, + {0xf0,0x56}, + {0x00,0x81c7e008}, + {0x04,0x81e80000}, + {0x08,0x9de3bf98}, + {0x0c,0xc2002540}, + {0x10,0x82006001}, + {0x14,0xc2202540}, + {0x18,0xc2002588}, + {0x1c,0x80a06000}, + {0x20,0x02800014}, + {0x24,0x11000018}, + {0x28,0xc2002594}, + {0x2c,0x80a06000}, + {0x30,0x12800004}, + {0x34,0x90122340}, + {0x38,0x7ffffc3f}, + {0x3c,0x01000000}, + {0x40,0xda002588}, + {0x44,0xc2002594}, + {0x48,0x82006001}, + {0x4c,0x9a037fff}, + {0x50,0xc2202594}, + {0x54,0x7ffff9cb}, + {0x58,0xda202588}, + {0x5c,0x13000018}, + {0x60,0x92126340}, + {0x64,0xc2002fc0}, + {0x68,0x9fc04000}, + {0x6c,0xd4002594}, + {0x70,0x01000000}, + {0x74,0x81c7e008}, + {0x78,0x81e80000}, + {0x7c,0xc2002588}, + {0xf0,0x57}, + {0x00,0x80a06001}, + {0x04,0x1280001a}, + {0x08,0xda002298}, + {0x0c,0xc2102548}, + {0x10,0x80886001}, + {0x14,0x22800009}, + {0x18,0xc2002208}, + {0x1c,0xc2002170}, + {0x20,0x80a06000}, + {0x24,0x22800005}, + {0x28,0xc2002208}, + {0x2c,0xc0202598}, + {0x30,0x1080000f}, + {0x34,0x9a100001}, + {0x38,0x80a06000}, + {0x3c,0x22800009}, + {0x40,0xc2002598}, + {0x44,0xc2002558}, + {0x48,0x80a06000}, + {0x4c,0x32800005}, + {0x50,0xc2002598}, + {0x54,0xc0202598}, + {0x58,0x10800005}, + {0x5c,0xda002234}, + {0x60,0x80a06000}, + {0x64,0x22800002}, + {0x68,0xda00233c}, + {0x6c,0x033fc200}, + {0x70,0x82106070}, + {0x74,0x81c3e008}, + {0x78,0xda204000}, + {0x7c,0x9de3bf98}, + {0xf0,0x58}, + {0x00,0xc2002588}, + {0x04,0x80a06000}, + {0x08,0x02800010}, + {0x0c,0x11000018}, + {0x10,0xd8002548}, + {0x14,0x83332010}, + {0x18,0x80886001}, + {0x1c,0x22800010}, + {0x20,0xc200258c}, + {0x24,0xc2002558}, + {0x28,0x80a06000}, + {0x2c,0x3280000c}, + {0x30,0xc200258c}, + {0x34,0xc2002594}, + {0x38,0x80a06001}, + {0x3c,0x32800008}, + {0x40,0xc200258c}, + {0x44,0x11000018}, + {0x48,0x90122340}, + {0x4c,0xd0202590}, + {0x50,0xc0202588}, + {0x54,0x1080001a}, + {0x58,0xd2002594}, + {0x5c,0x80a06000}, + {0x60,0x12800015}, + {0x64,0x82102001}, + {0x68,0xda002554}, + {0x6c,0xc2002598}, + {0x70,0x80a0400d}, + {0x74,0x1a800007}, + {0x78,0x03000017}, + {0x7c,0x82102001}, + {0xf0,0x59}, + {0x00,0xda20258c}, + {0x04,0xc2202584}, + {0x08,0x10800028}, + {0x0c,0xc0202598}, + {0x10,0x808b2400}, + {0x14,0x12800004}, + {0x18,0x82106240}, + {0x1c,0x03000017}, + {0x20,0x82106100}, + {0x24,0xc2202590}, + {0x28,0xd2002598}, + {0x2c,0x10800004}, + {0x30,0xd0002590}, + {0x34,0x1080001d}, + {0x38,0xc2202584}, + {0x3c,0x7ffffbe6}, + {0x40,0x01000000}, + {0x44,0x13000018}, + {0x48,0xc2002fd0}, + {0x4c,0x92126200}, + {0x50,0x9fc04000}, + {0x54,0xd0002590}, + {0x58,0xc2002690}, + {0x5c,0x82087dff}, + {0x60,0xc2202690}, + {0x64,0x82102080}, + {0x68,0xc220256c}, + {0x6c,0xc2002200}, + {0x70,0x80a06000}, + {0x74,0x32800008}, + {0x78,0xc2002548}, + {0x7c,0xda002548}, + {0xf0,0x5a}, + {0x00,0x83336010}, + {0x04,0x80886001}, + {0x08,0x22800006}, + {0x0c,0x03000004}, + {0x10,0xc2002548}, + {0x14,0x1b000004}, + {0x18,0x10800003}, + {0x1c,0x8210400d}, + {0x20,0x822b4001}, + {0x24,0xc2202548}, + {0x28,0x81c7e008}, + {0x2c,0x81e80000}, + {0x30,0xda002508}, + {0x34,0x033fc000}, + {0x38,0x960b4001}, + {0x3c,0x808b7f00}, + {0x40,0x0280001a}, + {0x44,0x901020a5}, + {0x48,0x1500003f}, + {0x4c,0x8212a300}, + {0x50,0x980b4001}, + {0x54,0x03294000}, + {0x58,0x80a2c001}, + {0x5c,0x02800013}, + {0x60,0x01000000}, + {0x64,0xc200254c}, + {0x68,0x8210400c}, + {0x6c,0xc220254c}, + {0x70,0xc2002500}, + {0x74,0x80a06028}, + {0x78,0xc0202508}, + {0x7c,0x0880000b}, + {0xf0,0x5b}, + {0x00,0x033fffc0}, + {0x04,0x9a0b4001}, + {0x08,0x03168000}, + {0x0c,0x80a2c001}, + {0x10,0x12800006}, + {0x14,0x9812a3ff}, + {0x18,0xc2002548}, + {0x1c,0x8208400c}, + {0x20,0x8210400d}, + {0x24,0xc2202548}, + {0x28,0x03000006}, + {0x2c,0x81c063cc}, + {0x30,0x01000000}, + {0x34,0x01000000}, + {0x38,0xda00247c}, + {0x3c,0xc20022f8}, + {0x40,0x8258400d}, + {0x44,0x83306001}, + {0x48,0x9a102000}, + {0x4c,0x80a34001}, + {0x50,0x1a800015}, + {0x54,0x031fffdf}, + {0x58,0x961063ff}, + {0x5c,0x98036001}, + {0x60,0x80a26008}, + {0x64,0x04800006}, + {0x68,0x9b2b6002}, + {0x6c,0xc202000d}, + {0x70,0x83306001}, + {0x74,0x10800003}, + {0x78,0x8208400b}, + {0x7c,0xc202000d}, + {0xf0,0x5c}, + {0x00,0x82584009}, + {0x04,0xc222000d}, + {0x08,0xda00247c}, + {0x0c,0xc20022f8}, + {0x10,0x8258400d}, + {0x14,0x83306001}, + {0x18,0x80a30001}, + {0x1c,0x0abffff0}, + {0x20,0x9a10000c}, + {0x24,0x81c3e008}, + {0x28,0x01000000}, + {0x2c,0x9de3bf98}, + {0x30,0xc2102548}, + {0x34,0x80886001}, + {0x38,0x12800068}, + {0x3c,0x01000000}, + {0x40,0xe6002460}, + {0x44,0x80a4e000}, + {0x48,0x02800064}, + {0x4c,0x01000000}, + {0x50,0xc2002588}, + {0x54,0xda002594}, + {0x58,0x9800400d}, + {0x5c,0xc2002554}, + {0x60,0x80a30001}, + {0x64,0x1280005d}, + {0x68,0x01000000}, + {0x6c,0xda002598}, + {0x70,0xc200258c}, + {0x74,0x8200400d}, + {0x78,0x80a0400c}, + {0x7c,0x02800004}, + {0xf0,0x5d}, + {0x00,0x80a36000}, + {0x04,0x12800055}, + {0x08,0x01000000}, + {0x0c,0xe208217e}, + {0x10,0x808c60ff}, + {0x14,0x9e102000}, + {0x18,0x0280002e}, + {0x1c,0x96102001}, + {0x20,0xe408217f}, + {0x24,0x13000019}, + {0x28,0x94102001}, + {0x2c,0x80a28012}, + {0x30,0x14800020}, + {0x34,0xa0102000}, + {0x38,0x832ae002}, + {0x3c,0x98006030}, + {0x40,0xac126080}, + {0x44,0xaa126050}, + {0x48,0xa81260b0}, + {0x4c,0xd008217f}, + {0x50,0xda030016}, + {0x54,0x80a34013}, + {0x58,0x26800013}, + {0x5c,0x9402a001}, + {0x60,0x80a2a001}, + {0x64,0x22800007}, + {0x68,0xc208217f}, + {0x6c,0xc2030015}, + {0x70,0x80a34001}, + {0x74,0x2480000c}, + {0x78,0x9402a001}, + {0x7c,0xc208217f}, + {0xf0,0x5e}, + {0x00,0x80a28001}, + {0x04,0x22800007}, + {0x08,0xa0042001}, + {0x0c,0xc2030014}, + {0x10,0x80a34001}, + {0x14,0x26800004}, + {0x18,0x9402a001}, + {0x1c,0xa0042001}, + {0x20,0x9402a001}, + {0x24,0x80a28008}, + {0x28,0x04bfffea}, + {0x2c,0x98032030}, + {0x30,0x80a4000f}, + {0x34,0x34800002}, + {0x38,0x9e100010}, + {0x3c,0x9602e001}, + {0x40,0x820c60ff}, + {0x44,0x80a2c001}, + {0x48,0x24bfffd9}, + {0x4c,0x94102001}, + {0x50,0x96102000}, + {0x54,0xc20ae464}, + {0x58,0x80a06000}, + {0x5c,0x22800006}, + {0x60,0x9602e001}, + {0x64,0x80a3c001}, + {0x68,0x34800007}, + {0x6c,0xc20ae278}, + {0x70,0x9602e001}, + {0x74,0x80a2e003}, + {0x78,0x24bffff8}, + {0x7c,0xc20ae464}, + {0xf0,0x5f}, + {0x00,0x30800016}, + {0x04,0xda00256c}, + {0x08,0x8258400d}, + {0x0c,0x83306007}, + {0x10,0xc220256c}, + {0x14,0xe00ae468}, + {0x18,0x80a42000}, + {0x1c,0x0280000f}, + {0x20,0x82102001}, + {0x24,0xc2202584}, + {0x28,0xd0002590}, + {0x2c,0x7fffff83}, + {0x30,0xd2002554}, + {0x34,0xc2002588}, + {0x38,0x82004010}, + {0x3c,0xc2202588}, + {0x40,0xda00258c}, + {0x44,0xc2002554}, + {0x48,0x80a34001}, + {0x4c,0x18800003}, + {0x50,0x82034010}, + {0x54,0xc220258c}, + {0x58,0x81c7e008}, + {0x5c,0x81e80000}, + {0x60,0x9de3bf98}, + {0x64,0xc2002588}, + {0x68,0x80a06000}, + {0x6c,0x1280005f}, + {0x70,0x01000000}, + {0x74,0xc20026f4}, + {0x78,0x82006001}, + {0x7c,0xda002310}, + {0xf0,0x60}, + {0x00,0x80a0400d}, + {0x04,0x0a800059}, + {0x08,0xc22026f4}, + {0x0c,0xd800227c}, + {0x10,0x80a32000}, + {0x14,0x02800031}, + {0x18,0xc02026f4}, + {0x1c,0xda0022f8}, + {0x20,0xc200247c}, + {0x24,0x965b4001}, + {0x28,0x03000007}, + {0x2c,0x821063ff}, + {0x30,0x9b33200d}, + {0x34,0xa2102000}, + {0x38,0x920b4001}, + {0x3c,0x80a4400b}, + {0x40,0x900b0001}, + {0x44,0x94102000}, + {0x48,0x1a800014}, + {0x4c,0xa0102000}, + {0x50,0x03000018}, + {0x54,0xa4106200}, + {0x58,0x9e106340}, + {0x5c,0x9a040010}, + {0x60,0xc213400f}, + {0x64,0x80a24001}, + {0x68,0xa2400011}, + {0x6c,0xc2534012}, + {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,0x7ffff8dd}, + {0x10,0x90100010}, + {0x14,0x92100008}, + {0x18,0x7ffff876}, + {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,0xda002310}, + {0x78,0x80a36000}, + {0x7c,0x0280004f}, + {0xf0,0x63}, + {0x00,0x01000000}, + {0x04,0xc200254c}, + {0x08,0x80886100}, + {0x0c,0x1280004b}, + {0x10,0x01000000}, + {0x14,0xc20026f0}, + {0x18,0x82006001}, + {0x1c,0x80a0400d}, + {0x20,0x0a800046}, + {0x24,0xc22026f0}, + {0x28,0xa4102000}, + {0x2c,0xc20023d4}, + {0x30,0x80a48001}, + {0x34,0xc02026f0}, + {0x38,0xa2102000}, + {0x3c,0x1a800027}, + {0x40,0xa72c6002}, + {0x44,0xc204e364}, + {0x48,0x80a06000}, + {0x4c,0x0280001f}, + {0x50,0xa0102000}, + {0x54,0xc208217e}, + {0x58,0x80a40001}, + {0x5c,0x1680001b}, + {0x60,0x15000018}, + {0x64,0xc2002548}, + {0x68,0x80886020}, + {0x6c,0xc20c2380}, + {0x70,0x9412a340}, + {0x74,0x90100011}, + {0x78,0x12800006}, + {0x7c,0x920860ff}, + {0xf0,0x64}, + {0x00,0x15000018}, + {0x04,0x920860ff}, + {0x08,0x9412a200}, + {0x0c,0x90100011}, + {0x10,0x7ffff861}, + {0x14,0xa0042001}, + {0x18,0xc204e364}, + {0x1c,0xda002348}, + {0x20,0x98020001}, + {0x24,0x82034001}, + {0x28,0x80a20001}, + {0x2c,0x38bfffea}, + {0x30,0xa404a001}, + {0x34,0x80a3000d}, + {0x38,0x3abfffe8}, + {0x3c,0xc208217e}, + {0x40,0x10bfffe5}, + {0x44,0xa404a001}, + {0x48,0xa2046001}, + {0x4c,0xc20023d4}, + {0x50,0x10bfffdb}, + {0x54,0x80a44001}, + {0x58,0xd80026ec}, + {0x5c,0x80930012}, + {0x60,0x1280000a}, + {0x64,0x80a4a000}, + {0x68,0xda002548}, + {0x6c,0x83336005}, + {0x70,0x82086001}, + {0x74,0x82186001}, + {0x78,0x83286005}, + {0x7c,0x9a0b7fdf}, + {0xf0,0x65}, + {0x00,0x9a134001}, + {0x04,0xda202548}, + {0x08,0x12800004}, + {0x0c,0x82032001}, + {0x10,0x10800003}, + {0x14,0xc02026ec}, + {0x18,0xc22026ec}, + {0x1c,0xc20026ec}, + {0x20,0x80a06002}, + {0x24,0x04800005}, + {0x28,0x1b000040}, + {0x2c,0xc200254c}, + {0x30,0x8210400d}, + {0x34,0xc220254c}, + {0x38,0x81c7e008}, + {0x3c,0x81e80000}, + {0x40,0x9de3bf58}, + {0x44,0xc2002548}, + {0x48,0x8330600c}, + {0x4c,0x80886001}, + {0x50,0x1280006d}, + {0x54,0x01000000}, + {0x58,0xfa002500}, + {0x5c,0xc20021f4}, + {0x60,0x80a74001}, + {0x64,0x18800068}, + {0x68,0x01000000}, + {0x6c,0xc200254c}, + {0x70,0x8330600b}, + {0x74,0x82086001}, + {0x78,0x80a00001}, + {0x7c,0x9a603fff}, + {0xf0,0x66}, + {0x00,0x9403400d}, + {0x04,0xc252a210}, + {0x08,0x80a06000}, + {0x0c,0x0280005e}, + {0x10,0x8207bfb8}, + {0x14,0xb810200f}, + {0x18,0xc0204000}, + {0x1c,0xb8873fff}, + {0x20,0x1cbffffe}, + {0x24,0x82006004}, + {0x28,0xb0102001}, + {0x2c,0xc2002300}, + {0x30,0x80a60001}, + {0x34,0x1880003b}, + {0x38,0x03000019}, + {0x3c,0x82106080}, + {0x40,0x96006030}, + {0x44,0xb4102001}, + {0x48,0xc2002308}, + {0x4c,0x80a68001}, + {0x50,0x38800030}, + {0x54,0xb0062001}, + {0x58,0xb202e004}, + {0x5c,0xfa52a210}, + {0x60,0xc2064000}, + {0x64,0x80a0401d}, + {0x68,0x36800025}, + {0x6c,0xb406a001}, + {0x70,0x832ea018}, + {0x74,0xbb2e2010}, + {0x78,0x8200401d}, + {0x7c,0x9e006001}, + {0xf0,0x67}, + {0x00,0xb8102000}, + {0x04,0x98102001}, + {0x08,0xb607bfb8}, + {0x0c,0xbb2f2002}, + {0x10,0xc20f6828}, + {0x14,0x80a68001}, + {0x18,0x1280000f}, + {0x1c,0xb8072001}, + {0x20,0xc20f6829}, + {0x24,0x80a60001}, + {0x28,0x3280000c}, + {0x2c,0xc2176828}, + {0x30,0xd826c000}, + {0x34,0xc217682a}, + {0x38,0x80a061fe}, + {0x3c,0x38800010}, + {0x40,0xb406a001}, + {0x44,0xc2076828}, + {0x48,0x82006001}, + {0x4c,0x1080000b}, + {0x50,0xc2276828}, + {0x54,0xc2176828}, + {0x58,0x80a06000}, + {0x5c,0x12800005}, + {0x60,0x80a7200f}, + {0x64,0xd826c000}, + {0x68,0x10800004}, + {0x6c,0xde276828}, + {0x70,0x08bfffe7}, + {0x74,0xb606e004}, + {0x78,0xb406a001}, + {0x7c,0xc2002308}, + {0xf0,0x68}, + {0x00,0x80a68001}, + {0x04,0x08bfffd6}, + {0x08,0xb2066004}, + {0x0c,0xb0062001}, + {0x10,0xc2002300}, + {0x14,0x80a60001}, + {0x18,0x08bfffcb}, + {0x1c,0x9602e030}, + {0x20,0xb4102000}, + {0x24,0xb8102000}, + {0x28,0xb607bff8}, + {0x2c,0xbb2f2002}, + {0x30,0x8207401b}, + {0x34,0xc2007fc0}, + {0x38,0x80a06000}, + {0x3c,0x32800004}, + {0x40,0xfa17682a}, + {0x44,0x10800005}, + {0x48,0xc0276828}, + {0x4c,0xc20b63cc}, + {0x50,0x80a74001}, + {0x54,0xb466bfff}, + {0x58,0xb8072001}, + {0x5c,0x80a7200f}, + {0x60,0x08bffff4}, + {0x64,0xbb2f2002}, + {0x68,0xc20b63ce}, + {0x6c,0x80a68001}, + {0x70,0x08800005}, + {0x74,0x3b000200}, + {0x78,0xc200254c}, + {0x7c,0x8210401d}, + {0xf0,0x69}, + {0x00,0xc220254c}, + {0x04,0x81c7e008}, + {0x08,0x81e80000}, + {0x0c,0x9de3bf98}, + {0x10,0xd8002200}, + {0x14,0x80a32000}, + {0x18,0x1280000a}, + {0x1c,0x03000019}, + {0x20,0xc2002548}, + {0x24,0x82087ffb}, + {0x28,0xc2202548}, + {0x2c,0x033fc180}, + {0x30,0x8210602c}, + {0x34,0xc0204000}, + {0x38,0x1080004f}, + {0x3c,0xc02026d8}, + {0x40,0x82106080}, + {0x44,0xc0202504}, + {0x48,0x9e006030}, + {0x4c,0xb2102001}, + {0x50,0x10800016}, + {0x54,0xda102238}, + {0x58,0xf0002308}, + {0x5c,0x80a6c018}, + {0x60,0x38800011}, + {0x64,0xb2066001}, + {0x68,0xf410223a}, + {0x6c,0xba03e004}, + {0x70,0xc2074000}, + {0x74,0xb606e001}, + {0x78,0xba076004}, + {0x7c,0x80a0401a}, + {0xf0,0x6a}, + {0x00,0x04800005}, + {0x04,0xb820401a}, + {0x08,0xc2002504}, + {0x0c,0x8200401c}, + {0x10,0xc2202504}, + {0x14,0x80a6c018}, + {0x18,0x28bffff7}, + {0x1c,0xc2074000}, + {0x20,0xb2066001}, + {0x24,0x9e03e030}, + {0x28,0x80a36000}, + {0x2c,0x32800003}, + {0x30,0x80a6400d}, + {0x34,0x80a6400c}, + {0x38,0x18800004}, + {0x3c,0x80a66010}, + {0x40,0x08bfffe6}, + {0x44,0xb6102001}, + {0x48,0xfa10223e}, + {0x4c,0xc2002504}, + {0x50,0x80a0401d}, + {0x54,0x3480000a}, + {0x58,0xc2002548}, + {0x5c,0xfa10223c}, + {0x60,0x80a76000}, + {0x64,0x2280000b}, + {0x68,0xc2002548}, + {0x6c,0xc2082517}, + {0x70,0x80a0401d}, + {0x74,0x0a800007}, + {0x78,0xc2002548}, + {0x7c,0x80886008}, + {0xf0,0x6b}, + {0x00,0x22800008}, + {0x04,0xc20026d8}, + {0x08,0x10800008}, + {0x0c,0xc02026d8}, + {0x10,0x80886008}, + {0x14,0x22800005}, + {0x18,0xc02026d8}, + {0x1c,0xc20026d8}, + {0x20,0x82006001}, + {0x24,0xc22026d8}, + {0x28,0xfa0026d8}, + {0x2c,0xc2002290}, + {0x30,0x80a74001}, + {0x34,0x0880000b}, + {0x38,0xfa002548}, + {0x3c,0x83376003}, + {0x40,0x82086001}, + {0x44,0x82186001}, + {0x48,0x83286002}, + {0x4c,0xba0f7ffb}, + {0x50,0xba174001}, + {0x54,0xfa202548}, + {0x58,0xc02026d8}, + {0x5c,0xfa002548}, + {0x60,0xbb376002}, + {0x64,0x033fc180}, + {0x68,0xba0f6001}, + {0x6c,0x8210602c}, + {0x70,0xfa204000}, + {0x74,0x81c7e008}, + {0x78,0x81e80000}, + {0x7c,0x9de3bf70}, + {0xf0,0x6c}, + {0x00,0x1b00003f}, + {0x04,0xc2002350}, + {0x08,0x9a1363ff}, + {0x0c,0xae08400d}, + {0x10,0xa6102001}, + {0x14,0xda002300}, + {0x18,0x80a4c00d}, + {0x1c,0x18800062}, + {0x20,0xa3306010}, + {0x24,0xa410200c}, + {0x28,0xac102000}, + {0x2c,0xaa102000}, + {0x30,0xa8102000}, + {0x34,0x80a46000}, + {0x38,0x0280002c}, + {0x3c,0xa0102000}, + {0x40,0x03000019}, + {0x44,0x96106080}, + {0x48,0x92102000}, + {0x4c,0x9807bfd0}, + {0x50,0x82050009}, + {0x54,0xda086440}, + {0x58,0x8204800d}, + {0x5c,0x80a36000}, + {0x60,0x02800008}, + {0x64,0x83286002}, + {0x68,0xc200400b}, + {0x6c,0xc2230000}, + {0x70,0x92026001}, + {0x74,0x80a2600b}, + {0x78,0x04bffff6}, + {0x7c,0x98032004}, + {0xf0,0x6d}, + {0x00,0x7ffff5d5}, + {0x04,0x9007bfd0}, + {0x08,0x80a5c011}, + {0x0c,0x1480000b}, + {0x10,0x92100017}, + {0x14,0x832de002}, + {0x18,0x8200401e}, + {0x1c,0x9a007fd0}, + {0x20,0xc2034000}, + {0x24,0x92026001}, + {0x28,0xa0040001}, + {0x2c,0x80a24011}, + {0x30,0x04bffffc}, + {0x34,0x9a036004}, + {0x38,0x82244017}, + {0x3c,0x82006001}, + {0x40,0x9b3c201f}, + {0x44,0x81836000}, + {0x48,0x01000000}, + {0x4c,0x01000000}, + {0x50,0x01000000}, + {0x54,0xa07c0001}, + {0x58,0xc25021ae}, + {0x5c,0x80a40001}, + {0x60,0x26800002}, + {0x64,0xa0100001}, + {0x68,0x03000019}, + {0x6c,0x94106080}, + {0x70,0x92102000}, + {0x74,0x82054009}, + {0x78,0xda086440}, + {0x7c,0x8204800d}, + {0xf0,0x6e}, + {0x00,0x99286002}, + {0x04,0x80a36000}, + {0x08,0x0280001d}, + {0x0c,0x9610000c}, + {0x10,0x80a42000}, + {0x14,0x2480000c}, + {0x18,0xc202c00a}, + {0x1c,0xc203000a}, + {0x20,0x80a04010}, + {0x24,0x16800007}, + {0x28,0x98102000}, + {0x2c,0x80a06000}, + {0x30,0x24800006}, + {0x34,0x98100001}, + {0x38,0x10800005}, + {0x3c,0x8204800d}, + {0x40,0xc202c00a}, + {0x44,0x98204010}, + {0x48,0x8204800d}, + {0x4c,0x9b286002}, + {0x50,0xc20023c8}, + {0x54,0x83306011}, + {0x58,0x80886001}, + {0x5c,0x02800005}, + {0x60,0x92026001}, + {0x64,0xc20ce2af}, + {0x68,0x825b0001}, + {0x6c,0x99386007}, + {0x70,0x80a2600b}, + {0x74,0x04bfffe0}, + {0x78,0xd823400a}, + {0x7c,0xac05a001}, + {0xf0,0x6f}, + {0x00,0xa805200c}, + {0x04,0x80a5a001}, + {0x08,0x04bfffab}, + {0x0c,0xaa05600c}, + {0x10,0xa604e001}, + {0x14,0xc2002300}, + {0x18,0x80a4c001}, + {0x1c,0x08bfffa3}, + {0x20,0xa404a00c}, + {0x24,0x81c7e008}, + {0x28,0x81e80000}, + {0x2c,0x9de3bf58}, + {0x30,0xe2502458}, + {0x34,0x80a46000}, + {0x38,0x02800065}, + {0x3c,0x01000000}, + {0x40,0xc208217f}, + {0x44,0x80a44001}, + {0x48,0x16800061}, + {0x4c,0xa0102001}, + {0x50,0xc208217e}, + {0x54,0x80a40001}, + {0x58,0x1480005d}, + {0x5c,0xe450245a}, + {0x60,0x96102001}, + {0x64,0xc208217f}, + {0x68,0x80a2c001}, + {0x6c,0x1480000f}, + {0x70,0x03000019}, + {0x74,0x9b2c2002}, + {0x78,0x82106080}, + {0x7c,0x9a034001}, + {0xf0,0x70}, + {0x00,0x9a036030}, + {0x04,0x9807bfb8}, + {0x08,0xc2034000}, + {0x0c,0xc2230000}, + {0x10,0x9602e001}, + {0x14,0xc208217f}, + {0x18,0x80a2c001}, + {0x1c,0x9a036030}, + {0x20,0x04bffffa}, + {0x24,0x98032004}, + {0x28,0x9007bfb8}, + {0x2c,0x7ffff56a}, + {0x30,0xd208217f}, + {0x34,0x96100012}, + {0x38,0x80a48011}, + {0x3c,0x1480000b}, + {0x40,0x94102000}, + {0x44,0x832ca002}, + {0x48,0x8200401e}, + {0x4c,0x9a007fb8}, + {0x50,0xc2034000}, + {0x54,0x9602e001}, + {0x58,0x94028001}, + {0x5c,0x80a2c011}, + {0x60,0x04bffffc}, + {0x64,0x9a036004}, + {0x68,0x82244012}, + {0x6c,0x82006001}, + {0x70,0x9b3aa01f}, + {0x74,0x81836000}, + {0x78,0x01000000}, + {0x7c,0x01000000}, + {0xf0,0x71}, + {0x00,0x01000000}, + {0x04,0x947a8001}, + {0x08,0xc25021ac}, + {0x0c,0x80a28001}, + {0x10,0x26800002}, + {0x14,0x94100001}, + {0x18,0x96102001}, + {0x1c,0xc208217f}, + {0x20,0x80a2c001}, + {0x24,0x14800025}, + {0x28,0x832c2002}, + {0x2c,0x11000019}, + {0x30,0x98006030}, + {0x34,0x92122080}, + {0x38,0x80a2a000}, + {0x3c,0x0480000b}, + {0x40,0x9a122080}, + {0x44,0xc203000d}, + {0x48,0x80a0400a}, + {0x4c,0x36800008}, + {0x50,0xc2030009}, + {0x54,0x80a06000}, + {0x58,0x34800007}, + {0x5c,0xc023000d}, + {0x60,0x10800006}, + {0x64,0xc20023c8}, + {0x68,0xc2030009}, + {0x6c,0x8220400a}, + {0x70,0xc2230009}, + {0x74,0xc20023c8}, + {0x78,0x83306012}, + {0x7c,0x80886001}, + {0xf0,0x72}, + {0x00,0x0280000a}, + {0x04,0x9602e001}, + {0x08,0xda0c22af}, + {0x0c,0xc2030009}, + {0x10,0x8258400d}, + {0x14,0x9b38601f}, + {0x18,0x9b336019}, + {0x1c,0x8200400d}, + {0x20,0x83386007}, + {0x24,0xc2230009}, + {0x28,0xc208217f}, + {0x2c,0x80a2c001}, + {0x30,0x04bfffe2}, + {0x34,0x98032030}, + {0x38,0xa0042001}, + {0x3c,0xc208217e}, + {0x40,0x80a40001}, + {0x44,0x04bfffa8}, + {0x48,0x96102001}, + {0x4c,0x81c7e008}, + {0x50,0x81e80000}, + {0x54,0x9de3bf98}, + {0x58,0xfa5023c6}, + {0x5c,0x80a76000}, + {0x60,0x0280003c}, + {0x64,0xb0102001}, + {0x68,0xc208217e}, + {0x6c,0x80a60001}, + {0x70,0x14800038}, + {0x74,0x19000019}, + {0x78,0x82132080}, + {0x7c,0x9a10001d}, + {0xf0,0x73}, + {0x00,0x9e006004}, + {0x04,0xfa08217f}, + {0x08,0x80a76000}, + {0x0c,0xb2102000}, + {0x10,0x0280002b}, + {0x14,0x82102000}, + {0x18,0xb810001d}, + {0x1c,0xf45023c4}, + {0x20,0xba03e030}, + {0x24,0xf6074000}, + {0x28,0x80a6c01a}, + {0x2c,0x06800004}, + {0x30,0xba076030}, + {0x34,0xb206401b}, + {0x38,0x82006001}, + {0x3c,0xb8873fff}, + {0x40,0x32bffffa}, + {0x44,0xf6074000}, + {0x48,0x80a06000}, + {0x4c,0x2280001d}, + {0x50,0xb0062001}, + {0x54,0x973e601f}, + {0x58,0x8182e000}, + {0x5c,0x01000000}, + {0x60,0x01000000}, + {0x64,0x01000000}, + {0x68,0x827e4001}, + {0x6c,0x8258400d}, + {0x70,0xbb38601f}, + {0x74,0xbb376016}, + {0x78,0x8200401d}, + {0x7c,0xb8102001}, + {0xf0,0x74}, + {0x00,0xfa08217f}, + {0x04,0x80a7001d}, + {0x08,0x1480000d}, + {0x0c,0xb338600a}, + {0x10,0x832e2002}, + {0x14,0xba006030}, + {0x18,0xb6132080}, + {0x1c,0xc207401b}, + {0x20,0x82204019}, + {0x24,0xc227401b}, + {0x28,0xb8072001}, + {0x2c,0xc208217f}, + {0x30,0x80a70001}, + {0x34,0x04bffffa}, + {0x38,0xba076030}, + {0x3c,0xb0062001}, + {0x40,0xc208217e}, + {0x44,0x80a60001}, + {0x48,0x04bfffcf}, + {0x4c,0x9e03e004}, + {0x50,0x81c7e008}, + {0x54,0x81e80000}, + {0x58,0xc2082573}, + {0x5c,0xda00256c}, + {0x60,0x82006001}, + {0x64,0xd808257f}, + {0x68,0x9a5b4001}, + {0x6c,0x98032001}, + {0x70,0x81800000}, + {0x74,0x01000000}, + {0x78,0x01000000}, + {0x7c,0x01000000}, + {0xf0,0x75}, + {0x00,0x9a73400c}, + {0x04,0xda20256c}, + {0x08,0x96102000}, + {0x0c,0x832ae002}, + {0x10,0xd800256c}, + {0x14,0xda1063b6}, + {0x18,0x9a5b400c}, + {0x1c,0x9b336007}, + {0x20,0x9602e001}, + {0x24,0x80a2e003}, + {0x28,0x04bffff9}, + {0x2c,0xda206520}, + {0x30,0xc20023c0}, + {0x34,0x80a06000}, + {0x38,0x02800007}, + {0x3c,0x82103000}, + {0x40,0xc2002200}, + {0x44,0x80a06000}, + {0x48,0x22800005}, + {0x4c,0xc200255c}, + {0x50,0x82103000}, + {0x54,0xc220252c}, + {0x58,0xc200255c}, + {0x5c,0x80a06000}, + {0x60,0x02800005}, + {0x64,0xc2002288}, + {0x68,0x9b306001}, + {0x6c,0x83306002}, + {0x70,0x8200400d}, + {0x74,0xc220251c}, + {0x78,0x03000007}, + {0x7c,0x81c062d4}, + {0xf0,0x76}, + {0x00,0x01000000}, + {0x04,0x01000000}, + {0x08,0x9de3bf98}, + {0x0c,0xc20021cc}, + {0x10,0x80a06000}, + {0x14,0x22800025}, + {0x18,0xc20026e4}, + {0x1c,0x82064019}, + {0x20,0x82004019}, + {0x24,0x83286002}, + {0x28,0x82004018}, + {0x2c,0x9f286002}, + {0x30,0xb92e2010}, + {0x34,0x3b003fc0}, + {0x38,0x03000019}, + {0x3c,0x9a1760ff}, + {0x40,0xb8070019}, + {0x44,0x98106080}, + {0x48,0xb4102007}, + {0x4c,0xbb2ea002}, + {0x50,0xc20761b0}, + {0x54,0x80a06000}, + {0x58,0x02800030}, + {0x5c,0xb608400d}, + {0x60,0x80a6c01c}, + {0x64,0x3280000e}, + {0x68,0xb486bfff}, + {0x6c,0xfa0f61b0}, + {0x70,0x80a76000}, + {0x74,0x2280000d}, + {0x78,0xc20026e4}, + {0x7c,0xc203c00c}, + {0xf0,0x77}, + {0x00,0x8258401d}, + {0x04,0xbb38601f}, + {0x08,0xbb376019}, + {0x0c,0x8200401d}, + {0x10,0x83386007}, + {0x14,0x10800004}, + {0x18,0xc223c00c}, + {0x1c,0x1cbfffed}, + {0x20,0xbb2ea002}, + {0x24,0xc20026e4}, + {0x28,0x80a06000}, + {0x2c,0x12800033}, + {0x30,0xb6064019}, + {0x34,0x8206c019}, + {0x38,0x83286002}, + {0x3c,0x82004018}, + {0x40,0x3b000019}, + {0x44,0x83286002}, + {0x48,0xba176080}, + {0x4c,0xf800401d}, + {0x50,0xc200251c}, + {0x54,0x80a70001}, + {0x58,0x04800028}, + {0x5c,0x01000000}, + {0x60,0xfa00255c}, + {0x64,0x80a76000}, + {0x68,0x02800015}, + {0x6c,0x832e2010}, + {0x70,0xc20023c8}, + {0x74,0x80886100}, + {0x78,0x02800011}, + {0x7c,0x832e2010}, + {0xf0,0x78}, + {0x00,0x80a7001d}, + {0x04,0x0880001d}, + {0x08,0x82004019}, + {0x0c,0x82207000}, + {0x10,0x10800012}, + {0x14,0xc2202710}, + {0x18,0x82064019}, + {0x1c,0x82004019}, + {0x20,0x83286002}, + {0x24,0x82004018}, + {0x28,0x3b000019}, + {0x2c,0x83286002}, + {0x30,0xba176080}, + {0x34,0x10bfffdc}, + {0x38,0xc020401d}, + {0x3c,0xfa002514}, + {0x40,0x82004019}, + {0x44,0xb92f6002}, + {0x48,0x82207000}, + {0x4c,0xc2272710}, + {0x50,0xba076001}, + {0x54,0xfa202514}, + {0x58,0x8206c019}, + {0x5c,0x83286002}, + {0x60,0x82004018}, + {0x64,0x3b000019}, + {0x68,0x83286002}, + {0x6c,0xba176080}, + {0x70,0xc200401d}, + {0x74,0xc220255c}, + {0x78,0x81c7e008}, + {0x7c,0x81e80000}, + {0xf0,0x79}, + {0x00,0x9de3bf98}, + {0x04,0xc2002308}, + {0x08,0x82006001}, + {0x0c,0xe208217e}, + {0x10,0x80a44001}, + {0x14,0x0a80001a}, + {0x18,0xa4102001}, + {0x1c,0xc208217f}, + {0x20,0x80a48001}, + {0x24,0x38800013}, + {0x28,0xc2002308}, + {0x2c,0x832c6002}, + {0x30,0xa0006030}, + {0x34,0x92100012}, + {0x38,0x7fffff94}, + {0x3c,0x90100011}, + {0x40,0x03000019}, + {0x44,0x98106080}, + {0x48,0xda04000c}, + {0x4c,0x82106084}, + {0x50,0xda240001}, + {0x54,0xc024000c}, + {0x58,0xa404a001}, + {0x5c,0xc208217f}, + {0x60,0x80a48001}, + {0x64,0x08bffff4}, + {0x68,0xa0042030}, + {0x6c,0xc2002308}, + {0x70,0xa2047fff}, + {0x74,0x10bfffe7}, + {0x78,0x82006001}, + {0x7c,0xc2002300}, + {0xf0,0x7a}, + {0x00,0x82006001}, + {0x04,0xe408217f}, + {0x08,0x80a48001}, + {0x0c,0x0a80001e}, + {0x10,0x82048012}, + {0x14,0x82004012}, + {0x18,0xa7286002}, + {0x1c,0xa2102001}, + {0x20,0xc2002308}, + {0x24,0x80a44001}, + {0x28,0x18800011}, + {0x2c,0x832ce002}, + {0x30,0xa0006004}, + {0x34,0x90100011}, + {0x38,0x7fffff74}, + {0x3c,0x92100012}, + {0x40,0x03000019}, + {0x44,0x98106080}, + {0x48,0xda04000c}, + {0x4c,0x821060b0}, + {0x50,0xda240001}, + {0x54,0xc024000c}, + {0x58,0xa2046001}, + {0x5c,0xc2002308}, + {0x60,0x80a44001}, + {0x64,0x08bffff4}, + {0x68,0xa0042004}, + {0x6c,0xc2002300}, + {0x70,0xa404bfff}, + {0x74,0x82006001}, + {0x78,0x80a48001}, + {0x7c,0x1abfffe8}, + {0xf0,0x7b}, + {0x00,0xa604fff4}, + {0x04,0xa2102000}, + {0x08,0xc2002514}, + {0x0c,0x80a44001}, + {0x10,0x1a80002f}, + {0x14,0x94102000}, + {0x18,0xc200237c}, + {0x1c,0x80a06000}, + {0x20,0x2280000a}, + {0x24,0xc20023c8}, + {0x28,0xc202a710}, + {0x2c,0x99306010}, + {0x30,0x82086fff}, + {0x34,0x980b2fff}, + {0x38,0x97286010}, + {0x3c,0x83286018}, + {0x40,0x1080000d}, + {0x44,0x9a032001}, + {0x48,0x80886200}, + {0x4c,0x22800010}, + {0x50,0xda02a710}, + {0x54,0xc202a710}, + {0x58,0x99306010}, + {0x5c,0x82086fff}, + {0x60,0x82006001}, + {0x64,0x980b2fff}, + {0x68,0x97286010}, + {0x6c,0x83286018}, + {0x70,0x9a033fff}, + {0x74,0x8200400b}, + {0x78,0x9b2b6008}, + {0x7c,0x8200400d}, + {0xf0,0x7c}, + {0x00,0x8200400c}, + {0x04,0x1080000c}, + {0x08,0x82006001}, + {0x0c,0x820b6fff}, + {0x10,0x82006001}, + {0x14,0x99286010}, + {0x18,0x9b336010}, + {0x1c,0x83286018}, + {0x20,0x9a0b6fff}, + {0x24,0x8200400c}, + {0x28,0x992b6008}, + {0x2c,0x8200400c}, + {0x30,0x8200400d}, + {0x34,0xc222a738}, + {0x38,0xa2046001}, + {0x3c,0xc2002514}, + {0x40,0x80a44001}, + {0x44,0x0abfffd5}, + {0x48,0x9402a004}, + {0x4c,0x81c7e008}, + {0x50,0x81e80000}, + {0x54,0x9de3bf98}, + {0x58,0xc2002548}, + {0x5c,0x80886100}, + {0x60,0xac102000}, + {0x64,0x128000cf}, + {0x68,0xa6102000}, + {0x6c,0xc20026e4}, + {0x70,0x80a06000}, + {0x74,0x02800004}, + {0x78,0xa2102001}, + {0x7c,0x82007fff}, + {0xf0,0x7d}, + {0x00,0xc22026e4}, + {0x04,0xc2002300}, + {0x08,0x80a44001}, + {0x0c,0x388000a9}, + {0x10,0xda002530}, + {0x14,0xae10200c}, + {0x18,0xa4102001}, + {0x1c,0xc2002308}, + {0x20,0x80a48001}, + {0x24,0x18800092}, + {0x28,0x9b2de002}, + {0x2c,0x03000050}, + {0x30,0xaa044001}, + {0x34,0xa8036004}, + {0x38,0xc2002514}, + {0x3c,0x80a06009}, + {0x40,0x1880009b}, + {0x44,0x03000019}, + {0x48,0x82106080}, + {0x4c,0xda050001}, + {0x50,0xc2002474}, + {0x54,0x80a34001}, + {0x58,0x0680007f}, + {0x5c,0x03000040}, + {0x60,0x90100012}, + {0x64,0x7ffff7b8}, + {0x68,0x92100011}, + {0x6c,0x80a22000}, + {0x70,0x02800079}, + {0x74,0x03000040}, + {0x78,0xc2002ff0}, + {0x7c,0x80a06000}, + {0xf0,0x7e}, + {0x00,0x2280000a}, + {0x04,0xc2002fe0}, + {0x08,0x90100012}, + {0x0c,0x9fc04000}, + {0x10,0x92100011}, + {0x14,0xc200259c}, + {0x18,0x80a06000}, + {0x1c,0x1280006e}, + {0x20,0x03000040}, + {0x24,0xc2002fe0}, + {0x28,0x80a06000}, + {0x2c,0x2280000b}, + {0x30,0xc2002ff4}, + {0x34,0x90100012}, + {0x38,0x92100011}, + {0x3c,0x9fc04000}, + {0x40,0xd4002470}, + {0x44,0xc200259c}, + {0x48,0x80a06000}, + {0x4c,0x12800062}, + {0x50,0x03000040}, + {0x54,0xc2002ff4}, + {0x58,0x80a06000}, + {0x5c,0x02800006}, + {0x60,0xa0102000}, + {0x64,0x90100012}, + {0x68,0x9fc04000}, + {0x6c,0x92100011}, + {0x70,0xe000259c}, + {0x74,0x90100012}, + {0x78,0x92100011}, + {0x7c,0x94100010}, + {0xf0,0x7f}, + {0x00,0x7ffff7e3}, + {0x04,0xd6002470}, + {0x08,0x80a22000}, + {0x0c,0x02800052}, + {0x10,0x03000040}, + {0x14,0xc2002fe0}, + {0x18,0x80a06000}, + {0x1c,0x02800007}, + {0x20,0x90100012}, + {0x24,0x92100011}, + {0x28,0x9fc04000}, + {0x2c,0x94102100}, + {0x30,0x10800004}, + {0x34,0x94100010}, + {0x38,0xc020259c}, + {0x3c,0x94100010}, + {0x40,0x90100012}, + {0x44,0x92100011}, + {0x48,0x7ffff7d1}, + {0x4c,0x96102100}, + {0x50,0x80a22000}, + {0x54,0x22800011}, + {0x58,0xc2002514}, + {0x5c,0xc200259c}, + {0x60,0x80a06000}, + {0x64,0x3280000d}, + {0x68,0xc2002514}, + {0x6c,0xc2002280}, + {0x70,0xd8002514}, + {0x74,0xc22026e4}, + {0x78,0x9b2ca010}, + {0x7c,0x832b2002}, + {0xf0,0x80}, + {0x00,0x9a034011}, + {0x04,0xda206710}, + {0x08,0x98032001}, + {0x0c,0xd8202514}, + {0x10,0x10800006}, + {0x14,0xac05a001}, + {0x18,0x9b286002}, + {0x1c,0xea236710}, + {0x20,0x82006001}, + {0x24,0xc2202514}, + {0x28,0xc2002514}, + {0x2c,0x80a0600a}, + {0x30,0x12800029}, + {0x34,0x03000040}, + {0x38,0x03000019}, + {0x3c,0x9e106080}, + {0x40,0xe6002710}, + {0x44,0x90102001}, + {0x48,0x932a2002}, + {0x4c,0xd4026710}, + {0x50,0x980aafff}, + {0x54,0x960cefff}, + {0x58,0x8203000c}, + {0x5c,0x9a02c00b}, + {0x60,0x8200400c}, + {0x64,0x9a03400b}, + {0x68,0x9932a010}, + {0x6c,0x980b2fff}, + {0x70,0x9734e010}, + {0x74,0x83286002}, + {0x78,0x8200400c}, + {0x7c,0x960aefff}, + {0xf0,0x81}, + {0x00,0x9b2b6002}, + {0x04,0x83286002}, + {0x08,0x9a03400b}, + {0x0c,0xd800400f}, + {0x10,0x9b2b6002}, + {0x14,0xc203400f}, + {0x18,0x80a30001}, + {0x1c,0x36800004}, + {0x20,0xd422670c}, + {0x24,0xe622670c}, + {0x28,0xa610000a}, + {0x2c,0x90022001}, + {0x30,0xda002514}, + {0x34,0x80a2000d}, + {0x38,0x2abfffe5}, + {0x3c,0x932a2002}, + {0x40,0x832b6002}, + {0x44,0xc0206710}, + {0x48,0x82037fff}, + {0x4c,0xc2202514}, + {0x50,0x03000040}, + {0x54,0xaa054001}, + {0x58,0xa404a001}, + {0x5c,0xc2002308}, + {0x60,0x80a48001}, + {0x64,0x08bfff75}, + {0x68,0xa8052004}, + {0x6c,0xa2046001}, + {0x70,0xc2002300}, + {0x74,0x80a44001}, + {0x78,0x08bfff68}, + {0x7c,0xae05e00c}, + {0xf0,0x82}, + {0x00,0x80a4e000}, + {0x04,0x2280000b}, + {0x08,0xda002530}, + {0x0c,0xda002514}, + {0x10,0x80a36009}, + {0x14,0x38800007}, + {0x18,0xda002530}, + {0x1c,0x832b6002}, + {0x20,0xe6206710}, + {0x24,0x82036001}, + {0x28,0xc2202514}, + {0x2c,0xda002530}, + {0x30,0x80a5800d}, + {0x34,0x14800006}, + {0x38,0x82100016}, + {0x3c,0xc2002514}, + {0x40,0x80a34001}, + {0x44,0x28800002}, + {0x48,0x8210000d}, + {0x4c,0x80a5a000}, + {0x50,0x02800004}, + {0x54,0xc2202530}, + {0x58,0x1080000a}, + {0x5c,0xc20021f8}, + {0x60,0x80a06000}, + {0x64,0x22800009}, + {0x68,0xc2002530}, + {0x6c,0xc20026f8}, + {0x70,0x80a06000}, + {0x74,0x22800004}, + {0x78,0xc0202530}, + {0x7c,0x82006001}, + {0xf0,0x83}, + {0x00,0xc22026f8}, + {0x04,0xc2002530}, + {0x08,0x80a06000}, + {0x0c,0x02800005}, + {0x10,0x01000000}, + {0x14,0xc2002548}, + {0x18,0x82106040}, + {0x1c,0xc2202548}, + {0x20,0x81c7e008}, + {0x24,0x81e80000}, + {0x28,0x82220009}, + {0x2c,0x9a58400a}, + {0x30,0x833b601f}, + {0x34,0x80a20009}, + {0x38,0x83306019}, + {0x3c,0x04800004}, + {0x40,0x90102000}, + {0x44,0x82034001}, + {0x48,0x91386007}, + {0x4c,0x81c3e008}, + {0x50,0x01000000}, + {0x54,0x9de3bf98}, + {0x58,0x7ffff7d4}, + {0x5c,0xa8102001}, + {0x60,0xc208217f}, + {0x64,0x80a07fff}, + {0x68,0x0280001c}, + {0x6c,0xa6102003}, + {0x70,0x23000019}, + {0x74,0xa12ce004}, + {0x78,0x82146088}, + {0x7c,0xa4146084}, + {0xf0,0x84}, + {0x00,0xd2040001}, + {0x04,0xd408228c}, + {0x08,0x7fffffe8}, + {0x0c,0xd0040012}, + {0x10,0x9a146080}, + {0x14,0xd024000d}, + {0x18,0xc2002308}, + {0x1c,0xa12ce002}, + {0x20,0xa0040001}, + {0x24,0xa12c2002}, + {0x28,0xa214607c}, + {0x2c,0xd004000d}, + {0x30,0xd2040011}, + {0x34,0x7fffffdd}, + {0x38,0xd408228d}, + {0x3c,0xd0240012}, + {0x40,0xc208217f}, + {0x44,0xa8052001}, + {0x48,0x82006001}, + {0x4c,0x80a50001}, + {0x50,0x08bfffe8}, + {0x54,0xa604e003}, + {0x58,0xa6102001}, + {0x5c,0xc2002308}, + {0x60,0x80a4c001}, + {0x64,0x1880001c}, + {0x68,0x23000019}, + {0x6c,0xa12ce002}, + {0x70,0x821460e0}, + {0x74,0xa41460b0}, + {0x78,0xd2040001}, + {0x7c,0xd408228e}, + {0xf0,0x85}, + {0x00,0x7fffffca}, + {0x04,0xd0040012}, + {0x08,0x9a146080}, + {0x0c,0xd024000d}, + {0x10,0xc2002300}, + {0x14,0xa0004001}, + {0x18,0xa0040001}, + {0x1c,0xa12c2002}, + {0x20,0xa0040013}, + {0x24,0xa12c2002}, + {0x28,0xa2146050}, + {0x2c,0xd004000d}, + {0x30,0xd2040011}, + {0x34,0x7fffffbd}, + {0x38,0xd408228f}, + {0x3c,0xd0240012}, + {0x40,0xa604e001}, + {0x44,0xc2002308}, + {0x48,0x80a4c001}, + {0x4c,0x08bfffe8}, + {0x50,0x23000019}, + {0x54,0x81c7e008}, + {0x58,0x81e80000}, + {0x5c,0x9de3bf88}, + {0x60,0xc2002fe4}, + {0x64,0x9fc04000}, + {0x68,0xd0002590}, + {0x6c,0xda002550}, + {0x70,0x832b6004}, + {0x74,0x8220400d}, + {0x78,0xe000259c}, + {0x7c,0x82040001}, + {0xf0,0x86}, + {0x00,0x83306004}, + {0x04,0xc2202550}, + {0x08,0x11000018}, + {0x0c,0xc2002fe4}, + {0x10,0x9fc04000}, + {0x14,0x90122200}, + {0x18,0xc208217c}, + {0x1c,0xda08217d}, + {0x20,0x9a5b4001}, + {0x24,0xc200259c}, + {0x28,0x8200400d}, + {0x2c,0xc220259c}, + {0x30,0xda00259c}, + {0x34,0xc2002550}, + {0x38,0x80a34001}, + {0x3c,0x28800011}, + {0x40,0xc2002548}, + {0x44,0xc200259c}, + {0x48,0x80a04010}, + {0x4c,0x0880000d}, + {0x50,0xc2002548}, + {0x54,0x80a42000}, + {0x58,0x0280000a}, + {0x5c,0x01000000}, + {0x60,0x82087f7f}, + {0x64,0xc2202548}, + {0x68,0xc2002658}, + {0x6c,0x80a06000}, + {0x70,0x26800006}, + {0x74,0xc0202658}, + {0x78,0x10800005}, + {0x7c,0xc208254e}, + {0xf0,0x87}, + {0x00,0x82106080}, + {0x04,0xc2202548}, + {0x08,0xc208254e}, + {0x0c,0x80a00001}, + {0x10,0x82602000}, + {0x14,0xa0087ffe}, + {0x18,0xd8002548}, + {0x1c,0x83332010}, + {0x20,0x80886001}, + {0x24,0x02800012}, + {0x28,0xa0042003}, + {0x2c,0x03000180}, + {0x30,0x820b0001}, + {0x34,0x1b000080}, + {0x38,0x80a0400d}, + {0x3c,0x22800061}, + {0x40,0xc02026d4}, + {0x44,0xc2002160}, + {0x48,0x80886040}, + {0x4c,0x0280002c}, + {0x50,0xa0102000}, + {0x54,0xc2002558}, + {0x58,0x80a06000}, + {0x5c,0x02800028}, + {0x60,0xa0102002}, + {0x64,0x10800026}, + {0x68,0xa0102000}, + {0x6c,0x033fc200}, + {0x70,0x82106030}, + {0x74,0xda004000}, + {0x78,0xc2002570}, + {0x7c,0x80a34001}, + {0xf0,0x88}, + {0x00,0x32800050}, + {0x04,0xc02026d4}, + {0x08,0xc2002200}, + {0x0c,0x80a06000}, + {0x10,0x3280004c}, + {0x14,0xc02026d4}, + {0x18,0xda002690}, + {0x1c,0x03000007}, + {0x20,0x808b4001}, + {0x24,0x32800047}, + {0x28,0xc02026d4}, + {0x2c,0xda002654}, + {0x30,0xc20021dc}, + {0x34,0x80a34001}, + {0x38,0x2a800008}, + {0x3c,0xc2002514}, + {0x40,0xc200254c}, + {0x44,0x8330600e}, + {0x48,0x80886001}, + {0x4c,0x1280000a}, + {0x50,0x808b2040}, + {0x54,0xc2002514}, + {0x58,0x80a06000}, + {0x5c,0x22800009}, + {0x60,0xc20c2314}, + {0x64,0x808b2080}, + {0x68,0x22800006}, + {0x6c,0xc20c2314}, + {0x70,0x808b2040}, + {0x74,0x32800033}, + {0x78,0xc02026d4}, + {0x7c,0xc20c2314}, + {0xf0,0x89}, + {0x00,0x80a06000}, + {0x04,0x2280002f}, + {0x08,0xc02026d4}, + {0x0c,0xc20026d4}, + {0x10,0x98006001}, + {0x14,0xc2002700}, + {0x18,0xda082169}, + {0x1c,0xd82026d4}, + {0x20,0x80a0400d}, + {0x24,0x0480000a}, + {0x28,0xc20c2314}, + {0x2c,0x820860ff}, + {0x30,0xda082168}, + {0x34,0x8258400d}, + {0x38,0x80a30001}, + {0x3c,0x06800021}, + {0x40,0x01000000}, + {0x44,0x10800007}, + {0x48,0xc02026d4}, + {0x4c,0x820860ff}, + {0x50,0x80a30001}, + {0x54,0x0680001b}, + {0x58,0x01000000}, + {0x5c,0xc02026d4}, + {0x60,0xc20c234c}, + {0x64,0xc227bfec}, + {0x68,0xc20c230c}, + {0x6c,0xc227bff0}, + {0x70,0xa0102000}, + {0x74,0xc208217c}, + {0x78,0x80a40001}, + {0x7c,0x1a800011}, + {0xf0,0x8a}, + {0x00,0x01000000}, + {0x04,0xc20c2380}, + {0x08,0xc227bfe8}, + {0x0c,0xa2102000}, + {0x10,0xc208217d}, + {0x14,0x80a44001}, + {0x18,0x3a800006}, + {0x1c,0xa0042001}, + {0x20,0x7ffff716}, + {0x24,0x9007bfe8}, + {0x28,0x10bffffa}, + {0x2c,0xa2046001}, + {0x30,0xc208217c}, + {0x34,0x80a40001}, + {0x38,0x2abffff4}, + {0x3c,0xc20c2380}, + {0x40,0x81c7e008}, + {0x44,0x81e80000}, + {0x48,0x9de3bf88}, + {0x4c,0xd8082246}, + {0x50,0x80a32000}, + {0x54,0x22800040}, + {0x58,0xc02026e0}, + {0x5c,0xda00254c}, + {0x60,0x83336018}, + {0x64,0x80886001}, + {0x68,0x12800007}, + {0x6c,0x03004000}, + {0x70,0xc20026e4}, + {0x74,0x80a06000}, + {0x78,0x22800008}, + {0x7c,0xc200255c}, + {0xf0,0x8b}, + {0x00,0x03004000}, + {0x04,0x822b4001}, + {0x08,0xc220254c}, + {0x0c,0xc027bfec}, + {0x10,0x1080000e}, + {0x14,0xc027bff0}, + {0x18,0x80a06000}, + {0x1c,0x3280002e}, + {0x20,0xc02026e0}, + {0x24,0xc20026e0}, + {0x28,0x82006001}, + {0x2c,0x80a0400c}, + {0x30,0x06800029}, + {0x34,0xc22026e0}, + {0x38,0xc2082244}, + {0x3c,0xc227bfec}, + {0x40,0xc2082245}, + {0x44,0xc227bff0}, + {0x48,0xe008217c}, + {0x4c,0xc20022fc}, + {0x50,0x80a40001}, + {0x54,0x1a80000c}, + {0x58,0xa2102001}, + {0x5c,0xc20c2380}, + {0x60,0xc227bfe8}, + {0x64,0xc20022f8}, + {0x68,0x80a44001}, + {0x6c,0x38bffff8}, + {0x70,0xa0042001}, + {0x74,0x7ffff6e1}, + {0x78,0x9007bfe8}, + {0x7c,0x10bffffa}, + {0xf0,0x8c}, + {0x00,0xa2046001}, + {0x04,0xa0102001}, + {0x08,0xc208217c}, + {0x0c,0x80a40001}, + {0x10,0x14800010}, + {0x14,0xa2102000}, + {0x18,0xc208217d}, + {0x1c,0xda00247c}, + {0x20,0x9a5b4001}, + {0x24,0xc20c237f}, + {0x28,0x8200400d}, + {0x2c,0xc227bfe8}, + {0x30,0xc2002304}, + {0x34,0x80a44001}, + {0x38,0x3abffff4}, + {0x3c,0xa0042001}, + {0x40,0x7ffff6ce}, + {0x44,0x9007bfe8}, + {0x48,0x10bffffa}, + {0x4c,0xa2046001}, + {0x50,0xc02026e0}, + {0x54,0x81c7e008}, + {0x58,0x81e80000}, + {0x5c,0xd2002208}, + {0x60,0x80a26000}, + {0x64,0x0280001a}, + {0x68,0x01000000}, + {0x6c,0xc2102548}, + {0x70,0x80886001}, + {0x74,0x12800016}, + {0x78,0x01000000}, + {0x7c,0xc2002514}, + {0xf0,0x8d}, + {0x00,0x80a06000}, + {0x04,0x12800007}, + {0x08,0xc2002558}, + {0x0c,0x80a06000}, + {0x10,0x0280000f}, + {0x14,0x9a007fff}, + {0x18,0x1080000d}, + {0x1c,0xda202558}, + {0x20,0x15200040}, + {0x24,0x1b3fc200}, + {0x28,0x9812a001}, + {0x2c,0x80a06000}, + {0x30,0x12800006}, + {0x34,0x96136070}, + {0x38,0xd8234000}, + {0x3c,0xc2002298}, + {0x40,0xc222c000}, + {0x44,0xd4234000}, + {0x48,0xd2202558}, + {0x4c,0x81c3e008}, + {0x50,0x01000000}, + {0x54,0x92102000}, + {0x58,0xc2002514}, + {0x5c,0x80a24001}, + {0x60,0x1a800019}, + {0x64,0x912a6002}, + {0x68,0xd4022710}, + {0x6c,0x820aafff}, + {0x70,0x9732a010}, + {0x74,0x98006001}, + {0x78,0x960aefff}, + {0x7c,0x82007fff}, + {0xf0,0x8e}, + {0x00,0x83286018}, + {0x04,0x992b2010}, + {0x08,0x9a02ffff}, + {0x0c,0x8200400c}, + {0x10,0x9b2b6008}, + {0x14,0x8200400d}, + {0x18,0x8200400b}, + {0x1c,0x9532a00c}, + {0x20,0x92026001}, + {0x24,0x808aa001}, + {0x28,0x12800003}, + {0x2c,0x82006001}, + {0x30,0xc2222738}, + {0x34,0xc2002514}, + {0x38,0x80a24001}, + {0x3c,0x0abfffeb}, + {0x40,0x912a6002}, + {0x44,0x81c3e008}, + {0x48,0x01000000}, + {0x4c,0x9de3bf98}, + {0x50,0x92102000}, + {0x54,0xc2002514}, + {0x58,0x80a24001}, + {0x5c,0x1a80005f}, + {0x60,0x94102000}, + {0x64,0xb72a6002}, + {0x68,0xf20ee738}, + {0x6c,0xc20ee739}, + {0x70,0x80a64001}, + {0x74,0x96102000}, + {0x78,0x9e102000}, + {0x7c,0x14800022}, + {0xf0,0x8f}, + {0x00,0x9a102000}, + {0x04,0x82064019}, + {0x08,0x82004019}, + {0x0c,0x3b000019}, + {0x10,0x90176080}, + {0x14,0xb9286002}, + {0x18,0xc20ee73b}, + {0x1c,0xf40ee73a}, + {0x20,0x80a68001}, + {0x24,0x14800012}, + {0x28,0x8207001a}, + {0x2c,0x83286002}, + {0x30,0x82004008}, + {0x34,0xd80aa73b}, + {0x38,0xf6004000}, + {0x3c,0xba5ec01a}, + {0x40,0x82006004}, + {0x44,0xb406a001}, + {0x48,0x80a6e000}, + {0x4c,0x04800005}, + {0x50,0xb05ec019}, + {0x54,0x9e03c018}, + {0x58,0x9a03401d}, + {0x5c,0x9602c01b}, + {0x60,0x80a6800c}, + {0x64,0x24bffff6}, + {0x68,0xf6004000}, + {0x6c,0xb72a6002}, + {0x70,0xb2066001}, + {0x74,0xc20ee739}, + {0x78,0x80a64001}, + {0x7c,0x04bfffe7}, + {0xf0,0x90}, + {0x00,0xb807200c}, + {0x04,0xbb2b6006}, + {0x08,0xb92be006}, + {0x0c,0xc202a710}, + {0x10,0x9b3f201f}, + {0x14,0x81836000}, + {0x18,0x01000000}, + {0x1c,0x01000000}, + {0x20,0x01000000}, + {0x24,0xb87f000b}, + {0x28,0x9b3f601f}, + {0x2c,0x81836000}, + {0x30,0x01000000}, + {0x34,0x01000000}, + {0x38,0x01000000}, + {0x3c,0xba7f400b}, + {0x40,0x8330600c}, + {0x44,0x80886001}, + {0x48,0x9e073fe0}, + {0x4c,0x02800007}, + {0x50,0x9a077fe0}, + {0x54,0xc200237c}, + {0x58,0x80a06000}, + {0x5c,0x22800003}, + {0x60,0x9e073fa0}, + {0x64,0x9a077fa0}, + {0x68,0x80a3e000}, + {0x6c,0x24800002}, + {0x70,0x9e102001}, + {0x74,0x80a36000}, + {0x78,0x24800002}, + {0x7c,0x9a102001}, + {0xf0,0x91}, + {0x00,0xc208217f}, + {0x04,0x83286006}, + {0x08,0x80a3c001}, + {0x0c,0x36800002}, + {0x10,0x9e007fff}, + {0x14,0xc208217e}, + {0x18,0x83286006}, + {0x1c,0x80a34001}, + {0x20,0x36800002}, + {0x24,0x9a007fff}, + {0x28,0xfa02a710}, + {0x2c,0x832be010}, + {0x30,0x3900003c}, + {0x34,0x8200400d}, + {0x38,0xba0f401c}, + {0x3c,0x8200401d}, + {0x40,0xc222a710}, + {0x44,0x92026001}, + {0x48,0xc2002514}, + {0x4c,0x80a24001}, + {0x50,0x0abfffa5}, + {0x54,0x9402a004}, + {0x58,0x7ffff4bd}, + {0x5c,0x91e8205a}, + {0x60,0x01000000}, + {0x64,0x9de3bf98}, + {0x68,0xd8002548}, + {0x6c,0x8333200c}, + {0x70,0x80886001}, + {0x74,0x12800081}, + {0x78,0x01000000}, + {0x7c,0xc208254d}, + {0xf0,0x92}, + {0x00,0x80a06000}, + {0x04,0x1280007d}, + {0x08,0x01000000}, + {0x0c,0xc208254e}, + {0x10,0x80a06000}, + {0x14,0x02800079}, + {0x18,0x01000000}, + {0x1c,0xc2002554}, + {0x20,0x825860fa}, + {0x24,0xda002500}, + {0x28,0x80a34001}, + {0x2c,0x0a800073}, + {0x30,0x01000000}, + {0x34,0xd6002658}, + {0x38,0x80a2e000}, + {0x3c,0x1480001c}, + {0x40,0x8202ffff}, + {0x44,0xc2002514}, + {0x48,0x80a06001}, + {0x4c,0x3280006b}, + {0x50,0xc0202658}, + {0x54,0xc2002710}, + {0x58,0x80a06000}, + {0x5c,0x12800004}, + {0x60,0x808b2040}, + {0x64,0x10800065}, + {0x68,0xc0202658}, + {0x6c,0x32800006}, + {0x70,0xd800239c}, + {0x74,0x80a2e000}, + {0x78,0x0680000d}, + {0x7c,0x8202e001}, + {0xf0,0x93}, + {0x00,0xd800239c}, + {0x04,0x0300003f}, + {0x08,0x9b332010}, + {0x0c,0x821063ff}, + {0x10,0x980b0001}, + {0x14,0x9a38000d}, + {0x18,0x9a23400c}, + {0x1c,0x80a2c00d}, + {0x20,0x06800005}, + {0x24,0x03296956}, + {0x28,0x8202ffff}, + {0x2c,0x10800053}, + {0x30,0xc2202658}, + {0x34,0x9a10625a}, + {0x38,0xc200250c}, + {0x3c,0x80a0400d}, + {0x40,0x02800004}, + {0x44,0xa0102000}, + {0x48,0xda20250c}, + {0x4c,0xc0202654}, + {0x50,0x832c2002}, + {0x54,0x92006610}, + {0x58,0xc2006610}, + {0x5c,0x90102710}, + {0x60,0x80a06000}, + {0x64,0x0280000d}, + {0x68,0xa0042001}, + {0x6c,0x7ffff4e6}, + {0x70,0x01000000}, + {0x74,0xc2002300}, + {0x78,0xda002308}, + {0x7c,0x82584001}, + {0xf0,0x94}, + {0x00,0x9a5b400d}, + {0x04,0x8200400d}, + {0x08,0x83286006}, + {0x0c,0x80a20001}, + {0x10,0x0a80003a}, + {0x14,0x01000000}, + {0x18,0x80a4200f}, + {0x1c,0x08bfffee}, + {0x20,0x832c2002}, + {0x24,0x030041eb}, + {0x28,0xc2202658}, + {0x2c,0xa010200f}, + {0x30,0x9b2c2002}, + {0x34,0xc203660c}, + {0x38,0xa0843fff}, + {0x3c,0x12bffffd}, + {0x40,0xc2236610}, + {0x44,0xda002654}, + {0x48,0xc2002710}, + {0x4c,0xc2202610}, + {0x50,0x80a3600f}, + {0x54,0x14800003}, + {0x58,0x9010200f}, + {0x5c,0x9010000d}, + {0x60,0x03000017}, + {0x64,0x9e106240}, + {0x68,0x82006400}, + {0x6c,0xa2106200}, + {0x70,0x0300003f}, + {0x74,0xa61063ff}, + {0x78,0x92022001}, + {0x7c,0xa0102000}, + {0xf0,0x95}, + {0x00,0xa410000f}, + {0x04,0x972c2002}, + {0x08,0x8203c00b}, + {0x0c,0xda106002}, + {0x10,0x9804400b}, + {0x14,0xd4132002}, + {0x18,0xc213c00b}, + {0x1c,0xd814400b}, + {0x20,0x82584008}, + {0x24,0x9a5b4008}, + {0x28,0x8200400c}, + {0x2c,0x9a03400a}, + {0x30,0x81800000}, + {0x34,0x01000000}, + {0x38,0x01000000}, + {0x3c,0x01000000}, + {0x40,0x82704009}, + {0x44,0x81800000}, + {0x48,0x01000000}, + {0x4c,0x01000000}, + {0x50,0x01000000}, + {0x54,0x9a734009}, + {0x58,0x83286010}, + {0x5c,0x9a0b4013}, + {0x60,0x8200400d}, + {0x64,0xa0042001}, + {0x68,0x80a4204f}, + {0x6c,0x08bfffe6}, + {0x70,0xc222c012}, + {0x74,0xd2202654}, + {0x78,0x81c7e008}, + {0x7c,0x81e80000}, + {0xf0,0x96}, + {0x00,0x9de3bf98}, + {0x04,0xa2102000}, + {0x08,0xc2002514}, + {0x0c,0x80a44001}, + {0x10,0xa0102000}, + {0x14,0x1a800012}, + {0x18,0x832c2002}, + {0x1c,0x92006710}, + {0x20,0xc2006710}, + {0x24,0x80a06000}, + {0x28,0x02800009}, + {0x2c,0x90100018}, + {0x30,0x7ffff495}, + {0x34,0x01000000}, + {0x38,0x82102001}, + {0x3c,0x80a20019}, + {0x40,0x1a800003}, + {0x44,0x83284010}, + {0x48,0xa2144001}, + {0x4c,0xa0042001}, + {0x50,0xc2002514}, + {0x54,0x10bffff0}, + {0x58,0x80a40001}, + {0x5c,0x81c7e008}, + {0x60,0x91e80011}, + {0x64,0x9de3bf90}, + {0x68,0x03003fc0}, + {0x6c,0x82106001}, + {0x70,0xc227bff0}, + {0x74,0xc027bff4}, + {0x78,0xa0102000}, + {0x7c,0x8207bff8}, + {0xf0,0x97}, + {0x00,0x82040001}, + {0x04,0xd2487ff9}, + {0x08,0xd0487ff8}, + {0x0c,0x90060008}, + {0x10,0x92064009}, + {0x14,0x94102000}, + {0x18,0x7ffff4dd}, + {0x1c,0x9610001a}, + {0x20,0x80a22000}, + {0x24,0x02800004}, + {0x28,0xa0042001}, + {0x2c,0x10800006}, + {0x30,0xb0102001}, + {0x34,0x80a42004}, + {0x38,0x04bffff2}, + {0x3c,0x8207bff8}, + {0x40,0xb0102000}, + {0x44,0x81c7e008}, + {0x48,0x81e80000}, + {0x4c,0x9de3bf98}, + {0x50,0xc2102548}, + {0x54,0x80886001}, + {0x58,0xb8102000}, + {0x5c,0xba102000}, + {0x60,0x02800004}, + {0x64,0xae102000}, + {0x68,0x10800026}, + {0x6c,0xec002354}, + {0x70,0xc200254c}, + {0x74,0x80886200}, + {0x78,0x32800010}, + {0x7c,0xc2002690}, + {0xf0,0x98}, + {0x00,0x03296956}, + {0x04,0xda00250c}, + {0x08,0x8210625a}, + {0x0c,0x80a34001}, + {0x10,0x12800006}, + {0x14,0xc20023c8}, + {0x18,0x80886800}, + {0x1c,0x32800007}, + {0x20,0xc2002690}, + {0x24,0xc20023c8}, + {0x28,0x80886400}, + {0x2c,0x22800015}, + {0x30,0xec0022ac}, + {0x34,0xc2002690}, + {0x38,0x80886200}, + {0x3c,0x1280000a}, + {0x40,0xb8102001}, + {0x44,0x13000017}, + {0x48,0xc2002fd0}, + {0x4c,0x92126240}, + {0x50,0x9fc04000}, + {0x54,0xd0002590}, + {0x58,0xc2002690}, + {0x5c,0x82106200}, + {0x60,0xc2202690}, + {0x64,0x10800007}, + {0x68,0xec0023a0}, + {0x6c,0xc200254c}, + {0x70,0x1b000080}, + {0x74,0x8210400d}, + {0x78,0x10800080}, + {0x7c,0xc220254c}, + {0xf0,0x99}, + {0x00,0x7ffff3d3}, + {0x04,0x901020aa}, + {0x08,0xda002500}, + {0x0c,0xc20022d0}, + {0x10,0x80a34001}, + {0x14,0x3880000b}, + {0x18,0xba102001}, + {0x1c,0xc2002200}, + {0x20,0x80a00001}, + {0x24,0x9a402000}, + {0x28,0x80a00016}, + {0x2c,0x82603fff}, + {0x30,0x80934001}, + {0x34,0x02800004}, + {0x38,0xaa102000}, + {0x3c,0xba102001}, + {0x40,0xaa102000}, + {0x44,0xa52d6003}, + {0x48,0xc204a760}, + {0x4c,0x80a06000}, + {0x50,0x22800067}, + {0x54,0xaa056001}, + {0x58,0x80a56000}, + {0x5c,0x12800008}, + {0x60,0x80a76000}, + {0x64,0xc200255c}, + {0x68,0x80a06000}, + {0x6c,0x1280000c}, + {0x70,0x29200000}, + {0x74,0x1080000a}, + {0x78,0xa8102000}, + {0x7c,0x02800005}, + {0xf0,0x9a}, + {0x00,0x9004a760}, + {0x04,0xc024a764}, + {0x08,0x10800058}, + {0x0c,0xc024a760}, + {0x10,0x7fffff7c}, + {0x14,0x92100016}, + {0x18,0xa8100008}, + {0x1c,0x80a52000}, + {0x20,0x02800050}, + {0x24,0xae15c014}, + {0x28,0xc214a766}, + {0x2c,0x80a06000}, + {0x30,0x0280000a}, + {0x34,0x80a56000}, + {0x38,0xc204a764}, + {0x3c,0x82007fff}, + {0x40,0xc224a764}, + {0x44,0xc214a766}, + {0x48,0x80a06000}, + {0x4c,0x32800048}, + {0x50,0xaa056001}, + {0x54,0x80a56000}, + {0x58,0x12800006}, + {0x5c,0x1b004000}, + {0x60,0xc200254c}, + {0x64,0x8210400d}, + {0x68,0x10800040}, + {0x6c,0xc220254c}, + {0x70,0xc2102548}, + {0x74,0x80886001}, + {0x78,0x02800006}, + {0x7c,0x82103fff}, + {0xf0,0x9b}, + {0x00,0xc024a764}, + {0x04,0xc024a760}, + {0x08,0x10800038}, + {0x0c,0xc2202700}, + {0x10,0x80a72000}, + {0x14,0x02bfffb6}, + {0x18,0xa6102000}, + {0x1c,0xc2002514}, + {0x20,0x80a4c001}, + {0x24,0x1a80002c}, + {0x28,0x83350013}, + {0x2c,0x80886001}, + {0x30,0x02800027}, + {0x34,0x9b2ce002}, + {0x38,0xe0036710}, + {0x3c,0xa3342016}, + {0x40,0xa00c2fff}, + {0x44,0xa13c2006}, + {0x48,0xa20c603f}, + {0x4c,0xa0042001}, + {0x50,0xa2046001}, + {0x54,0x92100011}, + {0x58,0xd410246e}, + {0x5c,0x7fffff62}, + {0x60,0x90100010}, + {0x64,0x80a22000}, + {0x68,0x92100011}, + {0x6c,0x1280000f}, + {0x70,0x90100010}, + {0x74,0xc210246c}, + {0x78,0x94906000}, + {0x7c,0x2280000f}, + {0xf0,0x9c}, + {0x00,0xc200254c}, + {0x04,0xc2002548}, + {0x08,0x80886080}, + {0x0c,0x2280000b}, + {0x10,0xc200254c}, + {0x14,0x7fffff54}, + {0x18,0x01000000}, + {0x1c,0x80a22000}, + {0x20,0x22800006}, + {0x24,0xc200254c}, + {0x28,0x82102001}, + {0x2c,0x83284013}, + {0x30,0x10800007}, + {0x34,0xa82d0001}, + {0x38,0x1b000080}, + {0x3c,0x8210400d}, + {0x40,0xc220254c}, + {0x44,0x10800004}, + {0x48,0xc02026e8}, + {0x4c,0x10bfffd4}, + {0x50,0xa604e001}, + {0x54,0x80a52000}, + {0x58,0x32800005}, + {0x5c,0xaa056001}, + {0x60,0xc024a764}, + {0x64,0xc024a760}, + {0x68,0xaa056001}, + {0x6c,0x80a56013}, + {0x70,0x04bfff96}, + {0x74,0xa52d6003}, + {0x78,0x80a5e000}, + {0x7c,0x22800002}, + {0xf0,0x9d}, + {0x00,0xc02026e8}, + {0x04,0xc200255c}, + {0x08,0x80a06000}, + {0x0c,0x0280000a}, + {0x10,0x80a76000}, + {0x14,0xc2002760}, + {0x18,0x80a06000}, + {0x1c,0x12800006}, + {0x20,0x80a76000}, + {0x24,0x03000004}, + {0x28,0xc2202760}, + {0x2c,0xc2002248}, + {0x30,0xc2202764}, + {0x34,0x1280002b}, + {0x38,0xaa102000}, + {0x3c,0xc2002514}, + {0x40,0x80a54001}, + {0x44,0x1a800027}, + {0x48,0x96102001}, + {0x4c,0x992d6002}, + {0x50,0xc2032710}, + {0x54,0x8330600c}, + {0x58,0x80886001}, + {0x5c,0x3280001d}, + {0x60,0xaa056001}, + {0x64,0x832ac015}, + {0x68,0x808dc001}, + {0x6c,0x32800019}, + {0x70,0xaa056001}, + {0x74,0xa6102001}, + {0x78,0x9b2ce003}, + {0x7c,0xc2036760}, + {0xf0,0x9e}, + {0x00,0x80a06000}, + {0x04,0x1280000f}, + {0x08,0xa604e001}, + {0x0c,0xc2032710}, + {0x10,0xc2236760}, + {0x14,0xc2102548}, + {0x18,0x80886001}, + {0x1c,0x02800004}, + {0x20,0x80a72000}, + {0x24,0x10800005}, + {0x28,0xc2002358}, + {0x2c,0x22800003}, + {0x30,0xc2002378}, + {0x34,0xc200239c}, + {0x38,0x10800005}, + {0x3c,0xc2236764}, + {0x40,0x80a4e013}, + {0x44,0x04bfffee}, + {0x48,0x9b2ce003}, + {0x4c,0xaa056001}, + {0x50,0xc2002514}, + {0x54,0x80a54001}, + {0x58,0x0abfffde}, + {0x5c,0x992d6002}, + {0x60,0x81c7e008}, + {0x64,0x81e80000}, + {0x68,0x9de3bf98}, + {0x6c,0x7ffff46f}, + {0x70,0x01000000}, + {0x74,0xda002548}, + {0x78,0x83336010}, + {0x7c,0x80886001}, + {0xf0,0x9f}, + {0x00,0x12800032}, + {0x04,0x8333600c}, + {0x08,0x80886001}, + {0x0c,0x1280002f}, + {0x10,0x01000000}, + {0x14,0xc2002538}, + {0x18,0x80a06000}, + {0x1c,0x2280000b}, + {0x20,0xc208254d}, + {0x24,0x82007fff}, + {0x28,0x80a06000}, + {0x2c,0x12800006}, + {0x30,0xc2202538}, + {0x34,0xc200254c}, + {0x38,0x1b002000}, + {0x3c,0x8210400d}, + {0x40,0xc220254c}, + {0x44,0xc208254d}, + {0x48,0x80a06000}, + {0x4c,0x0280001f}, + {0x50,0x033fc180}, + {0x54,0xc0204000}, + {0x58,0xa0102002}, + {0x5c,0x7ffff4a9}, + {0x60,0x90102001}, + {0x64,0x11000099}, + {0x68,0x7fffef6b}, + {0x6c,0x9012233c}, + {0x70,0xa0843fff}, + {0x74,0x1cbffffa}, + {0x78,0x01000000}, + {0x7c,0x7ffff4a1}, + {0xf0,0xa0}, + {0x00,0x90102000}, + {0x04,0xda00254c}, + {0x08,0x83336010}, + {0x0c,0x80886001}, + {0x10,0x32800002}, + {0x14,0xc020250c}, + {0x18,0x83336017}, + {0x1c,0x80886001}, + {0x20,0x32800005}, + {0x24,0xc2002538}, + {0x28,0xc2002188}, + {0x2c,0xc2202538}, + {0x30,0xc2002538}, + {0x34,0xc220265c}, + {0x38,0x7ffff190}, + {0x3c,0x90102015}, + {0x40,0x82102001}, + {0x44,0xc2202584}, + {0x48,0x81c7e008}, + {0x4c,0x81e80000}, + {0x50,0xc2002588}, + {0x54,0x80a06000}, + {0x58,0x32800006}, + {0x5c,0xc200258c}, + {0x60,0xc2002554}, + {0x64,0xc2202588}, + {0x68,0xc0202594}, + {0x6c,0xc200258c}, + {0x70,0x80a06000}, + {0x74,0x32800006}, + {0x78,0xc2102548}, + {0x7c,0xc2002554}, + {0xf0,0xa1}, + {0x00,0xc220258c}, + {0x04,0xc0202598}, + {0x08,0xc2102548}, + {0x0c,0x80886001}, + {0x10,0x02800007}, + {0x14,0x01000000}, + {0x18,0xc2002558}, + {0x1c,0x80a06001}, + {0x20,0x18800003}, + {0x24,0x82102001}, + {0x28,0xc2202584}, + {0x2c,0x81c3e008}, + {0x30,0x01000000}, + {0x34,0xc2002548}, + {0x38,0x8330600e}, + {0x3c,0x80886001}, + {0x40,0x12800048}, + {0x44,0x98102000}, + {0x48,0xc2002514}, + {0x4c,0x80a30001}, + {0x50,0x1a80000b}, + {0x54,0x033fc180}, + {0x58,0x96106004}, + {0x5c,0x832b2002}, + {0x60,0xda006710}, + {0x64,0xda20400b}, + {0x68,0x98032001}, + {0x6c,0xc2002514}, + {0x70,0x80a30001}, + {0x74,0x0abffffb}, + {0x78,0x832b2002}, + {0x7c,0xda00254c}, + {0xf0,0xa2}, + {0x00,0x808b6001}, + {0x04,0x32800008}, + {0x08,0xc208254e}, + {0x0c,0xc2002514}, + {0x10,0x9a136001}, + {0x14,0x82106100}, + {0x18,0xda20254c}, + {0x1c,0xc2202514}, + {0x20,0xc208254e}, + {0x24,0x80a06000}, + {0x28,0x3280000b}, + {0x2c,0xc2082517}, + {0x30,0xc20023c8}, + {0x34,0x83306016}, + {0x38,0x80886001}, + {0x3c,0x22800006}, + {0x40,0xc2082517}, + {0x44,0xc2002514}, + {0x48,0x82106200}, + {0x4c,0xc2202514}, + {0x50,0xc2082517}, + {0x54,0x80a06000}, + {0x58,0x2280001d}, + {0x5c,0xd8082517}, + {0x60,0xc2002548}, + {0x64,0x80886800}, + {0x68,0x22800006}, + {0x6c,0xd80023c8}, + {0x70,0xc2002514}, + {0x74,0x82106400}, + {0x78,0xc2202514}, + {0x7c,0xd80023c8}, + {0xf0,0xa3}, + {0x00,0x80a32000}, + {0x04,0x16800007}, + {0x08,0x8333200c}, + {0x0c,0xc2002514}, + {0x10,0x1b000004}, + {0x14,0x8210400d}, + {0x18,0xc2202514}, + {0x1c,0x8333200c}, + {0x20,0x80886001}, + {0x24,0x2280000a}, + {0x28,0xd8082517}, + {0x2c,0xc2002540}, + {0x30,0x1b164020}, + {0x34,0x83286010}, + {0x38,0x8200400d}, + {0x3c,0xda002514}, + {0x40,0x9a134001}, + {0x44,0xda202514}, + {0x48,0xd8082517}, + {0x4c,0xda002514}, + {0x50,0x033fc180}, + {0x54,0xda204000}, + {0x58,0xd8202568}, + {0x5c,0xc0202540}, + {0x60,0x81c3e008}, + {0x64,0x01000000}, + {0x68,0x9de3bf98}, + {0x6c,0xd8002548}, + {0x70,0x8333200e}, + {0x74,0x80886001}, + {0x78,0x22800006}, + {0x7c,0xc2102516}, + {0xf0,0xa4}, + {0x00,0x03000010}, + {0x04,0x822b0001}, + {0x08,0x1080001e}, + {0x0c,0xc2202548}, + {0x10,0x80a06000}, + {0x14,0x02800006}, + {0x18,0x9b332003}, + {0x1c,0x808b2004}, + {0x20,0x2280000a}, + {0x24,0xc200231c}, + {0x28,0x9b332003}, + {0x2c,0x83332002}, + {0x30,0x82086001}, + {0x34,0x9a0b6001}, + {0x38,0x80a0400d}, + {0x3c,0x2280000a}, + {0x40,0xc2002560}, + {0x44,0xc200231c}, + {0x48,0x80a06000}, + {0x4c,0x22800003}, + {0x50,0xc2082360}, + {0x54,0x82102005}, + {0x58,0xc2202560}, + {0x5c,0x10800007}, + {0x60,0x90102001}, + {0x64,0x80a06000}, + {0x68,0x02800004}, + {0x6c,0x90102000}, + {0x70,0x10bffffa}, + {0x74,0x82007fff}, + {0x78,0x7ffff402}, + {0x7c,0x01000000}, + {0xf0,0xa5}, + {0x00,0xc2002548}, + {0x04,0x9a004001}, + {0x08,0x9a0b6008}, + {0x0c,0x82087ff7}, + {0x10,0x8210400d}, + {0x14,0xc2202548}, + {0x18,0x81c7e008}, + {0x1c,0x81e80000}, + {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,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x00000000}, + {0x6c,0x00000000}, + {0x70,0x00000000}, + {0x74,0x00000000}, + {0x78,0x00000000}, + {0x7c,0x00000000}, + {0xf0,0xa6}, + {0x00,0x00001688}, + {0x04,0xa5010503}, + {0x08,0xa5000000}, + {0x0c,0x00000000}, + {0x10,0x4c494348}, + {0x14,0x49444449}, + {0x18,0x88ecbdae}, + {0x1c,0x39cf8648}, + {0x20,0xa98080cd}, + {0x24,0xc96fbe71}, + {0x28,0x9243c641}, + {0x2c,0xc654cc4d}, + {0x30,0x80cb80d1}, + {0x34,0xc471cce5}, + {0x38,0xa898c9e5}, + {0x3c,0xc400bc0d}, + {0x40,0xbc43c643}, + {0x44,0xbd130000}, + {0x48,0x00000000}, + {0x4c,0x00000000}, + {0x50,0x00000000}, + {0x54,0x00000000}, + {0x58,0x00000000}, + {0x5c,0x00000000}, + {0x60,0x00000000}, + {0x64,0x00000000}, + {0x68,0x41756720}, + {0x6c,0x31322032}, + {0x70,0x30313500}, + {0x74,0x00000000}, + {0x78,0x31383a31}, + {0x7c,0x393a3338}, + + + +}; + + + +#endif -- 2.34.1