
/************************************************************/
/*                                                   		*/
/*   Program Name:                                   		*/
/*                                                   		*/
/*   Author      : Takashi Nakajima                  		*/
/*                                                   		*/
/*   Function    : BINARY FILE OPEN                   		*/
/*                                                   		*/
/*   History     : 2010.07.31 11:48 New Create Ver0.001  	*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/*                                                   		*/
/************************************************************/
//#ifndef _STDLIB_H_
//#define _STDLIB_H_
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

typedef struct control_data {
	unsigned int sizex;
	unsigned int sizey;
	char InputFileName[128];
	char OutputFileName[128];
} CNTL;
int hsize;
int vsize;
char inputfile[128];
char outputfile[128];

//#include "mediancut8.c"
/***********************************************/
/*                                             */
/*    YUV空間でカットY方向を4倍にのばした空間  */
/*                                             */
/*                                             */
/*    分散最大の軸で大津法でカット             */
/*                                             */
/*    平均からの距離が最大のものがあるもの     */
/*    を分轄                                   */
/*                                             */
/*                                             */
/*                                             */
/*                                             */
/*                                             */
/*    画素から最短距離にあるインデックス       */
/*    カラーを採用                             */
/*                                             */
/*    インデックスカラーはボックスの重心       */
/*                                             */
/*    画素数が０のボックスをカウントに         */
/*    入れない                                 */
/*                                             */
/*    IROSUU に減色する色の数を設定            */
/*                                             */
/*                                             */
/*                                             */
/*                                             */
/***********************************************/
//#ifndef _STDLIB_H_
//#define _STDLIB_H_
//#include <stdio.h>



//#include <string.h>
//#include <math.h>
//#include <stdlib.h>
//#endif
#define RD 0
#define GD 0
#define BD 0
#define IROSUU 256
#define YGAMMA 1.1
#define YMULT 4.0*255.0/pow(255.0,YGAMMA)
#define RMULT 4.0
#define BMULT 3.0
#define EDGETH 25


struct palet//パレット構造体
{ 
	int U_R;
	int U_G;
	int U_B;
	int IG_R;
	int IG_G;
	int IG_B;
	int INDEXNUM;
	int INDEXNO;
	double MAXDISTANCE;
	double IGENMAX;
	
};


struct palet PT[2][IROSUU];
struct palet *PTP;

int Jacobi(int n, int ct, double eps, double **A, double **A1, double **A2,
           double **X1, double **X2)
{
	double max, s, t, v, sn, cs;
	int i1, i2, k = 0, ind = 1, p = 0, q = 0;
					// 初期設定
	for (i1 = 0; i1 < n; i1++) {
		for (i2 = 0; i2 < n; i2++) {
			A1[i1][i2] = A[i1][i2];
			X1[i1][i2] = 0.0;
		}
		X1[i1][i1] = 1.0;
	}
					// 計算
	while (ind > 0 && k < ct) {
						// 最大要素の探索
		max = 0.0;
		for (i1 = 0; i1 < n; i1++) {
			for (i2 = 0; i2 < n; i2++) {
				if (i2 != i1) {
					if (fabs(A1[i1][i2]) > max) {
						max = fabs(A1[i1][i2]);
						p   = i1;
						q   = i2;
					}
				}
			}
		}
						// 収束判定
							// 収束した
		if (max < eps)
			ind = 0;
							// 収束しない
		else {
								// 準備
			s  = -A1[p][q];
			t  = 0.5 * (A1[p][p] - A1[q][q]);
			v  = fabs(t) / sqrt(s * s + t * t);
			sn = sqrt(0.5 * (1.0 - v));
			if (s*t < 0.0)
				sn = -sn;
			cs = sqrt(1.0 - sn * sn);
								// Akの計算
			for (i1 = 0; i1 < n; i1++) {
				if (i1 == p) {
					for (i2 = 0; i2 < n; i2++) {
						if (i2 == p)
							A2[p][p] = A1[p][p] * cs * cs + A1[q][q] * sn * sn -
                                       2.0 * A1[p][q] * sn * cs;
						else if (i2 == q)
							A2[p][q] = 0.0;
						else
							A2[p][i2] = A1[p][i2] * cs - A1[q][i2] * sn;
					}
				}
				else if (i1 == q) {
					for (i2 = 0; i2 < n; i2++) {
						if (i2 == q)
							A2[q][q] = A1[p][p] * sn * sn + A1[q][q] * cs * cs +
                                       2.0 * A1[p][q] * sn * cs;
						else if (i2 == p)
							A2[q][p] = 0.0;
						else
							A2[q][i2] = A1[q][i2] * cs + A1[p][i2] * sn;
					}
				}
				else {
					for (i2 = 0; i2 < n; i2++) {
						if (i2 == p)
							A2[i1][p] = A1[i1][p] * cs - A1[i1][q] * sn;
						else if (i2 == q)
							A2[i1][q] = A1[i1][q] * cs + A1[i1][p] * sn;
						else
							A2[i1][i2] = A1[i1][i2];
					}
				}
			}
								// Xkの計算
			for (i1 = 0; i1 < n; i1++) {
				for (i2 = 0; i2 < n; i2++) {
					if (i2 == p)
						X2[i1][p] = X1[i1][p] * cs - X1[i1][q] * sn;
					else if (i2 == q)
						X2[i1][q] = X1[i1][q] * cs + X1[i1][p] * sn;
					else
						X2[i1][i2] = X1[i1][i2];
				}
			}
								// 次のステップへ
			k++;
			for (i1 = 0; i1 < n; i1++) {
				for (i2 = 0; i2 < n; i2++) {
					A1[i1][i2] = A2[i1][i2];
					X1[i1][i2] = X2[i1][i2];
				}
			}
		}
	}

	return ind;
}

int ohtsu (int NUM,int *X){
int i,j,k,l,m,n,o,p;
//int SUM1;
//int X[NUM] = {-10,-10,-10,-10,-10,
//        -10,-10,-10,-10,-10,
//        -3,-3,-3,-3,-3,
//        -1,-1,0,1,1,
//        3,3,3,3,3,
//        10,10,10,10,10,
//        10,10,10,10,10};
int MAX = -10000;
int MIN = 99999;
for(i=0;i<NUM;i++){
	if(MIN > *(X+i)){
		MIN = *(X+i);
	}
	if(MAX < *(X+i)){
		MAX = *(X+i);
	}
}
int NODEHANI;
NODEHANI = MAX - MIN + 1;
int *HIST;
HIST = (int *)malloc(sizeof(int)*NODEHANI);
//ND  
//0- -11
//1- -10
     
//11-  0


//22- 11
for(i=0;i<NODEHANI;i++){
	*(HIST+i) = 0;
}
int TMP;
for(i=0;i<NUM;i++){
	TMP = *(X+i)-MIN;
	(*(HIST+TMP))++;
}
//debug start
//for(i=0;i<NODEHANI;i++){
//	fprintf(stderr,"NUM ATAI HIST %d %d %d\n",i,i+MIN,*(HIST+i));
//}
//	while(1);
//debug end

float MAX2 = 0.0;
float AVE1,AVE2;
int TOTAL1,TOTAL2;
float HANTEI;
int THRESH;
for(i=1;i<NODEHANI;i++){
	AVE1 = 0.0;
	TOTAL1 = 0;
	for(j=0;j<i;j++){
		AVE1 += (*(HIST+j))*(j+MIN);
		TOTAL1 += (*(HIST+j));
	}
	AVE1 /= (float)(TOTAL1);
	AVE2 = 0.0;
	TOTAL2 = 0;
	for(j=i;j<NODEHANI;j++){
		AVE2 += (*(HIST+j))*(j+MIN);
		TOTAL2 += (*(HIST+j));
	}
	AVE2 /= (float)(TOTAL2);
	
	HANTEI = (float)(TOTAL1)*(float)(TOTAL2)*(AVE1 - AVE2)*(AVE1 - AVE2);
	
	if(MAX2 < HANTEI){
		MAX2 = HANTEI;
		THRESH = i;
	}
	
}
	THRESH += MIN;
//debug start
//	fprintf(stderr,"THRE=%d",THRESH);
//debug end
	return (THRESH);
//	return (0);
}//main kansuu end


void modoshi(double V[3],double R,double G,double B,double *X,double *Y,double *Z)
{
double THIETA,FAI;
double X1,Y1,Z1,KARI;
double PI=atan(1.0)*4.0;
double COSTHIETA,SINTHIETA,SQV1V2,ONEMINCOSTHIETA,NX,NY,NZ;
	
	SINTHIETA = -sqrt((V[1]*V[1]+V[2]*V[2])/(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]));
	COSTHIETA = V[0]/sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]);
	SQV1V2=sqrt(V[1]*V[1]+V[2]*V[2]);
	NX=0.0;
	NY=V[2]/SQV1V2;
	NZ=-V[1]/SQV1V2;
	ONEMINCOSTHIETA=1.0-COSTHIETA;
	*X=(NX*NX*ONEMINCOSTHIETA+COSTHIETA)*R+(NX*NY*ONEMINCOSTHIETA-NZ*SINTHIETA)*G+(NZ*NX*ONEMINCOSTHIETA+NY*SINTHIETA)*B;
	*Y=(NX*NY*ONEMINCOSTHIETA+NZ*SINTHIETA)*R+(NY*NY*ONEMINCOSTHIETA+COSTHIETA)*G+(NY*NZ*ONEMINCOSTHIETA-NX*SINTHIETA)*B;
	*Z=(NZ*NX*ONEMINCOSTHIETA-NY*SINTHIETA)*R+(NY*NZ*ONEMINCOSTHIETA+NX*SINTHIETA)*G+(NZ*NZ*ONEMINCOSTHIETA+COSTHIETA)*B;
}//fprintf(stderr,"X1=%f,Y1=%f,Z1=%fTHIETA=%fFAI=%f,%f\n",X1,Y1,Z1,THIETA/3.14,FAI/3.14,sqrt(V[0]*V[0]+V[1]*V[1])/V[2]);


void kaiten(double V[3],double X,double Y,double Z,double *R,double *G,double *B){
double SINTHIETA,COSTHIETA;
double NX,NY,NZ;
double R1,G1,B1,KARI;
double PI=atan(1.0)*4.0;
double SQV1V2,ONEMINCOSTHIETA;
	SINTHIETA = sqrt((V[1]*V[1]+V[2]*V[2])/(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]));
	COSTHIETA = V[0]/sqrt(V[0]*V[0]+V[1]*V[1]+V[2]*V[2]);
	SQV1V2=sqrt(V[1]*V[1]+V[2]*V[2]);
	NX=0.0;
	NY=V[2]/SQV1V2;
	NZ=-V[1]/SQV1V2;
	ONEMINCOSTHIETA=1.0-COSTHIETA;
	R1=(NX*NX*ONEMINCOSTHIETA+COSTHIETA)*X+(NX*NY*ONEMINCOSTHIETA-NZ*SINTHIETA)*Y+(NZ*NX*ONEMINCOSTHIETA+NY*SINTHIETA)*Z;
	G1=(NX*NY*ONEMINCOSTHIETA+NZ*SINTHIETA)*X+(NY*NY*ONEMINCOSTHIETA+COSTHIETA)*Y+(NY*NZ*ONEMINCOSTHIETA-NX*SINTHIETA)*Z;
	B1=(NZ*NX*ONEMINCOSTHIETA-NY*SINTHIETA)*X+(NY*NZ*ONEMINCOSTHIETA+NX*SINTHIETA)*Y+(NZ*NZ*ONEMINCOSTHIETA+COSTHIETA)*Z;
	
//	*R=R1+0.5;
  //  *G=G1+0.5;
	//*B=B1+0.5;
	*R=R1;
    *G=G1;
	*B=B1;
}


