
//typedef struct {
//	u8	Flg;
//	u8	DisCon;
//	u8	World;
//	u8	Stage;
//	u8	Level;
//}SaveReadyDef;
//extern SaveReadyDef	SaveReady[2];

//**************************************************************
//
//			Ready_main.c
//
//**************************************************************
#include	<Agb.h>
#include	"../define.h"
#include	"../m4aLib.h"

#define		GLOBAL_VALUE_DEFINE
#include	"Ready.h"
#undef		GLOBAL_VALUE_DEFINE

#include	"../global.h"
#include	"../sub.h"
#include	"../data.h"

#include	"title2.h"

#include	"../gmap/gmap.h"
#include	"../gmap/save_data.h"

//--------------------------------------------------------------
//		定義
//--------------------------------------------------------------
#define		ON	1
#define		OFF	0
#define		CANCEL	0x80

#define		ST_EVB_ON	0		//透明度
#define		ST_EVB_OFF	10		//透明度
#define		ST_EVY		8		//画面の明るさ (明るい→0)

#define		SCRVRAM3	(BG_VRAM+0xc000+0x800*6)	//SCR-ADR
#define		SCRVRAM2	(BG_VRAM+0xc000+0x800*4)	//SCR-ADR
#define		SCRVRAM1	(BG_VRAM+0xc000+0x800*2)	//SCR-ADR
#define		SCRVRAM0	(BG_VRAM+0xc000)			//SCR-ADR

#define		ReadyTimer	usFadeTimer

//-----------------------------
enum {
	INIT, FIN, MAIN, TYUDAN, WAIT_GAME, WAIT_TITLE, FOUT, READY,
	FIN2, KOWARETA, FOUT2,
};
//-----------------------------
enum Ready_Main {				//Ready.SelM
	SELECT_A, SELECT_B, DELETE,
};
//-----------------------------
enum Ready_Change {				//Ready.SelS
	NAME_POS, LEVEL_POS, DELETE_POS, OK_POS
};


//-------------------------------------
//	OBJ-WORK
//-------------------------------------
enum ObjNum
{
	OCUR, OWIN, OTYUA, OTYUB, OKAKO, ODEL,
	OBJNUM_MAX,
};
//-----------------------------
enum ObjAnmKind {
	ANON,
	ACUR_SEL, ACUR_SET,
	ACUR_STP1,ACUR_STP2,				//カーソル
	A_04,								//未使用
	ALEV_Ne,  ALEV_He,					//
	ALEV_Nj,  ALEV_Hj,					//
	ALEV_PNe, ALEV_PHe, ALEV_PSe,		//
	ALEV_PNj, ALEV_PHj, ALEV_PSj,		//
	ADEL_Ne,  ADEL_Ye,					//
	ADEL_Nj,  ADEL_Yj,					//
	AARROW_D, AARROW_U,					//矢印 △ ▽

	ATYU_2j,ATYU_2e,					//中断SAVE-MARK
	ATYU_1j,ATYU_1e,					//

	AMDEL_STPe,AMDEL_SELe,				//DELETE-MAIN-POSI-OBJ(US)
	AKAKO_RED,AKAKO_BLU,				//
	ABOM_STP,ABOM_SEL,ABOM_CLEAR,		//
	ACWN_SEL,ACWN_SET,ACWN_STP,			//PERFECT-CROWN
	AMDEL_STPj,AMDEL_SELj,				//DELETE-MAIN-POSI-OBJ(JP)

	ATYU_0j,ATYU_0e,					//中断SAVE-MARK（非選択）

	AKOWARE_Aj,AKOWARE_Ae,				//SAVE破壊MESS(A)
	AKOWARE_Bj,AKOWARE_Be,				//SAVE破壊MESS(B)

	ANMNUM_MAX,
};

//-----------------------------
//-----------------------------
typedef struct {
	u32	uiObjAddr;
	u8	ucTimer;
}AnmDef;
//--------------------------------------------------------------
//		外部DATA
//--------------------------------------------------------------
#include	"Csdobj1_LZ.c"
#include	"Osdobj1.c"
#include	"Ckowareta1_LZ.c"
#include	"Ckowareta2_LZ.c"
#include	"Ckowareta3_LZ.c"

#include	"Psdobj1.c"
#include	"Pselectdata.c"

//--------------------------------------------------------------
//		外部
//--------------------------------------------------------------
extern const GateDef *WarioGateData_Tbl[];

extern int MapLH_kaitou(u8 mode, u8 *ptr, u8 *pexram);

extern void FadeColor_DMA(void);			//SW=Fade.ucDMAf

//-----
extern const u8 selectdata_CharLZ[];
extern const u8 Scr_selectdata[];
extern const u8 Scr_selectdata2[];
extern const u8 Scr_selectdata3[];

//-----SRAM関連-----
extern void	GameReady_INIT_Read(void);			//SRAM to EX_WRAM(image)
extern void EXimage_to_Work_2Mode(void);
extern void EXimage_Clear_Work_2Mode(void);

//-----STAGE-NAME-----	from安部
extern const u8		font_Char[0x4000];	//shop
// メッセージ表示用
extern const int	smap_Mes_j[6][6];	//select
extern const int	smap_Mes_e[6][6];	//select
// メッセージ表示用
extern const int	dmap_Mes_j[6];
extern const int	dmap_Mes_e[6];

//--------------------------------------------------------------
//--------------------------------------------------------------
#define NAME_Y		0x18
#define NAME_X		0x18

#define LEV_N_Y		-0x08
#define LEV_H_Y		(LEV_N_Y+0x10)
#define LEV_S_Y		(LEV_N_Y+0x20)
#define LEV_X		-0x1c

#define DELwin_Y	0x14
#define DELn_X		-0x2c
#define DELy_X		(DELn_X+0x30)

#define OK_Y		NAME_Y
#define OK_X		NAME_X

#define CUR_DEL_Y	0xa0
#define CUR_DEL_X	0x0c

