#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*/30;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*/29;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*/28;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*/27;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*/26;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*/25;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*/24;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 SYNDSIGMA9EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
for(i=0;i</*7*/23;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW1EXP)) )) ^
S[i+10]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+9)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}



int SYNDSIGMA10EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
for(i=0;i</*6*/22;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW1EXP)) )) ^
S[i+11]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+10)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}



int SYNDSIGMA11EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
for(i=0;i</*5*/21;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW1EXP)) )) ^
S[i+12]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+11)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}



int SYNDSIGMA12EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,int RAW12EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
KARI = ((S[13]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW12EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*12))) ));
}
for(i=0;i</*4*/20;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW12EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+12]),RAW1EXP)) )) ^
S[i+13]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+12)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}




int SYNDSIGMA13EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,int RAW12EXP,int RAW13EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
KARI = ((S[13]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW12EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*12))) ));
}
KARI = ((S[14]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW13EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*13))) ));
}
for(i=0;i</*3*/19;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW13EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW12EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+12]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+13]),RAW1EXP)) )) ^
S[i+14]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+13)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}




int SYNDSIGMA14EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,int RAW12EXP,int RAW13EXP,int RAW14EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
KARI = ((S[13]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW12EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*12))) ));
}
KARI = ((S[14]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW13EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*13))) ));
}
KARI = ((S[15]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW14EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*14))) ));
}
for(i=0;i</*2*/18;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW14EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW13EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW12EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+12]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+13]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+14]),RAW1EXP)) )) ^
S[i+15]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+14)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}



int SYNDSIGMA15EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,int RAW12EXP,int RAW13EXP,int RAW14EXP,int RAW15EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
KARI = ((S[13]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW12EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*12))) ));
}
KARI = ((S[14]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW13EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*13))) ));
}
KARI = ((S[15]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW14EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*14))) ));
}
KARI = ((S[16]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[15]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW14EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW15EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*15))) ));
}
for(i=0;i</*1*/17;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW15EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW14EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW13EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW12EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+12]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+13]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+14]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+15]),RAW1EXP)) )) ^
S[i+16]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+15)))) );
}
}
return GF256VEC2EXP(Y,TOTAL);
}




