/************************************************************************/
/*									*/
/*	パズルプログラミング勉強会		第１課題 ３Ｄ版		*/
/*									*/
/*		５×４×３の直方体に詰める場合	(3940通り)		*/
/*									*/
/*	ペントミノ箱詰めパズル						*/
/*	株式会社テンヨーから『ＦＡＣＯＭ』として発売されていた		*/
/*									*/
/*	by パソコン初心者						*/
/*									*/
/************************************************************************/
/*  注意事項								*/
/*									*/
/*	Cのプログラムらしくない！					*/
/*	C++の影響を変に受けていて、これならちゃんとC++で書くべき！	*/
/*									*/
/*	long long 64ビット整数 を利用					*/
/*	5x4x3 の場合しか考えていない！					*/
/*	コンパイラ: gcc   						*/
/*									*/
/************************************************************************/
/*	メモ(はずかしいから読むな)					*/
/*									*/
/*  開始の動機								*/
/*	３Ｄでも、２Ｄと同程度の時間で解き終えられるし、		*/
/*	技術的にも似たようなもので、ちょっと手を加えてみた		*/
/*	つまり、ペントミノのプログラムに若干手を加えた状態		*/
/*									*/
/*  2001年10月3日							*/
/*	一応動くようになり、３９４０通りが出るようになった。		*/
/*	めでたし、めでたしということで、一応公開。			*/
/*	回転は F の配置方向で制限し、鏡映は鏡映パターンによる確認	*/
/*									*/
/*  勝手な期待								*/
/*	多分、だれかが高速化、汎用化をするものと期待する。		*/
/*									*/
/************************************************************************/

#define TRUE	1
#define FALSE	0

#define	CN	5		/* セル数	*/
#define	PN	12		/* ピース数	*/

#define WIDTH	5		/* ボード幅	*/
#define HEIGHT	4		/* ボード高	*/
#define DEPTH	3		/* ボード奥行き	*/

#define BPOS(x,y,z)	((x)*HEIGHT+(y))*DEPTH+(z)
#define X(z)		((z)/(DEPTH*HEIGHT))
#define Y(z)		(((z)/DEPTH)%HEIGHT)
#define Z(z)		((z)%(DEPTH))

#define MIN(x,y)	((x)<(y)?(x):(y))

#define BLANKCELL	'.'
#define WALLCELL	'#'

typedef	long long	BitsForm;

typedef struct {
	int	x;
	int	y;
	int	z;
} Pos;

typedef struct {
	Pos		form[CN];
	char		name;
} PieceFormDef;



typedef struct {
	int		n;
	BitsForm	bits[24];		/* 可能ビットパターン	*/	
	int		offsets[24][CN];	/* 可能オフセット	*/
} AllBitsForm;

typedef struct {
	char		name;
	int		n;
	Pos		form[24][CN];	/* 基準パターン(Pos)		*/
	BitsForm	bits[24];	/* 基準パターン(ビット)		*/
	AllBitsForm	allbits[64];	/* 特定基準位置の可能パターン	*/
} PieceAllFormDef;

PieceFormDef OriginalPieceForm[PN] = {
    {{{ 0, 0, 0},{ 0, 1, 0},{ 1, 1, 0},{ 1, 2, 0},{ 2, 1, 0}}, 'F'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 0, 2, 0},{ 0, 3, 0},{ 0, 4, 0}}, 'I'},
    {{{ 0, 1, 0},{ 1, 0, 0},{ 1, 1, 0},{ 1, 2, 0},{ 2, 1, 0}}, 'X'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 1, 1, 0},{ 1, 2, 0},{ 2, 2, 0}}, 'W'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 1, 1, 0},{ 2, 1, 0},{ 2, 2, 0}}, 'Z'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 0, 2, 0},{ 1, 1, 0},{ 2, 1, 0}}, 'T'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 0, 2, 0},{ 1, 0, 0},{ 2, 0, 0}}, 'V'},
    {{{ 0, 0, 0},{ 0, 2, 0},{ 1, 0, 0},{ 1, 1, 0},{ 1, 2, 0}}, 'U'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 1, 1, 0},{ 1, 2, 0},{ 1, 3, 0}}, 'N'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 0, 2, 0},{ 0, 3, 0},{ 1, 1, 0}}, 'Y'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 0, 2, 0},{ 0, 3, 0},{ 1, 0, 0}}, 'L'},
    {{{ 0, 0, 0},{ 0, 1, 0},{ 1, 0, 0},{ 1, 1, 0},{ 2, 0, 0}}, 'P'}
};

