#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int ika254(int x)
{
while(x>=255){
x -=255;
}
	while(-9999<x && x<0){
		x+=255;
	}
	if(x<=-9999){
		x=-99999;
	}
return x;
}



int GF256MULT(int x,int y)
{
if(x<0 || y <0){
return -99999;
} else {
return ika254(ika254(x)+ika254(y));
}

}
int GF256EXP2VEC( int *x , int y)
{
int h;
if(y < 0){
return 0;
}

h =x[ika254(y)];
//while(1);
return h;
}
int GF256VEC2EXP( int *x , int y)
{
int p;
for(p=0;p<255;p++){
if(y==0){
return -99999;
}
if(x[p] == y){
break;
}
}
return p;
}
int GF256VEC2EXP2( int *x , int y)
{
int p;
for(p=0;p<255;p++){
if(y==0){
while(1);
return -99999;
}
if(x[p] == y){
break;
}
}
return p;
}

int ayamarifuka(int X,int Y)
{
return (X ^ Y);
}

int SYNDSIGMA2EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y, ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y, (GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
for(i=0;i<14;i++){
KARI = ((GF256EXP2VEC(Y, ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW1EXP)))) ^
S[i+3]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+2)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int SYNDSIGMA3EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)))) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
for(i=0;i<13;i++){
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW1EXP)) )) ^
S[i+4]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+3)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int SYNDSIGMA4EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
KARI = ((S[4]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW3EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*3))) ));
}
KARI = ((S[5]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW4EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*4))) ));
}
for(i=0;i<12;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW1EXP)) )) ^
S[i+5]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+4)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int SYNDSIGMA5EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
KARI = ((S[4]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW3EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*3))) ));
}
KARI = ((S[5]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW4EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*4))) ));
}
KARI = ((S[6]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW5EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*5))) ));
}
for(i=0;i<11;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW1EXP)) )) ^
S[i+6]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+5)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int SYNDSIGMA6EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
KARI = ((S[4]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW3EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*3))) ));
}
KARI = ((S[5]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW4EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*4))) ));
}
KARI = ((S[6]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW5EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*5))) ));
}
KARI = ((S[7]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW6EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*6))) ));
}
for(i=0;i<10;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW1EXP)) )) ^
S[i+7]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+6)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}

int SYNDSIGMA7EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
KARI = ((S[4]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW3EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*3))) ));
}
KARI = ((S[5]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW4EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*4))) ));
}
KARI = ((S[6]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW5EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*5))) ));
}
KARI = ((S[7]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW6EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*6))) ));
}
KARI = ((S[8]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW2EXP)) ))
^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW4EXP)) ))
^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW7EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*7))) ));
}
for(i=0;i<9;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW1EXP)) )) ^
S[i+8]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+7)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int SYNDSIGMA8EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int MINUSEXP)
{
int TOTAL,KARI,i;
TOTAL = S[1];
KARI = ((GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW1EXP)) )) ^ S[2]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254(255-MINUSEXP))) );
}
KARI = ((S[3]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW2EXP)) )));
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*2))) ));
}
KARI = ((S[4]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW3EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*3))) ));
}
KARI = ((S[5]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW4EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*4))) ));
}
KARI = ((S[6]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW5EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*5))) ));
}
KARI = ((S[7]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW6EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*6))) ));
}
KARI = ((S[8]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW7EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*7))) ));
}
KARI = ((S[9]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW8EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*8))) ));
}
for(i=0;i<8;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW1EXP)) )) ^
S[i+9]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+8)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}
int VEC_DET3x3(int A11,int A12,int A13,int A21,int A22,int A23,int A31,int A32,int A33,int *Y)
{
return (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,A22)+GF256VEC2EXP(Y,A33) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A21)+GF256VEC2EXP(Y,A32)+GF256VEC2EXP(Y,A13) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A31)+GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,A23) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,A22)+GF256VEC2EXP(Y,A31) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,A23)+GF256VEC2EXP(Y,A32) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,A21)+GF256VEC2EXP(Y,A33) ))) );
}
int VEC_DET4x4(int A11,int A12,int A13,int A14,int A21,int A22,int A23,int A24,int A31,int A32,int A33,int A34,int A41,int A42,int A43,int A44,int *Y)
{
int A,B,C,D;
printf("4x4 %d\n",VEC_DET3x3(A22,A23,A24,A32,A33,A34,A42,A43,A44,Y));
printf("4x4 %d\n",VEC_DET3x3(A21,A23,A24,A31,A33,A34,A41,A43,A44,Y));
printf("4x4 %d\n",VEC_DET3x3(A21,A22,A24,A31,A32,A34,A41,A42,A44,Y));
printf("4x4 %d\n",VEC_DET3x3(A21,A22,A23,A31,A32,A33,A41,A42,A43,Y));

if(VEC_DET3x3(A22,A23,A24,A32,A33,A34,A42,A43,A44,Y) == 0){
A = 0;
} else {
A = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET3x3(A22,A23,A24,A32,A33,A34,A42,A43,A44,Y))));
}
if(VEC_DET3x3(A21,A23,A24,A31,A33,A34,A41,A43,A44,Y) == 0){
B = 0;
} else {
B = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A23,A24,A31,A33,A34,A41,A43,A44,Y))));
}
if(VEC_DET3x3(A21,A22,A24,A31,A32,A34,A41,A42,A44,Y) == 0){
C = 0;
} else {
C = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A22,A24,A31,A32,A34,A41,A42,A44,Y))));
}
if(VEC_DET3x3(A21,A22,A23,A31,A32,A33,A41,A42,A43,Y) == 0){
D = 0;
} else {
D = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A22,A23,A31,A32,A33,A41,A42,A43,Y))));
}
return (A ^ B ^ C ^ D);
// return (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET3x3(A22,A23,A24,A32,A33,A34,A42,A43,A44,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A23,A24,A31,A33,A34,A41,A43,A44,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A22,A24,A31,A32,A34,A41,A42,A44,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET3x3(A21,A22,A23,A31,A32,A33,A41,A42,A43,Y)))));
}
int VEC_DET5x5(int A11,int A12,int A13,int A14,int A15,int A21,int A22,int A23,int A24,int A25,int A31,int A32,int A33,int A34,int A35,int A41,int A42,int A43,int A44,int A45,int A51,int A52,int A53,int A54,int A55,int *Y)
{
int A,B,C,D,E;
printf("5x5 %d\n",VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y));
printf("5x5 %d\n",VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y));
printf("5x5 %d\n",VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y));
printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y));
printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y));

if(VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y) == 0){
A = 0;
} else {
A = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y))));
}
if(VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y) == 0 ){
B = 0;
} else {
B = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y))));
}
if(VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y) == 0){
C = 0;
} else {
C = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y))));
}
if(VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y) == 0){
D = 0;
} else {
D = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y))));
}
if(VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y) == 0){
E = 0;
} else {
E = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y))));
}

return (A ^ B ^ C ^ D ^ E);
// return (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y))))
// );
}
int VEC_DET6x6(int A11,int A12,int A13,int A14,int A15,int A16,int A21,int A22,int A23,int A24,int A25,int A26,int A31,int A32,int A33,int A34,int A35,int A36,int A41,int A42,int A43,int A44,int A45,int A46,int A51,int A52,int A53,int A54,int A55,int A56,int A61,int A62,int A63,int A64,int A65,int A66,int *Y)
{
int A,B,C,D,E,F;
// printf("5x5 %d\n",VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y));

if(VEC_DET5x5(A22,A23,A24,A25,A26,A32,A33,A34,A35,A36,A42,A43,A44,A45,A46,A52,A53,A54,A55,A56,A62,A63,A64,A65,A66,Y) == 0){
A = 0;
} else {
A = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET5x5(A22,A23,A24,A25,A26,A32,A33,A34,A35,A36,A42,A43,A44,A45,A46,A52,A53,A54,A55,A56,A62,A63,A64,A65,A66,Y))));
}
if(VEC_DET5x5(A21,A23,A24,A25,A26,A31,A33,A34,A35,A36,A41,A43,A44,A45,A46,A51,A53,A54,A55,A56,A61,A63,A64,A65,A66,Y) == 0 ){
B = 0;
} else {
B = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET5x5(A21,A23,A24,A25,A26,A31,A33,A34,A35,A36,A41,A43,A44,A45,A46,A51,A53,A54,A55,A56,A61,A63,A64,A65,A66,Y))));
}
if(VEC_DET5x5(A21,A22,A24,A25,A26,A31,A32,A34,A35,A36,A41,A42,A44,A45,A46,A51,A52,A54,A55,A56,A61,A62,A64,A65,A66,Y) == 0){
C = 0;
} else {
C = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET5x5(A21,A22,A24,A25,A26,A31,A32,A34,A35,A36,A41,A42,A44,A45,A46,A51,A52,A54,A55,A56,A61,A62,A64,A65,A66,Y))));
}
if(VEC_DET5x5(A21,A22,A23,A25,A26,A31,A32,A33,A35,A36,A41,A42,A43,A45,A46,A51,A52,A53,A55,A56,A61,A62,A63,A65,A66,Y) == 0){
D = 0;
} else {
D = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET5x5(A21,A22,A23,A25,A26,A31,A32,A33,A35,A36,A41,A42,A43,A45,A46,A51,A52,A53,A55,A56,A61,A62,A63,A65,A66,Y))));
}
if(VEC_DET5x5(A21,A22,A23,A24,A26,A31,A32,A33,A34,A36,A41,A42,A43,A44,A46,A51,A52,A53,A54,A56,A61,A62,A63,A64,A66,Y) == 0){
E = 0;
} else {
E = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET5x5(A21,A22,A23,A24,A26,A31,A32,A33,A34,A36,A41,A42,A43,A44,A46,A51,A52,A53,A54,A56,A61,A62,A63,A64,A66,Y))));
}
if(VEC_DET5x5(A21,A22,A23,A24,A25,A31,A32,A33,A34,A35,A41,A42,A43,A44,A45,A51,A52,A53,A54,A55,A61,A62,A63,A64,A65,Y) == 0){
F = 0;
} else {
F = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A16)+GF256VEC2EXP(Y,VEC_DET5x5(A21,A22,A23,A24,A25,A31,A32,A33,A34,A35,A41,A42,A43,A44,A45,A51,A52,A53,A54,A55,A61,A62,A63,A64,A65,Y))));
}