//---------------------------------------------
////Ready.SelS
//	NAME_POS, LEVEL_POS, DELETE_POS, OK_POS
//---------------------------------------------
static const s8 Ready_CurPosi_NoData[] = {
	0,	NAME_Y		,NAME_Y+0x48	,NAME_X,		//0		0:NAME
	1,	LEV_N_Y		,0				,LEV_X,			//1		1:LEV
	1,	LEV_H_Y		,0				,LEV_X,
	1,	LEV_S_Y		,0				,LEV_X,
	0,	OK_Y		,OK_Y+0x48		,OK_X,			//4		3:OK
	0,	0			,0				,0,				//5
};
static const s8 Ready_CurPosi_Save[] = {
	0,	NAME_Y		,NAME_Y+0x48	,NAME_X,		//0		0:NAME
	1,	DELwin_Y	,0				,DELn_X,		//1		2:DEL
	1,	DELwin_Y	,0				,DELy_X,
	0,	OK_Y		,OK_Y+0x48		,OK_X,			//3		3:OK
	0,	0			,0				,0,				//4
	0,	0			,0				,0,
};

static const s8 *Ready_CurPosi_Tbl[]= {
	Ready_CurPosi_NoData,
	Ready_CurPosi_Save,
};

//---------------------------------------------
//---------------------------------------------
static const u8 Ready_CurPosi_Step_NoData[]= {
	0*4,1*4,0*4,4*4,5*4
};
static const u8 Ready_CurPosi_Step_Save[]= {
	0*4,0*4,1*4,3*4,4*4
};

static const u8 *Ready_CurPosi_Step_Tbl[]= {
	Ready_CurPosi_Step_NoData,
	Ready_CurPosi_Step_Save,
};

#undef NAME_Y
#undef NAME_X
#undef LEV_N_Y
#undef LEV_H_Y
#undef LEV_S_Y
#undef LEV_X
#undef DELwin_Y
#undef DELn_X
#undef DELy_X
#undef OK_Y
#undef OK_X

//--------------------------------------
//--------------------------------------
enum ObjAnmCur {				//CURSOL-OBJ ANM指定用番号
	ASCUR_SELECT, ASCUR_SET, ASCUR_STOP,
};
//--------------
static const u8 CurAnm_Tbl[2][3]= {		//	[ucPerfect][ObjAnmCur]
	{ACUR_SEL, ACUR_SET ,ACUR_STP2},	//CURSOL
	{ACWN_SEL, ACWN_SET ,ACWN_STP},		//PERFECT-CROWN
};
//--------------------------------------
//--------------------------------------
static const u8 AOBJ_Tyudan_Tbl[2][3]= {
	{ATYU_0e,ATYU_1e,ATYU_2e},
	{ATYU_0j,ATYU_1j,ATYU_2j},
};
//--------------------------------------
//--------------------------------------
enum ObjAnmDelete {				//DELETE-OBJ ANM指定用番号
	AMDEL_NO, AMDEL_YES,
};
//--------------
static const u8 AOBJ_Deleten_Tbl[2][2]= {
	{AMDEL_STPe,AMDEL_SELe},
	{AMDEL_STPj,AMDEL_SELj},
};
//--------------------------------------
//--------------------------------------
static const u8 AOBJ_Kowareta_Tbl[2][2]= {
	{AKOWARE_Ae, AKOWARE_Be},
	{AKOWARE_Aj, AKOWARE_Bj},
};

//--------------------------------------------------------------
//		変数
//--------------------------------------------------------------

//-----------------------------
typedef struct {
	u8	SelM;
	u8	SelS;
	u8	SelP;
	u8	Set;
	u8	Start;
	u8	Delete;
}ReadyDef;
ReadyDef Ready;

//-----------------------------
typedef struct
{
	s16	sYpos;
	s16	sXpos;
	u32	iAnmAddr;
	u8	ucAnmTimer;
	u8	ucAnmPat;
	u8	uckind;
}AnmPartsDef;
AnmPartsDef OReady[OBJNUM_MAX];

//--------------------------------------------------------------
//		Local関数
//--------------------------------------------------------------

//---INIT---
static int ReadyInit(void);

//---OBJ---
static void ReadyObjCreate(void);
static void ReadyObj_Win1Set(void);		//選択OBJ-WINDOW SET
static void ReadyObj_CurSet(void);		//カーソルＯＢＪの位置決め
static void ReadyObj_KakoSet(void);		//
static void ReadyObj_DeleteSet(void);
static void ReadyObj_Tyudan_Init(void);
static void ReadyObj_Tyudan_Set(u8 anm);
static void ReadyObj_Tyudan_PickUpSet(void);

//---FADE---
static int ReadyMain_Fade_IN(void);
static int ReadyMain_Fade_OUT(void);

//---MAIN KEY 判定---
static int ReadyKey(void);				//<MSEQ>を移動するKEY判定

//---MAIN SELECT ---
static void ReadyMain_Save_Select(void);
static void ReadyMain_Select_Set(void);
static void ReadyMain_Change_Select(void);
static void	ReadyMain_Change_Delete(void);

static void ReadyMain_PickUp_SetReady(void);

static void ReadySet_SelectDef(u8 num);
static void ReadySet_SelectKey(u8 num, u8 mode);	//

static void Ready_OBJ_CurSelectSet(void);			//決定  (OBJ)CUR Anime :SE
static void Ready_OBJ_BomSelectSet(void);

static void Ready_INIT_Scr_BgPut(void);
static void Ready_INIT_tmsc_BgPut(void);
static void Ready_INIT_totalcoin_BgPut(u8 num, u8 cls);		//num:ucSaveNum , cls=1:消去
static void Ready_INIT_cd_BgPut(u8 num, u8 cls);			//num:ucSaveNum , cls=1:消去
static void Ready_INIT_boss_BgPut(u8 num, u8 cls);			//num:ucSaveNum , cls=1:消去
static void Ready_INIT_LocalWork_Set(u8 num);
static void Ready_INIT_StageName_BgPut(u8 num);

static void Ready_CHANGE_Level_BgPut(u8 num);

static void	Ready_INIT_RomDate_BgPut(void);


//---KOWARETA---
static int KowaretaKey(void);


//--------------------------------------------------------------
//		別ファイルＰＲＧ
//--------------------------------------------------------------
#include	"../BinDate.c"
#include	"Ready_Init.c"
#include	"Ready_Load.c"