int SYNDSIGMA16EXP(int *Y,int *S,int RAW1EXP,int RAW2EXP,int RAW3EXP,int RAW4EXP,int RAW5EXP,int RAW6EXP,int RAW7EXP,int RAW8EXP,int RAW9EXP,int RAW10EXP,int RAW11EXP,int RAW12EXP,int RAW13EXP,int RAW14EXP,int RAW15EXP,int RAW16EXP,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))) ));
}
KARI = ((S[10]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW9EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*9))) ));
}
KARI = ((S[11]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW10EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*10))) ));
}
KARI = ((S[12]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW11EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*11))) ));
}
KARI = ((S[13]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW12EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*12))) ));
}
KARI = ((S[14]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW13EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*13))) ));
}
KARI = ((S[15]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW14EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*14))) ));
}
KARI = ((S[16]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[15]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW14EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW15EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*15))) ));
}
KARI = ((S[17]) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[16]),RAW1EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[15]),RAW2EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[14]),RAW3EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[13]),RAW4EXP)) )) ^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[12]),RAW5EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[11]),RAW6EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[10]),RAW7EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[9]),RAW8EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[8]),RAW9EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[7]),RAW10EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[6]),RAW11EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[5]),RAW12EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[4]),RAW13EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[3]),RAW14EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[2]),RAW15EXP)) ))^ (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[1]),RAW16EXP)) )) );
if(KARI == 0){
;
} else {
TOTAL ^= (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((255-MINUSEXP)*16))) ));
}
for(i=0;i</*0*/16;i++){
KARI = ( (GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+1]),RAW16EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+2]),RAW15EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+3]),RAW14EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+4]),RAW13EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+5]),RAW12EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+6]),RAW11EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+7]),RAW10EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+8]),RAW9EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+9]),RAW8EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+10]),RAW7EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+11]),RAW6EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+12]),RAW5EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+13]),RAW4EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+14]),RAW3EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+15]),RAW2EXP)) )) ^
(GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,S[i+16]),RAW1EXP)) )) ^
S[i+17]);
if(KARI == 0){
;
} else {
TOTAL ^= GF256EXP2VEC(Y,ika254(GF256MULT(GF256VEC2EXP(Y,KARI) , ika254((ika254(255-MINUSEXP))*(i+16)))) );
}
}
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[31]
//  C[30]
//  C[29]
//  C[28]
//  C[27]
//  C[26]	
//	C[25]
//	C[24]
//	C[23]
//	C[22]
//	C[21]
//	C[20]
	C[19] = GF256VECMULT(A+9,B+10,GEN) ^ GF256VECMULT(A+10,B+9,GEN) ^ GF256VECMULT(A+8,B+11,GEN) ^ GF256VECMULT(A+11,B+8,GEN) ^ GF256VECMULT(A+7,B+12,GEN) ^ GF256VECMULT(A+12,B+7,GEN) ^ GF256VECMULT(A+13,B+6,GEN) ^ GF256VECMULT(A+6,B+13,GEN) ^ GF256VECMULT(A+5,B+14,GEN) ^ GF256VECMULT(A+14,B+5,GEN) ^ GF256VECMULT(A+4,B+15,GEN) ^ GF256VECMULT(A+15,B+4,GEN) ^ GF256VECMULT(A+3,B+16,GEN) ^ GF256VECMULT(A+16,B+3,GEN);
	C[18] = GF256VECMULT(A+9,B+9,GEN) ^ GF256VECMULT(A+10,B+8,GEN) ^ GF256VECMULT(A+8,B+10,GEN) ^ GF256VECMULT(A+11,B+7,GEN) ^ GF256VECMULT(A+7,B+11,GEN) ^ GF256VECMULT(A+12,B+6,GEN) ^ GF256VECMULT(A+6,B+12,GEN) ^ GF256VECMULT(A+13,B+5,GEN) ^ GF256VECMULT(A+5,B+13,GEN) ^ GF256VECMULT(A+14,B+4,GEN) ^ GF256VECMULT(A+4,B+14,GEN) ^ GF256VECMULT(A+15,B+3,GEN) ^ GF256VECMULT(A+3,B+15,GEN) ^ GF256VECMULT(A+16,B+2,GEN) ^ GF256VECMULT(A+2,B+16,GEN); 
    C[17] = GF256VECMULT(A+8,B+9,GEN) ^ GF256VECMULT(A+9,B+8,GEN) ^ GF256VECMULT(A+10,B+7,GEN) ^ GF256VECMULT(A+7,B+10,GEN) ^ GF256VECMULT(A+11,B+6,GEN) ^ GF256VECMULT(A+6,B+11,GEN) ^ GF256VECMULT(A+12,B+5,GEN) ^ GF256VECMULT(A+5,B+12,GEN) ^ GF256VECMULT(A+13,B+4,GEN) ^ GF256VECMULT(A+4,B+13,GEN) ^ GF256VECMULT(A+14,B+3,GEN) ^ GF256VECMULT(A+3,B+14,GEN) ^ GF256VECMULT(A+15,B+2,GEN) ^ GF256VECMULT(A+2,B+15,GEN) ^ GF256VECMULT(A+16,B+1,GEN) ^ GF256VECMULT(A+1,B+16,GEN);
	C[16] = GF256VECMULT(A+8,B+8,GEN) ^ GF256VECMULT(A+9,B+7,GEN) ^ GF256VECMULT(A+7,B+9,GEN) ^ GF256VECMULT(A+10,B+6,GEN) ^ GF256VECMULT(A+6,B+10,GEN) ^ GF256VECMULT(A+11,B+5,GEN) ^ GF256VECMULT(A+5,B+11,GEN) ^ GF256VECMULT(A+12,B+4,GEN) ^ GF256VECMULT(A+4,B+12,GEN) ^ GF256VECMULT(A+13,B+3,GEN) ^ GF256VECMULT(A+3,B+13,GEN) ^ GF256VECMULT(A+14,B+2,GEN) ^ GF256VECMULT(A+2,B+14,GEN) ^ GF256VECMULT(A+1,B+15,GEN) ^ GF256VECMULT(A+15,B+1,GEN) ^ GF256VECMULT(A+16,B+0,GEN) ^ GF256VECMULT(A+0,B+16,GEN);
	C[15] = GF256VECMULT(A+7,B+8,GEN) ^ GF256VECMULT(A+8,B+7,GEN) ^ GF256VECMULT(A+6,B+9,GEN) ^ GF256VECMULT(A+9,B+6,GEN) ^ GF256VECMULT(A+5,B+10,GEN) ^ GF256VECMULT(A+10,B+5,GEN) ^ GF256VECMULT(A+11,B+4,GEN) ^ GF256VECMULT(A+4,B+11,GEN) ^ GF256VECMULT(A+12,B+3,GEN) ^ GF256VECMULT(A+3,B+12,GEN) ^ GF256VECMULT(A+13,B+2,GEN) ^ GF256VECMULT(A+2,B+13,GEN) ^ GF256VECMULT(A+14,B+1,GEN) ^ GF256VECMULT(A+1,B+14,GEN) ^ GF256VECMULT(A+0,B+15,GEN) ^ GF256VECMULT(A+15,B+0,GEN);
	C[14] = GF256VECMULT(A+7,B+7,GEN) ^ GF256VECMULT(A+8,B+6,GEN) ^ GF256VECMULT(A+6,B+8,GEN) ^ GF256VECMULT(A+9,B+5,GEN) ^ GF256VECMULT(A+5,B+9,GEN) ^ GF256VECMULT(A+10,B+4,GEN) ^ GF256VECMULT(A+4,B+10,GEN) ^ GF256VECMULT(A+11,B+3,GEN) ^ GF256VECMULT(A+3,B+11,GEN) ^ GF256VECMULT(A+12,B+2,GEN) ^ GF256VECMULT(A+2,B+12,GEN) ^ GF256VECMULT(A+13,B+1,GEN) ^ GF256VECMULT(A+1,B+13,GEN) ^ GF256VECMULT(A+14,B+0,GEN) ^ GF256VECMULT(A+0,B+14,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) ^ GF256VECMULT(A+4,B+9,GEN) ^ GF256VECMULT(A+9,B+4,GEN) ^ GF256VECMULT(A+3,B+10,GEN) ^ GF256VECMULT(A+10,B+3,GEN) ^ GF256VECMULT(A+2,B+11,GEN) ^ GF256VECMULT(A+11,B+2,GEN) ^ GF256VECMULT(A+1,B+12,GEN) ^ GF256VECMULT(A+12,B+1,GEN) ^ GF256VECMULT(A+0,B+13,GEN) ^ GF256VECMULT(A+13,B+0,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) ^ GF256VECMULT(A+9,B+3,GEN) ^ GF256VECMULT(A+3,B+9,GEN) ^ GF256VECMULT(A+10,B+2,GEN) ^ GF256VECMULT(A+2,B+10,GEN) ^ GF256VECMULT(A+11,B+1,GEN) ^ GF256VECMULT(A+1,B+11,GEN) ^ GF256VECMULT(A+12,B+0,GEN) ^ GF256VECMULT(A+0,B+12,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) ^ GF256VECMULT(A+2,B+9,GEN) ^ GF256VECMULT(A+9,B+2,GEN) ^ GF256VECMULT(A+1,B+10,GEN) ^ GF256VECMULT(A+10,B+1,GEN) ^ GF256VECMULT(A+0,B+11,GEN) ^ GF256VECMULT(A+11,B+0,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) ^ GF256VECMULT(A+9,B+1,GEN) ^ GF256VECMULT(A+1,B+9,GEN) ^ GF256VECMULT(A+10,B+0,GEN) ^ GF256VECMULT(A+0,B+10,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) ^ GF256VECMULT(A+0,B+9,GEN) ^ GF256VECMULT(A+9,B+0,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[213] = 0x34;	
FUGOU[33] = 0xfe;
FUGOU[54] =0x12;	
FUGOU[233] = 0x57;//01010111b
for(i=0;i</*239*/223;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)*33);
G[32]=0;G[31]=10;G[30]=6;G[29]=106;G[28]=190;
G[27]=249;G[26]=167;G[25]=4;G[24]=67;G[23]=209;
G[22]=138;G[21]=138;G[20]=32;G[19]=242;G[18]=123;
G[17]=89;
G[16]=27;G[15]=120;G[14]=185;G[13]=80;
G[12]=156;G[11]=38;G[10]=69;G[9]=171;
G[8]=60;G[7]=28;G[6]=222;G[5]=80;
G[4]=52;G[3]=254;G[2]=185;G[1]=220;
G[0]=241;
//encoder
// FUGOU[54] = 1;
for(i=0;i</*239*/223;i++){
if(FUGOU[254-i] != 0){
for(j=0;j</*16*/32;j++){
(FUGOU[254-1-i-j]) = ((FUGOU[254-1-i-j]) ^ (GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),G[/*15*/31-j]))));
//printf("i=%d,j=%d\n",i,j);
}
FUGOU[254-i] = 0;
for(k=0;k</*17*/33;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*/33);
// FUGOU[254] = 0x57;
// FUGOU[45] = 0x11;
for(i=0;i</*239*/223;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;
FUGOU[66] ^=0x13;
FUGOU[13] ^=0x96;	
FUGOU[98] ^=0x27;	
FUGOU[101] ^=0x7e;	
FUGOU[2] ^=0x05;	
FUGOU[222] ^=0xca;	
FUGOU[253] ^=0x6b;	
FUGOU[41] ^=0xaa;	

	
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;

	
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)*16))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*16)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[17]=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)*17))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*17)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[18]=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)*18))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*18)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[19]=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)*19))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*19)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[20]=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)*20))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*20)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[21]=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)*21))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*21)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[22]=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)*22))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*22)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[23]=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)*23))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*23)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[24]=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)*24))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*24)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[25]=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)*25))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*25)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[26]=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)*26))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*26)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[27]=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)*27))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*27)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[28]=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)*28))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*28)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[29]=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)*29))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*29)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[30]=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)*30))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*30)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[31]=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)*31))));
}
}
if(FLAG == 0){
if(FUGOU[254-i] != 0){
KARI = GF256EXP2VEC(Y,GF256MULT(GF256VEC2EXP(Y,FUGOU[254-i]),ika254((254-i)*31)));
FLAG = 1;
}
}
}
printf("SINDROME ALFA=%d\n",KARI);
S[32]=KARI;
	
	
for(i=0;i</*16*/32;i++){
printf("S[%d]=%dEXP\n",i+1,GF256VEC2EXP(Y,S[i+1]));
	}//while(1);
