--- np2/i286c/memory.c	2003/10/19 14:56:15	1.2
+++ np2/i286c/memory.c	2003/12/01 10:45:46	1.7
@@ -9,34 +9,35 @@
 
 
 #define	USE_HIMEM
+// #define	MEMORY_DEBUG
 
 // ---- write byte
 
-static void MEMCALL i286_wt(UINT32 address, BYTE value) {
+static void MEMCALL i286_wt(UINT32 address, REG8 value) {
 
-	mem[address & extmem.adrsmask] = value;
+	mem[address & i286core.s.adrsmask] = (BYTE)value;
 }
 
-static void MEMCALL tram_wt(UINT32 address, BYTE value) {
+static void MEMCALL tram_wt(UINT32 address, REG8 value) {
 
 	I286_REMCLOCK -= vramop.tramwait;
 	if (address < 0xa2000) {
-		mem[address] = value;
-		tramupdate[(address >> 1) & 0x0fff] = 1;
+		mem[address] = (BYTE)value;
+		tramupdate[LOW12(address >> 1)] = 1;
 		gdcs.textdisp |= 1;
 	}
 	else if (address < 0xa3fe0) {
 		if (!(address & 1)) {
-			mem[address] = value;
-			tramupdate[(address >> 1) & 0x0fff] = 1;
+			mem[address] = (BYTE)value;
+			tramupdate[LOW12(address >> 1)] = 1;
 			gdcs.textdisp |= 1;
 		}
 	}
 	else if (address < 0xa4000) {
 		if (!(address & 1)) {
 			if ((!(address & 2)) || (gdcs.msw_accessable)) {
-				mem[address] = value;
-				tramupdate[(address >> 1) & 0x0fff] = 1;
+				mem[address] = (BYTE)value;
+				tramupdate[LOW12(address >> 1)] = 1;
 				gdcs.textdisp |= 1;
 			}
 		}
@@ -44,35 +45,35 @@ static void MEMCALL tram_wt(UINT32 addre
 	else if (address < 0xa5000) {
 		if ((address & 1) && (cgwindow.writable & 1)) {
 			cgwindow.writable |= 0x80;
-			font[cgwindow.high + ((address >> 1) & 0x0f)] = value;
+			fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
 		}
 	}
 }
 
-static void MEMCALL vram_w0(UINT32 address, BYTE value) {
+static void MEMCALL vram_w0(UINT32 address, REG8 value) {
 
 	I286_REMCLOCK -= vramop.vramwait;
-	mem[address] = value;
-	vramupdate[address & 0x7fff] |= 1;
+	mem[address] = (BYTE)value;
+	vramupdate[LOW15(address)] |= 1;
 	gdcs.grphdisp |= 1;
 }
 
-static void MEMCALL vram_w1(UINT32 address, BYTE value) {
+static void MEMCALL vram_w1(UINT32 address, REG8 value) {
 
 	I286_REMCLOCK -= vramop.vramwait;
-	mem[address + VRAM_STEP] = value;
-	vramupdate[address & 0x7fff] |= 2;
+	mem[address + VRAM_STEP] = (BYTE)value;
+	vramupdate[LOW15(address)] |= 2;
 	gdcs.grphdisp |= 2;
 }
 
-static void MEMCALL grcg_rmw0(UINT32 address, BYTE value) {
+static void MEMCALL grcg_rmw0(UINT32 address, REG8 value) {
 
-	BYTE	mask;
+	REG8	mask;
 	BYTE	*vram;
 
 	I286_REMCLOCK -= vramop.grcgwait;
 	mask = ~value;
-	address &= 0x7fff;
+	address = LOW15(address);
 	vramupdate[address] |= 1;
 	gdcs.grphdisp |= 1;
 	vram = mem + address;
@@ -94,14 +95,14 @@ static void MEMCALL grcg_rmw0(UINT32 add
 	}
 }
 
-static void MEMCALL grcg_rmw1(UINT32 address, BYTE value) {
+static void MEMCALL grcg_rmw1(UINT32 address, REG8 value) {
 
-	BYTE	mask;
+	REG8	mask;
 	BYTE	*vram;
 
 	I286_REMCLOCK -= vramop.grcgwait;
 	mask = ~value;
-	address &= 0x7fff;
+	address = LOW15(address);
 	vramupdate[address] |= 2;
 	gdcs.grphdisp |= 2;
 	vram = mem + address;
@@ -123,12 +124,12 @@ static void MEMCALL grcg_rmw1(UINT32 add
 	}
 }
 
-static void MEMCALL grcg_tdw0(UINT32 address, BYTE value) {
+static void MEMCALL grcg_tdw0(UINT32 address, REG8 value) {
 
 	BYTE	*vram;
 
 	I286_REMCLOCK -= vramop.grcgwait;
-	address &= 0x7fff;
+	address = LOW15(address);
 	vramupdate[address] |= 1;
 	gdcs.grphdisp |= 1;
 	vram = mem + address;
@@ -147,12 +148,12 @@ static void MEMCALL grcg_tdw0(UINT32 add
 	(void)value;
 }
 
-static void MEMCALL grcg_tdw1(UINT32 address, BYTE value) {
+static void MEMCALL grcg_tdw1(UINT32 address, REG8 value) {
 
 	BYTE	*vram;
 
 	I286_REMCLOCK -= vramop.grcgwait;
-	address &= 0x7fff;
+	address = LOW15(address);
 	vramupdate[address] |= 2;
 	gdcs.grphdisp |= 2;
 	vram = mem + address;
@@ -171,17 +172,17 @@ static void MEMCALL grcg_tdw1(UINT32 add
 	(void)value;
 }
 
-static void MEMCALL egc_wt(UINT32 address, BYTE value) {
+static void MEMCALL egc_wt(UINT32 address, REG8 value) {
 
 	egc_write(address, value);
 }
 
-static void MEMCALL emmc_wt(UINT32 address, BYTE value) {
+static void MEMCALL emmc_wt(UINT32 address, REG8 value) {
 
-	extmem.pageptr[(address >> 14) & 3][address & 0x3fff] = value;
+	extmem.pageptr[(address >> 14) & 3][LOW14(address)] = (BYTE)value;
 }
 
-static void MEMCALL i286_wn(UINT32 address, BYTE value) {
+static void MEMCALL i286_wn(UINT32 address, REG8 value) {
 
 	(void)address;
 	(void)value;
@@ -190,12 +191,12 @@ static void MEMCALL i286_wn(UINT32 addre
 
 // ---- read byte
 
-static BYTE MEMCALL i286_rd(UINT32 address) {
+static REG8 MEMCALL i286_rd(UINT32 address) {
 
-	return(mem[address & extmem.adrsmask]);
+	return(mem[address & i286core.s.adrsmask]);
 }
 
-static BYTE MEMCALL tram_rd(UINT32 address) {
+static REG8 MEMCALL tram_rd(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.tramwait;
 	if (address < 0xa4000) {
@@ -203,34 +204,34 @@ static BYTE MEMCALL tram_rd(UINT32 addre
 	}
 	else if (address < 0xa5000) {
 		if (address & 1) {
-			return(font[cgwindow.high + ((address >> 1) & 0x0f)]);
+			return(fontrom[cgwindow.high + ((address >> 1) & 0x0f)]);
 		}
 		else {
-			return(font[cgwindow.low + ((address >> 1) & 0x0f)]);
+			return(fontrom[cgwindow.low + ((address >> 1) & 0x0f)]);
 		}
 	}
 	return(mem[address]);
 }
 
-static BYTE MEMCALL vram_r0(UINT32 address) {
+static REG8 MEMCALL vram_r0(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.vramwait;
 	return(mem[address]);
 }
 
-static BYTE MEMCALL vram_r1(UINT32 address) {
+static REG8 MEMCALL vram_r1(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.vramwait;
 	return(mem[address + VRAM_STEP]);
 }
 
-static BYTE MEMCALL grcg_tcr0(UINT32 address) {
+static REG8 MEMCALL grcg_tcr0(UINT32 address) {
 
 const BYTE	*vram;
-	BYTE	ret;
+	REG8	ret;
 
 	I286_REMCLOCK -= vramop.grcgwait;
-	vram = mem + (address & 0x7fff);
+	vram = mem + LOW15(address);
 	ret = 0;
 	if (!(grcg.modereg & 1)) {
 		ret |= vram[VRAM0_B] ^ grcg.tile[0].b[0];
@@ -244,17 +245,17 @@ const BYTE	*vram;
 	if (!(grcg.modereg & 8)) {
 		ret |= vram[VRAM0_E] ^ grcg.tile[3].b[0];
 	}
-	return(~ret);
+	return(ret ^ 0xff);
 }
 
-static BYTE MEMCALL grcg_tcr1(UINT32 address) {
+static REG8 MEMCALL grcg_tcr1(UINT32 address) {
 
-	BYTE	*vram;
-	BYTE	ret;
+const BYTE	*vram;
+	REG8	ret;
 
 	I286_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
-	vram = mem + (address & 0x7fff);
+	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
 		ret |= vram[VRAM1_B] ^ grcg.tile[0].b[0];
 	}
@@ -267,23 +268,23 @@ static BYTE MEMCALL grcg_tcr1(UINT32 add
 	if (!(grcg.modereg & 8)) {
 		ret |= vram[VRAM1_E] ^ grcg.tile[3].b[0];
 	}
-	return(~ret);
+	return(ret ^ 0xff);
 }
 
-static BYTE MEMCALL egc_rd(UINT32 address) {
+static REG8 MEMCALL egc_rd(UINT32 address) {
 
 	return(egc_read(address));
 }
 
-static BYTE MEMCALL emmc_rd(UINT32 address) {
+static REG8 MEMCALL emmc_rd(UINT32 address) {
 
-	return(extmem.pageptr[(address >> 14) & 3][address & 0x3fff]);
+	return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);
 }
 
-static BYTE MEMCALL i286_itf(UINT32 address) {
+static REG8 MEMCALL i286_itf(UINT32 address) {
 
-	if (itf.bank) {
-		address = ITF_ADRS + (address & 0x7fff);
+	if (i286core.s.itfbank) {
+		address = ITF_ADRS + LOW15(address);
 	}
 	return(mem[address]);
 }
@@ -291,20 +292,20 @@ static BYTE MEMCALL i286_itf(UINT32 addr
 
 // ---- write word
 
-static void MEMCALL i286w_wt(UINT32 address, UINT16 value) {
+static void MEMCALL i286w_wt(UINT32 address, REG16 value) {
 
 	BYTE	*ptr;
 
-	ptr = mem + (address & extmem.adrsmask);
+	ptr = mem + (address & i286core.s.adrsmask);
 	STOREINTELWORD(ptr, value);
 }
 
-static void MEMCALL tramw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL tramw_wt(UINT32 address, REG16 value) {
 
 	if (address < 0xa1fff) {
 		STOREINTELWORD(mem + address, value);
-		tramupdate[(address >> 1) & 0x0fff] = 1;
-		tramupdate[((address + 1) >> 1) & 0x0fff] = 1;
+		tramupdate[LOW12(address >> 1)] = 1;
+		tramupdate[LOW12((address + 1) >> 1)] = 1;
 		gdcs.textdisp |= 1;
 	}
 	else if (address == 0xa1fff) {
@@ -319,7 +320,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 			value >>= 8;
 		}
 		mem[address] = (BYTE)value;
-		tramupdate[(address >> 1) & 0x0fff] = 1;
+		tramupdate[LOW12(address >> 1)] = 1;
 		gdcs.textdisp |= 1;
 	}
 	else if (address < 0xa3fff) {
@@ -329,7 +330,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 		}
 		if ((!(address & 2)) || (gdcs.msw_accessable)) {
 			mem[address] = (BYTE)value;
-			tramupdate[(address >> 1) & 0x0fff] = 1;
+			tramupdate[LOW12(address >> 1)] = 1;
 			gdcs.textdisp |= 1;
 		}
 	}
@@ -339,7 +340,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 		}
 		if (cgwindow.writable & 1) {
 			cgwindow.writable |= 0x80;
-			font[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
+			fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
 		}
 	}
 }
@@ -348,15 +349,15 @@ static void MEMCALL tramw_wt(UINT32 addr
 #define GRCGW_NON(page) {											\
 	I286_REMCLOCK -= vramop.vramwait;								\
 	STOREINTELWORD(mem + address + VRAM_STEP*(page), value);		\
-	vramupdate[address & 0x7fff] |= (1 << page);					\
-	vramupdate[(address + 1) & 0x7fff] |= (1 << page);				\
+	vramupdate[LOW15(address)] |= (1 << page);						\
+	vramupdate[LOW15(address + 1)] |= (1 << page);					\
 	gdcs.grphdisp |= (1 << page);									\
 }
 
 #define GRCGW_RMW(page) {											\
 	BYTE	*vram;													\
 	I286_REMCLOCK -= vramop.grcgwait;								\
-	address &= 0x7fff;												\
+	address = LOW15(address);										\
 	vramupdate[address] |= (1 << page);								\
 	vramupdate[address + 1] |= (1 << page);							\
 	gdcs.grphdisp |= (1 << page);									\
@@ -402,7 +403,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 #define GRCGW_TDW(page) {											\
 	BYTE	*vram;													\
 	I286_REMCLOCK -= vramop.grcgwait;								\
-	address &= 0x7fff;												\
+	address = LOW15(address);										\
 	vramupdate[address] |= (1 << page);								\
 	vramupdate[address + 1] |= (1 << page);							\
 	gdcs.grphdisp |= (1 << page);									\
@@ -426,45 +427,45 @@ static void MEMCALL tramw_wt(UINT32 addr
 	(void)value;													\
 }
 
-static void MEMCALL vramw_w0(UINT32 address, UINT16 value) GRCGW_NON(0)
-static void MEMCALL vramw_w1(UINT32 address, UINT16 value) GRCGW_NON(1)
-static void MEMCALL grcgw_rmw0(UINT32 address, UINT16 value) GRCGW_RMW(0)
-static void MEMCALL grcgw_rmw1(UINT32 address, UINT16 value) GRCGW_RMW(1)
-static void MEMCALL grcgw_tdw0(UINT32 address, UINT16 value) GRCGW_TDW(0)
-static void MEMCALL grcgw_tdw1(UINT32 address, UINT16 value) GRCGW_TDW(1)
+static void MEMCALL vramw_w0(UINT32 address, REG16 value) GRCGW_NON(0)
+static void MEMCALL vramw_w1(UINT32 address, REG16 value) GRCGW_NON(1)
+static void MEMCALL grcgw_rmw0(UINT32 address, REG16 value) GRCGW_RMW(0)
+static void MEMCALL grcgw_rmw1(UINT32 address, REG16 value) GRCGW_RMW(1)
+static void MEMCALL grcgw_tdw0(UINT32 address, REG16 value) GRCGW_TDW(0)
+static void MEMCALL grcgw_tdw1(UINT32 address, REG16 value) GRCGW_TDW(1)
 
-static void MEMCALL egcw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL egcw_wt(UINT32 address, REG16 value) {
 
 	if (!(address & 1)) {
 		egc_write_w(address, value);
 	}
 	else {
 		if (!(egc.sft & 0x1000)) {
-			egc_write(address, (BYTE)value);
-			egc_write(address + 1, (BYTE)(value >> 8));
+			egc_write(address, (REG8)value);
+			egc_write(address + 1, (REG8)(value >> 8));
 		}
 		else {
-			egc_write(address + 1, (BYTE)(value >> 8));
-			egc_write(address, (BYTE)value);
+			egc_write(address + 1, (REG8)(value >> 8));
+			egc_write(address, (REG8)value);
 		}
 	}
 }
 
-static void MEMCALL emmcw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL emmcw_wt(UINT32 address, REG16 value) {
 
 	BYTE	*ptr;
 
 	if ((address & 0x3fff) != 0x3fff) {
-		ptr = extmem.pageptr[(address >> 14) & 3] + (address & 0x3fff);
+		ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
 		STOREINTELWORD(ptr, value);
 	}
 	else {
 		extmem.pageptr[(address >> 14) & 3][0x3fff] = (BYTE)value;
-		extmem.pageptr[((address + 1)>> 14) & 3][0] = (BYTE)(value >> 8);
+		extmem.pageptr[((address + 1) >> 14) & 3][0] = (BYTE)(value >> 8);
 	}
 }
 
-static void MEMCALL i286w_wn(UINT32 address, UINT16 value) {
+static void MEMCALL i286w_wn(UINT32 address, REG16 value) {
 
 	(void)address;
 	(void)value;
@@ -473,63 +474,63 @@ static void MEMCALL i286w_wn(UINT32 addr
 
 // ---- read word
 
-static UINT16 MEMCALL i286w_rd(UINT32 address) {
+static REG16 MEMCALL i286w_rd(UINT32 address) {
 
 	BYTE	*ptr;
 
-	ptr = mem + (address & extmem.adrsmask);
+	ptr = mem + (address & i286core.s.adrsmask);
 	return(LOADINTELWORD(ptr));
 }
 
-static UINT16 MEMCALL tramw_rd(UINT32 address) {
+static REG16 MEMCALL tramw_rd(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.tramwait;
 	if (address < (0xa4000 - 1)) {
 		return(LOADINTELWORD(mem + address));
 	}
 	else if (address == 0xa3fff) {
-		return(mem[address] + (font[cgwindow.low] << 8));
+		return(mem[address] + (fontrom[cgwindow.low] << 8));
 	}
 	else if (address < 0xa4fff) {
 		if (address & 1) {
-			UINT16 ret;
-			ret = font[cgwindow.high + ((address >> 1) & 0x0f)];
-			ret += font[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
+			REG16 ret;
+			ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];
+			ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
 			return(ret);
 		}
 		else {
-			UINT16 ret;
-			ret = font[cgwindow.low + ((address >> 1) & 0x0f)];
-			ret += font[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
+			REG16 ret;
+			ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];
+			ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
 			return(ret);
 		}
 	}
 	else if (address == 0xa4fff) {
-		return((mem[0xa5000] << 8) | font[cgwindow.high + 15]);
+		return((mem[0xa5000] << 8) | fontrom[cgwindow.high + 15]);
 	}
 	return(LOADINTELWORD(mem + address));
 }
 
-static UINT16 MEMCALL vramw_r0(UINT32 address) {
+static REG16 MEMCALL vramw_r0(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.vramwait;
 	return(LOADINTELWORD(mem + address));
 }
 
-static UINT16 MEMCALL vramw_r1(UINT32 address) {
+static REG16 MEMCALL vramw_r1(UINT32 address) {
 
 	I286_REMCLOCK -= vramop.vramwait;
 	return(LOADINTELWORD(mem + address + VRAM_STEP));
 }
 
-static UINT16 MEMCALL grcgw_tcr0(UINT32 address) {
+static REG16 MEMCALL grcgw_tcr0(UINT32 address) {
 
 	BYTE	*vram;
-	UINT16	ret;
+	REG16	ret;
 
 	I286_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
-	vram = mem + (address & 0x7fff);
+	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
 		ret |= LOADINTELWORD(vram + VRAM0_B) ^ grcg.tile[0].w;
 	}
@@ -542,17 +543,17 @@ static UINT16 MEMCALL grcgw_tcr0(UINT32 
 	if (!(grcg.modereg & 8)) {
 		ret |= LOADINTELWORD(vram + VRAM0_E) ^ grcg.tile[3].w;
 	}
-	return(~ret);
+	return((UINT16)~ret);
 }
 
-static UINT16 MEMCALL grcgw_tcr1(UINT32 address) {
+static REG16 MEMCALL grcgw_tcr1(UINT32 address) {
 
 	BYTE	*vram;
-	UINT16	ret;
+	REG16	ret;
 
 	I286_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
-	vram = mem + (address & 0x7fff);
+	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
 		ret |= LOADINTELWORD(vram + VRAM1_B) ^ grcg.tile[0].w;
 	}
@@ -565,12 +566,12 @@ static UINT16 MEMCALL grcgw_tcr1(UINT32 
 	if (!(grcg.modereg & 8)) {
 		ret |= LOADINTELWORD(vram + VRAM1_E) ^ grcg.tile[3].w;
 	}
-	return(~ret);
+	return((UINT16)(~ret));
 }
 
-static UINT16 MEMCALL egcw_rd(UINT32 address) {
+static REG16 MEMCALL egcw_rd(UINT32 address) {
 
-	UINT16 ret;
+	REG16	ret;
 
 	if (!(address & 1)) {
 		return(egc_read_w(address));
@@ -578,30 +579,29 @@ static UINT16 MEMCALL egcw_rd(UINT32 add
 	else {
 		if (!(egc.sft & 0x1000)) {
 			ret = egc_read(address);
-			ret += (UINT16)egc_read(address + 1) << 8;
+			ret += egc_read(address + 1) << 8;
 			return(ret);
 		}
 		else {
-			UINT16 ret;
-			ret = (UINT16)egc_read(address + 1) << 8;
+			ret = egc_read(address + 1) << 8;
 			ret += egc_read(address);
 			return(ret);
 		}
 	}
 }
 
-static UINT16 MEMCALL emmcw_rd(UINT32 address) {
+static REG16 MEMCALL emmcw_rd(UINT32 address) {
 
 	BYTE	*ptr;
 
-	ptr = extmem.pageptr[(address >> 14) & 3] + (address & 0x3fff);
+	ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
 	return(LOADINTELWORD(ptr));
 }
 
-static UINT16 MEMCALL i286w_itf(UINT32 address) {
+static REG16 MEMCALL i286w_itf(UINT32 address) {
 
-	if (itf.bank) {
-		address = ITF_ADRS + (address & 0x7fff);
+	if (i286core.s.itfbank) {
+		address = ITF_ADRS + LOW15(address);
 	}
 	return(LOADINTELWORD(mem + address));
 }
@@ -609,10 +609,10 @@ static UINT16 MEMCALL i286w_itf(UINT32 a
 
 // ---- table
 
-typedef void (MEMCALL * MEM8WRITE)(UINT32 address, BYTE value);
-typedef BYTE (MEMCALL * MEM8READ)(UINT32 address);
-typedef void (MEMCALL * MEM16WRITE)(UINT32 address, UINT16 value);
-typedef UINT16 (MEMCALL * MEM16READ)(UINT32 address);
+typedef void (MEMCALL * MEM8WRITE)(UINT32 address, REG8 value);
+typedef REG8 (MEMCALL * MEM8READ)(UINT32 address);
+typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);
+typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);
 
 static MEM8WRITE memory_write[] = {
 			i286_wt,	i286_wt,	i286_wt,	i286_wt,		// 00
@@ -679,13 +679,13 @@ static const MEM16READ vramw_read[] = {
 			vramw_r0,	vramw_r1,	egcw_rd,	egcw_rd};		// c0 rmw
 
 
-static BYTE MEMCALL i286_nonram_r(UINT32 address) {
+static REG8 MEMCALL i286_nonram_r(UINT32 address) {
 
 	(void)address;
 	return(0xff);
 }
 
-static UINT16 MEMCALL i286_nonram_rw(UINT32 address) {
+static REG16 MEMCALL i286_nonram_rw(UINT32 address) {
 
 	(void)address;
 	return(0xffff);
@@ -724,7 +724,91 @@ void MEMCALL i286_vram_dispatch(UINT fun
 	}
 }
 
-BYTE MEMCALL i286_memoryread(UINT32 address) {
+#if defined(MEMORY_DEBUG)
+static REG8 MEMCALL _i286_memoryread(UINT32 address) {
+
+	if (address < I286_MEMREADMAX) {
+		return(mem[address]);
+	}
+#if defined(USE_HIMEM)
+	else if (address >= 0x10fff0) {
+		address -= 0x100000;
+		if (address < extmemmng_size) {
+			return(extmemmng_ptr[address]);
+		}
+		else {
+			return(0xff);
+		}
+	}
+#endif
+	else {
+		return(memory_read[(address >> 15) & 0x1f](address));
+	}
+}
+
+static REG16 MEMCALL _i286_memoryread_w(UINT32 address) {
+
+	REG16	ret;
+
+	if (address < (I286_MEMREADMAX - 1)) {
+		return(LOADINTELWORD(mem + address));
+	}
+#if defined(USE_HIMEM)
+	else if (address >= (0x10fff0 - 1)) {
+		address -= 0x100000;
+		if (address == (0x00fff0 - 1)) {
+			ret = mem[0x100000 + address];
+		}
+		else if (address < extmemmng_size) {
+			ret = extmemmng_ptr[address];
+		}
+		else {
+			ret = 0xff;
+		}
+		address++;
+		if (address < extmemmng_size) {
+			ret += extmemmng_ptr[address] << 8;
+		}
+		else {
+			ret += 0xff00;
+		}
+		return(ret);
+	}
+#endif
+	else if ((address & 0x7fff) != 0x7fff) {
+		return(memword_read[(address >> 15) & 0x1f](address));
+	}
+	else {
+		ret = memory_read[(address >> 15) & 0x1f](address);
+		address++;
+		ret += memory_read[(address >> 15) & 0x1f](address) << 8;
+		return(ret);
+	}
+}
+
+REG8 MEMCALL i286_memoryread(UINT32 address) {
+
+	REG8	r;
+
+	r = _i286_memoryread(address);
+	if (r & 0xffffff00) {
+		TRACEOUT(("error i286_memoryread %x %x", address, r));
+	}
+	return(r);
+}
+
+REG16 MEMCALL i286_memoryread_w(UINT32 address) {
+
+	REG16	r;
+
+	r = _i286_memoryread_w(address);
+	if (r & 0xffff0000) {
+		TRACEOUT(("error i286_memoryread_w %x %x", address, r));
+	}
+	return(r);
+}
+#else
+REG8 MEMCALL i286_memoryread(UINT32 address) {
 
 	if (address < I286_MEMREADMAX) {
 		return(mem[address]);
@@ -745,9 +829,9 @@ BYTE MEMCALL i286_memoryread(UINT32 addr
 	}
 }
 
-UINT16 MEMCALL i286_memoryread_w(UINT32 address) {
+REG16 MEMCALL i286_memoryread_w(UINT32 address) {
 
-	UINT16	ret;
+	REG16	ret;
 
 	if (address < (I286_MEMREADMAX - 1)) {
 		return(LOADINTELWORD(mem + address));
@@ -784,17 +868,18 @@ UINT16 MEMCALL i286_memoryread_w(UINT32 
 		return(ret);
 	}
 }
+#endif
 
-void MEMCALL i286_memorywrite(UINT32 address, BYTE value) {
+void MEMCALL i286_memorywrite(UINT32 address, REG8 value) {
 
 	if (address < I286_MEMWRITEMAX) {
-		mem[address] = value;
+		mem[address] = (BYTE)value;
 	}
 #if defined(USE_HIMEM)
 	else if (address >= 0x10fff0) {
 		address -= 0x100000;
 		if (address < extmemmng_size) {
-			extmemmng_ptr[address] = value;
+			extmemmng_ptr[address] = (BYTE)value;
 		}
 	}
 #endif
@@ -803,7 +888,7 @@ void MEMCALL i286_memorywrite(UINT32 add
 	}
 }
 
-void MEMCALL i286_memorywrite_w(UINT32 address, UINT16 value) {
+void MEMCALL i286_memorywrite_w(UINT32 address, REG16 value) {
 
 	if (address < (I286_MEMWRITEMAX - 1)) {
 		STOREINTELWORD(mem + address, value);
@@ -833,7 +918,7 @@ void MEMCALL i286_memorywrite_w(UINT32 a
 	}
 }
 
-BYTE MEMCALL i286_membyte_read(UINT seg, UINT off) {
+REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {
 
 	UINT32	address;
 
@@ -846,7 +931,7 @@ BYTE MEMCALL i286_membyte_read(UINT seg,
 	}
 }
 
-UINT16 MEMCALL i286_memword_read(UINT seg, UINT off) {
+REG16 MEMCALL i286_memword_read(UINT seg, UINT off) {
 
 	UINT32	address;
 
@@ -859,26 +944,26 @@ UINT16 MEMCALL i286_memword_read(UINT se
 	}
 }
 
-void MEMCALL i286_membyte_write(UINT seg, UINT off, BYTE value) {
+void MEMCALL i286_membyte_write(UINT seg, UINT off, REG8 value) {
 
 	UINT32	address;
 
 	address = (seg << 4) + off;
 	if (address < I286_MEMWRITEMAX) {
-		mem[address] = value;
+		mem[address] = (BYTE)value;
 	}
 	else {
 		i286_memorywrite(address, value);
 	}
 }
 
-void MEMCALL i286_memword_write(UINT seg, UINT off, UINT16 value) {
+void MEMCALL i286_memword_write(UINT seg, UINT off, REG16 value) {
 
 	UINT32	address;
 
 	address = (seg << 4) + off;
 	if (address < (I286_MEMWRITEMAX - 1)) {
-		STOREINTELWORD(mem + address,  value);
+		STOREINTELWORD(mem + address, value);
 	}
 	else {
 		i286_memorywrite_w(address, value);
@@ -917,7 +1002,7 @@ void MEMCALL i286_memstr_read(UINT seg, 
 	else {
 		while(leng--) {
 			*out++ = i286_memoryread(adrs + off);
-			off = (off + 1) & 0xffff;
+			off = LOW16(off + 1);
 		}
 	}
 }
@@ -955,7 +1040,7 @@ void MEMCALL i286_memstr_write(UINT seg,
 	else {
 		while(leng--) {
 			i286_memorywrite(adrs + off, *out++);
-			off = (off + 1) & 0xffff;
+			off = LOW16(off + 1);
 		}
 	}
 }