/*	
 *	clipsl4r.c
 *
 *	スロットゲーム用サブルーチン集(4ライン・ART機)
 *
 *	CLiP - Common Library for P/ECE
 *	Copyright (C) 2001-2014 Naoyuki Sawa
 *
 *	* Tue Jun 24 21:30:13 JST 2014 Naoyuki Sawa
 *	- 1stリリース。
 *	- 当モジュールは、PCでツールを作成する時にプロジェクトに含めて使用します。
 *	  P/ECE上で直接使用することは無いので、clip.h,Makefileには含めていません。
 */
#include "clip.h"

/****************************************************************************
 *	スペックデータ作成・出力
 ****************************************************************************/
#ifdef  WIN32	//PC上でスペックデータを作成する時に使用します。P/ECE上では使用しません。
/*--------------------------------------------------------------------------*
 *	演出上の判断
 *--------------------------------------------------------------------------*/
#define PRODUCT_SPECIFIC		//このシンボルを定義すると、機種特有の調整を行う。
//#define SLOT_SPEC_ALLOW_TPIHZ_NOBONUS	//このシンボルを定義すると、ダブルテンパイハズレ・トリプルテンパイハズレを許容する。
//#define SLOT_SPEC_ALLOW_MIDCH_NOBONUS	//このシンボルを定義すると、中段チェリーをリーチ目としない。
//#define SLOT_SPEC_ALLOW_CHSEV_NOBONUS	//このシンボルを定義すると、下段チェリー付きセブンをリーチ目としない。
/*--------------------------------------------------------------------------*
 *	構造体
 *--------------------------------------------------------------------------*/
/* 3リール入賞判定 */
typedef struct _ST_Slot_HitChk3 {
	unsigned char	iHitFlg[7/*iLine*/];					//[ライン番号]⇒絵柄組合せ番号				0〜(SIZE_HitFlg-1)
	unsigned char	aPriority[64/*SIZE_HitCd*/][3];				//[条件装置番号][押順]⇒優先度				0,1〜		「優先度=0」ならば、停止不可であることを示す。
} ST_Slot_HitChk3;
/* 2リール入賞予測 */
typedef struct _ST_Slot_HitChk2 {
	unsigned char	aMinPriority[64/*SIZE_HitCd*/];				//[条件装置番号]⇒最小優先度				0,1〜		「最小優先度=0」ならば、停止不可であることを示す。
	unsigned char	aMaxPriority[64/*SIZE_HitCd*/];				//[条件装置番号]⇒最大優先度				0,1〜		最大優先度≧最小優先度
} ST_Slot_HitChk2;
/* 1リール入賞予測 */
typedef struct _ST_Slot_HitChk1 {
	unsigned char	aMinPriority[64/*SIZE_HitCd*/];				//[条件装置番号]⇒最小優先度				0,1〜		「最小優先度=0」ならば、停止不可であることを示す。
	unsigned char	aMaxPriority[64/*SIZE_HitCd*/];				//[条件装置番号]⇒最大優先度				0,1〜		最大優先度≧最小優先度
} ST_Slot_HitChk1;
/* 1リール停止制御 */
typedef struct _ST_Slot_StpCtl1 {
	unsigned char	aHkmCnt[64/*SIZE_HitCd*/];				//[条件装置番号]⇒引込駒数				0〜4
	unsigned char	aStpFlg[64/*SIZE_HitCd*/];				//[条件装置番号]⇒停止可能				0,1
} ST_Slot_StpCtl1;
/* 2リール停止制御 */
typedef struct _ST_Slot_StpCtl2 {
	unsigned char	aHkmCnt[64/*SIZE_HitCd*/];				//[条件装置番号]⇒引込駒数				0〜4,5		「引込駒数=5」とは、停止済リールの停止不可位置であり、引込駒数が定義されていないことを示す。
	unsigned char	aStpFlg[64/*SIZE_HitCd*/];				//[条件装置番号]⇒停止可能				0,1
} ST_Slot_StpCtl2;
/* 3リール停止制御 */
typedef struct _ST_Slot_StpCtl3 {
	unsigned char	aHkmCnt[64/*SIZE_HitCd*/];				//[条件装置番号]⇒引込駒数				0〜4,5		「引込駒数=5」とは、停止済リールの停止不可位置であり、引込駒数が定義されていないことを示す。
	unsigned char	aStpFlg[64/*SIZE_HitCd*/];				//[条件装置番号]⇒停止可能				0,1
} ST_Slot_StpCtl3;
/* 停止制御テスト */
typedef struct _ST_Slot_StpTst {
	unsigned char	aHkmCnt[64/*SIZE_HitCd*/][3];				//[条件装置番号][リール番号]⇒引込駒数			0〜4,5		「引込駒数=5」とは、停止済リールの停止不可位置であり、引込駒数が定義されていないことを示す。
	unsigned char	aPriority[64/*SIZE_HitCd*/];				//[条件装置番号]⇒優先度				0,1〜
} ST_Slot_StpTst;
/* 絵柄組合せテスト */
typedef struct _ST_Slot_CmbTst {
	int		nCmbCnt;						//絵柄組合せ個数					0~
	int		aStpCnt[64/*SIZE_HitCd*/][7/*iLine*/];			//[条件装置番号][ライン番号]⇒絵柄組合せ表示回数	0~
	unsigned char	aResult[64/*SIZE_HitCd*/];				//[条件装置番号]⇒検査結果				0~2		0=正常,1=エラー:条件装置に含まれないのに表示された,2=警告:条件装置に含まれるのに表示されなかった
} ST_Slot_CmbTst;
/* スペックデータビルダ */
typedef struct _ST_Slot_Spec_Builder {
	const ST_Slot_SpecInfo* pInfo;						//スペック情報
	ST_Slot_HitChk3 TBL_HitChk3[21][21][21];				//[左リール停止位置][中リール停止位置][右リール停止位置]⇒3リール入賞判定
	ST_Slot_HitChk2 TBL_HitChk2[6][21][21];					//[押順][停止済リール1停止位置][停止済リール2停止位置]⇒2リール入賞予測
										// 押順=0…第1停止リール=左,第2停止リール=中
										// 押順=1…第1停止リール=中,第2停止リール=右
										// 押順=2…第1停止リール=右,第2停止リール=左
										// 押順=3…第1停止リール=左,第2停止リール=右
										// 押順=4…第1停止リール=中,第2停止リール=左
										// 押順=5…第1停止リール=右,第2停止リール=中
	ST_Slot_HitChk1 TBL_HitChk1[3][21];					//[押順][停止済リール停止位置]⇒1リール入賞予測
										// 押順=0…第1停止リール=左
										// 押順=1…第1停止リール=中
										// 押順=2…第1停止リール=右
	ST_Slot_StpCtl1 TBL_StpCtl1[3][21];					//[押順][停止中リール押下位置]⇒1リール停止制御
										// 押順=0…第1停止リール=左
										// 押順=1…第1停止リール=中
										// 押順=2…第1停止リール=右
	ST_Slot_StpCtl2 TBL_StpCtl2[6][21][21];					//[押順][停止済リール停止位置][停止中リール押下位置]⇒2リール停止制御
										// 押順=0…第1停止リール=左,第2停止リール=中
										// 押順=1…第1停止リール=中,第2停止リール=右
										// 押順=2…第1停止リール=右,第2停止リール=左
										// 押順=3…第1停止リール=左,第2停止リール=右
										// 押順=4…第1停止リール=中,第2停止リール=左
										// 押順=5…第1停止リール=右,第2停止リール=中
	ST_Slot_StpCtl3 TBL_StpCtl3[6][21][21][21];				//[押順][停止済リール1停止位置][停止済リール2停止位置][停止中リール押下位置]⇒3リール停止制御
										// 押順=0…第1停止リール1=左,第2停止リール2=中,第3停止リール=右
										// 押順=1…第1停止リール1=中,第2停止リール2=右,第3停止リール=左
										// 押順=2…第1停止リール1=右,第2停止リール2=左,第3停止リール=中
										// 押順=3…第1停止リール1=左,第2停止リール2=右,第3停止リール=中
										// 押順=4…第1停止リール1=中,第2停止リール2=左,第3停止リール=右
										// 押順=5…第1停止リール1=右,第2停止リール2=中,第3停止リール=左
	ST_Slot_StpTst TBL_StpTst[6][21][21][21];				//[押順番号][第1停止リール押下位置][第2停止リール押下位置][第3停止リール押下位置]⇒停止制御テスト
	ST_Slot_CmbTst TBL_CmbTst[256/*SIZE_HitFlg*/];				//[絵柄組合せ番号]⇒絵柄組合せテスト
} ST_Slot_Spec_Builder;
/*--------------------------------------------------------------------------*
 *	ローカル定数
 *--------------------------------------------------------------------------*/
static const char* const TBL_Slot_Spec_Color[7+1]={"gray","red","green","yellow","blue","magenta","cyan","white"};	//[色番号]⇒HTMLカラーネーム
static const unsigned char TBL_Slot_Spec_HkmCnt_Color[5+1]={7,6,3,5,1,0};	//[引込駒数]⇒色番号
static const char* const TBL_Slot_Spec_Result_Mark[2+1]={"○","×","△"};	//[検査結果]⇒検査結果記号
static const unsigned char TBL_Slot_Spec_Result_Color[2+1]={4,1,3};		//[検査結果]⇒色番号
/*--------------------------------------------------------------------------*
 *	ローカル関数
 *--------------------------------------------------------------------------*/
/* 絵柄位置(iPictPos)から、引込駒数(nHkmCnt)駒、引込んだ絵柄位置を求める。
 * [in]
 *	iPictPos	絵柄位置	0〜20
 *	nHkmCnt		引込駒数	0〜4
 * [out]
 *	戻り値		絵柄位置	0〜20
 */
static int Slot_Spec_GetPictPos_Hkm(int iPictPos, int nHkmCnt) {
	if((unsigned)iPictPos > 20) { DIE(); }
	if((unsigned)nHkmCnt > 4) { DIE(); }
	if((iPictPos -= nHkmCnt) < 0) { iPictPos += 21; }
	return iPictPos;
}
/*--------------------------------------------------------------------------*/
/* 各リールの停止絵柄が、iPict1,iPict2,iPict3である、絵柄組合せを検索する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	iPict1		左リールの絵柄番号	0〜(SIZE_Pict-1)
 *	iPict2		中リールの絵柄番号	0〜(SIZE_Pict-1)
 *	iPict3		右リールの絵柄番号	0〜(SIZE_Pict-1)
 * [out]
 *	戻り値		絵柄組合せ番号		0〜(SIZE_HitFlg-1)
 */