int AAD,AAE,AAF,AAG;
int RAW1BUNSHI;
int RAW2BUNSHI;
int RAW3BUNSHI;
int RAW4BUNSHI;
int RAW5BUNSHI;
int RAW6BUNSHI;
int RAW7BUNSHI;
int RAW8BUNSHI;
int RAW9BUNSHI;
int RAW10BUNSHI;
int RAW11BUNSHI;
int RAW12BUNSHI;
int RAW13BUNSHI;
int RAW14BUNSHI;
int RAW15BUNSHI;
int RAW16BUNSHI;
int AAB,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP;
int *CHEN;
CHEN = (int*)malloc(sizeof(int)*255);
int ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12,ERRLOC13,ERRLOC14,ERRLOC15,ERRLOC16;
int BUNBO16EXP,BUNBO16EXP2,BUNBO16EXP3,BUNBO16EXP4,BUNBO16EXP5,BUNBO16EXP6,BUNBO16EXP7,BUNBO16EXP8,BUNBO16EXP9,BUNBO16EXP10,BUNBO16EXP11,BUNBO16EXP12,BUNBO16EXP13,BUNBO16EXP14,BUNBO16EXP15,BUNBO16EXP16;
int BUNBO15EXP,BUNBO15EXP2,BUNBO15EXP3,BUNBO15EXP4,BUNBO15EXP5,BUNBO15EXP6,BUNBO15EXP7,BUNBO15EXP8,BUNBO15EXP9,BUNBO15EXP10,BUNBO15EXP11,BUNBO15EXP12,BUNBO15EXP13,BUNBO15EXP14,BUNBO15EXP15;
int BUNBO14EXP,BUNBO14EXP2,BUNBO14EXP3,BUNBO14EXP4,BUNBO14EXP5,BUNBO14EXP6,BUNBO14EXP7,BUNBO14EXP8,BUNBO14EXP9,BUNBO14EXP10,BUNBO14EXP11,BUNBO14EXP12,BUNBO14EXP13,BUNBO14EXP14;
int BUNBO13EXP,BUNBO13EXP2,BUNBO13EXP3,BUNBO13EXP4,BUNBO13EXP5,BUNBO13EXP6,BUNBO13EXP7,BUNBO13EXP8,BUNBO13EXP9,BUNBO13EXP10,BUNBO13EXP11,BUNBO13EXP12,BUNBO13EXP13;
int BUNBO12EXP,BUNBO12EXP2,BUNBO12EXP3,BUNBO12EXP4,BUNBO12EXP5,BUNBO12EXP6,BUNBO12EXP7,BUNBO12EXP8,BUNBO12EXP9,BUNBO12EXP10,BUNBO12EXP11,BUNBO12EXP12;
int BUNBO11EXP,BUNBO11EXP2,BUNBO11EXP3,BUNBO11EXP4,BUNBO11EXP5,BUNBO11EXP6,BUNBO11EXP7,BUNBO11EXP8,BUNBO11EXP9,BUNBO11EXP10,BUNBO11EXP11;
int BUNBO10EXP,BUNBO10EXP2,BUNBO10EXP3,BUNBO10EXP4,BUNBO10EXP5,BUNBO10EXP6,BUNBO10EXP7,BUNBO10EXP8,BUNBO10EXP9,BUNBO10EXP10;
int BUNBO9EXP,BUNBO9EXP2,BUNBO9EXP3,BUNBO9EXP4,BUNBO9EXP5,BUNBO9EXP6,BUNBO9EXP7,BUNBO9EXP8,BUNBO9EXP9;
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*/33],KARI11,XX,YY,Q[33];
int B3[5] = { 0,0,0,0,0 };
int WARARERU[/*16*/33];
int SWA[/*16*/32];	
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 && S[17] == 0 && S[18] == 0 && S[19] == 0 && S[20] == 0 && S[21] == 0 && S[22] == 0 && S[23] == 0 && S[24] == 0 && S[25] == 0 && S[26] == 0 && S[27] == 0 && S[28] == 0 && S[29] == 0 && S[30] == 0 && S[31] == 0 && S[32] == 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*/32;i++){
		WARU[i] = 0;
	}
	WARU[/*16*/32] = 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*/32;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*/31;i++){
		if(S[/*16*/32-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+16-i] == 0){continue;}//4+12
		KARI11 = WARU[4+12+16-i];//4+12
		for(j=0;j<(4+12+16-k);j++){//4+12-k
			Q[1+k-i]= GF256EXP2VEC(Y,ika254(GF256VEC2EXP(Y,KARI11) - GF256VEC2EXP(Y,WARARERU[3+12+16-k])));//3+12-k 
			XX = ika254(GF256VEC2EXP(Y,WARARERU[3+12+16-k-j]) - GF256VEC2EXP(Y,WARARERU[3+12+16-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+16-j-i] = (WARU[4+12+16-j-i] ^ YY);//4+12
		}
	}
	for(i=0;i</*17*/33;i++){
		printf("WARU[%d]=%d,ALFA^%d\n",i,WARU[i],GF256VEC2EXP(Y,WARU[i]));
	}
	for(i=0;i<12;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<10;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+16;i++){
		if(WARU[4+12+16-i] != 0){
			if(i==0){deg = 4+12+16; break;}
			if(i==1){deg = 3+12+16; break;}
			if(i==2){deg = 2+12+16; break;}
			if(i==3){deg = 1+12+16; break;}
			if(i==4){deg = 0+12+16; break;}
			if(i==5){deg = -1+12+16; break;}
			if(i==6){deg = -2+12+16; break;}
			if(i==7){deg = -3+12+16; break;}
			if(i==8){deg = -4+12+16; break;}
			if(i==9){deg = -5+12+16; break;}
			if(i==10){deg = -6+12+16; break;}
			if(i==11){deg = -7+12+16; break;}
			if(i==12){deg = -8+12+16; break;}
			if(i==13){deg = -9+12+16; break;}
			if(i==14){deg = -10+12+16; break;}
			if(i==15){deg = -11+12+16; break;}
			if(i==16){deg = -12+12+16; break;}
			if(i==17){deg = -13+12+16; break;}
			if(i==18){deg = -14+12+16; break;}
			if(i==19){deg = -15+12+16; break;}
			if(i==20){deg = -16+12+16; break;}
			if(i==21){deg = -17+12+16; break;}
			if(i==22){deg = -18+12+16; break;}
			if(i==23){deg = -19+12+16; break;}
			if(i==24){deg = -20+12+16; break;}
			if(i==25){deg = -21+12+16; break;}
			if(i==26){deg = -22+12+16; break;}
			if(i==27){deg = -23+12+16; break;}
			if(i==28){deg = -24+12+16; break;}
			if(i==29){deg = -25+12+16; break;}
			if(i==30){deg = -26+12+16; break;}
			if(i==31){deg = -27+12+16; break;}
			if(i==32){deg = -28+12+16;}
			
		} 
	}
	printf("deg = %d\n",deg);
	if(deg < 16){goto last;}
if(l==0){
//warizan 2kaime	
	
	for(i=0;i<4+12+16;i++){
		WARARERU[i] = WARU[i];
	}
	for(i=0;i<4+12+16;i++){
		WARU[i] = S[i+1];
	}
    WARU[4+12+16] = 0;
}
if(l>=1){
	for(i=0;i<16+16;i++){
		SWA[i] = WARARERU[i];
	}
	for(i=0;i<4+12+16;i++){
		WARARERU[i] = WARU[i];
	}
	for(i=0;i<4+12+16;i++){
		WARU[i] = SWA[i];
	}
    WARU[4+12+16] = 0;
}
	for(i=0;i<33;i++){
		Q[i] = 0;
	}
	for(i=0;i</*15*/31;i++){
	if(WARARERU[3+12+16-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+8;i++){
		if(SIGMA[8+8-i] != 0){
			l=8+8-i;break;
		}
	}
	if(l==16){goto ayamari16ko;}
	if(l==15){goto ayamari15ko;}
	if(l==14){goto ayamari14ko;}
	if(l==13){goto ayamari13ko;}
	if(l==12){goto ayamari12ko;}
	if(l==11){goto ayamari11ko;}
	if(l==10){goto ayamari10ko;}
	if(l==9){goto ayamari9ko;}
	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;}
	
	
	
	
	
	
	
ayamari16ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
	RAW12EXP = GF256VEC2EXP(Y,SIGMA[12]);
	RAW13EXP = GF256VEC2EXP(Y,SIGMA[13]);
	RAW14EXP = GF256VEC2EXP(Y,SIGMA[14]);
	RAW15EXP = GF256VEC2EXP(Y,SIGMA[15]);
	RAW16EXP = GF256VEC2EXP(Y,SIGMA[16]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW16EXP,(255-i)*16)) ^GF256EXP2VEC(Y,GF256MULT(RAW15EXP,(255-i)*15)) ^GF256EXP2VEC(Y,GF256MULT(RAW14EXP,(255-i)*14)) ^GF256EXP2VEC(Y,GF256MULT(RAW13EXP,(255-i)*13)) ^GF256EXP2VEC(Y,GF256MULT(RAW12EXP,(255-i)*12)) ^GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 15 && CHEN[i] == 1){
ERRLOC16 = i;FLAG = 16;
}
if(FLAG == 14 && CHEN[i] == 1){
ERRLOC15 = i;FLAG = 15;
}
if(FLAG == 13 && CHEN[i] == 1){
ERRLOC14 = i;FLAG = 14;
}
if(FLAG == 12 && CHEN[i] == 1){
ERRLOC13 = i;FLAG = 13;
}
if(FLAG == 11 && CHEN[i] == 1){
ERRLOC12 = i;FLAG = 12;
}
if(FLAG == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%dERRLOC12=%dERRLOC13=%dERRLOC14=%dERRLOC15=%dERRLOC16=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12,ERRLOC13,ERRLOC14,ERRLOC15,ERRLOC16);
BUNBO16EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC1)))
))
)
;
BUNBO16EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC2)))
))
)
;
BUNBO16EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC3)))
))
)
;
BUNBO16EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC4)))
))
)
;
BUNBO16EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC5)))
))
)
;
BUNBO16EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC6)))
))
)
;
BUNBO16EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC7)))
))
)
;
BUNBO16EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC8)))
))
)
;
BUNBO16EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC9)))
))
)
;	
BUNBO16EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC10)))
))
)
;
BUNBO16EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC11)))
))
)
;
BUNBO16EXP12 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC12)))
))
)
;
BUNBO16EXP13 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC13)))
))
)
;
BUNBO16EXP14 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC14)))
))
)
;
BUNBO16EXP15 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC16+(255-ERRLOC15)))
))
)
;
BUNBO16EXP16 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC16)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC16)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC1) + (255-BUNBO16EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC2) + (255-BUNBO16EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC3) + (255-BUNBO16EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC4) + (255-BUNBO16EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC5) + (255-BUNBO16EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC6) + (255-BUNBO16EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC7) + (255-BUNBO16EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC8) + (255-BUNBO16EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC9) + (255-BUNBO16EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC10) + (255-BUNBO16EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC11) + (255-BUNBO16EXP11))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC12, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC12) + (255-BUNBO16EXP12))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC13, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC13) + (255-BUNBO16EXP13))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC14, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC14) + (255-BUNBO16EXP14))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC15, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC15) + (255-BUNBO16EXP15))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC16, GF256EXP2VEC(Y,ika254(SYNDSIGMA16EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,RAW16EXP,ERRLOC16) + (255-BUNBO16EXP16))));
goto endend;// while(1);
	
	
	