PieceAllFormDef	AllPieceForm[PN];	/* ピースの全方向データ */

char		CharBoard[WIDTH*HEIGHT*DEPTH];	/* 文字型ボード		*/
BitsForm	BitsConv[WIDTH*HEIGHT*DEPTH];

int		RestPieces[PN];		/* 未使用ピース TRUE/FALSE	*/

int		totalcount;		/* 解の総数			*/
int		tryalcount;		/* 試行錯誤の回数		*/

int		printflag;		/* 解の印刷フラグ		*/
					/* 0 : 印刷しない		*/
					/* 1 : 文字表示			*/
					/* 2 : 境界線表示		*/
int		stepflag;		/* ステップ毎印刷フラグ		*/
int		debugflag;		/* デバッグ用印刷フラグ		*/

/*----------------------------------------------------------------------*/
/*	一応宣言しておこう						*/
/*----------------------------------------------------------------------*/
int	CmpPos( Pos p1, Pos p2 );
int	IsInsidePos( Pos p );
int	IsSamePieceForm( Pos cell1[], Pos cell2[] );
char	GetChar( char board[], int x, int y, int z );

BitsForm  PieceFormToBitsForm( Pos cells[] );
void	RotetePiece( Pos *cells, int rot, int plane );
void	MakeAllPieceForm( void );
int	IsPieceOnBoard( Pos cells[], int x, int y, int z );
void	MakeAllPieceBits( void );
void	Initialize( void );

void	PrintPieceForm( Pos cells[] );
void	PrintBitsForm( BitsForm bits );
void	PrintAllPieceForm( void );
void	PrintAllBitsForm( int x, int y, int z );
void	PrintCurrentBoardbyChar( char board[] );
void	PrintCurrentBoardbyLine( char board[] );
void	PrintCurrentBoard( char board[] );

int	MirrorCheck( void );
void	Found( void );
int	SearchNextBase( BitsForm board, int base );
void	SearchOneLevel( int level, BitsForm board, int base );
void	SearchAll( void );

int	main(int argc, char **argv);

/************************************************************************/
/*				道具箱					*/
/************************************************************************/
/*----------------------------------------------------------------------*/
/*	位置の大小比較							*/
/*----------------------------------------------------------------------*/
int	CmpPos( Pos p1, Pos p2 )
{
	if( p1.x == p2.x ) {
		if( p1.y == p2.y ) {
			if( p1.z == p2.z )
				return	0;
			return p1.z > p2.z ? 1 : -1;
		}
		return p1.y > p2.y ? 1 : -1;
	}
	return p1.x > p2.x ? 1 : -1;
}

/*----------------------------------------------------------------------*/
/*	位置がボード範囲内かどうかの判定				*/
/*----------------------------------------------------------------------*/
int	IsInsidePos( Pos p )
{
	if( p.x < 0 || p.x >= WIDTH )
		return	FALSE;
	if( p.y < 0 || p.y >= HEIGHT )
		return	FALSE;
	if( p.z < 0 || p.z >= DEPTH )
		return	FALSE;
	return	TRUE;
}

/*----------------------------------------------------------------------*/
/*	駒の一致比較							*/
/*----------------------------------------------------------------------*/
int	IsSamePieceForm( Pos cell1[], Pos cell2[] )
{
	int	i;

	for( i=0; i<CN; ++i ) {
		if( CmpPos( cell1[i], cell2[i] ) != 0 )
			return	FALSE;
	}
	return	TRUE;
}

/*----------------------------------------------------------------------*/
/*	指定位置の文字  ボードの外側は、WALLCELL('#') を返す		*/
/*----------------------------------------------------------------------*/
char	GetChar( char board[], int x, int y, int z )
{
	if( x < 0 || x >= WIDTH )
		return	WALLCELL;
	if( y < 0 || y >= HEIGHT )
		return	WALLCELL;
	if( z < 0 || z >= DEPTH )
		return	WALLCELL;
	return board[BPOS(x,y,z)];
}

/************************************************************************/
/*				初期化					*/
/************************************************************************/
/*----------------------------------------------------------------------*/
/*	駒のビットデータ化						*/
/*		駒の置き方の変換: 配列 → ビットデータ 			*/
/*----------------------------------------------------------------------*/
BitsForm  PieceFormToBitsForm( Pos cells[] )
{
	int		i;
	BitsForm	bits = 0;
	BitsForm	one = 1;
	Pos		*p;

	for( p=cells, i=0; i<CN; ++i, ++p ) {
		bits |= BitsConv[BPOS(p->x, p->y, p->z)];
	}
	return	bits;
}