//==============================================================
//		メインルーチン
//==============================================================
int GameReady(void)
{
int	a;

	a = 0;
	ReadyTimer++;

	switch(sGameSeq)
	{
		//初期化
		case INIT:
			sGameSeq = ReadyInit() ? FIN2 : FIN ;
			break;

		//FADE IN
		case FIN:
		case FIN2:
			FadeColor_DMA();			//SW=Fade.ucDMAf
			if(ReadyMain_Fade_IN())	{
				sGameSeq++;
			}
			break;

		//SAVE選択
		case MAIN:
			if(cNextFlg = ReadyKey()) {
				//-----NEW GAME FLGを落とす----
				SaveReady[0].Flg &= 0x7f;	//
				SaveReady[1].Flg &= 0x7f;	//
				ReadyTimer = 0;

				//-----
				if(cNextFlg == 2) {
					m4aMPlayFadeOut(mplay_table[Song_Player(M_BGM_TITLE)].ma, M4A_FADEOUT_23);		//BGM-FADEOUT
					OReady[OCUR].uckind = CurAnm_Tbl[ucPerfect][ASCUR_STOP];
					OReady[OCUR].ucAnmTimer = 0;
					OReady[OCUR].ucAnmPat = 0;
					sGameSeq = WAIT_TITLE;
				}
				//---中断SAVEから開始の場合”中断MARK”を壊すデモ付---
				else if(SaveReady[ucSaveNum].DisCon & DISCON_YES) {
					ReadyObj_Tyudan_Set(ON);			//”ucSaveNum”に応じたMARKを消す
					m4aSongNumStart(S_SAVE_PAPER_OUT);	//SE
					sGameSeq = TYUDAN;
				}
				else {
					sGameSeq = WAIT_GAME;
				}
			}
			else {
				ReadyMain_Save_Select();
			}
			break;

		//中断SAVE
		case TYUDAN:
			if(OReady[OTYUA+ucSaveNum].uckind == ANON) {
				ReadyTimer = 0;
				sGameSeq++;
			}
			break;
		//GEMEへ
		case WAIT_GAME:
			if(ReadyTimer > 20) {
				if(SaveReady[ucSaveNum].Flg) {
					m4aSongNumStop(M_BGM_TITLE);		//BGM-STOP
				}
				sGameSeq = FOUT;
			}
			break;

		//TITLEへ
		case WAIT_TITLE:
			if(ReadyTimer > 40) {
				sGameSeq = FOUT;
			}
			break;

		//FADE OUT
		case FOUT:
			FadeColor_DMA();			//SW=Fade.ucDMAf
			if(ReadyMain_Fade_OUT()) {
				sGameSeq++;
			}
			break;

		//READY
		case READY:
			ReadyMain_SaveLoad();	//画面OFFしてWORK調整
			a = 1;
			break;

		//-----
		case KOWARETA:
			if(KowaretaKey()) {
				sGameSeq++;
			}
			break;
		case FOUT2:
			FadeColor_DMA();			//SW=Fade.ucDMAf
			if(ReadyMain_Fade_OUT()) {
				sGameSeq = INIT;
			}
			break;

		default:
			break;
	}

	if(!a)	{
		ucCntObj = 0;
		ReadyObjCreate();
		ClearOamBuf();
	}

	return a;
}

//==============================================================
//==============================================================
//	選択カーソル移動時のデフォルト
//	NAME_POS, LEVEL_POS, DELETE_POS, OK_POS
//==============================================================
//==============================================================
static void ReadySet_SelectDef(u8 num)
{
	switch(num) {
		default:
		case NAME_POS:
			Ready.SelP = 0;
			break;
		case DELETE_POS:
			Ready.SelP = 0;
			break;
		case LEVEL_POS:
			if(SaveReady[ucSaveNum].Level == GAME_SHARD) {
				Ready.SelP = 2;
			}
			else if(SaveReady[ucSaveNum].Level == GAME_HARD) {
				Ready.SelP = 1;
			}
			else {		//if(SaveReady[ucSaveNum].Level == GAME_NORMAL) {
				Ready.SelP = 0;
			}
			break;
		case OK_POS:			//
			Ready.SelP = 0;
			if(!SaveReady[ucSaveNum].Flg) {
				Ready.SelS = NAME_POS;
				return;
			}
			break;
	}
	Ready.SelS = num;
}


//==============================================================
//==============================================================
//	コントローラ決定処理
//	SELECT_A, SELECT_B, DELETE,
//==============================================================
//==============================================================
static int ReadyKey(void)
{
int a;
#define	SEL_MAX	SELECT_B

	a=0;
	//-----
	switch(Ready.SelM) {
	  case SELECT_A:
	  case SELECT_B:
		//-----決定処理-----
		a = Ready.Start;
		break;
	  case DELETE:
		//-----決定処理-----
		if(Ready.Start == 2)	a = 2;
		break;
	  default:
		//break;
	}
	return a;
}
#undef SEL_MAX


//==============================================================
//==============================================================
//	ＭＡＩＮ処理
//		選択ＭＡＩＮ
//	SELECT_A, SELECT_B, DELETE,
//==============================================================
//==============================================================
static void ReadyMain_Save_Select(void)
{
#define	SEL_MAX	SELECT_B
int a;

	a=0;
	if(Ready.Set) {
		ReadyMain_Select_Set();
	}
	else {
		switch(Ready.SelM) {
			case SELECT_A:
			case SELECT_B:
				ReadyMain_Change_Select();
				break;
			case DELETE:
				ReadyMain_Change_Delete();
				break;
			default:
				break;
		}
	}
	ReadyObj_Win1Set();
	ReadyObj_CurSet();
	ReadyObj_KakoSet();
	ReadyObj_DeleteSet();
}
#undef SEL_MAX