ayamari15ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
	RAW12EXP = GF256VEC2EXP(Y,SIGMA[12]);
	RAW13EXP = GF256VEC2EXP(Y,SIGMA[13]);
	RAW14EXP = GF256VEC2EXP(Y,SIGMA[14]);
	RAW15EXP = GF256VEC2EXP(Y,SIGMA[15]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW15EXP,(255-i)*15)) ^GF256EXP2VEC(Y,GF256MULT(RAW14EXP,(255-i)*14)) ^GF256EXP2VEC(Y,GF256MULT(RAW13EXP,(255-i)*13)) ^GF256EXP2VEC(Y,GF256MULT(RAW12EXP,(255-i)*12)) ^GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 14 && CHEN[i] == 1){
ERRLOC15 = i;FLAG = 15;
}
if(FLAG == 13 && CHEN[i] == 1){
ERRLOC14 = i;FLAG = 14;
}
if(FLAG == 12 && CHEN[i] == 1){
ERRLOC13 = i;FLAG = 13;
}
if(FLAG == 11 && CHEN[i] == 1){
ERRLOC12 = i;FLAG = 12;
}
if(FLAG == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%dERRLOC12=%dERRLOC13=%dERRLOC14=%dERRLOC15=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12,ERRLOC13,ERRLOC14,ERRLOC15);
BUNBO15EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC1)))
))
)
;
BUNBO15EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC2)))
))
)
;
BUNBO15EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC3)))
))
)
;
BUNBO15EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC4)))
))
)
;
BUNBO15EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC5)))
))
)
;
BUNBO15EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC6)))
))
)
;
BUNBO15EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC7)))
))
)
;
BUNBO15EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC8)))
))
)
;
BUNBO15EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC9)))
))
)
;	
BUNBO15EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC10)))
))
)
;
BUNBO15EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC11)))
))
)
;
BUNBO15EXP12 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC12)))
))
)
;
BUNBO15EXP13 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC13)))
))
)
;
BUNBO15EXP14 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC15+(255-ERRLOC14)))
))
)
;
BUNBO15EXP15 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC15)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC15)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC1) + (255-BUNBO15EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC2) + (255-BUNBO15EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC3) + (255-BUNBO15EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC4) + (255-BUNBO15EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC5) + (255-BUNBO15EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC6) + (255-BUNBO15EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC7) + (255-BUNBO15EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC8) + (255-BUNBO15EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC9) + (255-BUNBO15EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC10) + (255-BUNBO15EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC11) + (255-BUNBO15EXP11))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC12, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC12) + (255-BUNBO15EXP12))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC13, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC13) + (255-BUNBO15EXP13))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC14, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC14) + (255-BUNBO15EXP14))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC15, GF256EXP2VEC(Y,ika254(SYNDSIGMA15EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,RAW15EXP,ERRLOC15) + (255-BUNBO15EXP15))));
goto endend;// while(1);
	
	
ayamari14ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
	RAW12EXP = GF256VEC2EXP(Y,SIGMA[12]);
	RAW13EXP = GF256VEC2EXP(Y,SIGMA[13]);
	RAW14EXP = GF256VEC2EXP(Y,SIGMA[14]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW14EXP,(255-i)*14)) ^GF256EXP2VEC(Y,GF256MULT(RAW13EXP,(255-i)*13)) ^GF256EXP2VEC(Y,GF256MULT(RAW12EXP,(255-i)*12)) ^GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 13 && CHEN[i] == 1){
ERRLOC14 = i;FLAG = 14;
}
if(FLAG == 12 && CHEN[i] == 1){
ERRLOC13 = i;FLAG = 13;
}
if(FLAG == 11 && CHEN[i] == 1){
ERRLOC12 = i;FLAG = 12;
}
if(FLAG == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%dERRLOC12=%dERRLOC13=%dERRLOC14=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12,ERRLOC13,ERRLOC14);
BUNBO14EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC1)))
))
)
;
BUNBO14EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC2)))
))
)
;
BUNBO14EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC3)))
))
)
;
BUNBO14EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC4)))
))
)
;
BUNBO14EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC5)))
))
)
;
BUNBO14EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC6)))
))
)
;
BUNBO14EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC7)))
))
)
;
BUNBO14EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC8)))
))
)
;
BUNBO14EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC9)))
))
)
;	
BUNBO14EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC10)))
))
)
;
BUNBO14EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC11)))
))
)
;
BUNBO14EXP12 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC12)))
))
)
;
BUNBO14EXP13 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC14+(255-ERRLOC13)))
))
)
;
BUNBO14EXP14 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC14)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC14)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC1) + (255-BUNBO14EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC2) + (255-BUNBO14EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC3) + (255-BUNBO14EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC4) + (255-BUNBO14EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC5) + (255-BUNBO14EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC6) + (255-BUNBO14EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC7) + (255-BUNBO14EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC8) + (255-BUNBO14EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC9) + (255-BUNBO14EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC10) + (255-BUNBO14EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC11) + (255-BUNBO14EXP11))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC12, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC12) + (255-BUNBO14EXP12))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC13, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC13) + (255-BUNBO14EXP13))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC14, GF256EXP2VEC(Y,ika254(SYNDSIGMA14EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,RAW14EXP,ERRLOC14) + (255-BUNBO14EXP14))));
goto endend;// while(1);
	
	
	
	
ayamari13ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
	RAW12EXP = GF256VEC2EXP(Y,SIGMA[12]);
	RAW13EXP = GF256VEC2EXP(Y,SIGMA[13]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW13EXP,(255-i)*13)) ^GF256EXP2VEC(Y,GF256MULT(RAW12EXP,(255-i)*12)) ^GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 12 && CHEN[i] == 1){
ERRLOC13 = i;FLAG = 13;
}
if(FLAG == 11 && CHEN[i] == 1){
ERRLOC12 = i;FLAG = 12;
}
if(FLAG == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%dERRLOC12=%dERRLOC13=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12,ERRLOC13);
BUNBO13EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC1)))
))
)
;
BUNBO13EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC2)))
))
)
;
BUNBO13EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC3)))
))
)
;
BUNBO13EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC4)))
))
)
;
BUNBO13EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC5)))
))
)
;
BUNBO13EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC6)))
))
)
;
BUNBO13EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC7)))
))
)
;
BUNBO13EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC8)))
))
)
;
BUNBO13EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC9)))
))
)
;	
BUNBO13EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC10)))
))
)
;
BUNBO13EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC11)))
))
)
;
BUNBO13EXP12 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC13+(255-ERRLOC12)))
))
)
;
BUNBO13EXP13 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC13)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC13)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC1) + (255-BUNBO13EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC2) + (255-BUNBO13EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC3) + (255-BUNBO13EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC4) + (255-BUNBO13EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC5) + (255-BUNBO13EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC6) + (255-BUNBO13EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC7) + (255-BUNBO13EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC8) + (255-BUNBO13EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC9) + (255-BUNBO13EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC10) + (255-BUNBO13EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC11) + (255-BUNBO13EXP11))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC12, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC12) + (255-BUNBO13EXP12))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC13, GF256EXP2VEC(Y,ika254(SYNDSIGMA13EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,RAW13EXP,ERRLOC13) + (255-BUNBO13EXP13))));
goto endend;// while(1);
	
	
	
	
ayamari12ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
	RAW12EXP = GF256VEC2EXP(Y,SIGMA[12]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW12EXP,(255-i)*12)) ^GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 11 && CHEN[i] == 1){
ERRLOC12 = i;FLAG = 12;
}
if(FLAG == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%dERRLOC12=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11,ERRLOC12);
BUNBO12EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC1)))
))
)
;
BUNBO12EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC2)))
))
)
;
BUNBO12EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC3)))
))
)
;
BUNBO12EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC4)))
))
)
;
BUNBO12EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC5)))
))
)
;
BUNBO12EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC6)))
))
)
;
BUNBO12EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC7)))
))
)
;
BUNBO12EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC8)))
))
)
;
BUNBO12EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC9)))
))
)
;	
BUNBO12EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC10)))
))
)
;
BUNBO12EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC12+(255-ERRLOC11)))
))
)
;
BUNBO12EXP12 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC12)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC12)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC1) + (255-BUNBO12EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC2) + (255-BUNBO12EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC3) + (255-BUNBO12EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC4) + (255-BUNBO12EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC5) + (255-BUNBO12EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC6) + (255-BUNBO12EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC7) + (255-BUNBO12EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC8) + (255-BUNBO12EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC9) + (255-BUNBO12EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC10) + (255-BUNBO12EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC11) + (255-BUNBO12EXP11))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC12, GF256EXP2VEC(Y,ika254(SYNDSIGMA12EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,RAW12EXP,ERRLOC12) + (255-BUNBO12EXP12))));
goto endend;// while(1);
	
	
	
	
ayamari11ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
	RAW11EXP = GF256VEC2EXP(Y,SIGMA[11]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW11EXP,(255-i)*11)) ^GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 10 && CHEN[i] == 1){
ERRLOC11 = i;FLAG = 11;
}
if(FLAG == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%dERRLOC11=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10,ERRLOC11);
BUNBO11EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC1)))
))
)
;
BUNBO11EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC2)))
))
)
;
BUNBO11EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC3)))
))
)
;
BUNBO11EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC4)))
))
)
;
BUNBO11EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC5)))
))
)
;
BUNBO11EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC6)))
))
)
;
BUNBO11EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC7)))
))
)
;
BUNBO11EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC8)))
))
)
;
BUNBO11EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC9)))
))
)
;	
BUNBO11EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC11+(255-ERRLOC10)))
))
)
;
BUNBO11EXP11 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC11)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC11)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC1) + (255-BUNBO11EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC2) + (255-BUNBO11EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC3) + (255-BUNBO11EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC4) + (255-BUNBO11EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC5) + (255-BUNBO11EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC6) + (255-BUNBO11EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC7) + (255-BUNBO11EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC8) + (255-BUNBO11EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC9) + (255-BUNBO11EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC10) + (255-BUNBO11EXP10))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC11, GF256EXP2VEC(Y,ika254(SYNDSIGMA11EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,RAW11EXP,ERRLOC11) + (255-BUNBO11EXP11))));
goto endend;// while(1);
	
	
	