/*----------------------------------------------------------------------*/
/*	ピースの回転							*/
/*		*cells	位置配列データ					*/
/*		rot	ピースの回転反転など 8通り (0..7)		*/
/*		plane	平面の決定  0:XY, 1:YZ, 2:ZX			*/
/*----------------------------------------------------------------------*/
void	RotetePiece( Pos *cells, int rot, int plane )
{
	int	i, j, k, dx, dy, dz, w;
	Pos	pw;

	/* XY平面での入れ換えステップ */

	if( rot & 0x01 )	/* 対角線を軸とする入れ換え	*/
		for( i=0; i<CN; ++i ) {
			w = cells[i].x; cells[i].x = cells[i].y; cells[i].y = w;
		}
	if( rot & 0x02 )	/* 左右入れ換え	*/
		for( i=0; i<CN; ++i ) {
			cells[i].x = - cells[i].x;
		}
	if( rot & 0x04 )	/* 上下入れ換え	*/
		for( i=0; i<CN; ++i ) {
			cells[i].y = - cells[i].y;
		}

	/* 平面 の決定  0:XY, 1:YZ, 2:ZX */
	switch( plane ) {
	case 0:
		break;
	case 1:
		for( i=0; i<CN; ++i ) {
			cells[i].z=cells[i].y;
			cells[i].y=cells[i].x;
			cells[i].x=0;
		}
		break;
	case 2:
		for( i=0; i<CN; ++i ) {
			cells[i].z=cells[i].x;
			cells[i].x=cells[i].y;
			cells[i].y=0;
		}
		break;
	}


	/* 正規化ステップ */
	for( i=0; i<CN-1; ++i ) {
		k = i;
		for( j=i+1; j<CN; ++j ) {
			if( CmpPos( cells[k], cells[j] ) > 0 )
				k = j;
		}
		if( k != i ) {
			pw = cells[i]; cells[i] = cells[k]; cells[k] = pw;
		}
	}

	dx = cells[0].x; dy = cells[0].y; dz = cells[0].z;
	for( i=0; i<CN; ++i ) {
		cells[i].x -= dx;
		cells[i].y -= dy;
		cells[i].z -= dz;
	}
}

/*----------------------------------------------------------------------*/
/*	ピースの全方向データの作成					*/
/*		配列 AllPieceForm を生成				*/
/*----------------------------------------------------------------------*/
void	MakeAllPieceForm( void )
{
	int		i, pl, j, k, n;
	Pos		cells[CN];

	for( i=0; i<PN; ++i ) {
		AllPieceForm[i].name = OriginalPieceForm[i].name;
		n = 0;
		for( pl=0; pl<3; ++pl ) {
			for( j=0; j<8; ++j ) {
				/* 対象性除去のために、最初の'F'を各平面につき	*/
				/* ２つだけに限定している。この方法はせこい！	*/
				if( i==0 && j>=2 )
					break;
				for( k=0; k<CN; ++k )
					cells[k] = OriginalPieceForm[i].form[k];
				RotetePiece( cells, j, pl );
				for( k=0; k<n ; ++k ) {
					if( IsSamePieceForm( cells, AllPieceForm[i].form[k] ) )
						break;
				} 
				if( k<n )
					continue;

				for( k=0; k<CN; ++k )
					AllPieceForm[i].form[n][k] = cells[k];
				AllPieceForm[i].bits[n] = PieceFormToBitsForm( cells );
				++n;
			}
		}
		AllPieceForm[i].n = n;
	}
}

/*----------------------------------------------------------------------*/
/*	ピース配置がボード範囲内かどうかの検査				*/
/*----------------------------------------------------------------------*/
int	IsPieceOnBoard( Pos cells[], int x, int y, int z )
{
	Pos	pos;
	int	i;

	for( i=0; i<CN; ++i ) {
		pos = cells[i];
		pos.x += x;
		pos.y += y;
		pos.z += z;
		if( ! IsInsidePos( pos ) )
			return	FALSE;
	}
	return	TRUE;
}