//==============================================================
//==============================================================
#define ABACK_SIZE	((BACKUP_SIZE_WORK+BACKUP_SIZE_POINT)*2)
#define DBACK_SIZE	BACKUP_SIZE_DISCON
enum SeqSw {
	SW_OFF,
	SW_SAVE_A,SW_SAVE_B,SW_NAME_LEV_ND,SW_SEL_DEL,
	SW_OK_DEL,
	SW_LEV_SET,SW_LEV_SEL,SW_LEV_NAME,
	SW_DELEET, SW_DEL_OK,
	SW_DEL_YES,SW_DEL_NO,
  //-----
	SW_DEL_SELB,SW_MDEL_MODE_SET,SW_MDEL_MODE_CAN,
  //-----
	SW_MES_GSTART,
	SW_GAME_START,SW_RET_TIT,
};
//--------------------------------------------------------------
static void ReadyMain_Select_Set(void)
{
int a,n;

	if(OReady[OCUR].uckind == CurAnm_Tbl[ucPerfect][ASCUR_SET])		return;
	if(OReady[OCUR].uckind == ABOM_CLEAR)	return;

	a=0;
	switch(Ready.Set) {
	  //-----------------------------
		case SW_SAVE_A:					//SAVE選択
		case SW_SAVE_B:					//SAVE選択
			if(Ready.Set == SW_SAVE_A)	Ready.SelM = 0;
			else 						Ready.SelM = 1;
			ReadyMain_PickUp_SetReady();		//WORK-SET(1)
			ReadySet_SelectDef(OK_POS);			//WORK-SET(2)
			break;
		case SW_NAME_LEV_ND:			//NAME-POSI -> 難易度選択（NO-DATA）
			ReadySet_SelectDef(LEVEL_POS);
			break;

		case SW_SEL_DEL:				//SAVE選択 -> DELETE
			Ready.SelP = 0;	//CLEAR
			Ready.SelS = 0;	//CLEAR
			Ready.SelM = DELETE;
			ReadyMain_PickUp_SetReady();
			break;
	  //-----------------------------
		case SW_LEV_SET:				//難易度確定 (*)
			SaveReady[ucSaveNum].Flg = 0x80;				//(1)
			SramBackup_Select_Save();						//基本SAVE
			Ready.Set = SW_GAME_START;
			a = 1;
			break;
		case SW_LEV_SEL:				//難易度 選択
			if(Ready.SelP == 2)			n = GAME_SHARD;
			else if(Ready.SelP == 1)	n = GAME_HARD;
			else						n = GAME_NORMAL;
			SaveReady[ucSaveNum].Level = n;
			Ready_CHANGE_Level_BgPut(ucSaveNum);
			break;
		case SW_LEV_NAME:				//難易度 -> NAME-POSI（戻る）
			ReadySet_SelectDef(NAME_POS);
			SaveReady[ucSaveNum].Level = GAME_NORMAL;		//基準難易度
			Ready_CHANGE_Level_BgPut(ucSaveNum);
			break;
		//-----------------------------
		case SW_DEL_OK:					//削除->ＯＫ（戻る）
			ReadySet_SelectDef(OK_POS);
			break;
		case SW_DEL_YES:				//削除 選択(yes)
			Ready.SelP = 1;
			break;
		case SW_DEL_NO:					//削除 選択(no)
			Ready.SelP = 0;
			break;
	  //-----------------------------
	  //-----------------------------
		case SW_DELEET:					//削除 実行	(*)
			DmaClear(3, 0, ExBackUp_Auto_M_Tbl[ucSaveNum] ,ABACK_SIZE , 16);	//CPU外部ワークRAM クリア
			DmaClear(3, 0, ExBackUp_DisCon_Tbl[ucSaveNum] ,DBACK_SIZE , 16);	//CPU外部ワークRAM クリア
			ReadySaveSelect_KeyWord_Clear(ucSaveNum);							//SAVE KEY-WORD CLEAR
			if(SaveReady[ucSaveNum].DisCon & DISCON_YES) {
				ReadyObj_Tyudan_Set(OFF);
			}
			SaveReady[ucSaveNum].Flg 	= SAVE_NO;
			SaveReady[ucSaveNum].DisCon = DISCON_NO;

			Ready_INIT_LocalWork_Set(ucSaveNum);	//WORKのSET

			Ready_INIT_Scr_BgPut();
			Ready_INIT_totalcoin_BgPut(ucSaveNum, ON);
			Ready_INIT_cd_BgPut(ucSaveNum, ON);
			Ready_INIT_boss_BgPut(ucSaveNum, ON);
			//break;						//↓

		case SW_MDEL_MODE_CAN:				//削除MODE解除
			Ready.Delete = 0;
			Ready.SelM = DELETE;
			Ready.SelP = 0;	//CLEAR
			Ready.SelS = 0;	//CLEAR
			ReadyMain_PickUp_SetReady();
			break;

		case SW_DEL_SELB:				//削除 -> SAVE選択
			Ready.SelM = SELECT_B;
			ReadyMain_PickUp_SetReady();
			ReadySet_SelectDef(OK_POS);
			break;
		case SW_MDEL_MODE_SET:				//削除MODE
			Ready.Delete = 1;
			break;

		//-----------------------------
		//-----------------------------
		case SW_MES_GSTART:				//MES GAME-START確定
			m4aMPlayVolumeControl(mplay_table[Song_Player(M_BGM_TITLE)].ma, 0xffff, M4A_VOLUME_8);
			Ready.Set = SW_GAME_START;
			a = 1;
			break;
		//-----------------------------
		//-----------------------------
		case SW_OK_DEL:					//OK  -> 削除
			ReadySet_SelectDef(DELETE_POS);
			break;

		//-----------------------------
		//-----------------------------
		case SW_GAME_START:				//
			Ready.Start = 1;			//GAME-START
			a = 1;
			break;

		case SW_RET_TIT:
			Ready.Start = 2;			//TITLE-RETURN
			a=1;
			break;

		default:
	}

	//-----
	if(!a) {
		Ready.Set = 0;
		if(Ready.Delete) {
			if(OReady[OCUR].uckind != ABOM_SEL) {
				OReady[OCUR].uckind = ABOM_SEL;
				OReady[OCUR].ucAnmTimer = 0;
				OReady[OCUR].ucAnmPat = 0;
			}
		}
		else {
			if(OReady[OCUR].uckind != CurAnm_Tbl[ucPerfect][ASCUR_SELECT]) {
				OReady[OCUR].uckind = CurAnm_Tbl[ucPerfect][ASCUR_SELECT];
				OReady[OCUR].ucAnmTimer = 0;
				OReady[OCUR].ucAnmPat = 0;
			}
		}
	}
}


