//  Rasterizor.cpp -- Analysis of 1D Mondrian scenes
//
//
// DESCRIPTION
//
// Copyright © Tim Bahls, Daniel Scharstien 2003.
//
///////////////////////////////////////////////////////////////////////////



#pragma once

#include "Error.h"
#include "Image.h"
#include "Color.h"
#include "Rasterizor.h"



#ifndef UNKNOWN
#define UNKNOWN -9876
#define UNKNOWNF -9876.5f
#define MAX 1234.5f
#define MIN -1234.5f
#ifndef WIN32
#define __max(a,b)  (((a) > (b)) ? (a) : (b))
#define __min(a,b)  (((a) < (b)) ? (a) : (b))
#endif
#endif

#define MAXSIMILARITY 15.0f;

#define MINVEL -4
#define MAXVEL 4
#define MINLEN 6
#define MAXLEN 399


///////////////////////////////////////////////////////////////////////////
// class CRegRast - a single region

CRegRast::CRegRast(int iid, int inFrames, int iwidth)
{
	id = iid;
	minVel=MINVEL;
	maxVel=MAXVEL;
	bool*possVelInit=new bool[MAXVEL-MINVEL+1];
	possVels=possVelInit-MINVEL;
	for(int v=MINVEL;v<=MAXVEL;v++){
		possVels[v]=true;
	}

	nFrames=inFrames;
	xmins=new int[nFrames];
	for(int i=0; i<nFrames;i++){
		xmins[i]=UNKNOWN;
	}
	xmaxes=new int[nFrames];
	for(int i=0; i<nFrames;i++){
		xmaxes[i]=UNKNOWN;
	}
	leftIDs=new int[nFrames];
	for(int i=0; i<nFrames;i++){
		leftIDs[i]=UNKNOWN;
	}
	rightIDs=new int[nFrames];
	for(int i=0; i<nFrames;i++){
		rightIDs[i]=UNKNOWN;
	}
	data=new int*[nFrames];
	for(int i=0;i<nFrames;i++){
		data[i]=new int[iwidth];
		for(int x=0; x<iwidth;x++){
			data[i][x]=0;
		}
	}
	maxWidth=iwidth;

}

bool CRegRast::limitV(int f1, int f2)
{
	bool a=false;
	for(int x1=0;x1<maxWidth;x1++){
		if(data[f1][x1]==0)
			continue;
		int contradict=-data[f1][x1];
		for(int v=minVel;v<=maxVel;v++){
			if(!possVels[v])
				continue;
			int testX=x1+v*(f2-f1);
			if(testX<0||testX>=maxWidth)
				continue;
			if(data[f2][testX]==contradict){
				possVels[v]=false;
				a=true;
			}
		}
	}
	if(a){
		for(int i=MINVEL;i<=MAXVEL;i++){
			if(possVels[i]){
				minVel=i;
				break;
			}
		}
		if(i>MAXVEL){
			throw CError("Region %d can have no velocity from MINVEL to MAXVEL\n",i);
		}
		for(int i=MAXVEL;i>=MINVEL;i--){
			if(possVels[i]){
				maxVel=i;
				break;
			}
		}

	}
	return a; 
}


bool CRegRast::restrictVel()
{
	if(minVel==maxVel)
		return false;
	bool change=false; 
	for(int f1=0; f1<nFrames-1;f1++){
		for(int f2=f1+1; f2<nFrames;f2++){
			change|=limitV(f1,f2);//restrict velocity by position
		}
	}
	return change;
}

bool CRegRast::limitP(int f1, int f2)
{
	bool a=false;
	for(int x1=0;x1<maxWidth;x1++){
		if(data[f1][x1]!=0)
			continue;
		bool allYes=true;
		bool allNo=true;
		for(int v=minVel;v<=maxVel;v++){
			if(!possVels[v])
				continue;
			int currX=x1+v*(f2-f1);
			if(currX<0||currX>=maxWidth){
				allYes=false;
				allNo=false;
				break;
			}
			int curr=data[f2][currX];
			if (curr==0){
				allYes=false;
				allNo=false;
				break;
			}else if(curr==1){
				allNo=false;
			}else if(curr==-1){
				allYes=false;
			}else{
				throw CError("Wrong value");
			}
		}
		if(allNo){
			data[f1][x1]=-1;
			a=true;
		}
		if(allYes){
			data[f1][x1]=1;
			a=true;
		}else{
		}
	}
	return a;
}