static int Slot_Spec_FindHitFlg(ST_Slot_Spec_Builder* pBuilder, int iPict1, int iPict2, int iPict3) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int iHitFlg;
	const ST_Slot_Spec_HitFlg* pHitFlg;
	/* 指定された絵柄番号が正常であることを確認する。 */
	if(((unsigned)iPict1 >= (unsigned)pInfo->SIZE_Pict) ||
	   ((unsigned)iPict2 >= (unsigned)pInfo->SIZE_Pict) ||
	   ((unsigned)iPict3 >= (unsigned)pInfo->SIZE_Pict)) { DIE(); }
	/* 各絵柄組合せについて… */
	for(iHitFlg = pInfo->SIZE_HitFlg - 1; iHitFlg >= 0; iHitFlg--) {
		pHitFlg = &pInfo->TBL_HitFlg[iHitFlg];
		/* 絵柄組合せデータが破損していないことを確認する。 */
		if(((unsigned)pHitFlg->aPict[0] >= (unsigned)pInfo->SIZE_Pict) ||
		   ((unsigned)pHitFlg->aPict[1] >= (unsigned)pInfo->SIZE_Pict) ||
		   ((unsigned)pHitFlg->aPict[2] >= (unsigned)pInfo->SIZE_Pict)) { DIE(); }
		/* 絵柄番号が一致したら、絵柄組合せ番号を返す。 */
		if((!pHitFlg->aPict[0] || (pHitFlg->aPict[0] == iPict1)) &&
		   (!pHitFlg->aPict[1] || (pHitFlg->aPict[1] == iPict2)) &&
		   (!pHitFlg->aPict[2] || (pHitFlg->aPict[2] == iPict3))) { return iHitFlg; }
	}
	DIE(); /* 少なくとも、(iHitFlg=0:ハズレ)に一致するはずなので、ここへ到達したらエラー。 */
}
/*--------------------------------------------------------------------------*/
/* 最大引込駒数を取得する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	iHitCd		条件装置番号		0〜(SIZE_HitCd-1)
 *	iReel		リール番号		0〜2
 * [out]
 *	戻り値		最大引込駒数		1,又は,4
 */
static int GetHkmCntMax(ST_Slot_Spec_Builder* pBuilder, int iHitCd, int iReel) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	/* 指定された条件装置番号が正常であることを確認する。 */
	if((unsigned)iHitCd >= (unsigned)pInfo->SIZE_HitCd) { DIE(); }
	/* 指定されたリール番号が正常であることを確認する。 */
	if((unsigned)iReel > 2) { DIE(); }
	/* CT中ならば、CT中に無制御とするリール番号ならば、最大引込駒数を1とする。 */
	if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "全小役") && (iReel == pInfo->CT_Reel)) { return 1; }
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
	/* ﾁｪﾘｰならば、CT中に無制御とするリール番号ならば、最大引込駒数を1とする。 */
	if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾁｪﾘｰ"  ) && (iReel == pInfo->CT_Reel)) { return 1; }
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
	/* それ以外ならば、最大引込駒数を1とする。 */
	return 4;
}
/*--------------------------------------------------------------------------*
 *	3リール入賞判定
 *--------------------------------------------------------------------------*/
/* 3リール入賞判定データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildHitChk3(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iReel1, iReel2, iReel3, iLine, iHitCd, iOrder, iPriority;
	ST_Slot_HitChk3* pHitChk3;
	const ST_Slot_Spec_HitFlg* pHitFlg;
	iReel1 = 0; /* 左リール */
	iReel2 = 1; /* 中リール */
	iReel3 = 2; /* 右リール */
	/* 左リールの各停止位置について… */
	for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
		/* 中リールの各停止位置について… */
		for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
			/* 右リールの各停止位置について… */
			for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
				pHitChk3 = &pBuilder->TBL_HitChk3[aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
				/* 各ラインについて… */
				for(iLine = 0; iLine < 7; iLine++) {
					/* 絵柄組合せ番号を取得する。 */
					pHitChk3->iHitFlg[iLine] = Slot_Spec_FindHitFlg(pBuilder,
						Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + Slot_GetLineRow(iLine, iReel1), iReel1),
						Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2] + Slot_GetLineRow(iLine, iReel2), iReel2),
						Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel3] + Slot_GetLineRow(iLine, iReel3), iReel3));
				}
				/* 各条件装置について… */
				for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
					/* 各押順について… */
					for(iOrder = 0; iOrder < 3; iOrder++) {
						/* 各ラインについて… */
						for(iLine = 0; iLine < 7; iLine++) {
							/* このラインの、絵柄組合せを取得する。 */
							pHitFlg = &pInfo->TBL_HitFlg[pHitChk3->iHitFlg[iLine]];
							iPriority = pHitFlg->aPriority[iHitCd][iOrder][iLine <= 2];
							if(iPriority < -1) { DIE(); }
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
							/* 特殊リプは昇斜ライン(=中段セブン揃い)を優先するよう、優先度(+1)する。 */
							if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "特殊ﾘﾌﾟ") && strstr(pHitFlg->pName, "特殊ﾘﾌﾟ")) {
								if(iLine == Slot_Line_Z) { if(iPriority <= 0) { DIE(); } iPriority += 1; } /* 中段セブン揃い */
							}
							/* 当機種は左右リールにチェリーが6駒間隔に有り、ボーナス絵柄を揃える時に、左リール中段チェリーや右リール下段チェリー付きセブンのリーチ目が出過ぎる。
							 * そこで、リーチ目の優先度を(-1)することにした。リーチ目を出さずにボーナス絵柄を揃えられるならば、リーチ目を出さない方を優先することにした。
							 * リーチ目を避けられない押し位置の場合のみ、リーチ目が出現するぐらいの方が、出現頻度として丁度良いと思ったから。 */
							if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾎﾞｰﾅｽ") && strstr(pHitFlg->pName, "ﾎﾞｰﾅｽ")) {
								if(iLine == Slot_Line_F) { if(iPriority <= 2) { DIE(); } iPriority -= 2; } /* 左リール中段チェリー+右リール下段チェリー付きセブン */
								if(iLine == Slot_Line_V) { if(iPriority <= 1) { DIE(); } iPriority -= 1; } /* 左リール中段チェリー                                */
								if(iLine == Slot_Line_A) { if(iPriority <= 1) { DIE(); } iPriority -= 1; } /*                      右リール下段チェリー付きセブン */
							}
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
							/* この条件装置で停止可能な絵柄組合せならば… */	//この判断では、優先度(-1)も含める。
							if(iPriority) {
								/* 優先度を更新する。 */			//この判断で、優先度(-1)を除外する。
								if((int)iPriority > (int)pHitChk3->aPriority[iHitCd][iOrder]) { pHitChk3->aPriority[iHitCd][iOrder] = iPriority; }
							/* この条件装置で停止不可な絵柄組合せが1つでも有れば… */
							} else {
								/* 停止不可と決定する。 */
								pHitChk3->aPriority[iHitCd][iOrder] = 0;
								break; /* ここまで */
							}
						}
					}
				}
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 3リール入賞判定データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintHitChk3(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iReel1, iReel2, iReel3, iLine, iHitCd, iOrder;
	const ST_Slot_HitChk3* pHitChk3;
	const ST_Slot_Spec_Pict* pPict;
	iReel1 = 0; /* 左リール */
	iReel2 = 1; /* 中リール */
	iReel3 = 2; /* 右リール */
	fprintf(fp, "<table>\n");
	fprintf(fp, "<caption>%s</caption>\n", "TBL_HitChk3");
	/* 左リールの各停止位置について… */
	for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
		/* 中リールの各停止位置について… */
		for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
			/* 右リールの各停止位置について… */
			for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
				pHitChk3 = &pBuilder->TBL_HitChk3[aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
				fprintf(fp, "<tr>");
				  fprintf(fp, "<td>");
				    fprintf(fp, "%2d", aPictPos[iReel1]);							//左リール停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//左リール停止絵柄
				    fprintf(fp, "</font>");
				    fprintf(fp, " ");
				    fprintf(fp, "%2d", aPictPos[iReel2]);							//中リール停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2], iReel2)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//中リール停止絵柄
				    fprintf(fp, "</font>");
				    fprintf(fp, " ");
				    fprintf(fp, "%2d", aPictPos[iReel3]);							//右リール停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel3], iReel3)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//右リール停止絵柄
				    fprintf(fp, "</font>");
				  fprintf(fp, "</td>");
				  /* 各ラインについて… */
				  fprintf(fp, "<td>");
				    for(iLine = 0; iLine < 7; iLine++) {
				    	if(iLine) { fprintf(fp, " "); }
				    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pInfo->TBL_HitFlg[pHitChk3->iHitFlg[iLine]].iColor]);
				    	  fprintf(fp, "%s", pInfo->TBL_HitFlg[pHitChk3->iHitFlg[iLine]].pName);			//絵柄組合せ
				    	fprintf(fp, "</font>");
				    }
				  fprintf(fp, "</td>");
				  /* 各条件装置について… */
				  fprintf(fp, "<td>");
				    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
				    	if(iHitCd) { fprintf(fp, "|"); }
				    	/* 各押順について… */
				    	for(iOrder = 0; iOrder < 3; iOrder++) {
				    		if(iOrder) { fprintf(fp, " "); }
				    		fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pHitChk3->aPriority[iHitCd][iOrder] ? 7 : 0]);
				    		  fprintf(fp, "%d", pHitChk3->aPriority[iHitCd][iOrder]);			//優先度
				    		fprintf(fp, "</font>");
				    	}
				    }
				  fprintf(fp, "</td>");
				fprintf(fp, "</tr>\n");
			}
		}
	}
	fprintf(fp, "</table>\n");
}
/*--------------------------------------------------------------------------*
 *	2リール入賞予測
 *--------------------------------------------------------------------------*/
/* 2リール入賞予測データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildHitChk2(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd, nHkmCnt, nMinPriority1, nMaxPriority1, nMinPriority2, nMaxPriority2;
	ST_Slot_HitChk2* pHitChk2;
	const ST_Slot_HitChk3* pHitChk3;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール1 */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止済リール2 */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 回転中リール */
		/* 停止済リール1の各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止済リール2の各停止位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				pHitChk2 = &pBuilder->TBL_HitChk2[iOrder][aPictPos[iReel1]][aPictPos[iReel2]];
				/* 各条件装置について… */
				for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
					nMinPriority1 = nMaxPriority1 = 0;
					/* 回転中リールの各停止位置について… */
					for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
						nMinPriority2 = nMaxPriority2 = 0;
						/* 最大引込駒数を取得する。 */
						nHkmCnt = GetHkmCntMax(pBuilder, iHitCd, iReel3);
						/* 各引込駒数について… */
						do {
							/* 3リール入賞判定データを取得する */
							switch(iReel3) {
							case 0: pHitChk3 = &pBuilder->TBL_HitChk3[Slot_Spec_GetPictPos_Hkm(aPictPos[0], nHkmCnt)][                         aPictPos[1]          ][                         aPictPos[2]          ]; break;
							case 1: pHitChk3 = &pBuilder->TBL_HitChk3[                         aPictPos[0]          ][Slot_Spec_GetPictPos_Hkm(aPictPos[1], nHkmCnt)][                         aPictPos[2]          ]; break;
							case 2: pHitChk3 = &pBuilder->TBL_HitChk3[                         aPictPos[0]          ][                         aPictPos[1]          ][Slot_Spec_GetPictPos_Hkm(aPictPos[2], nHkmCnt)]; break;
							default: DIE();
							}
							/* 停止可能ならば… */
							if(pHitChk3->aPriority[iHitCd][iReel1]) {
								/* 最小優先度と最大優先度を更新する。 */
								if(!nMinPriority2) {	/* 初回 */
									nMinPriority2 = pHitChk3->aPriority[iHitCd][iReel1];
									nMaxPriority2 = pHitChk3->aPriority[iHitCd][iReel1];
								} else {		/* 更新 */
									if(pHitChk3->aPriority[iHitCd][iReel1] < nMinPriority2) { nMinPriority2 = pHitChk3->aPriority[iHitCd][iReel1]; }
									if(pHitChk3->aPriority[iHitCd][iReel1] > nMaxPriority2) { nMaxPriority2 = pHitChk3->aPriority[iHitCd][iReel1]; }
								}
							}
						} while(--nHkmCnt >= 0);
						/* 全ての引込駒数で停止不可ならば… */
						if(!nMinPriority2) {
							/* 停止不可と決定する。 */
							nMinPriority1 = nMaxPriority1 = 0;
							break; /* ここまで */
						}
						/* 最小優先度と最大優先度を更新する。 */
						if(!nMinPriority1) {	/* 初回 */
							nMinPriority1 = nMinPriority2;
							nMaxPriority1 = nMaxPriority2;
						} else {		/* 更新 */
							if(nMinPriority2 < nMinPriority1) { nMinPriority1 = nMinPriority2; }
							if(nMaxPriority2 > nMaxPriority1) { nMaxPriority1 = nMaxPriority2; }
						}
					}