return (A ^ B ^ C ^ D ^ E ^ F);
// return (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y))))
// );
}
int VEC_DET7x7(int A11,int A12,int A13,int A14,int A15,int A16,int A17,int A21,int A22,int A23,int A24,int A25,int A26,int A27,int A31,int A32,int A33,int A34,int A35,int A36,int A37,int A41,int A42,int A43,int A44,int A45,int A46,int A47,int A51,int A52,int A53,int A54,int A55,int A56,int A57,int A61,int A62,int A63,int A64,int A65,int A66,int A67,int A71,int A72,int A73,int A74,int A75,int A76,int A77,int *Y)
{
int A,B,C,D,E,F,G;
// printf("5x5 %d\n",VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y));

if(VEC_DET6x6(A22,A23,A24,A25,A26,A27,A32,A33,A34,A35,A36,A37,A42,A43,A44,A45,A46,A47,A52,A53,A54,A55,A56,A57,A62,A63,A64,A65,A66,A67,A72,A73,A74,A75,A76,A77,Y) == 0){
A = 0;
} else {
A = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET6x6(A22,A23,A24,A25,A26,A27,A32,A33,A34,A35,A36,A37,A42,A43,A44,A45,A46,A47,A52,A53,A54,A55,A56,A57,A62,A63,A64,A65,A66,A67,A72,A73,A74,A75,A76,A77,Y))));
}
if(VEC_DET6x6(A21,A23,A24,A25,A26,A27,A31,A33,A34,A35,A36,A37,A41,A43,A44,A45,A46,A47,A51,A53,A54,A55,A56,A57,A61,A63,A64,A65,A66,A67,A71,A73,A74,A75,A76,A77,Y) == 0 ){
B = 0;
} else {
B = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A23,A24,A25,A26,A27,A31,A33,A34,A35,A36,A37,A41,A43,A44,A45,A46,A47,A51,A53,A54,A55,A56,A57,A61,A63,A64,A65,A66,A67,A71,A73,A74,A75,A76,A77,Y))));
}
if(VEC_DET6x6(A21,A22,A24,A25,A26,A27,A31,A32,A34,A35,A36,A37,A41,A42,A44,A45,A46,A47,A51,A52,A54,A55,A56,A57,A61,A62,A64,A65,A66,A67,A71,A72,A74,A75,A76,A77,Y) == 0){
C = 0;
} else {
C = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A22,A24,A25,A26,A27,A31,A32,A34,A35,A36,A37,A41,A42,A44,A45,A46,A47,A51,A52,A54,A55,A56,A57,A61,A62,A64,A65,A66,A67,A71,A72,A74,A75,A76,A77,Y))));
}
if(VEC_DET6x6(A21,A22,A23,A25,A26,A27,A31,A32,A33,A35,A36,A37,A41,A42,A43,A45,A46,A47,A51,A52,A53,A55,A56,A57,A61,A62,A63,A65,A66,A67,A71,A72,A73,A75,A76,A77,Y) == 0){
D = 0;
} else {
D = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A22,A23,A25,A26,A27,A31,A32,A33,A35,A36,A37,A41,A42,A43,A45,A46,A47,A51,A52,A53,A55,A56,A57,A61,A62,A63,A65,A66,A67,A71,A72,A73,A75,A76,A77,Y))));
}
if(VEC_DET6x6(A21,A22,A23,A24,A26,A27,A31,A32,A33,A34,A36,A37,A41,A42,A43,A44,A46,A47,A51,A52,A53,A54,A56,A57,A61,A62,A63,A64,A66,A67,A71,A72,A73,A74,A76,A77,Y) == 0){
E = 0;
} else {
E = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A22,A23,A24,A26,A27,A31,A32,A33,A34,A36,A37,A41,A42,A43,A44,A46,A47,A51,A52,A53,A54,A56,A57,A61,A62,A63,A64,A66,A67,A71,A72,A73,A74,A76,A77,Y))));
}
if(VEC_DET6x6(A21,A22,A23,A24,A25,A27,A31,A32,A33,A34,A35,A37,A41,A42,A43,A44,A45,A47,A51,A52,A53,A54,A55,A57,A61,A62,A63,A64,A65,A67,A71,A72,A73,A74,A75,A77,Y) == 0){
F = 0;
} else {
F = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A16)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A22,A23,A24,A25,A27,A31,A32,A33,A34,A35,A37,A41,A42,A43,A44,A45,A47,A51,A52,A53,A54,A55,A57,A61,A62,A63,A64,A65,A67,A71,A72,A73,A74,A75,A77,Y))));
}
if(VEC_DET6x6(A21,A22,A23,A24,A25,A26,A31,A32,A33,A34,A35,A36,A41,A42,A43,A44,A45,A46,A51,A52,A53,A54,A55,A56,A61,A62,A63,A64,A65,A66,A71,A72,A73,A74,A75,A76,Y) == 0){
G = 0;
} else {
G = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A17)+GF256VEC2EXP(Y,VEC_DET6x6(A21,A22,A23,A24,A25,A26,A31,A32,A33,A34,A35,A36,A41,A42,A43,A44,A45,A46,A51,A52,A53,A54,A55,A56,A61,A62,A63,A64,A65,A66,A71,A72,A73,A74,A75,A76,Y))));
}

return (A ^ B ^ C ^ D ^ E ^ F ^ G);
// return (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y))))
// );
}
int VEC_DET8x8(int A11,int A12,int A13,int A14,int A15,int A16,int A17,int A18,int A21,int A22,int A23,int A24,int A25,int A26,int A27,int A28,int A31,int A32,int A33,int A34,int A35,int A36,int A37,int A38,int A41,int A42,int A43,int A44,int A45,int A46,int A47,int A48,int A51,int A52,int A53,int A54,int A55,int A56,int A57,int A58,int A61,int A62,int A63,int A64,int A65,int A66,int A67,int A68,int A71,int A72,int A73,int A74,int A75,int A76,int A77,int A78,int A81,int A82,int A83,int A84,int A85,int A86,int A87,int A88,int *Y)
{
int A,B,C,D,E,F,G,H;
// printf("5x5 %d\n",VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y));
// printf("5x5 %d\n",VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y));

if(VEC_DET7x7(A22,A23,A24,A25,A26,A27,A28,A32,A33,A34,A35,A36,A37,A38,A42,A43,A44,A45,A46,A47,A48,A52,A53,A54,A55,A56,A57,A58,A62,A63,A64,A65,A66,A67,A68,A72,A73,A74,A75,A76,A77,A78,A82,A83,A84,A85,A86,A87,A88,Y) == 0){
A = 0;
} else {
A = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET7x7(A22,A23,A24,A25,A26,A27,A28,A32,A33,A34,A35,A36,A37,A38,A42,A43,A44,A45,A46,A47,A48,A52,A53,A54,A55,A56,A57,A58,A62,A63,A64,A65,A66,A67,A68,A72,A73,A74,A75,A76,A77,A78,A82,A83,A84,A85,A86,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A23,A24,A25,A26,A27,A28,A31,A33,A34,A35,A36,A37,A38,A41,A43,A44,A45,A46,A47,A48,A51,A53,A54,A55,A56,A57,A58,A61,A63,A64,A65,A66,A67,A68,A71,A73,A74,A75,A76,A77,A78,A81,A83,A84,A85,A86,A87,A88,Y) == 0 ){
B = 0;
} else {
B = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A23,A24,A25,A26,A27,A28,A31,A33,A34,A35,A36,A37,A38,A41,A43,A44,A45,A46,A47,A48,A51,A53,A54,A55,A56,A57,A58,A61,A63,A64,A65,A66,A67,A68,A71,A73,A74,A75,A76,A77,A78,A81,A83,A84,A85,A86,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A24,A25,A26,A27,A28,A31,A32,A34,A35,A36,A37,A38,A41,A42,A44,A45,A46,A47,A48,A51,A52,A54,A55,A56,A57,A58,A61,A62,A64,A65,A66,A67,A68,A71,A72,A74,A75,A76,A77,A78,A81,A82,A84,A85,A86,A87,A88,Y) == 0){
C = 0;
} else {
C = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A24,A25,A26,A27,A28,A31,A32,A34,A35,A36,A37,A38,A41,A42,A44,A45,A46,A47,A48,A51,A52,A54,A55,A56,A57,A58,A61,A62,A64,A65,A66,A67,A68,A71,A72,A74,A75,A76,A77,A78,A81,A82,A84,A85,A86,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A23,A25,A26,A27,A28,A31,A32,A33,A35,A36,A37,A38,A41,A42,A43,A45,A46,A47,A48,A51,A52,A53,A55,A56,A57,A58,A61,A62,A63,A65,A66,A67,A68,A71,A72,A73,A75,A76,A77,A78,A81,A82,A83,A85,A86,A87,A88,Y) == 0){
D = 0;
} else {
D = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A23,A25,A26,A27,A28,A31,A32,A33,A35,A36,A37,A38,A41,A42,A43,A45,A46,A47,A48,A51,A52,A53,A55,A56,A57,A58,A61,A62,A63,A65,A66,A67,A68,A71,A72,A73,A75,A76,A77,A78,A81,A82,A83,A85,A86,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A23,A24,A26,A27,A28,A31,A32,A33,A34,A36,A37,A38,A41,A42,A43,A44,A46,A47,A48,A51,A52,A53,A54,A56,A57,A58,A61,A62,A63,A64,A66,A67,A68,A71,A72,A73,A74,A76,A77,A78,A81,A82,A83,A84,A86,A87,A88,Y) == 0){
E = 0;
} else {
E = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A23,A24,A26,A27,A28,A31,A32,A33,A34,A36,A37,A38,A41,A42,A43,A44,A46,A47,A48,A51,A52,A53,A54,A56,A57,A58,A61,A62,A63,A64,A66,A67,A68,A71,A72,A73,A74,A76,A77,A78,A81,A82,A83,A84,A86,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A23,A24,A25,A27,A28,A31,A32,A33,A34,A35,A37,A38,A41,A42,A43,A44,A45,A47,A48,A51,A52,A53,A54,A55,A57,A58,A61,A62,A63,A64,A65,A67,A68,A71,A72,A73,A74,A75,A77,A78,A81,A82,A83,A84,A85,A87,A88,Y) == 0){
F = 0;
} else {
F = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A16)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A23,A24,A25,A27,A28,A31,A32,A33,A34,A35,A37,A38,A41,A42,A43,A44,A45,A47,A48,A51,A52,A53,A54,A55,A57,A58,A61,A62,A63,A64,A65,A67,A68,A71,A72,A73,A74,A75,A77,A78,A81,A82,A83,A84,A85,A87,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A23,A24,A25,A26,A28,A31,A32,A33,A34,A35,A36,A38,A41,A42,A43,A44,A45,A46,A48,A51,A52,A53,A54,A55,A56,A58,A61,A62,A63,A64,A65,A66,A68,A71,A72,A73,A74,A75,A76,A78,A81,A82,A83,A84,A85,A86,A88,Y) == 0){
G = 0;
} else {
G = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A17)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A23,A24,A25,A26,A28,A31,A32,A33,A34,A35,A36,A38,A41,A42,A43,A44,A45,A46,A48,A51,A52,A53,A54,A55,A56,A58,A61,A62,A63,A64,A65,A66,A68,A71,A72,A73,A74,A75,A76,A78,A81,A82,A83,A84,A85,A86,A88,Y))));
}
if(VEC_DET7x7(A21,A22,A23,A24,A25,A26,A27,A31,A32,A33,A34,A35,A36,A37,A41,A42,A43,A44,A45,A46,A47,A51,A52,A53,A54,A55,A56,A57,A61,A62,A63,A64,A65,A66,A67,A71,A72,A73,A74,A75,A76,A77,A81,A82,A83,A84,A85,A86,A87,Y) == 0){
H = 0;
} else {
H = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A18)+GF256VEC2EXP(Y,VEC_DET7x7(A21,A22,A23,A24,A25,A26,A27,A31,A32,A33,A34,A35,A36,A37,A41,A42,A43,A44,A45,A46,A47,A51,A52,A53,A54,A55,A56,A57,A61,A62,A63,A64,A65,A66,A67,A71,A72,A73,A74,A75,A76,A77,A81,A82,A83,A84,A85,A86,A87,Y))));
}