bool CRegRast::restrictPosition()
{
	bool change=false;
	for(int f=0; f<nFrames;f++){	
		for(int f2=f+1; f2<nFrames;f2++){
			change|=limitP(f,f2);//restrict position by velocity
			change|=limitP(f2,f);//restrict position by velocity
		}
	}
	return change;
}


//this method is a beast.  Be forewarned.
//The idea is that since the region 
//is convex and the velocity is constant, 
//then the epislice is convex.  That is, 
//if you see a 1 at (0,1) and (3, 10)
//then put a i at (1,4) and (2,7),
//which lie in the line in between
bool CRegRast::convexHull()
{
	bool a=false;
	for(int f=0;f<nFrames;f++){
		int maxmin=UNKNOWN;
		int minmax=UNKNOWN;
		for(int j=0;j<maxWidth;j++){
			if(data[f][j]==1){
				maxmin=j;
				break;
			}
		}
		if(maxmin!=UNKNOWN){
			for(int k=maxWidth-1;k>=0;k--){
				if(data[f][k]==1){
					minmax=k;
					break;
				}
			}
			for(int x=maxmin;x<=minmax;x++){

				if(data[f][x]==1){
					//do nothing
				}else if(data[f][x]==0){

					data[f][x]=1;
					a=true;
				}else if(data[f][x]==-1){
					throw CError("This region is not convex: %d",id);

				}else{
					printf("Screwy value for region[%d].data[%d][%d]=%d\n",id,f,x,data[f][x]);
				}
			}
			int minmin=maxmin-1;
			while(minmin>=0&&data[f][minmin]!=-1){
				minmin--;
			}
			for(;minmin>=0;minmin--){

				if(data[f][minmin]==-1){
					//do nothing
				}else if(data[f][minmin]==0){

					data[f][minmin]=-1;
					a=true;
				}else if(data[f][x]==1){
					throw CError("This region is not convex: %d",id);

				}else{
					printf("cScrewy value for region[%d].data[%d][%d]=%d\n",id,f,minmin,data[f][minmin]);
				}
			}
			int maxmax=minmax+1;
			while(maxmax<maxWidth&&data[f][maxmax]!=-1){
				maxmax++;
			}
			for(;maxmax<maxWidth;maxmax++){
				if(data[f][maxmax]==-1){
					//do nothing
				}else if(data[f][maxmax]==0){

					data[f][maxmax]=-1;
					a=true;
				}else if(data[f][maxmax]==1){
					throw CError("This region is not convex: %d",id);

				}else{
					printf("Screwy value for region[%d].data[%d][%d]=%d\n",id,f,maxmax,data[f][maxmax]);
				}
			}

		}
	}
	for(int v=-10; v<11; v++){
		for(int lineAt0=__min(0,v*nFrames);lineAt0<__max(maxWidth,v*nFrames);lineAt0++){
			int maxmin=UNKNOWN;
			int minmax=UNKNOWN;
			for(int f=0;f<nFrames;f++){
				if(lineAt0+v*f>=maxWidth||lineAt0+v*f<0){
					continue;
				}
				if(data[f][lineAt0+v*f]==1){
					maxmin=f;
					break;
				}
			}
			if(maxmin!=UNKNOWN){
				for(int f=nFrames-1;f>=0;f--){
					if(lineAt0+v*f>=maxWidth||lineAt0+v*f<0){
						continue;
					}
					if(data[f][lineAt0+v*f]==1){
						minmax=f;
						break;
					}
				}
				for(int f=maxmin;f<=minmax;f++){
					if(data[f][lineAt0+v*f]==1){
						//do nothing
					}else if(data[f][lineAt0+v*f]==0){

						data[f][lineAt0+v*f]=1;
						a=true;
					}else if(data[f][lineAt0+v*f]==-1){
						throw CError("This region is not convex: %d\n",id);

					}else{
						printf("Screwy value for region[%d].data[%d][%d]=%d in ABA analysis\n"
							,id,f,lineAt0+v*f,data[f][lineAt0+v*f]);
					}
				}
				int minmin=maxmin-1;
				while(minmin>=0&&data[minmin][lineAt0+minmin*v]!=-1){
					minmin--;
				}

				for(;minmin>=0;minmin--){
					if(lineAt0+v*minmin>=maxWidth||lineAt0+v*minmin<0){
						continue;
					}
					if(data[minmin][lineAt0+v*minmin]==-1){
						//do nothing
					}else if(data[minmin][lineAt0+v*minmin]==0){

						data[minmin][lineAt0+v*minmin]=-1;
						a=true;
					}else if(data[minmin][lineAt0+v*minmin]==1){
						throw CError("This region is not convex: %d\n",id);

					}else{
						printf("Screwy value for region[%d].data[%d][%d]=%d in minmin Analysis\n",
							id,minmin,lineAt0+v*minmin,data[f][minmin]);
					}
				}
				int maxmax=minmax+1;
				while(maxmax<nFrames&&data[maxmax][lineAt0+v*maxmax]!=-1){
					maxmax++;
				}
				for(;maxmax<nFrames;maxmax++){
					if(lineAt0+v*maxmax>=maxWidth||lineAt0+v*maxmax<0){
						continue;
					}
					if(data[maxmax][lineAt0+v*maxmax]==-1){
						//do nothing
					}else if(data[maxmax][lineAt0+v*maxmax]==0){

						data[maxmax][lineAt0+v*maxmax]=-1;
						a=true;
					}else if(data[maxmax][lineAt0+v*maxmax]==1){
						throw CError("This region is not convex: %d\n",id);

					}else{
						printf("lineAt0=%d v=%d maxmax=%d\n",lineAt0,v,maxmax);
						printf("Screwy value for region[%d].data[%d][%d]=%d in maxmax Analysis\n",
							id,maxmax,lineAt0+v*maxmax,data[maxmax][lineAt0+v*maxmax]);
					}
				}
			}
		}
	}
	return a;
}