void MedianCut (int hsize, int vsize, unsigned char *RIN, unsigned char *GIN, unsigned char *BIN, unsigned char *PALETGAZOU,unsigned char REDUCE_R[256],unsigned char REDUCE_G[256],unsigned char REDUCE_B[256])//unsigned char *ROUT, unsigned char *GOUT, unsigned char *BOUT)
{
	int DIVIDENUM;
	int RDIV;
	int GDIV;
	int BDIV;
	int i,j,k,l,m,n,o,p;
	int MEN;
	int NMEN;
	int NUM;
//	unsigned char *PALETGAZOU;
//	unsigned char REDUCE_R[IROSUU];
//	unsigned char REDUCE_G[IROSUU];
//	unsigned char REDUCE_B[IROSUU];
	double MINZ;
	double Z[IROSUU];
	int X;
	double SUM_R[IROSUU];
	double SUM_G[IROSUU];
	double SUM_B[IROSUU];
	double HEIKIN_R[IROSUU];
	double HEIKIN_G[IROSUU];
	double HEIKIN_B[IROSUU];
	double **A , **A1, **A2, **X1, **X2, eps;
	int i1, i2, ind, ct;
	double TMP_RR;
	double TMP_GG;
	double TMP_BB;
	double TMP_RG;
	double TMP_RB;
	double TMP_GB;
	double IGENMAX;
	int Y;
	double ZZ;
	int *INDEX;
	double U_R;
	double U_G;
	double U_B;
	int MAXINDEXNUM;
//	int KARI;
	int KARI1;
	int KARI2;
	int KARI3;
	int KARI4;
	int KARI5;
	int KARI6;
	int FLAG;
	double *YIN;
	double *UIN;
	double *VIN;
	double *RRR33;
	//RGBをYUVに変換
	YIN = (double *)malloc(sizeof(double)*hsize*vsize);
	UIN = (double *)malloc(sizeof(double)*hsize*vsize);
	VIN = (double *)malloc(sizeof(double)*hsize*vsize);
	RRR33 = (double *)malloc(sizeof(double)*hsize*vsize);
	for(i=0;i<hsize*vsize;i++){
		*(YIN+i) = (0.29891*(float)(*(RIN+i))+0.58661*(float)(*(GIN+i))+0.11448*(float)(*(BIN+i)) + 0.5);
		*(UIN+i) = ((-0.16874*(float)(*(RIN+i))-0.33126*(float)(*(GIN+i))+0.50000*(float)(*(BIN+i))) + 128.5);
		*(VIN+i) = (0.50000*(float)(*(RIN+i))-0.41869*(float)(*(GIN+i))-0.08131*(float)(*(BIN+i)) + 128.5);
	}
	for(i=0;i<hsize*vsize;i++){
		*(YIN+i) *= YMULT;
	}
	for(i=0;i<hsize*vsize;i++){
		*(YIN+i) = pow(*(YIN+i),YGAMMA);
	}
	for(i=0;i<hsize*vsize;i++){
		*(VIN+i) *= RMULT;
	}
	for(i=0;i<hsize*vsize;i++){
		*(UIN+i) *= BMULT;
	}
	//YUVは、0-255 たまに負や255を超える場合が発生するかも、あとで検証
//debug start
//	for(i=0;i<hsize*vsize;i++){
//		fprintf(stderr," %d %d %d\n",*(YIN+i),*(UIN+i),*(VIN+i));
//	}
//	while(1);
//debug end
/****************************************/
/*										*/
/* edge detect							*/
/*										*/
/****************************************/
	int *IRIN;
	int *IGIN;
	int *IBIN;
	IRIN = (int*)malloc(sizeof(int)*hsize*vsize);
	IGIN = (int*)malloc(sizeof(int)*hsize*vsize);
	IBIN = (int*)malloc(sizeof(int)*hsize*vsize);
	int *EDGER,*EDGEG,*EDGEB;
	EDGER = (int *)malloc(sizeof(int)*hsize*vsize);
	EDGEG = (int *)malloc(sizeof(int)*hsize*vsize);
	EDGEB = (int *)malloc(sizeof(int)*hsize*vsize);
	int *VEDGER,*VEDGEG,*VEDGEB;
	VEDGER = (int *)malloc(sizeof(int)*hsize*vsize);
	VEDGEG = (int *)malloc(sizeof(int)*hsize*vsize);
	VEDGEB = (int *)malloc(sizeof(int)*hsize*vsize);
	for(i=0;i<hsize*vsize;i++){
		*(IRIN+i) = (int)(*(RIN+i));
		*(IGIN+i) = (int)(*(GIN+i));
		*(IBIN+i) = (int)(*(BIN+i));
	}
	
	for(i=0;i<vsize;i++){
		for(j=0;j<hsize;j++){
			k=j-1;
			l=j+1;
			if(k<0){k=-k;}
			if(k>(hsize-1)){k=2*(hsize-1)-k;}
			if(l<0){l=-l;}
			if(l>(hsize-1)){l=2*(hsize-1)-l;}
			if((abs(IRIN[k*vsize+i]-IRIN[l*vsize+i]))>=EDGETH){
            	EDGER[j*vsize+i]=1;
			} else {
				EDGER[j*vsize+i]=0;
			}
			if((abs(IGIN[k*vsize+i]-IGIN[l*vsize+i]))>=EDGETH){
            	EDGEG[j*vsize+i]=1;
			} else {
				EDGEG[j*vsize+i]=0;
			}
			if((abs(IBIN[k*vsize+i]-IBIN[l*vsize+i]))>=EDGETH){
            	EDGEB[j*vsize+i]=1;
			} else {
				EDGEB[j*vsize+i]=0;
			}
		}
	}
	for(i=0;i<hsize;i++){
		for(j=0;j<vsize;j++){
			k=j-1;
			l=j+1;
			if(k<0){
				k=-k;
			}
			if(l>(vsize-1)){
				l=2*(vsize-1)-l;
			}
			if(abs(IRIN[i*vsize+l]-IRIN[i*vsize+k])>=EDGETH){
				VEDGER[i*vsize+j] = 1;
			} else {
				VEDGER[i*vsize+j] = 0;
			}
			if(labs(IGIN[i*vsize+l]-IGIN[i*vsize+k])>=EDGETH){
				VEDGEG[i*vsize+j] = 1;
			} else {
				VEDGEG[i*vsize+j] = 0;
			}
			if(labs(IBIN[i*vsize+l]-IBIN[i*vsize+k])>=EDGETH){
				VEDGEB[i*vsize+j] = 1;
			} else {
				VEDGEB[i*vsize+j] = 0;
			}
		}
	}
	int *index3;
	index3 = (int*)malloc(sizeof(int)*hsize*vsize);
	for(i=0,k=0;i<vsize;i++){
		for(j=0;j<hsize;j++){
			if(EDGER[j*vsize+i] == 1 || EDGEG[j*vsize+i] == 1 || EDGEB[j*vsize+i] == 1 ||
			VEDGER[j*vsize+i] == 1 || VEDGEG[j*vsize+i] == 1 || VEDGEB[j*vsize+i] == 1){
				*(index3+j*vsize+i)=-1;
				k++;
			} else {
				*(index3+j*vsize+i)=1;
			}
		}
	}
//debug start
	printf("EDGE gasosuu=%d\n",k);
//debug end

	
	
	
	
	DIVIDENUM =1;
	MEN=0;
	RDIV = RD;
	GDIV = GD;
	BDIV = BD;
	if(MEN == 1){
		NMEN = 0;
	} else {
		NMEN = 1;
	}
	//MEN = 0,NMEN = 1
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	for(i=0;i<hsize*vsize;i++){
		if(*(index3+i) !=-1){
		U_R += *(YIN+i);
		U_G += *(UIN+i);
		U_B += *(VIN+i);
		}
	}
	U_R /= (double)(hsize*vsize-k);
	U_G /= (double)(hsize*vsize-k);
	U_B /= (double)(hsize*vsize-k);
//	U_R = (U_R>>RDIV);
	//U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	//U_R,U_G,U_Bは平均
	ct = 1000;
	eps = 1.0e-10;
	n = 3;
	A    = new double * [n];
	A1   = new double * [n];
	A2   = new double * [n];
	X1   = new double * [n];
	X2   = new double * [n];
	for (i1 = 0; i1 < n; i1++) {
		A[i1]  = new double [n];
		A1[i1] = new double [n];
		A2[i1] = new double [n];
		X1[i1] = new double [n];
		X2[i1] = new double [n];
	}
    //A[0][0],A[0][1],A[0][2],A[1][0],A[1][1],A[1][2],A[2][0],A[2][1],A[2][2]に分散共分散を入れる
	TMP_RR=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(RIN+i))>>RDIV)-U_R);
	TMP_GG=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(GIN+i))>>GDIV)-U_G);
	TMP_BB=0.0;//(((*(BIN+i))>>BDIV)-U_B)*(((*(BIN+i))>>BDIV)-U_B);
	TMP_RG=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(GIN+i))>>GDIV)-U_G);
	TMP_RB=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(BIN+i))>>BDIV)-U_B);
	TMP_GB=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(BIN+i))>>BDIV)-U_B);
	for(i=0;i<hsize*vsize;i++){
		if(*(index3+i) !=-1){
			TMP_RR += (double)((((*(YIN+i)))-U_R)*(((*(YIN+i)))-U_R));
			TMP_GG += (double)((((*(UIN+i)))-U_G)*(((*(UIN+i)))-U_G));
			TMP_BB += (double)((((*(VIN+i)))-U_B)*(((*(VIN+i)))-U_B));
			TMP_RG += (double)((((*(YIN+i)))-U_R)*(((*(UIN+i)))-U_G));
			TMP_RB += (double)((((*(YIN+i)))-U_R)*(((*(VIN+i)))-U_B));
			TMP_GB += (double)((((*(UIN+i)))-U_G)*(((*(VIN+i)))-U_B));
		}
	}
//debug start
//	fprintf(stderr,"BUNSAN=%f %f\n",TMP_RR,TMP_RB);
//	while(1);
//debug end
	TMP_RR /= (double)(hsize*vsize-k);
	TMP_GG /= (double)(hsize*vsize-k);
	TMP_BB /= (double)(hsize*vsize-k);
	TMP_RG /= (double)(hsize*vsize-k);
	TMP_RB /= (double)(hsize*vsize-k);
	TMP_GB /= (double)(hsize*vsize-k);
//debug start
//	fprintf(stderr,"BUNSAN=%f %f\n",TMP_RR,TMP_RB);
//	while(1);
//debug end
	
	
	
	A[0][0]= TMP_RR;
	A[0][1]= TMP_RG;
	A[1][0]= TMP_RG;
	A[1][1]= TMP_GG;
	A[2][2]= TMP_BB;
	A[0][2]= TMP_RB;
	A[2][0]= TMP_RB;
	A[1][2]= TMP_GB;
	A[2][1]= TMP_GB;
	
	ind=Jacobi(3, ct, eps, A, A1, A2, X1, X2);
	
	if(ind > 0){
		fprintf(stderr,"Jacobi syuusoku simasen!!\n");
		exit(0);
	}
//	if((A1[0][0] == A1[1][1]) || (A1[1][1] == A1[2][2]) || (A1[0][0] == A1[2][2]) ){
//		fprintf(stderr,"Igen Value duplication!!\n");
//		exit(0);
//	}
//debug start
//	for(i=0;i<3;i++){
//		for(j=0;j<3;j++){
//			fprintf(stderr,"%f ",A1[i][j]);
//		}
//			fprintf(stderr,"\n");
//	}
//debug end
	IGENMAX = -999999999999999999.9;
	for(i=0;i<3;i++){
		if(A1[i][i] > IGENMAX ){
			IGENMAX = A1[i][i];
			Y = i;
		}
	}
//debug start
//	fprintf(stderr,"Y=%d\n",Y);
//	fprintf(stderr,"IGENVEC=%f %f %f\n",X1[0][Y],X1[1][Y],X1[2][Y]);
//	while(1);
//debug end
	//Yは最大固有値の番号
	
	//(X1[0][Y],X1[1][Y],X1[2][Y]) 最大分散の固有ベクトル
//ohtsu tuika start
	double *RR;
	double *GG;
	double *BB;
	double *RRR;
	double *GGG;
	double *BBB;
	double V[3];
	double *XXX;
	double *YYY;
	double *ZZZ;
	int THRESH;
	double DTHRESH;
	RR = (double *)malloc(sizeof(double)*hsize*vsize);
	GG = (double *)malloc(sizeof(double)*hsize*vsize);
	BB = (double *)malloc(sizeof(double)*hsize*vsize);
	XXX = (double *)malloc(sizeof(double));
	YYY = (double *)malloc(sizeof(double));
	ZZZ = (double *)malloc(sizeof(double));
	RRR = (double *)malloc(sizeof(double)*hsize*vsize);
	GGG = (double *)malloc(sizeof(double)*hsize*vsize);
	BBB = (double *)malloc(sizeof(double)*hsize*vsize);
	for(i=0;i<hsize*vsize;i++){
		if(*(index3+i) !=-1){
		*(RR+i) = (double)(((*(YIN+i))) - U_R);
		*(GG+i) = (double)(((*(UIN+i))) - U_G);
		*(BB+i) = (double)(((*(VIN+i))) - U_B);
		}
	}
	V[0]=X1[0][Y];
	V[1]=X1[1][Y];
	V[2]=X1[2][Y];
	int *RRRR;
	RRRR = (int*)malloc(sizeof(int)*(hsize*vsize));
	for(i=0;i<hsize*vsize;i++){
		kaiten(V,*(RR+i),*(GG+i),*(BB+i),RRR+i,GGG+i,BBB+i);
	}
	for(i=0,l=0;i<hsize*vsize;i++){
		if(*(index3+i)!=-1){
			*(RRRR+l) = (int)(*(RRR+i)+0.5);
			l++;
		}
	}
		
	int GASOSUU = hsize*vsize-k;
	THRESH = ohtsu(GASOSUU,RRRR);
	DTHRESH = (double)(THRESH);
	modoshi(V,DTHRESH,0.0,0.0,XXX,YYY,ZZZ);

//MEN = 0,NMEN = 1
	PT[MEN][0].INDEXNO = 0;
	PT[MEN][1].INDEXNO = 1;
	
	INDEX = (int *)malloc(sizeof(int)*hsize*vsize);
	int kk;
	kk=k;
	for(i=0;i<hsize*vsize;i++){
		*(INDEX+i) =-1;
	}
	for(i=0,k=0,l=0;i<hsize*vsize;i++){
		if(*(index3+i)!=-1){
//			ZZ = X1[0][Y]*((double)(((*(YIN+i)))) - ((double)(U_R)+(*XXX))) +
//		    	 X1[1][Y]*((double)(((*(UIN+i)))) - ((double)(U_G)+(*YYY))) +
//		     	X1[2][Y]*((double)(((*(VIN+i)))) - ((double)(U_B)+(*ZZZ))) ;
//			if(ZZ>=0.0){
			if((double)(*(RRR+i))>=DTHRESH){
				*(INDEX+i) = PT[MEN][0].INDEXNO;
				k++;
			} else {
				*(INDEX+i) = PT[MEN][1].INDEXNO;
				l++;
			}
		}
	}
	PT[MEN][0].INDEXNUM = k;
	PT[MEN][1].INDEXNUM = l;
//maxdistance tuika start
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//0側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	double MAXD;
	double TEMP;
	if(PT[MEN][0].INDEXNUM != 0){
	U_R /= (double)PT[MEN][0].INDEXNUM;
	U_G /= (double)PT[MEN][0].INDEXNUM;
	U_B /= (double)PT[MEN][0].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][0].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][0].MAXDISTANCE = 0.0;
	}

	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//1側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	if(PT[MEN][1].INDEXNUM != 0){
	U_R /= (double)PT[MEN][1].INDEXNUM;
	U_G /= (double)PT[MEN][1].INDEXNUM;
	U_B /= (double)PT[MEN][1].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][1].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][1].MAXDISTANCE = 0.0;	
	}
//max distance div end	
	
//ohtsu tuika end
//debug start
//	fprintf(stderr,"%d %d\n",k,l);
//	while(1);
//debug end	
//2回目の分轄
//分轄の中の画素数が多いものを分轄
//	if(PT[MEN][0].INDEXNUM >= PT[MEN][1].INDEXNUM){
	if(PT[MEN][0].MAXDISTANCE*PT[MEN][0].INDEXNUM >= PT[MEN][1].MAXDISTANCE*PT[MEN][1].INDEXNUM){//maxdistance div tuika
		j=0;//INDEXNO
	} else {
		j=1;
	}
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	
	U_R /= (double)PT[MEN][j].INDEXNUM;
	U_G /= (double)PT[MEN][j].INDEXNUM;
	U_B /= (double)PT[MEN][j].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
//debug start
//	fprintf(stderr,"2kaimeheikin %d %d %d\n",U_R,U_G,U_B);
//debug end
	TMP_RR=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(RIN+i))>>RDIV)-U_R);
	TMP_GG=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(GIN+i))>>GDIV)-U_G);
	TMP_BB=0.0;//(((*(BIN+i))>>BDIV)-U_B)*(((*(BIN+i))>>BDIV)-U_B);
	TMP_RG=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(GIN+i))>>GDIV)-U_G);
	TMP_RB=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(BIN+i))>>BDIV)-U_B);
	TMP_GB=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(BIN+i))>>BDIV)-U_B);
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
			TMP_RR += (double)((((*(YIN+i)))-U_R)*(((*(YIN+i)))-U_R));
			TMP_GG += (double)((((*(UIN+i)))-U_G)*(((*(UIN+i)))-U_G));
			TMP_BB += (double)((((*(VIN+i)))-U_B)*(((*(VIN+i)))-U_B));
			TMP_RG += (double)((((*(YIN+i)))-U_R)*(((*(UIN+i)))-U_G));
			TMP_RB += (double)((((*(YIN+i)))-U_R)*(((*(VIN+i)))-U_B));
			TMP_GB += (double)((((*(UIN+i)))-U_G)*(((*(VIN+i)))-U_B));
		}
	}
	TMP_RR /= (double)(PT[MEN][j].INDEXNUM);
	TMP_GG /= (double)(PT[MEN][j].INDEXNUM);
	TMP_BB /= (double)(PT[MEN][j].INDEXNUM);
	TMP_RG /= (double)(PT[MEN][j].INDEXNUM);
	TMP_RB /= (double)(PT[MEN][j].INDEXNUM);
	TMP_GB /= (double)(PT[MEN][j].INDEXNUM);
//2番目の分轄の軸を求める（固有ベクトルの計算）
	A[0][0]= TMP_RR;
	A[0][1]= TMP_RG;
	A[1][0]= TMP_RG;
	A[1][1]= TMP_GG;
	A[2][2]= TMP_BB;
	A[0][2]= TMP_RB;
	A[2][0]= TMP_RB;
	A[1][2]= TMP_GB;
	A[2][1]= TMP_GB;
	
	ind=Jacobi(3, ct, eps, A, A1, A2, X1, X2);
	
	if(ind > 0){
		fprintf(stderr,"Jacobi syuusoku simasen!!\n");
		exit(0);
	}