return (A ^ B ^ C ^ D ^ E ^ F ^ G ^ H);
// return (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A11)+GF256VEC2EXP(Y,VEC_DET4x4(A22,A23,A24,A25,A32,A33,A34,A35,A42,A43,A44,A45,A52,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A12)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A23,A24,A25,A31,A33,A34,A35,A41,A43,A44,A45,A51,A53,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A13)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A24,A25,A31,A32,A34,A35,A41,A42,A44,A45,A51,A52,A54,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A14)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A25,A31,A32,A33,A35,A41,A42,A43,A45,A51,A52,A53,A55,Y))))
// ^ GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,A15)+GF256VEC2EXP(Y,VEC_DET4x4(A21,A22,A23,A24,A31,A32,A33,A34,A41,A42,A43,A44,A51,A52,A53,A54,Y))))
// );
}
	int GF256VECMULT( int *A , int *B, int *GEN)
	{
		return GF256EXP2VEC(GEN,ika254( GF256VEC2EXP(GEN,*A) + GF256VEC2EXP(GEN,*B)));
	}
void ji8ji8polymult( int *A, int *B ,int *C,int *GEN)
{

	C[16] = GF256VECMULT(A+8,B+8,GEN);
	C[15] = GF256VECMULT(A+7,B+8,GEN) ^ GF256VECMULT(A+8,B+7,GEN);
	C[14] = GF256VECMULT(A+7,B+7,GEN) ^ GF256VECMULT(A+8,B+6,GEN) ^ GF256VECMULT(A+6,B+8,GEN);
	C[13] = GF256VECMULT(A+7,B+6,GEN) ^ GF256VECMULT(A+6,B+7,GEN) ^ GF256VECMULT(A+5,B+8,GEN) ^ GF256VECMULT(A+8,B+5,GEN);
	C[12] = GF256VECMULT(A+6,B+6,GEN) ^ GF256VECMULT(A+7,B+5,GEN) ^ GF256VECMULT(A+5,B+7,GEN) ^ GF256VECMULT(A+8,B+4,GEN) ^ GF256VECMULT(A+4,B+8,GEN);
	C[11] = GF256VECMULT(A+6,B+5,GEN) ^ GF256VECMULT(A+5,B+6,GEN) ^ GF256VECMULT(A+4,B+7,GEN) ^ GF256VECMULT(A+7,B+4,GEN) ^ GF256VECMULT(A+3,B+8,GEN) ^ GF256VECMULT(A+8,B+3,GEN);
	C[10] = GF256VECMULT(A+5,B+5,GEN) ^ GF256VECMULT(A+4,B+6,GEN) ^ GF256VECMULT(A+6,B+4,GEN) ^ GF256VECMULT(A+7,B+3,GEN) ^ GF256VECMULT(A+3,B+7,GEN) ^ GF256VECMULT(A+8,B+2,GEN) ^ GF256VECMULT(A+2,B+8,GEN);
	C[9] = GF256VECMULT(A+5,B+4,GEN) ^ GF256VECMULT(A+4,B+5,GEN) ^ GF256VECMULT(A+6,B+3,GEN) ^ GF256VECMULT(A+3,B+6,GEN) ^ GF256VECMULT(A+2,B+7,GEN) ^ GF256VECMULT(A+7,B+2,GEN) ^ GF256VECMULT(A+1,B+8,GEN) ^ GF256VECMULT(A+8,B+1,GEN);
	C[8] = GF256VECMULT(A+4,B+4,GEN) ^ GF256VECMULT(A+3,B+5,GEN) ^ GF256VECMULT(A+5,B+3,GEN) ^ GF256VECMULT(A+2,B+6,GEN) ^ GF256VECMULT(A+6,B+2,GEN) ^ GF256VECMULT(A+7,B+1,GEN) ^ GF256VECMULT(A+1,B+7,GEN) ^ GF256VECMULT(A+8,B+0,GEN) ^ GF256VECMULT(A+0,B+8,GEN);
	C[7] = GF256VECMULT(A+3,B+4,GEN) ^ GF256VECMULT(A+4,B+3,GEN) ^ GF256VECMULT(A+5,B+2,GEN) ^ GF256VECMULT(A+2,B+5,GEN) ^ GF256VECMULT(A+6,B+1,GEN) ^ GF256VECMULT(A+1,B+6,GEN) ^ GF256VECMULT(A+0,B+7,GEN) ^ GF256VECMULT(A+7,B+0,GEN);
	C[6] = GF256VECMULT(A+3,B+3,GEN) ^ GF256VECMULT(A+4,B+2,GEN) ^ GF256VECMULT(A+2,B+4,GEN) ^ GF256VECMULT(A+1,B+5,GEN) ^ GF256VECMULT(A+5,B+1,GEN) ^ GF256VECMULT(A+0,B+6,GEN) ^ GF256VECMULT(A+6,B+0,GEN);
	C[5] = GF256VECMULT(A+3,B+2,GEN) ^ GF256VECMULT(A+2,B+3,GEN) ^ GF256VECMULT(A+1,B+4,GEN) ^ GF256VECMULT(A+4,B+1,GEN) ^ GF256VECMULT(A+0,B+5,GEN) ^ GF256VECMULT(A+5,B+0,GEN);
	C[4] = GF256VECMULT(A+2,B+2,GEN) ^ GF256VECMULT(A+4,B+0,GEN) ^ GF256VECMULT(A+0,B+4,GEN) ^ GF256VECMULT(A+3,B+1,GEN) ^ GF256VECMULT(A+1,B+3,GEN);
	C[3] = GF256VECMULT(A+1,B+2,GEN) ^ GF256VECMULT(A+2,B+1,GEN) ^ GF256VECMULT(A+3,B+0,GEN) ^ GF256VECMULT(A+0,B+3,GEN);
	C[2] = GF256VECMULT(A+0,B+2,GEN) ^ GF256VECMULT(A+2,B+0,GEN) ^ GF256VECMULT(A+1,B+1,GEN);
	C[1] = GF256VECMULT(A+1,B+0,GEN) ^ GF256VECMULT(A+0,B+1,GEN);
	C[0] = GF256VECMULT(A,B,GEN);
	
}