#ifndef SLOT_SPEC_ALLOW_TPIHZ_NOBONUS
					//{{--- ダブルテンパイハズレ・トリプルテンパイハズレを禁止する場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
					/* 条件装置がハズレならば… */
					if(!iHitCd) {
						int iLine, TpiCnt = 0;
						/* 各ラインについて… */
						for(iLine = 0; iLine < 7; iLine++) {
							/* テンパイ判定を行う。 */
							if(Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + Slot_GetLineRow(iLine, iReel1), iReel1) ==
							   Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2] + Slot_GetLineRow(iLine, iReel2), iReel2)) { TpiCnt++; }
						}
						/* 条件装置がハズレで、テンパイライン数が2ライン以上ならば、停止不可と決定する。 */
						if(TpiCnt >= 2) { nMinPriority1 = nMaxPriority1 = 0; }
					}
					//}}--- ダブルテンパイハズレ・トリプルテンパイハズレを禁止する場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
#endif//SLOT_SPEC_ALLOW_TPIHZ_NOBONUS
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
					/* 第1停止リールが中リールだったならば… */
					if(iReel1 == 1) {
						/* 第2停止リール(左リール,又は,右リール)の上段,又は下段にチェリー出現ならば… */
						if((strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2] + 0/*上段*/, iReel2)].pName, "ﾁｪﾘｰ")) ||
						   (strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2] + 2/*下段*/, iReel2)].pName, "ﾁｪﾘｰ"))) {
							/* 条件装置がチェリー,又は,全小役ならば… */
							if((strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾁｪﾘｰ"  )) ||
							   (strstr(pInfo->TBL_HitCd[iHitCd].pName, "全小役"))) {
								/* 停止可能ならば…(中リールの位置によっては、実際には停止しない箇所があるので除外する。) */
								if(nMinPriority1) {
									/* 出来る限り早く、チェリーを出現させる。これは演出上の判断であり、必須ではない。 */
									nMaxPriority1++;		/* 最大優先度を、チェリーの既定の優先度+1とする。 */
								}
							}
						}
					}
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
					/* 最小優先度と最大優先度を格納する。 */
					pHitChk2->aMinPriority[iHitCd] = nMinPriority1;
					pHitChk2->aMaxPriority[iHitCd] = nMaxPriority1;
				}
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 2リール入賞予測データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintHitChk2(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iHitCd;
	const ST_Slot_HitChk2* pHitChk2;
	const ST_Slot_Spec_Pict* pPict;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_HitChk2", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール1 */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止済リール2 */
		/* 停止済リール1の各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止済リール2の各停止位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				pHitChk2 = &pBuilder->TBL_HitChk2[iOrder][aPictPos[iReel1]][aPictPos[iReel2]];
				fprintf(fp, "<tr>");
				  fprintf(fp, "<td>");
				    fprintf(fp, "%2d", aPictPos[iReel1]);							//停止済リール1停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//停止済リール1停止絵柄
				    fprintf(fp, "</font>");
				    fprintf(fp, " ");
				    fprintf(fp, "%2d", aPictPos[iReel2]);							//停止済リール2停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2], iReel2)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//停止済リール2停止絵柄
				    fprintf(fp, "</font>");
				  fprintf(fp, "</td>");
				  /* 各条件装置について… */
				  fprintf(fp, "<td>");
				    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
				    	if(iHitCd) { fprintf(fp, " "); }
				    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pHitChk2->aMinPriority[iHitCd] ? 7 : 0]);
				    	  fprintf(fp, "%d-%d", pHitChk2->aMinPriority[iHitCd], pHitChk2->aMaxPriority[iHitCd]);	//最小優先度,最大優先度
				    	fprintf(fp, "</font>");
				    }
				  fprintf(fp, "</td>");
				fprintf(fp, "</tr>\n");
			}
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	1リール入賞予測
 *--------------------------------------------------------------------------*/
/* 1リール入賞予測データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildHitChk1(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iHitCd, nHkmCnt, nMinPriority1, nMaxPriority1, nMinPriority2, nMaxPriority2, nMinPriority3, nMaxPriority3;
	ST_Slot_HitChk1* pHitChk1;
	const ST_Slot_HitChk2* pHitChk2;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 3; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール */
		/* 停止済リールの各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			pHitChk1 = &pBuilder->TBL_HitChk1[iOrder][aPictPos[iReel1]];
			/* 各条件装置について… */
			for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
				nMinPriority1 = nMaxPriority1 = 0;
				/* 回転中リール1と回転中リール2について… */
				for(iReel2 = (iReel1+1)%3; iReel2 != iReel1; iReel2 = (iReel2+1)%3) {
					nMinPriority2 = nMaxPriority2 = 0;
					/* 回転中リールの各停止位置について… */
					for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
						nMinPriority3 = nMaxPriority3 = 0;
						/* 最大引込駒数を取得する。 */
						nHkmCnt = GetHkmCntMax(pBuilder, iHitCd, iReel2);
						/* 各引込駒数について… */
						do {
							/* 2リール入賞予測データを取得する */
							pHitChk2 = &pBuilder->TBL_HitChk2[Slot_FindOrder(iReel1, iReel2)][aPictPos[iReel1]][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel2], nHkmCnt)];
							/* 停止可能ならば… */
							if(pHitChk2->aMinPriority[iHitCd]) {
								/* 最小優先度と最大優先度を更新する。 */
								if(!nMinPriority3) {
									nMinPriority3 = pHitChk2->aMinPriority[iHitCd];
									nMaxPriority3 = pHitChk2->aMaxPriority[iHitCd];
								} else {
									if(pHitChk2->aMinPriority[iHitCd] < nMinPriority3) { nMinPriority3 = pHitChk2->aMinPriority[iHitCd]; }
									if(pHitChk2->aMaxPriority[iHitCd] > nMaxPriority3) { nMaxPriority3 = pHitChk2->aMaxPriority[iHitCd]; }
								}
							}
						} while(--nHkmCnt >= 0);
						/* 全ての引込駒数で停止不可ならば… */
						if(!nMinPriority3) {
							/* 停止不可と決定する。 */
							nMinPriority2 = nMaxPriority2 = 0;
							break; /* ここまで */
						}
						/* 最小優先度と最大優先度を更新する。 */
						if(!nMinPriority2) {
							nMinPriority2 = nMinPriority3;
							nMaxPriority2 = nMaxPriority3;
						} else {
							if(nMinPriority3 < nMinPriority2) { nMinPriority2 = nMinPriority3; }
							if(nMaxPriority3 > nMaxPriority2) { nMaxPriority2 = nMaxPriority3; }
						}
					}
					/* 回転中リールの片方でも停止不可ならば… */
					if(!nMinPriority2) {
						/* 停止不可と決定する。 */
						nMinPriority1 = nMaxPriority1 = 0;
						break; /* ここまで */
					}
					/* 最小優先度と最大優先度を更新する。 */
					if(!nMinPriority1) {
						nMinPriority1 = nMinPriority2;
						nMaxPriority1 = nMaxPriority2;
					} else {
						if(nMinPriority2 < nMinPriority1) { nMinPriority1 = nMinPriority2; }
						if(nMaxPriority2 > nMaxPriority1) { nMaxPriority1 = nMaxPriority2; }
					}
				}
#ifndef SLOT_SPEC_ALLOW_MIDCH_NOBONUS
				//{{--- 左リール第1停止時、中段チェリーをリーチ目とする場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
				/* 左リール第1停止ならば… */
				if(iReel1 == 0) {
					/* 中段チェリーならば… */
					if(strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + 1/*中段*/, iReel1)].pName, "ﾁｪﾘｰ")) {
						/* 条件装置がボーナスならば… */
						if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾎﾞｰﾅｽ")) {
							/* 出来る限り、リーチ目を引込むことにする。これは演出上の判断であり、必須ではない。 */
							if(!nMinPriority1) { DIE(); }	/* 最小優先度が、停止可能であるはず。もしそうでなければ設計ミス。 */
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
							/* 当機種は左右リールにチェリーが6駒間隔に有り、ボーナス絵柄を揃える時に、左リール中段チェリーや右リール下段チェリー付きセブンのリーチ目が出過ぎる。
							 * そこで、リーチ目の優先度を(+1)しないことにした。Slot_Spec_BuildHitChk3()の、機種特有の調整を参照せよ。 */
#else //PRODUCT_SPECIFIC//}}機種特有の調整
							nMaxPriority1++;		/* 最大優先度を、セブン揃いの既定の優先度+1とする。 */			//「最大優先度≧最小優先度」を維持するために、最大優先度の方を増やすことにした。これで良いか要検討。今回は違うが、ボーナスと小役が重複当選し小役優先制御としたい場合に、小役優先にならない問題が生じるかも知れない。最小優先度を増やす方が適切か?
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
						/* 条件装置がボーナス以外ならば… */
						} else {
							/* 停止不可と決定する。 */
							nMinPriority1 = nMaxPriority1 = 0;
						}
					}
				}
				//}}--- 左リール第1停止時、中段チェリーをリーチ目とする場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
#endif//SLOT_SPEC_ALLOW_MIDCH_NOBONUS
#ifndef SLOT_SPEC_ALLOW_CHSEV_NOBONUS
				//{{--- 右リール第1停止時、下段チェリー付きセブンをリーチ目とする場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
				/* 右リール第1停止ならば… */
				if(iReel1 == 2) {
					/* 下段チェリー付きセブンならば… */
					if(strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + 1/*中段*/, iReel1)].pName, "ﾁｪﾘｰ") &&
					   strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + 2/*下段*/, iReel1)].pName, "ｾﾌﾞﾝ")) {
						/* 条件装置がボーナスならば… */
						if(strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾎﾞｰﾅｽ")) {
							/* 出来る限り、リーチ目を引込むことにする。これは演出上の判断であり、必須ではない。 */
							if(!nMinPriority1) { DIE(); }	/* 最小優先度が、停止可能であるはず。もしそうでなければ設計ミス。 */
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
							/* 当機種は左右リールにチェリーが6駒間隔に有り、ボーナス絵柄を揃える時に、左リール中段チェリーや右リール下段チェリー付きセブンのリーチ目が出過ぎる。
							 * そこで、リーチ目の優先度を(+1)しないことにした。Slot_Spec_BuildHitChk3()の、機種特有の調整を参照せよ。 */
#else //PRODUCT_SPECIFIC//}}機種特有の調整
							nMaxPriority1++;		/* 最大優先度を、セブン揃いの既定の優先度+1とする。 */			//「最大優先度≧最小優先度」を維持するために、最大優先度の方を増やすことにした。これで良いか要検討。今回は違うが、ボーナスと小役が重複当選し小役優先制御としたい場合に、小役優先にならない問題が生じるかも知れない。最小優先度を増やす方が適切か?
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
						/* 条件装置がボーナス以外ならば… */
						} else {
							/* 停止不可と決定する。 */
							nMinPriority1 = nMaxPriority1 = 0;
						}
					}
				}
				//}}--- 右リール第1停止時、下段チェリー付きセブンをリーチ目とする場合は、このブロックを有効にせよ。これは演出上の判断であり、必須ではない。 ---