//	if((A1[0][0] == A1[1][1]) || (A1[1][1] == A1[2][2]) || (A1[0][0] == A1[2][2]) ){
//		fprintf(stderr,"Igen Value duplication!!\n");
//		exit(0);
//	}
//debug start
//	for(i=0;i<3;i++){
//		for(m=0;m<3;m++){
//			fprintf(stderr,"%f ",A1[i][m]);
//		}
//			fprintf(stderr,"\n");
//	}
//debug end
	IGENMAX = -999999999999999999.9;
	for(i=0;i<3;i++){
		if(A1[i][i] > IGENMAX ){
			IGENMAX = A1[i][i];
			Y = i;
		}
	}
	DIVIDENUM = 3;

//ohtsu tuika start	
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
			*(RR+i) = (double)(((*(YIN+i))) - U_R);
			*(GG+i) = (double)(((*(UIN+i))) - U_G);
			*(BB+i) = (double)(((*(VIN+i))) - U_B);
		}
	}
	V[0]=X1[0][Y];
	V[1]=X1[1][Y];
	V[2]=X1[2][Y];
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
			kaiten(V,*(RR+i),*(GG+i),*(BB+i),RRR+i,GGG+i,BBB+i);
		}
	}
	GASOSUU = PT[MEN][j].INDEXNUM;
	for(i=0;i<hsize*vsize;i++){
		*(RRR33+i)=(double)(*(RRR+i));
	}
	for(i=0,k=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
			*(RR+k) = (double)(*(RRR+i));
			k++;
		}
	}
	for(i=0;i<hsize*vsize;i++){
		*(RRRR+i) = (int)(*(RR+i)+0.5);
	}
//ohtsu tuika end	
	if(MEN == 1){
		MEN = 0;
		NMEN = 1;
	} else {
		MEN = 1;
		NMEN = 0;
	}
//ohtsu tuika start	
	THRESH = ohtsu(GASOSUU,RRRR);
	DTHRESH = (double)(THRESH);
	modoshi(V,DTHRESH,0.0,0.0,XXX,YYY,ZZZ);

	
	for(i=0,k=0,l=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == j){
//			ZZ = X1[0][Y]*((double)(((*(YIN+i)))) - ((double)(U_R)+(*XXX))) +
//			     X1[1][Y]*((double)(((*(UIN+i)))) - ((double)(U_G)+(*YYY))) +
//			     X1[2][Y]*((double)(((*(VIN+i)))) - ((double)(U_B)+(*ZZZ))) ;
//			if(ZZ>=0.0){
			if(*(RRR33+i)>=DTHRESH){
				*(INDEX+i) = DIVIDENUM-1;
				k++;
			} else {
				;
				l++;
			}
		}
	}
	PT[MEN][0].INDEXNO = j;
	PT[MEN][1].INDEXNO = DIVIDENUM - 1;
	PT[MEN][0].INDEXNUM = l;
	PT[MEN][1].INDEXNUM = k;

//max distance div tuika	
	

	
	
	
//maxdistance tuika start
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//0側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	if(PT[MEN][0].INDEXNUM != 0){
	U_R /= (double)PT[MEN][0].INDEXNUM;
	U_G /= (double)PT[MEN][0].INDEXNUM;
	U_B /= (double)PT[MEN][0].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
//	int TEMP;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][0].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][0].MAXDISTANCE = 0.0;	
	}
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//1側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	if(PT[MEN][1].INDEXNUM != 0){
	U_R /= (double)PT[MEN][1].INDEXNUM;
	U_G /= (double)PT[MEN][1].INDEXNUM;
	U_B /= (double)PT[MEN][1].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][1].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][1].MAXDISTANCE = 0.0;	
	}
//max distance div end	
	
	
	
	
	
	
		if(j == 0){
			for(i=2;i<=DIVIDENUM-1;i++){
				PT[MEN][i].INDEXNO =PT[NMEN][i-1].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-1].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-1].MAXDISTANCE;//max distance div tuika
			}
		}
		if((j >= 1) && (j <=(DIVIDENUM-3))){
			for(i=2;i<=j+1;i++){
////				i i-2
				PT[MEN][i].INDEXNO =PT[NMEN][i-2].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-2].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-2].MAXDISTANCE;//max distance div tuika
			}
			
			for(i=j+2;i<=DIVIDENUM-1;i++){
////				i i-1
				PT[MEN][i].INDEXNO =PT[NMEN][i-1].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-1].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-1].MAXDISTANCE;//max distance div tuika
			}
		}
		if(j == (DIVIDENUM-2)){
			for(i=2;i<=j+1;i++){
////				i i-2
				PT[MEN][i].INDEXNO =PT[NMEN][i-2].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-2].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-2].MAXDISTANCE;//max distance div tuika
				
			}
		}

//debug start
//	for(i=0;i<3;i++){
//		fprintf(stderr,"%d %d %d\n",i,PT[MEN][i].INDEXNO,PT[MEN][i].INDEXNUM);
//	}
//debug end
	
	double MAXBUNSAN = 100.0;
//9/9 kokokara	
	while(DIVIDENUM < 256){
//最大画素数のブロックをさがし、そのINDEXNOを調べる。
		MAXINDEXNUM = -1;
		for(i=0;i<DIVIDENUM;i++){
//			if(PT[MEN][i].INDEXNUM > MAXINDEXNUM){
//				MAXINDEXNUM = PT[MEN][i].INDEXNUM;
			if(PT[MEN][i].MAXDISTANCE*PT[MEN][i].INDEXNUM > MAXINDEXNUM){
				MAXINDEXNUM = (int)PT[MEN][i].MAXDISTANCE*PT[MEN][i].INDEXNUM;//max distance tuika
				NUM = i;
			}
		}
		FLAG = 0;
label:		
//debug start
		if(DIVIDENUM == 41){
			fprintf(stderr,"NUM= %d\n",NUM);
			fprintf(stderr,"PT[MEN][%d].INDEXNO=%d\n",NUM,PT[MEN][NUM].INDEXNO);
		}
//debug end
//次に分轄するブロックNO----- NUM
//次に分轄するINDEXNO-------- PT[MEN][NUM].INDEXNO
		U_R=0.0;
		U_G=0.0;
		U_B=0.0;
		for(i=0;i<hsize*vsize;i++){
			if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
				U_R += *(YIN+i);
				U_G += *(UIN+i);
				U_B += *(VIN+i);
			}
		}
		U_R /= (double)PT[MEN][NUM].INDEXNUM;
		U_G /= (double)PT[MEN][NUM].INDEXNUM;
		U_B /= (double)PT[MEN][NUM].INDEXNUM;
//		U_R = (U_R>>RDIV);
//		U_G = (U_G>>GDIV);
//		U_B = (U_B>>BDIV);
//debug start
//		if(DIVIDENUM == 41){
//			fprintf(stderr,"AVE= %d %d %d\n",U_R,U_G,U_B);
//			fprintf(stderr,"NUM= %d\n",NUM);
//		}
//debug end
		TMP_RR=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(RIN+i))>>RDIV)-U_R);
		TMP_GG=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(GIN+i))>>GDIV)-U_G);
		TMP_BB=0.0;//(((*(BIN+i))>>BDIV)-U_B)*(((*(BIN+i))>>BDIV)-U_B);
		TMP_RG=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(GIN+i))>>GDIV)-U_G);
		TMP_RB=0.0;//(((*(RIN+i))>>RDIV)-U_R)*(((*(BIN+i))>>BDIV)-U_B);
		TMP_GB=0.0;//(((*(GIN+i))>>GDIV)-U_G)*(((*(BIN+i))>>BDIV)-U_B);
		for(i=0;i<hsize*vsize;i++){
			if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
				TMP_RR += (double)((((*(YIN+i)))-U_R)*(((*(YIN+i)))-U_R));
				TMP_GG += (double)((((*(UIN+i)))-U_G)*(((*(UIN+i)))-U_G));
				TMP_BB += (double)((((*(VIN+i)))-U_B)*(((*(VIN+i)))-U_B));
				TMP_RG += (double)((((*(YIN+i)))-U_R)*(((*(UIN+i)))-U_G));
				TMP_RB += (double)((((*(YIN+i)))-U_R)*(((*(VIN+i)))-U_B));
				TMP_GB += (double)((((*(UIN+i)))-U_G)*(((*(VIN+i)))-U_B));
			}
		}
		TMP_RR /= (double)(PT[MEN][NUM].INDEXNUM);
		TMP_GG /= (double)(PT[MEN][NUM].INDEXNUM);
		TMP_BB /= (double)(PT[MEN][NUM].INDEXNUM);
		TMP_RG /= (double)(PT[MEN][NUM].INDEXNUM);
		TMP_RB /= (double)(PT[MEN][NUM].INDEXNUM);
		TMP_GB /= (double)(PT[MEN][NUM].INDEXNUM);
		
		
		
		
		
		
//DIVIDENUM-1番目の分轄の軸を求める（固有ベクトルの計算）
		A[0][0]= TMP_RR;
		A[0][1]= TMP_RG;
		A[1][0]= TMP_RG;
		A[1][1]= TMP_GG;
		A[2][2]= TMP_BB;
		A[0][2]= TMP_RB;
		A[2][0]= TMP_RB;
		A[1][2]= TMP_GB;
		A[2][1]= TMP_GB;
//debug start
		if(DIVIDENUM == 41){
			for(i=0;i<3;i++){
				for(j=0;j<3;j++){
					fprintf(stderr,"%f ",A[i][j]);
				}
				fprintf(stderr,"\n");
			}
		}
//debug end	
		ind=Jacobi(3, ct, eps, A, A1, A2, X1, X2);
	
		if(ind > 0){
			fprintf(stderr,"Jacobi syuusoku simasen!!\n");
			exit(0);
		}
//		if((A1[0][0] == A1[1][1]) || (A1[1][1] == A1[2][2]) || (A1[0][0] == A1[2][2]) ){
//			fprintf(stderr,"Igen Value duplication!!\n");
//			exit(0);
//		}
//debug start
//if(DIVIDENUM == 4){
//	for(i=0;i<3;i++){
//		for(m=0;m<3;m++){
//			fprintf(stderr,"%f ",A1[i][m]);
//		}
//			fprintf(stderr,"\n");
//	}
//}
//debug end
		IGENMAX = -999999999999999999.9;
		for(i=0;i<3;i++){
			if(A1[i][i] > IGENMAX ){
				IGENMAX = A1[i][i];
				Y = i;
			}
		}
		DIVIDENUM++;		

//ohtsu tuika start	
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
			*(RR+i) = (double)(((*(YIN+i))) - U_R);
			*(GG+i) = (double)(((*(UIN+i))) - U_G);
			*(BB+i) = (double)(((*(VIN+i))) - U_B);
		}
	}
	V[0]=X1[0][Y];
	V[1]=X1[1][Y];
	V[2]=X1[2][Y];
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
			kaiten(V,*(RR+i),*(GG+i),*(BB+i),RRR+i,GGG+i,BBB+i);
		}
	}
	GASOSUU = PT[MEN][NUM].INDEXNUM;
	for(i=0;i<hsize*vsize;i++){
		*(RRR33+i) = (double)(*(RRR+i));
	}			
	for(i=0,k=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
			*(RR+k) = (double)(*(RRR+i));
			k++;
		}
	}
	for(i=0;i<hsize*vsize;i++){
		*(RRRR+i) = (int)(*(RR+i)+0.5);
	}
//ohtsu tuika end	
//	if(MEN == 1){
//		MEN = 0;
//		NMEN = 1;
////	} else {
//		MEN = 1;
//		NMEN = 0;
//	}
//ohtsu tuika start	
	THRESH = ohtsu(GASOSUU,RRRR);
	DTHRESH = (double)(THRESH);
	modoshi(V,DTHRESH,0.0,0.0,XXX,YYY,ZZZ);

	
		
		for(i=0,k=0,l=0;i<hsize*vsize;i++){
			if((*(INDEX+i)) == PT[MEN][NUM].INDEXNO){
//				ZZ = X1[0][Y]*((double)(((*(YIN+i)))) - ((double)(U_R)+(*XXX))) +
//				     X1[1][Y]*((double)(((*(UIN+i)))) - ((double)(U_G)+(*YYY))) +
//			    	 X1[2][Y]*((double)(((*(VIN+i)))) - ((double)(U_B)+(*ZZZ))) ;
//				if(ZZ>=0.0){
				if(*(RRR33+i)>=DTHRESH){
					*(INDEX+i) = DIVIDENUM-1;
					k++;
				} else {
					;
					l++;
				}
			}
		}
		if(MEN == 1){
			MEN = 0;
			NMEN = 1;
		} else {
			MEN = 1;
			NMEN = 0;
		}
		PT[MEN][0].INDEXNO = PT[NMEN][NUM].INDEXNO;
		PT[MEN][1].INDEXNO = DIVIDENUM - 1;
		PT[MEN][0].INDEXNUM = l;
		PT[MEN][1].INDEXNUM = k;
//debug start
		if(DIVIDENUM == 5 || DIVIDENUM == 6){
			fprintf(stderr,"INDEXNO%d %d\n",PT[MEN][0].INDEXNO,l);
			fprintf(stderr,"INDEXNO%d %d\n",PT[MEN][1].INDEXNO,k);
		}
		//while(1);
//debug end
			
//max distance divide tuika			
//maxdistance tuika start
	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//0側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	if(PT[MEN][0].INDEXNUM != 0){
	U_R /= PT[MEN][0].INDEXNUM;
	U_G /= PT[MEN][0].INDEXNUM;
	U_B /= PT[MEN][0].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
//	int TEMP;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][0].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][0].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][0].MAXDISTANCE = 0.0;
	}

	U_R=0.0;
	U_G=0.0;
	U_B=0.0;
	//1側のmaxdistanceを求める
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			U_R += *(YIN+i);
			U_G += *(UIN+i);
			U_B += *(VIN+i);
		}
	}
	if(PT[MEN][1].INDEXNUM != 0){
	U_R /= PT[MEN][1].INDEXNUM;
	U_G /= PT[MEN][1].INDEXNUM;
	U_B /= PT[MEN][1].INDEXNUM;
//	U_R = (U_R>>RDIV);
//	U_G = (U_G>>GDIV);
//	U_B = (U_B>>BDIV);
	MAXD = 0.0;
	for(i=0;i<hsize*vsize;i++){
		if((*(INDEX+i)) == PT[MEN][1].INDEXNO){
			TEMP = (((*(YIN+i))) - U_R)*(((*(YIN+i))) - U_R) +
			       (((*(UIN+i))) - U_G)*(((*(UIN+i))) - U_G) +
			       (((*(VIN+i))) - U_B)*(((*(VIN+i))) - U_B);
			if( MAXD < TEMP){
				MAXD = TEMP;
			}
		}
	}
	PT[MEN][1].MAXDISTANCE = MAXD;
	} else {
	PT[MEN][1].MAXDISTANCE = 0.0;
	}
//max distance div end	
			
			
			
			
//分割しなかったボックスのパラメータを違うMEN*に保存
		if(NUM == 0){
			for(i=2;i<=DIVIDENUM-1;i++){
				PT[MEN][i].INDEXNO =PT[NMEN][i-1].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-1].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-1].MAXDISTANCE;
			}
		}
		if((NUM >= 1) && (NUM <=(DIVIDENUM-3))){
			for(i=2;i<=NUM+1;i++){
//				i i-2
				PT[MEN][i].INDEXNO =PT[NMEN][i-2].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-2].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-2].MAXDISTANCE;
			}
			for(i=NUM+2;i<=DIVIDENUM-1;i++){
//				i i-1
				PT[MEN][i].INDEXNO =PT[NMEN][i-1].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-1].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-1].MAXDISTANCE;
			}
		}
		if(NUM == (DIVIDENUM-2)){
			for(i=2;i<=NUM+1;i++){
//				i i-2
				PT[MEN][i].INDEXNO =PT[NMEN][i-2].INDEXNO;
				PT[MEN][i].INDEXNUM =PT[NMEN][i-2].INDEXNUM;
				PT[MEN][i].MAXDISTANCE = PT[NMEN][i-2].MAXDISTANCE;
			}
		}