int main()
{
// FILE *fpr;
int a,i,j,k,l,m,n,o;
int X[17] = {0,0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0};
int *Y;
int *BUFFER;
BUFFER = (int*)malloc(sizeof(int)*255);
// fpr=fopen("kari.tx","w");
Y=(int*)malloc(sizeof(int)*256);
// while(1);
X[0] = 1;
for(i=0;i<256;i++){
Y[i] = (/*(X[15] << 15) |(X[14] << 14) |(X[13] << 13) |(X[12] << 12) |(X[11] << 11) |(X[10] << 10) |(X[9] << 9) |(X[8] << 8) |*/(X[7] << 7) |(X[6] << 6) |(X[5] << 5) |(X[4] << 4) |(X[3] << 3) |(X[2] << 2) |(X[1] << 1) |(X[0]));
printf("%d %d %d %d %d %d %d %d \n",/*X[15]
,X[14]
,X[13]
,X[12]
,X[11]
,X[10]
,X[9]
,X[8]
,*/X[7]
,X[6]
,X[5]
,X[4]
,X[3]
,X[2]
,X[1]
,X[0]);
// X[16] = X[15];
// X[15] = X[14];
// X[14] = X[13];
// X[13] = X[12];
// X[12] = X[11]^X[16];
// X[11] = X[10];
// X[10] = X[9];
// X[9] = X[8];
X[8] = X[7];
X[7] = X[6];
X[6] = X[5];
X[5] = X[4];
X[4] = X[3]^X[8];
X[3] = X[2]^X[8];
X[2] = X[1]^X[8];
X[1] = X[0];
X[0] = X[8];
}


// for(i=0;i<256;i++){
//if(Y[i] == 65535){printf("zenbitgatattaarufabanngouha=%d\n",i);};
// }
for(i=0;i<256;i++){
printf("ALUFA^%d=%4x\n",i,Y[i]);
}
//HERE TO Y[] GF256 ELEMENT INSTOLED
int *FUGOU;
//while(1);
FUGOU = (int *)malloc(sizeof(int)*255);
for(i=0;i<255;i++){
FUGOU[i] = 0;
}
FUGOU[233] = 0x57;//01010111b
for(i=0;i<239;i++){
BUFFER[254-i] = FUGOU[254-i];
}
//000----0
//100----0
//000----0
//100----0
//000----0
//100----0
//100----0
//100----0
//GENERATOR POLYNOMINAL
int *G;
//while(1);
G = (int*)malloc(sizeof(int)*17);
G[16]=0;G[15]=120;G[14]=104;G[13]=107;
G[12]=109;G[11]=102;G[10]=161;G[9]=76;
G[8]=3;G[7]=91;G[6]=191;G[5]=147;
G[4]=169;G[3]=182;G[2]=194;G[1]=225;
G[0]=120;
//encoder
// FUGOU[54] = 1;
for(i=0;i<239;i++){
if(FUGOU[254-i] != 0){
for(j=0;j<16;j++){
(FUGOU[254-1-i-j]) = ((FUGOU[254-1-i-j]) ^ (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),G[15-j]))));
//printf("i=%d,j=%d\n",i,j);
}
FUGOU[254-i] = 0;
for(k=0;k<17;k++){
if(GF256VEC2EXP(Y,FUGOU[254-i-k]) < 0){
printf("0 ");
} else {
printf("%d ",GF256VEC2EXP(Y,FUGOU[254-i-k]));
}
}
}
printf("\n");

}
//while(1);
//syndrome check
int *S;
S=(int*)malloc(sizeof(int)*17);
// FUGOU[254] = 0x57;
// FUGOU[45] = 0x11;
for(i=0;i<239;i++){
FUGOU[254-i] = BUFFER[254-i];
}
FUGOU[0] ^= 0xde;//ayamari bit fuka
FUGOU[198] ^= 0x78;
FUGOU[54] ^= 0x31;
FUGOU[32] ^=0x5d;
FUGOU[124] ^=0x35;
FUGOU[129] ^=0x84;
FUGOU[81] ^=0x29;
FUGOU[77] ^=0xff;
for(i=0;i<255;i++){
printf("%d ",GF256VEC2EXP(Y,FUGOU[254-i]));
}
printf("\n");


int KARI;
int FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*0))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*0)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[1]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*1))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*1)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[2]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*2))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*2)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[3]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*3))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*3)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[4]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*4))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*4)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[5]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*5))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*5)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[6]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*6))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*6)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[7]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*7))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*7)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[8]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*8))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*8)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[9]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*9))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*9)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[10]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*10))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*10)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[11]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*11))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*11)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[12]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*12))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*12)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[13]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*13))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*13)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[14]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*14))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*14)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[15]=KARI;
FLAG = 0;
for(i=0;i<255;i++){
if(FLAG == 1){
if(FUGOU[254-i] != 0){
KARI ^= (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*15))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*15)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[16]=KARI;
for(i=0;i<16;i++){
printf("S[%d]=%dEXP\n",i+1,GF256VEC2EXP(Y,S[i+1]));
}
int AAD,AAE,AAF,AAG;
int RAW1BUNSHI;
int RAW2BUNSHI;
int RAW3BUNSHI;
int RAW4BUNSHI;
int RAW5BUNSHI;
int RAW6BUNSHI;
int RAW7BUNSHI;
int RAW8BUNSHI;
int AAB,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP;
int *CHEN;
CHEN = (int*)malloc(sizeof(int)*255);
int ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8;
int BUNBO8EXP,BUNBO8EXP2,BUNBO8EXP3,BUNBO8EXP4,BUNBO8EXP5,BUNBO8EXP6,BUNBO8EXP7,BUNBO8EXP8;
int BUNBO7EXP,BUNBO7EXP2,BUNBO7EXP3,BUNBO7EXP4,BUNBO7EXP5,BUNBO7EXP6,BUNBO7EXP7;
int BUNBO6EXP,BUNBO6EXP2,BUNBO6EXP3,BUNBO6EXP4,BUNBO6EXP5,BUNBO6EXP6;
int BUNBO5EXP,BUNBO5EXP2,BUNBO5EXP3,BUNBO5EXP4,BUNBO5EXP5;
int AAC;
int BUNBO4EXP,BUNBO4EXP2,BUNBO4EXP3,BUNBO4EXP4;
int BUNBO2EXP,BUNBO2EXP2,BUNBO3EXP,BUNBO3EXP2,BUNBO3EXP3;
int AAA,RAW1HEX,RAW2HEX;
int ayamariiti;
int KARI2;
int KARI3;	
int DANKAI1,DANKAI2;
int **MAT;	
	
	
int B[33][33];
//int B2[33];
int deg;
int SIGMA[17];	
int WARU[17],KARI11,XX,YY,Q[33];
int B3[5] = { 0,0,0,0,0 };
int WARARERU[16];
int SWA[16];	
if(S[1] == 0 && S[2] == 0 && S[3] == 0 && S[4] == 0 && S[5] == 0 && S[6] == 0 && S[7] == 0 && S[8] == 0 && S[9] == 0 && S[10] == 0 && S[11] == 0 && S[12] == 0 && S[13] == 0 && S[14] == 0 && S[15] == 0 && S[16] == 0){
printf("ayamari nashi!!!!!!!\n");goto endend;
}
/***********************/
/* EUCLIDEAN ALGORITHM */
/***********************/
	
	
//  WARARERU[3]*X^3+WARARERU[2]*X^2+WARARERU[1]*X+WARARERU[0] / WARU[4]*X4+WARU[3]*X^3+WARU[2]*X^2+WARU[1]*X+WARU[0]
//  WARARERU[3]=0 	WARARERU[2]*X^2+WARARERU[1]*X+WARARERU[0] / WARU[4]*X4+WARU[3]*X^3+WARU[2]*X^2+WARU[1]*X+WARU[0]
	
//	KARI=WARU[4]
//	WARU[4] = WARU[4] - WARARERU[3]/WARARERU[3]*KARI
//	WARU[3] = WARU[3] - WARARERU[2]/WARARERU[3]*KARI
//	WARU[2] = WARU[2] - WARARERU[1]/WARARERU[3]*KARI
//	WARU[1] = WARU[1] - WARARERU[0]/WARARERU[3]*KARI
//	KARI =WARU[3]
//	WARU[3] = WARU[3] - WARARERU[3]/WARARERU[3]*KARI
//	WARU[2] = WARU[2] - WARARERU[2]/WARARERU[3]*KARI
//	WARU[1] = WARU[1] - WARARERU[1]/WARARERU[3]*KARI
//	WARU[0] = WARU[0] - WARARERU[0]/WARARERU[3]*KARI
//
//  KARI = WARU[4]	
//  WARU[4] = WARU[4] - WARARERU[2]/WARARERU[2]*KARI
//  WARU[3] = WARU[3] - WARARERU[1]/WARARERU[2]*KARI
//       2         2             0           2
//
//       3         3             2           2 
//       2         2             1           2
//       1         1             0           2
//	
//       2         2             2           2	
//	     1         1             1           2
//       0         0             0           2

	
	
/*	int WARU[17],KARI11,XX,YY,Q[3];*/
/*	int B3[5] = { 0,0,0,0,0 };*/
	for(i=0;i<33;i++){
		Q[i] = 0;
	}
	for(i=0;i<16;i++){
		WARU[i] = 0;
	}
	WARU[16] = 1;//WARU HIJYOSUU AMARI 
	             //WARARERU JYOSUU
	             //Q SHOU
/*	int WARARERU[16];*/
//	S[1] = 0x7;S[2]=0xa;S[3] =0x2;S[4]=0x0;
	for(i=0;i<16;i++){
		WARARERU[i] = S[i+1];
	}
/*	if(S[16] != 0){// i=0-1 
		k=0;//goto l2;
	} else if(S[15] != 0){// i=0-2
		k=1;//goto l3;
	} else if(S[14] != 0){
		k=2;//goto l4;
	} else if(S[13] != 0){
		goto l5;
	} else if(S[12] != 0){
		goto l6;
	} else if(S[11] != 0){
		goto l7;
	} else if(S[10] != 0){
		goto l8;
	} else if(S[9]  != 0){
		goto l9;
	} else if(S[8]  != 0){
		goto l10;
	} else if(S[7]  != 0){
		goto l11;
	} else if(S[6]  != 0){
		goto l12;
	} else if(S[5]  != 0){
		goto l13;
	} else if(S[4]  != 0){
		goto l14;
	} else if(S[3]  != 0){
		goto l15;
	} else if(S[2]  != 0){
		goto l16;
	}*/
	for(i=0;i<15;i++){
		if(S[16-i] !=0){
			k=i; break;
		}
	}
	for(i=0;i<33;i++){
	B[0][i] = 0;
	}
	for(i=0;i<33;i++){
		B[1][i] = 0;
	}
	B[1][0] = 1;
l=0;	
while(1){	
	for(i=0;i<2+k;i++){//2+k
		if(WARU[4+12-i] == 0){continue;}//4+12
		KARI11 = WARU[4+12-i];//4+12
		for(j=0;j<(4+12-k);j++){//4+12-k
			Q[1+k-i]= GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,KARI11) - GF256VEC2EXP(Y,WARARERU[3+12-k])));//3+12-k 
			XX = ika254(GF256VEC2EXP(Y,WARARERU[3+12-k-j]) - GF256VEC2EXP(Y,WARARERU[3+12-k]) + GF256VEC2EXP(Y,KARI11));//3+12-k 3+12-k
			YY = GF256EXP2VEC(Y,XX);//printf("WARU=%d,YY=%d\n",WARU[4+12-j-i],YY);
			WARU[4+12-j-i] = (WARU[4+12-j-i] ^ YY);//4+12
		}
	}
	for(i=0;i<17;i++){
		printf("WARU[%d]=%d,ALFA^%d\n",i,WARU[i],GF256VEC2EXP(Y,WARU[i]));
	}
	for(i=0;i<2;i++){
		printf("Q[%d]=%d,ALFA^%d\n",i,Q[i],GF256VEC2EXP(Y,Q[i]));
	}
	