#endif//SLOT_SPEC_ALLOW_CHSEV_NOBONUS
#ifdef  PRODUCT_SPECIFIC//{{機種特有の調整
				/* 左リール第1停止,又は,右リール第1停止ならば… */
				if((iReel1 == 0) || (iReel1 == 2)) {
					/* 上段,又は下段にチェリー出現ならば… */
					if((strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + 0/*上段*/, iReel1)].pName, "ﾁｪﾘｰ")) ||
					   (strstr(pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1] + 2/*下段*/, iReel1)].pName, "ﾁｪﾘｰ"))) {
						/* 条件装置がチェリー,又は,全小役ならば… */
						if((strstr(pInfo->TBL_HitCd[iHitCd].pName, "ﾁｪﾘｰ"  )) ||
						   (strstr(pInfo->TBL_HitCd[iHitCd].pName, "全小役"))) {
							/* 出来る限り早く、チェリーを出現させる。これは演出上の判断であり、必須ではない。 */
							if(!nMinPriority1) { DIE(); }	/* 最小優先度が、停止可能であるはず。もしそうでなければ設計ミス。 */
							nMaxPriority1++;		/* 最大優先度を、チェリーの既定の優先度+1とする。 */
						}
					}
				}
#endif//PRODUCT_SPECIFIC//}}機種特有の調整
				/* 最小優先度と最大優先度を格納する。 */
				pHitChk1->aMinPriority[iHitCd] = nMinPriority1;
				pHitChk1->aMaxPriority[iHitCd] = nMaxPriority1;
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 1リール入賞予測データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintHitChk1(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iHitCd;
	const ST_Slot_HitChk1* pHitChk1;
	const ST_Slot_Spec_Pict* pPict;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 3; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_HitChk1", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール */
		/* 停止済リールの各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			pHitChk1 = &pBuilder->TBL_HitChk1[iOrder][aPictPos[iReel1]];
			fprintf(fp, "<tr>");
			  fprintf(fp, "<td>");
			    fprintf(fp, "%2d", aPictPos[iReel1]);								//停止済リール停止位置
			    fprintf(fp, " ");
			    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
			    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
			      fprintf(fp, "%s", pPict->pName);									//停止済リール停止絵柄
			    fprintf(fp, "</font>");
			  fprintf(fp, "</td>");
			  /* 各条件装置について… */
			  fprintf(fp, "<td>");
			    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
			    	if(iHitCd) { fprintf(fp, " "); }
			    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pHitChk1->aMinPriority[iHitCd] ? 7 : 0]);
			    	  fprintf(fp, "%d-%d", pHitChk1->aMinPriority[iHitCd], pHitChk1->aMaxPriority[iHitCd]);		//最小優先度,最大優先度
			    	fprintf(fp, "</font>");
			    }
			  fprintf(fp, "</td>");
			fprintf(fp, "</tr>\n");
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	1リール停止制御
 *--------------------------------------------------------------------------*/
/* 1リール停止制御データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildStpCtl1(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iHitCd, nHkmCnt, nMinPriority, nMaxPriority;
	ST_Slot_StpCtl1* pStpCtl1;
	const ST_Slot_HitChk1* pHitChk1;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 3; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止中リール */
		/* 停止中リールの各押下位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			pStpCtl1 = &pBuilder->TBL_StpCtl1[iOrder][aPictPos[iReel1]];
			/* 各条件装置について… */
			for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
				nMinPriority = nMaxPriority = 0;
				pStpCtl1->aHkmCnt[iHitCd] = 5;	/* 停止不可としておく。 */
				/* 最大引込駒数を取得する。 */
				nHkmCnt = GetHkmCntMax(pBuilder, iHitCd, iReel1);
				/* 各引込駒数について… */
				do {
					/* 1リール入賞予測データを取得する */
					pHitChk1 = &pBuilder->TBL_HitChk1[iReel1][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel1], nHkmCnt)];
					/* 停止可能ならば… */
					if(pHitChk1->aMinPriority[iHitCd]) {
						/* 引込駒数を選択する:
						 * ・最大優先度が大きければ、選択する。
						 * ・最大優先度が同じ,かつ,最小優先度が大きければ、選択する。
						 * ・最大優先度が同じ,かつ,最小優先度が同じならば、引込駒数が小さい方を選択する。即ち、ループの後方優先で上書きする。
						 */
						if((pHitChk1->aMaxPriority[iHitCd] >  nMaxPriority) ||
						  ((pHitChk1->aMaxPriority[iHitCd] == nMaxPriority) && (pHitChk1->aMinPriority[iHitCd] >= nMinPriority))) {
							nMinPriority = pHitChk1->aMinPriority[iHitCd];
							nMaxPriority = pHitChk1->aMaxPriority[iHitCd];
							pStpCtl1->aHkmCnt[iHitCd] = nHkmCnt;
						}
					}
				} while(--nHkmCnt >= 0);
				/* 全ての引込駒数で停止不可ならば、設計ミスである。 */
				if(pStpCtl1->aHkmCnt[iHitCd] == 5) { DIE(); }
				/* 実際に停止する停止位置に、停止可能をマークする。 */
				pBuilder->TBL_StpCtl1[iOrder][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel1], pStpCtl1->aHkmCnt[iHitCd])].aStpFlg[iHitCd] = 1;
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 1リール停止制御データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintStpCtl1(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iHitCd;
	const ST_Slot_StpCtl1* pStpCtl1;
	const ST_Slot_Spec_Pict* pPict;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 3; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_StpCtl1", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止中リール */
		/* 停止中リールの各押下位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			pStpCtl1 = &pBuilder->TBL_StpCtl1[iOrder][aPictPos[iReel1]];
			fprintf(fp, "<tr>");
			  fprintf(fp, "<td>");
			    fprintf(fp, "%2d", aPictPos[iReel1]);								//停止中リール押下位置
			    fprintf(fp, " ");
			    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
			    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
			      fprintf(fp, "%s", pPict->pName);									//停止中リール押下絵柄
			    fprintf(fp, "</font>");
			  fprintf(fp, "</td>");
			  /* 各条件装置について… */
			  fprintf(fp, "<td>");
			    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
			    	if(iHitCd) { fprintf(fp, " "); }
			    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[TBL_Slot_Spec_HkmCnt_Color[pStpCtl1->aHkmCnt[iHitCd]]]);
			    	  fprintf(fp, "%d", pStpCtl1->aHkmCnt[iHitCd]);							//引込駒数
			    	fprintf(fp, "</font>");
			    }
			  fprintf(fp, "</td>");
			fprintf(fp, "</tr>\n");
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	2リール停止制御
 *--------------------------------------------------------------------------*/
/* 2リール停止制御データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildStpCtl2(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iHitCd, nHkmCnt, nMinPriority, nMaxPriority;
	ST_Slot_StpCtl2* pStpCtl2;
	const ST_Slot_HitChk2* pHitChk2;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止中リール */
		/* 停止済リールの各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止中リールの各押下位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				pStpCtl2 = &pBuilder->TBL_StpCtl2[iOrder][aPictPos[iReel1]][aPictPos[iReel2]];
				/* 各条件装置について… */
				for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
					nMinPriority = nMaxPriority = 0;
					pStpCtl2->aHkmCnt[iHitCd] = 5;	/* 停止不可としておく。 */
					/* 停止済リールの停止位置が、停止可能ならば… */
					if(pBuilder->TBL_StpCtl1[iReel1][aPictPos[iReel1]].aStpFlg[iHitCd]) {
						/* 最大引込駒数を取得する。 */
						nHkmCnt = GetHkmCntMax(pBuilder, iHitCd, iReel2);
						/* 各引込駒数について… */
						do {
							/* 2リール入賞予測データを取得する */
							pHitChk2 = &pBuilder->TBL_HitChk2[Slot_FindOrder(iReel1, iReel2)][aPictPos[iReel1]][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel2], nHkmCnt)];
							/* 停止可能ならば… */
							if(pHitChk2->aMinPriority[iHitCd]) {
								/* 引込駒数を選択する:
								 * ・最大優先度が大きければ、選択する。
								 * ・最大優先度が同じ,かつ,最小優先度が大きければ、選択する。
								 * ・最大優先度が同じ,かつ,最小優先度が同じならば、引込駒数が小さい方を選択する。即ち、ループの後方優先で上書きする。
								 */
								if((pHitChk2->aMaxPriority[iHitCd] >  nMaxPriority) ||
								  ((pHitChk2->aMaxPriority[iHitCd] == nMaxPriority) && (pHitChk2->aMinPriority[iHitCd] >= nMinPriority))) {
									nMinPriority = pHitChk2->aMinPriority[iHitCd];
									nMaxPriority = pHitChk2->aMaxPriority[iHitCd];
									pStpCtl2->aHkmCnt[iHitCd] = nHkmCnt;
								}
							}
						} while(--nHkmCnt >= 0);
						/* 全ての引込駒数で停止不可ならば、設計ミスである。 */
						if(pStpCtl2->aHkmCnt[iHitCd] == 5) { DIE(); }
						/* 実際に停止する停止位置に、停止可能をマークする。 */
						pBuilder->TBL_StpCtl2[iOrder][aPictPos[iReel1]][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel2], pStpCtl2->aHkmCnt[iHitCd])].aStpFlg[iHitCd] = 1;
					}
				}
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 2リール停止制御データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintStpCtl2(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iHitCd;
	const ST_Slot_StpCtl2* pStpCtl2;
	const ST_Slot_Spec_Pict* pPict;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_StpCtl2", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止中リール */
		/* 停止済リールの各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止中リールの各押下位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				pStpCtl2 = &pBuilder->TBL_StpCtl2[iOrder][aPictPos[iReel1]][aPictPos[iReel2]];
				fprintf(fp, "<tr>");
				  fprintf(fp, "<td>");
				    fprintf(fp, "%2d", aPictPos[iReel1]);							//停止済リール停止位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//停止済リール停止絵柄
				    fprintf(fp, "</font>");
				    fprintf(fp, " ");
				    fprintf(fp, "%2d", aPictPos[iReel2]);							//停止中リール押下位置
				    fprintf(fp, " ");
				    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2], iReel2)];
				    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
				      fprintf(fp, "%s", pPict->pName);								//停止中リール押下絵柄
				    fprintf(fp, "</font>");
				  fprintf(fp, "</td>");
				  /* 各条件装置について… */
				  fprintf(fp, "<td>");
				    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
				    	if(iHitCd) { fprintf(fp, " "); }
				    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[TBL_Slot_Spec_HkmCnt_Color[pStpCtl2->aHkmCnt[iHitCd]]]);
				    	  fprintf(fp, "%d", pStpCtl2->aHkmCnt[iHitCd]);						//引込駒数
				    	fprintf(fp, "</font>");
				    }
				  fprintf(fp, "</td>");
				fprintf(fp, "</tr>\n");
			}
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	3リール停止制御
 *--------------------------------------------------------------------------*/