//debug start
		if(DIVIDENUM == 256 ){
			for(i=0;i<DIVIDENUM;i++){
				fprintf(stderr,"%d %d %d\n",i,PT[MEN][i].INDEXNO,PT[MEN][i].INDEXNUM);
			}
		}
//debug end		
	}//while end
//debug start
//			for(i=0;i<256;i++){
//				fprintf(stderr,"%d %d %d\n",i,PT[MEN][i].INDEXNO,PT[MEN][i].INDEXNUM);
//			}
//debug end

	
	
	
	


//256個のパラメータ空間の重心をだしパレットとして登録

	    double Y_JYUSHIN[IROSUU];
	    double U_JYUSHIN[IROSUU];
	    double V_JYUSHIN[IROSUU];
		for(i=0;i<IROSUU;i++){
			Y_JYUSHIN[i] = 0.0;
			U_JYUSHIN[i] = 0.0;
			V_JYUSHIN[i] = 0.0;
		}
		for(i=0;i<hsize*vsize;i++){
			for(j=0;j<IROSUU;j++){
				if((*(INDEX+i)) == j){
					Y_JYUSHIN[j] += *(YIN+i);
					U_JYUSHIN[j] += *(UIN+i);
					V_JYUSHIN[j] += *(VIN+i);
				}
			}
		}
		for(m=0;m<IROSUU;m++){
			k=PT[MEN][m].INDEXNO;
			if(PT[MEN][m].INDEXNUM != 0){
				Y_JYUSHIN[k] /= (double)PT[MEN][m].INDEXNUM;
				U_JYUSHIN[k] /= (double)PT[MEN][m].INDEXNUM;
				V_JYUSHIN[k] /= (double)PT[MEN][m].INDEXNUM;
			} else {
				Y_JYUSHIN[k] = 255.0;
				U_JYUSHIN[k] = 128.0;
				V_JYUSHIN[k] = 128.0;
			}
		}