//multiplier
	
//	KAKERU[2]*X^2+KAKERU[1]*X+KAKERU[0] * KAKERA[2]*X^2 + KAKERA[1]*X + KAKERA[0] =   
	
//  KAKERU[2] * KAKERA[2] X^4
//  KAKERA[2 1 + 1 2
//         2 0   1 1  0 2
//	       1 0   0 1
//         0 0 
	for(i=0;i<33;i++){
		 B[l+2][i] = 0;
	}
	ji8ji8polymult(Q,B[l+1],B[l+2],Y);
	for(i=0;i<33;i++){
		B[l+2][i] = (B[l+2][i] ^ B[l][i]);
	}
	for(i=0;i<5;i++){
		printf("B[%d][%d]=%d,ALFA^%d\n",l+2,i,B[l+2][i],GF256VEC2EXP(Y,B[l+2][i]));	
	}
//	while(1);
/*	int deg;*/
	for(i=0;i<5+12;i++){
		if(WARU[4+12-i] != 0){
			if(i==0){deg = 4+12; break;}
			if(i==1){deg = 3+12; break;}
			if(i==2){deg = 2+12; break;}
			if(i==3){deg = 1+12; break;}
			if(i==4){deg = 0+12; break;}
			if(i==5){deg = -1+12; break;}
			if(i==6){deg = -2+12; break;}
			if(i==7){deg = -3+12; break;}
			if(i==8){deg = -4+12; break;}
			if(i==9){deg = -5+12; break;}
			if(i==10){deg = -6+12; break;}
			if(i==11){deg = -7+12; break;}
			if(i==12){deg = -8+12; break;}
			if(i==13){deg = -9+12; break;}
			if(i==14){deg = -10+12; break;}
			if(i==15){deg = -11+12; break;}
			if(i==16){deg = -12+12;}
			
		} 
	}
	printf("deg = %d\n",deg);
	if(deg < 8){goto last;}
if(l==0){
//warizan 2kaime	
	
	for(i=0;i<4+12;i++){
		WARARERU[i] = WARU[i];
	}
	for(i=0;i<4+12;i++){
		WARU[i] = S[i+1];
	}
    WARU[4+12] = 0;
}
if(l>=1){
	for(i=0;i<16;i++){
		SWA[i] = WARARERU[i];
	}
	for(i=0;i<4+12;i++){
		WARARERU[i] = WARU[i];
	}
	for(i=0;i<4+12;i++){
		WARU[i] = SWA[i];
	}
    WARU[4+12] = 0;
}
	for(i=0;i<33;i++){
		Q[i] = 0;
	}
	for(i=0;i<15;i++){
	if(WARARERU[3+12-i] != 0){ 
		k=i;break;//goto l2a;
	} 
	}
	l++;
}//while loop end	
		

//last:
/*	int SIGMA[3];*/
	SIGMA[2] = 0;
	SIGMA[1] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,Q[1]) - GF256VEC2EXP(Y,Q[0])));
	SIGMA[0] = 1;
//	goto hhh;	
;;;
	printf("miseisaku!!\n");while(1);

last:
//	ji8ji8polymult(B[l+1],Q,B[l+2],Y);
	
//	B[l+2][0] ^= 1;
	

	for(i=0;i<17;i++){
		SIGMA[i] = B[l+2][i];
	}
	SIGMA[16] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[16]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[15] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[15]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[14] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[14]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[13] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[13]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[12] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[12]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[11] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[11]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[10] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[10]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[9] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[9]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[8] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[8]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[7] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[7]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[6] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[6]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[5] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[5]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[4] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[4]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[3] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[3]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[2] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[2]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[1] = GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,SIGMA[1]) - GF256VEC2EXP(Y,SIGMA[0])));
	SIGMA[0] = 1;
//hhh:
	;
	for(i=0;i<17;i++){
		printf("SIGMA[%d] = %d,ALFA^%d\n",i,SIGMA[i],GF256VEC2EXP(Y,SIGMA[i]));
	}
	
	
	//while(1);	
	for(i=0;i<9;i++){
		if(SIGMA[8-i] != 0){
			l=8-i;break;
		}
	}
	if(l==8){goto ayamari8ko;}
	if(l==7){goto ayamari7ko;}
	if(l==6){goto ayamari6ko;}
	if(l==5){goto ayamari5ko;}
	if(l==4){goto ayamari4ko;}
	if(l==3){goto ayamari3ko;}
	if(l==2){goto ayamari2ko;}
	if(l==1){goto ayamari1ko;}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
//8 block ayamari no baai
AAG = VEC_DET8x8(S[8],S[7],S[6],S[5],S[4],S[3],S[2],S[1], S[9],S[8],S[7],S[6],S[5],S[4],S[3],S[2], S[10],S[9],S[8],S[7],S[6],S[5],S[4],S[3], S[11],S[10],S[9],S[8],S[7],S[6],S[5],S[4], S[12],S[11],S[10],S[9],S[8],S[7],S[6],S[5], S[13],S[12],S[11],S[10],S[9],S[8],S[7],S[6], S[14],S[13],S[12],S[11],S[10],S[9],S[8],S[7], S[15],S[14],S[13],S[12],S[11],S[10],S[9],S[8],Y);
printf("AAG=%d\n",AAG);
// while(1);
if(AAG==0){goto ayamari7ika;}
RAW1BUNSHI = VEC_DET8x8(S[9],S[7],S[6],S[5],S[4],S[3],S[2],S[1], S[10],S[8],S[7],S[6],S[5],S[4],S[3],S[2], S[11],S[9],S[8],S[7],S[6],S[5],S[4],S[3], S[12],S[10],S[9],S[8],S[7],S[6],S[5],S[4], S[13],S[11],S[10],S[9],S[8],S[7],S[6],S[5], S[14],S[12],S[11],S[10],S[9],S[8],S[7],S[6], S[15],S[13],S[12],S[11],S[10],S[9],S[8],S[7], S[16],S[14],S[13],S[12],S[11],S[10],S[9],S[8],Y);
RAW2BUNSHI = VEC_DET8x8(S[8],S[9],S[6],S[5],S[4],S[3],S[2],S[1], S[9],S[10],S[7],S[6],S[5],S[4],S[3],S[2], S[10],S[11],S[8],S[7],S[6],S[5],S[4],S[3], S[11],S[12],S[9],S[8],S[7],S[6],S[5],S[4], S[12],S[13],S[10],S[9],S[8],S[7],S[6],S[5], S[13],S[14],S[11],S[10],S[9],S[8],S[7],S[6], S[14],S[15],S[12],S[11],S[10],S[9],S[8],S[7], S[15],S[16],S[13],S[12],S[11],S[10],S[9],S[8],Y);
RAW3BUNSHI = VEC_DET8x8(S[8],S[7],S[9],S[5],S[4],S[3],S[2],S[1], S[9],S[8],S[10],S[6],S[5],S[4],S[3],S[2], S[10],S[9],S[11],S[7],S[6],S[5],S[4],S[3], S[11],S[10],S[12],S[8],S[7],S[6],S[5],S[4], S[12],S[11],S[13],S[9],S[8],S[7],S[6],S[5], S[13],S[12],S[14],S[10],S[9],S[8],S[7],S[6], S[14],S[13],S[15],S[11],S[10],S[9],S[8],S[7], S[15],S[14],S[16],S[12],S[11],S[10],S[9],S[8],Y);
RAW4BUNSHI = VEC_DET8x8(S[8],S[7],S[6],S[9],S[4],S[3],S[2],S[1], S[9],S[8],S[7],S[10],S[5],S[4],S[3],S[2], S[10],S[9],S[8],S[11],S[6],S[5],S[4],S[3], S[11],S[10],S[9],S[12],S[7],S[6],S[5],S[4], S[12],S[11],S[10],S[13],S[8],S[7],S[6],S[5], S[13],S[12],S[11],S[14],S[9],S[8],S[7],S[6], S[14],S[13],S[12],S[15],S[10],S[9],S[8],S[7], S[15],S[14],S[13],S[16],S[11],S[10],S[9],S[8],Y);
RAW5BUNSHI = VEC_DET8x8(S[8],S[7],S[6],S[5],S[9],S[3],S[2],S[1], S[9],S[8],S[7],S[6],S[10],S[4],S[3],S[2], S[10],S[9],S[8],S[7],S[11],S[5],S[4],S[3], S[11],S[10],S[9],S[8],S[12],S[6],S[5],S[4], S[12],S[11],S[10],S[9],S[13],S[7],S[6],S[5], S[13],S[12],S[11],S[10],S[14],S[8],S[7],S[6], S[14],S[13],S[12],S[11],S[15],S[9],S[8],S[7], S[15],S[14],S[13],S[12],S[16],S[10],S[9],S[8],Y);
RAW6BUNSHI = VEC_DET8x8(S[8],S[7],S[6],S[5],S[4],S[9],S[2],S[1], S[9],S[8],S[7],S[6],S[5],S[10],S[3],S[2], S[10],S[9],S[8],S[7],S[6],S[11],S[4],S[3], S[11],S[10],S[9],S[8],S[7],S[12],S[5],S[4], S[12],S[11],S[10],S[9],S[8],S[13],S[6],S[5], S[13],S[12],S[11],S[10],S[9],S[14],S[7],S[6], S[14],S[13],S[12],S[11],S[10],S[15],S[8],S[7], S[15],S[14],S[13],S[12],S[11],S[16],S[9],S[8],Y);
RAW7BUNSHI = VEC_DET8x8(S[8],S[7],S[6],S[5],S[4],S[3],S[9],S[1], S[9],S[8],S[7],S[6],S[5],S[4],S[10],S[2], S[10],S[9],S[8],S[7],S[6],S[5],S[11],S[3], S[11],S[10],S[9],S[8],S[7],S[6],S[12],S[4], S[12],S[11],S[10],S[9],S[8],S[7],S[13],S[5], S[13],S[12],S[11],S[10],S[9],S[8],S[14],S[6], S[14],S[13],S[12],S[11],S[10],S[9],S[15],S[7], S[15],S[14],S[13],S[12],S[11],S[10],S[16],S[8],Y);
RAW8BUNSHI = VEC_DET8x8(S[8],S[7],S[6],S[5],S[4],S[3],S[2],S[9], S[9],S[8],S[7],S[6],S[5],S[4],S[3],S[10], S[10],S[9],S[8],S[7],S[6],S[5],S[4],S[11], S[11],S[10],S[9],S[8],S[7],S[6],S[5],S[12], S[12],S[11],S[10],S[9],S[8],S[7],S[6],S[13], S[13],S[12],S[11],S[10],S[9],S[8],S[7],S[14], S[14],S[13],S[12],S[11],S[10],S[9],S[8],S[15], S[15],S[14],S[13],S[12],S[11],S[10],S[9],S[16],Y);
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW4EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW4BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW5EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW5BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW6EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW6BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW7EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW7BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
RAW8EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW8BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAG)))));
//	for(i=0;i<9;i++){
		printf("RAW1EXP=%d\n",RAW1EXP);
		printf("RAW2EXP=%d\n",RAW2EXP);
		printf("RAW3EXP=%d\n",RAW3EXP);
		printf("RAW4EXP=%d\n",RAW4EXP);
		printf("RAW5EXP=%d\n",RAW5EXP);
		printf("RAW6EXP=%d\n",RAW6EXP);
		printf("RAW7EXP=%d\n",RAW7EXP);
		printf("RAW8EXP=%d\n",RAW8EXP);while(1);