bool CRegRast::operator == (CRegRast param)
{
	return (param.id==id);
}

void CRegRast::printStuff(){
	CRegRast reg=*this;
	//CRegRast reg=regp;

	CCol(id).printName();
	printf("'s possVels is ");
	for(int v=MINVEL;v<=MAXVEL;v++){
		if(reg.possVels[v]){
			printf("0");
		}else{
			printf("X");

		}
	}
	printf("\n");

	for(int f=0;f<nFrames;f++){
		for(int x=0;x<maxWidth;x++){
			if(reg.data[f][x]==-1){
				printf(".");
			}else if(reg.data[f][x]==0){
				printf("?");
			}else if(reg.data[f][x]==1){
				printf("o");
			}else{
				printf("*");
			}
			//}
		}
		printf("\n");
	}
}




///////////////////////////////////////////////////////////////////////////
// class CRasterizor - all regions



// destructor
CRasterizor::~CRasterizor()
{
	for (int i = 0; i <=maxID; i++) {
		if (&region[i]!=0) {
			//delete &region[i];
		}
	}
}


void CRasterizor::p(int id){
	if(verbose)
		CCol(id).printName();
}


int CRasterizor::compare(int a,int b)   
{
	if(a==-1){//everything is below the boundary
		return 2;
	}
	if(b==-1){
		return -2;
	}
	return relative[a][b];
}

//sets c closer than f
bool CRasterizor::setCloser(int c, int f)
{

	if(c==f){

		printf("Whoops: highSetCloser(%d,%d)\n",c,f);
		return false;
	}

	switch(compare(c,f)){

		case -2:
			verbose=true;
			printf("WARNING: setCloserThan(");
			p(c);
			printf(",");
			p(f);
			printf(") when the opposite is recorded\n");

			throw CError("setCloserThan(%d)", f);
			return false;
			break;
		case 0:
			relative[c][f]=2;
			relative[f][c]=-2;
			if(verbose){
				printf("     ");
				p(c);
				printf(" closer than ");
				p(f);
				printf("\n");
			}
			return true;
			break;
		case 2:
			return false;
			break;
		default:
			printf("Screwy value--compare(%d,%d)=%d\n",c,f,compare(c,f));
			relative[c][f]=2;
			relative[f][c]=-2;
			return true;
	}
	return false;
}




//Goes about extending and copying maxID, relative, minmax, and found.

