np2/i286c/egcmem.c - diff

Return to egcmem.c CVS log

Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/Attic/egcmem.c between versions 1.1 and 1.10

version 1.1, 2003/10/16 17:57:49	version 1.10, 2004/02/18 03:56:57
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"
#include "memory.h"	#include "cpucore.h"
#include "egcmem.h"	#include "egcmem.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "vram.h"	#include "vram.h"


// エンディアン修正しる！	enum {
	EGCADDR_L = 0,
	EGCADDR_H = 1
	};
	#define EGCADDR(a) (a)

// C版EGCのみ ROPの回数を記録する
// #define LOG_EGCROP


static QWORD_P egc_src;	static EGCQUAD egc_src;
static QWORD_P data;	static EGCQUAD egc_data;

static const UINT planead[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};	static const UINT planead[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};


static const BYTE bytemask_u0[64] = // dir:right by startbit + (len-1)*8	static const UINT8 bytemask_u0[64] = // dir:right by startbit + (len-1)*8
{0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,	{0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x01,	0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x01,
0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x03, 0x01,	0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x03, 0x01,
Line 28 static const BYTE bytemask_u0[64] = //	Line 30 static const BYTE bytemask_u0[64] = //
0xfe, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01,	0xfe, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01,
0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};	0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};

static const BYTE bytemask_u1[8] = // dir:right by length	static const UINT8 bytemask_u1[8] = // dir:right by length
{0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};	{0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};

static const BYTE bytemask_d0[64] = // dir:left by startbit + (len-1)*8	static const UINT8 bytemask_d0[64] = // dir:left by startbit + (len-1)*8
{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,	{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80,	0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80,
0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xc0, 0x80,	0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xc0, 0x80,
Line 41 static const BYTE bytemask_d0[64] = //	Line 43 static const BYTE bytemask_d0[64] = //
0x7f, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80,	0x7f, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80,
0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};	0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};

static const BYTE bytemask_d1[8] = // dir:left by length	static const UINT8 bytemask_d1[8] = // dir:left by length
{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};	{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};

#ifdef LOG_EGCROP
static int egcropcnt[256];
#endif