//	}
ayamari8ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
	RAW4EXP = GF256VEC2EXP(Y,SIGMA[4]);
	RAW5EXP = GF256VEC2EXP(Y,SIGMA[5]);
	RAW6EXP = GF256VEC2EXP(Y,SIGMA[6]);
	RAW7EXP = GF256VEC2EXP(Y,SIGMA[7]);
	RAW8EXP = GF256VEC2EXP(Y,SIGMA[8]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW8EXP,(255-i)*8)) ^GF256EXP2VEC(Y,GF256MULT(RAW7EXP,(255-i)*7)) ^GF256EXP2VEC(Y,GF256MULT(RAW6EXP,(255-i)*6)) ^GF256EXP2VEC(Y,GF256MULT(RAW5EXP,(255-i)*5)) ^ GF256EXP2VEC(Y,GF256MULT(RAW4EXP,(255-i)*4)) ^ GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 7 && CHEN[i] == 1){
ERRLOC8 = i;FLAG = 8;
}
if(FLAG == 6 && CHEN[i] == 1){
ERRLOC7 = i;FLAG = 7;
}
if(FLAG == 5 && CHEN[i] == 1){
ERRLOC6 = i;FLAG = 6;
}
if(FLAG == 4 && CHEN[i] == 1){
ERRLOC5 = i;FLAG = 5;
}
if(FLAG == 3 && CHEN[i] == 1){
ERRLOC4 = i;FLAG = 4;
}
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%dERRLOC4=%dERRLOC5=%dERRLOC6=%dERRLOC7=%dERRLOC8=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8);
BUNBO8EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC1)))
))
)
;
BUNBO8EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC2)))
))
)
;
BUNBO8EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC3)))
))
)
;
BUNBO8EXP4 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC4)))
))
)
;
BUNBO8EXP5 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC5)))
))
)
;
BUNBO8EXP6 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC6)))
))
)
;
BUNBO8EXP7 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC7)))
))
)
;
BUNBO8EXP8 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC8)))
))
)
;
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC1) + (255-BUNBO8EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC2) + (255-BUNBO8EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC3) + (255-BUNBO8EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC4) + (255-BUNBO8EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC5) + (255-BUNBO8EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC6) + (255-BUNBO8EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC7) + (255-BUNBO8EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA8EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,ERRLOC8) + (255-BUNBO8EXP8))));
goto endend;// while(1);
//7 block ayamari no baai
ayamari7ika:
AAF = VEC_DET7x7(S[7],S[6],S[5],S[4],S[3],S[2],S[1], S[8],S[7],S[6],S[5],S[4],S[3],S[2], S[9],S[8],S[7],S[6],S[5],S[4],S[3], S[10],S[9],S[8],S[7],S[6],S[5],S[4], S[11],S[10],S[9],S[8],S[7],S[6],S[5], S[12],S[11],S[10],S[9],S[8],S[7],S[6], S[13],S[12],S[11],S[10],S[9],S[8],S[7],Y);
printf("AAF=%d\n",AAF);
if(AAF==0){goto ayamari6ika;}
RAW1BUNSHI = VEC_DET7x7(S[8],S[6],S[5],S[4],S[3],S[2],S[1], S[9],S[7],S[6],S[5],S[4],S[3],S[2], S[10],S[8],S[7],S[6],S[5],S[4],S[3], S[11],S[9],S[8],S[7],S[6],S[5],S[4] ,S[12],S[10],S[9],S[8],S[7],S[6],S[5] ,S[13],S[11],S[10],S[9],S[8],S[7],S[6], S[14],S[12],S[11],S[10],S[9],S[8],S[7],Y);
RAW2BUNSHI = VEC_DET7x7(S[7],S[8],S[5],S[4],S[3],S[2],S[1], S[8],S[9],S[6],S[5],S[4],S[3],S[2], S[9],S[10],S[7],S[6],S[5],S[4],S[3], S[10],S[11],S[8],S[7],S[6],S[5],S[4] ,S[11],S[12],S[9],S[8],S[7],S[6],S[5] ,S[12],S[13],S[10],S[9],S[8],S[7],S[6], S[13],S[14],S[11],S[10],S[9],S[8],S[7],Y);
RAW3BUNSHI = VEC_DET7x7(S[7],S[6],S[8],S[4],S[3],S[2],S[1], S[8],S[7],S[9],S[5],S[4],S[3],S[2], S[9],S[8],S[10],S[6],S[5],S[4],S[3], S[10],S[9],S[11],S[7],S[6],S[5],S[4] ,S[11],S[10],S[12],S[8],S[7],S[6],S[5] ,S[12],S[11],S[13],S[9],S[8],S[7],S[6], S[13],S[12],S[14],S[10],S[9],S[8],S[7],Y);
RAW4BUNSHI = VEC_DET7x7(S[7],S[6],S[5],S[8],S[3],S[2],S[1], S[8],S[7],S[6],S[9],S[4],S[3],S[2], S[9],S[8],S[7],S[10],S[5],S[4],S[3], S[10],S[9],S[8],S[11],S[6],S[5],S[4] ,S[11],S[10],S[9],S[12],S[7],S[6],S[5] ,S[12],S[11],S[10],S[13],S[8],S[7],S[6], S[13],S[12],S[11],S[14],S[9],S[8],S[7],Y);
RAW5BUNSHI = VEC_DET7x7(S[7],S[6],S[5],S[4],S[8],S[2],S[1], S[8],S[7],S[6],S[5],S[9],S[3],S[2], S[9],S[8],S[7],S[6],S[10],S[4],S[3], S[10],S[9],S[8],S[7],S[11],S[5],S[4] ,S[11],S[10],S[9],S[8],S[12],S[6],S[5] ,S[12],S[11],S[10],S[9],S[13],S[7],S[6], S[13],S[12],S[11],S[10],S[14],S[8],S[7],Y);
RAW6BUNSHI = VEC_DET7x7(S[7],S[6],S[5],S[4],S[3],S[8],S[1], S[8],S[7],S[6],S[5],S[4],S[9],S[2], S[9],S[8],S[7],S[6],S[5],S[10],S[3], S[10],S[9],S[8],S[7],S[6],S[11],S[4] ,S[11],S[10],S[9],S[8],S[7],S[12],S[5] ,S[12],S[11],S[10],S[9],S[8],S[13],S[6], S[13],S[12],S[11],S[10],S[9],S[14],S[7],Y);
RAW7BUNSHI = VEC_DET7x7(S[7],S[6],S[5],S[4],S[3],S[2],S[8], S[8],S[7],S[6],S[5],S[4],S[3],S[9], S[9],S[8],S[7],S[6],S[5],S[4],S[10], S[10],S[9],S[8],S[7],S[6],S[5],S[11] ,S[11],S[10],S[9],S[8],S[7],S[6],S[12] ,S[12],S[11],S[10],S[9],S[8],S[7],S[13], S[13],S[12],S[11],S[10],S[9],S[8],S[14],Y);
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW4EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW4BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW5EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW5BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW6EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW6BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
RAW7EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW7BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAF)))));
		printf("RAW1EXP=%d\n",RAW1EXP);
		printf("RAW2EXP=%d\n",RAW2EXP);
		printf("RAW3EXP=%d\n",RAW3EXP);
		printf("RAW4EXP=%d\n",RAW4EXP);
		printf("RAW5EXP=%d\n",RAW5EXP);
		printf("RAW6EXP=%d\n",RAW6EXP);
		printf("RAW7EXP=%d\n",RAW7EXP);while(1);
