--- np2/statsave.c	2003/10/16 17:57:09	1.1
+++ np2/statsave.c	2004/01/05 09:31:24	1.25
@@ -4,22 +4,22 @@
 #include	"scrnmng.h"
 #include	"soundmng.h"
 #include	"timemng.h"
-#include	"i286.h"
-#include	"memory.h"
+#include	"cpucore.h"
 #include	"pccore.h"
 #include	"iocore.h"
 #include	"cbuscore.h"
 #include	"pc9861k.h"
 #include	"mpu98ii.h"
 #include	"board14.h"
+#include	"amd98.h"
+#include	"bios.h"
 #include	"vram.h"
-#include	"maketext.h"
 #include	"palettes.h"
-#include	"font.h"
+#include	"maketext.h"
 #include	"sound.h"
-#include	"bios.h"
 #include	"fmboard.h"
 #include	"beep.h"
+#include	"font.h"
 #include	"fddfile.h"
 #include	"fdd_mtr.h"
 #include	"sxsi.h"
@@ -28,6 +28,18 @@
 #include	"keydisp.h"
 
 
+#if defined(MACOS)
+#define	CRLITERAL	"\r"
+#define	CRCONST		str_cr
+#elif defined(WIN32) || defined(X11) || defined(SLZAURUS)
+#define	CRLITERAL	"\n"
+#define	CRCONST		str_lf
+#else
+#define	CRLITERAL	"\r\n"
+#define	CRCONST		str_crlf
+#endif
+
+
 typedef struct {
 	char	name[16];
 	char	vername[28];
@@ -38,22 +50,25 @@ typedef struct {
 	char	index[10];
 	UINT16	ver;
 	UINT32	size;
-} NP2FLAGPART_T;
+} NP2FENT;
 
 enum {
 	NP2FLAG_BIN			= 0,
 	NP2FLAG_TERM,
-	NP2FLAG_286,
-	NP2FLAG_CORE,
+#if defined(CGWND_FONTPTR)
+	NP2FLAG_CGW,
+#endif
+	NP2FLAG_CLOCK,
+	NP2FLAG_COM,
+	NP2FLAG_DISK,
 	NP2FLAG_DMA,
 	NP2FLAG_EGC,
-	NP2FLAG_EXT,
+	NP2FLAG_EPSON,
 	NP2FLAG_EVT,
-	NP2FLAG_GIJ,
+	NP2FLAG_EXT,
 	NP2FLAG_FM,
-	NP2FLAG_BEEP,
-	NP2FLAG_MIDI,
-	NP2FLAG_DISK
+	NP2FLAG_GIJ,
+	NP2FLAG_MEM
 };
 
 typedef struct {
@@ -74,9 +89,9 @@ typedef struct {
 	int		num;
 } ENUMTBL;
 
-#define	PROCID(a, b, c, d)	(((d) << 24) | ((c) << 16) | ((b) << 8) | (a))
-#define	PROC2NUM(a, b)		proc2num(&(a), b, sizeof(b)/sizeof(PROCTBL))
-#define	NUM2PROC(a, b)		num2proc(&(a), b, sizeof(b)/sizeof(PROCTBL))
+#define	PROCID(a, b, c, d)	(((d) << 24) + ((c) << 16) + ((b) << 8) + (a))
+#define	PROC2NUM(a, b)		proc2num(&(a), (b), sizeof(b)/sizeof(PROCTBL))
+#define	NUM2PROC(a, b)		num2proc(&(a), (b), sizeof(b)/sizeof(PROCTBL))
 
 #include "statsave.tbl"
 
@@ -91,9 +106,10 @@ typedef struct {
 
 static void err_append(ERR_BUF *e, char *buf) {
 
+	int		len;
+
 	if ((e) && (buf)) {
 		if (e->buf) {
-			int len;
 			len = strlen(buf);
 			if (e->remain >= len) {
 				CopyMemory(e->buf, buf, len);
@@ -140,15 +156,15 @@ static BOOL num2proc(void *func, const P
 // ----
 
 typedef struct {
-	FILEH		fh;
-	long		pos;
-	long		bak;
-	long		next;
-	NP2FHDR		f;
-	NP2FLAGPART_T	p;
-} NP2FFILE;
+	FILEH	fh;
+	long	pos;
+	long	bak;
+	long	next;
+	NP2FHDR	f;
+	NP2FENT	p;
+} _NP2FFILE, *NP2FFILE;
 
-static int flagopen(NP2FFILE *f, const char *filename, ERR_BUF *e) {
+static int flagopen(NP2FFILE f, const char *filename, ERR_BUF *e) {
 
 	if (f) {
 		f->fh = file_open(filename);
@@ -187,7 +203,7 @@ static int flagopen(NP2FFILE *f, const c
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagcreate(NP2FFILE *f, const char *filename) {
+static int flagcreate(NP2FFILE f, const char *filename) {
 
 	if (f) {
 		f->fh = file_create(filename);
@@ -205,10 +221,10 @@ static int flagcreate(NP2FFILE *f, const
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagload_create(NP2FFILE *f) {
+static int flagload_create(NP2FFILE f) {
 
 	if (f) {
-		ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));
+		ZeroMemory(&f->p, sizeof(NP2FENT));
 		if (f->pos & 15) {
 			f->pos += 15;
 			f->pos &= ~0xf;
@@ -216,18 +232,17 @@ static int flagload_create(NP2FFILE *f) 
 				return(NP2FLAG_FAILURE);
 			}
 		}
-		if (file_read(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
+		if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
 			return(NP2FLAG_FAILURE);
 		}
-		f->pos += sizeof(NP2FLAGPART_T);
+		f->pos += sizeof(NP2FENT);
 		f->next = f->pos + f->p.size;
 		return(NP2FLAG_SUCCESS);
 	}
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagload_load(NP2FFILE *f, void *buf, UINT size) {
+static int flagload_load(NP2FFILE f, void *buf, UINT size) {
 
 	if (f && buf && size && (file_read(f->fh, buf, size) == size)) {
 		f->pos += size;
@@ -236,7 +251,7 @@ static int flagload_load(NP2FFILE *f, vo
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagload_close(NP2FFILE *f) {
+static int flagload_close(NP2FFILE f) {
 
 	if (file_seek(f->fh, f->next, 0) != f->next) {
 		return(NP2FLAG_FAILURE);
@@ -245,11 +260,11 @@ static int flagload_close(NP2FFILE *f) {
 	return(NP2FLAG_SUCCESS);
 }
 
-static int flagsave_create(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_create(NP2FFILE f, const STENTRY *t) {
 
 	if (f && t) {
 		int		len;
-		ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));
+		ZeroMemory(&f->p, sizeof(NP2FENT));
 		if (f->pos & 15) {
 			UINT rem;
 			rem = 16 - (f->pos & 15);
@@ -268,17 +283,16 @@ static int flagsave_create(NP2FFILE *f, 
 			CopyMemory(f->p.index, t->index, len);
 		}
 		f->p.ver = t->ver;
-		if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
+		if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
 			return(NP2FLAG_FAILURE);
 		}
-		f->pos += sizeof(NP2FLAGPART_T);
+		f->pos += sizeof(NP2FENT);
 		return(NP2FLAG_SUCCESS);
 	}
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagsave_save(NP2FFILE *f, void *buf, UINT size) {
+static int flagsave_save(NP2FFILE f, void *buf, UINT size) {
 
 	if (f && buf && size && (file_write(f->fh, buf, size) == size)) {
 		f->pos += size;
@@ -288,7 +302,7 @@ static int flagsave_save(NP2FFILE *f, vo
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagsave_close(NP2FFILE *f) {
+static int flagsave_close(NP2FFILE f) {
 
 	if (!f) {
 		goto fs_closeerr;
@@ -296,8 +310,7 @@ static int flagsave_close(NP2FFILE *f) {
 	if (file_seek(f->fh, f->bak, 0) != f->bak) {
 		goto fs_closeerr;
 	}
-	if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
+	if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
 		goto fs_closeerr;
 	}
 	if (file_seek(f->fh, f->pos, 0) == f->pos) {
@@ -308,7 +321,7 @@ fs_closeerr:
 	return(NP2FLAG_FAILURE);
 }
 
-static void flagclose(NP2FFILE *f) {
+static void flagclose(NP2FFILE f) {
 
 	if (f) {
 		file_close(f->fh);
@@ -318,7 +331,7 @@ static void flagclose(NP2FFILE *f) {
 
 // ----
 
-static int flagsave_term(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_term(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
@@ -328,9 +341,9 @@ static int flagsave_term(NP2FFILE *f, co
 }
 
 
-// ----
+// ---- common
 
-static int flagsave_common(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_common(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
@@ -342,58 +355,139 @@ static int flagsave_common(NP2FFILE *f, 
 	return(ret);
 }
 
-static int flagload_common(NP2FFILE *f, const STENTRY *t) {
+static int flagload_common(NP2FFILE f, const STENTRY *t) {
 
 	return(flagload_load(f, t->arg1, t->arg2));
 }
 
 
-// -----
+// ----- clock
+
+static int flagload_clock(NP2FFILE f, const STENTRY *t) {
+
+	int		ret;
+
+	ret = flagload_common(f, t);
+	sound_changeclock();
+	beep_changeclock();
+	return(ret);
+}
+
+
+// ---- memory
 
-static int flagsave_286(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_mem(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
 	ret = flagsave_create(f, t);
 	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &i286r, sizeof(I286REGS));
-		ret |= flagsave_save(f, &i286s, sizeof(I286STAT));
+		ret |= flagsave_save(f, mem, 0x110000);
+		ret |= flagsave_save(f, mem + VRAM1_B, 0x18000);
+		ret |= flagsave_save(f, mem + VRAM1_E, 0x8000);
 		ret |= flagsave_close(f);
 	}
 	return(ret);
 }
 
-static int flagload_286(NP2FFILE *f, const STENTRY *t) {
+static int flagload_mem(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
-	ret = flagload_load(f, &i286r, sizeof(I286REGS));
-	ret |= flagload_load(f, &i286s, sizeof(I286STAT));
+	ret = flagload_load(f, mem, 0x110000);
+	ret |= flagload_load(f, mem + VRAM1_B, 0x18000);
+	ret |= flagload_load(f, mem + VRAM1_E, 0x8000);
 	(void)t;
 	return(ret);
 }
 
 
-// -----
+// ---- ext memory
 
-static int flagload_core(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_ext(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
-	ret = flagload_common(f, t);
-	if (opna_rate) {
-		pc.sampleclock = (pc.realclock / opna_rate) + 1;
+	ret = flagsave_create(f, t);
+	if (ret != NP2FLAG_FAILURE) {
+		ret |= flagsave_save(f, &extmem, sizeof(extmem));
+		if (CPU_EXTMEM) {
+			ret |= flagsave_save(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
+		}
+		ret |= flagsave_close(f);
 	}
-	else {
-		pc.sampleclock = 0;
+	return(ret);
+}
+
+static int flagload_ext(NP2FFILE f, const STENTRY *t) {
+
+	int		ret;
+	int		i;
+	UINT	pagemax = 0;
+
+	ret = flagload_load(f, &extmem, sizeof(extmem));
+	if (extmem.maxmem) {
+		if (extmem.maxmem > (13+1)) {
+			extmem.maxmem = (13+1);
+		}
+		if (!extmemmng_realloc(extmem.maxmem - 1)) {
+			pagemax = (extmem.maxmem - 1) << 8;
+			if (CPU_EXTMEM) {
+				ret |= flagload_load(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
+			}
+		}
+		else {
+			extmem.maxmem = 0;
+		}
+	}
+	for (i=0; i<4; i++) {
+		if (extmem.page[i] < pagemax) {
+			extmem.pageptr[i] = CPU_EXTMEM + (extmem.page[i] << 12);
+		}
+		else {
+			extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
+		}
+	}
+	(void)t;
+	return(ret);
+}
+
+
+// ---- cg window
+
+#if defined(CGWND_FONTPTR)
+static int flagsave_cgwnd(NP2FFILE f, const STENTRY *t) {
+
+	int			ret;
+	_CGWINDOW	cgwnd;
+
+	cgwnd = cgwindow;
+	cgwnd.fontlow -= (long)fontrom;
+	cgwnd.fonthigh -= (long)fontrom;
+	ret = flagsave_create(f, t);
+	if (ret != NP2FLAG_FAILURE) {
+		ret |= flagsave_save(f, &cgwindow, sizeof(cgwindow));
+		ret |= flagsave_close(f);
 	}
 	return(ret);
 }
 
+static int flagload_cgwnd(NP2FFILE f, const STENTRY *t) {
+
+	int		ret;
+
+	ret = flagload_load(f, &cgwindow, sizeof(cgwindow));
+	cgwindow.fontlow += (long)fontrom;
+	cgwindow.fonthigh += (long)fontrom;
+	(void)t;
+	return(ret);
+}
+#endif
 
-// -----
 
-static int flagsave_dma(NP2FFILE *f, const STENTRY *t) {
+// ---- dma
+
+static int flagsave_dma(NP2FFILE f, const STENTRY *t) {
 
 	int			ret;
 	int			i;
@@ -401,9 +495,9 @@ static int flagsave_dma(NP2FFILE *f, con
 
 	dmabak = dmac;
 	for (i=0; i<4; i++) {
-		if ((PROC2NUM(dmabak.dmach[i].outproc, dmaproc)) ||
-			(PROC2NUM(dmabak.dmach[i].inproc, dmaproc)) ||
-			(PROC2NUM(dmabak.dmach[i].extproc, dmaproc))) {
+		if ((PROC2NUM(dmabak.dmach[i].proc.outproc, dmaproc)) ||
+			(PROC2NUM(dmabak.dmach[i].proc.inproc, dmaproc)) ||
+			(PROC2NUM(dmabak.dmach[i].proc.extproc, dmaproc))) {
 			return(NP2FLAG_FAILURE);
 		}
 	}
@@ -415,7 +509,7 @@ static int flagsave_dma(NP2FFILE *f, con
 	return(ret);
 }
 
-static int flagload_dma(NP2FFILE *f, const STENTRY *t) {
+static int flagload_dma(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	int		i;
@@ -423,16 +517,16 @@ static int flagload_dma(NP2FFILE *f, con
 	ret = flagload_load(f, &dmac, sizeof(dmac));
 
 	for (i=0; i<4; i++) {
-		if (NUM2PROC(dmac.dmach[i].outproc, dmaproc)) {
-			dmac.dmach[i].outproc = dma_dummyout;
+		if (NUM2PROC(dmac.dmach[i].proc.outproc, dmaproc)) {
+			dmac.dmach[i].proc.outproc = dma_dummyout;
 			ret |= NP2FLAG_WARNING;
 		}
-		if (NUM2PROC(dmac.dmach[i].inproc, dmaproc)) {
-			dmac.dmach[i].inproc = dma_dummyin;
+		if (NUM2PROC(dmac.dmach[i].proc.inproc, dmaproc)) {
+			dmac.dmach[i].proc.inproc = dma_dummyin;
 			ret |= NP2FLAG_WARNING;
 		}
-		if (NUM2PROC(dmac.dmach[i].extproc, dmaproc)) {
-			dmac.dmach[i].extproc = dma_dummyproc;
+		if (NUM2PROC(dmac.dmach[i].proc.extproc, dmaproc)) {
+			dmac.dmach[i].proc.extproc = dma_dummyproc;
 			ret |= NP2FLAG_WARNING;
 		}
 	}
@@ -441,9 +535,9 @@ static int flagload_dma(NP2FFILE *f, con
 }
 
 
-// -----
+// ---- egc
 
-static int flagsave_egc(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_egc(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	_EGC	egcbak;
@@ -460,7 +554,7 @@ static int flagsave_egc(NP2FFILE *f, con
 	return(ret);
 }
 
-static int flagload_egc(NP2FFILE *f, const STENTRY *t) {
+static int flagload_egc(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
@@ -472,63 +566,40 @@ static int flagload_egc(NP2FFILE *f, con
 }
 
 
-// -----
+// ---- epson
 
-static int flagsave_ext(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_epson(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 
+	if (!(pc.model & PCMODEL_EPSON)) {
+		return(NP2FLAG_SUCCESS);
+	}
 	ret = flagsave_create(f, t);
 	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &extmem, sizeof(extmem));
-		if (extmemmng_size) {
-			ret |= flagsave_save(f, extmemmng_ptr, extmemmng_size);
-		}
+		ret |= flagsave_save(f, &epsonio, sizeof(epsonio));
+		ret |= flagsave_save(f, mem + 0x1c0000, 0x8000);
+		ret |= flagsave_save(f, mem + 0x1e8000, 0x18000);
 		ret |= flagsave_close(f);
 	}
 	return(ret);
 }
 
-static int flagload_ext(NP2FFILE *f, const STENTRY *t) {
+static int flagload_epson(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
-	int		i;
-	UINT	pagemax = 0;
 
-	ret = flagload_load(f, &extmem, sizeof(extmem));
-	if (extmem.maxmem) {
-		if (extmem.maxmem > (13+1)) {
-			extmem.maxmem = (13+1);
-		}
-		if (!extmemmng_realloc(extmem.maxmem - 1)) {
-			pagemax = (extmem.maxmem - 1) << 8;
-			if (extmemmng_size) {
-				ret |= flagload_load(f, extmemmng_ptr, extmemmng_size);
-			}
-		}
-		else {
-			extmem.maxmem = 0;
-		}
-	}
-	for (i=0; i<4; i++) {
-		if (extmem.page[i] < pagemax) {
-			extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);
-		}
-		else {
-			extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
-		}
-	}
+	ret = flagload_load(f, &epsonio, sizeof(epsonio));
+	ret |= flagload_load(f, mem + 0x1c0000, 0x8000);
+	ret |= flagload_load(f, mem + 0x1e8000, 0x18000);
 	(void)t;
 	return(ret);
 }
 
 
-// -----
+// ---- event
 
 typedef struct {
-	SINT32		remainclock;
-	SINT32		baseclock;
-	UINT32		clock;
 	UINT		readyevents;
 	UINT		waitevents;
 } NEVTSAVE;
@@ -540,10 +611,10 @@ typedef struct {
 	NEVENTCB	proc;
 } NEVTITEM;
 
-static int nevent_save(NP2FFILE *f, int num) {
+static int nevent_save(NP2FFILE f, int num) {
 
 	NEVTITEM	nit;
-	int			i;
+	UINT		i;
 
 	ZeroMemory(&nit, sizeof(nit));
 	for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {
@@ -561,15 +632,12 @@ static int nevent_save(NP2FFILE *f, int 
 	return(flagsave_save(f, &nit, sizeof(nit)));
 }
 
-static int flagsave_evt(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_evt(NP2FFILE f, const STENTRY *t) {
 
 	NEVTSAVE	nevt;
 	int			ret;
 	UINT		i;
 
-	nevt.remainclock = nevent.remainclock;
-	nevt.baseclock = nevent.baseclock;
-	nevt.clock = nevent.clock;
 	nevt.readyevents = nevent.readyevents;
 	nevt.waitevents = nevent.waitevents;
 
@@ -587,7 +655,7 @@ static int flagsave_evt(NP2FFILE *f, con
 	return(ret);
 }
 
-static int nevent_load(NP2FFILE *f, UINT *tbl, UINT *pos) {
+static int nevent_load(NP2FFILE f, UINT *tbl, UINT *pos) {
 
 	int			ret;
 	NEVTITEM	nit;
@@ -620,7 +688,7 @@ static int nevent_load(NP2FFILE *f, UINT
 	return(ret);
 }
 
-static int flagload_evt(NP2FFILE *f, const STENTRY *t) {
+static int flagload_evt(NP2FFILE f, const STENTRY *t) {
 
 	int			ret;
 	NEVTSAVE	nevt;
@@ -628,9 +696,6 @@ static int flagload_evt(NP2FFILE *f, con
 
 	ret = flagload_load(f, &nevt, sizeof(nevt));
 
-	nevent.remainclock = nevt.remainclock;
-	nevent.baseclock = nevt.baseclock;
-	nevent.clock = nevt.clock;
 	nevent.readyevents = 0;
 	nevent.waitevents = 0;
 
@@ -645,9 +710,9 @@ static int flagload_evt(NP2FFILE *f, con
 }
 
 
-// ----
+// ---- gaiji
 
-static int flagsave_gij(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_gij(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	int		i;
@@ -657,7 +722,7 @@ static int flagsave_gij(NP2FFILE *f, con
 	ret = flagsave_create(f, t);
 	if (ret != NP2FLAG_FAILURE) {
 		for (i=0; i<2; i++) {
-			fnt = font + ((0x56 + (i << 7)) << 4);
+			fnt = fontrom + ((0x56 + (i << 7)) << 4);
 			for (j=0; j<0x80; j++) {
 				ret |= flagsave_save(f, fnt, 32);
 				fnt += 0x1000;
@@ -668,7 +733,7 @@ static int flagsave_gij(NP2FFILE *f, con
 	return(ret);
 }
 
-static int flagload_gij(NP2FFILE *f, const STENTRY *t) {
+static int flagload_gij(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	int		i;
@@ -677,7 +742,7 @@ static int flagload_gij(NP2FFILE *f, con
 
 	ret = 0;
 	for (i=0; i<2; i++) {
-		fnt = font + ((0x56 + (i << 7)) << 4);
+		fnt = fontrom + ((0x56 + (i << 7)) << 4);
 		for (j=0; j<0x80; j++) {
 			ret |= flagload_load(f, fnt, 32);
 			fnt += 0x1000;
@@ -688,7 +753,7 @@ static int flagload_gij(NP2FFILE *f, con
 }
 
 
-// -----
+// ---- FM
 
 enum {
 	FLAG_MG			= 0x0001,
@@ -698,10 +763,11 @@ enum {
 	FLAG_FM2B		= 0x0010,
 	FLAG_PSG1		= 0x0020,
 	FLAG_PSG2		= 0x0040,
-	FLAG_RHYTHM		= 0x0080,
-	FLAG_ADPCM		= 0x0100,
-	FLAG_PCM86		= 0x0200,
-	FLAG_CS4231		= 0x0400
+	FLAG_PSG3		= 0x0080,
+	FLAG_RHYTHM		= 0x0100,
+	FLAG_ADPCM		= 0x0200,
+	FLAG_PCM86		= 0x0400,
+	FLAG_CS4231		= 0x0800
 };
 
 typedef struct {
@@ -709,7 +775,7 @@ typedef struct {
 	BYTE	extop[4];
 } OPNKEY;
 
-static int flagsave_fm(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_fm(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	UINT	saveflg;
@@ -754,6 +820,10 @@ static int flagsave_fm(NP2FFILE *f, cons
 										FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
 			break;
 
+		case 0x80:
+			saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
+			break;
+
 		default:
 			saveflg = 0;
 			break;
@@ -769,7 +839,7 @@ static int flagsave_fm(NP2FFILE *f, cons
 		if (saveflg & FLAG_FM1A) {
 			ret |= flagsave_save(f, &fmtimer, sizeof(fmtimer));
 			ret |= flagsave_save(f, &opn, sizeof(opn));
-			CopyMemory(opnkey.keyreg, fm_keyreg, sizeof(fm_keyreg));
+			CopyMemory(opnkey.keyreg, opngen.keyreg, sizeof(opngen.keyreg));
 			opnkey.extop[0] = opnch[2].extop;
 			opnkey.extop[1] = opnch[5].extop;
 			opnkey.extop[2] = opnch[8].extop;
@@ -782,6 +852,9 @@ static int flagsave_fm(NP2FFILE *f, cons
 		if (saveflg & FLAG_PSG2) {
 			ret |= flagsave_save(f, &psg2.reg, sizeof(PSGREG));
 		}
+		if (saveflg & FLAG_PSG3) {
+			ret |= flagsave_save(f, &psg3.reg, sizeof(PSGREG));
+		}
 		if (saveflg & FLAG_ADPCM) {
 			ret |= flagsave_save(f, &adpcm, sizeof(adpcm));
 		}
@@ -796,14 +869,12 @@ static int flagsave_fm(NP2FFILE *f, cons
 	return(ret);
 }
 
-static void play_fmreg(BYTE num) {
+static void play_fmreg(BYTE num, UINT reg) {
 
 	UINT	chbase;
-	UINT	reg;
 	UINT	i;
 
 	chbase = num * 3;
-	reg = num * 0x100;
 	for (i=0x30; i<0xa0; i++) {
 		opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
 	}
@@ -811,7 +882,7 @@ static void play_fmreg(BYTE num) {
 		opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
 	}
 	for (i=0; i<3; i++) {
-		opngen_keyon(chbase + i, fm_keyreg[chbase + i]);
+		opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);
 	}
 }
 
@@ -824,11 +895,15 @@ static void play_psgreg(PSGGEN psg) {
 	}
 }
 
-static int flagload_fm(NP2FFILE *f, const STENTRY *t) {
+static int flagload_fm(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	UINT	saveflg;
 	OPNKEY	opnkey;
+	UINT	fmreg1a;
+	UINT	fmreg1b;
+	UINT	fmreg2a;
+	UINT	fmreg2b;
 
 	opngen_reset();
 	psggen_reset(&psg1);
@@ -842,6 +917,10 @@ static int flagload_fm(NP2FFILE *f, cons
 	ret = flagload_load(f, &usesound, sizeof(usesound));
 	fmboard_reset((BYTE)usesound);
 
+	fmreg1a = 0x000;
+	fmreg1b = 0x100;
+	fmreg2a = 0x200;
+	fmreg2b = 0x300;
 	switch(usesound) {
 		case 0x01:
 			saveflg = FLAG_MG;
@@ -859,6 +938,9 @@ static int flagload_fm(NP2FFILE *f, cons
 		case 0x06:
 			saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_PSG1 |
 										FLAG_PSG2 | FLAG_RHYTHM | FLAG_PCM86;
+			fmreg1a = 0x200;	// 逆転してるのん…
+			fmreg1b = 0x000;
+			fmreg2a = 0x100;
 			break;
 
 		case 0x08:
@@ -881,7 +963,12 @@ static int flagload_fm(NP2FFILE *f, cons
 										FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
 			break;
 
+		case 0x80:
+			saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
+			break;
+
 		default:
+			saveflg = 0;
 			break;
 	}
 
@@ -894,7 +981,7 @@ static int flagload_fm(NP2FFILE *f, cons
 		ret |= flagload_load(f, &fmtimer, sizeof(fmtimer));
 		ret |= flagload_load(f, &opn, sizeof(opn));
 		ret |= flagload_load(f, &opnkey, sizeof(opnkey));
-		CopyMemory(fm_keyreg, &opnkey.keyreg, sizeof(fm_keyreg));
+		CopyMemory(opngen.keyreg, &opnkey.keyreg, sizeof(opngen.keyreg));
 		opnch[2].extop = opnkey.extop[0];
 		opnch[5].extop = opnkey.extop[1];
 		opnch[8].extop = opnkey.extop[2];
@@ -906,6 +993,9 @@ static int flagload_fm(NP2FFILE *f, cons
 	if (saveflg & FLAG_PSG2) {
 		ret |= flagload_load(f, &psg2.reg, sizeof(PSGREG));
 	}
+	if (saveflg & FLAG_PSG3) {
+		ret |= flagload_load(f, &psg3.reg, sizeof(PSGREG));
+	}
 	if (saveflg & FLAG_ADPCM) {
 		ret |= flagload_load(f, &adpcm, sizeof(adpcm));
 	}
@@ -929,16 +1019,16 @@ static int flagload_fm(NP2FFILE *f, cons
 	}
 
 	if (saveflg & FLAG_FM1A) {
-		play_fmreg(0);
+		play_fmreg(0, fmreg1a);
 	}
 	if (saveflg & FLAG_FM1B) {
-		play_fmreg(1);
+		play_fmreg(1, fmreg1b);
 	}
 	if (saveflg & FLAG_FM2A) {
-		play_fmreg(2);
+		play_fmreg(2, fmreg2a);
 	}
 	if (saveflg & FLAG_FM2B) {
-		play_fmreg(3);
+		play_fmreg(3, fmreg2b);
 	}
 	if (saveflg & FLAG_PSG1) {
 		play_psgreg(&psg1);
@@ -946,6 +1036,9 @@ static int flagload_fm(NP2FFILE *f, cons
 	if (saveflg & FLAG_PSG2) {
 		play_psgreg(&psg2);
 	}
+	if (saveflg & FLAG_PSG3) {
+		play_psgreg(&psg3);
+	}
 	(void)t;
 	return(ret);
 }
@@ -960,7 +1053,13 @@ typedef struct {
 	DOSTIME	time;
 } STATDISK;
 
-static int disksave(NP2FFILE *f, const char *path, int readonly) {
+static const char str_fddx[] = "FDD%u";
+static const char str_sasix[] = "SASI%u";
+static const char str_scsix[] = "SCSI%u";
+static const char str_updated[] = "%s: updated" CRLITERAL;
+static const char str_notfound[] = "%s: not found" CRLITERAL;
+
+static int disksave(NP2FFILE f, const char *path, int readonly) {
 
 	STATDISK	st;
 	FILEH		fh;
@@ -978,7 +1077,7 @@ static int disksave(NP2FFILE *f, const c
 	return(flagsave_save(f, &st, sizeof(st)));
 }
 
-static int flagsave_disk(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_disk(NP2FFILE f, const STENTRY *t) {
 
 	int		ret;
 	BYTE	i;
@@ -1000,7 +1099,7 @@ static int flagsave_disk(NP2FFILE *f, co
 	return(ret);
 }
 
-static int diskcheck(NP2FFILE *f, const char *name, ERR_BUF *e) {
+static int diskcheck(NP2FFILE f, const char *name, ERR_BUF *e) {
 
 	int			ret;
 	FILEH		fh;
@@ -1018,20 +1117,20 @@ static int diskcheck(NP2FFILE *f, const 
 			if ((memcmp(&st.date, &date, sizeof(date))) ||
 				(memcmp(&st.time, &time, sizeof(time)))) {
 				ret |= NP2FLAG_DISKCHG;
-				SPRINTF(buf, "%s: updated\n", name);
+				SPRINTF(buf, str_updated, name);
 				err_append(e, buf);
 			}
 		}
 		else {
 			ret |= NP2FLAG_DISKCHG;
-			SPRINTF(buf, "%s: not found\n", name);
+			SPRINTF(buf, str_notfound, name);
 			err_append(e, buf);
 		}
 	}
 	return(ret);
 }
 
-static int flagcheck_disk(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_disk(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
 
 	int		ret;
 	int		i;
@@ -1039,23 +1138,23 @@ static int flagcheck_disk(NP2FFILE *f, c
 
 	ret = 0;
 	for (i=0; i<4; i++) {
-		SPRINTF(buf, "FDD%d", i+1);
+		SPRINTF(buf, str_fddx, i+1);
 		ret |= diskcheck(f, buf, e);
 	}
 	sxsi_flash();
 	for (i=0; i<2; i++) {
-		SPRINTF(buf, "SASI%u", i+1);
+		SPRINTF(buf, str_sasix, i+1);
 		ret |= diskcheck(f, buf, e);
 	}
 	for (i=0; i<2; i++) {
-		SPRINTF(buf, "SCSI%d", i+1);
+		SPRINTF(buf, str_scsix, i+1);
 		ret |= diskcheck(f, buf, e);
 	}
 	(void)t;
 	return(ret);
 }
 
-static int flagload_disk(NP2FFILE *f, const STENTRY *t) {
+static int flagload_disk(NP2FFILE f, const STENTRY *t) {
 
 	int			ret;
 	BYTE		i;
@@ -1088,15 +1187,14 @@ static int flagload_disk(NP2FFILE *f, co
 }
 
 
-// -----
+// ---- com
 
-#ifdef _MIDICH
-static int flagsave_midi(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_com(NP2FFILE f, const STENTRY *t) {
 
 	UINT	device;
 	COMMNG	cm;
 	int		ret;
-	_MIDICH	mch[16];
+	COMFLAG	flag;
 
 	device = (UINT)t->arg1;
 	switch(device) {
@@ -1113,55 +1211,78 @@ static int flagsave_midi(NP2FFILE *f, co
 			break;
 	}
 	ret = NP2FLAG_SUCCESS;
-	if ((cm != NULL) && (cm->msg(cm, COMMSG_MIDISTATGET, (long)mch))) {
-		ret = flagsave_create(f, t);
-		if (ret != NP2FLAG_FAILURE) {
-			ret |= flagsave_save(f, mch, sizeof(mch));
-			ret |= flagsave_close(f);
+	if (cm) {
+		flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);
+		if (flag) {
+			ret = flagsave_create(f, t);
+			if (ret != NP2FLAG_FAILURE) {
+				ret |= flagsave_save(f, flag, flag->size);
+				ret |= flagsave_close(f);
+			}
+			_MFREE(flag);
 		}
 	}
 	return(ret);
 }
 
-static int flagload_midi(NP2FFILE *f, const STENTRY *t) {
+static int flagload_com(NP2FFILE f, const STENTRY *t) {
 
-	_MIDICH	mch[16];
-	UINT	device;
-	COMMNG	cm;
-	int		ret;
+	UINT		device;
+	COMMNG		cm;
+	int			ret;
+	_COMFLAG	fhdr;
+	COMFLAG		flag;
 
-	ret = flagload_load(f, mch, sizeof(mch));
-	if (ret != NP2FLAG_FAILURE) {
-		device = (UINT)t->arg1;
-		switch(device) {
-			case 0:
-				commng_destroy(cm_mpu98);
-				cm = commng_create(COMCREATE_MPU98II);
-				cm_mpu98 = cm;
-				break;
+	ret = flagload_load(f, &fhdr, sizeof(fhdr));
+	if (ret != NP2FLAG_SUCCESS) {
+		goto flcom_err1;
+	}
+	if (fhdr.size < sizeof(fhdr)) {
+		goto flcom_err1;
+	}
+	flag = (COMFLAG)_MALLOC(fhdr.size, "com stat flag");
+	if (flag == NULL) {
+		goto flcom_err1;
+	}
+	CopyMemory(flag, &fhdr, sizeof(fhdr));
+	ret |= flagload_load(f, flag + 1, fhdr.size - sizeof(fhdr));
+	if (ret != NP2FLAG_SUCCESS) {
+		goto flcom_err2;
+	}
 
-			case 1:
-				commng_destroy(cm_rs232c);
-				cm = commng_create(COMCREATE_SERIAL);
-				cm_rs232c = cm;
-				break;
+	device = (UINT)t->arg1;
+	switch(device) {
+		case 0:
+			commng_destroy(cm_mpu98);
+			cm = commng_create(COMCREATE_MPU98II);
+			cm_mpu98 = cm;
+			break;
 
-			default:
-				cm = NULL;
-				break;
-		}
-		if (cm) {
-			cm->msg(cm, COMMSG_MIDISTATSET, (long)mch);
-		}
+		case 1:
+			commng_destroy(cm_rs232c);
+			cm = commng_create(COMCREATE_SERIAL);
+			cm_rs232c = cm;
+			break;
+
+		default:
+			cm = NULL;
+			break;
+	}
+	if (cm) {
+		cm->msg(cm, COMMSG_SETFLAG, (long)flag);
 	}
+
+flcom_err2:
+	_MFREE(flag);
+
+flcom_err1:
 	return(ret);
 }
-#endif
 
 
 // ----
 
-static int flagcheck_versize(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_versize(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
 
 	if ((f) && (t)) {
 		if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {
@@ -1173,7 +1294,7 @@ static int flagcheck_versize(NP2FFILE *f
 	return(NP2FLAG_FAILURE);
 }
 
-static int flagcheck_veronly(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_veronly(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
 
 	if ((f) && (t)) {
 		if (f->p.ver == t->ver) {
@@ -1190,64 +1311,75 @@ static int flagcheck_veronly(NP2FFILE *f
 
 int statsave_save(const char *filename) {
 
-	NP2FFILE	f;
+	_NP2FFILE	f;
 	int			ret;
-	int			i;
+const STENTRY	*tbl;
+const STENTRY	*tblterm;
 
 	ret = flagcreate(&f, filename);
 	if (ret == NP2FLAG_FAILURE) {
 		return(ret);
 	}
-	for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-		switch(np2tbl[i].type) {
+	tbl = np2tbl;
+	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
+	while(tbl < tblterm) {
+		switch(tbl->type) {
 			case NP2FLAG_BIN:
-			case NP2FLAG_CORE:
-			case NP2FLAG_BEEP:
-				ret |= flagsave_common(&f, &np2tbl[i]);
+			case NP2FLAG_CLOCK:
+				ret |= flagsave_common(&f, tbl);
 				break;
 
 			case NP2FLAG_TERM:
-				ret |= flagsave_term(&f, &np2tbl[i]);
+				ret |= flagsave_term(&f, tbl);
 				break;
 
-			case NP2FLAG_286:
-				ret |= flagsave_286(&f, &np2tbl[i]);
+#if defined(CGWND_FONTPTR)
+			case NP2FLAG_CGW:
+				ret |= flagsave_cgwnd(&f, tbl);
+				break;
+#endif
+
+			case NP2FLAG_COM:
+				ret |= flagsave_com(&f, tbl);
+				break;
+
+			case NP2FLAG_DISK:
+				ret |= flagsave_disk(&f, tbl);
 				break;
 
 			case NP2FLAG_DMA:
-				ret |= flagsave_dma(&f, &np2tbl[i]);
+				ret |= flagsave_dma(&f, tbl);
 				break;
 
 			case NP2FLAG_EGC:
-				ret |= flagsave_egc(&f, &np2tbl[i]);
+				ret |= flagsave_egc(&f, tbl);
 				break;
 
-			case NP2FLAG_EXT:
-				ret |= flagsave_ext(&f, &np2tbl[i]);
+			case NP2FLAG_EPSON:
+				ret |= flagsave_epson(&f, tbl);
 				break;
 
 			case NP2FLAG_EVT:
-				ret |= flagsave_evt(&f, &np2tbl[i]);
+				ret |= flagsave_evt(&f, tbl);
 				break;
 
-			case NP2FLAG_GIJ:
-				ret |= flagsave_gij(&f, &np2tbl[i]);
+			case NP2FLAG_EXT:
+				ret |= flagsave_ext(&f, tbl);
 				break;
 
 			case NP2FLAG_FM:
-				ret |= flagsave_fm(&f, &np2tbl[i]);
+				ret |= flagsave_fm(&f, tbl);
 				break;
 
-			case NP2FLAG_DISK:
-				ret |= flagsave_disk(&f, &np2tbl[i]);
+			case NP2FLAG_GIJ:
+				ret |= flagsave_gij(&f, tbl);
 				break;
 
-#if defined(MIDICH)
-			case NP2FLAG_MIDI:
-				ret |= flagsave_midi(&f, &np2tbl[i]);
+			case NP2FLAG_MEM:
+				ret |= flagsave_mem(&f, tbl);
 				break;
-#endif
 		}
+		tbl++;
 	}
 	flagclose(&f);
 	return(ret);
@@ -1255,11 +1387,12 @@ int statsave_save(const char *filename) 
 
 int statsave_check(const char *filename, char *buf, int size) {
 
-	NP2FFILE	f;
+	ERR_BUF		e;
+	_NP2FFILE	f;
 	int			ret;
-	int			i;
 	BOOL		done;
-	ERR_BUF		e;
+const STENTRY	*tbl;
+const STENTRY	*tblterm;
 
 	e.buf = buf;
 	e.remain = size;
@@ -1281,40 +1414,42 @@ int statsave_check(const char *filename,
 			ret |= flagload_create(&f);
 			CopyMemory(index, f.p.index, sizeof(f.p.index));
 			index[10] = 0;
-			for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-				if (!strcmp(index, np2tbl[i].index)) {
+			tbl = np2tbl;
+			tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
+			while(tbl < tblterm) {
+				if (!strcmp(index, tbl->index)) {
 					break;
 				}
+				tbl++;
 			}
-			if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
-				switch(np2tbl[i].type) {
+			if (tbl < tblterm) {
+				switch(tbl->type) {
 					case NP2FLAG_BIN:
-						ret |= flagcheck_versize(&f, &np2tbl[i], &e);
+#if defined(CGWND_FONTPTR)
+					case NP2FLAG_CGW:
+#endif
+					case NP2FLAG_CLOCK:
+					case NP2FLAG_MEM:
+						ret |= flagcheck_versize(&f, tbl, &e);
 						break;
 
 					case NP2FLAG_TERM:
 						done = TRUE;
 						break;
 
-					case NP2FLAG_286:
-					case NP2FLAG_CORE:
+					case NP2FLAG_COM:
 					case NP2FLAG_DMA:
 					case NP2FLAG_EGC:
-					case NP2FLAG_EXT:
+					case NP2FLAG_EPSON:
 					case NP2FLAG_EVT:
+					case NP2FLAG_EXT:
 					case NP2FLAG_GIJ:
-					case NP2FLAG_BEEP:
-#if defined(MIDICH)
-					case NP2FLAG_MIDI:
-#endif
-						ret |= flagcheck_veronly(&f, &np2tbl[i], &e);
+					case NP2FLAG_FM:
+						ret |= flagcheck_veronly(&f, tbl, &e);
 						break;
 
 					case NP2FLAG_DISK:
-						ret |= flagcheck_disk(&f, &np2tbl[i], &e);
-						break;
-
-					case NP2FLAG_FM:							// ver0.31
+						ret |= flagcheck_disk(&f, tbl, &e);
 						break;
 
 					default:
@@ -1337,10 +1472,11 @@ int statsave_check(const char *filename,
 
 int statsave_load(const char *filename) {
 
-	NP2FFILE	f;
+	_NP2FFILE	f;
 	int			ret;
-	int			i;
 	BOOL		done;
+const STENTRY	*tbl;
+const STENTRY	*tblterm;
 
 	ret = flagopen(&f, filename, NULL);
 	if (ret == NP2FLAG_FAILURE) {
@@ -1360,63 +1496,73 @@ int statsave_load(const char *filename) 
 		ret |= flagload_create(&f);
 		CopyMemory(index, f.p.index, sizeof(f.p.index));
 		index[10] = 0;
-		for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-			if (!strcmp(index, np2tbl[i].index)) {
+		tbl = np2tbl;
+		tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
+		while(tbl < tblterm) {
+			if (!strcmp(index, tbl->index)) {
 				break;
 			}
+			tbl++;
 		}
-		if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
-			switch(np2tbl[i].type) {
+		if (tbl < tblterm) {
+			switch(tbl->type) {
 				case NP2FLAG_BIN:
-				case NP2FLAG_BEEP:
-					ret |= flagload_common(&f, &np2tbl[i]);
+					ret |= flagload_common(&f, tbl);
 					break;
 
 				case NP2FLAG_TERM:
 					done = TRUE;
 					break;
 
-				case NP2FLAG_286:
-					ret |= flagload_286(&f, &np2tbl[i]);
+#if defined(CGWND_FONTPTR)
+				case NP2FLAG_CGW:
+					ret |= flagload_cgwnd(&f, tbl);
+					break;
+#endif
+
+				case NP2FLAG_CLOCK:
+					ret |= flagload_clock(&f, tbl);
+					break;
+
+				case NP2FLAG_COM:
+					ret |= flagload_com(&f, tbl);
 					break;
 
-				case NP2FLAG_CORE:
-					ret |= flagload_core(&f, &np2tbl[i]);
+				case NP2FLAG_DISK:
+					ret |= flagload_disk(&f, tbl);
 					break;
 
 				case NP2FLAG_DMA:
-					ret |= flagload_dma(&f, &np2tbl[i]);
+					ret |= flagload_dma(&f, tbl);
 					break;
 
 				case NP2FLAG_EGC:
-					ret |= flagload_egc(&f, &np2tbl[i]);
+					ret |= flagload_egc(&f, tbl);
 					break;
 
-				case NP2FLAG_EXT:
-					ret |= flagload_ext(&f, &np2tbl[i]);
+				case NP2FLAG_EPSON:
+					ret |= flagload_epson(&f, tbl);
 					break;
 
 				case NP2FLAG_EVT:
-					ret |= flagload_evt(&f, &np2tbl[i]);
+					ret |= flagload_evt(&f, tbl);
 					break;
 
-				case NP2FLAG_GIJ:
-					ret |= flagload_gij(&f, &np2tbl[i]);
+				case NP2FLAG_EXT:
+					ret |= flagload_ext(&f, tbl);
 					break;
 
 				case NP2FLAG_FM:
-					ret |= flagload_fm(&f, &np2tbl[i]);
+					ret |= flagload_fm(&f, tbl);
 					break;
 
-				case NP2FLAG_DISK:
-					ret |= flagload_disk(&f, &np2tbl[i]);
+				case NP2FLAG_GIJ:
+					ret |= flagload_gij(&f, tbl);
 					break;
 
-#if defined(MIDICH)
-				case NP2FLAG_MIDI:
-					ret |= flagload_midi(&f, &np2tbl[i]);
+				case NP2FLAG_MEM:
+					ret |= flagload_mem(&f, tbl);
 					break;
-#endif
 
 				default:
 					ret |= NP2FLAG_WARNING;
@@ -1431,6 +1577,7 @@ int statsave_load(const char *filename) 
 	flagclose(&f);
 
 	// I/O作り直し
+	i286_memorymap((pc.model & PCMODEL_EPSON)?1:0);
 	iocore_build();
 	iocore_bind();
 	cbuscore_bind();
@@ -1443,6 +1590,10 @@ int statsave_load(const char *filename) 
 	gdcs.palchange = GDCSCRN_REDRAW;
 	tramflag.renewal = 1;
 	cgwindow.writable |= 0x80;
+#if defined(CPUSTRUC_FONTPTR)
+	FONTPTR_LOW = fontrom + cgwindow.low;
+	FONTPTR_HIGH = fontrom + cgwindow.high;
+#endif
 	i286_vram_dispatch(vramop.operate);
 	soundmng_play();