//==============================================================
//==============================================================
//	選択された瞬間の処理
//	num:変化番号
//	mode:変化モード	OFF:ｶｰｿﾙ移動 ON:決定 CANCEL:ｷｬﾝｾﾙ
//==============================================================
//==============================================================
//-----------------------------
enum {
	PUSH_KEY, PUSH_A, PUSH_B, PUSH_NSTART, PUSH_GSTART , PUSH_Ase, PUSH_DELETE,
};
//-----------------------------
static void ReadySet_SelectKey(u8 num, u8 mode)
{
u16	se;

	se = 0;
	Ready.Set = num;
	switch(mode) {
		case PUSH_A:
			Ready_OBJ_CurSelectSet();		//(OBJ)CUR Anime
			se = S_BUTTON_A;
			break;
		case PUSH_B:
			se = S_BUTTON_B;
			break;
		case PUSH_NSTART:
			m4aSongNumStart(M_BGM_TITLE_PYRAMID);	//NEW GAME START Sound(ピラミッドへ)
			Ready_OBJ_CurSelectSet();				//(OBJ)CUR Anime
			se =  S_BUTTON_A1;						//SEQ変化決定時のSE
			break;
		case PUSH_GSTART:
			m4aMPlayVolumeControl(mplay_table[Song_Player(M_BGM_TITLE)].ma, 0xffff, M4A_VOLUME_7);
			Ready_OBJ_CurSelectSet();				//(OBJ)CUR Anime
			se =  S_BUTTON_A1;						//SEQ変化決定時のSE
			break;
		case PUSH_Ase:
			se = S_BUTTON_A;
			break;
		case PUSH_DELETE:
			Ready_OBJ_BomSelectSet();				//(OBJ)CUR Anime
			se =  S_BUTTON_A_ERASE;					//
			break;
		default:
		case PUSH_KEY:
			se = S_CURSOL_1;
	}

	if(se) {
		m4aSongNumStart(se);	//
	}
}
//---------------------------------------------
//---------------------------------------------
static void Ready_OBJ_CurSelectSet(void)
{
	OReady[OCUR].uckind = CurAnm_Tbl[ucPerfect][ASCUR_SET];
	OReady[OCUR].ucAnmTimer = 0;
	OReady[OCUR].ucAnmPat = 0;
}

//---------------------------------------------
//---------------------------------------------
static void Ready_OBJ_BomSelectSet(void)
{
	OReady[OCUR].uckind = ABOM_CLEAR;
	OReady[OCUR].ucAnmTimer = 0;
	OReady[OCUR].ucAnmPat = 0;
}

//==============================================================
//==============================================================
//	ＭＡＩＮ処理
//		選択ＳＵＢ
//	NAME_POS, LEVEL_POS, DELETE_POS, OK_POS
//==============================================================
//==============================================================
static void ReadySub_Select(u8 posi);
static void ReadySub_Level(void);
static void ReadySub_Delete(void);
//------------------------------------------------------
static void ReadyMain_Change_Select(void)
{
#define	SEL_MAX	DELETE_POS
int a;

	a=0;
	//-----
	switch(Ready.SelS) {
		case NAME_POS:
		case OK_POS:
			ReadySub_Select(Ready.SelS);
			break;
		case LEVEL_POS:
			ReadySub_Level();
			break;
		case DELETE_POS:
			ReadySub_Delete();
			break;
		//---
		default:
		break;
	}
}
#undef SEL_MAX


//--------------------------------------
//--------------------------------------
//	ＳＡＶＥ選択
//	SELECT_A, SELECT_B, DELETE,
//--------------------------------------
//--------------------------------------
static void ReadySub_Select(u8 posi)
{
int a;

	a = 0;
	//-----
	if(usTrg & U_KEY) {
		if(Ready.SelM == SELECT_B) {
			ReadySet_SelectKey(SW_SAVE_A, PUSH_KEY);		//SAVE選択
			a=1;
		}
		else if(Ready.SelM == DELETE) {
			ReadySet_SelectKey(SW_SAVE_B, PUSH_KEY);		//SAVE選択
			a=1;
		}
	}
	else if(usTrg & D_KEY) {
		if(Ready.SelM == SELECT_A) {
			ReadySet_SelectKey(SW_SAVE_B, PUSH_KEY);		//SAVE選択
			a=1;
		}
		else if(Ready.SelM == SELECT_B) {
			ReadySet_SelectKey(SW_SEL_DEL, PUSH_KEY);		//DELETE
			a=1;
		}
	}
	if(a) return;

	//----
	if(usTrg & B_BUTTON) {
		if(Ready.Delete) {
			ReadySet_SelectKey(SW_MDEL_MODE_CAN, PUSH_B);		//SAVE選択 -> DELETE MODE CANSEL
		}
		else {
			ReadySet_SelectKey(SW_RET_TIT, PUSH_B);				//タイトルへ戻る
		}
	}
	else if(posi == OK_POS)			//(Ready.SelS);
	{
		if(usTrg & A_BUTTON) {
			if(Ready.Delete) {
				ReadySet_SelectKey(SW_OK_DEL, PUSH_Ase);			//SAVE選択 -> 削除
			}
			else {
				ReadySet_SelectKey(SW_MES_GSTART,PUSH_GSTART);		//MES GAME-START確定
			}
		}
	}
	//----
	else if(posi == NAME_POS)		//(Ready.SelS);
	{
		if(usTrg & A_BUTTON) {
			if(Ready.Delete) {
				m4aSongNumStart(S_BUTTON_B);					//DATAが無いのにDELETE選択の警告音
			}
			else {
				ReadySet_SelectKey(SW_NAME_LEV_ND,PUSH_Ase);	//NAME-POSI -> 難易度選択
			}
		}
	}
}

//--------------------------------------
//--------------------------------------
//	難易度選択
//--------------------------------------
//--------------------------------------
static void ReadySub_Level(void)
{
int n;

	//-----
	n = 1;
	if(ucPerfect)	n = 2;

	//-----
	if(usTrg & B_BUTTON ) {
		ReadySet_SelectKey(SW_LEV_NAME,PUSH_B);		//難易度 -> NAME-POSI（戻る）
	}
	else if(usTrg & A_BUTTON) {
		ReadySet_SelectKey(SW_LEV_SET,PUSH_NSTART);		//難易度確定
	}
	//-----
	else if(usTrg & U_KEY) {
		if(Ready.SelP) {
			Ready.SelP--;
			n = 0;
		}
	}
	else if(usTrg & D_KEY) {
		if(Ready.SelP < n) {
			Ready.SelP++;
			n = 0;
		}
	}
	if(!n)	ReadySet_SelectKey(SW_LEV_SEL,PUSH_KEY);		//難易度 選択
}