ayamari10ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
	RAW10EXP = GF256VEC2EXP(Y,SIGMA[10]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW10EXP,(255-i)*10)) ^GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 9 && CHEN[i] == 1){
ERRLOC10 = i;FLAG = 10;
}
if(FLAG == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%dERRLOC10=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9,ERRLOC10);
BUNBO10EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC1)))
))
)
;
BUNBO10EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC2)))
))
)
;
BUNBO10EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC3)))
))
)
;
BUNBO10EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC4)))
))
)
;
BUNBO10EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC5)))
))
)
;
BUNBO10EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC6)))
))
)
;
BUNBO10EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC7)))
))
)
;
BUNBO10EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC8)))
))
)
;
BUNBO10EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC10+(255-ERRLOC9)))
))
)
;	
BUNBO10EXP10 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC10)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC10)))
))
)
;
//	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC1) + (255-BUNBO10EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC2) + (255-BUNBO10EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC3) + (255-BUNBO10EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC4) + (255-BUNBO10EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC5) + (255-BUNBO10EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC6) + (255-BUNBO10EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC7) + (255-BUNBO10EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC8) + (255-BUNBO10EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC9) + (255-BUNBO10EXP9))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC10, GF256EXP2VEC(Y,ika254(SYNDSIGMA10EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,RAW10EXP,ERRLOC10) + (255-BUNBO10EXP10))));
goto endend;// while(1);
	
	
	
	
	
