Ajedrez inteligente
Introducción
La idea principal del proyecto ha sido el desarrollo de un programa de ajedrez inteligente que permita a una persona jugar sola contra una IA que detecta las posición de las piezas en el teclado y los movimientos que realiza el jugador y que muestra mediante una pantalla el movimiento que hace.
Junto al código principal de partida también se ha desarrollado un código de reloj de ajedrez para uno o dos jugadores y un código alternativo de partida en el que en lugar de leerse las posiciones de las fichas en un tablero los movimientos se introducen por teclado.
Componentes
Para el desarrollo del proyecto se utilizaron los siguientes componentes:
- Placa Arduino Uno
- Placa Arduino Mega
- Piezas de ajedrez magnéticas
- 2 pantallas LCD 16×2 con I2C (unos 4€)
- 64 interruptores de lengüeta (unos 8€)
- 3 interruptores
- Tablero de cartón pluma (unos 2€)
- Cableado (unos 3€)
Como varios de los materiales y componentes utilizados para el proyecto han sido reutilizados en lugar de comprados, el coste de desarrollo ha sido de unos 17€.
Desarrollo y montaje
Tablero
En este proyecto el programa detecta la posición de las piezas magnéticas en el tablero mediante el uso de interruptores de lengüeta, que dejan pasar la electricidad si no hay un imán sobre ellos. Esto conllevó el problema de que son necesarios 64 interruptores de lengüeta y con estos 64 pines, además de aquellos que necesite la pantalla LCD.
Una posible solución a este problema es añadir registros de desplazamiento, pero como serían necesarios 8 para llegar a cubrir todas las piezas y el software se complicaría. Pero se nos ocurrió una idea: ¿Qué solución ingenieril ya inventada existe para detectar las pulsaciones de botones (ya que al fin y al cabo los interruptores de lengüeta son botones) que se encuentran en una alineados de forma matricial? Un teclado matricial. Así que se optó por construir el tablero como si se tratase de un teclado matricial adaptado a nuestro problema.
Problemas con el tablero
El proyecto final, tenía varios problemas relacionados con lo delicados que eran los interruptores magnéticos. El primer problema fue que los interruptores no eran muy potentes y el imán debía estar a distancias muy cortas para detectar el campo magnético. Por lo que tuvimos que modificar el tablero que estaba ya hecho para introducir los interruptores por encima del tablero, lo que provocó que el prototipo quedase poco estético y organizado. Además a cada transporte o a cada prueba se rompían más de ellos. Y aunque se comenzó pudiendo detectar casi todas las posiciones menos alguna posición, al final solo funcionaron unos pocos interruptores, permitiéndonos únicamente grabar vídeos con peones.
Para solucionar este problema, la solución ideal sería haber comprado unos interruptores de lengüeta mejores, ya que se ha visto en vídeos que normalmente no son tan frágiles y son mucho más potentes que los nuestros. Con esos interruptores podríamos haber montado un hardware más organizado, y se hubiese conseguido un proyecto más estético y funcional. A parte de este componente existen otros que nos pueden servir, como los sensores de efecto Hall, que realizan la medición a distancia y existen sensores digitales de tipo Switch que se activan al acercar el polo, y se desactivan al retirar el polo.
Algoritmo de ajedrez
Uno de los problemas a los que se tuvo que hacer frente en este proyecto fue encontrar un algoritmo de ajedrez de código abierto lo suficientemente sencillo y ligero como para funcionar en Arduino.
Al final se a usado como base CHESSuino, un programa de ajedrez para Arduino Mega desarrollado por Diego Cueva, que está a su vez basado en Micro-Max, uno de los programa de ajedrez más pequeños creado por Harm Geert Muller.
Reloj competitivo
Para el desarrollo del reloj competitivo se han usado:
- 2 Pantallas LCD 16×2 con I2C
- 3 Botones de distintos colores
- Placa Arduino Uno
Para el controlar el tiempo de cada jugador hemos usado interrupciones en el juego. Cuando se pulsa un botón, después de haber decidido el modo de juego (jugador vs jugador o jugador vs IA), se produce una interrupción que cambia el valor de una variable, la cual usamos para saber a quién disminuir el tiempo.
Para el tratamiento de las interrupciones se ha usado una lógica para evitar fallos. Se ha realizado un mapa de Karnaugh para elaboración.
while ((digitalRead(4) == HIGH= || (!ju1 && !ju2))
En la siguiente imagen se muestra cómo se han conectado los pulsadores y la pantalla LDC en la placa de Arduino UNO.
Ejecutar 2 tareas individuales
En el primer prototipo, conectamos 2 placas de Arduino para compartir información entre ellas. Las dos tarjetas estaban programadas en una configuración de Escritor maestro / Receptor Esclavo a través del protocolo serie síncrono I2C. Esta configuración fue descartada ya que necesitábamos los pines 5 (SCL) y el pin 4 (SDA) para las pantallas LCD.
En el prototipo final utilizamos el mismo botón para leer en los dos Arduino para ello necesitamos tener un ground común, y conectar el botón en paralelo.
En la siguiente imagen se muestra cómo se han conectado los pulsadores tanto a la placa Arduino que ejecuta el algoritmo de ajedrez como a la placa que ejecuta el programa de reloj.
Uso de CHESSuino
Una vez elegido el modo de juego para un jugador vs máquina, se sincronizarán ambos arduinos para empezar una partida. Las imágenes siguientes muestran un ejemplo de ello.
Una vez pulsado el botón de comenzar (botón central) empieza la partida.
Ejemplo de movimiento válido
Material visual
Detección de movimientos
En el siguiente vídeo se puede ver una demostración del funcionamiento del proyecto. Cuando se detecta un movimiento, este aparece en la esquina inferior izquierda de la pantalla LCD y el programa comprueba si es válido. Si el movimiento es válido, el movimiento introducido por el jugador pasará a la esquina superior izquierda de la pantalla, mientras que el movimiento respuesta de la máquina aparecerá a la derecha. En el caso de que el movimiento no fuera válido, entonces el programa lo ignoraría y esperaría a que se introdujera un movimiento legal, como se puede ver en la segunda mitad del vídeo.
Coordinación de los dos códigos
En el siguiente vídeo podemos ver como se hace la configura inicial de jugar una partida. Conectando ambos Arduinos (poniendo los componentes en paralelo y controlando en ambos códigos el funcionamiento de los botones) para que ambos sepan si juegan 2 jugadores o es contra la IA.
En el siguiente vídeo se puede ver como se juega una partida a través del puerto serie (enviándole los movimientos a través del ordenador). Para ayudar al desarrollo de la partida se imprimirá por pantalla el estado actual de la partida. Este prototipo es totalmente funcional y se pueden desarrollar partidas enteras. Este prototipo se diseño a modo de depuración del otro prototipo.
Comer fichas
En el siguiente prototipo se puede ver el prototipo final en el que se pueden mover todos los peones blancos, y te da una respuesta del enemigo que es el negro. Algunas de las posiciones de la primera fila llegaron a funcionar en pruebas anteriores que no pudieron ser grabadas debido a los problemas descritos anteriormente. Por ejemplo se pudieron hacer movimientos con una torre, uno de los caballos también se podía mover a una única posición (ya que de la tercera fila también había algún interruptor roto) , así como la reina y el rey una posición hacia delante. A pesar de que funcionase un movimiento la partida más adelante era insostenible porque no se detectaban muchos movimientos.
Código
El siguiente código es el de la versión del programa que detecta los movimientos realizados en el tablero.
/***************************************************************************/
/* CHESSimple */
/***************************************************************************/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <LinkedListLib.h>
#include "pieza.h"
#include "CHESSimple.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
int adc_key_val[5] ={50, 200, 400, 600, 800 }; /* Analog values from keypad */
const byte countRows = 8; // Nº de filas
const byte countColumns = 8; // Nº de columnas
const byte rowsPins[countRows] = { 38, 40, 42, 44, 46, 48, 50, 52 }; // Pins de filas
const byte columnsPins[countColumns] = {39, 41, 43, 45, 47 , 49 , 51, 53}; // Pins de columnas
boolean matrix[8][8]; // Verdadero si hay pieza
pieza piezas[32];
boolean reset1=false;
boolean reset2=false;
const unsigned long period = 50;
unsigned long prevMillis = 0;
byte iRow = 0, iCol = 0; // Posición inicial
byte jRow = 0, jCol = 0; // Siguiente posición
boolean antes = false; // Verdadero si se ha levantado una ficha
boolean comerb = false; // Verdadero si se ha comido una ficha
byte comRow = 0, comCol = 0;
int keys[countRows][countColumns] = {
{ 1, 2, 3, 4, 5, 6, 7, 8},
{ 9, 10, 11, 12, 13, 14, 15, 16},
{ 17, 18, 19, 20, 21, 22, 23,24},
{ 25, 26, 27, 28, 29, 30, 31, 32},
{ 33, 34, 35, 36, 37, 38, 39, 40},
{ 41, 42, 43, 44, 45, 46, 47, 48},
{ 49, 50, 51, 52, 53, 54, 55, 56},
{ 57, 58, 59, 60, 61, 62, 63, 64}
};
//#define SPEAKER_OUT 2 /* Pin to connect speaker */
void setup(){
Serial.begin(9600);
Serial.println(" *** CHESSimple ***");
lcd.init();
lcd.backlight();
lcd.clear();
lcd.begin(16, 2);
lastH[0] = 0;
pinMode(13, OUTPUT);
cargarPiezas();
// Columnas en alta impedancia
for (byte col = 0; col < countColumns; col++){
pinMode(columnsPins[col], INPUT);
digitalWrite(columnsPins[col], HIGH);
pinMode(rowsPins[col], INPUT_PULLUP);
}
/* for (byte col = 0; col < countColumns; col++){
// Poner columna a LOW
pinMode(columnsPins[col], INPUT);
digitalWrite(columnsPins[col], HIGH);
// Barrer todas las filas comprobando pulsaciones
for (byte row = 0; row < countRows; row++) {
if (digitalRead(columnsPins[row]) == LOW) {
matrix[row][col]=true;
}else{
matrix[row][col]=false;
}
}
}*/
for (int i=0; i< countColumns; i++){
for (int j= 0; j< countRows; j++){
matrix[i][j]=true;
}
}
/* matrix[0][0]=false;
matrix[0][1]=false;
matrix[0][2]=false;
matrix[0][3]=false;
matrix[0][4]=false;
matrix[0][5]=false;
matrix[0][6]=false;
matrix[0][7]=false;*/
matrix[1][0]=false;
matrix[1][1]=false;
matrix[1][2]=false;
matrix[1][3]=false;
matrix[1][4]=false;
matrix[1][5]=false;
matrix[1][6]=false;
matrix[1][7]=false;
matrix[6][0]=false;
matrix[6][1]=false;
matrix[6][2]=false;
matrix[6][3]=false;
matrix[6][4]=false;
matrix[6][5]=false;
matrix[6][6]=false;
matrix[6][7]=false;
}
void loop(){
int r;
digitalWrite(13, LOW);
// Print last movements
printLastMovs();
// Take move from human
x1=x2=y1=y2=-1;
takeMove();
lcd.setCursor(10, 1);
lcd.print("Think"); /* Turn for ARDUINO */
K=*c-16*c[1]+799,L=c[2]-16*c[3]+799; /* parse entered move */
N=0;
T=0x3F; /* T=Computer Play strength */
bkp(); /* Save the board just in case */
r = D(-I,I,Q,O,1,3); /* Check & do the human movement */
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print("Lose ");
gameOver();
}
if(k == 0x10){ /* The flag turn must change to 0x08 */
lcd.setCursor(10, 1);
lcd.print(" ");
Serial.println("Movimiento no valido");
return;
}
strcpy(lastH, c); /* Valid human movement */
mn++; /* Next move */
searchDataBase(); /* Search in database */
if(c[0]){ /* Movement found */
lcd.setCursor(10, 1);
lcd.print(c);
lcd.print(" *");
K=*c-16*c[1]+799,L=c[2]-16*c[3]+799; /* parse move found */
N=0;
T=0x3F; /* T=Computer Play strength */
r = D(-I,I,Q,O,1,3); /* Check & do*/
if( !(r>-I+1) ) gameOver();
if(k == 0x08){
lcd.setCursor(10, 1);
lcd.print("ERR DB");
gameOver();
}
strcpy(lastM, c); /* Valid ARDUINO movement */
Serial.println("movimiento valido");
//delay(1000);
return;
}
K=I;
N=0;
T=0x3F; /* T=Computer Play strength */
r = D(-I,I,Q,O,1,3); /* Think & do*/
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print("Lose*");
gameOver();
}
if(k == 0x08){ /* Some times the algorithm do not */
lcd.setCursor(10, 1); /* execute the move and do not change */
lcd.print("ERR 3 "); /* the turn flag */
gameOver(); /* 1. b1c3 c7c5? 2. f2f4? */
}
strcpy(lastM, c); /* Valid ARDUINO movement */
strcpy(c, "a1a1"); /* Execute a invalid move to check score again */
r = D(-I,I,Q,O,1,3);
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print(lastM);
lcd.print(" ");
gameOver();
}
if(k == 0x08){ /* Some times the algorithm do not */
lcd.setCursor(10, 1); /* execute the move and do not change */
lcd.print("ERR 3 "); /* the turn flag */
gameOver(); /* 1. b1c3 c7c5? 2. f2f4? */
}
delay(500);
}
void cargarPiezas() {
//TORRES
//BLANCAS
piezas[0]= pieza(1, true);
piezas[1]= pieza(8, true);
//NEGRAS
piezas[2]= pieza(57, true);
piezas[3]= pieza(64, true);
//ALFILES
//BLANCAS
piezas[4]= pieza(3, true);
piezas[5]= pieza(6, true);
//NEGRAS
piezas[6]= pieza(59, true);
piezas[7]= pieza(62, true);
//CABALLO
//BLANCAS
piezas[8]= pieza(2, true);
piezas[9]= pieza(7, true);
//NEGRAS
piezas[10]= pieza(63, true);
piezas[11]= pieza(58, true);
//REY
//BLANCAS
piezas[12]= pieza(5, true);
//NEGRAS
piezas[13]= pieza(61, true);
//REINA
//BLANCAS
piezas[14]= pieza(4, true);
//NEGRAS
piezas[15]= pieza(60, true);
//PEON
//BLANCAS
piezas[16]= pieza(9, true);
piezas[17]= pieza(10, true);
piezas[18]= pieza(11, true);
piezas[19]= pieza(12, true);
piezas[20]= pieza(13, true);
piezas[21]= pieza(14, true);
piezas[22]= pieza(15, true);
piezas[23]= pieza(16, true);
//NEGRAS
piezas[24]= pieza(49, true);
piezas[25]= pieza(50, true);
piezas[26]= pieza(51, true);
piezas[27]= pieza(52, true);
piezas[28]= pieza(53, true);
piezas[29]= pieza(54, true);
piezas[30]= pieza(55, true);
piezas[31]= pieza(56, true);
}
void takeMove(){
if (millis() - prevMillis > period){ // Espera no bloqueante
prevMillis = millis();
while (!readKeypad()){
while(millis() - prevMillis > period){ // Espera no bloqueante
prevMillis = millis();}} // Detección de tecla pulsada
Serial.println("HAS PULSADO TECLA");
for (int i = 0; i < 32 ; i++) {
if (piezas[i].getPosicion() == keys[iRow][iCol]) {
piezas[i].setPosicion(keys[jRow][jCol]);
Serial.println(piezas[i].getPosicion());
}
}
}
Serial.print("Se ha movido ficha de ");
Serial.print(jRow);
Serial.print(" : ");
Serial.print(jCol);
Serial.print(" a ");
Serial.print(iRow);
Serial.print(" : ");
Serial.println(iCol);
x1 = jCol;
y1 = jRow;
x2 = iCol;
y2 = iRow;
reset1=false; reset2=false;
printMove();
c[0] = x1+'a';
c[1] = y1+'1';
c[2] = x2+'a';
c[3] = y2+'1';
c[4] = 0;
}
// Leer el estado del teclado
bool readKeypad() {
int piezas = 0;
// Barrido de columnas
for (byte col = 0; col < countColumns; col++){
// Poner columna a LOW
/* for(byte col2 = 0; col2 < countColumns; col2++){
// Devolver la columna a alta impedancia
digitalWrite(columnsPins[col2], HIGH);
}
*/
pinMode(columnsPins[col], OUTPUT);
digitalWrite(columnsPins[col], LOW);
// Barrer todas las filas comprobando pulsaciones
for (byte row = 0; row < countRows; row++) {
/*if(digitalRead(rowsPins[row])== LOW){
Serial.print("Posicion con pieza: ");
Serial.print(row);
Serial.print(" ");
Serial.print(col);
Serial.print(": ");
Serial.println(digitalRead(rowsPins[row])); delay(500);
} */
if (digitalRead(rowsPins[row]) == LOW) {
piezas++;
}
// Se comprueba si ya no hay una ficha
if (digitalRead(rowsPins[row]) != matrix[row][col] && (row!=0) && (row!=6)) {
matrix[row][col]= !matrix[row][col];
if (digitalRead(rowsPins[row]) == HIGH) {
// Si ya se ha levantado una ficha
if(antes==true){
// Serial.println("Se ha comido una ficha");
comerb=true;
antes=false;
comRow = jRow;
comCol = jCol;
}else{
antes = true;
}
Serial.print("Se ha levantado una ficha"); Serial.print(row);Serial.println(col);
jRow = row;
jCol = col;
reset1 = true;
break;
} else if(digitalRead(rowsPins[row]) == LOW){
iRow = row;
iCol = col;
reset2 = true;
antes = false;
Serial.print("Se ha dejado la ficha: "); Serial.print(row);Serial.println(col);
break;
}
}
}
// Devolver la columna a alta impedancia
digitalWrite(columnsPins[col], HIGH);
pinMode(columnsPins[col], INPUT);
}
if (comerb == true) {
comer();
}
/* Serial.print("Sale: ");
Serial.println(rst1 && rst2);
Serial.print("PosSalida: ");
Serial.print(iRow);
Serial.print(" ");
Serial.println(iCol);
Serial.print("PosEntrada: ");
Serial.print(jRow);
Serial.print(" ");
Serial.println(jCol);
delay(2000);*/
if(iRow==jRow && iCol==jCol){
/*reset1=false;*/ reset2=false;
}
return reset1 && reset2;
}
void comer() {
comerb = false;
for (int i = 0; i < 32 ; i++) {
if (piezas[i].getPosicion() == keys[comRow][comCol]) {
piezas[i].setVida(true);
}
}
}
void printMove(){
lcd.setCursor(4, 1);
if(x1>=0) lcd.print((char)(x1+'a')); else lcd.print('_');
if(y1>=0) lcd.print((char)(y1+'1')); else lcd.print('_');
if(x2>=0) lcd.print((char)(x2+'a')); else lcd.print('_');
if(y2>=0) lcd.print((char)(y2+'1')); else lcd.print('_');
}
void printMN(int n, int y){
if(n<=9){
lcd.setCursor(1, y);
}else{
lcd.setCursor(0, y);
}
lcd.print(n);
lcd.print('.');
}
/* User interface routines */
void myputchar(char c) {
Serial.print(c);
}
void myputs(const char *s) {
while(*s) myputchar(*s++);
myputchar('\n');
}
char mygetchar(void) {
while(Serial.available() <= 0);
return (char)Serial.read();
}
unsigned short myrand(void) {
unsigned short r = (unsigned short)(seed%MYRAND_MAX);
return r=((r<<11)+(r<<7)+r)>>1;
}
/* recursive minimax search */
/* (q,l)=window, e=current eval. score, */
/* E=e.p. sqr.z=prev.dest, n=depth; return score */
short D(short q, short l, short e, unsigned char E, unsigned char z, unsigned char n){
short m,v,i,P,V,s;
unsigned char t,p,u,x,y,X,Y,H,B,j,d,h,F,G,C;
signed char r;
if (++Z>30) { /* stack underrun check */
breakpoint=1; /* AVR Studio 4 Breakpoint for stack underrun */
myputchar('u');
--Z;return e;
}
digitalWrite(13, (ledv++)%8?0:1);
q--; /* adj. window: delay bonus */
k^=24; /* change sides */
d=Y=0; /* start iter. from scratch */
X=myrand()&~M; /* start at random field */
W(d++<n||d<3|| /* iterative deepening loop */
z&K==I&&(N<T&d<98|| /* root: deepen upto time */
(K=X,L=Y&~M,d=3))) /* time's up: go do best */
{x=B=X; /* start scan at prev. best */
h=Y&S; /* request try noncastl. 1st*/
P=d<3?I:D(-l,1-l,-e,S,0,d-3); /* Search null move */
m=-P<l|R>35?d>2?-I:e:-P; /* Prune or stand-pat */
++N; /* node count (for timing) */
do{
u=b[x]; /* scan board looking for */
if(u&k){ /* own piece (inefficient!)*/
r=p=u&7; /* p = piece type (set r>0) */
j=o[p+16]; /* first step vector f.piece*/
W(r=p>2&r<0?-r:-o[++j]) /* loop over directions o[] */
{A: /* resume normal after best */
y=x;F=G=S; /* (x,y)=move, (F,G)=castl.R*/
do{ /* y traverses ray, or: */
H=y=h?Y^h:y+r; /* sneak in prev. best move */
if(y&M)break; /* board edge hit */
m=E-S&b[E]&&y-E<2&E-y<2?I:m; /* bad castling */
if(p<3&y==E)H^=16; /* shift capt.sqr. H if e.p.*/
t=b[H];if(t&k|p<3&!(y-x&7)-!t)break; /* capt. own, bad pawn mode */
i=37*w[t&7]+(t&192); /* value of capt. piece t */
m=i<0?I:m; /* K capture */
if(m>=l&d>1)goto C; /* abort on fail high */
v=d-1?e:i-p; /* MVV/LVA scoring */
if(d-!t>1) /* remaining depth */
{v=p<6?b[x+8]-b[y+8]:0; /* center positional pts. */
b[G]=b[H]=b[x]=0;b[y]=u|32; /* do move, set non-virgin */
if(!(G&M))b[F]=k+6,v+=50; /* castling: put R & score */
v-=p-4|R>29?0:20; /* penalize mid-game K move */
if(p<3) /* pawns: */
{v-=9*((x-2&M||b[x-2]-u)+ /* structure, undefended */
(x+2&M||b[x+2]-u)-1 /* squares plus bias */
+(b[x^16]==k+36)) /* kling to non-virgin King */
-(R>>2); /* end-game Pawn-push bonus */
V=y+r+1&S?647-p:2*(u&y+16&32); /* promotion or 6/7th bonus */
b[y]+=V;i+=V; /* change piece, add score */
}
v+=e+i;V=m>q?m:q; /* new eval and alpha */
C=d-1-(d>5&p>2&!t&!h);
C=R>29|d<3|P-I?C:d; /* extend 1 ply if in check */
do
s=C>2|v>V?-D(-l,-V,-v, /* recursive eval. of reply */
F,0,C):v; /* or fail low if futile */
W(s>q&++C<d);v=s;
if(z&&K-I&&v+I&&x==K&y==L) /* move pending & in root: */
{Q=-e-i;O=F; /* exit if legal & found */
R+=i>>7;--Z;return l; /* captured non-P material */
}
b[G]=k+6;b[F]=b[y]=0;b[x]=u;b[H]=t; /* undo move,G can be dummy */
}
if(v>m) /* new best, update max,best*/
m=v,X=x,Y=y|S&F; /* mark double move with S */
if(h){h=0;goto A;} /* redo after doing old best*/
if(x+r-y|u&32| /* not 1st step,moved before*/
p>2&(p-4|j-7|| /* no P & no lateral K move,*/
b[G=x+3^r>>1&7]-k-6 /* no virgin R in corner G, */
||b[G^1]|b[G^2]) /* no 2 empty sq. next to R */
)t+=p<5; /* fake capt. for nonsliding*/
else F=y; /* enable e.p. */
}W(!t); /* if not capt. continue ray*/
}}}W((x=x+9&~M)-B); /* next sqr. of board, wrap */
C:if(m>I-M|m<M-I)d=98; /* mate holds to any depth */
m=m+I|P==I?m:0; /* best loses K: (stale)mate*/
if(z&&d>2)
{*c='a'+(X&7);c[1]='8'-(X>>4);c[2]='a'+(Y&7);c[3]='8'-(Y>>4&7);c[4]=0;
breakpoint=2; /* AVR Studio 4 Breakpoint for moves, watch c[] */
char buff[150];
#ifdef DEBUG
sprintf(buff, "%2d ply, %9d searched, score=%6d by %c%c%c%c\n",d-1,N-S,m,
'a'+(X&7),'8'-(X>>4),'a'+(Y&7),'8'-(Y>>4&7)); /* uncomment for Kibitz */
Serial.print(buff);
#endif
}
} /* encoded in X S,8 bits */
k^=24; /* change sides back */
--Z;return m+=m<e; /* delayed-loss bonus */
}
void getByteBoard(){
uint32_t n1, n2;
char sym[17] = {0x0,0xF,0x1,0x3,0x6,0x4,0x2,0x5,0xF,0x9,0xF,0xB,0xE,0xC,0xA,0xD};
for(int i=0; i<8; i++){
byteBoard[i] = 0;
for(int j=0; j<8; j+=2){
n1 = sym[b[16*i+j+0]&15];
n2 = sym[b[16*i+j+1]&15];
byteBoard[i] |= (n1<<((7-j)*4)) | (n2 << ((6-j)*4));
}
}
}
void searchDataBase(){
c[0]=0; /* Flag to set move not found */
getByteBoard(); /* Convert the board to a binary representation searchable in DB */
int i, j;
for(i=0; i < INDM; i++){ /* Loop INDM amount blocks */
boolean found=true;
int block = ((seed+i)%INDM)*9; /* Start in any block */
for(j=0; j<8; j++){
uint32_t db = pgm_read_dword_near(dataBase+block+j);
if( byteBoard[j] != db ){
found=false;
break;
}
}
if(found){
uint32_t db = pgm_read_dword_near(dataBase+block+j);
c[4]=0;
c[3] = (char)(db&0x000000FF)+'0';
db>>=8;
c[2] = (char)(db&0x000000FF)-0xA+'a';
db>>=8;
c[1] = (char)(db&0x000000FF)+'0';
db>>=8;
c[0] = (char)(db&0x000000FF)-0xA+'a';
break;
}
}
}
// Convert ADC value to key number
int getKey(){
int k;
unsigned int input = analogRead(KEYBOARD_INPUT);
for (k = 0; k < NUM_KEYS; k++){
if (input < adc_key_val[k]){
return k;
}
}
if (k >= NUM_KEYS)k = -1; // No valid key pressed
return k;
}
int waitForKey(){
int res;
do{
seed++;
res = getKey();
}while(res<0);
return res;
}
void gameOver(){
for(;;);
}
void bkp(){
for(int i=0; i<16*8+1; i++){
bk[i] = b[i];
}
}
void rst(){
for(int i=0; i<16*8+1; i++){
b[i] = bk[i];
}
}
void printLastMovs(){
lcd.clear();
if(mn > 1){
printMN(mn-1, 0);
lcd.setCursor(4, 0);
lcd.print(lastH);
lcd.setCursor(10, 0);
lcd.print(lastM);
}else{
lcd.setCursor(0,0);
lcd.print("** CHESSuino **");
}
}
El siguiente código es el de la versión del programa que lee los movimientos por teclado.
/***************************************************************************/
// CHESSIMPLE
/***************************************************************************/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "CHESSimple.h"
LiquidCrystal_I2C lcd(0x27, 16, 2);
int adc_key_val[5] ={50, 200, 400, 600, 800 }; /* Analog values from keypad */
int numJugadores=1;
#define SPEAKER_OUT 2 /* Pin to connect speaker */
volatile boolean ju1 = false;
volatile boolean ju2 = false;
void setup(){
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.begin(16, 2);
lcd.print("Esperando...");
pinMode(2, INPUT);
pinMode(3, INPUT);
pinMode(4, INPUT);
while ((digitalRead(4) == HIGH) || ((digitalRead(4) == LOW) && !ju1 && !ju2)){
if(digitalRead(2) == LOW){
ju1=true;
}
if(digitalRead(3) == LOW){
ju1=true;
ju2=true;
}
}
delay(3000);
if(ju1 && ju2){
numJugadores = 2;
}
lcd.println(" *** CHESSimple ***");
lcd.clear();
lcd.begin(16, 2);
lastH[0] = 0;
pinMode(13, OUTPUT);
}
void loop(){
if(numJugadores==1){
int r;
digitalWrite(13, LOW);
// Print last movements
printLastMovs();
// Take move from human
x1=x2=y1=y2=-1;
takeMove();
lcd.setCursor(10, 1);
lcd.print("Think"); /* Turn for ARDUINO */
K=*c-16*c[1]+799,L=c[2]-16*c[3]+799; /* parse entered move */
N=0;
T=0x3F; /* T=Computer Play strength */
bkp(); /* Save the board just in case */
r = D(-I,I,Q,O,1,3); /* Check & do the human movement */
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print("Lose ");
gameOver();
}
if(k == 0x10){ /* The flag turn must change to 0x08 */
lcd.setCursor(10, 1);
lcd.print(" ");
Serial.println("Su movimiento no ha sido aceptado.");
return;
}
while(digitalRead(2) == LOW){}
strcpy(lastH, c); /* Valid human movement */
mn++; /* Next move */
searchDataBase(); /* Search in database */
if(c[0]){ /* Movement found */
lcd.setCursor(10, 1);
lcd.print(c);
lcd.print(" *");
K=*c-16*c[1]+799,L=c[2]-16*c[3]+799; /* parse move found */
N=0;
T=0x3F; /* T=Computer Play strength */
r = D(-I,I,Q,O,1,3); /* Check & do*/
if( !(r>-I+1) ) gameOver();
if(k == 0x08){
lcd.setCursor(10, 1);
lcd.print("ERR DB");
gameOver();
}
strcpy(lastM, c); /* Valid ARDUINO movement */
delay(1000);
return;
}
K=I;
N=0;
T=0x3F; /* T=Computer Play strength */
r = D(-I,I,Q,O,1,3); /* Think & do*/
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print("Lose*");
gameOver();
}
if(k == 0x08){ /* Some times the algorithm do not */
lcd.setCursor(10, 1); /* execute the move and do not change */
lcd.print("ERR 3 "); /* the turn flag */
gameOver(); /* 1. b1c3 c7c5? 2. f2f4? */
}
strcpy(lastM, c); /* Valid ARDUINO movement */
strcpy(c, "a1a1"); /* Execute a invalid move to check score again */
r = D(-I,I,Q,O,1,3);
if( !(r>-I+1) ){
lcd.setCursor(10, 1);
lcd.print(lastM);
lcd.print(" ");
gameOver();
}
if(k == 0x08){ /* Some times the algorithm do not */
lcd.setCursor(10, 1); /* execute the move and do not change */
lcd.print("ERR 3 "); /* the turn flag */
gameOver(); /* 1. b1c3 c7c5? 2. f2f4? */
}
serialBoard();
delay(11000);
}
}
void takeMove(){
Serial.println("Introduce tu movimiento:");
int info[4];
while (Serial.available() < 4) {}
int temp;
for(int i=0; i<4; i++){
temp = Serial.read();
/* info[i] = temp - 48;*/
if(i%2==0){
info[i] = temp - 97;
}else{
info[i] = temp - 49;
}
}
Serial.println("Movimiento introducido");
x1 = info[0];
Serial.println(x1);
y1 = info[1];
Serial.println(y1);
x2 = info[2];
Serial.println(x2);
y2 = info[3];
Serial.println(y2);
printMove();
c[0] = x1+'a';
c[1] = y1+'1';
c[2] = x2+'a';
c[3] = y2+'1';
c[4] = 0;
}
void printMove(){
lcd.setCursor(4, 1);
if(x1>=0) lcd.print((char)(x1+'a')); else lcd.print('_');
if(y1>=0) lcd.print((char)(y1+'1')); else lcd.print('_');
if(x2>=0) lcd.print((char)(x2+'a')); else lcd.print('_');
if(y2>=0) lcd.print((char)(y2+'1')); else lcd.print('_');
}
void printMN(int n, int y){
if(n<=9){
lcd.setCursor(1, y);
}else{
lcd.setCursor(0, y);
}
lcd.print(n);
lcd.print('.');
}
/* User interface routines */
void myputchar(char c) {
Serial.print(c);
}
void myputs(const char *s) {
while(*s) myputchar(*s++);
myputchar('\n');
}
char mygetchar(void) {
while(Serial.available() <= 0);
return (char)Serial.read();
}
unsigned short myrand(void) {
unsigned short r = (unsigned short)(seed%MYRAND_MAX);
return r=((r<<11)+(r<<7)+r)>>1;
}
/* recursive minimax search */
/* (q,l)=window, e=current eval. score, */
/* E=e.p. sqr.z=prev.dest, n=depth; return score */
short D(short q, short l, short e, unsigned char E, unsigned char z, unsigned char n){
short m,v,i,P,V,s;
unsigned char t,p,u,x,y,X,Y,H,B,j,d,h,F,G,C;
signed char r;
if (++Z>30) { /* stack underrun check */
breakpoint=1; /* AVR Studio 4 Breakpoint for stack underrun */
myputchar('u');
--Z;return e;
}
digitalWrite(13, (ledv++)%8?0:1);
q--; /* adj. window: delay bonus */
k^=24; /* change sides */
d=Y=0; /* start iter. from scratch */
X=myrand()&~M; /* start at random field */
W(d++<n||d<3|| /* iterative deepening loop */
z&K==I&&(N<T&d<98|| /* root: deepen upto time */
(K=X,L=Y&~M,d=3))) /* time's up: go do best */
{x=B=X; /* start scan at prev. best */
h=Y&S; /* request try noncastl. 1st*/
P=d<3?I:D(-l,1-l,-e,S,0,d-3); /* Search null move */
m=-P<l|R>35?d>2?-I:e:-P; /* Prune or stand-pat */
++N; /* node count (for timing) */
do{
u=b[x]; /* scan board looking for */
if(u&k){ /* own piece (inefficient!)*/
r=p=u&7; /* p = piece type (set r>0) */
j=o[p+16]; /* first step vector f.piece*/
W(r=p>2&r<0?-r:-o[++j]) /* loop over directions o[] */
{A: /* resume normal after best */
y=x;F=G=S; /* (x,y)=move, (F,G)=castl.R*/
do{ /* y traverses ray, or: */
H=y=h?Y^h:y+r; /* sneak in prev. best move */
if(y&M)break; /* board edge hit */
m=E-S&b[E]&&y-E<2&E-y<2?I:m; /* bad castling */
if(p<3&y==E)H^=16; /* shift capt.sqr. H if e.p.*/
t=b[H];if(t&k|p<3&!(y-x&7)-!t)break; /* capt. own, bad pawn mode */
i=37*w[t&7]+(t&192); /* value of capt. piece t */
m=i<0?I:m; /* K capture */
if(m>=l&d>1)goto C; /* abort on fail high */
v=d-1?e:i-p; /* MVV/LVA scoring */
if(d-!t>1) /* remaining depth */
{v=p<6?b[x+8]-b[y+8]:0; /* center positional pts. */
b[G]=b[H]=b[x]=0;b[y]=u|32; /* do move, set non-virgin */
if(!(G&M))b[F]=k+6,v+=50; /* castling: put R & score */
v-=p-4|R>29?0:20; /* penalize mid-game K move */
if(p<3) /* pawns: */
{v-=9*((x-2&M||b[x-2]-u)+ /* structure, undefended */
(x+2&M||b[x+2]-u)-1 /* squares plus bias */
+(b[x^16]==k+36)) /* kling to non-virgin King */
-(R>>2); /* end-game Pawn-push bonus */
V=y+r+1&S?647-p:2*(u&y+16&32); /* promotion or 6/7th bonus */
b[y]+=V;i+=V; /* change piece, add score */
}
v+=e+i;V=m>q?m:q; /* new eval and alpha */
C=d-1-(d>5&p>2&!t&!h);
C=R>29|d<3|P-I?C:d; /* extend 1 ply if in check */
do
s=C>2|v>V?-D(-l,-V,-v, /* recursive eval. of reply */
F,0,C):v; /* or fail low if futile */
W(s>q&++C<d);v=s;
if(z&&K-I&&v+I&&x==K&y==L) /* move pending & in root: */
{Q=-e-i;O=F; /* exit if legal & found */
R+=i>>7;--Z;return l; /* captured non-P material */
}
b[G]=k+6;b[F]=b[y]=0;b[x]=u;b[H]=t; /* undo move,G can be dummy */
}
if(v>m) /* new best, update max,best*/
m=v,X=x,Y=y|S&F; /* mark double move with S */
if(h){h=0;goto A;} /* redo after doing old best*/
if(x+r-y|u&32| /* not 1st step,moved before*/
p>2&(p-4|j-7|| /* no P & no lateral K move,*/
b[G=x+3^r>>1&7]-k-6 /* no virgin R in corner G, */
||b[G^1]|b[G^2]) /* no 2 empty sq. next to R */
)t+=p<5; /* fake capt. for nonsliding*/
else F=y; /* enable e.p. */
}W(!t); /* if not capt. continue ray*/
}}}W((x=x+9&~M)-B); /* next sqr. of board, wrap */
C:if(m>I-M|m<M-I)d=98; /* mate holds to any depth */
m=m+I|P==I?m:0; /* best loses K: (stale)mate*/
if(z&&d>2)
{*c='a'+(X&7);c[1]='8'-(X>>4);c[2]='a'+(Y&7);c[3]='8'-(Y>>4&7);c[4]=0;
breakpoint=2; /* AVR Studio 4 Breakpoint for moves, watch c[] */
char buff[150];
#ifdef DEBUG
sprintf(buff, "%2d ply, %9d searched, score=%6d by %c%c%c%c\n",d-1,N-S,m,
'a'+(X&7),'8'-(X>>4),'a'+(Y&7),'8'-(Y>>4&7)); /* uncomment for Kibitz */
Serial.print(buff);
#endif
}
} /* encoded in X S,8 bits */
k^=24; /* change sides back */
--Z;return m+=m<e; /* delayed-loss bonus */
}
void serialBoard(){
Serial.println(" +-----------------+");
for(int i=0; i<8; i++){
Serial.print(8-i);
Serial.print("| ");
for(int j=0; j<8; j++){
char c = sym[b[16*i+j]&15];
Serial.print(c);
Serial.print(' ');
}
Serial.println('|');
}
Serial.println(" +-----------------+");
Serial.println(" a b c d e f g h");
/*Serial.print("char b[]={");
for(int i=0; i< 16*8; i++){
Serial.print((int)b[i]);
Serial.print(",");
}
Serial.println("0};");
getByteBoard();
char buff[11];
for(int i=0; i<8; i++){
sprintf(buff, "0x%08lX, ", byteBoard[i]);
Serial.print(buff);
}
Serial.println('|'); */
}
void getByteBoard(){
uint32_t n1, n2;
char sym[17] = {0x0,0xF,0x1,0x3,0x6,0x4,0x2,0x5,0xF,0x9,0xF,0xB,0xE,0xC,0xA,0xD};
for(int i=0; i<8; i++){
byteBoard[i] = 0;
for(int j=0; j<8; j+=2){
n1 = sym[b[16*i+j+0]&15];
n2 = sym[b[16*i+j+1]&15];
byteBoard[i] |= (n1<<((7-j)*4)) | (n2 << ((6-j)*4));
}
}
}
void searchDataBase(){
c[0]=0; /* Flag to set move not found */
getByteBoard(); /* Convert the board to a binary representation searchable in DB */
int i, j;
for(i=0; i < INDM; i++){ /* Loop INDM amount blocks */
boolean found=true;
int block = ((seed+i)%INDM)*9; /* Start in any block */
for(j=0; j<8; j++){
uint32_t db = pgm_read_dword_near(dataBase+block+j);
if( byteBoard[j] != db ){
found=false;
break;
}
}
if(found){
uint32_t db = pgm_read_dword_near(dataBase+block+j);
c[4]=0;
c[3] = (char)(db&0x000000FF)+'0';
db>>=8;
c[2] = (char)(db&0x000000FF)-0xA+'a';
db>>=8;
c[1] = (char)(db&0x000000FF)+'0';
db>>=8;
c[0] = (char)(db&0x000000FF)-0xA+'a';
break;
}
}
}
// Convert ADC value to key number
int getKey(){
int k;
unsigned int input = analogRead(KEYBOARD_INPUT);
for (k = 0; k < NUM_KEYS; k++){
if (input < adc_key_val[k]){
return k;
}
}
if (k >= NUM_KEYS)k = -1; // No valid key pressed
return k;
}
int waitForKey(){
int res;
do{
seed++;
res = getKey();
}while(res<0);
return res;
}
void gameOver(){
for(;;);
}
void bkp(){
for(int i=0; i<16*8+1; i++){
bk[i] = b[i];
}
}
void rst(){
for(int i=0; i<16*8+1; i++){
b[i] = bk[i];
}
}
void printLastMovs(){
lcd.clear();
if(mn > 1){
printMN(mn-1, 0);
lcd.setCursor(4, 0);
lcd.print(lastH);
lcd.setCursor(10, 0);
lcd.print(lastM);
}else{
lcd.setCursor(0,0);
lcd.print("** CHESSuino **");
}
}
La biblioteca pieza.h es la siguiente.
#ifndef pieza_h
#define pieza_h
#include "Arduino.h"
class pieza {
private:
int posicion;
bool vida; //0 vivo || -1 muerto
/*String nombre;
int color; //0 blanco|| 1 negro*/
public:
pieza();
pieza(int posicion, bool vida/*, String nombre, int color*/);
int getPosicion();
bool getVida();
String getnombre();
void setPosicion(int);
void setVida(bool);
/*int getColor();
void setPosicion(int);*/
};
pieza::pieza(){
this->posicion = 0;
this->vida = false;
/*this->nombre = "adsfadsf";
this->color=0;*/
}
pieza::pieza(int posicion, bool vida/*, String nombre, int color*/) {
this->posicion = posicion;
this->vida = vida;
/* this->nombre = nombre;
this->color = color;*/
}
int pieza::getPosicion(){
return this->posicion;
}
bool pieza::getVida(){
return this->vida;
}
/* String pieza::getnombre(){
return this->nombre;
}
int pieza::getColor(){
return this->color;
}*/
void pieza::setPosicion(int pos){
this->posicion = pos;
}
void pieza::setVida(bool b){
this->vida = b;
}
#endif
La siguiente biblioteca es CHESSimple.h.
#include <avr/pgmspace.h>
#define W while
#define M 0x88
#define S 128
#define I 8000
#define KEYBOARD_INPUT 0 /* Analog read pin */
#define MYRAND_MAX 65535 /* 16bit pseudo random generator */
long N, T; /* N=evaluated positions+S, T=recursion limit */
short Q, O, K, R, k=16; /* k=moving side */
char *p, c[5], Z; /* p=pointer to c, c=user input, computer output, Z=recursion counter */
char L,
w[]={0,2,2,7,-1,8,12,23}, /* relative piece values */
o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
7,-1,11,6,8,3,6, /* 1st dir. in o[] per piece*/
6,3,5,7,4,5,3,6}; /* initial piece setup */
/* board is left part, center-pts table is right part, and dummy */
char b[]={
22, 19, 21, 23, 20, 21, 19, 22, 28, 21, 16, 13, 12, 13, 16, 21,
18, 18, 18, 18, 18, 18, 18, 18, 22, 15, 10, 7, 6, 7, 10, 15,
0, 0, 0, 0, 0, 0, 0, 0, 18, 11, 6, 3, 2, 3, 6, 11,
0, 0, 0, 0, 0, 0, 0, 0, 16, 9, 4, 1, 0, 1, 4, 9,
0, 0, 0, 0, 0, 0, 0, 0, 16, 9, 4, 1, 0, 1, 4, 9,
0, 0, 0, 0, 0, 0, 0, 0, 18, 11, 6, 3, 2, 3, 6, 11,
9, 9, 9, 9, 9, 9, 9, 9, 22, 15, 10, 7, 6, 7, 10, 15,
14, 11, 13, 15, 12, 13, 11, 14, 28, 21, 16, 13, 12, 13, 16, 21, 0
};
//char b[]={22,19,21,23,20,21,19,22,28,21,16,13,12,13,16,21,18,18,18,18,18,18,18,18,22,15,10,7,6,7,10,15,0,0,0,0,0,0,0,0,18,11,6,3,2,3,6,11,0,0,0,0,0,0,0,0,16,9,4,1,0,1,4,9,0,0,0,0,0,0,0,0,16,9,4,1,0,1,4,9,0,0,0,0,0,0,0,0,18,11,6,3,2,3,6,11,9,9,9,9,9,9,9,9,22,15,10,7,6,7,10,15,14,11,13,15,12,13,11,14,28,21,16,13,12,13,16,21,0};
//char b[]={22,19,21,0,20,21,19,22,28,21,16,13,12,13,16,21,18,18,18,18,0,18,18,18,22,15,10,7,6,7,10,15,0,0,0,0,0,0,0,0,18,11,6,3,2,3,6,11,0,0,0,0,0,0,0,0,16,9,4,1,0,1,4,9,0,0,0,50,41,41,0,55,16,9,4,1,0,1,4,9,0,0,0,0,0,0,0,0,18,11,6,3,2,3,6,11,9,9,9,0,0,0,9,9,22,15,10,7,6,7,10,15,14,11,13,15,12,13,11,14,28,21,16,13,12,13,16,21,0};
//char b[]={22,0,21,0,20,21,19,22,28,21,16,13,12,13,16,21,18,18,18,18,0,18,18,18,22,15,10,7,6,7,10,15,0,0,51,0,0,0,0,0,18,11,6,3,2,3,6,11,0,0,0,0,0,0,0,0,16,9,4,1,0,1,4,9,0,0,0,50,41,41,0,0,16,9,4,1,0,1,4,9,0,0,0,44,0,0,0,0,18,11,6,3,2,3,6,11,9,9,9,0,0,0,0,9,22,15,10,7,6,7,10,15,14,11,13,55,0,13,11,14,28,21,16,13,12,13,16,21,0};
char bk[16*8+1];
volatile char breakpoint; /* for debugger */
unsigned int seed=0;
uint32_t byteBoard[8];
// LCD Shield vars
char sym[17] = {".?inkbrq?P?NKBRQ"};
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
int mn=1;
short x1, y1, x2, y2;
char lastH[5], lastM[5];
unsigned short ledv=1;
/*******************************************/
/* OPENING DATABASE */
/* */
/* Build from PGN txt files */
/* Just consider black movements */
/* The uint32 array can´t size over 8191 */
/*******************************************/
// TOTAL 898 movements
#define INDM 898
const uint32_t PROGMEM dataBase[8082]={
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000090, 0x00000000, 0x99999909, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000090, 0x00000000, 0x999999C9, 0xABCDE0BA, 0x0c081004, // c8g4 1
0x23056432, 0x11101111, 0x00000000, 0x00010000, 0x00900040, 0x00000000, 0x990999C9, 0xABCDE0BA, 0x0d050d04, // d5d4 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x0000000B, 0x99999999, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000000, 0x0000009B, 0x99999909, 0xABCDEC0A, 0x0e070e05, // e7e5 1
0x23456432, 0x11100111, 0x00000000, 0x00011000, 0x00000900, 0x0000009B, 0x99999009, 0xABCDEC0A, 0x0c081103, // c8h3 1
0x23056432, 0x11100111, 0x00000000, 0x00011000, 0x00000900, 0x0000009C, 0x99999009, 0xABCDE00A, 0x0e050f04, // e5f4 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x00B00000, 0x99999999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00090000, 0x00B00000, 0x99909999, 0xA0CDECBA, 0x0c050d04, // c5d4 1
0x23456432, 0x11011111, 0x00000000, 0x00000000, 0x000D0000, 0x00B00000, 0x99909999, 0xA0C0ECBA, 0x0b080c06, // b8c6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x00090000, 0x99909999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00000000, 0x00B90000, 0x99909999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000900, 0x00000000, 0x99999099, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456432, 0x11110111, 0x00000000, 0x00009000, 0x00000000, 0x00000000, 0x99999099, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456432, 0x11100111, 0x00090000, 0x00000000, 0x00000000, 0x00000000, 0x99999099, 0xABCDECBA, 0x0f080d06, // f8d6 1
0x23456032, 0x11100111, 0x00040000, 0x00000000, 0x00000000, 0x00000B00, 0x99999099, 0xABCDEC0A, 0x10071005, // g7g5 1
0x23456032, 0x11100111, 0x00040000, 0x00000000, 0x00000000, 0x00000B00, 0x99999099, 0xABCDEC0A, 0x10081106, // g8h6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000900, 0x00000000, 0x99999099, 0xABCDECBA, 0x0f070f05, // f7f5 1
0x23456432, 0x11111011, 0x00000000, 0x00000100, 0x00009900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0f050e04, // f5e4 1
0x23456432, 0x11111011, 0x00000000, 0x00000000, 0x00001900, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x00000B00, 0x99999999, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000000, 0x00000B90, 0x99999909, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00000300, 0x00010000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCD0AE0, 0x0c081004, // c8g4 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000000, 0x00000B90, 0x99999909, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23056432, 0x11101111, 0x00000000, 0x00010000, 0x00000040, 0x00000B90, 0x999999C9, 0xABCDE00A, 0x0b080d07, // b8d7 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000000, 0x00000B90, 0x99999909, 0xABCDEC0A, 0x10071006, // g7g6 1
0x23456432, 0x11101101, 0x00000010, 0x00010000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCDE00A, 0x0f081007, // f8g7 1
0x23456032, 0x11101141, 0x00000010, 0x00010000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCD0AE0, 0x0e070e05, // e7e5 1
0x23456032, 0x11100141, 0x00000010, 0x00011000, 0x00000000, 0x00090B90, 0x999099C9, 0xABCD0AE0, 0x10080e07, // g8e7 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00000000, 0x00000B90, 0x99999909, 0xABCDEC0A, 0x0c070c05, // c7c5 1
0x23456432, 0x11001111, 0x00000000, 0x00110000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCDE00A, 0x0b080c06, // b8c6 1
0x20456432, 0x11001111, 0x00300000, 0x00110000, 0x00000000, 0x00000B90, 0x999999C9, 0xABCD0AE0, 0x0e070e06, // e7e6 1
0x20456432, 0x11000111, 0x00301000, 0x00110000, 0x00000000, 0x00090B90, 0x999099C9, 0xABCD0AE0, 0x10080f06, // g8f6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00900000, 0x00000000, 0x99099999, 0xABCDECBA, 0x0c070c06, // c7c6 1
0x23456432, 0x11011111, 0x00100000, 0x00000000, 0x00900000, 0x00000B00, 0x99099999, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11001111, 0x00100000, 0x00010000, 0x00900000, 0x09000B00, 0x90099999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00900000, 0x09000B90, 0x90099909, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00900000, 0x09000B90, 0x90099909, 0xABCDEC0A, 0x0c080f05, // c8f5 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00900000, 0x09000B00, 0x9C099999, 0xAB0DEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00900000, 0x09000B00, 0x9C099999, 0xAB0DEC0A, 0x0c080f05, // c8f5 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00900000, 0x09000B00, 0x9C099999, 0xAB0DEC0A, 0x0c081004, // c8g4 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00900000, 0x00000000, 0x99099999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456432, 0x11110111, 0x00001000, 0x00000000, 0x00900000, 0x00000B00, 0x99099999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00900000, 0x00000B90, 0x99099909, 0xABCDEC0A, 0x0a070a06, // a7a6 1
0x23456402, 0x01110111, 0x10001300, 0x00000000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x23456432, 0x11110111, 0x00001000, 0x00000000, 0x00900000, 0x00000B00, 0x99099999, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00900000, 0x09000B00, 0x90099999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00900000, 0x09000B00, 0x9C099999, 0xAB0DEC0A, 0x0c070c05, // c7c5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00900000, 0x00000B90, 0x99099909, 0xABCDEC0A, 0x0c070c06, // c7c6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00900000, 0x00000B90, 0x99099909, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCDE00A, 0x0d050c04, // d5c4 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCDE00A, 0x0f080e07, // f8e7 1
0x23456002, 0x11104111, 0x00001300, 0x00010000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCD0AE0, 0x0c070c05, // c7c5 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00900000, 0x00000000, 0x99099999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11101111, 0x00000300, 0x00090000, 0x00000000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0f060d05, // f6d5 1
0x23456402, 0x11101111, 0x00000000, 0x00030000, 0x00000000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11101101, 0x00000010, 0x00030000, 0x00000000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0d050c03, // d5c3 1
0x23456402, 0x11101101, 0x00000010, 0x00030000, 0x00000000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0d050b06, // d5b6 1
0x23456402, 0x11101111, 0x00000000, 0x00030000, 0x00000000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11101101, 0x00000010, 0x00030000, 0x00000000, 0x00B00B90, 0x99099909, 0xA0CDEC0A, 0x0f081007, // f8g7 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0e070e06, // e7e6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x0b070b06, // b7b6 1
0x23456402, 0x10110111, 0x01001300, 0x00000000, 0x00909000, 0x00B00B00, 0x99090999, 0xA0CDEC0A, 0x0c080b07, // c8b7 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00909000, 0x00B00000, 0x99090999, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00909000, 0x00B00000, 0x99090999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00909000, 0x00B00000, 0x99090999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00900000, 0x00000000, 0x99099999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0d070d06, // d7d6 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0c080e06, // c8e6 1
0x23056432, 0x11100111, 0x00014000, 0x00001000, 0x00900000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0b080c06, // b8c6 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x0e050e04, // e5e4 1
0x23456402, 0x11110111, 0x00000300, 0x000000B0, 0x00901000, 0x00B00000, 0x99099999, 0xA0CDEC0A, 0x0b070b05, // b7b5 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0f080b04, // f8b4 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0c070c06, // c7c6 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x20456432, 0x11110101, 0x00300010, 0x00001000, 0x00900000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0f081007, // f8g7 1
0x20456032, 0x11110141, 0x00300010, 0x00001000, 0x00900000, 0x00B09090, 0x990909C9, 0xA0CDE0BA, 0x0d070d06, // d7d6 1
0x20456032, 0x11110141, 0x00300010, 0x00001000, 0x00900000, 0x00B00090, 0x990999C9, 0x0ACDE0BA, 0x10081106, // g8h6 1
0x20456032, 0x11110141, 0x00300010, 0x00001000, 0x00900000, 0x00B90090, 0x990099C9, 0xA0CDE0BA, 0x0d070d06, // d7d6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0e050d04, // e5d4 1
0x20456402, 0x11110111, 0x00300300, 0x00000000, 0x009B0000, 0x00B00000, 0x99009999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0e050e04, // e5e4 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00900000, 0x00B09B00, 0x99090999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x20456002, 0x11110111, 0x00300300, 0x00001000, 0x04900000, 0x00B09B00, 0x99D90999, 0xA0C0EC0A, 0x0e081008, // e8g8 1
0x20456002, 0x11110111, 0x00300300, 0x00001000, 0x04900000, 0x00B09B00, 0x99D90999, 0xA0C0EC0A, 0x0b040c03, // b4c3 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00900000, 0x00000000, 0x99099999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00900000, 0x00000B00, 0x99099999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11011111, 0x00000300, 0x00100000, 0x00900000, 0x00000B90, 0x99099909, 0xABCDEC0A, 0x0b070b06, // b7b6 1
0x23456402, 0x10011111, 0x01000300, 0x00100000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCDE00A, 0x0c080b07, // c8b7 1
0x23056402, 0x14011111, 0x01000300, 0x00100000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCD0AE0, 0x0e070e06, // e7e6 1
0x23456402, 0x11011111, 0x00000300, 0x00100000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0c050d04, // c5d4 1
0x23456402, 0x11011111, 0x00000300, 0x00000000, 0x009B0000, 0x00000000, 0x99009999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11010111, 0x00001300, 0x00000000, 0x009B0000, 0x00B00000, 0x99009999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11011111, 0x00000300, 0x00100000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x0d070d05, // d7d5 1
0x23456402, 0x11001111, 0x00000300, 0x00190000, 0x00000000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x0f060d05, // f6d5 1
0x23456402, 0x11011111, 0x00000300, 0x00100000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11001111, 0x00000300, 0x00190000, 0x00000000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x0f060d05, // f6d5 1
0x23456402, 0x11001111, 0x00000000, 0x00130000, 0x00000000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0d050c07, // d5c7 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11011111, 0x00300000, 0x00100000, 0x00900000, 0x00B00B00, 0x99099999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x20456432, 0x11011111, 0x00300000, 0x00100000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x20456432, 0x11011101, 0x00300010, 0x00100000, 0x00900000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0f081007, // f8g7 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00900000, 0x00B09090, 0x990909C9, 0xA0CDE0BA, 0x0e070e05, // e7e5 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00900000, 0x00B00B90, 0x990999C9, 0xA0CDE00A, 0x0e070e05, // e7e5 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00900000, 0x00B00B90, 0x990999C9, 0xA0CDE00A, 0x10080f06, // g8f6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456432, 0x11110111, 0x00000000, 0x00009000, 0x00000000, 0x00000000, 0x99909999, 0xABCDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11110111, 0x00300000, 0x00009000, 0x00000000, 0x00000B00, 0x99909999, 0xABCDEC0A, 0x0d080e07, // d8e7 1
0x20406432, 0x11115111, 0x00300000, 0x000D9000, 0x00000000, 0x00000B00, 0x99909999, 0xABC0EC0A, 0x0f070f06, // f7f6 1
0x20406432, 0x11115011, 0x00300900, 0x000D0000, 0x00000000, 0x00000B00, 0x99909999, 0xABC0EC0A, 0x10080f06, // g8f6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11111101, 0x00000010, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0f081007, // f8g7 1
0x23456032, 0x11111141, 0x00000010, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456032, 0x11011141, 0x00000010, 0x00190000, 0x00900000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x10070c03, // g7c3 1
0x23456032, 0x11011101, 0x00000010, 0x00190000, 0x00900000, 0x00900000, 0x90009999, 0xA0CDECBA, 0x0f070f05, // f7f5 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11111101, 0x00000010, 0x00000000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0f081007, // f8g7 1
0x23456032, 0x11111141, 0x00000010, 0x00000000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456032, 0x11101141, 0x00010010, 0x00000000, 0x00999000, 0x00000B00, 0x99000999, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456432, 0x11101111, 0x00010000, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11101101, 0x00010010, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0f081007, // f8g7 1
0x23456032, 0x11101141, 0x00010010, 0x00000000, 0x00999000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456032, 0x11001141, 0x00010010, 0x00100000, 0x00999000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0d080a05, // d8a5 1
0x23456032, 0x11101141, 0x00010010, 0x00000000, 0x00999000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0f070f05, // f7f5 1
0x23456032, 0x11101141, 0x00010010, 0x00000000, 0x00999000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00090000, 0x00000B00, 0x99909999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11110111, 0x00001300, 0x000000C0, 0x00090000, 0x00000B00, 0x99909999, 0xAB0DEC0A, 0x0c070c05, // c7c5 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00090000, 0x00000B00, 0x99909999, 0xABCDEC0A, 0x0b070b06, // b7b6 1
0x23456402, 0x10111111, 0x01000300, 0x00000000, 0x00090000, 0x00000B90, 0x99909909, 0xABCDEC0A, 0x0c080b07, // c8b7 1
0x23056402, 0x14111111, 0x01000300, 0x00000000, 0x00090000, 0x00000B90, 0x999099C9, 0xABCDE00A, 0x0c070c05, // c7c5 1
0x23056402, 0x14011111, 0x01000300, 0x00100000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0c050d04, // c5d4 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456402, 0x11110111, 0x00000300, 0x00009000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0f060e04, // f6e4 1
0x23456402, 0x11110111, 0x00000300, 0x00009000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0f061004, // f6g4 1
0x23456402, 0x11110111, 0x00000000, 0x00009000, 0x00909030, 0x00000000, 0x99000999, 0xABCDECBA, 0x10040e05, // g4e5 1
0x23456402, 0x11110111, 0x00000000, 0x00003000, 0x00909900, 0x00000000, 0x99000099, 0xABCDECBA, 0x0e050c06, // e5c6 1
0x23456402, 0x11110111, 0x00000000, 0x00009000, 0x00909030, 0x00000000, 0x99000999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11101111, 0x00010300, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0c080f05, // c8f5 1
0x23456402, 0x11101111, 0x00010300, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0e070e05, // e7e5 1
0x23456402, 0x11100111, 0x00010300, 0x00001000, 0x00990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0b080d07, // b8d7 1
0x23456402, 0x11100111, 0x00010300, 0x00001000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456402, 0x11011111, 0x00000300, 0x00190000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11011111, 0x00000300, 0x00190000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0f060e04, // f6e4 1
0x23456402, 0x11011111, 0x00000300, 0x00190000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456402, 0x11010111, 0x00000300, 0x00191000, 0x00900000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11000111, 0x00010300, 0x00191000, 0x00909000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11011111, 0x00000300, 0x00190000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0b070b05, // b7b5 1
0x23456402, 0x10011111, 0x00000300, 0x09190000, 0x00000000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0a070a06, // a7a6 1
0x23456402, 0x00011111, 0x10000300, 0x09190000, 0x00000000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0a060b05, // a6b5 1
0x23456402, 0x00011111, 0x90000300, 0x00190000, 0x00000000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0c080a06, // c8a6 1
0x23456402, 0x11011111, 0x00000300, 0x00190000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456402, 0x11010111, 0x00001300, 0x00190000, 0x00900000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0e060d05, // e6d5 1
0x23456402, 0x11010111, 0x00000300, 0x00190000, 0x00000000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d070d06, // d7d6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x0f070f05, // f7f5 1
0x23456432, 0x11111011, 0x00000000, 0x00000100, 0x00090000, 0x00000090, 0x99909909, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11111001, 0x00000010, 0x00000100, 0x00090000, 0x00000090, 0x999099C9, 0xABCDE0BA, 0x0f081007, // f8g7 1
0x23456032, 0x11111041, 0x00000010, 0x00000100, 0x00090000, 0x00000B90, 0x999099C9, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x23456032, 0x11011041, 0x00100010, 0x00000100, 0x00090000, 0x00000B90, 0x999099C9, 0xABCD0AE0, 0x10081106, // g8h6 1
0x23456432, 0x11111011, 0x00000000, 0x00000100, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0f050e04, // f5e4 1
0x23456432, 0x11111011, 0x00000000, 0x00000000, 0x00091000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11111011, 0x00000300, 0x000000C0, 0x00091000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x10071006, // g7g6 1
0x23456402, 0x11111011, 0x00000300, 0x000000C0, 0x00091000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0c070c06, // c7c6 1
0x23456402, 0x11111011, 0x00000300, 0x000000C0, 0x00091000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0b070b06, // b7b6 1
0x23456432, 0x11111011, 0x00000000, 0x00000100, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11111011, 0x00000300, 0x00000100, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11101011, 0x00010300, 0x00000100, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0c070c06, // c7c6 1
0x23456402, 0x11001011, 0x00110300, 0x00000100, 0x00990000, 0x00B00090, 0x990099C9, 0xA0CDE0BA, 0x0d080c07, // d8c7 1
0x23456402, 0x11111011, 0x00000300, 0x00000100, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11111001, 0x00000310, 0x00000100, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f081007, // f8g7 1
0x23456002, 0x11111041, 0x00000310, 0x00000100, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0e081008, // e8g8 1
0x23456402, 0x11111011, 0x00000300, 0x00000100, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456402, 0x11110011, 0x00001300, 0x00000100, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f080b04, // f8b4 1
0x23456002, 0x11110011, 0x00001300, 0x00000100, 0x04990000, 0x00000090, 0x990C99C9, 0xAB0DE0BA, 0x0b040e07, // b4e7 1
0x23456402, 0x11110011, 0x00001300, 0x00000100, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f080e07, // f8e7 1
0x23456002, 0x11114011, 0x00001300, 0x00000100, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0e081008, // e8g8 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11111111, 0x00300000, 0x00000000, 0x09009000, 0x00000000, 0x90990999, 0xABCDECBA, 0x0c060b04, // c6b4 1
0x20456432, 0x11111111, 0x00000000, 0x00000000, 0x03009000, 0x00900000, 0x90090999, 0xABCDECBA, 0x0b040c06, // b4c6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11101111, 0x00000000, 0x00090000, 0x00000000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0d080d05, // d8d5 1
0x23406432, 0x11101111, 0x00000000, 0x00050000, 0x00000000, 0x00B00000, 0x99990999, 0xA0CDECBA, 0x0d050a05, // d5a5 1
0x23406432, 0x11101111, 0x00000000, 0x50000000, 0x00090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23406402, 0x11101111, 0x00000300, 0x50000000, 0x00090000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x23406402, 0x11101111, 0x00000300, 0x50000000, 0x00090000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0c080f05, // c8f5 1
0x23406432, 0x11101111, 0x00000000, 0x50000000, 0x00090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0e070e05, // e7e5 1
0x23406432, 0x11100111, 0x00000000, 0x50009000, 0x00000000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0f080b04, // f8b4 1
0x23406432, 0x11100111, 0x00000000, 0x50001000, 0x00090000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x23456432, 0x11101111, 0x00000000, 0x00090000, 0x00000000, 0x00000000, 0x99990999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00000300, 0x00090000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0f060d05, // f6d5 1
0x23456402, 0x11101111, 0x00000000, 0x00030000, 0x00990000, 0x00000000, 0x99000999, 0xABCDECBA, 0x0d050b04, // d5b4 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11111111, 0x00000300, 0x00009000, 0x00000000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0f060d05, // f6d5 1
0x23456402, 0x11111111, 0x00000000, 0x00039000, 0x00C00000, 0x00000000, 0x99990999, 0xABCDE0BA, 0x0d050b06, // d5b6 1
0x23456402, 0x11111111, 0x03000000, 0x00009000, 0x00000000, 0x0C000000, 0x99990999, 0xABCDE0BA, 0x0c070c05, // c7c5 1
0x23456402, 0x11111111, 0x00000000, 0x00039000, 0x00900000, 0x00000000, 0x99090999, 0xABCDECBA, 0x0d050b06, // d5b6 1
0x23456402, 0x11111111, 0x03000000, 0x00909000, 0x00000000, 0x00000000, 0x99090999, 0xABCDECBA, 0x0b060d05, // b6d5 1
0x23456402, 0x11111111, 0x00000000, 0x00939000, 0x00C00000, 0x00000000, 0x99090999, 0xABCDE0BA, 0x0e070e06, // e7e6 1
0x23456402, 0x11111111, 0x00000000, 0x00039000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456402, 0x11101111, 0x00010000, 0x00039000, 0x00990000, 0x00000000, 0x99000999, 0xABCDECBA, 0x0d050b06, // d5b6 1
0x23456402, 0x11101111, 0x03090000, 0x00000000, 0x00990000, 0x00000000, 0x99000999, 0xABCDECBA, 0x0c070d06, // c7d6 1
0x23456402, 0x11101111, 0x03010000, 0x00009000, 0x00990900, 0x00000000, 0x99000099, 0xABCDECBA, 0x0d060e05, // d6e5 1
0x23456402, 0x11101111, 0x03010000, 0x00009000, 0x00990900, 0x00000000, 0x99000099, 0xABCDECBA, 0x10071005, // g7g5 1
0x23456402, 0x11101111, 0x03010000, 0x00009000, 0x00990900, 0x00000000, 0x99000099, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11101111, 0x03010000, 0x00009000, 0x00990900, 0x00000000, 0x99000099, 0xABCDECBA, 0x0c080f05, // c8f5 1
0x23456402, 0x11101111, 0x00010000, 0x00039000, 0x00090000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0d060e05, // d6e5 1
0x23456402, 0x11101111, 0x00010000, 0x00039000, 0x00090000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0d050b06, // d5b6 1
0x23456402, 0x11101111, 0x00010000, 0x00039000, 0x00090000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11101101, 0x00010010, 0x00039000, 0x00C90000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0d050b06, // d5b6 1
0x23456402, 0x11101111, 0x00010000, 0x00039000, 0x00090000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23056402, 0x11101111, 0x00010000, 0x00039000, 0x00090040, 0x00000B00, 0x9990C999, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x23056402, 0x11101111, 0x00010000, 0x00039000, 0x00990040, 0x00000B00, 0x99000999, 0xABCDEC0A, 0x0d050b06, // d5b6 1
0x23456032, 0x11111141, 0x00000010, 0x00000000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0c070c06, // c7c6 1
0x23456032, 0x11011141, 0x00100010, 0x00000000, 0x00099900, 0x00B00000, 0x99900099, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456032, 0x11001141, 0x00100010, 0x00019000, 0x00090900, 0x00B00000, 0x99900099, 0xA0CDECBA, 0x11071105, // h7h5 1
0x23456032, 0x11111141, 0x00000010, 0x00000000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0d070d06, // d7d6 1
0x23456032, 0x11101141, 0x00010010, 0x00000000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0c070c06, // c7c6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0d070d06, // d7d6 1
0x23456432, 0x11101111, 0x00010000, 0x00000000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00010300, 0x00000000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11101101, 0x00010310, 0x00000000, 0x00099000, 0x00B0C000, 0x99900999, 0xA00DECBA, 0x0c070c06, // c7c6 1
0x23456402, 0x11101101, 0x00010310, 0x00000000, 0x00099000, 0x00B00000, 0x9990C999, 0xA0CDE0BA, 0x0f081007, // f8g7 1
0x23456402, 0x11101101, 0x00010310, 0x00000000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0f081007, // f8g7 1
0x23456402, 0x11101101, 0x00010310, 0x00000000, 0x00099900, 0x00B00000, 0x99900099, 0xA0CDECBA, 0x0f081007, // f8g7 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00099900, 0x00B00B00, 0x99900099, 0xA0CDEC0A, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00099900, 0x00B00B00, 0x99900099, 0xA0CDEC0A, 0x0c070c05, // c7c5 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0c070c06, // c7c6 1
0x23456432, 0x11011111, 0x00100000, 0x00000000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11001111, 0x00100000, 0x00019000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0c080f05, // c8f5 1
0x23056432, 0x11001111, 0x00100000, 0x00019400, 0x00090000, 0x00900000, 0x99000999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456432, 0x11001111, 0x00100000, 0x00090000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0c060d05, // c6d5 1
0x23456432, 0x11001111, 0x00000000, 0x00010000, 0x00090000, 0x000C0000, 0x99900999, 0xABCDE0BA, 0x0b080c06, // b8c6 1
0x20456432, 0x11001111, 0x00300000, 0x00010000, 0x00090000, 0x009C0000, 0x99000999, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456432, 0x11001111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99000999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00000300, 0x00010000, 0x00990000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x23456402, 0x11001111, 0x00000300, 0x00010000, 0x00990000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0e070e06, // e7e6 1
0x23456402, 0x11001111, 0x00000300, 0x00010000, 0x00990000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11001111, 0x00100000, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0d050e04, // d5e4 1
0x23456432, 0x11001111, 0x00100000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00100B00, 0x00000000, 0x00090000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0e070f06, // e7f6 1
0x23456402, 0x11001111, 0x00100B00, 0x00000000, 0x00090000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x10070f06, // g7f6 1
0x23456432, 0x11001111, 0x00100000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0b080d07, // b8d7 1
0x23456432, 0x11001111, 0x00100000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0c080f05, // c8f5 1
0x23056432, 0x11001111, 0x00100000, 0x00000400, 0x00090000, 0x000000B0, 0x99900999, 0xA0CDECBA, 0x0f051006, // f5g6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0c050d04, // c5d4 1
0x23456432, 0x11011111, 0x00000000, 0x00000000, 0x00019000, 0x00900000, 0x99000999, 0xABCDECBA, 0x0d040c03, // d4c3 1
0x23456432, 0x11011111, 0x00000000, 0x00000000, 0x00009000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11011111, 0x00300000, 0x00000000, 0x00009000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0d070d06, // d7d6 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00B00000, 0x99990999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11011111, 0x00300000, 0x00100000, 0x00009900, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x10071006, // g7g6 1
0x20456432, 0x11011101, 0x00300010, 0x00100000, 0x00009900, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x0f081007, // f8g7 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00C09900, 0x00B00B00, 0x99990099, 0xA0CDE00A, 0x0e070e06, // e7e6 1
0x20456432, 0x11011111, 0x00300000, 0x00100000, 0x00009000, 0x00B00090, 0x99990909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x20456432, 0x11011101, 0x00300010, 0x00100000, 0x00009000, 0x00B00090, 0x999909C9, 0xA0CDE0BA, 0x0f081007, // f8g7 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00009000, 0x00B90090, 0x999009C9, 0xA0CDE0BA, 0x0e070e06, // e7e6 1
0x20456032, 0x11011141, 0x00300010, 0x00100000, 0x00009000, 0x00B90090, 0x999009C9, 0xA0CDE0BA, 0x0d070d06, // d7d6 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11011111, 0x00000300, 0x00109000, 0x00000000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0f060d05, // f6d5 1
0x23456402, 0x11011111, 0x00000000, 0x00139000, 0x00000000, 0x00B00B00, 0x99990999, 0xA0CDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11010111, 0x00001000, 0x001B9000, 0x00000000, 0x00000B00, 0x99990999, 0xA0CDEC0A, 0x0e060d05, // e6d5 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0b080c06, // b8c6 1
0x20456432, 0x11011111, 0x00300000, 0x0C100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10071006, // g7g6 1
0x20456432, 0x11011101, 0x00300010, 0x0C100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f081007, // f8g7 1
0x20456032, 0x11011141, 0x00300010, 0x0C100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDA0E0, 0x0e070e05, // e7e5 1
0x20456432, 0x11011111, 0x00300000, 0x00100000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c050d04, // c5d4 1
0x20456432, 0x11011111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0e070e05, // e7e5 1
0x20456432, 0x11010111, 0x00300000, 0x0B001000, 0x00009000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x20456432, 0x11011111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x20456402, 0x11011111, 0x00300300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0e070e05, // e7e5 1
0x20456432, 0x11011111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10071006, // g7g6 1
0x20456432, 0x11011101, 0x00300010, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0f081007, // f8g7 1
0x20456432, 0x11011101, 0x00300010, 0x00000000, 0x009B9000, 0x00000000, 0x99000999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x20456432, 0x11011101, 0x00300010, 0x00000000, 0x009B9000, 0x00000000, 0x99000999, 0xABCDEC0A, 0x0f081007, // f8g7 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456432, 0x11010111, 0x00001000, 0x00100000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c050d04, // c5d4 1
0x23456432, 0x11010111, 0x00001000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11010111, 0x00001300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x23456432, 0x11010111, 0x00001000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0a070a06, // a7a6 1
0x23456432, 0x01010111, 0x10001000, 0x00000000, 0x009B9000, 0x00000000, 0x99000999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456432, 0x01010111, 0x10001000, 0x00000000, 0x000B9000, 0x000C0000, 0x99900999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x23456432, 0x01010111, 0x10001000, 0x00000000, 0x000B9000, 0x000C0000, 0x99900999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x23456432, 0x01010111, 0x10001000, 0x00000000, 0x000B9000, 0x000C0000, 0x99900999, 0xABCDE00A, 0x10071006, // g7g6 1
0x23456432, 0x11010111, 0x00001000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0b080c06, // b8c6 1
0x20456432, 0x11010111, 0x00301000, 0x0B000000, 0x00009000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x20456432, 0x11010111, 0x00301000, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x20456432, 0x11010111, 0x00301000, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0a070a06, // a7a6 1
0x20456432, 0x11010111, 0x00301000, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0d080c07, // d8c7 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456432, 0x11001111, 0x00010000, 0x0C100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0c080d07, // c8d7 1
0x23056432, 0x110C1111, 0x00010000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0d080d07, // d8d7 1
0x23006432, 0x11051111, 0x00010000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0b080c06, // b8c6 1
0x23456432, 0x11001111, 0x00010000, 0x00100000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c050d04, // c5d4 1
0x23456432, 0x11001111, 0x00010000, 0x00000000, 0x000D9000, 0x00000B00, 0x99900999, 0xABC0EC0A, 0x0b080c06, // b8c6 1
0x20456432, 0x11001111, 0x00310000, 0x0C000000, 0x000D9000, 0x00000B00, 0x99900999, 0xABC0E00A, 0x0d080d07, // d8d7 1
0x23456432, 0x11001111, 0x00010000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00000900, 0x99900099, 0xABCDEC0A, 0x0e070e05, // e7e5 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0e070e05, // e7e5 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x20456402, 0x11011111, 0x00300300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0d070d06, // d7d6 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11001111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0a070a06, // a7a6 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456432, 0x11110111, 0x00001000, 0x00000000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00001000, 0x00090000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0e060d05, // e6d5 1
0x23456432, 0x11100111, 0x00000000, 0x00010000, 0x00090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00000300, 0x000100C0, 0x00090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0b080c06, // b8c6 1
0x23456432, 0x11100111, 0x00001000, 0x00019000, 0x00090000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11000111, 0x00001000, 0x00119000, 0x00090000, 0x00900000, 0x99000999, 0xABCDECBA, 0x0d080b06, // d8b6 1
0x23406432, 0x11000111, 0x05001000, 0x00119000, 0x00090000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0c080d07, // c8d7 1
0x23456432, 0x11000111, 0x00001000, 0x00119000, 0x00090000, 0x00900000, 0x99000999, 0xABCDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11000111, 0x00301000, 0x00119000, 0x00090000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0d080b06, // d8b6 1
0x20456432, 0x11000111, 0x00301000, 0x00119000, 0x00090000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0c080d07, // c8d7 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0f070f05, // f7f5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11100111, 0x00301000, 0x00010000, 0x00099000, 0x00000B00, 0x999B0999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00019000, 0x00090000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0f060d07, // f6d7 1
0x23456402, 0x11130111, 0x00001000, 0x00019000, 0x00090000, 0x000C0000, 0x999B0999, 0xA0CDE0BA, 0x0c070c05, // c7c5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11000111, 0x00001000, 0x00190000, 0x00090000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0d080d05, // d8d5 1
0x23406432, 0x11000111, 0x00001000, 0x00150000, 0x00090000, 0x00000B00, 0x999B0999, 0xA0CDEC0A, 0x0c050d04, // c5d4 1
0x23456432, 0x11000111, 0x00001000, 0x00190000, 0x00090000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0e060d05, // e6d5 1
0x23456432, 0x11000111, 0x00000000, 0x00110000, 0x00090000, 0x00000B00, 0x999B0999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0d050e04, // d5e4 1
0x23456432, 0x11100111, 0x00001000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0c080d07, // c8d7 1
0x23056432, 0x11140111, 0x00001000, 0x00000000, 0x0009B000, 0x00000B00, 0x99900999, 0xA0CDEC0A, 0x0d070c06, // d7c6 1
0x23456432, 0x11100111, 0x00001000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0b080d07, // b8d7 1
0x20456432, 0x11130111, 0x00001000, 0x00000000, 0x0009B000, 0x00000B00, 0x99900999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x23456432, 0x11100111, 0x00001000, 0x00000000, 0x0009B000, 0x00000000, 0x99900999, 0xA0CDECBA, 0x0d080d05, // d8d5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00019000, 0x00090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0f060d07, // f6d7 1
0x23456402, 0x11130111, 0x00001000, 0x00019000, 0x00090900, 0x00B00000, 0x99900099, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00099000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0d050e04, // d5e4 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00099000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0f080b04, // f8b4 1
0x23456002, 0x11100111, 0x00001300, 0x000900C0, 0x04090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0d080d05, // d8d5 1
0x23456002, 0x11100111, 0x00001300, 0x000190C0, 0x04090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x11071106, // h7h6 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00099000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0f080e07, // f8e7 1
0x23456002, 0x11104111, 0x00001C00, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0e070f06, // e7f6 1
0x23456002, 0x11104111, 0x00001300, 0x000190C0, 0x00090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0f061008, // f6g8 1
0x23456002, 0x11104111, 0x00001300, 0x000190C0, 0x00090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0f060e04, // f6e4 1
0x23456002, 0x11104111, 0x00001300, 0x000190C0, 0x00090000, 0x00B00000, 0x99900999, 0xA00DECBA, 0x0f060d07, // f6d7 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0f080b04, // f8b4 1
0x23456032, 0x11100111, 0x00001000, 0x00010000, 0x04099000, 0x00BC0000, 0x99900999, 0xA0CDE0BA, 0x0c070c05, // c7c5 1
0x23456032, 0x11000111, 0x00001000, 0x00190000, 0x04090000, 0x00BC0000, 0x99900999, 0xA0CDE0BA, 0x0d080d05, // d8d5 1
0x23456032, 0x11100111, 0x00001000, 0x00010000, 0x04099000, 0x00B00000, 0x9990B999, 0xA0CDEC0A, 0x0d050e04, // d5e4 1
0x23456032, 0x11100111, 0x00001000, 0x00000000, 0x04091000, 0x90B00000, 0x0990B999, 0xA0CDEC0A, 0x0b040e07, // b4e7 1
0x23456032, 0x11100111, 0x00001000, 0x00000000, 0x04091000, 0x90B00000, 0x0990B999, 0xA0CDEC0A, 0x0b040c03, // b4c3 1
0x23456032, 0x11100111, 0x00001000, 0x00019000, 0x04090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0d080d07, // d8d7 1
0x23456032, 0x11100111, 0x00001000, 0x00019000, 0x04090000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456032, 0x11000111, 0x00001000, 0x00119000, 0x04090000, 0x90B00000, 0x09900999, 0xA0CDECBA, 0x0c050d04, // c5d4 1
0x23456032, 0x11000111, 0x00001000, 0x00119000, 0x04090000, 0x90B00000, 0x09900999, 0xA0CDECBA, 0x0b040c03, // b4c3 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00009000, 0x00000000, 0x99990999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00099000, 0x00000000, 0x99900999, 0xABCDECBA, 0x0e050d04, // e5d4 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00019000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c070c05, // c7c5 1
0x23456432, 0x11010111, 0x00000000, 0x00100000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00019000, 0x00900000, 0x99000999, 0xABCDECBA, 0x0d040c03, // d4c3 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09000, 0x00100000, 0x99000999, 0xABCDE0BA, 0x0c030b02, // c3b2 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09000, 0x00000000, 0x9C000999, 0xAB0DE0BA, 0x0d080e07, // d8e7 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09000, 0x00000000, 0x9C000999, 0xAB0DE0BA, 0x0d070d05, // d7d5 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x000D9000, 0x00000000, 0x99900999, 0xABC0ECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009000, 0x0000D000, 0x99900999, 0xABC0ECBA, 0x0f080b04, // f8b4 1
0x20456032, 0x11110111, 0x00300000, 0x00000000, 0x04009000, 0x0090D000, 0x99000999, 0xABC0ECBA, 0x0b040e07, // b4e7 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009000, 0x0000D000, 0x99900999, 0xABC0ECBA, 0x0f070f05, // f7f5 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009000, 0x0000D000, 0x99900999, 0xABC0ECBA, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00000000, 0x00009000, 0x00B0D000, 0x99900999, 0xA0C0ECBA, 0x0f080b04, // f8b4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00C09000, 0x00000000, 0x99990999, 0xABCDE0BA, 0x0c070c06, // c7c6 1
0x23456432, 0x11010111, 0x00100000, 0x00001000, 0x00C99000, 0x00000000, 0x99900999, 0xABCDE0BA, 0x0d070d05, // d7d5 1
0x23456432, 0x11000111, 0x00100000, 0x00091000, 0x00C90000, 0x00000000, 0x99900999, 0xABCDE0BA, 0x0c060d05, // c6d5 1
0x23456432, 0x11000111, 0x00000000, 0x0C011000, 0x00090000, 0x00000000, 0x99900999, 0xABCDE0BA, 0x0c080d07, // c8d7 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00C09000, 0x00000000, 0x99990999, 0xABCDE0BA, 0x0f080c05, // f8c5 1
0x23456032, 0x11110111, 0x00000000, 0x00401000, 0x00C09000, 0x00000000, 0x9999D999, 0xABC0E0BA, 0x0b080c06, // b8c6 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00900000, 0x9909D999, 0xABC0E0BA, 0x10080f06, // g8f6 1
0x23456032, 0x11110111, 0x00000000, 0x00401000, 0x00C09000, 0x00900000, 0x99090999, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456002, 0x11110111, 0x00000300, 0x00401000, 0x00C99000, 0x00900000, 0x99000999, 0xABCDE0BA, 0x0e050d04, // e5d4 1
0x23456002, 0x11110111, 0x00000300, 0x00409000, 0x00C10000, 0x00900000, 0x99000999, 0xABCDE0BA, 0x0d070d05, // d7d5 1
0x23456032, 0x11110111, 0x00000000, 0x00401000, 0x09C09000, 0x00000000, 0x90990999, 0xABCDE0BA, 0x0c050b04, // c5b4 1
0x23456032, 0x11110111, 0x00000000, 0x00001000, 0x04C09900, 0x00000000, 0x90990099, 0xABCDE0BA, 0x0e050f04, // e5f4 1
0x23456032, 0x11110111, 0x00000000, 0x00000000, 0x04C09100, 0x00000B00, 0x90990099, 0xABCDE00A, 0x0b040e07, // b4e7 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00C09000, 0x00000000, 0x99990999, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00C99000, 0x00000000, 0x99900999, 0xABCDE0BA, 0x0e050d04, // e5d4 1
0x23456402, 0x11110111, 0x00000300, 0x00000000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00000300, 0x00090000, 0x00C10000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0f080b04, // f8b4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00B00000, 0x99990999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009900, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x0e050f04, // e5f4 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00099100, 0x00B00000, 0x99900099, 0xA0CDECBA, 0x0d081104, // d8h4 1
0x20406432, 0x11110111, 0x00300000, 0x00000000, 0x00099105, 0x00B00000, 0x9990E099, 0xA0CD0CBA, 0x0d070d05, // d7d5 1
0x20406432, 0x11110111, 0x00300000, 0x00000000, 0x00099105, 0x00B00000, 0x9990E099, 0xA0CD0CBA, 0x0b070b06, // b7b6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009100, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x10071005, // g7g5 1
0x20456432, 0x11110101, 0x00300000, 0x00000010, 0x00009109, 0x00B00B00, 0x99990090, 0xA0CDEC0A, 0x10051004, // g5g4 1
0x20456432, 0x11110101, 0x00300000, 0x00000010, 0x00C09100, 0x00B00B00, 0x99990099, 0xA0CDE00A, 0x10051004, // g5g4 1
0x20456432, 0x11110101, 0x00300000, 0x00000010, 0x00099100, 0x00B00B00, 0x99900099, 0xA0CDEC0A, 0x10051004, // g5g4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00B00000, 0x99990999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00C09000, 0x00B00000, 0x99990999, 0xA0CDE0BA, 0x0f060e04, // f6e4 1
0x23456402, 0x11110111, 0x00000000, 0x0000100D, 0x00C03000, 0x00B00000, 0x99990999, 0xA0C0E0BA, 0x0e040d06, // e4d6 1
0x23456402, 0x11110111, 0x00030000, 0x0000100D, 0x00000000, 0x0CB00000, 0x99990999, 0xA0C0E0BA, 0x0b080c06, // b8c6 1
0x23456402, 0x11110111, 0x00030000, 0x0000100D, 0x00000000, 0x0CB00000, 0x99990999, 0xA0C0E0BA, 0x0f080e07, // f8e7 1
0x23456402, 0x11110111, 0x00000000, 0x00001000, 0x00C03000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0d070d05, // d7d5 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00009900, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00000300, 0x00019000, 0x00009000, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x0f060e04, // f6e4 1
0x23456402, 0x11100111, 0x00000000, 0x00019000, 0x00003000, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x23456402, 0x11100111, 0x00000000, 0x00019000, 0x00003000, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00000000, 0x00019000, 0x00003000, 0x00B00D00, 0x99990099, 0xA0C0ECBA, 0x0f070f05, // f7f5 1
0x23456402, 0x11100111, 0x00000000, 0x00019000, 0x00003000, 0x00B90000, 0x99900099, 0xA0CDECBA, 0x0d081104, // d8h4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0d080f06, // d8f6 1
0x23406432, 0x11110111, 0x00000500, 0x00001000, 0x00009900, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x0f060f04, // f6f4 1
0x23406432, 0x11110111, 0x00000000, 0x00001000, 0x00009500, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0f080c05, // f8c5 1
0x23456032, 0x11110111, 0x00000000, 0x00401000, 0x00009900, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456032, 0x11100111, 0x00010000, 0x00401000, 0x00009900, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x23456002, 0x11100111, 0x00010300, 0x00401000, 0x00C09900, 0x00B00B00, 0x99990099, 0xA0CDE00A, 0x0b080c06, // b8c6 1
0x23456032, 0x11100111, 0x00010000, 0x00401000, 0x00009900, 0x00B00B00, 0x99990099, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x23456032, 0x11100111, 0x00010000, 0x00401000, 0x00009900, 0x00900B00, 0x99090099, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23056032, 0x11100111, 0x00010000, 0x00409000, 0x00009040, 0x00900B00, 0x99090099, 0xABCDEC0A, 0x0d060e05, // d6e5 1
0x23456032, 0x11100111, 0x00010000, 0x00401000, 0x00009900, 0x00900B00, 0x99090099, 0xABCDEC0A, 0x0f070f05, // f7f5 1
0x23456032, 0x11100011, 0x00010000, 0x00409100, 0x00009000, 0x00900B00, 0x99090099, 0xABCDEC0A, 0x0d060e05, // d6e5 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00000000, 0x00091000, 0x00000900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0e050e04, // e5e4 1
0x23456432, 0x11100111, 0x00000000, 0x00090000, 0x00001900, 0x00B00000, 0x99990099, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456432, 0x11100111, 0x00000000, 0x00090000, 0x00001900, 0x00090000, 0x99900099, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00000300, 0x00090000, 0x00001900, 0x00B90000, 0x99900099, 0xA0CDECBA, 0x0f080b04, // f8b4 1
0x23456402, 0x11100111, 0x00000300, 0x00090000, 0x00009900, 0x00000000, 0x99900099, 0xABCDECBA, 0x0f060e04, // f6e4 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009900, 0x00000000, 0x99990099, 0xABCDECBA, 0x0e050f04, // e5f4 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x0d081104, // d8h4 1
0x23406432, 0x11110111, 0x00000000, 0x00000000, 0x00C09105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x0d070d05, // d7d5 1
0x23406432, 0x11100111, 0x00000000, 0x000C0000, 0x00009105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x10071005, // g7g5 1
0x23406432, 0x11110111, 0x00000000, 0x00000000, 0x00C09105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x0f080c05, // f8c5 1
0x23406432, 0x11110111, 0x00000000, 0x00000000, 0x00C09105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x10071005, // g7g5 1
0x23406432, 0x11110101, 0x00000000, 0x00000010, 0x00C09105, 0x00B00000, 0x99990099, 0xA0CD0EBA, 0x0f081007, // f8g7 1
0x23406432, 0x11110111, 0x00000000, 0x00000000, 0x00C09105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x0b080c06, // b8c6 1
0x23406432, 0x11110111, 0x00000000, 0x00000000, 0x00C09105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x0b070b05, // b7b5 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x0f070f05, // f7f5 1
0x23456432, 0x11110011, 0x00000000, 0x00000100, 0x00C09100, 0x00000000, 0x9999D099, 0xABC0E0BA, 0x0d081104, // d8h4 1
0x23406432, 0x11110011, 0x00000000, 0x00000100, 0x00C09105, 0x00000000, 0x9999D099, 0xABCE00BA, 0x0f050e04, // f5e4 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00000000, 0x000C0000, 0x00009100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x0d081104, // d8h4 1
0x23406432, 0x11100111, 0x00000000, 0x000C0000, 0x00009105, 0x00000000, 0x99990099, 0xABCD0EBA, 0x0f080d06, // f8d6 1
0x23456432, 0x11100111, 0x00000000, 0x000C0000, 0x00009100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x0c070c06, // c7c6 1
0x23456432, 0x11100111, 0x00000000, 0x000C0000, 0x00009100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00C09100, 0x00000000, 0x99990099, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x00000000, 0x00C09100, 0x00B00000, 0x99990099, 0xA0CDE0BA, 0x0f080b04, // f8b4 1
0x23456402, 0x11110111, 0x00000300, 0x00000000, 0x00C09100, 0x00B00000, 0x99990099, 0xA0CDE0BA, 0x0c070c06, // c7c6 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00009100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x0f080e07, // f8e7 1
0x23456032, 0x11114111, 0x00000000, 0x00000000, 0x00C09100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x0e071104, // e7h4 1
0x23456032, 0x11110111, 0x00000000, 0x00000000, 0x00C09104, 0x00000B90, 0x99990009, 0xABCDE00A, 0x0f041003, // f4g3 1
0x23456032, 0x11114111, 0x00000000, 0x00000000, 0x00C09100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x10080f06, // g8f6 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00009100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00000000, 0x00090000, 0x00000100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00000300, 0x0C090000, 0x00000100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00009100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x10071005, // g7g5 1
0x23456432, 0x11110101, 0x00000000, 0x00000010, 0x00099100, 0x00000B00, 0x99900099, 0xABCDEC0A, 0x10051004, // g5g4 1
0x23456432, 0x11110101, 0x00000000, 0x00000010, 0x00C09100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x0b080c06, // b8c6 1
0x23456432, 0x11110101, 0x00000000, 0x00000010, 0x00C09100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x10051004, // g5g4 1
0x23456432, 0x11110C01, 0x00000000, 0x00000000, 0x00009110, 0x00000B00, 0x99990099, 0xABCDE00A, 0x0e080f07, // e8f7 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00C09110, 0x00000000, 0x99990099, 0xABCDE00A, 0x0d081104, // d8h4 1
0x23456432, 0x11110101, 0x00000000, 0x00000000, 0x00C09110, 0x00000B00, 0x99990099, 0xABCD0AE0, 0x10040f03, // g4f3 1
0x23456432, 0x11110101, 0x00000000, 0x00000000, 0x00C09110, 0x00000B00, 0x99990099, 0xABCD0AE0, 0x0d080e07, // d8e7 1
0x23456432, 0x11110101, 0x00000000, 0x00000000, 0x00C09110, 0x00000B00, 0x99990099, 0xABCD0AE0, 0x0d070d05, // d7d5 1
0x23456432, 0x11110101, 0x00000000, 0x00000010, 0x00C09100, 0x00000B00, 0x99990099, 0xABCDE00A, 0x0f081007, // f8g7 1
0x23456032, 0x11110141, 0x00000000, 0x00000010, 0x00C09109, 0x00000B00, 0x99990090, 0xABCDE00A, 0x11071106, // h7h6 1
0x23456432, 0x11110101, 0x00000000, 0x00000010, 0x00009109, 0x00000B00, 0x99990090, 0xABCDEC0A, 0x10051004, // g5g4 1
0x23456432, 0x11110101, 0x00000000, 0x000000B0, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x11071106, // h7h6 1
0x23456432, 0x11110101, 0x00000000, 0x000000B0, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0f081007, // f8g7 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x11071105, // h7h5 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0d080e07, // d8e7 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0f080e07, // f8e7 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0b080c06, // b8c6 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456432, 0x11110101, 0x00000000, 0x0000B000, 0x00009119, 0x00000000, 0x99990090, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0f070f05, // f7f5 1
0x23456432, 0x11110011, 0x00000000, 0x0000B100, 0x00009000, 0x00000000, 0x99990999, 0xABCDEC0A, 0x0d080f06, // d8f6 1
0x23406432, 0x11110011, 0x00000500, 0x0000B100, 0x00099000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23406432, 0x11100011, 0x00010500, 0x00000100, 0x00B99000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0f050e04, // f5e4 1
0x23456432, 0x11110011, 0x00000000, 0x00001100, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f050e04, // f5e4 1
0x23456432, 0x11110011, 0x00000000, 0x0000B000, 0x00C01000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0d081005, // d8g5 1
0x23406432, 0x11110B11, 0x00000000, 0x00000050, 0x00C01000, 0x00000000, 0x99990999, 0xABCDE00A, 0x10051002, // g5g2 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x23456432, 0x11100011, 0x00010000, 0x00001100, 0x00C99000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x23456432, 0x11100011, 0x00010000, 0x000001B0, 0x00C19000, 0x00000000, 0x99900999, 0xABCDE00A, 0x10081106, // g8h6 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0f070f05, // f7f5 1
0x23456432, 0x11100011, 0x00010000, 0x00009100, 0x00009000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0f050e04, // f5e4 1
0x23456432, 0x11100011, 0x00010000, 0x000090B0, 0x00001000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d060d05, // d6d5 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0e050d04, // e5d4 1
0x23456432, 0x11100111, 0x00010000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d060d05, // d6d5 1
0x23456432, 0x11100111, 0x00010000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00010300, 0x00000000, 0x000B9000, 0x00B00000, 0x99900999, 0xA0CDEC0A, 0x0f080e07, // f8e7 1
0x23456432, 0x11100111, 0x00010000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10071006, // g7g6 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00010300, 0x00001000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x20456402, 0x11130111, 0x00010300, 0x00001000, 0x00C99000, 0x00B00B00, 0x99900999, 0xA0CDE00A, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00010300, 0x00009000, 0x00009000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0f060e04, // f6e4 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0b080d07, // b8d7 1
0x20456432, 0x11130111, 0x00010000, 0x00001000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x20456432, 0x11030111, 0x00110000, 0x00001000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0f080e07, // f8e7 1
0x20456432, 0x11030111, 0x00110000, 0x000010B0, 0x00C99000, 0x00000000, 0x99900999, 0xABCDE00A, 0x10081106, // g8h6 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x0000B000, 0x00009000, 0x00000000, 0x99990999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x23456402, 0x11100111, 0x00010300, 0x00000000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0f060e04, // f6e4 1
0x23456402, 0x11100111, 0x00010000, 0x00000000, 0x00093000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0d060d05, // d6d5 1
0x23456402, 0x11100111, 0x00010000, 0x00000000, 0x00093000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0e040f06, // e4f6 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0e050d04, // e5d4 1
0x23456402, 0x11110111, 0x00000300, 0x00009000, 0x00010000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0f060e04, // f6e4 1
0x23456402, 0x11110111, 0x00000000, 0x00009000, 0x00013000, 0x00000B00, 0x9990D999, 0xABC0EC0A, 0x0e040c05, // e4c5 1
0x23456402, 0x11110111, 0x00000300, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0f060e04, // f6e4 1
0x23456402, 0x11110111, 0x00000000, 0x00001000, 0x00093000, 0x000C0B00, 0x99900999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00000000, 0x0001B000, 0x00093000, 0x000C0000, 0x99900999, 0xABCDE00A, 0x0f080d06, // f8d6 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0b080c06, // b8c6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00000B00, 0x9999C999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00009000, 0x00090B00, 0x9990C999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x20456432, 0x11100111, 0x00300000, 0x00011000, 0xD0009000, 0x00900B00, 0x99090999, 0xABC0EC0A, 0x0c080d07, // c8d7 1
0x20456432, 0x11100111, 0x00300000, 0x00011000, 0xD0009000, 0x00900B00, 0x99090999, 0xABC0EC0A, 0x10080f06, // g8f6 1
0x20456432, 0x11100111, 0x00300000, 0x00011000, 0xD0009000, 0x00900B00, 0x99090999, 0xABC0EC0A, 0x0f070f06, // f7f6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00099000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0f060e04, // f6e4 1
0x20456402, 0x11110111, 0x00300000, 0x00091000, 0x00003000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0f080c05, // f8c5 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDEC0A, 0x0f070f05, // f7f5 1
0x20456432, 0x11110011, 0x00300000, 0x00001100, 0x00099000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x20456432, 0x11100011, 0x00310000, 0x00091100, 0x00009000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0f050e04, // f5e4 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0c060d04, // c6d4 1
0x20456432, 0x11110111, 0x00000000, 0x0000B000, 0x00039000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d040e06, // d4e6 1
0x20456432, 0x11110111, 0x00003000, 0x0000B000, 0x00C09000, 0x00000000, 0x99900999, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDEC0A, 0x0e050d04, // e5d4 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00019000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0d040c03, // d4c3 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0d070d06, // d7d6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00009000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456032, 0x11110111, 0x00300000, 0x00400000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0d070d06, // d7d6 1
0x20456032, 0x11110111, 0x00300000, 0x004000B0, 0x00C19000, 0x00000000, 0x99900999, 0xABCDE00A, 0x10081106, // g8h6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0f080b04, // f8b4 1
0x20456032, 0x11110111, 0x00300000, 0x00000000, 0x04C19000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x0d040c03, // d4c3 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0c060d04, // c6d4 1
0x20456432, 0x11110111, 0x00000000, 0x00000000, 0x000D9000, 0x00000000, 0x99900999, 0xABC0EC0A, 0x0d070d06, // d7d6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0d081104, // d8h4 1
0x20406432, 0x11110111, 0x00300000, 0x0B000000, 0x00009005, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0f080b04, // f8b4 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00B00300, 0x00000000, 0x00009000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0b070c06, // b7c6 1
0x20456432, 0x11110111, 0x00300000, 0x00000000, 0x000B9000, 0x00000000, 0x99900999, 0xABCDEC0A, 0x0f080c05, // f8c5 1
0x20456032, 0x11110111, 0x00300000, 0x00400000, 0x000B9000, 0x0000C000, 0x99900999, 0xAB0DEC0A, 0x0d080f06, // d8f6 1
0x20456032, 0x11110111, 0x00300000, 0x00400000, 0x00009000, 0x0B000000, 0x99900999, 0xABCDEC0A, 0x0c050b04, // c5b4 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDEC0A, 0x10071006, // g7g6 1
0x20456432, 0x11110101, 0x00300010, 0x00001000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0e050d04, // e5d4 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDEC0A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDEC0A, 0x0e050d04, // e5d4 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0a070a06, // a7a6 1
0x20456402, 0x01110111, 0x10C00300, 0x00001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0d070c06, // d7c6 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0f080c05, // f8c5 1
0x20456002, 0x11110111, 0x00300300, 0x0C401000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CD0AE0, 0x0e081008, // e8g8 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0c060d04, // c6d4 1
0x20456402, 0x11110111, 0x00000300, 0x0C00B000, 0x00039000, 0x00B00000, 0x99990999, 0xA0CDE00A, 0x0d080e07, // d8e7 1
0x20456402, 0x11110111, 0x00000300, 0x00001000, 0x00039000, 0x00B00B00, 0x9999C999, 0xA0CDE00A, 0x0d040f03, // d4f3 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0f080b04, // f8b4 1
0x20456002, 0x11110111, 0x00300300, 0x0C001000, 0x04009000, 0x00B00B00, 0x99990999, 0xA0CD0AE0, 0x0e081008, // e8g8 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0c060d04, // c6d4 1
0x20456432, 0x11110111, 0x00000000, 0x0000B000, 0x00C39000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0d081005, // d8g5 1
0x20406432, 0x11110B11, 0x00000000, 0x00000050, 0x00C39000, 0x00000000, 0x99990999, 0xABCDE00A, 0x10051002, // g5g2 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f080e07, // f8e7 1
0x20456032, 0x11114111, 0x00300000, 0x00001000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456032, 0x11114111, 0x00300000, 0x00000000, 0x00C19000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x20456032, 0x11110011, 0x00300000, 0x004011B0, 0x00C09000, 0x00090000, 0x99900999, 0xABCDE00A, 0x0f050f04, // f5f4 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456002, 0x11110111, 0x00300300, 0x00401000, 0x00C09000, 0x00B90B00, 0x99900999, 0xA0CDE00A, 0x0d070d06, // d7d6 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x09C09000, 0x00000B00, 0x90990999, 0xABCDE00A, 0x0c050b06, // c5b6 1
0x20456032, 0x11110111, 0x04300000, 0x09001000, 0x00C09000, 0x00000B00, 0x90990999, 0xABCDE00A, 0x0c060a05, // c6a5 1
0x20456032, 0x11110111, 0x04300000, 0x00001000, 0x99C09000, 0x00000B00, 0x00990999, 0xABCDE00A, 0x0a070a06, // a7a6 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x09C09000, 0x00000B00, 0x90990999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x09C09000, 0x00000B00, 0x90990999, 0xABCDE00A, 0x0c050b04, // c5b4 1
0x20456032, 0x11110111, 0x00300000, 0x00001000, 0x04C09000, 0x00900B00, 0x90090999, 0xABCDE00A, 0x0b040c05, // b4c5 1
0x20456032, 0x11110111, 0x00300000, 0x00001000, 0x04C09000, 0x00900B00, 0x90090999, 0xABCDE00A, 0x0b040d06, // b4d6 1
0x20456032, 0x11110111, 0x00300000, 0x00001000, 0x04C09000, 0x00900B00, 0x90090999, 0xABCDE00A, 0x0b040f08, // b4f8 1
0x20456032, 0x11110111, 0x00300000, 0x00001000, 0x04C09000, 0x00900B00, 0x90090999, 0xABCDE00A, 0x0b040e07, // b4e7 1
0x20456032, 0x11110111, 0x00300000, 0x00001000, 0x04C09000, 0x00900B00, 0x90090999, 0xABCDE00A, 0x0b040a05, // b4a5 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456032, 0x11100111, 0x00310000, 0x00401000, 0x00C99000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0d080e07, // d8e7 1
0x20406032, 0x11115111, 0x00300000, 0x00401000, 0x00C99000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x0c050b06, // c5b6 1
0x20456032, 0x11110111, 0x00300000, 0x00401000, 0x00C09000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456002, 0x11110111, 0x00300300, 0x00401000, 0x00C99000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00C09000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f080c05, // f8c5 1
0x20456002, 0x11110111, 0x00300300, 0x00401000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0c050d04, // c5d4 1
0x20456402, 0x11110111, 0x00300300, 0x00001000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456402, 0x11110111, 0x00300300, 0x00009000, 0x00C10000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x20456402, 0x11110111, 0x00300300, 0x00000000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0f080c05, // f8c5 1
0x20456402, 0x11110111, 0x00300300, 0x00000000, 0x00C19000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0f060e04, // f6e4 1
0x20456402, 0x11110111, 0x00300300, 0x000010B0, 0x00C09000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456402, 0x11110111, 0x00300300, 0x000010B0, 0x00C09000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0d070d05, // d7d5 1
0x20456402, 0x11100111, 0x00300300, 0x000910B0, 0x00C00000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x20456402, 0x11100111, 0x00300300, 0x000910B0, 0x00C00000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0c060d04, // c6d4 1
0x20456402, 0x11100111, 0x00300300, 0x000910B0, 0x00C00000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0f060d05, // f6d5 1
0x20456402, 0x11100111, 0x00300300, 0x000910B0, 0x00C00000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0c060a05, // c6a5 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0c060d04, // c6d4 1
0x20456432, 0x11110111, 0x00000000, 0x0C001000, 0x000B9000, 0x00000000, 0x99990999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456432, 0x11110111, 0x00000000, 0x0C000000, 0x00019000, 0x00000000, 0x99990999, 0xABCD0AE0, 0x10080e07, // g8e7 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456432, 0x11100111, 0x00310000, 0x0C001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0c080d07, // c8d7 1
0x20056432, 0x11140111, 0x00310000, 0x0C001000, 0x00099000, 0x00B00B00, 0x99900999, 0xA0CDE00A, 0x10080f06, // g8f6 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456032, 0x11110111, 0x00300000, 0x0C401000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0c060d04, // c6d4 1
0x20456032, 0x11110111, 0x00300000, 0x0C401000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456002, 0x11110111, 0x00300300, 0x0C401000, 0x00009000, 0x00900B00, 0x99090999, 0xABCD0AE0, 0x0e081008, // e8g8 1
0x20456032, 0x11110111, 0x00300000, 0x0C401000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0c050b06, // c5b6 1
0x20456032, 0x11110111, 0x00300000, 0x0C401000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0d080e07, // d8e7 1
0x20456032, 0x11110111, 0x00300000, 0x0C401000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0c060e07, // c6e7 1
0x20456402, 0x11113111, 0x00000300, 0x0C00B000, 0x00009000, 0x00090000, 0x99900999, 0xABCDE00A, 0x0c070c06, // c7c6 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f080c05, // f8c5 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0d070d06, // d7d6 1
0x20456402, 0x11100111, 0x00310300, 0x0C001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0c080d07, // c8d7 1
0x20456402, 0x11100111, 0x00310300, 0x0C001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0f060d07, // f6d7 1
0x20456402, 0x11110111, 0x00300300, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f060e04, // f6e4 1
0x20456402, 0x11110111, 0x00300000, 0x0C001000, 0x00093000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0e040d06, // e4d6 1
0x20456402, 0x11110111, 0x00300000, 0x0C001000, 0x00093000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0f080e07, // f8e7 1
0x20456402, 0x11110111, 0x00300000, 0x0C001000, 0x00093000, 0x00000B00, 0x99900999, 0xABCD0AE0, 0x0a070a06, // a7a6 1
0x20456432, 0x11110111, 0x00300000, 0x0C001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0a070a06, // a7a6 1
0x20456432, 0x01110111, 0x10C00000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0d070c06, // d7c6 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00099000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0f070f06, // f7f6 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0c081004, // c8g4 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f070f06, // f7f6 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0d080d06, // d8d6 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10071006, // g7g6 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10080e07, // g8e7 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0c060d04, // c6d4 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f080b04, // f8b4 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x20456432, 0x00110111, 0x10300000, 0x01001000, 0x00009000, 0x0C000B00, 0x99990999, 0xABCDE00A, 0x0f080c05, // f8c5 1
0x20456432, 0x00110111, 0x10300000, 0x01001000, 0x00009000, 0x0C000B00, 0x99990999, 0xABCDE00A, 0x0c060a05, // c6a5 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456432, 0x01100111, 0x10310000, 0x00001000, 0xC0099000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x20456432, 0x01100111, 0x10C10000, 0x00001000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x0b070c06, // b7c6 1
0x20456432, 0x01100111, 0x10310000, 0x00001000, 0xC0009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0f070f05, // f7f5 1
0x20456432, 0x01100111, 0x10310000, 0x00001000, 0xC0009000, 0x00900B00, 0x99090999, 0xABCDE00A, 0x0c080d07, // c8d7 1
0x20456432, 0x01110111, 0x10300000, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x9999D999, 0xABC0E00A, 0x0b070b05, // b7b5 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0b070b05, // b7b5 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f080c05, // f8c5 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0d070d06, // d7d6 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f060e04, // f6e4 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00000B00, 0x99990999, 0xABCD0AE0, 0x0f080e07, // f8e7 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00090000, 0x00000000, 0x99909999, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00090000, 0x00B00000, 0x99909999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00000300, 0x00010000, 0x00099000, 0x00B00000, 0x99900999, 0xA0CDECBA, 0x0d050e04, // d5e4 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00091000, 0x00B00900, 0x99900099, 0xA0CDECBA, 0x0e040f03, // e4f3 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00090000, 0x00B00B00, 0x99900099, 0xA0CDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11101111, 0x00000300, 0x000100C0, 0x00090000, 0x00B00000, 0x99909999, 0xA00DECBA, 0x0c080f05, // c8f5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00090000, 0x00000B00, 0x99909999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00000300, 0x00010000, 0x00090000, 0x00009B00, 0x99900999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00090000, 0x00009B00, 0x999B0999, 0xA0CDEC0A, 0x0c070c05, // c7c5 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00090000, 0x000C9B00, 0x99900999, 0xABCDE00A, 0x0c070c05, // c7c5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11101111, 0x00300000, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d050c04, // d5c4 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e05, // e7e5 1
0x23456432, 0x11100111, 0x00000000, 0x00019000, 0x00900000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0d050d04, // d5d4 1
0x23456432, 0x11100111, 0x00000000, 0x00009000, 0x00910000, 0x00009000, 0x99000999, 0xABCDECBA, 0x0f080b04, // f8b4 1
0x23456032, 0x11100111, 0x00000000, 0x00009000, 0x04910000, 0x00009000, 0x990C0999, 0xAB0DECBA, 0x0d040e03, // d4e3 1
0x23456432, 0x11100111, 0x00000000, 0x00009000, 0x00910000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0b080c06, // b8c6 1
0x20456432, 0x11100111, 0x00300000, 0x00009000, 0x00910000, 0x00000B00, 0x990B9999, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x20456432, 0x11100111, 0x00300000, 0x00009000, 0x00910000, 0x00000B00, 0x990B9999, 0xA0CDEC0A, 0x0f070f06, // f7f6 1
0x20456432, 0x11100111, 0x00300000, 0x00009000, 0x00910000, 0x00000B00, 0x990B9999, 0xA0CDEC0A, 0x0d080e07, // d8e7 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0c070c06, // c7c6 1
0x23456432, 0x11001111, 0x00100000, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d050c04, // d5c4 1
0x23456432, 0x11001111, 0x00100000, 0x00010000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00990000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c080f05, // c8f5 1
0x23056402, 0x11001111, 0x00100300, 0x00090400, 0x00090000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c060d05, // c6d5 1
0x23456402, 0x11001111, 0x00100300, 0x00090000, 0x00090000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0c060d05, // c6d5 1
0x23456402, 0x11001111, 0x00000300, 0x00010000, 0x00090000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11001111, 0x00100300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0d050c04, // d5c4 1
0x23456402, 0x11001111, 0x00100300, 0x00000000, 0x00199000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0b070b05, // b7b5 1
0x23456402, 0x11001111, 0x00100300, 0x00000000, 0x90190000, 0x00B00B00, 0x09009999, 0xA0CDEC0A, 0x0b080a06, // b8a6 1
0x23456402, 0x11001111, 0x00100300, 0x00000000, 0x90190000, 0x00B00B00, 0x09009999, 0xA0CDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11001111, 0x00100300, 0x00000000, 0x90190000, 0x00B00B00, 0x09009999, 0xA0CDEC0A, 0x0c081004, // c8g4 1
0x23456402, 0x11001111, 0x00100300, 0x00000000, 0x90190000, 0x00B00B00, 0x09009999, 0xA0CDEC0A, 0x0c080f05, // c8f5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0d050c04, // d5c4 1
0x23456432, 0x11101111, 0x00000000, 0x00000000, 0x00199000, 0x00000000, 0x99000999, 0xABCDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11001111, 0x00000000, 0x00190000, 0x00109000, 0x00000000, 0x99000999, 0xABCDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11001111, 0x00000300, 0x00190000, 0x00109000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0b070b05, // b7b5 1
0x23456432, 0x11101111, 0x00000000, 0x00000000, 0x00190000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0a070a06, // a7a6 1
0x23456432, 0x01101111, 0x10000000, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23056432, 0x01101111, 0x10000000, 0x00000000, 0x00C90040, 0x00009B00, 0x99000999, 0xABCDE00A, 0x0e070e06, // e7e6 1
0x23456432, 0x01101111, 0x10000000, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0b070b05, // b7b5 1
0x23456432, 0x11101111, 0x00000000, 0x00000000, 0x00190000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00190000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0a070a06, // a7a6 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c081004, // c8g4 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c080e06, // c8e6 1
0x23456402, 0x11101111, 0x00000300, 0x00000000, 0x00190000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11100111, 0x00001300, 0x00000000, 0x00C90000, 0x00009B00, 0x99000999, 0xABCDE00A, 0x0c070c05, // c7c5 1
0x23456432, 0x11101111, 0x00000000, 0x00010000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c070c06, // c7c6 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00009B00, 0x990B0999, 0xA0CDEC0A, 0x0f060e04, // f6e4 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00009B00, 0x990B0999, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00009B00, 0x990B0999, 0xA0CDEC0A, 0x10071006, // g7g6 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0b080d07, // b8d7 1
0x20456402, 0x11130111, 0x00001300, 0x000100C0, 0x00990000, 0x00009B00, 0x99000999, 0xAB0DEC0A, 0x0c070c06, // c7c6 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0f080b04, // f8b4 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x11071106, // h7h6 1
0x23456402, 0x11100110, 0x00001C01, 0x00010000, 0x00990000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0d080f06, // d8f6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0c070c06, // c7c6 1
0x23456432, 0x11000111, 0x00101000, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0d050c04, // d5c4 1
0x23456432, 0x11000111, 0x00101000, 0x00000000, 0x90190000, 0x00B00B00, 0x09009999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11000111, 0x00001000, 0x00190000, 0x00090000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0c050d04, // c5d4 1
0x23456432, 0x11000111, 0x00001000, 0x00190000, 0x00090000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0e060d05, // e6d5 1
0x23456432, 0x11000111, 0x00000000, 0x00910000, 0x00000000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d050d04, // d5d4 1
0x23456432, 0x11000111, 0x00000000, 0x00110000, 0x00090000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00090000, 0x00090000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0e060d05, // e6d5 1
0x23456402, 0x11100111, 0x00000300, 0x00010000, 0x00090000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x23456402, 0x11100111, 0x00000300, 0x000100C0, 0x00090000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00000300, 0x000100C0, 0x00090000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0c070c06, // c7c6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0f080b04, // f8b4 1
0x23456002, 0x11100111, 0x00001300, 0x000100C0, 0x04990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0d050c04, // d5c4 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0c070c05, // c7c5 1
0x23456402, 0x11000111, 0x00001300, 0x00110000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0b080c06, // b8c6 1
0x23456402, 0x11000111, 0x00001300, 0x00190000, 0x00090000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0f060d05, // f6d5 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0c070c06, // c7c6 1
0x23456402, 0x11000111, 0x00101300, 0x000100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x11071106, // h7h6 1
0x23456402, 0x11000111, 0x00101300, 0x000100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0d050c04, // d5c4 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0f060e04, // f6e4 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0a070a06, // a7a6 1
0x23456402, 0x11000111, 0x00101300, 0x00010000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0b080d07, // b8d7 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0c070c05, // c7c5 1
0x23456402, 0x11000111, 0x00001300, 0x001100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0c050d04, // c5d4 1
0x23456402, 0x11000111, 0x00001300, 0x001900C0, 0x00090000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0d080b06, // d8b6 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0b080d07, // b8d7 1
0x20456402, 0x11130111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0c070c06, // c7c6 1
0x20456402, 0x11130111, 0x00001300, 0x000100C0, 0x00990000, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0f080b04, // f8b4 1
0x20456402, 0x11130111, 0x00001300, 0x000100C0, 0x00990000, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0c070c06, // c7c6 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0f080e07, // f8e7 1
0x23456002, 0x11104111, 0x00001300, 0x000100C0, 0x00990000, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0f060e04, // f6e4 1
0x23456002, 0x11104111, 0x00001300, 0x000100C0, 0x00990000, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0e081008, // e8g8 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456402, 0x11111101, 0x00000310, 0x00000000, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11101101, 0x00000310, 0x00010000, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f081007, // f8g7 1
0x23456002, 0x11101141, 0x00000310, 0x00090000, 0x00090000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f060d05, // f6d5 1
0x23456002, 0x11101141, 0x00000310, 0x00010000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0e081008, // e8g8 1
0x23456402, 0x11111101, 0x00000310, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11101101, 0x00000310, 0x000100C0, 0x00990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0f060e04, // f6e4 1
0x23456402, 0x11101101, 0x00000010, 0x000100C0, 0x0099B000, 0x00000000, 0x99009999, 0xA00DECBA, 0x0d050e04, // d5e4 1
0x23456402, 0x11101101, 0x00000310, 0x00010000, 0x00990C00, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0f081007, // f8g7 1
0x23456002, 0x11101141, 0x00000310, 0x00010000, 0x00990C00, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0e081008, // e8g8 1
0x23456402, 0x11101101, 0x00000310, 0x00090000, 0x00090000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0f060d05, // f6d5 1
0x23456402, 0x11101101, 0x00000010, 0x00030000, 0x00099000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0d050c03, // d5c3 1
0x23456402, 0x11101101, 0x00000310, 0x00010000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0f081007, // f8g7 1
0x23456002, 0x11101141, 0x00000310, 0x00010000, 0x00990C00, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00000310, 0x00010000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00000310, 0x00010000, 0x00990000, 0x0DB00B00, 0x99009999, 0xA0C0EC0A, 0x0d050c04, // d5c4 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00990000, 0x00000000, 0x99009999, 0xABCDECBA, 0x0e070e06, // e7e6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0d050c04, // d5c4 1
0x23456402, 0x11100111, 0x00001300, 0x00000000, 0xD0190000, 0x00000090, 0x990099C9, 0xABC0E0BA, 0x0b080d07, // b8d7 1
0x23456402, 0x11100111, 0x00001300, 0x00000000, 0x00190000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0f080e07, // f8e7 1
0x23456002, 0x11104111, 0x00001300, 0x00010000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0e081008, // e8g8 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0c070c05, // c7c5 1
0x23456402, 0x11010111, 0x00001300, 0x00190000, 0x00900000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0b070b05, // b7b5 1
0x23456402, 0x10010111, 0x00009300, 0x01100000, 0x00900000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0f070e06, // f7e6 1
0x23456402, 0x10010111, 0x00001300, 0x011900C0, 0x00900000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0e060d05, // e6d5 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0f080b04, // f8b4 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00000B00, 0x990C9999, 0xAB0DEC0A, 0x0d080e07, // d8e7 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00000B00, 0x990C9999, 0xAB0DEC0A, 0x0b040d02, // b4d2 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00000B00, 0x990D9999, 0xAB00EC0A, 0x0b070b06, // b7b6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00000B00, 0x99009999, 0xABCDEC0A, 0x0b070b06, // b7b6 1
0x23456402, 0x10110111, 0x01001300, 0x00000000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0c080b07, // c8b7 1
0x23056402, 0x14110111, 0x01001300, 0x000000C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x11071106, // h7h6 1
0x23456402, 0x10110111, 0x01001300, 0x00000000, 0x00990000, 0x00009B00, 0x99000999, 0xABCDEC0A, 0x0c080b07, // c8b7 1
0x23056402, 0x14110111, 0x01001300, 0x00000000, 0x00990000, 0x000C9B00, 0x99000999, 0xABCDE00A, 0x0c070c05, // c7c5 1
0x23456402, 0x10110111, 0x01001300, 0x00000000, 0x00990000, 0x00000B90, 0x99009909, 0xABCDEC0A, 0x0c080a06, // c8a6 1
0x23456402, 0x10110111, 0x01001300, 0x00000000, 0x00990000, 0x00000B90, 0x99009909, 0xABCDEC0A, 0x0c080b07, // c8b7 1
0x23056402, 0x14110111, 0x01001300, 0x00000000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0c070c05, // c7c5 1
0x23056402, 0x14110111, 0x01001300, 0x00000000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0f080b04, // f8b4 1
0x23056402, 0x14110111, 0x01001300, 0x00000000, 0x00990000, 0x00000B90, 0x990099C9, 0xABCDE00A, 0x0f080e07, // f8e7 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0f080b04, // f8b4 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0c070c05, // c7c5 1
0x23456002, 0x11010111, 0x00001300, 0x00190000, 0x04900000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0f060e04, // f6e4 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x0DB00000, 0x99009999, 0xA0C0ECBA, 0x0c070c05, // c7c5 1
0x23456002, 0x11010111, 0x00001300, 0x00900000, 0x04900000, 0x0DB00000, 0x99009999, 0xA0C0ECBA, 0x0b080c06, // b8c6 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x90B00000, 0x09009999, 0xA0CDECBA, 0x0b040c03, // b4c3 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x90900000, 0x00009999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x90900000, 0x00009999, 0xA0CDECBA, 0x0e081008, // e8g8 1
0x23456002, 0x11110111, 0x00001300, 0x000000C0, 0x04990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x11071106, // h7h6 1
0x23456002, 0x11110110, 0x00001301, 0x00000000, 0x0499000C, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0c070c05, // c7c5 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0e081008, // e8g8 1
0x23450260, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x90B00000, 0x09D09999, 0xA0C0ECBA, 0x0b040c03, // b4c3 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0b080c06, // b8c6 1
0x20456002, 0x11110111, 0x00301300, 0x00000000, 0x04990000, 0x00B00B00, 0x99D09999, 0xA0C0EC0A, 0x0d070d06, // d7d6 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0d070d05, // d7d5 1
0x23456002, 0x11100111, 0x00001300, 0x00090000, 0x04090000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0e060d05, // e6d5 1
0x23456002, 0x11100111, 0x00001300, 0x00010000, 0x04990000, 0x90B00000, 0x09D09999, 0xA0C0ECBA, 0x0b040c03, // b4c3 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0c070c05, // c7c5 1
0x23456002, 0x11010111, 0x00001300, 0x00900000, 0x04900000, 0x00B00000, 0x99D09999, 0xA0C0ECBA, 0x0e081008, // e8g8 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0c070c05, // c7c5 1
0x23456002, 0x11010111, 0x00001300, 0x00100000, 0x04990000, 0x00BC9000, 0x99000999, 0xA0CDE0BA, 0x0b080c06, // b8c6 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0b070b06, // b7b6 1
0x23456002, 0x10110111, 0x01001300, 0x00000000, 0x04990000, 0x00B09000, 0x9900B999, 0xA0CDEC0A, 0x0c080a06, // c8a6 1
0x23456002, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0e081008, // e8g8 1
0x23450260, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x9900B999, 0xA0CDEC0A, 0x0d070d05, // d7d5 1
0x23450260, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00BC9000, 0x99000999, 0xA0CDE0BA, 0x0d070d05, // d7d5 1
0x23450260, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0d070d05, // d7d5 1
0x23456402, 0x11111101, 0x00000310, 0x00000000, 0x00990000, 0x00000090, 0x99009909, 0xABCDECBA, 0x0f081007, // f8g7 1
0x23456002, 0x11111141, 0x00000310, 0x00000000, 0x00990000, 0x00000090, 0x990099C9, 0xABCDE0BA, 0x0d070d05, // d7d5 1
0x23456402, 0x11111101, 0x00000310, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0f081007, // f8g7 1
0x23456002, 0x11111141, 0x00000310, 0x00000000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0d070d06, // d7d6 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00990000, 0x00B00B90, 0x99009909, 0xA0CDEC0A, 0x0e081008, // e8g8 1
0x23456002, 0x11111141, 0x00000310, 0x00000000, 0x00999000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0d070d06, // d7d6 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00999000, 0x00B00090, 0x99000909, 0xA0CDECBA, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00999000, 0x00B00000, 0x9900C999, 0xA0CDE0BA, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00999900, 0x00B00000, 0x99000099, 0xA0CDECBA, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00999000, 0x00B00900, 0x99000099, 0xA0CDECBA, 0x0e081008, // e8g8 1
0x23456002, 0x11101141, 0x00010310, 0x00000000, 0x00999000, 0x00B00B00, 0x99000999, 0xA0CDEC0A, 0x0e081008, // e8g8 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00099000, 0x00000000, 0x999B0999, 0xA0CDECBA, 0x0d050e04, // d5e4 1
0x23456432, 0x11110111, 0x00000000, 0x00000000, 0x00009100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00000300, 0x00009000, 0x00000100, 0x00000B00, 0x99990099, 0xABCDEC0A, 0x0f061105, // f6h5 1
0x23456402, 0x11110111, 0x00000000, 0x00009003, 0x00090100, 0x00000B00, 0x99900099, 0xABCDEC0A, 0x0d070d05, // d7d5 1
0x23456002, 0x11104111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x11071106, // h7h6 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0b070b05, // b7b5 1
0x23456432, 0x11110111, 0x00000000, 0x00001000, 0x00900000, 0x00000090, 0x99099909, 0xABCDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11110101, 0x00000010, 0x00001000, 0x00900000, 0x00000090, 0x990999C9, 0xABCDE0BA, 0x0f081007, // f8g7 1
0x23456032, 0x11110141, 0x00000010, 0x00001000, 0x00900000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x10080e07, // g8e7 1
0x23456002, 0x11113141, 0x00000010, 0x00001000, 0x00900000, 0x09B00090, 0x900999C9, 0xA0CDE0BA, 0x0e081008, // e8g8 1
0x20456032, 0x11114111, 0x00300000, 0x00001000, 0x00C99000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0d070d06, // d7d6 1
0x20456032, 0x11104111, 0x00310000, 0x00001000, 0x00C99000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x10080f06, // g8f6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0d070d05, // d7d5 1
0x20456402, 0x11130111, 0x00001300, 0x000100C0, 0x00990000, 0x00B09000, 0x99000999, 0xA00DECBA, 0x0f080e07, // f8e7 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00990000, 0x00B09000, 0x99000999, 0xA0CDECBA, 0x0b070b06, // b7b6 1
0x23456402, 0x10100111, 0x01001300, 0x00010000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0c080b07, // c8b7 1
0x20456432, 0x11110111, 0x00300000, 0x00001000, 0x00009000, 0x00900B00, 0x99090999, 0xABCDEC0A, 0x0f080e07, // f8e7 1
0x20456032, 0x11114111, 0x00300000, 0x00001000, 0x00099000, 0x00900B00, 0x99000999, 0xABCDEC0A, 0x0d070d06, // d7d6 1
0x20456032, 0x11104111, 0x00310000, 0x0C001000, 0x00099000, 0x00900B00, 0x99000999, 0xABCDE00A, 0x0e050d04, // e5d4 1
0x23456402, 0x11110111, 0x00001300, 0x000000C0, 0x00090000, 0x00000B00, 0x99909999, 0xAB0DEC0A, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00001300, 0x000100C0, 0x00990000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0f080e07, // f8e7 1
0x23456002, 0x11104111, 0x00001300, 0x000100C0, 0x00990000, 0x00B00B00, 0x99009999, 0xA00DEC0A, 0x0e081008, // e8g8 1
0x23456002, 0x11111141, 0x00000310, 0x00000000, 0x00990000, 0x00B00B00, 0x99009999, 0xA0CDEC0A, 0x0e081008, // e8g8 1
0x23450260, 0x11111141, 0x00000310, 0x00000000, 0x00990000, 0x00B09B00, 0x99000999, 0xA0CDEC0A, 0x0d070d05, // d7d5 1
0x23456002, 0x11104111, 0x00001C00, 0x00010000, 0x00990000, 0x00B00000, 0x99009999, 0xA00DECBA, 0x0e070f06, // e7f6 1
0x20456432, 0x01100111, 0x10100000, 0x00001000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDE00A, 0x0c081004, // c8g4 1
0x23456402, 0x11101111, 0x00000000, 0x00030000, 0x00990000, 0x00000000, 0x99000999, 0xABCDECBA, 0x0d050b06, // d5b6 1
0x23456402, 0x11101111, 0x03000000, 0x00000000, 0x00990000, 0x00B00000, 0x99000999, 0xA0CDECBA, 0x0e070e05, // e7e5 1
0x23456002, 0x11010111, 0x00001300, 0x00100000, 0x04990000, 0x0DB00000, 0x990C9999, 0xA000ECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11110011, 0x00300000, 0x0C001100, 0x00099000, 0x00000B00, 0x99900999, 0xABCDE00A, 0x0f050e04, // f5e4 1
0x20456432, 0x11110011, 0x00300000, 0x0C00B000, 0x00091000, 0x00000000, 0x99900999, 0xABCDE00A, 0x0c060e05, // c6e5 1
0x20456402, 0x01110111, 0x10300300, 0x00001000, 0xC0009000, 0x00090B00, 0x99900999, 0xABCDE00A, 0x0b070b05, // b7b5 1
0x23456432, 0x11100111, 0x00010000, 0x00001000, 0x00900000, 0x00B00090, 0x99099909, 0xA0CDECBA, 0x10071006, // g7g6 1
0x23456432, 0x11100101, 0x00010010, 0x00001000, 0x00990000, 0x00B00090, 0x99009909, 0xA0CDECBA, 0x0b080c06, // b8c6 1
0x20456432, 0x11100101, 0x00310010, 0x00009000, 0x00900000, 0x00B00090, 0x99009909, 0xA0CDECBA, 0x0d060e05, // d6e5 1
0x23456002, 0x11010111, 0x00001300, 0x00100000, 0x04990000, 0x00B09000, 0x99D00999, 0xA0C0ECBA, 0x0e081008, // e8g8 1
0x23456432, 0x11111111, 0x00000000, 0x00000000, 0x00000000, 0x00000B00, 0x99999999, 0xABCDEC0A, 0x10080f06, // g8f6 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00090000, 0x00000B00, 0x99909999, 0xABCDEC0A, 0x0e070e06, // e7e6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00090C00, 0x00000B00, 0x99909999, 0xAB0DEC0A, 0x0d070d05, // d7d5 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00090C00, 0x00009B00, 0x99900999, 0xAB0DEC0A, 0x0a070a06, // a7a6 1
0x23456402, 0x01100111, 0x10001300, 0x00010000, 0x00090C00, 0x00009B00, 0x999B0999, 0xA00DEC0A, 0x0b080d07, // b8d7 1
0x23456402, 0x11111111, 0x00000300, 0x00000000, 0x00900000, 0x00B00000, 0x99099999, 0xA0CDECBA, 0x0e070e05, // e7e5 1
0x23456402, 0x11110101, 0x00000310, 0x00001000, 0x00900000, 0x00B00090, 0x990999C9, 0xA0CDE0BA, 0x0f081007, // f8g7 1
0x23456002, 0x11110141, 0x00000310, 0x00001000, 0x00909000, 0x00B00090, 0x990909C9, 0xA0CDE0BA, 0x0d070d06, // d7d6 1
0x23450260, 0x11110111, 0x00001300, 0x00000000, 0x04990000, 0x00B09000, 0x99D00999, 0xA0C0ECBA, 0x0c070c05, // c7c5 1
0x23456432, 0x11110111, 0x00001000, 0x00000000, 0x00900000, 0x00000090, 0x99099909, 0xABCDECBA, 0x0d070d05, // d7d5 1
0x23456432, 0x11100111, 0x00001000, 0x00010000, 0x00900000, 0x00000090, 0x990999C9, 0xABCDE0BA, 0x10080f06, // g8f6 1
0x23456402, 0x11100111, 0x00001300, 0x00010000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCDE00A, 0x0b080c06, // b8c6 1
0x20456402, 0x11100111, 0x00301300, 0x00010000, 0x00900000, 0x00000B90, 0x990999C9, 0xABCD0AE0, 0x0f080e07, // f8e7 1
0x23456432, 0x11011111, 0x00000000, 0x00100000, 0x00009000, 0x00000B00, 0x99990999, 0xABCDEC0A, 0x0a070a06, // a7a6 1
0x23456432, 0x01011111, 0x10000000, 0x00100000, 0x00009000, 0x00B00B00, 0x99990999, 0xA0CDEC0A, 0x0b070b05, // b7b5 1
0x23456432, 0x00011111, 0x10000000, 0x01100000, 0x90009000, 0x00B00B00, 0x09990999, 0xA0CDEC0A, 0x0b050b04, // b5b4 1
0x23456432, 0x00011111, 0x10000000, 0x001B0000, 0x91009000, 0x00000B00, 0x09990999, 0xA0CDEC0A, 0x0c080b07, // c8b7 1
0x23456402, 0x11010111, 0x00001300, 0x001000C0, 0x00090000, 0x00900B00, 0x99009999, 0xAB0DEC0A, 0x0c050d04, // c5d4 1
0x23456402, 0x11010111, 0x00001300, 0x000000C0, 0x00090000, 0x00000B00, 0x99009999, 0xAB0DEC0A, 0x0d080b06, // d8b6 1
0x23456402, 0x11110111, 0x00001300, 0x00000000, 0x00990000, 0x00B00000, 0x99009999, 0xA0CDECBA, 0x0f080b04, // f8b4 1
};
Por último el códico que se implemento para el funcionamiento del reloj de ajedrez.
/* I2C LCD with Arduino example code. More info: https://www.makerguides.com */
// Include the libraries:
// LiquidCrystal_I2C.h: https://github.com/johnrickman/LiquidCrystal_I2C
#include <Wire.h> // Library for I2C communication
#include <LiquidCrystal_I2C.h> // Library for LCD
// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
int num1p1, num2p1, num3p1, num1p2, num2p2, num3p2; //Cifras de los relojes
bool pos = false;
volatile boolean ju1 = false;
volatile boolean ju2 = false;
int numJugadores = 1;
volatile boolean para =false;
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);
void Actju1(){
ju1=true;
lcd.setCursor(2,1);
lcd.print("JU1!");
}
void setup() {
pinMode(2, INPUT);pinMode(3, INPUT);pinMode(4, INPUT);
lcd.init();lcd.backlight(); lcd.setCursor(2, 0);lcd.print("Preparados?");
while ((digitalRead(4) == HIGH) || (!ju1 && !ju2)){
if(digitalRead(2) == LOW){
Actju1();
}
if(digitalRead(3) == LOW){
Actju1();
ju2=true;lcd.setCursor(10,1);lcd.print("JU2!");
}
}
lcd.clear();
lcd.setCursor(3, 0);lcd.print("Empecemos!");
lcd.setCursor(7,1);lcd.print("3");
delay(1000);
lcd.setCursor(7,1);lcd.print("2");
delay(1000);
lcd.setCursor(7,1); lcd.print("1");
delay(1000);
if(ju1 && ju2){numJugadores = 2;}
pinMode(2, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), paraJu1, FALLING);
lcd.clear();
num1p1 = num1p2 = 5;num2p1 = num3p1 = num2p2 = num3p2 = 0;
lcd.print("Player1");
if(numJugadores==2){
pinMode(3, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(3), paraJu2, FALLING);
// Initiate the LCD:
lcd.setCursor(8, 0);
lcd.print("Player2");
lcd.setCursor(10, 1);
lcd.print(String(num1p2));
lcd.print(":");
lcd.print(String(num2p2));
lcd.print(String(num3p2));
}
para =false;
}
void loop() {
if(para){lcd.clear();
lcd.setCursor(2, 1);
lcd.print("10 segundos"); delay(1000);
lcd.print("9 segundos"); delay(1000);
lcd.print("8 segundos"); delay(1000);
lcd.print("7 segundos"); delay(1000);
lcd.print("6 segundos"); delay(1000);
lcd.print("5 segundos"); delay(1000);
lcd.print("4 segundos"); delay(1000);
lcd.print("3 segundos"); delay(1000);
lcd.print("2 segundos"); delay(1000);
lcd.print("1 segundos"); delay(1000);
lcd.print("Empezamos"); delay(1000);
lcd.clear();
lcd.print("Player1");
para=false;}
if(!pos){
lcd.setCursor(2, 1);
lcd.print(String(num1p1));
lcd.print(":");
lcd.print(String(num2p1));
lcd.print(String(num3p1));
disminuir(&num1p1, &num2p1, &num3p1);
} else {
lcd.setCursor(10, 1);
lcd.print(String(num1p2));
lcd.print(":");
lcd.print(String(num2p2));
lcd.print(String(num3p2));
disminuir(&num1p2, &num2p2, &num3p2);
}
delay(1000);
}
void disminuir(int *num1, int *num2, int *num3){
if((*num3) > 0){
(*num3)--;
} else if((*num2) > 0){
(*num2)--;
*num3 = 9;
} else if((*num1) > 0){
(*num1)--;
*num2 = 5;
*num3 = 9;
} else {
lcd.clear();
lcd.setCursor(7, 0);
if(pos){lcd.print("JU2");}
else{lcd.print("JU1");}
lcd.setCursor(2, 1);
lcd.print("HAS PERDIDO");
for(;;);
}
}
void paraJu1(){
if(numJugadores==2){
if(!pos){pos=!pos;}}else{para=true;}
}
void paraJu2(){
if(pos){pos=!pos;}
}
Mejoras
Posibles mejoras futuras o modificaciones con los que mejorar el proyecto incluirían:
- Usar sensores de efecto hall, más resistentes que los interruptores de lengüeta.
- Poner un papel o tela en el tablero para mejorar su aspecto.
- Usar un buzzer que haga distintos sonidos en función de si se detecta un movimiento, se pulsa un botón o se termina la partida.
- Usar un modulo wifi ESP8266 y sincronizarlo con alexa para hacer movimientos por voz.
Fuentes
- Micro-Max: https://home.hccnet.nl/h.g.muller/max-src2.html
- CHESSuino: http://www.diego-cueva.com/projects/chessuino/
- Mismo pulsador para distintas placas Arduino: https://www.youtube.com/watch?v=alnvWB-H93Q
- Teclado matricial: http://anilarduino.blogspot.com/2015/05/interfacing-keypad-with-arduino.html