void CRasterizor::addid(int a){

	int oldMax=maxID;
	maxID=a;
	CRegRast * b=new CRegRast[maxID+1];
	for(int i=0;i<=maxID;i++){
		if(i<=oldMax){
			b[i]=region[i];
		}else{
			b[i]=null;
		}
	}
	region=b;
	int ** c=new int*[maxID+1];
	for(int i=0;i<=maxID;i++){
		c[i]=new int[maxID+1];
	}
	for(int i=0;i<=maxID;i++){
		for(int j=0;j<=maxID;j++){

			if(i<=oldMax&&j<=oldMax){
				c[i][j]=relative[i][j];
			}else{
				if(i==j){
					c[i][j]=0;
				}else{
					c[i][j]=0;
				}
			}

		}
	}
	//if(oldMax>0){
	//delete [] relative;
	//}
	relative=c;

}


//returns the id of the color
int CRasterizor::getPixID(int row, int col){
	CCol *c=(CCol*)&im.Pixel(col,row,0);     //notice switch
	CCol cc=*c;
	int a= cc.getId();

	if (a>maxID){
		addid(a);
	}

	if(region[a]==null){
		region[a]=CRegRast(a,nFrames,maxWidth);
		nRegions++;
	}
	return a;
}



// create new region if necessary, add a new component, and record its left edge
void CRasterizor::startRegion(int id, int frame, int x, int prevID)
{
	if(region[id].xmins[frame]==UNKNOWN){
		region[id].xmins[frame]=x;
		region[id].leftIDs[frame]=prevID;
	}
}

// record right boundary of current region
void CRasterizor::endRegion(int id, int frame, int x, int nextID)
{
	region[id].xmaxes[frame]=x;
	region[id].rightIDs[frame]=nextID;
}


// read a frame: look at all pixels in center scanline and initialize / update
// regions and their edges


void CRasterizor::readFrame(CByteImage iim, int frame)
{
	im=iim;
	CShape sh = im.Shape();
	int w = sh.width, h = sh.height;
	maxWidth=w;
	data[frame]=new int[w];
	int row=h/2;
	int oldid = getPixID(row,0);
	startRegion(oldid, frame, 0, -1);
	data[frame][0]=oldid;
	region[oldid].data[frame][0]=1;
	for (int x = 1; x < w; x++) {
		int newid = getPixID(row,x);
		data[frame][x]=newid;
		region[newid].data[frame][x]=1;
		if(newid!=oldid){      
			endRegion(oldid, frame, x-1, newid);
			startRegion(newid, frame, x, oldid);
			oldid = newid;
		}
	}
	//update last extent:
	endRegion(oldid, frame, w-1, -1);
}

void CRasterizor::printData()
{
	printf("%d regions observed\n", nRegions);
	for (int i=0; i <= maxID; i++) {
		if (region[i]==null)
			continue;
		printf("     ");
		p(i);
		printf(":");
		CRegRast r = region[i]; 
		for (int f=0; f < nFrames; f++) {
			printf("  f%d:", f);        
			if(r.xmins[f]==UNKNOWN)
				continue;
			printf("%d-%d,", r.xmins[f],r.xmaxes[f]);
		}
		printf("\n");

	}
}





void CRasterizor::checkTripletForQuadT(int i, int f1, int f2,int f3, int *minmax,int*rightleft)
{
	int x1=minmax[f1];
	int x2=minmax[f2];
	int x3=minmax[f3];
	// check if motion is consistent over three frames
	int x21 = x2-x1;
	int x31 = x3-x1;
	int f21 = f2-f1;
	int f31 = f3-f1;
	if (f21*x31 != f31*x21)//if motion is inconsistant
		return;
	int edgeVel = x21/f21;
	int id1=rightleft[f1];
	int id2=rightleft[f2];
	int id3=rightleft[f3];
	if (id1 < 0 || id2 < 0 || id3 < 0)//if they are off the edge
		return;

	if (id1 == id2 && id2 != id3){
		for(int f4=f3+1;f4<nFrames;f4++){
			int id4=rightleft[f4];
			if (id4<0)
				continue;
			if (id4!=id3)
				continue;
			int x4=minmax[f4];
			int x41 = x4-x1;
			int f41 = f4-f1;
			if (f21*x41 != f41*x21)
				continue;

			if(setCloser(i,id1)){
				change=true;
				//times++;
			}
			region[i].minVel=region[i].maxVel=edgeVel;
			if(setCloser(i,id3)){
				change=true;
				//times++;
			}
			return;
		}	
	}
}