/* 3リール停止制御データを作成する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildStpCtl3(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd, nHkmCnt, Priority;
	ST_Slot_StpCtl3* pStpCtl3;
	const ST_Slot_HitChk3* pHitChk3;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール1 */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止済リール2 */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 停止中リール */
		/* 停止済リール1の各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止済リール2の各停止位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				/* 停止中リールの各押下位置について… */
				for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
					pStpCtl3 = &pBuilder->TBL_StpCtl3[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
					/* 各条件装置について… */
					for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
						Priority = 0;
						pStpCtl3->aHkmCnt[iHitCd] = 5;	/* 停止不可としておく。 */
						/* 停止済リール1と停止済リール2の停止位置が、停止可能ならば… */
						if(pBuilder->TBL_StpCtl2[iOrder][aPictPos[iReel1]][aPictPos[iReel2]].aStpFlg[iHitCd]) {
							/* 最大引込駒数を取得する。 */
							nHkmCnt = GetHkmCntMax(pBuilder, iHitCd, iReel3);
							/* 各引込駒数について… */
							do {
								/* 3リール入賞判定データを取得する */
								switch(iReel3) {
								case 0: pHitChk3 = &pBuilder->TBL_HitChk3[Slot_Spec_GetPictPos_Hkm(aPictPos[0], nHkmCnt)][                         aPictPos[1]          ][                         aPictPos[2]          ]; break;
								case 1: pHitChk3 = &pBuilder->TBL_HitChk3[                         aPictPos[0]          ][Slot_Spec_GetPictPos_Hkm(aPictPos[1], nHkmCnt)][                         aPictPos[2]          ]; break;
								case 2: pHitChk3 = &pBuilder->TBL_HitChk3[                         aPictPos[0]          ][                         aPictPos[1]          ][Slot_Spec_GetPictPos_Hkm(aPictPos[2], nHkmCnt)]; break;
								default: DIE();
								}
								/* 停止可能ならば… */
								if(pHitChk3->aPriority[iHitCd][iReel1]) {
									/* 引込駒数を選択する:
									 * ・優先度が大きければ、選択する。
									 * ・優先度が同じならば、引込駒数が小さい方を選択する。即ち、ループの後方優先で上書きする。
									 */
									if(pHitChk3->aPriority[iHitCd][iReel1] >= Priority) {
										Priority = pHitChk3->aPriority[iHitCd][iReel1];
										pStpCtl3->aHkmCnt[iHitCd] = nHkmCnt;
									}
								}
							} while(--nHkmCnt >= 0);
							/* 全ての引込駒数で停止不可ならば、設計ミスである。 */
							if(pStpCtl3->aHkmCnt[iHitCd] == 5) { DIE(); }
							/* 実際に停止する停止位置に、停止可能をマークする。 */
							pBuilder->TBL_StpCtl3[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][Slot_Spec_GetPictPos_Hkm(aPictPos[iReel3], pStpCtl3->aHkmCnt[iHitCd])].aStpFlg[iHitCd] = 1;
						}
					}
				}
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 3リール停止制御データをHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintStpCtl3(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd;
	const ST_Slot_StpCtl3* pStpCtl3;
	const ST_Slot_Spec_Pict* pPict;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_StpCtl3", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 停止済リール1 */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 停止済リール2 */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 停止中リール */
		/* 停止済リール1の各停止位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 停止済リール2の各停止位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				/* 停止中リールの各押下位置について… */
				for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
					pStpCtl3 = &pBuilder->TBL_StpCtl3[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
					fprintf(fp, "<tr>");
					  fprintf(fp, "<td>");
					    fprintf(fp, "%2d", aPictPos[iReel1]);						//停止済リール1停止位置
					    fprintf(fp, " ");
					    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel1], iReel1)];
					    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
					      fprintf(fp, "%s", pPict->pName);							//停止済リール1停止絵柄
					    fprintf(fp, "</font>");
					    fprintf(fp, " ");
					    fprintf(fp, "%2d", aPictPos[iReel2]);						//停止済リール2停止位置
					    fprintf(fp, " ");
					    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel2], iReel2)];
					    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
					      fprintf(fp, "%s", pPict->pName);							//停止済リール2停止絵柄
					    fprintf(fp, "</font>");
					    fprintf(fp, " ");
					    fprintf(fp, "%2d", aPictPos[iReel3]);						//停止中リール停止位置
					    fprintf(fp, " ");
					    pPict = &pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[iReel3], iReel3)];
					    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pPict->iColor]);
					      fprintf(fp, "%s", pPict->pName);							//停止中リール停止絵柄
					    fprintf(fp, "</font>");
					  fprintf(fp, "</td>");
					  /* 各条件装置について… */
					  fprintf(fp, "<td>");
					    for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
					    	if(iHitCd) { fprintf(fp, " "); }
					    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[TBL_Slot_Spec_HkmCnt_Color[pStpCtl3->aHkmCnt[iHitCd]]]);
					    	  fprintf(fp, "%d", pStpCtl3->aHkmCnt[iHitCd]);					//引込駒数
					    	fprintf(fp, "</font>");
					    }
					  fprintf(fp, "</td>");
					fprintf(fp, "</tr>\n");
				}
			}
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	停止制御テスト
 *--------------------------------------------------------------------------*/
/* 停止テストを実行する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildStpTst(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd, iOrder1, iOrder2, iOrder3, aStopPos[3];
	ST_Slot_StpTst* pStpTst;
	const ST_Slot_StpCtl1* pStpCtl1;
	const ST_Slot_StpCtl2* pStpCtl2;
	const ST_Slot_StpCtl3* pStpCtl3;
	const ST_Slot_HitChk3* pHitChk3;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 第1停止リール */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 第2停止リール */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 第3停止リール */
		/* 第1停止リールの各押下位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 第2停止リールの各押下位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				/* 第3停止リールの各押下位置について… */
				for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
					pStpTst = &pBuilder->TBL_StpTst[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
					/* 各条件装置について… */
					for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
						/* 1リール停止制御データと2リール停止制御データと3リール停止制御データの押順番号を取得する。 */
						iOrder1 = iOrder % 3;	/* 0,1,2,0,1,2 */
						iOrder2 = iOrder;	/* 0,1,2,3,4,5 */
						iOrder3 = iOrder;	/* 0,1,2,3,4,5 */
						/* 第1停止リールの引込駒数を格納する。 */
						pStpCtl1 = &pBuilder->TBL_StpCtl1[iOrder1][aPictPos[iReel1]];
						pStpTst->aHkmCnt[iHitCd][iReel1] = pStpCtl1->aHkmCnt[iHitCd];
						if(pStpTst->aHkmCnt[iHitCd][iReel1] > 4) { DIE(); }
						aStopPos[iReel1] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel1], pStpTst->aHkmCnt[iHitCd][iReel1]);
						/* 第2停止リールの引込駒数を格納する。 */
						pStpCtl2 = &pBuilder->TBL_StpCtl2[iOrder2][aStopPos[iReel1]][aPictPos[iReel2]];
						pStpTst->aHkmCnt[iHitCd][iReel2] = pStpCtl2->aHkmCnt[iHitCd];
						if(pStpTst->aHkmCnt[iHitCd][iReel2] > 4) { DIE(); }
						aStopPos[iReel2] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel2], pStpTst->aHkmCnt[iHitCd][iReel2]);
						/* 第3停止リールの引込駒数を格納する。 */
						pStpCtl3 = &pBuilder->TBL_StpCtl3[iOrder3][aStopPos[iReel1]][aStopPos[iReel2]][aPictPos[iReel3]];
						pStpTst->aHkmCnt[iHitCd][iReel3] = pStpCtl3->aHkmCnt[iHitCd];
						if(pStpTst->aHkmCnt[iHitCd][iReel3] > 4) { DIE(); }
						aStopPos[iReel3] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel3], pStpTst->aHkmCnt[iHitCd][iReel3]);
						/* 3リール入賞判定データを取得する */
						pHitChk3 = &pBuilder->TBL_HitChk3[aStopPos[0]][aStopPos[1]][aStopPos[2]];
						/* 優先度を取得する。 */
						pStpTst->aPriority[iHitCd] = pHitChk3->aPriority[iHitCd][iReel1];
						if(!pStpTst->aPriority[iHitCd]) { DIE(); }
					}
				}
			}
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 停止テストの結果をHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintStpTst(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd;
	const ST_Slot_StpTst* pStpTst;
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		fprintf(fp, "<table>\n");
		fprintf(fp, "<caption>%s[%d]</caption>\n", "TBL_StpTst", iOrder);
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 第1停止リール */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 第2停止リール */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 第3停止リール */
		/* 第1停止リールの各押下位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 第2停止リールの各押下位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				/* 第3停止リールの各押下位置について… */
				for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
					pStpTst = &pBuilder->TBL_StpTst[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
					fprintf(fp, "<tr>");
					  fprintf(fp, "<td>%2d %2d %2d</td>", aPictPos[iReel1],					//第1停止リールの押下位置
					                                      aPictPos[iReel2],					//第2停止リールの押下位置
					                                      aPictPos[iReel3]);				//第3停止リールの押下位置
					  /* 各条件装置について… */
					  for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
					  	fprintf(fp, "<td>");
					  	  fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[0]);
					  	    fprintf(fp, "%d %d %d", pStpTst->aHkmCnt[iHitCd][iReel1],			//第1停止リールの引込駒数
					  	                            pStpTst->aHkmCnt[iHitCd][iReel2],			//第2停止リールの引込駒数
					  	                            pStpTst->aHkmCnt[iHitCd][iReel3]);			//第3停止リールの引込駒数
					  	  fprintf(fp, "</font>");
					  	  fprintf(fp, " ");
					  	  fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[1]);
					  	    fprintf(fp, "%d", pStpTst->aPriority[iHitCd]);				//優先度
					  	  fprintf(fp, "</font>");
					  	fprintf(fp, "</td>");
					  }
					fprintf(fp, "</tr>\n");
				}
			}
		}
		fprintf(fp, "</table>\n");
	}
}
/*--------------------------------------------------------------------------*
 *	絵柄組合せテスト
 *--------------------------------------------------------------------------*/
/* 絵柄組合せテストを実行する。
 * [in]
 *	pBuilder	スペックデータビルダ
 * [out]
 *	無し
 */
