diff --git a/src/emu/cpu/lh5801/5801tbl.c b/src/emu/cpu/lh5801/5801tbl.c
index c309173aed2..ca2d42f6e40 100644
--- a/src/emu/cpu/lh5801/5801tbl.c
+++ b/src/emu/cpu/lh5801/5801tbl.c
@@ -4,463 +4,463 @@
    (decrement, compare the same)
    (like in the m6502 processors)
 */
-INLINE UINT8 lh5801_add_generic(int left, int right, int carry)
+INLINE UINT8 lh5801_add_generic(lh5801_state *cpustate, int left, int right, int carry)
 {
 	int res=left+right+carry;
 	int v,c;
 
-	lh5801.t&=~(H|V|Z|C);
+	cpustate->t&=~(H|V|Z|C);
 
-	if (!(res&0xff)) lh5801.t|=Z;
+	if (!(res&0xff)) cpustate->t|=Z;
 	c=res&0x100;
-	if (c) lh5801.t|=C;
-	if (((left&0xf)+(right&0xf)+carry)&0x10) lh5801.t|=H;
+	if (c) cpustate->t|=C;
+	if (((left&0xf)+(right&0xf)+carry)&0x10) cpustate->t|=H;
 	v=((left&0x7f)+(right&0x7f)+carry)&0x80;
-	if ( (c&&!v)||(!c&&v) ) lh5801.t|=V;
+	if ( (c&&!v)||(!c&&v) ) cpustate->t|=V;
 
 	return res;
 }
 
-INLINE UINT16 lh5801_readop_word(void)
+INLINE UINT16 lh5801_readop_word(lh5801_state *cpustate)
 {
 	UINT16 r;
-	r=memory_decrypted_read_byte(lh5801.program,P++)<<8;
-	r|=memory_decrypted_read_byte(lh5801.program,P++);
+	r=memory_decrypted_read_byte(cpustate->program,P++)<<8;
+	r|=memory_decrypted_read_byte(cpustate->program,P++);
 	return r;
 }
 
 
-INLINE void lh5801_adc(UINT8 data)
+INLINE void lh5801_adc(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a=lh5801_add_generic(lh5801.a,data,lh5801.t&C);
+	cpustate->a=lh5801_add_generic(cpustate,cpustate->a,data,cpustate->t&C);
 }
 
-INLINE void lh5801_add_mem(int addr, UINT8 data)
+INLINE void lh5801_add_mem(lh5801_state *cpustate, int addr, UINT8 data)
 {
-	int v=lh5801_add_generic(memory_read_byte(lh5801.program,addr),data,0);
-	memory_write_byte(lh5801.program,addr,v);
+	int v=lh5801_add_generic(cpustate,memory_read_byte(cpustate->program,addr),data,0);
+	memory_write_byte(cpustate->program,addr,v);
 }
 