void egcshift(void) {	void egcshift(void) {

BYTE src8, dst8;	BYTE src8, dst8;

egc.remain = (egc.leng & 0xfff) + 1;	egc.remain = LOW12(egc.leng) + 1;
egc.func = (egc.sft >> 12) & 1;	egc.func = (egc.sft >> 12) & 1;
if (!egc.func) {	if (!egc.func) {
egc.inptr = egc.buf;	egc.inptr = egc.buf;
Line 108 void egcshift(void) {	Line 106 void egcshift(void) {
}	}


static void egcsftb_upn_sub(DWORD ext) {	static void MEMCALL egcsftb_upn_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 132 static void egcsftb_upn_sub(DWORD ext) {	Line 131 static void egcsftb_upn_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = egc.outptr[0];	egc_src._b[0][ext] = egc.outptr[0];
egc_src.b[1][ext] = egc.outptr[4];	egc_src._b[1][ext] = egc.outptr[4];
egc_src.b[2][ext] = egc.outptr[8];	egc_src._b[2][ext] = egc.outptr[8];
egc_src.b[3][ext] = egc.outptr[12];	egc_src._b[3][ext] = egc.outptr[12];
egc.outptr++;	egc.outptr++;
}	}

	static void MEMCALL egcsftb_dnn_sub(UINT ext) {
static void egcsftb_dnn_sub(DWORD ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 168 static void egcsftb_dnn_sub(DWORD ext) {	Line 167 static void egcsftb_dnn_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = egc.outptr[0];	egc_src._b[0][ext] = egc.outptr[0];
egc_src.b[1][ext] = egc.outptr[4];	egc_src._b[1][ext] = egc.outptr[4];
egc_src.b[2][ext] = egc.outptr[8];	egc_src._b[2][ext] = egc.outptr[8];
egc_src.b[3][ext] = egc.outptr[12];	egc_src._b[3][ext] = egc.outptr[12];
egc.outptr--;	egc.outptr--;
}	}

Line 185 static void egcsftb_dnn_sub(DWORD ext) {	Line 184 static void egcsftb_dnn_sub(DWORD ext) {
// 1st -> data[0] >> (dst - src)	// 1st -> data[0] >> (dst - src)
// 2nd -> (data[0] << (8 - (dst - src))) \| (data[1] >> (dst - src))	// 2nd -> (data[0] << (8 - (dst - src))) \| (data[1] >> (dst - src))

static void egcsftb_upr_sub(DWORD ext) {	static void MEMCALL egcsftb_upr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
}	}
egc.dstbit = 0;	egc.dstbit = 0;
egc_src.b[0][ext] = (egc.outptr[0] >> egc.sft8bitr);	egc_src._b[0][ext] = (egc.outptr[0] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] >> egc.sft8bitr);	egc_src._b[1][ext] = (egc.outptr[4] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] >> egc.sft8bitr);	egc_src._b[2][ext] = (egc.outptr[8] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] >> egc.sft8bitr);	egc_src._b[3][ext] = (egc.outptr[12] >> egc.sft8bitr);
}	}
else {	else {
if (egc.remain >= 8) {	if (egc.remain >= 8) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|
(egc.outptr[1] >> egc.sft8bitr);	(egc.outptr[1] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|
(egc.outptr[5] >> egc.sft8bitr);	(egc.outptr[5] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|
(egc.outptr[9] >> egc.sft8bitr);	(egc.outptr[9] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|
(egc.outptr[13] >> egc.sft8bitr);	(egc.outptr[13] >> egc.sft8bitr);
egc.outptr++;	egc.outptr++;
}	}
Line 233 static void egcsftb_upr_sub(DWORD ext) {	Line 233 static void egcsftb_upr_sub(DWORD ext) {
// 1st -> data[0] << (dst - src)	// 1st -> data[0] << (dst - src)
// 2nd -> (data[0] >> (8 - (dst - src))) \| (data[-1] << (dst - src))	// 2nd -> (data[0] >> (8 - (dst - src))) \| (data[-1] << (dst - src))

static void egcsftb_dnr_sub(DWORD ext) {	static void MEMCALL egcsftb_dnr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
}	}
egc.dstbit = 0;	egc.dstbit = 0;
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitr);	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitr);	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitr);	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitr);	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitr);
}	}
else {	else {
if (egc.remain >= 8) {	if (egc.remain >= 8) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
egc.outptr--;	egc.outptr--;
egc_src.b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|
(egc.outptr[0] << egc.sft8bitr);	(egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|
(egc.outptr[4] << egc.sft8bitr);	(egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|
(egc.outptr[8] << egc.sft8bitr);	(egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|
(egc.outptr[12] << egc.sft8bitr);	(egc.outptr[12] << egc.sft8bitr);
}	}
}	}
Line 281 static void egcsftb_dnr_sub(DWORD ext) {	Line 282 static void egcsftb_dnr_sub(DWORD ext) {
// 1st -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))	// 1st -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))
// 2nd -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))	// 2nd -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))

static void egcsftb_upl_sub(DWORD ext) {	static void MEMCALL egcsftb_upl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 305 static void egcsftb_upl_sub(DWORD ext) {	Line 307 static void egcsftb_upl_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|
(egc.outptr[1] >> egc.sft8bitr);	(egc.outptr[1] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|
(egc.outptr[5] >> egc.sft8bitr);	(egc.outptr[5] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|
(egc.outptr[9] >> egc.sft8bitr);	(egc.outptr[9] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|
(egc.outptr[13] >> egc.sft8bitr);	(egc.outptr[13] >> egc.sft8bitr);
egc.outptr++;	egc.outptr++;
}	}
Line 326 static void egcsftb_upl_sub(DWORD ext) {	Line 328 static void egcsftb_upl_sub(DWORD ext) {
// 1st -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))	// 1st -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))
// 2nd -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))	// 2nd -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))

static void egcsftb_dnl_sub(DWORD ext) {	static void MEMCALL egcsftb_dnl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 350 static void egcsftb_dnl_sub(DWORD ext) {	Line 353 static void egcsftb_dnl_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc.outptr--;	egc.outptr--;
egc_src.b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|
(egc.outptr[0] << egc.sft8bitr);	(egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|
(egc.outptr[4] << egc.sft8bitr);	(egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|
(egc.outptr[8] << egc.sft8bitr);	(egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|
(egc.outptr[12] << egc.sft8bitr);	(egc.outptr[12] << egc.sft8bitr);
}	}


static void egcsftb_upn0(DWORD adrs) {	static void MEMCALL egcsftb_upn0(UINT ext) {

int ext;

ext = adrs & 1;	if (egc.stack < (UINT)(8 - egc.dstbit)) {
if (egc.stack < (DWORD)(8 - egc.dstbit)) {	egc.srcmask._b[ext] = 0;
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 382 static void egcsftb_upn0(DWORD adrs) {	Line 382 static void egcsftb_upn0(DWORD adrs) {
}	}
}	}

static void egcsftw_upn0(DWORD adrs) {	static void MEMCALL egcsftw_upn0(void) {

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upn_sub(0);	egcsftb_upn_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upn_sub(1);	egcsftb_upn_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

	static void MEMCALL egcsftb_dnn0(UINT ext) {

static void egcsftb_dnn0(DWORD adrs) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
	egc.srcmask._b[ext] = 0;
int ext;

ext = adrs & 1;
if (egc.stack < (DWORD)(8 - egc.dstbit)) {
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 420 static void egcsftb_dnn0(DWORD adrs) {	Line 415 static void egcsftb_dnn0(DWORD adrs) {
}	}
}	}

static void egcsftw_dnn0(DWORD adrs) {	static void MEMCALL egcsftw_dnn0(void) {

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnn_sub(1);	egcsftb_dnn_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnn_sub(0);	egcsftb_dnn_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void egcsftb_upr0(DWORD adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftb_upr0(UINT ext) { // dir:up srcbit < dstbit

int ext;	if (egc.stack < (UINT)(8 - egc.dstbit)) {
	egc.srcmask._b[ext] = 0;
ext = adrs & 1;
if (egc.stack < (DWORD)(8 - egc.dstbit)) {
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 458 static void egcsftb_upr0(DWORD adrs) {	Line 449 static void egcsftb_upr0(DWORD adrs) {
}	}
}	}

static void egcsftw_upr0(DWORD adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftw_upr0(void) { // dir:up srcbit < dstbit

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upr_sub(0);	egcsftb_upr_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upr_sub(1);	egcsftb_upr_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

	static void MEMCALL egcsftb_dnr0(UINT ext) { // dir:up srcbit < dstbit

static void egcsftb_dnr0(DWORD adrs) { // dir:up srcbit < dstbit	if (egc.stack < (UINT)(8 - egc.dstbit)) {
	egc.srcmask._b[ext] = 0;
int ext;

ext = adrs & 1;
if (egc.stack < (DWORD)(8 - egc.dstbit)) {
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 496 static void egcsftb_dnr0(DWORD adrs) {	Line 482 static void egcsftb_dnr0(DWORD adrs) {
}	}
}	}

static void egcsftw_dnr0(DWORD adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftw_dnr0(void) { // dir:up srcbit < dstbit

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnr_sub(1);	egcsftb_dnr_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnr_sub(0);	egcsftb_dnr_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void egcsftb_upl0(DWORD adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftb_upl0(UINT ext) { // dir:up srcbit > dstbit

int ext;

ext = adrs & 1;	if (egc.stack < (UINT)(8 - egc.dstbit)) {
if (egc.stack < (DWORD)(8 - egc.dstbit)) {	egc.srcmask._b[ext] = 0;
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 534 static void egcsftb_upl0(DWORD adrs) {	Line 516 static void egcsftb_upl0(DWORD adrs) {
}	}
}	}

static void egcsftw_upl0(DWORD adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftw_upl0(void) { // dir:up srcbit > dstbit

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upl_sub(0);	egcsftb_upl_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upl_sub(1);	egcsftb_upl_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

	static void MEMCALL egcsftb_dnl0(UINT ext) { // dir:up srcbit > dstbit

static void egcsftb_dnl0(DWORD adrs) { // dir:up srcbit > dstbit	if (egc.stack < (UINT)(8 - egc.dstbit)) {
	egc.srcmask._b[ext] = 0;
int ext;

ext = adrs & 1;
if (egc.stack < (DWORD)(8 - egc.dstbit)) {
egc.srcmask.b[ext] = 0;
return;	return;
}	}
egc.stack -= (8 - egc.dstbit);	egc.stack -= (8 - egc.dstbit);
Line 572 static void egcsftb_dnl0(DWORD adrs) {	Line 549 static void egcsftb_dnl0(DWORD adrs) {
}	}
}	}

static void egcsftw_dnl0(DWORD adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftw_dnl0(void) { // dir:up srcbit > dstbit

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnl_sub(1);	egcsftb_dnl_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnl_sub(0);	egcsftb_dnl_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void (*egcsft_proc[])(DWORD adrs) = {	typedef void (MEMCALL * EGCSFTB)(UINT ext);
egcsftw_upn0, egcsftw_dnn0,	typedef void (MEMCALL * EGCSFTW)(void);
egcsftw_upr0, egcsftw_dnr0,
egcsftw_upl0, egcsftw_dnl0,

	static const EGCSFTB egcsftb[6] = {
egcsftb_upn0, egcsftb_dnn0,	egcsftb_upn0, egcsftb_dnn0,
egcsftb_upr0, egcsftb_dnr0,	egcsftb_upr0, egcsftb_dnr0,
egcsftb_upl0, egcsftb_dnl0};	egcsftb_upl0, egcsftb_dnl0};

	static const EGCSFTW egcsftw[6] = {
	egcsftw_upn0, egcsftw_dnn0,
	egcsftw_upr0, egcsftw_dnr0,
	egcsftw_upl0, egcsftw_dnl0};



// ---------------------------------------------------------------------------	// ---------------------------------------------------------------------------

static void shiftinput_byte(DWORD ext) {	static void MEMCALL shiftinput_byte(UINT ext) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
if (egc.srcbit >= 8) {	if (egc.srcbit >= 8) {
Line 622 static void shiftinput_byte(DWORD ext) {	Line 604 static void shiftinput_byte(DWORD ext) {
egc.inptr--;	egc.inptr--;
}	}
}	}
egc.srcmask.b[ext] = 0xff;	egc.srcmask._b[ext] = 0xff;
egcsft_proc[egc.func + 6](ext);	(*egcsftb[egc.func])(ext);
}	}

static void shiftinput_incw(void) {	static void MEMCALL shiftinput_incw(void) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
egc.inptr += 2;	egc.inptr += 2;
Line 637 static void shiftinput_incw(void) {	Line 619 static void shiftinput_incw(void) {
egc.srcbit = 0;	egc.srcbit = 0;
}	}
egc.srcmask.w = 0xffff;	egc.srcmask.w = 0xffff;
egcsft_proc[egc.func](0);	(*egcsftw[egc.func])();
}	}

static void shiftinput_decw(void) {	static void MEMCALL shiftinput_decw(void) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
egc.inptr -= 2;	egc.inptr -= 2;
Line 651 static void shiftinput_decw(void) {	Line 633 static void shiftinput_decw(void) {
egc.srcbit = 0;	egc.srcbit = 0;
}	}
egc.srcmask.w = 0xffff;	egc.srcmask.w = 0xffff;
egcsft_proc[egc.func](0);	(*egcsftw[egc.func])();
}	}

	#define EGCOPE_SHIFTB \
	if (egc.ope & 0x400) { \
	egc.inptr[ 0] = (BYTE)value; \
	egc.inptr[ 4] = (BYTE)value; \
	egc.inptr[ 8] = (BYTE)value; \
	egc.inptr[12] = (BYTE)value; \
	shiftinput_byte(EGCADDR(ad & 1)); \
	} \

	#define EGCOPE_SHIFTW \
	if (egc.ope & 0x400) { \
	if (!(egc.sft & 0x1000)) { \
	egc.inptr[ 0] = (BYTE)value; \
	egc.inptr[ 1] = (BYTE)(value >> 8); \
	egc.inptr[ 4] = (BYTE)value; \
	egc.inptr[ 5] = (BYTE)(value >> 8); \
	egc.inptr[ 8] = (BYTE)value; \
	egc.inptr[ 9] = (BYTE)(value >> 8); \
	egc.inptr[12] = (BYTE)value; \
	egc.inptr[13] = (BYTE)(value >> 8); \
	shiftinput_incw(); \
	} \
	else { \
	egc.inptr[-1] = (BYTE)value; \
	egc.inptr[ 0] = (BYTE)(value >> 8); \
	egc.inptr[ 3] = (BYTE)value; \
	egc.inptr[ 4] = (BYTE)(value >> 8); \
	egc.inptr[ 7] = (BYTE)value; \
	egc.inptr[ 8] = (BYTE)(value >> 8); \
	egc.inptr[11] = (BYTE)value; \
	egc.inptr[12] = (BYTE)(value >> 8); \
	shiftinput_decw(); \
	} \
	}


	// ----

	static const UINT8 data_00[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
	static const UINT8 data_ff[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};

#define EGCOPE_SHIFT { \	static const EGCQUAD * MEMCALL ope_00(REG8 ope, UINT32 ad) {
if (egc.ope & 0x400) { \
if (func < 6) { \	(void)ope;
if (!(egc.sft & 0x1000)) { \	(void)ad;
(WORD )(egc.inptr + 0) = value; \	return((EGCQUAD *)data_00);
(WORD )(egc.inptr + 4) = value; \
(WORD )(egc.inptr + 8) = value; \
(WORD )(egc.inptr +12) = value; \
shiftinput_incw(); \
} \
else { \
(WORD )(egc.inptr - 1) = value; \
(WORD )(egc.inptr + 3) = value; \
(WORD )(egc.inptr + 7) = value; \
(WORD )(egc.inptr +11) = value; \
shiftinput_decw(); \
} \
} \
else { \
*(egc.inptr + 0) = (BYTE)value; \
*(egc.inptr + 4) = (BYTE)value; \
*(egc.inptr + 8) = (BYTE)value; \
*(egc.inptr +12) = (BYTE)value; \
shiftinput_byte(ad & 1); \
} \
} \
}	}

	static const EGCQUAD * MEMCALL ope_0f(REG8 ope, UINT32 ad) {

	egc_data.d[0] = ~egc_src.d[0];
	egc_data.d[1] = ~egc_src.d[1];

static void gdc_ope(DWORD ad, WORD value, int func) {	(void)ope;
	(void)ad;
	return(&egc_data);
	}

QWORD_P pat;	static const EGCQUAD * MEMCALL ope_c0(REG8 ope, UINT32 ad) {
QWORD_P dst;

egc.mask2.w = egc.mask.w;	EGCQUAD dst;

	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);
	egc_data.d[0] = (egc_src.d[0] & dst.d[0]);
	egc_data.d[1] = (egc_src.d[1] & dst.d[1]);

	(void)ope;
	(void)ad;
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_f0(REG8 ope, UINT32 ad) {

	(void)ope;
	(void)ad;
	return(&egc_src);
	}

	static const EGCQUAD * MEMCALL ope_fc(REG8 ope, UINT32 ad) {

	EGCQUAD dst;

	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);
	egc_data.d[0] = egc_src.d[0];
	egc_data.d[0] \|= ((~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] = egc_src.d[1];
	egc_data.d[1] \|= ((~egc_src.d[1]) & dst.d[1]);

	(void)ope;
	(void)ad;
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_ff(REG8 ope, UINT32 ad) {

	(void)ope;
	(void)ad;
	return((EGCQUAD *)data_ff);
	}

	static const EGCQUAD * MEMCALL ope_nd(REG8 ope, UINT32 ad) {

	EGCQUAD pat;

	switch(egc.fgbg & 0x6000) {
	case 0x2000:
	pat.d[0] = egc.bgc.d[0];
	pat.d[1] = egc.bgc.d[1];
	break;

	case 0x4000:
	pat.d[0] = egc.fgc.d[0];
	pat.d[1] = egc.fgc.d[1];
	break;

	default:
	if ((egc.ope & 0x0300) == 0x0100) {
	pat.d[0] = egc_src.d[0];
	pat.d[1] = egc_src.d[1];
	}
	else {
	pat.d[0] = egc.patreg.d[0];
	pat.d[1] = egc.patreg.d[1];
	}
	break;
	}

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0]);
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1]);
	}
	if (ope & 0x40) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1]);
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]));
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]));
	}
	if (ope & 0x04) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]));
	}
	(void)ad;
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_np(REG8 ope, UINT32 ad) {

	EGCQUAD dst;

	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= (egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x20) {
	egc_data.d[0] \|= (egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= (egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= ((~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= ((~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x02) {
	egc_data.d[0] \|= ((~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= ((~egc_src.d[1]) & (~dst.d[1]));
	}
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_xx(REG8 ope, UINT32 ad) {

	EGCQUAD pat;
	EGCQUAD dst;

	switch(egc.fgbg & 0x6000) {
	case 0x2000:
	pat.d[0] = egc.bgc.d[0];
	pat.d[1] = egc.bgc.d[1];
	break;

	case 0x4000:
	pat.d[0] = egc.fgc.d[0];
	pat.d[1] = egc.fgc.d[1];
	break;

	default:
	if ((egc.ope & 0x0300) == 0x0100) {
	pat.d[0] = egc_src.d[0];
	pat.d[1] = egc_src.d[1];
	}
	else {
	pat.d[0] = egc.patreg.d[0];
	pat.d[1] = egc.patreg.d[1];
	}
	break;
	}
	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x40) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x20) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x10) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x04) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x02) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & (~dst.d[1]));
	}
	if (ope & 0x01) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & (~dst.d[1]));
	}
	return(&egc_data);
	}

	typedef const EGCQUAD * (MEMCALL * OPEFN)(REG8 ope, UINT32 ad);

	static const OPEFN opefn[256] = {
	ope_00, ope_xx, ope_xx, ope_np, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_np, ope_xx, ope_xx, ope_0f,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_np, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_np,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_c0, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_np,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_f0, ope_xx, ope_xx, ope_np, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_fc, ope_xx, ope_xx, ope_ff};


	// ----

	static const EGCQUAD * MEMCALL egc_opeb(UINT32 ad, REG8 value) {

	UINT tmp;

	egc.mask2.w = egc.mask.w;
switch(egc.ope & 0x1800) {	switch(egc.ope & 0x1800) {
case 0x0800:	case 0x0800:
EGCOPE_SHIFT;	EGCOPE_SHIFTB;
	egc.mask2.w &= egc.srcmask.w;
	tmp = egc.ope & 0xff;
	return((*opefn[tmp])((REG8)tmp, ad & (~1)));

	case 0x1000:
switch(egc.fgbg & 0x6000) {	switch(egc.fgbg & 0x6000) {
case 0x2000:	case 0x2000:
pat.d[0] = egc.bgc.d[0];	return(&egc.bgc);
pat.d[1] = egc.bgc.d[1];
break;
case 0x4000:	case 0x4000:
pat.d[0] = egc.fgc.d[0];	return(&egc.fgc);
pat.d[1] = egc.fgc.d[1];
break;
default:
if ((egc.ope & 0x0300) == 0x0100) { // ver0.29
pat.d[0] = egc_src.d[0];
pat.d[1] = egc_src.d[1];
}
else {
pat.d[0] = egc.patreg.d[0];
pat.d[1] = egc.patreg.d[1];
}
break;
}
ad &= ~1;
dst.w[0] = (WORD )(&mem[ad + VRAM_B]);
dst.w[1] = (WORD )(&mem[ad + VRAM_R]);
dst.w[2] = (WORD )(&mem[ad + VRAM_G]);
dst.w[3] = (WORD )(&mem[ad + VRAM_E]);

#ifdef LOG_EGCROP	default:
egcropcnt[egc.ope & 0xff]++;	EGCOPE_SHIFTB;
#endif	egc.mask2.w &= egc.srcmask.w;
data.d[0] = 0;	return(&egc_src);
data.d[1] = 0;
if (egc.ope & 0x80) {
data.d[0] \|= (pat.d[0] & egc_src.d[0] & dst.d[0]);
data.d[1] \|= (pat.d[1] & egc_src.d[1] & dst.d[1]);
}
if (egc.ope & 0x40) {
data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & dst.d[0]);
data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & dst.d[1]);
}
if (egc.ope & 0x20) {
data.d[0] \|= (pat.d[0] & egc_src.d[0] & (~dst.d[0]));
data.d[1] \|= (pat.d[1] & egc_src.d[1] & (~dst.d[1]));
}
if (egc.ope & 0x10) {
data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & (~dst.d[0]));
data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & (~dst.d[1]));
}
if (egc.ope & 0x08) {
data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & dst.d[0]);
data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & dst.d[1]);
}
if (egc.ope & 0x04) {
data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & dst.d[0]);
data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & dst.d[1]);
}
if (egc.ope & 0x02) {
data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & (~dst.d[0]));
data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & (~dst.d[1]));
}
if (egc.ope & 0x01) {
data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & (~dst.d[0]));
data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & (~dst.d[1]));
}	}
egc.mask2.w &= egc.srcmask.w;
break;	break;

	default:
	tmp = value & 0xff;
	tmp = tmp \| (tmp << 8);
	egc_data.w[0] = (UINT16)tmp;
	egc_data.w[1] = (UINT16)tmp;
	egc_data.w[2] = (UINT16)tmp;
	egc_data.w[3] = (UINT16)tmp;
	return(&egc_data);
	}
	}

	static const EGCQUAD * MEMCALL egc_opew(UINT32 ad, REG16 value) {

	UINT tmp;

	egc.mask2.w = egc.mask.w;
	switch(egc.ope & 0x1800) {
	case 0x0800:
	EGCOPE_SHIFTW;
	egc.mask2.w &= egc.srcmask.w;
	tmp = egc.ope & 0xff;
	return((*opefn[tmp])((REG8)tmp, ad));

case 0x1000:	case 0x1000:
switch(egc.fgbg & 0x6000) {	switch(egc.fgbg & 0x6000) {
case 0x2000: // ver0.29	case 0x2000:
data.d[0] = egc.bgc.d[0];	return(&egc.bgc);
data.d[1] = egc.bgc.d[1];
break;	case 0x4000:
case 0x4000: // ver0.29	return(&egc.fgc);
data.d[0] = egc.fgc.d[0];
data.d[1] = egc.fgc.d[1];
break;
default:	default:
#if 0	EGCOPE_SHIFTW;
data.d[0] = egc.patreg.d[0];
data.d[1] = egc.patreg.d[1];
#else
EGCOPE_SHIFT;
data.d[0] = egc_src.d[0];
data.d[1] = egc_src.d[1];
egc.mask2.w &= egc.srcmask.w;	egc.mask2.w &= egc.srcmask.w;
#endif	return(&egc_src);
break;
}	}
break;	break;

default:	default:
data.w[0] = value;	#if defined(BYTESEX_BIG)
data.w[1] = value;	value = ((value >> 8) & 0xff) \| ((value & 0xff) << 8);
data.w[2] = value;	#endif
data.w[3] = value;	egc_data.w[0] = (UINT16)value;
break;	egc_data.w[1] = (UINT16)value;
	egc_data.w[2] = (UINT16)value;
	egc_data.w[3] = (UINT16)value;
	return(&egc_data);
}	}
}	}

