1. Introduction
3. Image Processing3.1 Convolution
3.2 Sobel
Read moreFacial recognition is a commonly discussed computer science topic, and has become a high interest one due to the exponential growth of the computer’s processing power. Detecting human faces is a widespread application in many domains such as robotics, bio-security or the automotive industry, and involves applying a mathematical algorithm on an input image in order to extract distinct features, indicating the presence of a face in the provided picture. The Histogram of Oriented Gradient (HOG) is a conventional algorithm, used to extract image features such as pixel orientation, and can be used among with a linear Support Vector Machine (SVM) to classify the input image as a human face or not.
We will be using the following image as a reference and testing candidate:
Test image
Convolution of two functions is an important mathematical operation that found heavy application in signal processing. In computer graphics and image processing fields, we usually work with discrete functions (e.g an image) and apply a discrete form of the convolution to remove high frequency noise, sharpen details or detect edges.
Convolution is a mathematical operation on two signals f and g, defined as :
Signal convolution
In therms of images, we can imagine convolution as a relation between a single pixel and it's neighbor pixels. This relation may be useful when searching for a distinct feature like color variation, brightness differences or even pixel periodicity.
The next figure illustrates the convolution using a small 3 by 3 kernel. The filter is defined as a matrix, where the central item weights the center pixel, and the other items define the weights of the neighbor pixels. We can also say that the radius of the 3 by3 kernel is 1, since only the one-ring neighborhood is considered during the convolution. We also have to define the convolution’s behavior at border of the image, where the kernel maps to undefined values outside the image.
3x3 kernel convolution
The convolution operation using a 3 by 3 window and a 3 by 3 kernel can be defined as following:
static int convolve(unsigned int window[3][3], int kernel[3][3])
{
int result = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result+= window[i][j] * kernel[i][j];
}
}
return result;
}In order to apply the convolution operation on the whole image, a sliding window technique is applied. Starting from the first pixel, each 8 neighbors are grouped into a square window, the input pixels inside the window are convoluted with the kernel, resulting in one pixel that will be placed in the output image. This step is repeated until the end of the image.
Sliding window
Edge detection is the most common way for detecting discontinuities in gray scale images. An edge is defined as a set connected pixels that lie on a particular boundary between two regions.
In the case where the input image is a color one, before applying the convolution operation, it should be converted in grayscale.
Presuming that each pixel is represented using a 32-bit unsigned int, the RGB representation can be converted to grayscale as following:
#define R(pixel) (((pixel) >> 16) & 0xFF)
#define G(pixel) (((pixel) >> 8) & 0xFF)
#define B(pixel) (((pixel) ) & 0xFF)
float rgb2gray(unsigned int pixel)
{
return (R(pixel) * 0.2989 + G(pixel) * 0.5870 + B(pixel) * 0.1440);
}After the operation, our test image will look like the following:
Grayscale test image
The Sobel Detector is one of the most frequently used operators in edge detection. The Sobel operator uses two 3×3 kernels which are convolved with the original image to calculate approximations of the derivatives – one for horizontal changes, and one for vertical. If we define A as the source image, and Gx and G y are two images which at each point contain the horizontal and vertical derivative approximations respectively, the computations are as follows:
Sobel convolution kernels
With the previous convolution function we can compute those output images using:
int dx = convolve(window, kernel_x);
int dy = convolve(window, kernel_y);Where window is defined as the 3 by 3 sliding window, and the kernels are the ones used by the Sobel operator:
static int kernel_x[3][3] = {
{ 1, 2, 1},
{ 0, 0, 0},
{-1, -2, -1}
};
static int kernel_y[3][3] = {
{ 1, 0, -1},
{ 2, 0, -2},
{ 1, 0, -1}
};The resulting images after convolving those kernels are the following:
1 / 2 • Gx
As you can see, the vertical and horizontal details are enhanced and easier to observe. As much as it helps, we need a more distinctive feature image, representing only the edges.
The next step would be combining those two images and get some sort of two-directional variation map. We can do this by computing the magnitude, or intensity, of each pixel value, and the direction, or angle, on which the current pixel is linked to another in an edge line.
At each point in the image, the resulting approximations can be combined to give the magnitude, using:
Magnitude gradient
And the angle using:
Gradient direction
Both squareroot and atan2 functions are already implemented in the HLS namespace:
unsigned int magnitude = hls::sqrt(dx*dx + dy*dy);
int angle = hls::atan2(dx,dy);And the results are:
1 / 2 • Magnitude
We already can observe a more edge-concentrated image. Still, the edges get wider in areas with multiple forms. We need to suppress those false edges with a technique called non-maximum supression:
unsigned int nms(unsigned int mag[3][3], int ang) {
unsigned int q,r;
q = r = 255;
if ((0 <= ang < 23) || (158 < ang <= 180)) {
q = mag[1][2];
r = mag[1][0];
} else if (223 <= ang < 68) {
q = mag[2][0];
r = mag[0][2];
} else if ( 68 <= ang < 113) {
q = mag[0][1];
r = mag[2][1];
} else if ( 113 <= ang < 158) {
q = mag[0][0];
r = mag[2][2];
}
if (mag[1][1] >= q && mag[1][1] >= r)
return mag[1][1];
return 0;
}Supressed false edges
Now the edges are thinner, and more concise. At this point we can pack a pretty robust feature map used in our algorithm.
3.3 ImplementationAs mentioned before, the input image is fed pixel by pixel under the form of a stream. In order to apply the convolution operation, we need to pack the data under a 3 by 3 window. We can achieve this using an architecture with two buffers with a number of elements equal to the width if our input image:
Line buffers
Here we will have two helper functions for shifting the line buffers, and the sliding window:
static void shift_w(unsigned int window[3][3], unsigned int v1, unsigned int v2,
unsigned int v3)
{
window[0][0] = window[0][1];
window[0][1] = window[0][2];
window[0][2] = v1;
window[1][0] = window[1][1];
window[1][1] = window[1][2];
window[1][2] = v2;
window[2][0] = window[2][1];
window[2][1] = window[2][2];
window[2][2] = v3;
}
static void shift_b(unsigned int line_buffer[2][1280], int pos,
unsigned int val)
{
line_buffer[0][pos] = line_buffer[1][pos];
line_buffer[1][pos] = val;
}Finally, we can pack this whole process into a HLS function:
#include <stdio.h>
#include <string.h>
#include <ap_int.h>
#include <ap_axi_sdata.h>
#include <hls_stream.h>
#include <hls_math.h>
#define R(pixel) (((pixel) >> 16) & 0xFF)
#define G(pixel) (((pixel) >> 8) & 0xFF)
#define B(pixel) (((pixel) ) & 0xFF)
float rgb2gray(unsigned int pixel)
{
return (R(pixel) * 0.2989 + G(pixel) * 0.5870 + B(pixel) * 0.1440);
}
static int kernel_x[3][3] = {
{ 1, 2, 1},
{ 0, 0, 0},
{-1, -2, -1}
};
static int kernel_y[3][3] = {
{ 1, 0, -1},
{ 2, 0, -2},
{ 1, 0, -1}
};
static void shift_w(unsigned int window[3][3], unsigned int v1, unsigned int v2,
unsigned int v3)
{
window[0][0] = window[0][1];
window[0][1] = window[0][2];
window[0][2] = v1;
window[1][0] = window[1][1];
window[1][1] = window[1][2];
window[1][2] = v2;
window[2][0] = window[2][1];
window[2][1] = window[2][2];
window[2][2] = v3;
}
static void shift_b(unsigned int line_buffer[2][1280], int pos,
unsigned int val)
{
line_buffer[0][pos] = line_buffer[1][pos];
line_buffer[1][pos] = val;
}
static int convolve(unsigned int window[3][3], int kernel[3][3])
{
int result = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result+= window[i][j] * kernel[i][j];
}
}
return result;
}
unsigned int nms(unsigned int mag[3][3], int ang) {
unsigned int q,r;
q = r = 255;
if ((0 <= ang < 23) || (158 < ang <= 180)) {
q = mag[1][2];
r = mag[1][0];
} else if (223 <= ang < 68) {
q = mag[2][0];
r = mag[0][2];
} else if ( 68 <= ang < 113) {
q = mag[0][1];
r = mag[2][1];
} else if ( 113 <= ang < 158) {
q = mag[0][0];
r = mag[2][2];
}
if (mag[1][1] >= q && mag[1][1] >= r)
return mag[1][1];
return 0;
}
int sobel(hls::stream<ap_axiu<32,1,1,1>>& in,
hls::stream<ap_axiu<32,1,1,1>>& out)
{
unsigned int line_buffer[2][1280];
unsigned int window[3][3];
unsigned int line_buffer_l1[2][1280];
unsigned int mag_window[3][3];
unsigned int threshold = 80;
int i = 0, j = 0;
#pragma HLS INTERFACE axis port=in
#pragma HLS INTERFACE axis port=out
#pragma HLS INTERFACE s_axilite port=return
#pragma HLS ARRAY_PARTITION variable=line_buffer block factor=2 dim=1
#pragma HLS RESOURCE variable=line_buffer core=RAM_2P
#pragma HLS ARRAY_PARTITION variable=line_buffer_l1 block factor=2 dim=1
#pragma HLS ARRAY_PARTITION variable=window complete dim=0
#pragma HLS ARRAY_PARTITION variable=mag_window complete dim=0
#pragma HLS RESOURCE variable=line_buffer_l1 core=RAM_2P
while (!in.empty()) {
#pragma HLS LOOP_TRIPCOUNT min=1280*720 max=1280*720
ap_axiu<32, 1, 1, 1> pixel_in = in.read();
float data = rgb2gray(pixel_in.data);
shift_w(window, line_buffer[0][i], line_buffer[1][i], data);
shift_b(line_buffer, i, data);
int dx = convolve(window, kernel_x);
int dy = convolve(window, kernel_y);
unsigned int magnitude = hls::sqrt(dx*dx + dy*dy);
int angle = hls::atan2(dx,dy);
unsigned int supressed = nms(mag_window, angle);
shift_w(mag_window, line_buffer_l1[0][i], line_buffer_l1[1][i], magnitude);
shift_b(line_buffer_l1, i, magnitude);
unsigned int data_out = supressed;
if (!(1 < i && i < 1279) && !(1 < j && j < 719))
data_out = 0;
if(data_out > threshold)
data_out = 255;
else
data_out = 0;
ap_axiu<32, 1, 1, 1> pixel_out = pixel_in;
pixel_out.data = (data_out | (data_out << 8) | (data_out << 16));
out.write(pixel_out);
if (pixel_in.user) {
i = 0;
j++;
} else {
i++;
}
if (pixel_in.last) {
j = 0;
}
}
return 0;
}We got the code but it also should be tested. GIMP has a really cool feature that lets you export an image directly as a header file. Presuming we exported our test image under the file image.h, we can use the following testbench:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <ap_axi_sdata.h>
#include "data/image.h"
#include "data/image2.h"
#include <iostream>
#include <fstream>
#define HORIZONTAL_PIXEL_WIDTH 1280
#define VERTICAL_PIXEL_WIDTH 720
using namespace std;
int sobel(hls::stream<ap_axiu<32,1,1,1>>& in,
hls::stream<ap_axiu<32,1,1,1>>& out);
int main()
{
hls::stream<ap_axiu<32,1,1,1> > in;
hls::stream<ap_axiu<32,1,1,1> > out;
ap_axiu<32,1,1,1> val;
ap_axiu<32,1,1,1> lap;
unsigned char pix[3];
ofstream ofs("result.data", ios::binary);
ofstream img("image.data", ios::binary);
char buf[3];
for (int j = 0; j < VERTICAL_PIXEL_WIDTH; j++)
for (int i = 0; i < HORIZONTAL_PIXEL_WIDTH; i++){
HEADER_PIXEL(header_data, pix);
img.write((char*)pix, 3);
val.data = (pix[0]<<16)|(pix[1]<<8)|(pix[2]);
if (i == HORIZONTAL_PIXEL_WIDTH-1){
val.user = 1;
if (j == VERTICAL_PIXEL_WIDTH-1)
val.last = 1;
else
val.last = 0;
}else{
val.user = 0;
}
in.write(val);
}
sobel(in, out);
do{
lap = out.read();
buf[0] = (lap.data >> 16) & 0xFF;
buf[1] = (lap.data >> 8) & 0xFF;
buf[2] = lap.data & 0xFF;
ofs.write(buf, 3);
}while (!lap.last);
ofs.close();
img.close();
return 0;
}Another way of validating our HLS IP is directly on the FPGA.
First step is to create a block design and add the synthesized Sobel IP to the repository:
Add the implemented IP, with a DMA feeding data to it, and another one reading the output:
1 / 2 • DMA0
Generate the bitstream and create a new PYNQ notebook:
from pynq import Overlay, allocate
from PIL import Image
import numpy as np
overlay = Overlay("/kv260_sobel.bit")
dma_send = overlay.axi_dma_0
dma_recv = overlay.axi_dma_1
img = np.array(Image.open("lena.png"))
#The DMA uses 32-bit addressing so we padd the 4th channel with zeroes
img = np.concatenate((np.zeros((720,1280, 1)), img), axis=2)
input_buffer = allocate(shape=(720,1280,4), dtype=np.uint8)
input_buffer[:]=img
dma_send.sendchannel.transfer(input_buffer)
output_buffer = allocate(shape=(720,1280,4), dtype=np.uint8)
dma_recv.recvchannel.transfer(output_buffer)
#Remove the padd channel and show the image
output_buffer = output_buffer[:,:,:3]
Image.fromarray(output_buffer)The resulted image should be similar to the one from the simulation.
Now we need to implement an architecture that grabs the input directly from the camera.
The first component is Znyq processing system and an i2c controller used to configure the camera interface:
1 / 3
On the image stream side, we need a MIPI controller and a Demosaic IP to conver the stream to RGB24:
1 / 3
And finally add our image processing IP and VDMA:
1 / 2
Test notebook:
from pynq.lib.iic import *
from pynq import Overlay, allocate
from time import sleep
import numpy as np
import cffi
from PIL import Image
import numpy as np
import time
_ffi = cffi.FFI()
class tof:
__iic_device_addr = 0x64
__cam_device_id = 0x78
__stream_on = [
[0xc022, 0x0001],
[0xc600, 0x0000],
[0xc600, 0x0000],
[0xc600, 0x0000],
[0xc031, 0x0001],
[0xc021, 0x0000],
[0xc020, 0x0167],
[0xc720, 0x1100],
[0xc030, 0x0001],
[0xc027, 0x0001],
[0xc025, 0x0001],
[0xc01c, 0x0400],
[0xc000, 0x0001],
[0xc001, 0x0002],
[0xc002, 0x000f],
[0xc003, 0x01ec],
[0xc023, 0x0001],
[0xc024, 0x0ff2],
[0xc026, 0x0001],
[0xc04f, 0x000c],
[0xc050, 0x0011],
[0xc051, 0x0000],
[0xc054, 0x0000],
[0xc055, 0xffff],
[0xc056, 0xffff],
[0xc057, 0xffff],
[0xc058, 0xffff],
[0xc05d, 0x0044],
[0xc05e, 0x0044],
[0xc038, 0x4000],
[0xc039, 0x4000],
[0xc03a, 0x0040],
[0xc03b, 0x0040],
[0xc040, 0x0040],
[0xc041, 0x0040],
[0xc042, 0x6040],
[0xc043, 0x6040],
[0xc088, 0x0000],
[0xc089, 0x0000],
[0xc08a, 0x00ff],
[0xc08b, 0x0000],
[0xc08f, 0x0000],
[0xc0a4, 0x4444],
[0xc0a5, 0x4444],
[0xc0a6, 0x0044],
[0xc0e0, 0x0002],
[0xc044, 0x6303],
[0xc046, 0x0043],
[0xc02d, 0x0000],
[0xc02c, 0x0001],
[0xc01b, 0x1140],
[0xc08c, 0x0010],
[0xc08d, 0x0003],
[0xc0a9, 0x0002],
[0xc090, 0x0040],
[0xc091, 0x0040],
[0xc092, 0x0040],
[0xc093, 0x0040],
[0xc094, 0x0040],
[0xc095, 0x0040],
[0xc096, 0x0040],
[0xc097, 0x0040],
[0xc098, 0x0040],
[0xc099, 0x0040],
[0xc4c4, 0x0000],
[0xc4c7, 0x0000],
[0xc4c0, 0x0039],
[0xc400, 0x0082],
[0xc4aa, 0x0001],
[0xc401, 0x0004],
[0xc402, 0x0003],
[0xc403, 0x0004],
[0xc404, 0x0003],
[0xc405, 0x0002],
[0xc406, 0x0003],
[0xc407, 0x0009],
[0xc408, 0x0003],
[0xc41e, 0x0080],
[0xc4d4, 0x00c2],
[0xc4f0, 0x0000],
[0xc4df, 0x00b0],
[0xc4e2, 0x0007],
[0xc4df, 0x0000],
[0xc4e2, 0x0006],
[0xc4e2, 0x0002],
[0xc4d3, 0x001f],
[0xc431, 0x0082],
[0xc4d4, 0x0042],
[0xc4d4, 0x00c2],
[0xc4da, 0x0001],
[0xc437, 0x001e],
[0xc436, 0x002d],
[0xc400, 0x0002],
[0xc431, 0x0080],
[0x47e0, 0x0002],
[0x47e1, 0x0597],
[0x47e2, 0x0598],
[0x47e3, 0x0202],
[0x47e4, 0x0202],
[0x47e5, 0x05d5],
[0x47e6, 0x0000],
[0x47e7, 0x0000],
[0x47e8, 0x0000],
[0x47e9, 0x0000],
[0x47ea, 0x0000],
[0x47eb, 0x0000],
[0x47ec, 0x0000],
[0x47ed, 0xffff],
[0x47ee, 0x0000],
[0x47ef, 0x0000],
[0x47f0, 0x0000],
[0x47f1, 0x0000],
[0x47f2, 0x05d6],
[0x47f3, 0x0202],
[0x47f4, 0x0033],
[0x47f5, 0x0000],
[0x47f6, 0x0a06],
[0x47f7, 0x05d7],
[0x47f8, 0x0000],
[0x47f9, 0x0000],
[0x47fa, 0x0000],
[0x47fb, 0x0000],
[0x47fc, 0x0000],
[0x47fd, 0x0000],
[0x47fe, 0x0000],
[0x47ff, 0xffff],
[0x4800, 0x0000],
[0x4801, 0x0000],
[0x4802, 0x0000],
[0x4803, 0x0000],
[0x4804, 0x05d8],
[0x4805, 0x0202],
[0x4806, 0x01ff],
[0x4807, 0x004b],
[0x4808, 0x0206],
[0x4809, 0x05d9],
[0x480a, 0x0000],
[0x480b, 0x0000],
[0x480c, 0x0000],
[0x480d, 0x0000],
[0x480e, 0x0000],
[0x480f, 0x0000],
[0x4810, 0x0000],
[0x4811, 0xffff],
[0x4812, 0x0000],
[0x4813, 0x0000],
[0x4814, 0x0000],
[0x4815, 0x0000],
[0x4816, 0x05da],
[0x4817, 0x0202],
[0x4818, 0x006f],
[0x4819, 0x0000],
[0x481a, 0x0210],
[0x481b, 0x05af],
[0x481c, 0x0000],
[0x481d, 0x0000],
[0x481e, 0x0000],
[0x481f, 0x0000],
[0x4820, 0x7f00],
[0x4821, 0x0000],
[0x4822, 0x0000],
[0x4823, 0xffff],
[0x4824, 0x0000],
[0x4825, 0x0000],
[0x4826, 0x0000],
[0x4827, 0x0000],
[0x4828, 0x05b0],
[0x4829, 0x0202],
[0x482a, 0x0020],
[0x482b, 0x0000],
[0x482c, 0x0a40],
[0x482d, 0x059f],
[0x482e, 0x4040],
[0x482f, 0x4040],
[0x4830, 0x4040],
[0x4831, 0x4040],
[0x4832, 0x4040],
[0x4833, 0x0000],
[0x4834, 0x0000],
[0x4835, 0xffff],
[0x4836, 0x0000],
[0x4837, 0x0000],
[0x4838, 0x0000],
[0x4839, 0x0000],
[0x483a, 0x05a1],
[0x483b, 0x0404],
[0x483c, 0x0064],
[0x483d, 0x0055],
[0x483e, 0x0200],
[0x483f, 0x0599],
[0x4840, 0x0000],
[0x4841, 0x0000],
[0x4842, 0x0000],
[0x4843, 0x0000],
[0x4844, 0x0000],
[0x4845, 0x0000],
[0x4846, 0x0000],
[0x4847, 0xffff],
[0x4848, 0x0000],
[0x4849, 0x0000],
[0x484a, 0x0000],
[0x484b, 0x0000],
[0x484c, 0x059a],
[0x484d, 0x0202],
[0x484e, 0x0051],
[0x484f, 0x0000],
[0x4850, 0x0a00],
[0x4851, 0x05a3],
[0x4852, 0x4000],
[0x4853, 0x4000],
[0x4854, 0x4000],
[0x4855, 0x4000],
[0x4856, 0x4000],
[0x4857, 0x0000],
[0x4858, 0x0000],
[0x4859, 0xffff],
[0x485a, 0x0000],
[0x485b, 0x0000],
[0x485c, 0x0000],
[0x485d, 0x0000],
[0x485e, 0x05a6],
[0x485f, 0x0505],
[0x4860, 0x0064],
[0x4861, 0x0054],
[0x4862, 0x0a00],
[0x4863, 0x05b1],
[0x4864, 0x0000],
[0x4865, 0x0000],
[0x4866, 0x0000],
[0x4867, 0x0000],
[0x4868, 0x4040],
[0x4869, 0x0000],
[0x486a, 0x0000],
[0x486b, 0xffff],
[0x486c, 0x0000],
[0x486d, 0x0000],
[0x486e, 0x0000],
[0x486f, 0x0000],
[0x4870, 0x05b3],
[0x4871, 0x0404],
[0x4872, 0x0064],
[0x4873, 0x0053],
[0x4874, 0x0600],
[0x4875, 0x059b],
[0x4876, 0x0000],
[0x4877, 0x0000],
[0x4878, 0x0000],
[0x4879, 0x0000],
[0x487a, 0x0000],
[0x487b, 0x0000],
[0x487c, 0x0000],
[0x487d, 0xffff],
[0x487e, 0x0000],
[0x487f, 0x0000],
[0x4880, 0x0000],
[0x4881, 0x0000],
[0x4882, 0x059c],
[0x4883, 0x0202],
[0x4884, 0x000b],
[0x4885, 0x0051],
[0x4886, 0x0a00],
[0x4887, 0x059f],
[0x4888, 0x4040],
[0x4889, 0x4040],
[0x488a, 0x4040],
[0x488b, 0x4040],
[0x488c, 0x4040],
[0x488d, 0x0000],
[0x488e, 0x0000],
[0x488f, 0xffff],
[0x4890, 0x0000],
[0x4891, 0x0000],
[0x4892, 0x0000],
[0x4893, 0x0000],
[0x4894, 0x05a1],
[0x4895, 0x0404],
[0x4896, 0x0064],
[0x4897, 0x0055],
[0x4898, 0x0a10],
[0x4899, 0x05b1],
[0x489a, 0x0000],
[0x489b, 0x0000],
[0x489c, 0x0000],
[0x489d, 0x0000],
[0x489e, 0x4040],
[0x489f, 0x0000],
[0x48a0, 0x0000],
[0x48a1, 0xffff],
[0x48a2, 0x0000],
[0x48a3, 0x0000],
[0x48a4, 0x0000],
[0x48a5, 0x0000],
[0x48a6, 0x05b3],
[0x48a7, 0x0404],
[0x48a8, 0x0064],
[0x48a9, 0x0053],
[0x48aa, 0x0200],
[0x48ab, 0x059d],
[0x48ac, 0x0000],
[0x48ad, 0x0000],
[0x48ae, 0x0000],
[0x48af, 0x0000],
[0x48b0, 0x7f00],
[0x48b1, 0x0000],
[0x48b2, 0x0000],
[0x48b3, 0xffff],
[0x48b4, 0x0000],
[0x48b5, 0x0000],
[0x48b6, 0x0000],
[0x48b7, 0x0000],
[0x48b8, 0x059e],
[0x48b9, 0x0202],
[0x48ba, 0x0044],
[0x48bb, 0x0000],
[0x48bc, 0x0200],
[0x48bd, 0x05ab],
[0x48be, 0x0000],
[0x48bf, 0x0000],
[0x48c0, 0x0000],
[0x48c1, 0x0000],
[0x48c2, 0x0000],
[0x48c3, 0x0000],
[0x48c4, 0x0000],
[0x48c5, 0xffff],
[0x48c6, 0x0000],
[0x48c7, 0x0000],
[0x48c8, 0x0000],
[0x48c9, 0x0000],
[0x48ca, 0x05ac],
[0x48cb, 0x0202],
[0x48cc, 0x0020],
[0x48cd, 0x0000],
[0x48ce, 0x0648],
[0x48cf, 0x05a9],
[0x48d0, 0x0000],
[0x48d1, 0x0000],
[0x48d2, 0x0000],
[0x48d3, 0x0000],
[0x48d4, 0x0000],
[0x48d5, 0x0000],
[0x48d6, 0x0000],
[0x48d7, 0xffff],
[0x48d8, 0x0000],
[0x48d9, 0x0000],
[0x48da, 0x0000],
[0x48db, 0x0000],
[0x48dc, 0x05aa],
[0x48dd, 0x0202],
[0x48de, 0x02f0],
[0x48df, 0x0020],
[0x48e0, 0x0210],
[0x48e1, 0x05ad],
[0x48e2, 0x0000],
[0x48e3, 0x0000],
[0x48e4, 0x0000],
[0x48e5, 0x0000],
[0x48e6, 0x0000],
[0x48e7, 0x0000],
[0x48e8, 0x0000],
[0x48e9, 0xffff],
[0x48ea, 0x0000],
[0x48eb, 0x0000],
[0x48ec, 0x0000],
[0x48ed, 0x0000],
[0x48ee, 0x05ae],
[0x48ef, 0x0202],
[0x48f0, 0x0020],
[0x48f1, 0x0000],
[0x48f2, 0xff89],
[0x48f3, 0xffff],
[0x48f4, 0x7f88],
[0x48f5, 0x6d76],
[0x48f6, 0x5b64],
[0x48f7, 0x5b52],
[0x48f8, 0x4049],
[0x48f9, 0x5b37],
[0x48fa, 0x5b52],
[0x48fb, 0x252e],
[0x48fc, 0x131c],
[0x48fd, 0xff0a],
[0x48fe, 0x0202],
[0x48ff, 0x05d5],
[0x4900, 0x0000],
[0x4901, 0x0000],
[0x4902, 0x0000],
[0x4903, 0x0000],
[0x4904, 0x0000],
[0x4905, 0x0000],
[0x4906, 0x0000],
[0x4907, 0xffff],
[0x4908, 0x0000],
[0x4909, 0x0000],
[0x490a, 0x0000],
[0x490b, 0x0000],
[0x490c, 0x05d6],
[0x490d, 0x0202],
[0x490e, 0x0033],
[0x490f, 0x0000],
[0x4910, 0x0a06],
[0x4911, 0x05d7],
[0x4912, 0x0000],
[0x4913, 0x0000],
[0x4914, 0x0000],
[0x4915, 0x0000],
[0x4916, 0x0000],
[0x4917, 0x0000],
[0x4918, 0x0000],
[0x4919, 0xffff],
[0x491a, 0x0000],
[0x491b, 0x0000],
[0x491c, 0x0000],
[0x491d, 0x0000],
[0x491e, 0x05d8],
[0x491f, 0x0202],
[0x4920, 0x01ff],
[0x4921, 0x004b],
[0x4922, 0x0206],
[0x4923, 0x05d9],
[0x4924, 0x0000],
[0x4925, 0x0000],
[0x4926, 0x0000],
[0x4927, 0x0000],
[0x4928, 0x0000],
[0x4929, 0x0000],
[0x492a, 0x0000],
[0x492b, 0xffff],
[0x492c, 0x0000],
[0x492d, 0x0000],
[0x492e, 0x0000],
[0x492f, 0x0000],
[0x4930, 0x05da],
[0x4931, 0x0202],
[0x4932, 0x006f],
[0x4933, 0x0000],
[0x4934, 0x0210],
[0x4935, 0x05af],
[0x4936, 0x0000],
[0x4937, 0x0000],
[0x4938, 0x0000],
[0x4939, 0x0000],
[0x493a, 0x7f00],
[0x493b, 0x0000],
[0x493c, 0x0000],
[0x493d, 0xffff],
[0x493e, 0x0000],
[0x493f, 0x0000],
[0x4940, 0x0000],
[0x4941, 0x0000],
[0x4942, 0x05b0],
[0x4943, 0x0202],
[0x4944, 0x0020],
[0x4945, 0x0000],
[0x4946, 0x0a40],
[0x4947, 0x05b5],
[0x4948, 0x4040],
[0x4949, 0x4040],
[0x494a, 0x4040],
[0x494b, 0x4040],
[0x494c, 0x4040],
[0x494d, 0x0000],
[0x494e, 0x0000],
[0x494f, 0xffff],
[0x4950, 0x0000],
[0x4951, 0x0000],
[0x4952, 0x0000],
[0x4953, 0x0000],
[0x4954, 0x05b7],
[0x4955, 0x0404],
[0x4956, 0x0064],
[0x4957, 0x0055],
[0x4958, 0x0200],
[0x4959, 0x0599],
[0x495a, 0x0000],
[0x495b, 0x0000],
[0x495c, 0x0000],
[0x495d, 0x0000],
[0x495e, 0x0000],
[0x495f, 0x0000],
[0x4960, 0x0000],
[0x4961, 0xffff],
[0x4962, 0x0000],
[0x4963, 0x0000],
[0x4964, 0x0000],
[0x4965, 0x0000],
[0x4966, 0x059a],
[0x4967, 0x0202],
[0x4968, 0x0051],
[0x4969, 0x0000],
[0x496a, 0x0a00],
[0x496b, 0x05bf],
[0x496c, 0x4040],
[0x496d, 0x4040],
[0x496e, 0x4040],
[0x496f, 0x4040],
[0x4970, 0x4040],
[0x4971, 0x0000],
[0x4972, 0x0000],
[0x4973, 0xffff],
[0x4974, 0x0000],
[0x4975, 0x0000],
[0x4976, 0x0000],
[0x4977, 0x0000],
[0x4978, 0x05c2],
[0x4979, 0x0606],
[0x497a, 0x0064],
[0x497b, 0x0054],
[0x497c, 0x0a00],
[0x497d, 0x05c5],
[0x497e, 0x4040],
[0x497f, 0x4040],
[0x4980, 0x4040],
[0x4981, 0x4040],
[0x4982, 0x4040],
[0x4983, 0x0000],
[0x4984, 0x0000],
[0x4985, 0xffff],
[0x4986, 0x0000],
[0x4987, 0x0000],
[0x4988, 0x0000],
[0x4989, 0x0000],
[0x498a, 0x05c8],
[0x498b, 0x0505],
[0x498c, 0x0064],
[0x498d, 0x0053],
[0x498e, 0x0600],
[0x498f, 0x059b],
[0x4990, 0x0000],
[0x4991, 0x0000],
[0x4992, 0x0000],
[0x4993, 0x0000],
[0x4994, 0x0000],
[0x4995, 0x0000],
[0x4996, 0x0000],
[0x4997, 0xffff],
[0x4998, 0x0000],
[0x4999, 0x0000],
[0x499a, 0x0000],
[0x499b, 0x0000],
[0x499c, 0x059c],
[0x499d, 0x0202],
[0x499e, 0x000b],
[0x499f, 0x0051],
[0x49a0, 0x0a00],
[0x49a1, 0x05b5],
[0x49a2, 0x4040],
[0x49a3, 0x4040],
[0x49a4, 0x4040],
[0x49a5, 0x4040],
[0x49a6, 0x4040],
[0x49a7, 0x0000],
[0x49a8, 0x0000],
[0x49a9, 0xffff],
[0x49aa, 0x0000],
[0x49ab, 0x0000],
[0x49ac, 0x0000],
[0x49ad, 0x0000],
[0x49ae, 0x05b7],
[0x49af, 0x0404],
[0x49b0, 0x0064],
[0x49b1, 0x0055],
[0x49b2, 0x0a10],
[0x49b3, 0x05c5],
[0x49b4, 0x4040],
[0x49b5, 0x4040],
[0x49b6, 0x4040],
[0x49b7, 0x4040],
[0x49b8, 0x4040],
[0x49b9, 0x0000],
[0x49ba, 0x0000],
[0x49bb, 0xffff],
[0x49bc, 0x0000],
[0x49bd, 0x0000],
[0x49be, 0x0000],
[0x49bf, 0x0000],
[0x49c0, 0x05c8],
[0x49c1, 0x0505],
[0x49c2, 0x0064],
[0x49c3, 0x0053],
[0x49c4, 0x0200],
[0x49c5, 0x059d],
[0x49c6, 0x0000],
[0x49c7, 0x0000],
[0x49c8, 0x0000],
[0x49c9, 0x0000],
[0x49ca, 0x7f00],
[0x49cb, 0x0000],
[0x49cc, 0x0000],
[0x49cd, 0xffff],
[0x49ce, 0x0000],
[0x49cf, 0x0000],
[0x49d0, 0x0000],
[0x49d1, 0x0000],
[0x49d2, 0x059e],
[0x49d3, 0x0202],
[0x49d4, 0x0044],
[0x49d5, 0x0000],
[0x49d6, 0x0200],
[0x49d7, 0x05ab],
[0x49d8, 0x0000],
[0x49d9, 0x0000],
[0x49da, 0x0000],
[0x49db, 0x0000],
[0x49dc, 0x0000],
[0x49dd, 0x0000],
[0x49de, 0x0000],
[0x49df, 0xffff],
[0x49e0, 0x0000],
[0x49e1, 0x0000],
[0x49e2, 0x0000],
[0x49e3, 0x0000],
[0x49e4, 0x05ac],
[0x49e5, 0x0202],
[0x49e6, 0x0020],
[0x49e7, 0x0000],
[0x49e8, 0x0648],
[0x49e9, 0x05a9],
[0x49ea, 0x0000],
[0x49eb, 0x0000],
[0x49ec, 0x0000],
[0x49ed, 0x0000],
[0x49ee, 0x0000],
[0x49ef, 0x0000],
[0x49f0, 0x0000],
[0x49f1, 0xffff],
[0x49f2, 0x0000],
[0x49f3, 0x0000],
[0x49f4, 0x0000],
[0x49f5, 0x0000],
[0x49f6, 0x05aa],
[0x49f7, 0x0202],
[0x49f8, 0x02f0],
[0x49f9, 0x0020],
[0x49fa, 0x0210],
[0x49fb, 0x05ad],
[0x49fc, 0x0000],
[0x49fd, 0x0000],
[0x49fe, 0x0000],
[0x49ff, 0x0000],
[0x4a00, 0x0000],
[0x4a01, 0x0000],
[0x4a02, 0x0000],
[0x4a03, 0xffff],
[0x4a04, 0x0000],
[0x4a05, 0x0000],
[0x4a06, 0x0000],
[0x4a07, 0x0000],
[0x4a08, 0x05ae],
[0x4a09, 0x0202],
[0x4a0a, 0x0020],
[0x4a0b, 0x0000],
[0x4a0c, 0x7e87],
[0x4a0d, 0x6c75],
[0x4a0e, 0x5a63],
[0x4a0f, 0x5a51],
[0x4a10, 0x3f48],
[0x4a11, 0x5a36],
[0x4a12, 0x5a51],
[0x4a13, 0x242d],
[0x4a14, 0x121b],
[0x4a15, 0xff09],
[0x4a16, 0x0202],
[0x4a17, 0x05d5],
[0x4a18, 0x0000],
[0x4a19, 0x0000],
[0x4a1a, 0x0000],
[0x4a1b, 0x0000],
[0x4a1c, 0x0000],
[0x4a1d, 0x0000],
[0x4a1e, 0x0000],
[0x4a1f, 0xffff],
[0x4a20, 0x0000],
[0x4a21, 0x0000],
[0x4a22, 0x0000],
[0x4a23, 0x0000],
[0x4a24, 0x05d6],
[0x4a25, 0x0202],
[0x4a26, 0x0033],
[0x4a27, 0x0000],
[0x4a28, 0x0a06],
[0x4a29, 0x05d7],
[0x4a2a, 0x0000],
[0x4a2b, 0x0000],
[0x4a2c, 0x0000],
[0x4a2d, 0x0000],
[0x4a2e, 0x0000],
[0x4a2f, 0x0000],
[0x4a30, 0x0000],
[0x4a31, 0xffff],
[0x4a32, 0x0000],
[0x4a33, 0x0000],
[0x4a34, 0x0000],
[0x4a35, 0x0000],
[0x4a36, 0x05d8],
[0x4a37, 0x0202],
[0x4a38, 0x01ff],
[0x4a39, 0x004b],
[0x4a3a, 0x0206],
[0x4a3b, 0x05d9],
[0x4a3c, 0x0000],
[0x4a3d, 0x0000],
[0x4a3e, 0x0000],
[0x4a3f, 0x0000],
[0x4a40, 0x0000],
[0x4a41, 0x0000],
[0x4a42, 0x0000],
[0x4a43, 0xffff],
[0x4a44, 0x0000],
[0x4a45, 0x0000],
[0x4a46, 0x0000],
[0x4a47, 0x0000],
[0x4a48, 0x05da],
[0x4a49, 0x0202],
[0x4a4a, 0x006f],
[0x4a4b, 0x0000],
[0x4a4c, 0x0210],
[0x4a4d, 0x05af],
[0x4a4e, 0x0000],
[0x4a4f, 0x0000],
[0x4a50, 0x0000],
[0x4a51, 0x0000],
[0x4a52, 0x7f00],
[0x4a53, 0x0000],
[0x4a54, 0x0000],
[0x4a55, 0xffff],
[0x4a56, 0x0000],
[0x4a57, 0x0000],
[0x4a58, 0x0000],
[0x4a59, 0x0000],
[0x4a5a, 0x05b0],
[0x4a5b, 0x0202],
[0x4a5c, 0x0020],
[0x4a5d, 0x0000],
[0x4a5e, 0x0a40],
[0x4a5f, 0x05b9],
[0x4a60, 0x4040],
[0x4a61, 0x4040],
[0x4a62, 0x4040],
[0x4a63, 0x4040],
[0x4a64, 0x4040],
[0x4a65, 0x0000],
[0x4a66, 0x0000],
[0x4a67, 0xffff],
[0x4a68, 0x0000],
[0x4a69, 0x0000],
[0x4a6a, 0x0000],
[0x4a6b, 0x0000],
[0x4a6c, 0x05bc],
[0x4a6d, 0x0606],
[0x4a6e, 0x0064],
[0x4a6f, 0x0055],
[0x4a70, 0x0200],
[0x4a71, 0x0599],
[0x4a72, 0x0000],
[0x4a73, 0x0000],
[0x4a74, 0x0000],
[0x4a75, 0x0000],
[0x4a76, 0x0000],
[0x4a77, 0x0000],
[0x4a78, 0x0000],
[0x4a79, 0xffff],
[0x4a7a, 0x0000],
[0x4a7b, 0x0000],
[0x4a7c, 0x0000],
[0x4a7d, 0x0000],
[0x4a7e, 0x059a],
[0x4a7f, 0x0202],
[0x4a80, 0x0051],
[0x4a81, 0x0000],
[0x4a82, 0x0a00],
[0x4a83, 0x05d1],
[0x4a84, 0x4040],
[0x4a85, 0x4040],
[0x4a86, 0x4040],
[0x4a87, 0x4040],
[0x4a88, 0x4040],
[0x4a89, 0x0000],
[0x4a8a, 0x0000],
[0x4a8b, 0xffff],
[0x4a8c, 0x0000],
[0x4a8d, 0x0000],
[0x4a8e, 0x0000],
[0x4a8f, 0x0000],
[0x4a90, 0x05d3],
[0x4a91, 0x0404],
[0x4a92, 0x0064],
[0x4a93, 0x0054],
[0x4a94, 0x0a00],
[0x4a95, 0x05cb],
[0x4a96, 0x4040],
[0x4a97, 0x4040],
[0x4a98, 0x4040],
[0x4a99, 0x4040],
[0x4a9a, 0x4040],
[0x4a9b, 0x0000],
[0x4a9c, 0x0000],
[0x4a9d, 0xffff],
[0x4a9e, 0x0000],
[0x4a9f, 0x0000],
[0x4aa0, 0x0000],
[0x4aa1, 0x0000],
[0x4aa2, 0x05ce],
[0x4aa3, 0x0606],
[0x4aa4, 0x0064],
[0x4aa5, 0x0053],
[0x4aa6, 0x0600],
[0x4aa7, 0x059b],
[0x4aa8, 0x0000],
[0x4aa9, 0x0000],
[0x4aaa, 0x0000],
[0x4aab, 0x0000],
[0x4aac, 0x0000],
[0x4aad, 0x0000],
[0x4aae, 0x0000],
[0x4aaf, 0xffff],
[0x4ab0, 0x0000],
[0x4ab1, 0x0000],
[0x4ab2, 0x0000],
[0x4ab3, 0x0000],
[0x4ab4, 0x059c],
[0x4ab5, 0x0202],
[0x4ab6, 0x000b],
[0x4ab7, 0x0051],
[0x4ab8, 0x0a00],
[0x4ab9, 0x05b9],
[0x4aba, 0x4040],
[0x4abb, 0x4040],
[0x4abc, 0x4040],
[0x4abd, 0x4040],
[0x4abe, 0x4040],
[0x4abf, 0x0000],
[0x4ac0, 0x0000],
[0x4ac1, 0xffff],
[0x4ac2, 0x0000],
[0x4ac3, 0x0000],
[0x4ac4, 0x0000],
[0x4ac5, 0x0000],
[0x4ac6, 0x05bc],
[0x4ac7, 0x0606],
[0x4ac8, 0x0064],
[0x4ac9, 0x0055],
[0x4aca, 0x0a10],
[0x4acb, 0x05cb],
[0x4acc, 0x4040],
[0x4acd, 0x4040],
[0x4ace, 0x4040],
[0x4acf, 0x4040],
[0x4ad0, 0x4040],
[0x4ad1, 0x0000],
[0x4ad2, 0x0000],
[0x4ad3, 0xffff],
[0x4ad4, 0x0000],
[0x4ad5, 0x0000],
[0x4ad6, 0x0000],
[0x4ad7, 0x0000],
[0x4ad8, 0x05ce],
[0x4ad9, 0x0606],
[0x4ada, 0x0064],
[0x4adb, 0x0053],
[0x4adc, 0x0200],
[0x4add, 0x059d],
[0x4ade, 0x0000],
[0x4adf, 0x0000],
[0x4ae0, 0x0000],
[0x4ae1, 0x0000],
[0x4ae2, 0x7f00],
[0x4ae3, 0x0000],
[0x4ae4, 0x0000],
[0x4ae5, 0xffff],
[0x4ae6, 0x0000],
[0x4ae7, 0x0000],
[0x4ae8, 0x0000],
[0x4ae9, 0x0000],
[0x4aea, 0x059e],
[0x4aeb, 0x0202],
[0x4aec, 0x0044],
[0x4aed, 0x0000],
[0x4aee, 0x0200],
[0x4aef, 0x05ab],
[0x4af0, 0x0000],
[0x4af1, 0x0000],
[0x4af2, 0x0000],
[0x4af3, 0x0000],
[0x4af4, 0x0000],
[0x4af5, 0x0000],
[0x4af6, 0x0000],
[0x4af7, 0xffff],
[0x4af8, 0x0000],
[0x4af9, 0x0000],
[0x4afa, 0x0000],
[0x4afb, 0x0000],
[0x4afc, 0x05ac],
[0x4afd, 0x0202],
[0x4afe, 0x0020],
[0x4aff, 0x0000],
[0x4b00, 0x0648],
[0x4b01, 0x05a9],
[0x4b02, 0x0000],
[0x4b03, 0x0000],
[0x4b04, 0x0000],
[0x4b05, 0x0000],
[0x4b06, 0x0000],
[0x4b07, 0x0000],
[0x4b08, 0x0000],
[0x4b09, 0xffff],
[0x4b0a, 0x0000],
[0x4b0b, 0x0000],
[0x4b0c, 0x0000],
[0x4b0d, 0x0000],
[0x4b0e, 0x05aa],
[0x4b0f, 0x0202],
[0x4b10, 0x02f0],
[0x4b11, 0x0020],
[0x4b12, 0x0210],
[0x4b13, 0x05ad],
[0x4b14, 0x0000],
[0x4b15, 0x0000],
[0x4b16, 0x0000],
[0x4b17, 0x0000],
[0x4b18, 0x0000],
[0x4b19, 0x0000],
[0x4b1a, 0x0000],
[0x4b1b, 0xffff],
[0x4b1c, 0x0000],
[0x4b1d, 0x0000],
[0x4b1e, 0x0000],
[0x4b1f, 0x0000],
[0x4b20, 0x05ae],
[0x4b21, 0x0202],
[0x4b22, 0x0020],
[0x4b23, 0x0000],
[0x4b24, 0x7e87],
[0x4b25, 0x6c75],
[0x4b26, 0x5a63],
[0x4b27, 0x5a51],
[0x4b28, 0x3f48],
[0x4b29, 0x5a36],
[0x4b2a, 0x5a51],
[0x4b2b, 0x242d],
[0x4b2c, 0x121b],
[0x4b2d, 0xff09],
[0x4b2e, 0x000a],
[0x4b2f, 0x0028],
[0x4b30, 0x0000],
[0x4b31, 0x0000],
[0x4b32, 0x000a],
[0x4b33, 0x0070],
[0x4b34, 0x0000],
[0x4b35, 0x0000],
[0x4b36, 0x000a],
[0x4b37, 0x00ee],
[0x4b38, 0x0000],
[0x4b39, 0x0000],
[0x4b3a, 0x001f],
[0x4b3b, 0x011b],
[0x4b3c, 0x0010],
[0x4b3d, 0x0000],
[0x4b3e, 0x0002],
[0x4b3f, 0x0004],
[0x4b40, 0x0002],
[0x4b41, 0x0008],
[0x4b42, 0x0040],
[0x4b43, 0x001f],
[0x4b44, 0x001f],
[0x4b45, 0x0040],
[0x4b46, 0x0002],
[0x4b47, 0x0005],
[0x4b48, 0x0001],
[0x4b49, 0x0001],
[0x4b4a, 0x0007],
[0x4b4b, 0x0000],
[0x4b4c, 0x0040],
[0x4b4d, 0x001f],
[0x4b4e, 0x000f],
[0x4b4f, 0x0010],
[0x4b50, 0x0040],
[0x4b51, 0x0000],
[0x4b52, 0x000a],
[0x4b53, 0x0088],
[0x4b54, 0x0000],
[0x4b55, 0x0000],
[0x4b56, 0x000a],
[0x4b57, 0x009b],
[0x4b58, 0x0000],
[0x4b59, 0x0000],
[0x4b5a, 0x000a],
[0x4b5b, 0x0088],
[0x4b5c, 0x0000],
[0x4b5d, 0x0000],
[0x4b5e, 0x0308],
[0x4b5f, 0x001f],
[0x4b60, 0x0010],
[0x4b61, 0x0000],
[0x4b62, 0x0002],
[0x4b63, 0x0006],
[0x4b64, 0x0002],
[0x4b65, 0x0006],
[0x4b66, 0x0040],
[0x4b67, 0x0010],
[0x4b68, 0x0010],
[0x4b69, 0x0040],
[0x4b6a, 0x0002],
[0x4b6b, 0x0004],
[0x4b6c, 0x0002],
[0x4b6d, 0x0008],
[0x4b6e, 0x0040],
[0x4b6f, 0x001f],
[0x4b70, 0x001f],
[0x4b71, 0x0040],
[0x4b72, 0x0002],
[0x4b73, 0x0003],
[0x4b74, 0x0001],
[0x4b75, 0x0001],
[0x4b76, 0x0001],
[0x4b77, 0x0008],
[0x4b78, 0x0040],
[0x4b79, 0x0010],
[0x4b7a, 0x000f],
[0x4b7b, 0x0010],
[0x4b7c, 0x000f],
[0x4b7d, 0x0040],
[0x4b7e, 0x0002],
[0x4b7f, 0x0004],
[0x4b80, 0x0001],
[0x4b81, 0x0001],
[0x4b82, 0x0001],
[0x4b83, 0x0007],
[0x4b84, 0x0040],
[0x4b85, 0x000f],
[0x4b86, 0x0010],
[0x4b87, 0x000f],
[0x4b88, 0x0010],
[0x4b89, 0x0040],
[0x4b8a, 0x0002],
[0x4b8b, 0x0004],
[0x4b8c, 0x0002],
[0x4b8d, 0x0002],
[0x4b8e, 0x0006],
[0x4b8f, 0x0000],
[0x4b90, 0x0040],
[0x4b91, 0x000f],
[0x4b92, 0x001f],
[0x4b93, 0x0010],
[0x4b94, 0x0040],
[0x4b95, 0x0000],
[0x4b96, 0x0002],
[0x4b97, 0x0004],
[0x4b98, 0x0001],
[0x4b99, 0x0001],
[0x4b9a, 0x0001],
[0x4b9b, 0x0007],
[0x4b9c, 0x0040],
[0x4b9d, 0x000f],
[0x4b9e, 0x0010],
[0x4b9f, 0x000f],
[0x4ba0, 0x0010],
[0x4ba1, 0x0040],
[0x4ba2, 0x0002],
[0x4ba3, 0x0004],
[0x4ba4, 0x0002],
[0x4ba5, 0x0008],
[0x4ba6, 0x0040],
[0x4ba7, 0x001f],
[0x4ba8, 0x001f],
[0x4ba9, 0x0040],
[0x4baa, 0x000a],
[0x4bab, 0x0004],
[0x4bac, 0x0000],
[0x4bad, 0x0000],
[0x4bae, 0x000a],
[0x4baf, 0x006e],
[0x4bb0, 0x0000],
[0x4bb1, 0x0000],
[0x4bb2, 0x000a],
[0x4bb3, 0x0034],
[0x4bb4, 0x0000],
[0x4bb5, 0x0000],
[0x6a00, 0x0000],
[0x6a10, 0x2b80],
[0x6a11, 0x2bc0],
[0x6a12, 0x2c00],
[0x6a13, 0x2c40],
[0x6a14, 0x2c80],
[0x6a15, 0x2cc0],
[0x6a16, 0x2d00],
[0x6a17, 0x2d40],
[0x6a18, 0x2d80],
[0x6a19, 0x2dc0],
[0x6a1a, 0x2e00],
[0x6a1b, 0x2e40],
[0x6a1c, 0x2e80],
[0x6a1d, 0x2ec0],
[0x6a1e, 0x2a80],
[0x6a1f, 0x2ac0],
[0x6a20, 0x2b00],
[0x6a21, 0x2b40],
[0x4000, 0x0000],
[0x4001, 0x0000],
[0x4002, 0x000b],
[0x4003, 0x055e],
[0x4004, 0x0586],
[0x4005, 0x058c],
[0x4006, 0x0592],
[0x4007, 0x05be],
[0x4008, 0x0000],
[0x4009, 0x0000],
[0x400a, 0x0000],
[0x400b, 0x0000],
[0x400c, 0x0000],
[0x400d, 0x0000],
[0x400e, 0x0000],
[0x400f, 0x0000],
[0x4010, 0x04d7],
[0x409e, 0x04c4],
[0x40a0, 0x0202],
[0x40a1, 0x025f],
[0x40a2, 0x01e3],
[0x40a3, 0x0202],
[0x40a4, 0x002b],
[0x40a5, 0x0000],
[0x40a6, 0x0648],
[0x40a7, 0x025f],
[0x40a8, 0x01e3],
[0x40a9, 0x0202],
[0x40aa, 0x0042],
[0x40ab, 0x002b],
[0x40ac, 0x0200],
[0x40ad, 0x01e4],
[0x40ae, 0x01e5],
[0x40af, 0x0202],
[0x40b0, 0x001e],
[0x40b1, 0x0000],
[0x40b2, 0x0240],
[0x40b3, 0x01e4],
[0x40b4, 0x01e8],
[0x40b5, 0x0202],
[0x40b6, 0x003a],
[0x40b7, 0x0000],
[0x40b8, 0x0a06],
[0x40b9, 0x01e9],
[0x40ba, 0x01e3],
[0x40bb, 0x0202],
[0x40bc, 0x0064],
[0x40bd, 0x0055],
[0x40be, 0x0200],
[0x40bf, 0x01e4],
[0x40c0, 0x01e8],
[0x40c1, 0x0202],
[0x40c2, 0x0039],
[0x40c3, 0x0000],
[0x40c4, 0x0200],
[0x40c5, 0x01e4],
[0x40c6, 0x01e8],
[0x40c7, 0x0202],
[0x40c8, 0x003a],
[0x40c9, 0x0000],
[0x40ca, 0x0600],
[0x40cb, 0x01e4],
[0x40cc, 0x01e8],
[0x40cd, 0x0202],
[0x40ce, 0x000b],
[0x40cf, 0x0039],
[0x40d0, 0x0200],
[0x40d1, 0x01e4],
[0x40d2, 0x01e8],
[0x40d3, 0x0202],
[0x40d4, 0x001e],
[0x40d5, 0x0000],
[0x40d6, 0x0200],
[0x40d7, 0x01e6],
[0x40d8, 0x01e7],
[0x40d9, 0x0202],
[0x40da, 0x001e],
[0x40db, 0x0000],
[0x40dc, 0x0200],
[0x40dd, 0x0200],
[0x40de, 0x0202],
[0x40df, 0x0404],
[0x40e0, 0x0007],
[0x40e1, 0x0000],
[0x40e2, 0x0648],
[0x40e3, 0x0200],
[0x40e4, 0x0202],
[0x40e5, 0x0404],
[0x40e6, 0x02f0],
[0x40e7, 0x0007],
[0x40e8, 0x0200],
[0x40e9, 0x0200],
[0x40ea, 0x0202],
[0x40eb, 0x0404],
[0x40ec, 0x0007],
[0x40ed, 0x0000],
[0x40ee, 0x2427],
[0x40ef, 0x1e21],
[0x40f0, 0x181b],
[0x40f1, 0x1b15],
[0x40f2, 0x1518],
[0x40f3, 0x121b],
[0x40f4, 0x1b15],
[0x40f5, 0x1518],
[0x40f6, 0x181b],
[0x40f7, 0x1b0f],
[0x40f8, 0x090c],
[0x40f9, 0x0306],
[0x40fa, 0xffff],
[0x40fb, 0xffff],
[0x40fc, 0x0202],
[0x40fd, 0x024d],
[0x40fe, 0x024e],
[0x40ff, 0x0202],
[0x4100, 0x0033],
[0x4101, 0x0000],
[0x4102, 0x0a06],
[0x4103, 0x024f],
[0x4104, 0x0255],
[0x4105, 0x0c0c],
[0x4106, 0x01ff],
[0x4107, 0x004b],
[0x4108, 0x0206],
[0x4109, 0x025b],
[0x410a, 0x025c],
[0x410b, 0x0602],
[0x410c, 0x006f],
[0x410d, 0x0000],
[0x410e, 0x0210],
[0x410f, 0x0233],
[0x4110, 0x0240],
[0x4111, 0x1919],
[0x4112, 0x0020],
[0x4113, 0x0000],
[0x4114, 0x0a40],
[0x4115, 0x01e2],
[0x4116, 0x01e3],
[0x4117, 0x0202],
[0x4118, 0x0064],
[0x4119, 0x0055],
[0x411a, 0x0200],
[0x411b, 0x0185],
[0x411c, 0x018a],
[0x411d, 0x1409],
[0x411e, 0x0051],
[0x411f, 0x0000],
[0x4120, 0x0a00],
[0x4121, 0x01e2],
[0x4122, 0x01e3],
[0x4123, 0x0202],
[0x4124, 0x0064],
[0x4125, 0x0054],
[0x4126, 0x0a00],
[0x4127, 0x01e2],
[0x4128, 0x01e3],
[0x4129, 0x0202],
[0x412a, 0x0064],
[0x412b, 0x0053],
[0x412c, 0x0600],
[0x412d, 0x0194],
[0x412e, 0x01a3],
[0x412f, 0x281d],
[0x4130, 0x000b],
[0x4131, 0x0051],
[0x4132, 0x0a00],
[0x4133, 0x01e2],
[0x4134, 0x01e3],
[0x4135, 0x0202],
[0x4136, 0x0064],
[0x4137, 0x0055],
[0x4138, 0x0a10],
[0x4139, 0x01e2],
[0x413a, 0x01e3],
[0x413b, 0x0202],
[0x413c, 0x0064],
[0x413d, 0x0053],
[0x413e, 0x0200],
[0x413f, 0x01b7],
[0x4140, 0x01cc],
[0x4141, 0x2b2a],
[0x4142, 0x0044],
[0x4143, 0x0000],
[0x4144, 0x0200],
[0x4145, 0x0204],
[0x4146, 0x020f],
[0x4147, 0x1716],
[0x4148, 0x0020],
[0x4149, 0x0000],
[0x414a, 0x0648],
[0x414b, 0x01ea],
[0x414c, 0x01f5],
[0x414d, 0x1615],
[0x414e, 0x02f0],
[0x414f, 0x0020],
[0x4150, 0x0210],
[0x4151, 0x021b],
[0x4152, 0x0227],
[0x4153, 0x1717],
[0x4154, 0x0020],
[0x4155, 0x0000],
[0x4156, 0x2a2d],
[0x4157, 0x2427],
[0x4158, 0x1e21],
[0x4159, 0x1e1b],
[0x415a, 0x1518],
[0x415b, 0x1e12],
[0x415c, 0x1e1b],
[0x415d, 0x0c0f],
[0x415e, 0x0609],
[0x415f, 0xff03],
[0x4160, 0x0202],
[0x4161, 0x025f],
[0x4162, 0x01e3],
[0x4163, 0x0202],
[0x4164, 0x002b],
[0x4165, 0x0000],
[0x4166, 0x0648],
[0x4167, 0x025f],
[0x4168, 0x01e3],
[0x4169, 0x0202],
[0x416a, 0x0042],
[0x416b, 0x002b],
[0x416c, 0x0200],
[0x416d, 0x01e4],
[0x416e, 0x01e5],
[0x416f, 0x0202],
[0x4170, 0x001e],
[0x4171, 0x0000],
[0x4172, 0x0240],
[0x4173, 0x01e4],
[0x4174, 0x01e8],
[0x4175, 0x0202],
[0x4176, 0x003a],
[0x4177, 0x0000],
[0x4178, 0x0a06],
[0x4179, 0x01e9],
[0x417a, 0x01e3],
[0x417b, 0x0202],
[0x417c, 0x0064],
[0x417d, 0x0055],
[0x417e, 0x0200],
[0x417f, 0x01e4],
[0x4180, 0x01e8],
[0x4181, 0x0202],
[0x4182, 0x0039],
[0x4183, 0x0000],
[0x4184, 0x0200],
[0x4185, 0x01e4],
[0x4186, 0x01e8],
[0x4187, 0x0202],
[0x4188, 0x003a],
[0x4189, 0x0000],
[0x418a, 0x0600],
[0x418b, 0x01e4],
[0x418c, 0x01e8],
[0x418d, 0x0202],
[0x418e, 0x000b],
[0x418f, 0x0039],
[0x4190, 0x0200],
[0x4191, 0x01e4],
[0x4192, 0x01e8],
[0x4193, 0x0202],
[0x4194, 0x001e],
[0x4195, 0x0000],
[0x4196, 0x0200],
[0x4197, 0x01e6],
[0x4198, 0x01e7],
[0x4199, 0x0202],
[0x419a, 0x001e],
[0x419b, 0x0000],
[0x419c, 0x0200],
[0x419d, 0x0200],
[0x419e, 0x0202],
[0x419f, 0x0404],
[0x41a0, 0x0007],
[0x41a1, 0x0000],
[0x41a2, 0x0648],
[0x41a3, 0x0200],
[0x41a4, 0x0202],
[0x41a5, 0x0404],
[0x41a6, 0x02f0],
[0x41a7, 0x0007],
[0x41a8, 0x0200],
[0x41a9, 0x0200],
[0x41aa, 0x0202],
[0x41ab, 0x0404],
[0x41ac, 0x0007],
[0x41ad, 0x0000],
[0x41ae, 0x2427],
[0x41af, 0x1e21],
[0x41b0, 0x181b],
[0x41b1, 0x1b15],
[0x41b2, 0x1518],
[0x41b3, 0x121b],
[0x41b4, 0x1b15],
[0x41b5, 0x1518],
[0x41b6, 0x181b],
[0x41b7, 0x1b0f],
[0x41b8, 0x090c],
[0x41b9, 0x0306],
[0x41ba, 0xffff],
[0x41bb, 0xffff],
[0x41bc, 0x0202],
[0x41bd, 0x024d],
[0x41be, 0x024e],
[0x41bf, 0x0202],
[0x41c0, 0x0033],
[0x41c1, 0x0000],
[0x41c2, 0x0a06],
[0x41c3, 0x024f],
[0x41c4, 0x0255],
[0x41c5, 0x0c0c],
[0x41c6, 0x01ff],
[0x41c7, 0x004b],
[0x41c8, 0x0206],
[0x41c9, 0x025b],
[0x41ca, 0x025c],
[0x41cb, 0x0602],
[0x41cc, 0x006f],
[0x41cd, 0x0000],
[0x41ce, 0x0210],
[0x41cf, 0x0233],
[0x41d0, 0x0240],
[0x41d1, 0x1919],
[0x41d2, 0x0020],
[0x41d3, 0x0000],
[0x41d4, 0x0a40],
[0x41d5, 0x01e2],
[0x41d6, 0x01e3],
[0x41d7, 0x0202],
[0x41d8, 0x0064],
[0x41d9, 0x0055],
[0x41da, 0x0200],
[0x41db, 0x0185],
[0x41dc, 0x018a],
[0x41dd, 0x1409],
[0x41de, 0x0051],
[0x41df, 0x0000],
[0x41e0, 0x0a00],
[0x41e1, 0x01e2],
[0x41e2, 0x01e3],
[0x41e3, 0x0202],
[0x41e4, 0x0064],
[0x41e5, 0x0054],
[0x41e6, 0x0a00],
[0x41e7, 0x01e2],
[0x41e8, 0x01e3],
[0x41e9, 0x0202],
[0x41ea, 0x0064],
[0x41eb, 0x0053],
[0x41ec, 0x0600],
[0x41ed, 0x0194],
[0x41ee, 0x01a3],
[0x41ef, 0x281d],
[0x41f0, 0x000b],
[0x41f1, 0x0051],
[0x41f2, 0x0a00],
[0x41f3, 0x01e2],
[0x41f4, 0x01e3],
[0x41f5, 0x0202],
[0x41f6, 0x0064],
[0x41f7, 0x0055],
[0x41f8, 0x0a10],
[0x41f9, 0x01e2],
[0x41fa, 0x01e3],
[0x41fb, 0x0202],
[0x41fc, 0x0064],
[0x41fd, 0x0053],
[0x41fe, 0x0200],
[0x41ff, 0x01b7],
[0x4200, 0x01cc],
[0x4201, 0x2b2a],
[0x4202, 0x0044],
[0x4203, 0x0000],
[0x4204, 0x0200],
[0x4205, 0x0204],
[0x4206, 0x020f],
[0x4207, 0x1716],
[0x4208, 0x0020],
[0x4209, 0x0000],
[0x420a, 0x0648],
[0x420b, 0x01ea],
[0x420c, 0x01f5],
[0x420d, 0x1615],
[0x420e, 0x02f0],
[0x420f, 0x0020],
[0x4210, 0x0210],
[0x4211, 0x021b],
[0x4212, 0x0227],
[0x4213, 0x1717],
[0x4214, 0x0020],
[0x4215, 0x0000],
[0x4216, 0x2a2d],
[0x4217, 0x2427],
[0x4218, 0x1e21],
[0x4219, 0x1e1b],
[0x421a, 0x1518],
[0x421b, 0x1e12],
[0x421c, 0x1e1b],
[0x421d, 0x0c0f],
[0x421e, 0x0609],
[0x421f, 0xff03],
[0x4220, 0x0202],
[0x4221, 0x025f],
[0x4222, 0x01e3],
[0x4223, 0x0202],
[0x4224, 0x002b],
[0x4225, 0x0000],
[0x4226, 0x0648],
[0x4227, 0x025f],
[0x4228, 0x01e3],
[0x4229, 0x0202],
[0x422a, 0x0042],
[0x422b, 0x002b],
[0x422c, 0x0200],
[0x422d, 0x01e4],
[0x422e, 0x01e5],
[0x422f, 0x0202],
[0x4230, 0x001e],
[0x4231, 0x0000],
[0x4232, 0x0240],
[0x4233, 0x01e4],
[0x4234, 0x01e8],
[0x4235, 0x0202],
[0x4236, 0x003a],
[0x4237, 0x0000],
[0x4238, 0x0a06],
[0x4239, 0x01e9],
[0x423a, 0x01e3],
[0x423b, 0x0202],
[0x423c, 0x0064],
[0x423d, 0x0055],
[0x423e, 0x0200],
[0x423f, 0x01e4],
[0x4240, 0x01e8],
[0x4241, 0x0202],
[0x4242, 0x0039],
[0x4243, 0x0000],
[0x4244, 0x0200],
[0x4245, 0x01e4],
[0x4246, 0x01e8],
[0x4247, 0x0202],
[0x4248, 0x003a],
[0x4249, 0x0000],
[0x424a, 0x0600],
[0x424b, 0x01e4],
[0x424c, 0x01e8],
[0x424d, 0x0202],
[0x424e, 0x000b],
[0x424f, 0x0039],
[0x4250, 0x0200],
[0x4251, 0x01e4],
[0x4252, 0x01e8],
[0x4253, 0x0202],
[0x4254, 0x001e],
[0x4255, 0x0000],
[0x4256, 0x0200],
[0x4257, 0x01e6],
[0x4258, 0x01e7],
[0x4259, 0x0202],
[0x425a, 0x001e],
[0x425b, 0x0000],
[0x425c, 0x0200],
[0x425d, 0x0200],
[0x425e, 0x0202],
[0x425f, 0x0404],
[0x4260, 0x0007],
[0x4261, 0x0000],
[0x4262, 0x0648],
[0x4263, 0x0200],
[0x4264, 0x0202],
[0x4265, 0x0404],
[0x4266, 0x02f0],
[0x4267, 0x0007],
[0x4268, 0x0200],
[0x4269, 0x0200],
[0x426a, 0x0202],
[0x426b, 0x0404],
[0x426c, 0x0007],
[0x426d, 0x0000],
[0x426e, 0x2427],
[0x426f, 0x1e21],
[0x4270, 0x181b],
[0x4271, 0x1b15],
[0x4272, 0x1518],
[0x4273, 0x121b],
[0x4274, 0x1b15],
[0x4275, 0x1518],
[0x4276, 0x181b],
[0x4277, 0x1b0f],
[0x4278, 0x090c],
[0x4279, 0x0306],
[0x427a, 0xffff],
[0x427b, 0xffff],
[0x427c, 0x0202],
[0x427d, 0x024d],
[0x427e, 0x024e],
[0x427f, 0x0202],
[0x4280, 0x0033],
[0x4281, 0x0000],
[0x4282, 0x0a06],
[0x4283, 0x024f],
[0x4284, 0x0255],
[0x4285, 0x0c0c],
[0x4286, 0x01ff],
[0x4287, 0x004b],
[0x4288, 0x0206],
[0x4289, 0x025b],
[0x428a, 0x025c],
[0x428b, 0x0602],
[0x428c, 0x006f],
[0x428d, 0x0000],
[0x428e, 0x0210],
[0x428f, 0x0233],
[0x4290, 0x0240],
[0x4291, 0x1919],
[0x4292, 0x0020],
[0x4293, 0x0000],
[0x4294, 0x0a40],
[0x4295, 0x01e2],
[0x4296, 0x01e3],
[0x4297, 0x0202],
[0x4298, 0x0064],
[0x4299, 0x0055],
[0x429a, 0x0200],
[0x429b, 0x0185],
[0x429c, 0x018a],
[0x429d, 0x1409],
[0x429e, 0x0051],
[0x429f, 0x0000],
[0x42a0, 0x0a00],
[0x42a1, 0x01e2],
[0x42a2, 0x01e3],
[0x42a3, 0x0202],
[0x42a4, 0x0064],
[0x42a5, 0x0054],
[0x42a6, 0x0a00],
[0x42a7, 0x01e2],
[0x42a8, 0x01e3],
[0x42a9, 0x0202],
[0x42aa, 0x0064],
[0x42ab, 0x0053],
[0x42ac, 0x0600],
[0x42ad, 0x0194],
[0x42ae, 0x01a3],
[0x42af, 0x281d],
[0x42b0, 0x000b],
[0x42b1, 0x0051],
[0x42b2, 0x0a00],
[0x42b3, 0x01e2],
[0x42b4, 0x01e3],
[0x42b5, 0x0202],
[0x42b6, 0x0064],
[0x42b7, 0x0055],
[0x42b8, 0x0a10],
[0x42b9, 0x01e2],
[0x42ba, 0x01e3],
[0x42bb, 0x0202],
[0x42bc, 0x0064],
[0x42bd, 0x0053],
[0x42be, 0x0200],
[0x42bf, 0x01b7],
[0x42c0, 0x01cc],
[0x42c1, 0x2b2a],
[0x42c2, 0x0044],
[0x42c3, 0x0000],
[0x42c4, 0x0200],
[0x42c5, 0x0204],
[0x42c6, 0x020f],
[0x42c7, 0x1716],
[0x42c8, 0x0020],
[0x42c9, 0x0000],
[0x42ca, 0x0648],
[0x42cb, 0x01ea],
[0x42cc, 0x01f5],
[0x42cd, 0x1615],
[0x42ce, 0x02f0],
[0x42cf, 0x0020],
[0x42d0, 0x0210],
[0x42d1, 0x021b],
[0x42d2, 0x0227],
[0x42d3, 0x1717],
[0x42d4, 0x0020],
[0x42d5, 0x0000],
[0x42d6, 0x2a2d],
[0x42d7, 0x2427],
[0x42d8, 0x1e21],
[0x42d9, 0x1e1b],
[0x42da, 0x1518],
[0x42db, 0x1e12],
[0x42dc, 0x1e1b],
[0x42dd, 0x0c0f],
[0x42de, 0x0609],
[0x42df, 0xff03],
[0x42e0, 0x0207],
[0x42e1, 0x2260],
[0x42e2, 0x03a0],
[0x42e3, 0x0000],
[0x42e4, 0x8807],
[0x42e5, 0x2261],
[0x42e6, 0x063a],
[0x42e7, 0x0000],
[0x42e8, 0x4207],
[0x42e9, 0x2261],
[0x42ea, 0x03a0],
[0x42eb, 0x0000],
[0x42ec, 0x0207],
[0x42ed, 0x2260],
[0x42ee, 0x03a0],
[0x42ef, 0x0000],
[0x42f0, 0x8807],
[0x42f1, 0x2261],
[0x42f2, 0x063a],
[0x42f3, 0x0000],
[0x42f4, 0x4207],
[0x42f5, 0x2261],
[0x42f6, 0x03a0],
[0x42f7, 0x0000],
[0x42f8, 0x0207],
[0x42f9, 0x2260],
[0x42fa, 0x03a0],
[0x42fb, 0x0000],
[0x42fc, 0x8807],
[0x42fd, 0x2261],
[0x42fe, 0x063a],
[0x42ff, 0x0000],
[0x4300, 0x4207],
[0x4301, 0x2261],
[0x4302, 0x03a0],
[0x4303, 0x0000],
[0x4304, 0x1012],
[0x4305, 0xff0e],
[0x4306, 0x0b0d],
[0x4307, 0xff09],
[0x4308, 0x0608],
[0x4309, 0xff04],
[0x430a, 0x0002],
[0x430b, 0x0006],
[0x430c, 0x0006],
[0x430d, 0x0006],
[0x430e, 0x0006],
[0x430f, 0x0006],
[0x4310, 0x0006],
[0x4311, 0x000c],
[0x4312, 0x0006],
[0x4313, 0x0000],
[0x4314, 0x0002],
[0x4315, 0x0001],
[0x4316, 0x0100],
[0x4317, 0x0080],
[0x4318, 0x0020],
[0x4319, 0x0010],
[0x431a, 0x0004],
[0x431b, 0x0002],
[0x431c, 0x0200],
[0x431d, 0x0100],
[0x431e, 0x0040],
[0x431f, 0x0020],
[0x4320, 0x0008],
[0x4321, 0x0004],
[0x4322, 0x0001],
[0x4323, 0x0200],
[0x4324, 0x0080],
[0x4325, 0x0040],
[0x4326, 0x0010],
[0x4327, 0x0008],
[0x4328, 0x0002],
[0x4329, 0x0006],
[0x432a, 0x0006],
[0x432b, 0x0006],
[0x432c, 0x0006],
[0x432d, 0x0006],
[0x432e, 0x0006],
[0x432f, 0x000c],
[0x4330, 0x0006],
[0x4331, 0x0006],
[0x4332, 0x0006],
[0x4333, 0x0006],
[0x4334, 0x0006],
[0x4335, 0x0006],
[0x4336, 0x0006],
[0x4337, 0x0006],
[0x4338, 0x0006],
[0x4339, 0x0006],
[0x433a, 0x0006],
[0x433b, 0x0006],
[0x433c, 0x0006],
[0x433d, 0x0006],
[0x433e, 0x0006],
[0x433f, 0x0006],
[0x4340, 0x0006],
[0x4341, 0x0006],
[0x4342, 0x0006],
[0x4343, 0x000c],
[0x4344, 0x0006],
[0x4345, 0x0000],
[0x4346, 0x0008],
[0x4347, 0x0010],
[0x4348, 0x0040],
[0x4349, 0x0080],
[0x434a, 0x0200],
[0x434b, 0x0001],
[0x434c, 0x0004],
[0x434d, 0x0008],
[0x434e, 0x0020],
[0x434f, 0x0040],
[0x4350, 0x0100],
[0x4351, 0x0200],
[0x4352, 0x0002],
[0x4353, 0x0004],
[0x4354, 0x0010],
[0x4355, 0x0020],
[0x4356, 0x0080],
[0x4357, 0x0100],
[0x4358, 0x0001],
[0x4359, 0x0002],
[0x435a, 0x0008],
[0x435b, 0x0010],
[0x435c, 0x0040],
[0x435d, 0x0080],
[0x435e, 0x0200],
[0x435f, 0x0001],
[0x4360, 0x0004],
[0x4361, 0x0008],
[0x4362, 0x0020],
[0x4363, 0x0040],
[0x4364, 0x0100],
[0x4365, 0x0200],
[0x4366, 0x0002],
[0x4367, 0x0004],
[0x4368, 0x0010],
[0x4369, 0x0020],
[0x436a, 0x0080],
[0x436b, 0x0100],
[0x436c, 0x0001],
[0x436d, 0x0002],
[0x436e, 0x0002],
[0x436f, 0x002a],
[0x4370, 0x0006],
[0x4371, 0x0006],
[0x4372, 0x0006],
[0x4373, 0x0006],
[0x4374, 0x0006],
[0x4375, 0x0006],
[0x4376, 0x000c],
[0x4377, 0x0006],
[0x4378, 0x0006],
[0x4379, 0x0006],
[0x437a, 0x0006],
[0x437b, 0x0006],
[0x437c, 0x0006],
[0x437d, 0x0006],
[0x437e, 0x0006],
[0x437f, 0x0006],
[0x4380, 0x0006],
[0x4381, 0x0006],
[0x4382, 0x0006],
[0x4383, 0x0006],
[0x4384, 0x0006],
[0x4385, 0x0006],
[0x4386, 0x0006],
[0x4387, 0x0006],
[0x4388, 0x0006],
[0x4389, 0x0006],
[0x438a, 0x000c],
[0x438b, 0x0006],
[0x438c, 0x0006],
[0x438d, 0x0006],
[0x438e, 0x0006],
[0x438f, 0x0006],
[0x4390, 0x0006],
[0x4391, 0x0006],
[0x4392, 0x0006],
[0x4393, 0x0006],
[0x4394, 0x0006],
[0x4395, 0x0006],
[0x4396, 0x0006],
[0x4397, 0x000c],
[0x4398, 0x8020],
[0x4399, 0x0002],
[0x439a, 0x0001],
[0x439b, 0x0100],
[0x439c, 0x0080],
[0x439d, 0x0020],
[0x439e, 0x0010],
[0x439f, 0x0004],
[0x43a0, 0x0002],
[0x43a1, 0x0200],
[0x43a2, 0x0100],
[0x43a3, 0x0040],
[0x43a4, 0x0020],
[0x43a5, 0x0008],
[0x43a6, 0x0004],
[0x43a7, 0x0001],
[0x43a8, 0x0200],
[0x43a9, 0x0080],
[0x43aa, 0x0040],
[0x43ab, 0x0010],
[0x43ac, 0x0008],
[0x43ad, 0x0002],
[0x43ae, 0x0001],
[0x43af, 0x0100],
[0x43b0, 0x0080],
[0x43b1, 0x0020],
[0x43b2, 0x0010],
[0x43b3, 0x0004],
[0x43b4, 0x0002],
[0x43b5, 0x0200],
[0x43b6, 0x0100],
[0x43b7, 0x0040],
[0x43b8, 0x0020],
[0x43b9, 0x0008],
[0x43ba, 0x0004],
[0x43bb, 0x0001],
[0x43bc, 0x0200],
[0x43bd, 0x0080],
[0x43be, 0x0040],
[0x43bf, 0x0010],
[0x43c0, 0x0008],
[0x43c1, 0x0002],
[0x43c2, 0x0002],
[0x43c3, 0x0000],
[0x43c4, 0x000a],
[0x43c5, 0x0006],
[0x43c6, 0x0000],
[0x43c7, 0x0000],
[0x43c8, 0x0001],
[0x43c9, 0x0001],
[0x43ca, 0x0000],
[0x43cb, 0x80cf],
[0x43cc, 0x0002],
[0x43cd, 0x00ab],
[0x43ce, 0x000f],
[0x43cf, 0x80cf],
[0x43d0, 0x0000],
[0x43d1, 0x000f],
[0x43d2, 0x0002],
[0x43d3, 0x000e],
[0x43d4, 0x0002],
[0x43d5, 0x0006],
[0x43d6, 0x0006],
[0x43d7, 0x0006],
[0x43d8, 0x0006],
[0x43d9, 0x0006],
[0x43da, 0x0006],
[0x43db, 0x000c],
[0x43dc, 0x0006],
[0x43dd, 0x0006],
[0x43de, 0x0006],
[0x43df, 0x0006],
[0x43e0, 0x0006],
[0x43e1, 0x0006],
[0x43e2, 0x0006],
[0x43e3, 0x0006],
[0x43e4, 0x0006],
[0x43e5, 0x0006],
[0x43e6, 0x0006],
[0x43e7, 0x0006],
[0x43e8, 0x000c],
[0x43e9, 0x0000],
[0x43ea, 0x0002],
[0x43eb, 0x0001],
[0x43ec, 0x0100],
[0x43ed, 0x0080],
[0x43ee, 0x0020],
[0x43ef, 0x0010],
[0x43f0, 0x0004],
[0x43f1, 0x0002],
[0x43f2, 0x0200],
[0x43f3, 0x0100],
[0x43f4, 0x0040],
[0x43f5, 0x0020],
[0x43f6, 0x0008],
[0x43f7, 0x0004],
[0x43f8, 0x0001],
[0x43f9, 0x0200],
[0x43fa, 0x0080],
[0x43fb, 0x0040],
[0x43fc, 0x0010],
[0x43fd, 0x0008],
[0x43fe, 0x0002],
[0x43ff, 0x0002],
[0x4400, 0x0002],
[0x4401, 0x0014],
[0x4402, 0x0017],
[0x4403, 0x00c6],
[0x4404, 0x8100],
[0x4405, 0x8100],
[0x4406, 0x8003],
[0x4407, 0x8003],
[0x4408, 0x0002],
[0x4409, 0x0013],
[0x440a, 0x0006],
[0x440b, 0x0006],
[0x440c, 0x0006],
[0x440d, 0x0006],
[0x440e, 0x0006],
[0x440f, 0x0006],
[0x4410, 0x000c],
[0x4411, 0x0006],
[0x4412, 0x0006],
[0x4413, 0x0006],
[0x4414, 0x0006],
[0x4415, 0x0006],
[0x4416, 0x0006],
[0x4417, 0x0006],
[0x4418, 0x0006],
[0x4419, 0x0006],
[0x441a, 0x0006],
[0x441b, 0x0006],
[0x441c, 0x0006],
[0x441d, 0x000c],
[0x441e, 0x8200],
[0x441f, 0x0002],
[0x4420, 0x0001],
[0x4421, 0x0100],
[0x4422, 0x0080],
[0x4423, 0x0020],
[0x4424, 0x0010],
[0x4425, 0x0004],
[0x4426, 0x0002],
[0x4427, 0x0200],
[0x4428, 0x0100],
[0x4429, 0x0040],
[0x442a, 0x0020],
[0x442b, 0x0008],
[0x442c, 0x0004],
[0x442d, 0x0001],
[0x442e, 0x0200],
[0x442f, 0x0080],
[0x4430, 0x0040],
[0x4431, 0x0010],
[0x4432, 0x0008],
[0x4433, 0x0002],
[0x4434, 0x0002],
[0x4435, 0x0000],
[0x4436, 0x0002],
[0x4437, 0x0006],
[0x4438, 0x0006],
[0x4439, 0x0006],
[0x443a, 0x0006],
[0x443b, 0x0006],
[0x443c, 0x0006],
[0x443d, 0x000c],
[0x443e, 0x0006],
[0x443f, 0x0006],
[0x4440, 0x0006],
[0x4441, 0x0006],
[0x4442, 0x0006],
[0x4443, 0x0006],
[0x4444, 0x0006],
[0x4445, 0x0006],
[0x4446, 0x0006],
[0x4447, 0x0006],
[0x4448, 0x0006],
[0x4449, 0x0006],
[0x444a, 0x0005],
[0x444b, 0x0007],
[0x444c, 0x000c],
[0x444d, 0x0000],
[0x444e, 0x0002],
[0x444f, 0x0001],
[0x4450, 0x0100],
[0x4451, 0x0080],
[0x4452, 0x0020],
[0x4453, 0x0010],
[0x4454, 0x0004],
[0x4455, 0x0002],
[0x4456, 0x0200],
[0x4457, 0x0100],
[0x4458, 0x0040],
[0x4459, 0x0020],
[0x445a, 0x0008],
[0x445b, 0x0004],
[0x445c, 0x0001],
[0x445d, 0x0200],
[0x445e, 0x0080],
[0x445f, 0x0040],
[0x4460, 0x0010],
[0x4461, 0x0008],
[0x4462, 0x8200],
[0x4463, 0x0002],
[0x4464, 0x0002],
[0x4465, 0x0000],
[0x4466, 0x0002],
[0x4467, 0x0006],
[0x4468, 0x0006],
[0x4469, 0x0006],
[0x446a, 0x0006],
[0x446b, 0x0006],
[0x446c, 0x0006],
[0x446d, 0x000c],
[0x446e, 0x0006],
[0x446f, 0x0006],
[0x4470, 0x0006],
[0x4471, 0x0006],
[0x4472, 0x0006],
[0x4473, 0x0006],
[0x4474, 0x0006],
[0x4475, 0x0006],
[0x4476, 0x0006],
[0x4477, 0x0006],
[0x4478, 0x0006],
[0x4479, 0x0006],
[0x447a, 0x000c],
[0x447b, 0x000c],
[0x447c, 0x026d],
[0x447d, 0x000a],
[0x447e, 0x001e],
[0x447f, 0x0000],
[0x4480, 0x0002],
[0x4481, 0x0001],
[0x4482, 0x0100],
[0x4483, 0x0080],
[0x4484, 0x0020],
[0x4485, 0x0010],
[0x4486, 0x0004],
[0x4487, 0x0002],
[0x4488, 0x0200],
[0x4489, 0x0100],
[0x448a, 0x0040],
[0x448b, 0x0020],
[0x448c, 0x0008],
[0x448d, 0x0004],
[0x448e, 0x0001],
[0x448f, 0x0200],
[0x4490, 0x0080],
[0x4491, 0x0040],
[0x4492, 0x0010],
[0x4493, 0x0008],
[0x4494, 0x0002],
[0x4495, 0x0002],
[0x4496, 0x0000],
[0x4497, 0x0000],
[0x4498, 0x8020],
[0x4499, 0x0000],
[0x449a, 0x0002],
[0x449b, 0x000c],
[0x449c, 0x0012],
[0x449d, 0x0084],
[0x449e, 0x0002],
[0x449f, 0x000c],
[0x44a0, 0x0009],
[0x44a1, 0x0003],
[0x44a2, 0x000c],
[0x44a3, 0x000c],
[0x44a4, 0x000c],
[0x44a5, 0x000c],
[0x44a6, 0x000c],
[0x44a7, 0x000c],
[0x44a8, 0x000c],
[0x44a9, 0x000a],
[0x44aa, 0x0009],
[0x44ab, 0x0012],
[0x44ac, 0x0000],
[0x44ad, 0x0024],
[0x44ae, 0x0048],
[0x44af, 0x0090],
[0x44b0, 0x0120],
[0x44b1, 0x0240],
[0x44b2, 0x0081],
[0x44b3, 0x0102],
[0x44b4, 0x0204],
[0x44b5, 0x0000],
[0x44b6, 0x0002],
[0x44b7, 0x000c],
[0x44b8, 0x0008],
[0x44b9, 0x0012],
[0x44ba, 0x0024],
[0x44bb, 0x0040],
[0x44bc, 0x00a0],
[0x44bd, 0x0048],
[0x44be, 0x0002],
[0x44bf, 0x00c6],
[0x44c0, 0xc000],
[0x44c1, 0xc028],
[0x44c2, 0x8000],
[0x44c3, 0x8028],
[0x44c4, 0x0000],
[0x44c5, 0x0091],
[0x44c6, 0x0000],
[0x44c7, 0x0010],
[0x44c8, 0x0060],
[0x44c9, 0x00ff],
[0x44ca, 0x0847],
[0x44cb, 0x0091],
[0x44cc, 0x0000],
[0x44cd, 0x0010],
[0x44ce, 0x0060],
[0x44cf, 0x00ff],
[0x44d0, 0x0847],
[0x44d1, 0x0091],
[0x44d2, 0x0000],
[0x44d3, 0x0010],
[0x44d4, 0x0060],
[0x44d5, 0x00ff],
[0x44d6, 0x0847],
[0x44d7, 0x04e3],
[0x44d8, 0x04ec],
[0x44d9, 0x04f5],
[0x44da, 0x0510],
[0x44db, 0x051a],
[0x44dc, 0x0524],
[0x44dd, 0x052a],
[0x44de, 0x0534],
[0x44df, 0x053e],
[0x44e0, 0x0544],
[0x44e1, 0x054e],
[0x44e2, 0x0558],
[0x44e3, 0x04c5],
[0x44e4, 0x0182],
[0x44e5, 0x00ab],
[0x44e6, 0x047a],
[0x44e7, 0x0077],
[0x44e8, 0xffff],
[0x44e9, 0xffff],
[0x44ea, 0x04da],
[0x44eb, 0xff67],
[0x44ec, 0x04cb],
[0x44ed, 0x0183],
[0x44ee, 0x010b],
[0x44ef, 0x0506],
[0x44f0, 0x00d7],
[0x44f1, 0xffff],
[0x44f2, 0xffff],
[0x44f3, 0x04dd],
[0x44f4, 0xff67],
[0x44f5, 0x04d1],
[0x44f6, 0x0184],
[0x44f7, 0x016b],
[0x44f8, 0x0592],
[0x44f9, 0x0137],
[0x44fa, 0xffff],
[0x44fb, 0xffff],
[0x44fc, 0x04e0],
[0x44fd, 0xff67],
[0x44fe, 0x0000],
[0x44ff, 0x0000],
[0x4500, 0x0000],
[0x4501, 0x0000],
[0x4502, 0x0000],
[0x4503, 0x0000],
[0x4504, 0x0000],
[0x4505, 0x0000],
[0x4506, 0x0000],
[0x4507, 0x0000],
[0x4508, 0x0000],
[0x4509, 0x0000],
[0x450a, 0x0000],
[0x450b, 0x0000],
[0x450c, 0x0000],
[0x450d, 0x0000],
[0x450e, 0x0000],
[0x450f, 0x0000],
[0x4510, 0x0006],
[0x4511, 0xc731],
[0x4512, 0x0086],
[0x4513, 0x0000],
[0x4514, 0x200c],
[0x4515, 0x0000],
[0x4516, 0x1986],
[0x4517, 0x051a],
[0x4518, 0x0035],
[0x4519, 0x0035],
[0x451a, 0x0006],
[0x451b, 0xc731],
[0x451c, 0x0086],
[0x451d, 0x1010],
[0x451e, 0x200c],
[0x451f, 0x0000],
[0x4520, 0x1986],
[0x4521, 0x0524],
[0x4522, 0x0035],
[0x4523, 0x0035],
[0x4524, 0x1986],
[0x4525, 0x0510],
[0x4526, 0x000b],
[0x4527, 0x072e],
[0x4528, 0x0035],
[0x4529, 0x000d],
[0x452a, 0x0006],
[0x452b, 0xc731],
[0x452c, 0x0086],
[0x452d, 0x0000],
[0x452e, 0x200c],
[0x452f, 0x0000],
[0x4530, 0x1986],
[0x4531, 0x0534],
[0x4532, 0x0035],
[0x4533, 0x0035],
[0x4534, 0x0006],
[0x4535, 0xc731],
[0x4536, 0x0086],
[0x4537, 0x1010],
[0x4538, 0x200c],
[0x4539, 0x0000],
[0x453a, 0x1986],
[0x453b, 0x053e],
[0x453c, 0x0035],
[0x453d, 0x0035],
[0x453e, 0x1986],
[0x453f, 0x052a],
[0x4540, 0x000b],
[0x4541, 0x072e],
[0x4542, 0x0035],
[0x4543, 0x000d],
[0x4544, 0x0006],
[0x4545, 0xc731],
[0x4546, 0x0086],
[0x4547, 0x0000],
[0x4548, 0x200c],
[0x4549, 0x0000],
[0x454a, 0x1986],
[0x454b, 0x054e],
[0x454c, 0x0035],
[0x454d, 0x0035],
[0x454e, 0x0006],
[0x454f, 0xc731],
[0x4550, 0x0086],
[0x4551, 0x1010],
[0x4552, 0x200c],
[0x4553, 0x0000],
[0x4554, 0x1986],
[0x4555, 0x0558],
[0x4556, 0x0035],
[0x4557, 0x0035],
[0x4558, 0x1986],
[0x4559, 0x0544],
[0x455a, 0x000b],
[0x455b, 0x072e],
[0x455c, 0x0035],
[0x455d, 0x000d],
[0x455e, 0x1806],
[0x455f, 0x0574],
[0x4560, 0x1906],
[0x4561, 0x0576],
[0x4562, 0x1a06],
[0x4563, 0x057c],
[0x4564, 0x1b86],
[0x4565, 0x057e],
[0x4566, 0x0386],
[0x4567, 0x0000],
[0x4568, 0x0586],
[0x4569, 0x003f],
[0x456a, 0x039c],
[0x456b, 0xc75e],
[0x456c, 0x038c],
[0x456d, 0x000d],
[0x456e, 0x039c],
[0x456f, 0xc730],
[0x4570, 0x038c],
[0x4571, 0x000e],
[0x4572, 0x0015],
[0x4573, 0x0025],
[0x4574, 0x000b],
[0x4575, 0x0592],
[0x4576, 0x039c],
[0x4577, 0x0001],
[0x4578, 0x001c],
[0x4579, 0x0000],
[0x457a, 0x0003],
[0x457b, 0x000d],
[0x457c, 0x000b],
[0x457d, 0x05be],
[0x457e, 0x0006],
[0x457f, 0x0001],
[0x4580, 0x038c],
[0x4581, 0xc07f],
[0x4582, 0x8186],
[0x4583, 0x000f],
[0x4584, 0x0035],
[0x4585, 0x000d],
[0x4586, 0x0006],
[0x4587, 0x0001],
[0x4588, 0x038c],
[0x4589, 0x2a00],
[0x458a, 0x0035],
[0x458b, 0x000d],
[0x458c, 0x001b],
[0x458d, 0x05de],
[0x458e, 0x8086],
[0x458f, 0x0002],
[0x4590, 0x0035],
[0x4591, 0x000d],
[0x4592, 0x0006],
[0x4593, 0x1f1f],
[0x4594, 0x038c],
[0x4595, 0xc731],
[0x4596, 0x0006],
[0x4597, 0x0000],
[0x4598, 0x038c],
[0x4599, 0xc75e],
[0x459a, 0x039c],
[0x459b, 0xc08c],
[0x459c, 0x239c],
[0x459d, 0xc08d],
[0x459e, 0x0106],
[0x459f, 0x0000],
[0x45a0, 0x438c],
[0x45a1, 0xc08c],
[0x45a2, 0x438c],
[0x45a3, 0xc08d],
[0x45a4, 0x0106],
[0x45a5, 0x0000],
[0x45a6, 0x438c],
[0x45a7, 0xc07f],
[0x45a8, 0x038c],
[0x45a9, 0xc08c],
[0x45aa, 0x238c],
[0x45ab, 0xc08d],
[0x45ac, 0x0006],
[0x45ad, 0x0001],
[0x45ae, 0x038c],
[0x45af, 0xc3dd],
[0x45b0, 0x039c],
[0x45b1, 0xc300],
[0x45b2, 0x0086],
[0x45b3, 0xfffe],
[0x45b4, 0x0420],
[0x45b5, 0x000d],
[0x45b6, 0x038c],
[0x45b7, 0xc300],
[0x45b8, 0x0586],
[0x45b9, 0x0001],
[0x45ba, 0x8186],
[0x45bb, 0x0000],
[0x45bc, 0x0035],
[0x45bd, 0x000d],
[0x45be, 0x039c],
[0x45bf, 0xc300],
[0x45c0, 0x0086],
[0x45c1, 0x0001],
[0x45c2, 0x0428],
[0x45c3, 0x000d],
[0x45c4, 0x038c],
[0x45c5, 0xc300],
[0x45c6, 0x0006],
[0x45c7, 0x1010],
[0x45c8, 0x038c],
[0x45c9, 0xc731],
[0x45ca, 0x039c],
[0x45cb, 0x000d],
[0x45cc, 0x038c],
[0x45cd, 0xc75e],
[0x45ce, 0x039c],
[0x45cf, 0x000e],
[0x45d0, 0x038c],
[0x45d1, 0xc730],
[0x45d2, 0x0586],
[0x45d3, 0x003f],
[0x45d4, 0xe38c],
[0x45d5, 0x2a00],
[0x45d6, 0x001b],
[0x45d7, 0x0624],
[0x45d8, 0x001b],
[0x45d9, 0x05de],
[0x45da, 0x8086],
[0x45db, 0x0001],
[0x45dc, 0x0035],
[0x45dd, 0x000d],
[0x45de, 0x039c],
[0x45df, 0x0000],
[0x45e0, 0x0086],
[0x45e1, 0x04d7],
[0x45e2, 0x4400],
[0x45e3, 0x000d],
[0x45e4, 0x411c],
[0x45e5, 0x0000],
[0x45e6, 0x611c],
[0x45e7, 0x0001],
[0x45e8, 0x638c],
[0x45e9, 0x3d25],
[0x45ea, 0x611c],
[0x45eb, 0x0002],
[0x45ec, 0x638c],
[0x45ed, 0x3d40],
[0x45ee, 0x611c],
[0x45ef, 0x0003],
[0x45f0, 0x638c],
[0x45f1, 0x3d60],
[0x45f2, 0x611c],
[0x45f3, 0x0004],
[0x45f4, 0x638c],
[0x45f5, 0x3d80],
[0x45f6, 0x611c],
[0x45f7, 0x0005],
[0x45f8, 0x638c],
[0x45f9, 0x3c35],
[0x45fa, 0x611c],
[0x45fb, 0x0006],
[0x45fc, 0x638c],
[0x45fd, 0x3c36],
[0x45fe, 0x0186],
[0x45ff, 0xff62],
[0x4600, 0x638c],
[0x4601, 0x3c20],
[0x4602, 0x611c],
[0x4603, 0x0000],
[0x4604, 0xa19c],
[0x4605, 0x0000],
[0x4606, 0xa38c],
[0x4607, 0x3d42],
[0x4608, 0xa19c],
[0x4609, 0x0001],
[0x460a, 0xa38c],
[0x460b, 0x3d43],
[0x460c, 0xa19c],
[0x460d, 0x0002],
[0x460e, 0xa38c],
[0x460f, 0x3d62],
[0x4610, 0xa19c],
[0x4611, 0x0003],
[0x4612, 0xa38c],
[0x4613, 0x3d63],
[0x4614, 0xa19c],
[0x4615, 0x0004],
[0x4616, 0xa38c],
[0x4617, 0x3d82],
[0x4618, 0xa19c],
[0x4619, 0x0005],
[0x461a, 0xa38c],
[0x461b, 0x3d83],
[0x461c, 0x611c],
[0x461d, 0x0007],
[0x461e, 0xa19c],
[0x461f, 0x0000],
[0x4620, 0xa38c],
[0x4621, 0x3c33],
[0x4622, 0x0055],
[0x4623, 0x000d],
[0x4624, 0x039c],
[0x4625, 0x000c],
[0x4626, 0x0009],
[0x4627, 0x0001],
[0x4628, 0x004a],
[0x4629, 0x0626],
[0x462a, 0xe38c],
[0x462b, 0xc084],
[0x462c, 0xe38c],
[0x462d, 0xc085],
[0x462e, 0x039c],
[0x462f, 0x0000],
[0x4630, 0x401c],
[0x4631, 0x2a10],
[0x4632, 0x011c],
[0x4633, 0x0006],
[0x4634, 0x038c],
[0x4635, 0xc3cc],
[0x4636, 0x6101],
[0x4637, 0x001c],
[0x4638, 0x011c],
[0x4639, 0x0005],
[0x463a, 0x219c],
[0x463b, 0x0000],
[0x463c, 0x008c],
[0x463d, 0x0000],
[0x463e, 0x219c],
[0x463f, 0x0001],
[0x4640, 0x008c],
[0x4641, 0x0000],
[0x4642, 0x219c],
[0x4643, 0x0002],
[0x4644, 0x008c],
[0x4645, 0x0000],
[0x4646, 0x219c],
[0x4647, 0x0003],
[0x4648, 0x008c],
[0x4649, 0x0000],
[0x464a, 0x219c],
[0x464b, 0x0004],
[0x464c, 0x008c],
[0x464d, 0x0000],
[0x464e, 0x219c],
[0x464f, 0x0005],
[0x4650, 0x008c],
[0x4651, 0x0000],
[0x4652, 0x219c],
[0x4653, 0x0006],
[0x4654, 0x008c],
[0x4655, 0x0000],
[0x4656, 0x219c],
[0x4657, 0x0007],
[0x4658, 0x008c],
[0x4659, 0x0000],
[0x465a, 0x219c],
[0x465b, 0x0008],
[0x465c, 0x008c],
[0x465d, 0x0000],
[0x465e, 0x219c],
[0x465f, 0x0009],
[0x4660, 0x008c],
[0x4661, 0x0000],
[0x4662, 0x219c],
[0x4663, 0x000a],
[0x4664, 0x008c],
[0x4665, 0x0000],
[0x4666, 0x6101],
[0x4667, 0x0027],
[0x4668, 0x011c],
[0x4669, 0x000d],
[0x466a, 0x219c],
[0x466b, 0x0000],
[0x466c, 0x008c],
[0x466d, 0x0000],
[0x466e, 0x219c],
[0x466f, 0x0001],
[0x4670, 0x008c],
[0x4671, 0x0000],
[0x4672, 0x219c],
[0x4673, 0x0002],
[0x4674, 0x008c],
[0x4675, 0x0000],
[0x4676, 0x219c],
[0x4677, 0x0003],
[0x4678, 0x008c],
[0x4679, 0x0000],
[0x467a, 0x219c],
[0x467b, 0x000f],
[0x467c, 0x008c],
[0x467d, 0x0000],
[0x467e, 0x219c],
[0x467f, 0x0010],
[0x4680, 0x008c],
[0x4681, 0x0000],
[0x4682, 0x219c],
[0x4683, 0x0011],
[0x4684, 0x008c],
[0x4685, 0x0000],
[0x4686, 0x219c],
[0x4687, 0x0012],
[0x4688, 0x008c],
[0x4689, 0x0000],
[0x468a, 0x011c],
[0x468b, 0x000e],
[0x468c, 0x219c],
[0x468d, 0x0005],
[0x468e, 0x008c],
[0x468f, 0x0000],
[0x4690, 0x219c],
[0x4691, 0x0006],
[0x4692, 0x008c],
[0x4693, 0x0000],
[0x4694, 0x219c],
[0x4695, 0x0007],
[0x4696, 0x008c],
[0x4697, 0x0000],
[0x4698, 0x219c],
[0x4699, 0x0008],
[0x469a, 0x008c],
[0x469b, 0x0000],
[0x469c, 0x011c],
[0x469d, 0x000f],
[0x469e, 0x219c],
[0x469f, 0x000a],
[0x46a0, 0x008c],
[0x46a1, 0x0000],
[0x46a2, 0x219c],
[0x46a3, 0x000b],
[0x46a4, 0x008c],
[0x46a5, 0x0000],
[0x46a6, 0x219c],
[0x46a7, 0x000c],
[0x46a8, 0x008c],
[0x46a9, 0x0000],
[0x46aa, 0x219c],
[0x46ab, 0x000d],
[0x46ac, 0x008c],
[0x46ad, 0x0000],
[0x46ae, 0x219c],
[0x46af, 0x0014],
[0x46b0, 0x008c],
[0x46b1, 0x0000],
[0x46b2, 0x219c],
[0x46b3, 0x0015],
[0x46b4, 0x008c],
[0x46b5, 0x0000],
[0x46b6, 0x219c],
[0x46b7, 0x0016],
[0x46b8, 0x008c],
[0x46b9, 0x0000],
[0x46ba, 0x219c],
[0x46bb, 0x0017],
[0x46bc, 0x008c],
[0x46bd, 0x0000],
[0x46be, 0x011c],
[0x46bf, 0x0010],
[0x46c0, 0x219c],
[0x46c1, 0x0004],
[0x46c2, 0x008c],
[0x46c3, 0x0000],
[0x46c4, 0x219c],
[0x46c5, 0x0009],
[0x46c6, 0x008c],
[0x46c7, 0x0000],
[0x46c8, 0x219c],
[0x46c9, 0x000e],
[0x46ca, 0x008c],
[0x46cb, 0x0000],
[0x46cc, 0x219c],
[0x46cd, 0x0013],
[0x46ce, 0x008c],
[0x46cf, 0x0000],
[0x46d0, 0x219c],
[0x46d1, 0x0018],
[0x46d2, 0x008c],
[0x46d3, 0x0000],
[0x46d4, 0x0086],
[0x46d5, 0x0001],
[0x46d6, 0x238c],
[0x46d7, 0xc3dd],
[0x46d8, 0xe38c],
[0x46d9, 0xc300],
[0x46da, 0x011c],
[0x46db, 0x0002],
[0x46dc, 0x2009],
[0x46dd, 0x0004],
[0x46de, 0x004a],
[0x46df, 0x06f8],
[0x46e0, 0x401c],
[0x46e1, 0x2a1e],
[0x46e2, 0x211c],
[0x46e3, 0x0002],
[0x46e4, 0x238c],
[0x46e5, 0xc380],
[0x46e6, 0x211c],
[0x46e7, 0x0003],
[0x46e8, 0x238c],
[0x46e9, 0xc381],
[0x46ea, 0x0086],
[0x46eb, 0x0000],
[0x46ec, 0x6101],
[0x46ed, 0x0004],
[0x46ee, 0x0594],
[0x46ef, 0x000d],
[0x46f0, 0x008c],
[0x46f1, 0xc382],
[0x46f2, 0x2081],
[0x46f3, 0x0001],
[0x46f4, 0x0089],
[0x46f5, 0x0031],
[0x46f6, 0x000a],
[0x46f7, 0x06ee],
[0x46f8, 0x039c],
[0x46f9, 0x0000],
[0x46fa, 0x401c],
[0x46fb, 0x2a10],
[0x46fc, 0x011c],
[0x46fd, 0x0003],
[0x46fe, 0x0029],
[0x46ff, 0x0801],
[0x4700, 0x038c],
[0x4701, 0xc300],
[0x4702, 0x0006],
[0x4703, 0x0002],
[0x4704, 0x038c],
[0x4705, 0xc033],
[0x4706, 0x0006],
[0x4707, 0x0010],
[0x4708, 0x038c],
[0x4709, 0xc032],
[0x470a, 0x011c],
[0x470b, 0x0007],
[0x470c, 0x038c],
[0x470d, 0xc084],
[0x470e, 0x038c],
[0x470f, 0xc085],
[0x4710, 0x011c],
[0x4711, 0x0008],
[0x4712, 0x038c],
[0x4713, 0xc054],
[0x4714, 0x639c],
[0x4715, 0xc731],
[0x4716, 0x0086],
[0x4717, 0x1f1f],
[0x4718, 0x238c],
[0x4719, 0xc731],
[0x471a, 0xe38c],
[0x471b, 0xc75e],
[0x471c, 0xe38c],
[0x471d, 0xc730],
[0x471e, 0x638c],
[0x471f, 0xc731],
[0x4720, 0x011c],
[0x4721, 0x000b],
[0x4722, 0x038c],
[0x4723, 0x000d],
[0x4724, 0x038c],
[0x4725, 0xc75e],
[0x4726, 0x011c],
[0x4727, 0x000c],
[0x4728, 0x038c],
[0x4729, 0x000e],
[0x472a, 0x038c],
[0x472b, 0xc730],
[0x472c, 0x0055],
[0x472d, 0x0055],
[0x472e, 0x0006],
[0x472f, 0x0740],
[0x4730, 0x0086],
[0x4731, 0x0001],
[0x4732, 0x0408],
[0x4733, 0x000d],
[0x4734, 0x0042],
[0x4735, 0x0732],
[0x4736, 0x039c],
[0x4737, 0x000f],
[0x4738, 0x2009],
[0x4739, 0x0001],
[0x473a, 0x0002],
[0x473b, 0x0592],
[0x473c, 0x2009],
[0x473d, 0x0002],
[0x473e, 0x0002],
[0x473f, 0x0750],
[0x4740, 0x039c],
[0x4741, 0x2a00],
[0x4742, 0x1c08],
[0x4743, 0x000d],
[0x4744, 0x0002],
[0x4745, 0x074e],
[0x4746, 0xe38c],
[0x4747, 0x2a00],
[0x4748, 0x001b],
[0x4749, 0x05de],
[0x474a, 0x8086],
[0x474b, 0x0002],
[0x474c, 0x001b],
[0x474d, 0x0624],
[0x474e, 0x0035],
[0x474f, 0x000d],
[0x4750, 0x038c],
[0x4751, 0x0034],
[0x4752, 0x0006],
[0x4753, 0x0004],
[0x4754, 0x038c],
[0x4755, 0xc431],
[0x4756, 0x0006],
[0x4757, 0x0000],
[0x4758, 0x038c],
[0x4759, 0xc423],
[0x475a, 0x0006],
[0x475b, 0x0020],
[0x475c, 0x038c],
[0x475d, 0xc426],
[0x475e, 0x0006],
[0x475f, 0x0002],
[0x4760, 0x038c],
[0x4761, 0xc427],
[0x4762, 0x0006],
[0x4763, 0x003c],
[0x4764, 0x038c],
[0x4765, 0xc4c0],
[0x4766, 0x0006],
[0x4767, 0x003c],
[0x4768, 0x038c],
[0x4769, 0xc4c3],
[0x476a, 0x0006],
[0x476b, 0x0003],
[0x476c, 0x038c],
[0x476d, 0xc4d5],
[0x476e, 0x0006],
[0x476f, 0x0000],
[0x4770, 0x038c],
[0x4771, 0xc4da],
[0x4772, 0x0006],
[0x4773, 0x0001],
[0x4774, 0x038c],
[0x4775, 0xc4d7],
[0x4776, 0x0006],
[0x4777, 0x0001],
[0x4778, 0x038c],
[0x4779, 0xc4f0],
[0x477a, 0x039c],
[0x477b, 0x0034],
[0x477c, 0x000b],
[0x477d, 0x0592],
[0x477e, 0x038c],
[0x477f, 0x0034],
[0x4780, 0x0006],
[0x4781, 0x001c],
[0x4782, 0x038c],
[0x4783, 0xc4c0],
[0x4784, 0x0006],
[0x4785, 0x001c],
[0x4786, 0x038c],
[0x4787, 0xc4c3],
[0x4788, 0x0006],
[0x4789, 0x0000],
[0x478a, 0x038c],
[0x478b, 0xc4d7],
[0x478c, 0x0006],
[0x478d, 0x0002],
[0x478e, 0x038c],
[0x478f, 0xc4d5],
[0x4790, 0x0006],
[0x4791, 0x0001],
[0x4792, 0x038c],
[0x4793, 0xc4da],
[0x4794, 0x0006],
[0x4795, 0x0000],
[0x4796, 0x038c],
[0x4797, 0xc4f0],
[0x4798, 0x0006],
[0x4799, 0x0003],
[0x479a, 0x038c],
[0x479b, 0xc427],
[0x479c, 0x0006],
[0x479d, 0x0001],
[0x479e, 0x038c],
[0x479f, 0xc427],
[0x47a0, 0x0006],
[0x47a1, 0x0000],
[0x47a2, 0x038c],
[0x47a3, 0xc427],
[0x47a4, 0x0006],
[0x47a5, 0x0030],
[0x47a6, 0x038c],
[0x47a7, 0xc426],
[0x47a8, 0x0006],
[0x47a9, 0x0010],
[0x47aa, 0x038c],
[0x47ab, 0xc426],
[0x47ac, 0x0006],
[0x47ad, 0x0000],
[0x47ae, 0x038c],
[0x47af, 0xc426],
[0x47b0, 0x0006],
[0x47b1, 0x0080],
[0x47b2, 0x038c],
[0x47b3, 0xc423],
[0x47b4, 0x0006],
[0x47b5, 0x0080],
[0x47b6, 0x038c],
[0x47b7, 0xc431],
[0x47b8, 0x039c],
[0x47b9, 0x0034],
[0x47ba, 0x0055],
[0x40e6, 0x02f0],
[0x414e, 0x02f0],
[0x48e0, 0x0210],
[0x41a6, 0x02f0],
[0x420e, 0x02f0],
[0x49fa, 0x0210],
[0x4266, 0x02f0],
[0x42ce, 0x02f0],
[0x4b12, 0x0210],
[0x4118, 0x0064],
[0x483c, 0x0064],
[0x4124, 0x0064],
[0x4860, 0x0064],
[0x412a, 0x0064],
[0x4872, 0x0064],
[0x4136, 0x0064],
[0x4896, 0x0064],
[0x413c, 0x0064],
[0x48a8, 0x0064],
[0x40bc, 0x0064],
[0x4106, 0x01ff],
[0x4806, 0x01ff],
[0x41d8, 0x0064],
[0x4956, 0x0064],
[0x41e4, 0x0064],
[0x497a, 0x0064],
[0x41ea, 0x0064],
[0x498c, 0x0064],
[0x41f6, 0x0064],
[0x49b0, 0x0064],
[0x41fc, 0x0064],
[0x49c2, 0x0064],
[0x417c, 0x0064],
[0x41c6, 0x01ff],
[0x4920, 0x01ff],
[0x4298, 0x0064],
[0x4a6e, 0x0064],
[0x42a4, 0x0064],
[0x4a92, 0x0064],
[0x42aa, 0x0064],
[0x4aa4, 0x0064],
[0x42b6, 0x0064],
[0x4ac8, 0x0064],
[0x42bc, 0x0064],
[0x4ada, 0x0064],
[0x423c, 0x0064],
[0x4286, 0x01ff],
[0x4a38, 0x01ff],
[0x6b80, 0x0050],
[0x6b81, 0x0010],
[0x6b82, 0x0000],
[0x6b83, 0x0000],
[0x6b84, 0x001e],
[0x6b85, 0x0320],
[0x6b86, 0x0279],
[0x6b87, 0x0011],
[0x6b88, 0x476e],
[0x6b89, 0x0000],
[0x6b8a, 0x0000],
[0x6b8b, 0x0011],
[0x6b8c, 0x1111],
[0x6b8d, 0x3c6c],
[0x6b8e, 0x6c1c],
[0x6b8f, 0x0000],
[0x6b90, 0x5a60],
[0x6b91, 0x5a60],
[0x6b92, 0x5a60],
[0x6b93, 0x0000],
[0x6b94, 0x0000],
[0x6b95, 0x0000],
[0x6b96, 0x0000],
[0x6b97, 0x0000],
[0x6b98, 0x0000],
[0x6b99, 0x0000],
[0x6b9a, 0x0000],
[0x6b9b, 0x0000],
[0x6b9c, 0x0118],
[0x6b9d, 0x083c],
[0x6b9e, 0x0124],
[0x6b9f, 0x0860],
[0x6ba0, 0x012a],
[0x6ba1, 0x0872],
[0x6ba2, 0x0136],
[0x6ba3, 0x0896],
[0x6ba4, 0x013c],
[0x6ba5, 0x08a8],
[0x6ba6, 0x00bc],
[0x6ba7, 0x082e],
[0x6ba8, 0x082f],
[0x6ba9, 0x0830],
[0x6baa, 0x0831],
[0x6bab, 0x0832],
[0x6bac, 0x0852],
[0x6bad, 0x0853],
[0x6bae, 0x0854],
[0x6baf, 0x0855],
[0x6bb0, 0x0856],
[0x6bb1, 0x0864],
[0x6bb2, 0x0865],
[0x6bb3, 0x0866],
[0x6bb4, 0x0867],
[0x6bb5, 0x0868],
[0x6bb6, 0x0888],
[0x6bb7, 0x0889],
[0x6bb8, 0x088a],
[0x6bb9, 0x088b],
[0x6bba, 0x088c],
[0x6bbb, 0x089a],
[0x6bbc, 0x089b],
[0x6bbd, 0x089c],
[0x6bbe, 0x089d],
[0x6bbf, 0x089e],
[0x6bc0, 0x005a],
[0x6bc1, 0x0010],
[0x6bc2, 0x0001],
[0x6bc3, 0x0002],
[0x6bc4, 0x001e],
[0x6bc5, 0x0384],
[0x6bc6, 0x02c1],
[0x6bc7, 0x0011],
[0x6bc8, 0x476e],
[0x6bc9, 0x0000],
[0x6bca, 0x0000],
[0x6bcb, 0x0011],
[0x6bcc, 0x1111],
[0x6bcd, 0x0228],
[0x6bce, 0x284e],
[0x6bcf, 0x4e74],
[0x6bd0, 0x1c1c],
[0x6bd1, 0x1c1c],
[0x6bd2, 0x1c1c],
[0x6bd3, 0x0000],
[0x6bd4, 0x0000],
[0x6bd5, 0x0000],
[0x6bd6, 0x0000],
[0x6bd7, 0x0000],
[0x6bd8, 0x0000],
[0x6bd9, 0x0000],
[0x6bda, 0x0000],
[0x6bdb, 0x0000],
[0x6bdc, 0x01d8],
[0x6bdd, 0x0956],
[0x6bde, 0x01e4],
[0x6bdf, 0x097a],
[0x6be0, 0x01ea],
[0x6be1, 0x098c],
[0x6be2, 0x01f6],
[0x6be3, 0x09b0],
[0x6be4, 0x01fc],
[0x6be5, 0x09c2],
[0x6be6, 0x017c],
[0x6be7, 0x0948],
[0x6be8, 0x0949],
[0x6be9, 0x094a],
[0x6bea, 0x094b],
[0x6beb, 0x094c],
[0x6bec, 0x096c],
[0x6bed, 0x096d],
[0x6bee, 0x096e],
[0x6bef, 0x096f],
[0x6bf0, 0x0970],
[0x6bf1, 0x097e],
[0x6bf2, 0x097f],
[0x6bf3, 0x0980],
[0x6bf4, 0x0981],
[0x6bf5, 0x0982],
[0x6bf6, 0x09a2],
[0x6bf7, 0x09a3],
[0x6bf8, 0x09a4],
[0x6bf9, 0x09a5],
[0x6bfa, 0x09a6],
[0x6bfb, 0x09b4],
[0x6bfc, 0x09b5],
[0x6bfd, 0x09b6],
[0x6bfe, 0x09b7],
[0x6bff, 0x09b8],
[0x6c00, 0x005a],
[0x6c01, 0x0010],
[0x6c02, 0x0001],
[0x6c03, 0x0002],
[0x6c04, 0x001e],
[0x6c05, 0x0384],
[0x6c06, 0x02c1],
[0x6c07, 0x0011],
[0x6c08, 0x476e],
[0x6c09, 0x0000],
[0x6c0a, 0x0000],
[0x6c0b, 0x0011],
[0x6c0c, 0x1111],
[0x6c0d, 0x0228],
[0x6c0e, 0x284e],
[0x6c0f, 0x4e74],
[0x6c10, 0x1c1c],
[0x6c11, 0x1c1c],
[0x6c12, 0x1c1c],
[0x6c13, 0x0000],
[0x6c14, 0x0000],
[0x6c15, 0x0000],
[0x6c16, 0x0000],
[0x6c17, 0x0000],
[0x6c18, 0x0000],
[0x6c19, 0x0000],
[0x6c1a, 0x0000],
[0x6c1b, 0x0000],
[0x6c1c, 0x0298],
[0x6c1d, 0x0a6e],
[0x6c1e, 0x02a4],
[0x6c1f, 0x0a92],
[0x6c20, 0x02aa],
[0x6c21, 0x0aa4],
[0x6c22, 0x02b6],
[0x6c23, 0x0ac8],
[0x6c24, 0x02bc],
[0x6c25, 0x0ada],
[0x6c26, 0x023c],
[0x6c27, 0x0a60],
[0x6c28, 0x0a61],
[0x6c29, 0x0a62],
[0x6c2a, 0x0a63],
[0x6c2b, 0x0a64],
[0x6c2c, 0x0a84],
[0x6c2d, 0x0a85],
[0x6c2e, 0x0a86],
[0x6c2f, 0x0a87],
[0x6c30, 0x0a88],
[0x6c31, 0x0a96],
[0x6c32, 0x0a97],
[0x6c33, 0x0a98],
[0x6c34, 0x0a99],
[0x6c35, 0x0a9a],
[0x6c36, 0x0aba],
[0x6c37, 0x0abb],
[0x6c38, 0x0abc],
[0x6c39, 0x0abd],
[0x6c3a, 0x0abe],
[0x6c3b, 0x0acc],
[0x6c3c, 0x0acd],
[0x6c3d, 0x0ace],
[0x6c3e, 0x0acf],
[0x6c3f, 0x0ad0],
[0x6a80, 0x0000],
[0x6a81, 0x0000],
[0x6a82, 0x0000],
[0x6a83, 0x0400],
[0x6a84, 0xf7ab],
[0x6a85, 0xf7c8],
[0x6a86, 0xf7e6],
[0x6a87, 0xf803],
[0x6a88, 0xf821],
[0x6a89, 0xf85c],
[0x6a8a, 0xf897],
[0x6a8b, 0xf8d2],
[0x6a8c, 0xf90d],
[0x6a8d, 0xf983],
[0x6a8e, 0xf9fa],
[0x6a8f, 0xfa6f],
[0x6a90, 0xfae5],
[0x6a91, 0xfb7f],
[0x6a92, 0xfc15],
[0x6a93, 0xfc9b],
[0x6a94, 0xfd0e],
[0x6a95, 0xfd57],
[0x6a96, 0xfdb2],
[0x6a97, 0xfde4],
[0x6a98, 0xfe12],
[0x6a99, 0xfe3f],
[0x6a9a, 0xfe6b],
[0x6a9b, 0xfe95],
[0x6a9c, 0xfebf],
[0x6a9d, 0xfee8],
[0x6a9e, 0xff18],
[0x6a9f, 0xff49],
[0x6aa0, 0xff78],
[0x6aa1, 0xffa7],
[0x6aa2, 0xffd5],
[0x6aa3, 0x0054],
[0x6aa4, 0x00da],
[0x6aa5, 0x0165],
[0x6aa6, 0x021a],
[0x6aa7, 0x02d7],
[0x6aa8, 0x0389],
[0x6aa9, 0x045c],
[0x6aaa, 0x054a],
[0x6aab, 0x0638],
[0x6aac, 0x0726],
[0x6aad, 0x079d],
[0x6aae, 0x0814],
[0x6aaf, 0x088b],
[0x6ab0, 0x0902],
[0x6ab1, 0x093d],
[0x6ab2, 0x0979],
[0x6ab3, 0x09b4],
[0x6ab4, 0x09ef],
[0x6ab5, 0x0000],
[0x6ab6, 0x0000],
[0x6ab7, 0x0000],
[0x6ab8, 0x0000],
[0x6ab9, 0x0000],
[0x6aba, 0x0000],
[0x6abb, 0x0000],
[0x6abc, 0x0000],
[0x6abd, 0x0000],
[0x6abe, 0x0000],
[0x6abf, 0x0000],
[0x6ac0, 0x0000],
[0x6ac1, 0x0000],
[0x6ac2, 0x0000],
[0x6ac3, 0x0400],
[0x6ac4, 0xfce9],
[0x6ac5, 0xfcf6],
[0x6ac6, 0xfd04],
[0x6ac7, 0xfd12],
[0x6ac8, 0xfd20],
[0x6ac9, 0xfd3b],
[0x6aca, 0xfd57],
[0x6acb, 0xfd72],
[0x6acc, 0xfd8d],
[0x6acd, 0xfdbf],
[0x6ace, 0xfdd7],
[0x6acf, 0xfdf4],
[0x6ad0, 0xfe17],
[0x6ad1, 0xfe34],
[0x6ad2, 0xfe46],
[0x6ad3, 0xfe61],
[0x6ad4, 0xfeb3],
[0x6ad5, 0xff2d],
[0x6ad6, 0xffa7],
[0x6ad7, 0xfff0],
[0x6ad8, 0x0051],
[0x6ad9, 0x0065],
[0x6ada, 0x003f],
[0x6adb, 0x0015],
[0x6adc, 0xffa4],
[0x6add, 0xff34],
[0x6ade, 0xfec4],
[0x6adf, 0xfe60],
[0x6ae0, 0xfe25],
[0x6ae1, 0xfdea],
[0x6ae2, 0xfdc9],
[0x6ae3, 0xfdc8],
[0x6ae4, 0xfdd2],
[0x6ae5, 0xfde3],
[0x6ae6, 0xfdfe],
[0x6ae7, 0xfe10],
[0x6ae8, 0xfe2c],
[0x6ae9, 0xfe5c],
[0x6aea, 0xfea7],
[0x6aeb, 0xff21],
[0x6aec, 0xffb4],
[0x6aed, 0x0006],
[0x6aee, 0x0058],
[0x6aef, 0x00a9],
[0x6af0, 0x00fb],
[0x6af1, 0x0124],
[0x6af2, 0x014d],
[0x6af3, 0x0176],
[0x6af4, 0x019f],
[0x6af5, 0x0000],
[0x6af6, 0x0000],
[0x6af7, 0x0000],
[0x6af8, 0x0000],
[0x6af9, 0x0000],
[0x6afa, 0x0000],
[0x6afb, 0x0000],
[0x6afc, 0x0000],
[0x6afd, 0x0000],
[0x6afe, 0x0000],
[0x6aff, 0x0000],
[0xc75d, 0x0000],
[0xc75f, 0x0022],
[0xc73d, 0x0003],
[0xc739, 0x0022],
[0xc750, 0x0640],
[0xc751, 0x0640],
[0xc752, 0x0640],
[0xc753, 0x0640],
[0xc754, 0x0640],
[0xc73b, 0x0000],
[0xc731, 0x1010],
[0xc75e, 0x0000],
[0xc730, 0x0000],
[0x7c0b, 0x00ff],
[0x7d05, 0x0001],
[0x7c07, 0x0000],
[0x7ce2, 0x00ff],
[0xc07f, 0x0000],
[0xc080, 0xffff],
[0xc081, 0xffff],
[0xc082, 0xffff],
[0xc083, 0xffff],
[0xc084, 0x0011],
[0xc085, 0x0011],
[0xc086, 0x0011],
[0xc087, 0xffff],
[0xc08f, 0x0000],
[0xc087, 0x00cf],
[0xc086, 0x0011],
[0xc08e, 0x000c],
[0x7c32, 0x0002],
[0x7c20, 0xffff],
[0x7d00, 0x0002],
[0x4000, 0x0001],
[0x7c22, 0x0000],
[0x7c21, 0x0000],
[0x7c20, 0xfffb],
[0x7c22, 0x0004],
[0xc020, 0x1167],
[0xc028, 0x00f1],
[0xc100, 0x0077],
[0xc101, 0x0077],
[0xc102, 0x0077],
[0xc103, 0x0077],
[0xc104, 0x0000],
[0xc105, 0x0000],
[0xc106, 0x0000],
[0xc107, 0x0000],
[0xc108, 0x00ff],
[0xc109, 0x00ff],
[0xc10a, 0x00ff],
[0xc10b, 0x00ff],
[0xc10c, 0x00ff],
[0xc10d, 0x00ff],
[0xc10e, 0x00ff],
[0xc10f, 0x00ff],
[0xc070, 0x0101],
[0xc071, 0x0303],
[0xc072, 0x0504],
[0xc073, 0x0706],
[0xc074, 0x0200],
[0xc075, 0x0504],
[0xc076, 0x0706],
[0xc077, 0x0908],
[0xc078, 0x110a],
[0xc079, 0x1312],
[0xc300, 0xcccc],
[0xc301, 0x0121],
[0xc302, 0x0120],
[0xc303, 0x010c],
[0xc304, 0x0104],
[0xc305, 0x0064],
[0xc306, 0x0024],
[0xc307, 0x0040],
[0xc308, 0x0000],
[0xc309, 0x0400],
[0xc30a, 0x0000],
[0xc30b, 0x0000],
[0xc30c, 0x0fff],
[0xc30d, 0x0000],
[0xc30e, 0x0000],
[0xc30f, 0x0000],
[0xc310, 0xfc20],
[0xc311, 0x0000],
[0xc312, 0x0000],
[0xc313, 0x0000],
[0xc314, 0x0000],
[0xc315, 0x0000],
[0xc316, 0x0f80],
[0xc317, 0x0000],
[0xc318, 0x0fff],
[0xc319, 0x0fff],
[0xc31a, 0x0fff],
[0xc31b, 0x0fff],
[0xc31c, 0x0fff],
[0xc31d, 0x0fff],
[0xc31e, 0x0fff],
[0xc31f, 0x0fff],
[0xc320, 0x0fff],
[0xc321, 0x0fff],
[0xc322, 0x0fff],
[0xc323, 0x0fff],
[0xc324, 0x03a0],
[0xc325, 0x01f1],
[0xc326, 0x029a],
[0xc327, 0x0000],
[0xc328, 0x0fff],
[0xc329, 0x0400],
[0xc32a, 0x0000],
[0xc32b, 0x0003],
[0xc32c, 0x0004],
[0xc32d, 0x0005],
[0xc32e, 0x0005],
[0xc32f, 0x0006],
[0xc330, 0x0008],
[0xc331, 0x0009],
[0xc332, 0x000a],
[0xc333, 0x000b],
[0xc334, 0x000d],
[0xc335, 0x0010],
[0xc336, 0x0012],
[0xc337, 0x0014],
[0xc338, 0x0003],
[0xc339, 0x0004],
[0xc33a, 0x0005],
[0xc33b, 0x0005],
[0xc33c, 0x0006],
[0xc33d, 0x0008],
[0xc33e, 0x0009],
[0xc33f, 0x000a],
[0xc340, 0x000b],
[0xc341, 0x000d],
[0xc342, 0x0010],
[0xc343, 0x0012],
[0xc344, 0x0014],
[0xc345, 0x0401],
[0xc346, 0x3e00],
[0xc347, 0x7777],
[0xc348, 0x8888],
[0xc349, 0xbaa9],
[0xc34a, 0x8064],
[0xc34b, 0x0000],
[0xc34c, 0x0000],
[0xc34d, 0x0100],
[0xc34e, 0x0000],
[0xc34f, 0x000f],
[0xc350, 0x0100],
[0xc351, 0x0000],
[0xc352, 0x000f],
[0xc371, 0x1100],
[0xc372, 0x9990],
[0xc373, 0x9999],
[0xc374, 0x0009],
[0xc375, 0x0000],
[0xc376, 0x00ae],
[0xc377, 0x00ae],
[0xc378, 0x00a4],
[0xc379, 0x008f],
[0xc37a, 0x007b],
[0xc37b, 0x0066],
[0xc37c, 0x0048],
[0xc37d, 0x0048],
[0xc37e, 0x0000],
[0xc37f, 0x2000],
[0xc380, 0x0000],
[0xc381, 0x0400],
[0xc382, 0x0000],
[0xc383, 0x0000],
[0xc384, 0x0000],
[0xc385, 0x0000],
[0xc386, 0x0000],
[0xc387, 0x0000],
[0xc388, 0x0000],
[0xc389, 0x0000],
[0xc38a, 0x0000],
[0xc38b, 0x0000],
[0xc38c, 0x0000],
[0xc38d, 0x0000],
[0xc38e, 0x0000],
[0xc38f, 0x0000],
[0xc390, 0x0000],
[0xc391, 0x0000],
[0xc392, 0x0000],
[0xc393, 0x0000],
[0xc394, 0x0000],
[0xc395, 0x0000],
[0xc396, 0x0000],
[0xc397, 0x0000],
[0xc398, 0x0000],
[0xc399, 0x0000],
[0xc39a, 0x0000],
[0xc39b, 0x0000],
[0xc39c, 0x0000],
[0xc39d, 0x0000],
[0xc39e, 0x0000],
[0xc39f, 0x0000],
[0xc3a0, 0x0000],
[0xc3a1, 0x0000],
[0xc3a2, 0x0000],
[0xc3a3, 0x0000],
[0xc3a4, 0x0000],
[0xc3a5, 0x0000],
[0xc3a6, 0x0000],
[0xc3a7, 0x0000],
[0xc3a8, 0x0000],
[0xc3a9, 0x0000],
[0xc3aa, 0x0000],
[0xc3ab, 0x0000],
[0xc3ac, 0x0000],
[0xc3ad, 0x0000],
[0xc3ae, 0x0000],
[0xc3af, 0x0000],
[0xc3b0, 0x0000],
[0xc3b1, 0x0000],
[0xc3b2, 0x0000],
[0xc3b3, 0x0000],
[0xc3b4, 0x7777],
[0xc3b5, 0x8888],
[0xc3b6, 0x9999],
[0xc3b7, 0x9999],
[0xc3b8, 0x8899],
[0xc3b9, 0x8888],
[0xc3ba, 0x8888],
[0xc3bb, 0x9988],
[0xc3bc, 0x9999],
[0xc3bd, 0x9999],
[0xc3be, 0x8888],
[0xc3bf, 0x7777],
[0xc3c0, 0x0000],
[0xc3c1, 0x0000],
[0xc3c2, 0x7777],
[0xc3c3, 0x7777],
[0xc3c4, 0x7777],
[0xc3c5, 0x7777],
[0xc3c6, 0x0000],
[0xc3c7, 0x7777],
[0xc3c8, 0x7777],
[0xc3c9, 0x0777],
[0xc3ca, 0x02f1],
[0xc3cb, 0x0000],
[0xc3cc, 0x030e],
[0xc3cd, 0x0000],
[0xc3ce, 0x039e],
[0xc3cf, 0x0109],
[0xc3d0, 0x029a],
[0xc3d1, 0x0001],
[0xc3d2, 0x01e0],
[0xc3d3, 0x0000],
[0xc3d4, 0x0000],
[0xc3d5, 0x0280],
[0xc3d6, 0x0000],
[0xc3d7, 0x0000],
[0xc3d8, 0x0000],
[0xc3d9, 0x0000],
[0xc353, 0x0010],
[0xc354, 0x0010],
[0xc355, 0x0010],
[0xc3e8, 0x0015],
[0xc36e, 0x8766],
[0xc36f, 0x9988],
[0xc370, 0xba99],
[0xc3e9, 0x170c],
[0xc3ea, 0x2d20],
[0xc3eb, 0x4e40],
[0xc3ec, 0x6f5b],
[0xc3ed, 0x8f80],
[0xc3ee, 0xb59d],
[0xc3ef, 0x00de],
[0xc356, 0x0000],
[0xc3e6, 0x1000],
[0xc3e7, 0x0000],
[0xc371, 0x1100],
[0xc3db, 0x0000],
[0xc3e0, 0x0000],
[0xc3e1, 0x0000],
[0xc3e2, 0x0280],
[0xc3e3, 0x01e0],
[0xc360, 0x0000],
[0xc361, 0x0000],
[0xc362, 0x0000],
[0xc363, 0x0000],
[0xc364, 0x0000],
[0xc365, 0x0000],
[0xc366, 0x0000],
[0xc367, 0x0000],
[0xc368, 0x0000],
[0xc369, 0x0000],
[0xc36a, 0x0000],
[0xc36b, 0x0000],
[0xc3da, 0x0007],
[0xc3db, 0x0000],
[0xc3dc, 0x00e0],
[0xc3de, 0x0000],
[0xc3df, 0x0000],
[0xc08f, 0x0040],
[0xc087, 0x0027],
[0xc300, 0x0803],
[0xc033, 0x0002],
[0xc032, 0x0010],
[0x4001, 0x0007],
[0x7c22, 0x0004]
]
__stream_off = [
[0x4001, 0x0006],
[0x7c22, 0x0004],
[0xC431, 0x0082],
[0xC423, 0x0000],
[0xC426, 0x0020],
[0xC427, 0x0002],
[0xC4C0, 0x003C],
[0xC4C3, 0x003C],
[0xC4D5, 0x0003],
[0xC4DA, 0x0000],
[0xC4D7, 0x0001],
[0xC4F0, 0x0001],
]
class axi_iic:
_ffi = cffi.FFI()
def __init__(self, axi_iic, dev_addr):
self._iic_dev = AxiIIC(axi_iic)
self._iic_dev_addr = dev_addr
def set_device_addr(self, addr):
self._iic_dev_addr = addr
def write(self, reg, data):
buf = self._ffi.new("unsigned char [4]")
buf[0] = (reg >> 8) & 0xFF
buf[1] = reg & 0xFF
buf[2] = (data >> 8) & 0xFF
buf[3] = data & 0xFF
self._iic_dev.send(self._iic_dev_addr, buf, 3, option=0)
def read(self, reg):
buf = self._ffi.new("unsigned char [2]")
buf[0] = (reg >> 8) & 0xFF
buf[1] = reg & 0xFF
self._iic_dev.send(self._iic_dev_addr, buf, 2, option=0)
self._iic_dev.receive(self._iic_dev_addr, buf, 2, option=0)
return ((buf[0] << 8) | buf[1])
def __init__(self, device):
self._iic = self.axi_iic(device, self.__iic_device_addr)
self.__init()
self.set_mode(0)
pass
def __init(self):
self.set_mode(0);
for val in self.__stream_on_2:
self._iic.write(val[0], val[1])
def set_mode(self, mode):
self._iic.write(0x4000, mode)
self._iic.write(0x4001, 0x0004)
self._iic.write(0x7c22, 0x0004)
class video_pipeline:
class hls_filter:
def __init__(self, device):
self._device = device
self._device.write(0x00, 0x81)
class demosaic:
def __init__(self, device):
self._device = device
self._device.write(0x10, 640)
self._device.write(0x18, 480)
self._device.write(0x28, 3)
self._device.write(0x00, 0x81)
def __init__(self, overlay):
self._demosaic = self.demosaic(overlay.demosaic)
self._hls_filter = self.hls_filter(overlay.sobel_0)
overlay = Overlay("kv260.bit", dtbo="./devicetree.dtbo", ignore_version=True)
iic = overlay.axi_iic_0
buf = _ffi.new("unsigned char [1]")
buf = 4
iic.send(0x74, 4, 1, option=0)
camera = tof(overlay.ip_dict['axi_iic_0'])
vdma = overlay.vdma
frameMode = VideoMode(640, 480, 24)
vdma.readchannel.reset()
vdma.readchannel.mode = frameMode
vdma.readchannel.start()
image = vdma.readchannel.readframe()Devicetree:
/dts-v1/;
/plugin/;
/ {
fragment@0 {
target-path="/amba";
__overlay__ {
#address-cells = <0x02>;
#size-cells = <0x02>;
mipi_clk: mipi_clk {
compatible = "fixed-clock";
#clock-cells = <0>;
clock-frequency = <0x16e3600>;
};
axi_intc: interrupt-controller@a0010000 {
#interrupt-cells = <2>;
clock-names = "s_axi_aclk";
clocks = <&zynqmp_clk 71>;
compatible = "xlnx,xps-intc-1.00.a";
interrupt-controller ;
interrupt-parent = <&gic>;
interrupts = <0 34 4>;
reg = <0x0 0xa0010000 0x0 0x10000>;
xlnx,kind-of-intr = <0x0>;
xlnx,num-intr-inputs = <0x8>;
};
axi_iic: i2c@a0060000 {
#address-cells = <1>;
#size-cells = <0>;
clock-frequency = <1000000>;
clock-names = "s_axi_aclk";
clocks = <&zynqmp_clk 71>;
compatible = "xlnx,xps-iic-2.00.a";
interrupt-names = "iic2intc_irpt";
interrupt-parent = <&gic>;
interrupts = <0 0 4>;
reg = <0x0 0xa0060000 0x0 0x10000>;
i2c-mux@74 {
#address-cells = <0x01>;
#size-cells = <0x00>;
compatible = "nxp,pca9546";
reg = <0x74>;
i2c@0 {
#address-cells = <0x01>;
#size-cells = <0x00>;
reg = <0x00>;
};
i2c@1 {
#address-cells = <0x01>;
#size-cells = <0x00>;
reg = <0x01>;
};
i2c@2 {
#address-cells = <0x01>;
#size-cells = <0x00>;
label = "RPICAM";
reg = <0x02>;
};
};
};
};4. HOG
Local object appearance and shape can often be characterized rather well by the distribution of local intensity gradients or edge directions, even without precise knowledge of the corresponding gradient or edge positions. In practice this is implemented by dividing the image window into small spatial regions (“cells”), for each cell accumulating a local 1-D histogram of gradient directions or edge orientations over the pixels of the cell. The combined histogram entries form the representation. For better invariance to illumination, shadowing, etc., it is also useful to contrast-normalize the local responses before using them. This can be done by accumulating a measure of local histogram “energy” over somewhat larger spatial regions (“blocks”) and using the results to normalize all of the cells in the block. We will refer to the normalized descriptor blocks as Histogram of Oriented Gradient (HOG) descriptors.
The computation of the HOG features is divided in the following steps:
- Preprocessing
- Computation of the gradients using the Sobel filter
- Gradient distribution in 8x8 cells (HOG)
- Block normalization
- Matrix flattening
1) Preprocessing: Before computing the histogram of oriented gradients, the image has to be cropped to the point of maximum interest and resized in order to comply with the HOG’s parameters.
2) Computation of the gradients: Prior to the HOG descriptor, an image filter needs to be applied to reduce noise and unnecessary information from the image. In this application, the Sobel filter is applied, resulting two output matrices: the gradients of angle and magnitude. Now, each pixel in the image has a corresponding intensity and direction.
3) Gradient distribution: The window is divided into adjacent, non-overlapping cells of size CxC pixels (C = 8). In each cell, a histogram of the gradient orientations binned into B bins (B = 9) is computed. With so few bins, a pixel whose orientation is close to a bin boundary might end up contributing to a different bin, were the image to change slightly. To prevent these quantization artifacts, each pixel in a cell contributes to two adjacent bins (modulo B) a fraction of the pixel’s gradient magnitude µ that decreases linearly with the distance of that pixel’s gradient orientation from the two bin centers.
4) Block normalization: The block normalization presumes obtaining an enhanced cell as a result of combining multiple other cells. Usually, the block normalization in HOG algorithms is done using a window size of 2x2 cells. This step is mandatory due to the descriptor’s high sensitivity to lighting sources. This lighting dependency can be decreased by applying a norm function on the blocks. One common norm, with a fast implementation, is the L2 norm, also called the Euclidean norm.
5. SVMIn machine learning, support-vector machines (SVMs, also support-vector networks) are supervised learning models with associated learning algorithms that analyze data used for classification and regression analysis. Given a set of training examples, each marked as belonging to one or the other of two categories, an SVM training algorithm builds a model that assigns new examples to one category or the other, making it a non-probabilistic binary linear classifier (although methods such as Platt scaling exist to use SVM in a probabilistic classification setting). An SVM model is a representation of the examples as points in space, mapped so that the examples of the separate categories are divided by a clear gap that is as wide as possible. New examples are then mapped into that same space and predicted to belong to a category based on the side of the gap on which they fall.
6. ImplementationTrain:
from processing import *
from matplotlib.pyplot import *
from hog import *
import cv2
import time
from sklearn.metrics import confusion_matrix, plot_confusion_matrix
from sklearn.feature_extraction.image import PatchExtractor
from skimage import color, data, transform, img_as_ubyte
from sklearn.datasets import fetch_lfw_people
from sklearn import svm
from cv2 import resize
import numpy as np
import pickle
import os
def extract_patches(img, N, scale=1.0, patch_size=(64,64)):
extracted_patch_size = tuple((scale * np.array(patch_size)).astype(int))
extractor = PatchExtractor(patch_size=extracted_patch_size,
max_patches=N, random_state=0)
patches = extractor.transform(img[np.newaxis])
if scale != 1:
patches = np.array([transform.resize(patch, (64,64))
for patch in patches])
return patches
# Window dimensions
w = 64
h = 64
# Use 80% of data to train and the rest to testP
train_data_percent = 80 / 100
if __name__ == "__main__":
faces = fetch_lfw_people()
faces = faces.images
positive_features = np.vstack([hog(nms(sobel(resize(faces[i],(64,64))))) \
for i in range(0, int(faces.shape[0] * train_data_percent))])
print("Loading random image dataset")
labels = ['camera', 'text', 'coins', 'moon', 'page', 'clock', 'coffee']
random_img = [color.rgb2gray(getattr(data, name)()) for name in labels]
not_faces = np.vstack([extract_patches(im, 1000, scale) for im in random_img for scale in [0.5, 1.0, 2.0]])
negative_features = np.vstack([hog(nms(sobel(resize(not_faces[i],(64,64))))) \
for i in range(0, int(not_faces.shape[0] * train_data_percent))])
# Prepare the dataset
data = np.concatenate((positive_features, negative_features))
labels = np.zeros(data.shape[0])
labels[:positive_features.shape[0]] = 1
classifier = svm.SVC()
print("Training the model")
classifier.fit(data, labels)
pickle.dump(classifier, open('face.svm', 'wb'))
classifier = pickle.load(open('face.svm', 'rb'))
print("Testing the model")
print("Computing positive features")
positive_features = np.vstack([hog(nms(sobel(resize(faces[i],(64,64))))) for i in range(int(faces.shape[0] * train_data_percent), faces.shape[0])])
print("Computing negative features")
for i in range(int(not_faces.shape[0] * train_data_percent), not_faces.shape[0])])
negative_features = np.vstack([hog(nms(sobel(resize(not_faces[i],(64,64))))) for i in range(int(not_faces.shape[0] * train_data_percent), not_faces.shape[0])])
# Prepare the dataset
data = np.concatenate((positive_features, negative_features))
labels = np.zeros(data.shape[0])
labels[:positive_features.shape[0]] = 1
predicted = np.zeros(labels.shape[0])
for i in range(0, data.shape[0]):
feature = np.array([data[i]])#np.array([hog(nms(sobel(resize(data[i],(64,64)))))])
result = classifier.predict(feature)
if (result[0] != 0):
predicted[i] = 1
print(confusion_matrix(labels, predicted))
Comments