//debug start
//	for(i=0;i<IROSUU;i++){
//		fprintf(stderr,"PALET%d %d %d\n",Y_JYUSHIN[i],U_JYUSHIN[i],V_JYUSHIN[i]);
//	}
//	while(1);
//debug end
//		for(i=0;i<IROSUU;i++){
//			REDUCE_R[i] = (unsigned char)(R_JYUSHIN[i]);
//			REDUCE_G[i] = (unsigned char)(G_JYUSHIN[i]);
//			REDUCE_B[i] = (unsigned char)(B_JYUSHIN[i]);
//		}
//	PALETGAZOU = (unsigned char*)malloc(sizeof(unsigned char)*hsize*vsize);
p=0;
while(1){
	p++;
	fprintf(stderr,"%d iter\n",p);	
	for(i=0;i<hsize*vsize;i++){
		if(index3[i]!=-1){
		MINZ = 60e60;
		for(j=0;j<IROSUU;j++){
		  	Z[j] =((((*(YIN+i)))) - Y_JYUSHIN[j]) * ((((*(YIN+i)))) - Y_JYUSHIN[j]) +
			      ((((*(UIN+i)))) - U_JYUSHIN[j]) * ((((*(UIN+i)))) - U_JYUSHIN[j]) +
			      ((((*(VIN+i)))) - V_JYUSHIN[j]) * ((((*(VIN+i)))) - V_JYUSHIN[j]) ;
		}
		for(j=0;j<IROSUU;j++){
			if(Z[j] < MINZ){
				MINZ = Z[j];
				X = j;
			}	
		}
		*(PALETGAZOU+i) = X;
		}
	}
//debug start
//	int KARI[IROSUU];
//		if(p==1){
//			for(i=0;i<IROSUU;i++){
//				KARI[i]=0;
//			}
//			for(i=0;i<hsize*vsize;i++){
//				KARI[*(PALETGAZOU+i)]++;
//			}
//			for(i=0;i<IROSUU;i++){
//				fprintf(stderr,"i=%d %d\n",i,KARI[i]);
//			}
//		}
//debug end
	
//kmeans法
	for(i=0;i<IROSUU;i++){
		SUM_R[i] = 0.0;
		SUM_G[i] = 0.0;
		SUM_B[i] = 0.0;
	}
	for(j=0;j<IROSUU;j++){
		for(i=0,k=0;i<hsize*vsize;i++){
			if(index3[i]!=-1){
//debug start
//			if((*(PALETGAZOU+i)) == j){
//				fprintf(stderr,"34atta!!\n");
//			}
//debug end
			if((*(PALETGAZOU+i)) == j){
				SUM_R[j] += (*(YIN+i));
				SUM_G[j] += (*(UIN+i));
				SUM_B[j] += (*(VIN+i));
				k++;
//debug start
//				if(j==34){
//					fprintf(stderr,"k=%d",k);
//				}
//debug end
			}
			}
		}
//debug start
//		fprintf(stderr,"owari\n");
//		for(;;){;}
//debug end
//debug start
//		if(k==0){
//			fprintf(stderr,"K=0hassei!! j=%d\n",j);
//			while(1){;}
//		}
//debug end
		if(k!=0){
			HEIKIN_R[j] = SUM_R[j]/(double)k;
			HEIKIN_G[j] = SUM_G[j]/(double)k;
			HEIKIN_B[j] = SUM_B[j]/(double)k;
		} else if(k==0){
			HEIKIN_R[j] = 1000.0;
			HEIKIN_G[j] = 1000.0;
			HEIKIN_B[j] = 1000.0;
		}
	}
	if((HEIKIN_R[0] == (int)REDUCE_R[0]) &&
	   (HEIKIN_R[1] == (int)REDUCE_R[1]) &&
	   (HEIKIN_R[2] == (int)REDUCE_R[2]) &&
	   (HEIKIN_R[3] == (int)REDUCE_R[3]) &&
	   (HEIKIN_R[4] == (int)REDUCE_R[4]) &&
	   (HEIKIN_R[5] == (int)REDUCE_R[5]) &&
	   (HEIKIN_R[6] == (int)REDUCE_R[6]) &&
	   (HEIKIN_R[7] == (int)REDUCE_R[7]) &&
	   (HEIKIN_R[8] == (int)REDUCE_R[8]) &&
	   (HEIKIN_R[9] == (int)REDUCE_R[9]) &&
	   (HEIKIN_R[10] == (int)REDUCE_R[10]) &&
	   (HEIKIN_R[11] == (int)REDUCE_R[11]) &&
	   (HEIKIN_R[12] == (int)REDUCE_R[12]) &&
	   (HEIKIN_R[13] == (int)REDUCE_R[13]) &&
	   (HEIKIN_R[14] == (int)REDUCE_R[14]) &&
	   (HEIKIN_R[15] == (int)REDUCE_R[15]) &&
	   (HEIKIN_R[16] == (int)REDUCE_R[16]) &&
	   (HEIKIN_R[17] == (int)REDUCE_R[17]) &&
	   (HEIKIN_R[18] == (int)REDUCE_R[18]) &&
	   (HEIKIN_R[19] == (int)REDUCE_R[19]) &&
	   (HEIKIN_R[20] == (int)REDUCE_R[20]) &&
	   (HEIKIN_R[21] == (int)REDUCE_R[21]) &&
	   (HEIKIN_R[22] == (int)REDUCE_R[22]) &&
	   (HEIKIN_R[23] == (int)REDUCE_R[23]) &&
	   (HEIKIN_R[24] == (int)REDUCE_R[24]) &&
	   (HEIKIN_R[25] == (int)REDUCE_R[25]) &&
	   (HEIKIN_R[26] == (int)REDUCE_R[26]) &&
	   (HEIKIN_R[27] == (int)REDUCE_R[27]) &&
	   (HEIKIN_R[28] == (int)REDUCE_R[28]) &&
	   (HEIKIN_R[29] == (int)REDUCE_R[29]) &&
	   (HEIKIN_R[30] == (int)REDUCE_R[30]) &&
	   (HEIKIN_R[31] == (int)REDUCE_R[31]) &&
	   (HEIKIN_R[32] == (int)REDUCE_R[32]) &&
	   (HEIKIN_R[33] == (int)REDUCE_R[33]) &&
	   (HEIKIN_R[34] == (int)REDUCE_R[34]) &&
	   (HEIKIN_R[35] == (int)REDUCE_R[35]) &&
	   (HEIKIN_R[36] == (int)REDUCE_R[36]) &&
	   (HEIKIN_R[37] == (int)REDUCE_R[37]) &&
	   (HEIKIN_R[38] == (int)REDUCE_R[38]) &&
	   (HEIKIN_R[39] == (int)REDUCE_R[39]) &&
	   (HEIKIN_R[40] == (int)REDUCE_R[40]) &&
	   (HEIKIN_R[41] == (int)REDUCE_R[41]) &&
	   (HEIKIN_R[42] == (int)REDUCE_R[42]) &&
	   (HEIKIN_R[43] == (int)REDUCE_R[43]) &&
	   (HEIKIN_R[44] == (int)REDUCE_R[44]) &&
	   (HEIKIN_R[45] == (int)REDUCE_R[45]) &&
	   (HEIKIN_R[46] == (int)REDUCE_R[46]) &&
	   (HEIKIN_R[47] == (int)REDUCE_R[47]) &&
	   (HEIKIN_R[48] == (int)REDUCE_R[48]) &&
	   (HEIKIN_R[49] == (int)REDUCE_R[49]) &&
	   (HEIKIN_R[50] == (int)REDUCE_R[50]) &&
	   (HEIKIN_R[51] == (int)REDUCE_R[51]) &&
	   (HEIKIN_R[52] == (int)REDUCE_R[52]) &&
	   (HEIKIN_R[53] == (int)REDUCE_R[53]) &&
	   (HEIKIN_R[54] == (int)REDUCE_R[54]) &&
	   (HEIKIN_R[55] == (int)REDUCE_R[55]) &&
	   (HEIKIN_R[56] == (int)REDUCE_R[56]) &&
	   (HEIKIN_R[57] == (int)REDUCE_R[57]) &&
	   (HEIKIN_R[58] == (int)REDUCE_R[58]) &&
	   (HEIKIN_R[59] == (int)REDUCE_R[59]) &&
	   (HEIKIN_R[60] == (int)REDUCE_R[60]) &&
	   (HEIKIN_R[61] == (int)REDUCE_R[61]) &&
	   (HEIKIN_R[62] == (int)REDUCE_R[62]) &&
	   (HEIKIN_R[63] == (int)REDUCE_R[63]) &&
	   (HEIKIN_R[64] == (int)REDUCE_R[64]) &&
	   (HEIKIN_R[65] == (int)REDUCE_R[65]) &&
	   (HEIKIN_R[66] == (int)REDUCE_R[66]) &&
	   (HEIKIN_R[67] == (int)REDUCE_R[67]) &&
	   (HEIKIN_R[68] == (int)REDUCE_R[68]) &&
	   (HEIKIN_R[69] == (int)REDUCE_R[69]) &&
	   (HEIKIN_R[70] == (int)REDUCE_R[70]) &&
	   (HEIKIN_R[71] == (int)REDUCE_R[71]) &&
	   (HEIKIN_R[72] == (int)REDUCE_R[72]) &&
	   (HEIKIN_R[73] == (int)REDUCE_R[73]) &&
	   (HEIKIN_R[74] == (int)REDUCE_R[74]) &&
	   (HEIKIN_R[75] == (int)REDUCE_R[75]) &&
	   (HEIKIN_R[76] == (int)REDUCE_R[76]) &&
	   (HEIKIN_R[77] == (int)REDUCE_R[77]) &&
	   (HEIKIN_R[78] == (int)REDUCE_R[78]) &&
	   (HEIKIN_R[79] == (int)REDUCE_R[79]) &&
	   (HEIKIN_R[80] == (int)REDUCE_R[80]) &&
	   (HEIKIN_R[81] == (int)REDUCE_R[81]) &&
	   (HEIKIN_R[82] == (int)REDUCE_R[82]) &&
	   (HEIKIN_R[83] == (int)REDUCE_R[83]) &&
	   (HEIKIN_R[84] == (int)REDUCE_R[84]) &&
	   (HEIKIN_R[85] == (int)REDUCE_R[85]) &&
	   (HEIKIN_R[86] == (int)REDUCE_R[86]) &&
	   (HEIKIN_R[87] == (int)REDUCE_R[87]) &&
	   (HEIKIN_R[88] == (int)REDUCE_R[88]) &&
	   (HEIKIN_R[89] == (int)REDUCE_R[89]) &&
	   (HEIKIN_R[90] == (int)REDUCE_R[90]) &&
	   (HEIKIN_R[91] == (int)REDUCE_R[91]) &&
	   (HEIKIN_R[92] == (int)REDUCE_R[92]) &&
	   (HEIKIN_R[93] == (int)REDUCE_R[93]) &&
	   (HEIKIN_R[94] == (int)REDUCE_R[94]) &&
	   (HEIKIN_R[95] == (int)REDUCE_R[95]) &&
	   (HEIKIN_R[96] == (int)REDUCE_R[96]) &&
	   (HEIKIN_R[97] == (int)REDUCE_R[97]) &&
	   (HEIKIN_R[98] == (int)REDUCE_R[98]) &&
	   (HEIKIN_R[99] == (int)REDUCE_R[99]) &&
	   (HEIKIN_R[100] == (int)REDUCE_R[100]) &&
	   (HEIKIN_R[101] == (int)REDUCE_R[101]) &&
	   (HEIKIN_R[102] == (int)REDUCE_R[102]) &&
	   (HEIKIN_R[103] == (int)REDUCE_R[103]) &&
	   (HEIKIN_R[104] == (int)REDUCE_R[104]) &&
	   (HEIKIN_R[105] == (int)REDUCE_R[105]) &&
	   (HEIKIN_R[106] == (int)REDUCE_R[106]) &&
	   (HEIKIN_R[107] == (int)REDUCE_R[107]) &&
	   (HEIKIN_R[108] == (int)REDUCE_R[108]) &&
	   (HEIKIN_R[109] == (int)REDUCE_R[109]) &&
	   (HEIKIN_R[110] == (int)REDUCE_R[110]) &&
	   (HEIKIN_R[111] == (int)REDUCE_R[111]) &&
	   (HEIKIN_R[112] == (int)REDUCE_R[112]) &&
	   (HEIKIN_R[113] == (int)REDUCE_R[113]) &&
	   (HEIKIN_R[114] == (int)REDUCE_R[114]) &&
	   (HEIKIN_R[115] == (int)REDUCE_R[115]) &&
	   (HEIKIN_R[116] == (int)REDUCE_R[116]) &&
	   (HEIKIN_R[117] == (int)REDUCE_R[117]) &&
	   (HEIKIN_R[118] == (int)REDUCE_R[118]) &&
	   (HEIKIN_R[119] == (int)REDUCE_R[119]) &&
	   (HEIKIN_R[120] == (int)REDUCE_R[120]) &&
	   (HEIKIN_R[121] == (int)REDUCE_R[121]) &&
	   (HEIKIN_R[122] == (int)REDUCE_R[122]) &&
	   (HEIKIN_R[123] == (int)REDUCE_R[123]) &&
	   (HEIKIN_R[124] == (int)REDUCE_R[124]) &&
	   (HEIKIN_R[125] == (int)REDUCE_R[125]) &&
	   (HEIKIN_R[126] == (int)REDUCE_R[126]) &&
	   (HEIKIN_R[127] == (int)REDUCE_R[127]) &&
	   (HEIKIN_R[128] == (int)REDUCE_R[128]) &&
	   (HEIKIN_R[129] == (int)REDUCE_R[129]) &&
	   (HEIKIN_R[130] == (int)REDUCE_R[130]) &&
	   (HEIKIN_R[131] == (int)REDUCE_R[131]) &&
	   (HEIKIN_R[132] == (int)REDUCE_R[132]) &&
	   (HEIKIN_R[133] == (int)REDUCE_R[133]) &&
	   (HEIKIN_R[134] == (int)REDUCE_R[134]) &&
	   (HEIKIN_R[135] == (int)REDUCE_R[135]) &&
	   (HEIKIN_R[136] == (int)REDUCE_R[136]) &&
	   (HEIKIN_R[137] == (int)REDUCE_R[137]) &&
	   (HEIKIN_R[138] == (int)REDUCE_R[138]) &&
	   (HEIKIN_R[139] == (int)REDUCE_R[139]) &&
	   (HEIKIN_R[140] == (int)REDUCE_R[140]) &&
	   (HEIKIN_R[141] == (int)REDUCE_R[141]) &&
	   (HEIKIN_R[142] == (int)REDUCE_R[142]) &&
	   (HEIKIN_R[143] == (int)REDUCE_R[143]) &&
	   (HEIKIN_R[144] == (int)REDUCE_R[144]) &&
	   (HEIKIN_R[145] == (int)REDUCE_R[145]) &&
	   (HEIKIN_R[146] == (int)REDUCE_R[146]) &&
	   (HEIKIN_R[147] == (int)REDUCE_R[147]) &&
	   (HEIKIN_R[148] == (int)REDUCE_R[148]) &&
	   (HEIKIN_R[149] == (int)REDUCE_R[149]) &&
	   (HEIKIN_R[150] == (int)REDUCE_R[150]) &&
	   (HEIKIN_R[151] == (int)REDUCE_R[151]) &&
	   (HEIKIN_R[152] == (int)REDUCE_R[152]) &&
	   (HEIKIN_R[153] == (int)REDUCE_R[153]) &&
	   (HEIKIN_R[154] == (int)REDUCE_R[154]) &&
	   (HEIKIN_R[155] == (int)REDUCE_R[155]) &&
	   (HEIKIN_R[156] == (int)REDUCE_R[156]) &&
	   (HEIKIN_R[157] == (int)REDUCE_R[157]) &&
	   (HEIKIN_R[158] == (int)REDUCE_R[158]) &&
	   (HEIKIN_R[159] == (int)REDUCE_R[159]) &&
	   (HEIKIN_R[160] == (int)REDUCE_R[160]) &&
	   (HEIKIN_R[161] == (int)REDUCE_R[161]) &&
	   (HEIKIN_R[162] == (int)REDUCE_R[162]) &&
	   (HEIKIN_R[163] == (int)REDUCE_R[163]) &&
	   (HEIKIN_R[164] == (int)REDUCE_R[164]) &&
	   (HEIKIN_R[165] == (int)REDUCE_R[165]) &&
	   (HEIKIN_R[166] == (int)REDUCE_R[166]) &&
	   (HEIKIN_R[167] == (int)REDUCE_R[167]) &&
	   (HEIKIN_R[168] == (int)REDUCE_R[168]) &&
	   (HEIKIN_R[169] == (int)REDUCE_R[169]) &&
	   (HEIKIN_R[170] == (int)REDUCE_R[170]) &&
	   (HEIKIN_R[171] == (int)REDUCE_R[171]) &&
	   (HEIKIN_R[172] == (int)REDUCE_R[172]) &&
	   (HEIKIN_R[173] == (int)REDUCE_R[173]) &&
	   (HEIKIN_R[174] == (int)REDUCE_R[174]) &&
	   (HEIKIN_R[175] == (int)REDUCE_R[175]) &&
	   (HEIKIN_R[176] == (int)REDUCE_R[176]) &&
	   (HEIKIN_R[177] == (int)REDUCE_R[177]) &&
	   (HEIKIN_R[178] == (int)REDUCE_R[178]) &&
	   (HEIKIN_R[179] == (int)REDUCE_R[179]) &&
	   (HEIKIN_R[180] == (int)REDUCE_R[180]) &&
	   (HEIKIN_R[181] == (int)REDUCE_R[181]) &&
	   (HEIKIN_R[182] == (int)REDUCE_R[182]) &&
	   (HEIKIN_R[183] == (int)REDUCE_R[183]) &&
	   (HEIKIN_R[184] == (int)REDUCE_R[184]) &&
	   (HEIKIN_R[185] == (int)REDUCE_R[185]) &&
	   (HEIKIN_R[186] == (int)REDUCE_R[186]) &&
	   (HEIKIN_R[187] == (int)REDUCE_R[187]) &&
	   (HEIKIN_R[188] == (int)REDUCE_R[188]) &&
	   (HEIKIN_R[189] == (int)REDUCE_R[189]) &&
	   (HEIKIN_R[190] == (int)REDUCE_R[190]) &&
	   (HEIKIN_R[191] == (int)REDUCE_R[191]) &&
	   (HEIKIN_R[192] == (int)REDUCE_R[192]) &&
	   (HEIKIN_R[193] == (int)REDUCE_R[193]) &&
	   (HEIKIN_R[194] == (int)REDUCE_R[194]) &&
	   (HEIKIN_R[195] == (int)REDUCE_R[195]) &&
	   (HEIKIN_R[196] == (int)REDUCE_R[196]) &&
	   (HEIKIN_R[197] == (int)REDUCE_R[197]) &&
	   (HEIKIN_R[198] == (int)REDUCE_R[198]) &&
	   (HEIKIN_R[199] == (int)REDUCE_R[199]) &&
	   (HEIKIN_R[200] == (int)REDUCE_R[200]) &&
	   (HEIKIN_R[201] == (int)REDUCE_R[201]) &&
	   (HEIKIN_R[202] == (int)REDUCE_R[202]) &&
	   (HEIKIN_R[203] == (int)REDUCE_R[203]) &&
	   (HEIKIN_R[204] == (int)REDUCE_R[204]) &&
	   (HEIKIN_R[205] == (int)REDUCE_R[205]) &&
	   (HEIKIN_R[206] == (int)REDUCE_R[206]) &&
	   (HEIKIN_R[207] == (int)REDUCE_R[207]) &&
	   (HEIKIN_R[208] == (int)REDUCE_R[208]) &&
	   (HEIKIN_R[209] == (int)REDUCE_R[209]) &&
	   (HEIKIN_R[210] == (int)REDUCE_R[210]) &&
	   (HEIKIN_R[211] == (int)REDUCE_R[211]) &&
	   (HEIKIN_R[212] == (int)REDUCE_R[212]) &&
	   (HEIKIN_R[213] == (int)REDUCE_R[213]) &&
	   (HEIKIN_R[214] == (int)REDUCE_R[214]) &&
	   (HEIKIN_R[215] == (int)REDUCE_R[215]) &&
	   (HEIKIN_R[216] == (int)REDUCE_R[216]) &&
	   (HEIKIN_R[217] == (int)REDUCE_R[217]) &&
	   (HEIKIN_R[218] == (int)REDUCE_R[218]) &&
	   (HEIKIN_R[219] == (int)REDUCE_R[219]) &&
	   (HEIKIN_R[220] == (int)REDUCE_R[220]) &&
	   (HEIKIN_R[221] == (int)REDUCE_R[221]) &&
	   (HEIKIN_R[222] == (int)REDUCE_R[222]) &&
	   (HEIKIN_R[223] == (int)REDUCE_R[223]) &&
	   (HEIKIN_R[224] == (int)REDUCE_R[224]) &&
	   (HEIKIN_R[225] == (int)REDUCE_R[225]) &&
	   (HEIKIN_R[226] == (int)REDUCE_R[226]) &&
	   (HEIKIN_R[227] == (int)REDUCE_R[227]) &&
	   (HEIKIN_R[228] == (int)REDUCE_R[228]) &&
	   (HEIKIN_R[229] == (int)REDUCE_R[229]) &&
	   (HEIKIN_R[230] == (int)REDUCE_R[230]) &&
	   (HEIKIN_R[231] == (int)REDUCE_R[231]) &&
	   (HEIKIN_R[232] == (int)REDUCE_R[232]) &&
	   (HEIKIN_R[233] == (int)REDUCE_R[233]) &&
	   (HEIKIN_R[234] == (int)REDUCE_R[234]) &&
	   (HEIKIN_R[235] == (int)REDUCE_R[235]) &&
	   (HEIKIN_R[236] == (int)REDUCE_R[236]) &&
	   (HEIKIN_R[237] == (int)REDUCE_R[237]) &&
	   (HEIKIN_R[238] == (int)REDUCE_R[238]) &&
	   (HEIKIN_R[239] == (int)REDUCE_R[239]) &&
	   (HEIKIN_R[240] == (int)REDUCE_R[240]) &&
	   (HEIKIN_R[241] == (int)REDUCE_R[241]) &&
	   (HEIKIN_R[242] == (int)REDUCE_R[242]) &&
	   (HEIKIN_R[243] == (int)REDUCE_R[243]) &&
	   (HEIKIN_R[244] == (int)REDUCE_R[244]) &&
	   (HEIKIN_R[245] == (int)REDUCE_R[245]) &&
	   (HEIKIN_R[246] == (int)REDUCE_R[246]) &&
	   (HEIKIN_R[247] == (int)REDUCE_R[247]) &&
	   (HEIKIN_R[248] == (int)REDUCE_R[248]) &&
	   (HEIKIN_R[249] == (int)REDUCE_R[249]) &&
	   (HEIKIN_R[250] == (int)REDUCE_R[250]) &&
	   (HEIKIN_R[251] == (int)REDUCE_R[251]) &&
	   (HEIKIN_R[252] == (int)REDUCE_R[252]) &&
	   (HEIKIN_R[253] == (int)REDUCE_R[253]) &&
	   (HEIKIN_R[254] == (int)REDUCE_R[254]) &&
	   (HEIKIN_R[255] == (int)REDUCE_R[255]) &&
	   (HEIKIN_G[0] == (int)REDUCE_G[0]) &&
	   (HEIKIN_G[1] == (int)REDUCE_G[1]) &&
	   (HEIKIN_G[2] == (int)REDUCE_G[2]) &&
	   (HEIKIN_G[3] == (int)REDUCE_G[3]) &&
	   (HEIKIN_G[4] == (int)REDUCE_G[4]) &&
	   (HEIKIN_G[5] == (int)REDUCE_G[5]) &&
	   (HEIKIN_G[6] == (int)REDUCE_G[6]) &&
	   (HEIKIN_G[7] == (int)REDUCE_G[7]) &&
	   (HEIKIN_G[8] == (int)REDUCE_G[8]) &&
	   (HEIKIN_G[9] == (int)REDUCE_G[9]) &&
	   (HEIKIN_G[10] == (int)REDUCE_G[10]) &&
	   (HEIKIN_G[11] == (int)REDUCE_G[11]) &&
	   (HEIKIN_G[12] == (int)REDUCE_G[12]) &&
	   (HEIKIN_G[13] == (int)REDUCE_G[13]) &&
	   (HEIKIN_G[14] == (int)REDUCE_G[14]) &&
	   (HEIKIN_G[15] == (int)REDUCE_G[15]) &&
	   (HEIKIN_G[16] == (int)REDUCE_G[16]) &&
	   (HEIKIN_G[17] == (int)REDUCE_G[17]) &&
	   (HEIKIN_G[18] == (int)REDUCE_G[18]) &&
	   (HEIKIN_G[19] == (int)REDUCE_G[19]) &&
	   (HEIKIN_G[20] == (int)REDUCE_G[20]) &&
	   (HEIKIN_G[21] == (int)REDUCE_G[21]) &&
	   (HEIKIN_G[22] == (int)REDUCE_G[22]) &&
	   (HEIKIN_G[23] == (int)REDUCE_G[23]) &&
	   (HEIKIN_G[24] == (int)REDUCE_G[24]) &&
	   (HEIKIN_G[25] == (int)REDUCE_G[25]) &&
	   (HEIKIN_G[26] == (int)REDUCE_G[26]) &&
	   (HEIKIN_G[27] == (int)REDUCE_G[27]) &&
	   (HEIKIN_G[28] == (int)REDUCE_G[28]) &&
	   (HEIKIN_G[29] == (int)REDUCE_G[29]) &&
	   (HEIKIN_G[30] == (int)REDUCE_G[30]) &&
	   (HEIKIN_G[31] == (int)REDUCE_G[31]) &&
	   (HEIKIN_G[32] == (int)REDUCE_G[32]) &&
	   (HEIKIN_G[33] == (int)REDUCE_G[33]) &&
	   (HEIKIN_G[34] == (int)REDUCE_G[34]) &&
	   (HEIKIN_G[35] == (int)REDUCE_G[35]) &&
	   (HEIKIN_G[36] == (int)REDUCE_G[36]) &&
	   (HEIKIN_G[37] == (int)REDUCE_G[37]) &&
	   (HEIKIN_G[38] == (int)REDUCE_G[38]) &&
	   (HEIKIN_G[39] == (int)REDUCE_G[39]) &&
	   (HEIKIN_G[40] == (int)REDUCE_G[40]) &&
	   (HEIKIN_G[41] == (int)REDUCE_G[41]) &&
	   (HEIKIN_G[42] == (int)REDUCE_G[42]) &&
	   (HEIKIN_G[43] == (int)REDUCE_G[43]) &&
	   (HEIKIN_G[44] == (int)REDUCE_G[44]) &&
	   (HEIKIN_G[45] == (int)REDUCE_G[45]) &&
	   (HEIKIN_G[46] == (int)REDUCE_G[46]) &&
	   (HEIKIN_G[47] == (int)REDUCE_G[47]) &&
	   (HEIKIN_G[48] == (int)REDUCE_G[48]) &&
	   (HEIKIN_G[49] == (int)REDUCE_G[49]) &&
	   (HEIKIN_G[50] == (int)REDUCE_G[50]) &&
	   (HEIKIN_G[51] == (int)REDUCE_G[51]) &&
	   (HEIKIN_G[52] == (int)REDUCE_G[52]) &&
	   (HEIKIN_G[53] == (int)REDUCE_G[53]) &&
	   (HEIKIN_G[54] == (int)REDUCE_G[54]) &&
	   (HEIKIN_G[55] == (int)REDUCE_G[55]) &&
	   (HEIKIN_G[56] == (int)REDUCE_G[56]) &&
	   (HEIKIN_G[57] == (int)REDUCE_G[57]) &&
	   (HEIKIN_G[58] == (int)REDUCE_G[58]) &&
	   (HEIKIN_G[59] == (int)REDUCE_G[59]) &&
	   (HEIKIN_G[60] == (int)REDUCE_G[60]) &&
	   (HEIKIN_G[61] == (int)REDUCE_G[61]) &&
	   (HEIKIN_G[62] == (int)REDUCE_G[62]) &&
	   (HEIKIN_G[63] == (int)REDUCE_G[63]) &&
	   (HEIKIN_G[64] == (int)REDUCE_G[64]) &&
	   (HEIKIN_G[65] == (int)REDUCE_G[65]) &&
	   (HEIKIN_G[66] == (int)REDUCE_G[66]) &&
	   (HEIKIN_G[67] == (int)REDUCE_G[67]) &&
	   (HEIKIN_G[68] == (int)REDUCE_G[68]) &&
	   (HEIKIN_G[69] == (int)REDUCE_G[69]) &&
	   (HEIKIN_G[70] == (int)REDUCE_G[70]) &&
	   (HEIKIN_G[71] == (int)REDUCE_G[71]) &&
	   (HEIKIN_G[72] == (int)REDUCE_G[72]) &&
	   (HEIKIN_G[73] == (int)REDUCE_G[73]) &&
	   (HEIKIN_G[74] == (int)REDUCE_G[74]) &&
	   (HEIKIN_G[75] == (int)REDUCE_G[75]) &&
	   (HEIKIN_G[76] == (int)REDUCE_G[76]) &&
	   (HEIKIN_G[77] == (int)REDUCE_G[77]) &&
	   (HEIKIN_G[78] == (int)REDUCE_G[78]) &&
	   (HEIKIN_G[79] == (int)REDUCE_G[79]) &&
	   (HEIKIN_G[80] == (int)REDUCE_G[80]) &&
	   (HEIKIN_G[81] == (int)REDUCE_G[81]) &&
	   (HEIKIN_G[82] == (int)REDUCE_G[82]) &&
	   (HEIKIN_G[83] == (int)REDUCE_G[83]) &&
	   (HEIKIN_G[84] == (int)REDUCE_G[84]) &&
	   (HEIKIN_G[85] == (int)REDUCE_G[85]) &&
	   (HEIKIN_G[86] == (int)REDUCE_G[86]) &&
	   (HEIKIN_G[87] == (int)REDUCE_G[87]) &&
	   (HEIKIN_G[88] == (int)REDUCE_G[88]) &&
	   (HEIKIN_G[89] == (int)REDUCE_G[89]) &&
	   (HEIKIN_G[90] == (int)REDUCE_G[90]) &&
	   (HEIKIN_G[91] == (int)REDUCE_G[91]) &&
	   (HEIKIN_G[92] == (int)REDUCE_G[92]) &&
	   (HEIKIN_G[93] == (int)REDUCE_G[93]) &&
	   (HEIKIN_G[94] == (int)REDUCE_G[94]) &&
	   (HEIKIN_G[95] == (int)REDUCE_G[95]) &&
	   (HEIKIN_G[96] == (int)REDUCE_G[96]) &&
	   (HEIKIN_G[97] == (int)REDUCE_G[97]) &&
	   (HEIKIN_G[98] == (int)REDUCE_G[98]) &&
	   (HEIKIN_G[99] == (int)REDUCE_G[99]) &&
	   (HEIKIN_G[100] == (int)REDUCE_G[100]) &&
	   (HEIKIN_G[101] == (int)REDUCE_G[101]) &&
	   (HEIKIN_G[102] == (int)REDUCE_G[102]) &&
	   (HEIKIN_G[103] == (int)REDUCE_G[103]) &&
	   (HEIKIN_G[104] == (int)REDUCE_G[104]) &&
	   (HEIKIN_G[105] == (int)REDUCE_G[105]) &&
	   (HEIKIN_G[106] == (int)REDUCE_G[106]) &&
	   (HEIKIN_G[107] == (int)REDUCE_G[107]) &&
	   (HEIKIN_G[108] == (int)REDUCE_G[108]) &&
	   (HEIKIN_G[109] == (int)REDUCE_G[109]) &&
	   (HEIKIN_G[110] == (int)REDUCE_G[110]) &&
	   (HEIKIN_G[111] == (int)REDUCE_G[111]) &&
	   (HEIKIN_G[112] == (int)REDUCE_G[112]) &&
	   (HEIKIN_G[113] == (int)REDUCE_G[113]) &&
	   (HEIKIN_G[114] == (int)REDUCE_G[114]) &&
	   (HEIKIN_G[115] == (int)REDUCE_G[115]) &&
	   (HEIKIN_G[116] == (int)REDUCE_G[116]) &&
	   (HEIKIN_G[117] == (int)REDUCE_G[117]) &&
	   (HEIKIN_G[118] == (int)REDUCE_G[118]) &&
	   (HEIKIN_G[119] == (int)REDUCE_G[119]) &&
	   (HEIKIN_G[120] == (int)REDUCE_G[120]) &&
	   (HEIKIN_G[121] == (int)REDUCE_G[121]) &&
	   (HEIKIN_G[122] == (int)REDUCE_G[122]) &&
	   (HEIKIN_G[123] == (int)REDUCE_G[123]) &&
	   (HEIKIN_G[124] == (int)REDUCE_G[124]) &&
	   (HEIKIN_G[125] == (int)REDUCE_G[125]) &&
	   (HEIKIN_G[126] == (int)REDUCE_G[126]) &&
	   (HEIKIN_G[127] == (int)REDUCE_G[127]) &&
	   (HEIKIN_G[128] == (int)REDUCE_G[128]) &&
	   (HEIKIN_G[129] == (int)REDUCE_G[129]) &&
	   (HEIKIN_G[130] == (int)REDUCE_G[130]) &&
	   (HEIKIN_G[131] == (int)REDUCE_G[131]) &&
	   (HEIKIN_G[132] == (int)REDUCE_G[132]) &&
	   (HEIKIN_G[133] == (int)REDUCE_G[133]) &&
	   (HEIKIN_G[134] == (int)REDUCE_G[134]) &&
	   (HEIKIN_G[135] == (int)REDUCE_G[135]) &&
	   (HEIKIN_G[136] == (int)REDUCE_G[136]) &&
	   (HEIKIN_G[137] == (int)REDUCE_G[137]) &&
	   (HEIKIN_G[138] == (int)REDUCE_G[138]) &&
	   (HEIKIN_G[139] == (int)REDUCE_G[139]) &&
	   (HEIKIN_G[140] == (int)REDUCE_G[140]) &&
	   (HEIKIN_G[141] == (int)REDUCE_G[141]) &&
	   (HEIKIN_G[142] == (int)REDUCE_G[142]) &&
	   (HEIKIN_G[143] == (int)REDUCE_G[143]) &&
	   (HEIKIN_G[144] == (int)REDUCE_G[144]) &&
	   (HEIKIN_G[145] == (int)REDUCE_G[145]) &&
	   (HEIKIN_G[146] == (int)REDUCE_G[146]) &&
	   (HEIKIN_G[147] == (int)REDUCE_G[147]) &&
	   (HEIKIN_G[148] == (int)REDUCE_G[148]) &&
	   (HEIKIN_G[149] == (int)REDUCE_G[149]) &&
	   (HEIKIN_G[150] == (int)REDUCE_G[150]) &&
	   (HEIKIN_G[151] == (int)REDUCE_G[151]) &&
	   (HEIKIN_G[152] == (int)REDUCE_G[152]) &&
	   (HEIKIN_G[153] == (int)REDUCE_G[153]) &&
	   (HEIKIN_G[154] == (int)REDUCE_G[154]) &&
	   (HEIKIN_G[155] == (int)REDUCE_G[155]) &&
	   (HEIKIN_G[156] == (int)REDUCE_G[156]) &&
	   (HEIKIN_G[157] == (int)REDUCE_G[157]) &&
	   (HEIKIN_G[158] == (int)REDUCE_G[158]) &&
	   (HEIKIN_G[159] == (int)REDUCE_G[159]) &&
	   (HEIKIN_G[160] == (int)REDUCE_G[160]) &&
	   (HEIKIN_G[161] == (int)REDUCE_G[161]) &&
	   (HEIKIN_G[162] == (int)REDUCE_G[162]) &&
	   (HEIKIN_G[163] == (int)REDUCE_G[163]) &&
	   (HEIKIN_G[164] == (int)REDUCE_G[164]) &&
	   (HEIKIN_G[165] == (int)REDUCE_G[165]) &&
	   (HEIKIN_G[166] == (int)REDUCE_G[166]) &&
	   (HEIKIN_G[167] == (int)REDUCE_G[167]) &&
	   (HEIKIN_G[168] == (int)REDUCE_G[168]) &&
	   (HEIKIN_G[169] == (int)REDUCE_G[169]) &&
	   (HEIKIN_G[170] == (int)REDUCE_G[170]) &&
	   (HEIKIN_G[171] == (int)REDUCE_G[171]) &&
	   (HEIKIN_G[172] == (int)REDUCE_G[172]) &&
	   (HEIKIN_G[173] == (int)REDUCE_G[173]) &&
	   (HEIKIN_G[174] == (int)REDUCE_G[174]) &&
	   (HEIKIN_G[175] == (int)REDUCE_G[175]) &&
	   (HEIKIN_G[176] == (int)REDUCE_G[176]) &&
	   (HEIKIN_G[177] == (int)REDUCE_G[177]) &&
	   (HEIKIN_G[178] == (int)REDUCE_G[178]) &&
	   (HEIKIN_G[179] == (int)REDUCE_G[179]) &&
	   (HEIKIN_G[180] == (int)REDUCE_G[180]) &&
	   (HEIKIN_G[181] == (int)REDUCE_G[181]) &&
	   (HEIKIN_G[182] == (int)REDUCE_G[182]) &&
	   (HEIKIN_G[183] == (int)REDUCE_G[183]) &&
	   (HEIKIN_G[184] == (int)REDUCE_G[184]) &&
	   (HEIKIN_G[185] == (int)REDUCE_G[185]) &&
	   (HEIKIN_G[186] == (int)REDUCE_G[186]) &&
	   (HEIKIN_G[187] == (int)REDUCE_G[187]) &&
	   (HEIKIN_G[188] == (int)REDUCE_G[188]) &&
	   (HEIKIN_G[189] == (int)REDUCE_G[189]) &&
	   (HEIKIN_G[190] == (int)REDUCE_G[190]) &&
	   (HEIKIN_G[191] == (int)REDUCE_G[191]) &&
	   (HEIKIN_G[192] == (int)REDUCE_G[192]) &&
	   (HEIKIN_G[193] == (int)REDUCE_G[193]) &&
	   (HEIKIN_G[194] == (int)REDUCE_G[194]) &&
	   (HEIKIN_G[195] == (int)REDUCE_G[195]) &&
	   (HEIKIN_G[196] == (int)REDUCE_G[196]) &&
	   (HEIKIN_G[197] == (int)REDUCE_G[197]) &&
	   (HEIKIN_G[198] == (int)REDUCE_G[198]) &&
	   (HEIKIN_G[199] == (int)REDUCE_G[199]) &&
	   (HEIKIN_G[200] == (int)REDUCE_G[200]) &&
	   (HEIKIN_G[201] == (int)REDUCE_G[201]) &&
	   (HEIKIN_G[202] == (int)REDUCE_G[202]) &&
	   (HEIKIN_G[203] == (int)REDUCE_G[203]) &&
	   (HEIKIN_G[204] == (int)REDUCE_G[204]) &&
	   (HEIKIN_G[205] == (int)REDUCE_G[205]) &&
	   (HEIKIN_G[206] == (int)REDUCE_G[206]) &&
	   (HEIKIN_G[207] == (int)REDUCE_G[207]) &&
	   (HEIKIN_G[208] == (int)REDUCE_G[208]) &&
	   (HEIKIN_G[209] == (int)REDUCE_G[209]) &&
	   (HEIKIN_G[210] == (int)REDUCE_G[210]) &&
	   (HEIKIN_G[211] == (int)REDUCE_G[211]) &&
	   (HEIKIN_G[212] == (int)REDUCE_G[212]) &&
	   (HEIKIN_G[213] == (int)REDUCE_G[213]) &&
	   (HEIKIN_G[214] == (int)REDUCE_G[214]) &&
	   (HEIKIN_G[215] == (int)REDUCE_G[215]) &&
	   (HEIKIN_G[216] == (int)REDUCE_G[216]) &&
	   (HEIKIN_G[217] == (int)REDUCE_G[217]) &&
	   (HEIKIN_G[218] == (int)REDUCE_G[218]) &&
	   (HEIKIN_G[219] == (int)REDUCE_G[219]) &&
	   (HEIKIN_G[220] == (int)REDUCE_G[220]) &&
	   (HEIKIN_G[221] == (int)REDUCE_G[221]) &&
	   (HEIKIN_G[222] == (int)REDUCE_G[222]) &&
	   (HEIKIN_G[223] == (int)REDUCE_G[223]) &&
	   (HEIKIN_G[224] == (int)REDUCE_G[224]) &&
	   (HEIKIN_G[225] == (int)REDUCE_G[225]) &&
	   (HEIKIN_G[226] == (int)REDUCE_G[226]) &&
	   (HEIKIN_G[227] == (int)REDUCE_G[227]) &&
	   (HEIKIN_G[228] == (int)REDUCE_G[228]) &&
	   (HEIKIN_G[229] == (int)REDUCE_G[229]) &&
	   (HEIKIN_G[230] == (int)REDUCE_G[230]) &&
	   (HEIKIN_G[231] == (int)REDUCE_G[231]) &&
	   (HEIKIN_G[232] == (int)REDUCE_G[232]) &&
	   (HEIKIN_G[233] == (int)REDUCE_G[233]) &&
	   (HEIKIN_G[234] == (int)REDUCE_G[234]) &&
	   (HEIKIN_G[235] == (int)REDUCE_G[235]) &&
	   (HEIKIN_G[236] == (int)REDUCE_G[236]) &&
	   (HEIKIN_G[237] == (int)REDUCE_G[237]) &&
	   (HEIKIN_G[238] == (int)REDUCE_G[238]) &&
	   (HEIKIN_G[239] == (int)REDUCE_G[239]) &&
	   (HEIKIN_G[240] == (int)REDUCE_G[240]) &&
	   (HEIKIN_G[241] == (int)REDUCE_G[241]) &&
	   (HEIKIN_G[242] == (int)REDUCE_G[242]) &&
	   (HEIKIN_G[243] == (int)REDUCE_G[243]) &&
	   (HEIKIN_G[244] == (int)REDUCE_G[244]) &&
	   (HEIKIN_G[245] == (int)REDUCE_G[245]) &&
	   (HEIKIN_G[246] == (int)REDUCE_G[246]) &&
	   (HEIKIN_G[247] == (int)REDUCE_G[247]) &&
	   (HEIKIN_G[248] == (int)REDUCE_G[248]) &&
	   (HEIKIN_G[249] == (int)REDUCE_G[249]) &&
	   (HEIKIN_G[250] == (int)REDUCE_G[250]) &&
	   (HEIKIN_G[251] == (int)REDUCE_G[251]) &&
	   (HEIKIN_G[252] == (int)REDUCE_G[252]) &&
	   (HEIKIN_G[253] == (int)REDUCE_G[253]) &&
	   (HEIKIN_G[254] == (int)REDUCE_G[254]) &&
	   (HEIKIN_G[255] == (int)REDUCE_G[255]) &&
	   (HEIKIN_B[0] == (int)REDUCE_B[0]) &&
	   (HEIKIN_B[1] == (int)REDUCE_B[1]) &&
	   (HEIKIN_B[2] == (int)REDUCE_B[2]) &&
	   (HEIKIN_B[3] == (int)REDUCE_B[3]) &&
	   (HEIKIN_B[4] == (int)REDUCE_B[4]) &&
	   (HEIKIN_B[5] == (int)REDUCE_B[5]) &&
	   (HEIKIN_B[6] == (int)REDUCE_B[6]) &&
	   (HEIKIN_B[7] == (int)REDUCE_B[7]) &&
	   (HEIKIN_B[8] == (int)REDUCE_B[8]) &&
	   (HEIKIN_B[9] == (int)REDUCE_B[9]) &&
	   (HEIKIN_B[10] == (int)REDUCE_B[10]) &&
	   (HEIKIN_B[11] == (int)REDUCE_B[11]) &&
	   (HEIKIN_B[12] == (int)REDUCE_B[12]) &&
	   (HEIKIN_B[13] == (int)REDUCE_B[13]) &&
	   (HEIKIN_B[14] == (int)REDUCE_B[14]) &&
	   (HEIKIN_B[15] == (int)REDUCE_B[15]) &&
	   (HEIKIN_B[16] == (int)REDUCE_B[16]) &&
	   (HEIKIN_B[17] == (int)REDUCE_B[17]) &&
	   (HEIKIN_B[18] == (int)REDUCE_B[18]) &&
	   (HEIKIN_B[19] == (int)REDUCE_B[19]) &&
	   (HEIKIN_B[20] == (int)REDUCE_B[20]) &&
	   (HEIKIN_B[21] == (int)REDUCE_B[21]) &&
	   (HEIKIN_B[22] == (int)REDUCE_B[22]) &&
	   (HEIKIN_B[23] == (int)REDUCE_B[23]) &&
	   (HEIKIN_B[24] == (int)REDUCE_B[24]) &&
	   (HEIKIN_B[25] == (int)REDUCE_B[25]) &&
	   (HEIKIN_B[26] == (int)REDUCE_B[26]) &&
	   (HEIKIN_B[27] == (int)REDUCE_B[27]) &&
	   (HEIKIN_B[28] == (int)REDUCE_B[28]) &&
	   (HEIKIN_B[29] == (int)REDUCE_B[29]) &&
	   (HEIKIN_B[30] == (int)REDUCE_B[30]) &&
	   (HEIKIN_B[31] == (int)REDUCE_B[31]) &&
	   (HEIKIN_B[32] == (int)REDUCE_B[32]) &&
	   (HEIKIN_B[33] == (int)REDUCE_B[33]) &&
	   (HEIKIN_B[34] == (int)REDUCE_B[34]) &&
	   (HEIKIN_B[35] == (int)REDUCE_B[35]) &&
	   (HEIKIN_B[36] == (int)REDUCE_B[36]) &&
	   (HEIKIN_B[37] == (int)REDUCE_B[37]) &&
	   (HEIKIN_B[38] == (int)REDUCE_B[38]) &&
	   (HEIKIN_B[39] == (int)REDUCE_B[39]) &&
	   (HEIKIN_B[40] == (int)REDUCE_B[40]) &&
	   (HEIKIN_B[41] == (int)REDUCE_B[41]) &&
	   (HEIKIN_B[42] == (int)REDUCE_B[42]) &&
	   (HEIKIN_B[43] == (int)REDUCE_B[43]) &&
	   (HEIKIN_B[44] == (int)REDUCE_B[44]) &&
	   (HEIKIN_B[45] == (int)REDUCE_B[45]) &&
	   (HEIKIN_B[46] == (int)REDUCE_B[46]) &&
	   (HEIKIN_B[47] == (int)REDUCE_B[47]) &&
	   (HEIKIN_B[48] == (int)REDUCE_B[48]) &&
	   (HEIKIN_B[49] == (int)REDUCE_B[49]) &&
	   (HEIKIN_B[50] == (int)REDUCE_B[50]) &&
	   (HEIKIN_B[51] == (int)REDUCE_B[51]) &&
	   (HEIKIN_B[52] == (int)REDUCE_B[52]) &&
	   (HEIKIN_B[53] == (int)REDUCE_B[53]) &&
	   (HEIKIN_B[54] == (int)REDUCE_B[54]) &&
	   (HEIKIN_B[55] == (int)REDUCE_B[55]) &&
	   (HEIKIN_B[56] == (int)REDUCE_B[56]) &&
	   (HEIKIN_B[57] == (int)REDUCE_B[57]) &&
	   (HEIKIN_B[58] == (int)REDUCE_B[58]) &&
	   (HEIKIN_B[59] == (int)REDUCE_B[59]) &&
	   (HEIKIN_B[60] == (int)REDUCE_B[60]) &&
	   (HEIKIN_B[61] == (int)REDUCE_B[61]) &&
	   (HEIKIN_B[62] == (int)REDUCE_B[62]) &&
	   (HEIKIN_B[63] == (int)REDUCE_B[63]) &&
	   (HEIKIN_B[64] == (int)REDUCE_B[64]) &&
	   (HEIKIN_B[65] == (int)REDUCE_B[65]) &&
	   (HEIKIN_B[66] == (int)REDUCE_B[66]) &&
	   (HEIKIN_B[67] == (int)REDUCE_B[67]) &&
	   (HEIKIN_B[68] == (int)REDUCE_B[68]) &&
	   (HEIKIN_B[69] == (int)REDUCE_B[69]) &&
	   (HEIKIN_B[70] == (int)REDUCE_B[70]) &&
	   (HEIKIN_B[71] == (int)REDUCE_B[71]) &&
	   (HEIKIN_B[72] == (int)REDUCE_B[72]) &&
	   (HEIKIN_B[73] == (int)REDUCE_B[73]) &&
	   (HEIKIN_B[74] == (int)REDUCE_B[74]) &&
	   (HEIKIN_B[75] == (int)REDUCE_B[75]) &&
	   (HEIKIN_B[76] == (int)REDUCE_B[76]) &&
	   (HEIKIN_B[77] == (int)REDUCE_B[77]) &&
	   (HEIKIN_B[78] == (int)REDUCE_B[78]) &&
	   (HEIKIN_B[79] == (int)REDUCE_B[79]) &&
	   (HEIKIN_B[80] == (int)REDUCE_B[80]) &&
	   (HEIKIN_B[81] == (int)REDUCE_B[81]) &&
	   (HEIKIN_B[82] == (int)REDUCE_B[82]) &&
	   (HEIKIN_B[83] == (int)REDUCE_B[83]) &&
	   (HEIKIN_B[84] == (int)REDUCE_B[84]) &&
	   (HEIKIN_B[85] == (int)REDUCE_B[85]) &&
	   (HEIKIN_B[86] == (int)REDUCE_B[86]) &&
	   (HEIKIN_B[87] == (int)REDUCE_B[87]) &&
	   (HEIKIN_B[88] == (int)REDUCE_B[88]) &&
	   (HEIKIN_B[89] == (int)REDUCE_B[89]) &&
	   (HEIKIN_B[90] == (int)REDUCE_B[90]) &&
	   (HEIKIN_B[91] == (int)REDUCE_B[91]) &&
	   (HEIKIN_B[92] == (int)REDUCE_B[92]) &&
	   (HEIKIN_B[93] == (int)REDUCE_B[93]) &&
	   (HEIKIN_B[94] == (int)REDUCE_B[94]) &&
	   (HEIKIN_B[95] == (int)REDUCE_B[95]) &&
	   (HEIKIN_B[96] == (int)REDUCE_B[96]) &&
	   (HEIKIN_B[97] == (int)REDUCE_B[97]) &&
	   (HEIKIN_B[98] == (int)REDUCE_B[98]) &&
	   (HEIKIN_B[99] == (int)REDUCE_B[99]) &&
	   (HEIKIN_B[100] == (int)REDUCE_B[100]) &&
	   (HEIKIN_B[101] == (int)REDUCE_B[101]) &&
	   (HEIKIN_B[102] == (int)REDUCE_B[102]) &&
	   (HEIKIN_B[103] == (int)REDUCE_B[103]) &&
	   (HEIKIN_B[104] == (int)REDUCE_B[104]) &&
	   (HEIKIN_B[105] == (int)REDUCE_B[105]) &&
	   (HEIKIN_B[106] == (int)REDUCE_B[106]) &&
	   (HEIKIN_B[107] == (int)REDUCE_B[107]) &&
	   (HEIKIN_B[108] == (int)REDUCE_B[108]) &&
	   (HEIKIN_B[109] == (int)REDUCE_B[109]) &&
	   (HEIKIN_B[110] == (int)REDUCE_B[110]) &&
	   (HEIKIN_B[111] == (int)REDUCE_B[111]) &&
	   (HEIKIN_B[112] == (int)REDUCE_B[112]) &&
	   (HEIKIN_B[113] == (int)REDUCE_B[113]) &&
	   (HEIKIN_B[114] == (int)REDUCE_B[114]) &&
	   (HEIKIN_B[115] == (int)REDUCE_B[115]) &&
	   (HEIKIN_B[116] == (int)REDUCE_B[116]) &&
	   (HEIKIN_B[117] == (int)REDUCE_B[117]) &&
	   (HEIKIN_B[118] == (int)REDUCE_B[118]) &&
	   (HEIKIN_B[119] == (int)REDUCE_B[119]) &&
	   (HEIKIN_B[120] == (int)REDUCE_B[120]) &&
	   (HEIKIN_B[121] == (int)REDUCE_B[121]) &&
	   (HEIKIN_B[122] == (int)REDUCE_B[122]) &&
	   (HEIKIN_B[123] == (int)REDUCE_B[123]) &&
	   (HEIKIN_B[124] == (int)REDUCE_B[124]) &&
	   (HEIKIN_B[125] == (int)REDUCE_B[125]) &&
	   (HEIKIN_B[126] == (int)REDUCE_B[126]) &&
	   (HEIKIN_B[127] == (int)REDUCE_B[127]) &&
	   (HEIKIN_B[128] == (int)REDUCE_B[128]) &&
	   (HEIKIN_B[129] == (int)REDUCE_B[129]) &&
	   (HEIKIN_B[130] == (int)REDUCE_B[130]) &&
	   (HEIKIN_B[131] == (int)REDUCE_B[131]) &&
	   (HEIKIN_B[132] == (int)REDUCE_B[132]) &&
	   (HEIKIN_B[133] == (int)REDUCE_B[133]) &&
	   (HEIKIN_B[134] == (int)REDUCE_B[134]) &&
	   (HEIKIN_B[135] == (int)REDUCE_B[135]) &&
	   (HEIKIN_B[136] == (int)REDUCE_B[136]) &&
	   (HEIKIN_B[137] == (int)REDUCE_B[137]) &&
	   (HEIKIN_B[138] == (int)REDUCE_B[138]) &&
	   (HEIKIN_B[139] == (int)REDUCE_B[139]) &&
	   (HEIKIN_B[140] == (int)REDUCE_B[140]) &&
	   (HEIKIN_B[141] == (int)REDUCE_B[141]) &&
	   (HEIKIN_B[142] == (int)REDUCE_B[142]) &&
	   (HEIKIN_B[143] == (int)REDUCE_B[143]) &&
	   (HEIKIN_B[144] == (int)REDUCE_B[144]) &&
	   (HEIKIN_B[145] == (int)REDUCE_B[145]) &&
	   (HEIKIN_B[146] == (int)REDUCE_B[146]) &&
	   (HEIKIN_B[147] == (int)REDUCE_B[147]) &&
	   (HEIKIN_B[148] == (int)REDUCE_B[148]) &&
	   (HEIKIN_B[149] == (int)REDUCE_B[149]) &&
	   (HEIKIN_B[150] == (int)REDUCE_B[150]) &&
	   (HEIKIN_B[151] == (int)REDUCE_B[151]) &&
	   (HEIKIN_B[152] == (int)REDUCE_B[152]) &&
	   (HEIKIN_B[153] == (int)REDUCE_B[153]) &&
	   (HEIKIN_B[154] == (int)REDUCE_B[154]) &&
	   (HEIKIN_B[155] == (int)REDUCE_B[155]) &&
	   (HEIKIN_B[156] == (int)REDUCE_B[156]) &&
	   (HEIKIN_B[157] == (int)REDUCE_B[157]) &&
	   (HEIKIN_B[158] == (int)REDUCE_B[158]) &&
	   (HEIKIN_B[159] == (int)REDUCE_B[159]) &&
	   (HEIKIN_B[160] == (int)REDUCE_B[160]) &&
	   (HEIKIN_B[161] == (int)REDUCE_B[161]) &&
	   (HEIKIN_B[162] == (int)REDUCE_B[162]) &&
	   (HEIKIN_B[163] == (int)REDUCE_B[163]) &&
	   (HEIKIN_B[164] == (int)REDUCE_B[164]) &&
	   (HEIKIN_B[165] == (int)REDUCE_B[165]) &&
	   (HEIKIN_B[166] == (int)REDUCE_B[166]) &&
	   (HEIKIN_B[167] == (int)REDUCE_B[167]) &&
	   (HEIKIN_B[168] == (int)REDUCE_B[168]) &&
	   (HEIKIN_B[169] == (int)REDUCE_B[169]) &&
	   (HEIKIN_B[170] == (int)REDUCE_B[170]) &&
	   (HEIKIN_B[171] == (int)REDUCE_B[171]) &&
	   (HEIKIN_B[172] == (int)REDUCE_B[172]) &&
	   (HEIKIN_B[173] == (int)REDUCE_B[173]) &&
	   (HEIKIN_B[174] == (int)REDUCE_B[174]) &&
	   (HEIKIN_B[175] == (int)REDUCE_B[175]) &&
	   (HEIKIN_B[176] == (int)REDUCE_B[176]) &&
	   (HEIKIN_B[177] == (int)REDUCE_B[177]) &&
	   (HEIKIN_B[178] == (int)REDUCE_B[178]) &&
	   (HEIKIN_B[179] == (int)REDUCE_B[179]) &&
	   (HEIKIN_B[180] == (int)REDUCE_B[180]) &&
	   (HEIKIN_B[181] == (int)REDUCE_B[181]) &&
	   (HEIKIN_B[182] == (int)REDUCE_B[182]) &&
	   (HEIKIN_B[183] == (int)REDUCE_B[183]) &&
	   (HEIKIN_B[184] == (int)REDUCE_B[184]) &&
	   (HEIKIN_B[185] == (int)REDUCE_B[185]) &&
	   (HEIKIN_B[186] == (int)REDUCE_B[186]) &&
	   (HEIKIN_B[187] == (int)REDUCE_B[187]) &&
	   (HEIKIN_B[188] == (int)REDUCE_B[188]) &&
	   (HEIKIN_B[189] == (int)REDUCE_B[189]) &&
	   (HEIKIN_B[190] == (int)REDUCE_B[190]) &&
	   (HEIKIN_B[191] == (int)REDUCE_B[191]) &&
	   (HEIKIN_B[192] == (int)REDUCE_B[192]) &&
	   (HEIKIN_B[193] == (int)REDUCE_B[193]) &&
	   (HEIKIN_B[194] == (int)REDUCE_B[194]) &&
	   (HEIKIN_B[195] == (int)REDUCE_B[195]) &&
	   (HEIKIN_B[196] == (int)REDUCE_B[196]) &&
	   (HEIKIN_B[197] == (int)REDUCE_B[197]) &&
	   (HEIKIN_B[198] == (int)REDUCE_B[198]) &&
	   (HEIKIN_B[199] == (int)REDUCE_B[199]) &&
	   (HEIKIN_B[200] == (int)REDUCE_B[200]) &&
	   (HEIKIN_B[201] == (int)REDUCE_B[201]) &&
	   (HEIKIN_B[202] == (int)REDUCE_B[202]) &&
	   (HEIKIN_B[203] == (int)REDUCE_B[203]) &&
	   (HEIKIN_B[204] == (int)REDUCE_B[204]) &&
	   (HEIKIN_B[205] == (int)REDUCE_B[205]) &&
	   (HEIKIN_B[206] == (int)REDUCE_B[206]) &&
	   (HEIKIN_B[207] == (int)REDUCE_B[207]) &&
	   (HEIKIN_B[208] == (int)REDUCE_B[208]) &&
	   (HEIKIN_B[209] == (int)REDUCE_B[209]) &&
	   (HEIKIN_B[210] == (int)REDUCE_B[210]) &&
	   (HEIKIN_B[211] == (int)REDUCE_B[211]) &&
	   (HEIKIN_B[212] == (int)REDUCE_B[212]) &&
	   (HEIKIN_B[213] == (int)REDUCE_B[213]) &&
	   (HEIKIN_B[214] == (int)REDUCE_B[214]) &&
	   (HEIKIN_B[215] == (int)REDUCE_B[215]) &&
	   (HEIKIN_B[216] == (int)REDUCE_B[216]) &&
	   (HEIKIN_B[217] == (int)REDUCE_B[217]) &&
	   (HEIKIN_B[218] == (int)REDUCE_B[218]) &&
	   (HEIKIN_B[219] == (int)REDUCE_B[219]) &&
	   (HEIKIN_B[220] == (int)REDUCE_B[220]) &&
	   (HEIKIN_B[221] == (int)REDUCE_B[221]) &&
	   (HEIKIN_B[222] == (int)REDUCE_B[222]) &&
	   (HEIKIN_B[223] == (int)REDUCE_B[223]) &&
	   (HEIKIN_B[224] == (int)REDUCE_B[224]) &&
	   (HEIKIN_B[225] == (int)REDUCE_B[225]) &&
	   (HEIKIN_B[226] == (int)REDUCE_B[226]) &&
	   (HEIKIN_B[227] == (int)REDUCE_B[227]) &&
	   (HEIKIN_B[228] == (int)REDUCE_B[228]) &&
	   (HEIKIN_B[229] == (int)REDUCE_B[229]) &&
	   (HEIKIN_B[230] == (int)REDUCE_B[230]) &&
	   (HEIKIN_B[231] == (int)REDUCE_B[231]) &&
	   (HEIKIN_B[232] == (int)REDUCE_B[232]) &&
	   (HEIKIN_B[233] == (int)REDUCE_B[233]) &&
	   (HEIKIN_B[234] == (int)REDUCE_B[234]) &&
	   (HEIKIN_B[235] == (int)REDUCE_B[235]) &&
	   (HEIKIN_B[236] == (int)REDUCE_B[236]) &&
	   (HEIKIN_B[237] == (int)REDUCE_B[237]) &&
	   (HEIKIN_B[238] == (int)REDUCE_B[238]) &&
	   (HEIKIN_B[239] == (int)REDUCE_B[239]) &&
	   (HEIKIN_B[240] == (int)REDUCE_B[240]) &&
	   (HEIKIN_B[241] == (int)REDUCE_B[241]) &&
	   (HEIKIN_B[242] == (int)REDUCE_B[242]) &&
	   (HEIKIN_B[243] == (int)REDUCE_B[243]) &&
	   (HEIKIN_B[244] == (int)REDUCE_B[244]) &&
	   (HEIKIN_B[245] == (int)REDUCE_B[245]) &&
	   (HEIKIN_B[246] == (int)REDUCE_B[246]) &&
	   (HEIKIN_B[247] == (int)REDUCE_B[247]) &&
	   (HEIKIN_B[248] == (int)REDUCE_B[248]) &&
	   (HEIKIN_B[249] == (int)REDUCE_B[249]) &&
	   (HEIKIN_B[250] == (int)REDUCE_B[250]) &&
	   (HEIKIN_B[251] == (int)REDUCE_B[251]) &&
	   (HEIKIN_B[252] == (int)REDUCE_B[252]) &&
	   (HEIKIN_B[253] == (int)REDUCE_B[253]) &&
	   (HEIKIN_B[254] == (int)REDUCE_B[254]) &&
	   (HEIKIN_B[255] == (int)REDUCE_B[255])){
			break;
	}
	for(i=0;i<IROSUU;i++){
		Y_JYUSHIN[i] = HEIKIN_R[i];
		U_JYUSHIN[i] = HEIKIN_G[i];
		V_JYUSHIN[i] = HEIKIN_B[i];
	}
	if(p==100){
		break;
	}
}//kmean loop end
	for(i=0;i<hsize*vsize;i++){
//		if(index3[i]!=-1){
			MINZ = 60e60;
			for(j=0;j<IROSUU;j++){
		  		Z[j] =((((*(YIN+i)))) - Y_JYUSHIN[j]) * ((((*(YIN+i)))) - Y_JYUSHIN[j]) +
			    	  ((((*(UIN+i)))) - U_JYUSHIN[j]) * ((((*(UIN+i)))) - U_JYUSHIN[j]) +
			      	((((*(VIN+i)))) - V_JYUSHIN[j]) * ((((*(VIN+i)))) - V_JYUSHIN[j]) ;
			}
			for(j=0;j<IROSUU;j++){
				if(Z[j] < MINZ){
					MINZ = Z[j];
					X = j;
				}	
			}
			*(PALETGAZOU+i) = X;
//		}
	}