BYTE MEMCALL egc_read(UINT32 addr) {	REG8 MEMCALL egc_read(UINT32 addr) {

DWORD ad;
DWORD ext;

// TRACE_("EGC read_byte", (WORD)(addr & 0x7fff));	UINT32 ad;
	UINT ext;

if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
ext = addr & 1;	ext = EGCADDR(addr & 1);
egc.lastvram.b[0][ext] = mem[ad + VRAM_B];	egc.lastvram._b[0][ext] = mem[ad + VRAM_B];
egc.lastvram.b[1][ext] = mem[ad + VRAM_R];	egc.lastvram._b[1][ext] = mem[ad + VRAM_R];
egc.lastvram.b[2][ext] = mem[ad + VRAM_G];	egc.lastvram._b[2][ext] = mem[ad + VRAM_G];
egc.lastvram.b[3][ext] = mem[ad + VRAM_E];	egc.lastvram._b[3][ext] = mem[ad + VRAM_E];

// shift input	// shift input
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
egc.inptr[0] = egc.lastvram.b[0][ext];	egc.inptr[0] = egc.lastvram._b[0][ext];
egc.inptr[4] = egc.lastvram.b[1][ext];	egc.inptr[4] = egc.lastvram._b[1][ext];
egc.inptr[8] = egc.lastvram.b[2][ext];	egc.inptr[8] = egc.lastvram._b[2][ext];
egc.inptr[12] = egc.lastvram.b[3][ext];	egc.inptr[12] = egc.lastvram._b[3][ext];
shiftinput_byte(ext);	shiftinput_byte(ext);
}	}

