LinuxTV Patchwork Which epg for Sky UK

login
register
mail settings
Submitter Tony Houghton
Date April 14, 2013, 12:11 p.m.
Message ID <20130414131155.081d3aab@realh.co.uk>
Download mbox | patch
Permalink /patch/17934/
State New
Headers show

Comments

Tony Houghton - April 14, 2013, 12:11 p.m.
On Sun, 14 Apr 2013 00:38:08 +0200
Lucian Muresan <lucianm@users.sourceforge.net> wrote:

> BTW, where is the most current freeview patch?

This is the version I use. I don't know whether its newer/better than
the one Andre posted this morning, but I'm pretty sure the tables in
this one are complete, and they have been embedded into the C code
instead of having to be loaded as separate files.
Teemu Suikki - April 18, 2013, 4:31 p.m.
Hi!

Your patch is slightly broken, perhaps when emailing? There are a few
missing lines in the huffman tables.

I compared these two patches, your version seems to be better
otherwise, but I took the tables from the other patch.. Works fine
now.

However, I have another issue. I need to clone EPG for a few channels.
EEPG and LoadEpg plugins have the .equiv files for this, but this
patch obviously doesn't

I tried copying with epgfixer plugin, which should do the trick.
However, VDR seems to crash always when it's receiving EPG data for
these channels.. So there is some weird incompatibility with epgfixer!
I have been using epgfixer successfully earlier. Perhaps epgfixer gets
unencoded raw data before the huffman decoding? The crash is inside
libc, which would suggest to some string manipulating functions
perhaps..

--
Teemu


2013/4/14 Tony Houghton <h@realh.co.uk>:
> On Sun, 14 Apr 2013 00:38:08 +0200
> Lucian Muresan <lucianm@users.sourceforge.net> wrote:
>
>> BTW, where is the most current freeview patch?
>
> This is the version I use. I don't know whether its newer/better than
> the one Andre posted this morning, but I'm pretty sure the tables in
> this one are complete, and they have been embedded into the C code
> instead of having to be loaded as separate files.
> _______________________________________________
> vdr mailing list
> vdr@linuxtv.org
> http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>
Davide Chiarini - April 19, 2013, 6:17 a.m.
Hi
I made a small perl script to copy epg from one channel to another, just
modifying some other script i had found around.
It's attached if you want to try it, you simply use it like this (e.g. from
a cron job):

cpepg.pl S13.0E-318-12400-8511 T-318-1-3401


regards
davide


2013/4/18 Teemu Suikki <tsuikki@zuik.org>

> Hi!
>
> Your patch is slightly broken, perhaps when emailing? There are a few
> missing lines in the huffman tables.
>
> I compared these two patches, your version seems to be better
> otherwise, but I took the tables from the other patch.. Works fine
> now.
>
> However, I have another issue. I need to clone EPG for a few channels.
> EEPG and LoadEpg plugins have the .equiv files for this, but this
> patch obviously doesn't
>
> I tried copying with epgfixer plugin, which should do the trick.
> However, VDR seems to crash always when it's receiving EPG data for
> these channels.. So there is some weird incompatibility with epgfixer!
> I have been using epgfixer successfully earlier. Perhaps epgfixer gets
> unencoded raw data before the huffman decoding? The crash is inside
> libc, which would suggest to some string manipulating functions
> perhaps..
>
> --
> Teemu
>
>
> 2013/4/14 Tony Houghton <h@realh.co.uk>:
> > On Sun, 14 Apr 2013 00:38:08 +0200
> > Lucian Muresan <lucianm@users.sourceforge.net> wrote:
> >
> >> BTW, where is the most current freeview patch?
> >
> > This is the version I use. I don't know whether its newer/better than
> > the one Andre posted this morning, but I'm pretty sure the tables in
> > this one are complete, and they have been embedded into the C code
> > instead of having to be loaded as separate files.
> > _______________________________________________
> > vdr mailing list
> > vdr@linuxtv.org
> > http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
> >
>
>
>
> --
> Teemu Suikki
> http://www.z-power.fi/
>
> _______________________________________________
> vdr mailing list
> vdr@linuxtv.org
> http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>
Teemu Suikki - April 19, 2013, 6:27 a.m.
Hi!

Thanks a bunch, I guess this is exactly what I need. :)
 19.4.2013 9.19 "Davide Chiarini" <davide.chiarini@gmail.com> kirjoitti:

> Hi
> I made a small perl script to copy epg from one channel to another, just
> modifying some other script i had found around.
> It's attached if you want to try it, you simply use it like this (e.g.
> from a cron job):
>
> cpepg.pl S13.0E-318-12400-8511 T-318-1-3401
>
>
> regards
> davide
>
>
> 2013/4/18 Teemu Suikki <tsuikki@zuik.org>
>
>> Hi!
>>
>> Your patch is slightly broken, perhaps when emailing? There are a few
>> missing lines in the huffman tables.
>>
>> I compared these two patches, your version seems to be better
>> otherwise, but I took the tables from the other patch.. Works fine
>> now.
>>
>> However, I have another issue. I need to clone EPG for a few channels.
>> EEPG and LoadEpg plugins have the .equiv files for this, but this
>> patch obviously doesn't
>>
>> I tried copying with epgfixer plugin, which should do the trick.
>> However, VDR seems to crash always when it's receiving EPG data for
>> these channels.. So there is some weird incompatibility with epgfixer!
>> I have been using epgfixer successfully earlier. Perhaps epgfixer gets
>> unencoded raw data before the huffman decoding? The crash is inside
>> libc, which would suggest to some string manipulating functions
>> perhaps..
>>
>> --
>> Teemu
>>
>>
>> 2013/4/14 Tony Houghton <h@realh.co.uk>:
>> > On Sun, 14 Apr 2013 00:38:08 +0200
>> > Lucian Muresan <lucianm@users.sourceforge.net> wrote:
>> >
>> >> BTW, where is the most current freeview patch?
>> >
>> > This is the version I use. I don't know whether its newer/better than
>> > the one Andre posted this morning, but I'm pretty sure the tables in
>> > this one are complete, and they have been embedded into the C code
>> > instead of having to be loaded as separate files.
>> > _______________________________________________
>> > vdr mailing list
>> > vdr@linuxtv.org
>> > http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>> >
>>
>>
>>
>> --
>> Teemu Suikki
>> http://www.z-power.fi/
>>
>> _______________________________________________
>> vdr mailing list
>> vdr@linuxtv.org
>> http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>>
>
>
> _______________________________________________
> vdr mailing list
> vdr@linuxtv.org
> http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>
>
lukkinosat - April 19, 2013, 6:58 a.m.
Hi Teemu
 
Have you received my email for testing of LoadEPG?
 
http://lukkinosat.altervista.org/vdr-loadepg-0.2.6.tgz
 
- Add comand STOP to SVDRP interface
- Apply patch for correct timezone
 
Hi, Luca
Teemu Suikki - April 19, 2013, 8:24 a.m.
Hi,

I tried it and it seems to work, thanks. :) But I'm not using it right
now, because this VDR patch seems to do the same thing a bit easier..

--
Teemu

2013/4/19 lukkinosat <lukkinosat@yahoo.it>:
> Hi Teemu
>
> Have you received my email for testing of LoadEPG?
>
> http://lukkinosat.altervista.org/vdr-loadepg-0.2.6.tgz
>
> - Add comand STOP to SVDRP interface
> - Apply patch for correct timezone
>
> Hi, Luca
>
> _______________________________________________
> vdr mailing list
> vdr@linuxtv.org
> http://www.linuxtv.org/cgi-bin/mailman/listinfo/vdr
>

Patch

diff -Naur vdr-1.7.27.orig/eit.c vdr-1.7.27/eit.c
--- vdr-1.7.27.orig/eit.c	2012-04-11 19:26:39.849914938 +0200
+++ vdr-1.7.27/eit.c	2012-04-11 19:26:59.830745486 +0200
@@ -349,6 +349,10 @@ 
   Set(0x12, 0x40, 0xC0);  // event info now&next actual/other TS (0x4E/0x4F), future actual/other TS (0x5X/0x6X)
   if (Setup.SetSystemTime && Setup.TimeTransponder)
      Set(0x14, 0x70);     // TDT
+
+  Set(3842, 0x4E, 0xFE);  // event info, actual(0x4E)/other(0x4F) TS, present/following
+  Set(3842, 0x50, 0xF0);  // event info, actual TS, schedule(0x50)/schedule for future days(0x5X)
+  Set(3842, 0x60, 0xF0);  // event info, other  TS, schedule(0x60)/schedule for future days(0x6X)
 }
 
 void cEitFilter::SetDisableUntil(time_t Time)
@@ -365,6 +369,7 @@ 
         return;
      }
   switch (Pid) {
+    case 3842:
     case 0x12: {
          if (Tid >= 0x4E && Tid <= 0x6F) {
             cSchedulesLock SchedulesLock(true, 10);
diff -Naur vdr-1.7.27.orig/libsi/freesat.c vdr-1.7.27/libsi/freesat.c
--- vdr-1.7.27.orig/libsi/freesat.c	1970-01-01 01:00:00.000000000 +0100
+++ vdr-1.7.27/libsi/freesat.c	2012-04-12 15:30:53.672277213 +0200
@@ -0,0 +1,300 @@ 
+/* FreeSat Huffman decoder for VDR
+ *
+ * Insert GPL licence
+ */
+
+/* The following features can be controlled:
+ *
+ * FREESAT_DATA_DIRECTORY   - Directory where the freesat.tX files are stored
+ * FREESAT_ARCHIVE_MESSAGES - Store raw huffman strings in /var/tmp/
+ * FREESAT_PRINT_MISSED_DECODING - Append missed hexcodes to end of string
+ * FREESAT_NO_SYSLOG             - Disable use of isyslog
+ */
+
+#include "freesat.h"
+#include <stdlib.h> 
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+
+#ifndef FREESAT_DATA_DIRECTORY
+#define FREESAT_DATA_DIRECTORY       "/var/lib/vdr/"
+#endif
+
+#ifndef FREESAT_NO_SYSLOG
+#include "../tools.h"
+/* Logging via vdr */
+#ifndef isyslog
+#define isyslog(a...) void( (SysLogLevel > 1) ? syslog_with_tid(LOG_INFO,  a) : void() )
+#endif
+void syslog_with_tid(int priority, const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+#else
+#define isyslog(a...)  fprintf(stderr,a)
+#endif
+
+
+
+struct hufftab { 
+    char from;
+    unsigned int value; 
+    short bits; 
+    char next; 
+}; 
+
+#include "huffman.t.h"
+ 
+#define START   '\0' 
+#define STOP    '\0' 
+#define ESCAPE  '\1' 
+ 
+
+int freesat_decode_error = 0;  /* If set an error has occurred during decoding */
+
+static struct hufftab *tables[2][256];
+static int             table_size[2][256];
+
+void freesat_table_init()
+{
+  int i;
+  int this_table = -1;
+  unsigned char this_char = 0xff;
+  static bool runonce = true;
+
+  if (runonce) {
+    runonce = false;
+  } else {
+    return;	// Initialisation to be done once only
+  }
+
+  for (i=0; i<256; i++) {
+    tables[0][i] = NULL;
+    tables[1][i] = NULL;
+    table_size[0][i] = 0;
+    table_size[1][i] = 0;
+  }
+
+  for (i=0; i<MEMTABLE_SIZE; i++) {
+    if (memtable[i].from != this_char) {
+      this_char = memtable[i].from;
+      if (!this_char) { // Jumping to next table
+        this_table++;
+      }
+      tables[this_table][this_char] = &memtable[i];
+    }
+    table_size[this_table][this_char]++;
+  }
+}
+
+
+/** \brief Convert a textual character description into a value
+ *
+ *  \param str - Encoded (in someway) string
+ *
+ *  \return Raw character
+ */
+static unsigned char resolve_char(char *str)
+{
+    int val;
+    if ( strcmp(str,"ESCAPE") == 0 ) {
+        return ESCAPE;
+    } else if ( strcmp(str,"STOP") == 0 ) {
+        return STOP;
+    } else if ( strcmp(str,"START") == 0 ) {
+        return START;
+    } else if ( sscanf(str,"0x%02x", &val) == 1 ) {
+        return val;
+    }
+    return str[0];
+
+
+}
+
+
+/** \brief Decode a binary string into a value
+ *
+ *  \param binary - Binary string to decode
+ *
+ *  \return Decoded value
+ */
+static unsigned long decode_binary(char *binary)
+{
+    unsigned long mask = 0x80000000;
+    unsigned long maskval = 0;
+    unsigned long val = 0;
+    size_t i;
+
+    for ( i = 0; i < strlen(binary); i++ ) {
+        if ( binary[i] == '1' ) {
+            val |= mask;
+        }
+        maskval |= mask;
+        mask >>= 1;
+    }
+    return val;
+}
+
+
+#ifdef FREESAT_ARCHIVE_MESSAGES
+static void write_message(const unsigned char *src, size_t size)
+{
+    static FILE *fp = NULL;
+    static int  written = 0;
+    static int  suffix = 0;
+    char buf[32768];
+
+    if ( written > 10000 ) {
+        fclose(fp);
+        fp = NULL;
+        written = 0;
+    }
+    if ( fp == NULL ) {
+        snprintf(buf,sizeof(buf),"mkdir -p /var/tmp/%d",getpid());
+        system(buf);
+
+        snprintf(buf,sizeof(buf),"/var/tmp/%d/freesat.%d",getpid(),suffix);
+        fp = fopen(buf, "w");
+        suffix = (suffix + 1)%1000;
+    }
+    size_t offs = 0;
+    size_t i;
+    for (  i = 0; i < size; i++ ) {
+        offs += snprintf(buf + offs, sizeof(buf) - offs, "%02x", src[i]);
+    }
+    fprintf(fp, "%s\n",buf);
+    fflush(fp);
+    written++;
+}
+#endif
+
+/** \brief Decode an EPG string as necessary
+ *
+ *  \param src - Possibly encoded string
+ *  \param size - Size of the buffer
+ *
+ *  \retval NULL - Can't decode
+ *  \return A decoded string
+ */
+char  *freesat_huffman_decode( const unsigned char *src, size_t size) 
+{ 
+    int tableid;
+
+    freesat_decode_error = 0;
+
+#ifdef FREESAT_ARCHIVE_MESSAGES
+    write_message(src, size);
+#endif
+    if (src[0] == 0x1f && (src[1] == 1 || src[1] == 2)) {
+        int    uncompressed_len = 30;
+        char * uncompressed = (char *)calloc(1,uncompressed_len + 1);
+        unsigned value = 0, byte = 2, bit = 0; 
+        int p = 0; 
+        int lastch = START; 
+
+        tableid = src[1] - 1;
+        while (byte < 6 && byte < size) {
+            value |= src[byte] << ((5-byte) * 8); 
+            byte++; 
+        } 
+  
+        freesat_table_init();   /**< Load the tables as necessary */
+
+        do {
+            int found = 0; 
+            unsigned bitShift = 0; 
+            if (lastch == ESCAPE) {
+                char nextCh = (value >> 24) & 0xff; 
+                found = 1; 
+                // Encoded in the next 8 bits. 
+                // Terminated by the first ASCII character. 
+                bitShift = 8; 
+                if ((nextCh & 0x80) == 0) 
+                    lastch = nextCh; 
+                if (p >= uncompressed_len) {
+                    uncompressed_len += 10;
+                    uncompressed = (char *)realloc(uncompressed, uncompressed_len + 1);
+                }
+                uncompressed[p++] = nextCh; 
+                uncompressed[p] = 0;
+            } else {
+                int j;
+                for ( j = 0; j < table_size[tableid][lastch]; j++) {
+                    unsigned mask = 0, maskbit = 0x80000000; 
+                    short kk;
+                    for ( kk = 0; kk < tables[tableid][lastch][j].bits; kk++) {
+                        mask |= maskbit; 
+                        maskbit >>= 1; 
+                    } 
+                    if ((value & mask) == tables[tableid][lastch][j].value) {
+                        char nextCh = tables[tableid][lastch][j].next; 
+                        bitShift = tables[tableid][lastch][j].bits; 
+                        if (nextCh != STOP && nextCh != ESCAPE) {
+                            if (p >= uncompressed_len) {
+                                uncompressed_len += 10;
+                                uncompressed = (char *)realloc(uncompressed, uncompressed_len + 1);
+                            }
+                            uncompressed[p++] = nextCh; 
+                            uncompressed[p] = 0;
+                        } 
+                        found = 1;
+                        lastch = nextCh; 
+                        break; 
+                    } 
+                } 
+            } 
+            if (found) {
+                // Shift up by the number of bits. 
+                unsigned b;
+                for ( b = 0; b < bitShift; b++) 
+                { 
+                    value = (value << 1) & 0xfffffffe; 
+                    if (byte < size) 
+                        value |= (src[byte] >> (7-bit)) & 1; 
+                    if (bit == 7) 
+                    { 
+                        bit = 0; 
+                        byte++; 
+                    } 
+                    else bit++; 
+                } 
+            } else {
+#ifdef FREESAT_PRINT_MISSED_DECODING
+                char  temp[1020];
+                size_t   tlen = 0;
+
+                tlen = snprintf(temp,sizeof(temp),"...[%02x][%02x][%02x][%02x]",(value >> 24 ) & 0xff, (value >> 16 ) & 0xff, (value >> 8) & 0xff, value &0xff);
+                do {
+                    // Shift up by the number of bits. 
+                    unsigned b;
+                    for ( b = 0; b < 8; b++) {
+                        value = (value << 1) & 0xfffffffe; 
+                        if (byte < size) 
+                            value |= (src[byte] >> (7-bit)) & 1; 
+                        if (bit == 7) {
+                            bit = 0; 
+                            byte++; 
+                        } 
+                        else bit++; 
+                    } 
+                    tlen += snprintf(temp+tlen, sizeof(temp) - tlen,"[%02x]", value & 0xff);
+                } while ( tlen < sizeof(temp) - 6 && byte <  size);
+                
+                uncompressed_len += tlen;
+                uncompressed = (char *)realloc(uncompressed, uncompressed_len + 1);
+                freesat_decode_error = 1;
+                strcpy(uncompressed + p, temp);
+#endif
+                isyslog("Missing table %d entry: <%s>",tableid + 1, uncompressed);
+                // Entry missing in table. 
+                return uncompressed; 
+            } 
+        } while (lastch != STOP && value != 0); 
+ 
+        return uncompressed;
+    } 
+    return NULL; 
+} 
+
+
diff -Naur vdr-1.7.27.orig/libsi/freesat.h vdr-1.7.27/libsi/freesat.h
--- vdr-1.7.27.orig/libsi/freesat.h	1970-01-01 01:00:00.000000000 +0100
+++ vdr-1.7.27/libsi/freesat.h	2012-04-11 19:26:59.834745650 +0200
@@ -0,0 +1,12 @@ 
+
+
+#ifndef FREESAT_H
+#define FREESAT_H
+
+#include <sys/types.h>
+
+extern char *freesat_huffman_decode(const unsigned char *compressed, size_t size); 
+
+#endif
+
+
diff -Naur vdr-1.7.27.orig/libsi/huffman.t.h vdr-1.7.27/libsi/huffman.t.h
--- vdr-1.7.27.orig/libsi/huffman.t.h	1970-01-01 01:00:00.000000000 +0100
+++ vdr-1.7.27/libsi/huffman.t.h	2012-04-12 15:09:54.795276187 +0200
@@ -0,0 +1,5192 @@ 
+#define	MEMTABLE_SIZE	5187
+
+struct hufftab memtable[] = {
+/* char from; unsigned int value; short bits; char next; */
+	{0x00, 0x00000000, 0x0002, 0x54},	// 51
+	{0x00, 0x40000000, 0x0003, 0x42},	// 51
+	{0x00, 0x80000000, 0x0004, 0x43},	// 51
+	{0x00, 0x90000000, 0x0004, 0x49},	// 51
+	{0x00, 0xd0000000, 0x0004, 0x53},	// 51
+	{0x00, 0x60000000, 0x0005, 0x4c},	// 51
+	{0x00, 0x70000000, 0x0005, 0x44},	// 51
+	{0x00, 0x78000000, 0x0005, 0x48},	// 51
+	{0x00, 0xa0000000, 0x0005, 0x52},	// 51
+	{0x00, 0xa8000000, 0x0005, 0x4e},	// 51
+	{0x00, 0xb0000000, 0x0005, 0x45},	// 51
+	{0x00, 0xc0000000, 0x0005, 0x46},	// 51
+	{0x00, 0xc8000000, 0x0005, 0x41},	// 51
+	{0x00, 0xe0000000, 0x0005, 0x4d},	// 51
+	{0x00, 0xe8000000, 0x0005, 0x50},	// 51
+	{0x00, 0xf0000000, 0x0005, 0x57},	// 51
+	{0x00, 0x6c000000, 0x0006, 0x51},	// 51
+	{0x00, 0xbc000000, 0x0006, 0x47},	// 51
+	{0x00, 0xf8000000, 0x0006, 0x4a},	// 51
+	{0x00, 0x68000000, 0x0007, 0x4b},	// 51
+	{0x00, 0xba000000, 0x0007, 0x55},	// 51
+	{0x00, 0xfc000000, 0x0007, 0x4f},	// 51
+	{0x00, 0x6a000000, 0x0008, 0x36},	// 51
+	{0x00, 0x6b000000, 0x0008, 0x2e},	// 51
+	{0x00, 0xb8000000, 0x0008, 0x56},	// 51
+	{0x00, 0xfe000000, 0x0008, 0x59},	// 51
+	{0x00, 0xb9800000, 0x0009, 0x32},	// 51
+	{0x00, 0xff800000, 0x0009, 0x58},	// 51
+	{0x00, 0xb9000000, 0x000a, 0x5a},	// 51
+	{0x00, 0xff000000, 0x000a, 0x38},	// 51
+	{0x00, 0xb9400000, 0x000b, 0x31},	// 51
+	{0x00, 0xb9600000, 0x000b, 0x33},	// 51
+	{0x00, 0xff400000, 0x000c, 0x34},	// 51
+	{0x00, 0xff500000, 0x000c, 0x27},	// 51
+	{0x00, 0xff700000, 0x000c, 0x20},	// 51
+	{0x00, 0xff600000, 0x000e, 0x35},	// 51
+	{0x00, 0xff6c0000, 0x000e, 0x30},	// 51
+	{0x00, 0xff660000, 0x000f, 0x6d},	// 51
+	{0x00, 0xff640000, 0x0010, 0x63},	// 51
+	{0x00, 0xff680000, 0x0010, 0x39},	// 51
+	{0x00, 0xff6a0000, 0x0010, 0x61},	// 51
+	{0x00, 0xff6b0000, 0x0010, 0x64},	// 51
+	{0x00, 0xff650000, 0x0011, 0x73},	// 51
+	{0x00, 0xff658000, 0x0011, 0x70},	// 51
+	{0x00, 0xff690000, 0x0011, 0x28},	// 51
+	{0x00, 0xff698000, 0x0012, 0x74},	// 51
+	{0x00, 0xff69c000, 0x0013, 0x37},	// 51
+	{0x00, 0xff69e000, 0x0014, 0x01},	// 51
+	{0x00, 0xff69f000, 0x0014, 0x6c},	// 51
+	{0x00, 0x00000000, 0x0001, 0x01},	// 51
+	{0x00, 0x80000000, 0x0001, 0x01},	// 51
+	{0x01, 0x00000000, 0x0001, 0x01},	// 2
+	{0x01, 0x80000000, 0x0001, 0x01},	// 2
+	{0x03, 0x00000000, 0x0001, 0x01},	// 2
+	{0x03, 0x80000000, 0x0001, 0x01},	// 2
+	{0x04, 0x00000000, 0x0001, 0x01},	// 2
+	{0x04, 0x80000000, 0x0001, 0x01},	// 2
+	{0x05, 0x00000000, 0x0001, 0x01},	// 2
+	{0x05, 0x80000000, 0x0001, 0x01},	// 2
+	{0x06, 0x00000000, 0x0001, 0x01},	// 2
+	{0x06, 0x80000000, 0x0001, 0x01},	// 2
+	{0x07, 0x00000000, 0x0001, 0x01},	// 2
+	{0x07, 0x80000000, 0x0001, 0x01},	// 2
+	{0x08, 0x00000000, 0x0001, 0x01},	// 2
+	{0x08, 0x80000000, 0x0001, 0x01},	// 2
+	{0x09, 0x00000000, 0x0001, 0x01},	// 2
+	{0x09, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0a, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0a, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x10, 0x00000000, 0x0001, 0x01},	// 2
+	{0x10, 0x80000000, 0x0001, 0x01},	// 2
+	{0x11, 0x00000000, 0x0001, 0x01},	// 2
+	{0x11, 0x80000000, 0x0001, 0x01},	// 2
+	{0x12, 0x00000000, 0x0001, 0x01},	// 2
+	{0x12, 0x80000000, 0x0001, 0x01},	// 2
+	{0x13, 0x00000000, 0x0001, 0x01},	// 2
+	{0x13, 0x80000000, 0x0001, 0x01},	// 2
+	{0x14, 0x00000000, 0x0001, 0x01},	// 2
+	{0x14, 0x80000000, 0x0001, 0x01},	// 2
+	{0x15, 0x00000000, 0x0001, 0x01},	// 2
+	{0x15, 0x80000000, 0x0001, 0x01},	// 2
+	{0x16, 0x00000000, 0x0001, 0x01},	// 2
+	{0x16, 0x80000000, 0x0001, 0x01},	// 2
+	{0x17, 0x00000000, 0x0001, 0x01},	// 2
+	{0x17, 0x80000000, 0x0001, 0x01},	// 2
+	{0x18, 0x00000000, 0x0001, 0x01},	// 2
+	{0x18, 0x80000000, 0x0001, 0x01},	// 2
+	{0x19, 0x00000000, 0x0001, 0x01},	// 2
+	{0x19, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1a, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1a, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x20, 0x00000000, 0x0004, 0x57},	// 70
+	{0x20, 0x30000000, 0x0004, 0x4d},	// 70
+	{0x20, 0x40000000, 0x0004, 0x43},	// 70
+	{0x20, 0x50000000, 0x0004, 0x42},	// 70
+	{0x20, 0x70000000, 0x0004, 0x50},	// 70
+	{0x20, 0x90000000, 0x0004, 0x54},	// 70
+	{0x20, 0xc0000000, 0x0004, 0x4e},	// 70
+	{0x20, 0xf0000000, 0x0004, 0x53},	// 70
+	{0x20, 0x18000000, 0x0005, 0x49},	// 70
+	{0x20, 0x20000000, 0x0005, 0x47},	// 70
+	{0x20, 0x60000000, 0x0005, 0x48},	// 70
+	{0x20, 0x68000000, 0x0005, 0x44},	// 70
+	{0x20, 0x80000000, 0x0005, 0x6f},	// 70
+	{0x20, 0x88000000, 0x0005, 0x41},	// 70
+	{0x20, 0xa0000000, 0x0005, 0x74},	// 70
+	{0x20, 0xb0000000, 0x0005, 0x61},	// 70
+	{0x20, 0xb8000000, 0x0005, 0x46},	// 70
+	{0x20, 0xd0000000, 0x0005, 0x4c},	// 70
+	{0x20, 0xd8000000, 0x0005, 0x52},	// 70
+	{0x20, 0x2c000000, 0x0006, 0x55},	// 70
+	{0x20, 0xac000000, 0x0006, 0x4f},	// 70
+	{0x20, 0xe4000000, 0x0006, 0x4a},	// 70
+	{0x20, 0xe8000000, 0x0006, 0x45},	// 70
+	{0x20, 0x10000000, 0x0007, 0x66},	// 70
+	{0x20, 0x12000000, 0x0007, 0x51},	// 70
+	{0x20, 0x16000000, 0x0007, 0x56},	// 70
+	{0x20, 0x28000000, 0x0007, 0x00},	// 70
+	{0x20, 0x2a000000, 0x0007, 0x77},	// 70
+	{0x20, 0xe0000000, 0x0007, 0x32},	// 70
+	{0x20, 0xe2000000, 0x0007, 0x4b},	// 70
+	{0x20, 0xec000000, 0x0007, 0x59},	// 70
+	{0x20, 0xee000000, 0x0007, 0x69},	// 70
+	{0x20, 0x14000000, 0x0008, 0x2d},	// 70
+	{0x20, 0xa9000000, 0x0008, 0x31},	// 70
+	{0x20, 0xa8000000, 0x0009, 0x26},	// 70
+	{0x20, 0xaa800000, 0x0009, 0x58},	// 70
+	{0x20, 0x15400000, 0x000a, 0x72},	// 70
+	{0x20, 0xa8800000, 0x000a, 0x35},	// 70
+	{0x20, 0xa8c00000, 0x000a, 0x5a},	// 70
+	{0x20, 0xaa400000, 0x000a, 0x39},	// 70
+	{0x20, 0xab400000, 0x000a, 0x73},	// 70
+	{0x20, 0xab800000, 0x000a, 0x34},	// 70
+	{0x20, 0xabc00000, 0x000a, 0x33},	// 70
+	{0x20, 0x15000000, 0x000b, 0x37},	// 70
+	{0x20, 0x15800000, 0x000b, 0x62},	// 70
+	{0x20, 0x15c00000, 0x000b, 0x79},	// 70
+	{0x20, 0xaa000000, 0x000b, 0x27},	// 70
+	{0x20, 0xab000000, 0x000b, 0x36},	// 70
+	{0x20, 0x15a00000, 0x000c, 0x76},	// 70
+	{0x20, 0x15b00000, 0x000c, 0x64},	// 70
+	{0x20, 0x15e00000, 0x000c, 0x28},	// 70
+	{0x20, 0xaa200000, 0x000c, 0x20},	// 70
+	{0x20, 0xaa300000, 0x000c, 0x30},	// 70
+	{0x20, 0xab200000, 0x000c, 0x6e},	// 70
+	{0x20, 0xab300000, 0x000c, 0x38},	// 70
+	{0x20, 0x15300000, 0x000d, 0x67},	// 70
+	{0x20, 0x15f00000, 0x000d, 0x75},	// 70
+	{0x20, 0x15200000, 0x000e, 0x2b},	// 70
+	{0x20, 0x15240000, 0x000e, 0x2e},	// 70
+	{0x20, 0x15280000, 0x000e, 0x01},	// 70
+	{0x20, 0x152c0000, 0x000e, 0x6c},	// 70
+	{0x20, 0x153c0000, 0x000e, 0x6d},	// 70
+	{0x20, 0x15f80000, 0x000e, 0x70},	// 70
+	{0x20, 0x15380000, 0x000f, 0x5c},	// 70
+	{0x20, 0x153a0000, 0x000f, 0x2f},	// 70
+	{0x20, 0x15fe0000, 0x000f, 0x65},	// 70
+	{0x20, 0x15fd0000, 0x0010, 0x22},	// 70
+	{0x20, 0x15fc8000, 0x0011, 0x63},	// 70
+	{0x20, 0x15fc0000, 0x0012, 0x6b},	// 70
+	{0x20, 0x15fc4000, 0x0012, 0x68},	// 70
+	{0x21, 0x80000000, 0x0001, 0x00},	// 7
+	{0x21, 0x40000000, 0x0002, 0x20},	// 7
+	{0x21, 0x20000000, 0x0003, 0x2e},	// 7
+	{0x21, 0x10000000, 0x0004, 0x21},	// 7
+	{0x21, 0x08000000, 0x0005, 0x22},	// 7
+	{0x21, 0x00000000, 0x0006, 0x01},	// 7
+	{0x21, 0x04000000, 0x0006, 0x3a},	// 7
+	{0x22, 0x00000000, 0x0001, 0x20},	// 3
+	{0x22, 0x80000000, 0x0002, 0x01},	// 3
+	{0x22, 0xc0000000, 0x0002, 0x49},	// 3
+	{0x23, 0x00000000, 0x0001, 0x01},	// 2
+	{0x23, 0x80000000, 0x0001, 0x01},	// 2
+	{0x24, 0x00000000, 0x0001, 0x01},	// 2
+	{0x24, 0x80000000, 0x0001, 0x01},	// 2
+	{0x25, 0x80000000, 0x0001, 0x20},	// 3
+	{0x25, 0x00000000, 0x0002, 0x01},	// 3
+	{0x25, 0x40000000, 0x0002, 0x00},	// 3
+	{0x26, 0x80000000, 0x0001, 0x20},	// 4
+	{0x26, 0x40000000, 0x0002, 0x42},	// 4
+	{0x26, 0x00000000, 0x0003, 0x01},	// 4
+	{0x26, 0x20000000, 0x0003, 0x2e},	// 4
+	{0x27, 0x80000000, 0x0001, 0x73},	// 32
+	{0x27, 0x00000000, 0x0003, 0x6d},	// 32
+	{0x27, 0x40000000, 0x0003, 0x43},	// 32
+	{0x27, 0x20000000, 0x0004, 0x74},	// 32
+	{0x27, 0x30000000, 0x0004, 0x20},	// 32
+	{0x27, 0x60000000, 0x0005, 0x64},	// 32
+	{0x27, 0x70000000, 0x0005, 0x76},	// 32
+	{0x27, 0x6c000000, 0x0006, 0x72},	// 32
+	{0x27, 0x7c000000, 0x0006, 0x41},	// 32
+	{0x27, 0x6a000000, 0x0007, 0x6e},	// 32
+	{0x27, 0x68000000, 0x0008, 0x47},	// 32
+	{0x27, 0x79000000, 0x0008, 0x6c},	// 32
+	{0x27, 0x69800000, 0x0009, 0x44},	// 32
+	{0x27, 0x78000000, 0x0009, 0x42},	// 32
+	{0x27, 0x78800000, 0x0009, 0x65},	// 32
+	{0x27, 0x7a800000, 0x0009, 0x69},	// 32
+	{0x27, 0x7b000000, 0x0009, 0x36},	// 32
+	{0x27, 0x69000000, 0x000a, 0x4c},	// 32
+	{0x27, 0x7a400000, 0x000a, 0x00},	// 32
+	{0x27, 0x7bc00000, 0x000a, 0x77},	// 32
+	{0x27, 0x69400000, 0x000b, 0x4f},	// 32
+	{0x27, 0x7a000000, 0x000b, 0x53},	// 32
+	{0x27, 0x7a200000, 0x000b, 0x45},	// 32
+	{0x27, 0x7ba00000, 0x000b, 0x4e},	// 32
+	{0x27, 0x7b900000, 0x000c, 0x52},	// 32
+	{0x27, 0x69600000, 0x000d, 0x61},	// 32
+	{0x27, 0x69680000, 0x000d, 0x4d},	// 32
+	{0x27, 0x69700000, 0x000d, 0x4b},	// 32
+	{0x27, 0x69780000, 0x000d, 0x46},	// 32
+	{0x27, 0x7b800000, 0x000d, 0x30},	// 32
+	{0x27, 0x7b880000, 0x000e, 0x01},	// 32
+	{0x27, 0x7b8c0000, 0x000e, 0x63},	// 32
+	{0x28, 0x80000000, 0x0001, 0x63},	// 12
+	{0x28, 0x00000000, 0x0003, 0x31},	// 12
+	{0x28, 0x20000000, 0x0004, 0x4d},	// 12
+	{0x28, 0x30000000, 0x0004, 0x55},	// 12
+	{0x28, 0x40000000, 0x0004, 0x52},	// 12
+	{0x28, 0x50000000, 0x0004, 0x44},	// 12
+	{0x28, 0x60000000, 0x0004, 0x48},	// 12
+	{0x28, 0x70000000, 0x0005, 0x53},	// 12
+	{0x28, 0x78000000, 0x0006, 0x46},	// 12
+	{0x28, 0x7c000000, 0x0007, 0x47},	// 12
+	{0x28, 0x7e000000, 0x0008, 0x01},	// 12
+	{0x28, 0x7f000000, 0x0008, 0x59},	// 12
+	{0x29, 0x80000000, 0x0001, 0x00},	// 3
+	{0x29, 0x00000000, 0x0002, 0x01},	// 3
+	{0x29, 0x40000000, 0x0002, 0x20},	// 3
+	{0x2a, 0x00000000, 0x0001, 0x2a},	// 11
+	{0x2a, 0xa0000000, 0x0003, 0x20},	// 11
+	{0x2a, 0x80000000, 0x0004, 0x64},	// 11
+	{0x2a, 0xc0000000, 0x0004, 0x6d},	// 11
+	{0x2a, 0xd0000000, 0x0004, 0x74},	// 11
+	{0x2a, 0xf0000000, 0x0004, 0x73},	// 11
+	{0x2a, 0x90000000, 0x0005, 0x65},	// 11
+	{0x2a, 0xe0000000, 0x0005, 0x67},	// 11
+	{0x2a, 0xe8000000, 0x0005, 0x6b},	// 11
+	{0x2a, 0x98000000, 0x0006, 0x01},	// 11
+	{0x2a, 0x9c000000, 0x0006, 0x79},	// 11
+	{0x2b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x2b, 0x80000000, 0x0001, 0x20},	// 2
+	{0x2c, 0x80000000, 0x0001, 0x20},	// 4
+	{0x2c, 0x40000000, 0x0002, 0x30},	// 4
+	{0x2c, 0x00000000, 0x0003, 0x01},	// 4
+	{0x2c, 0x20000000, 0x0003, 0x2e},	// 4
+	{0x2d, 0xc0000000, 0x0002, 0x20},	// 37
+	{0x2d, 0x60000000, 0x0003, 0x53},	// 37
+	{0x2d, 0x80000000, 0x0003, 0x47},	// 37
+	{0x2d, 0xa0000000, 0x0003, 0x4f},	// 37
+	{0x2d, 0x30000000, 0x0004, 0x54},	// 37
+	{0x2d, 0x40000000, 0x0004, 0x55},	// 37
+	{0x2d, 0x00000000, 0x0005, 0x45},	// 37
+	{0x2d, 0x10000000, 0x0005, 0x44},	// 37
+	{0x2d, 0x08000000, 0x0006, 0x6d},	// 37
+	{0x2d, 0x18000000, 0x0006, 0x30},	// 37
+	{0x2d, 0x1c000000, 0x0006, 0x49},	// 37
+	{0x2d, 0x28000000, 0x0006, 0x36},	// 37
+	{0x2d, 0x50000000, 0x0006, 0x46},	// 37
+	{0x2d, 0x54000000, 0x0006, 0x6f},	// 37
+	{0x2d, 0x0c000000, 0x0007, 0x4c},	// 37
+	{0x2d, 0x0e000000, 0x0007, 0x43},	// 37
+	{0x2d, 0x22000000, 0x0007, 0x41},	// 37
+	{0x2d, 0x24000000, 0x0007, 0x74},	// 37
+	{0x2d, 0x26000000, 0x0007, 0x59},	// 37
+	{0x2d, 0x2e000000, 0x0007, 0x32},	// 37
+	{0x2d, 0x58000000, 0x0007, 0x42},	// 37
+	{0x2d, 0x5a000000, 0x0007, 0x2e},	// 37
+	{0x2d, 0x20000000, 0x0008, 0x50},	// 37
+	{0x2d, 0x21000000, 0x0008, 0x5a},	// 37
+	{0x2d, 0x5c000000, 0x0008, 0x38},	// 37
+	{0x2d, 0x5d000000, 0x0008, 0x69},	// 37
+	{0x2d, 0x5e000000, 0x0008, 0x64},	// 37
+	{0x2d, 0x5f000000, 0x0008, 0x48},	// 37
+	{0x2d, 0x2c800000, 0x0009, 0x4e},	// 37
+	{0x2d, 0x2d800000, 0x0009, 0x52},	// 37
+	{0x2d, 0x2c000000, 0x000a, 0x31},	// 37
+	{0x2d, 0x2c400000, 0x000a, 0x57},	// 37
+	{0x2d, 0x2d200000, 0x000b, 0x63},	// 37
+	{0x2d, 0x2d400000, 0x000b, 0x61},	// 37
+	{0x2d, 0x2d600000, 0x000b, 0x4d},	// 37
+	{0x2d, 0x2d000000, 0x000c, 0x01},	// 37
+	{0x2d, 0x2d100000, 0x000c, 0x51},	// 37
+	{0x2e, 0x80000000, 0x0001, 0x2e},	// 25
+	{0x2e, 0x40000000, 0x0002, 0x00},	// 25
+	{0x2e, 0x20000000, 0x0004, 0x20},	// 25
+	{0x2e, 0x00000000, 0x0005, 0x49},	// 25
+	{0x2e, 0x08000000, 0x0005, 0x54},	// 25
+	{0x2e, 0x10000000, 0x0005, 0x43},	// 25
+	{0x2e, 0x30000000, 0x0005, 0x70},	// 25
+	{0x2e, 0x38000000, 0x0005, 0x30},	// 25
+	{0x2e, 0x1c000000, 0x0006, 0x48},	// 25
+	{0x2e, 0x1a000000, 0x0008, 0x57},	// 25
+	{0x2e, 0x18800000, 0x0009, 0x53},	// 25
+	{0x2e, 0x1b000000, 0x0009, 0x33},	// 25
+	{0x2e, 0x1b800000, 0x0009, 0x42},	// 25
+	{0x2e, 0x18000000, 0x000a, 0x31},	// 25
+	{0x2e, 0x18400000, 0x000a, 0x4d},	// 25
+	{0x2e, 0x19800000, 0x000a, 0x63},	// 25
+	{0x2e, 0x19000000, 0x000b, 0x74},	// 25
+	{0x2e, 0x19200000, 0x000b, 0x52},	// 25
+	{0x2e, 0x19400000, 0x000b, 0x46},	// 25
+	{0x2e, 0x19c00000, 0x000b, 0x45},	// 25
+	{0x2e, 0x19e00000, 0x000b, 0x41},	// 25
+	{0x2e, 0x19600000, 0x000d, 0x01},	// 25
+	{0x2e, 0x19680000, 0x000d, 0x6c},	// 25
+	{0x2e, 0x19700000, 0x000d, 0x64},	// 25
+	{0x2e, 0x19780000, 0x000d, 0x55},	// 25
+	{0x2f, 0x00000000, 0x0002, 0x31},	// 18
+	{0x2f, 0x80000000, 0x0002, 0x37},	// 18
+	{0x2f, 0x40000000, 0x0003, 0x34},	// 18
+	{0x2f, 0x60000000, 0x0003, 0x32},	// 18
+	{0x2f, 0xc0000000, 0x0003, 0x33},	// 18
+	{0x2f, 0xe0000000, 0x0004, 0x35},	// 18
+	{0x2f, 0xf0000000, 0x0006, 0x36},	// 18
+	{0x2f, 0xf8000000, 0x0006, 0x43},	// 18
+	{0x2f, 0xf4000000, 0x0007, 0x39},	// 18
+	{0x2f, 0xf6000000, 0x0007, 0x20},	// 18
+	{0x2f, 0xfc000000, 0x0007, 0x38},	// 18
+	{0x2f, 0xff000000, 0x0008, 0x55},	// 18
+	{0x2f, 0xfe000000, 0x000a, 0x47},	// 18
+	{0x2f, 0xfe800000, 0x000a, 0x30},	// 18
+	{0x2f, 0xfe400000, 0x000b, 0x01},	// 18
+	{0x2f, 0xfe600000, 0x000b, 0x57},	// 18
+	{0x2f, 0xfec00000, 0x000b, 0x56},	// 18
+	{0x2f, 0xfee00000, 0x000b, 0x53},	// 18
+	{0x30, 0x00000000, 0x0002, 0x36},	// 23
+	{0x30, 0x40000000, 0x0002, 0x20},	// 23
+	{0x30, 0xc0000000, 0x0002, 0x30},	// 23
+	{0x30, 0x90000000, 0x0004, 0x70},	// 23
+	{0x30, 0xa0000000, 0x0004, 0x00},	// 23
+	{0x30, 0x80000000, 0x0005, 0x31},	// 23
+	{0x30, 0x88000000, 0x0005, 0x61},	// 23
+	{0x30, 0xb8000000, 0x0005, 0x37},	// 23
+	{0x30, 0xb0000000, 0x0007, 0x2d},	// 23
+	{0x30, 0xb4000000, 0x0007, 0x73},	// 23
+	{0x30, 0xb3000000, 0x0008, 0x34},	// 23
+	{0x30, 0xb6000000, 0x0008, 0x74},	// 23
+	{0x30, 0xb7800000, 0x0009, 0x25},	// 23
+	{0x30, 0xb2000000, 0x000a, 0x38},	// 23
+	{0x30, 0xb2400000, 0x000a, 0x3a},	// 23
+	{0x30, 0xb2800000, 0x000a, 0x35},	// 23
+	{0x30, 0xb2c00000, 0x000a, 0x32},	// 23
+	{0x30, 0xb7000000, 0x000a, 0x2f},	// 23
+	{0x30, 0xb7600000, 0x000b, 0x55},	// 23
+	{0x30, 0xb7500000, 0x000c, 0x2c},	// 23
+	{0x30, 0xb7400000, 0x000d, 0x2e},	// 23
+	{0x30, 0xb7480000, 0x000e, 0x01},	// 23
+	{0x30, 0xb74c0000, 0x000e, 0x6c},	// 23
+	{0x31, 0x40000000, 0x0002, 0x00},	// 22
+	{0x31, 0x00000000, 0x0003, 0x2e},	// 22
+	{0x31, 0xa0000000, 0x0003, 0x30},	// 22
+	{0x31, 0xe0000000, 0x0003, 0x31},	// 22
+	{0x31, 0x20000000, 0x0004, 0x32},	// 22
+	{0x31, 0x30000000, 0x0004, 0x20},	// 22
+	{0x31, 0xd0000000, 0x0004, 0x2f},	// 22
+	{0x31, 0x90000000, 0x0005, 0x38},	// 22
+	{0x31, 0xc0000000, 0x0005, 0x33},	// 22
+	{0x31, 0x80000000, 0x0006, 0x35},	// 22
+	{0x31, 0x84000000, 0x0006, 0x73},	// 22
+	{0x31, 0x88000000, 0x0006, 0x36},	// 22
+	{0x31, 0x8c000000, 0x0006, 0x3a},	// 22
+	{0x31, 0x98000000, 0x0006, 0x27},	// 22
+	{0x31, 0xc8000000, 0x0006, 0x58},	// 22
+	{0x31, 0xcc000000, 0x0006, 0x39},	// 22
+	{0x31, 0x9e000000, 0x0007, 0x34},	// 22
+	{0x31, 0x9d000000, 0x0008, 0x2d},	// 22
+	{0x31, 0x9c800000, 0x0009, 0x37},	// 22
+	{0x31, 0x9c000000, 0x000a, 0x29},	// 22
+	{0x31, 0x9c400000, 0x000b, 0x01},	// 22
+	{0x31, 0x9c600000, 0x000b, 0x2c},	// 22
+	{0x32, 0x00000000, 0x0001, 0x30},	// 18
+	{0x32, 0xc0000000, 0x0002, 0x34},	// 18
+	{0x32, 0xa0000000, 0x0003, 0x00},	// 18
+	{0x32, 0x90000000, 0x0004, 0x20},	// 18
+	{0x32, 0x80000000, 0x0005, 0x3a},	// 18
+	{0x32, 0x8a000000, 0x0007, 0x35},	// 18
+	{0x32, 0x8e000000, 0x0007, 0x2f},	// 18
+	{0x32, 0x88000000, 0x0008, 0x2e},	// 18
+	{0x32, 0x89000000, 0x0008, 0x31},	// 18
+	{0x32, 0x8c000000, 0x0008, 0x57},	// 18
+	{0x32, 0x8d800000, 0x0009, 0x37},	// 18
+	{0x32, 0x8d200000, 0x000b, 0x33},	// 18
+	{0x32, 0x8d600000, 0x000b, 0x5a},	// 18
+	{0x32, 0x8d000000, 0x000c, 0x6e},	// 18
+	{0x32, 0x8d100000, 0x000c, 0x36},	// 18
+	{0x32, 0x8d500000, 0x000c, 0x27},	// 18
+	{0x32, 0x8d400000, 0x000d, 0x01},	// 18
+	{0x32, 0x8d480000, 0x000d, 0x73},	// 18
+	{0x33, 0x00000000, 0x0001, 0x20},	// 19
+	{0x33, 0x80000000, 0x0002, 0x00},	// 19
+	{0x33, 0xc0000000, 0x0004, 0x72},	// 19
+	{0x33, 0xd0000000, 0x0004, 0x2f},	// 19
+	{0x33, 0xf0000000, 0x0004, 0x42},	// 19
+	{0x33, 0xe0000000, 0x0005, 0x30},	// 19
+	{0x33, 0xe8000000, 0x0007, 0x3a},	// 19
+	{0x33, 0xec000000, 0x0007, 0x2d},	// 19
+	{0x33, 0xea000000, 0x0008, 0x31},	// 19
+	{0x33, 0xeb000000, 0x0008, 0x38},	// 19
+	{0x33, 0xef000000, 0x0008, 0x34},	// 19
+	{0x33, 0xee000000, 0x000a, 0x36},	// 19
+	{0x33, 0xeec00000, 0x000a, 0x39},	// 19
+	{0x33, 0xee600000, 0x000b, 0x74},	// 19
+	{0x33, 0xee800000, 0x000b, 0x33},	// 19
+	{0x33, 0xee400000, 0x000c, 0x01},	// 19
+	{0x33, 0xee500000, 0x000c, 0x65},	// 19
+	{0x33, 0xeea00000, 0x000c, 0x37},	// 19
+	{0x33, 0xeeb00000, 0x000c, 0x35},	// 19
+	{0x34, 0x00000000, 0x0001, 0x00},	// 19
+	{0x34, 0xc0000000, 0x0002, 0x20},	// 19
+	{0x34, 0x90000000, 0x0004, 0x3a},	// 19
+	{0x34, 0xb0000000, 0x0004, 0x2f},	// 19
+	{0x34, 0x88000000, 0x0005, 0x38},	// 19
+	{0x34, 0xa8000000, 0x0005, 0x2e},	// 19
+	{0x34, 0x80000000, 0x0006, 0x39},	// 19
+	{0x34, 0xa0000000, 0x0006, 0x30},	// 19
+	{0x34, 0xa4000000, 0x0007, 0x4d},	// 19
+	{0x34, 0x85000000, 0x0008, 0x49},	// 19
+	{0x34, 0x86000000, 0x0008, 0x29},	// 19
+	{0x34, 0xa6000000, 0x0008, 0x52},	// 19
+	{0x34, 0xa7000000, 0x0008, 0x2d},	// 19
+	{0x34, 0x84000000, 0x0009, 0x57},	// 19
+	{0x34, 0x87000000, 0x0009, 0x50},	// 19
+	{0x34, 0x87800000, 0x0009, 0x35},	// 19
+	{0x34, 0x84c00000, 0x000a, 0x32},	// 19
+	{0x34, 0x84800000, 0x000b, 0x01},	// 19
+	{0x34, 0x84a00000, 0x000b, 0x27},	// 19
+	{0x35, 0x00000000, 0x0001, 0x00},	// 11
+	{0x35, 0xc0000000, 0x0002, 0x20},	// 11
+	{0x35, 0xa0000000, 0x0003, 0x30},	// 11
+	{0x35, 0x90000000, 0x0004, 0x2f},	// 11
+	{0x35, 0x84000000, 0x0006, 0x2d},	// 11
+	{0x35, 0x8c000000, 0x0006, 0x3a},	// 11
+	{0x35, 0x82000000, 0x0007, 0x74},	// 11
+	{0x35, 0x88000000, 0x0007, 0x33},	// 11
+	{0x35, 0x8a000000, 0x0007, 0x31},	// 11
+	{0x35, 0x80000000, 0x0008, 0x01},	// 11
+	{0x35, 0x81000000, 0x0008, 0x61},	// 11
+	{0x36, 0x00000000, 0x0002, 0x00},	// 16
+	{0x36, 0x40000000, 0x0002, 0x20},	// 16
+	{0x36, 0x80000000, 0x0002, 0x30},	// 16
+	{0x36, 0xe0000000, 0x0003, 0x3a},	// 16
+	{0x36, 0xc8000000, 0x0005, 0x2e},	// 16
+	{0x36, 0xd8000000, 0x0005, 0x69},	// 16
+	{0x36, 0xc0000000, 0x0006, 0x2d},	// 16
+	{0x36, 0xd4000000, 0x0006, 0x61},	// 16
+	{0x36, 0xc6000000, 0x0007, 0x34},	// 16
+	{0x36, 0xd0000000, 0x0007, 0x38},	// 16
+	{0x36, 0xd2000000, 0x0007, 0x2f},	// 16
+	{0x36, 0xc4000000, 0x0008, 0x36},	// 16
+	{0x36, 0xc5800000, 0x0009, 0x39},	// 16
+	{0x36, 0xc5000000, 0x000a, 0x33},	// 16
+	{0x36, 0xc5400000, 0x000b, 0x01},	// 16
+	{0x36, 0xc5600000, 0x000b, 0x74},	// 16
+	{0x37, 0x80000000, 0x0001, 0x00},	// 11
+	{0x37, 0x40000000, 0x0002, 0x20},	// 11
+	{0x37, 0x00000000, 0x0003, 0x30},	// 11
+	{0x37, 0x30000000, 0x0004, 0x2e},	// 11
+	{0x37, 0x28000000, 0x0005, 0x2f},	// 11
+	{0x37, 0x20000000, 0x0007, 0x31},	// 11
+	{0x37, 0x24000000, 0x0007, 0x35},	// 11
+	{0x37, 0x22000000, 0x0008, 0x01},	// 11
+	{0x37, 0x23000000, 0x0008, 0x34},	// 11
+	{0x37, 0x26000000, 0x0008, 0x33},	// 11
+	{0x37, 0x27000000, 0x0008, 0x32},	// 11
+	{0x38, 0x80000000, 0x0001, 0x20},	// 15
+	{0x38, 0x00000000, 0x0002, 0x30},	// 15
+	{0x38, 0x40000000, 0x0003, 0x3a},	// 15
+	{0x38, 0x68000000, 0x0005, 0x00},	// 15
+	{0x38, 0x60000000, 0x0006, 0x74},	// 15
+	{0x38, 0x64000000, 0x0006, 0x70},	// 15
+	{0x38, 0x74000000, 0x0006, 0x38},	// 15
+	{0x38, 0x78000000, 0x0006, 0x2e},	// 15
+	{0x38, 0x7c000000, 0x0006, 0x36},	// 15
+	{0x38, 0x70000000, 0x0007, 0x35},	// 15
+	{0x38, 0x72000000, 0x0008, 0x39},	// 15
+	{0x38, 0x73000000, 0x0009, 0x4d},	// 15
+	{0x38, 0x73800000, 0x000a, 0x46},	// 15
+	{0x38, 0x73c00000, 0x000b, 0x01},	// 15
+	{0x38, 0x73e00000, 0x000b, 0x63},	// 15
+	{0x39, 0x00000000, 0x0001, 0x31},	// 14
+	{0x39, 0xc0000000, 0x0002, 0x00},	// 14
+	{0x39, 0x80000000, 0x0004, 0x39},	// 14
+	{0x39, 0xa0000000, 0x0004, 0x2e},	// 14
+	{0x39, 0x98000000, 0x0005, 0x30},	// 14
+	{0x39, 0x90000000, 0x0006, 0x20},	// 14
+	{0x39, 0x94000000, 0x0006, 0x38},	// 14
+	{0x39, 0xb0000000, 0x0006, 0x37},	// 14
+	{0x39, 0xb4000000, 0x0006, 0x2f},	// 14
+	{0x39, 0xb8000000, 0x0006, 0x36},	// 14
+	{0x39, 0xbe000000, 0x0007, 0x3a},	// 14
+	{0x39, 0xbd000000, 0x0008, 0x34},	// 14
+	{0x39, 0xbc000000, 0x0009, 0x01},	// 14
+	{0x39, 0xbc800000, 0x0009, 0x33},	// 14
+	{0x3a, 0x80000000, 0x0001, 0x20},	// 9
+	{0x3a, 0x00000000, 0x0002, 0x30},	// 9
+	{0x3a, 0x60000000, 0x0003, 0x2e},	// 9
+	{0x3a, 0x40000000, 0x0004, 0x32},	// 9
+	{0x3a, 0x50000000, 0x0005, 0x31},	// 9
+	{0x3a, 0x5c000000, 0x0006, 0x33},	// 9
+	{0x3a, 0x5a000000, 0x0007, 0x43},	// 9
+	{0x3a, 0x58000000, 0x0008, 0x01},	// 9
+	{0x3a, 0x59000000, 0x0008, 0x54},	// 9
+	{0x3b, 0x80000000, 0x0001, 0x20},	// 3
+	{0x3b, 0x00000000, 0x0002, 0x01},	// 3
+	{0x3b, 0x40000000, 0x0002, 0x2e},	// 3
+	{0x3c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3f, 0x80000000, 0x0001, 0x00},	// 5
+	{0x3f, 0x40000000, 0x0002, 0x20},	// 5
+	{0x3f, 0x20000000, 0x0003, 0x3a},	// 5
+	{0x3f, 0x00000000, 0x0004, 0x01},	// 5
+	{0x3f, 0x10000000, 0x0004, 0x2e},	// 5
+	{0x40, 0x00000000, 0x0001, 0x01},	// 2
+	{0x40, 0x80000000, 0x0001, 0x48},	// 2
+	{0x41, 0x20000000, 0x0003, 0x72},	// 44
+	{0x41, 0x40000000, 0x0003, 0x20},	// 44
+	{0x41, 0x80000000, 0x0003, 0x6c},	// 44
+	{0x41, 0xc0000000, 0x0003, 0x6e},	// 44
+	{0x41, 0x00000000, 0x0004, 0x6d},	// 44
+	{0x41, 0x70000000, 0x0004, 0x67},	// 44
+	{0x41, 0xf0000000, 0x0004, 0x64},	// 44
+	{0x41, 0x10000000, 0x0005, 0x77},	// 44
+	{0x41, 0x60000000, 0x0005, 0x54},	// 44
+	{0x41, 0x68000000, 0x0005, 0x63},	// 44
+	{0x41, 0xa8000000, 0x0005, 0x74},	// 44
+	{0x41, 0xb0000000, 0x0005, 0x66},	// 44
+	{0x41, 0xb8000000, 0x0005, 0x69},	// 44
+	{0x41, 0xe0000000, 0x0005, 0x73},	// 44
+	{0x41, 0x18000000, 0x0006, 0x75},	// 44
+	{0x41, 0x1c000000, 0x0006, 0x00},	// 44
+	{0x41, 0xa4000000, 0x0006, 0x52},	// 44
+	{0x41, 0xe8000000, 0x0006, 0x62},	// 44
+	{0x41, 0xa2000000, 0x0007, 0x76},	// 44
+	{0x41, 0xec000000, 0x0007, 0x70},	// 44
+	{0x41, 0xa0000000, 0x0008, 0x53},	// 44
+	{0x41, 0xee000000, 0x0008, 0x4d},	// 44
+	{0x41, 0xa1800000, 0x0009, 0x50},	// 44
+	{0x41, 0xef800000, 0x0009, 0x2e},	// 44
+	{0x41, 0xa1000000, 0x000b, 0x65},	// 44
+	{0x41, 0xa1200000, 0x000b, 0x42},	// 44
+	{0x41, 0xa1400000, 0x000b, 0x31},	// 44
+	{0x41, 0xef600000, 0x000b, 0x2d},	// 44
+	{0x41, 0xa1600000, 0x000c, 0x6b},	// 44
+	{0x41, 0xa1700000, 0x000c, 0x68},	// 44
+	{0x41, 0xef000000, 0x000c, 0x61},	// 44
+	{0x41, 0xef400000, 0x000c, 0x79},	// 44
+	{0x41, 0xef500000, 0x000c, 0x2a},	// 44
+	{0x41, 0xef100000, 0x000d, 0x78},	// 44
+	{0x41, 0xef180000, 0x000d, 0x27},	// 44
+	{0x41, 0xef200000, 0x000d, 0x4e},	// 44
+	{0x41, 0xef300000, 0x000d, 0x32},	// 44
+	{0x41, 0xef280000, 0x000e, 0x3a},	// 44
+	{0x41, 0xef3c0000, 0x000e, 0x7a},	// 44
+	{0x41, 0xef2c0000, 0x000f, 0x4c},	// 44
+	{0x41, 0xef2e0000, 0x000f, 0x46},	// 44
+	{0x41, 0xef380000, 0x000f, 0x44},	// 44
+	{0x41, 0xef3a0000, 0x0010, 0x01},	// 44
+	{0x41, 0xef3b0000, 0x0010, 0x71},	// 44
+	{0x42, 0x00000000, 0x0002, 0x43},	// 26
+	{0x42, 0x40000000, 0x0002, 0x42},	// 26
+	{0x42, 0xa0000000, 0x0003, 0x72},	// 26
+	{0x42, 0x90000000, 0x0004, 0x69},	// 26
+	{0x42, 0xc0000000, 0x0004, 0x6f},	// 26
+	{0x42, 0xd0000000, 0x0004, 0x75},	// 26
+	{0x42, 0xe0000000, 0x0004, 0x61},	// 26
+	{0x42, 0xf0000000, 0x0004, 0x65},	// 26
+	{0x42, 0x88000000, 0x0005, 0x6c},	// 26
+	{0x42, 0x80000000, 0x0007, 0x00},	// 26
+	{0x42, 0x84000000, 0x0007, 0x79},	// 26
+	{0x42, 0x82000000, 0x0008, 0x4f},	// 26
+	{0x42, 0x86000000, 0x0008, 0x33},	// 26
+	{0x42, 0x83800000, 0x0009, 0x41},	// 26
+	{0x42, 0x87000000, 0x0009, 0x53},	// 26
+	{0x42, 0x83400000, 0x000a, 0x3a},	// 26
+	{0x42, 0x83000000, 0x000b, 0x2e},	// 26
+	{0x42, 0x83200000, 0x000b, 0x77},	// 26
+	{0x42, 0x87a00000, 0x000b, 0x68},	// 26
+	{0x42, 0x87c00000, 0x000b, 0x2a},	// 26
+	{0x42, 0x87e00000, 0x000b, 0x20},	// 26
+	{0x42, 0x87900000, 0x000c, 0x52},	// 26
+	{0x42, 0x87800000, 0x000d, 0x27},	// 26
+	{0x42, 0x878c0000, 0x000e, 0x54},	// 26
+	{0x42, 0x87880000, 0x000f, 0x01},	// 26
+	{0x42, 0x878a0000, 0x000f, 0x34},	// 26
+	{0x43, 0x00000000, 0x0002, 0x6f},	// 31
+	{0x43, 0x40000000, 0x0002, 0x20},	// 31
+	{0x43, 0x80000000, 0x0003, 0x6c},	// 31
+	{0x43, 0xc0000000, 0x0003, 0x68},	// 31
+	{0x43, 0xa0000000, 0x0004, 0x72},	// 31
+	{0x43, 0xe0000000, 0x0004, 0x61},	// 31
+	{0x43, 0xb0000000, 0x0005, 0x69},	// 31
+	{0x43, 0xb8000000, 0x0005, 0x65},	// 31
+	{0x43, 0xf0000000, 0x0006, 0x75},	// 31
+	{0x43, 0xf4000000, 0x0006, 0x42},	// 31
+	{0x43, 0xf8000000, 0x0007, 0x79},	// 31
+	{0x43, 0xfc000000, 0x0007, 0x21},	// 31
+	{0x43, 0xfb000000, 0x0008, 0x2e},	// 31
+	{0x43, 0xfa000000, 0x0009, 0x77},	// 31
+	{0x43, 0xfe000000, 0x0009, 0x00},	// 31
+	{0x43, 0xff000000, 0x0009, 0x53},	// 31
+	{0x43, 0xff800000, 0x0009, 0x54},	// 31
+	{0x43, 0xfac00000, 0x000a, 0x32},	// 31
+	{0x43, 0xfec00000, 0x000a, 0x49},	// 31
+	{0x43, 0xfa800000, 0x000b, 0x34},	// 31
+	{0x43, 0xfaa00000, 0x000b, 0x2a},	// 31
+	{0x43, 0xfea00000, 0x000b, 0x44},	// 31
+	{0x43, 0xfe800000, 0x000c, 0x55},	// 31
+	{0x43, 0xfe900000, 0x000d, 0x27},	// 31
+	{0x43, 0xfe980000, 0x000e, 0x6e},	// 31
+	{0x43, 0xfe9c0000, 0x000f, 0x7a},	// 31
+	{0x43, 0xfe9e0000, 0x0011, 0x4f},	// 31
+	{0x43, 0xfe9e8000, 0x0011, 0x45},	// 31
+	{0x43, 0xfe9f0000, 0x0011, 0x41},	// 31
+	{0x43, 0xfe9f8000, 0x0012, 0x01},	// 31
+	{0x43, 0xfe9fc000, 0x0012, 0x73},	// 31
+	{0x44, 0x40000000, 0x0002, 0x6f},	// 28
+	{0x44, 0x80000000, 0x0002, 0x61},	// 28
+	{0x44, 0x00000000, 0x0003, 0x72},	// 28
+	{0x44, 0xc0000000, 0x0003, 0x65},	// 28
+	{0x44, 0xe0000000, 0x0003, 0x69},	// 28
+	{0x44, 0x20000000, 0x0005, 0x74},	// 28
+	{0x44, 0x38000000, 0x0005, 0x75},	// 28
+	{0x44, 0x2c000000, 0x0006, 0x20},	// 28
+	{0x44, 0x2a000000, 0x0007, 0x4a},	// 28
+	{0x44, 0x30000000, 0x0007, 0x79},	// 28
+	{0x44, 0x34000000, 0x0007, 0x00},	// 28
+	{0x44, 0x36000000, 0x0007, 0x49},	// 28
+	{0x44, 0x33000000, 0x0008, 0x3a},	// 28
+	{0x44, 0x28800000, 0x0009, 0x2a},	// 28
+	{0x44, 0x29000000, 0x0009, 0x2d},	// 28
+	{0x44, 0x29800000, 0x0009, 0x26},	// 28
+	{0x44, 0x32000000, 0x0009, 0x27},	// 28
+	{0x44, 0x28000000, 0x000a, 0x41},	// 28
+	{0x44, 0x28400000, 0x000a, 0x68},	// 28
+	{0x44, 0x32a00000, 0x000b, 0x4e},	// 28
+	{0x44, 0x32c00000, 0x000b, 0x56},	// 28
+	{0x44, 0x32e00000, 0x000c, 0x44},	// 28
+	{0x44, 0x32f00000, 0x000c, 0x77},	// 28
+	{0x44, 0x32800000, 0x000d, 0x4f},	// 28
+	{0x44, 0x32880000, 0x000d, 0x45},	// 28
+	{0x44, 0x32980000, 0x000d, 0x64},	// 28
+	{0x44, 0x32900000, 0x000e, 0x01},	// 28
+	{0x44, 0x32940000, 0x000e, 0x54},	// 28
+	{0x45, 0x00000000, 0x0002, 0x6d},	// 45
+	{0x45, 0x60000000, 0x0003, 0x76},	// 45
+	{0x45, 0xa0000000, 0x0003, 0x6e},	// 45
+	{0x45, 0xe0000000, 0x0003, 0x61},	// 45
+	{0x45, 0x40000000, 0x0004, 0x45},	// 45
+	{0x45, 0x80000000, 0x0004, 0x00},	// 45
+	{0x45, 0xd0000000, 0x0004, 0x78},	// 45
+	{0x45, 0x98000000, 0x0005, 0x64},	// 45
+	{0x45, 0xc8000000, 0x0005, 0x6c},	// 45
+	{0x45, 0x50000000, 0x0006, 0x34},	// 45
+	{0x45, 0x54000000, 0x0006, 0x79},	// 45
+	{0x45, 0x58000000, 0x0006, 0x75},	// 45
+	{0x45, 0x90000000, 0x0006, 0x72},	// 45
+	{0x45, 0xc0000000, 0x0006, 0x69},	// 45
+	{0x45, 0x5e000000, 0x0007, 0x73},	// 45
+	{0x45, 0x94000000, 0x0007, 0x46},	// 45
+	{0x45, 0xc4000000, 0x0007, 0x58},	// 45
+	{0x45, 0x96000000, 0x0008, 0x52},	// 45
+	{0x45, 0xc7000000, 0x0008, 0x20},	// 45
+	{0x45, 0x5d000000, 0x0009, 0x67},	// 45
+	{0x45, 0x97800000, 0x0009, 0x3a},	// 45
+	{0x45, 0xc6000000, 0x0009, 0x54},	// 45
+	{0x45, 0xc6800000, 0x0009, 0x27},	// 45
+	{0x45, 0x5c400000, 0x000a, 0x63},	// 45
+	{0x45, 0x5cc00000, 0x000a, 0x71},	// 45
+	{0x45, 0x5d800000, 0x000a, 0x65},	// 45
+	{0x45, 0x5dc00000, 0x000a, 0x43},	// 45
+	{0x45, 0x97000000, 0x000a, 0x70},	// 45
+	{0x45, 0x5c000000, 0x000b, 0x2d},	// 45
+	{0x45, 0x5ca00000, 0x000b, 0x5a},	// 45
+	{0x45, 0x97600000, 0x000b, 0x74},	// 45
+	{0x45, 0x5c200000, 0x000c, 0x53},	// 45
+	{0x45, 0x5c300000, 0x000c, 0x2e},	// 45
+	{0x45, 0x97500000, 0x000c, 0x57},	// 45
+	{0x45, 0x5c800000, 0x000d, 0x21},	// 45
+	{0x45, 0x97400000, 0x000d, 0x6f},	// 45
+	{0x45, 0x5c880000, 0x000e, 0x66},	// 45
+	{0x45, 0x5c8c0000, 0x000e, 0x55},	// 45
+	{0x45, 0x5c900000, 0x000e, 0x4e},	// 45
+	{0x45, 0x5c940000, 0x000e, 0x4d},	// 45
+	{0x45, 0x5c980000, 0x000e, 0x4c},	// 45
+	{0x45, 0x5c9c0000, 0x000e, 0x41},	// 45
+	{0x45, 0x974c0000, 0x000e, 0x44},	// 45
+	{0x45, 0x97480000, 0x000f, 0x01},	// 45
+	{0x45, 0x974a0000, 0x000f, 0x77},	// 45
+	{0x46, 0x00000000, 0x0002, 0x69},	// 26
+	{0x46, 0x80000000, 0x0002, 0x61},	// 26
+	{0x46, 0x60000000, 0x0003, 0x72},	// 26
+	{0x46, 0xc0000000, 0x0003, 0x75},	// 26
+	{0x46, 0xe0000000, 0x0003, 0x6f},	// 26
+	{0x46, 0x40000000, 0x0004, 0x65},	// 26
+	{0x46, 0x58000000, 0x0005, 0x6c},	// 26
+	{0x46, 0x50000000, 0x0007, 0x41},	// 26
+	{0x46, 0x54000000, 0x0007, 0x4f},	// 26
+	{0x46, 0x52000000, 0x0008, 0x20},	// 26
+	{0x46, 0x53000000, 0x0009, 0x68},	// 26
+	{0x46, 0x53800000, 0x0009, 0x74},	// 26
+	{0x46, 0x56800000, 0x0009, 0x66},	// 26
+	{0x46, 0x57800000, 0x0009, 0x4c},	// 26
+	{0x46, 0x56400000, 0x000a, 0x00},	// 26
+	{0x46, 0x57000000, 0x000b, 0x6a},	// 26
+	{0x46, 0x57200000, 0x000b, 0x49},	// 26
+	{0x46, 0x57400000, 0x000b, 0x2e},	// 26
+	{0x46, 0x57600000, 0x000b, 0x31},	// 26
+	{0x46, 0x56000000, 0x000c, 0x4d},	// 26
+	{0x46, 0x56200000, 0x000c, 0x2a},	// 26
+	{0x46, 0x56300000, 0x000c, 0x4b},	// 26
+	{0x46, 0x56100000, 0x000d, 0x79},	// 26
+	{0x46, 0x561c0000, 0x000e, 0x48},	// 26
+	{0x46, 0x56180000, 0x000f, 0x01},	// 26
+	{0x46, 0x561a0000, 0x000f, 0x21},	// 26
+	{0x47, 0x80000000, 0x0002, 0x72},	// 25
+	{0x47, 0x20000000, 0x0003, 0x4d},	// 25
+	{0x47, 0x40000000, 0x0003, 0x61},	// 25
+	{0x47, 0x60000000, 0x0003, 0x6f},	// 25
+	{0x47, 0xc0000000, 0x0003, 0x69},	// 25
+	{0x47, 0xe0000000, 0x0003, 0x65},	// 25
+	{0x47, 0x08000000, 0x0005, 0x75},	// 25
+	{0x47, 0x10000000, 0x0005, 0x58},	// 25
+	{0x47, 0x04000000, 0x0006, 0x68},	// 25
+	{0x47, 0x1c000000, 0x0006, 0x6c},	// 25
+	{0x47, 0x02000000, 0x0007, 0x79},	// 25
+	{0x47, 0x18000000, 0x0007, 0x77},	// 25
+	{0x47, 0x00000000, 0x0008, 0x3a},	// 25
+	{0x47, 0x1b000000, 0x0008, 0x43},	// 25
+	{0x47, 0x01800000, 0x0009, 0x00},	// 25
+	{0x47, 0x1a000000, 0x0009, 0x2d},	// 25
+	{0x47, 0x1a800000, 0x000a, 0x50},	// 25
+	{0x47, 0x1ac00000, 0x000a, 0x20},	// 25
+	{0x47, 0x01000000, 0x000b, 0x27},	// 25
+	{0x47, 0x01400000, 0x000b, 0x41},	// 25
+	{0x47, 0x01200000, 0x000c, 0x55},	// 25
+	{0x47, 0x01600000, 0x000c, 0x54},	// 25
+	{0x47, 0x01700000, 0x000c, 0x34},	// 25
+	{0x47, 0x01300000, 0x000d, 0x01},	// 25
+	{0x47, 0x01380000, 0x000d, 0x59},	// 25
+	{0x48, 0x00000000, 0x0001, 0x6f},	// 19
+	{0x48, 0x80000000, 0x0003, 0x61},	// 19
+	{0x48, 0xa0000000, 0x0003, 0x69},	// 19
+	{0x48, 0xc0000000, 0x0003, 0x65},	// 19
+	{0x48, 0xe0000000, 0x0004, 0x75},	// 19
+	{0x48, 0xf0000000, 0x0005, 0x52},	// 19
+	{0x48, 0xf8000000, 0x0006, 0x41},	// 19
+	{0x48, 0xfc000000, 0x0007, 0x2e},	// 19
+	{0x48, 0xfe800000, 0x0009, 0x79},	// 19
+	{0x48, 0xff000000, 0x0009, 0x53},	// 19
+	{0x48, 0xff800000, 0x000a, 0x45},	// 19
+	{0x48, 0xffc00000, 0x000a, 0x72},	// 19
+	{0x48, 0xfe000000, 0x000b, 0x00},	// 19
+	{0x48, 0xfe400000, 0x000b, 0x4c},	// 19
+	{0x48, 0xfe600000, 0x000b, 0x4d},	// 19
+	{0x48, 0xfe300000, 0x000c, 0x77},	// 19
+	{0x48, 0xfe280000, 0x000d, 0x44},	// 19
+	{0x48, 0xfe200000, 0x000e, 0x01},	// 19
+	{0x48, 0xfe240000, 0x000e, 0x49},	// 19
+	{0x49, 0x00000000, 0x0001, 0x54},	// 41
+	{0x49, 0x80000000, 0x0003, 0x73},	// 41
+	{0x49, 0xa0000000, 0x0003, 0x6e},	// 41
+	{0x49, 0xd0000000, 0x0004, 0x74},	// 41
+	{0x49, 0xc8000000, 0x0005, 0x20},	// 41
+	{0x49, 0xe8000000, 0x0005, 0x27},	// 41
+	{0x49, 0xf8000000, 0x0005, 0x72},	// 41
+	{0x49, 0xc0000000, 0x0006, 0x49},	// 41
+	{0x49, 0xc4000000, 0x0006, 0x00},	// 41
+	{0x49, 0xe4000000, 0x0006, 0x6d},	// 41
+	{0x49, 0xe0000000, 0x0007, 0x64},	// 41
+	{0x49, 0xe2000000, 0x0007, 0x4e},	// 41
+	{0x49, 0xf2000000, 0x0007, 0x7a},	// 41
+	{0x49, 0xf4000000, 0x0007, 0x2e},	// 41
+	{0x49, 0xf0000000, 0x0008, 0x61},	// 41
+	{0x49, 0xf1000000, 0x0008, 0x59},	// 41
+	{0x49, 0xf6000000, 0x0009, 0x53},	// 41
+	{0x49, 0xf7000000, 0x0009, 0x63},	// 41
+	{0x49, 0xf6a00000, 0x000b, 0x44},	// 41
+	{0x49, 0xf6c00000, 0x000b, 0x66},	// 41
+	{0x49, 0xf7800000, 0x000b, 0x6c},	// 41
+	{0x49, 0xf7e00000, 0x000b, 0x79},	// 41
+	{0x49, 0xf6800000, 0x000c, 0x56},	// 41
+	{0x49, 0xf6e00000, 0x000c, 0x6f},	// 41
+	{0x49, 0xf7b00000, 0x000c, 0x46},	// 41
+	{0x49, 0xf6900000, 0x000d, 0x2c},	// 41
+	{0x49, 0xf6980000, 0x000d, 0x41},	// 41
+	{0x49, 0xf6f00000, 0x000d, 0x4f},	// 41
+	{0x49, 0xf7a80000, 0x000d, 0x67},	// 41
+	{0x49, 0xf7c00000, 0x000d, 0x43},	// 41
+	{0x49, 0xf7c80000, 0x000d, 0x3a},	// 41
+	{0x49, 0xf7d80000, 0x000d, 0x76},	// 41
+	{0x49, 0xf6f80000, 0x000e, 0x70},	// 41
+	{0x49, 0xf6fc0000, 0x000e, 0x45},	// 41
+	{0x49, 0xf7a00000, 0x000e, 0x42},	// 41
+	{0x49, 0xf7d00000, 0x000e, 0x6b},	// 41
+	{0x49, 0xf7d40000, 0x000e, 0x62},	// 41
+	{0x49, 0xf7a40000, 0x0010, 0x01},	// 41
+	{0x49, 0xf7a50000, 0x0010, 0x52},	// 41
+	{0x49, 0xf7a60000, 0x0010, 0x4c},	// 41
+	{0x49, 0xf7a70000, 0x0010, 0x47},	// 41
+	{0x4a, 0x00000000, 0x0002, 0x61},	// 16
+	{0x4a, 0x40000000, 0x0002, 0x75},	// 16
+	{0x4a, 0xc0000000, 0x0002, 0x65},	// 16
+	{0x4a, 0xa0000000, 0x0003, 0x6f},	// 16
+	{0x4a, 0x90000000, 0x0004, 0x69},	// 16
+	{0x4a, 0x80000000, 0x0005, 0x20},	// 16
+	{0x4a, 0x88000000, 0x0006, 0x4b},	// 16
+	{0x4a, 0x8e000000, 0x0007, 0x00},	// 16
+	{0x4a, 0x8c800000, 0x0009, 0x73},	// 16
+	{0x4a, 0x8d000000, 0x0009, 0x46},	// 16
+	{0x4a, 0x8c000000, 0x000a, 0x56},	// 16
+	{0x4a, 0x8c400000, 0x000a, 0x27},	// 16
+	{0x4a, 0x8dc00000, 0x000a, 0x66},	// 16
+	{0x4a, 0x8da00000, 0x000b, 0x47},	// 16
+	{0x4a, 0x8d800000, 0x000c, 0x01},	// 16
+	{0x4a, 0x8d900000, 0x000c, 0x44},	// 16
+	{0x4b, 0x40000000, 0x0002, 0x69},	// 26
+	{0x4b, 0xc0000000, 0x0002, 0x79},	// 26
+	{0x4b, 0x20000000, 0x0003, 0x65},	// 26
+	{0x4b, 0xa0000000, 0x0003, 0x20},	// 26
+	{0x4b, 0x00000000, 0x0004, 0x61},	// 26
+	{0x4b, 0x80000000, 0x0004, 0x6f},	// 26
+	{0x4b, 0x10000000, 0x0005, 0x00},	// 26
+	{0x4b, 0x18000000, 0x0005, 0x72},	// 26
+	{0x4b, 0x94000000, 0x0006, 0x74},	// 26
+	{0x4b, 0x98000000, 0x0006, 0x6e},	// 26
+	{0x4b, 0x9c000000, 0x0006, 0x53},	// 26
+	{0x4b, 0x93000000, 0x0008, 0x47},	// 26
+	{0x4b, 0x90000000, 0x0009, 0x2d},	// 26
+	{0x4b, 0x91800000, 0x0009, 0x4f},	// 26
+	{0x4b, 0x92000000, 0x0009, 0x68},	// 26
+	{0x4b, 0x92800000, 0x0009, 0x77},	// 26
+	{0x4b, 0x90800000, 0x000a, 0x31},	// 26
+	{0x4b, 0x90c00000, 0x000a, 0x27},	// 26
+	{0x4b, 0x91600000, 0x000b, 0x75},	// 26
+	{0x4b, 0x91000000, 0x000c, 0x54},	// 26
+	{0x4b, 0x91100000, 0x000c, 0x4e},	// 26
+	{0x4b, 0x91200000, 0x000c, 0x3a},	// 26
+	{0x4b, 0x91300000, 0x000c, 0x2e},	// 26
+	{0x4b, 0x91400000, 0x000c, 0x2c},	// 26
+	{0x4b, 0x91500000, 0x000d, 0x01},	// 26
+	{0x4b, 0x91580000, 0x000d, 0x6c},	// 26
+	{0x4c, 0x00000000, 0x0002, 0x61},	// 19
+	{0x4c, 0x80000000, 0x0002, 0x6f},	// 19
+	{0x4c, 0xc0000000, 0x0002, 0x69},	// 19
+	{0x4c, 0x40000000, 0x0003, 0x65},	// 19
+	{0x4c, 0x70000000, 0x0004, 0x75},	// 19
+	{0x4c, 0x68000000, 0x0005, 0x4b},	// 19
+	{0x4c, 0x60000000, 0x0007, 0x6c},	// 19
+	{0x4c, 0x64000000, 0x0007, 0x41},	// 19
+	{0x4c, 0x66000000, 0x0007, 0x20},	// 19
+	{0x4c, 0x63000000, 0x0008, 0x79},	// 19
+	{0x4c, 0x62000000, 0x000a, 0x4c},	// 19
+	{0x4c, 0x62400000, 0x000a, 0x49},	// 19
+	{0x4c, 0x62800000, 0x000b, 0x43},	// 19
+	{0x4c, 0x62a00000, 0x000b, 0x2e},	// 19
+	{0x4c, 0x62e00000, 0x000b, 0x00},	// 19
+	{0x4c, 0x62d00000, 0x000c, 0x27},	// 19
+	{0x4c, 0x62c00000, 0x000d, 0x45},	// 19
+	{0x4c, 0x62c80000, 0x000e, 0x01},	// 19
+	{0x4c, 0x62cc0000, 0x000e, 0x59},	// 19
+	{0x4d, 0x40000000, 0x0002, 0x61},	// 29
+	{0x4d, 0x80000000, 0x0002, 0x6f},	// 29
+	{0x4d, 0x00000000, 0x0003, 0x65},	// 29
+	{0x4d, 0xe0000000, 0x0003, 0x69},	// 29
+	{0x4d, 0x20000000, 0x0004, 0x54},	// 29
+	{0x4d, 0xc0000000, 0x0004, 0x79},	// 29
+	{0x4d, 0xd0000000, 0x0004, 0x75},	// 29
+	{0x4d, 0x30000000, 0x0005, 0x00},	// 29
+	{0x4d, 0x3c000000, 0x0006, 0x63},	// 29
+	{0x4d, 0x39000000, 0x0008, 0x72},	// 29
+	{0x4d, 0x3a000000, 0x0008, 0x45},	// 29
+	{0x4d, 0x3b800000, 0x0009, 0x46},	// 29
+	{0x4d, 0x38400000, 0x000a, 0x5a},	// 29
+	{0x4d, 0x38c00000, 0x000a, 0x20},	// 29
+	{0x4d, 0x3b000000, 0x000a, 0x31},	// 29
+	{0x4d, 0x3b400000, 0x000a, 0x49},	// 29
+	{0x4d, 0x38200000, 0x000b, 0x68},	// 29
+	{0x4d, 0x38800000, 0x000b, 0x43},	// 29
+	{0x4d, 0x38100000, 0x000c, 0x51},	// 29
+	{0x4d, 0x38a00000, 0x000c, 0x4b},	// 29
+	{0x4d, 0x38b00000, 0x000d, 0x50},	// 29
+	{0x4d, 0x38000000, 0x000e, 0x3a},	// 29
+	{0x4d, 0x38040000, 0x000e, 0x2e},	// 29
+	{0x4d, 0x38080000, 0x000e, 0x27},	// 29
+	{0x4d, 0x38b80000, 0x000e, 0x4d},	// 29
+	{0x4d, 0x380c0000, 0x000f, 0x01},	// 29
+	{0x4d, 0x380e0000, 0x000f, 0x77},	// 29
+	{0x4d, 0x38bc0000, 0x000f, 0x53},	// 29
+	{0x4d, 0x38be0000, 0x000f, 0x52},	// 29
+	{0x4e, 0x80000000, 0x0001, 0x65},	// 22
+	{0x4e, 0x00000000, 0x0002, 0x6f},	// 22
+	{0x4e, 0x60000000, 0x0003, 0x69},	// 22
+	{0x4e, 0x50000000, 0x0004, 0x61},	// 22
+	{0x4e, 0x48000000, 0x0005, 0x75},	// 22
+	{0x4e, 0x40000000, 0x0006, 0x43},	// 22
+	{0x4e, 0x44000000, 0x0008, 0x45},	// 22
+	{0x4e, 0x46000000, 0x0008, 0x46},	// 22
+	{0x4e, 0x47000000, 0x0009, 0x42},	// 22
+	{0x4e, 0x47800000, 0x0009, 0x48},	// 22
+	{0x4e, 0x45800000, 0x000a, 0x59},	// 22
+	{0x4e, 0x45000000, 0x000b, 0x47},	// 22
+	{0x4e, 0x45200000, 0x000b, 0x27},	// 22
+	{0x4e, 0x45600000, 0x000b, 0x49},	// 22
+	{0x4e, 0x45c00000, 0x000b, 0x41},	// 22
+	{0x4e, 0x45400000, 0x000c, 0x4d},	// 22
+	{0x4e, 0x45e00000, 0x000c, 0x20},	// 22
+	{0x4e, 0x45f00000, 0x000c, 0x00},	// 22
+	{0x4e, 0x45500000, 0x000d, 0x54},	// 22
+	{0x4e, 0x45580000, 0x000e, 0x2e},	// 22
+	{0x4e, 0x455c0000, 0x000f, 0x01},	// 22
+	{0x4e, 0x455e0000, 0x000f, 0x5a},	// 22
+	{0x4f, 0x00000000, 0x0003, 0x27},	// 44
+	{0x4f, 0x40000000, 0x0003, 0x66},	// 44
+	{0x4f, 0xc0000000, 0x0003, 0x75},	// 44
+	{0x4f, 0xe0000000, 0x0003, 0x6e},	// 44
+	{0x4f, 0x20000000, 0x0004, 0x4d},	// 44
+	{0x4f, 0x30000000, 0x0004, 0x6c},	// 44
+	{0x4f, 0x90000000, 0x0004, 0x6d},	// 44
+	{0x4f, 0x68000000, 0x0005, 0x72},	// 44
+	{0x4f, 0x70000000, 0x0005, 0x64},	// 44
+	{0x4f, 0x80000000, 0x0005, 0x70},	// 44
+	{0x4f, 0xa0000000, 0x0005, 0x68},	// 44
+	{0x4f, 0xb0000000, 0x0005, 0x00},	// 44
+	{0x4f, 0x64000000, 0x0006, 0x53},	// 44
+	{0x4f, 0x78000000, 0x0006, 0x7a},	// 44
+	{0x4f, 0x7c000000, 0x0006, 0x62},	// 44
+	{0x4f, 0x8c000000, 0x0006, 0x76},	// 44
+	{0x4f, 0xa8000000, 0x0006, 0x77},	// 44
+	{0x4f, 0xac000000, 0x0006, 0x55},	// 44
+	{0x4f, 0xb8000000, 0x0007, 0x54},	// 44
+	{0x4f, 0xba000000, 0x0007, 0x4f},	// 44
+	{0x4f, 0xbc000000, 0x0007, 0x4b},	// 44
+	{0x4f, 0x61000000, 0x0008, 0x43},	// 44
+	{0x4f, 0x62000000, 0x0008, 0x78},	// 44
+	{0x4f, 0x63000000, 0x0008, 0x2e},	// 44
+	{0x4f, 0x89000000, 0x0008, 0x74},	// 44
+	{0x4f, 0x8b000000, 0x0008, 0x20},	// 44
+	{0x4f, 0xbe000000, 0x0008, 0x73},	// 44
+	{0x4f, 0xbf000000, 0x0008, 0x4e},	// 44
+	{0x4f, 0x60800000, 0x0009, 0x67},	// 44
+	{0x4f, 0x88000000, 0x0009, 0x2d},	// 44
+	{0x4f, 0x8a800000, 0x0009, 0x61},	// 44
+	{0x4f, 0x88800000, 0x000a, 0x69},	// 44
+	{0x4f, 0x88c00000, 0x000a, 0x65},	// 44
+	{0x4f, 0x8a400000, 0x000a, 0x6f},	// 44
+	{0x4f, 0x60000000, 0x000b, 0x41},	// 44
+	{0x4f, 0x60200000, 0x000b, 0x6a},	// 44
+	{0x4f, 0x60400000, 0x000b, 0x63},	// 44
+	{0x4f, 0x8a000000, 0x000b, 0x32},	// 44
+	{0x4f, 0x60700000, 0x000c, 0x52},	// 44
+	{0x4f, 0x8a200000, 0x000c, 0x50},	// 44
+	{0x4f, 0x8a300000, 0x000c, 0x3a},	// 44
+	{0x4f, 0x60600000, 0x000d, 0x45},	// 44
+	{0x4f, 0x60680000, 0x000e, 0x01},	// 44
+	{0x4f, 0x606c0000, 0x000e, 0x4c},	// 44
+	{0x50, 0x40000000, 0x0002, 0x72},	// 28
+	{0x50, 0x80000000, 0x0002, 0x6c},	// 28
+	{0x50, 0x00000000, 0x0003, 0x65},	// 28
+	{0x50, 0x20000000, 0x0003, 0x61},	// 28
+	{0x50, 0xe0000000, 0x0003, 0x6f},	// 28
+	{0x50, 0xd0000000, 0x0004, 0x69},	// 28
+	{0x50, 0xc0000000, 0x0006, 0x44},	// 28
+	{0x50, 0xc4000000, 0x0006, 0x75},	// 28
+	{0x50, 0xcc000000, 0x0006, 0x68},	// 28
+	{0x50, 0xc8000000, 0x0008, 0x20},	// 28
+	{0x50, 0xca000000, 0x0008, 0x32},	// 28
+	{0x50, 0xc9000000, 0x0009, 0x48},	// 28
+	{0x50, 0xc9800000, 0x0009, 0x4d},	// 28
+	{0x50, 0xcb000000, 0x0009, 0x53},	// 28
+	{0x50, 0xcb800000, 0x000b, 0x3a},	// 28
+	{0x50, 0xcba00000, 0x000b, 0x2a},	// 28
+	{0x50, 0xcbd00000, 0x000c, 0x73},	// 28
+	{0x50, 0xcbc80000, 0x000d, 0x49},	// 28
+	{0x50, 0xcbe00000, 0x000d, 0x00},	// 28
+	{0x50, 0xcbe80000, 0x000d, 0x47},	// 28
+	{0x50, 0xcbf00000, 0x000d, 0x27},	// 28
+	{0x50, 0xcbf80000, 0x000e, 0x79},	// 28
+	{0x50, 0xcbc00000, 0x000f, 0x59},	// 28
+	{0x50, 0xcbc20000, 0x000f, 0x4c},	// 28
+	{0x50, 0xcbc40000, 0x000f, 0x43},	// 28
+	{0x50, 0xcbc60000, 0x000f, 0x01},	// 28
+	{0x50, 0xcbfc0000, 0x000f, 0x4f},	// 28
+	{0x50, 0xcbfe0000, 0x000f, 0x2e},	// 28
+	{0x51, 0x80000000, 0x0001, 0x75},	// 8
+	{0x51, 0x00000000, 0x0003, 0x49},	// 8
+	{0x51, 0x20000000, 0x0003, 0x00},	// 8
+	{0x51, 0x40000000, 0x0003, 0x56},	// 8
+	{0x51, 0x70000000, 0x0004, 0x20},	// 8
+	{0x51, 0x68000000, 0x0005, 0x43},	// 8
+	{0x51, 0x60000000, 0x0006, 0x01},	// 8
+	{0x51, 0x64000000, 0x0006, 0x27},	// 8
+	{0x52, 0x00000000, 0x0002, 0x61},	// 23
+	{0x52, 0x40000000, 0x0002, 0x6f},	// 23
+	{0x52, 0xc0000000, 0x0002, 0x65},	// 23
+	{0x52, 0x80000000, 0x0003, 0x69},	// 23
+	{0x52, 0xb0000000, 0x0004, 0x75},	// 23
+	{0x52, 0xa8000000, 0x0005, 0x45},	// 23
+	{0x52, 0xa0000000, 0x0006, 0x44},	// 23
+	{0x52, 0xa6000000, 0x0007, 0x00},	// 23
+	{0x52, 0xa5000000, 0x0008, 0x68},	// 23
+	{0x52, 0xa4000000, 0x000a, 0x49},	// 23
+	{0x52, 0xa4800000, 0x000a, 0x79},	// 23
+	{0x52, 0xa4c00000, 0x000a, 0x6e},	// 23
+	{0x52, 0xa4600000, 0x000c, 0x20},	// 23
+	{0x52, 0xa4400000, 0x000d, 0x27},	// 23
+	{0x52, 0xa4580000, 0x000d, 0x53},	// 23
+	{0x52, 0xa4700000, 0x000d, 0x4e},	// 23
+	{0x52, 0xa4480000, 0x000e, 0x42},	// 23
+	{0x52, 0xa44c0000, 0x000e, 0x2e},	// 23
+	{0x52, 0xa4500000, 0x000e, 0x26},	// 23
+	{0x52, 0xa4780000, 0x000e, 0x54},	// 23
+	{0x52, 0xa47c0000, 0x000e, 0x31},	// 23
+	{0x52, 0xa4540000, 0x000f, 0x01},	// 23
+	{0x52, 0xa4560000, 0x000f, 0x43},	// 23
+	{0x53, 0x20000000, 0x0003, 0x6f},	// 39
+	{0x53, 0x40000000, 0x0003, 0x70},	// 39
+	{0x53, 0x60000000, 0x0003, 0x75},	// 39
+	{0x53, 0xc0000000, 0x0003, 0x68},	// 39
+	{0x53, 0xe0000000, 0x0003, 0x74},	// 39
+	{0x53, 0x10000000, 0x0004, 0x61},	// 39
+	{0x53, 0x90000000, 0x0004, 0x65},	// 39
+	{0x53, 0xb0000000, 0x0004, 0x63},	// 39
+	{0x53, 0x00000000, 0x0005, 0x6e},	// 39
+	{0x53, 0x88000000, 0x0005, 0x69},	// 39
+	{0x53, 0xa8000000, 0x0005, 0x6b},	// 39
+	{0x53, 0x0c000000, 0x0006, 0x77},	// 39
+	{0x53, 0xa0000000, 0x0006, 0x6d},	// 39
+	{0x53, 0x0a000000, 0x0007, 0x41},	// 39
+	{0x53, 0x84000000, 0x0007, 0x6c},	// 39
+	{0x53, 0xa4000000, 0x0007, 0x71},	// 39
+	{0x53, 0xa6000000, 0x0007, 0x4d},	// 39
+	{0x53, 0x08000000, 0x0008, 0x32},	// 39
+	{0x53, 0x09000000, 0x0008, 0x50},	// 39
+	{0x53, 0x80000000, 0x0008, 0x4f},	// 39
+	{0x53, 0x82000000, 0x0008, 0x49},	// 39
+	{0x53, 0x83000000, 0x0008, 0x20},	// 39
+	{0x53, 0x87000000, 0x0008, 0x00},	// 39
+	{0x53, 0x81000000, 0x0009, 0x79},	// 39
+	{0x53, 0x86000000, 0x0009, 0x45},	// 39
+	{0x53, 0x81c00000, 0x000a, 0x3f},	// 39
+	{0x53, 0x86c00000, 0x000a, 0x48},	// 39
+	{0x53, 0x81800000, 0x000b, 0x42},	// 39
+	{0x53, 0x86800000, 0x000b, 0x67},	// 39
+	{0x53, 0x81b00000, 0x000c, 0x72},	// 39
+	{0x53, 0x86a00000, 0x000c, 0x2a},	// 39
+	{0x53, 0x86b00000, 0x000d, 0x33},	// 39
+	{0x53, 0x86b80000, 0x000d, 0x2e},	// 39
+	{0x53, 0x81a00000, 0x000e, 0x35},	// 39
+	{0x53, 0x81a80000, 0x000e, 0x3a},	// 39
+	{0x53, 0x81ac0000, 0x000e, 0x31},	// 39
+	{0x53, 0x81a40000, 0x000f, 0x43},	// 39
+	{0x53, 0x81a60000, 0x0010, 0x01},	// 39
+	{0x53, 0x81a70000, 0x0010, 0x59},	// 39
+	{0x54, 0x00000000, 0x0001, 0x68},	// 33
+	{0x54, 0xa0000000, 0x0003, 0x6f},	// 33
+	{0x54, 0xe0000000, 0x0003, 0x56},	// 33
+	{0x54, 0x80000000, 0x0004, 0x65},	// 33
+	{0x54, 0x90000000, 0x0004, 0x72},	// 33
+	{0x54, 0xc0000000, 0x0005, 0x61},	// 33
+	{0x54, 0xd0000000, 0x0005, 0x77},	// 33
+	{0x54, 0xcc000000, 0x0006, 0x69},	// 33
+	{0x54, 0xda000000, 0x0007, 0x4f},	// 33
+	{0x54, 0xde000000, 0x0007, 0x48},	// 33
+	{0x54, 0xc9000000, 0x0008, 0x79},	// 33
+	{0x54, 0xca000000, 0x0008, 0x4d},	// 33
+	{0x54, 0xd8000000, 0x0008, 0x2e},	// 33
+	{0x54, 0xdc000000, 0x0008, 0x75},	// 33
+	{0x54, 0xdd000000, 0x0008, 0x57},	// 33
+	{0x54, 0xc8800000, 0x0009, 0x50},	// 33
+	{0x54, 0xcb000000, 0x0009, 0x3a},	// 33
+	{0x54, 0xcb800000, 0x0009, 0x34},	// 33
+	{0x54, 0xd9800000, 0x0009, 0x49},	// 33
+	{0x54, 0xd9000000, 0x000a, 0x20},	// 33
+	{0x54, 0xd9400000, 0x000a, 0x00},	// 33
+	{0x54, 0xc8400000, 0x000b, 0x58},	// 33
+	{0x54, 0xc8600000, 0x000b, 0x73},	// 33
+	{0x54, 0xc8000000, 0x000c, 0x54},	// 33
+	{0x54, 0xc8100000, 0x000c, 0x53},	// 33
+	{0x54, 0xc8200000, 0x000c, 0x42},	// 33
+	{0x54, 0xc8300000, 0x000d, 0x55},	// 33
+	{0x54, 0xc8380000, 0x000e, 0x41},	// 33
+	{0x54, 0xc83c0000, 0x0010, 0x43},	// 33
+	{0x54, 0xc83d0000, 0x0010, 0x2a},	// 33
+	{0x54, 0xc83f0000, 0x0010, 0x4e},	// 33
+	{0x54, 0xc83e0000, 0x0011, 0x01},	// 33
+	{0x54, 0xc83e8000, 0x0011, 0x59},	// 33
+	{0x55, 0x00000000, 0x0001, 0x6e},	// 23
+	{0x55, 0x80000000, 0x0002, 0x70},	// 23
+	{0x55, 0xd0000000, 0x0004, 0x4b},	// 23
+	{0x55, 0xf0000000, 0x0004, 0x6c},	// 23
+	{0x55, 0xc0000000, 0x0005, 0x52},	// 23
+	{0x55, 0xe0000000, 0x0005, 0x53},	// 23
+	{0x55, 0xcc000000, 0x0006, 0x45},	// 23
+	{0x55, 0xec000000, 0x0006, 0x73},	// 23
+	{0x55, 0xca000000, 0x0007, 0x67},	// 23
+	{0x55, 0xea000000, 0x0007, 0x54},	// 23
+	{0x55, 0xc9000000, 0x0008, 0x20},	// 23
+	{0x55, 0xc8000000, 0x0009, 0x2d},	// 23
+	{0x55, 0xc8800000, 0x0009, 0x72},	// 23
+	{0x55, 0xe8000000, 0x0009, 0x32},	// 23
+	{0x55, 0xe8800000, 0x0009, 0x6d},	// 23
+	{0x55, 0xe9800000, 0x0009, 0x00},	// 23
+	{0x55, 0xe9000000, 0x000a, 0x2e},	// 23
+	{0x55, 0xe9400000, 0x000b, 0x63},	// 23
+	{0x55, 0xe9600000, 0x000c, 0x6b},	// 23
+	{0x55, 0xe9700000, 0x000e, 0x01},	// 23
+	{0x55, 0xe9740000, 0x000e, 0x7a},	// 23
+	{0x55, 0xe9780000, 0x000e, 0x74},	// 23
+	{0x55, 0xe97c0000, 0x000e, 0x42},	// 23
+	{0x56, 0x80000000, 0x0001, 0x20},	// 21
+	{0x56, 0x00000000, 0x0003, 0x3a},	// 21
+	{0x56, 0x60000000, 0x0003, 0x69},	// 21
+	{0x56, 0x20000000, 0x0004, 0x65},	// 21
+	{0x56, 0x30000000, 0x0004, 0x61},	// 21
+	{0x56, 0x40000000, 0x0004, 0x33},	// 21
+	{0x56, 0x54000000, 0x0006, 0x43},	// 21
+	{0x56, 0x5c000000, 0x0006, 0x00},	// 21
+	{0x56, 0x50000000, 0x0007, 0x27},	// 21
+	{0x56, 0x52000000, 0x0007, 0x34},	// 21
+	{0x56, 0x5a000000, 0x0007, 0x6f},	// 21
+	{0x56, 0x59000000, 0x0008, 0x49},	// 21
+	{0x56, 0x58000000, 0x000a, 0x73},	// 21
+	{0x56, 0x58400000, 0x000a, 0x44},	// 21
+	{0x56, 0x58800000, 0x000a, 0x2e},	// 21
+	{0x56, 0x58c00000, 0x000b, 0x38},	// 21
+	{0x56, 0x58e80000, 0x000d, 0x75},	// 21
+	{0x56, 0x58f00000, 0x000d, 0x72},	// 21
+	{0x56, 0x58f80000, 0x000d, 0x42},	// 21
+	{0x56, 0x58e00000, 0x000e, 0x01},	// 21
+	{0x56, 0x58e40000, 0x000e, 0x45},	// 21
+	{0x57, 0x40000000, 0x0002, 0x6f},	// 18
+	{0x57, 0xc0000000, 0x0002, 0x65},	// 18
+	{0x57, 0x20000000, 0x0003, 0x68},	// 18
+	{0x57, 0x80000000, 0x0003, 0x61},	// 18
+	{0x57, 0xa0000000, 0x0003, 0x69},	// 18
+	{0x57, 0x00000000, 0x0005, 0x2e},	// 18
+	{0x57, 0x10000000, 0x0005, 0x4f},	// 18
+	{0x57, 0x18000000, 0x0005, 0x72},	// 18
+	{0x57, 0x0c000000, 0x0006, 0x79},	// 18
+	{0x57, 0x08000000, 0x0007, 0x75},	// 18
+	{0x57, 0x0a000000, 0x0008, 0x00},	// 18
+	{0x57, 0x0b800000, 0x0009, 0x41},	// 18
+	{0x57, 0x0b200000, 0x000b, 0x59},	// 18
+	{0x57, 0x0b400000, 0x000b, 0x54},	// 18
+	{0x57, 0x0b600000, 0x000b, 0x20},	// 18
+	{0x57, 0x0b000000, 0x000c, 0x49},	// 18
+	{0x57, 0x0b100000, 0x000d, 0x01},	// 18
+	{0x57, 0x0b180000, 0x000d, 0x6c},	// 18
+	{0x58, 0x00000000, 0x0002, 0x00},	// 14
+	{0x58, 0x80000000, 0x0002, 0x20},	// 14
+	{0x58, 0xc0000000, 0x0002, 0x74},	// 14
+	{0x58, 0x40000000, 0x0003, 0x54},	// 14
+	{0x58, 0x70000000, 0x0004, 0x63},	// 14
+	{0x58, 0x68000000, 0x0005, 0x6d},	// 14
+	{0x58, 0x64000000, 0x0006, 0x55},	// 14
+	{0x58, 0x60000000, 0x0008, 0x61},	// 14
+	{0x58, 0x61000000, 0x0008, 0x58},	// 14
+	{0x58, 0x62000000, 0x0008, 0x2d},	// 14
+	{0x58, 0x63000000, 0x0009, 0x78},	// 14
+	{0x58, 0x63c00000, 0x000a, 0x39},	// 14
+	{0x58, 0x63800000, 0x000b, 0x01},	// 14
+	{0x58, 0x63a00000, 0x000b, 0x69},	// 14
+	{0x59, 0x80000000, 0x0001, 0x6f},	// 19
+	{0x59, 0x40000000, 0x0002, 0x65},	// 19
+	{0x59, 0x00000000, 0x0003, 0x75},	// 19
+	{0x59, 0x30000000, 0x0004, 0x20},	// 19
+	{0x59, 0x20000000, 0x0005, 0x76},	// 19
+	{0x59, 0x28000000, 0x0006, 0x61},	// 19
+	{0x59, 0x2e000000, 0x0008, 0x50},	// 19
+	{0x59, 0x2f000000, 0x0008, 0x27},	// 19
+	{0x59, 0x2c000000, 0x0009, 0x6e},	// 19
+	{0x59, 0x2d800000, 0x0009, 0x72},	// 19
+	{0x59, 0x2c800000, 0x000a, 0x44},	// 19
+	{0x59, 0x2cc00000, 0x000b, 0x77},	// 19
+	{0x59, 0x2ce00000, 0x000b, 0x73},	// 19
+	{0x59, 0x2d000000, 0x000b, 0x52},	// 19
+	{0x59, 0x2d200000, 0x000b, 0x4c},	// 19
+	{0x59, 0x2d400000, 0x000b, 0x00},	// 19
+	{0x59, 0x2d600000, 0x000c, 0x43},	// 19
+	{0x59, 0x2d700000, 0x000d, 0x01},	// 19
+	{0x59, 0x2d780000, 0x000d, 0x4e},	// 19
+	{0x5a, 0x80000000, 0x0001, 0x6f},	// 11
+	{0x5a, 0x00000000, 0x0002, 0x61},	// 11
+	{0x5a, 0x40000000, 0x0003, 0x69},	// 11
+	{0x5a, 0x60000000, 0x0005, 0x4f},	// 11
+	{0x5a, 0x68000000, 0x0005, 0x75},	// 11
+	{0x5a, 0x70000000, 0x0005, 0x65},	// 11
+	{0x5a, 0x78000000, 0x0006, 0x20},	// 11
+	{0x5a, 0x7e000000, 0x0007, 0x00},	// 11
+	{0x5a, 0x7d000000, 0x0008, 0x3a},	// 11
+	{0x5a, 0x7c000000, 0x0009, 0x01},	// 11
+	{0x5a, 0x7c800000, 0x0009, 0x2d},	// 11
+	{0x5b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x5c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5c, 0x80000000, 0x0001, 0x78},	// 2
+	{0x5d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x5e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x5f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x60, 0x00000000, 0x0001, 0x01},	// 2
+	{0x60, 0x80000000, 0x0001, 0x01},	// 2
+	{0x61, 0x20000000, 0x0003, 0x72},	// 39
+	{0x61, 0x60000000, 0x0003, 0x74},	// 39
+	{0x61, 0x80000000, 0x0003, 0x6c},	// 39
+	{0x61, 0xc0000000, 0x0003, 0x6e},	// 39
+	{0x61, 0x10000000, 0x0004, 0x6d},	// 39
+	{0x61, 0x40000000, 0x0004, 0x63},	// 39
+	{0x61, 0xa0000000, 0x0004, 0x73},	// 39
+	{0x61, 0xe0000000, 0x0004, 0x79},	// 39
+	{0x61, 0xb0000000, 0x0005, 0x20},	// 39
+	{0x61, 0xb8000000, 0x0005, 0x64},	// 39
+	{0x61, 0xf0000000, 0x0005, 0x69},	// 39
+	{0x61, 0xf8000000, 0x0005, 0x6b},	// 39
+	{0x61, 0x08000000, 0x0006, 0x62},	// 39
+	{0x61, 0x0c000000, 0x0006, 0x00},	// 39
+	{0x61, 0x58000000, 0x0006, 0x70},	// 39
+	{0x61, 0x5c000000, 0x0006, 0x67},	// 39
+	{0x61, 0x00000000, 0x0007, 0x65},	// 39
+	{0x61, 0x02000000, 0x0007, 0x27},	// 39
+	{0x61, 0x06000000, 0x0007, 0x77},	// 39
+	{0x61, 0x52000000, 0x0007, 0x75},	// 39
+	{0x61, 0x54000000, 0x0007, 0x7a},	// 39
+	{0x61, 0x56000000, 0x0007, 0x76},	// 39
+	{0x61, 0x05000000, 0x0008, 0x66},	// 39
+	{0x61, 0x51000000, 0x0008, 0x68},	// 39
+	{0x61, 0x04800000, 0x0009, 0x3a},	// 39
+	{0x61, 0x04000000, 0x000a, 0x21},	// 39
+	{0x61, 0x50000000, 0x000a, 0x6f},	// 39
+	{0x61, 0x50400000, 0x000a, 0x78},	// 39
+	{0x61, 0x04400000, 0x000b, 0x2d},	// 39
+	{0x61, 0x04600000, 0x000b, 0x61},	// 39
+	{0x61, 0x50a00000, 0x000b, 0x2e},	// 39
+	{0x61, 0x50c00000, 0x000b, 0x4e},	// 39
+	{0x61, 0x50e00000, 0x000b, 0x2c},	// 39
+	{0x61, 0x50800000, 0x000c, 0x71},	// 39
+	{0x61, 0x50900000, 0x000d, 0x6a},	// 39
+	{0x61, 0x509c0000, 0x000e, 0x3f},	// 39
+	{0x61, 0x509a0000, 0x000f, 0x4a},	// 39
+	{0x61, 0x50980000, 0x0010, 0x01},	// 39
+	{0x61, 0x50990000, 0x0010, 0x55},	// 39
+	{0x62, 0x00000000, 0x0003, 0x72},	// 24
+	{0x62, 0x20000000, 0x0003, 0x6f},	// 24
+	{0x62, 0x40000000, 0x0003, 0x65},	// 24
+	{0x62, 0x60000000, 0x0003, 0x61},	// 24
+	{0x62, 0x80000000, 0x0003, 0x69},	// 24
+	{0x62, 0xb0000000, 0x0004, 0x75},	// 24
+	{0x62, 0xc0000000, 0x0004, 0x79},	// 24
+	{0x62, 0xd0000000, 0x0004, 0x6c},	// 24
+	{0x62, 0xf0000000, 0x0004, 0x20},	// 24
+	{0x62, 0xa8000000, 0x0005, 0x73},	// 24
+	{0x62, 0xe0000000, 0x0005, 0x62},	// 24
+	{0x62, 0xe8000000, 0x0005, 0x00},	// 24
+	{0x62, 0xa0000000, 0x0006, 0x68},	// 24
+	{0x62, 0xa4000000, 0x0007, 0x33},	// 24
+	{0x62, 0xa7000000, 0x0008, 0x27},	// 24
+	{0x62, 0xa6400000, 0x000a, 0x74},	// 24
+	{0x62, 0xa6800000, 0x000a, 0x6a},	// 24
+	{0x62, 0xa6000000, 0x000b, 0x6e},	// 24
+	{0x62, 0xa6200000, 0x000b, 0x64},	// 24
+	{0x62, 0xa6e00000, 0x000b, 0x77},	// 24
+	{0x62, 0xa6d00000, 0x000c, 0x6d},	// 24
+	{0x62, 0xa6c80000, 0x000d, 0x2e},	// 24
+	{0x62, 0xa6c00000, 0x000e, 0x01},	// 24
+	{0x62, 0xa6c40000, 0x000e, 0x3a},	// 24
+	{0x63, 0x00000000, 0x0002, 0x6b},	// 37
+	{0x63, 0x40000000, 0x0003, 0x6f},	// 37
+	{0x63, 0x80000000, 0x0003, 0x68},	// 37
+	{0x63, 0xc0000000, 0x0003, 0x74},	// 37
+	{0x63, 0xe0000000, 0x0003, 0x65},	// 37
+	{0x63, 0x70000000, 0x0004, 0x72},	// 37
+	{0x63, 0xa0000000, 0x0005, 0x20},	// 37
+	{0x63, 0xb0000000, 0x0005, 0x69},	// 37
+	{0x63, 0xb8000000, 0x0005, 0x61},	// 37
+	{0x63, 0x60000000, 0x0006, 0x6c},	// 37
+	{0x63, 0x64000000, 0x0006, 0x79},	// 37
+	{0x63, 0x68000000, 0x0006, 0x73},	// 37
+	{0x63, 0x6c000000, 0x0006, 0x00},	// 37
+	{0x63, 0xa8000000, 0x0007, 0x63},	// 37
+	{0x63, 0xae000000, 0x0007, 0x75},	// 37
+	{0x63, 0xaa000000, 0x0008, 0x3a},	// 37
+	{0x63, 0xab000000, 0x0008, 0x50},	// 37
+	{0x63, 0xac800000, 0x0009, 0x44},	// 37
+	{0x63, 0xad000000, 0x000a, 0x47},	// 37
+	{0x63, 0xad800000, 0x000a, 0x62},	// 37
+	{0x63, 0xac000000, 0x000b, 0x4c},	// 37
+	{0x63, 0xac200000, 0x000b, 0x4b},	// 37
+	{0x63, 0xac600000, 0x000b, 0x41},	// 37
+	{0x63, 0xad400000, 0x000b, 0x71},	// 37
+	{0x63, 0xadc00000, 0x000b, 0x2e},	// 37
+	{0x63, 0xade00000, 0x000b, 0x43},	// 37
+	{0x63, 0xac400000, 0x000c, 0x6e},	// 37
+	{0x63, 0xac500000, 0x000c, 0x27},	// 37
+	{0x63, 0xad600000, 0x000d, 0x42},	// 37
+	{0x63, 0xad680000, 0x000d, 0x49},	// 37
+	{0x63, 0xad740000, 0x000e, 0x66},	// 37
+	{0x63, 0xad780000, 0x000e, 0x38},	// 37
+	{0x63, 0xad700000, 0x000f, 0x4d},	// 37
+	{0x63, 0xad720000, 0x000f, 0x01},	// 37
+	{0x63, 0xad7e0000, 0x000f, 0x46},	// 37
+	{0x63, 0xad7c0000, 0x0010, 0x77},	// 37
+	{0x63, 0xad7d0000, 0x0010, 0x51},	// 37
+	{0x64, 0xc0000000, 0x0002, 0x20},	// 36
+	{0x64, 0x20000000, 0x0003, 0x65},	// 36
+	{0x64, 0x80000000, 0x0003, 0x00},	// 36
+	{0x64, 0xa0000000, 0x0003, 0x61},	// 36
+	{0x64, 0x10000000, 0x0004, 0x79},	// 36
+	{0x64, 0x40000000, 0x0004, 0x69},	// 36
+	{0x64, 0x60000000, 0x0004, 0x73},	// 36
+	{0x64, 0x00000000, 0x0005, 0x6f},	// 36
+	{0x64, 0x50000000, 0x0005, 0x64},	// 36
+	{0x64, 0x0c000000, 0x0006, 0x75},	// 36
+	{0x64, 0x58000000, 0x0006, 0x72},	// 36
+	{0x64, 0x5c000000, 0x0006, 0x6c},	// 36
+	{0x64, 0x74000000, 0x0006, 0x76},	// 36
+	{0x64, 0x78000000, 0x0006, 0x67},	// 36
+	{0x64, 0x08000000, 0x0007, 0x27},	// 36
+	{0x64, 0x7e000000, 0x0007, 0x2e},	// 36
+	{0x64, 0x0a000000, 0x0008, 0x3a},	// 36
+	{0x64, 0x0b000000, 0x0008, 0x68},	// 36
+	{0x64, 0x70000000, 0x0008, 0x63},	// 36
+	{0x64, 0x72000000, 0x0008, 0x6e},	// 36
+	{0x64, 0x73000000, 0x0008, 0x77},	// 36
+	{0x64, 0x71000000, 0x0009, 0x3f},	// 36
+	{0x64, 0x7c000000, 0x0009, 0x21},	// 36
+	{0x64, 0x7c800000, 0x0009, 0x2d},	// 36
+	{0x64, 0x7d000000, 0x0009, 0x66},	// 36
+	{0x64, 0x71c00000, 0x000a, 0x6d},	// 36
+	{0x64, 0x7d800000, 0x000a, 0x2c},	// 36
+	{0x64, 0x7dc00000, 0x000b, 0x74},	// 36
+	{0x64, 0x7de00000, 0x000b, 0x62},	// 36
+	{0x64, 0x71900000, 0x000c, 0x29},	// 36
+	{0x64, 0x71a00000, 0x000c, 0x2f},	// 36
+	{0x64, 0x71b00000, 0x000c, 0x6b},	// 36
+	{0x64, 0x71880000, 0x000d, 0x70},	// 36
+	{0x64, 0x71840000, 0x000e, 0x7a},	// 36
+	{0x64, 0x71800000, 0x000f, 0x01},	// 36
+	{0x64, 0x71820000, 0x000f, 0x34},	// 36
+	{0x65, 0x40000000, 0x0002, 0x20},	// 42
+	{0x65, 0x00000000, 0x0003, 0x73},	// 42
+	{0x65, 0xa0000000, 0x0003, 0x72},	// 42
+	{0x65, 0x20000000, 0x0004, 0x74},	// 42
+	{0x65, 0x90000000, 0x0004, 0x6e},	// 42
+	{0x65, 0xc0000000, 0x0004, 0x00},	// 42
+	{0x65, 0xe0000000, 0x0004, 0x61},	// 42
+	{0x65, 0xf0000000, 0x0004, 0x77},	// 42
+	{0x65, 0x80000000, 0x0005, 0x6c},	// 42
+	{0x65, 0xd8000000, 0x0005, 0x65},	// 42
+	{0x65, 0x38000000, 0x0006, 0x6d},	// 42
+	{0x65, 0x88000000, 0x0006, 0x63},	// 42
+	{0x65, 0x8c000000, 0x0006, 0x64},	// 42
+	{0x65, 0x34000000, 0x0007, 0x69},	// 42
+	{0x65, 0x36000000, 0x0007, 0x70},	// 42
+	{0x65, 0x3c000000, 0x0007, 0x62},	// 42
+	{0x65, 0xd0000000, 0x0007, 0x76},	// 42
+	{0x65, 0xd6000000, 0x0007, 0x79},	// 42
+	{0x65, 0x30000000, 0x0008, 0x67},	// 42
+	{0x65, 0x31000000, 0x0008, 0x66},	// 42
+	{0x65, 0x32000000, 0x0008, 0x78},	// 42
+	{0x65, 0x3e000000, 0x0008, 0x6b},	// 42
+	{0x65, 0x3f000000, 0x0008, 0x3a},	// 42
+	{0x65, 0xd3000000, 0x0008, 0x6f},	// 42
+	{0x65, 0xd4000000, 0x0008, 0x27},	// 42
+	{0x65, 0x33800000, 0x0009, 0x68},	// 42
+	{0x65, 0xd2800000, 0x0009, 0x2e},	// 42
+	{0x65, 0x33000000, 0x000a, 0x50},	// 42
+	{0x65, 0x33400000, 0x000a, 0x42},	// 42
+	{0x65, 0xd2000000, 0x000a, 0x2c},	// 42
+	{0x65, 0xd5000000, 0x000a, 0x56},	// 42
+	{0x65, 0xd5400000, 0x000a, 0x7a},	// 42
+	{0x65, 0xd5c00000, 0x000a, 0x6a},	// 42
+	{0x65, 0xd2400000, 0x000b, 0x34},	// 42
+	{0x65, 0xd2600000, 0x000b, 0x3f},	// 42
+	{0x65, 0xd5a00000, 0x000b, 0x75},	// 42
+	{0x65, 0xd5900000, 0x000c, 0x2d},	// 42
+	{0x65, 0xd5880000, 0x000d, 0x21},	// 42
+	{0x65, 0xd5840000, 0x000e, 0x71},	// 42
+	{0x65, 0xd5820000, 0x000f, 0x47},	// 42
+	{0x65, 0xd5800000, 0x0010, 0x01},	// 42
+	{0x65, 0xd5810000, 0x0010, 0x53},	// 42
+	{0x66, 0x00000000, 0x0001, 0x20},	// 24
+	{0x66, 0xa0000000, 0x0003, 0x6f},	// 24
+	{0x66, 0x90000000, 0x0004, 0x74},	// 24
+	{0x66, 0xc0000000, 0x0004, 0x61},	// 24
+	{0x66, 0xd0000000, 0x0004, 0x69},	// 24
+	{0x66, 0xf0000000, 0x0004, 0x65},	// 24
+	{0x66, 0x80000000, 0x0005, 0x2e},	// 24
+	{0x66, 0xe0000000, 0x0005, 0x72},	// 24
+	{0x66, 0xe8000000, 0x0005, 0x66},	// 24
+	{0x66, 0x88000000, 0x0006, 0x00},	// 24
+	{0x66, 0x8d000000, 0x0008, 0x79},	// 24
+	{0x66, 0x8f000000, 0x0008, 0x75},	// 24
+	{0x66, 0x8c000000, 0x0009, 0x27},	// 24
+	{0x66, 0x8e800000, 0x0009, 0x6c},	// 24
+	{0x66, 0x8cc00000, 0x000a, 0x6e},	// 24
+	{0x66, 0x8e000000, 0x000a, 0x67},	// 24
+	{0x66, 0x8c800000, 0x000b, 0x63},	// 24
+	{0x66, 0x8e400000, 0x000b, 0x2d},	// 24
+	{0x66, 0x8ca00000, 0x000c, 0x2c},	// 24
+	{0x66, 0x8cb00000, 0x000c, 0x73},	// 24
+	{0x66, 0x8e700000, 0x000c, 0x3a},	// 24
+	{0x66, 0x8e680000, 0x000d, 0x6b},	// 24
+	{0x66, 0x8e600000, 0x000e, 0x01},	// 24
+	{0x66, 0x8e640000, 0x000e, 0x62},	// 24
+	{0x67, 0x00000000, 0x0002, 0x68},	// 33
+	{0x67, 0x80000000, 0x0002, 0x20},	// 33
+	{0x67, 0x40000000, 0x0003, 0x00},	// 33
+	{0x67, 0x60000000, 0x0003, 0x65},	// 33
+	{0x67, 0xc0000000, 0x0004, 0x69},	// 33
+	{0x67, 0xe0000000, 0x0005, 0x3a},	// 33
+	{0x67, 0xe8000000, 0x0005, 0x72},	// 33
+	{0x67, 0xf8000000, 0x0005, 0x61},	// 33
+	{0x67, 0xd0000000, 0x0006, 0x73},	// 33
+	{0x67, 0xdc000000, 0x0006, 0x6c},	// 33
+	{0x67, 0xf4000000, 0x0006, 0x75},	// 33
+	{0x67, 0xd6000000, 0x0007, 0x62},	// 33
+	{0x67, 0xd8000000, 0x0007, 0x67},	// 33
+	{0x67, 0xda000000, 0x0007, 0x6f},	// 33
+	{0x67, 0xf2000000, 0x0007, 0x6e},	// 33
+	{0x67, 0xd4000000, 0x0008, 0x32},	// 33
+	{0x67, 0xf0000000, 0x0008, 0x21},	// 33
+	{0x67, 0xf1800000, 0x0009, 0x64},	// 33
+	{0x67, 0xd5000000, 0x000a, 0x2e},	// 33
+	{0x67, 0xd5400000, 0x000a, 0x2c},	// 33
+	{0x67, 0xd5800000, 0x000a, 0x27},	// 33
+	{0x67, 0xd5c00000, 0x000a, 0x74},	// 33
+	{0x67, 0xf1400000, 0x000a, 0x79},	// 33
+	{0x67, 0xf1000000, 0x000b, 0x77},	// 33
+	{0x67, 0xf1300000, 0x000c, 0x6d},	// 33
+	{0x67, 0xf12c0000, 0x000e, 0x3f},	// 33
+	{0x67, 0xf1200000, 0x000f, 0x70},	// 33
+	{0x67, 0xf1220000, 0x000f, 0x66},	// 33
+	{0x67, 0xf1240000, 0x000f, 0x40},	// 33
+	{0x67, 0xf1260000, 0x000f, 0x2d},	// 33
+	{0x67, 0xf12a0000, 0x000f, 0x3b},	// 33
+	{0x67, 0xf1280000, 0x0010, 0x01},	// 33
+	{0x67, 0xf1290000, 0x0010, 0x7a},	// 33
+	{0x68, 0x00000000, 0x0001, 0x65},	// 31
+	{0x68, 0xa0000000, 0x0003, 0x6f},	// 31
+	{0x68, 0x90000000, 0x0004, 0x69},	// 31
+	{0x68, 0xc0000000, 0x0004, 0x61},	// 31
+	{0x68, 0xe0000000, 0x0004, 0x20},	// 31
+	{0x68, 0xf0000000, 0x0004, 0x74},	// 31
+	{0x68, 0xd0000000, 0x0005, 0x72},	// 31
+	{0x68, 0xd8000000, 0x0005, 0x00},	// 31
+	{0x68, 0x80000000, 0x0006, 0x62},	// 31
+	{0x68, 0x84000000, 0x0006, 0x75},	// 31
+	{0x68, 0x88000000, 0x0008, 0x77},	// 31
+	{0x68, 0x89000000, 0x0008, 0x64},	// 31
+	{0x68, 0x8a000000, 0x0008, 0x6e},	// 31
+	{0x68, 0x8b000000, 0x0008, 0x79},	// 31
+	{0x68, 0x8c000000, 0x0008, 0x21},	// 31
+	{0x68, 0x8d000000, 0x0008, 0x6c},	// 31
+	{0x68, 0x8f000000, 0x0008, 0x2e},	// 31
+	{0x68, 0x8e000000, 0x0009, 0x27},	// 31
+	{0x68, 0x8e800000, 0x000a, 0x73},	// 31
+	{0x68, 0x8ec00000, 0x000b, 0x6d},	// 31
+	{0x68, 0x8ef00000, 0x000c, 0x3a},	// 31
+	{0x68, 0x8ee00000, 0x000e, 0x66},	// 31
+	{0x68, 0x8ee40000, 0x000e, 0x3f},	// 31
+	{0x68, 0x8ee80000, 0x000e, 0x63},	// 31
+	{0x68, 0x8eec0000, 0x0010, 0x76},	// 31
+	{0x68, 0x8eed0000, 0x0010, 0x71},	// 31
+	{0x68, 0x8eee0000, 0x0010, 0x67},	// 31
+	{0x68, 0x8eef0000, 0x0012, 0x68},	// 31
+	{0x68, 0x8eef4000, 0x0012, 0x01},	// 31
+	{0x68, 0x8eef8000, 0x0012, 0x2c},	// 31
+	{0x68, 0x8eefc000, 0x0012, 0x2a},	// 31
+	{0x69, 0x40000000, 0x0002, 0x6e},	// 35
+	{0x69, 0x00000000, 0x0003, 0x63},	// 35
+	{0x69, 0x90000000, 0x0004, 0x6f},	// 35
+	{0x69, 0xa0000000, 0x0004, 0x6c},	// 35
+	{0x69, 0xc0000000, 0x0004, 0x67},	// 35
+	{0x69, 0xd0000000, 0x0004, 0x73},	// 35
+	{0x69, 0xe0000000, 0x0004, 0x74},	// 35
+	{0x69, 0xf0000000, 0x0004, 0x65},	// 35
+	{0x69, 0x28000000, 0x0005, 0x61},	// 35
+	{0x69, 0x30000000, 0x0005, 0x76},	// 35
+	{0x69, 0x80000000, 0x0005, 0x72},	// 35
+	{0x69, 0x88000000, 0x0005, 0x64},	// 35
+	{0x69, 0xb0000000, 0x0005, 0x6d},	// 35
+	{0x69, 0x20000000, 0x0006, 0x70},	// 35
+	{0x69, 0x38000000, 0x0006, 0x20},	// 35
+	{0x69, 0xbc000000, 0x0006, 0x66},	// 35
+	{0x69, 0x3c000000, 0x0007, 0x7a},	// 35
+	{0x69, 0x3e000000, 0x0007, 0x00},	// 35
+	{0x69, 0xb8000000, 0x0007, 0x62},	// 35
+	{0x69, 0xba000000, 0x0007, 0x6b},	// 35
+	{0x69, 0x25000000, 0x0008, 0x2d},	// 35
+	{0x69, 0x26000000, 0x0008, 0x78},	// 35
+	{0x69, 0x24800000, 0x0009, 0x27},	// 35
+	{0x69, 0x27800000, 0x0009, 0x71},	// 35
+	{0x69, 0x27000000, 0x000a, 0x75},	// 35
+	{0x69, 0x27400000, 0x000a, 0x69},	// 35
+	{0x69, 0x24200000, 0x000b, 0x68},	// 35
+	{0x69, 0x24400000, 0x000b, 0x3a},	// 35
+	{0x69, 0x24600000, 0x000b, 0x77},	// 35
+	{0x69, 0x24080000, 0x000d, 0x2c},	// 35
+	{0x69, 0x24100000, 0x000d, 0x79},	// 35
+	{0x69, 0x24180000, 0x000d, 0x2f},	// 35
+	{0x69, 0x24000000, 0x000e, 0x2e},	// 35
+	{0x69, 0x24040000, 0x000f, 0x01},	// 35
+	{0x69, 0x24060000, 0x000f, 0x6a},	// 35
+	{0x6a, 0x00000000, 0x0001, 0x79},	// 9
+	{0x6a, 0xc0000000, 0x0002, 0x6f},	// 9
+	{0x6a, 0xa0000000, 0x0003, 0x65},	// 9
+	{0x6a, 0x90000000, 0x0004, 0x61},	// 9
+	{0x6a, 0x88000000, 0x0005, 0x75},	// 9
+	{0x6a, 0x84000000, 0x0006, 0x69},	// 9
+	{0x6a, 0x80000000, 0x0007, 0x00},	// 9
+	{0x6a, 0x82000000, 0x0008, 0x01},	// 9
+	{0x6a, 0x83000000, 0x0008, 0x20},	// 9
+	{0x6b, 0x00000000, 0x0002, 0x20},	// 33
+	{0x6b, 0x80000000, 0x0002, 0x65},	// 33
+	{0x6b, 0x40000000, 0x0003, 0x69},	// 33
+	{0x6b, 0xc0000000, 0x0003, 0x00},	// 33
+	{0x6b, 0x60000000, 0x0004, 0x79},	// 33
+	{0x6b, 0x70000000, 0x0004, 0x73},	// 33
+	{0x6b, 0xf0000000, 0x0004, 0x66},	// 33
+	{0x6b, 0xe4000000, 0x0006, 0x61},	// 33
+	{0x6b, 0xe8000000, 0x0006, 0x6c},	// 33
+	{0x6b, 0xe2000000, 0x0007, 0x3a},	// 33
+	{0x6b, 0xec000000, 0x0007, 0x6b},	// 33
+	{0x6b, 0xe0000000, 0x0008, 0x27},	// 33
+	{0x6b, 0xef000000, 0x0008, 0x2e},	// 33
+	{0x6b, 0xe1800000, 0x0009, 0x77},	// 33
+	{0x6b, 0xee000000, 0x0009, 0x6f},	// 33
+	{0x6b, 0xe1400000, 0x000a, 0x68},	// 33
+	{0x6b, 0xe1000000, 0x000b, 0x62},	// 33
+	{0x6b, 0xe1200000, 0x000b, 0x2c},	// 33
+	{0x6b, 0xeee00000, 0x000b, 0x6e},	// 33
+	{0x6b, 0xeea00000, 0x000c, 0x3f},	// 33
+	{0x6b, 0xeec00000, 0x000c, 0x6d},	// 33
+	{0x6b, 0xeed00000, 0x000c, 0x21},	// 33
+	{0x6b, 0xee900000, 0x000d, 0x75},	// 33
+	{0x6b, 0xee980000, 0x000d, 0x63},	// 33
+	{0x6b, 0xeeb00000, 0x000d, 0x64},	// 33
+	{0x6b, 0xeeb80000, 0x000d, 0x74},	// 33
+	{0x6b, 0xee840000, 0x000e, 0x6a},	// 33
+	{0x6b, 0xee880000, 0x000e, 0x2d},	// 33
+	{0x6b, 0xee800000, 0x000f, 0x70},	// 33
+	{0x6b, 0xee820000, 0x000f, 0x2f},	// 33
+	{0x6b, 0xee8e0000, 0x000f, 0x53},	// 33
+	{0x6b, 0xee8c0000, 0x0010, 0x01},	// 33
+	{0x6b, 0xee8d0000, 0x0010, 0x72},	// 33
+	{0x6c, 0x40000000, 0x0002, 0x65},	// 36
+	{0x6c, 0x00000000, 0x0003, 0x6c},	// 36
+	{0x6c, 0xa0000000, 0x0003, 0x61},	// 36
+	{0x6c, 0x30000000, 0x0004, 0x79},	// 36
+	{0x6c, 0x80000000, 0x0004, 0x00},	// 36
+	{0x6c, 0x90000000, 0x0004, 0x64},	// 36
+	{0x6c, 0xc0000000, 0x0004, 0x6f},	// 36
+	{0x6c, 0xe0000000, 0x0004, 0x69},	// 36
+	{0x6c, 0xf0000000, 0x0004, 0x20},	// 36
+	{0x6c, 0x20000000, 0x0005, 0x75},	// 36
+	{0x6c, 0xd0000000, 0x0005, 0x73},	// 36
+	{0x6c, 0x28000000, 0x0006, 0x74},	// 36
+	{0x6c, 0x2c000000, 0x0006, 0x6d},	// 36
+	{0x6c, 0xda000000, 0x0007, 0x6b},	// 36
+	{0x6c, 0xd8000000, 0x0008, 0x66},	// 36
+	{0x6c, 0xdc000000, 0x0008, 0x62},	// 36
+	{0x6c, 0xde000000, 0x0008, 0x27},	// 36
+	{0x6c, 0xdf000000, 0x0008, 0x63},	// 36
+	{0x6c, 0xd9800000, 0x0009, 0x76},	// 36
+	{0x6c, 0xdd000000, 0x0009, 0x3a},	// 36
+	{0x6c, 0xd9400000, 0x000a, 0x2e},	// 36
+	{0x6c, 0xdd800000, 0x000a, 0x77},	// 36
+	{0x6c, 0xd9000000, 0x000b, 0x7a},	// 36
+	{0x6c, 0xdde00000, 0x000b, 0x70},	// 36
+	{0x6c, 0xd9200000, 0x000c, 0x68},	// 36
+	{0x6c, 0xd9300000, 0x000c, 0x2a},	// 36
+	{0x6c, 0xddc00000, 0x000d, 0x67},	// 36
+	{0x6c, 0xddc80000, 0x000d, 0x2c},	// 36
+	{0x6c, 0xddd00000, 0x000e, 0x72},	// 36
+	{0x6c, 0xddd40000, 0x000e, 0x6e},	// 36
+	{0x6c, 0xdddc0000, 0x000e, 0x2d},	// 36
+	{0x6c, 0xddd80000, 0x000f, 0x21},	// 36
+	{0x6c, 0xdddb0000, 0x0010, 0x3f},	// 36
+	{0x6c, 0xddda8000, 0x0011, 0x43},	// 36
+	{0x6c, 0xddda0000, 0x0012, 0x01},	// 36
+	{0x6c, 0xddda4000, 0x0012, 0x6a},	// 36
+	{0x6d, 0x80000000, 0x0002, 0x65},	// 25
+	{0x6d, 0x20000000, 0x0003, 0x6d},	// 25
+	{0x6d, 0x60000000, 0x0003, 0x20},	// 25
+	{0x6d, 0xe0000000, 0x0003, 0x61},	// 25
+	{0x6d, 0x00000000, 0x0004, 0x69},	// 25
+	{0x6d, 0x10000000, 0x0004, 0x00},	// 25
+	{0x6d, 0x40000000, 0x0004, 0x79},	// 25
+	{0x6d, 0xd0000000, 0x0004, 0x70},	// 25
+	{0x6d, 0x50000000, 0x0005, 0x62},	// 25
+	{0x6d, 0xc0000000, 0x0005, 0x6f},	// 25
+	{0x6d, 0xc8000000, 0x0006, 0x6e},	// 25
+	{0x6d, 0xcc000000, 0x0006, 0x73},	// 25
+	{0x6d, 0x58000000, 0x0007, 0x6c},	// 25
+	{0x6d, 0x5c000000, 0x0007, 0x66},	// 25
+	{0x6d, 0x5a000000, 0x0008, 0x3a},	// 25
+	{0x6d, 0x5e000000, 0x0008, 0x34},	// 25
+	{0x6d, 0x5b000000, 0x0009, 0x68},	// 25
+	{0x6d, 0x5f000000, 0x0009, 0x77},	// 25
+	{0x6d, 0x5bc00000, 0x000a, 0x27},	// 25
+	{0x6d, 0x5f800000, 0x000a, 0x72},	// 25
+	{0x6d, 0x5fc00000, 0x000a, 0x75},	// 25
+	{0x6d, 0x5ba00000, 0x000b, 0x2e},	// 25
+	{0x6d, 0x5b900000, 0x000c, 0x6b},	// 25
+	{0x6d, 0x5b800000, 0x000d, 0x01},	// 25
+	{0x6d, 0x5b880000, 0x000d, 0x64},	// 25
+	{0x6e, 0x00000000, 0x0003, 0x69},	// 40
+	{0x6e, 0x80000000, 0x0003, 0x67},	// 40
+	{0x6e, 0xa0000000, 0x0003, 0x20},	// 40
+	{0x6e, 0xc0000000, 0x0003, 0x64},	// 40
+	{0x6e, 0x30000000, 0x0004, 0x61},	// 40
+	{0x6e, 0x40000000, 0x0004, 0x73},	// 40
+	{0x6e, 0x60000000, 0x0004, 0x65},	// 40
+	{0x6e, 0xe0000000, 0x0004, 0x00},	// 40
+	{0x6e, 0xf0000000, 0x0004, 0x74},	// 40
+	{0x6e, 0x70000000, 0x0005, 0x63},	// 40
+	{0x6e, 0x78000000, 0x0005, 0x6e},	// 40
+	{0x6e, 0x28000000, 0x0006, 0x79},	// 40
+	{0x6e, 0x50000000, 0x0006, 0x27},	// 40
+	{0x6e, 0x54000000, 0x0006, 0x6b},	// 40
+	{0x6e, 0x5c000000, 0x0006, 0x6f},	// 40
+	{0x6e, 0x20000000, 0x0007, 0x72},	// 40
+	{0x6e, 0x26000000, 0x0007, 0x66},	// 40
+	{0x6e, 0x2c000000, 0x0007, 0x75},	// 40
+	{0x6e, 0x2e000000, 0x0007, 0x6a},	// 40
+	{0x6e, 0x22000000, 0x0008, 0x76},	// 40
+	{0x6e, 0x24000000, 0x0008, 0x2d},	// 40
+	{0x6e, 0x25000000, 0x0008, 0x2e},	// 40
+	{0x6e, 0x58000000, 0x0008, 0x6c},	// 40
+	{0x6e, 0x5a000000, 0x0008, 0x78},	// 40
+	{0x6e, 0x5b000000, 0x0008, 0x3a},	// 40
+	{0x6e, 0x23800000, 0x0009, 0x2c},	// 40
+	{0x6e, 0x59800000, 0x0009, 0x6d},	// 40
+	{0x6e, 0x23000000, 0x000a, 0x21},	// 40
+	{0x6e, 0x23400000, 0x000b, 0x7a},	// 40
+	{0x6e, 0x59200000, 0x000b, 0x3f},	// 40
+	{0x6e, 0x59400000, 0x000b, 0x68},	// 40
+	{0x6e, 0x59600000, 0x000b, 0x62},	// 40
+	{0x6e, 0x23600000, 0x000c, 0x42},	// 40
+	{0x6e, 0x23700000, 0x000c, 0x2a},	// 40
+	{0x6e, 0x59000000, 0x000c, 0x77},	// 40
+	{0x6e, 0x59180000, 0x000d, 0x71},	// 40
+	{0x6e, 0x59140000, 0x000e, 0x70},	// 40
+	{0x6e, 0x59100000, 0x000f, 0x3b},	// 40
+	{0x6e, 0x59120000, 0x0010, 0x2f},	// 40
+	{0x6e, 0x59130000, 0x0010, 0x01},	// 40
+	{0x6f, 0x00000000, 0x0002, 0x72},	// 42
+	{0x6f, 0xc0000000, 0x0003, 0x6e},	// 42
+	{0x6f, 0x40000000, 0x0004, 0x66},	// 42
+	{0x6f, 0x50000000, 0x0004, 0x20},	// 42
+	{0x6f, 0x60000000, 0x0004, 0x77},	// 42
+	{0x6f, 0x80000000, 0x0004, 0x6f},	// 42
+	{0x6f, 0xb0000000, 0x0004, 0x75},	// 42
+	{0x6f, 0x78000000, 0x0005, 0x74},	// 42
+	{0x6f, 0x90000000, 0x0005, 0x63},	// 42
+	{0x6f, 0xa0000000, 0x0005, 0x70},	// 42
+	{0x6f, 0xa8000000, 0x0005, 0x64},	// 42
+	{0x6f, 0xe0000000, 0x0005, 0x6d},	// 42
+	{0x6f, 0xf0000000, 0x0005, 0x6c},	// 42
+	{0x6f, 0x70000000, 0x0006, 0x61},	// 42
+	{0x6f, 0x74000000, 0x0006, 0x62},	// 42
+	{0x6f, 0x98000000, 0x0006, 0x79},	// 42
+	{0x6f, 0x9c000000, 0x0006, 0x00},	// 42
+	{0x6f, 0xe8000000, 0x0006, 0x73},	// 42
+	{0x6f, 0xec000000, 0x0006, 0x6b},	// 42
+	{0x6f, 0xfa000000, 0x0007, 0x76},	// 42
+	{0x6f, 0xfc000000, 0x0007, 0x67},	// 42
+	{0x6f, 0xff000000, 0x0008, 0x69},	// 42
+	{0x6f, 0xf8800000, 0x0009, 0x68},	// 42
+	{0x6f, 0xf9000000, 0x0009, 0x21},	// 42
+	{0x6f, 0xfe000000, 0x0009, 0x65},	// 42
+	{0x6f, 0xfe800000, 0x0009, 0x6a},	// 42
+	{0x6f, 0xf9800000, 0x000a, 0x27},	// 42
+	{0x6f, 0xf8200000, 0x000b, 0x3f},	// 42
+	{0x6f, 0xf8400000, 0x000b, 0x3a},	// 42
+	{0x6f, 0xf9c00000, 0x000b, 0x7a},	// 42
+	{0x6f, 0xf9e00000, 0x000b, 0x78},	// 42
+	{0x6f, 0xf8000000, 0x000c, 0x4a},	// 42
+	{0x6f, 0xf8600000, 0x000c, 0x2e},	// 42
+	{0x6f, 0xf8700000, 0x000c, 0x2d},	// 42
+	{0x6f, 0xf8100000, 0x000e, 0x34},	// 42
+	{0x6f, 0xf8180000, 0x000e, 0x2c},	// 42
+	{0x6f, 0xf81c0000, 0x000e, 0x47},	// 42
+	{0x6f, 0xf8160000, 0x000f, 0x29},	// 42
+	{0x6f, 0xf8140000, 0x0010, 0x53},	// 42
+	{0x6f, 0xf8150000, 0x0011, 0x44},	// 42
+	{0x6f, 0xf8158000, 0x0012, 0x01},	// 42
+	{0x6f, 0xf815c000, 0x0012, 0x71},	// 42
+	{0x70, 0x00000000, 0x0002, 0x65},	// 28
+	{0x70, 0x40000000, 0x0003, 0x00},	// 28
+	{0x70, 0x80000000, 0x0003, 0x69},	// 28
+	{0x70, 0xc0000000, 0x0003, 0x6f},	// 28
+	{0x70, 0x60000000, 0x0004, 0x73},	// 28
+	{0x70, 0xa0000000, 0x0004, 0x20},	// 28
+	{0x70, 0xe0000000, 0x0004, 0x70},	// 28
+	{0x70, 0x70000000, 0x0005, 0x6c},	// 28
+	{0x70, 0x78000000, 0x0005, 0x72},	// 28
+	{0x70, 0xb0000000, 0x0005, 0x68},	// 28
+	{0x70, 0xf0000000, 0x0005, 0x61},	// 28
+	{0x70, 0xb8000000, 0x0006, 0x74},	// 28
+	{0x70, 0xbc000000, 0x0006, 0x27},	// 28
+	{0x70, 0xf8000000, 0x0007, 0x64},	// 28
+	{0x70, 0xfa000000, 0x0007, 0x6d},	// 28
+	{0x70, 0xfc000000, 0x0007, 0x79},	// 28
+	{0x70, 0xfe800000, 0x0009, 0x3a},	// 28
+	{0x70, 0xff800000, 0x0009, 0x21},	// 28
+	{0x70, 0xff000000, 0x000a, 0x77},	// 28
+	{0x70, 0xff400000, 0x000a, 0x75},	// 28
+	{0x70, 0xfe000000, 0x000b, 0x62},	// 28
+	{0x70, 0xfe400000, 0x000b, 0x2d},	// 28
+	{0x70, 0xfe600000, 0x000b, 0x2e},	// 28
+	{0x70, 0xfe300000, 0x000c, 0x6e},	// 28
+	{0x70, 0xfe280000, 0x000d, 0x6b},	// 28
+	{0x70, 0xfe240000, 0x000e, 0x2c},	// 28
+	{0x70, 0xfe200000, 0x000f, 0x01},	// 28
+	{0x70, 0xfe220000, 0x000f, 0x63},	// 28
+	{0x71, 0x80000000, 0x0001, 0x75},	// 5
+	{0x71, 0x40000000, 0x0002, 0x00},	// 5
+	{0x71, 0x20000000, 0x0003, 0x3a},	// 5
+	{0x71, 0x00000000, 0x0004, 0x01},	// 5
+	{0x71, 0x10000000, 0x0004, 0x27},	// 5
+	{0x72, 0x00000000, 0x0003, 0x20},	// 40
+	{0x72, 0x60000000, 0x0003, 0x69},	// 40
+	{0x72, 0xa0000000, 0x0003, 0x65},	// 40
+	{0x72, 0x30000000, 0x0004, 0x79},	// 40
+	{0x72, 0x40000000, 0x0004, 0x64},	// 40
+	{0x72, 0x80000000, 0x0004, 0x73},	// 40
+	{0x72, 0x90000000, 0x0004, 0x74},	// 40
+	{0x72, 0xc0000000, 0x0004, 0x61},	// 40
+	{0x72, 0xd0000000, 0x0004, 0x00},	// 40
+	{0x72, 0xf0000000, 0x0004, 0x6f},	// 40
+	{0x72, 0x58000000, 0x0005, 0x6e},	// 40
+	{0x72, 0xe8000000, 0x0005, 0x6c},	// 40
+	{0x72, 0x24000000, 0x0006, 0x6b},	// 40
+	{0x72, 0x28000000, 0x0006, 0x72},	// 40
+	{0x72, 0x2c000000, 0x0006, 0x6d},	// 40
+	{0x72, 0x54000000, 0x0006, 0x75},	// 40
+	{0x72, 0xe4000000, 0x0006, 0x67},	// 40
+	{0x72, 0x20000000, 0x0007, 0x27},	// 40
+	{0x72, 0x52000000, 0x0007, 0x63},	// 40
+	{0x72, 0xe2000000, 0x0007, 0x3a},	// 40
+	{0x72, 0x22000000, 0x0008, 0x66},	// 40
+	{0x72, 0x23000000, 0x0008, 0x2e},	// 40
+	{0x72, 0x51000000, 0x0008, 0x62},	// 40
+	{0x72, 0xe0000000, 0x0008, 0x76},	// 40
+	{0x72, 0x50000000, 0x0009, 0x2c},	// 40
+	{0x72, 0x50800000, 0x0009, 0x70},	// 40
+	{0x72, 0xe1000000, 0x0009, 0x77},	// 40
+	{0x72, 0xe1c00000, 0x000a, 0x6a},	// 40
+	{0x72, 0xe1800000, 0x000b, 0x2d},	// 40
+	{0x72, 0xe1a00000, 0x000c, 0x68},	// 40
+	{0x72, 0xe1b00000, 0x000d, 0x47},	// 40
+	{0x72, 0xe1b80000, 0x000e, 0x71},	// 40
+	{0x72, 0xe1be0000, 0x000f, 0x53},	// 40
+	{0x72, 0xe1bc0000, 0x0010, 0x21},	// 40
+	{0x72, 0xe1bd0000, 0x0012, 0x2a},	// 40
+	{0x72, 0xe1bd8000, 0x0012, 0x54},	// 40
+	{0x72, 0xe1bd4000, 0x0013, 0x01},	// 40
+	{0x72, 0xe1bd6000, 0x0013, 0x45},	// 40
+	{0x72, 0xe1bdc000, 0x0013, 0x31},	// 40
+	{0x72, 0xe1bde000, 0x0013, 0x2f},	// 40
+	{0x73, 0x80000000, 0x0002, 0x20},	// 37
+	{0x73, 0xc0000000, 0x0002, 0x00},	// 37
+	{0x73, 0x60000000, 0x0003, 0x74},	// 37
+	{0x73, 0x00000000, 0x0004, 0x73},	// 37
+	{0x73, 0x20000000, 0x0004, 0x69},	// 37
+	{0x73, 0x30000000, 0x0004, 0x68},	// 37
+	{0x73, 0x18000000, 0x0005, 0x3b},	// 37
+	{0x73, 0x50000000, 0x0005, 0x65},	// 37
+	{0x73, 0x44000000, 0x0006, 0x6f},	// 37
+	{0x73, 0x4c000000, 0x0006, 0x63},	// 37
+	{0x73, 0x58000000, 0x0006, 0x3a},	// 37
+	{0x73, 0x10000000, 0x0007, 0x2e},	// 37
+	{0x73, 0x12000000, 0x0007, 0x21},	// 37
+	{0x73, 0x16000000, 0x0007, 0x79},	// 37
+	{0x73, 0x40000000, 0x0007, 0x70},	// 37
+	{0x73, 0x48000000, 0x0007, 0x61},	// 37
+	{0x73, 0x5e000000, 0x0007, 0x75},	// 37
+	{0x73, 0x14000000, 0x0008, 0x2c},	// 37
+	{0x73, 0x15000000, 0x0008, 0x66},	// 37
+	{0x73, 0x43000000, 0x0008, 0x27},	// 37
+	{0x73, 0x4b000000, 0x0008, 0x6e},	// 37
+	{0x73, 0x5c000000, 0x0008, 0x6c},	// 37
+	{0x73, 0x5d000000, 0x0008, 0x72},	// 37
+	{0x73, 0x42800000, 0x0009, 0x6b},	// 37
+	{0x73, 0x4a000000, 0x0009, 0x64},	// 37
+	{0x73, 0x42400000, 0x000a, 0x6d},	// 37
+	{0x73, 0x4ac00000, 0x000a, 0x62},	// 37
+	{0x73, 0x42000000, 0x000b, 0x3f},	// 37
+	{0x73, 0x42200000, 0x000b, 0x77},	// 37
+	{0x73, 0x4a800000, 0x000b, 0x67},	// 37
+	{0x73, 0x4aa00000, 0x000c, 0x71},	// 37
+	{0x73, 0x4ab40000, 0x000e, 0x45},	// 37
+	{0x73, 0x4ab80000, 0x000e, 0x2d},	// 37
+	{0x73, 0x4ab00000, 0x000f, 0x01},	// 37
+	{0x73, 0x4ab20000, 0x000f, 0x29},	// 37
+	{0x73, 0x4abc0000, 0x000f, 0x57},	// 37
+	{0x73, 0x4abe0000, 0x000f, 0x31},	// 37
+	{0x74, 0x00000000, 0x0003, 0x69},	// 39
+	{0x74, 0x60000000, 0x0003, 0x00},	// 39
+	{0x74, 0x80000000, 0x0003, 0x20},	// 39
+	{0x74, 0xe0000000, 0x0003, 0x68},	// 39
+	{0x74, 0x20000000, 0x0004, 0x61},	// 39
+	{0x74, 0x40000000, 0x0004, 0x72},	// 39
+	{0x74, 0xa0000000, 0x0004, 0x73},	// 39
+	{0x74, 0xb0000000, 0x0004, 0x6f},	// 39
+	{0x74, 0xd0000000, 0x0004, 0x65},	// 39
+	{0x74, 0x38000000, 0x0005, 0x74},	// 39
+	{0x74, 0x50000000, 0x0005, 0x79},	// 39
+	{0x74, 0xc0000000, 0x0005, 0x75},	// 39
+	{0x74, 0x58000000, 0x0006, 0x6d},	// 39
+	{0x74, 0xc8000000, 0x0006, 0x63},	// 39
+	{0x74, 0xcc000000, 0x0006, 0x6c},	// 39
+	{0x74, 0x30000000, 0x0007, 0x27},	// 39
+	{0x74, 0x34000000, 0x0007, 0x3a},	// 39
+	{0x74, 0x32000000, 0x0008, 0x77},	// 39
+	{0x74, 0x36000000, 0x0008, 0x21},	// 39
+	{0x74, 0x5c000000, 0x0008, 0x2e},	// 39
+	{0x74, 0x5d000000, 0x0008, 0x62},	// 39
+	{0x74, 0x5e000000, 0x0008, 0x45},	// 39
+	{0x74, 0x5f000000, 0x0008, 0x66},	// 39
+	{0x74, 0x33000000, 0x0009, 0x3f},	// 39
+	{0x74, 0x37000000, 0x0009, 0x6e},	// 39
+	{0x74, 0x33800000, 0x000a, 0x7a},	// 39
+	{0x74, 0x37800000, 0x000a, 0x64},	// 39
+	{0x74, 0x33e00000, 0x000b, 0x2c},	// 39
+	{0x74, 0x37c00000, 0x000b, 0x50},	// 39
+	{0x74, 0x33c00000, 0x000c, 0x76},	// 39
+	{0x74, 0x33d00000, 0x000c, 0x2d},	// 39
+	{0x74, 0x37e00000, 0x000c, 0x29},	// 39
+	{0x74, 0x37f00000, 0x000d, 0x67},	// 39
+	{0x74, 0x37f80000, 0x000e, 0x01},	// 39
+	{0x74, 0x37fc0000, 0x000f, 0x53},	// 39
+	{0x74, 0x37ff0000, 0x0010, 0x34},	// 39
+	{0x74, 0x37fe0000, 0x0011, 0x6b},	// 39
+	{0x74, 0x37fe8000, 0x0012, 0x6a},	// 39
+	{0x74, 0x37fec000, 0x0012, 0x70},	// 39
+	{0x75, 0x00000000, 0x0002, 0x72},	// 34
+	{0x75, 0x80000000, 0x0003, 0x73},	// 34
+	{0x75, 0xe0000000, 0x0003, 0x6e},	// 34
+	{0x75, 0x40000000, 0x0004, 0x65},	// 34
+	{0x75, 0x50000000, 0x0004, 0x6d},	// 34
+	{0x75, 0xc0000000, 0x0004, 0x74},	// 34
+	{0x75, 0x60000000, 0x0005, 0x63},	// 34
+	{0x75, 0x68000000, 0x0005, 0x67},	// 34
+	{0x75, 0x70000000, 0x0005, 0x62},	// 34
+	{0x75, 0xa0000000, 0x0005, 0x70},	// 34
+	{0x75, 0xa8000000, 0x0005, 0x69},	// 34
+	{0x75, 0xb0000000, 0x0005, 0x6c},	// 34
+	{0x75, 0xd0000000, 0x0005, 0x64},	// 34
+	{0x75, 0xd8000000, 0x0005, 0x61},	// 34
+	{0x75, 0x78000000, 0x0006, 0x00},	// 34
+	{0x75, 0xb8000000, 0x0006, 0x79},	// 34
+	{0x75, 0x7c000000, 0x0007, 0x7a},	// 34
+	{0x75, 0xbc000000, 0x0007, 0x20},	// 34
+	{0x75, 0x7f000000, 0x0008, 0x27},	// 34
+	{0x75, 0xbe000000, 0x0008, 0x2d},	// 34
+	{0x75, 0x7e000000, 0x0009, 0x6b},	// 34
+	{0x75, 0xbf800000, 0x0009, 0x3a},	// 34
+	{0x75, 0x7e800000, 0x000a, 0x66},	// 34
+	{0x75, 0x7ec00000, 0x000a, 0x2c},	// 34
+	{0x75, 0xbf000000, 0x000a, 0x77},	// 34
+	{0x75, 0xbf400000, 0x000c, 0x76},	// 34
+	{0x75, 0xbf500000, 0x000c, 0x78},	// 34
+	{0x75, 0xbf700000, 0x000c, 0x6f},	// 34
+	{0x75, 0xbf600000, 0x000d, 0x6a},	// 34
+	{0x75, 0xbf680000, 0x000e, 0x75},	// 34
+	{0x75, 0xbf6c0000, 0x000f, 0x2e},	// 34
+	{0x75, 0xbf6f0000, 0x0010, 0x68},	// 34
+	{0x75, 0xbf6e0000, 0x0011, 0x3f},	// 34
+	{0x75, 0xbf6e8000, 0x0011, 0x01},	// 34
+	{0x76, 0x80000000, 0x0001, 0x65},	// 11
+	{0x76, 0x40000000, 0x0002, 0x69},	// 11
+	{0x76, 0x20000000, 0x0003, 0x61},	// 11
+	{0x76, 0x10000000, 0x0004, 0x6f},	// 11
+	{0x76, 0x00000000, 0x0005, 0x20},	// 11
+	{0x76, 0x0c000000, 0x0006, 0x00},	// 11
+	{0x76, 0x08000000, 0x0007, 0x79},	// 11
+	{0x76, 0x0b000000, 0x0008, 0x73},	// 11
+	{0x76, 0x0a800000, 0x0009, 0x72},	// 11
+	{0x76, 0x0a000000, 0x000a, 0x01},	// 11
+	{0x76, 0x0a400000, 0x000a, 0x2e},	// 11
+	{0x77, 0x00000000, 0x0001, 0x73},	// 31
+	{0x77, 0x80000000, 0x0003, 0x20},	// 31
+	{0x77, 0xc0000000, 0x0003, 0x00},	// 31
+	{0x77, 0xb0000000, 0x0004, 0x69},	// 31
+	{0x77, 0xe0000000, 0x0004, 0x6f},	// 31
+	{0x77, 0xa0000000, 0x0005, 0x61},	// 31
+	{0x77, 0xf0000000, 0x0005, 0x6e},	// 31
+	{0x77, 0xf8000000, 0x0005, 0x65},	// 31
+	{0x77, 0xae000000, 0x0007, 0x79},	// 31
+	{0x77, 0xa8000000, 0x0008, 0x6d},	// 31
+	{0x77, 0xab000000, 0x0008, 0x64},	// 31
+	{0x77, 0xad000000, 0x0008, 0x6c},	// 31
+	{0x77, 0xa9800000, 0x0009, 0x62},	// 31
+	{0x77, 0xaa000000, 0x0009, 0x6b},	// 31
+	{0x77, 0xaa800000, 0x0009, 0x72},	// 31
+	{0x77, 0xa9000000, 0x000a, 0x6a},	// 31
+	{0x77, 0xac400000, 0x000a, 0x2c},	// 31
+	{0x77, 0xacc00000, 0x000a, 0x68},	// 31
+	{0x77, 0xa9600000, 0x000b, 0x2d},	// 31
+	{0x77, 0xac000000, 0x000b, 0x63},	// 31
+	{0x77, 0xac200000, 0x000b, 0x66},	// 31
+	{0x77, 0xaca00000, 0x000b, 0x70},	// 31
+	{0x77, 0xa9400000, 0x000c, 0x67},	// 31
+	{0x77, 0xac800000, 0x000c, 0x74},	// 31
+	{0x77, 0xa9500000, 0x000d, 0x2e},	// 31
+	{0x77, 0xa9580000, 0x000d, 0x3a},	// 31
+	{0x77, 0xac980000, 0x000d, 0x71},	// 31
+	{0x77, 0xac940000, 0x000e, 0x27},	// 31
+	{0x77, 0xac920000, 0x000f, 0x3f},	// 31
+	{0x77, 0xac900000, 0x0010, 0x01},	// 31
+	{0x77, 0xac910000, 0x0010, 0x42},	// 31
+	{0x78, 0x00000000, 0x0002, 0x70},	// 20
+	{0x78, 0x80000000, 0x0002, 0x20},	// 20
+	{0x78, 0xc0000000, 0x0002, 0x74},	// 20
+	{0x78, 0x60000000, 0x0004, 0x00},	// 20
+	{0x78, 0x40000000, 0x0005, 0x6f},	// 20
+	{0x78, 0x50000000, 0x0005, 0x63},	// 20
+	{0x78, 0x70000000, 0x0005, 0x69},	// 20
+	{0x78, 0x78000000, 0x0005, 0x6d},	// 20
+	{0x78, 0x48000000, 0x0006, 0x65},	// 20
+	{0x78, 0x58000000, 0x0006, 0x79},	// 20
+	{0x78, 0x4c000000, 0x0007, 0x75},	// 20
+	{0x78, 0x4e000000, 0x0007, 0x66},	// 20
+	{0x78, 0x5e000000, 0x0007, 0x2c},	// 20
+	{0x78, 0x5c000000, 0x0009, 0x67},	// 20
+	{0x78, 0x5c800000, 0x0009, 0x61},	// 20
+	{0x78, 0x5d800000, 0x0009, 0x39},	// 20
+	{0x78, 0x5d400000, 0x000a, 0x27},	// 20
+	{0x78, 0x5d200000, 0x000b, 0x78},	// 20
+	{0x78, 0x5d000000, 0x000c, 0x01},	// 20
+	{0x78, 0x5d100000, 0x000c, 0x73},	// 20
+	{0x79, 0x00000000, 0x0001, 0x20},	// 36
+	{0x79, 0xc0000000, 0x0002, 0x00},	// 36
+	{0x79, 0x88000000, 0x0005, 0x6f},	// 36
+	{0x79, 0x90000000, 0x0005, 0x73},	// 36
+	{0x79, 0xa0000000, 0x0005, 0x61},	// 36
+	{0x79, 0xb0000000, 0x0005, 0x6c},	// 36
+	{0x79, 0xb8000000, 0x0005, 0x3a},	// 36
+	{0x79, 0x98000000, 0x0006, 0x64},	// 36
+	{0x79, 0x82000000, 0x0007, 0x6e},	// 36
+	{0x79, 0x84000000, 0x0007, 0x74},	// 36
+	{0x79, 0xa8000000, 0x0007, 0x27},	// 36
+	{0x79, 0xaa000000, 0x0007, 0x62},	// 36
+	{0x79, 0xae000000, 0x0007, 0x2e},	// 36
+	{0x79, 0x80000000, 0x0008, 0x69},	// 36
+	{0x79, 0x86000000, 0x0008, 0x2c},	// 36
+	{0x79, 0x87000000, 0x0008, 0x70},	// 36
+	{0x79, 0x9c000000, 0x0008, 0x6d},	// 36
+	{0x79, 0x9e000000, 0x0008, 0x63},	// 36
+	{0x79, 0xac000000, 0x0008, 0x77},	// 36
+	{0x79, 0xad000000, 0x0008, 0x65},	// 36
+	{0x79, 0x81000000, 0x0009, 0x3f},	// 36
+	{0x79, 0x81800000, 0x0009, 0x66},	// 36
+	{0x79, 0x9d000000, 0x0009, 0x72},	// 36
+	{0x79, 0x9d800000, 0x0009, 0x67},	// 36
+	{0x79, 0x9f000000, 0x000a, 0x7a},	// 36
+	{0x79, 0x9f800000, 0x000a, 0x2d},	// 36
+	{0x79, 0x9fc00000, 0x000a, 0x54},	// 36
+	{0x79, 0x9f400000, 0x000c, 0x32},	// 36
+	{0x79, 0x9f600000, 0x000c, 0x21},	// 36
+	{0x79, 0x9f700000, 0x000c, 0x6b},	// 36
+	{0x79, 0x9f500000, 0x000d, 0x76},	// 36
+	{0x79, 0x9f580000, 0x000e, 0x79},	// 36
+	{0x79, 0x9f5c0000, 0x000f, 0x68},	// 36
+	{0x79, 0x9f5f0000, 0x0010, 0x6a},	// 36
+	{0x79, 0x9f5e0000, 0x0011, 0x01},	// 36
+	{0x79, 0x9f5e8000, 0x0011, 0x29},	// 36
+	{0x7a, 0x00000000, 0x0002, 0x7a},	// 21
+	{0x7a, 0x40000000, 0x0002, 0x00},	// 21
+	{0x7a, 0xa0000000, 0x0003, 0x69},	// 21
+	{0x7a, 0x80000000, 0x0004, 0x79},	// 21
+	{0x7a, 0x90000000, 0x0004, 0x65},	// 21
+	{0x7a, 0xc0000000, 0x0004, 0x77},	// 21
+	{0x7a, 0xd0000000, 0x0004, 0x20},	// 21
+	{0x7a, 0xe0000000, 0x0004, 0x6c},	// 21
+	{0x7a, 0xf0000000, 0x0005, 0x61},	// 21
+	{0x7a, 0xf8000000, 0x0006, 0x6f},	// 21
+	{0x7a, 0xfc000000, 0x0008, 0x6d},	// 21
+	{0x7a, 0xfd000000, 0x0008, 0x3a},	// 21
+	{0x7a, 0xff000000, 0x0008, 0x63},	// 21
+	{0x7a, 0xfe000000, 0x0009, 0x2c},	// 21
+	{0x7a, 0xfec00000, 0x000a, 0x62},	// 21
+	{0x7a, 0xfe800000, 0x000b, 0x75},	// 21
+	{0x7a, 0xfeb00000, 0x000c, 0x21},	// 21
+	{0x7a, 0xfea00000, 0x000e, 0x01},	// 21
+	{0x7a, 0xfea40000, 0x000e, 0x74},	// 21
+	{0x7a, 0xfea80000, 0x000e, 0x68},	// 21
+	{0x7a, 0xfeac0000, 0x000e, 0x3f},	// 21
+	{0x7b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x00, 0x40000000, 0x0003, 0x41},	// 51
+	{0x00, 0x80000000, 0x0003, 0x43},	// 51
+	{0x00, 0xe0000000, 0x0003, 0x54},	// 51
+	{0x00, 0x10000000, 0x0004, 0x4a},	// 51
+	{0x00, 0x30000000, 0x0004, 0x44},	// 51
+	{0x00, 0xa0000000, 0x0004, 0x53},	// 51
+	{0x00, 0x00000000, 0x0005, 0x48},	// 51
+	{0x00, 0x20000000, 0x0005, 0x49},	// 51
+	{0x00, 0x28000000, 0x0005, 0x52},	// 51
+	{0x00, 0x68000000, 0x0005, 0x46},	// 51
+	{0x00, 0x70000000, 0x0005, 0x2e},	// 51
+	{0x00, 0x78000000, 0x0005, 0x57},	// 51
+	{0x00, 0xb8000000, 0x0005, 0x4d},	// 51
+	{0x00, 0xc0000000, 0x0005, 0x42},	// 51
+	{0x00, 0xc8000000, 0x0005, 0x50},	// 51
+	{0x00, 0xd8000000, 0x0005, 0x4e},	// 51
+	{0x00, 0x08000000, 0x0006, 0x4f},	// 51
+	{0x00, 0x64000000, 0x0006, 0x5b},	// 51
+	{0x00, 0xb4000000, 0x0006, 0x4c},	// 51
+	{0x00, 0xd4000000, 0x0006, 0x45},	// 51
+	{0x00, 0x0c000000, 0x0007, 0x4b},	// 51
+	{0x00, 0xd0000000, 0x0007, 0x59},	// 51
+	{0x00, 0xd2000000, 0x0007, 0x47},	// 51
+	{0x00, 0x0e000000, 0x0008, 0x32},	// 51
+	{0x00, 0x60000000, 0x0008, 0x70},	// 51
+	{0x00, 0x61000000, 0x0008, 0x62},	// 51
+	{0x00, 0x62000000, 0x0008, 0x55},	// 51
+	{0x00, 0x63000000, 0x0008, 0x28},	// 51
+	{0x00, 0xb0000000, 0x0008, 0x31},	// 51
+	{0x00, 0xb3000000, 0x0008, 0x56},	// 51
+	{0x00, 0x0f000000, 0x0009, 0x51},	// 51
+	{0x00, 0xb1000000, 0x0009, 0x33},	// 51
+	{0x00, 0x0f800000, 0x000a, 0x39},	// 51
+	{0x00, 0x0fc00000, 0x000a, 0x38},	// 51
+	{0x00, 0xb1800000, 0x000a, 0x36},	// 51
+	{0x00, 0xb1c00000, 0x000a, 0x35},	// 51
+	{0x00, 0xb2000000, 0x000a, 0x5a},	// 51
+	{0x00, 0xb2400000, 0x000a, 0x37},	// 51
+	{0x00, 0xb2800000, 0x000a, 0x34},	// 51
+	{0x00, 0xb2e00000, 0x000c, 0x58},	// 51
+	{0x00, 0xb2f00000, 0x000c, 0x20},	// 51
+	{0x00, 0xb2c80000, 0x000d, 0x77},	// 51
+	{0x00, 0xb2d00000, 0x000d, 0x27},	// 51
+	{0x00, 0xb2d80000, 0x000d, 0x22},	// 51
+	{0x00, 0xb2c00000, 0x000e, 0x74},	// 51
+	{0x00, 0xb2c40000, 0x000f, 0x61},	// 51
+	{0x00, 0xb2c60000, 0x0010, 0x60},	// 51
+	{0x00, 0xb2c70000, 0x0011, 0x01},	// 51
+	{0x00, 0xb2c78000, 0x0011, 0x6d},	// 51
+	{0x00, 0x00000000, 0x0001, 0x01},	// 51
+	{0x00, 0x80000000, 0x0001, 0x01},	// 51
+	{0x01, 0x00000000, 0x0001, 0x01},	// 2
+	{0x01, 0x80000000, 0x0001, 0x01},	// 2
+	{0x03, 0x00000000, 0x0001, 0x01},	// 2
+	{0x03, 0x80000000, 0x0001, 0x01},	// 2
+	{0x04, 0x00000000, 0x0001, 0x01},	// 2
+	{0x04, 0x80000000, 0x0001, 0x01},	// 2
+	{0x05, 0x00000000, 0x0001, 0x01},	// 2
+	{0x05, 0x80000000, 0x0001, 0x01},	// 2
+	{0x06, 0x00000000, 0x0001, 0x01},	// 2
+	{0x06, 0x80000000, 0x0001, 0x01},	// 2
+	{0x07, 0x00000000, 0x0001, 0x01},	// 2
+	{0x07, 0x80000000, 0x0001, 0x01},	// 2
+	{0x08, 0x00000000, 0x0001, 0x01},	// 2
+	{0x08, 0x80000000, 0x0001, 0x01},	// 2
+	{0x09, 0x00000000, 0x0001, 0x01},	// 2
+	{0x09, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0a, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0a, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x0f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x0f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x10, 0x00000000, 0x0001, 0x01},	// 2
+	{0x10, 0x80000000, 0x0001, 0x01},	// 2
+	{0x11, 0x00000000, 0x0001, 0x01},	// 2
+	{0x11, 0x80000000, 0x0001, 0x01},	// 2
+	{0x12, 0x00000000, 0x0001, 0x01},	// 2
+	{0x12, 0x80000000, 0x0001, 0x01},	// 2
+	{0x13, 0x00000000, 0x0001, 0x01},	// 2
+	{0x13, 0x80000000, 0x0001, 0x01},	// 2
+	{0x14, 0x00000000, 0x0001, 0x01},	// 2
+	{0x14, 0x80000000, 0x0001, 0x01},	// 2
+	{0x15, 0x00000000, 0x0001, 0x01},	// 2
+	{0x15, 0x80000000, 0x0001, 0x01},	// 2
+	{0x16, 0x00000000, 0x0001, 0x01},	// 2
+	{0x16, 0x80000000, 0x0001, 0x01},	// 2
+	{0x17, 0x00000000, 0x0001, 0x01},	// 2
+	{0x17, 0x80000000, 0x0001, 0x01},	// 2
+	{0x18, 0x00000000, 0x0001, 0x01},	// 2
+	{0x18, 0x80000000, 0x0001, 0x01},	// 2
+	{0x19, 0x00000000, 0x0001, 0x01},	// 2
+	{0x19, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1a, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1a, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x1f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x1f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x20, 0x40000000, 0x0003, 0x61},	// 80
+	{0x20, 0x80000000, 0x0003, 0x74},	// 80
+	{0x20, 0x10000000, 0x0004, 0x6f},	// 80
+	{0x20, 0x20000000, 0x0004, 0x73},	// 80
+	{0x20, 0x30000000, 0x0005, 0x64},	// 80
+	{0x20, 0x60000000, 0x0005, 0x5b},	// 80
+	{0x20, 0x78000000, 0x0005, 0x70},	// 80
+	{0x20, 0xa8000000, 0x0005, 0x62},	// 80
+	{0x20, 0xc8000000, 0x0005, 0x63},	// 80
+	{0x20, 0xd0000000, 0x0005, 0x68},	// 80
+	{0x20, 0xe0000000, 0x0005, 0x77},	// 80
+	{0x20, 0xe8000000, 0x0005, 0x69},	// 80
+	{0x20, 0xf8000000, 0x0005, 0x66},	// 80
+	{0x20, 0x00000000, 0x0006, 0x41},	// 80
+	{0x20, 0x0c000000, 0x0006, 0x4d},	// 80
+	{0x20, 0x3c000000, 0x0006, 0x65},	// 80
+	{0x20, 0x70000000, 0x0006, 0x42},	// 80
+	{0x20, 0x74000000, 0x0006, 0x43},	// 80
+	{0x20, 0xa0000000, 0x0006, 0x54},	// 80
+	{0x20, 0xb4000000, 0x0006, 0x53},	// 80
+	{0x20, 0xb8000000, 0x0006, 0x67},	// 80
+	{0x20, 0xc0000000, 0x0006, 0x72},	// 80
+	{0x20, 0xd8000000, 0x0006, 0x6e},	// 80
+	{0x20, 0xdc000000, 0x0006, 0x6c},	// 80
+	{0x20, 0xf4000000, 0x0006, 0x6d},	// 80
+	{0x20, 0x06000000, 0x0007, 0x76},	// 80
+	{0x20, 0x08000000, 0x0007, 0x47},	// 80
+	{0x20, 0x0a000000, 0x0007, 0x4e},	// 80
+	{0x20, 0x3a000000, 0x0007, 0x79},	// 80
+	{0x20, 0x6a000000, 0x0007, 0x48},	// 80
+	{0x20, 0x6e000000, 0x0007, 0x4c},	// 80
+	{0x20, 0xa4000000, 0x0007, 0x4a},	// 80
+	{0x20, 0xa6000000, 0x0007, 0x46},	// 80
+	{0x20, 0xb2000000, 0x0007, 0x52},	// 80
+	{0x20, 0xbc000000, 0x0007, 0x75},	// 80
+	{0x20, 0xc4000000, 0x0007, 0x44},	// 80
+	{0x20, 0xc6000000, 0x0007, 0x57},	// 80
+	{0x20, 0xf2000000, 0x0007, 0x50},	// 80
+	{0x20, 0x04000000, 0x0008, 0x6b},	// 80
+	{0x20, 0x05000000, 0x0008, 0x4f},	// 80
+	{0x20, 0x68000000, 0x0008, 0x2d},	// 80
+	{0x20, 0x6d000000, 0x0008, 0x31},	// 80
+	{0x20, 0xb1000000, 0x0008, 0x4b},	// 80
+	{0x20, 0xbe000000, 0x0008, 0x6a},	// 80
+	{0x20, 0xf0000000, 0x0008, 0x49},	// 80
+	{0x20, 0xf1000000, 0x0008, 0x45},	// 80
+	{0x20, 0x39000000, 0x0009, 0x71},	// 80
+	{0x20, 0x39800000, 0x0009, 0x55},	// 80
+	{0x20, 0x69000000, 0x0009, 0x56},	// 80
+	{0x20, 0x6c000000, 0x0009, 0x59},	// 80
+	{0x20, 0x6c800000, 0x0009, 0x20},	// 80
+	{0x20, 0xb0800000, 0x0009, 0x32},	// 80
+	{0x20, 0xbf000000, 0x0009, 0x00},	// 80
+	{0x20, 0x38000000, 0x000a, 0x33},	// 80
+	{0x20, 0x38400000, 0x000a, 0x38},	// 80
+	{0x20, 0x38800000, 0x000a, 0x36},	// 80
+	{0x20, 0x69c00000, 0x000a, 0x35},	// 80
+	{0x20, 0xb0000000, 0x000a, 0x28},	// 80
+	{0x20, 0xbf800000, 0x000a, 0x37},	// 80
+	{0x20, 0x38c00000, 0x000b, 0x30},	// 80
+	{0x20, 0x69800000, 0x000b, 0x27},	// 80
+	{0x20, 0x69a00000, 0x000b, 0x39},	// 80
+	{0x20, 0xb0400000, 0x000b, 0x5a},	// 80
+	{0x20, 0xbfc00000, 0x000b, 0x34},	// 80
+	{0x20, 0xbfe00000, 0x000b, 0x51},	// 80
+	{0x20, 0x38f00000, 0x000c, 0x58},	// 80
+	{0x20, 0xb0600000, 0x000d, 0x01},	// 80
+	{0x20, 0xb0680000, 0x000d, 0x2e},	// 80
+	{0x20, 0xb0700000, 0x000d, 0x26},	// 80
+	{0x20, 0x38e00000, 0x000e, 0x5c},	// 80
+	{0x20, 0x38e80000, 0x000e, 0x40},	// 80
+	{0x20, 0x38ec0000, 0x000e, 0x60},	// 80
+	{0x20, 0xb0780000, 0x000e, 0x22},	// 80
+	{0x20, 0xb07c0000, 0x000e, 0x7a},	// 80
+	{0x20, 0x38e60000, 0x000f, 0x24},	// 80
+	{0x20, 0x38e40000, 0x0010, 0x2b},	// 80
+	{0x20, 0x38e58000, 0x0011, 0x78},	// 80
+	{0x20, 0x38e54000, 0x0012, 0x5d},	// 80
+	{0x20, 0x38e50000, 0x0013, 0x2f},	// 80
+	{0x20, 0x38e52000, 0x0013, 0x3f},	// 80
+	{0x21, 0x80000000, 0x0001, 0x20},	// 13
+	{0x21, 0x40000000, 0x0002, 0x00},	// 13
+	{0x21, 0x20000000, 0x0003, 0x2e},	// 13
+	{0x21, 0x00000000, 0x0004, 0x3a},	// 13
+	{0x21, 0x18000000, 0x0005, 0x5b},	// 13
+	{0x21, 0x12000000, 0x0007, 0x22},	// 13
+	{0x21, 0x14000000, 0x0007, 0x2f},	// 13
+	{0x21, 0x16000000, 0x0007, 0x21},	// 13
+	{0x21, 0x10000000, 0x0008, 0x29},	// 13
+	{0x21, 0x11000000, 0x0009, 0x27},	// 13
+	{0x21, 0x11c00000, 0x000a, 0x3f},	// 13
+	{0x21, 0x11800000, 0x000b, 0x01},	// 13
+	{0x21, 0x11a00000, 0x000b, 0x5d},	// 13
+	{0x22, 0xc0000000, 0x0002, 0x20},	// 36
+	{0x22, 0x20000000, 0x0003, 0x2e},	// 36
+	{0x22, 0x00000000, 0x0004, 0x70},	// 36
+	{0x22, 0x50000000, 0x0004, 0x42},	// 36
+	{0x22, 0x70000000, 0x0004, 0x54},	// 36
+	{0x22, 0x80000000, 0x0004, 0x69},	// 36
+	{0x22, 0x10000000, 0x0005, 0x66},	// 36
+	{0x22, 0x18000000, 0x0005, 0x57},	// 36
+	{0x22, 0x40000000, 0x0005, 0x53},	// 36
+	{0x22, 0x60000000, 0x0005, 0x74},	// 36
+	{0x22, 0x68000000, 0x0005, 0x43},	// 36
+	{0x22, 0xa0000000, 0x0005, 0x00},	// 36
+	{0x22, 0xb8000000, 0x0005, 0x2c},	// 36
+	{0x22, 0x48000000, 0x0006, 0x4a},	// 36
+	{0x22, 0x90000000, 0x0006, 0x6d},	// 36
+	{0x22, 0xa8000000, 0x0006, 0x6e},	// 36
+	{0x22, 0xac000000, 0x0006, 0x49},	// 36
+	{0x22, 0x4c000000, 0x0007, 0x45},	// 36
+	{0x22, 0x4e000000, 0x0007, 0x44},	// 36
+	{0x22, 0x94000000, 0x0007, 0x77},	// 36
+	{0x22, 0x96000000, 0x0007, 0x67},	// 36
+	{0x22, 0x98000000, 0x0007, 0x62},	// 36
+	{0x22, 0x9a000000, 0x0007, 0x4c},	// 36
+	{0x22, 0x9c000000, 0x0007, 0x2d},	// 36
+	{0x22, 0xb0000000, 0x0007, 0x63},	// 36
+	{0x22, 0xb2000000, 0x0007, 0x48},	// 36
+	{0x22, 0x9e000000, 0x0008, 0x50},	// 36
+	{0x22, 0xb4000000, 0x0008, 0x72},	// 36
+	{0x22, 0xb7000000, 0x0008, 0x4b},	// 36
+	{0x22, 0x9f800000, 0x0009, 0x6c},	// 36
+	{0x22, 0xb5000000, 0x0009, 0x59},	// 36
+	{0x22, 0xb5800000, 0x0009, 0x51},	// 36
+	{0x22, 0xb6000000, 0x0009, 0x47},	// 36
+	{0x22, 0xb6800000, 0x0009, 0x41},	// 36
+	{0x22, 0x9f000000, 0x000a, 0x01},	// 36
+	{0x22, 0x9f400000, 0x000a, 0x61},	// 36
+	{0x23, 0x00000000, 0x0001, 0x01},	// 2
+	{0x23, 0x80000000, 0x0001, 0x01},	// 2
+	{0x24, 0x00000000, 0x0001, 0x31},	// 8
+	{0x24, 0xc0000000, 0x0002, 0x33},	// 8
+	{0x24, 0x80000000, 0x0003, 0x34},	// 8
+	{0x24, 0xb0000000, 0x0004, 0x32},	// 8
+	{0x24, 0xa8000000, 0x0005, 0x37},	// 8
+	{0x24, 0xa4000000, 0x0006, 0x35},	// 8
+	{0x24, 0xa0000000, 0x0007, 0x01},	// 8
+	{0x24, 0xa2000000, 0x0007, 0x39},	// 8
+	{0x25, 0x80000000, 0x0001, 0x20},	// 3
+	{0x25, 0x00000000, 0x0002, 0x01},	// 3
+	{0x25, 0x40000000, 0x0002, 0x2c},	// 3
+	{0x26, 0x80000000, 0x0001, 0x20},	// 12
+	{0x26, 0x40000000, 0x0002, 0x77},	// 12
+	{0x26, 0x20000000, 0x0003, 0x42},	// 12
+	{0x26, 0x00000000, 0x0004, 0x45},	// 12
+	{0x26, 0x10000000, 0x0006, 0x32},	// 12
+	{0x26, 0x18000000, 0x0006, 0x41},	// 12
+	{0x26, 0x1c000000, 0x0006, 0x52},	// 12
+	{0x26, 0x14000000, 0x0008, 0x4f},	// 12
+	{0x26, 0x15000000, 0x0008, 0x34},	// 12
+	{0x26, 0x17000000, 0x0008, 0x4a},	// 12
+	{0x26, 0x16000000, 0x0009, 0x01},	// 12
+	{0x26, 0x16800000, 0x0009, 0x50},	// 12
+	{0x27, 0x80000000, 0x0001, 0x73},	// 71
+	{0x27, 0x20000000, 0x0003, 0x74},	// 71
+	{0x27, 0x40000000, 0x0003, 0x20},	// 71
+	{0x27, 0x00000000, 0x0004, 0x6c},	// 71
+	{0x27, 0x68000000, 0x0005, 0x72},	// 71
+	{0x27, 0x10000000, 0x0006, 0x6e},	// 71
+	{0x27, 0x14000000, 0x0006, 0x2e},	// 71
+	{0x27, 0x18000000, 0x0006, 0x43},	// 71
+	{0x27, 0x60000000, 0x0006, 0x42},	// 71
+	{0x27, 0x74000000, 0x0006, 0x41},	// 71
+	{0x27, 0x70000000, 0x0007, 0x64},	// 71
+	{0x27, 0x78000000, 0x0007, 0x76},	// 71
+	{0x27, 0x1c000000, 0x0008, 0x53},	// 71
+	{0x27, 0x1f000000, 0x0008, 0x70},	// 71
+	{0x27, 0x65000000, 0x0008, 0x44},	// 71
+	{0x27, 0x7b000000, 0x0008, 0x69},	// 71
+	{0x27, 0x7c000000, 0x0008, 0x63},	// 71
+	{0x27, 0x7d000000, 0x0008, 0x6d},	// 71
+	{0x27, 0x7f000000, 0x0008, 0x2c},	// 71
+	{0x27, 0x1d000000, 0x0009, 0x66},	// 71
+	{0x27, 0x1d800000, 0x0009, 0x67},	// 71
+	{0x27, 0x64000000, 0x0009, 0x46},	// 71
+	{0x27, 0x64800000, 0x0009, 0x68},	// 71
+	{0x27, 0x66800000, 0x0009, 0x48},	// 71
+	{0x27, 0x67000000, 0x0009, 0x4e},	// 71
+	{0x27, 0x72800000, 0x0009, 0x52},	// 71
+	{0x27, 0x73000000, 0x0009, 0x00},	// 71
+	{0x27, 0x73800000, 0x0009, 0x54},	// 71
+	{0x27, 0x7a800000, 0x0009, 0x47},	// 71
+	{0x27, 0x7e800000, 0x0009, 0x4c},	// 71
+	{0x27, 0x1e000000, 0x000a, 0x6f},	// 71
+	{0x27, 0x1e400000, 0x000a, 0x4b},	// 71
+	{0x27, 0x1ec00000, 0x000a, 0x61},	// 71
+	{0x27, 0x66400000, 0x000a, 0x75},	// 71
+	{0x27, 0x67c00000, 0x000a, 0x4f},	// 71
+	{0x27, 0x72400000, 0x000a, 0x49},	// 71
+	{0x27, 0x7a000000, 0x000a, 0x77},	// 71
+	{0x27, 0x7a400000, 0x000a, 0x62},	// 71
+	{0x27, 0x7e400000, 0x000a, 0x65},	// 71
+	{0x27, 0x1ea00000, 0x000b, 0x3f},	// 71
+	{0x27, 0x66000000, 0x000b, 0x45},	// 71
+	{0x27, 0x66200000, 0x000b, 0x37},	// 71
+	{0x27, 0x72000000, 0x000b, 0x50},	// 71
+	{0x27, 0x1e900000, 0x000c, 0x57},	// 71
+	{0x27, 0x67900000, 0x000c, 0x3a},	// 71
+	{0x27, 0x67a00000, 0x000c, 0x21},	// 71
+	{0x27, 0x72300000, 0x000c, 0x4a},	// 71
+	{0x27, 0x7e100000, 0x000c, 0x71},	// 71
+	{0x27, 0x7e300000, 0x000c, 0x4d},	// 71
+	{0x27, 0x1e880000, 0x000d, 0x56},	// 71
+	{0x27, 0x67880000, 0x000d, 0x39},	// 71
+	{0x27, 0x67b80000, 0x000d, 0x79},	// 71
+	{0x27, 0x72200000, 0x000d, 0x38},	// 71
+	{0x27, 0x72280000, 0x000d, 0x35},	// 71
+	{0x27, 0x7e000000, 0x000d, 0x36},	// 71
+	{0x27, 0x7e280000, 0x000d, 0x6b},	// 71
+	{0x27, 0x1e800000, 0x000e, 0x32},	// 71
+	{0x27, 0x1e840000, 0x000e, 0x30},	// 71
+	{0x27, 0x67840000, 0x000e, 0x59},	// 71
+	{0x27, 0x67b00000, 0x000e, 0x29},	// 71
+	{0x27, 0x7e080000, 0x000e, 0x6a},	// 71
+	{0x27, 0x7e0c0000, 0x000e, 0x51},	// 71
+	{0x27, 0x67800000, 0x000f, 0x2d},	// 71
+	{0x27, 0x67820000, 0x000f, 0x27},	// 71
+	{0x27, 0x67b60000, 0x000f, 0x7a},	// 71
+	{0x27, 0x7e200000, 0x000f, 0x58},	// 71
+	{0x27, 0x7e220000, 0x000f, 0x55},	// 71
+	{0x27, 0x7e240000, 0x000f, 0x34},	// 71
+	{0x27, 0x7e260000, 0x000f, 0x33},	// 71
+	{0x27, 0x67b40000, 0x0010, 0x01},	// 71
+	{0x27, 0x67b50000, 0x0010, 0x31},	// 71
+	{0x28, 0x40000000, 0x0002, 0x31},	// 55
+	{0x28, 0x00000000, 0x0003, 0x50},	// 55
+	{0x28, 0xa0000000, 0x0003, 0x74},	// 55
+	{0x28, 0x80000000, 0x0004, 0x32},	// 55
+	{0x28, 0xd0000000, 0x0004, 0x35},	// 55
+	{0x28, 0xe0000000, 0x0004, 0x4e},	// 55
+	{0x28, 0x38000000, 0x0005, 0x54},	// 55
+	{0x28, 0x90000000, 0x0005, 0x70},	// 55
+	{0x28, 0xf8000000, 0x0005, 0x63},	// 55
+	{0x28, 0x24000000, 0x0006, 0x61},	// 55
+	{0x28, 0x28000000, 0x0006, 0x53},	// 55
+	{0x28, 0x30000000, 0x0006, 0x52},	// 55
+	{0x28, 0x9c000000, 0x0006, 0x65},	// 55
+	{0x28, 0xf0000000, 0x0006, 0x4a},	// 55
+	{0x28, 0xf4000000, 0x0006, 0x41},	// 55
+	{0x28, 0x2c000000, 0x0007, 0x44},	// 55
+	{0x28, 0x36000000, 0x0007, 0x4b},	// 55
+	{0x28, 0x98000000, 0x0007, 0x76},	// 55
+	{0x28, 0x9a000000, 0x0007, 0x73},	// 55
+	{0x28, 0xc0000000, 0x0007, 0x62},	// 55
+	{0x28, 0xc4000000, 0x0007, 0x47},	// 55
+	{0x28, 0xc6000000, 0x0007, 0x38},	// 55
+	{0x28, 0xc8000000, 0x0007, 0x4d},	// 55
+	{0x28, 0xca000000, 0x0007, 0x48},	// 55
+	{0x28, 0xcc000000, 0x0007, 0x43},	// 55
+	{0x28, 0x20000000, 0x0008, 0x6d},	// 55
+	{0x28, 0x22000000, 0x0008, 0x6f},	// 55
+	{0x28, 0x23000000, 0x0008, 0x45},	// 55
+	{0x28, 0x2e000000, 0x0008, 0x57},	// 55
+	{0x28, 0xc3000000, 0x0008, 0x67},	// 55
+	{0x28, 0xce000000, 0x0008, 0x4c},	// 55
+	{0x28, 0x21000000, 0x0009, 0x64},	// 55
+	{0x28, 0x2f800000, 0x0009, 0x55},	// 55
+	{0x28, 0x34000000, 0x0009, 0x46},	// 55
+	{0x28, 0x35000000, 0x0009, 0x66},	// 55
+	{0x28, 0xc2000000, 0x0009, 0x77},	// 55
+	{0x28, 0xc2800000, 0x0009, 0x42},	// 55
+	{0x28, 0xcf800000, 0x0009, 0x6e},	// 55
+	{0x28, 0x21800000, 0x000a, 0x6c},	// 55
+	{0x28, 0x21c00000, 0x000a, 0x39},	// 55
+	{0x28, 0x2f000000, 0x000a, 0x34},	// 55
+	{0x28, 0x2f400000, 0x000a, 0x49},	// 55
+	{0x28, 0x34800000, 0x000a, 0x33},	// 55
+	{0x28, 0x35c00000, 0x000a, 0x68},	// 55
+	{0x28, 0xcf400000, 0x000a, 0x69},	// 55
+	{0x28, 0x34c00000, 0x000b, 0x5a},	// 55
+	{0x28, 0x34e00000, 0x000b, 0x56},	// 55
+	{0x28, 0x35800000, 0x000b, 0x20},	// 55
+	{0x28, 0xcf000000, 0x000b, 0x6b},	// 55
+	{0x28, 0x35b00000, 0x000c, 0x4f},	// 55
+	{0x28, 0xcf200000, 0x000c, 0x27},	// 55
+	{0x28, 0x35a00000, 0x000d, 0x01},	// 55
+	{0x28, 0x35a80000, 0x000d, 0x75},	// 55
+	{0x28, 0xcf300000, 0x000d, 0x58},	// 55
+	{0x28, 0xcf380000, 0x000d, 0x37},	// 55
+	{0x29, 0x00000000, 0x0001, 0x20},	// 12
+	{0x29, 0xc0000000, 0x0002, 0x2e},	// 12
+	{0x29, 0xa0000000, 0x0003, 0x00},	// 12
+	{0x29, 0x90000000, 0x0004, 0x2c},	// 12
+	{0x29, 0x80000000, 0x0005, 0x3a},	// 12
+	{0x29, 0x8c000000, 0x0006, 0x3b},	// 12
+	{0x29, 0x8a000000, 0x0007, 0x21},	// 12
+	{0x29, 0x89000000, 0x0008, 0x28},	// 12
+	{0x29, 0x88000000, 0x000a, 0x01},	// 12
+	{0x29, 0x88400000, 0x000a, 0x6f},	// 12
+	{0x29, 0x88800000, 0x000a, 0x3f},	// 12
+	{0x29, 0x88c00000, 0x000a, 0x29},	// 12
+	{0x2a, 0x00000000, 0x0001, 0x2a},	// 13
+	{0x2a, 0x80000000, 0x0003, 0x73},	// 13
+	{0x2a, 0xa0000000, 0x0003, 0x20},	// 13
+	{0x2a, 0xc0000000, 0x0004, 0x6d},	// 13
+	{0x2a, 0xe0000000, 0x0004, 0x74},	// 13
+	{0x2a, 0xd0000000, 0x0005, 0x67},	// 13
+	{0x2a, 0xd8000000, 0x0005, 0x6b},	// 13
+	{0x2a, 0xf8000000, 0x0005, 0x64},	// 13
+	{0x2a, 0xf4000000, 0x0006, 0x79},	// 13
+	{0x2a, 0xf2000000, 0x0007, 0x65},	// 13
+	{0x2a, 0xf0000000, 0x0008, 0x69},	// 13
+	{0x2a, 0xf1000000, 0x0009, 0x01},	// 13
+	{0x2a, 0xf1800000, 0x0009, 0x6e},	// 13
+	{0x2b, 0x80000000, 0x0001, 0x6e},	// 3
+	{0x2b, 0x00000000, 0x0002, 0x01},	// 3
+	{0x2b, 0x40000000, 0x0002, 0x20},	// 3
+	{0x2c, 0x80000000, 0x0001, 0x20},	// 20
+	{0x2c, 0x40000000, 0x0002, 0x53},	// 20
+	{0x2c, 0x20000000, 0x0003, 0x30},	// 20
+	{0x2c, 0x10000000, 0x0004, 0x41},	// 20
+	{0x2c, 0x00000000, 0x0005, 0x35},	// 20
+	{0x2c, 0x0c000000, 0x0007, 0x62},	// 20
+	{0x2c, 0x0e000000, 0x0007, 0x33},	// 20
+	{0x2c, 0x08000000, 0x0008, 0x32},	// 20
+	{0x2c, 0x09000000, 0x0008, 0x22},	// 20
+	{0x2c, 0x0b000000, 0x0008, 0x31},	// 20
+	{0x2c, 0x0a000000, 0x000a, 0x51},	// 20
+	{0x2c, 0x0a800000, 0x000a, 0x27},	// 20
+	{0x2c, 0x0ae00000, 0x000b, 0x34},	// 20
+	{0x2c, 0x0a400000, 0x000c, 0x54},	// 20
+	{0x2c, 0x0a500000, 0x000c, 0x42},	// 20
+	{0x2c, 0x0a600000, 0x000c, 0x37},	// 20
+	{0x2c, 0x0a700000, 0x000c, 0x36},	// 20
+	{0x2c, 0x0ac00000, 0x000c, 0x00},	// 20
+	{0x2c, 0x0ad00000, 0x000d, 0x01},	// 20
+	{0x2c, 0x0ad80000, 0x000d, 0x69},	// 20
+	{0x2d, 0x00000000, 0x0002, 0x20},	// 64
+	{0x2d, 0x40000000, 0x0004, 0x74},	// 64
+	{0x2d, 0x50000000, 0x0004, 0x62},	// 64
+	{0x2d, 0x60000000, 0x0004, 0x77},	// 64
+	{0x2d, 0x70000000, 0x0004, 0x75},	// 64
+	{0x2d, 0x90000000, 0x0004, 0x6f},	// 64
+	{0x2d, 0xa0000000, 0x0004, 0x73},	// 64
+	{0x2d, 0xb0000000, 0x0004, 0x66},	// 64
+	{0x2d, 0x80000000, 0x0005, 0x63},	// 64
+	{0x2d, 0xd8000000, 0x0005, 0x6c},	// 64
+	{0x2d, 0xe8000000, 0x0005, 0x64},	// 64
+	{0x2d, 0x88000000, 0x0006, 0x39},	// 64
+	{0x2d, 0xc0000000, 0x0006, 0x68},	// 64
+	{0x2d, 0xc8000000, 0x0006, 0x31},	// 64
+	{0x2d, 0xcc000000, 0x0006, 0x79},	// 64
+	{0x2d, 0xd4000000, 0x0006, 0x72},	// 64
+	{0x2d, 0xe0000000, 0x0006, 0x61},	// 64
+	{0x2d, 0xf0000000, 0x0006, 0x6d},	// 64
+	{0x2d, 0xf8000000, 0x0006, 0x70},	// 64
+	{0x2d, 0x8c000000, 0x0007, 0x53},	// 64
+	{0x2d, 0xd0000000, 0x0007, 0x65},	// 64
+	{0x2d, 0xd2000000, 0x0007, 0x69},	// 64
+	{0x2d, 0xf6000000, 0x0007, 0x6e},	// 64
+	{0x2d, 0x8e000000, 0x0008, 0x43},	// 64
+	{0x2d, 0xc5000000, 0x0008, 0x57},	// 64
+	{0x2d, 0xc7000000, 0x0008, 0x67},	// 64
+	{0x2d, 0xe5000000, 0x0008, 0x4a},	// 64
+	{0x2d, 0xe6000000, 0x0008, 0x44},	// 64
+	{0x2d, 0xf5000000, 0x0008, 0x32},	// 64
+	{0x2d, 0xfc000000, 0x0008, 0x37},	// 64
+	{0x2d, 0xfe000000, 0x0008, 0x47},	// 64
+	{0x2d, 0xff000000, 0x0008, 0x4f},	// 64
+	{0x2d, 0x8f800000, 0x0009, 0x48},	// 64
+	{0x2d, 0xc4000000, 0x0009, 0x41},	// 64
+	{0x2d, 0xc6000000, 0x0009, 0x36},	// 64
+	{0x2d, 0xc6800000, 0x0009, 0x42},	// 64
+	{0x2d, 0xe7800000, 0x0009, 0x4d},	// 64
+	{0x2d, 0xf4000000, 0x0009, 0x45},	// 64
+	{0x2d, 0xf4800000, 0x0009, 0x4c},	// 64
+	{0x2d, 0xfd000000, 0x0009, 0x55},	// 64
+	{0x2d, 0xfd800000, 0x0009, 0x6b},	// 64
+	{0x2d, 0x8f000000, 0x000a, 0x46},	// 64
+	{0x2d, 0xc4800000, 0x000a, 0x6a},	// 64
+	{0x2d, 0xc4c00000, 0x000a, 0x50},	// 64
+	{0x2d, 0xe4400000, 0x000a, 0x71},	// 64
+	{0x2d, 0xe4800000, 0x000a, 0x35},	// 64
+	{0x2d, 0xe4c00000, 0x000a, 0x54},	// 64
+	{0x2d, 0xe7400000, 0x000a, 0x49},	// 64
+	{0x2d, 0x8f600000, 0x000b, 0x4b},	// 64
+	{0x2d, 0xe4000000, 0x000b, 0x76},	// 64
+	{0x2d, 0xe4200000, 0x000b, 0x5a},	// 64
+	{0x2d, 0xe7200000, 0x000b, 0x4e},	// 64
+	{0x2d, 0x8f500000, 0x000c, 0x52},	// 64
+	{0x2d, 0xe7100000, 0x000c, 0x59},	// 64
+	{0x2d, 0x8f480000, 0x000d, 0x30},	// 64
+	{0x2d, 0x8f400000, 0x000e, 0x34},	// 64
+	{0x2d, 0x8f440000, 0x000e, 0x7a},	// 64
+	{0x2d, 0xe7040000, 0x000e, 0x56},	// 64
+	{0x2d, 0xe7080000, 0x000e, 0x33},	// 64
+	{0x2d, 0xe70c0000, 0x000e, 0x38},	// 64
+	{0x2d, 0xe7020000, 0x000f, 0x51},	// 64
+	{0x2d, 0xe7000000, 0x0010, 0x27},	// 64
+	{0x2d, 0xe7010000, 0x0011, 0x01},	// 64
+	{0x2d, 0xe7018000, 0x0011, 0x78},	// 64
+	{0x2e, 0x80000000, 0x0001, 0x20},	// 65
+	{0x2e, 0x40000000, 0x0002, 0x00},	// 65
+	{0x2e, 0x30000000, 0x0004, 0x2e},	// 65
+	{0x2e, 0x10000000, 0x0005, 0x69},	// 65
+	{0x2e, 0x20000000, 0x0005, 0x30},	// 65
+	{0x2e, 0x28000000, 0x0005, 0x63},	// 65
+	{0x2e, 0x04000000, 0x0006, 0x75},	// 65
+	{0x2e, 0x00000000, 0x0007, 0x61},	// 65
+	{0x2e, 0x02000000, 0x0007, 0x5b},	// 65
+	{0x2e, 0x1a000000, 0x0007, 0x33},	// 65
+	{0x2e, 0x08000000, 0x0008, 0x34},	// 65
+	{0x2e, 0x0e000000, 0x0008, 0x48},	// 65
+	{0x2e, 0x18000000, 0x0008, 0x53},	// 65
+	{0x2e, 0x19000000, 0x0008, 0x57},	// 65
+	{0x2e, 0x1c000000, 0x0008, 0x6f},	// 65
+	{0x2e, 0x1e000000, 0x0008, 0x31},	// 65
+	{0x2e, 0x0a000000, 0x0009, 0x35},	// 65
+	{0x2e, 0x0a800000, 0x0009, 0x4c},	// 65
+	{0x2e, 0x0b800000, 0x0009, 0x70},	// 65
+	{0x2e, 0x0c000000, 0x0009, 0x54},	// 65
+	{0x2e, 0x0c800000, 0x0009, 0x41},	// 65
+	{0x2e, 0x0d000000, 0x0009, 0x4d},	// 65
+	{0x2e, 0x0f000000, 0x0009, 0x43},	// 65
+	{0x2e, 0x0f800000, 0x0009, 0x32},	// 65
+	{0x2e, 0x1d800000, 0x0009, 0x44},	// 65
+	{0x2e, 0x1f000000, 0x0009, 0x42},	// 65
+	{0x2e, 0x09000000, 0x000a, 0x4e},	// 65
+	{0x2e, 0x09800000, 0x000a, 0x74},	// 65
+	{0x2e, 0x09c00000, 0x000a, 0x4a},	// 65
+	{0x2e, 0x0b400000, 0x000a, 0x52},	// 65
+	{0x2e, 0x0dc00000, 0x000a, 0x50},	// 65
+	{0x2e, 0x1d400000, 0x000a, 0x73},	// 65
+	{0x2e, 0x1fc00000, 0x000a, 0x49},	// 65
+	{0x2e, 0x0b000000, 0x000b, 0x72},	// 65
+	{0x2e, 0x0d800000, 0x000b, 0x56},	// 65
+	{0x2e, 0x1d000000, 0x000b, 0x77},	// 65
+	{0x2e, 0x1d200000, 0x000b, 0x46},	// 65
+	{0x2e, 0x1fa00000, 0x000b, 0x47},	// 65
+	{0x2e, 0x09400000, 0x000c, 0x45},	// 65
+	{0x2e, 0x09500000, 0x000c, 0x3a},	// 65
+	{0x2e, 0x0b200000, 0x000c, 0x68},	// 65
+	{0x2e, 0x0da00000, 0x000c, 0x2c},	// 65
+	{0x2e, 0x1f800000, 0x000c, 0x27},	// 65
+	{0x2e, 0x09680000, 0x000d, 0x62},	// 65
+	{0x2e, 0x09700000, 0x000d, 0x4b},	// 65
+	{0x2e, 0x09780000, 0x000d, 0x59},	// 65
+	{0x2e, 0x0b380000, 0x000d, 0x4f},	// 65
+	{0x2e, 0x0db00000, 0x000d, 0x2d},	// 65
+	{0x2e, 0x1f900000, 0x000d, 0x66},	// 65
+	{0x2e, 0x1f980000, 0x000d, 0x28},	// 65
+	{0x2e, 0x0b300000, 0x000e, 0x22},	// 65
+	{0x2e, 0x0db80000, 0x000e, 0x79},	// 65
+	{0x2e, 0x09600000, 0x000f, 0x3f},	// 65
+	{0x2e, 0x09620000, 0x000f, 0x6d},	// 65
+	{0x2e, 0x09640000, 0x000f, 0x51},	// 65
+	{0x2e, 0x0dbc0000, 0x000f, 0x2a},	// 65
+	{0x2e, 0x0dbe0000, 0x000f, 0x26},	// 65
+	{0x2e, 0x09660000, 0x0010, 0x55},	// 65
+	{0x2e, 0x09670000, 0x0010, 0x3b},	// 65
+	{0x2e, 0x0b340000, 0x0010, 0x38},	// 65
+	{0x2e, 0x0b350000, 0x0010, 0x36},	// 65
+	{0x2e, 0x0b370000, 0x0010, 0x6b},	// 65
+	{0x2e, 0x0b360000, 0x0011, 0x64},	// 65
+	{0x2e, 0x0b368000, 0x0012, 0x01},	// 65
+	{0x2e, 0x0b36c000, 0x0012, 0x6e},	// 65
+	{0x2f, 0x40000000, 0x0002, 0x63},	// 51
+	{0x2f, 0xc0000000, 0x0003, 0x31},	// 51
+	{0x2f, 0xe0000000, 0x0003, 0x65},	// 51
+	{0x2f, 0x00000000, 0x0004, 0x35},	// 51
+	{0x2f, 0x20000000, 0x0004, 0x38},	// 51
+	{0x2f, 0x10000000, 0x0005, 0x54},	// 51
+	{0x2f, 0x18000000, 0x0005, 0x66},	// 51
+	{0x2f, 0x30000000, 0x0005, 0x42},	// 51
+	{0x2f, 0x38000000, 0x0005, 0x32},	// 51
+	{0x2f, 0x88000000, 0x0005, 0x33},	// 51
+	{0x2f, 0x90000000, 0x0005, 0x37},	// 51
+	{0x2f, 0xa0000000, 0x0005, 0x36},	// 51
+	{0x2f, 0xb0000000, 0x0005, 0x61},	// 51
+	{0x2f, 0xbc000000, 0x0006, 0x34},	// 51
+	{0x2f, 0x80000000, 0x0007, 0x46},	// 51
+	{0x2f, 0x84000000, 0x0007, 0x73},	// 51
+	{0x2f, 0x86000000, 0x0007, 0x4d},	// 51
+	{0x2f, 0x98000000, 0x0007, 0x48},	// 51
+	{0x2f, 0x9c000000, 0x0007, 0x44},	// 51
+	{0x2f, 0x9e000000, 0x0007, 0x41},	// 51
+	{0x2f, 0xaa000000, 0x0007, 0x53},	// 51
+	{0x2f, 0x83000000, 0x0008, 0x6d},	// 51
+	{0x2f, 0x9a000000, 0x0008, 0x57},	// 51
+	{0x2f, 0xa8000000, 0x0008, 0x47},	// 51
+	{0x2f, 0xa9000000, 0x0008, 0x55},	// 51
+	{0x2f, 0xac000000, 0x0008, 0x64},	// 51
+	{0x2f, 0xad000000, 0x0008, 0x4f},	// 51
+	{0x2f, 0xae000000, 0x0008, 0x4e},	// 51
+	{0x2f, 0xb9000000, 0x0008, 0x43},	// 51
+	{0x2f, 0xbb000000, 0x0008, 0x50},	// 51
+	{0x2f, 0x9b000000, 0x0009, 0x4c},	// 51
+	{0x2f, 0xaf000000, 0x0009, 0x20},	// 51
+	{0x2f, 0xaf800000, 0x0009, 0x49},	// 51
+	{0x2f, 0xb8000000, 0x0009, 0x45},	// 51
+	{0x2f, 0xb8800000, 0x0009, 0x52},	// 51
+	{0x2f, 0xba000000, 0x0009, 0x4b},	// 51
+	{0x2f, 0xba800000, 0x0009, 0x74},	// 51
+	{0x2f, 0x82400000, 0x000a, 0x4a},	// 51
+	{0x2f, 0x82c00000, 0x000a, 0x39},	// 51
+	{0x2f, 0x82000000, 0x000b, 0x76},	// 51
+	{0x2f, 0x82200000, 0x000b, 0x70},	// 51
+	{0x2f, 0x82800000, 0x000b, 0x68},	// 51
+	{0x2f, 0x9ba00000, 0x000b, 0x6f},	// 51
+	{0x2f, 0x9bc00000, 0x000b, 0x51},	// 51
+	{0x2f, 0x9be00000, 0x000b, 0x30},	// 51
+	{0x2f, 0x82a00000, 0x000c, 0x6c},	// 51
+	{0x2f, 0x82b00000, 0x000c, 0x69},	// 51
+	{0x2f, 0x9b800000, 0x000c, 0x56},	// 51
+	{0x2f, 0x9b980000, 0x000d, 0x79},	// 51
+	{0x2f, 0x9b900000, 0x000e, 0x01},	// 51
+	{0x2f, 0x9b940000, 0x000e, 0x67},	// 51
+	{0x30, 0x00000000, 0x0001, 0x30},	// 35
+	{0x30, 0xe0000000, 0x0003, 0x20},	// 35
+	{0x30, 0x90000000, 0x0004, 0x61},	// 35
+	{0x30, 0xb0000000, 0x0004, 0x70},	// 35
+	{0x30, 0x88000000, 0x0005, 0x73},	// 35
+	{0x30, 0xc0000000, 0x0005, 0x2e},	// 35
+	{0x30, 0xc8000000, 0x0005, 0x38},	// 35
+	{0x30, 0xd8000000, 0x0005, 0x2c},	// 35
+	{0x30, 0x80000000, 0x0006, 0x34},	// 35
+	{0x30, 0x84000000, 0x0006, 0x74},	// 35
+	{0x30, 0xa4000000, 0x0006, 0x35},	// 35
+	{0x30, 0xd0000000, 0x0006, 0x36},	// 35
+	{0x30, 0xa0000000, 0x0007, 0x33},	// 35
+	{0x30, 0xa2000000, 0x0007, 0x37},	// 35
+	{0x30, 0xaa000000, 0x0007, 0x5d},	// 35
+	{0x30, 0xac000000, 0x0007, 0x2d},	// 35
+	{0x30, 0xae000000, 0x0007, 0x31},	// 35
+	{0x30, 0xa8000000, 0x0008, 0x29},	// 35
+	{0x30, 0xa9000000, 0x0008, 0x2f},	// 35
+	{0x30, 0xd4000000, 0x0008, 0x00},	// 35
+	{0x30, 0xd5000000, 0x0008, 0x39},	// 35
+	{0x30, 0xd7000000, 0x0008, 0x32},	// 35
+	{0x30, 0xd6000000, 0x0009, 0x25},	// 35
+	{0x30, 0xd6800000, 0x000a, 0x3a},	// 35
+	{0x30, 0xd6d00000, 0x000c, 0x66},	// 35
+	{0x30, 0xd6f00000, 0x000c, 0x6d},	// 35
+	{0x30, 0xd6e00000, 0x000d, 0x79},	// 35
+	{0x30, 0xd6c40000, 0x000e, 0x6c},	// 35
+	{0x30, 0xd6c80000, 0x000e, 0x3b},	// 35
+	{0x30, 0xd6cc0000, 0x000e, 0x27},	// 35
+	{0x30, 0xd6e80000, 0x000e, 0x6b},	// 35
+	{0x30, 0xd6ec0000, 0x000e, 0x21},	// 35
+	{0x30, 0xd6c00000, 0x000f, 0x43},	// 35
+	{0x30, 0xd6c20000, 0x0010, 0x01},	// 35
+	{0x30, 0xd6c30000, 0x0010, 0x4a},	// 35
+	{0x31, 0x00000000, 0x0002, 0x39},	// 38
+	{0x31, 0x80000000, 0x0003, 0x31},	// 38
+	{0x31, 0xe0000000, 0x0003, 0x30},	// 38
+	{0x31, 0x50000000, 0x0004, 0x20},	// 38
+	{0x31, 0x70000000, 0x0004, 0x32},	// 38
+	{0x31, 0xb0000000, 0x0004, 0x2e},	// 38
+	{0x31, 0xc0000000, 0x0004, 0x35},	// 38
+	{0x31, 0x40000000, 0x0005, 0x36},	// 38
+	{0x31, 0x48000000, 0x0005, 0x38},	// 38
+	{0x31, 0x68000000, 0x0005, 0x2f},	// 38
+	{0x31, 0xa0000000, 0x0005, 0x5d},	// 38
+	{0x31, 0xd0000000, 0x0005, 0x33},	// 38
+	{0x31, 0x64000000, 0x0006, 0x37},	// 38
+	{0x31, 0xd8000000, 0x0006, 0x34},	// 38
+	{0x31, 0x60000000, 0x0007, 0x00},	// 38
+	{0x31, 0x62000000, 0x0007, 0x2d},	// 38
+	{0x31, 0xa8000000, 0x0007, 0x29},	// 38
+	{0x31, 0xac000000, 0x0007, 0x3a},	// 38
+	{0x31, 0xae000000, 0x0007, 0x73},	// 38
+	{0x31, 0xdc000000, 0x0007, 0x2c},	// 38
+	{0x31, 0xde000000, 0x0007, 0x78},	// 38
+	{0x31, 0xaa000000, 0x0008, 0x27},	// 38
+	{0x31, 0xab000000, 0x0009, 0x58},	// 38
+	{0x31, 0xabc00000, 0x000b, 0x74},	// 38
+	{0x31, 0xabe00000, 0x000b, 0x52},	// 38
+	{0x31, 0xabb00000, 0x000c, 0x3b},	// 38
+	{0x31, 0xab800000, 0x000d, 0x70},	// 38
+	{0x31, 0xab880000, 0x000d, 0x6d},	// 38
+	{0x31, 0xab900000, 0x000d, 0x21},	// 38
+	{0x31, 0xaba80000, 0x000d, 0x26},	// 38
+	{0x31, 0xab980000, 0x000e, 0x65},	// 38
+	{0x31, 0xab9c0000, 0x000f, 0x62},	// 38
+	{0x31, 0xab9e0000, 0x000f, 0x61},	// 38
+	{0x31, 0xaba00000, 0x000f, 0x44},	// 38
+	{0x31, 0xaba20000, 0x000f, 0x43},	// 38
+	{0x31, 0xaba40000, 0x000f, 0x25},	// 38
+	{0x31, 0xaba60000, 0x0010, 0x01},	// 38
+	{0x31, 0xaba70000, 0x0010, 0x6f},	// 38
+	{0x32, 0xc0000000, 0x0002, 0x30},	// 32
+	{0x32, 0x00000000, 0x0003, 0x20},	// 32
+	{0x32, 0x40000000, 0x0003, 0x2e},	// 32
+	{0x32, 0x80000000, 0x0003, 0x35},	// 32
+	{0x32, 0x30000000, 0x0004, 0x2f},	// 32
+	{0x32, 0xb0000000, 0x0004, 0x2c},	// 32
+	{0x32, 0x20000000, 0x0005, 0x5d},	// 32
+	{0x32, 0x28000000, 0x0005, 0x70},	// 32
+	{0x32, 0x68000000, 0x0005, 0x31},	// 32
+	{0x32, 0xa8000000, 0x0005, 0x34},	// 32
+	{0x32, 0x60000000, 0x0006, 0x36},	// 32
+	{0x32, 0x64000000, 0x0006, 0x32},	// 32
+	{0x32, 0x70000000, 0x0006, 0x3a},	// 32
+	{0x32, 0x74000000, 0x0006, 0x2d},	// 32
+	{0x32, 0x7c000000, 0x0006, 0x29},	// 32
+	{0x32, 0xa0000000, 0x0007, 0x00},	// 32
+	{0x32, 0xa4000000, 0x0007, 0x38},	// 32
+	{0x32, 0xa6000000, 0x0007, 0x39},	// 32
+	{0x32, 0x78000000, 0x0008, 0x44},	// 32
+	{0x32, 0x79000000, 0x0008, 0x33},	// 32
+	{0x32, 0x7a000000, 0x0008, 0x74},	// 32
+	{0x32, 0x7b000000, 0x0008, 0x37},	// 32
+	{0x32, 0xa2000000, 0x0008, 0x6e},	// 32
+	{0x32, 0xa3000000, 0x0009, 0x61},	// 32
+	{0x32, 0xa3800000, 0x000a, 0x27},	// 32
+	{0x32, 0xa3e00000, 0x000b, 0x3b},	// 32
+	{0x32, 0xa3c00000, 0x000c, 0x73},	// 32
+	{0x32, 0xa3d00000, 0x000d, 0x22},	// 32
+	{0x32, 0xa3d80000, 0x000f, 0x01},	// 32
+	{0x32, 0xa3da0000, 0x000f, 0x69},	// 32
+	{0x32, 0xa3dc0000, 0x000f, 0x57},	// 32
+	{0x32, 0xa3de0000, 0x000f, 0x4c},	// 32
+	{0x33, 0x00000000, 0x0002, 0x20},	// 36
+	{0x33, 0x80000000, 0x0002, 0x30},	// 36
+	{0x33, 0xc0000000, 0x0003, 0x2e},	// 36
+	{0x33, 0xe0000000, 0x0004, 0x2f},	// 36
+	{0x33, 0x40000000, 0x0005, 0x32},	// 36
+	{0x33, 0x48000000, 0x0005, 0x31},	// 36
+	{0x33, 0x50000000, 0x0005, 0x29},	// 36
+	{0x33, 0x60000000, 0x0005, 0x3a},	// 36
+	{0x33, 0x70000000, 0x0005, 0x2d},	// 36
+	{0x33, 0xf8000000, 0x0005, 0x5d},	// 36
+	{0x33, 0x58000000, 0x0006, 0x44},	// 36
+	{0x33, 0x68000000, 0x0006, 0x34},	// 36
+	{0x33, 0x6c000000, 0x0006, 0x00},	// 36
+	{0x33, 0x7c000000, 0x0006, 0x35},	// 36
+	{0x33, 0xf0000000, 0x0006, 0x2c},	// 36
+	{0x33, 0x5c000000, 0x0007, 0x37},	// 36
+	{0x33, 0x5e000000, 0x0007, 0x33},	// 36
+	{0x33, 0x7a000000, 0x0007, 0x36},	// 36
+	{0x33, 0xf6000000, 0x0007, 0x74},	// 36
+	{0x33, 0x79000000, 0x0008, 0x42},	// 36
+	{0x33, 0xf4000000, 0x0008, 0x38},	// 36
+	{0x33, 0xf5000000, 0x0009, 0x39},	// 36
+	{0x33, 0x78400000, 0x000a, 0x3b},	// 36
+	{0x33, 0xf5800000, 0x000a, 0x72},	// 36
+	{0x33, 0xf5c00000, 0x000a, 0x73},	// 36
+	{0x33, 0x78000000, 0x000b, 0x6e},	// 36
+	{0x33, 0x78a00000, 0x000b, 0x62},	// 36
+	{0x33, 0x78c00000, 0x000b, 0x27},	// 36
+	{0x33, 0x78e00000, 0x000b, 0x41},	// 36
+	{0x33, 0x78200000, 0x000c, 0x70},	// 36
+	{0x33, 0x78300000, 0x000c, 0x65},	// 36
+	{0x33, 0x78800000, 0x000d, 0x61},	// 36
+	{0x33, 0x78880000, 0x000d, 0x26},	// 36
+	{0x33, 0x78900000, 0x000d, 0x25},	// 36
+	{0x33, 0x78980000, 0x000e, 0x01},	// 36
+	{0x33, 0x789c0000, 0x000e, 0x6b},	// 36
+	{0x34, 0x40000000, 0x0002, 0x20},	// 35
+	{0x34, 0x00000000, 0x0003, 0x34},	// 35
+	{0x34, 0x80000000, 0x0003, 0x2e},	// 35
+	{0x34, 0xc0000000, 0x0003, 0x30},	// 35
+	{0x34, 0x20000000, 0x0004, 0x2f},	// 35
+	{0x34, 0xa0000000, 0x0004, 0x35},	// 35
+	{0x34, 0xb0000000, 0x0004, 0x2d},	// 35
+	{0x34, 0x30000000, 0x0005, 0x31},	// 35
+	{0x34, 0xe8000000, 0x0005, 0x5d},	// 35
+	{0x34, 0xf0000000, 0x0005, 0x2c},	// 35
+	{0x34, 0x38000000, 0x0006, 0x32},	// 35
+	{0x34, 0xe4000000, 0x0006, 0x38},	// 35
+	{0x34, 0xf8000000, 0x0006, 0x29},	// 35
+	{0x34, 0x3c000000, 0x0007, 0x3a},	// 35
+	{0x34, 0x3e000000, 0x0007, 0x27},	// 35
+	{0x34, 0xe0000000, 0x0007, 0x74},	// 35
+	{0x34, 0xe2000000, 0x0007, 0x33},	// 35
+	{0x34, 0xfe000000, 0x0007, 0x00},	// 35
+	{0x34, 0xfd000000, 0x0008, 0x36},	// 35
+	{0x34, 0xfc000000, 0x000a, 0x39},	// 35
+	{0x34, 0xfc800000, 0x000a, 0x37},	// 35
+	{0x34, 0xfc600000, 0x000b, 0x43},	// 35
+	{0x34, 0xfcc00000, 0x000b, 0x3b},	// 35
+	{0x34, 0xfc500000, 0x000c, 0x78},	// 35
+	{0x34, 0xfce80000, 0x000d, 0x6d},	// 35
+	{0x34, 0xfcf00000, 0x000d, 0x49},	// 35
+	{0x34, 0xfc400000, 0x000e, 0x66},	// 35
+	{0x34, 0xfc440000, 0x000e, 0x65},	// 35
+	{0x34, 0xfc480000, 0x000e, 0x62},	// 35
+	{0x34, 0xfc4c0000, 0x000e, 0x4c},	// 35
+	{0x34, 0xfce00000, 0x000e, 0x25},	// 35
+	{0x34, 0xfcf80000, 0x000e, 0x70},	// 35
+	{0x34, 0xfcfc0000, 0x000e, 0x63},	// 35
+	{0x34, 0xfce40000, 0x000f, 0x01},	// 35
+	{0x34, 0xfce60000, 0x000f, 0x69},	// 35
+	{0x35, 0x00000000, 0x0002, 0x30},	// 32
+	{0x35, 0x80000000, 0x0002, 0x20},	// 32
+	{0x35, 0x40000000, 0x0003, 0x2e},	// 32
+	{0x35, 0x70000000, 0x0004, 0x70},	// 32
+	{0x35, 0xc0000000, 0x0004, 0x35},	// 32
+	{0x35, 0x60000000, 0x0005, 0x2f},	// 32
+	{0x35, 0xd0000000, 0x0005, 0x61},	// 32
+	{0x35, 0xd8000000, 0x0005, 0x2d},	// 32
+	{0x35, 0xe8000000, 0x0005, 0x36},	// 32
+	{0x35, 0x68000000, 0x0006, 0x33},	// 32
+	{0x35, 0xf0000000, 0x0006, 0x32},	// 32
+	{0x35, 0xf8000000, 0x0006, 0x38},	// 32
+	{0x35, 0xfc000000, 0x0006, 0x5d},	// 32
+	{0x35, 0x6c000000, 0x0007, 0x3a},	// 32
+	{0x35, 0xe0000000, 0x0007, 0x29},	// 32
+	{0x35, 0xe2000000, 0x0007, 0x73},	// 32
+	{0x35, 0xe6000000, 0x0007, 0x2c},	// 32
+	{0x35, 0xf4000000, 0x0007, 0x37},	// 32
+	{0x35, 0xf6000000, 0x0007, 0x39},	// 32
+	{0x35, 0x6e000000, 0x0008, 0x34},	// 32
+	{0x35, 0xe4000000, 0x0008, 0x00},	// 32
+	{0x35, 0xe5000000, 0x0008, 0x74},	// 32
+	{0x35, 0x6f800000, 0x000a, 0x63},	// 32
+	{0x35, 0x6fc00000, 0x000a, 0x31},	// 32
+	{0x35, 0x6f200000, 0x000b, 0x3b},	// 32
+	{0x35, 0x6f600000, 0x000b, 0x6d},	// 32
+	{0x35, 0x6f000000, 0x000c, 0x65},	// 32
+	{0x35, 0x6f100000, 0x000c, 0x27},	// 32
+	{0x35, 0x6f500000, 0x000c, 0x6b},	// 32
+	{0x35, 0x6f480000, 0x000d, 0x6c},	// 32
+	{0x35, 0x6f400000, 0x000e, 0x01},	// 32
+	{0x35, 0x6f440000, 0x000e, 0x66},	// 32
+	{0x36, 0x00000000, 0x0002, 0x20},	// 33
+	{0x36, 0x80000000, 0x0002, 0x2e},	// 33
+	{0x36, 0xe0000000, 0x0003, 0x30},	// 33
+	{0x36, 0x50000000, 0x0004, 0x5d},	// 33
+	{0x36, 0x48000000, 0x0005, 0x31},	// 33
+	{0x36, 0x60000000, 0x0005, 0x37},	// 33
+	{0x36, 0x70000000, 0x0005, 0x29},	// 33
+	{0x36, 0xc0000000, 0x0005, 0x2c},	// 33
+	{0x36, 0xc8000000, 0x0005, 0x3a},	// 33
+	{0x36, 0xd0000000, 0x0005, 0x2f},	// 33
+	{0x36, 0x44000000, 0x0006, 0x2d},	// 33
+	{0x36, 0x68000000, 0x0006, 0x35},	// 33
+	{0x36, 0x6c000000, 0x0006, 0x34},	// 33
+	{0x36, 0x7c000000, 0x0006, 0x38},	// 33
+	{0x36, 0xdc000000, 0x0006, 0x74},	// 33
+	{0x36, 0x40000000, 0x0007, 0x36},	// 33
+	{0x36, 0x78000000, 0x0007, 0x33},	// 33
+	{0x36, 0x7a000000, 0x0007, 0x32},	// 33
+	{0x36, 0xda000000, 0x0007, 0x39},	// 33
+	{0x36, 0x42000000, 0x0008, 0x00},	// 33
+	{0x36, 0x43000000, 0x0008, 0x2b},	// 33
+	{0x36, 0xd8000000, 0x0008, 0x27},	// 33
+	{0x36, 0xd9400000, 0x000a, 0x61},	// 33
+	{0x36, 0xd9800000, 0x000a, 0x3f},	// 33
+	{0x36, 0xd9000000, 0x000b, 0x6d},	// 33
+	{0x36, 0xd9200000, 0x000b, 0x65},	// 33
+	{0x36, 0xd9c00000, 0x000b, 0x3b},	// 33
+	{0x36, 0xd9e00000, 0x000d, 0x66},	// 33
+	{0x36, 0xd9e80000, 0x000d, 0x62},	// 33
+	{0x36, 0xd9f00000, 0x000d, 0x4d},	// 33
+	{0x36, 0xd9f80000, 0x000e, 0x22},	// 33
+	{0x36, 0xd9fc0000, 0x000f, 0x01},	// 33
+	{0x36, 0xd9fe0000, 0x000f, 0x69},	// 33
+	{0x37, 0xc0000000, 0x0002, 0x2e},	// 31
+	{0x37, 0x20000000, 0x0003, 0x20},	// 31
+	{0x37, 0x60000000, 0x0003, 0x30},	// 31
+	{0x37, 0xa0000000, 0x0003, 0x2d},	// 31
+	{0x37, 0x00000000, 0x0004, 0x38},	// 31
+	{0x37, 0x40000000, 0x0004, 0x37},	// 31
+	{0x37, 0x90000000, 0x0004, 0x5d},	// 31
+	{0x37, 0x50000000, 0x0005, 0x2f},	// 31
+	{0x37, 0x14000000, 0x0006, 0x36},	// 31
+	{0x37, 0x18000000, 0x0006, 0x32},	// 31
+	{0x37, 0x1c000000, 0x0006, 0x31},	// 31
+	{0x37, 0x5c000000, 0x0006, 0x74},	// 31
+	{0x37, 0x80000000, 0x0006, 0x39},	// 31
+	{0x37, 0x88000000, 0x0006, 0x29},	// 31
+	{0x37, 0x8c000000, 0x0006, 0x35},	// 31
+	{0x37, 0x12000000, 0x0007, 0x33},	// 31
+	{0x37, 0x5a000000, 0x0007, 0x2c},	// 31
+	{0x37, 0x84000000, 0x0007, 0x61},	// 31
+	{0x37, 0x86000000, 0x0007, 0x34},	// 31
+	{0x37, 0x10000000, 0x0008, 0x00},	// 31
+	{0x37, 0x58000000, 0x0008, 0x3a},	// 31
+	{0x37, 0x59000000, 0x0008, 0x70},	// 31
+	{0x37, 0x11400000, 0x000a, 0x52},	// 31
+	{0x37, 0x11800000, 0x000a, 0x3b},	// 31
+	{0x37, 0x11000000, 0x000b, 0x27},	// 31
+	{0x37, 0x11e00000, 0x000b, 0x6d},	// 31
+	{0x37, 0x11300000, 0x000c, 0x66},	// 31
+	{0x37, 0x11c00000, 0x000c, 0x41},	// 31
+	{0x37, 0x11d00000, 0x000c, 0x3f},	// 31
+	{0x37, 0x11200000, 0x000d, 0x01},	// 31
+	{0x37, 0x11280000, 0x000d, 0x73},	// 31
+	{0x38, 0x40000000, 0x0002, 0x20},	// 31
+	{0x38, 0x00000000, 0x0003, 0x34},	// 31
+	{0x38, 0xc0000000, 0x0003, 0x2e},	// 31
+	{0x38, 0x30000000, 0x0004, 0x30},	// 31
+	{0x38, 0x80000000, 0x0004, 0x39},	// 31
+	{0x38, 0x90000000, 0x0004, 0x37},	// 31
+	{0x38, 0xb0000000, 0x0004, 0x38},	// 31
+	{0x38, 0xe0000000, 0x0004, 0x31},	// 31
+	{0x38, 0x20000000, 0x0005, 0x2f},	// 31
+	{0x38, 0xa0000000, 0x0005, 0x33},	// 31
+	{0x38, 0xf0000000, 0x0005, 0x35},	// 31
+	{0x38, 0xa8000000, 0x0006, 0x29},	// 31
+	{0x38, 0xf8000000, 0x0006, 0x36},	// 31
+	{0x38, 0xfc000000, 0x0006, 0x5d},	// 31
+	{0x38, 0x28000000, 0x0007, 0x3a},	// 31
+	{0x38, 0x2a000000, 0x0007, 0x2c},	// 31
+	{0x38, 0xae000000, 0x0007, 0x74},	// 31
+	{0x38, 0x2c000000, 0x0008, 0x70},	// 31
+	{0x38, 0x2d000000, 0x0008, 0x2d},	// 31
+	{0x38, 0x2f000000, 0x0008, 0x61},	// 31
+	{0x38, 0xac000000, 0x0008, 0x63},	// 31
+	{0x38, 0xad000000, 0x0008, 0x32},	// 31
+	{0x38, 0x2e800000, 0x0009, 0x00},	// 31
+	{0x38, 0x2e400000, 0x000a, 0x3b},	// 31
+	{0x38, 0x2e000000, 0x000c, 0x6c},	// 31
+	{0x38, 0x2e100000, 0x000c, 0x27},	// 31
+	{0x38, 0x2e200000, 0x000d, 0x66},	// 31
+	{0x38, 0x2e280000, 0x000d, 0x44},	// 31
+	{0x38, 0x2e300000, 0x000d, 0x41},	// 31
+	{0x38, 0x2e380000, 0x000e, 0x01},	// 31
+	{0x38, 0x2e3c0000, 0x000e, 0x69},	// 31
+	{0x39, 0x00000000, 0x0003, 0x35},	// 28
+	{0x39, 0x20000000, 0x0003, 0x5d},	// 28
+	{0x39, 0xe0000000, 0x0003, 0x39},	// 28
+	{0x39, 0x50000000, 0x0004, 0x30},	// 28
+	{0x39, 0x60000000, 0x0004, 0x2e},	// 28
+	{0x39, 0x70000000, 0x0004, 0x2d},	// 28
+	{0x39, 0x80000000, 0x0004, 0x34},	// 28
+	{0x39, 0x90000000, 0x0004, 0x38},	// 28
+	{0x39, 0xb0000000, 0x0004, 0x36},	// 28
+	{0x39, 0xc0000000, 0x0004, 0x20},	// 28
+	{0x39, 0xd0000000, 0x0004, 0x37},	// 28
+	{0x39, 0x40000000, 0x0005, 0x32},	// 28
+	{0x39, 0xa0000000, 0x0005, 0x33},	// 28
+	{0x39, 0x48000000, 0x0006, 0x31},	// 28
+	{0x39, 0x4c000000, 0x0006, 0x2f},	// 28
+	{0x39, 0xa8000000, 0x0006, 0x74},	// 28
+	{0x39, 0xae000000, 0x0007, 0x29},	// 28
+	{0x39, 0xac000000, 0x0008, 0x3a},	// 28
+	{0x39, 0xad000000, 0x0009, 0x2c},	// 28
+	{0x39, 0xad800000, 0x000b, 0x70},	// 28
+	{0x39, 0xada00000, 0x000b, 0x3b},	// 28
+	{0x39, 0xade00000, 0x000b, 0x00},	// 28
+	{0x39, 0xadc00000, 0x000d, 0x6e},	// 28
+	{0x39, 0xadc80000, 0x000d, 0x6d},	// 28
+	{0x39, 0xadd00000, 0x000d, 0x61},	// 28
+	{0x39, 0xaddc0000, 0x000e, 0x65},	// 28
+	{0x39, 0xadd80000, 0x000f, 0x01},	// 28
+	{0x39, 0xadda0000, 0x000f, 0x6b},	// 28
+	{0x3a, 0x80000000, 0x0001, 0x20},	// 9
+	{0x3a, 0x40000000, 0x0002, 0x30},	// 9
+	{0x3a, 0x20000000, 0x0003, 0x33},	// 9
+	{0x3a, 0x08000000, 0x0005, 0x31},	// 9
+	{0x3a, 0x10000000, 0x0005, 0x54},	// 9
+	{0x3a, 0x18000000, 0x0005, 0x43},	// 9
+	{0x3a, 0x04000000, 0x0006, 0x34},	// 9
+	{0x3a, 0x00000000, 0x0007, 0x01},	// 9
+	{0x3a, 0x02000000, 0x0007, 0x35},	// 9
+	{0x3b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3b, 0x80000000, 0x0001, 0x20},	// 2
+	{0x3c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3d, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x3e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x3f, 0x80000000, 0x0001, 0x20},	// 12
+	{0x3f, 0x40000000, 0x0002, 0x00},	// 12
+	{0x3f, 0x00000000, 0x0003, 0x3a},	// 12
+	{0x3f, 0x20000000, 0x0005, 0x21},	// 12
+	{0x3f, 0x30000000, 0x0005, 0x5b},	// 12
+	{0x3f, 0x38000000, 0x0005, 0x2e},	// 12
+	{0x3f, 0x28000000, 0x0006, 0x3b},	// 12
+	{0x3f, 0x2c000000, 0x0007, 0x27},	// 12
+	{0x3f, 0x2f000000, 0x0008, 0x2c},	// 12
+	{0x3f, 0x2e800000, 0x0009, 0x2f},	// 12
+	{0x3f, 0x2e000000, 0x000a, 0x01},	// 12
+	{0x3f, 0x2e400000, 0x000a, 0x51},	// 12
+	{0x40, 0x00000000, 0x0001, 0x6b},	// 6
+	{0x40, 0x80000000, 0x0002, 0x20},	// 6
+	{0x40, 0xe0000000, 0x0003, 0x54},	// 6
+	{0x40, 0xd0000000, 0x0004, 0x62},	// 6
+	{0x40, 0xc0000000, 0x0005, 0x01},	// 6
+	{0x40, 0xc8000000, 0x0005, 0x48},	// 6
+	{0x41, 0x40000000, 0x0002, 0x20},	// 58
+	{0x41, 0xc0000000, 0x0003, 0x44},	// 58
+	{0x41, 0xe0000000, 0x0003, 0x6e},	// 58
+	{0x41, 0x00000000, 0x0004, 0x73},	// 58
+	{0x41, 0x10000000, 0x0004, 0x6d},	// 58
+	{0x41, 0x20000000, 0x0004, 0x64},	// 58
+	{0x41, 0x80000000, 0x0004, 0x72},	// 58
+	{0x41, 0xb0000000, 0x0004, 0x6c},	// 58
+	{0x41, 0x30000000, 0x0005, 0x63},	// 58
+	{0x41, 0x90000000, 0x0005, 0x75},	// 58
+	{0x41, 0xa0000000, 0x0005, 0x67},	// 58
+	{0x41, 0x3c000000, 0x0006, 0x62},	// 58
+	{0x41, 0x9c000000, 0x0006, 0x74},	// 58
+	{0x41, 0xac000000, 0x0006, 0x66},	// 58
+	{0x41, 0xa8000000, 0x0007, 0x77},	// 58
+	{0x41, 0xaa000000, 0x0007, 0x69},	// 58
+	{0x41, 0x99000000, 0x0008, 0x76},	// 58
+	{0x41, 0x9b000000, 0x0008, 0x70},	// 58
+	{0x41, 0x39000000, 0x0009, 0x68},	// 58
+	{0x41, 0x3a000000, 0x0009, 0x2e},	// 58
+	{0x41, 0x3b800000, 0x0009, 0x42},	// 58
+	{0x41, 0x9a000000, 0x0009, 0x71},	// 58
+	{0x41, 0x38000000, 0x000a, 0x43},	// 58
+	{0x41, 0x38800000, 0x000a, 0x2c},	// 58
+	{0x41, 0x39800000, 0x000a, 0x79},	// 58
+	{0x41, 0x3a800000, 0x000a, 0x53},	// 58
+	{0x41, 0x3b000000, 0x000a, 0x6b},	// 58
+	{0x41, 0x3b400000, 0x000a, 0x54},	// 58
+	{0x41, 0x98400000, 0x000a, 0x52},	// 58
+	{0x41, 0x98800000, 0x000a, 0x46},	// 58
+	{0x41, 0x98c00000, 0x000a, 0x7a},	// 58
+	{0x41, 0x9ac00000, 0x000a, 0x61},	// 58
+	{0x41, 0x38400000, 0x000b, 0x50},	// 58
+	{0x41, 0x38c00000, 0x000b, 0x2d},	// 58
+	{0x41, 0x3ac00000, 0x000b, 0x41},	// 58
+	{0x41, 0x3ae00000, 0x000b, 0x49},	// 58
+	{0x41, 0x98200000, 0x000b, 0x65},	// 58
+	{0x41, 0x9a800000, 0x000b, 0x4e},	// 58
+	{0x41, 0x9aa00000, 0x000b, 0x78},	// 58
+	{0x41, 0x38600000, 0x000c, 0x58},	// 58
+	{0x41, 0x38700000, 0x000c, 0x4b},	// 58
+	{0x41, 0x38e00000, 0x000c, 0x33},	// 58
+	{0x41, 0x38f00000, 0x000c, 0x26},	// 58
+	{0x41, 0x39d00000, 0x000c, 0x4d},	// 58
+	{0x41, 0x39f00000, 0x000c, 0x59},	// 58
+	{0x41, 0x39c00000, 0x000d, 0x4c},	// 58
+	{0x41, 0x39c80000, 0x000d, 0x57},	// 58
+	{0x41, 0x39e00000, 0x000d, 0x2a},	// 58
+	{0x41, 0x98000000, 0x000d, 0x6f},	// 58
+	{0x41, 0x98080000, 0x000d, 0x31},	// 58
+	{0x41, 0x98100000, 0x000d, 0x27},	// 58
+	{0x41, 0x98180000, 0x000d, 0x3a},	// 58
+	{0x41, 0x39e80000, 0x000e, 0x6a},	// 58
+	{0x41, 0x39ec0000, 0x000f, 0x47},	// 58
+	{0x41, 0x39ee0000, 0x0010, 0x4f},	// 58
+	{0x41, 0x39ef0000, 0x0011, 0x34},	// 58
+	{0x41, 0x39ef8000, 0x0012, 0x01},	// 58
+	{0x41, 0x39efc000, 0x0012, 0x45},	// 58
+	{0x42, 0x00000000, 0x0002, 0x43},	// 40
+	{0x42, 0x40000000, 0x0003, 0x61},	// 40
+	{0x42, 0xa0000000, 0x0003, 0x72},	// 40
+	{0x42, 0xc0000000, 0x0003, 0x65},	// 40
+	{0x42, 0xe0000000, 0x0003, 0x42},	// 40
+	{0x42, 0x70000000, 0x0004, 0x69},	// 40
+	{0x42, 0x80000000, 0x0004, 0x75},	// 40
+	{0x42, 0x90000000, 0x0004, 0x6f},	// 40
+	{0x42, 0x68000000, 0x0005, 0x6c},	// 40
+	{0x42, 0x60000000, 0x0008, 0x54},	// 40
+	{0x42, 0x61000000, 0x0008, 0x2e},	// 40
+	{0x42, 0x63000000, 0x0008, 0x79},	// 40
+	{0x42, 0x64000000, 0x0008, 0x49},	// 40
+	{0x42, 0x66000000, 0x0008, 0x68},	// 40
+	{0x42, 0x67000000, 0x0008, 0x20},	// 40
+	{0x42, 0x62000000, 0x0009, 0x41},	// 40
+	{0x42, 0x62800000, 0x000a, 0x4f},	// 40
+	{0x42, 0x62c00000, 0x000b, 0x3a},	// 40
+	{0x42, 0x65000000, 0x000b, 0x26},	// 40
+	{0x42, 0x65200000, 0x000b, 0x33},	// 40
+	{0x42, 0x65400000, 0x000b, 0x6a},	// 40
+	{0x42, 0x65600000, 0x000b, 0x4d},	// 40
+	{0x42, 0x65c00000, 0x000b, 0x44},	// 40
+	{0x42, 0x62f00000, 0x000c, 0x57},	// 40
+	{0x42, 0x65800000, 0x000c, 0x2a},	// 40
+	{0x42, 0x65a00000, 0x000c, 0x2c},	// 40
+	{0x42, 0x65b00000, 0x000c, 0x31},	// 40
+	{0x42, 0x65e00000, 0x000c, 0x01},	// 40
+	{0x42, 0x65f00000, 0x000c, 0x50},	// 40
+	{0x42, 0x62e00000, 0x000d, 0x45},	// 40
+	{0x42, 0x65980000, 0x000d, 0x52},	// 40
+	{0x42, 0x62ec0000, 0x000e, 0x77},	// 40
+	{0x42, 0x62e80000, 0x000f, 0x2d},	// 40
+	{0x42, 0x65920000, 0x000f, 0x55},	// 40
+	{0x42, 0x65940000, 0x000f, 0x53},	// 40
+	{0x42, 0x65960000, 0x000f, 0x46},	// 40
+	{0x42, 0x62ea0000, 0x0010, 0x58},	// 40
+	{0x42, 0x62eb0000, 0x0010, 0x56},	// 40
+	{0x42, 0x65900000, 0x0010, 0x51},	// 40
+	{0x42, 0x65910000, 0x0010, 0x34},	// 40
+	{0x43, 0x00000000, 0x0002, 0x68},	// 47
+	{0x43, 0x60000000, 0x0003, 0x42},	// 47
+	{0x43, 0x80000000, 0x0003, 0x61},	// 47
+	{0x43, 0xc0000000, 0x0003, 0x6f},	// 47
+	{0x43, 0x50000000, 0x0004, 0x72},	// 47
+	{0x43, 0xa0000000, 0x0004, 0x2e},	// 47
+	{0x43, 0xe0000000, 0x0004, 0x20},	// 47
+	{0x43, 0xf0000000, 0x0004, 0x6c},	// 47
+	{0x43, 0x40000000, 0x0005, 0x27},	// 47
+	{0x43, 0xb8000000, 0x0005, 0x69},	// 47
+	{0x43, 0x4c000000, 0x0006, 0x65},	// 47
+	{0x43, 0xb4000000, 0x0006, 0x75},	// 47
+	{0x43, 0x4a000000, 0x0007, 0x79},	// 47
+	{0x43, 0xb2000000, 0x0007, 0x2c},	// 47
+	{0x43, 0x49000000, 0x0008, 0x49},	// 47
+	{0x43, 0x48000000, 0x0009, 0x41},	// 47
+	{0x43, 0xb0000000, 0x000a, 0x43},	// 47
+	{0x43, 0xb0400000, 0x000a, 0x44},	// 47
+	{0x43, 0xb0c00000, 0x000a, 0x00},	// 47
+	{0x43, 0xb1000000, 0x000a, 0x53},	// 47
+	{0x43, 0xb1400000, 0x000a, 0x54},	// 47
+	{0x43, 0xb1c00000, 0x000a, 0x47},	// 47
+	{0x43, 0x48800000, 0x000b, 0x2a},	// 47
+	{0x43, 0x48e00000, 0x000b, 0x77},	// 47
+	{0x43, 0xb1a00000, 0x000b, 0x4a},	// 47
+	{0x43, 0x48a00000, 0x000c, 0x52},	// 47
+	{0x43, 0x48c00000, 0x000c, 0x32},	// 47
+	{0x43, 0x48d00000, 0x000c, 0x55},	// 47
+	{0x43, 0xb0800000, 0x000c, 0x3f},	// 47
+	{0x43, 0xb0a00000, 0x000c, 0x4f},	// 47
+	{0x43, 0xb0b00000, 0x000c, 0x48},	// 47
+	{0x43, 0xb1800000, 0x000c, 0x45},	// 47
+	{0x43, 0x48b00000, 0x000d, 0x7a},	// 47
+	{0x43, 0xb0980000, 0x000d, 0x2d},	// 47
+	{0x43, 0xb1980000, 0x000d, 0x73},	// 47
+	{0x43, 0x48bc0000, 0x000e, 0x31},	// 47
+	{0x43, 0xb0940000, 0x000e, 0x21},	// 47
+	{0x43, 0xb1900000, 0x000e, 0x50},	// 47
+	{0x43, 0x48ba0000, 0x000f, 0x6e},	// 47
+	{0x43, 0xb0900000, 0x000f, 0x4b},	// 47
+	{0x43, 0xb0920000, 0x000f, 0x37},	// 47
+	{0x43, 0xb1960000, 0x000f, 0x34},	// 47
+	{0x43, 0x48b80000, 0x0010, 0x3a},	// 47
+	{0x43, 0xb1940000, 0x0010, 0x46},	// 47
+	{0x43, 0xb1950000, 0x0010, 0x29},	// 47
+	{0x43, 0x48b90000, 0x0011, 0x01},	// 47
+	{0x43, 0x48b98000, 0x0011, 0x62},	// 47
+	{0x44, 0x00000000, 0x0002, 0x61},	// 47
+	{0x44, 0x40000000, 0x0002, 0x2c},	// 47
+	{0x44, 0x80000000, 0x0003, 0x72},	// 47
+	{0x44, 0xa0000000, 0x0003, 0x6f},	// 47
+	{0x44, 0xc0000000, 0x0003, 0x65},	// 47
+	{0x44, 0xe0000000, 0x0004, 0x69},	// 47
+	{0x44, 0xfc000000, 0x0006, 0x75},	// 47
+	{0x44, 0xf2000000, 0x0007, 0x20},	// 47
+	{0x44, 0xf6000000, 0x0007, 0x27},	// 47
+	{0x44, 0xf0000000, 0x0008, 0x2e},	// 47
+	{0x44, 0xf1000000, 0x0008, 0x5d},	// 47
+	{0x44, 0xfa000000, 0x0008, 0x79},	// 47
+	{0x44, 0xf5000000, 0x0009, 0x77},	// 47
+	{0x44, 0xf5800000, 0x0009, 0x57},	// 47
+	{0x44, 0xf8800000, 0x0009, 0x4e},	// 47
+	{0x44, 0xf9000000, 0x0009, 0x43},	// 47
+	{0x44, 0xfb800000, 0x0009, 0x4a},	// 47
+	{0x44, 0xf4800000, 0x000a, 0x68},	// 47
+	{0x44, 0xf8000000, 0x000a, 0x74},	// 47
+	{0x44, 0xf9c00000, 0x000a, 0x49},	// 47
+	{0x44, 0xfb400000, 0x000a, 0x3a},	// 47
+	{0x44, 0xf4200000, 0x000b, 0x4d},	// 47
+	{0x44, 0xf4400000, 0x000b, 0x26},	// 47
+	{0x44, 0xf4600000, 0x000b, 0x56},	// 47
+	{0x44, 0xf8400000, 0x000b, 0x2d},	// 47
+	{0x44, 0xf8600000, 0x000b, 0x47},	// 47
+	{0x44, 0xf9800000, 0x000b, 0x4f},	// 47
+	{0x44, 0xf9a00000, 0x000b, 0x41},	// 47
+	{0x44, 0xfb200000, 0x000b, 0x53},	// 47
+	{0x44, 0xf4000000, 0x000c, 0x46},	// 47
+	{0x44, 0xf4c00000, 0x000c, 0x2a},	// 47
+	{0x44, 0xf4d00000, 0x000c, 0x73},	// 47
+	{0x44, 0xf4f00000, 0x000c, 0x64},	// 47
+	{0x44, 0xfb000000, 0x000c, 0x76},	// 47
+	{0x44, 0xf4e00000, 0x000d, 0x6d},	// 47
+	{0x44, 0xf4e80000, 0x000d, 0x6a},	// 47
+	{0x44, 0xfb100000, 0x000d, 0x01},	// 47
+	{0x44, 0xfb180000, 0x000d, 0x54},	// 47
+	{0x44, 0xf4180000, 0x000e, 0x39},	// 47
+	{0x44, 0xf4100000, 0x000f, 0x29},	// 47
+	{0x44, 0xf4160000, 0x000f, 0x45},	// 47
+	{0x44, 0xf41c0000, 0x000f, 0x38},	// 47
+	{0x44, 0xf41e0000, 0x000f, 0x37},	// 47
+	{0x44, 0xf4120000, 0x0010, 0x55},	// 47
+	{0x44, 0xf4130000, 0x0010, 0x52},	// 47
+	{0x44, 0xf4140000, 0x0010, 0x42},	// 47
+	{0x44, 0xf4150000, 0x0010, 0x34},	// 47
+	{0x45, 0x00000000, 0x0003, 0x70},	// 54
+	{0x45, 0x40000000, 0x0003, 0x61},	// 54
+	{0x45, 0x60000000, 0x0003, 0x6e},	// 54
+	{0x45, 0xc0000000, 0x0003, 0x6c},	// 54
+	{0x45, 0x90000000, 0x0004, 0x6d},	// 54
+	{0x45, 0xa0000000, 0x0004, 0x78},	// 54
+	{0x45, 0xe0000000, 0x0004, 0x76},	// 54
+	{0x45, 0xf0000000, 0x0004, 0x64},	// 54
+	{0x45, 0x20000000, 0x0005, 0x73},	// 54
+	{0x45, 0x30000000, 0x0005, 0x72},	// 54
+	{0x45, 0x38000000, 0x0005, 0x75},	// 54
+	{0x45, 0x80000000, 0x0005, 0x45},	// 54
+	{0x45, 0x88000000, 0x0005, 0x20},	// 54
+	{0x45, 0x28000000, 0x0006, 0x2e},	// 54
+	{0x45, 0x2c000000, 0x0006, 0x69},	// 54
+	{0x45, 0xb4000000, 0x0006, 0x3a},	// 54
+	{0x45, 0xb0000000, 0x0007, 0x79},	// 54
+	{0x45, 0xb2000000, 0x0007, 0x74},	// 54
+	{0x45, 0xb8000000, 0x0007, 0x67},	// 54
+	{0x45, 0xbc000000, 0x0007, 0x34},	// 54
+	{0x45, 0xbb000000, 0x0009, 0x77},	// 54
+	{0x45, 0xbe000000, 0x0009, 0x63},	// 54
+	{0x45, 0xbf000000, 0x0009, 0x62},	// 54
+	{0x45, 0xba800000, 0x000a, 0x52},	// 54
+	{0x45, 0xbac00000, 0x000a, 0x46},	// 54
+	{0x45, 0xbbc00000, 0x000a, 0x43},	// 54
+	{0x45, 0xba200000, 0x000b, 0x6b},	// 54
+	{0x45, 0xba400000, 0x000b, 0x66},	// 54
+	{0x45, 0xba600000, 0x000b, 0x6f},	// 54
+	{0x45, 0xbb800000, 0x000b, 0x55},	// 54
+	{0x45, 0xbba00000, 0x000b, 0x4c},	// 54
+	{0x45, 0xbea00000, 0x000b, 0x65},	// 54
+	{0x45, 0xbec00000, 0x000b, 0x4e},	// 54
+	{0x45, 0xbf800000, 0x000b, 0x68},	// 54
+	{0x45, 0xbfa00000, 0x000b, 0x49},	// 54
+	{0x45, 0xbfe00000, 0x000b, 0x44},	// 54
+	{0x45, 0xbe800000, 0x000c, 0x4d},	// 54
+	{0x45, 0xbef00000, 0x000c, 0x27},	// 54
+	{0x45, 0xbfc00000, 0x000c, 0x32},	// 54
+	{0x45, 0xbfd00000, 0x000c, 0x2d},	// 54
+	{0x45, 0xba180000, 0x000d, 0x71},	// 54
+	{0x45, 0xbe900000, 0x000d, 0x4f},	// 54
+	{0x45, 0xbe980000, 0x000d, 0x41},	// 54
+	{0x45, 0xbee80000, 0x000d, 0x5a},	// 54
+	{0x45, 0xba000000, 0x000e, 0x57},	// 54
+	{0x45, 0xba040000, 0x000e, 0x53},	// 54
+	{0x45, 0xba080000, 0x000e, 0x48},	// 54
+	{0x45, 0xba0c0000, 0x000e, 0x39},	// 54
+	{0x45, 0xba100000, 0x000e, 0x29},	// 54
+	{0x45, 0xbee00000, 0x000e, 0x54},	// 54
+	{0x45, 0xbee40000, 0x000e, 0x2c},	// 54
+	{0x45, 0xba140000, 0x000f, 0x50},	// 54
+	{0x45, 0xba160000, 0x0010, 0x01},	// 54
+	{0x45, 0xba170000, 0x0010, 0x7a},	// 54
+	{0x46, 0x00000000, 0x0002, 0x6f},	// 36
+	{0x46, 0x80000000, 0x0002, 0x72},	// 36
+	{0x46, 0x40000000, 0x0003, 0x65},	// 36
+	{0x46, 0xc0000000, 0x0003, 0x69},	// 36
+	{0x46, 0xe0000000, 0x0003, 0x61},	// 36
+	{0x46, 0x60000000, 0x0004, 0x6c},	// 36
+	{0x46, 0x70000000, 0x0005, 0x75},	// 36
+	{0x46, 0x78000000, 0x0007, 0x20},	// 36
+	{0x46, 0x7a000000, 0x0007, 0x4f},	// 36
+	{0x46, 0x7d000000, 0x0008, 0x41},	// 36
+	{0x46, 0x7f000000, 0x0008, 0x42},	// 36
+	{0x46, 0x7e000000, 0x0009, 0x66},	// 36
+	{0x46, 0x7c000000, 0x000a, 0x2e},	// 36
+	{0x46, 0x7cc00000, 0x000a, 0x4c},	// 36
+	{0x46, 0x7c400000, 0x000b, 0x4d},	// 36
+	{0x46, 0x7c600000, 0x000b, 0x45},	// 36
+	{0x46, 0x7ca00000, 0x000b, 0x54},	// 36
+	{0x46, 0x7ea00000, 0x000b, 0x43},	// 36
+	{0x46, 0x7ec00000, 0x000b, 0x57},	// 36
+	{0x46, 0x7c800000, 0x000c, 0x3a},	// 36
+	{0x46, 0x7e800000, 0x000c, 0x55},	// 36
+	{0x46, 0x7e900000, 0x000c, 0x27},	// 36
+	{0x46, 0x7ef00000, 0x000c, 0x31},	// 36
+	{0x46, 0x7c900000, 0x000d, 0x79},	// 36
+	{0x46, 0x7c980000, 0x000d, 0x2c},	// 36
+	{0x46, 0x7ee00000, 0x000e, 0x2d},	// 36
+	{0x46, 0x7ee80000, 0x000e, 0x49},	// 36
+	{0x46, 0x7ee60000, 0x000f, 0x68},	// 36
+	{0x46, 0x7ee40000, 0x0010, 0x2a},	// 36
+	{0x46, 0x7ee50000, 0x0010, 0x4b},	// 36
+	{0x46, 0x7eec0000, 0x0010, 0x46},	// 36
+	{0x46, 0x7eed0000, 0x0010, 0x01},	// 36
+	{0x46, 0x7eee0000, 0x0011, 0x58},	// 36
+	{0x46, 0x7eee8000, 0x0011, 0x52},	// 36
+	{0x46, 0x7eef0000, 0x0011, 0x3b},	// 36
+	{0x46, 0x7eef8000, 0x0011, 0x34},	// 36
+	{0x47, 0x00000000, 0x0002, 0x72},	// 37
+	{0x47, 0x40000000, 0x0002, 0x61},	// 37
+	{0x47, 0xa0000000, 0x0003, 0x6f},	// 37
+	{0x47, 0xc0000000, 0x0003, 0x65},	// 37
+	{0x47, 0x90000000, 0x0004, 0x75},	// 37
+	{0x47, 0xf0000000, 0x0004, 0x69},	// 37
+	{0x47, 0x88000000, 0x0005, 0x6e},	// 37
+	{0x47, 0xe8000000, 0x0005, 0x6c},	// 37
+	{0x47, 0x80000000, 0x0006, 0x58},	// 37
+	{0x47, 0xe0000000, 0x0007, 0x79},	// 37
+	{0x47, 0xe2000000, 0x0007, 0x20},	// 37
+	{0x47, 0xe6000000, 0x0007, 0x77},	// 37
+	{0x47, 0x85000000, 0x0008, 0x34},	// 37
+	{0x47, 0x87000000, 0x0008, 0x50},	// 37
+	{0x47, 0xe5000000, 0x0008, 0x68},	// 37
+	{0x47, 0x84000000, 0x0009, 0x2d},	// 37
+	{0x47, 0x86000000, 0x0009, 0x43},	// 37
+	{0x47, 0xe4800000, 0x0009, 0x4d},	// 37
+	{0x47, 0x86800000, 0x000a, 0x42},	// 37
+	{0x47, 0xe4000000, 0x000a, 0x2e},	// 37
+	{0x47, 0xe4400000, 0x000a, 0x49},	// 37
+	{0x47, 0x84800000, 0x000b, 0x3b},	// 37
+	{0x47, 0x84a00000, 0x000b, 0x2c},	// 37
+	{0x47, 0x84c00000, 0x000b, 0x41},	// 37
+	{0x47, 0x84e00000, 0x000b, 0x4e},	// 37
+	{0x47, 0x86e00000, 0x000b, 0x3a},	// 37
+	{0x47, 0x86c00000, 0x000d, 0x4f},	// 37
+	{0x47, 0x86c80000, 0x000d, 0x4c},	// 37
+	{0x47, 0x86d80000, 0x000e, 0x62},	// 37
+	{0x47, 0x86d00000, 0x000f, 0x4b},	// 37
+	{0x47, 0x86d20000, 0x000f, 0x32},	// 37
+	{0x47, 0x86d40000, 0x000f, 0x31},	// 37
+	{0x47, 0x86d60000, 0x000f, 0x27},	// 37
+	{0x47, 0x86dc0000, 0x0010, 0x01},	// 37
+	{0x47, 0x86dd0000, 0x0010, 0x6d},	// 37
+	{0x47, 0x86de0000, 0x0010, 0x54},	// 37
+	{0x47, 0x86df0000, 0x0010, 0x53},	// 37
+	{0x48, 0x00000000, 0x0002, 0x65},	// 32
+	{0x48, 0x40000000, 0x0002, 0x61},	// 32
+	{0x48, 0x80000000, 0x0002, 0x6f},	// 32
+	{0x48, 0xc0000000, 0x0003, 0x69},	// 32
+	{0x48, 0xf0000000, 0x0004, 0x75},	// 32
+	{0x48, 0xe0000000, 0x0005, 0x52},	// 32
+	{0x48, 0xe8000000, 0x0007, 0x50},	// 32
+	{0x48, 0xec000000, 0x0007, 0x79},	// 32
+	{0x48, 0xeb000000, 0x0008, 0x49},	// 32
+	{0x48, 0xee000000, 0x0009, 0x51},	// 32
+	{0x48, 0xee800000, 0x0009, 0x4d},	// 32
+	{0x48, 0xef000000, 0x0009, 0x41},	// 32
+	{0x48, 0xef800000, 0x0009, 0x20},	// 32
+	{0x48, 0xea000000, 0x000a, 0x53},	// 32
+	{0x48, 0xea400000, 0x000a, 0x2e},	// 32
+	{0x48, 0xeaa00000, 0x000b, 0x47},	// 32
+	{0x48, 0xeac00000, 0x000b, 0x29},	// 32
+	{0x48, 0xea900000, 0x000c, 0x45},	// 32
+	{0x48, 0xeae00000, 0x000d, 0x4f},	// 32
+	{0x48, 0xeae80000, 0x000d, 0x4c},	// 32
+	{0x48, 0xea800000, 0x000e, 0x31},	// 32
+	{0x48, 0xea840000, 0x000e, 0x26},	// 32
+	{0x48, 0xeaf00000, 0x000e, 0x48},	// 32
+	{0x48, 0xeaf40000, 0x000e, 0x77},	// 32
+	{0x48, 0xeaf80000, 0x000e, 0x76},	// 32
+	{0x48, 0xea880000, 0x000f, 0x58},	// 32
+	{0x48, 0xea8a0000, 0x000f, 0x57},	// 32
+	{0x48, 0xea8c0000, 0x000f, 0x44},	// 32
+	{0x48, 0xeafc0000, 0x000f, 0x73},	// 32
+	{0x48, 0xeafe0000, 0x000f, 0x46},	// 32
+	{0x48, 0xea8e0000, 0x0010, 0x01},	// 32
+	{0x48, 0xea8f0000, 0x0010, 0x72},	// 32
+	{0x49, 0x00000000, 0x0001, 0x6e},	// 52
+	{0x49, 0xc0000000, 0x0003, 0x74},	// 52
+	{0x49, 0x90000000, 0x0004, 0x73},	// 52
+	{0x49, 0xf0000000, 0x0004, 0x72},	// 52
+	{0x49, 0x80000000, 0x0005, 0x54},	// 52
+	{0x49, 0xa8000000, 0x0005, 0x61},	// 52
+	{0x49, 0xe0000000, 0x0005, 0x20},	// 52
+	{0x49, 0x88000000, 0x0006, 0x63},	// 52
+	{0x49, 0xa4000000, 0x0006, 0x6d},	// 52
+	{0x49, 0xb0000000, 0x0006, 0x7a},	// 52
+	{0x49, 0xb4000000, 0x0006, 0x2e},	// 52
+	{0x49, 0xbc000000, 0x0006, 0x64},	// 52
+	{0x49, 0xec000000, 0x0006, 0x49},	// 52
+	{0x49, 0x8e000000, 0x0007, 0x27},	// 52
+	{0x49, 0xba000000, 0x0007, 0x6c},	// 52
+	{0x49, 0xa0000000, 0x0008, 0x41},	// 52
+	{0x49, 0xa1000000, 0x0008, 0x76},	// 52
+	{0x49, 0xb9000000, 0x0008, 0x56},	// 52
+	{0x49, 0xe9000000, 0x0008, 0x66},	// 52
+	{0x49, 0xeb000000, 0x0008, 0x6f},	// 52
+	{0x49, 0x8c800000, 0x0009, 0x43},	// 52
+	{0x49, 0x8d000000, 0x0009, 0x50},	// 52
+	{0x49, 0xa2000000, 0x0009, 0x77},	// 52
+	{0x49, 0xa3000000, 0x0009, 0x3a},	// 52
+	{0x49, 0xb8000000, 0x0009, 0x70},	// 52
+	{0x49, 0xe8000000, 0x0009, 0x52},	// 52
+	{0x49, 0xe8800000, 0x0009, 0x2c},	// 52
+	{0x49, 0xea800000, 0x0009, 0x59},	// 52
+	{0x49, 0x8c000000, 0x000a, 0x45},	// 52
+	{0x49, 0x8c400000, 0x000a, 0x36},	// 52
+	{0x49, 0x8dc00000, 0x000a, 0x71},	// 52
+	{0x49, 0xa2c00000, 0x000a, 0x79},	// 52
+	{0x49, 0xa3800000, 0x000a, 0x4d},	// 52
+	{0x49, 0xea000000, 0x000a, 0x67},	// 52
+	{0x49, 0xea400000, 0x000a, 0x44},	// 52
+	{0x49, 0x8d800000, 0x000b, 0x65},	// 52
+	{0x49, 0x8da00000, 0x000b, 0x35},	// 52
+	{0x49, 0xa2800000, 0x000b, 0x53},	// 52
+	{0x49, 0xa2a00000, 0x000b, 0x39},	// 52
+	{0x49, 0xa3e00000, 0x000b, 0x46},	// 52
+	{0x49, 0xb8800000, 0x000b, 0x62},	// 52
+	{0x49, 0xb8c00000, 0x000b, 0x2d},	// 52
+	{0x49, 0xb8e00000, 0x000b, 0x4c},	// 52
+	{0x49, 0xa3c00000, 0x000c, 0x42},	// 52
+	{0x49, 0xa3d00000, 0x000c, 0x29},	// 52
+	{0x49, 0xb8a00000, 0x000d, 0x4e},	// 52
+	{0x49, 0xb8a80000, 0x000d, 0x51},	// 52
+	{0x49, 0xb8b00000, 0x000d, 0x6b},	// 52
+	{0x49, 0xb8bc0000, 0x000e, 0x4f},	// 52
+	{0x49, 0xb8ba0000, 0x000f, 0x3f},	// 52
+	{0x49, 0xb8b80000, 0x0010, 0x01},	// 52
+	{0x49, 0xb8b90000, 0x0010, 0x68},	// 52
+	{0x4a, 0x00000000, 0x0002, 0x65},	// 29
+	{0x4a, 0x80000000, 0x0002, 0x61},	// 29
+	{0x4a, 0xc0000000, 0x0002, 0x6f},	// 29
+	{0x4a, 0x60000000, 0x0003, 0x75},	// 29
+	{0x4a, 0x50000000, 0x0004, 0x69},	// 29
+	{0x4a, 0x40000000, 0x0005, 0x20},	// 29
+	{0x4a, 0x4c000000, 0x0007, 0x44},	// 29
+	{0x4a, 0x4e000000, 0x0007, 0x2e},	// 29
+	{0x4a, 0x49000000, 0x0008, 0x72},	// 29
+	{0x4a, 0x4b000000, 0x0009, 0x73},	// 29
+	{0x4a, 0x48000000, 0x000a, 0x4d},	// 29
+	{0x4a, 0x48800000, 0x000a, 0x4a},	// 29
+	{0x4a, 0x48c00000, 0x000a, 0x2c},	// 29
+	{0x4a, 0x4a000000, 0x000a, 0x42},	// 29
+	{0x4a, 0x4a400000, 0x000a, 0x2d},	// 29
+	{0x4a, 0x4a800000, 0x000a, 0x56},	// 29
+	{0x4a, 0x4b800000, 0x000a, 0x4b},	// 29
+	{0x4a, 0x4bc00000, 0x000a, 0x54},	// 29
+	{0x4a, 0x48400000, 0x000b, 0x43},	// 29
+	{0x4a, 0x4ac00000, 0x000b, 0x6e},	// 29
+	{0x4a, 0x48600000, 0x000c, 0x21},	// 29
+	{0x4a, 0x48700000, 0x000d, 0x77},	// 29
+	{0x4a, 0x48780000, 0x000d, 0x52},	// 29
+	{0x4a, 0x4ae00000, 0x000d, 0x46},	// 29
+	{0x4a, 0x4af00000, 0x000d, 0x37},	// 29
+	{0x4a, 0x4af80000, 0x000d, 0x27},	// 29
+	{0x4a, 0x4ae80000, 0x000e, 0x47},	// 29
+	{0x4a, 0x4aec0000, 0x000f, 0x01},	// 29
+	{0x4a, 0x4aee0000, 0x000f, 0x4c},	// 29
+	{0x4b, 0x00000000, 0x0002, 0x69},	// 40
+	{0x4b, 0x40000000, 0x0002, 0x61},	// 40
+	{0x4b, 0x80000000, 0x0002, 0x65},	// 40
+	{0x4b, 0xf0000000, 0x0004, 0x79},	// 40
+	{0x4b, 0xc0000000, 0x0005, 0x6e},	// 40
+	{0x4b, 0xc8000000, 0x0005, 0x6f},	// 40
+	{0x4b, 0xd8000000, 0x0005, 0x72},	// 40
+	{0x4b, 0xe8000000, 0x0005, 0x20},	// 40
+	{0x4b, 0xd0000000, 0x0006, 0x27},	// 40
+	{0x4b, 0xe0000000, 0x0006, 0x75},	// 40
+	{0x4b, 0xd6000000, 0x0007, 0x2e},	// 40
+	{0x4b, 0xe6000000, 0x0007, 0x6c},	// 40
+	{0x4b, 0xe5000000, 0x0008, 0x68},	// 40
+	{0x4b, 0xd4000000, 0x0009, 0x54},	// 40
+	{0x4b, 0xd5800000, 0x0009, 0x47},	// 40
+	{0x4b, 0xe4800000, 0x0009, 0x2c},	// 40
+	{0x4b, 0xd5000000, 0x000a, 0x77},	// 40
+	{0x4b, 0xd4800000, 0x000b, 0x35},	// 40
+	{0x4b, 0xd4a00000, 0x000b, 0x34},	// 40
+	{0x4b, 0xd4c00000, 0x000b, 0x41},	// 40
+	{0x4b, 0xd5400000, 0x000b, 0x33},	// 40
+	{0x4b, 0xe4000000, 0x000b, 0x32},	// 40
+	{0x4b, 0xe4600000, 0x000b, 0x4d},	// 40
+	{0x4b, 0xd4e00000, 0x000c, 0x2d},	// 40
+	{0x4b, 0xd5600000, 0x000c, 0x3a},	// 40
+	{0x4b, 0xd5700000, 0x000c, 0x21},	// 40
+	{0x4b, 0xe4200000, 0x000c, 0x29},	// 40
+	{0x4b, 0xe4500000, 0x000c, 0x53},	// 40
+	{0x4b, 0xd4f00000, 0x000d, 0x56},	// 40
+	{0x4b, 0xe4300000, 0x000d, 0x36},	// 40
+	{0x4b, 0xe4380000, 0x000d, 0x31},	// 40
+	{0x4b, 0xd4fc0000, 0x000e, 0x4c},	// 40
+	{0x4b, 0xe4400000, 0x000e, 0x49},	// 40
+	{0x4b, 0xe4440000, 0x000e, 0x3f},	// 40
+	{0x4b, 0xd4f80000, 0x000f, 0x01},	// 40
+	{0x4b, 0xd4fa0000, 0x000f, 0x76},	// 40
+	{0x4b, 0xe4480000, 0x000f, 0x6b},	// 40
+	{0x4b, 0xe44a0000, 0x000f, 0x59},	// 40
+	{0x4b, 0xe44c0000, 0x000f, 0x4e},	// 40
+	{0x4b, 0xe44e0000, 0x000f, 0x45},	// 40
+	{0x4c, 0x00000000, 0x0002, 0x69},	// 36
+	{0x4c, 0x80000000, 0x0002, 0x6f},	// 36
+	{0x4c, 0x60000000, 0x0003, 0x5d},	// 36
+	{0x4c, 0xc0000000, 0x0003, 0x65},	// 36
+	{0x4c, 0xe0000000, 0x0003, 0x61},	// 36
+	{0x4c, 0x40000000, 0x0004, 0x75},	// 36
+	{0x4c, 0x50000000, 0x0006, 0x6c},	// 36
+	{0x4c, 0x54000000, 0x0006, 0x41},	// 36
+	{0x4c, 0x5c000000, 0x0006, 0x79},	// 36
+	{0x4c, 0x5b000000, 0x0008, 0x20},	// 36
+	{0x4c, 0x58000000, 0x0009, 0x49},	// 36
+	{0x4c, 0x58800000, 0x0009, 0x52},	// 36
+	{0x4c, 0x5a800000, 0x0009, 0x2c},	// 36
+	{0x4c, 0x59000000, 0x000a, 0x4f},	// 36
+	{0x4c, 0x59400000, 0x000a, 0x27},	// 36
+	{0x4c, 0x59a00000, 0x000b, 0x2e},	// 36
+	{0x4c, 0x59c00000, 0x000b, 0x43},	// 36
+	{0x4c, 0x59e00000, 0x000b, 0x59},	// 36
+	{0x4c, 0x5a200000, 0x000b, 0x46},	// 36
+	{0x4c, 0x5a400000, 0x000b, 0x4c},	// 36
+	{0x4c, 0x59900000, 0x000c, 0x74},	// 36
+	{0x4c, 0x5a100000, 0x000c, 0x47},	// 36
+	{0x4c, 0x5a700000, 0x000c, 0x53},	// 36
+	{0x4c, 0x59880000, 0x000d, 0x68},	// 36
+	{0x4c, 0x5a080000, 0x000d, 0x57},	// 36
+	{0x4c, 0x5a600000, 0x000d, 0x4a},	// 36
+	{0x4c, 0x59800000, 0x000e, 0x45},	// 36
+	{0x4c, 0x5a040000, 0x000e, 0x22},	// 36
+	{0x4c, 0x5a6c0000, 0x000e, 0x00},	// 36
+	{0x4c, 0x59840000, 0x000f, 0x54},	// 36
+	{0x4c, 0x59860000, 0x000f, 0x50},	// 36
+	{0x4c, 0x5a000000, 0x000f, 0x44},	// 36
+	{0x4c, 0x5a020000, 0x000f, 0x37},	// 36
+	{0x4c, 0x5a6a0000, 0x000f, 0x6a},	// 36
+	{0x4c, 0x5a680000, 0x0010, 0x01},	// 36
+	{0x4c, 0x5a690000, 0x0010, 0x55},	// 36
+	{0x4d, 0x00000000, 0x0002, 0x6f},	// 47
+	{0x4d, 0xc0000000, 0x0002, 0x61},	// 47
+	{0x4d, 0x60000000, 0x0003, 0x65},	// 47
+	{0x4d, 0xa0000000, 0x0003, 0x69},	// 47
+	{0x4d, 0x50000000, 0x0004, 0x63},	// 47
+	{0x4d, 0x90000000, 0x0004, 0x75},	// 47
+	{0x4d, 0x48000000, 0x0005, 0x79},	// 47
+	{0x4d, 0x88000000, 0x0005, 0x72},	// 47
+	{0x4d, 0x80000000, 0x0006, 0x53},	// 47
+	{0x4d, 0x84000000, 0x0006, 0x50},	// 47
+	{0x4d, 0x42000000, 0x0007, 0x20},	// 47
+	{0x4d, 0x41000000, 0x0008, 0x43},	// 47
+	{0x4d, 0x46000000, 0x0008, 0x46},	// 47
+	{0x4d, 0x40000000, 0x0009, 0x31},	// 47
+	{0x4d, 0x44000000, 0x0009, 0x68},	// 47
+	{0x4d, 0x45000000, 0x0009, 0x49},	// 47
+	{0x4d, 0x47000000, 0x0009, 0x54},	// 47
+	{0x4d, 0x47800000, 0x0009, 0x58},	// 47
+	{0x4d, 0x40800000, 0x000a, 0x41},	// 47
+	{0x4d, 0x44800000, 0x000a, 0x7a},	// 47
+	{0x4d, 0x44c00000, 0x000b, 0x66},	// 47
+	{0x4d, 0x45c00000, 0x000b, 0x2e},	// 47
+	{0x4d, 0x40c00000, 0x000c, 0x5a},	// 47
+	{0x4d, 0x40d00000, 0x000c, 0x4b},	// 47
+	{0x4d, 0x40e00000, 0x000c, 0x42},	// 47
+	{0x4d, 0x44f00000, 0x000c, 0x73},	// 47
+	{0x4d, 0x45800000, 0x000c, 0x52},	// 47
+	{0x4d, 0x45900000, 0x000c, 0x57},	// 47
+	{0x4d, 0x45a00000, 0x000c, 0x4f},	// 47
+	{0x4d, 0x40f00000, 0x000d, 0x2c},	// 47
+	{0x4d, 0x40f80000, 0x000d, 0x27},	// 47
+	{0x4d, 0x45b80000, 0x000d, 0x44},	// 47
+	{0x4d, 0x45e00000, 0x000d, 0x34},	// 47
+	{0x4d, 0x45f00000, 0x000d, 0x45},	// 47
+	{0x4d, 0x44e00000, 0x000e, 0x6d},	// 47
+	{0x4d, 0x44e40000, 0x000e, 0x4a},	// 47
+	{0x4d, 0x44e80000, 0x000e, 0x01},	// 47
+	{0x4d, 0x45e80000, 0x000e, 0x6c},	// 47
+	{0x4d, 0x45ec0000, 0x000e, 0x2d},	// 47
+	{0x4d, 0x45f80000, 0x000e, 0x29},	// 47
+	{0x4d, 0x45fc0000, 0x000e, 0x77},	// 47
+	{0x4d, 0x44ec0000, 0x000f, 0x74},	// 47
+	{0x4d, 0x44ee0000, 0x000f, 0x56},	// 47
+	{0x4d, 0x45b00000, 0x000f, 0x51},	// 47
+	{0x4d, 0x45b20000, 0x000f, 0x4e},	// 47
+	{0x4d, 0x45b40000, 0x000f, 0x36},	// 47
+	{0x4d, 0x45b60000, 0x000f, 0x32},	// 47
+	{0x4e, 0x00000000, 0x0002, 0x61},	// 35
+	{0x4e, 0x80000000, 0x0002, 0x6f},	// 35
+	{0x4e, 0xc0000000, 0x0002, 0x65},	// 35
+	{0x4e, 0x60000000, 0x0003, 0x69},	// 35
+	{0x4e, 0x50000000, 0x0005, 0x75},	// 35
+	{0x4e, 0x58000000, 0x0005, 0x45},	// 35
+	{0x4e, 0x48000000, 0x0006, 0x41},	// 35
+	{0x4e, 0x44000000, 0x0007, 0x79},	// 35
+	{0x4e, 0x4c000000, 0x0007, 0x67},	// 35
+	{0x4e, 0x41000000, 0x0008, 0x42},	// 35
+	{0x4e, 0x42000000, 0x0008, 0x49},	// 35
+	{0x4e, 0x46000000, 0x0008, 0x46},	// 35
+	{0x4e, 0x47000000, 0x0008, 0x20},	// 35
+	{0x4e, 0x40000000, 0x0009, 0x29},	// 35
+	{0x4e, 0x40800000, 0x0009, 0x27},	// 35
+	{0x4e, 0x43800000, 0x0009, 0x59},	// 35
+	{0x4e, 0x4e000000, 0x0009, 0x4c},	// 35
+	{0x4e, 0x4e800000, 0x0009, 0x48},	// 35
+	{0x4e, 0x43000000, 0x000a, 0x43},	// 35
+	{0x4e, 0x4f000000, 0x000a, 0x57},	// 35
+	{0x4e, 0x4f800000, 0x000a, 0x4e},	// 35
+	{0x4e, 0x4fc00000, 0x000a, 0x54},	// 35
+	{0x4e, 0x43500000, 0x000c, 0x4d},	// 35
+	{0x4e, 0x43700000, 0x000c, 0x4f},	// 35
+	{0x4e, 0x4f400000, 0x000c, 0x2c},	// 35
+	{0x4e, 0x4f500000, 0x000c, 0x4a},	// 35
+	{0x4e, 0x4f700000, 0x000c, 0x68},	// 35
+	{0x4e, 0x43400000, 0x000d, 0x44},	// 35
+	{0x4e, 0x43480000, 0x000d, 0x2e},	// 35
+	{0x4e, 0x4f600000, 0x000d, 0x58},	// 35
+	{0x4e, 0x4f680000, 0x000d, 0x01},	// 35
+	{0x4e, 0x43600000, 0x000e, 0x6b},	// 35
+	{0x4e, 0x43640000, 0x000e, 0x5a},	// 35
+	{0x4e, 0x43680000, 0x000e, 0x51},	// 35
+	{0x4e, 0x436c0000, 0x000e, 0x47},	// 35
+	{0x4f, 0xe0000000, 0x0003, 0x6e},	// 59
+	{0x4f, 0x00000000, 0x0004, 0x73},	// 59
+	{0x4f, 0x10000000, 0x0004, 0x4e},	// 59
+	{0x4f, 0x30000000, 0x0004, 0x7a},	// 59
+	{0x4f, 0x40000000, 0x0004, 0x72},	// 59
+	{0x4f, 0x80000000, 0x0004, 0x75},	// 59
+	{0x4f, 0xa0000000, 0x0004, 0x70},	// 59
+	{0x4f, 0xb0000000, 0x0004, 0x6c},	// 59
+	{0x4f, 0xd0000000, 0x0004, 0x27},	// 59
+	{0x4f, 0x28000000, 0x0005, 0x55},	// 59
+	{0x4f, 0x58000000, 0x0005, 0x68},	// 59
+	{0x4f, 0x70000000, 0x0005, 0x66},	// 59
+	{0x4f, 0x78000000, 0x0005, 0x77},	// 59
+	{0x4f, 0x90000000, 0x0005, 0x2e},	// 59
+	{0x4f, 0xc0000000, 0x0005, 0x20},	// 59
+	{0x4f, 0x20000000, 0x0006, 0x6f},	// 59
+	{0x4f, 0x24000000, 0x0006, 0x4a},	// 59
+	{0x4f, 0x50000000, 0x0006, 0x62},	// 59
+	{0x4f, 0x54000000, 0x0006, 0x6d},	// 59
+	{0x4f, 0x64000000, 0x0006, 0x48},	// 59
+	{0x4f, 0x68000000, 0x0006, 0x4f},	// 59
+	{0x4f, 0x6c000000, 0x0006, 0x76},	// 59
+	{0x4f, 0x9c000000, 0x0006, 0x63},	// 59
+	{0x4f, 0xcc000000, 0x0006, 0x78},	// 59
+	{0x4f, 0x9a000000, 0x0007, 0x64},	// 59
+	{0x4f, 0xc8000000, 0x0007, 0x61},	// 59
+	{0x4f, 0x61000000, 0x0008, 0x74},	// 59
+	{0x4f, 0x62000000, 0x0008, 0x6b},	// 59
+	{0x4f, 0x98000000, 0x0008, 0x67},	// 59
+	{0x4f, 0xca000000, 0x0008, 0x52},	// 59
+	{0x4f, 0x60000000, 0x0009, 0x4b},	// 59
+	{0x4f, 0x99000000, 0x0009, 0x69},	// 59
+	{0x4f, 0xcb800000, 0x0009, 0x56},	// 59
+	{0x4f, 0x60c00000, 0x000a, 0x32},	// 59
+	{0x4f, 0x63400000, 0x000a, 0x53},	// 59
+	{0x4f, 0x63800000, 0x000a, 0x42},	// 59
+	{0x4f, 0x99800000, 0x000a, 0x57},	// 59
+	{0x4f, 0x99c00000, 0x000a, 0x2d},	// 59
+	{0x4f, 0x60800000, 0x000b, 0x2c},	// 59
+	{0x4f, 0x63000000, 0x000b, 0x6a},	// 59
+	{0x4f, 0x63200000, 0x000b, 0x4c},	// 59
+	{0x4f, 0x63e00000, 0x000b, 0x49},	// 59
+	{0x4f, 0xcb200000, 0x000b, 0x41},	// 59
+	{0x4f, 0xcb600000, 0x000b, 0x43},	// 59
+	{0x4f, 0x60a00000, 0x000c, 0x3a},	// 59
+	{0x4f, 0x63c00000, 0x000c, 0x65},	// 59
+	{0x4f, 0xcb000000, 0x000c, 0x79},	// 59
+	{0x4f, 0xcb100000, 0x000c, 0x2f},	// 59
+	{0x4f, 0xcb400000, 0x000c, 0x4d},	// 59
+	{0x4f, 0x60b00000, 0x000d, 0x21},	// 59
+	{0x4f, 0x63d80000, 0x000d, 0x50},	// 59
+	{0x4f, 0xcb580000, 0x000d, 0x46},	// 59
+	{0x4f, 0x60b80000, 0x000e, 0x45},	// 59
+	{0x4f, 0x60bc0000, 0x000e, 0x44},	// 59
+	{0x4f, 0x63d00000, 0x000e, 0x38},	// 59
+	{0x4f, 0x63d40000, 0x000e, 0x34},	// 59
+	{0x4f, 0xcb540000, 0x000e, 0x54},	// 59
+	{0x4f, 0xcb500000, 0x000f, 0x01},	// 59
+	{0x4f, 0xcb520000, 0x000f, 0x71},	// 59
+	{0x50, 0xc0000000, 0x0002, 0x61},	// 39
+	{0x50, 0x00000000, 0x0003, 0x69},	// 39
+	{0x50, 0x40000000, 0x0003, 0x65},	// 39
+	{0x50, 0x60000000, 0x0003, 0x6c},	// 39
+	{0x50, 0x80000000, 0x0003, 0x6f},	// 39
+	{0x50, 0xa0000000, 0x0003, 0x72},	// 39
+	{0x50, 0x20000000, 0x0004, 0x68},	// 39
+	{0x50, 0x3c000000, 0x0006, 0x75},	// 39
+	{0x50, 0x34000000, 0x0007, 0x43},	// 39
+	{0x50, 0x38000000, 0x0007, 0x2e},	// 39
+	{0x50, 0x3a000000, 0x0007, 0x20},	// 39
+	{0x50, 0x30000000, 0x0008, 0x42},	// 39
+	{0x50, 0x32000000, 0x0008, 0x44},	// 39
+	{0x50, 0x37000000, 0x0008, 0x73},	// 39
+	{0x50, 0x31800000, 0x0009, 0x4f},	// 39
+	{0x50, 0x33800000, 0x0009, 0x2c},	// 39
+	{0x50, 0x31400000, 0x000a, 0x79},	// 39
+	{0x50, 0x33000000, 0x000a, 0x4d},	// 39
+	{0x50, 0x36000000, 0x000a, 0x45},	// 39
+	{0x50, 0x36400000, 0x000a, 0x27},	// 39
+	{0x50, 0x36c00000, 0x000a, 0x33},	// 39
+	{0x50, 0x31200000, 0x000b, 0x54},	// 39
+	{0x50, 0x31000000, 0x000c, 0x4c},	// 39
+	{0x50, 0x31100000, 0x000c, 0x47},	// 39
+	{0x50, 0x33400000, 0x000c, 0x2a},	// 39
+	{0x50, 0x33600000, 0x000c, 0x41},	// 39
+	{0x50, 0x33700000, 0x000c, 0x53},	// 39
+	{0x50, 0x36800000, 0x000c, 0x77},	// 39
+	{0x50, 0x36900000, 0x000c, 0x46},	// 39
+	{0x50, 0x33580000, 0x000d, 0x4a},	// 39
+	{0x50, 0x36a00000, 0x000d, 0x66},	// 39
+	{0x50, 0x36a80000, 0x000d, 0x52},	// 39
+	{0x50, 0x36b80000, 0x000d, 0x74},	// 39
+	{0x50, 0x33500000, 0x000e, 0x56},	// 39
+	{0x50, 0x36b00000, 0x000e, 0x59},	// 39
+	{0x50, 0x36b40000, 0x000e, 0x49},	// 39
+	{0x50, 0x33560000, 0x000f, 0x26},	// 39
+	{0x50, 0x33540000, 0x0010, 0x01},	// 39
+	{0x50, 0x33550000, 0x0010, 0x29},	// 39
+	{0x51, 0x80000000, 0x0001, 0x75},	// 13
+	{0x51, 0x00000000, 0x0002, 0x56},	// 13
+	{0x51, 0x60000000, 0x0003, 0x20},	// 13
+	{0x51, 0x50000000, 0x0004, 0x2e},	// 13
+	{0x51, 0x40000000, 0x0005, 0x61},	// 13
+	{0x51, 0x48000000, 0x0007, 0x77},	// 13
+	{0x51, 0x4c000000, 0x0007, 0x45},	// 13
+	{0x51, 0x4e000000, 0x0007, 0x43},	// 13
+	{0x51, 0x4b000000, 0x0008, 0x26},	// 13
+	{0x51, 0x4a800000, 0x0009, 0x27},	// 13
+	{0x51, 0x4a000000, 0x000a, 0x54},	// 13
+	{0x51, 0x4a400000, 0x000b, 0x01},	// 13
+	{0x51, 0x4a600000, 0x000b, 0x73},	// 13
+	{0x52, 0x40000000, 0x0002, 0x61},	// 37
+	{0x52, 0xc0000000, 0x0002, 0x6f},	// 37
+	{0x52, 0x80000000, 0x0003, 0x69},	// 37
+	{0x52, 0xa0000000, 0x0003, 0x65},	// 37
+	{0x52, 0x00000000, 0x0004, 0x70},	// 37
+	{0x52, 0x30000000, 0x0004, 0x75},	// 37
+	{0x52, 0x18000000, 0x0005, 0x45},	// 37
+	{0x52, 0x20000000, 0x0005, 0x68},	// 37
+	{0x52, 0x10000000, 0x0006, 0x20},	// 37
+	{0x52, 0x28000000, 0x0006, 0x79},	// 37
+	{0x52, 0x14000000, 0x0008, 0x44},	// 37
+	{0x52, 0x16000000, 0x0008, 0x2e},	// 37
+	{0x52, 0x2c000000, 0x0008, 0x54},	// 37
+	{0x52, 0x2e000000, 0x0008, 0x53},	// 37
+	{0x52, 0x15000000, 0x0009, 0x46},	// 37
+	{0x52, 0x2d000000, 0x0009, 0x42},	// 37
+	{0x52, 0x2d800000, 0x0009, 0x6e},	// 37
+	{0x52, 0x2f800000, 0x0009, 0x41},	// 37
+	{0x52, 0x15800000, 0x000a, 0x77},	// 37
+	{0x52, 0x17000000, 0x000a, 0x4e},	// 37
+	{0x52, 0x17400000, 0x000a, 0x26},	// 37
+	{0x52, 0x17800000, 0x000a, 0x56},	// 37
+	{0x52, 0x17c00000, 0x000a, 0x48},	// 37
+	{0x52, 0x2f400000, 0x000a, 0x27},	// 37
+	{0x52, 0x15c00000, 0x000b, 0x74},	// 37
+	{0x52, 0x15e00000, 0x000b, 0x49},	// 37
+	{0x52, 0x2f000000, 0x000c, 0x43},	// 37
+	{0x52, 0x2f200000, 0x000c, 0x4f},	// 37
+	{0x52, 0x2f100000, 0x000e, 0x2c},	// 37
+	{0x52, 0x2f140000, 0x000e, 0x73},	// 37
+	{0x52, 0x2f180000, 0x000e, 0x55},	// 37
+	{0x52, 0x2f1c0000, 0x000e, 0x4d},	// 37
+	{0x52, 0x2f300000, 0x000e, 0x2d},	// 37
+	{0x52, 0x2f340000, 0x000e, 0x01},	// 37
+	{0x52, 0x2f3c0000, 0x000e, 0x3a},	// 37
+	{0x52, 0x2f380000, 0x000f, 0x32},	// 37
+	{0x52, 0x2f3a0000, 0x000f, 0x52},	// 37
+	{0x53, 0x80000000, 0x0001, 0x5d},	// 59
+	{0x53, 0x00000000, 0x0004, 0x61},	// 59
+	{0x53, 0x20000000, 0x0004, 0x68},	// 59
+	{0x53, 0x70000000, 0x0004, 0x74},	// 59
+	{0x53, 0x10000000, 0x0005, 0x70},	// 59
+	{0x53, 0x18000000, 0x0005, 0x2c},	// 59
+	{0x53, 0x30000000, 0x0005, 0x4c},	// 59
+	{0x53, 0x40000000, 0x0005, 0x69},	// 59
+	{0x53, 0x48000000, 0x0005, 0x75},	// 59
+	{0x53, 0x50000000, 0x0005, 0x6f},	// 59
+	{0x53, 0x58000000, 0x0005, 0x63},	// 59
+	{0x53, 0x60000000, 0x0005, 0x65},	// 59
+	{0x53, 0x3c000000, 0x0006, 0x6b},	// 59
+	{0x53, 0x38000000, 0x0007, 0x77},	// 59
+	{0x53, 0x6a000000, 0x0007, 0x20},	// 59
+	{0x53, 0x6e000000, 0x0007, 0x6d},	// 59
+	{0x53, 0x3a000000, 0x0008, 0x71},	// 59
+	{0x53, 0x68000000, 0x0008, 0x4d},	// 59
+	{0x53, 0x69000000, 0x0008, 0x6e},	// 59
+	{0x53, 0x6c000000, 0x0008, 0x6c},	// 59
+	{0x53, 0x3b000000, 0x0009, 0x50},	// 59
+	{0x53, 0x6d800000, 0x0009, 0x79},	// 59
+	{0x53, 0x3b800000, 0x000a, 0x41},	// 59
+	{0x53, 0x6d200000, 0x000b, 0x2e},	// 59
+	{0x53, 0x3bd00000, 0x000c, 0x72},	// 59
+	{0x53, 0x3be00000, 0x000c, 0x53},	// 59
+	{0x53, 0x3bf00000, 0x000c, 0x57},	// 59
+	{0x53, 0x6d000000, 0x000c, 0x43},	// 59
+	{0x53, 0x6d500000, 0x000c, 0x45},	// 59
+	{0x53, 0x6d600000, 0x000c, 0x76},	// 59
+	{0x53, 0x6d180000, 0x000d, 0x01},	// 59
+	{0x53, 0x6d400000, 0x000d, 0x49},	// 59
+	{0x53, 0x6d780000, 0x000d, 0x67},	// 59
+	{0x53, 0x3bc00000, 0x000e, 0x2a},	// 59
+	{0x53, 0x3bc80000, 0x000e, 0x34},	// 59
+	{0x53, 0x3bcc0000, 0x000e, 0x31},	// 59
+	{0x53, 0x6d100000, 0x000e, 0x4f},	// 59
+	{0x53, 0x6d480000, 0x000e, 0x00},	// 59
+	{0x53, 0x6d700000, 0x000e, 0x7a},	// 59
+	{0x53, 0x6d160000, 0x000f, 0x42},	// 59
+	{0x53, 0x6d740000, 0x000f, 0x48},	// 59
+	{0x53, 0x6d760000, 0x000f, 0x54},	// 59
+	{0x53, 0x3bc40000, 0x0010, 0x47},	// 59
+	{0x53, 0x3bc60000, 0x0010, 0x7d},	// 59
+	{0x53, 0x3bc70000, 0x0010, 0x44},	// 59
+	{0x53, 0x6d140000, 0x0010, 0x2d},	// 59
+	{0x53, 0x6d4c0000, 0x0010, 0x33},	// 59
+	{0x53, 0x6d4d0000, 0x0010, 0x32},	// 59
+	{0x53, 0x3bc50000, 0x0011, 0x27},	// 59
+	{0x53, 0x3bc58000, 0x0011, 0x3f},	// 59
+	{0x53, 0x6d4e8000, 0x0011, 0x73},	// 59
+	{0x53, 0x6d4f0000, 0x0011, 0x6a},	// 59
+	{0x53, 0x6d4f8000, 0x0011, 0x62},	// 59
+	{0x53, 0x6d150000, 0x0012, 0x52},	// 59
+	{0x53, 0x6d154000, 0x0012, 0x4b},	// 59
+	{0x53, 0x6d158000, 0x0012, 0x4a},	// 59
+	{0x53, 0x6d15c000, 0x0012, 0x46},	// 59
+	{0x53, 0x6d4e0000, 0x0012, 0x3a},	// 59
+	{0x53, 0x6d4e4000, 0x0012, 0x29},	// 59
+	{0x54, 0x00000000, 0x0001, 0x68},	// 44
+	{0x54, 0x80000000, 0x0003, 0x6f},	// 44
+	{0x54, 0xa0000000, 0x0004, 0x56},	// 44
+	{0x54, 0xb0000000, 0x0004, 0x77},	// 44
+	{0x54, 0xc0000000, 0x0004, 0x72},	// 44
+	{0x54, 0xf0000000, 0x0004, 0x65},	// 44
+	{0x54, 0xd0000000, 0x0005, 0x61},	// 44
+	{0x54, 0xd8000000, 0x0005, 0x69},	// 44
+	{0x54, 0xe0000000, 0x0005, 0x75},	// 44
+	{0x54, 0xe8000000, 0x0007, 0x48},	// 44
+	{0x54, 0xec000000, 0x0007, 0x57},	// 44
+	{0x54, 0xea000000, 0x0008, 0x20},	// 44
+	{0x54, 0xeb000000, 0x0008, 0x79},	// 44
+	{0x54, 0xee800000, 0x0009, 0x4d},	// 44
+	{0x54, 0xef800000, 0x0009, 0x78},	// 44
+	{0x54, 0xee000000, 0x000a, 0x53},	// 44
+	{0x54, 0xee400000, 0x000b, 0x41},	// 44
+	{0x54, 0xef200000, 0x000b, 0x73},	// 44
+	{0x54, 0xef600000, 0x000b, 0x4a},	// 44
+	{0x54, 0xee700000, 0x000c, 0x58},	// 44
+	{0x54, 0xef000000, 0x000c, 0x2e},	// 44
+	{0x54, 0xee680000, 0x000d, 0x2d},	// 44
+	{0x54, 0xef180000, 0x000d, 0x4c},	// 44
+	{0x54, 0xef400000, 0x000d, 0x43},	// 44
+	{0x54, 0xef580000, 0x000d, 0x63},	// 44
+	{0x54, 0xee600000, 0x000e, 0x54},	// 44
+	{0x54, 0xee640000, 0x000e, 0x55},	// 44
+	{0x54, 0xef140000, 0x000e, 0x34},	// 44
+	{0x54, 0xef480000, 0x000e, 0x4f},	// 44
+	{0x54, 0xef120000, 0x000f, 0x47},	// 44
+	{0x54, 0xef4c0000, 0x000f, 0x45},	// 44
+	{0x54, 0xef4e0000, 0x000f, 0x2c},	// 44
+	{0x54, 0xef540000, 0x000f, 0x27},	// 44
+	{0x54, 0xef110000, 0x0010, 0x3b},	// 44
+	{0x54, 0xef500000, 0x0010, 0x50},	// 44
+	{0x54, 0xef510000, 0x0010, 0x31},	// 44
+	{0x54, 0xef520000, 0x0010, 0x01},	// 44
+	{0x54, 0xef570000, 0x0010, 0x44},	// 44
+	{0x54, 0xef100000, 0x0011, 0x3a},	// 44
+	{0x54, 0xef108000, 0x0011, 0x2a},	// 44
+	{0x54, 0xef530000, 0x0011, 0x52},	// 44
+	{0x54, 0xef538000, 0x0011, 0x4e},	// 44
+	{0x54, 0xef560000, 0x0011, 0x49},	// 44
+	{0x54, 0xef568000, 0x0011, 0x42},	// 44
+	{0x55, 0x00000000, 0x0002, 0x4b},	// 45
+	{0x55, 0x80000000, 0x0002, 0x6e},	// 45
+	{0x55, 0x60000000, 0x0003, 0x53},	// 45
+	{0x55, 0xc0000000, 0x0003, 0x70},	// 45
+	{0x55, 0xf0000000, 0x0004, 0x6c},	// 45
+	{0x55, 0x50000000, 0x0005, 0x73},	// 45
+	{0x55, 0x58000000, 0x0005, 0x72},	// 45
+	{0x55, 0xe8000000, 0x0005, 0x52},	// 45
+	{0x55, 0x40000000, 0x0006, 0x67},	// 45
+	{0x55, 0xe0000000, 0x0006, 0x20},	// 45
+	{0x55, 0x4e000000, 0x0007, 0x2e},	// 45
+	{0x55, 0xe4000000, 0x0007, 0x6d},	// 45
+	{0x55, 0x44000000, 0x0008, 0x6b},	// 45
+	{0x55, 0x45000000, 0x0008, 0x74},	// 45
+	{0x55, 0x46000000, 0x0008, 0x45},	// 45
+	{0x55, 0x47000000, 0x0008, 0x2d},	// 45
+	{0x55, 0x48000000, 0x0008, 0x46},	// 45
+	{0x55, 0x4c000000, 0x0008, 0x32},	// 45
+	{0x55, 0xe6000000, 0x0008, 0x63},	// 45
+	{0x55, 0xe7000000, 0x0008, 0x4e},	// 45
+	{0x55, 0x49000000, 0x0009, 0x66},	// 45
+	{0x55, 0x49800000, 0x0009, 0x38},	// 45
+	{0x55, 0x4a000000, 0x0009, 0x2c},	// 45
+	{0x55, 0x4b800000, 0x0009, 0x5a},	// 45
+	{0x55, 0x4a800000, 0x000a, 0x68},	// 45
+	{0x55, 0x4d000000, 0x000a, 0x69},	// 45
+	{0x55, 0x4d400000, 0x000a, 0x77},	// 45
+	{0x55, 0x4d800000, 0x000a, 0x61},	// 45
+	{0x55, 0x4ac00000, 0x000b, 0x62},	// 45
+	{0x55, 0x4ae00000, 0x000b, 0x44},	// 45
+	{0x55, 0x4dc00000, 0x000b, 0x21},	// 45
+	{0x55, 0x4b000000, 0x000c, 0x65},	// 45
+	{0x55, 0x4b100000, 0x000c, 0x56},	// 45
+	{0x55, 0x4b200000, 0x000c, 0x50},	// 45
+	{0x55, 0x4b300000, 0x000c, 0x49},	// 45
+	{0x55, 0x4b400000, 0x000c, 0x42},	// 45
+	{0x55, 0x4b500000, 0x000c, 0x41},	// 45
+	{0x55, 0x4df00000, 0x000c, 0x64},	// 45
+	{0x55, 0x4b600000, 0x000d, 0x48},	// 45
+	{0x55, 0x4b680000, 0x000d, 0x43},	// 45
+	{0x55, 0x4b700000, 0x000d, 0x3a},	// 45
+	{0x55, 0x4b780000, 0x000d, 0x29},	// 45
+	{0x55, 0x4de80000, 0x000d, 0x7a},	// 45
+	{0x55, 0x4de00000, 0x000e, 0x01},	// 45
+	{0x55, 0x4de40000, 0x000e, 0x54},	// 45
+	{0x56, 0x40000000, 0x0002, 0x20},	// 38
+	{0x56, 0xc0000000, 0x0002, 0x69},	// 38
+	{0x56, 0x00000000, 0x0003, 0x2e},	// 38
+	{0x56, 0x20000000, 0x0003, 0x61},	// 38
+	{0x56, 0xa0000000, 0x0003, 0x65},	// 38
+	{0x56, 0x88000000, 0x0005, 0x43},	// 38
+	{0x56, 0x98000000, 0x0005, 0x6f},	// 38
+	{0x56, 0x82000000, 0x0007, 0x46},	// 38
+	{0x56, 0x86000000, 0x0007, 0x49},	// 38
+	{0x56, 0x81000000, 0x0008, 0x31},	// 38
+	{0x56, 0x85000000, 0x0008, 0x34},	// 38
+	{0x56, 0x90000000, 0x0008, 0x72},	// 38
+	{0x56, 0x92000000, 0x0008, 0x45},	// 38
+	{0x56, 0x93000000, 0x0008, 0x73},	// 38
+	{0x56, 0x95000000, 0x0008, 0x27},	// 38
+	{0x56, 0x96000000, 0x0008, 0x3a},	// 38
+	{0x56, 0x97000000, 0x0008, 0x6c},	// 38
+	{0x56, 0x80800000, 0x0009, 0x2f},	// 38
+	{0x56, 0x84800000, 0x0009, 0x2d},	// 38
+	{0x56, 0x91000000, 0x0009, 0x44},	// 38
+	{0x56, 0x91800000, 0x0009, 0x75},	// 38
+	{0x56, 0x94800000, 0x0009, 0x2c},	// 38
+	{0x56, 0x80000000, 0x000a, 0x36},	// 38
+	{0x56, 0x80400000, 0x000a, 0x32},	// 38
+	{0x56, 0x84000000, 0x000a, 0x35},	// 38
+	{0x56, 0x94000000, 0x000a, 0x3b},	// 38
+	{0x56, 0x94400000, 0x000b, 0x01},	// 38
+	{0x56, 0x84400000, 0x000c, 0x37},	// 38
+	{0x56, 0x94600000, 0x000c, 0x33},	// 38
+	{0x56, 0x84500000, 0x000d, 0x39},	// 38
+	{0x56, 0x84580000, 0x000d, 0x79},	// 38
+	{0x56, 0x84600000, 0x000d, 0x50},	// 38
+	{0x56, 0x84680000, 0x000d, 0x48},	// 38
+	{0x56, 0x84700000, 0x000d, 0x41},	// 38
+	{0x56, 0x84780000, 0x000d, 0x38},	// 38
+	{0x56, 0x94780000, 0x000d, 0x57},	// 38
+	{0x56, 0x94700000, 0x000e, 0x66},	// 38
+	{0x56, 0x94740000, 0x000e, 0x42},	// 38
+	{0x57, 0x00000000, 0x0002, 0x68},	// 30
+	{0x57, 0x80000000, 0x0002, 0x69},	// 30
+	{0x57, 0x60000000, 0x0003, 0x61},	// 30
+	{0x57, 0xc0000000, 0x0003, 0x6f},	// 30
+	{0x57, 0xe0000000, 0x0003, 0x65},	// 30
+	{0x57, 0x40000000, 0x0004, 0x72},	// 30
+	{0x57, 0x58000000, 0x0005, 0x4f},	// 30
+	{0x57, 0x52000000, 0x0007, 0x20},	// 30
+	{0x57, 0x54000000, 0x0007, 0x79},	// 30
+	{0x57, 0x50000000, 0x0009, 0x42},	// 30
+	{0x57, 0x50800000, 0x0009, 0x2e},	// 30
+	{0x57, 0x56000000, 0x0009, 0x49},	// 30
+	{0x57, 0x57000000, 0x0009, 0x57},	// 30
+	{0x57, 0x57800000, 0x0009, 0x41},	// 30
+	{0x57, 0x51000000, 0x000a, 0x27},	// 30
+	{0x57, 0x51400000, 0x000a, 0x4d},	// 30
+	{0x57, 0x51c00000, 0x000a, 0x54},	// 30
+	{0x57, 0x51800000, 0x000b, 0x32},	// 30
+	{0x57, 0x51a00000, 0x000b, 0x3a},	// 30
+	{0x57, 0x56800000, 0x000b, 0x48},	// 30
+	{0x57, 0x56c00000, 0x000b, 0x56},	// 30
+	{0x57, 0x56a00000, 0x000c, 0x6c},	// 30
+	{0x57, 0x56e00000, 0x000c, 0x73},	// 30
+	{0x57, 0x56f00000, 0x000c, 0x2c},	// 30
+	{0x57, 0x56b80000, 0x000d, 0x75},	// 30
+	{0x57, 0x56b00000, 0x000f, 0x35},	// 30
+	{0x57, 0x56b20000, 0x000f, 0x29},	// 30
+	{0x57, 0x56b60000, 0x000f, 0x45},	// 30
+	{0x57, 0x56b40000, 0x0010, 0x01},	// 30
+	{0x57, 0x56b50000, 0x0010, 0x6d},	// 30
+	{0x58, 0x80000000, 0x0001, 0x20},	// 24
+	{0x58, 0x00000000, 0x0003, 0x61},	// 24
+	{0x58, 0x20000000, 0x0004, 0x7a},	// 24
+	{0x58, 0x30000000, 0x0004, 0x6d},	// 24
+	{0x58, 0x70000000, 0x0004, 0x74},	// 24
+	{0x58, 0x48000000, 0x0005, 0x55},	// 24
+	{0x58, 0x50000000, 0x0005, 0x2d},	// 24
+	{0x58, 0x58000000, 0x0005, 0x65},	// 24
+	{0x58, 0x60000000, 0x0006, 0x75},	// 24
+	{0x58, 0x64000000, 0x0006, 0x49},	// 24
+	{0x58, 0x6c000000, 0x0006, 0x2c},	// 24
+	{0x58, 0x44000000, 0x0007, 0x56},	// 24
+	{0x58, 0x68000000, 0x0007, 0x35},	// 24
+	{0x58, 0x6a000000, 0x0007, 0x2e},	// 24
+	{0x58, 0x40000000, 0x0008, 0x53},	// 24
+	{0x58, 0x42000000, 0x0008, 0x3a},	// 24
+	{0x58, 0x46000000, 0x0008, 0x63},	// 24
+	{0x58, 0x47000000, 0x0008, 0x69},	// 24
+	{0x58, 0x41000000, 0x0009, 0x39},	// 24
+	{0x58, 0x41800000, 0x0009, 0x27},	// 24
+	{0x58, 0x43800000, 0x0009, 0x58},	// 24
+	{0x58, 0x43000000, 0x000a, 0x29},	// 24
+	{0x58, 0x43400000, 0x000b, 0x01},	// 24
+	{0x58, 0x43600000, 0x000b, 0x79},	// 24
+	{0x59, 0x80000000, 0x0001, 0x6f},	// 24
+	{0x59, 0x00000000, 0x0002, 0x65},	// 24
+	{0x59, 0x40000000, 0x0003, 0x75},	// 24
+	{0x59, 0x60000000, 0x0005, 0x61},	// 24
+	{0x59, 0x70000000, 0x0005, 0x76},	// 24
+	{0x59, 0x78000000, 0x0005, 0x20},	// 24
+	{0x59, 0x68000000, 0x0007, 0x6e},	// 24
+	{0x59, 0x6a000000, 0x0008, 0x72},	// 24
+	{0x59, 0x6d000000, 0x0008, 0x4f},	// 24
+	{0x59, 0x6f000000, 0x0008, 0x69},	// 24
+	{0x59, 0x6b800000, 0x0009, 0x4e},	// 24
+	{0x59, 0x6c000000, 0x0009, 0x4c},	// 24
+	{0x59, 0x6c800000, 0x0009, 0x73},	// 24
+	{0x59, 0x6e800000, 0x0009, 0x6d},	// 24
+	{0x59, 0x6b000000, 0x000a, 0x2e},	// 24
+	{0x59, 0x6b400000, 0x000a, 0x4d},	// 24
+	{0x59, 0x6e400000, 0x000a, 0x50},	// 24
+	{0x59, 0x6e100000, 0x000c, 0x52},	// 24
+	{0x59, 0x6e200000, 0x000c, 0x32},	// 24
+	{0x59, 0x6e000000, 0x000d, 0x2d},	// 24
+	{0x59, 0x6e300000, 0x000d, 0x43},	// 24
+	{0x59, 0x6e380000, 0x000d, 0x2c},	// 24
+	{0x59, 0x6e080000, 0x000e, 0x01},	// 24
+	{0x59, 0x6e0c0000, 0x000e, 0x64},	// 24
+	{0x5a, 0x40000000, 0x0002, 0x61},	// 18
+	{0x5a, 0x80000000, 0x0002, 0x65},	// 18
+	{0x5a, 0xc0000000, 0x0002, 0x6f},	// 18
+	{0x5a, 0x20000000, 0x0004, 0x7a},	// 18
+	{0x5a, 0x30000000, 0x0004, 0x69},	// 18
+	{0x5a, 0x08000000, 0x0005, 0x5a},	// 18
+	{0x5a, 0x10000000, 0x0005, 0x20},	// 18
+	{0x5a, 0x18000000, 0x0005, 0x75},	// 18
+	{0x5a, 0x04000000, 0x0007, 0x4f},	// 18
+	{0x5a, 0x06000000, 0x0007, 0x2e},	// 18
+	{0x5a, 0x00000000, 0x0008, 0x79},	// 18
+	{0x5a, 0x01000000, 0x0008, 0x34},	// 18
+	{0x5a, 0x02000000, 0x0008, 0x2c},	// 18
+	{0x5a, 0x03000000, 0x000a, 0x66},	// 18
+	{0x5a, 0x03400000, 0x000a, 0x2d},	// 18
+	{0x5a, 0x03800000, 0x000a, 0x00},	// 18
+	{0x5a, 0x03c00000, 0x000b, 0x01},	// 18
+	{0x5a, 0x03e00000, 0x000b, 0x6c},	// 18
+	{0x5b, 0x80000000, 0x0001, 0x53},	// 34
+	{0x5b, 0x40000000, 0x0002, 0x41},	// 34
+	{0x5b, 0x00000000, 0x0004, 0x32},	// 34
+	{0x5b, 0x20000000, 0x0004, 0x52},	// 34
+	{0x5b, 0x30000000, 0x0004, 0x31},	// 34
+	{0x5b, 0x14000000, 0x0006, 0x6e},	// 34
+	{0x5b, 0x18000000, 0x0006, 0x6d},	// 34
+	{0x5b, 0x1e000000, 0x0007, 0x6c},	// 34
+	{0x5b, 0x13000000, 0x0008, 0x72},	// 34
+	{0x5b, 0x1d000000, 0x0008, 0x62},	// 34
+	{0x5b, 0x10800000, 0x0009, 0x43},	// 34
+	{0x5b, 0x11000000, 0x0009, 0x66},	// 34
+	{0x5b, 0x12800000, 0x0009, 0x4d},	// 34
+	{0x5b, 0x1c800000, 0x0009, 0x63},	// 34
+	{0x5b, 0x10400000, 0x000a, 0x00},	// 34
+	{0x5b, 0x11c00000, 0x000a, 0x4b},	// 34
+	{0x5b, 0x12000000, 0x000a, 0x48},	// 34
+	{0x5b, 0x1c400000, 0x000a, 0x54},	// 34
+	{0x5b, 0x10000000, 0x000b, 0x4a},	// 34
+	{0x5b, 0x10200000, 0x000b, 0x42},	// 34
+	{0x5b, 0x11a00000, 0x000b, 0x5a},	// 34
+	{0x5b, 0x12600000, 0x000b, 0x50},	// 34
+	{0x5b, 0x1c000000, 0x000b, 0x4c},	// 34
+	{0x5b, 0x11800000, 0x000c, 0x46},	// 34
+	{0x5b, 0x12500000, 0x000c, 0x49},	// 34
+	{0x5b, 0x1c300000, 0x000c, 0x4e},	// 34
+	{0x5b, 0x11900000, 0x000d, 0x73},	// 34
+	{0x5b, 0x11980000, 0x000d, 0x56},	// 34
+	{0x5b, 0x12400000, 0x000d, 0x55},	// 34
+	{0x5b, 0x12480000, 0x000d, 0x47},	// 34
+	{0x5b, 0x1c280000, 0x000d, 0x44},	// 34
+	{0x5b, 0x1c200000, 0x000e, 0x4f},	// 34
+	{0x5b, 0x1c240000, 0x000f, 0x01},	// 34
+	{0x5b, 0x1c260000, 0x000f, 0x57},	// 34
+	{0x5c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5c, 0x80000000, 0x0001, 0x78},	// 2
+	{0x5d, 0x80000000, 0x0001, 0x00},	// 9
+	{0x5d, 0x40000000, 0x0002, 0x20},	// 9
+	{0x5d, 0x20000000, 0x0003, 0x2e},	// 9
+	{0x5d, 0x10000000, 0x0004, 0x5b},	// 9
+	{0x5d, 0x08000000, 0x0005, 0x3a},	// 9
+	{0x5d, 0x04000000, 0x0006, 0x2c},	// 9
+	{0x5d, 0x02000000, 0x0007, 0x3b},	// 9
+	{0x5d, 0x00000000, 0x0008, 0x01},	// 9
+	{0x5d, 0x01000000, 0x0008, 0x5d},	// 9
+	{0x5e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x5f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x5f, 0x80000000, 0x0001, 0x01},	// 2
+	{0x60, 0x20000000, 0x0003, 0x77},	// 31
+	{0x60, 0x60000000, 0x0003, 0x48},	// 31
+	{0x60, 0xc0000000, 0x0003, 0x50},	// 31
+	{0x60, 0xe0000000, 0x0003, 0x46},	// 31
+	{0x60, 0x50000000, 0x0004, 0x6e},	// 31
+	{0x60, 0xb0000000, 0x0004, 0x44},	// 31
+	{0x60, 0x08000000, 0x0005, 0x73},	// 31
+	{0x60, 0x10000000, 0x0005, 0x41},	// 31
+	{0x60, 0x48000000, 0x0005, 0x74},	// 31
+	{0x60, 0x80000000, 0x0005, 0x67},	// 31
+	{0x60, 0x98000000, 0x0005, 0x63},	// 31
+	{0x60, 0x00000000, 0x0006, 0x57},	// 31
+	{0x60, 0x04000000, 0x0006, 0x72},	// 31
+	{0x60, 0x18000000, 0x0006, 0x65},	// 31
+	{0x60, 0x1c000000, 0x0006, 0x43},	// 31
+	{0x60, 0x8c000000, 0x0006, 0x6c},	// 31
+	{0x60, 0x90000000, 0x0006, 0x68},	// 31
+	{0x60, 0x94000000, 0x0006, 0x47},	// 31
+	{0x60, 0xa4000000, 0x0006, 0x42},	// 31
+	{0x60, 0xa8000000, 0x0006, 0x54},	// 31
+	{0x60, 0xac000000, 0x0006, 0x53},	// 31
+	{0x60, 0x40000000, 0x0007, 0x6f},	// 31
+	{0x60, 0x42000000, 0x0007, 0x64},	// 31
+	{0x60, 0x44000000, 0x0007, 0x62},	// 31
+	{0x60, 0x46000000, 0x0007, 0x52},	// 31
+	{0x60, 0x88000000, 0x0007, 0x4f},	// 31
+	{0x60, 0x8a000000, 0x0007, 0x4c},	// 31
+	{0x60, 0xa2000000, 0x0007, 0x66},	// 31
+	{0x60, 0xa0000000, 0x0008, 0x4a},	// 31
+	{0x60, 0xa1000000, 0x0009, 0x01},	// 31
+	{0x60, 0xa1800000, 0x0009, 0x4d},	// 31
+	{0x61, 0x40000000, 0x0002, 0x6e},	// 51
+	{0x61, 0x20000000, 0x0003, 0x72},	// 51
+	{0x61, 0xa0000000, 0x0003, 0x74},	// 51
+	{0x61, 0x00000000, 0x0004, 0x6d},	// 51
+	{0x61, 0x90000000, 0x0004, 0x73},	// 51
+	{0x61, 0xe0000000, 0x0004, 0x20},	// 51
+	{0x61, 0xf0000000, 0x0004, 0x6c},	// 51
+	{0x61, 0x18000000, 0x0005, 0x64},	// 51
+	{0x61, 0x80000000, 0x0005, 0x69},	// 51
+	{0x61, 0xc0000000, 0x0005, 0x79},	// 51
+	{0x61, 0xd0000000, 0x0005, 0x63},	// 51
+	{0x61, 0x10000000, 0x0006, 0x70},	// 51
+	{0x61, 0x88000000, 0x0006, 0x75},	// 51
+	{0x61, 0x8c000000, 0x0006, 0x76},	// 51
+	{0x61, 0xcc000000, 0x0006, 0x67},	// 51
+	{0x61, 0xd8000000, 0x0006, 0x62},	// 51
+	{0x61, 0xdc000000, 0x0006, 0x6b},	// 51
+	{0x61, 0x14000000, 0x0007, 0x77},	// 51
+	{0x61, 0x17000000, 0x0008, 0x7a},	// 51
+	{0x61, 0xc8000000, 0x0008, 0x2e},	// 51
+	{0x61, 0xcb000000, 0x0008, 0x66},	// 51
+	{0x61, 0x16000000, 0x0009, 0x2c},	// 51
+	{0x61, 0x16800000, 0x0009, 0x27},	// 51
+	{0x61, 0xc9800000, 0x0009, 0x65},	// 51
+	{0x61, 0xca800000, 0x0009, 0x68},	// 51
+	{0x61, 0xca400000, 0x000a, 0x78},	// 51
+	{0x61, 0xc9000000, 0x000b, 0x61},	// 51
+	{0x61, 0xc9200000, 0x000b, 0x2d},	// 51
+	{0x61, 0xc9600000, 0x000b, 0x6a},	// 51
+	{0x61, 0xca000000, 0x000b, 0x3a},	// 51
+	{0x61, 0xca200000, 0x000b, 0x6f},	// 51
+	{0x61, 0xc9400000, 0x000c, 0x71},	// 51
+	{0x61, 0xc9500000, 0x000e, 0x21},	// 51
+	{0x61, 0xc95c0000, 0x000e, 0x3f},	// 51
+	{0x61, 0xc9540000, 0x0010, 0x01},	// 51
+	{0x61, 0xc9560000, 0x0010, 0x3b},	// 51
+	{0x61, 0xc9570000, 0x0010, 0x29},	// 51
+	{0x61, 0xc9590000, 0x0010, 0x2f},	// 51
+	{0x61, 0xc95b0000, 0x0010, 0x40},	// 51
+	{0x61, 0xc9550000, 0x0011, 0x4a},	// 51
+	{0x61, 0xc9558000, 0x0011, 0x5d},	// 51
+	{0x61, 0xc95a0000, 0x0011, 0x4e},	// 51
+	{0x61, 0xc95a8000, 0x0011, 0x4c},	// 51
+	{0x61, 0xc9580000, 0x0012, 0x52},	// 51
+	{0x61, 0xc9584000, 0x0012, 0x53},	// 51
+	{0x61, 0xc9588000, 0x0012, 0x56},	// 51
+	{0x61, 0xc958c000, 0x0014, 0x5b},	// 51
+	{0x61, 0xc958e000, 0x0014, 0x50},	// 51
+	{0x61, 0xc958f000, 0x0014, 0x00},	// 51
+	{0x61, 0xc958d000, 0x0015, 0x57},	// 51
+	{0x61, 0xc958d800, 0x0015, 0x31},	// 51
+	{0x62, 0x00000000, 0x0002, 0x65},	// 39
+	{0x62, 0x40000000, 0x0003, 0x75},	// 39
+	{0x62, 0x60000000, 0x0003, 0x61},	// 39
+	{0x62, 0x80000000, 0x0003, 0x79},	// 39
+	{0x62, 0xa0000000, 0x0003, 0x6f},	// 39
+	{0x62, 0xc0000000, 0x0004, 0x6c},	// 39
+	{0x62, 0xe0000000, 0x0004, 0x72},	// 39
+	{0x62, 0xf0000000, 0x0004, 0x69},	// 39
+	{0x62, 0xd0000000, 0x0006, 0x73},	// 39
+	{0x62, 0xd8000000, 0x0006, 0x20},	// 39
+	{0x62, 0xdc000000, 0x0006, 0x62},	// 39
+	{0x62, 0xd5000000, 0x0008, 0x63},	// 39
+	{0x62, 0xd4000000, 0x0009, 0x6a},	// 39
+	{0x62, 0xd6000000, 0x0009, 0x2c},	// 39
+	{0x62, 0xd6800000, 0x0009, 0x2e},	// 39
+	{0x62, 0xd4c00000, 0x000a, 0x27},	// 39
+	{0x62, 0xd7c00000, 0x000a, 0x74},	// 39
+	{0x62, 0xd4a00000, 0x000b, 0x3a},	// 39
+	{0x62, 0xd7000000, 0x000b, 0x77},	// 39
+	{0x62, 0xd7200000, 0x000b, 0x64},	// 39
+	{0x62, 0xd7400000, 0x000b, 0x68},	// 39
+	{0x62, 0xd7600000, 0x000b, 0x26},	// 39
+	{0x62, 0xd7a00000, 0x000b, 0x2d},	// 39
+	{0x62, 0xd7800000, 0x000c, 0x6d},	// 39
+	{0x62, 0xd7900000, 0x000c, 0x6e},	// 39
+	{0x62, 0xd4800000, 0x000d, 0x3f},	// 39
+	{0x62, 0xd4900000, 0x000d, 0x76},	// 39
+	{0x62, 0xd4880000, 0x000e, 0x66},	// 39
+	{0x62, 0xd49c0000, 0x000e, 0x70},	// 39
+	{0x62, 0xd48e0000, 0x000f, 0x3b},	// 39
+	{0x62, 0xd49a0000, 0x000f, 0x44},	// 39
+	{0x62, 0xd48c0000, 0x0010, 0x2f},	// 39
+	{0x62, 0xd4990000, 0x0010, 0x40},	// 39
+	{0x62, 0xd48d0000, 0x0011, 0x58},	// 39
+	{0x62, 0xd48d8000, 0x0011, 0x22},	// 39
+	{0x62, 0xd4988000, 0x0011, 0x6b},	// 39
+	{0x62, 0xd4980000, 0x0012, 0x00},	// 39
+	{0x62, 0xd4984000, 0x0013, 0x01},	// 39
+	{0x62, 0xd4986000, 0x0013, 0x21},	// 39
+	{0x63, 0x00000000, 0x0002, 0x6f},	// 57
+	{0x63, 0x60000000, 0x0003, 0x61},	// 57
+	{0x63, 0x80000000, 0x0003, 0x65},	// 57
+	{0x63, 0xc0000000, 0x0003, 0x68},	// 57
+	{0x63, 0x40000000, 0x0004, 0x69},	// 57
+	{0x63, 0x50000000, 0x0004, 0x6c},	// 57
+	{0x63, 0xb0000000, 0x0004, 0x6b},	// 57
+	{0x63, 0xf0000000, 0x0004, 0x74},	// 57
+	{0x63, 0xa0000000, 0x0005, 0x75},	// 57
+	{0x63, 0xa8000000, 0x0005, 0x72},	// 57
+	{0x63, 0xe0000000, 0x0005, 0x20},	// 57
+	{0x63, 0xe8000000, 0x0007, 0x79},	// 57
+	{0x63, 0xea000000, 0x0007, 0x63},	// 57
+	{0x63, 0xed000000, 0x0008, 0x73},	// 57
+	{0x63, 0xee000000, 0x0008, 0x2e},	// 57
+	{0x63, 0xef800000, 0x0009, 0x2c},	// 57
+	{0x63, 0xec400000, 0x000a, 0x47},	// 57
+	{0x63, 0xec200000, 0x000b, 0x6e},	// 57
+	{0x63, 0xecc00000, 0x000b, 0x44},	// 57
+	{0x63, 0xef000000, 0x000b, 0x4b},	// 57
+	{0x63, 0xef600000, 0x000b, 0x43},	// 57
+	{0x63, 0xec000000, 0x000c, 0x3a},	// 57
+	{0x63, 0xec900000, 0x000c, 0x2d},	// 57
+	{0x63, 0xeca00000, 0x000c, 0x41},	// 57
+	{0x63, 0xece00000, 0x000c, 0x4c},	// 57
+	{0x63, 0xecf00000, 0x000c, 0x27},	// 57
+	{0x63, 0xef200000, 0x000c, 0x64},	// 57
+	{0x63, 0xef400000, 0x000c, 0x71},	// 57
+	{0x63, 0xef500000, 0x000c, 0x49},	// 57
+	{0x63, 0xec800000, 0x000d, 0x4e},	// 57
+	{0x63, 0xec880000, 0x000d, 0x7a},	// 57
+	{0x63, 0xef380000, 0x000d, 0x46},	// 57
+	{0x63, 0xec140000, 0x000e, 0x77},	// 57
+	{0x63, 0xec1c0000, 0x000e, 0x45},	// 57
+	{0x63, 0xecb00000, 0x000e, 0x3f},	// 57
+	{0x63, 0xef300000, 0x000e, 0x4d},	// 57
+	{0x63, 0xef340000, 0x000e, 0x53},	// 57
+	{0x63, 0xec100000, 0x000f, 0x62},	// 57
+	{0x63, 0xec120000, 0x000f, 0x01},	// 57
+	{0x63, 0xec180000, 0x000f, 0x21},	// 57
+	{0x63, 0xecb40000, 0x000f, 0x51},	// 57
+	{0x63, 0xecb60000, 0x000f, 0x50},	// 57
+	{0x63, 0xecb80000, 0x000f, 0x3b},	// 57
+	{0x63, 0xecbc0000, 0x000f, 0x42},	// 57
+	{0x63, 0xec1b0000, 0x0010, 0x56},	// 57
+	{0x63, 0xecbb0000, 0x0010, 0x6d},	// 57
+	{0x63, 0xecbe0000, 0x0010, 0x2f},	// 57
+	{0x63, 0xec1a8000, 0x0011, 0x29},	// 57
+	{0x63, 0xecba0000, 0x0011, 0x55},	// 57
+	{0x63, 0xecbf0000, 0x0011, 0x57},	// 57
+	{0x63, 0xec1a0000, 0x0012, 0x70},	// 57
+	{0x63, 0xec1a4000, 0x0012, 0x48},	// 57
+	{0x63, 0xecba8000, 0x0012, 0x00},	// 57
+	{0x63, 0xecbf8000, 0x0012, 0x52},	// 57
+	{0x63, 0xecbfc000, 0x0012, 0x54},	// 57
+	{0x63, 0xecbac000, 0x0013, 0x5d},	// 57
+	{0x63, 0xecbae000, 0x0013, 0x5b},	// 57
+	{0x64, 0x00000000, 0x0001, 0x20},	// 46
+	{0x64, 0xa0000000, 0x0003, 0x65},	// 46
+	{0x64, 0xc0000000, 0x0004, 0x61},	// 46
+	{0x64, 0xe0000000, 0x0004, 0x69},	// 46
+	{0x64, 0x88000000, 0x0005, 0x2e},	// 46
+	{0x64, 0x98000000, 0x0005, 0x6f},	// 46
+	{0x64, 0xd8000000, 0x0005, 0x72},	// 46
+	{0x64, 0xf8000000, 0x0005, 0x73},	// 46
+	{0x64, 0x84000000, 0x0006, 0x64},	// 46
+	{0x64, 0x94000000, 0x0006, 0x6c},	// 46
+	{0x64, 0xd0000000, 0x0006, 0x75},	// 46
+	{0x64, 0xf4000000, 0x0006, 0x79},	// 46
+	{0x64, 0x92000000, 0x0007, 0x2d},	// 46
+	{0x64, 0xd6000000, 0x0007, 0x76},	// 46
+	{0x64, 0xf0000000, 0x0007, 0x67},	// 46
+	{0x64, 0xf2000000, 0x0007, 0x2c},	// 46
+	{0x64, 0x80000000, 0x0008, 0x68},	// 46
+	{0x64, 0x81000000, 0x0008, 0x3a},	// 46
+	{0x64, 0x82000000, 0x0008, 0x6d},	// 46
+	{0x64, 0x90000000, 0x0008, 0x77},	// 46
+	{0x64, 0x91000000, 0x0008, 0x6e},	// 46
+	{0x64, 0xd5000000, 0x0008, 0x27},	// 46
+	{0x64, 0x83800000, 0x0009, 0x66},	// 46
+	{0x64, 0xd4400000, 0x000a, 0x3f},	// 46
+	{0x64, 0xd4800000, 0x000a, 0x62},	// 46
+	{0x64, 0xd4c00000, 0x000a, 0x63},	// 46
+	{0x64, 0x83000000, 0x000b, 0x21},	// 46
+	{0x64, 0xd4000000, 0x000b, 0x70},	// 46
+	{0x64, 0xd4200000, 0x000b, 0x74},	// 46
+	{0x64, 0x83200000, 0x000c, 0x00},	// 46
+	{0x64, 0x83300000, 0x000c, 0x29},	// 46
+	{0x64, 0x83400000, 0x000c, 0x6b},	// 46
+	{0x64, 0x83500000, 0x000c, 0x3b},	// 46
+	{0x64, 0x83700000, 0x000c, 0x2f},	// 46
+	{0x64, 0x83680000, 0x000e, 0x22},	// 46
+	{0x64, 0x836c0000, 0x000e, 0x6a},	// 46
+	{0x64, 0x83600000, 0x000f, 0x7a},	// 46
+	{0x64, 0x83660000, 0x000f, 0x71},	// 46
+	{0x64, 0x83630000, 0x0010, 0x40},	// 46
+	{0x64, 0x83640000, 0x0010, 0x01},	// 46
+	{0x64, 0x83628000, 0x0011, 0x43},	// 46
+	{0x64, 0x83650000, 0x0011, 0x5d},	// 46
+	{0x64, 0x83620000, 0x0012, 0x5a},	// 46
+	{0x64, 0x83624000, 0x0012, 0x5b},	// 46
+	{0x64, 0x83658000, 0x0012, 0x54},	// 46
+	{0x64, 0x8365c000, 0x0012, 0x60},	// 46
+	{0x65, 0x80000000, 0x0002, 0x20},	// 61
+	{0x65, 0x40000000, 0x0003, 0x73},	// 61
+	{0x65, 0xc0000000, 0x0003, 0x72},	// 61
+	{0x65, 0x00000000, 0x0004, 0x64},	// 61
+	{0x65, 0x30000000, 0x0004, 0x61},	// 61
+	{0x65, 0xf0000000, 0x0004, 0x6e},	// 61
+	{0x65, 0x10000000, 0x0005, 0x63},	// 61
+	{0x65, 0x60000000, 0x0005, 0x65},	// 61
+	{0x65, 0x68000000, 0x0005, 0x77},	// 61
+	{0x65, 0x78000000, 0x0005, 0x74},	// 61
+	{0x65, 0xe0000000, 0x0005, 0x6c},	// 61
+	{0x65, 0x18000000, 0x0006, 0x78},	// 61
+	{0x65, 0x20000000, 0x0006, 0x76},	// 61
+	{0x65, 0x24000000, 0x0006, 0x69},	// 61
+	{0x65, 0x28000000, 0x0006, 0x79},	// 61
+	{0x65, 0x70000000, 0x0006, 0x6d},	// 61
+	{0x65, 0xe8000000, 0x0006, 0x2e},	// 61
+	{0x65, 0x1c000000, 0x0007, 0x66},	// 61
+	{0x65, 0x2e000000, 0x0007, 0x62},	// 61
+	{0x65, 0x74000000, 0x0007, 0x2c},	// 61
+	{0x65, 0xec000000, 0x0007, 0x70},	// 61
+	{0x65, 0x1e000000, 0x0008, 0x2d},	// 61
+	{0x65, 0x1f000000, 0x0008, 0x68},	// 61
+	{0x65, 0x2c000000, 0x0008, 0x6b},	// 61
+	{0x65, 0x76000000, 0x0008, 0x27},	// 61
+	{0x65, 0xee000000, 0x0008, 0x67},	// 61
+	{0x65, 0xef000000, 0x0008, 0x6f},	// 61
+	{0x65, 0x2d800000, 0x0009, 0x3a},	// 61
+	{0x65, 0x2d000000, 0x000a, 0x29},	// 61
+	{0x65, 0x2d400000, 0x000a, 0x71},	// 61
+	{0x65, 0x77400000, 0x000a, 0x3f},	// 61
+	{0x65, 0x77800000, 0x000a, 0x75},	// 61
+	{0x65, 0x77000000, 0x000b, 0x7a},	// 61
+	{0x65, 0x77c00000, 0x000b, 0x21},	// 61
+	{0x65, 0x77e00000, 0x000c, 0x00},	// 61
+	{0x65, 0x77f00000, 0x000c, 0x6a},	// 61
+	{0x65, 0x77300000, 0x000d, 0x2f},	// 61
+	{0x65, 0x77240000, 0x000e, 0x34},	// 61
+	{0x65, 0x77280000, 0x000e, 0x42},	// 61
+	{0x65, 0x77380000, 0x000e, 0x5d},	// 61
+	{0x65, 0x773c0000, 0x000e, 0x3b},	// 61
+	{0x65, 0x77200000, 0x000f, 0x22},	// 61
+	{0x65, 0x77230000, 0x0010, 0x44},	// 61
+	{0x65, 0x772c0000, 0x0010, 0x01},	// 61
+	{0x65, 0x772e0000, 0x0010, 0x40},	// 61
+	{0x65, 0x77220000, 0x0011, 0x54},	// 61
+	{0x65, 0x77228000, 0x0011, 0x43},	// 61
+	{0x65, 0x772d8000, 0x0011, 0x5b},	// 61
+	{0x65, 0x772f8000, 0x0011, 0x4c},	// 61
+	{0x65, 0x772d0000, 0x0012, 0x56},	// 61
+	{0x65, 0x772d4000, 0x0012, 0x47},	// 61
+	{0x65, 0x772f0000, 0x0012, 0x31},	// 61
+	{0x65, 0x772f5000, 0x0014, 0x45},	// 61
+	{0x65, 0x772f4000, 0x0015, 0x32},	// 61
+	{0x65, 0x772f4800, 0x0015, 0x4e},	// 61
+	{0x65, 0x772f6000, 0x0015, 0x46},	// 61
+	{0x65, 0x772f6800, 0x0015, 0x41},	// 61
+	{0x65, 0x772f7000, 0x0016, 0x5c},	// 61
+	{0x65, 0x772f7400, 0x0016, 0x50},	// 61
+	{0x65, 0x772f7800, 0x0016, 0x4d},	// 61
+	{0x65, 0x772f7c00, 0x0016, 0x48},	// 61
+	{0x66, 0x00000000, 0x0002, 0x6f},	// 35
+	{0x66, 0x80000000, 0x0002, 0x20},	// 35
+	{0x66, 0x40000000, 0x0003, 0x69},	// 35
+	{0x66, 0xc0000000, 0x0003, 0x72},	// 35
+	{0x66, 0x70000000, 0x0004, 0x61},	// 35
+	{0x66, 0xe0000000, 0x0004, 0x65},	// 35
+	{0x66, 0x60000000, 0x0005, 0x74},	// 35
+	{0x66, 0xf0000000, 0x0005, 0x75},	// 35
+	{0x66, 0xf8000000, 0x0005, 0x66},	// 35
+	{0x66, 0x6c000000, 0x0006, 0x6c},	// 35
+	{0x66, 0x68000000, 0x0008, 0x73},	// 35
+	{0x66, 0x69000000, 0x0008, 0x79},	// 35
+	{0x66, 0x6b000000, 0x0009, 0x2e},	// 35
+	{0x66, 0x6a000000, 0x000a, 0x3f},	// 35
+	{0x66, 0x6ac00000, 0x000a, 0x2c},	// 35
+	{0x66, 0x6bc00000, 0x000a, 0x2d},	// 35
+	{0x66, 0x6a600000, 0x000b, 0x3a},	// 35
+	{0x66, 0x6a800000, 0x000b, 0x27},	// 35
+	{0x66, 0x6aa00000, 0x000b, 0x67},	// 35
+	{0x66, 0x6a400000, 0x000c, 0x6d},	// 35
+	{0x66, 0x6b800000, 0x000c, 0x01},	// 35
+	{0x66, 0x6ba00000, 0x000c, 0x62},	// 35
+	{0x66, 0x6bb00000, 0x000c, 0x6e},	// 35
+	{0x66, 0x6a580000, 0x000d, 0x63},	// 35
+	{0x66, 0x6b900000, 0x000d, 0x21},	// 35
+	{0x66, 0x6b980000, 0x000e, 0x29},	// 35
+	{0x66, 0x6b9c0000, 0x000e, 0x77},	// 35
+	{0x66, 0x6a520000, 0x000f, 0x70},	// 35
+	{0x66, 0x6a540000, 0x000f, 0x2f},	// 35
+	{0x66, 0x6a500000, 0x0010, 0x68},	// 35
+	{0x66, 0x6a560000, 0x0010, 0x3b},	// 35
+	{0x66, 0x6a510000, 0x0011, 0x00},	// 35
+	{0x66, 0x6a518000, 0x0011, 0x64},	// 35
+	{0x66, 0x6a570000, 0x0011, 0x6b},	// 35
+	{0x66, 0x6a578000, 0x0011, 0x76},	// 35
+	{0x67, 0xc0000000, 0x0002, 0x20},	// 40
+	{0x67, 0x00000000, 0x0003, 0x61},	// 40
+	{0x67, 0x40000000, 0x0003, 0x68},	// 40
+	{0x67, 0xa0000000, 0x0003, 0x65},	// 40
+	{0x67, 0x30000000, 0x0004, 0x75},	// 40
+	{0x67, 0x60000000, 0x0004, 0x72},	// 40
+	{0x67, 0x80000000, 0x0004, 0x69},	// 40
+	{0x67, 0x70000000, 0x0005, 0x6c},	// 40
+	{0x67, 0x90000000, 0x0005, 0x73},	// 40
+	{0x67, 0x98000000, 0x0005, 0x6f},	// 40
+	{0x67, 0x24000000, 0x0006, 0x2c},	// 40
+	{0x67, 0x28000000, 0x0006, 0x6e},	// 40
+	{0x67, 0x78000000, 0x0006, 0x67},	// 40
+	{0x67, 0x7c000000, 0x0006, 0x2e},	// 40
+	{0x67, 0x2c000000, 0x0007, 0x79},	// 40
+	{0x67, 0x21000000, 0x0008, 0x27},	// 40
+	{0x67, 0x22000000, 0x0008, 0x2d},	// 40
+	{0x67, 0x23000000, 0x0008, 0x3a},	// 40
+	{0x67, 0x20000000, 0x0009, 0x64},	// 40
+	{0x67, 0x2e800000, 0x0009, 0x62},	// 40
+	{0x67, 0x2f000000, 0x0009, 0x74},	// 40
+	{0x67, 0x2f800000, 0x0009, 0x77},	// 40
+	{0x67, 0x20800000, 0x000a, 0x3f},	// 40
+	{0x67, 0x20c00000, 0x000a, 0x6d},	// 40
+	{0x67, 0x2e200000, 0x000b, 0x21},	// 40
+	{0x67, 0x2e600000, 0x000b, 0x66},	// 40
+	{0x67, 0x2e100000, 0x000c, 0x3b},	// 40
+	{0x67, 0x2e500000, 0x000c, 0x00},	// 40
+	{0x67, 0x2e000000, 0x000d, 0x6b},	// 40
+	{0x67, 0x2e400000, 0x000d, 0x70},	// 40
+	{0x67, 0x2e080000, 0x000e, 0x29},	// 40
+	{0x67, 0x2e0c0000, 0x000e, 0x22},	// 40
+	{0x67, 0x2e4a0000, 0x000f, 0x63},	// 40
+	{0x67, 0x2e4e0000, 0x000f, 0x2f},	// 40
+	{0x67, 0x2e480000, 0x0010, 0x01},	// 40
+	{0x67, 0x2e4c0000, 0x0010, 0x5d},	// 40
+	{0x67, 0x2e4d0000, 0x0010, 0x7a},	// 40
+	{0x67, 0x2e490000, 0x0011, 0x60},	// 40
+	{0x67, 0x2e498000, 0x0012, 0x76},	// 40
+	{0x67, 0x2e49c000, 0x0012, 0x40},	// 40
+	{0x68, 0x00000000, 0x0001, 0x65},	// 41
+	{0x68, 0x80000000, 0x0003, 0x6f},	// 41
+	{0x68, 0xa0000000, 0x0003, 0x69},	// 41
+	{0x68, 0xc0000000, 0x0003, 0x20},	// 41
+	{0x68, 0xf0000000, 0x0004, 0x61},	// 41
+	{0x68, 0xe4000000, 0x0006, 0x72},	// 41
+	{0x68, 0xec000000, 0x0006, 0x74},	// 41
+	{0x68, 0xe1000000, 0x0008, 0x79},	// 41
+	{0x68, 0xe3000000, 0x0008, 0x6c},	// 41
+	{0x68, 0xe8000000, 0x0008, 0x2e},	// 41
+	{0x68, 0xe9000000, 0x0008, 0x6e},	// 41
+	{0x68, 0xeb000000, 0x0008, 0x75},	// 41
+	{0x68, 0xe0000000, 0x0009, 0x64},	// 41
+	{0x68, 0xe2000000, 0x0009, 0x73},	// 41
+	{0x68, 0xea000000, 0x0009, 0x2c},	// 41
+	{0x68, 0xe0c00000, 0x000a, 0x77},	// 41
+	{0x68, 0xe2800000, 0x000a, 0x27},	// 41
+	{0x68, 0xe2c00000, 0x000a, 0x2d},	// 41
+	{0x68, 0xeaa00000, 0x000b, 0x6d},	// 41
+	{0x68, 0xeac00000, 0x000b, 0x3a},	// 41
+	{0x68, 0xeae00000, 0x000b, 0x62},	// 41
+	{0x68, 0xe0900000, 0x000c, 0x63},	// 41
+	{0x68, 0xe0b00000, 0x000c, 0x3f},	// 41
+	{0x68, 0xea800000, 0x000c, 0x21},	// 41
+	{0x68, 0xe0800000, 0x000d, 0x29},	// 41
+	{0x68, 0xe0a00000, 0x000d, 0x68},	// 41
+	{0x68, 0xe0a80000, 0x000d, 0x6b},	// 41
+	{0x68, 0xea980000, 0x000d, 0x66},	// 41
+	{0x68, 0xea940000, 0x000e, 0x67},	// 41
+	{0x68, 0xe0880000, 0x000f, 0x70},	// 41
+	{0x68, 0xe08a0000, 0x000f, 0x3b},	// 41
+	{0x68, 0xe08c0000, 0x000f, 0x2f},	// 41
+	{0x68, 0xe08e0000, 0x000f, 0x00},	// 41
+	{0x68, 0xea920000, 0x000f, 0x76},	// 41
+	{0x68, 0xea900000, 0x0010, 0x71},	// 41
+	{0x68, 0xea910000, 0x0011, 0x01},	// 41
+	{0x68, 0xea918000, 0x0012, 0x22},	// 41
+	{0x68, 0xea91c000, 0x0014, 0x7a},	// 41
+	{0x68, 0xea91d000, 0x0014, 0x6a},	// 41
+	{0x68, 0xea91e000, 0x0014, 0x5d},	// 41
+	{0x68, 0xea91f000, 0x0014, 0x2a},	// 41
+	{0x69, 0x80000000, 0x0002, 0x6e},	// 44
+	{0x69, 0x00000000, 0x0003, 0x74},	// 44
+	{0x69, 0x40000000, 0x0003, 0x73},	// 44
+	{0x69, 0x30000000, 0x0004, 0x6c},	// 44
+	{0x69, 0xc0000000, 0x0004, 0x6f},	// 44
+	{0x69, 0xd0000000, 0x0004, 0x63},	// 44
+	{0x69, 0xf0000000, 0x0004, 0x65},	// 44
+	{0x69, 0x20000000, 0x0005, 0x61},	// 44
+	{0x69, 0x60000000, 0x0005, 0x6d},	// 44
+	{0x69, 0x68000000, 0x0005, 0x64},	// 44
+	{0x69, 0x70000000, 0x0005, 0x76},	// 44
+	{0x69, 0xe0000000, 0x0005, 0x67},	// 44
+	{0x69, 0xe8000000, 0x0005, 0x72},	// 44
+	{0x69, 0x28000000, 0x0006, 0x70},	// 44
+	{0x69, 0x78000000, 0x0006, 0x66},	// 44
+	{0x69, 0x2c000000, 0x0007, 0x7a},	// 44
+	{0x69, 0x7c000000, 0x0007, 0x20},	// 44
+	{0x69, 0x2f000000, 0x0008, 0x62},	// 44
+	{0x69, 0x7e000000, 0x0008, 0x6b},	// 44
+	{0x69, 0x2e000000, 0x0009, 0x2d},	// 44
+	{0x69, 0x2e800000, 0x0009, 0x78},	// 44
+	{0x69, 0x7f000000, 0x000a, 0x75},	// 44
+	{0x69, 0x7f800000, 0x000a, 0x71},	// 44
+	{0x69, 0x7f400000, 0x000b, 0x2e},	// 44
+	{0x69, 0x7fc00000, 0x000b, 0x2c},	// 44
+	{0x69, 0x7f700000, 0x000c, 0x77},	// 44
+	{0x69, 0x7ff00000, 0x000c, 0x27},	// 44
+	{0x69, 0x7f680000, 0x000d, 0x69},	// 44
+	{0x69, 0x7fe80000, 0x000d, 0x6a},	// 44
+	{0x69, 0x7f640000, 0x000e, 0x3a},	// 44
+	{0x69, 0x7fe00000, 0x000e, 0x68},	// 44
+	{0x69, 0x7f600000, 0x000f, 0x2f},	// 44
+	{0x69, 0x7fe60000, 0x000f, 0x79},	// 44
+	{0x69, 0x7f630000, 0x0010, 0x3f},	// 44
+	{0x69, 0x7fe40000, 0x0010, 0x50},	// 44
+	{0x69, 0x7f628000, 0x0011, 0x52},	// 44
+	{0x69, 0x7fe58000, 0x0011, 0x21},	// 44
+	{0x69, 0x7fe50000, 0x0012, 0x29},	// 44
+	{0x69, 0x7fe54000, 0x0012, 0x53},	// 44
+	{0x69, 0x7f620000, 0x0013, 0x00},	// 44
+	{0x69, 0x7f622000, 0x0013, 0x43},	// 44
+	{0x69, 0x7f624000, 0x0013, 0x01},	// 44
+	{0x69, 0x7f626000, 0x0014, 0x44},	// 44
+	{0x69, 0x7f627000, 0x0014, 0x3b},	// 44
+	{0x6a, 0x00000000, 0x0001, 0x6f},	// 14
+	{0x6a, 0xc0000000, 0x0002, 0x75},	// 14
+	{0x6a, 0xa0000000, 0x0003, 0x61},	// 14
+	{0x6a, 0x90000000, 0x0004, 0x65},	// 14
+	{0x6a, 0x80000000, 0x0005, 0x69},	// 14
+	{0x6a, 0x8c000000, 0x0006, 0x79},	// 14
+	{0x6a, 0x8a000000, 0x0007, 0x20},	// 14
+	{0x6a, 0x89000000, 0x0008, 0x2e},	// 14
+	{0x6a, 0x88000000, 0x0009, 0x27},	// 14
+	{0x6a, 0x88c00000, 0x000a, 0x74},	// 14
+	{0x6a, 0x88800000, 0x000b, 0x6e},	// 14
+	{0x6a, 0x88b00000, 0x000c, 0x73},	// 14
+	{0x6a, 0x88a00000, 0x000d, 0x01},	// 14
+	{0x6a, 0x88a80000, 0x000d, 0x68},	// 14
+	{0x6b, 0x80000000, 0x0002, 0x20},	// 40
+	{0x6b, 0xc0000000, 0x0002, 0x65},	// 40
+	{0x6b, 0x00000000, 0x0003, 0x73},	// 40
+	{0x6b, 0x60000000, 0x0003, 0x69},	// 40
+	{0x6b, 0x20000000, 0x0004, 0x2e},	// 40
+	{0x6b, 0x48000000, 0x0005, 0x79},	// 40
+	{0x6b, 0x30000000, 0x0006, 0x27},	// 40
+	{0x6b, 0x34000000, 0x0006, 0x61},	// 40
+	{0x6b, 0x38000000, 0x0006, 0x70},	// 40
+	{0x6b, 0x3c000000, 0x0006, 0x2c},	// 40
+	{0x6b, 0x50000000, 0x0006, 0x6c},	// 40
+	{0x6b, 0x54000000, 0x0006, 0x66},	// 40
+	{0x6b, 0x58000000, 0x0006, 0x6e},	// 40
+	{0x6b, 0x40000000, 0x0007, 0x2f},	// 40
+	{0x6b, 0x44000000, 0x0007, 0x2d},	// 40
+	{0x6b, 0x46000000, 0x0007, 0x6f},	// 40
+	{0x6b, 0x5d000000, 0x0008, 0x3a},	// 40
+	{0x6b, 0x43800000, 0x0009, 0x62},	// 40
+	{0x6b, 0x5c000000, 0x0009, 0x77},	// 40
+	{0x6b, 0x5c800000, 0x0009, 0x6d},	// 40
+	{0x6b, 0x5e000000, 0x0009, 0x68},	// 40
+	{0x6b, 0x5f000000, 0x0009, 0x75},	// 40
+	{0x6b, 0x5f800000, 0x0009, 0x6b},	// 40
+	{0x6b, 0x42000000, 0x000a, 0x72},	// 40
+	{0x6b, 0x42400000, 0x000a, 0x01},	// 40
+	{0x6b, 0x42800000, 0x000a, 0x3f},	// 40
+	{0x6b, 0x43000000, 0x000a, 0x74},	// 40
+	{0x6b, 0x43400000, 0x000a, 0x67},	// 40
+	{0x6b, 0x5ec00000, 0x000a, 0x64},	// 40
+	{0x6b, 0x42c00000, 0x000b, 0x6a},	// 40
+	{0x6b, 0x42e00000, 0x000c, 0x29},	// 40
+	{0x6b, 0x5e800000, 0x000c, 0x3b},	// 40
+	{0x6b, 0x5e900000, 0x000c, 0x63},	// 40
+	{0x6b, 0x5ea00000, 0x000c, 0x53},	// 40
+	{0x6b, 0x42f00000, 0x000d, 0x76},	// 40
+	{0x6b, 0x42f80000, 0x000d, 0x52},	// 40
+	{0x6b, 0x5eb00000, 0x000d, 0x21},	// 40
+	{0x6b, 0x5eb80000, 0x000e, 0x40},	// 40
+	{0x6b, 0x5ebc0000, 0x000f, 0x22},	// 40
+	{0x6b, 0x5ebe0000, 0x000f, 0x00},	// 40
+	{0x6c, 0x40000000, 0x0003, 0x61},	// 43
+	{0x6c, 0x60000000, 0x0003, 0x69},	// 43
+	{0x6c, 0x80000000, 0x0003, 0x6c},	// 43
+	{0x6c, 0xc0000000, 0x0003, 0x65},	// 43
+	{0x6c, 0xe0000000, 0x0003, 0x20},	// 43
+	{0x6c, 0x00000000, 0x0004, 0x75},	// 43
+	{0x6c, 0x10000000, 0x0004, 0x64},	// 43
+	{0x6c, 0x20000000, 0x0004, 0x79},	// 43
+	{0x6c, 0xb0000000, 0x0004, 0x6f},	// 43
+	{0x6c, 0xa0000000, 0x0005, 0x73},	// 43
+	{0x6c, 0x30000000, 0x0006, 0x2e},	// 43
+	{0x6c, 0x38000000, 0x0006, 0x74},	// 43
+	{0x6c, 0x34000000, 0x0007, 0x76},	// 43
+	{0x6c, 0x3c000000, 0x0007, 0x66},	// 43
+	{0x6c, 0xa8000000, 0x0007, 0x6d},	// 43
+	{0x6c, 0xaa000000, 0x0007, 0x6b},	// 43
+	{0x6c, 0xac000000, 0x0007, 0x70},	// 43
+	{0x6c, 0x37000000, 0x0008, 0x63},	// 43
+	{0x6c, 0x3e000000, 0x0008, 0x2d},	// 43
+	{0x6c, 0xaf000000, 0x0008, 0x2c},	// 43
+	{0x6c, 0x36800000, 0x0009, 0x3a},	// 43
+	{0x6c, 0x3f800000, 0x0009, 0x62},	// 43
+	{0x6c, 0xae000000, 0x0009, 0x27},	// 43
+	{0x6c, 0x36000000, 0x000a, 0x72},	// 43
+	{0x6c, 0x36400000, 0x000a, 0x68},	// 43
+	{0x6c, 0x3f000000, 0x000a, 0x6e},	// 43
+	{0x6c, 0x3f400000, 0x000a, 0x67},	// 43
+	{0x6c, 0xaec00000, 0x000a, 0x77},	// 43
+	{0x6c, 0xae800000, 0x000b, 0x3f},	// 43
+	{0x6c, 0xaea00000, 0x000d, 0x21},	// 43
+	{0x6c, 0xaeb00000, 0x000d, 0x7a},	// 43
+	{0x6c, 0xaeac0000, 0x000e, 0x2f},	// 43
+	{0x6c, 0xaea80000, 0x000f, 0x3b},	// 43
+	{0x6c, 0xaeb80000, 0x000f, 0x45},	// 43
+	{0x6c, 0xaeba0000, 0x000f, 0x2a},	// 43
+	{0x6c, 0xaebe0000, 0x000f, 0x00},	// 43
+	{0x6c, 0xaeab0000, 0x0010, 0x01},	// 43
+	{0x6c, 0xaebc0000, 0x0010, 0x29},	// 43
+	{0x6c, 0xaeaa0000, 0x0011, 0x40},	// 43
+	{0x6c, 0xaeaa8000, 0x0011, 0x6a},	// 43
+	{0x6c, 0xaebd0000, 0x0011, 0x22},	// 43
+	{0x6c, 0xaebd8000, 0x0012, 0x5b},	// 43
+	{0x6c, 0xaebdc000, 0x0012, 0x5d},	// 43
+	{0x6d, 0x00000000, 0x0002, 0x61},	// 40
+	{0x6d, 0x40000000, 0x0002, 0x65},	// 40
+	{0x6d, 0xe0000000, 0x0003, 0x20},	// 40
+	{0x6d, 0x90000000, 0x0004, 0x70},	// 40
+	{0x6d, 0xb0000000, 0x0004, 0x6f},	// 40
+	{0x6d, 0xc0000000, 0x0004, 0x69},	// 40
+	{0x6d, 0x80000000, 0x0005, 0x2e},	// 40
+	{0x6d, 0x88000000, 0x0005, 0x73},	// 40
+	{0x6d, 0xd0000000, 0x0005, 0x75},	// 40
+	{0x6d, 0xd8000000, 0x0005, 0x6d},	// 40
+	{0x6d, 0xa4000000, 0x0006, 0x79},	// 40
+	{0x6d, 0xac000000, 0x0006, 0x62},	// 40
+	{0x6d, 0xa0000000, 0x0007, 0x2c},	// 40
+	{0x6d, 0xa8000000, 0x0007, 0x2f},	// 40
+	{0x6d, 0xa2000000, 0x0008, 0x5d},	// 40
+	{0x6d, 0xa3000000, 0x0009, 0x3a},	// 40
+	{0x6d, 0xaa000000, 0x0009, 0x27},	// 40
+	{0x6d, 0xa3c00000, 0x000a, 0x72},	// 40
+	{0x6d, 0xaac00000, 0x000a, 0x66},	// 40
+	{0x6d, 0xab000000, 0x000a, 0x6c},	// 40
+	{0x6d, 0xab800000, 0x000a, 0x6e},	// 40
+	{0x6d, 0xa3800000, 0x000b, 0x3f},	// 40
+	{0x6d, 0xa3a00000, 0x000b, 0x21},	// 40
+	{0x6d, 0xaa800000, 0x000b, 0x00},	// 40
+	{0x6d, 0xaaa00000, 0x000b, 0x77},	// 40
+	{0x6d, 0xab600000, 0x000b, 0x68},	// 40
+	{0x6d, 0xabc00000, 0x000b, 0x2d},	// 40
+	{0x6d, 0xabe00000, 0x000c, 0x34},	// 40
+	{0x6d, 0xab500000, 0x000d, 0x74},	// 40
+	{0x6d, 0xab580000, 0x000d, 0x40},	// 40
+	{0x6d, 0xabf00000, 0x000d, 0x3b},	// 40
+	{0x6d, 0xabf80000, 0x000d, 0x63},	// 40
+	{0x6d, 0xab400000, 0x000e, 0x29},	// 40
+	{0x6d, 0xab440000, 0x000e, 0x01},	// 40
+	{0x6d, 0xab4c0000, 0x000e, 0x64},	// 40
+	{0x6d, 0xab4a0000, 0x000f, 0x67},	// 40
+	{0x6d, 0xab480000, 0x0011, 0x5b},	// 40
+	{0x6d, 0xab488000, 0x0011, 0x76},	// 40
+	{0x6d, 0xab490000, 0x0011, 0x6b},	// 40
+	{0x6d, 0xab498000, 0x0011, 0x7a},	// 40
+	{0x6e, 0x40000000, 0x0002, 0x20},	// 44
+	{0x6e, 0x20000000, 0x0003, 0x74},	// 44
+	{0x6e, 0x80000000, 0x0003, 0x67},	// 44
+	{0x6e, 0xe0000000, 0x0003, 0x64},	// 44
+	{0x6e, 0x00000000, 0x0004, 0x73},	// 44
+	{0x6e, 0xa0000000, 0x0004, 0x61},	// 44
+	{0x6e, 0xd0000000, 0x0004, 0x65},	// 44
+	{0x6e, 0xb0000000, 0x0005, 0x63},	// 44
+	{0x6e, 0xc0000000, 0x0005, 0x69},	// 44
+	{0x6e, 0x1c000000, 0x0006, 0x2e},	// 44
+	{0x6e, 0xbc000000, 0x0006, 0x6e},	// 44
+	{0x6e, 0xcc000000, 0x0006, 0x6f},	// 44
+	{0x6e, 0x12000000, 0x0007, 0x75},	// 44
+	{0x6e, 0x16000000, 0x0007, 0x76},	// 44
+	{0x6e, 0x18000000, 0x0007, 0x66},	// 44
+	{0x6e, 0xb8000000, 0x0007, 0x6b},	// 44
+	{0x6e, 0xba000000, 0x0007, 0x27},	// 44
+	{0x6e, 0xc8000000, 0x0007, 0x79},	// 44
+	{0x6e, 0xca000000, 0x0007, 0x2c},	// 44
+	{0x6e, 0x10000000, 0x0008, 0x6d},	// 44
+	{0x6e, 0x14000000, 0x0008, 0x6c},	// 44
+	{0x6e, 0x15000000, 0x0008, 0x2d},	// 44
+	{0x6e, 0x11800000, 0x0009, 0x77},	// 44
+	{0x6e, 0x1a800000, 0x0009, 0x3a},	// 44
+	{0x6e, 0x11400000, 0x000a, 0x7a},	// 44
+	{0x6e, 0x1a000000, 0x000a, 0x68},	// 44
+	{0x6e, 0x1b000000, 0x000a, 0x62},	// 44
+	{0x6e, 0x1b400000, 0x000a, 0x6a},	// 44
+	{0x6e, 0x1b800000, 0x000a, 0x72},	// 44
+	{0x6e, 0x11000000, 0x000b, 0x70},	// 44
+	{0x6e, 0x1a600000, 0x000b, 0x78},	// 44
+	{0x6e, 0x1be00000, 0x000b, 0x3f},	// 44
+	{0x6e, 0x11300000, 0x000c, 0x3b},	// 44
+	{0x6e, 0x1a500000, 0x000c, 0x29},	// 44
+	{0x6e, 0x1bc00000, 0x000c, 0x21},	// 44
+	{0x6e, 0x1bd00000, 0x000c, 0x71},	// 44
+	{0x6e, 0x11200000, 0x000d, 0x2f},	// 44
+	{0x6e, 0x11280000, 0x000d, 0x00},	// 44
+	{0x6e, 0x1a400000, 0x000d, 0x01},	// 44
+	{0x6e, 0x1a480000, 0x000e, 0x42},	// 44
+	{0x6e, 0x1a4c0000, 0x0010, 0x5d},	// 44
+	{0x6e, 0x1a4d0000, 0x0010, 0x22},	// 44
+	{0x6e, 0x1a4e0000, 0x0010, 0x40},	// 44
+	{0x6e, 0x1a4f0000, 0x0010, 0x2a},	// 44
+	{0x6f, 0x20000000, 0x0003, 0x75},	// 48
+	{0x6f, 0x60000000, 0x0003, 0x20},	// 48
+	{0x6f, 0x80000000, 0x0003, 0x72},	// 48
+	{0x6f, 0xe0000000, 0x0003, 0x6e},	// 48
+	{0x6f, 0x00000000, 0x0004, 0x6c},	// 48
+	{0x6f, 0xc0000000, 0x0004, 0x6d},	// 48
+	{0x6f, 0xd0000000, 0x0004, 0x66},	// 48
+	{0x6f, 0x10000000, 0x0005, 0x76},	// 48
+	{0x6f, 0x40000000, 0x0005, 0x73},	// 48
+	{0x6f, 0x48000000, 0x0005, 0x70},	// 48
+	{0x6f, 0xa0000000, 0x0005, 0x74},	// 48
+	{0x6f, 0xa8000000, 0x0005, 0x6f},	// 48
+	{0x6f, 0xb8000000, 0x0005, 0x77},	// 48
+	{0x6f, 0x18000000, 0x0006, 0x6b},	// 48
+	{0x6f, 0x1c000000, 0x0006, 0x69},	// 48
+	{0x6f, 0x50000000, 0x0006, 0x67},	// 48
+	{0x6f, 0x5c000000, 0x0006, 0x63},	// 48
+	{0x6f, 0xb4000000, 0x0006, 0x64},	// 48
+	{0x6f, 0x56000000, 0x0007, 0x65},	// 48
+	{0x6f, 0x58000000, 0x0007, 0x79},	// 48
+	{0x6f, 0x5a000000, 0x0007, 0x61},	// 48
+	{0x6f, 0xb2000000, 0x0007, 0x62},	// 48
+	{0x6f, 0x55000000, 0x0008, 0x68},	// 48
+	{0x6f, 0xb0000000, 0x0008, 0x2e},	// 48
+	{0x6f, 0x54000000, 0x0009, 0x2d},	// 48
+	{0x6f, 0x54800000, 0x0009, 0x2c},	// 48
+	{0x6f, 0xb1400000, 0x000a, 0x27},	// 48
+	{0x6f, 0xb1c00000, 0x000a, 0x78},	// 48
+	{0x6f, 0xb1200000, 0x000b, 0x3a},	// 48
+	{0x6f, 0xb1a00000, 0x000b, 0x7a},	// 48
+	{0x6f, 0xb1100000, 0x000c, 0x3f},	// 48
+	{0x6f, 0xb1900000, 0x000c, 0x6a},	// 48
+	{0x6f, 0xb1000000, 0x000d, 0x21},	// 48
+	{0x6f, 0xb1880000, 0x000d, 0x71},	// 48
+	{0x6f, 0xb1080000, 0x000e, 0x4a},	// 48
+	{0x6f, 0xb1800000, 0x000e, 0x2f},	// 48
+	{0x6f, 0xb1840000, 0x000e, 0x29},	// 48
+	{0x6f, 0xb10d0000, 0x0010, 0x3b},	// 48
+	{0x6f, 0xb10e0000, 0x0010, 0x47},	// 48
+	{0x6f, 0xb10c0000, 0x0011, 0x22},	// 48
+	{0x6f, 0xb10f0000, 0x0011, 0x01},	// 48
+	{0x6f, 0xb10c8000, 0x0012, 0x5d},	// 48
+	{0x6f, 0xb10cc000, 0x0012, 0x40},	// 48
+	{0x6f, 0xb10f8000, 0x0013, 0x34},	// 48
+	{0x6f, 0xb10fa000, 0x0013, 0x00},	// 48
+	{0x6f, 0xb10fc000, 0x0013, 0x42},	// 48
+	{0x6f, 0xb10fe000, 0x0014, 0x4f},	// 48
+	{0x6f, 0xb10ff000, 0x0014, 0x43},	// 48
+	{0x70, 0x20000000, 0x0003, 0x6c},	// 39
+	{0x70, 0x40000000, 0x0003, 0x20},	// 39
+	{0x70, 0x60000000, 0x0003, 0x6f},	// 39
+	{0x70, 0xa0000000, 0x0003, 0x72},	// 39
+	{0x70, 0xe0000000, 0x0003, 0x65},	// 39
+	{0x70, 0x00000000, 0x0004, 0x70},	// 39
+	{0x70, 0xc0000000, 0x0004, 0x61},	// 39
+	{0x70, 0xd0000000, 0x0004, 0x69},	// 39
+	{0x70, 0x18000000, 0x0005, 0x74},	// 39
+	{0x70, 0x80000000, 0x0005, 0x75},	// 39
+	{0x70, 0x88000000, 0x0005, 0x68},	// 39
+	{0x70, 0x90000000, 0x0005, 0x73},	// 39
+	{0x70, 0x14000000, 0x0006, 0x6d},	// 39
+	{0x70, 0x12000000, 0x0007, 0x64},	// 39
+	{0x70, 0x9a000000, 0x0007, 0x79},	// 39
+	{0x70, 0x9c000000, 0x0007, 0x2e},	// 39
+	{0x70, 0x9e000000, 0x0007, 0x2c},	// 39
+	{0x70, 0x10000000, 0x0008, 0x2d},	// 39
+	{0x70, 0x11800000, 0x0009, 0x3f},	// 39
+	{0x70, 0x98800000, 0x0009, 0x3a},	// 39
+	{0x70, 0x99000000, 0x000a, 0x27},	// 39
+	{0x70, 0x99400000, 0x000a, 0x5d},	// 39
+	{0x70, 0x99800000, 0x000a, 0x2b},	// 39
+	{0x70, 0x99c00000, 0x000a, 0x62},	// 39
+	{0x70, 0x11200000, 0x000b, 0x66},	// 39
+	{0x70, 0x11400000, 0x000b, 0x6b},	// 39
+	{0x70, 0x11600000, 0x000b, 0x21},	// 39
+	{0x70, 0x98200000, 0x000b, 0x63},	// 39
+	{0x70, 0x98400000, 0x000b, 0x6e},	// 39
+	{0x70, 0x98600000, 0x000b, 0x77},	// 39
+	{0x70, 0x11000000, 0x000c, 0x00},	// 39
+	{0x70, 0x11100000, 0x000c, 0x3b},	// 39
+	{0x70, 0x98100000, 0x000c, 0x2f},	// 39
+	{0x70, 0x98080000, 0x000d, 0x67},	// 39
+	{0x70, 0x98040000, 0x000e, 0x29},	// 39
+	{0x70, 0x98020000, 0x000f, 0x22},	// 39
+	{0x70, 0x98010000, 0x0010, 0x53},	// 39
+	{0x70, 0x98000000, 0x0011, 0x01},	// 39
+	{0x70, 0x98008000, 0x0011, 0x42},	// 39
+	{0x71, 0x80000000, 0x0001, 0x75},	// 13
+	{0x71, 0x00000000, 0x0003, 0x2c},	// 13
+	{0x71, 0x20000000, 0x0003, 0x2e},	// 13
+	{0x71, 0x60000000, 0x0003, 0x20},	// 13
+	{0x71, 0x48000000, 0x0005, 0x62},	// 13
+	{0x71, 0x50000000, 0x0005, 0x27},	// 13
+	{0x71, 0x58000000, 0x0005, 0x69},	// 13
+	{0x71, 0x44000000, 0x0006, 0x61},	// 13
+	{0x71, 0x40000000, 0x0008, 0x3f},	// 13
+	{0x71, 0x41000000, 0x0008, 0x3a},	// 13
+	{0x71, 0x43000000, 0x0008, 0x29},	// 13
+	{0x71, 0x42000000, 0x0009, 0x01},	// 13
+	{0x71, 0x42800000, 0x0009, 0x77},	// 13
+	{0x72, 0x00000000, 0x0003, 0x61},	// 47
+	{0x72, 0x20000000, 0x0003, 0x6f},	// 47
+	{0x72, 0x80000000, 0x0003, 0x69},	// 47
+	{0x72, 0xc0000000, 0x0003, 0x20},	// 47
+	{0x72, 0xe0000000, 0x0003, 0x65},	// 47
+	{0x72, 0x40000000, 0x0004, 0x73},	// 47
+	{0x72, 0x50000000, 0x0004, 0x74},	// 47
+	{0x72, 0x70000000, 0x0005, 0x64},	// 47
+	{0x72, 0xa0000000, 0x0005, 0x6e},	// 47
+	{0x72, 0xa8000000, 0x0005, 0x79},	// 47
+	{0x72, 0x68000000, 0x0006, 0x75},	// 47
+	{0x72, 0x6c000000, 0x0006, 0x6d},	// 47
+	{0x72, 0x7c000000, 0x0006, 0x6b},	// 47
+	{0x72, 0xb4000000, 0x0006, 0x6c},	// 47
+	{0x72, 0xb8000000, 0x0006, 0x2e},	// 47
+	{0x72, 0xbc000000, 0x0006, 0x72},	// 47
+	{0x72, 0x60000000, 0x0007, 0x66},	// 47
+	{0x72, 0x64000000, 0x0007, 0x2c},	// 47
+	{0x72, 0x66000000, 0x0007, 0x76},	// 47
+	{0x72, 0xb0000000, 0x0007, 0x63},	// 47
+	{0x72, 0xb2000000, 0x0007, 0x67},	// 47
+	{0x72, 0x63000000, 0x0008, 0x27},	// 47
+	{0x72, 0x78000000, 0x0008, 0x2d},	// 47
+	{0x72, 0x79000000, 0x0008, 0x62},	// 47
+	{0x72, 0x7b000000, 0x0008, 0x70},	// 47
+	{0x72, 0x62800000, 0x0009, 0x3a},	// 47
+	{0x72, 0x7a000000, 0x0009, 0x77},	// 47
+	{0x72, 0x7a800000, 0x000a, 0x3f},	// 47
+	{0x72, 0x7ac00000, 0x000a, 0x68},	// 47
+	{0x72, 0x62400000, 0x000b, 0x21},	// 47
+	{0x72, 0x62100000, 0x000c, 0x71},	// 47
+	{0x72, 0x62200000, 0x000c, 0x6a},	// 47
+	{0x72, 0x62300000, 0x000c, 0x00},	// 47
+	{0x72, 0x62600000, 0x000c, 0x2f},	// 47
+	{0x72, 0x62080000, 0x000d, 0x3b},	// 47
+	{0x72, 0x62780000, 0x000d, 0x29},	// 47
+	{0x72, 0x62700000, 0x000e, 0x38},	// 47
+	{0x72, 0x62740000, 0x000e, 0x7a},	// 47
+	{0x72, 0x62020000, 0x000f, 0x22},	// 47
+	{0x72, 0x62060000, 0x000f, 0x5d},	// 47
+	{0x72, 0x62000000, 0x0010, 0x54},	// 47
+	{0x72, 0x62040000, 0x0010, 0x78},	// 47
+	{0x72, 0x62050000, 0x0010, 0x01},	// 47
+	{0x72, 0x62018000, 0x0011, 0x5a},	// 47
+	{0x72, 0x62010000, 0x0012, 0x2a},	// 47
+	{0x72, 0x62014000, 0x0013, 0x44},	// 47
+	{0x72, 0x62016000, 0x0013, 0x42},	// 47
+	{0x73, 0x00000000, 0x0001, 0x20},	// 45
+	{0x73, 0xa0000000, 0x0003, 0x74},	// 45
+	{0x73, 0x80000000, 0x0004, 0x2e},	// 45
+	{0x73, 0xe0000000, 0x0004, 0x65},	// 45
+	{0x73, 0x98000000, 0x0005, 0x2c},	// 45
+	{0x73, 0xc0000000, 0x0005, 0x6f},	// 45
+	{0x73, 0xc8000000, 0x0005, 0x73},	// 45
+	{0x73, 0xf0000000, 0x0005, 0x68},	// 45
+	{0x73, 0xf8000000, 0x0005, 0x69},	// 45
+	{0x73, 0x94000000, 0x0006, 0x63},	// 45
+	{0x73, 0xd0000000, 0x0006, 0x75},	// 45
+	{0x73, 0xd8000000, 0x0006, 0x70},	// 45
+	{0x73, 0xde000000, 0x0007, 0x61},	// 45
+	{0x73, 0x91000000, 0x0008, 0x6e},	// 45
+	{0x73, 0x93000000, 0x0008, 0x6d},	// 45
+	{0x73, 0xd4000000, 0x0008, 0x79},	// 45
+	{0x73, 0xd6000000, 0x0008, 0x3a},	// 45
+	{0x73, 0xdc000000, 0x0008, 0x6c},	// 45
+	{0x73, 0xdd000000, 0x0008, 0x6b},	// 45
+	{0x73, 0x90800000, 0x0009, 0x62},	// 45
+	{0x73, 0x92000000, 0x0009, 0x66},	// 45
+	{0x73, 0xd5000000, 0x0009, 0x77},	// 45
+	{0x73, 0xd7800000, 0x0009, 0x27},	// 45
+	{0x73, 0x90000000, 0x000a, 0x21},	// 45
+	{0x73, 0x90400000, 0x000a, 0x67},	// 45
+	{0x73, 0x92800000, 0x000a, 0x72},	// 45
+	{0x73, 0xd5800000, 0x000a, 0x3f},	// 45
+	{0x73, 0xd5c00000, 0x000a, 0x2d},	// 45
+	{0x73, 0xd7400000, 0x000a, 0x71},	// 45
+	{0x73, 0xd7200000, 0x000b, 0x64},	// 45
+	{0x73, 0x92c00000, 0x000c, 0x2f},	// 45
+	{0x73, 0x92d00000, 0x000c, 0x29},	// 45
+	{0x73, 0x92f00000, 0x000c, 0x00},	// 45
+	{0x73, 0xd7000000, 0x000c, 0x5d},	// 45
+	{0x73, 0xd7100000, 0x000c, 0x3b},	// 45
+	{0x73, 0x92e80000, 0x000d, 0x76},	// 45
+	{0x73, 0x92e20000, 0x000f, 0x22},	// 45
+	{0x73, 0x92e60000, 0x000f, 0x7a},	// 45
+	{0x73, 0x92e00000, 0x0010, 0x6a},	// 45
+	{0x73, 0x92e10000, 0x0010, 0x01},	// 45
+	{0x73, 0x92e40000, 0x0010, 0x5b},	// 45
+	{0x73, 0x92e58000, 0x0011, 0x40},	// 45
+	{0x73, 0x92e54000, 0x0012, 0x54},	// 45
+	{0x73, 0x92e50000, 0x0013, 0x78},	// 45
+	{0x73, 0x92e52000, 0x0013, 0x60},	// 45
+	{0x74, 0x80000000, 0x0002, 0x68},	// 49
+	{0x74, 0x00000000, 0x0003, 0x69},	// 49
+	{0x74, 0x40000000, 0x0003, 0x6f},	// 49
+	{0x74, 0x60000000, 0x0003, 0x65},	// 49
+	{0x74, 0xe0000000, 0x0003, 0x20},	// 49
+	{0x74, 0x20000000, 0x0004, 0x61},	// 49
+	{0x74, 0x30000000, 0x0005, 0x75},	// 49
+	{0x74, 0xc8000000, 0x0005, 0x72},	// 49
+	{0x74, 0xd8000000, 0x0005, 0x73},	// 49
+	{0x74, 0x3c000000, 0x0006, 0x2e},	// 49
+	{0x74, 0xc4000000, 0x0006, 0x74},	// 49
+	{0x74, 0xd0000000, 0x0006, 0x79},	// 49
+	{0x74, 0x3a000000, 0x0007, 0x63},	// 49
+	{0x74, 0xc2000000, 0x0007, 0x6c},	// 49
+	{0x74, 0x39000000, 0x0008, 0x2d},	// 49
+	{0x74, 0xc0000000, 0x0008, 0x76},	// 49
+	{0x74, 0xc1000000, 0x0008, 0x6d},	// 49
+	{0x74, 0xd5000000, 0x0008, 0x77},	// 49
+	{0x74, 0xd6000000, 0x0008, 0x2c},	// 49
+	{0x74, 0xd7000000, 0x0008, 0x27},	// 49
+	{0x74, 0x38000000, 0x0009, 0x6e},	// 49
+	{0x74, 0x38c00000, 0x000a, 0x3f},	// 49
+	{0x74, 0xd4400000, 0x000a, 0x62},	// 49
+	{0x74, 0xd4800000, 0x000a, 0x3a},	// 49
+	{0x74, 0x38800000, 0x000b, 0x21},	// 49
+	{0x74, 0xd4000000, 0x000b, 0x7a},	// 49
+	{0x74, 0xd4c00000, 0x000b, 0x64},	// 49
+	{0x74, 0xd4e00000, 0x000b, 0x66},	// 49
+	{0x74, 0xd4200000, 0x000c, 0x78},	// 49
+	{0x74, 0x38a00000, 0x000d, 0x67},	// 49
+	{0x74, 0x38a80000, 0x000d, 0x3b},	// 49
+	{0x74, 0xd4300000, 0x000d, 0x70},	// 49
+	{0x74, 0x38b00000, 0x000e, 0x50},	// 49
+	{0x74, 0x38b40000, 0x000e, 0x00},	// 49
+	{0x74, 0x38bc0000, 0x000e, 0x29},	// 49
+	{0x74, 0xd4380000, 0x000e, 0x2f},	// 49
+	{0x74, 0xd43c0000, 0x000e, 0x6b},	// 49
+	{0x74, 0x38b80000, 0x0010, 0x40},	// 49
+	{0x74, 0x38ba0000, 0x0010, 0x45},	// 49
+	{0x74, 0x38b98000, 0x0011, 0x5d},	// 49
+	{0x74, 0x38bb8000, 0x0011, 0x22},	// 49
+	{0x74, 0x38b90000, 0x0012, 0x46},	// 49
+	{0x74, 0x38bb0000, 0x0012, 0x01},	// 49
+	{0x74, 0x38b94000, 0x0013, 0x6a},	// 49
+	{0x74, 0x38bb4000, 0x0013, 0x31},	// 49
+	{0x74, 0x38bb6000, 0x0013, 0x5b},	// 49
+	{0x74, 0x38b96000, 0x0014, 0x5c},	// 49
+	{0x74, 0x38b97000, 0x0015, 0x4b},	// 49
+	{0x74, 0x38b97800, 0x0015, 0x43},	// 49
+	{0x75, 0x60000000, 0x0003, 0x74},	// 43
+	{0x75, 0xa0000000, 0x0003, 0x6e},	// 43
+	{0x75, 0xc0000000, 0x0003, 0x73},	// 43
+	{0x75, 0xe0000000, 0x0003, 0x72},	// 43
+	{0x75, 0x10000000, 0x0004, 0x64},	// 43
+	{0x75, 0x20000000, 0x0004, 0x65},	// 43
+	{0x75, 0x50000000, 0x0004, 0x6c},	// 43
+	{0x75, 0x80000000, 0x0004, 0x70},	// 43
+	{0x75, 0x00000000, 0x0005, 0x62},	// 43
+	{0x75, 0x08000000, 0x0005, 0x20},	// 43
+	{0x75, 0x30000000, 0x0005, 0x69},	// 43
+	{0x75, 0x40000000, 0x0005, 0x61},	// 43
+	{0x75, 0x48000000, 0x0005, 0x67},	// 43
+	{0x75, 0x90000000, 0x0005, 0x63},	// 43
+	{0x75, 0x98000000, 0x0005, 0x6d},	// 43
+	{0x75, 0x38000000, 0x0007, 0x79},	// 43
+	{0x75, 0x3a000000, 0x0008, 0x7a},	// 43
+	{0x75, 0x3c000000, 0x0008, 0x27},	// 43
+	{0x75, 0x3e000000, 0x0008, 0x66},	// 43
+	{0x75, 0x3f000000, 0x0008, 0x6b},	// 43
+	{0x75, 0x3d000000, 0x0009, 0x2c},	// 43
+	{0x75, 0x3b400000, 0x000a, 0x2d},	// 43
+	{0x75, 0x3b800000, 0x000a, 0x6f},	// 43
+	{0x75, 0x3d800000, 0x000a, 0x2e},	// 43
+	{0x75, 0x3dc00000, 0x000a, 0x78},	// 43
+	{0x75, 0x3b000000, 0x000b, 0x77},	// 43
+	{0x75, 0x3bc00000, 0x000b, 0x3a},	// 43
+	{0x75, 0x3b200000, 0x000c, 0x71},	// 43
+	{0x75, 0x3be00000, 0x000c, 0x68},	// 43
+	{0x75, 0x3bf00000, 0x000c, 0x76},	// 43
+	{0x75, 0x3b300000, 0x000d, 0x6a},	// 43
+	{0x75, 0x3b380000, 0x000f, 0x75},	// 43
+	{0x75, 0x3b3a0000, 0x000f, 0x3f},	// 43
+	{0x75, 0x3b3e0000, 0x0010, 0x2f},	// 43
+	{0x75, 0x3b3f0000, 0x0010, 0x21},	// 43
+	{0x75, 0x3b3c8000, 0x0011, 0x01},	// 43
+	{0x75, 0x3b3c0000, 0x0012, 0x5c},	// 43
+	{0x75, 0x3b3c4000, 0x0012, 0x00},	// 43
+	{0x75, 0x3b3d0000, 0x0012, 0x3b},	// 43
+	{0x75, 0x3b3d8000, 0x0012, 0x4a},	// 43
+	{0x75, 0x3b3dc000, 0x0012, 0x29},	// 43
+	{0x75, 0x3b3d4000, 0x0013, 0x54},	// 43
+	{0x75, 0x3b3d6000, 0x0013, 0x5d},	// 43
+	{0x76, 0x80000000, 0x0001, 0x65},	// 26
+	{0x76, 0x40000000, 0x0002, 0x69},	// 26
+	{0x76, 0x00000000, 0x0003, 0x61},	// 26
+	{0x76, 0x30000000, 0x0004, 0x6f},	// 26
+	{0x76, 0x28000000, 0x0005, 0x2e},	// 26
+	{0x76, 0x24000000, 0x0006, 0x20},	// 26
+	{0x76, 0x21000000, 0x0008, 0x27},	// 26
+	{0x76, 0x23000000, 0x0008, 0x79},	// 26
+	{0x76, 0x20000000, 0x0009, 0x75},	// 26
+	{0x76, 0x22000000, 0x0009, 0x73},	// 26
+	{0x76, 0x22800000, 0x000a, 0x72},	// 26
+	{0x76, 0x20800000, 0x000b, 0x2d},	// 26
+	{0x76, 0x20c00000, 0x000b, 0x2c},	// 26
+	{0x76, 0x22c00000, 0x000b, 0x6e},	// 26
+	{0x76, 0x20a00000, 0x000c, 0x67},	// 26
+	{0x76, 0x20b00000, 0x000c, 0x76},	// 26
+	{0x76, 0x20f00000, 0x000c, 0x6c},	// 26
+	{0x76, 0x22e00000, 0x000c, 0x40},	// 26
+	{0x76, 0x22f00000, 0x000c, 0x3a},	// 26
+	{0x76, 0x20e80000, 0x000d, 0x6b},	// 26
+	{0x76, 0x20e00000, 0x000e, 0x62},	// 26
+	{0x76, 0x20e40000, 0x000f, 0x74},	// 26
+	{0x76, 0x20e60000, 0x0010, 0x64},	// 26
+	{0x76, 0x20e70000, 0x0011, 0x2f},	// 26
+	{0x76, 0x20e78000, 0x0012, 0x01},	// 26
+	{0x76, 0x20e7c000, 0x0012, 0x31},	// 26
+	{0x77, 0x00000000, 0x0002, 0x69},	// 39
+	{0x77, 0x60000000, 0x0003, 0x65},	// 39
+	{0x77, 0x80000000, 0x0003, 0x20},	// 39
+	{0x77, 0xa0000000, 0x0003, 0x73},	// 39
+	{0x77, 0xc0000000, 0x0003, 0x68},	// 39
+	{0x77, 0x50000000, 0x0004, 0x61},	// 39
+	{0x77, 0xf0000000, 0x0004, 0x6f},	// 39
+	{0x77, 0x40000000, 0x0005, 0x2e},	// 39
+	{0x77, 0x48000000, 0x0005, 0x77},	// 39
+	{0x77, 0xe0000000, 0x0005, 0x6e},	// 39
+	{0x77, 0xec000000, 0x0007, 0x72},	// 39
+	{0x77, 0xea000000, 0x0008, 0x2c},	// 39
+	{0x77, 0xeb000000, 0x0008, 0x6c},	// 39
+	{0x77, 0xef000000, 0x0008, 0x79},	// 39
+	{0x77, 0xe9000000, 0x0009, 0x63},	// 39
+	{0x77, 0xee800000, 0x0009, 0x62},	// 39
+	{0x77, 0xe8800000, 0x000a, 0x3a},	// 39
+	{0x77, 0xe9800000, 0x000a, 0x6d},	// 39
+	{0x77, 0xe9c00000, 0x000a, 0x27},	// 39
+	{0x77, 0xee000000, 0x000a, 0x64},	// 39
+	{0x77, 0xe8000000, 0x000b, 0x66},	// 39
+	{0x77, 0xe8200000, 0x000b, 0x5d},	// 39
+	{0x77, 0xe8400000, 0x000b, 0x21},	// 39
+	{0x77, 0xe8e00000, 0x000b, 0x6b},	// 39
+	{0x77, 0xee400000, 0x000b, 0x2d},	// 39
+	{0x77, 0xe8700000, 0x000c, 0x67},	// 39
+	{0x77, 0xe8c00000, 0x000c, 0x3f},	// 39
+	{0x77, 0xe8d00000, 0x000c, 0x74},	// 39
+	{0x77, 0xee700000, 0x000c, 0x70},	// 39
+	{0x77, 0xe8600000, 0x000d, 0x00},	// 39
+	{0x77, 0xe8680000, 0x000d, 0x75},	// 39
+	{0x77, 0xee680000, 0x000d, 0x29},	// 39
+	{0x77, 0xee640000, 0x000e, 0x6a},	// 39
+	{0x77, 0xee620000, 0x000f, 0x71},	// 39
+	{0x77, 0xee600000, 0x0010, 0x2f},	// 39
+	{0x77, 0xee610000, 0x0011, 0x3b},	// 39
+	{0x77, 0xee61c000, 0x0012, 0x5b},	// 39
+	{0x77, 0xee618000, 0x0013, 0x01},	// 39
+	{0x77, 0xee61a000, 0x0013, 0x42},	// 39
+	{0x78, 0x40000000, 0x0002, 0x70},	// 39
+	{0x78, 0xc0000000, 0x0002, 0x74},	// 39
+	{0x78, 0xa0000000, 0x0003, 0x20},	// 39
+	{0x78, 0x00000000, 0x0004, 0x69},	// 39
+	{0x78, 0x20000000, 0x0004, 0x61},	// 39
+	{0x78, 0x80000000, 0x0004, 0x63},	// 39
+	{0x78, 0x10000000, 0x0005, 0x75},	// 39
+	{0x78, 0x38000000, 0x0005, 0x65},	// 39
+	{0x78, 0x98000000, 0x0005, 0x2d},	// 39
+	{0x78, 0x18000000, 0x0006, 0x66},	// 39
+	{0x78, 0x34000000, 0x0006, 0x6f},	// 39
+	{0x78, 0x90000000, 0x0006, 0x2e},	// 39
+	{0x78, 0x1c000000, 0x0007, 0x2c},	// 39
+	{0x78, 0x1e000000, 0x0007, 0x6d},	// 39
+	{0x78, 0x32000000, 0x0007, 0x79},	// 39
+	{0x78, 0x31000000, 0x0008, 0x39},	// 39
+	{0x78, 0x95000000, 0x0008, 0x27},	// 39
+	{0x78, 0x96000000, 0x0008, 0x71},	// 39
+	{0x78, 0x30000000, 0x0009, 0x73},	// 39
+	{0x78, 0x94000000, 0x0009, 0x3a},	// 39
+	{0x78, 0x97000000, 0x0009, 0x68},	// 39
+	{0x78, 0x30c00000, 0x000a, 0x3f},	// 39
+	{0x78, 0x94800000, 0x000a, 0x6c},	// 39
+	{0x78, 0x97800000, 0x000a, 0x77},	// 39
+	{0x78, 0x30800000, 0x000b, 0x41},	// 39
+	{0x78, 0x94c00000, 0x000b, 0x78},	// 39
+	{0x78, 0x94e00000, 0x000b, 0x62},	// 39
+	{0x78, 0x97e00000, 0x000b, 0x29},	// 39
+	{0x78, 0x30b00000, 0x000c, 0x2f},	// 39
+	{0x78, 0x30a00000, 0x000d, 0x34},	// 39
+	{0x78, 0x30a80000, 0x000d, 0x21},	// 39
+	{0x78, 0x97c00000, 0x000d, 0x67},	// 39
+	{0x78, 0x97c80000, 0x000d, 0x00},	// 39
+	{0x78, 0x97d80000, 0x000d, 0x3b},	// 39
+	{0x78, 0x97d20000, 0x000f, 0x76},	// 39
+	{0x78, 0x97d40000, 0x000f, 0x46},	// 39
+	{0x78, 0x97d60000, 0x000f, 0x45},	// 39
+	{0x78, 0x97d00000, 0x0010, 0x01},	// 39
+	{0x78, 0x97d10000, 0x0010, 0x43},	// 39
+	{0x79, 0x80000000, 0x0001, 0x20},	// 45
+	{0x79, 0x00000000, 0x0003, 0x6f},	// 45
+	{0x79, 0x30000000, 0x0004, 0x73},	// 45
+	{0x79, 0x50000000, 0x0004, 0x2e},	// 45
+	{0x79, 0x48000000, 0x0005, 0x2c},	// 45
+	{0x79, 0x60000000, 0x0005, 0x65},	// 45
+	{0x79, 0x70000000, 0x0005, 0x27},	// 45
+	{0x79, 0x24000000, 0x0006, 0x61},	// 45
+	{0x79, 0x28000000, 0x0006, 0x69},	// 45
+	{0x79, 0x2c000000, 0x0006, 0x64},	// 45
+	{0x79, 0x44000000, 0x0006, 0x6e},	// 45
+	{0x79, 0x6c000000, 0x0006, 0x3a},	// 45
+	{0x79, 0x7c000000, 0x0006, 0x6c},	// 45
+	{0x79, 0x20000000, 0x0007, 0x77},	// 45
+	{0x79, 0x68000000, 0x0007, 0x74},	// 45
+	{0x79, 0x6a000000, 0x0007, 0x6d},	// 45
+	{0x79, 0x7a000000, 0x0007, 0x2d},	// 45
+	{0x79, 0x23000000, 0x0008, 0x62},	// 45
+	{0x79, 0x40000000, 0x0008, 0x3f},	// 45
+	{0x79, 0x41000000, 0x0008, 0x72},	// 45
+	{0x79, 0x42000000, 0x0008, 0x70},	// 45
+	{0x79, 0x43000000, 0x0008, 0x66},	// 45
+	{0x79, 0x79000000, 0x0008, 0x63},	// 45
+	{0x79, 0x22400000, 0x000a, 0x3b},	// 45
+	{0x79, 0x22800000, 0x000a, 0x4a},	// 45
+	{0x79, 0x78000000, 0x000a, 0x68},	// 45
+	{0x79, 0x78400000, 0x000a, 0x21},	// 45
+	{0x79, 0x78c00000, 0x000a, 0x67},	// 45
+	{0x79, 0x22000000, 0x000b, 0x29},	// 45
+	{0x79, 0x22e00000, 0x000b, 0x2f},	// 45
+	{0x79, 0x78a00000, 0x000b, 0x5d},	// 45
+	{0x79, 0x22300000, 0x000c, 0x6b},	// 45
+	{0x79, 0x22c00000, 0x000c, 0x01},	// 45
+	{0x79, 0x22d00000, 0x000c, 0x75},	// 45
+	{0x79, 0x78900000, 0x000c, 0x00},	// 45
+	{0x79, 0x22200000, 0x000d, 0x7a},	// 45
+	{0x79, 0x78880000, 0x000d, 0x22},	// 45
+	{0x79, 0x222c0000, 0x000e, 0x6a},	// 45
+	{0x79, 0x78840000, 0x000e, 0x32},	// 45
+	{0x79, 0x22280000, 0x000f, 0x79},	// 45
+	{0x79, 0x222a0000, 0x000f, 0x78},	// 45
+	{0x79, 0x78800000, 0x0010, 0x76},	// 45
+	{0x79, 0x78810000, 0x0010, 0x54},	// 45
+	{0x79, 0x78820000, 0x0010, 0x45},	// 45
+	{0x79, 0x78830000, 0x0010, 0x50},	// 45
+	{0x7a, 0x80000000, 0x0002, 0x65},	// 37
+	{0x7a, 0x20000000, 0x0003, 0x61},	// 37
+	{0x7a, 0x60000000, 0x0003, 0x7a},	// 37
+	{0x7a, 0xc0000000, 0x0003, 0x20},	// 37
+	{0x7a, 0xe0000000, 0x0003, 0x69},	// 37
+	{0x7a, 0x10000000, 0x0004, 0x6c},	// 37
+	{0x7a, 0x40000000, 0x0004, 0x79},	// 37
+	{0x7a, 0x50000000, 0x0005, 0x6f},	// 37
+	{0x7a, 0x00000000, 0x0006, 0x63},	// 37
+	{0x7a, 0x08000000, 0x0006, 0x2c},	// 37
+	{0x7a, 0x0c000000, 0x0006, 0x2e},	// 37
+	{0x7a, 0x58000000, 0x0006, 0x77},	// 37
+	{0x7a, 0x04000000, 0x0007, 0x27},	// 37
+	{0x7a, 0x06000000, 0x0008, 0x3a},	// 37
+	{0x7a, 0x07000000, 0x0008, 0x74},	// 37
+	{0x7a, 0x5d000000, 0x0008, 0x6d},	// 37
+	{0x7a, 0x5c000000, 0x0009, 0x6b},	// 37
+	{0x7a, 0x5e000000, 0x0009, 0x2d},	// 37
+	{0x7a, 0x5e800000, 0x0009, 0x75},	// 37
+	{0x7a, 0x5f800000, 0x0009, 0x62},	// 37
+	{0x7a, 0x5c800000, 0x000b, 0x73},	// 37
+	{0x7a, 0x5ca00000, 0x000b, 0x2f},	// 37
+	{0x7a, 0x5ce00000, 0x000b, 0x64},	// 37
+	{0x7a, 0x5f200000, 0x000b, 0x70},	// 37
+	{0x7a, 0x5f600000, 0x000b, 0x3f},	// 37
+	{0x7a, 0x5cc00000, 0x000c, 0x68},	// 37
+	{0x7a, 0x5f000000, 0x000c, 0x40},	// 37
+	{0x7a, 0x5f400000, 0x000c, 0x29},	// 37
+	{0x7a, 0x5cd00000, 0x000d, 0x21},	// 37
+	{0x7a, 0x5f180000, 0x000d, 0x76},	// 37
+	{0x7a, 0x5f500000, 0x000d, 0x67},	// 37
+	{0x7a, 0x5cd80000, 0x000e, 0x66},	// 37
+	{0x7a, 0x5cdc0000, 0x000e, 0x72},	// 37
+	{0x7a, 0x5f100000, 0x000e, 0x71},	// 37
+	{0x7a, 0x5f140000, 0x000e, 0x6e},	// 37
+	{0x7a, 0x5f580000, 0x000e, 0x01},	// 37
+	{0x7a, 0x5f5c0000, 0x000e, 0x5d},	// 37
+	{0x7b, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7b, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7c, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7c, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7d, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7d, 0x80000000, 0x0001, 0x00},	// 2
+	{0x7e, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7e, 0x80000000, 0x0001, 0x01},	// 2
+	{0x7f, 0x00000000, 0x0001, 0x01},	// 2
+	{0x7f, 0x80000000, 0x0001, 0x01}	// 2
+};
diff -Naur vdr-1.7.27.orig/libsi/Makefile vdr-1.7.27/libsi/Makefile
--- vdr-1.7.27.orig/libsi/Makefile	2012-04-11 19:26:39.353894320 +0200
+++ vdr-1.7.27/libsi/Makefile	2012-04-11 19:26:59.834745650 +0200
@@ -24,7 +24,7 @@ 
 
 ### The object files (add further files here):
 
-OBJS = util.o si.o section.o descriptor.o
+OBJS = util.o si.o section.o descriptor.o freesat.o
 
 ### Implicit rules:
 
diff -Naur vdr-1.7.27.orig/libsi/si.c vdr-1.7.27/libsi/si.c
--- vdr-1.7.27.orig/libsi/si.c	2012-04-11 19:26:39.345893988 +0200
+++ vdr-1.7.27/libsi/si.c	2012-04-11 19:26:59.834745650 +0200
@@ -17,6 +17,7 @@ 
 #include <stdlib.h> // for broadcaster stupidity workaround
 #include <string.h>
 #include "descriptor.h"
+#include "freesat.h"
 
 namespace SI {
 
@@ -405,6 +406,8 @@ 
   return false;
 }
 
+#include <stdio.h>
+
 // originally from libdtv, Copyright Rolf Hakenes <hakenes@hippomi.de>
 void String::decodeText(char *buffer, int size) {
    const unsigned char *from=data.getData(0);
@@ -415,6 +418,21 @@ 
       return;
       }
    bool singleByte;
+
+
+   if ( from[0] == 0x1f ) {
+       char *temp = freesat_huffman_decode(from, len);
+       if (temp ) {
+           len = strlen(temp);
+           len = len < size - 1 ? len : size - 1;
+           strncpy(buffer, temp, len);
+           buffer[len] = 0;
+           free(temp);
+           return;
+       }
+   }
+
+
    const char *cs = getCharacterTable(from, len, &singleByte);
    // FIXME Need to make this UTF-8 aware (different control codes).
    // However, there's yet to be found a broadcaster that actually
@@ -443,6 +461,7 @@ 
 
 void String::decodeText(char *buffer, char *shortVersion, int sizeBuffer, int sizeShortVersion) {
    const unsigned char *from=data.getData(0);
+   unsigned char *temp = NULL;
    char *to=buffer;
    char *toShort=shortVersion;
    int IsShortName=0;
@@ -452,6 +471,14 @@ 
       *toShort = '\0';
       return;
       }
+
+
+   if ( from[0] == 0x1f ) {
+       temp = ( unsigned char *)freesat_huffman_decode(from, len);
+       from = temp;
+   }
+
+
    bool singleByte;
    const char *cs = getCharacterTable(from, len, &singleByte);
    // FIXME Need to make this UTF-8 aware (different control codes).
@@ -489,6 +516,7 @@ 
       if (convertCharacterTable(shortVersion, strlen(shortVersion), convShortVersion, sizeof(convShortVersion), cs))
          strncpy(shortVersion, convShortVersion, strlen(convShortVersion) + 1);
    }
+   if (temp) free(temp);
 }
 
 Descriptor *Descriptor::getDescriptor(CharArray da, DescriptorTagDomain domain, bool returnUnimplemetedDescriptor) {
diff -Naur vdr-1.7.27.orig/README.freesat vdr-1.7.27/README.freesat
--- vdr-1.7.27.orig/README.freesat	1970-01-01 01:00:00.000000000 +0100
+++ vdr-1.7.27/README.freesat	2012-04-12 09:12:23.756072483 +0200
@@ -0,0 +1,37 @@ 
+Freesat EPG patch for vdr
+Update and Debianisation by Tony Houghton
+
+Installation:
+
+1. Apply the patch
+2. make clean && make vdr
+3. Install vdr
+
+Restart VDR - enjoy a 7 day EPG with Freesat.
+
+Updates:
+
+Former external Freesat Huffman tables are in their final version.
+For speed, installation handling and simplification these tables have now moved into the program
+code and will be loaded upon startup along with the data-section of the executable.
+For readability purposes still a short initialisation is kept.
+
+Advance configuration:
+
+1. Edit libsi/Makefile and add the following to DEFINES:
+
+  FREESAT_DATA_DIRECTORY   - Directory where the freesat.tX files are stored
+  FREESAT_ARCHIVE_MESSAGES - Store raw huffman strings in /var/tmp/pid/freesat.X
+  FREESAT_PRINT_MISSED_DECODING - Append missed hexcodes to end of string
+  FREESAT_NO_SYSLOG             - Disable use of isyslog
+
+Credits:
+
+Original code from MythTV
+(Huffman codes updated with data from mitsubushi, Jochen Mann and dom)
+Huffman codes now extracted from vdr-plugin-eepg
+
+Enjoy,
+
+dom /at/ suborbital.org.uk
+h /at/ realh.co.uk

Privacy Policy