/*----------------------------------------------------------------------*/
/*	ピースの全配置データ(全ビットパターン)の作成			*/
/*----------------------------------------------------------------------*/
void	MakeAllPieceBits( void )
{
	int		i, j, k, n;
	int		x, y, z, w;
	int		fn;
	Pos		pos;
	AllBitsForm	*abf;

	for( i=0; i<PN; ++i ) {
	    fn = AllPieceForm[i].n;
	    for( x=0; x<WIDTH; ++x ) {
	        for( y=0; y<HEIGHT; ++y ) {
	            for( z=0; z<DEPTH; ++z ) {
			w = BPOS(x,y,z);
			abf = &(AllPieceForm[i].allbits[w]);
			n = 0;
			for( j=0; j<fn ; ++j ) {
				if( ! IsPieceOnBoard( AllPieceForm[i].form[j], x, y, z ) )
					continue;
				abf->bits[n] = (AllPieceForm[i].bits[j] << w);
				for( k=0; k<CN ; ++k ) {
					pos = AllPieceForm[i].form[j][k];
					abf->offsets[n][k] = BPOS(pos.x,pos.y,pos.z) + w;
				}
				++n;
			}
			abf->n = n;
	            }
	        }
	    }
	}
}

/*----------------------------------------------------------------------*/
/*	初期化								*/
/*----------------------------------------------------------------------*/
void	Initialize( void )
{
	int		i;
	BitsForm	one = 1;

	/* ビット変換テーブルの初期化	*/
	for( i=0; i<WIDTH*HEIGHT*DEPTH; ++i )
		BitsConv[i] = (one << i);

	MakeAllPieceForm();
	MakeAllPieceBits();
}

/************************************************************************/
/*				印刷関係				*/
/************************************************************************/
/*-----------------------------------------------------------------Print*/
/*	ピースの印刷							*/
/*		*p	位置配列データ					*/
/*----------------------------------------------------------------------*/
void	PrintPieceForm( Pos cells[] )
{
	int	i;

	for( i=0; i<CN; ++i )
		printf( " (%d,%d,%d)", cells[i].x, cells[i].y, cells[i].z );
	printf( "\n");
}

/*-----------------------------------------------------------------Print*/
/*	ビットデータの印刷						*/
/*----------------------------------------------------------------------*/
void	PrintBitsForm( BitsForm bits )
{
	int		i, x, y, z;
	BitsForm	mask = 1;

	for( i=0; i<64; ++i ) {
		if( (i % HEIGHT) == 0 && (i>0) )
			printf( " " );
		if( (i % (HEIGHT*DEPTH) ) == 0 && (i>0) )
			printf( " " );
		printf( "%c", (bits & mask) ? '1' : '0' );
		mask <<= 1;
	}	
	printf( "\n" );

	for( y=0; y<HEIGHT; ++y ) {
		for( z=0; z<DEPTH; ++z ) {
			for( x=0; x<WIDTH; ++x ) {
				printf( "%c ", (bits >> BPOS(x,y,z)) & 1 ? 'X' : '.' );
			}
			printf( "  " );
		}
		printf( "\n" );
	}
	printf( "\n" );
}

/*-----------------------------------------------------------------Print*/
/*	全ピース方向データの印刷					*/
/*----------------------------------------------------------------------*/
void	PrintAllPieceForm( void )
{
	int		i, j;

	for( i=0; i<PN; ++i ) {
		printf( "%c\n", AllPieceForm[i].name );

		for( j=0; j<AllPieceForm[i].n; ++j ) {
			PrintPieceForm( AllPieceForm[i].form[j] );
			PrintBitsForm( AllPieceForm[i].bits[j] );
		}
		printf( "\n" );
	}
}

/*-----------------------------------------------------------------Print*/
/*	指定位置での全ピース方向データの印刷(可能ビットパターンより)	*/
/*----------------------------------------------------------------------*/
void	PrintAllBitsForm( int x, int y, int z )
{
	int	i, j;
	AllBitsForm *abf;

	for( i=0; i<PN; ++i ) {
		*abf = AllPieceForm[i].allbits[BPOS(x,y,z)];
		if( abf->n == 0 )
			continue;
		printf( "%c\n", AllPieceForm[i].name );
		for( j=0; j < abf->n; ++j ) {
			PrintBitsForm( abf->bits[j] );
		}
	}
}

/*-----------------------------------------------------------------Print*/
/*	現在の試行錯誤状況(文字)の印刷					*/
/*----------------------------------------------------------------------*/
void	PrintCurrentBoardbyChar( char board[] )
{
	int	x, y, z;
	int	c;

	for( y=0; y<HEIGHT; ++y ) {
		for( z=0; z<DEPTH; ++z ) {
			for( x=0; x<WIDTH; ++x ) {
				printf( "%c ", board[BPOS(x,y,z)] );
			}
			printf( "  " );
		}
		printf( "\n" );
	}
	printf( "\n" );
}