//--------------------------------------
//--------------------------------------
//	SAVE削除
//--------------------------------------
//--------------------------------------
static void ReadySub_Delete(void)
{
	if(usTrg & B_BUTTON) {
		ReadySet_SelectKey(SW_DEL_OK,PUSH_B);			//削除 -> OK-POSI (戻る)
	}
	else if(usTrg & R_KEY) {
		if(Ready.SelP != 1) {
			ReadySet_SelectKey(SW_DEL_YES,PUSH_KEY);	//削除 選択(yes)
		}
	}
	else if(usTrg & L_KEY) {
		if(Ready.SelP != 0) {
			ReadySet_SelectKey(SW_DEL_NO,PUSH_KEY);		//削除 選択(no)
		}
	}
	//-----
	else if(Ready.SelP == 0) {
		if(usTrg & A_BUTTON) {
			ReadySet_SelectKey(SW_DEL_OK,PUSH_B);		//削除 -> OK-POSI (戻る)
		}
	}
	else if(Ready.SelP == 1) {
		if(usTrg & A_BUTTON) {
			ReadySet_SelectKey(SW_DELEET,PUSH_DELETE);	//削除 実行
		}
	}
}


//==============================================================
//==============================================================
//	削除処理
//==============================================================
//==============================================================
static void	ReadyMain_Change_Delete(void)
{
	if(usTrg & U_KEY) {
		ReadySet_SelectKey(SW_DEL_SELB,PUSH_KEY);			//削除 -> SAVE選択
	}
	else if((usTrg & A_BUTTON)&&(!Ready.Delete)) {
			ReadySet_SelectKey(SW_MDEL_MODE_SET,PUSH_A);	//削除MODE
	}
//	else if((usTrg & B_BUTTON)&&(Ready.Delete)) {
//			ReadySet_SelectKey(SW_MDEL_MODE_CAN,PUSH_B);	//削除MODE解除
//	}

	else if(usTrg & B_BUTTON) {
		if(Ready.Delete) {
			ReadySet_SelectKey(SW_MDEL_MODE_CAN,PUSH_B);	//削除MODE解除
		}
		else {
			ReadySet_SelectKey(SW_RET_TIT, PUSH_B);			// タイトルへ戻る
		}
	}
}

//**************************************************************
//**************************************************************
//	選択画面の準備
//	SELECT_A, SELECT_B, DELETE,
//**************************************************************
//**************************************************************
static void ReadyMain_PickUp_SetReady(void)
{
#define	WIN1_X		0x00 << WIN_START_POS_SHIFT | 0xF0
#define	WIN1_Y_A	0x00 << WIN_START_POS_SHIFT | 0x48
#define	WIN1_Y_B	0x48 << WIN_START_POS_SHIFT | 0x90
#define	WIN1_Y_D	0x8F << WIN_START_POS_SHIFT | 0xA0

	switch(Ready.SelM) {
		case SELECT_A:
			*(vu16 *)REG_WIN1H = WIN1_X;
			*(vu16 *)REG_WIN1V = WIN1_Y_A;
			ucSaveNum = SAVE_NUM_A;
			break;
		case SELECT_B:
			*(vu16 *)REG_WIN1H = WIN1_X;
			*(vu16 *)REG_WIN1V = WIN1_Y_B;
			ucSaveNum = SAVE_NUM_B;
			break;
		case DELETE:
			*(vu16 *)REG_WIN1H = WIN1_X;
			*(vu16 *)REG_WIN1V = WIN1_Y_D;
			//ucSaveNum = SAVE_NUM_B;			// <-保留
			break;
		default:
			break;
	}
	ReadyObj_Tyudan_PickUpSet();
}
#undef	WIN1_X
#undef	WIN1_Y_A
#undef	WIN1_Y_B
#undef	WIN1_Y_D


//	*(vu16 *)REG_WIN0H = 0x17<<WIN_START_POS_SHIFT|0x50;	//[DELETE DATA]
//	*(vu16 *)REG_WIN0V = 0x94<<WIN_START_POS_SHIFT|0x9c;	//OBJを輝度調整から外す






//==============================================================
//==============================================================
//	画面フェード
//==============================================================
//==============================================================

//----------------------------------------------
static int ReadyMain_Fade_IN(void)
{
	return	(GateFade_Color(0,0));
}
//----------------------------------------------
static int ReadyMain_Fade_OUT(void)
{
	return	(GateFade_Color(1,0));
}


//**************************************************************
//**************************************************************
//		OBJデータ作成ルーチン
//**************************************************************
//**************************************************************

//==============================================================
//	カーソル位置決め
//	NAME_POS, LEVEL_POS, DELETE_POS, OK_POS
//==============================================================
static void ReadyObj_CurSet(void)
{
int n,a,i;

	//-----
	if(Ready.SelM == DELETE) {
		OReady[OCUR].sYpos = CUR_DEL_Y;
		OReady[OCUR].sXpos = CUR_DEL_X;
		return;
	}

	a = 0;
	if(SaveReady[Ready.SelM].Flg & 0x7f )		a = 1;
	n = (Ready_CurPosi_Step_Tbl[a])[Ready.SelS];

	switch(Ready.SelS) {
		case LEVEL_POS:
		case DELETE_POS:
			n += Ready.SelP*4;
		default:
		case NAME_POS:
		case OK_POS:
			break;
	}

	i = (Ready_CurPosi_Tbl[a])[n];
	n++;
	//-----
	if(i == 1) {
		OReady[OCUR].sYpos = OReady[OWIN].sYpos + (Ready_CurPosi_Tbl[a])[n];
		OReady[OCUR].sXpos = OReady[OWIN].sXpos + (Ready_CurPosi_Tbl[a])[n+2];
	}
	else {
		OReady[OCUR].sYpos = (Ready_CurPosi_Tbl[a])[n+Ready.SelM];
		OReady[OCUR].sXpos = (Ready_CurPosi_Tbl[a])[n+2];
	}
}
#undef	CUR_DEL_Y
#undef	CUR_DEL_X


//==============================================================
//	選択ＷＩＮＤＯＷ
//==============================================================
static const u8 AOBJ_LEVEL_N[2][2]= {
	{ALEV_Ne,  ALEV_He},
	{ALEV_Nj,  ALEV_Hj},
};
static const u8 AOBJ_LEVEL_P[2][3]= {
	{ALEV_PNe, ALEV_PHe, ALEV_PSe},
	{ALEV_PNj, ALEV_PHj, ALEV_PSj},
};
static const u8 AOBJ_DELETE[2][2]= {
	{ADEL_Ne,  ADEL_Ye},				//
	{ADEL_Nj,  ADEL_Yj},				//
};
static const u8 Aobj_PosiTbl[3][3] = {	//yA,yB,x
	{0x62, 0x2c, 0x68},				//DEL		(1)
	{0x50, 0x48, 0xB8},				//LEVEL		(1)
	{0x5c, 0x28, 0x40},				//MES		(0)
};