static void Slot_Spec_BuildCmbTst(ST_Slot_Spec_Builder* pBuilder) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int aPictPos[3], iOrder, iReel1, iReel2, iReel3, iHitCd, iHitFlg, iLine, nStpCntSum_Total, nStpCntSum_HitCd, aStopPos[3];
	ST_Slot_CmbTst* pCmbTst;
	const ST_Slot_StpTst* pStpTst;
	const ST_Slot_HitChk3* pHitChk3;
	const ST_Slot_Spec_HitFlg* pHitFlg;
	/* 左リールの各絵柄位置について… */
	for(aPictPos[0] = 0; aPictPos[0] < 21; aPictPos[0]++) {
		/* 中リールの各絵柄位置について… */
		for(aPictPos[1] = 0; aPictPos[1] < 21; aPictPos[1]++) {
			/* 右リールの各絵柄位置について… */
			for(aPictPos[2] = 0; aPictPos[2] < 21; aPictPos[2]++) {
				/* 絵柄組合せ番号を取得する。 */
				iHitFlg = Slot_Spec_FindHitFlg(pBuilder,
					Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[0], 0),
					Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[1], 1),
					Slot_GetReelPict(pInfo->TBL_Reel, aPictPos[2], 2));
				/* 絵柄組合せ個数を加算する。 */
				pCmbTst = &pBuilder->TBL_CmbTst[iHitFlg];
				pCmbTst->nCmbCnt++;
			}
		}
	}
	/* 各押順について… */
	for(iOrder = 0; iOrder < 6; iOrder++) {
		iReel1 = Slot_GetOrderReel(iOrder, 0); /* 第1停止リール */
		iReel2 = Slot_GetOrderReel(iOrder, 1); /* 第2停止リール */
		iReel3 = Slot_GetOrderReel(iOrder, 2); /* 第3停止リール */
		/* 第1停止リールの各押下位置について… */
		for(aPictPos[iReel1] = 0; aPictPos[iReel1] < 21; aPictPos[iReel1]++) {
			/* 第2停止リールの各押下位置について… */
			for(aPictPos[iReel2] = 0; aPictPos[iReel2] < 21; aPictPos[iReel2]++) {
				/* 第3停止リールの各押下位置について… */
				for(aPictPos[iReel3] = 0; aPictPos[iReel3] < 21; aPictPos[iReel3]++) {
					pStpTst = &pBuilder->TBL_StpTst[iOrder][aPictPos[iReel1]][aPictPos[iReel2]][aPictPos[iReel3]];
					/* 各条件装置について… */
					for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
						/* 第1停止リールの停止位置を取得する。 */
						if(pStpTst->aHkmCnt[iHitCd][iReel1] > 4) { DIE(); }
						aStopPos[iReel1] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel1], pStpTst->aHkmCnt[iHitCd][iReel1]);
						/* 第2停止リールの停止位置を取得する。 */
						if(pStpTst->aHkmCnt[iHitCd][iReel2] > 4) { DIE(); }
						aStopPos[iReel2] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel2], pStpTst->aHkmCnt[iHitCd][iReel2]);
						/* 第3停止リールの停止位置を取得する。 */
						if(pStpTst->aHkmCnt[iHitCd][iReel3] > 4) { DIE(); }
						aStopPos[iReel3] = Slot_Spec_GetPictPos_Hkm(aPictPos[iReel3], pStpTst->aHkmCnt[iHitCd][iReel3]);
						/* 3リール入賞判定データを取得する */
						pHitChk3 = &pBuilder->TBL_HitChk3[aStopPos[0]][aStopPos[1]][aStopPos[2]];
						/* 各ラインについて… */
						for(iLine = 0; iLine < 7; iLine++) {
							/* 絵柄組合せ表示回数を増やす。 */
							if((unsigned)pHitChk3->iHitFlg[iLine] >= (unsigned)pInfo->SIZE_HitFlg) { DIE(); }
							pCmbTst = &pBuilder->TBL_CmbTst[pHitChk3->iHitFlg[iLine]];
							pCmbTst->aStpCnt[iHitCd][iLine]++;
						}
					}
				}
			}
		}
	}
	/* 各絵柄組合せについて… */
	for(iHitFlg = 0; iHitFlg < pInfo->SIZE_HitFlg; iHitFlg++) {
		pCmbTst = &pBuilder->TBL_CmbTst[iHitFlg];	/* 絵柄組合せ個数 */
		pHitFlg = &pInfo->TBL_HitFlg[iHitFlg];		/* 絵柄組合せ表示回数 */
		nStpCntSum_Total = 0;				/* 絵柄組合せ表示回数の合計 */
		/* 各条件装置について… */
		for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
			nStpCntSum_HitCd = 0;			/* 絵柄組合せ表示回数の合計 */
			/* 各*有効*ラインについて… */
			for(iLine = 3/*有効ライン*/; iLine < 7; iLine++) {
				/* 絵柄組合せ表示回数の合計を加算する。 */
				nStpCntSum_HitCd += pCmbTst->aStpCnt[iHitCd][iLine];
				nStpCntSum_Total += pCmbTst->aStpCnt[iHitCd][iLine];
			}
			/* この条件装置で、この絵柄組合せが表示されるならば… */
			if(nStpCntSum_HitCd) {
				/* この条件装置に、この絵柄組合せが含まれるならば… */
				if((pHitFlg->aPriority[iHitCd][0/*左*/][0/*有効ライン*/] != 0) ||	//(-1)も含む
				   (pHitFlg->aPriority[iHitCd][1/*中*/][0/*有効ライン*/] != 0) ||	//(-1)も含む
				   (pHitFlg->aPriority[iHitCd][2/*右*/][0/*有効ライン*/] != 0)) {	//(-1)も含む
					pCmbTst->aResult[iHitCd] = 0;	/* 正常 */
				/* この条件装置に、この絵柄組合せが含まれないならば… */
				} else {
					pCmbTst->aResult[iHitCd] = 1;	/* エラー:条件装置に含まれないのに表示された */
					fprintf(stderr, "###Slot_BuildCmbTst: 条件装置番号%d,絵柄組合せ番号%dにて「エラー:条件装置に含まれないのに表示された」が発生しました。\n", iHitCd, iHitFlg);
				}
			/* この条件装置で、この絵柄組合せが表示されないならば… */
			} else {
				/* この条件装置に、この絵柄組合せが含まれるならば… */
				if((pHitFlg->aPriority[iHitCd][0/*左*/][0/*有効ライン*/] >= 1) ||	//(-1)は除く
				   (pHitFlg->aPriority[iHitCd][1/*中*/][0/*有効ライン*/] >= 1) ||	//(-1)は除く
				   (pHitFlg->aPriority[iHitCd][2/*右*/][0/*有効ライン*/] >= 1)) {	//(-1)は除く
					pCmbTst->aResult[iHitCd] = 2;	/* 警告:条件装置に含まれるのに表示されなかった */
					if(iHitCd != (pInfo->SIZE_HitCd-1)/*全小役*/) { /* 条件装置が全小役ならば、厳密には条件装置に絵柄組合せは定義されないので、警告を表示しない。表示しても構わないが、警告表示が増えすぎる。 */
						fprintf(stderr, "###Slot_BuildCmbTst: 条件装置番号%d,絵柄組合せ番号%dにて「警告:条件装置に含まれるのに表示されなかった」が発生しました。\n", iHitCd, iHitFlg);
					}
				/* この条件装置に、この絵柄組合せが含まれないならば… */
				} else {
					pCmbTst->aResult[iHitCd] = 0;	/* 正常 */
				}
			}
		}
		if(!nStpCntSum_Total && pHitFlg->nPay) {
			fprintf(stderr, "###Slot_BuildCmbTst: 絵柄組合せ番号%dにて「警告:この絵柄組合せは一度も表示されない」が発生しました。\n", iHitFlg);
		}
	}
}
/*--------------------------------------------------------------------------*/
/* 絵柄組合せテストの結果をHTML出力する。
 * [in]
 *	pBuilder	スペックデータビルダ
 *	fp		出力ストリーム
 * [out]
 *	無し
 */
static void Slot_Spec_PrintCmbTst(ST_Slot_Spec_Builder* pBuilder, FILE* fp) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int iHitFlg, iHitCd, iReel, iLine, aStpCntSum[7/*iLine*/], nCmbCntSum = 0;	/* 払出の有る小役の絵柄組合せ個数の合計 */
	const ST_Slot_CmbTst* pCmbTst;
	const ST_Slot_Spec_HitFlg* pHitFlg;
	fprintf(fp, "<table>\n");
	fprintf(fp, "<caption>%s</caption>\n", "TBL_CmbTst");
	/* 列ヘッダを表示する。 */
	fprintf(fp, "<tr>");
	  fprintf(fp, "<th></th>");
	  fprintf(fp, "<th></th>");
	  for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
	  	fprintf(fp, "<th>");
	  	  fprintf(fp, "%2d", iHitCd);											//条件装置番号
	  	  fprintf(fp, " ");
	  	  fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pInfo->TBL_HitCd[iHitCd].iColor]);
	  	    fprintf(fp, "%s",  pInfo->TBL_HitCd[iHitCd].pName);								//条件装置
	  	  fprintf(fp, "</font>");
	  	fprintf(fp, "</th>");
	  }
	  fprintf(fp, "<th align=center>合計</th>");
	fprintf(fp, "</tr>");
	/* 各絵柄組合せについて… */
	for(iHitFlg = 0; iHitFlg < pInfo->SIZE_HitFlg; iHitFlg++) {
		pCmbTst = &pBuilder->TBL_CmbTst[iHitFlg];
		pHitFlg = &pInfo->TBL_HitFlg[iHitFlg];
		fprintf(fp, "<tr>");
		  fprintf(fp, "<td>");
		    fprintf(fp, "%3d", iHitFlg);										//絵柄組合せ番号
		    for(iReel = 0; iReel < 3; iReel++) {
		    	fprintf(fp, " ");
		    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pInfo->TBL_Pict[pHitFlg->aPict[iReel]].iColor]);
		    	  fprintf(fp, "%s", pInfo->TBL_Pict[pHitFlg->aPict[iReel]].pName);					//絵柄組合せ
		    	fprintf(fp, "</font>");
		    }
		    fprintf(fp, " ");
		    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pHitFlg->nPay ? 7 : 0]);
		      fprintf(fp, "%2d", pHitFlg->nPay);									//払出枚数
		    fprintf(fp, "</font>");
		  fprintf(fp, "</td>");
		  /* 絵柄組合せ個数を表示する。 */
		  fprintf(fp, "<td>");
		    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pHitFlg->nPay ? 7 : 0]);
		      fprintf(fp, "%4d", pCmbTst->nCmbCnt);									//絵柄組合せ個数
		      if(pHitFlg->nPay) { nCmbCntSum += pCmbTst->nCmbCnt; }		/* 払出の有る小役の絵柄組合せ個数の合計を加算する。 */
		    fprintf(fp, "</font>");
		  fprintf(fp, "</td>");
		  /* 絵柄組合せ表示回数の合計をクリアする。 */
		  memset(aStpCntSum, 0, sizeof aStpCntSum);
		  /* 各条件装置について… */
		  for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
		  	fprintf(fp, "<td>");
		  	  fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[TBL_Slot_Spec_Result_Color[pCmbTst->aResult[iHitCd]]]);
		  	    fprintf(fp, "%s", TBL_Slot_Spec_Result_Mark[pCmbTst->aResult[iHitCd]]);				//検査結果
		  	  fprintf(fp, "</font>");
		  	  /* 各ラインについて… */
		  	  for(iLine = 0; iLine < 7; iLine++) {
		  	  	fprintf(fp, " ");
		  	  	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[pCmbTst->aStpCnt[iHitCd][iLine] ? 7 : 0]);
		  	  	  fprintf(fp, "%5d", pCmbTst->aStpCnt[iHitCd][iLine]);						//絵柄組合せ表示回数
		  	  	fprintf(fp, "</font>");
		  	  	aStpCntSum[iLine] += pCmbTst->aStpCnt[iHitCd][iLine];	/* 絵柄組合せ表示回数の合計を加算する。 */
		  	  }
		  	fprintf(fp, "</td>");
		  }
		  /* 絵柄組合せ表示回数の合計を表示する。 */
		  fprintf(fp, "<td>");
		    for(iLine = 0; iLine < 7; iLine++) {
		    	if(iLine) { fprintf(fp, " "); }
		    	fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[aStpCntSum[iLine] ? 7 : 0]);
		    	  fprintf(fp, "%7d", aStpCntSum[iLine]);								//絵柄組合せ表示回数の合計
		    	fprintf(fp, "</font>");
		    }
		  fprintf(fp, "</td>");
		fprintf(fp, "</tr>\n");
	}
	/* 絵柄組合せ個数の合計を表示する。
	 * ■「遊技機の認定及び型式の検定等に関する規則 別表第5 回胴式遊技機に係る技術上の規格(1)性能に関する規格」から要約:
	 * □BBの絵柄組合わせ
	 * ・BBの払出枚数が360枚以下(≒CT搭載有り)の場合、BBの絵柄組合せが、(21^3)/(2/1500)以下であること。即ち、最大12通り。		(当機種には関係無い)
	 * ・BBの払出枚数が360枚超過(≒CT搭載無し)の場合、BBの絵柄組合せが、(21^3)/(1/1500)以下であること。即ち、最大 6通り。		(当機種には関係無い)
	 * □RB&JACの絵柄組合わせ
	 * ・BB搭載有りの場合、RBの絵柄組合せが、(21^3)*(1/500)以下であること。即ち、最大18通り。					(当機種には関係無い)
	 * 　BB搭載無しの場合、RBの絵柄組合せが、(21^3)*(3/500)以下であること。即ち、最大55通り。					(当機種には関係無い)
	 * ・RBがJACIN有りの場合、JACINの絵柄組合せが、(21^3)/(10/500)以下であること。即ち、最大185通り。				(当機種には関係無い)
	 * □CTの絵柄組合わせ
	 * ・CTの絵柄組合せには、制限が無い。
	 * □小役の絵柄組合せ
	 * ・払出の有る小役の絵柄組合せが、(21^3)/(11/100)超過,かつ,(21^3)/(40/100)以下であること。即ち、最小1019,最大3704通り。	←この点をテストする
	 * ・リプレイの絵柄組合わせには、制限が無い。
	 */
	fprintf(fp, "<tr>");
	  fprintf(fp, "<td align=center>1019≦合計≦3704</td>");
	  fprintf(fp, "<td>");
	    fprintf(fp, "<font color=%s>", TBL_Slot_Spec_Color[((nCmbCntSum >= 1019) && (nCmbCntSum <= 3704)) ? 7 : 1]);
	      fprintf(fp, "%4d", nCmbCntSum);											//払出の有る小役の絵柄組合せ個数の合計
	    fprintf(fp, "</font>");
	  fprintf(fp, "</td>");
	  fprintf(fp, "<td colspan=%d></td>", pInfo->SIZE_HitCd+1);
	fprintf(fp, "</tr>\n");
	fprintf(fp, "</table>\n");
}
/*--------------------------------------------------------------------------*
 *	データ作成
 *--------------------------------------------------------------------------*/