/*-----------------------------------------------------------------Print*/
/*	現在の試行錯誤状況(境界線)の印刷				*/
/*----------------------------------------------------------------------*/
void	PrintCurrentBoardbyLine( char board[] )
{
	int	x, y, z;
	char	c, gc;

	for( y=0; y<=HEIGHT; ++y ) {
		for( z=0; z<DEPTH; ++z ) {
			/* 水平線処理	*/
			for( x=0; x<=WIDTH; ++x ) {
				c = ' ';
				gc = GetChar(board, x, y, z); 
				if( gc != GetChar(board, x-1,y, z) )	c = '+';
				if( gc != GetChar(board, x,y-1, z) )	c = '+';
				if( gc != GetChar(board, x-1,y-1, z) )	c = '+';
				printf( "%c", c );
				if( x == WIDTH )
					break;
				c = gc != GetChar(board, x, y-1,z) ? '-' : ' ';
				printf( "%c%c%c", c, c, c );
			}
			printf( "   " );
		}
		printf( "\n" );
		if( y == HEIGHT )
			break;

		for( z=0; z<DEPTH; ++z ) {
			/* 垂直線処理	*/
			for( x=0; x<=WIDTH; ++x ) {
				c = GetChar(board,x-1, y,z) != GetChar(board,x,y,z) ? '|' : ' ';
				printf( "%c", c );
				if( x == WIDTH )
					break;
				c = (printflag & 1) ? board[BPOS(x,y,z)] : ' ';
				printf( " %c ", c );
			}
			printf( "   " );
		}
		printf( "\n" );
	}
	printf( "\n" );
}

/*-----------------------------------------------------------------Print*/
/*	現在の試行錯誤状況の印刷					*/
/*----------------------------------------------------------------------*/
void	PrintCurrentBoard( char board[] )
{
	if( printflag & 2 ) {
		PrintCurrentBoardbyLine( board );
	} else if( printflag & 1 ) {
		PrintCurrentBoardbyChar( board );
	}
}

/************************************************************************/
/*				試行錯誤関係				*/
/************************************************************************/
/*----------------------------------------------------------------------*/
/*	鏡映チェック		TRUE: OK				*/
/*----------------------------------------------------------------------*/
int	MirrorCheck( void )
{
	char	mirror[WIDTH*HEIGHT*DEPTH];	/* 鏡映パターン	*/
	int	plane;				/* 鏡映面	*/
	Pos	F[5];
	int	i, j, x, y, z;

	for( j=i=0; i<WIDTH*HEIGHT*DEPTH; ++i ) {
		if( CharBoard[i] != 'F' )
			continue;
		/*   F が見つかった	*/
		F[j].x = X(i);
		F[j].y = Y(i);
		F[j].z = Z(i);
		++j;
	}

	x = y = z = TRUE;
	for( i=1; i<5; ++i ) {
		x &= (F[i].x == F[0].x);
		y &= (F[i].y == F[0].y);
		z &= (F[i].z == F[0].z);
	}
	if( x )			/* YZ plane	*/
		plane = 1;
	if( y )			/* ZX plane	*/
		plane = 2;
	if( z )			/* XY plane	*/
		plane = 0;

	for( i=0; i<WIDTH*HEIGHT*DEPTH; ++i ) {
		x = X(i);
		y = Y(i);
		z = Z(i);
		switch( plane ) {
		case 0:		/* XY plane	*/
			z = DEPTH-1 - z;
			break;
		case 1:		/* YZ plane	*/
			x = WIDTH-1 - x;
			break;
		case 2:		/* ZX plane	*/
			y = HEIGHT-1 - y;
			break;
		}
		mirror[i] = CharBoard[BPOS(x,y,z)];
		if( CharBoard[i] > mirror[i] )
			return	FALSE;
		if( CharBoard[i] < mirror[i] )
			break;
	}

	return	TRUE;
}

/*----------------------------------------------------------------------*/
/*	解を発見							*/
/*----------------------------------------------------------------------*/
void	Found( void )
{
	if( ! MirrorCheck() )
		return;

	++totalcount;
	if( printflag ) {
		printf( "No. %d\n", totalcount );
		PrintCurrentBoard( CharBoard );
	}
}