//----------------------------------------------
//----------------------------------------------
static void ReadyObj_Win1Set(void)
{
int n,a;

	n = ANON;

	switch(Ready.SelS) {
		default:
		case NAME_POS:
		case OK_POS:
			break;
		case LEVEL_POS:
			if(ucPerfect) {
				n = AOBJ_LEVEL_P[ucLanguage][SaveReady[Ready.SelM].Level];
			}
			else {
				n = AOBJ_LEVEL_N[ucLanguage][SaveReady[Ready.SelM].Level];
			}
			a=1;
			break;
		case DELETE_POS:
			//if(Ready.SelP) {
				n = AOBJ_DELETE[ucLanguage][Ready.SelP];
				a=0;
			//}
			break;
	}
	//-----
	if(n != OReady[OWIN].uckind) {
		OReady[OWIN].uckind = n;
		OReady[OWIN].ucAnmTimer = 0;
		OReady[OWIN].ucAnmPat = 0;
		OReady[OWIN].sYpos = Aobj_PosiTbl[a][0+Ready.SelM];
		OReady[OWIN].sXpos = Aobj_PosiTbl[a][2];
	}
}

//----------------------------------------------
//	選択してるＳＡＶＥの括弧	//OKAKO
//		AKAKO_RED,AKAKO_BLU,
//----------------------------------------------
static void ReadyObj_KakoSet(void)
{
int n,y;

	//---
	n = ANON;
	if(Ready.SelM != DELETE) {
		if(Ready.Delete) {
			n = AKAKO_RED;
		}
		else {
			n = AKAKO_BLU;
		}
	}
	y = 0x0a+ucSaveNum*0x48;

	//-----
	if(n != OReady[OKAKO].uckind) {
		OReady[OKAKO].uckind = n;
		OReady[OKAKO].ucAnmTimer = 0;
		OReady[OKAKO].ucAnmPat = 0;
	}
	if(y != OReady[OKAKO].sYpos) {
		OReady[OKAKO].sYpos = y;
		OReady[OKAKO].sXpos = 0x78;
	}
}


//----------------------------------------------
//	DELETE専用OBJ	//ODEL
//----------------------------------------------
static void ReadyObj_DeleteSet(void)
{
int n;

	n = AOBJ_Deleten_Tbl[ucLanguage][AMDEL_NO];
	if(Ready.SelM == DELETE) 	n = AOBJ_Deleten_Tbl[ucLanguage][AMDEL_YES];

	//-----
	if(n != OReady[ODEL].uckind) {
		OReady[ODEL].uckind = n;
		OReady[ODEL].ucAnmTimer = 0;
		OReady[ODEL].ucAnmPat = 0;
		OReady[ODEL].sYpos = 0x9c;
		OReady[ODEL].sXpos = 0x32;
	}
}


//----------------------------------------------
//	中断MARK-OBJ	//OTYUA,OTYUB
//		SELECT_A, SELECT_B, DELETE,
//----------------------------------------------
static void ReadyObj_Tyudan_Init(void)
{
	OReady[OTYUA].uckind = ANON;
	OReady[OTYUB].uckind = ANON;
	if(SaveReady[0].DisCon & DISCON_YES) {
		OReady[OTYUA].uckind = AOBJ_Tyudan_Tbl[ucLanguage][Ready.SelM==SELECT_A];
	}
	if(SaveReady[1].DisCon & DISCON_YES) {
		OReady[OTYUB].uckind = AOBJ_Tyudan_Tbl[ucLanguage][Ready.SelM==SELECT_B];
	}
	//-----
	OReady[OTYUA].ucAnmTimer = 0;
	OReady[OTYUA].ucAnmPat = 0;
	OReady[OTYUA].sYpos = 0x18;
	OReady[OTYUA].sXpos = 0xD8;
	//-----
	OReady[OTYUB].ucAnmTimer = 0;
	OReady[OTYUB].ucAnmPat = 0;
	OReady[OTYUB].sYpos = 0x60;
	OReady[OTYUB].sXpos = 0xD8;
}
//-----
//-----
static void ReadyObj_Tyudan_Set(u8 anm)
{
int n,a;

	if(!ucSaveNum)	n = OTYUA;
	else			n = OTYUB;

	OReady[n].ucAnmTimer = 0;
	OReady[n].ucAnmPat = 0;

	if(anm == ON) {
		OReady[n].uckind = AOBJ_Tyudan_Tbl[ucLanguage][2];
	}
	else {
		OReady[n].uckind = ANON;
	}
}
//----------------------------------------------
//	中断MARK-OBJ
//	選択された(Ready.SelM)に応じてOBJを変化
//----------------------------------------------
static void ReadyObj_Tyudan_PickUpSet(void)
{
	if(OReady[OTYUA].uckind != ANON) {
		OReady[OTYUA].uckind = AOBJ_Tyudan_Tbl[ucLanguage][Ready.SelM==SELECT_A];
		OReady[OTYUA].ucAnmTimer = 0;
		OReady[OTYUA].ucAnmPat = 0;
	}
	if(OReady[OTYUB].uckind != ANON) {
		OReady[OTYUB].uckind = AOBJ_Tyudan_Tbl[ucLanguage][Ready.SelM==SELECT_B];
		OReady[OTYUB].ucAnmTimer = 0;
		OReady[OTYUB].ucAnmPat = 0;
	}
}