void CRasterizor::quadT()
{
	if(verbose)
		printf("Quad T:\n");
	for (int i=0; i <= maxID; i++) {
		if (region[i]==null)
			continue;
		CRegRast r=region[i];
		for (int f1=0; f1 < nFrames; f1++) {
			for (int f2=f1+1; f2 < nFrames; f2++) {				
				for (int f3=f2+1; f3 < nFrames; f3++) {																							checkTripletForQuadT(i,f1,f2,f3,r.xmins,r.leftIDs);  
				checkTripletForQuadT(i,f1,f2,f3,r.xmaxes,r.rightIDs);					
				}
			}
		}
	}
}


//Okay, this is based on the idea that if 
//you see two colors adjacent through two
//frames, then you have found the velocity 
//of the closer one.  So suppose we track 
//region A and region B through two frames. 
//Since two points define a line, we can 
//predict which two pixels would define the
//edge in all frames.  Thus if we see color
//C on both pixels, then either A<B, so we
//are tracking A's edge and C<A and thus C<B
//by the transitive property, or B<A and then
//C<B, so C<A.  Either way we know that C<A
//and C<B.

void CRasterizor::extendedT()
{
	if(verbose)
		printf("Extended T:\n");
	for (int i=0; i <= maxID; i++) {
		CRegRast r1=region[i];
		if (r1==null)//(If this color ID hasn't been seen)
			continue;
		for (int j=0; j <= maxID; j++) {//for every ordered pair of regions 
			//(going through ordered pairs lets us assume r1 is on the right
			CRegRast r2=region[j];
			if (r2==null||i==j)
				continue;
			int f1=0;
			int f2;
			if(concave){//If concave, only assume you've found a pairing if the frames are adjacent
				for(f1=0; f1<nFrames-1;f1++){
					if(r1.leftIDs[f1]!=j)
						continue;
					f2=f1+1;
					if(r1.leftIDs[f2]==j)
						break;
				}
			}else{//If we can assume convexity, any two frames will establish an edge velocity.
				for(f1=0; f1<nFrames;f1++){
					if(r1.leftIDs[f1]==j)
						break;
				}
				f2=f1+1;
				for(; f2<nFrames;f2++){
					if(r1.leftIDs[f2]==j)
						break;
				}
			}
			if(f2>=nFrames||r2.rightIDs[f1]!=i||r2.rightIDs[f2]!=i)
				//if there is no two frames that have these regions adjacent
				continue;
			float edgeVel=(float)(r1.xmins[f2]-r1.xmins[f1])/(float)(f2-f1);
			int pos=r1.xmins[f1];
			for(int f=0;f<nFrames; f++){
				int loc=(int)(pos+edgeVel*(f-f1));//here's the equation defined by two points
				if(loc<=0||loc>=maxWidth)// so both x2 and x2-1 are on image
					continue;
				int id1=data[f][loc-1];
				int id2=data[f][loc];
				if(id1==id2&&id2!=i){//We don't need to check that id1!=j
					change|=setCloser(id1,i);
					change|=setCloser(id1,j);
				}
			}
		}

	}
}




void CRasterizor::possibilityElimination(){
	for (int i=0; i <= maxID; i++) {
		CRegRast r=region[i];
		if (r==null)
			continue;
		bool change2=true;
		while(change2==true){
			change2=false;
			change2|=region[i].restrictPosition();
			change2|=region[i].restrictVel();
			if(!concave){
				change2|=region[i].convexHull();

			}
			change|=change2;
		}
	}
}

void CRasterizor::occlusionDetection()
{
	if(verbose)
		printf("Occlusion Detection:\n");
	for (int i=0; i <= maxID; i++) {
		CRegRast r=region[i];
		if (r==null)
			continue;	
		for(int f=0; f<nFrames;f++){
			for(int x=0;x<maxWidth;x++){
				int curr=data[f][x];
				if (curr==i)
					continue;
				if(compare(i,curr)==2){
					if(r.data[f][x]!=-1){//Reverse Occlusion
						change=true;

						region[i].data[f][x]=-1;
					}
				}
				if(r.data[f][x]==1){
					if(setCloser(curr,i)){//Occlusion Detection;
						change=true;
					}
				}
			}
		}
	}

}