static void Slot_Spec_BuildData(ST_Slot_Spec_Builder* pBuilder) {
	static const struct {
		const char* HtmlFileName;
		void (*pfnBuild)(ST_Slot_Spec_Builder* pBuilder);
		void (*pfnPrint)(ST_Slot_Spec_Builder* pBuilder, FILE* fp);
	} tbl[]={
		/* データ作成準備 */
		{"HitChk3.html",&Slot_Spec_BuildHitChk3,&Slot_Spec_PrintHitChk3},	//3リール入賞判定
		{"HitChk2.html",&Slot_Spec_BuildHitChk2,&Slot_Spec_PrintHitChk2},	//2リール入賞予測
		{"HitChk1.html",&Slot_Spec_BuildHitChk1,&Slot_Spec_PrintHitChk1},	//1リール入賞予測
		/* データ作成 */
		{"StpCtl1.html",&Slot_Spec_BuildStpCtl1,&Slot_Spec_PrintStpCtl1},	//1リール停止制御
		{"StpCtl2.html",&Slot_Spec_BuildStpCtl2,&Slot_Spec_PrintStpCtl2},	//2リール停止制御
		{"StpCtl3.html",&Slot_Spec_BuildStpCtl3,&Slot_Spec_PrintStpCtl3},	//3リール停止制御
		/* テスト */
		{"StpTst.html",&Slot_Spec_BuildStpTst,&Slot_Spec_PrintStpTst},		//停止制御テスト
		{"CmbTst.html",&Slot_Spec_BuildCmbTst,&Slot_Spec_PrintCmbTst},		//絵柄組合せテスト
	};
	FILE* fp;
	int i;
	for(i = 0; i < ARRAY_SIZE(tbl); i++) {
		fp = fopen(tbl[i].HtmlFileName, "w");
		if(!fp) { DIE(); }
		/* データ作成準備・データ作成・テスト */
		(*tbl[i].pfnBuild)(pBuilder);
		/* HTMLヘッダ出力 */
		fprintf(fp, "<html>\n");
		fprintf(fp, "<head>\n");
		fprintf(fp, "  <style type=\"text/css\">\n");
		fprintf(fp, "    *{font-family:\"MS Mincho\";font-size:12px}\n");
		fprintf(fp, "    *{white-space:pre}\n");
		fprintf(fp, "    body{color:white;background-color:black}\n");
		fprintf(fp, "    table,caption,th,td{border-width:1px;border-style:solid;border-collapse:collapse}\n");
		fprintf(fp, "  </style>\n");
		fprintf(fp, "</head>\n");
		fprintf(fp, "<body>\n");
		/* HTMLボディ出力 */
		(*tbl[i].pfnPrint)(pBuilder, fp);
		/* HTMLフッタ出力 */
		fprintf(fp, "</body>\n");
		fprintf(fp, "</html>\n");
		fclose(fp);
	}
	/* HTMLインデクスページ出力 */
	fp = fopen("index.html", "w");
	if(!fp) { DIE(); }
	fprintf(fp, "<html>\n");
	fprintf(fp, "<body>\n");
	fprintf(fp, "<table>\n");
	for(i = 0; i < ARRAY_SIZE(tbl); i++) {
		struct stat st;
		if(stat(tbl[i].HtmlFileName, &st)) { DIE(); }
		fprintf(fp, "<tr><td><a href=\"%s\">%s</td><td align=right>%d</td></tr>\n", tbl[i].HtmlFileName, tbl[i].HtmlFileName, (int)st.st_size);
	}
	fprintf(fp, "</table>\n");
	fprintf(fp, "</body>\n");
	fprintf(fp, "</html>\n");
	fclose(fp);
}
/*--------------------------------------------------------------------------*
 *	データ出力
 *--------------------------------------------------------------------------*/