//**************************************************************
//**************************************************************
//		OAMデータ作成ルーチン
//**************************************************************
//**************************************************************
static const AnmDef *ReadyAnm[ANMNUM_MAX] =
{
	sdobj1_Anm_00,		//dummy
	sdobj1_Anm_00,		//ACUR_SEL
	sdobj1_Anm_01,		//ACUR_SET
	sdobj1_Anm_02,		//ACUR_STP1
	sdobj1_Anm_03,		//ACUR_STP2
	sdobj1_Anm_04,		//A_04
	sdobj1_Anm_05,		//ALEV_Ne
	sdobj1_Anm_06,		//ALEV_He
	sdobj1_Anm_07,		//ALEV_Nj
	sdobj1_Anm_08,		//ALEV_Hj
	sdobj1_Anm_09,		//ALEV_PNe
	sdobj1_Anm_0a,		//ALEV_PHe
	sdobj1_Anm_0b,		//ALEV_PSe
	sdobj1_Anm_0c,		//ALEV_PNj
	sdobj1_Anm_0d,		//ALEV_PHj
	sdobj1_Anm_0e,		//ALEV_PSj
	sdobj1_Anm_0f,		//ADEL_Ne
	sdobj1_Anm_10,		//ADEL_Ye
	sdobj1_Anm_11,		//ADEL_Nj
	sdobj1_Anm_12,		//ADEL_Yj
	sdobj1_Anm_13,		//AARROW_D
	sdobj1_Anm_14,		//AARROW_U

	sdobj1_Anm_15,		//ATYU_2j
	sdobj1_Anm_16,		//ATYU_2e
	sdobj1_Anm_17,		//ATYU_1j
	sdobj1_Anm_18,		//ATYU_1e

	sdobj1_Anm_19,		//AMDEL_STPe
	sdobj1_Anm_1a,		//AMDEL_SELe
	sdobj1_Anm_1b,		//AKAKO_RED
	sdobj1_Anm_1c,		//AKAKO_BLU
	sdobj1_Anm_1d,		//ABOM_STP
	sdobj1_Anm_1e,		//ABOM_SEL
	sdobj1_Anm_1f,		//ABOM_CLEAR

	sdobj1_Anm_20,		//ACWN_SEL
	sdobj1_Anm_21,		//ACWN_SET
	sdobj1_Anm_22,		//ACWN_STP

	sdobj1_Anm_23,		//AMDEL_STPj
	sdobj1_Anm_24,		//AMDEL_SELj
	sdobj1_Anm_25,		//ATYU_0j
	sdobj1_Anm_26,		//ATYU_0e

	sdobj1_Anm_27,		//AKOWARE_Aj
	sdobj1_Anm_28,		//AKOWARE_Ae
	sdobj1_Anm_29,		//AKOWARE_Bj
	sdobj1_Anm_2a,		//AKOWARE_Be
};


//==============================================================
//==============================================================
static void ReadyObjCreate(void)
{

int		i, n;
s16		x, y;
AnmDef	*anmd;
u16		*oam;
u16		*anm;
u16		data;
int		num;

//OamBufの作成
	oam = (u16*)OamBuf;
	oam += (ucCntObj*4);
	n = ucCntObj;
	i = n;

	for( num=0; num<OBJNUM_MAX; num++)
	{

		if(OReady[num].uckind == ANON)	continue;

		switch(OReady[num].uckind)
		{
			//-----アニメーションループ（効果音無し）-----
			case ACUR_SEL:
			case ACUR_STP1:
			case ACUR_STP2:
			case ALEV_Ne:
			case ALEV_He:
			case ALEV_Nj:
			case ALEV_Hj:
			case ALEV_PNe:
			case ALEV_PHe:
			case ALEV_PSe:
			case ALEV_PNj:
			case ALEV_PHj:
			case ALEV_PSj:
			case ADEL_Ne:
			case ADEL_Ye:
			case ADEL_Nj:
			case ADEL_Yj:
			case AARROW_D:
			case AARROW_U:
			case ATYU_1j:
			case ATYU_1e:
			case AMDEL_STPe:
			case AMDEL_SELe:
			case AKAKO_RED:
			case AKAKO_BLU:
			case ABOM_STP:
			case ABOM_SEL:

			case ACWN_SEL:
			case ACWN_STP:
			case AMDEL_STPj:
			case AMDEL_SELj:

			case ATYU_0j:
			case ATYU_0e:

			case AKOWARE_Aj:
			case AKOWARE_Ae:
			case AKOWARE_Bj:
			case AKOWARE_Be:
			//-----------------ANIME  LOOP
				anmd = (AnmDef*)ReadyAnm[OReady[num].uckind];
				if(OReady[num].ucAnmTimer >= anmd[OReady[num].ucAnmPat].ucTimer)
				{
					OReady[num].ucAnmTimer = 0;
					OReady[num].ucAnmPat++;
					if(!anmd[OReady[num].ucAnmPat].ucTimer)
					{
						OReady[num].ucAnmPat = 0;
					}
				}
				break;

			case ACUR_SET:
			case ACWN_SET:
			//-----------------ANIME  END -> KIND++
				anmd = (AnmDef*)ReadyAnm[OReady[num].uckind];
				if(OReady[num].ucAnmTimer >= anmd[OReady[num].ucAnmPat].ucTimer)
				{
					OReady[num].ucAnmTimer = 0;
					OReady[num].ucAnmPat++;
					if(!anmd[OReady[num].ucAnmPat].ucTimer)
					{
						OReady[num].uckind++;
						*anmd++;						//anmd(+1)
						OReady[num].ucAnmTimer = 0;
						OReady[num].ucAnmPat = 0;
					}
				}
				break;

			case ATYU_2j:
			case ATYU_2e:
			case ABOM_CLEAR:
			//-----------------ANIME  ONCE
				anmd = (AnmDef*)ReadyAnm[OReady[num].uckind];
				if(OReady[num].ucAnmTimer >= anmd[OReady[num].ucAnmPat].ucTimer)
				{
					OReady[num].ucAnmTimer = 0;
					OReady[num].ucAnmPat++;
					if(!anmd[OReady[num].ucAnmPat].ucTimer)
					{
						OReady[num].uckind = ANON;
						OReady[num].ucAnmTimer = 0;
						OReady[num].ucAnmPat = 0;
						continue;
					}
				}
				break;

			default:
				break;
		}

		//-----
		OReady[num].ucAnmTimer++;

		y = OReady[num].sYpos - usBg1Vofs;
		x = OReady[num].sXpos - usBg1Hofs;

		anmd += OReady[num].ucAnmPat;
		anm = (u16*)anmd->uiObjAddr;

		n += *(u16*)anm++;
		for( ; i < n; i++)
		{
			data = *(u16*)anm++;
			*(u16*)(oam++) = data;
			OamBuf[i].VPos = (data+y)&0xff;

			data = *(u16*)anm++;
			*(u16*)(oam++) = data;
			OamBuf[i].HPos = (data+x)&0x1ff;

			*(u16*)(oam++) = *(u16*)anm++;
			OamBuf[i].Priority = 1;

			oam++;
		}
	}
	ucCntObj = n;
}

//------------------------------
//------------------------------
#undef	ON
#undef	OFF
#undef	CANCEL
#undef	ABACK_SIZE
#undef	DBACK_SIZE

//-----------------------------------------------------
//-----------------------------------------------------
//-----------------------------------------------------
//-----------------------------------------------------

#undef	BINDATE_PUT

//**************************************************************
//end