//YUVパレットが完成
//これをＲＧＢに変換
	int IREDUCE_R[IROSUU];
	int IREDUCE_G[IROSUU];
	int IREDUCE_B[IROSUU];
	for(i=0;i<IROSUU;i++){
		Y_JYUSHIN[i] = pow(Y_JYUSHIN[i],1.0/YGAMMA); 
	}
	for(i=0;i<IROSUU;i++){
		IREDUCE_R[i] = (int)((((float)(Y_JYUSHIN[i])/((float)(YMULT)))+1.40200*((float)(V_JYUSHIN[i])/((float)(RMULT))-128.0))+0.5);
		IREDUCE_G[i] = (int)((((float)(Y_JYUSHIN[i])/((float)(YMULT)))-0.34414*((float)(U_JYUSHIN[i])/((float)(BMULT))-128.0)-0.71414*((float)(V_JYUSHIN[i])/((float)(RMULT))-128.0))+0.5);
		IREDUCE_B[i] = (int)((((float)(Y_JYUSHIN[i])/((float)(YMULT)))+1.77200*((float)(U_JYUSHIN[i]/((float)(BMULT)))-128.0))+0.5);
	}
	for(i=0;i<IROSUU;i++){
		if(IREDUCE_R[i] > 255){
			REDUCE_R[i] = 255;
		} else if(IREDUCE_R[i] < 0){
			REDUCE_R[i] = 0;
		} else {
			REDUCE_R[i] = (unsigned char)(IREDUCE_R[i]);
		}

		if(IREDUCE_G[i] > 255){
			REDUCE_G[i] = 255;
		} else if(IREDUCE_G[i] < 0){
			REDUCE_G[i] = 0;
		} else {
			REDUCE_G[i] = (unsigned char)(IREDUCE_G[i]);
		}

		if(IREDUCE_B[i] > 255){
			REDUCE_B[i] = 255;
		} else if(IREDUCE_B[i] < 0){
			REDUCE_B[i] = 0;
		} else {
			REDUCE_B[i] = (unsigned char)(IREDUCE_B[i]);
		}
	}