/* 絵柄 */
static void Slot_Spec_PrintData_Pict(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	const ST_Slot_Spec_Pict* pPict;
	int iPict;
	for(iPict = 0; iPict < pInfo->SIZE_Pict; iPict++) {
		pPict = &pInfo->TBL_Pict[iPict];
		fprintf(fpH, "#define Pict_%s %2d//%s\n",
			pPict->pSym, iPict, pPict->pName);
	}
	fprintf(fpH, "#define Pict_Size %d\n", pInfo->SIZE_Pict);
	//
	fprintf(fpC, "#ifdef  USE_NAME\n");
	fprintf(fpH, "#ifdef  USE_NAME\n");
	fprintf(fpC, "const char* const TBL_Pict_Name[Pict_Size]={\n");
	for(iPict = 0; iPict < pInfo->SIZE_Pict; iPict++) {
		pPict = &pInfo->TBL_Pict[iPict];
		fprintf(fpC, "\"%s\",//%2d %s\n",
			pPict->pName,
			iPict, pPict->pSym);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "extern const char* const TBL_Pict_Name[Pict_Size];\n");
	fprintf(fpC, "#endif//USE_NAME\n");
	fprintf(fpH, "#endif//USE_NAME\n");
}
/*--------------------------------------------------------------------------*/
/* リール配列 */
static void Slot_Spec_PrintData_Reel(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	int iPictPos;
	fprintf(fpH, "#define Reel_CT %d\n", pInfo->CT_Reel);
	//
	fprintf(fpC, "const unsigned short TBL_Reel[21]={\n");
	for(iPictPos = 0; iPictPos < 21; iPictPos++) {
		fprintf(fpC, "%2d<<0|%2d<<4|%2d<<8,//%2d %s %s %s\n",
			Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 0),
			Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 1),
			Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 2),
			iPictPos,
			pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 0)].pName,
			pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 1)].pName,
			pInfo->TBL_Pict[Slot_GetReelPict(pInfo->TBL_Reel, iPictPos, 2)].pName);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "extern const unsigned short TBL_Reel[21];\n");
}
/*--------------------------------------------------------------------------*/
/* 条件装置 */
static void Slot_Spec_PrintData_HitCd(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	const ST_Slot_Spec_HitCd* pHitCd;
	int iHitCd, iRT;
	fprintf(fpC, "const unsigned short TBL_HitCd[HitCd_Size][%d][6]={\n", ARRAY_SIZE(pInfo->TBL_HitCd->aWeight));
	for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
		pHitCd = &pInfo->TBL_HitCd[iHitCd];
		fprintf(fpH, "#define HitCd_%s %2d//%s\n",
			pHitCd->pSym, iHitCd, pHitCd->pName);
		fprintf(fpC, "{");
		for(iRT = 0; iRT < ARRAY_SIZE(pInfo->TBL_HitCd->aWeight); iRT++) {
			if(iRT) { fprintf(fpC, ","); }
			fprintf(fpC, "{%5d,%5d,%5d,%5d,%5d,%5d}",
				pHitCd->aWeight[iRT][0], pHitCd->aWeight[iRT][1], pHitCd->aWeight[iRT][2], pHitCd->aWeight[iRT][3], pHitCd->aWeight[iRT][4], pHitCd->aWeight[iRT][5]);
		}
		fprintf(fpC, "},//%2d %s %s\n",
			iHitCd, pHitCd->pSym, pHitCd->pName);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "#define HitCd_Size %d\n", pInfo->SIZE_HitCd);
	fprintf(fpH, "extern const unsigned short TBL_HitCd[HitCd_Size][%d][6];\n", ARRAY_SIZE(pInfo->TBL_HitCd->aWeight));
	//
	fprintf(fpC, "#ifdef  USE_NAME\n");
	fprintf(fpH, "#ifdef  USE_NAME\n");
	fprintf(fpC, "const char* const TBL_HitCd_Name[HitCd_Size]={\n");
	for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
		pHitCd = &pInfo->TBL_HitCd[iHitCd];
		fprintf(fpC, "\"%s\",//%2d %s\n",
			pHitCd->pName,
			iHitCd, pHitCd->pSym);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "extern const char* const TBL_HitCd_Name[HitCd_Size];\n");
	fprintf(fpC, "#endif//USE_NAME\n");
	fprintf(fpH, "#endif//USE_NAME\n");
}
/*--------------------------------------------------------------------------*/
/* 絵柄組合せ */
static void Slot_Spec_PrintData_HitFlg(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	const ST_Slot_Spec_HitFlg* pHitFlg;
	int iHitFlg, nNameLen = strlen(pInfo->TBL_Pict[0].pName);
	fprintf(fpC, "const unsigned short TBL_HitFlg[HitFlg_Size]={\n");
	for(iHitFlg = 0; iHitFlg < pInfo->SIZE_HitFlg; iHitFlg++) {
		pHitFlg = &pInfo->TBL_HitFlg[iHitFlg];
		fprintf(fpH, "#define HitFlg_%s %3d//%s\n",
			pHitFlg->pSym, iHitFlg, pHitFlg->pName);
		fprintf(fpC, "%2d|%2d<<4|%2d<<8|%2d<<12,//%2d %s %s %-*s %-*s %-*s\n",
			pHitFlg->aPict[0],pHitFlg->aPict[1],pHitFlg->aPict[2],pHitFlg->nPay,
			iHitFlg, pHitFlg->pSym, pHitFlg->pName,
			nNameLen,pHitFlg->aPict[0]?pInfo->TBL_Pict[pHitFlg->aPict[0]].pName:"-",
			nNameLen,pHitFlg->aPict[1]?pInfo->TBL_Pict[pHitFlg->aPict[1]].pName:"-",
			nNameLen,pHitFlg->aPict[2]?pInfo->TBL_Pict[pHitFlg->aPict[2]].pName:"-");
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "#define HitFlg_Size %d\n", pInfo->SIZE_HitFlg);
	fprintf(fpH, "extern const unsigned short TBL_HitFlg[HitFlg_Size];\n");
	//
	fprintf(fpC, "#ifdef  USE_NAME\n");
	fprintf(fpH, "#ifdef  USE_NAME\n");
	fprintf(fpC, "const char* const TBL_HitFlg_Name[HitFlg_Size]={\n");
	for(iHitFlg = 0; iHitFlg < pInfo->SIZE_HitFlg; iHitFlg++) {
		pHitFlg = &pInfo->TBL_HitFlg[iHitFlg];
		fprintf(fpC, "\"%s\",//%3d %s\n",
			pHitFlg->pName,
			iHitFlg, pHitFlg->pSym);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "extern const char* const TBL_HitFlg_Name[HitFlg_Size];\n");
	fprintf(fpC, "#endif//USE_NAME\n");
	fprintf(fpH, "#endif//USE_NAME\n");
}
/*--------------------------------------------------------------------------*/
/* 条件装置⇒絵柄組合せ */
static void Slot_Spec_PrintData_HitCd_HitFlg(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	const ST_Slot_Spec_HitCd* pHitCd;
	int iHitCd, iHitFlg, x;
	fprintf(fpC, "const unsigned char TBL_HitCd_HitFlg[HitCd_Size][(HitFlg_Size+7)/8]={\n");
	for(iHitCd = 0; iHitCd < pInfo->SIZE_HitCd; iHitCd++) {
		pHitCd = &pInfo->TBL_HitCd[iHitCd];
		x = 0;
		fprintf(fpC, "{");
		for(iHitFlg = 0; iHitFlg < pInfo->SIZE_HitFlg; iHitFlg++) {
			if((pInfo->TBL_HitFlg[iHitFlg].aPriority[iHitCd][0/*左*/][0/*有効ライン*/] != 0) ||	//(-1)も含む
			   (pInfo->TBL_HitFlg[iHitFlg].aPriority[iHitCd][1/*中*/][0/*有効ライン*/] != 0) ||	//(-1)も含む
			   (pInfo->TBL_HitFlg[iHitFlg].aPriority[iHitCd][2/*右*/][0/*有効ライン*/] != 0)) {	//(-1)も含む
				x |= (1<<(iHitFlg&7));
			}
			if(((iHitFlg&7) == 7) || (iHitFlg == (pInfo->SIZE_HitFlg-1))) {
				fprintf(fpC, "%3d", x);
				x = 0;
				if(iHitFlg != (pInfo->SIZE_HitFlg-1)) { fprintf(fpC, ","); }
			}
		}
		fprintf(fpC, "},//%2d %s %s\n",
			iHitCd, pHitCd->pSym, pHitCd->pName);
	}
	fprintf(fpC, "};\n");
	fprintf(fpH, "extern const unsigned char TBL_HitCd_HitFlg[HitCd_Size][(HitFlg_Size+7)/8];\n");
}
/*--------------------------------------------------------------------------*/
/* 停止制御 */
static int Slot_Spec_PrintData_fnGetStpCtl1(void* pParam, int iHitCd, int iReel1, int iPushPos1) {
	ST_Slot_Spec_Builder* pBuilder = pParam;
	const ST_Slot_StpCtl1* pStpCtl1;
	int iOrder = iReel1;
	if((unsigned)iOrder    >= ARRAY_SIZE(pBuilder->TBL_StpCtl1   )) { DIE(); }
	if((unsigned)iPushPos1 >= ARRAY_SIZE(pBuilder->TBL_StpCtl1[0])) { DIE(); }
	pStpCtl1 = &pBuilder->TBL_StpCtl1[iOrder][iPushPos1];
	if((unsigned)pStpCtl1->aHkmCnt[iHitCd] > 4) { DIE(); }
	return pStpCtl1->aHkmCnt[iHitCd];
}
static int Slot_Spec_PrintData_fnGetStpCtl2(void* pParam, int iHitCd, int iReel1, int iReel2, int iStopPos1, int iPushPos2) {
	ST_Slot_Spec_Builder* pBuilder = pParam;
	const ST_Slot_StpCtl2* pStpCtl2;
	int iOrder = Slot_FindOrder(iReel1, iReel2);
	if((unsigned)iOrder    >= ARRAY_SIZE(pBuilder->TBL_StpCtl2      )) { DIE(); }
	if((unsigned)iStopPos1 >= ARRAY_SIZE(pBuilder->TBL_StpCtl2[0]   )) { DIE(); }
	if((unsigned)iPushPos2 >= ARRAY_SIZE(pBuilder->TBL_StpCtl2[0][0])) { DIE(); }
	pStpCtl2 = &pBuilder->TBL_StpCtl2[iOrder][iStopPos1][iPushPos2];
	if((unsigned)pStpCtl2->aHkmCnt[iHitCd] > 4) { DIE(); }
	return pStpCtl2->aHkmCnt[iHitCd];
}
static int Slot_Spec_PrintData_fnGetStpCtl3(void* pParam, int iHitCd, int iReel1, int iReel2, int iReel3, int iStopPos1, int iStopPos2, int iPushPos3) {
	ST_Slot_Spec_Builder* pBuilder = pParam;
	const ST_Slot_StpCtl3* pStpCtl3;
	int iOrder = Slot_FindOrder(iReel1, iReel2);
	if((unsigned)iOrder    >= ARRAY_SIZE(pBuilder->TBL_StpCtl3         )) { DIE(); }
	if((unsigned)iStopPos1 >= ARRAY_SIZE(pBuilder->TBL_StpCtl3[0]      )) { DIE(); }
	if((unsigned)iStopPos2 >= ARRAY_SIZE(pBuilder->TBL_StpCtl3[0][0]   )) { DIE(); }
	if((unsigned)iPushPos3 >= ARRAY_SIZE(pBuilder->TBL_StpCtl3[0][0][0])) { DIE(); }
	pStpCtl3 = &pBuilder->TBL_StpCtl3[iOrder][iStopPos1][iStopPos2][iPushPos3];
	if((unsigned)pStpCtl3->aHkmCnt[iHitCd] > 4) { DIE(); }
	return pStpCtl3->aHkmCnt[iHitCd];
}
static void Slot_Spec_PrintData_StpCtl(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC) {
	const ST_Slot_SpecInfo* pInfo = pBuilder->pInfo;
	ST_Slot_StpCtl_BuilderInfo stBuilderInfo;
	ST_Slot_StpCtl* pStpCtl;
	/* 停止制御データビルダ情報を設定する。 */
	memset(&stBuilderInfo, 0, sizeof stBuilderInfo);
	stBuilderInfo.HitCd_Size   = pInfo->SIZE_HitCd;
	stBuilderInfo.pParam       = pBuilder;
	stBuilderInfo.fnGetStpCtl1 = &Slot_Spec_PrintData_fnGetStpCtl1;
	stBuilderInfo.fnGetStpCtl2 = &Slot_Spec_PrintData_fnGetStpCtl2;
	stBuilderInfo.fnGetStpCtl3 = &Slot_Spec_PrintData_fnGetStpCtl3;
	/* 停止制御データを作成する。 */
	pStpCtl = Slot_BuildStpCtl(&stBuilderInfo);
	/* 停止制御データを出力する。 */
	Slot_PrintStpCtl(pStpCtl, fpH, fpC);
	/* 停止制御データを開放する。 */
	free(pStpCtl);
}
/*--------------------------------------------------------------------------*/
static void Slot_Spec_PrintData(ST_Slot_Spec_Builder* pBuilder) {
	static const struct {
		void (*pfnPrint)(ST_Slot_Spec_Builder* pBuilder, FILE* fpH, FILE* fpC);
	} tbl[]={
		{&Slot_Spec_PrintData_Pict},		//絵柄
		{&Slot_Spec_PrintData_Reel},		//リール配列
		{&Slot_Spec_PrintData_HitCd},		//条件装置
		{&Slot_Spec_PrintData_HitFlg},		//絵柄組合せ
		{&Slot_Spec_PrintData_HitCd_HitFlg},	//条件装置⇒絵柄組合せ
		{&Slot_Spec_PrintData_StpCtl},		//停止制御
	};
	FILE *fpH, *fpC;
	int i;
	if(!(fpH = fopen("SlotData.h", "w"))) { DIE(); }
	if(!(fpC = fopen("SlotData.c", "w"))) { DIE(); }
	fprintf(fpC, "#include <clip.h>\n");
	fprintf(fpC, "#include \"SlotData.h\"\n");
	fprintf(fpH, "#ifndef __SLOTDATA_H__\n");
	fprintf(fpH, "#define __SLOTDATA_H__\n");
	for(i = 0; i < ARRAY_SIZE(tbl); i++) {
		(*tbl[i].pfnPrint)(pBuilder, fpH, fpC);
	}
	fprintf(fpH, "#endif//__SLOTDATA_H__\n");
	fclose(fpH);
	fclose(fpC);
}
/*--------------------------------------------------------------------------*
 *	グローバル関数
 *--------------------------------------------------------------------------*/
void Slot_MakeSpec(const ST_Slot_SpecInfo* pInfo) {
	ST_Slot_Spec_Builder* pBuilder;
	/* スペック情報を検査する。 */
	if((pInfo->SIZE_Pict   < 1) || (pInfo->SIZE_Pict   >  11)) { DIE(); }	//Any+10絵柄まで
	if(                   (unsigned)pInfo->CT_Reel     >   2 ) { DIE(); }
	if((pInfo->SIZE_HitCd  < 1) || (pInfo->SIZE_HitCd  >  64)) { DIE(); }
	if((pInfo->SIZE_HitFlg < 1) || (pInfo->SIZE_HitFlg > 256)) { DIE(); }
	/* スペックデータビルダのメモリを確保する。 */
	pBuilder = calloc(1, sizeof(ST_Slot_Spec_Builder));
	if(!pBuilder) { DIE(); }
	/* スペック情報を格納する。 */
	pBuilder->pInfo = pInfo;
	/* データ作成 */
	Slot_Spec_BuildData(pBuilder);
	/* データ出力 */
	Slot_Spec_PrintData(pBuilder);
	/* スペックデータビルダのメモリを開放する。 */
	free(pBuilder);
}
#endif//WIN32	//PC上でスペックデータを作成する時に使用します。P/ECE上では使用しません。