ayamari9ko:
	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]);
	RAW9EXP = GF256VEC2EXP(Y,SIGMA[9]);
for(i=0;i<255;i++){
	CHEN[i] = (GF256EXP2VEC(Y,GF256MULT(RAW9EXP,(255-i)*9)) ^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 == 8 && CHEN[i] == 1){
ERRLOC9 = i;FLAG = 9;
}
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=%dERRLOC9=%d\n",ERRLOC1,ERRLOC2,ERRLOC3,ERRLOC4,ERRLOC5,ERRLOC6,ERRLOC7,ERRLOC8,ERRLOC9);
BUNBO9EXP = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC1)))
))
)
;
BUNBO9EXP2 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC2)))
))
)
;
BUNBO9EXP3 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC3)))
))
)
;
BUNBO9EXP4 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC4)))
))
)
;
BUNBO9EXP5 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC5)))
))
)
;
BUNBO9EXP6 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC6)))
))
)
;
BUNBO9EXP7 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC7)))
))
)
;
BUNBO9EXP8 = 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)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC9+(255-ERRLOC8)))
))
)
;
BUNBO9EXP9 = ika254(GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC1+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC2+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC3+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC4+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC5+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC6+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC7+(255-ERRLOC9)))
))
+ GF256VEC2EXP2(Y,(1 ^ GF256EXP2VEC(Y,
ika254(ERRLOC8+(255-ERRLOC9)))
))
)
	;printf("tootta!!\n");
printf("AYAMARIATAI[%d]=%x\n",ERRLOC1, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC1) + (255-BUNBO9EXP))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC2, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC2) + (255-BUNBO9EXP2))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC3, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC3) + (255-BUNBO9EXP3))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC4, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC4) + (255-BUNBO9EXP4))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC5, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC5) + (255-BUNBO9EXP5))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC6, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC6) + (255-BUNBO9EXP6))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC7, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC7) + (255-BUNBO9EXP7))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC8, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC8) + (255-BUNBO9EXP8))));
printf("AYAMARIATAI[%d]=%x\n",ERRLOC9, GF256EXP2VEC(Y,ika254(SYNDSIGMA9EXP(Y,S,RAW1EXP,RAW2EXP,RAW3EXP,RAW4EXP,RAW5EXP,RAW6EXP,RAW7EXP,RAW8EXP,RAW9EXP,ERRLOC9) + (255-BUNBO9EXP9))));
goto endend;// while(1);
	
	
	
//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("tootta!!\n");
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;
}