ayamari7ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
	RAW4EXP = GF256VEC2EXP(Y,SIGMA[4]);
	RAW5EXP = GF256VEC2EXP(Y,SIGMA[5]);
	RAW6EXP = GF256VEC2EXP(Y,SIGMA[6]);
	RAW7EXP = GF256VEC2EXP(Y,SIGMA[7]);
	
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW7EXP,(255-i)*7)) ^GF256EXP2VEC(Y,GF256MULT(RAW6EXP,(255-i)*6)) ^GF256EXP2VEC(Y,GF256MULT(RAW5EXP,(255-i)*5)) ^ GF256EXP2VEC(Y,GF256MULT(RAW4EXP,(255-i)*4)) ^ GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 6 && CHEN[i] == 1){
ERRLOC7 = i;FLAG = 7;
}
if(FLAG == 5 && CHEN[i] == 1){
ERRLOC6 = i;FLAG = 6;
}
if(FLAG == 4 && CHEN[i] == 1){
ERRLOC5 = i;FLAG = 5;
}
if(FLAG == 3 && CHEN[i] == 1){
ERRLOC4 = i;FLAG = 4;
}
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%dERRLOC4=%dERRLOC5=%dERRLOC6=%dERRLOC7=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7);
BUNBO7EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC1)))
))
)
;
BUNBO7EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC2)))
))
)
;
BUNBO7EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC3)))
))
)
;
BUNBO7EXP4 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC4)))
))
)
;
BUNBO7EXP5 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC5)))
))
)
;
BUNBO7EXP6 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC6)))
))
)
;
BUNBO7EXP7 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC7)))
))
)
;
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC1) + (255-BUNBO7EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC2) + (255-BUNBO7EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC3) + (255-BUNBO7EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC4) + (255-BUNBO7EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC5) + (255-BUNBO7EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC6) + (255-BUNBO7EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA7EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,ERRLOC7) + (255-BUNBO7EXP7))));
goto endend;
// while(1);
//6 block ayamari no baai
ayamari6ika:
AAE = VEC_DET6x6(S[6],S[5],S[4],S[3],S[2],S[1], S[7],S[6],S[5],S[4],S[3],S[2], S[8],S[7],S[6],S[5],S[4],S[3], S[9],S[8],S[7],S[6],S[5],S[4], S[10],S[9],S[8],S[7],S[6],S[5], S[11],S[10],S[9],S[8],S[7],S[6],Y);
printf("AAE=%d\n",AAE);
if(AAE==0){goto ayamari5ika;}
RAW1BUNSHI = VEC_DET6x6(S[7],S[5],S[4],S[3],S[2],S[1], S[8],S[6],S[5],S[4],S[3],S[2], S[9],S[7],S[6],S[5],S[4],S[3] ,S[10],S[8],S[7],S[6],S[5],S[4] ,S[11],S[9],S[8],S[7],S[6],S[5] ,S[12],S[10],S[9],S[8],S[7],S[6],Y);
RAW2BUNSHI = VEC_DET6x6(S[6],S[7],S[4],S[3],S[2],S[1], S[7],S[8],S[5],S[4],S[3],S[2], S[8],S[9],S[6],S[5],S[4],S[3] ,S[9],S[10],S[7],S[6],S[5],S[4] ,S[10],S[11],S[8],S[7],S[6],S[5] ,S[11],S[12],S[9],S[8],S[7],S[6],Y);
RAW3BUNSHI = VEC_DET6x6(S[6],S[5],S[7],S[3],S[2],S[1], S[7],S[6],S[8],S[4],S[3],S[2], S[8],S[7],S[9],S[5],S[4],S[3] ,S[9],S[8],S[10],S[6],S[5],S[4] ,S[10],S[9],S[11],S[7],S[6],S[5] ,S[11],S[10],S[12],S[8],S[7],S[6],Y);
RAW4BUNSHI = VEC_DET6x6(S[6],S[5],S[4],S[7],S[2],S[1], S[7],S[6],S[5],S[8],S[3],S[2], S[8],S[7],S[6],S[9],S[4],S[3] ,S[9],S[8],S[7],S[10],S[5],S[4] ,S[10],S[9],S[8],S[11],S[6],S[5] ,S[11],S[10],S[9],S[12],S[7],S[6],Y);
RAW5BUNSHI = VEC_DET6x6(S[6],S[5],S[4],S[3],S[7],S[1], S[7],S[6],S[5],S[4],S[8],S[2], S[8],S[7],S[6],S[5],S[9],S[3] ,S[9],S[8],S[7],S[6],S[10],S[4] ,S[10],S[9],S[8],S[7],S[11],S[5] ,S[11],S[10],S[9],S[8],S[12],S[6],Y);
RAW6BUNSHI = VEC_DET6x6(S[6],S[5],S[4],S[3],S[2],S[7], S[7],S[6],S[5],S[4],S[3],S[8], S[8],S[7],S[6],S[5],S[4],S[9] ,S[9],S[8],S[7],S[6],S[5],S[10] ,S[10],S[9],S[8],S[7],S[6],S[11] ,S[11],S[10],S[9],S[8],S[7],S[12],Y);
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
RAW4EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW4BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
RAW5EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW5BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
RAW6EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW6BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAE)))));
ayamari6ko:	
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
	RAW4EXP = GF256VEC2EXP(Y,SIGMA[4]);
	RAW5EXP = GF256VEC2EXP(Y,SIGMA[5]);
	RAW6EXP = GF256VEC2EXP(Y,SIGMA[6]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW6EXP,(255-i)*6)) ^GF256EXP2VEC(Y,GF256MULT(RAW5EXP,(255-i)*5)) ^ GF256EXP2VEC(Y,GF256MULT(RAW4EXP,(255-i)*4)) ^ GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 5 && CHEN[i] == 1){
ERRLOC6 = i;FLAG = 6;
}
if(FLAG == 4 && CHEN[i] == 1){
ERRLOC5 = i;FLAG = 5;
}
if(FLAG == 3 && CHEN[i] == 1){
ERRLOC4 = i;FLAG = 4;
}
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%dERRLOC4=%dERRLOC5=%dERRLOC6=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6);
BUNBO6EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC1)))
))
)
;
BUNBO6EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC2)))
))
)
;
BUNBO6EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC3)))
))
)
;
BUNBO6EXP4 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC4)))
))
)
;
BUNBO6EXP5 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC5)))
))
)
;
BUNBO6EXP6 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC6)))
))
)
;
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC1) + (255-BUNBO6EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC2) + (255-BUNBO6EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC3) + (255-BUNBO6EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC4) + (255-BUNBO6EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC5) + (255-BUNBO6EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA6EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,ERRLOC6) + (255-BUNBO6EXP6))));
goto endend;

// while(1);
//5 block ayamari no baai
ayamari5ika:
AAD = VEC_DET5x5(S[5],S[4],S[3],S[2],S[1], S[6],S[5],S[4],S[3],S[2], S[7],S[6],S[5],S[4],S[3], S[8],S[7],S[6],S[5],S[4], S[9],S[8],S[7],S[6],S[5],Y);
printf("DET5x5=%d\n",AAD);//while(1);
if(AAD == 0){goto ayamari4ika;}
RAW1BUNSHI = VEC_DET5x5(S[6],S[4],S[3],S[2],S[1] ,S[7],S[5],S[4],S[3],S[2] ,S[8],S[6],S[5],S[4],S[3] ,S[9],S[7],S[6],S[5],S[4] ,S[10],S[8],S[7],S[6],S[5],Y);
RAW2BUNSHI = VEC_DET5x5(S[5],S[6],S[3],S[2],S[1] ,S[6],S[7],S[4],S[3],S[2] ,S[7],S[8],S[5],S[4],S[3] ,S[8],S[9],S[6],S[5],S[4] ,S[9],S[10],S[7],S[6],S[5],Y);
RAW3BUNSHI = VEC_DET5x5(S[5],S[4],S[6],S[2],S[1] ,S[6],S[5],S[7],S[3],S[2] ,S[7],S[6],S[8],S[4],S[3] ,S[8],S[7],S[9],S[5],S[4] ,S[9],S[8],S[10],S[6],S[5],Y);
RAW4BUNSHI = VEC_DET5x5(S[5],S[4],S[3],S[6],S[1] ,S[6],S[5],S[4],S[7],S[2] ,S[7],S[6],S[5],S[8],S[3] ,S[8],S[7],S[6],S[9],S[4] ,S[9],S[8],S[7],S[10],S[5],Y);
RAW5BUNSHI = VEC_DET5x5(S[5],S[4],S[3],S[2],S[6] ,S[6],S[5],S[4],S[3],S[7] ,S[7],S[6],S[5],S[4],S[8] ,S[8],S[7],S[6],S[5],S[9] ,S[9],S[8],S[7],S[6],S[10],Y);
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAD)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAD)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAD)))));
RAW4EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW4BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAD)))));
RAW5EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW5BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAD)))));
ayamari5ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
	RAW4EXP = GF256VEC2EXP(Y,SIGMA[4]);
	RAW5EXP = GF256VEC2EXP(Y,SIGMA[5]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW5EXP,(255-i)*5)) ^ GF256EXP2VEC(Y,GF256MULT(RAW4EXP,(255-i)*4)) ^ GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 4 && CHEN[i] == 1){
ERRLOC5 = i;FLAG = 5;
}
if(FLAG == 3 && CHEN[i] == 1){
ERRLOC4 = i;FLAG = 4;
}
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%dERRLOC4=%dERRLOC5=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5);
BUNBO5EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC1)))
))
)
;
BUNBO5EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC2)))
))
)
;
BUNBO5EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC3)))
))
)
;
BUNBO5EXP4 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC4)))
))
)
;
BUNBO5EXP5 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC5)))
))
)
;
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA5EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,ERRLOC1) + (255-BUNBO5EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA5EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,ERRLOC2) + (255-BUNBO5EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA5EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,ERRLOC3) + (255-BUNBO5EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA5EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,ERRLOC4) + (255-BUNBO5EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA5EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,ERRLOC5) + (255-BUNBO5EXP5))));
goto endend;