if ((egc.ope & 0x0300) == 0x0100) {	if ((egc.ope & 0x0300) == 0x0100) {
egc.patreg.b[0][ext] = mem[ad + VRAM_B];	egc.patreg._b[0][ext] = mem[ad + VRAM_B];
egc.patreg.b[1][ext] = mem[ad + VRAM_R];	egc.patreg._b[1][ext] = mem[ad + VRAM_R];
egc.patreg.b[2][ext] = mem[ad + VRAM_G];	egc.patreg._b[2][ext] = mem[ad + VRAM_G];
egc.patreg.b[3][ext] = mem[ad + VRAM_E];	egc.patreg._b[3][ext] = mem[ad + VRAM_E];
}	}
if (!(egc.ope & 0x2000)) {	if (!(egc.ope & 0x2000)) {
int pl = (egc.fgbg >> 8) & 3;	int pl = (egc.fgbg >> 8) & 3;
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
return(egc_src.b[pl][ext]);	return(egc_src._b[pl][ext]);
}	}
else {	else {
return(mem[ad + planead[pl]]);	return(mem[ad + planead[pl]]);
Line 836 BYTE MEMCALL egc_read(UINT32 addr) {	Line 1049 BYTE MEMCALL egc_read(UINT32 addr) {
}	}


void MEMCALL egc_write(UINT32 addr, BYTE value) {	void MEMCALL egc_write(UINT32 addr, REG8 value) {

DWORD ext;	UINT ext;
WORD wvalue;	const EGCQUAD *data;

// TRACE_("EGC write_byte", (WORD)(addr & 0x7fff));	addr = LOW15(addr);
	ext = EGCADDR(addr & 1);
addr &= 0x7fff;
ext = addr & 1;
if (!gdcs.access) {	if (!gdcs.access) {
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
vramupdate[addr] \|= 0x01;	vramupdate[addr] \|= 0x01;
Line 855 void MEMCALL egc_write(UINT32 addr, BYTE	Line 1066 void MEMCALL egc_write(UINT32 addr, BYTE
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
if ((egc.ope & 0x0300) == 0x0200) {	if ((egc.ope & 0x0300) == 0x0200) {
egc.patreg.b[0][ext] = mem[addr + VRAM_B];	egc.patreg._b[0][ext] = mem[addr + VRAM_B];
egc.patreg.b[1][ext] = mem[addr + VRAM_R];	egc.patreg._b[1][ext] = mem[addr + VRAM_R];
egc.patreg.b[2][ext] = mem[addr + VRAM_G];	egc.patreg._b[2][ext] = mem[addr + VRAM_G];
egc.patreg.b[3][ext] = mem[addr + VRAM_E];	egc.patreg._b[3][ext] = mem[addr + VRAM_E];
}	}

wvalue = (value << 8) \| (value); // ver0.28/pr4	data = egc_opeb(addr, value);
if (!ext) {	if (egc.mask2._b[ext]) {
gdc_ope(addr, wvalue, egc.func + 6);
}
else {
gdc_ope(addr, wvalue, egc.func + 6);
}
if (egc.mask2.b[ext]) {
if (!(egc.access & 1)) {	if (!(egc.access & 1)) {
mem[addr + VRAM_B] &= ~egc.mask2.b[ext];	mem[addr + VRAM_B] &= ~egc.mask2._b[ext];
mem[addr + VRAM_B] \|= data.b[0][ext] & egc.mask2.b[ext];	mem[addr + VRAM_B] \|= data->_b[0][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 2)) {	if (!(egc.access & 2)) {
mem[addr + VRAM_R] &= ~egc.mask2.b[ext];	mem[addr + VRAM_R] &= ~egc.mask2._b[ext];
mem[addr + VRAM_R] \|= data.b[1][ext] & egc.mask2.b[ext];	mem[addr + VRAM_R] \|= data->_b[1][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 4)) {	if (!(egc.access & 4)) {
mem[addr + VRAM_G] &= ~egc.mask2.b[ext];	mem[addr + VRAM_G] &= ~egc.mask2._b[ext];
mem[addr + VRAM_G] \|= data.b[2][ext] & egc.mask2.b[ext];	mem[addr + VRAM_G] \|= data->_b[2][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 8)) {	if (!(egc.access & 8)) {
mem[addr + VRAM_E] &= ~egc.mask2.b[ext];	mem[addr + VRAM_E] &= ~egc.mask2._b[ext];
mem[addr + VRAM_E] \|= data.b[3][ext] & egc.mask2.b[ext];	mem[addr + VRAM_E] \|= data->_b[3][ext] & egc.mask2._b[ext];
}	}
}	}
}	}

UINT16 MEMCALL egc_read_w(UINT32 addr) {	REG16 MEMCALL egc_read_w(UINT32 addr) {

DWORD ad;

// TRACE_("EGC read_word", (WORD)(addr & 0x7fff));	UINT32 ad;

if (!(addr & 1)) {	if (!(addr & 1)) {
if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
egc.lastvram.w[0] = (WORD )(&mem[ad + VRAM_B]);	egc.lastvram.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
egc.lastvram.w[1] = (WORD )(&mem[ad + VRAM_R]);	egc.lastvram.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
egc.lastvram.w[2] = (WORD )(&mem[ad + VRAM_G]);	egc.lastvram.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
egc.lastvram.w[3] = (WORD )(&mem[ad + VRAM_E]);	egc.lastvram.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

// shift input	// shift input
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
if (!(egc.sft & 0x1000)) {	if (!(egc.sft & 0x1000)) {
(WORD )(egc.inptr + 0) = egc.lastvram.w[0];	egc.inptr[ 0] = egc.lastvram._b[0][EGCADDR_L];
(WORD )(egc.inptr + 4) = egc.lastvram.w[1];	egc.inptr[ 1] = egc.lastvram._b[0][EGCADDR_H];
(WORD )(egc.inptr + 8) = egc.lastvram.w[2];	egc.inptr[ 4] = egc.lastvram._b[1][EGCADDR_L];
(WORD )(egc.inptr +12) = egc.lastvram.w[3];	egc.inptr[ 5] = egc.lastvram._b[1][EGCADDR_H];
	egc.inptr[ 8] = egc.lastvram._b[2][EGCADDR_L];
	egc.inptr[ 9] = egc.lastvram._b[2][EGCADDR_H];
	egc.inptr[12] = egc.lastvram._b[3][EGCADDR_L];
	egc.inptr[13] = egc.lastvram._b[3][EGCADDR_H];
shiftinput_incw();	shiftinput_incw();
}	}
else {	else {
(WORD )(egc.inptr - 1) = egc.lastvram.w[0];	egc.inptr[-1] = egc.lastvram._b[0][EGCADDR_L];
(WORD )(egc.inptr + 3) = egc.lastvram.w[1];	egc.inptr[ 0] = egc.lastvram._b[0][EGCADDR_H];
(WORD )(egc.inptr + 7) = egc.lastvram.w[2];	egc.inptr[ 3] = egc.lastvram._b[1][EGCADDR_L];
(WORD )(egc.inptr +11) = egc.lastvram.w[3];	egc.inptr[ 4] = egc.lastvram._b[1][EGCADDR_H];
	egc.inptr[ 7] = egc.lastvram._b[2][EGCADDR_L];
	egc.inptr[ 8] = egc.lastvram._b[2][EGCADDR_H];
	egc.inptr[11] = egc.lastvram._b[3][EGCADDR_L];
	egc.inptr[12] = egc.lastvram._b[3][EGCADDR_H];
shiftinput_decw();	shiftinput_decw();
}	}
}	}
Line 929 UINT16 MEMCALL egc_read_w(UINT32 addr) {	Line 1140 UINT16 MEMCALL egc_read_w(UINT32 addr) {
if (!(egc.ope & 0x2000)) {	if (!(egc.ope & 0x2000)) {
int pl = (egc.fgbg >> 8) & 3;	int pl = (egc.fgbg >> 8) & 3;
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
return(egc_src.w[pl]);	return(LOADINTELWORD(egc_src._b[pl]));
}	}
else {	else {
return((WORD )(&mem[ad + planead[pl]]));	return(LOADINTELWORD(mem + ad + planead[pl]));
}	}
}	}
return((WORD )(&mem[addr]));	return(LOADINTELWORD(mem + addr));
}	}
else if (!(egc.sft & 0x1000)) {	else if (!(egc.sft & 0x1000)) {
WORD ret;	REG16 ret;
ret = egc_read(addr);	ret = egc_read(addr);
ret \|= egc_read(addr+1) << 8;	ret \|= egc_read(addr+1) << 8;
return(ret);	return(ret);
}	}
else {	else {
WORD ret;	REG16 ret;
ret = egc_read(addr+1) << 8;	ret = egc_read(addr+1) << 8;
ret \|= egc_read(addr);	ret \|= egc_read(addr);
return(ret);	return(ret);
}	}
}	}

void MEMCALL egc_write_w(UINT32 addr, UINT16 value) {	void MEMCALL egc_write_w(UINT32 addr, REG16 value) {

// TRACE_("EGC write_word", (WORD)(addr & 0x7fff));	const EGCQUAD *data;

if (!(addr & 1)) { // word access	if (!(addr & 1)) { // word access
addr &= 0x7ffe;	addr = LOW15(addr);
if (!gdcs.access) {	if (!gdcs.access) {
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
(WORD )(&vramupdate[addr]) \|= 0x0101;	(UINT16 )(vramupdate + addr) \|= 0x0101;
}	}
else {	else {
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
(WORD )(&vramupdate[addr]) \|= 0x0202;	(UINT16 )(vramupdate + addr) \|= 0x0202;
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
if ((egc.ope & 0x0300) == 0x0200) {	if ((egc.ope & 0x0300) == 0x0200) {
egc.patreg.w[0] = (WORD )(&mem[addr + VRAM_B]);	egc.patreg.w[0] = (UINT16 )(&mem[addr + VRAM_B]);
egc.patreg.w[1] = (WORD )(&mem[addr + VRAM_R]);	egc.patreg.w[1] = (UINT16 )(&mem[addr + VRAM_R]);
egc.patreg.w[2] = (WORD )(&mem[addr + VRAM_G]);	egc.patreg.w[2] = (UINT16 )(&mem[addr + VRAM_G]);
egc.patreg.w[3] = (WORD )(&mem[addr + VRAM_E]);	egc.patreg.w[3] = (UINT16 )(&mem[addr + VRAM_E]);
}	}
gdc_ope(addr, value, egc.func);	data = egc_opew(addr, value);
if (egc.mask2.w) {	if (egc.mask2.w) {
if (!(egc.access & 1)) {	if (!(egc.access & 1)) {
(WORD )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;
(WORD )(&mem[addr + VRAM_B]) \|= data.w[0] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_B]) \|= data->w[0] & egc.mask2.w;
}	}
if (!(egc.access & 2)) {	if (!(egc.access & 2)) {
(WORD )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;
(WORD )(&mem[addr + VRAM_R]) \|= data.w[1] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_R]) \|= data->w[1] & egc.mask2.w;
}	}
if (!(egc.access & 4)) {	if (!(egc.access & 4)) {
(WORD )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;
(WORD )(&mem[addr + VRAM_G]) \|= data.w[2] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_G]) \|= data->w[2] & egc.mask2.w;
}	}
if (!(egc.access & 8)) {	if (!(egc.access & 8)) {
(WORD )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;
(WORD )(&mem[addr + VRAM_E]) \|= data.w[3] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_E]) \|= data->w[3] & egc.mask2.w;
}	}
}	}
}	}
else if (!(egc.sft & 0x1000)) {	else if (!(egc.sft & 0x1000)) {
egc_write(addr, (BYTE)value);	egc_write(addr, (REG8)value);
egc_write(addr+1, (BYTE)(value >> 8));	egc_write(addr+1, (REG8)(value >> 8));
}	}
else {	else {
egc_write(addr+1, (BYTE)(value >> 8));	egc_write(addr+1, (REG8)(value >> 8));
egc_write(addr, (BYTE)value);	egc_write(addr, (REG8)value);
}	}
}	}

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.1
changed lines
	Added in v.1.10