#include <iostream.h>
#include <string.h>
#include <stdlib.h>

//Declarations
int pi(int); //returns a 1 or 0 depending on wether the match is up or down
void flipBit(const char *oflips, int pos);
int testCircle(const char *flips);
int canFlipBit(const char *, int, int);

//Global Constants
int n = 6;
int length = 64;


//#########################################################################
//## Main Function
//#########################################################################
int main() {
	char *flips = new char[65];
	flips[64] = 0;
	flips[0] = '1';
	flips[1] = '2';
	flips[2] = '3';
	flips[3] = '4';
	flips[4] = '5';
	flips[5] = '6';
	flips[6] = '1';
	//cout << "\n" << flips << " " << n << "\n";
	flipBit(flips, 7);
	delete flips;
	return 0;
}

//########################################################################
//## FlipBit Function
//########################################################################
void flipBit(const char *oflips, int pos) {
	int i;
	//cout << ".";
	//cout << "\n" << oflips << "\n";
	char *flips = new char[65];
	if(!flips) { cout << "Error Allocating"; exit(0); }
	memcpy(flips,oflips,65);
	if(pos >= length-1) {
		if(testCircle(flips)) {
			cout << /*"\nfound one: " <<*/ flips << "\n";
			//if(flips)
			//delete[] flips;
			// exit(0);
		}
	}
	else {
		for(i=1; i<=n; i++) {
			if(canFlipBit(flips, pos, i)) {
				flips[pos] = i+'0';
				flipBit(flips,pos+1);
			}
		}
	}

	if(flips)
		delete[] flips;
}

//#######################################################################
//## TestUnique Function
//#######################################################################
int testCircle(const char *flips) {

	/*switch (flips[-1+length]) {
	  case '1':
	  case '2':
	  case '3': return 0;
	  case '4':
	  case '5': break;
	  case '6': return 0;
	  default: cerr << "Improper Flip ("<< flips[-1+length]
	  << "--" << (-1+length) << ")!\n"; return 0;
	  }*/

	switch (flips[-2+length]) {
	case '1':
	case '2': 
	case '3': return 0;
	case '4':
	case '5': 
	case '6': break;
	default: cerr << "Improper Flip ("<< flips[-2+length]
				  << "--" << (-2+length) << ")!\n"; return 0;
	}

	switch (flips[-3+length]) {
	case '1':
	case '2': 
	case '3': return 0;
	case '4':
	case '5': 
	case '6': break;
	default: cerr << "Improper Flip ("<< flips[-3+length]
				  << "--" << (-3+length) << ")!\n"; return 0;
	}

	switch (flips[-4+length]) {
	case '1':
	case '2': return 0;
	case '3': 
	case '4':
	case '5': 
	case '6': break;
	default: cerr << "Improper Flip ("<< flips[-4+length]
				  << "--" << (-4+length) << ")!\n"; return 0;
	}

	return 1;
}

//########################################################################
//## CanFlipBit Function
//########################################################################
int canFlipBit(const char* flips, int pos, int i) {
	//  cout << "\ncheck: " << flips << "," << pos << "," << i << "," << pi(pos+1)
	//       << "\n";
	int check[6];
	if((pos+1)%4 == 0) {
		if(flips[pos-1]-'0' == i || flips[pos-2]-'0' == i ||
		   flips[pos-3]-'0' == i || flips[pos-6]-'0' == i) {
			return 0;
		}
		return 1;
	}
	else if((pos+1)%4 == 1) {
		if(flips[pos-1]-'0' == i || flips[pos-2]-'0' == i ||
		   flips[pos-3]-'0' == i || flips[pos-4]-'0' == i ||
		   (flips[pos-5]-'0' != i && flips[pos-1] != flips[pos-5])) {
			return 0;
		}
		return 1;
	}
	else if((pos+1)%4 == 2) {
		for(int j=pos-n+1; j<pos; j++) {
			if(flips[j]-'0' == i) return 0;
		}
		return 1;
	}
	else if((pos+1)%4 == 3) {
		for(int j=pos-n+1; j<pos; j++) {
			if(flips[j]-'0' == i) return 0;
		}
		return 1;
	}

	return 0;
}