//like it sounds
void CRasterizor::transitiveClosure()
{
	if(verbose)
		printf("Computing Transitive closure:\n");
	bool newEdge = true;
	while (newEdge) {
		newEdge = false;
		for (int i=0; i <= maxID; i++) {
			if (region[i]==null)
				continue;
			for (int j=0; j <= maxID; j++) {
				if(compare(i,j)==2){//definite
					for (int k=0; k <= maxID; k++) {
						if(compare(j,k)==2&&i!=k){//definite
							newEdge |= setCloser(i,k);//definite
							change |=newEdge;
						}
					}
				}
			}
		}
	}
}


void CRasterizor::reportResults()
{
	printf("\nResults: %d regions observed\n", nRegions);
	for (int i=0; i <= maxID; i++) {
		CRegRast r=region[i];
		if (r==null)
			continue;
		printf("   ");
		p(i);
		printf(": v");
		if(r.minVel==r.maxVel){
			printf(":%2d=%2d", (int)r.minVel,(int)r.maxVel);
		}else{
			printf(":%2d~%2d",(int)r.minVel,(int)r.maxVel);
		}	
		printf(" Over: ");
		for (int j=0; j <= maxID; j++) {
			if(compare(i,j)==2){
				p(j);
				printf(" ");
			}         
		}
		printf("\n");
	}
}

// infer depth ordering, lengths and motion
int CRasterizor::goGoGo(bool iconcave)
{
	concave=iconcave;
	times=0;
	extendedT();
	quadT();
	change = true;
	while (change) {
		change = false;
		occlusionDetection();
		possibilityElimination();
		transitiveClosure();
	}
	for (int i=0; i <= maxID; i++) {
		for (int j=0; j <= maxID; j++) {
			if(compare(i,j)==2)
				times++;
		}
	}
	if(verbose)
		reportResults();
	return times;
}


void CRasterizor::printStuff(int i)
{
	printf("Printing1\n");
	CRegRast reg=region[i];
	if (reg==null)
		return;
	printf("Printing2\n");
	p(i);
	printf("'s possVels is ");
	for(int v=MINVEL;v<=MAXVEL;v++){
		if(reg.possVels[v]){
			printf("0");
		}else{
			printf("X");

		}
	}
	printf("\n");
	for(int f=0;f<nFrames;f++){
		for(int x=0;x<maxWidth;x++){
			if(data[f][x]==i){

				if(reg.data[f][x]==-1){
					printf("^");
				}else if(reg.data[f][x]==0){
					printf("!");
				}else if(reg.data[f][x]==1){
					printf("O");
				}else{
					printf("*");
				}
			}else{
				if(reg.data[f][x]==-1){
					printf(".");
				}else if(reg.data[f][x]==0){
					printf("?");
				}else if(reg.data[f][x]==1){
					printf("o");
				}else{
					printf("*");
				}
			}
		}
		printf("\n");
	}

}

void CRasterizor::checkAccuracy(CScene scene)
{
	for (int i=1; i <= maxID; i++) {
		CRegRast reg=region[i];
		if (reg==null)
			continue;
		CRect rect=scene.getByID(i);
		if(rect.vel.x>reg.maxVel||rect.vel.x<reg.minVel){

			printf("ERROR! This velocity is false: %d <= %d <= %d\n",(int)reg.minVel,(int)rect.vel.x,(int)reg.maxVel);
			throw CError("Velocity incorrect: %d",(int)rect.vel.x);
		}
		for(int j=1; j<=maxID;j++){
			CRect rect2=scene.getByID(j);
			if(compare(i,j)==-2&&rect.z<rect2.z){
				verbose=true;
				printf("ERROR! ");
				p(i);
				printf(" not behind ");
				p(j);
				printf("!\n");
				throw CError("Relative Distances incorrect\n");
			}
			if(compare(i,j)==2&&rect.z>rect2.z){
				verbose=true;
				printf("ERROR! ");
				p(i);
				printf(" doesn't beat ");
				p(j);
				printf("!\n");
				throw CError("Relative Distances incorrect\n");
			}
		}
		if(compare(0,i)==2){
			verbose=true;
			printf("ERROR! ");
			p(i);
			printf(" doesn't beat ");
			p(0);
			throw CError("Nothing behind white\n");

		}
	}


	if(verbose)
		printf("All true\n");

}