//4 block ayamari no baai
ayamari4ika:
AAC = VEC_DET4x4(S[4],S[3],S[2],S[1] ,S[5],S[4],S[3],S[2] ,S[6],S[5],S[4],S[3] ,S[7],S[6],S[5],S[4],Y);
// printf("DET4x4=%d\n",AAC);
if(AAC == 0){goto ayamari3ika;}
RAW1BUNSHI = VEC_DET4x4(S[5],S[3],S[2],S[1] ,S[6],S[4],S[3],S[2] ,S[7],S[5],S[4],S[3] ,S[8],S[6],S[5],S[4],Y);
RAW2BUNSHI = VEC_DET4x4(S[4],S[5],S[2],S[1] ,S[5],S[6],S[3],S[2] ,S[6],S[7],S[4],S[3] ,S[7],S[8],S[5],S[4],Y);
RAW3BUNSHI = VEC_DET4x4(S[4],S[3],S[5],S[1] ,S[5],S[4],S[6],S[2] ,S[6],S[5],S[7],S[3] ,S[7],S[6],S[8],S[4],Y);
RAW4BUNSHI = VEC_DET4x4(S[4],S[3],S[2],S[5] ,S[5],S[4],S[3],S[6] ,S[6],S[5],S[4],S[7] ,S[7],S[6],S[5],S[8],Y);
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAC)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAC)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAC)))));
RAW4EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW4BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAC)))));
ayamari4ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
	RAW4EXP = GF256VEC2EXP(Y,SIGMA[4]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW4EXP,(255-i)*4)) ^ GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
// int ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4;
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 3 && CHEN[i] == 1){
ERRLOC4 = i;FLAG = 4;
}
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%dERRLOC4=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4);
BUNBO4EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC1)))
))
)
;
BUNBO4EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC2)))
))
)
;
BUNBO4EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC3)))
))
)
;
BUNBO4EXP4 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC4)))
))
)
;
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA4EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,ERRLOC1) + (255-BUNBO4EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA4EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,ERRLOC2) + (255-BUNBO4EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA4EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,ERRLOC3) + (255-BUNBO4EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA4EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,ERRLOC4) + (255-BUNBO4EXP4))));
//3 block ayamari no baai
// int RAW1BUNSHI;
// int RAW2BUNSHI;
// int RAW3BUNSHI;
goto endend;
ayamari3ika:
AAB = (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[4]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[5]) ))) );
if(AAB == 0){goto ayamari2ika;}
RAW1BUNSHI = (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[4]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[6]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[6]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[4]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[5]) ))) );
RAW2BUNSHI = (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[6]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[1])+GF256VEC2EXP(Y,S[5])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[6]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[4]) ))) );
RAW3BUNSHI = (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[6]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[4]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[5])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[5]) )))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[6]) ))) );


RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW1BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAB)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW2BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAB)))));
RAW3EXP = ika254(GF256MULT(GF256VEC2EXP(Y,RAW3BUNSHI) ,(ika254(255-GF256VEC2EXP(Y,AAB)))));
ayamari3ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
	RAW3EXP = GF256VEC2EXP(Y,SIGMA[3]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW3EXP,(255-i)*3)) ^ GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
//printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
}
FLAG = 0;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 2 && CHEN[i] == 1){
ERRLOC3 = i;FLAG = 3;
}
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;FLAG=2;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1=%d,ERRLOC2=%dERRLOC3=%d\n",ERRLOC1,ERRLOC2,ERRLOC3);
BUNBO3EXP = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC1)))
)))
;
BUNBO3EXP2 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC2)))
)))
;
BUNBO3EXP3 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC3)))
)))
;

// printf("2222222222\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA3EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,ERRLOC1) + (255-BUNBO3EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA3EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,ERRLOC2) + (255-BUNBO3EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA3EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,ERRLOC3) + (255-BUNBO3EXP3))));
goto endend;
//2 block ayamari no baai
ayamari2ika:
AAA = (GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[2])+GF256VEC2EXP(Y,S[2]))))
^ (GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[1])))));
if(AAA == 0){goto ayamari1ika;}
RAW1EXP = ika254(GF256MULT(GF256VEC2EXP(Y,(GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[2])))
^ GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[1])))))) , (ika254(255-GF256VEC2EXP(Y,AAA)))));
RAW2EXP = ika254(GF256MULT(GF256VEC2EXP(Y,(GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,S[4])+GF256VEC2EXP(Y,S[2])))
^ GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,S[3])+GF256VEC2EXP(Y,S[3])))))) , (ika254(255-GF256VEC2EXP(Y,AAA)))));

RAW1HEX = GF256EXP2VEC(Y,RAW1EXP);
RAW2HEX = GF256EXP2VEC(Y,RAW2EXP);

printf("DET4x4=%xHEX\n",AAA);
printf("RAW1EXP=%dEXP\n",RAW1EXP);
printf("RAW2EXP=%dEXP\n",RAW2EXP);
ayamari2ko:
	RAW1EXP = GF256VEC2EXP(Y,SIGMA[1]);
	RAW2EXP = GF256VEC2EXP(Y,SIGMA[2]);
for(i=0;i<255;i++){
CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW2EXP,(255-i)*2)) ^ GF256EXP2VEC(Y,GF256MULT(RAW1EXP,255-i)));
}
FLAG=0;
// int ERRLOC1,ERRLOC2;
for(i=0,k=0;i<255;i++){
// printf("CHEN[%d]=%xHEX\n",i,CHEN[i]);
if(FLAG == 1 && CHEN[i] == 1){
ERRLOC2 = i;
}
if(CHEN[i] == 1 && FLAG ==0 ){
ERRLOC1 = i;FLAG=1;
}
}
printf("ERRLOC1 = %d,ERRLOC2 = %d\n",ERRLOC1,ERRLOC2);
// SYNDSIGMA2EXP(Y,S,RAW1EXP,RAW2EXP,ERRLOC1)
// int BUNBO2EXP,BUNBO2EXP2;
// printf("1111111111\n");
BUNBO2EXP = GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC1))
)));
BUNBO2EXP2 = GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC2))
)));

// printf("2222222222\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA2EXP(Y,S,RAW1EXP,RAW2EXP,ERRLOC1) + (255-BUNBO2EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA2EXP(Y,S,RAW1EXP,RAW2EXP,ERRLOC2) + (255-BUNBO2EXP2))));
goto endend;
//1 block ayamari no baai S1‚ªŒë‚è’l
ayamari1ko:;
ayamari1ika:
if(S[1] == 0){printf("ERROR!!!!\n");goto endend;}
//int RAW1EXP;
RAW1EXP = ika254(GF256VEC2EXP2(Y,S[2])+(ika254(255-GF256VEC2EXP2(Y,S[1]))));
printf("AYAMARIATAI[%d]=%x\n",RAW1EXP,S[1]);
goto endend;
ayamariiti = RAW1EXP;
//ayamari suuti takousiki ayamari 1ko
KARI2 = S[1];
// printf("S0=%xHEX\n",S[1]);
// printf("S0=%dEXP\n",GF256VEC2EXP(Y,S[1]));
// printf("S1=%dEXP\n",GF256VEC2EXP(Y,S[2]));
// printf("S2=%dEXP\n",GF256VEC2EXP(Y,S[3]));
// printf("S3=%dEXP\n",GF256VEC2EXP(Y,S[4]));
// printf("S4=%dEXP\n",GF256VEC2EXP(Y,S[5]));
// printf("S5=%dEXP\n",GF256VEC2EXP(Y,S[6]));
// printf("S6=%dEXP\n",GF256VEC2EXP(Y,S[7]));
// printf("S7=%dEXP\n",GF256VEC2EXP(Y,S[8]));
// printf("S15=%dEXP\n",GF256VEC2EXP(Y,S[16]));
//int DANKAI1,DANKAI2;
for(i=0;i<15;i++){
DANKAI1 =((S[i+2]) ^ (GF256EXP2VEC(Y,ika254(RAW1EXP+GF256VEC2EXP(Y,S[i+1])))));
if(DANKAI1 == 0){
;
} else {
DANKAI2=GF256EXP2VEC(Y,
ika254(
GF256VEC2EXP(Y,
((S[i+2]) ^ (GF256EXP2VEC(Y,ika254(RAW1EXP+GF256VEC2EXP(Y,S[i+1])))))
) + (255-ayamariiti)*(i+1)
)
);
//if((DANKAI2 ^ KARI2) == 0){
// KARI2 = 0;
//} else {
KARI2 = (DANKAI2 ^ KARI2);
//}
}
printf("i=%d,KEIKA=%dEXP\n",i,GF256VEC2EXP(Y,KARI2));
}
printf("ayamariiti=%d\n",ayamariiti);
printf("KARI2=%xHEX\n",KARI2);
printf("RAW1*S15*X^16=%xHEX\n",(GF256EXP2VEC(Y,ika254(RAW1EXP+GF256VEC2EXP(Y,S[16])+(255-ayamariiti)*16))

));
KARI2 = (KARI2 ^ (GF256EXP2VEC(Y,ika254(RAW1EXP+GF256VEC2EXP(Y,S[16])+(255-ayamariiti)*16))

));
//int KARI3;
KARI3=GF256EXP2VEC(Y,(ika254(GF256VEC2EXP(Y,KARI2)+(255-RAW1EXP))));
printf("ayamariatai32block=%x\n",KARI3);


//int **MAT;
MAT = (int**)malloc(sizeof(int*)*8);

for(i=0;i<8;i++){
MAT[i] = (int*)malloc(sizeof(int)*8);
}
for(i=0;i<8;i++){
for(j=0;j<8;j++){
MAT[i][j] = 8*i+j;
}
}
for(i=0;i<8;i++){
for(j=0;j<8;j++){
//printf("MAT[%d][%d]=%d\n",i,j,MAT[i][j]);
}
}
//8 block ayamari ayamari block detect
endend:
//fclose(fpr);
return 0;
}