//debug start
//	for(i=0;i<IROSUU;i++){
//		fprintf(stderr,"RGBPALET%d %d %d\n",REDUCE_R[i],REDUCE_G[i],REDUCE_B[i]);
//	}
//debug end

//出力画像をつくる
//	for(i=0;i<hsize*vsize;i++){
//		*(ROUT+i) = REDUCE_R[*(PALETGAZOU+i)];
//		*(GOUT+i) = REDUCE_G[*(PALETGAZOU+i)];
//		*(BOUT+i) = REDUCE_B[*(PALETGAZOU+i)];
//	}
	
//	free(PALETGAZOU);	

} //median cut end



void option_set( int argc, char* argv[],CNTL *ptr)
{
	int i;
	for(i=1;i<argc;i++){
		if(argv[i][0] !='-'){
			continue;
		}
		if(!strcmp(&argv[i][1],"i")){
			strcpy(ptr->InputFileName,argv[++i]);
		} else if(!strcmp(&argv[i][1],"o")){
			strcpy(ptr->OutputFileName,argv[++i]);
		} else if(!strcmp(&argv[i][1],"x")){
			ptr->sizex = atoi(argv[++i]);
		} else if(!strcmp(&argv[i][1],"y")){
			ptr->sizey = atoi(argv[++i]);
		} else {
			; 
		}
	}
	
}