/*----------------------------------------------------------------------*/
/*	次に試すべき場所を探す						*/
/*----------------------------------------------------------------------*/
int	SearchNextBase( BitsForm board, int base )
{
	for( ; base<WIDTH*HEIGHT*DEPTH; ++base ) {
		if( ( (board >> base ) & 1 ) == 0 )
			break;
	}
	return	base;
}

/*----------------------------------------------------------------------*/
/*	試行錯誤 (１レベル再帰的に)					*/
/*----------------------------------------------------------------------*/
void	SearchOneLevel( int level, BitsForm board, int base )
{
	int		i, j;
	int		pn;		/* ピース番号	*/
	char		name;		/* ピース名	*/
	int		ss, nx;
	int		nth;
	BitsForm	prevboard;
	BitsForm	*bitsp;
	AllBitsForm	*pats;

	if( level >= PN ) {
		Found();
		return;
	}

	base = SearchNextBase( board, base );	/* 次のベース位置	*/

	/*	速度向上のため 「I」は x軸と並行にしか置けない。	*/
	/*	x=0 の平面を調べ終えたときに、既に使用済み。		*/
	if( (base >= DEPTH*HEIGHT) && RestPieces[1] )
		return;

	for( pn = 0; pn < PN; ++pn ) {
		/* 次の可能なピースを探す	*/
		if( ! RestPieces[pn] )
			continue;

		name = AllPieceForm[pn].name;
		pats = &(AllPieceForm[pn].allbits[base]);
		bitsp = pats->bits;
		for( nth=0; nth < pats->n; ++nth, ++bitsp ) {
			/* 同じピースで、次の置き方を探す	*/
			/* 重なる時は、次のピースを探す		*/
			if( board & *bitsp )
				continue;

			/* 置けることが分かったので、置いて先に進もう	*/
			++tryalcount;
			prevboard = board;
			board |= *bitsp;
			RestPieces[pn] = FALSE;
			for( j=0; j<CN; ++j )
				CharBoard[pats->offsets[nth][j]] = name;

			if( stepflag )			/* ステップ印字	*/
				PrintCurrentBoard( CharBoard );

			SearchOneLevel( level+1, board, base+1 );	/* 再帰	*/
			
			/* 戻って来たので、取り除いて以前の状態にする	*/
			board = prevboard;
			RestPieces[pn] = TRUE;
			for( j=0; j<CN; ++j )
				CharBoard[pats->offsets[nth][j]] = BLANKCELL;
		}

	}
}

/*----------------------------------------------------------------------*/
/*	試行錯誤 (全部調べ尽くす)					*/
/*----------------------------------------------------------------------*/
void	SearchAll( void )
{
	int		i;
	BitsForm 	board;

	totalcount = tryalcount = 0;

	/* 全ピースを未使用にする	*/
	for( i=0; i<PN; ++i )
		RestPieces[i] = TRUE;

	/* ボードのクリア		*/
	board = 0;
	for( i=0; i<WIDTH*HEIGHT*DEPTH; ++i )
		CharBoard[i] = BLANKCELL;

	SearchOneLevel( 0, board, 0 );
}
/************************************************************************/
/*				main					*/
/************************************************************************/
int	main(int argc, char **argv)
{
	int	x, y;

	printflag = 0;
	stepflag = FALSE;
				/* 引数処理は、とても簡略化している。	*/
	while( --argc > 0 ) {
		++argv;
		if( strcmp( *argv, "-p" ) == 0 ) {
			printflag |= 1;
		}
		if( strcmp( *argv, "-l" ) == 0 ) {
			printflag |= 2;
		}
		if( strcmp( *argv, "-s" ) == 0 ) {
			stepflag = TRUE;
			printflag |= 1;
		}
		if( strcmp( *argv, "-h" ) == 0 ) {
			printf( "\nusage: pentomino [-p][-l][-s][-h]\n" );
			printf( "\tp : print by characters\n" );
			printf( "\tl : print by lines\n" );
			printf( "\ts : print each step\n" );
			printf( "\th : help\n" );
			exit(0);
		}
	}

	Initialize();					/* 初期化	*/

	SearchAll();					/* 調べ尽くす	*/

	printf( "Total Count : %d\n", totalcount );	/* 総数		*/
	printf( "Tryal Count : %d\n", tryalcount );	/* 試行回数	*/
}

/************************************************************************/
/*				End of File				*/
/************************************************************************/