-INLINE void lh5801_adr(PAIR *reg)
+INLINE void lh5801_adr(lh5801_state *cpustate, PAIR *reg)
 {
-	reg->b.l=lh5801_add_generic(reg->b.l,lh5801.a,0);
-	if (lh5801.t&C) {
+	reg->b.l=lh5801_add_generic(cpustate,reg->b.l,cpustate->a,0);
+	if (cpustate->t&C) {
 		reg->b.h++;
 	}
 }
 
-INLINE void lh5801_sbc(UINT8 data)
+INLINE void lh5801_sbc(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a=lh5801_add_generic(lh5801.a,data^0xff,(lh5801.t&C)^1);
+	cpustate->a=lh5801_add_generic(cpustate,cpustate->a,data^0xff,(cpustate->t&C)^1);
 }
 
-INLINE void lh5801_cpa(UINT8 a, UINT8 b)
+INLINE void lh5801_cpa(lh5801_state *cpustate, UINT8 a, UINT8 b)
 {
-	lh5801_add_generic(a, b^0xff, 1);
+	lh5801_add_generic(cpustate,a, b^0xff, 1);
 }
 
-INLINE UINT8 lh5801_decimaladd_generic(int left, int right, int carry)
+INLINE UINT8 lh5801_decimaladd_generic(lh5801_state *cpustate, int left, int right, int carry)
 {
 	int res=(left&0xf)+(right&0xf)+carry;
-	lh5801.t&=~(H|V|Z|C);
+	cpustate->t&=~(H|V|Z|C);
 
 	if (res>=10) {
 		res+=6;
-		lh5801.t|=H;
+		cpustate->t|=H;
 	}
 	res+=(left&0xf0)+(right&0xf0);
 	if (res>=0xa0) {
 		res+=0x60;
-		lh5801.t|=C;
+		cpustate->t|=C;
 	}
-	if (!(res&0xff)) lh5801.t|=Z;
+	if (!(res&0xff)) cpustate->t|=Z;
 	//v???
 	return res;
 }
 
-INLINE void lh5801_dca(UINT8 data)
+INLINE void lh5801_dca(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a=lh5801_decimaladd_generic(lh5801.a, data, lh5801.t&C);
+	cpustate->a=lh5801_decimaladd_generic(cpustate, cpustate->a, data, cpustate->t&C);
 }
 
-INLINE void lh5801_dcs(UINT8 data)
+INLINE void lh5801_dcs(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a=lh5801_decimaladd_generic(lh5801.a, data^0xff, (lh5801.t&C)^1);
+	cpustate->a=lh5801_decimaladd_generic(cpustate, cpustate->a, data^0xff, (cpustate->t&C)^1);
 }
 
-INLINE void lh5801_and(UINT8 data)
+INLINE void lh5801_and(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a&=data;
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a&=data;
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_and_mem(int addr, UINT8 data)
+INLINE void lh5801_and_mem(lh5801_state *cpustate, int addr, UINT8 data)
 {
-	data&=memory_read_byte(lh5801.program,addr);
-	lh5801.t&=~Z;
-	if (!data) lh5801.t|=Z;
-	memory_write_byte(lh5801.program,addr,data);
+	data&=memory_read_byte(cpustate->program,addr);
+	cpustate->t&=~Z;
+	if (!data) cpustate->t|=Z;
+	memory_write_byte(cpustate->program,addr,data);
 }
 
-INLINE void lh5801_bit(UINT8 a, UINT8 b)
+INLINE void lh5801_bit(lh5801_state *cpustate, UINT8 a, UINT8 b)
 {
-	lh5801.t&=~Z;
-	if (!(a&b)) lh5801.t|=Z;
+	cpustate->t&=~Z;
+	if (!(a&b)) cpustate->t|=Z;
 }
 
-INLINE void lh5801_eor(UINT8 data)
+INLINE void lh5801_eor(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a^=data;
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a^=data;
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_ora(UINT8 data)
+INLINE void lh5801_ora(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a^=data;
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a^=data;
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_ora_mem(int addr, UINT8 data)
+INLINE void lh5801_ora_mem(lh5801_state *cpustate, int addr, UINT8 data)
 {
-	data|=memory_read_byte(lh5801.program,addr);
-	lh5801.t&=~Z;
-	if (!data) lh5801.t|=Z;
-	memory_write_byte(lh5801.program,addr,data);
+	data|=memory_read_byte(cpustate->program,addr);
+	cpustate->t&=~Z;
+	if (!data) cpustate->t|=Z;
+	memory_write_byte(cpustate->program,addr,data);
 }
 
-INLINE void lh5801_lda(UINT8 data)
+INLINE void lh5801_lda(lh5801_state *cpustate, UINT8 data)
 {
-	lh5801.a=data;
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a=data;
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_lde(PAIR *reg)
+INLINE void lh5801_lde(lh5801_state *cpustate, PAIR *reg)
 {
 	// or z flag depends on reg
-	lh5801.a=memory_read_byte(lh5801.program,reg->w.l--);
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a=memory_read_byte(cpustate->program,reg->w.l--);
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_sde(PAIR *reg)
+INLINE void lh5801_sde(lh5801_state *cpustate, PAIR *reg)
 {
-	memory_write_byte(lh5801.program,reg->w.l--, lh5801.a);
+	memory_write_byte(cpustate->program,reg->w.l--, cpustate->a);
 }
 
-INLINE void lh5801_lin(PAIR *reg)
+INLINE void lh5801_lin(lh5801_state *cpustate, PAIR *reg)
 {
 	// or z flag depends on reg
-	lh5801.a=memory_read_byte(lh5801.program,reg->w.l++);
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a=memory_read_byte(cpustate->program,reg->w.l++);
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_sin(PAIR *reg)
+INLINE void lh5801_sin(lh5801_state *cpustate, PAIR *reg)
 {
-	memory_write_byte(lh5801.program,reg->w.l++, lh5801.a);
+	memory_write_byte(cpustate->program,reg->w.l++, cpustate->a);
 }
 
-INLINE void lh5801_dec(UINT8 *adr)
+INLINE void lh5801_dec(lh5801_state *cpustate, UINT8 *adr)
 {
-	*adr=lh5801_add_generic(*adr,0xff,0);
+	*adr=lh5801_add_generic(cpustate,*adr,0xff,0);
 }
 
-INLINE void lh5801_inc(UINT8 *adr)
+INLINE void lh5801_inc(lh5801_state *cpustate, UINT8 *adr)
 {
-	*adr=lh5801_add_generic(*adr,1,0);
+	*adr=lh5801_add_generic(cpustate,*adr,1,0);
 }
 
-INLINE void lh5801_pop(void)
+INLINE void lh5801_pop(lh5801_state *cpustate)
 {
-	lh5801.a=memory_read_byte(lh5801.program,++S);
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->a=memory_read_byte(cpustate->program,++S);
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_pop_word(PAIR *reg)
+INLINE void lh5801_pop_word(lh5801_state *cpustate, PAIR *reg)
 {
-	reg->b.h=memory_read_byte(lh5801.program,++S);
-	reg->b.l=memory_read_byte(lh5801.program,++S);
+	reg->b.h=memory_read_byte(cpustate->program,++S);
+	reg->b.l=memory_read_byte(cpustate->program,++S);
 	// z flag?
 }
 
-INLINE void lh5801_rtn(void)
+INLINE void lh5801_rtn(lh5801_state *cpustate)
 {
-	P=memory_read_byte(lh5801.program,++S)<<8;
-	P|=memory_read_byte(lh5801.program,++S);
+	P=memory_read_byte(cpustate->program,++S)<<8;
+	P|=memory_read_byte(cpustate->program,++S);
 }
 
-INLINE void lh5801_rti(void)
+INLINE void lh5801_rti(lh5801_state *cpustate)
 {
-	P=memory_read_byte(lh5801.program,++S)<<8;
-	P|=memory_read_byte(lh5801.program,++S);
-	lh5801.t=memory_read_byte(lh5801.program,++S);
+	P=memory_read_byte(cpustate->program,++S)<<8;
+	P|=memory_read_byte(cpustate->program,++S);
+	cpustate->t=memory_read_byte(cpustate->program,++S);
 }
 
-INLINE void lh5801_push(UINT8 data)
+INLINE void lh5801_push(lh5801_state *cpustate, UINT8 data)
 {
-	memory_write_byte(lh5801.program,S--, data);
+	memory_write_byte(cpustate->program,S--, data);
 }
 
-INLINE void lh5801_push_word(UINT16 data)
+INLINE void lh5801_push_word(lh5801_state *cpustate, UINT16 data)
 {
-	memory_write_byte(lh5801.program,S--, data&0xff);
-	memory_write_byte(lh5801.program,S--, data>>8);
+	memory_write_byte(cpustate->program,S--, data&0xff);
+	memory_write_byte(cpustate->program,S--, data>>8);
 }
 
-INLINE void lh5801_jmp(UINT16 adr)
+INLINE void lh5801_jmp(lh5801_state *cpustate, UINT16 adr)
 {
 	P=adr;
 }
 
-INLINE void lh5801_branch_plus(int doit)
+INLINE void lh5801_branch_plus(lh5801_state *cpustate, int doit)
 {
-	UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
+	UINT8 t=memory_decrypted_read_byte(cpustate->program,P++);
 	if (doit) {
-		lh5801_icount-=3;
+		cpustate->icount-=3;
 		P+=t;
 	}
 }
 
-INLINE void lh5801_branch_minus(int doit)
+INLINE void lh5801_branch_minus(lh5801_state *cpustate, int doit)
 {
-	UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
+	UINT8 t=memory_decrypted_read_byte(cpustate->program,P++);
 	if (doit) {
-		lh5801_icount-=3;
+		cpustate->icount-=3;
 		P-=t;
 	}
 }
 
-INLINE void lh5801_lop(void)
+INLINE void lh5801_lop(lh5801_state *cpustate)
 {
-	UINT8 t=memory_decrypted_read_byte(lh5801.program,P++);
-	lh5801_icount-=8;
+	UINT8 t=memory_decrypted_read_byte(cpustate->program,P++);
+	cpustate->icount-=8;
 	if (UL--) {
-		lh5801_icount-=3;
+		cpustate->icount-=3;
 		P-=t;
 	}
 }
 
-INLINE void lh5801_sjp(void)
+INLINE void lh5801_sjp(lh5801_state *cpustate)
 {
-	UINT16 n=lh5801_readop_word();
-	lh5801_push_word(P);
+	UINT16 n=lh5801_readop_word(cpustate);
+	lh5801_push_word(cpustate,P);
 	P=n;
 }
 
-INLINE void lh5801_vector(int doit, int nr)
+INLINE void lh5801_vector(lh5801_state *cpustate, int doit, int nr)
 {
 	if (doit) {
-		lh5801_push_word(P);
-		P=memory_read_byte(lh5801.program,0xff00+nr)<<8;
-		P|=memory_read_byte(lh5801.program,0xff00+nr+1);
-		lh5801_icount-=21-8;
+		lh5801_push_word(cpustate,P);
+		P=memory_read_byte(cpustate->program,0xff00+nr)<<8;
+		P|=memory_read_byte(cpustate->program,0xff00+nr+1);
+		cpustate->icount-=21-8;
 	}
-	lh5801.t&=~Z; // after the jump!?
+	cpustate->t&=~Z; // after the jump!?
 }
 
-INLINE void lh5801_aex(void)
+INLINE void lh5801_aex(lh5801_state *cpustate)
 {
-	UINT8 t=lh5801.a;
-	lh5801.a=(t<<4)|(t>>4);
+	UINT8 t=cpustate->a;
+	cpustate->a=(t<<4)|(t>>4);
 	// flags?
 }
 
-INLINE void lh5801_drl(int adr)
+INLINE void lh5801_drl(lh5801_state *cpustate, int adr)
 {
-	UINT16 t=lh5801.a|(memory_read_byte(lh5801.program,adr)<<8);
+	UINT16 t=cpustate->a|(memory_read_byte(cpustate->program,adr)<<8);
 
-	lh5801.a=t>>8;
-	memory_write_byte(lh5801.program,adr,t>>4);
+	cpustate->a=t>>8;
+	memory_write_byte(cpustate->program,adr,t>>4);
 }
 
-INLINE void lh5801_drr(int adr)
+INLINE void lh5801_drr(lh5801_state *cpustate, int adr)
 {
-	UINT16 t=memory_read_byte(lh5801.program,adr)|(lh5801.a<<8);
+	UINT16 t=memory_read_byte(cpustate->program,adr)|(cpustate->a<<8);
 
-	lh5801.a=t;
-	memory_write_byte(lh5801.program,adr,t>>4);
+	cpustate->a=t;
+	memory_write_byte(cpustate->program,adr,t>>4);
 }
 
-INLINE void lh5801_rol(void)
+INLINE void lh5801_rol(lh5801_state *cpustate)
 {
 	// maybe use of the adder
-	int n=(lh5801.a<<1)|(lh5801.t&C);
-	lh5801.a=n;
+	int n=(cpustate->a<<1)|(cpustate->t&C);
+	cpustate->a=n;
 	// flags cvhz
-	lh5801.t&=~(C&Z);
-	if (n&0x100) lh5801.t|=C;
-	if (!(n&0xff)) lh5801.t|=Z;
+	cpustate->t&=~(C&Z);
+	if (n&0x100) cpustate->t|=C;
+	if (!(n&0xff)) cpustate->t|=Z;
 }
 
-INLINE void lh5801_ror(void)
+INLINE void lh5801_ror(lh5801_state *cpustate)
 {
-	int n=lh5801.a|((lh5801.t&C)<<8);
-	lh5801.a=n>>1;
+	int n=cpustate->a|((cpustate->t&C)<<8);
+	cpustate->a=n>>1;
 	// flags cvhz
-	lh5801.t&=~(C&Z);
-	lh5801.t|=(n&C);
-	if (!(n&0x1fe)) lh5801.t|=Z;
+	cpustate->t&=~(C&Z);
+	cpustate->t|=(n&C);
+	if (!(n&0x1fe)) cpustate->t|=Z;
 }
 
-INLINE void lh5801_shl(void)
+INLINE void lh5801_shl(lh5801_state *cpustate)
 {
-	int nc=lh5801.a&0x80;
-	lh5801.a<<=1;
+	int nc=cpustate->a&0x80;
+	cpustate->a<<=1;
 	// flags cvhz
-	lh5801.t&=~(C&Z);
-	if (nc) lh5801.t|=C;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->t&=~(C&Z);
+	if (nc) cpustate->t|=C;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_shr(void)
+INLINE void lh5801_shr(lh5801_state *cpustate)
 {
-	int nc=lh5801.a&1;
-	lh5801.a>>=1;
+	int nc=cpustate->a&1;
+	cpustate->a>>=1;
 	// flags cvhz
-	lh5801.t&=~(C|Z);
-	if (nc) lh5801.t|=C;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->t&=~(C|Z);
+	if (nc) cpustate->t|=C;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-INLINE void lh5801_am(int value)
+INLINE void lh5801_am(lh5801_state *cpustate, int value)
 {
-	lh5801.tm=value;
+	cpustate->tm=value;
 	// jfkas?jfkl?jkd?
 }
 
-INLINE void lh5801_ita(void)
+INLINE void lh5801_ita(lh5801_state *cpustate)
 {
-	if (lh5801.config&&lh5801.config->in) {
-		lh5801.a=lh5801.config->in();
+	if (cpustate->config&&cpustate->config->in) {
+		cpustate->a=cpustate->config->in(cpustate->device);
 	} else {
-		lh5801.a=0;
+		cpustate->a=0;
 	}
-	lh5801.t&=~Z;
-	if (!lh5801.a) lh5801.t|=Z;
+	cpustate->t&=~Z;
+	if (!cpustate->a) cpustate->t|=Z;
 }
 
-static void lh5801_instruction_fd(void)
+static void lh5801_instruction_fd(lh5801_state *cpustate)
 {
 	int oper;
 	int adr;
 
-	oper=memory_decrypted_read_byte(lh5801.program,P++);
+	oper=memory_decrypted_read_byte(cpustate->program,P++);
 	switch (oper) {
-	case 0x01: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x03: lh5801_adc(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x05: lh5801_lda(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=10;break;
-	case 0x07: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x08: X=X;lh5801_icount-=11;break; //!!!
-	case 0x09: lh5801_and(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x0a: lh5801_pop_word(&lh5801.x); lh5801_icount-=15;break;
-	case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=17; break;
-	case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=11;break;
-	case 0x0e: memory_write_byte(lh5801.program,0x10000|X,lh5801.a); lh5801_icount-=10;break;
-	case 0x0f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|X),lh5801.a); lh5801_icount-=11;break;
-	case 0x11: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x13: lh5801_adc(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x15: lh5801_lda(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=10;break;
-	case 0x17: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x18: X=Y;lh5801_icount-=11;break;
-	case 0x19: lh5801_and(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x1a: lh5801_pop_word(&lh5801.y); lh5801_icount-=15;break;
-	case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=17; break;
-	case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=11;break;
-	case 0x1e: memory_write_byte(lh5801.program,0x10000|Y,lh5801.a); lh5801_icount-=10;break;
-	case 0x1f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|Y),lh5801.a); lh5801_icount-=11;break;
-	case 0x21: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x23: lh5801_adc(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x25: lh5801_lda(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=10;break;
-	case 0x27: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x28: X=U;lh5801_icount-=11;break;
-	case 0x29: lh5801_and(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x2a: lh5801_pop_word(&lh5801.u); lh5801_icount-=15;break;
-	case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=17; break;
-	case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=11;break;
-	case 0x2e: memory_write_byte(lh5801.program,0x10000|U,lh5801.a); lh5801_icount-=10;break;
-	case 0x2f: lh5801_bit(memory_read_byte(lh5801.program,0x10000|U),lh5801.a); lh5801_icount-=11;break;
-	case 0x40: lh5801_inc(&XH);lh5801_icount-=9;break;
-	case 0x42: lh5801_dec(&XH);lh5801_icount-=9;break;
-	case 0x48: X=S;lh5801_icount-=11;break;
-	case 0x49: lh5801_and_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x4a: X=X;lh5801_icount-=11;break; //!!!
-	case 0x4b: lh5801_ora_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x4c: lh5801.bf=0;/*off !*/ lh5801_icount-=8;break;
-	case 0x4d: lh5801_bit(memory_read_byte(lh5801.program,X|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
-	case 0x4e: S=X;lh5801_icount-=11;break;
-	case 0x4f: lh5801_add_mem(0x10000|X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x50: lh5801_inc(&YH);lh5801_icount-=9;break;
-	case 0x52: lh5801_dec(&YH);lh5801_icount-=9;break;
-	case 0x58: X=P;lh5801_icount-=11;break;
-	case 0x59: lh5801_and_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x5a: Y=X;lh5801_icount-=11;break;
-	case 0x5b: lh5801_ora_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x5d: lh5801_bit(memory_read_byte(lh5801.program,Y|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
-	case 0x5e: lh5801_jmp(X);lh5801_icount-=11;break; // P=X
-	case 0x5f: lh5801_add_mem(0x10000|Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x60: lh5801_inc(&UH);lh5801_icount-=9;break;
-	case 0x62: lh5801_dec(&UH);lh5801_icount-=9;break;
-	case 0x69: lh5801_and_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x6a: U=X;lh5801_icount-=11;break;
-	case 0x6b: lh5801_ora_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x6d: lh5801_bit(memory_read_byte(lh5801.program,X|0x10000), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=14;break;
-	case 0x6f: lh5801_add_mem(0x10000|U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=17;break;
-	case 0x81: lh5801.t|=IE; /*sie !*/lh5801_icount-=8;break;
-	case 0x88: lh5801_push_word(X); lh5801_icount-=14;break;
-	case 0x8a: lh5801_pop(); lh5801_icount-=12; break;
-	case 0x8c: lh5801_dca(memory_read_byte(lh5801.program,0x10000|X)); lh5801_icount-=19; break;
-	case 0x8e: /*cdv clears internal devider*/lh5801_icount-=8;break;
-	case 0x98: lh5801_push_word(Y); lh5801_icount-=14;break;
-	case 0x9c: lh5801_dca(memory_read_byte(lh5801.program,0x10000|Y)); lh5801_icount-=19; break;
-	case 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xa3: lh5801_adc(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xa5: lh5801_lda(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=16;break;
-	case 0xa7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xa8: lh5801_push_word(U); lh5801_icount-=14;break;
-	case 0xa9: lh5801_and(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xaa: lh5801_lda(lh5801.t); lh5801_icount-=9;break;
-	case 0xab: lh5801_ora(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xac: lh5801_dca(memory_read_byte(lh5801.program,0x10000|U)); lh5801_icount-=19; break;
-	case 0xad: lh5801_eor(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word())); lh5801_icount-=17;break;
-	case 0xae: memory_write_byte(lh5801.program,0x10000|lh5801_readop_word(),lh5801.a); lh5801_icount-=16;break;
-	case 0xaf: lh5801_bit(memory_read_byte(lh5801.program,0x10000|lh5801_readop_word()),lh5801.a); lh5801_icount-=17;break;
-	case 0xb1: /*hlt*/lh5801_icount-=8;break;
-	case 0xba: lh5801_ita();lh5801_icount-=9;break;
-	case 0xbe: lh5801.t&=~IE; /*rie !*/lh5801_icount-=8;break;
-	case 0xc0: lh5801.dp=0; /*rdp !*/lh5801_icount-=8;break;
-	case 0xc1: lh5801.dp=1; /*sdp !*/lh5801_icount-=8;break;
-	case 0xc8: lh5801_push(lh5801.a); lh5801_icount-=11;break;
-	case 0xca: lh5801_adr(&lh5801.x);lh5801_icount-=11;break;
-	case 0xcc: /*atp sends a to data bus*/lh5801_icount-=9;break;
-	case 0xce: lh5801_am(lh5801.a); lh5801_icount-=9; break;
-	case 0xd3: lh5801_drr(0x10000|X); lh5801_icount-=16; break;
-	case 0xd7: lh5801_drl(0x10000|X); lh5801_icount-=16; break;
-	case 0xda: lh5801_adr(&lh5801.y);lh5801_icount-=11;break;
-	case 0xde: lh5801_am(lh5801.a|0x100); lh5801_icount-=9; break;
-	case 0xea: lh5801_adr(&lh5801.u);lh5801_icount-=11;break;
+	case 0x01: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x03: lh5801_adc(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x05: lh5801_lda(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=10;break;
+	case 0x07: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x08: X=X;cpustate->icount-=11;break; //!!!
+	case 0x09: lh5801_and(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x0a: lh5801_pop_word(cpustate,&cpustate->x); cpustate->icount-=15;break;
+	case 0x0b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x0c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=17; break;
+	case 0x0d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=11;break;
+	case 0x0e: memory_write_byte(cpustate->program,0x10000|X,cpustate->a); cpustate->icount-=10;break;
+	case 0x0f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,0x10000|X),cpustate->a); cpustate->icount-=11;break;
+	case 0x11: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x13: lh5801_adc(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x15: lh5801_lda(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=10;break;
+	case 0x17: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x18: X=Y;cpustate->icount-=11;break;
+	case 0x19: lh5801_and(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x1a: lh5801_pop_word(cpustate,&cpustate->y); cpustate->icount-=15;break;
+	case 0x1b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x1c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=17; break;
+	case 0x1d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=11;break;
+	case 0x1e: memory_write_byte(cpustate->program,0x10000|Y,cpustate->a); cpustate->icount-=10;break;
+	case 0x1f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,0x10000|Y),cpustate->a); cpustate->icount-=11;break;
+	case 0x21: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x23: lh5801_adc(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x25: lh5801_lda(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=10;break;
+	case 0x27: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x28: X=U;cpustate->icount-=11;break;
+	case 0x29: lh5801_and(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x2a: lh5801_pop_word(cpustate,&cpustate->u); cpustate->icount-=15;break;
+	case 0x2b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x2c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=17; break;
+	case 0x2d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=11;break;
+	case 0x2e: memory_write_byte(cpustate->program,0x10000|U,cpustate->a); cpustate->icount-=10;break;
+	case 0x2f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,0x10000|U),cpustate->a); cpustate->icount-=11;break;
+	case 0x40: lh5801_inc(cpustate,&XH);cpustate->icount-=9;break;
+	case 0x42: lh5801_dec(cpustate,&XH);cpustate->icount-=9;break;
+	case 0x48: X=S;cpustate->icount-=11;break;
+	case 0x49: lh5801_and_mem(cpustate,0x10000|X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x4a: X=X;cpustate->icount-=11;break; //!!!
+	case 0x4b: lh5801_ora_mem(cpustate,0x10000|X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x4c: cpustate->bf=0;/*off !*/ cpustate->icount-=8;break;
+	case 0x4d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,X|0x10000), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=14;break;
+	case 0x4e: S=X;cpustate->icount-=11;break;
+	case 0x4f: lh5801_add_mem(cpustate,0x10000|X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x50: lh5801_inc(cpustate,&YH);cpustate->icount-=9;break;
+	case 0x52: lh5801_dec(cpustate,&YH);cpustate->icount-=9;break;
+	case 0x58: X=P;cpustate->icount-=11;break;
+	case 0x59: lh5801_and_mem(cpustate,0x10000|Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x5a: Y=X;cpustate->icount-=11;break;
+	case 0x5b: lh5801_ora_mem(cpustate,0x10000|Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x5d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,Y|0x10000), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=14;break;
+	case 0x5e: lh5801_jmp(cpustate,X);cpustate->icount-=11;break; // P=X
+	case 0x5f: lh5801_add_mem(cpustate,0x10000|Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x60: lh5801_inc(cpustate,&UH);cpustate->icount-=9;break;
+	case 0x62: lh5801_dec(cpustate,&UH);cpustate->icount-=9;break;
+	case 0x69: lh5801_and_mem(cpustate,0x10000|U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x6a: U=X;cpustate->icount-=11;break;
+	case 0x6b: lh5801_ora_mem(cpustate,0x10000|U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x6d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,X|0x10000), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=14;break;
+	case 0x6f: lh5801_add_mem(cpustate,0x10000|U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=17;break;
+	case 0x81: cpustate->t|=IE; /*sie !*/cpustate->icount-=8;break;
+	case 0x88: lh5801_push_word(cpustate,X); cpustate->icount-=14;break;
+	case 0x8a: lh5801_pop(cpustate); cpustate->icount-=12; break;
+	case 0x8c: lh5801_dca(cpustate,memory_read_byte(cpustate->program,0x10000|X)); cpustate->icount-=19; break;
+	case 0x8e: /*cdv clears internal devider*/cpustate->icount-=8;break;
+	case 0x98: lh5801_push_word(cpustate,Y); cpustate->icount-=14;break;
+	case 0x9c: lh5801_dca(cpustate,memory_read_byte(cpustate->program,0x10000|Y)); cpustate->icount-=19; break;
+	case 0xa1: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xa3: lh5801_adc(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xa5: lh5801_lda(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=16;break;
+	case 0xa7: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xa8: lh5801_push_word(cpustate,U); cpustate->icount-=14;break;
+	case 0xa9: lh5801_and(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xaa: lh5801_lda(cpustate,cpustate->t); cpustate->icount-=9;break;
+	case 0xab: lh5801_ora(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xac: lh5801_dca(cpustate,memory_read_byte(cpustate->program,0x10000|U)); cpustate->icount-=19; break;
+	case 0xad: lh5801_eor(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate))); cpustate->icount-=17;break;
+	case 0xae: memory_write_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate),cpustate->a); cpustate->icount-=16;break;
+	case 0xaf: lh5801_bit(cpustate,memory_read_byte(cpustate->program,0x10000|lh5801_readop_word(cpustate)),cpustate->a); cpustate->icount-=17;break;
+	case 0xb1: /*hlt*/cpustate->icount-=8;break;
+	case 0xba: lh5801_ita(cpustate);cpustate->icount-=9;break;
+	case 0xbe: cpustate->t&=~IE; /*rie !*/cpustate->icount-=8;break;
+	case 0xc0: cpustate->dp=0; /*rdp !*/cpustate->icount-=8;break;
+	case 0xc1: cpustate->dp=1; /*sdp !*/cpustate->icount-=8;break;
+	case 0xc8: lh5801_push(cpustate,cpustate->a); cpustate->icount-=11;break;
+	case 0xca: lh5801_adr(cpustate,&cpustate->x);cpustate->icount-=11;break;
+	case 0xcc: /*atp sends a to data bus*/cpustate->icount-=9;break;
+	case 0xce: lh5801_am(cpustate,cpustate->a); cpustate->icount-=9; break;
+	case 0xd3: lh5801_drr(cpustate,0x10000|X); cpustate->icount-=16; break;
+	case 0xd7: lh5801_drl(cpustate,0x10000|X); cpustate->icount-=16; break;
+	case 0xda: lh5801_adr(cpustate,&cpustate->y);cpustate->icount-=11;break;
+	case 0xde: lh5801_am(cpustate,cpustate->a|0x100); cpustate->icount-=9; break;
+	case 0xea: lh5801_adr(cpustate,&cpustate->u);cpustate->icount-=11;break;
 	case 0xe9:
-		adr=lh5801_readop_word()|0x10000;
-		lh5801_and_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
+		adr=lh5801_readop_word(cpustate)|0x10000;
+		lh5801_and_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=23;
 		break;
 	case 0xeb:
-		adr=lh5801_readop_word()|0x10000;
-		lh5801_ora_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
+		adr=lh5801_readop_word(cpustate)|0x10000;
+		lh5801_ora_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=23;
 		break;
-	case 0xec: lh5801.t=lh5801.a; lh5801_icount-=9;break;
+	case 0xec: cpustate->t=cpustate->a; cpustate->icount-=9;break;
 	case 0xed:
-		adr=lh5801_readop_word()|0x10000;lh5801_bit(memory_read_byte(lh5801.program,adr), memory_decrypted_read_byte(lh5801.program,P++));
-		lh5801_icount-=20;break;
+		adr=lh5801_readop_word(cpustate)|0x10000;lh5801_bit(cpustate,memory_read_byte(cpustate->program,adr), memory_decrypted_read_byte(cpustate->program,P++));
+		cpustate->icount-=20;break;
 	case 0xef:
-		adr=lh5801_readop_word()|0x10000;
-		lh5801_add_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=23;
+		adr=lh5801_readop_word(cpustate)|0x10000;
+		lh5801_add_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=23;
 		break;
 
 	default:
@@ -468,205 +468,205 @@ static void lh5801_instruction_fd(void)
 	}
 }
 
-static void lh5801_instruction(void)
+static void lh5801_instruction(lh5801_state *cpustate)
 {
 	int oper;
 	int adr;
 
-	oper=memory_decrypted_read_byte(lh5801.program,P++);
+	oper=memory_decrypted_read_byte(cpustate->program,P++);
 	switch (oper) {
-	case 0x00: lh5801_sbc(XL); lh5801_icount-=6;break;
-	case 0x01: lh5801_sbc(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x02: lh5801_adc(XL); lh5801_icount-=6;break;
-	case 0x03: lh5801_adc(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x04: lh5801_lda(XL); lh5801_icount-=5;break;
-	case 0x05: lh5801_lda(memory_read_byte(lh5801.program,X)); lh5801_icount-=6;break;
-	case 0x06: lh5801_cpa(lh5801.a, XL); lh5801_icount-=6;break;
-	case 0x07: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x08: XH=lh5801.a; lh5801_icount-=5; break;
-	case 0x09: lh5801_and(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x0a: XL=lh5801.a; lh5801_icount-=5; break;
-	case 0x0b: lh5801_ora(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x0c: lh5801_dcs(memory_read_byte(lh5801.program,X)); lh5801_icount-=13; break;
-	case 0x0d: lh5801_eor(memory_read_byte(lh5801.program,X)); lh5801_icount-=7;break;
-	case 0x0e: memory_write_byte(lh5801.program,X,lh5801.a); lh5801_icount-=6;break;
-	case 0x0f: lh5801_bit(memory_read_byte(lh5801.program,X),lh5801.a); lh5801_icount-=7;break;
-	case 0x10: lh5801_sbc(YL); lh5801_icount-=6;break;
-	case 0x11: lh5801_sbc(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x12: lh5801_adc(YL); lh5801_icount-=6;break;
-	case 0x13: lh5801_adc(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x14: lh5801_lda(YL); lh5801_icount-=5;break;
-	case 0x15: lh5801_lda(memory_read_byte(lh5801.program,Y)); lh5801_icount-=6;break;
-	case 0x16: lh5801_cpa(lh5801.a, YL); lh5801_icount-=6;break;
-	case 0x17: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x18: YH=lh5801.a; lh5801_icount-=5; break;
-	case 0x19: lh5801_and(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x1a: YL=lh5801.a; lh5801_icount-=5; break;
-	case 0x1b: lh5801_ora(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x1c: lh5801_dcs(memory_read_byte(lh5801.program,Y)); lh5801_icount-=13; break;
-	case 0x1d: lh5801_eor(memory_read_byte(lh5801.program,Y)); lh5801_icount-=7;break;
-	case 0x1e: memory_write_byte(lh5801.program,Y,lh5801.a); lh5801_icount-=6;break;
-	case 0x1f: lh5801_bit(memory_read_byte(lh5801.program,Y),lh5801.a); lh5801_icount-=7;break;
-	case 0x20: lh5801_sbc(UL); lh5801_icount-=6;break;
-	case 0x21: lh5801_sbc(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x22: lh5801_adc(UL); lh5801_icount-=6;break;
-	case 0x23: lh5801_adc(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x24: lh5801_lda(UL); lh5801_icount-=5;break;
-	case 0x25: lh5801_lda(memory_read_byte(lh5801.program,U)); lh5801_icount-=6;break;
-	case 0x26: lh5801_cpa(lh5801.a, UL); lh5801_icount-=6;break;
-	case 0x27: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x28: UH=lh5801.a; lh5801_icount-=5; break;
-	case 0x29: lh5801_and(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x2a: UL=lh5801.a; lh5801_icount-=5; break;
-	case 0x2b: lh5801_ora(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x2c: lh5801_dcs(memory_read_byte(lh5801.program,U)); lh5801_icount-=13; break;
-	case 0x2d: lh5801_eor(memory_read_byte(lh5801.program,U)); lh5801_icount-=7;break;
-	case 0x2e: memory_write_byte(lh5801.program,U,lh5801.a); lh5801_icount-=6;break;
-	case 0x2f: lh5801_bit(memory_read_byte(lh5801.program,U),lh5801.a); lh5801_icount-=7;break;
-	case 0x38: /*nop*/lh5801_icount-=5;break;
-	case 0x40: lh5801_inc(&XL);lh5801_icount-=5;break;
-	case 0x41: lh5801_sin(&lh5801.x); lh5801_icount-=6;break;
-	case 0x42: lh5801_dec(&XL);lh5801_icount-=5;break;
-	case 0x43: lh5801_sde(&lh5801.x); lh5801_icount-=6;break;
-	case 0x44: X++;lh5801_icount-=5;break;
-	case 0x45: lh5801_lin(&lh5801.x);lh5801_icount-=6;break;
-	case 0x46: X--;lh5801_icount-=5;break;
-	case 0x47: lh5801_lde(&lh5801.x);lh5801_icount-=6;break;
-	case 0x48: XH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x49: lh5801_and_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x4a: XL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x4b: lh5801_ora_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x4c: lh5801_cpa(XH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x4d: lh5801_bit(memory_read_byte(lh5801.program,X), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
-	case 0x4e: lh5801_cpa(XL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x4f: lh5801_add_mem(X, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x50: lh5801_inc(&YL);lh5801_icount-=5;break;
-	case 0x51: lh5801_sin(&lh5801.y); lh5801_icount-=6;break;
-	case 0x52: lh5801_dec(&YL);lh5801_icount-=5;break;
-	case 0x53: lh5801_sde(&lh5801.y); lh5801_icount-=6;break;
-	case 0x54: Y++;lh5801_icount-=5;break;
-	case 0x55: lh5801_lin(&lh5801.y);lh5801_icount-=6;break;
-	case 0x56: Y--;lh5801_icount-=5;break;
-	case 0x57: lh5801_lde(&lh5801.y);lh5801_icount-=6;break;
-	case 0x58: YH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x59: lh5801_and_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x5a: YL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x5b: lh5801_ora_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x5c: lh5801_cpa(YH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x5d: lh5801_bit(memory_read_byte(lh5801.program,Y), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
-	case 0x5e: lh5801_cpa(YL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x5f: lh5801_add_mem(Y, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x60: lh5801_inc(&UL);lh5801_icount-=5;break;
-	case 0x61: lh5801_sin(&lh5801.u); lh5801_icount-=6;break;
-	case 0x62: lh5801_dec(&UL);lh5801_icount-=5;break;
-	case 0x63: lh5801_sde(&lh5801.u); lh5801_icount-=6;break;
-	case 0x64: U++;lh5801_icount-=5;break;
-	case 0x65: lh5801_lin(&lh5801.u);lh5801_icount-=6;break;
-	case 0x66: U--;lh5801_icount-=5;break;
-	case 0x67: lh5801_lde(&lh5801.u);lh5801_icount-=6;break;
-	case 0x68: UH=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x69: lh5801_and_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x6a: UL=memory_decrypted_read_byte(lh5801.program,P++);lh5801_icount-=6;break;
-	case 0x6b: lh5801_ora_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x6c: lh5801_cpa(UH, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x6d: lh5801_bit(memory_read_byte(lh5801.program,U), memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=10;break;
-	case 0x6e: lh5801_cpa(UL, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0x6f: lh5801_add_mem(U, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=13;break;
-	case 0x80: lh5801_sbc(XH); lh5801_icount-=6;break;
-	case 0x81: lh5801_branch_plus(!(lh5801.t&C)); lh5801_icount-=8; break;
-	case 0x82: lh5801_adc(XH); lh5801_icount-=6;break;
-	case 0x83: lh5801_branch_plus(lh5801.t&C); lh5801_icount-=8; break;
-	case 0x84: lh5801_lda(XH); lh5801_icount-=5;break;
-	case 0x85: lh5801_branch_plus(!(lh5801.t&H)); lh5801_icount-=8; break;
-	case 0x86: lh5801_cpa(lh5801.a, XH); lh5801_icount-=6;break;
-	case 0x87: lh5801_branch_plus(lh5801.t&H); lh5801_icount-=8; break;
-	case 0x88: lh5801_lop(); break;
-	case 0x89: lh5801_branch_plus(!(lh5801.t&Z)); lh5801_icount-=8; break;
-	case 0x8a: lh5801_rti(); lh5801_icount-=14; break;
-	case 0x8b: lh5801_branch_plus(lh5801.t&Z); lh5801_icount-=8; break;
-	case 0x8c: lh5801_dca(memory_read_byte(lh5801.program,X)); lh5801_icount-=15; break;
-	case 0x8d: lh5801_branch_plus(!(lh5801.t&V)); lh5801_icount-=8; break;
-	case 0x8e: lh5801_branch_plus(1); lh5801_icount-=5; break;
-	case 0x8f: lh5801_branch_plus(lh5801.t&V); lh5801_icount-=8; break;
-	case 0x90: lh5801_sbc(YH); lh5801_icount-=6;break;
-	case 0x91: lh5801_branch_minus(!(lh5801.t&C)); lh5801_icount-=8; break;
-	case 0x92: lh5801_adc(YH); lh5801_icount-=6;break;
-	case 0x93: lh5801_branch_minus(lh5801.t&C); lh5801_icount-=8; break;
-	case 0x94: lh5801_lda(YH); lh5801_icount-=5;break;
-	case 0x95: lh5801_branch_minus(!(lh5801.t&H)); lh5801_icount-=8; break;
-	case 0x96: lh5801_cpa(lh5801.a, YH); lh5801_icount-=6;break;
-	case 0x97: lh5801_branch_minus(lh5801.t&H); lh5801_icount-=8; break;
-	case 0x99: lh5801_branch_minus(!(lh5801.t&Z)); lh5801_icount-=8; break;
-	case 0x9a: lh5801_rtn(); lh5801_icount-=11; break;
-	case 0x9b: lh5801_branch_minus(lh5801.t&Z); lh5801_icount-=8; break;
-	case 0x9c: lh5801_dca(memory_read_byte(lh5801.program,Y)); lh5801_icount-=15; break;
-	case 0x9d: lh5801_branch_minus(!(lh5801.t&V)); lh5801_icount-=8; break;
-	case 0x9e: lh5801_branch_minus(1); lh5801_icount-=6; break;
-	case 0x9f: lh5801_branch_minus(lh5801.t&V); lh5801_icount-=8; break;
-	case 0xa0: lh5801_sbc(UH); lh5801_icount-=6;break;
-	case 0xa2: lh5801_adc(UH); lh5801_icount-=6;break;
-	case 0xa1: lh5801_sbc(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xa3: lh5801_adc(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xa4: lh5801_lda(UH); lh5801_icount-=5;break;
-	case 0xa5: lh5801_lda(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=12;break;
-	case 0xa6: lh5801_cpa(lh5801.a, UH); lh5801_icount-=6;break;
-	case 0xa7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xa8: lh5801.pv=1;/*spv!*/ lh5801_icount-=4; break;
-	case 0xa9: lh5801_and(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xaa: S=lh5801_readop_word();lh5801_icount-=6;break;
-	case 0xab: lh5801_ora(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xac: lh5801_dca(memory_read_byte(lh5801.program,U)); lh5801_icount-=15; break;
-	case 0xad: lh5801_eor(memory_read_byte(lh5801.program,lh5801_readop_word())); lh5801_icount-=13;break;
-	case 0xae: memory_write_byte(lh5801.program,lh5801_readop_word(),lh5801.a); lh5801_icount-=12;break;
-	case 0xaf: lh5801_bit(memory_read_byte(lh5801.program,lh5801_readop_word()),lh5801.a); lh5801_icount-=13;break;
-	case 0xb1: lh5801_sbc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xb3: lh5801_adc(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xb5: lh5801_lda(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=6;break;
-	case 0xb7: lh5801_cpa(lh5801.a, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xb8: lh5801.pv=0;/*rpv!*/ lh5801_icount-=4; break;
-	case 0xb9: lh5801_and(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xba: lh5801_jmp(lh5801_readop_word()); lh5801_icount-=12;break;
-	case 0xbb: lh5801_ora(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xbd: lh5801_eor(memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xbe: lh5801_sjp(); lh5801_icount-=19; break;
-	case 0xbf: lh5801_bit(lh5801.a, memory_decrypted_read_byte(lh5801.program,P++));lh5801_icount-=7;break;
-	case 0xc1: lh5801_vector(!(lh5801.t&C), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xc3: lh5801_vector(lh5801.t&C, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xc5: lh5801_vector(!(lh5801.t&H), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xc7: lh5801_vector(lh5801.t&H, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xc9: lh5801_vector(!(lh5801.t&Z), memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xcb: lh5801_vector(lh5801.t&Z, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xcd: lh5801_vector(1, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=7;break;
-	case 0xcf: lh5801_vector(lh5801.t&V, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=8;break;
-	case 0xd1: lh5801_ror(); lh5801_icount-=6; break;
-	case 0xd3: lh5801_drr(X); lh5801_icount-=12; break;
-	case 0xd5: lh5801_shr(); lh5801_icount-=6; break;
-	case 0xd7: lh5801_drl(X); lh5801_icount-=12; break;
-	case 0xd9: lh5801_shl(); lh5801_icount-=6; break;
-	case 0xdb: lh5801_rol(); lh5801_icount-=6; break;
-	case 0xdd: lh5801_inc(&lh5801.a);lh5801_icount-=5;break;
-	case 0xdf: lh5801_dec(&lh5801.a);lh5801_icount-=5;break;
-	case 0xe1: lh5801.pu=1;/*spu!*/ lh5801_icount-=4; break;
-	case 0xe3: lh5801.pu=0;/*rpu!*/ lh5801_icount-=4; break;
+	case 0x00: lh5801_sbc(cpustate,XL); cpustate->icount-=6;break;
+	case 0x01: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x02: lh5801_adc(cpustate,XL); cpustate->icount-=6;break;
+	case 0x03: lh5801_adc(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x04: lh5801_lda(cpustate,XL); cpustate->icount-=5;break;
+	case 0x05: lh5801_lda(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=6;break;
+	case 0x06: lh5801_cpa(cpustate,cpustate->a, XL); cpustate->icount-=6;break;
+	case 0x07: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x08: XH=cpustate->a; cpustate->icount-=5; break;
+	case 0x09: lh5801_and(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x0a: XL=cpustate->a; cpustate->icount-=5; break;
+	case 0x0b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x0c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=13; break;
+	case 0x0d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=7;break;
+	case 0x0e: memory_write_byte(cpustate->program,X,cpustate->a); cpustate->icount-=6;break;
+	case 0x0f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,X),cpustate->a); cpustate->icount-=7;break;
+	case 0x10: lh5801_sbc(cpustate,YL); cpustate->icount-=6;break;
+	case 0x11: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x12: lh5801_adc(cpustate,YL); cpustate->icount-=6;break;
+	case 0x13: lh5801_adc(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x14: lh5801_lda(cpustate,YL); cpustate->icount-=5;break;
+	case 0x15: lh5801_lda(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=6;break;
+	case 0x16: lh5801_cpa(cpustate,cpustate->a, YL); cpustate->icount-=6;break;
+	case 0x17: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x18: YH=cpustate->a; cpustate->icount-=5; break;
+	case 0x19: lh5801_and(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x1a: YL=cpustate->a; cpustate->icount-=5; break;
+	case 0x1b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x1c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=13; break;
+	case 0x1d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=7;break;
+	case 0x1e: memory_write_byte(cpustate->program,Y,cpustate->a); cpustate->icount-=6;break;
+	case 0x1f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,Y),cpustate->a); cpustate->icount-=7;break;
+	case 0x20: lh5801_sbc(cpustate,UL); cpustate->icount-=6;break;
+	case 0x21: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x22: lh5801_adc(cpustate,UL); cpustate->icount-=6;break;
+	case 0x23: lh5801_adc(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x24: lh5801_lda(cpustate,UL); cpustate->icount-=5;break;
+	case 0x25: lh5801_lda(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=6;break;
+	case 0x26: lh5801_cpa(cpustate,cpustate->a, UL); cpustate->icount-=6;break;
+	case 0x27: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x28: UH=cpustate->a; cpustate->icount-=5; break;
+	case 0x29: lh5801_and(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x2a: UL=cpustate->a; cpustate->icount-=5; break;
+	case 0x2b: lh5801_ora(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x2c: lh5801_dcs(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=13; break;
+	case 0x2d: lh5801_eor(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=7;break;
+	case 0x2e: memory_write_byte(cpustate->program,U,cpustate->a); cpustate->icount-=6;break;
+	case 0x2f: lh5801_bit(cpustate,memory_read_byte(cpustate->program,U),cpustate->a); cpustate->icount-=7;break;
+	case 0x38: /*nop*/cpustate->icount-=5;break;
+	case 0x40: lh5801_inc(cpustate,&XL);cpustate->icount-=5;break;
+	case 0x41: lh5801_sin(cpustate,&cpustate->x); cpustate->icount-=6;break;
+	case 0x42: lh5801_dec(cpustate,&XL);cpustate->icount-=5;break;
+	case 0x43: lh5801_sde(cpustate,&cpustate->x); cpustate->icount-=6;break;
+	case 0x44: X++;cpustate->icount-=5;break;
+	case 0x45: lh5801_lin(cpustate,&cpustate->x);cpustate->icount-=6;break;
+	case 0x46: X--;cpustate->icount-=5;break;
+	case 0x47: lh5801_lde(cpustate,&cpustate->x);cpustate->icount-=6;break;
+	case 0x48: XH=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x49: lh5801_and_mem(cpustate,X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x4a: XL=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x4b: lh5801_ora_mem(cpustate,X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x4c: lh5801_cpa(cpustate,XH, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x4d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,X), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=10;break;
+	case 0x4e: lh5801_cpa(cpustate,XL, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x4f: lh5801_add_mem(cpustate,X, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x50: lh5801_inc(cpustate,&YL);cpustate->icount-=5;break;
+	case 0x51: lh5801_sin(cpustate,&cpustate->y); cpustate->icount-=6;break;
+	case 0x52: lh5801_dec(cpustate,&YL);cpustate->icount-=5;break;
+	case 0x53: lh5801_sde(cpustate,&cpustate->y); cpustate->icount-=6;break;
+	case 0x54: Y++;cpustate->icount-=5;break;
+	case 0x55: lh5801_lin(cpustate,&cpustate->y);cpustate->icount-=6;break;
+	case 0x56: Y--;cpustate->icount-=5;break;
+	case 0x57: lh5801_lde(cpustate,&cpustate->y);cpustate->icount-=6;break;
+	case 0x58: YH=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x59: lh5801_and_mem(cpustate,Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x5a: YL=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x5b: lh5801_ora_mem(cpustate,Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x5c: lh5801_cpa(cpustate,YH, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x5d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,Y), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=10;break;
+	case 0x5e: lh5801_cpa(cpustate,YL, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x5f: lh5801_add_mem(cpustate,Y, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x60: lh5801_inc(cpustate,&UL);cpustate->icount-=5;break;
+	case 0x61: lh5801_sin(cpustate,&cpustate->u); cpustate->icount-=6;break;
+	case 0x62: lh5801_dec(cpustate,&UL);cpustate->icount-=5;break;
+	case 0x63: lh5801_sde(cpustate,&cpustate->u); cpustate->icount-=6;break;
+	case 0x64: U++;cpustate->icount-=5;break;
+	case 0x65: lh5801_lin(cpustate,&cpustate->u);cpustate->icount-=6;break;
+	case 0x66: U--;cpustate->icount-=5;break;
+	case 0x67: lh5801_lde(cpustate,&cpustate->u);cpustate->icount-=6;break;
+	case 0x68: UH=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x69: lh5801_and_mem(cpustate,U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x6a: UL=memory_decrypted_read_byte(cpustate->program,P++);cpustate->icount-=6;break;
+	case 0x6b: lh5801_ora_mem(cpustate,U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x6c: lh5801_cpa(cpustate,UH, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x6d: lh5801_bit(cpustate,memory_read_byte(cpustate->program,U), memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=10;break;
+	case 0x6e: lh5801_cpa(cpustate,UL, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0x6f: lh5801_add_mem(cpustate,U, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=13;break;
+	case 0x80: lh5801_sbc(cpustate,XH); cpustate->icount-=6;break;
+	case 0x81: lh5801_branch_plus(cpustate,!(cpustate->t&C)); cpustate->icount-=8; break;
+	case 0x82: lh5801_adc(cpustate,XH); cpustate->icount-=6;break;
+	case 0x83: lh5801_branch_plus(cpustate,cpustate->t&C); cpustate->icount-=8; break;
+	case 0x84: lh5801_lda(cpustate,XH); cpustate->icount-=5;break;
+	case 0x85: lh5801_branch_plus(cpustate,!(cpustate->t&H)); cpustate->icount-=8; break;
+	case 0x86: lh5801_cpa(cpustate,cpustate->a, XH); cpustate->icount-=6;break;
+	case 0x87: lh5801_branch_plus(cpustate,cpustate->t&H); cpustate->icount-=8; break;
+	case 0x88: lh5801_lop(cpustate); break;
+	case 0x89: lh5801_branch_plus(cpustate,!(cpustate->t&Z)); cpustate->icount-=8; break;
+	case 0x8a: lh5801_rti(cpustate); cpustate->icount-=14; break;
+	case 0x8b: lh5801_branch_plus(cpustate,cpustate->t&Z); cpustate->icount-=8; break;
+	case 0x8c: lh5801_dca(cpustate,memory_read_byte(cpustate->program,X)); cpustate->icount-=15; break;
+	case 0x8d: lh5801_branch_plus(cpustate,!(cpustate->t&V)); cpustate->icount-=8; break;
+	case 0x8e: lh5801_branch_plus(cpustate,1); cpustate->icount-=5; break;
+	case 0x8f: lh5801_branch_plus(cpustate,cpustate->t&V); cpustate->icount-=8; break;
+	case 0x90: lh5801_sbc(cpustate,YH); cpustate->icount-=6;break;
+	case 0x91: lh5801_branch_minus(cpustate,!(cpustate->t&C)); cpustate->icount-=8; break;
+	case 0x92: lh5801_adc(cpustate,YH); cpustate->icount-=6;break;
+	case 0x93: lh5801_branch_minus(cpustate,cpustate->t&C); cpustate->icount-=8; break;
+	case 0x94: lh5801_lda(cpustate,YH); cpustate->icount-=5;break;
+	case 0x95: lh5801_branch_minus(cpustate,!(cpustate->t&H)); cpustate->icount-=8; break;
+	case 0x96: lh5801_cpa(cpustate,cpustate->a, YH); cpustate->icount-=6;break;
+	case 0x97: lh5801_branch_minus(cpustate,cpustate->t&H); cpustate->icount-=8; break;
+	case 0x99: lh5801_branch_minus(cpustate,!(cpustate->t&Z)); cpustate->icount-=8; break;
+	case 0x9a: lh5801_rtn(cpustate); cpustate->icount-=11; break;
+	case 0x9b: lh5801_branch_minus(cpustate,cpustate->t&Z); cpustate->icount-=8; break;
+	case 0x9c: lh5801_dca(cpustate,memory_read_byte(cpustate->program,Y)); cpustate->icount-=15; break;
+	case 0x9d: lh5801_branch_minus(cpustate,!(cpustate->t&V)); cpustate->icount-=8; break;
+	case 0x9e: lh5801_branch_minus(cpustate,1); cpustate->icount-=6; break;
+	case 0x9f: lh5801_branch_minus(cpustate,cpustate->t&V); cpustate->icount-=8; break;
+	case 0xa0: lh5801_sbc(cpustate,UH); cpustate->icount-=6;break;
+	case 0xa2: lh5801_adc(cpustate,UH); cpustate->icount-=6;break;
+	case 0xa1: lh5801_sbc(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xa3: lh5801_adc(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xa4: lh5801_lda(cpustate,UH); cpustate->icount-=5;break;
+	case 0xa5: lh5801_lda(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=12;break;
+	case 0xa6: lh5801_cpa(cpustate,cpustate->a, UH); cpustate->icount-=6;break;
+	case 0xa7: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xa8: cpustate->pv=1;/*spv!*/ cpustate->icount-=4; break;
+	case 0xa9: lh5801_and(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xaa: S=lh5801_readop_word(cpustate);cpustate->icount-=6;break;
+	case 0xab: lh5801_ora(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xac: lh5801_dca(cpustate,memory_read_byte(cpustate->program,U)); cpustate->icount-=15; break;
+	case 0xad: lh5801_eor(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate))); cpustate->icount-=13;break;
+	case 0xae: memory_write_byte(cpustate->program,lh5801_readop_word(cpustate),cpustate->a); cpustate->icount-=12;break;
+	case 0xaf: lh5801_bit(cpustate,memory_read_byte(cpustate->program,lh5801_readop_word(cpustate)),cpustate->a); cpustate->icount-=13;break;
+	case 0xb1: lh5801_sbc(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xb3: lh5801_adc(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xb5: lh5801_lda(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=6;break;
+	case 0xb7: lh5801_cpa(cpustate,cpustate->a, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xb8: cpustate->pv=0;/*rpv!*/ cpustate->icount-=4; break;
+	case 0xb9: lh5801_and(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xba: lh5801_jmp(cpustate,lh5801_readop_word(cpustate)); cpustate->icount-=12;break;
+	case 0xbb: lh5801_ora(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xbd: lh5801_eor(cpustate,memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xbe: lh5801_sjp(cpustate); cpustate->icount-=19; break;
+	case 0xbf: lh5801_bit(cpustate,cpustate->a, memory_decrypted_read_byte(cpustate->program,P++));cpustate->icount-=7;break;
+	case 0xc1: lh5801_vector(cpustate,!(cpustate->t&C), memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xc3: lh5801_vector(cpustate,cpustate->t&C, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xc5: lh5801_vector(cpustate,!(cpustate->t&H), memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xc7: lh5801_vector(cpustate,cpustate->t&H, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xc9: lh5801_vector(cpustate,!(cpustate->t&Z), memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xcb: lh5801_vector(cpustate,cpustate->t&Z, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xcd: lh5801_vector(cpustate,1, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=7;break;
+	case 0xcf: lh5801_vector(cpustate,cpustate->t&V, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=8;break;
+	case 0xd1: lh5801_ror(cpustate); cpustate->icount-=6; break;
+	case 0xd3: lh5801_drr(cpustate,X); cpustate->icount-=12; break;
+	case 0xd5: lh5801_shr(cpustate); cpustate->icount-=6; break;
+	case 0xd7: lh5801_drl(cpustate,X); cpustate->icount-=12; break;
+	case 0xd9: lh5801_shl(cpustate); cpustate->icount-=6; break;
+	case 0xdb: lh5801_rol(cpustate); cpustate->icount-=6; break;
+	case 0xdd: lh5801_inc(cpustate,&cpustate->a);cpustate->icount-=5;break;
+	case 0xdf: lh5801_dec(cpustate,&cpustate->a);cpustate->icount-=5;break;
+	case 0xe1: cpustate->pu=1;/*spu!*/ cpustate->icount-=4; break;
+	case 0xe3: cpustate->pu=0;/*rpu!*/ cpustate->icount-=4; break;
 	case 0xe9:
-		adr=lh5801_readop_word();lh5801_and_mem(adr, memory_decrypted_read_byte(lh5801.program,P++));
-		lh5801_icount-=19;break;
+		adr=lh5801_readop_word(cpustate);lh5801_and_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++));
+		cpustate->icount-=19;break;
 	case 0xeb:
-		adr=lh5801_readop_word();lh5801_ora_mem(adr, memory_decrypted_read_byte(lh5801.program,P++));
-		lh5801_icount-=19;break;
+		adr=lh5801_readop_word(cpustate);lh5801_ora_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++));
+		cpustate->icount-=19;break;
 	case 0xed:
-		adr=lh5801_readop_word();lh5801_bit(memory_read_byte(lh5801.program,adr), memory_decrypted_read_byte(lh5801.program,P++));
-		lh5801_icount-=16;break;
+		adr=lh5801_readop_word(cpustate);lh5801_bit(cpustate,memory_read_byte(cpustate->program,adr), memory_decrypted_read_byte(cpustate->program,P++));
+		cpustate->icount-=16;break;
 	case 0xef:
-		adr=lh5801_readop_word();
-		lh5801_add_mem(adr, memory_decrypted_read_byte(lh5801.program,P++)); lh5801_icount-=19;
+		adr=lh5801_readop_word(cpustate);
+		lh5801_add_mem(cpustate,adr, memory_decrypted_read_byte(cpustate->program,P++)); cpustate->icount-=19;
 		break;
-	case 0xf1: lh5801_aex(); lh5801_icount-=6; break;
-	case 0xf5: memory_write_byte(lh5801.program,Y++, memory_read_byte(lh5801.program,X++)); lh5801_icount-=7; break; //tin
-	case 0xf7: lh5801_cpa(lh5801.a, memory_read_byte(lh5801.program,X++));lh5801_icount-=7; break; //cin
-	case 0xf9: lh5801.t&=~C;lh5801_icount-=4;break;
-	case 0xfb: lh5801.t|=C;lh5801_icount-=4;break;
-	case 0xfd: lh5801_instruction_fd();break;
+	case 0xf1: lh5801_aex(cpustate); cpustate->icount-=6; break;
+	case 0xf5: memory_write_byte(cpustate->program,Y++, memory_read_byte(cpustate->program,X++)); cpustate->icount-=7; break; //tin
+	case 0xf7: lh5801_cpa(cpustate,cpustate->a, memory_read_byte(cpustate->program,X++));cpustate->icount-=7; break; //cin
+	case 0xf9: cpustate->t&=~C;cpustate->icount-=4;break;
+	case 0xfb: cpustate->t|=C;cpustate->icount-=4;break;
+	case 0xfd: lh5801_instruction_fd(cpustate);break;
 	case 0xc0: case 0xc2: case 0xc4: case 0xc6:
 	case 0xc8: case 0xca: case 0xcc: case 0xce:
 	case 0xd0: case 0xd2: case 0xd4: case 0xd6:
@@ -674,7 +674,7 @@ static void lh5801_instruction(void)
 	case 0xe0: case 0xe2: case 0xe4: case 0xe6:
 	case 0xe8: case 0xea: case 0xec: case 0xee:
 	case 0xf0: case 0xf2: case 0xf4: case 0xf6:
-		lh5801_vector(1, oper);lh5801_icount-=4;break;
+		lh5801_vector(cpustate,1, oper);cpustate->icount-=4;break;
 	default:
 		logerror("lh5801 illegal opcode at %.4x %.2x\n",P-1, oper);
 	}
diff --git a/src/emu/cpu/lh5801/lh5801.c b/src/emu/cpu/lh5801/lh5801.c
index e69f8a51458..0a8ecf56fce 100644
--- a/src/emu/cpu/lh5801/lh5801.c
+++ b/src/emu/cpu/lh5801/lh5801.c
@@ -45,7 +45,8 @@ enum
 	LH5801_IRQ_STATE
 };
 
-typedef struct
+typedef struct _lh5810_state lh5801_state;
+struct _lh5810_state
 {
 	const lh5801_cpu_core *config;
 	const device_config *device;
@@ -63,23 +64,20 @@ typedef struct
 	int irq_state;
 
 	int idle;
-} LH5801_Regs;
+	int icount;
+};
 
-static int lh5801_icount = 0;
-
-static LH5801_Regs lh5801= { 0 };
-
-#define P lh5801.p.w.l
-#define S lh5801.s.w.l
-#define U lh5801.u.w.l
-#define UL lh5801.u.b.l
-#define UH lh5801.u.b.h
-#define X lh5801.x.w.l
-#define XL lh5801.x.b.l
-#define XH lh5801.x.b.h
-#define Y lh5801.y.w.l
-#define YL lh5801.y.b.l
-#define YH lh5801.y.b.h
+#define P cpustate->p.w.l
+#define S cpustate->s.w.l
+#define U cpustate->u.w.l
+#define UL cpustate->u.b.l
+#define UH cpustate->u.b.h
+#define X cpustate->x.w.l
+#define XL cpustate->x.b.l
+#define XH cpustate->x.b.h
+#define Y cpustate->y.w.l
+#define YL cpustate->y.b.l
+#define YH cpustate->y.b.h
 
 #define C 0x01
 #define IE 0x02
@@ -94,56 +92,48 @@ static LH5801_Regs lh5801= { 0 };
 
 static CPU_INIT( lh5801 )
 {
-	memset(&lh5801, 0, sizeof(lh5801));
-	lh5801.config = (const lh5801_cpu_core *) device->static_config;
-	lh5801.device = device;
-	lh5801.program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
+	lh5801_state *cpustate = device->token;
+	
+	memset(cpustate, 0, sizeof(*cpustate));
+	cpustate->config = (const lh5801_cpu_core *) device->static_config;
+	cpustate->device = device;
+	cpustate->program = memory_find_address_space(device, ADDRESS_SPACE_PROGRAM);
 }
 
 static CPU_RESET( lh5801 )
 {
-	P = (memory_read_byte(lh5801.program, 0xfffe)<<8) | memory_read_byte(lh5801.program, 0xffff);
+	lh5801_state *cpustate = device->token;
 
-	lh5801.idle=0;
-}
+	P = (memory_read_byte(cpustate->program, 0xfffe)<<8) | memory_read_byte(cpustate->program, 0xffff);
 
-static CPU_GET_CONTEXT( lh5801 )
-{
-	if( dst )
-		*(LH5801_Regs*)dst = lh5801;
-}
-
-static CPU_SET_CONTEXT( lh5801 )
-{
-	if( src )
-	{
-		lh5801 = *(LH5801_Regs*)src;
-	}
+	cpustate->idle=0;
 }
 
 static CPU_EXECUTE( lh5801 )
 {
-	lh5801_icount = cycles;
+	lh5801_state *cpustate = device->token;
 
-	if (lh5801.idle) {
-		lh5801_icount=0;
+	cpustate->icount = cycles;
+
+	if (cpustate->idle) {
+		cpustate->icount=0;
 	} else {
 		do
 		{
-			lh5801.oldpc = P;
+			cpustate->oldpc = P;
 
 			debugger_instruction_hook(device, P);
-			lh5801_instruction();
+			lh5801_instruction(cpustate);
 
-		} while (lh5801_icount > 0);
+		} while (cpustate->icount > 0);
 	}
 
-	return cycles - lh5801_icount;
+	return cycles - cpustate->icount;
 }
 
-static void set_irq_line(int irqline, int state)
+static void set_irq_line(lh5801_state *cpustate, int irqline, int state)
 {
-	lh5801.idle=0;
+	cpustate->idle=0;
 }
 
 
@@ -154,10 +144,11 @@ static void set_irq_line(int irqline, int state)
 
 static CPU_SET_INFO( lh5801 )
 {
+	lh5801_state *cpustate = device->token;
 	switch (state)
 	{
 		/* --- the following bits of info are set as 64-bit signed integers --- */
-		case CPUINFO_INT_INPUT_STATE:					set_irq_line(0, info->i);				break;
+		case CPUINFO_INT_INPUT_STATE:					set_irq_line(cpustate, 0, info->i);				break;
 
 		case CPUINFO_INT_PC:
 		case CPUINFO_INT_REGISTER + LH5801_P:			P = info->i;							break;
@@ -166,12 +157,12 @@ static CPU_SET_INFO( lh5801 )
 		case CPUINFO_INT_REGISTER + LH5801_U:			U = info->i;							break;
 		case CPUINFO_INT_REGISTER + LH5801_X:			X = info->i;							break;
 		case CPUINFO_INT_REGISTER + LH5801_Y:			Y = info->i;							break;
-		case CPUINFO_INT_REGISTER + LH5801_T:			lh5801.t = info->i;						break;
-		case CPUINFO_INT_REGISTER + LH5801_TM:			lh5801.tm = info->i;					break;
-		case CPUINFO_INT_REGISTER + LH5801_BF:			lh5801.bf = info->i;					break;
-		case CPUINFO_INT_REGISTER + LH5801_PV:			lh5801.pv = info->i;					break;
-		case CPUINFO_INT_REGISTER + LH5801_PU:			lh5801.pu = info->i;					break;
-		case CPUINFO_INT_REGISTER + LH5801_DP:			lh5801.dp = info->i;					break;
+		case CPUINFO_INT_REGISTER + LH5801_T:			cpustate->t = info->i;						break;
+		case CPUINFO_INT_REGISTER + LH5801_TM:			cpustate->tm = info->i;					break;
+		case CPUINFO_INT_REGISTER + LH5801_BF:			cpustate->bf = info->i;					break;
+		case CPUINFO_INT_REGISTER + LH5801_PV:			cpustate->pv = info->i;					break;
+		case CPUINFO_INT_REGISTER + LH5801_PU:			cpustate->pu = info->i;					break;
+		case CPUINFO_INT_REGISTER + LH5801_DP:			cpustate->dp = info->i;					break;
 	}
 }
 
@@ -183,10 +174,12 @@ static CPU_SET_INFO( lh5801 )
 
 CPU_GET_INFO( lh5801 )
 {
+	lh5801_state *cpustate = (device != NULL) ? device->token : NULL;
+
 	switch (state)
 	{
 		/* --- the following bits of info are returned as 64-bit signed integers --- */
-		case CPUINFO_INT_CONTEXT_SIZE:					info->i = sizeof(lh5801);				break;
+		case CPUINFO_INT_CONTEXT_SIZE:					info->i = sizeof(lh5801_state);			break;
 		case CPUINFO_INT_INPUT_LINES:					info->i = 2;							break;
 		case CPUINFO_INT_DEFAULT_IRQ_VECTOR:			info->i = 0;							break;
 		case CPUINFO_INT_ENDIANNESS:					info->i = ENDIANNESS_LITTLE;					break;
@@ -207,9 +200,9 @@ CPU_GET_INFO( lh5801 )
 		case CPUINFO_INT_ADDRBUS_WIDTH + ADDRESS_SPACE_IO: 		info->i = 0;					break;
 		case CPUINFO_INT_ADDRBUS_SHIFT + ADDRESS_SPACE_IO: 		info->i = 0;					break;
 
-		case CPUINFO_INT_INPUT_STATE:					info->i = lh5801.irq_state;				break;
+		case CPUINFO_INT_INPUT_STATE:					info->i = cpustate->irq_state;				break;
 
-		case CPUINFO_INT_PREVIOUSPC:					info->i = lh5801.oldpc;					break;
+		case CPUINFO_INT_PREVIOUSPC:					info->i = cpustate->oldpc;					break;
 
 		case CPUINFO_INT_PC:
 		case CPUINFO_INT_REGISTER + LH5801_P:			info->i = P;							break;
@@ -218,25 +211,25 @@ CPU_GET_INFO( lh5801 )
 		case CPUINFO_INT_REGISTER + LH5801_U:			info->i = U;							break;
 		case CPUINFO_INT_REGISTER + LH5801_X:			info->i = X;							break;
 		case CPUINFO_INT_REGISTER + LH5801_Y:			info->i = Y;							break;
-		case CPUINFO_INT_REGISTER + LH5801_T:			info->i = lh5801.t;						break;
-		case CPUINFO_INT_REGISTER + LH5801_TM:			info->i = lh5801.tm;					break;
-		case CPUINFO_INT_REGISTER + LH5801_IN:			info->i = lh5801.config->in();			break;
-		case CPUINFO_INT_REGISTER + LH5801_BF:			info->i = lh5801.bf;					break;
-		case CPUINFO_INT_REGISTER + LH5801_PV:			info->i = lh5801.pv;					break;
-		case CPUINFO_INT_REGISTER + LH5801_PU:			info->i = lh5801.pu;					break;
-		case CPUINFO_INT_REGISTER + LH5801_DP:			info->i = lh5801.dp;					break;
+		case CPUINFO_INT_REGISTER + LH5801_T:			info->i = cpustate->t;						break;
+		case CPUINFO_INT_REGISTER + LH5801_TM:			info->i = cpustate->tm;					break;
+		case CPUINFO_INT_REGISTER + LH5801_IN:			info->i = cpustate->config->in(device);			break;
+		case CPUINFO_INT_REGISTER + LH5801_BF:			info->i = cpustate->bf;					break;
+		case CPUINFO_INT_REGISTER + LH5801_PV:			info->i = cpustate->pv;					break;
+		case CPUINFO_INT_REGISTER + LH5801_PU:			info->i = cpustate->pu;					break;
+		case CPUINFO_INT_REGISTER + LH5801_DP:			info->i = cpustate->dp;					break;
 
 		/* --- the following bits of info are returned as pointers to data or functions --- */
 		case CPUINFO_PTR_SET_INFO:						info->setinfo = CPU_SET_INFO_NAME(lh5801);		break;
-		case CPUINFO_PTR_GET_CONTEXT:					info->getcontext = CPU_GET_CONTEXT_NAME(lh5801);	break;
-		case CPUINFO_PTR_SET_CONTEXT:					info->setcontext = CPU_SET_CONTEXT_NAME(lh5801);	break;
+		case CPUINFO_PTR_GET_CONTEXT:					info->getcontext = CPU_GET_CONTEXT_NAME(dummy);	break;
+		case CPUINFO_PTR_SET_CONTEXT:					info->setcontext = CPU_SET_CONTEXT_NAME(dummy);	break;
 		case CPUINFO_PTR_INIT:							info->init = CPU_INIT_NAME(lh5801);				break;
 		case CPUINFO_PTR_RESET:							info->reset = CPU_RESET_NAME(lh5801);				break;
 		case CPUINFO_PTR_EXIT:							info->exit = NULL;						break;
 		case CPUINFO_PTR_EXECUTE:						info->execute = CPU_EXECUTE_NAME(lh5801);			break;
 		case CPUINFO_PTR_BURN:							info->burn = NULL;						break;
 		case CPUINFO_PTR_DISASSEMBLE:					info->disassemble = CPU_DISASSEMBLE_NAME(lh5801);		break;
-		case CPUINFO_PTR_INSTRUCTION_COUNTER:			info->icount = &lh5801_icount;			break;
+		case CPUINFO_PTR_INSTRUCTION_COUNTER:			info->icount = &cpustate->icount;			break;
 
 		/* --- the following bits of info are returned as NULL-terminated strings --- */
 		case CPUINFO_STR_NAME:							strcpy(info->s, "LH5801"); break;
@@ -247,28 +240,28 @@ CPU_GET_INFO( lh5801 )
 
 		case CPUINFO_STR_FLAGS:
 			sprintf(info->s, "%s%s%s%s%s%s%s%s",
-				lh5801.t&0x80?"1":"0",
-				lh5801.t&0x40?"1":"0",
-				lh5801.t&0x20?"1":"0",
-				lh5801.t&0x10?"H":".",
-				lh5801.t&8?"V":".",
-				lh5801.t&4?"Z":".",
-				lh5801.t&2?"I":".",
-				lh5801.t&1?"C":".");
+				cpustate->t&0x80?"1":"0",
+				cpustate->t&0x40?"1":"0",
+				cpustate->t&0x20?"1":"0",
+				cpustate->t&0x10?"H":".",
+				cpustate->t&8?"V":".",
+				cpustate->t&4?"Z":".",
+				cpustate->t&2?"I":".",
+				cpustate->t&1?"C":".");
 			break;
 
-		case CPUINFO_STR_REGISTER + LH5801_P:			sprintf(info->s, "P:%04X", lh5801.p.w.l); break;
-		case CPUINFO_STR_REGISTER + LH5801_S:			sprintf(info->s, "S:%04X", lh5801.s.w.l); break;
-		case CPUINFO_STR_REGISTER + LH5801_U:			sprintf(info->s, "U:%04X", lh5801.u.w.l); break;
-		case CPUINFO_STR_REGISTER + LH5801_X:			sprintf(info->s, "X:%04X", lh5801.x.w.l); break;
-		case CPUINFO_STR_REGISTER + LH5801_Y:			sprintf(info->s, "Y:%04X", lh5801.y.w.l); break;
-		case CPUINFO_STR_REGISTER + LH5801_T:			sprintf(info->s, "T:%02X", lh5801.t); break;
-		case CPUINFO_STR_REGISTER + LH5801_A:			sprintf(info->s, "A:%02X", lh5801.a); break;
-		case CPUINFO_STR_REGISTER + LH5801_TM:			sprintf(info->s, "TM:%03X", lh5801.tm); break;
-		case CPUINFO_STR_REGISTER + LH5801_IN:			sprintf(info->s, "IN:%02X", lh5801.config->in()); break;
-		case CPUINFO_STR_REGISTER + LH5801_PV:			sprintf(info->s, "PV:%04X", lh5801.pv); break;
-		case CPUINFO_STR_REGISTER + LH5801_PU:			sprintf(info->s, "PU:%04X", lh5801.pu); break;
-		case CPUINFO_STR_REGISTER + LH5801_BF:			sprintf(info->s, "BF:%04X", lh5801.bf); break;
-		case CPUINFO_STR_REGISTER + LH5801_DP:			sprintf(info->s, "DP:%04X", lh5801.dp); break;
+		case CPUINFO_STR_REGISTER + LH5801_P:			sprintf(info->s, "P:%04X", cpustate->p.w.l); break;
+		case CPUINFO_STR_REGISTER + LH5801_S:			sprintf(info->s, "S:%04X", cpustate->s.w.l); break;
+		case CPUINFO_STR_REGISTER + LH5801_U:			sprintf(info->s, "U:%04X", cpustate->u.w.l); break;
+		case CPUINFO_STR_REGISTER + LH5801_X:			sprintf(info->s, "X:%04X", cpustate->x.w.l); break;
+		case CPUINFO_STR_REGISTER + LH5801_Y:			sprintf(info->s, "Y:%04X", cpustate->y.w.l); break;
+		case CPUINFO_STR_REGISTER + LH5801_T:			sprintf(info->s, "T:%02X", cpustate->t); break;
+		case CPUINFO_STR_REGISTER + LH5801_A:			sprintf(info->s, "A:%02X", cpustate->a); break;
+		case CPUINFO_STR_REGISTER + LH5801_TM:			sprintf(info->s, "TM:%03X", cpustate->tm); break;
+		case CPUINFO_STR_REGISTER + LH5801_IN:			sprintf(info->s, "IN:%02X", cpustate->config->in(device)); break;
+		case CPUINFO_STR_REGISTER + LH5801_PV:			sprintf(info->s, "PV:%04X", cpustate->pv); break;
+		case CPUINFO_STR_REGISTER + LH5801_PU:			sprintf(info->s, "PU:%04X", cpustate->pu); break;
+		case CPUINFO_STR_REGISTER + LH5801_BF:			sprintf(info->s, "BF:%04X", cpustate->bf); break;
+		case CPUINFO_STR_REGISTER + LH5801_DP:			sprintf(info->s, "DP:%04X", cpustate->dp); break;
 	}
 }
diff --git a/src/emu/cpu/lh5801/lh5801.h b/src/emu/cpu/lh5801/lh5801.h
index 3beacbc0fb2..ead8230c465 100644
--- a/src/emu/cpu/lh5801/lh5801.h
+++ b/src/emu/cpu/lh5801/lh5801.h
@@ -1,6 +1,6 @@
 /*****************************************************************************
  *
- *   lh5801.h
+ *   cpustate->h
  *   portable lh5801 emulator interface
  *
  *   Copyright Peter Trauner, all rights reserved.
@@ -66,10 +66,12 @@ pc 8bit
 #include "cpuintrf.h"
 
 
+typedef UINT8 (*lh5801_in_func)(const device_config *device);
+
 typedef struct _lh5801_cpu_core lh5801_cpu_core;
 struct _lh5801_cpu_core
 {
-	UINT8 (*in)(void);
+	lh5801_in_func	in;
 };
 
 #define LH5801_INT_NONE 0