int main (int argc, char* argv[])
{
    CNTL *cnt;
	char inputfile[128];
	char outputfile[128];
	FILE *fpr;
	FILE *fpw;
	int hsize;
	int vsize;
	int filesizebyte;
	unsigned char *vin;
	unsigned char *B;
	unsigned char *G;
	unsigned char *R;
	int i,j,k,l,m,n,o,p;
	unsigned char *BIN;
	unsigned char *GIN;
	unsigned char *RIN;
//	unsigned char *BOUT;
//	unsigned char *GOUT;
//	unsigned char *ROUT;
	unsigned char *PALETGAZOU;
	unsigned char REDUCE_R[256];
	unsigned char REDUCE_G[256];
	unsigned char REDUCE_B[256];
	
	int filesize;
	unsigned char temp;
	if(argc < 2){;
		exit(0);
	}
/*******************************************/
/*										   */
/*	MAIN KANSUU NO HIKISUU NO SYORI		   */
/*										   */
/*******************************************/
	cnt = (CNTL *)malloc(sizeof(CNTL)*sizeof(unsigned char));
	option_set(argc, argv, cnt);
	
	strcpy(inputfile,cnt->InputFileName);
	strcpy(outputfile,cnt->OutputFileName);
	
/*******************************************/
/*										   */
/*	BITMAP FILE OPEN					   */
/*										   */
/*******************************************/

	
	if((fpr = fopen(inputfile,"rb"))==NULL){
		exit(0);
	}
	fseek(fpr,18,SEEK_SET);
	fread(&hsize,sizeof(int),1,fpr);//hsize syutoku
	fread(&vsize,sizeof(int),1,fpr);//vsize syutoku
	fseek(fpr,2,SEEK_SET);
	fread(&filesizebyte,sizeof(int),1,fpr);

/*******************************************/
/*										   */
/*	PICTURE GET      					   */
/*										   */
/*******************************************/
	
	vin = (unsigned char *)malloc(sizeof(unsigned char)*(filesizebyte-54));
	B = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	G = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	R = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	fseek(fpr,54,SEEK_SET);
	if(fread(vin,sizeof(unsigned char),filesizebyte - 54,fpr) != filesizebyte - 54){
		fprintf(stderr,"InputFileSizeError!!!\n");
		exit(0);
	}
	fclose(fpr);
/*******************************************/
/*										   */
/*	SET B,G,R ARRAYS WITH RGB PIXEL DATAS  */
/*										   */
/*******************************************/
	
	for(i=0,k=0;i<vsize;i++){
		for(j=0;j<hsize;j++){
			*(B+j*vsize+i) = *(vin+k);
			k++;
			*(G+j*vsize+i) = *(vin+k);
			k++;
			*(R+j*vsize+i) = *(vin+k);
			k++;
		}
		if(((hsize*3)%4) == 1){
			k=k+3;
		}
		if(((hsize*3)%4) == 2){
			k=k+2;
		}
		if(((hsize*3)%4) == 3){
			k=k+1;
		}
		if(((hsize*3)%4) == 0){// kokokara 3gyou nakutemoyoi
			;
		}
	}
	BIN = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	GIN = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	RIN = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);

/*******************************************/
/*										   */
/*	RGB PIXEL SITAKARA HAIRETU KARA UEKARA */ 
/*										   */
/*	HAIRETU NI NAOSU					   */
/*										   */
/*******************************************/

	for(i=0;i<vsize;i++){
		for(j=0;j<hsize;j++){
			*(RIN+j*vsize+i) = *(R+j*vsize+vsize-1-i);
			*(GIN+j*vsize+i) = *(G+j*vsize+vsize-1-i);
			*(BIN+j*vsize+i) = *(B+j*vsize+vsize-1-i);
		}
	}
	free(R);
	free(G);
	free(B);
//	BOUT = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
//	GOUT = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
//	ROUT = (unsigned char *)malloc(sizeof(unsigned char)*hsize*vsize);
	PALETGAZOU = (unsigned char*)malloc(sizeof(unsigned char)*hsize*vsize);

//	resize(hsize, vsize, cnt->sizex, cnt->sizey, RIN, ROUT);
//	resize(hsize, vsize, cnt->sizex, cnt->sizey, GIN, GOUT);
//	resize(hsize, vsize, cnt->sizex, cnt->sizey, BIN, BOUT);
	MedianCut(hsize, vsize, RIN, GIN, BIN, PALETGAZOU,REDUCE_R,REDUCE_G,REDUCE_B);//ROUT, GOUT, BOUT);
//debug start
//	for(;;);
//debug end	
	sprintf(cnt->OutputFileName,"%s.bmp",outputfile);
	fpw = fopen(cnt->OutputFileName,"wb");
	//hsize = cnt->sizex;
	//vsize = cnt->sizey;
	
/*******************************************/
/*										   */
/*	BITMAP HEADER 54BYTES WRITE			   */ 
/*										   */
/*******************************************/
	
	if((hsize%4) == 0){
		filesize = 0x36 + 0x400 + hsize * vsize;
	} else {
		filesize = 0x36 + 0x400 + hsize * vsize + (4-hsize%4)*vsize;
	}
	
	temp = 0x42;//B
	fwrite(&temp,sizeof(unsigned char),1,fpw);
	temp = 0x4D;//M
	fwrite(&temp,sizeof(unsigned char),1,fpw);
	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0;
	fwrite(&filesize,sizeof(int),1,fpw);
//	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0x00000436;
	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0x28;
	fwrite(&filesize,sizeof(int),1,fpw);
	fwrite(&hsize,sizeof(int),1,fpw);
	fwrite(&vsize,sizeof(int),1,fpw);
	filesize = 0x00080001;
	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0x0;
	fwrite(&filesize,sizeof(int),1,fpw);
	
	if((hsize%4) == 0 ){
		filesize = hsize*vsize;
	} else {
		filesize = hsize*vsize+(4-hsize%4)*vsize;
	}
	
	
	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0x0;
	fwrite(&filesize,sizeof(int),1,fpw);
	fwrite(&filesize,sizeof(int),1,fpw);
	filesize = 0x100;
	fwrite(&filesize,sizeof(int),1,fpw);
	fwrite(&filesize,sizeof(int),1,fpw);
	temp = 0;
	for(i=0;i<256;i++){
			fwrite(REDUCE_B+i,sizeof(unsigned char),1,fpw);
			fwrite(REDUCE_G+i,sizeof(unsigned char),1,fpw);
			fwrite(REDUCE_R+i,sizeof(unsigned char),1,fpw);
			fwrite(&temp,sizeof(unsigned char),1,fpw);
	}
	
	for(i=0;i<vsize;i++){
		for(j=0;j<hsize;j++){
			fwrite(PALETGAZOU+j*vsize+vsize-1-i,sizeof(unsigned char),1,fpw);
//			fwrite(GOUT+j*vsize+vsize-1-i,sizeof(unsigned char),1,fpw);
//			fwrite(ROUT+j*vsize+vsize-1-i,sizeof(unsigned char),1,fpw);
		}
        l=4-hsize%4;
		if(l !=4 ){
			for(k=0;k<l;k++){
				fwrite(&temp,sizeof(unsigned char),1,fpw);
			}
		}
	}
//	free(ROUT);
//	free(GOUT);
//	free(BOUT);
	free(PALETGAZOU);
	fclose(fpw);
	return 0;
}//main owari



