||| == -*- gas-*- =========================================================
||| ========================================================================
|||      ___   ___                    ======= ==============================
|||  ___( _ ) / _ \   emulation core    ====================================
||| |_  / _ \| | | |  emulation core     ===================================
|||  / ( (_) | |_| |  emulation core      ==================================
||| /___\___/ \___/   emulation core       =================================
|||                                   ======= ==============================
||| ========================================================================
||| ========================================================================

||| http://z80.info/z80oplist.txt

	|| == Memory Macros ================================================

	|| Macro to read a byte from main memory at register \addr.  Puts
	|| the byte read in \dest.
.macro	FETCHB	src dest	| 106 cycles, 8 bytes
	move.w	\addr,d1
	jsr	deref
	move.b	(a0),\dest
.endm

	|| Macro to write a byte in \val to main memory at \addr
.macro	PUTB	val addr	| 106 cycles, 8 bytes
	move.w	\addr,d1
	jsr	deref
	move.b	\val,(a0)
.endm

	|| Macro to read a word from main memory at register \addr
	|| (unaligned).  Puts the word read in \dest.
.macro	FETCHW	addr dest	| 140 cycles, 16 bytes
	move.w	\addr,d1
	jsr	deref
	|| XXX SPEED
	move.b	(a0)+,d2
	move.b	(a0),\dest
	rol.w	#8,\dest
	move.b	d2,\dest
.endm

	|| Macro to write a word in \val to main memory at \addr (regs only)
.macro	PUTW	val addr	| 140 cycles, 14 bytes
	move.w	\addr,d1
	jsr	deref
	move.w	\val,d0
	move.b	d0,(a0)+
	LOHI	d0
	move.b	d0,(a0)
.endm

	|| Push the word in \val (register) using stack register esp.
	|| Sadly, I can't trust the stack register to be aligned.
	|| Destroys d2.

	||   (SP-2) <- \1_l
	||   (SP-1) <- \1_h
	||   SP <- SP - 2
.macro	PUSHW	val		| 42 cycles, 8 bytes
	move.w	\val,d2
	LOHI	d2		|slow
	move.b	d2,-(esp)	| high byte
	move.b	\val,-(esp)	| low byte
.endm

	|| Pop the word at the top of stack esp into \dest.
	|| Destroys d0.

	||   \1_h <- (SP+1)
	||   \1_l <- (SP)
	||   SP <- SP + 2
.macro	POPW	dest		| 60 cycles, 8 bytes
	move.b	(esp)+,\dest
	LOHI	\dest
	move.b	(esp)+,\dest	| high byte
	HILO	\dest
.endm

	|| == Immediate Memory Macros ==

	|| Macro to read an immediate byte into \dest.
.macro	FETCHBI	dest		| 8 cycles, 2 bytes
	move.b	(epc)+,\dest
.endm

	|| Macro to read an immediate word (unaligned) into \dest.
.macro	FETCHWI	dest		| 42 cycles, 8 bytes
	|| XXX SPEED
	move.b	(epc)+,d2
	move.b	(epc)+,\dest
	rol.w	#8,\dest
	move.b	d2,\dest
.endm

	|| == Common Opcode Macros =========================================

	|| To align opcode routines.
.set	_align,0

.macro	start
	.org	emu_plain_op+_align
.set	_align,_align+$100	| opcode routine length
	jmp	do_interrupt	| for interrupt routines
.endm

.macro	START_DD
	.org	emu_plain_op+_align+$40
.endm

.macro	START_CB
	.org	emu_plain_op+_align+$42
.endm

.macro	START_DDCB
	.org	emu_plain_op+_align+$44
.endm

.macro	START_FD
	.org	emu_plain_op+_align+$46
.endm

.macro	START_FDCB
	.org	emu_plain_op+_align+$48
.endm

.macro	START_ED
	.org	emu_plain_op+_align+$4A
.endm

	|| LOHI/HILO are hideously slow for instructions used often.
	|| Consider interleaving registers instead:
	||
	|| d4 = [B' B  C' C]
	||
	|| Thus access to B is fast (swap d4) while access to BC is
	|| slow.

	|| When you want to use the high reg of a pair, use this first
.macro	LOHI	reg		| 22 cycles, 2 bytes
	ror.w	#8,\reg
.endm

	|| Then do your shit and finish with this
.macro	HILO	reg		| 22 cycles, 2 bytes
	rol.w	#8,\reg
.endm

	|| Rearrange a register: ABCD -> ACBD.
.macro	WORD	reg	  	| 52 cycles, 14 bytes
	move.l	\reg,-(sp)
	movep.w	0(sp),\reg
	swap	\reg
	movep.w	1(sp),\reg
	addq	#4,sp
.endm

	|| == Special Opcode Macros ========================================

	|| Do an ADD \1,\2
.macro	F_ADD_W			| ? cycles, ? bytes
	|| XXX
.endm
	|| Do an SUB \1,\2
.macro	F_SUB_W			| ? cycles, ? bytes
	|| XXX
.endm

	|| INC and DEC macros
.macro	F_INC_B	reg		| 108 cycles, 34 bytes
	move.b	#1,f_tmp_byte-flag_storage(a3)
	move.b	#1,f_tmp_src_b-flag_storage(a3)
	move.b	\reg,f_tmp_dst_b-flag_storage(a3)
	addq	#1,\reg
	moveq	#2,d0
	F_CLEAR	d0
	F_OVFL
.endm

.macro	F_DEC_B	reg		| 80 cycles, 26 bytes
	move.b	#1,f_tmp_byte-flag_storage(a3)
	st	f_tmp_src_b-flag_storage(a3) || why did I do this?
	move.b	\reg,f_tmp_dst_b-flag_storage(a3)
	subq	#1,\reg
	F_SET	#2
.endm

.macro	F_INC_W	regpr		| 4 cycles, 2 bytes
	addq.w	#1,\regpr
	ENDM

.macro	F_DEC_W	regpr		| 4 cycles, 2 bytes
	subq.w	#1,\regpr
	ENDM

	|| I might be able to unify rotation flags or maybe use a
	|| lookup table


	|| This is run at the end of every instruction routine.
done:
	clr.w	d0		| 4 cycles / 2 bytes
	move.b	(epc)+,d0	| 8 cycles / 2 bytes
	move.b	d0,$4c00+32*(128/8)
	rol.w	#6,d0		|18 cycles / 2 bytes
	jmp	0(a5,d0.w)	|14 cycles / 4 bytes
	|| overhead:		 42 cycles /10 bytes


.macro	DONE
	clr.w	d0		| 4 cycles / 2 bytes
	move.b	(epc)+,d0	| 8 cycles / 2 bytes
	move.b	d0,$4c00+32*(128/8)
	rol.w	#6,d0		|18 cycles / 2 bytes
	jmp	0(a5,d0.w)	|14 cycles / 4 bytes
.endm

	|| Timing correction for more precise emulation
	||
	|| \1 is number of tstates the current instruction should take
	|| \2 is number of cycles taken already
.macro	TIME
.endm

	CNOP	0,32

emu_plain_op:			| Size(bytes) Time(cycles)
				| S0 T0

	|| I would like to thank the State of Washington for
	|| supporting the initial development of this file, by giving
	|| me a job doing nothing with no oversight for hours at a
	|| time.

	|| NOP
OPCODE(00,«»,4)

	||
OP_DD(00,«»)

	|| RLC	B
OP_CB(00,«»)

	||
OP_DDCB(00,«»)

	||
OP_FD(00,«»)

	||
OP_FDCB(00,«»)

	||
OP_ED(00,«»)

	|| LD	BC,immed.w
	|| Read a word and put it in BC
	|| No flags
	|| 42 cycles
OPCODE(01,«
	FETCHWI	ebc
	»,36,,12)

OP_DD(01,«»)
OP_CB(01,«»)
OP_DDCB(01,«»)
OP_FD(01,«»)
OP_FDCB(01,«»)
OP_ED(01,«»)


	|| LD	(BC),A
	|| (BC) <- A
	|| No flags
	|| 106 cycles
OPCODE(02,«
	PUTB	eaf,ebc
	»,14,,4)

OP_DD(02,«»)
OP_CB(02,«»)
OP_DDCB(02,«»)
OP_FD(02,«»)
OP_FDCB(02,«»)
OP_ED(02,«»)

	|| INC	BC
	|| BC <- BC+1
	|| No flags
	|| 4 cycles
OPCODE(03,«
	F_INC_W	ebc
	»,4,,2)

OP_DD(03,«»)
OP_CB(03,«»)
OP_DDCB(03,«»)
OP_FD(03,«»)
OP_FDCB(03,«»)
OP_ED(03,«»)

	|| INC	B
	|| B <- B+1
	|| 152 cycles
OPCODE(04,«
	LOHI	ebc
	F_INC_B	ebc
	HILO	ebc
	»)

OP_DD(04,«»)
OP_CB(04,«»)
OP_DDCB(04,«»)
OP_FD(04,«»)
OP_FDCB(04,«»)
OP_ED(04,«»)

	|| DEC	B
	|| B <- B-1
	|| 124 cycles
OPCODE(05,«
	LOHI	ebc
	F_DEC_B	ebc
	HILO	ebc
	»)
				|nok

OP_DD(05,«»)
OP_CB(05,«»)
OP_DDCB(05,«»)
OP_FD(05,«»)
OP_FDCB(05,«»)
OP_ED(05,«»)

	|| LD	B,immed.b
	|| Read a byte and put it in B
	|| B <- immed.b
	|| No flags
	|| 52 cycles
OPCODE(06,«
	LOHI	ebc
	FETCHBI	ebc
	HILO	ebc
	»,26,,10)
				|nok

OP_DD(06,«»)
OP_CB(06,«»)
OP_DDCB(06,«»)
OP_FD(06,«»)
OP_FDCB(06,«»)
OP_ED(06,«»)

	|| RLCA
	|| Rotate A left, carry bit gets top bit
	|| Flags: H,N=0| C aff.
	|| XXX flags
	|| ? cycles
OPCODE(07,«
	rol.b	#1,eaf
	»,4,,2)
				|nok

OP_DD(07,«»)
OP_CB(07,«»)
OP_DDCB(07,«»)
OP_FD(07,«»)
OP_FDCB(07,«»)
OP_ED(07,«»)

	|| EX	AF,AF'
	|| No flags
	|| XXX AF
	|| 4 cycles, 2 bytes
OPCODE(08,«
	swap	eaf
	»,4,,2)
				|nok

OP_DD(08,«»)
OP_CB(08,«»)
OP_DDCB(08,«»)
OP_FD(08,«»)
OP_FDCB(08,«»)
OP_ED(08,«»)

	|| ADD	HL,BC
	|| HL <- HL+BC
	|| Flags: H, C aff.| N=0
	|| ? cycles
OPCODE(09,«
	F_ADD_W	ebc,ehl
	»)
				|nok

OP_DD(09,«»)
OP_CB(09,«»)
OP_DDCB(09,«»)
OP_FD(09,«»)
OP_FDCB(09,«»)
OP_ED(09,«»)

	|| LD	A,(BC)
	|| A <- (BC)
	|| No flags
	|| 106 cycles, 8 bytes
OPCODE(0a,«
	FETCHB	ebc,eaf
	»,14,,4)

OP_DD(0a,«»)
OP_CB(0a,«»)
OP_DDCB(0a,«»)
OP_FD(0a,«»)
OP_FDCB(0a,«»)
OP_ED(0a,«»)

	|| DEC	BC
	|| BC <- BC-1
	|| No flags
	|| 4 cycles, 2 bytes
OPCODE(0b,«
	F_DEC_W	ebc
	»,4,,2)
				|nok

OP_DD(0b,«»)
OP_CB(0b,«»)
OP_DDCB(0b,«»)
OP_FD(0b,«»)
OP_FDCB(0b,«»)
OP_ED(0b,«»)

	|| INC	C
	|| C <- C+1
	|| Flags: S,Z,H aff.| P=overflow, N=0
	|| 108 cycles, 34 bytes
OPCODE(0c,«
	F_INC_B	ebc
	»)
				|nok

OP_DD(0c,«»)
OP_CB(0c,«»)
OP_DDCB(0c,«»)
OP_FD(0c,«»)
OP_FDCB(0c,«»)
OP_ED(0c,«»)

	|| DEC	C
	|| C <- C-1
	|| Flags: S,Z,H aff., P=overflow, N=1
	|| 80 cycles, 26 bytes
OPCODE(0d,«
	F_DEC_B	ebc
	»)
				|nok

OP_DD(0d,«»)
OP_CB(0d,«»)
OP_DDCB(0d,«»)
OP_FD(0d,«»)
OP_FDCB(0d,«»)
OP_ED(0d,«»)

	|| LD	C,immed.b
	|| C <- immed.b
	|| No flags
	|| 8 cycles, 2 bytes
OPCODE(0e,«
	FETCHBI	ebc
	»,18,,6)
				|nok

OP_DD(0e,«»)
OP_CB(0e,«»)
OP_DDCB(0e,«»)
OP_FD(0e,«»)
OP_FDCB(0e,«»)
OP_ED(0e,«»)

	|| RRCA
	|| Rotate A right, carry bit gets top bit
	|| Flags: H,N=0| C aff.
	|| XXX FLAGS
	|| ? cycles
OPCODE(0f,«
	ror.b	#1,eaf
	»)
				|nok

OP_DD(0f,«»)
OP_CB(0f,«»)
OP_DDCB(0f,«»)
OP_FD(0f,«»)
OP_FDCB(0f,«»)
OP_ED(0f,«»)

	|| DJNZ	immed.w
	|| Decrement B
	||  and branch by immed.b
	||  if B not zero
	|| No flags
	|| 24 bytes
	|| take: 22+4+ 8+8+4+8+22 = 76
	|| skip: 22+4+10+      22 = 58
OPCODE(10,«
	LOHI	ebc
	subq.b	#1,ebc
	beq.s	local(end)	| slooooow
	FETCHBI	d1
	ext.w	d1
	add.w	d1,epc
local(end):
	HILO	ebc
	»,,,32)
				|nok

OP_DD(10,«»)
OP_CB(10,«»)
OP_DDCB(10,«»)
OP_FD(10,«»)
OP_FDCB(10,«»)
OP_ED(10,«»)

	|| LD	DE,immed.w
	|| DE <- immed.w
	|| No flags
	|| 42 cycles, 8 bytes
OPCODE(11,«
	FETCHWI	ede
	»)
				|nok

OP_DD(11,«»)
OP_CB(11,«»)
OP_DDCB(11,«»)
OP_FD(11,«»)
OP_FDCB(11,«»)
OP_ED(11,«»)

	|| LD	(DE),A
	|| (DE) <- A
	|| No flags
	|| 106 cycles, 8 bytes
OPCODE(12,«
	PUTB	eaf,ede
	»)
				|nok

OP_DD(12,«»)
OP_CB(12,«»)
OP_DDCB(12,«»)
OP_FD(12,«»)
OP_FDCB(12,«»)
OP_ED(12,«»)

	|| INC	DE
	|| No flags
	|| 4 cycles, 2 bytes
OPCODE(13,«
	F_INC_W	ede
	»)
				|nok

OP_DD(13,«»)
OP_CB(13,«»)
OP_DDCB(13,«»)
OP_FD(13,«»)
OP_FDCB(13,«»)
OP_ED(13,«»)

	|| INC	D
	|| Flags: S,Z,H aff.| P=overflow, N=0
	|| 152 cycles
OPCODE(14,«
	LOHI	ede
	F_INC_B	ede
	HILO	ede
	»)
				|nok

OP_DD(14,«»)
OP_CB(14,«»)
OP_DDCB(14,«»)
OP_FD(14,«»)
OP_FDCB(14,«»)
OP_ED(14,«»)

	|| DEC	D
	|| Flags: S,Z,H aff.| P=overflow, N=1
	|| 124 cycles
OPCODE(15,«
	LOHI	ede
	F_DEC_B	ede
	HILO	ede
	»)
				|nok

OP_DD(15,«»)
OP_CB(15,«»)
OP_DDCB(15,«»)
OP_FD(15,«»)
OP_FDCB(15,«»)
OP_ED(15,«»)

	|| LD	D,immed.b
	|| No flags
	|| 52 cycles
OPCODE(16,«
	LOHI	ede
	FETCHBI	ede
	HILO	ede
	»)
				|nok

OP_DD(16,«»)
OP_CB(16,«»)
OP_DDCB(16,«»)
OP_FD(16,«»)
OP_FDCB(16,«»)
OP_ED(16,«»)

	|| RLA
	|| Flags: P,N=0| C aff.
	|| XXX flags
	|| ? cycles
OPCODE(17,«
	roxl.b	#1,eaf
	»)
				|nok

OP_DD(17,«»)
OP_CB(17,«»)
OP_DDCB(17,«»)
OP_FD(17,«»)
OP_FDCB(17,«»)
OP_ED(17,«»)

	|| JR	immed.b
	|| PC <- immed.b
	|| Branch relative by a signed immediate byte
	|| No flags
	|| 20 cycles

	|| XXX
	|| Yes, I can avoid the underef/deref cycle.  To do so, put a
	|| sled of emulator trap instructions on either side of each
	|| 16k page.  When that trap is executed, undo the shortcut
	|| and redo it by the book.

OPCODE(18,«
	clr.w	d1
	FETCHBI	d1
	add.w	d1,epc
	»)
				|nok

OP_DD(18,«»)
OP_CB(18,«»)
OP_DDCB(18,«»)
OP_FD(18,«»)
OP_FDCB(18,«»)
OP_ED(18,«»)

	|| ADD	HL,DE
	|| HL <- HL+DE
	|| Flags: H,C aff,| N=0
	|| ? cycles
OPCODE(19,«
	F_ADD_W	ede,ehl
	»)
				|nok

OP_DD(19,«»)
OP_CB(19,«»)
OP_DDCB(19,«»)
OP_FD(19,«»)
OP_FDCB(19,«»)
OP_ED(19,«»)

	|| LD	A,(DE)
	|| A <- (DE)
	|| No flags
	|| 106 cycles, 8 bytes
OPCODE(1a,«
	FETCHB	ede,eaf
	»)
				|nok

OP_DD(1a,«»)
OP_CB(1a,«»)
OP_DDCB(1a,«»)
OP_FD(1a,«»)
OP_FDCB(1a,«»)
OP_ED(1a,«»)

	|| DEC	DE
	|| No flags
	|| 4 cycles, 2 bytes
OPCODE(1b,«
	subq.w	#1,ede
	»)
				|nok

OP_DD(1b,«»)
OP_CB(1b,«»)
OP_DDCB(1b,«»)
OP_FD(1b,«»)
OP_FDCB(1b,«»)
OP_ED(1b,«»)

	|| INC	E
	|| Flags: S,Z,H aff.| P=overflow| N=0
	|| 108 cycles, 34 bytes
OPCODE(1c,«
	F_INC_B	ede
	»)
				|nok

OP_DD(1c,«»)
OP_CB(1c,«»)
OP_DDCB(1c,«»)
OP_FD(1c,«»)
OP_FDCB(1c,«»)
OP_ED(1c,«»)

	|| DEC	E
	|| Flags: S,Z,H aff.| P=overflow, N=1
	|| 80 cycles, 26 bytes
OPCODE(1d,«
	F_DEC_B	ede
	»)
				|nok

OP_DD(1d,«»)
OP_CB(1d,«»)
OP_DDCB(1d,«»)
OP_FD(1d,«»)
OP_FDCB(1d,«»)
OP_ED(1d,«»)

	|| LD	E,immed.b
	|| No flags
	|| 8 cycles, 2 bytes
OPCODE(1e,«
	FETCHBI	ede
	»)
				|nok

OP_DD(1e,«»)
OP_CB(1e,«»)
OP_DDCB(1e,«»)
OP_FD(1e,«»)
OP_FDCB(1e,«»)
OP_ED(1e,«»)

	|| RRA
	|| Flags: H,N=0| C aff.
	|| XXX FLAGS
	|| ? cycles
OPCODE(1f,«
	roxr.b	#1,eaf
	»)
				|nok

OP_DD(1f,«»)
OP_CB(1f,«»)
OP_DDCB(1f,«»)
OP_FD(1f,«»)
OP_FDCB(1f,«»)
OP_ED(1f,«»)

	|| JR	NZ,immed.b
	|| if ~Z,
	||  PC <- PC+immed.b
	|| No flags
	|| 10 bytes
	|| take: 40+10+20(=JR immed.b) = 70
	|| skip: 40+12+12              = 64
OPCODE(20,«
	jsr	f_norm_z
	|| if the emulated Z flag is set, this will be clear
	beq	emu_op_18	| branch taken: Z reset -> eq (zero set)
	add.l	#1,epc		| skip over the immediate byte
	»)

OP_DD(20,«»)
OP_CB(20,«»)
OP_DDCB(20,«»)
OP_FD(20,«»)
OP_FDCB(20,«»)
OP_ED(20,«»)

	|| LD	HL,immed.w
	|| No flags
	|| 42 cycles
OPCODE(21,«
	FETCHWI	ehl
	»)
				|nok

OP_DD(21,«»)
OP_CB(21,«»)
OP_DDCB(21,«»)
OP_FD(21,«»)
OP_FDCB(21,«»)
OP_ED(21,«»)

	|| LD	immed.w,HL
	|| (address) <- HL
	|| No flags
	|| 182 cycles
OPCODE(22,«
	FETCHWI	d1
	PUTW	ehl,d1
	»)
				|nok

OP_DD(22,«»)
OP_CB(22,«»)
OP_DDCB(22,«»)
OP_FD(22,«»)
OP_FDCB(22,«»)
OP_ED(22,«»)

	|| INC	HL
	|| No flags
	|| 4 cycles
OPCODE(23,«
	addq.w	#1,ehl
	»)
				|nok

OP_DD(23,«»)
OP_CB(23,«»)
OP_DDCB(23,«»)
OP_FD(23,«»)
OP_FDCB(23,«»)
OP_ED(23,«»)

	|| INC	H
	|| Flags: S,Z,H aff.| P=overflow, N=0
	|| 152 cycles
OPCODE(24,«
	LOHI	ehl
	F_INC_B	ehl
	HILO	ehl
	»)
				|nok

OP_DD(24,«»)
OP_CB(24,«»)
OP_DDCB(24,«»)
OP_FD(24,«»)
OP_FDCB(24,«»)
OP_ED(24,«»)

	|| DEC	H
	|| Flags: S,Z,H aff.| P=overflow, N=1
	|| 124 cycles
OPCODE(25,«
	LOHI	ehl
	F_DEC_B	ehl
	HILO	ehl
	»)
				|nok

OP_DD(25,«»)
OP_CB(25,«»)
OP_DDCB(25,«»)
OP_FD(25,«»)
OP_FDCB(25,«»)
OP_ED(25,«»)

	|| LD	H,immed.b
	|| No flags
	|| 52 cycles
OPCODE(26,«
	LOHI	ehl
	FETCHBI	ehl
	HILO	ehl
	»)
				|nok

OP_DD(26,«»)
OP_CB(26,«»)
OP_DDCB(26,«»)
OP_FD(26,«»)
OP_FDCB(26,«»)
OP_ED(26,«»)

	|| DAA
	|| Decrement, adjust accum
	|| http://www.z80.info/z80syntx.htm#DAA
	|| Flags: ummm, go find a manual.
	|| XXX
	|| ? cycles
OPCODE(27,«
	F_PAR	eaf
	»)
				|nok

OP_DD(27,«»)
OP_CB(27,«»)
OP_DDCB(27,«»)
OP_FD(27,«»)
OP_FDCB(27,«»)
OP_ED(27,«»)

	|| JR	Z,immed.b
	|| If zero
	||  PC <- PC+immed.b
	|| SPEED can be made faster
	|| No flags
	|| ~130 cycles
OPCODE(28,«
	jsr	f_norm_z
	bne	emu_op_18
	add.l	#1,epc
	»)
				|nok

OP_DD(28,«»)
OP_CB(28,«»)
OP_DDCB(28,«»)
OP_FD(28,«»)
OP_FDCB(28,«»)
OP_ED(28,«»)

	|| ADD	HL,HL
	|| No flags
	|| ? cycles
OPCODE(29,«
	F_ADD_W	ehl,ehl
	»)
				|nok

OP_DD(29,«»)
OP_CB(29,«»)
OP_DDCB(29,«»)
OP_FD(29,«»)
OP_FDCB(29,«»)
OP_ED(29,«»)

	|| LD	HL,(immed.w)
	|| address is absolute
	|| 172 cycles
OPCODE(2a,«
	FETCHWI	d1
	FETCHW	d1,ehl
	»)
				|nok

OP_DD(2a,«»)
OP_CB(2a,«»)
OP_DDCB(2a,«»)
OP_FD(2a,«»)
OP_FDCB(2a,«»)
OP_ED(2a,«»)

	|| XXX TOO LONG
	|| DEC	HL
	|| ? cycles
OPCODE(2b,«
	F_DEC_W	ehl
	»)
				|nok

OP_DD(2b,«»)
OP_CB(2b,«»)
OP_DDCB(2b,«»)
OP_FD(2b,«»)
OP_FDCB(2b,«»)
OP_ED(2b,«»)

	|| INC	L
	|| 108 cycles
OPCODE(2c,«
	F_INC_B	ehl
	»)
				|nok

OP_DD(2c,«»)
OP_CB(2c,«»)
OP_DDCB(2c,«»)
OP_FD(2c,«»)
OP_FDCB(2c,«»)
OP_ED(2c,«»)

	|| DEC	L
	|| 80 cycles
OPCODE(2d,«
	F_DEC_B	ehl
	»)
				|nok

OP_DD(2d,«»)
OP_CB(2d,«»)
OP_DDCB(2d,«»)
OP_FD(2d,«»)
OP_FDCB(2d,«»)
OP_ED(2d,«»)

	|| LD	L,immed.b
	|| 8 cycles
OPCODE(2e,«
	FETCHBI	ehl
	»)
				|nok

OP_DD(2e,«»)
OP_CB(2e,«»)
OP_DDCB(2e,«»)
OP_FD(2e,«»)
OP_FDCB(2e,«»)
OP_ED(2e,«»)

	|| CPL
	|| A <- NOT A
	|| XXX flags
	|| ? cycles
OPCODE(2f,«
	not.b	eaf
	»)
				|nok

OP_DD(2f,«»)
OP_CB(2f,«»)
OP_DDCB(2f,«»)
OP_FD(2f,«»)
OP_FDCB(2f,«»)
OP_ED(2f,«»)

	|| JR	NC,immed.b
	|| If carry clear
	||  PC <- PC+immed.b
	|| ? cycles
OPCODE(30,«
	jsr	f_norm_c
	beq	emu_op_18	| branch taken: carry clear
	add.l	#1,epc
	»)

OP_DD(30,«»)
OP_CB(30,«»)
OP_DDCB(30,«»)
OP_FD(30,«»)
OP_FDCB(30,«»)
OP_ED(30,«»)

	|| LD	SP,immed.w
	|| 140 cycles
OPCODE(31,«
	FETCHWI	d1
	jsr	deref
	movea.l	a0,esp
	»)
				|nok

OP_DD(31,«»)
OP_CB(31,«»)
OP_DDCB(31,«»)
OP_FD(31,«»)
OP_FDCB(31,«»)
OP_ED(31,«»)

	|| LD	(immed.w),A
	|| store indirect
	|| 170 cycles
OPCODE(32,«
	FETCHWI	d1
	rol.w	#8,d1
	PUTB	eaf,d1
	»)
				|nok

OP_DD(32,«»)
OP_CB(32,«»)
OP_DDCB(32,«»)
OP_FD(32,«»)
OP_FDCB(32,«»)
OP_ED(32,«»)

	|| INC	SP
	|| No flags
	||
	|| FYI:  Do not have to deref because this will never cross a
	|| page boundary.  So sayeth BrandonW.
	|| 4 cycles
OPCODE(33,«
	addq.w	#1,esp
	»)
				|nok

OP_DD(33,«»)
OP_CB(33,«»)
OP_DDCB(33,«»)
OP_FD(33,«»)
OP_FDCB(33,«»)
OP_ED(33,«»)

	|| INC	(HL)
	|| Increment byte
	|| SPEED can be made faster
	|| 320 cycles
OPCODE(34,«
	FETCHB	ehl,d1
	F_INC_B	d1
	PUTB	d1,ehl
	»)
				|nok

OP_DD(34,«»)
OP_CB(34,«»)
OP_DDCB(34,«»)
OP_FD(34,«»)
OP_FDCB(34,«»)
OP_ED(34,«»)

	|| DEC	(HL)
	|| Decrement byte
	|| SPEED can be made faster
	|| 292 cycles
OPCODE(35,«
	FETCHB	ehl,d1
	F_DEC_B	d1
	PUTB	d1,ehl
	»)
				|nok

OP_DD(35,«»)
OP_CB(35,«»)
OP_DDCB(35,«»)
OP_FD(35,«»)
OP_FDCB(35,«»)
OP_ED(35,«»)

	|| LD	(HL),immed.b
	|| 114 cycles
OPCODE(36,«
	FETCHBI	d1
	PUTB	ehl,d1
	»)
				|nok

OP_DD(36,«»)
OP_CB(36,«»)
OP_DDCB(36,«»)
OP_FD(36,«»)
OP_FDCB(36,«»)
OP_ED(36,«»)

	|| SCF
	|| Set Carry Flag
	|| XXX flags are more complicated than this :(
	|| ? cycles
OPCODE(37,«
	ori.b	#%00111011,flag_valid-flag_storage(a3)
	move.b	eaf,d1
	ori.b	#%00000001,d1
	andi.b	#%11101101,d1
	or.b	d1,flag_byte-flag_storage(a3)
	»)
				|nok

OP_DD(37,«»)
OP_CB(37,«»)
OP_DDCB(37,«»)
OP_FD(37,«»)
OP_FDCB(37,«»)
OP_ED(37,«»)

	|| JR	C,immed.b
	|| If carry set
	||  PC <- PC+immed.b
	|| ? cycles
OPCODE(38,«
	jsr	f_norm_c
	bne	emu_op_18
	add.l	#1,epc
	»)

OP_DD(38,«»)
OP_CB(38,«»)
OP_DDCB(38,«»)
OP_FD(38,«»)
OP_FDCB(38,«»)
OP_ED(38,«»)

	|| ADD	HL,SP
	|| HL <- HL+SP
OPCODE(39,«
	move.l	esp,a0
	jsr	underef
	F_ADD_W	d0,ehl
	»)
				|nok

OP_DD(39,«»)
OP_CB(39,«»)
OP_DDCB(39,«»)
OP_FD(39,«»)
OP_FDCB(39,«»)
OP_ED(39,«»)

	|| LD	A,(immed.w)
OPCODE(3a,«
	FETCHWI	d1
	FETCHB	d1,eaf
	»)
				|nok

OP_DD(3a,«»)
OP_CB(3a,«»)
OP_DDCB(3a,«»)
OP_FD(3a,«»)
OP_FDCB(3a,«»)
OP_ED(3a,«»)

	|| DEC	SP
	|| No flags
OPCODE(3b,«
	subq.l	#1,esp
	»)
				|nok

OP_DD(3b,«»)
OP_CB(3b,«»)
OP_DDCB(3b,«»)
OP_FD(3b,«»)
OP_FDCB(3b,«»)
OP_ED(3b,«»)

	|| INC	A
OPCODE(3c,«
	F_INC_B	eaf
	»)

OP_DD(3c,«»)
OP_CB(3c,«»)
OP_DDCB(3c,«»)
OP_FD(3c,«»)
OP_FDCB(3c,«»)
OP_ED(3c,«»)

	|| DEC	A
OPCODE(3d,«
	F_DEC_B	eaf
	»)
				|nok

OP_DD(3d,«»)
OP_CB(3d,«»)
OP_DDCB(3d,«»)
OP_FD(3d,«»)
OP_FDCB(3d,«»)
OP_ED(3d,«»)

	|| LD	A,immed.b
OPCODE(3e,«
	FETCHBI	eaf
	»)

	|| CCF
	|| Clear carry flag
	|| XXX fuck flags

OP_DD(3e,«»)
OP_CB(3e,«»)
OP_DDCB(3e,«»)
OP_FD(3e,«»)
OP_FDCB(3e,«»)
OP_ED(3e,«»)

OPCODE(3f,«
	jsr	flags_normalize
	|| 	  SZ5H3PNC
	ori.b	#%00000001,flag_valid-flag_storage(a3)
	andi.b	#%11111110,flag_byte-flag_storage(a3)
	»)
				|nok

OP_DD(3f,«»)
OP_CB(3f,«»)
OP_DDCB(3f,«»)
OP_FD(3f,«»)
OP_FDCB(3f,«»)
OP_ED(3f,«»)

	|| LD	B,B
	|| SPEED
OPCODE(40,«
	LOHI	ebc
	move.b	ebc,ebc
	HILO	ebc
	»)
				|nok

OP_DD(40,«»)

	|| BIT	0,A
OP_CB(40,«»)

OP_DDCB(40,«»)
OP_FD(40,«»)
OP_FDCB(40,«»)

	|| IN	B,(C)
OP_ED(40,«
	move.b	ebc,d0
	jsr	port_in
	LOHI	ebc
	move.b	d1,ebc
	HILO	ebc
	»)
				|nok

	|| LD	B,C
OPCODE(41,«
	move.w	ebc,d1
	LOHI	d1		| deliberate trickery
	move.b	d1,ebc
	»)
				|nok

OP_DD(41,«»)
OP_CB(41,«»)
OP_DDCB(41,«»)
OP_FD(41,«»)
OP_FDCB(41,«»)

	|| OUT	(C),B
OP_ED(41,«
	move.b	ebc,d0
	LOHI	ebc
	move.b	ebc,d1
	HILO	ebc
	jsr	port_out
	»)

	|| LD	B,D
	|| B <- D
	|| SPEED
OPCODE(42,«
	LOHI	ebc
	LOHI	ede
	move.b	ede,ebc
	HILO	ebc
	HILO	ede
	»)
				|nok

OP_DD(42,«»)
OP_CB(42,«»)
OP_DDCB(42,«»)
OP_FD(42,«»)
OP_FDCB(42,«»)
OP_ED(42,«»)

	|| LD	B,E
	|| B <- E
OPCODE(43,«
	LOHI	ebc
	move.b	ebc,ede		| 4
	HILO	ebc
	»)
				|nok

OP_DD(43,«»)
OP_CB(43,«»)
OP_DDCB(43,«»)
OP_FD(43,«»)
OP_FDCB(43,«»)
OP_ED(43,«»)

	|| LD	B,H
	|| B <- H
	|| SPEED
OPCODE(44,«
	LOHI	ebc
	LOHI	ehl
	move.b	ehl,ebc
	HILO	ebc
	HILO	ehl
	»)
				|nok

OP_DD(44,«»)
OP_CB(44,«»)
OP_DDCB(44,«»)
OP_FD(44,«»)
OP_FDCB(44,«»)
OP_ED(44,«»)

	|| LD	B,L
	|| B <- L
OPCODE(45,«
	LOHI	ebc
	move.b	ehl,ebc
	HILO	ebc
	»)
				|nok

OP_DD(45,«»)
OP_CB(45,«»)
OP_DDCB(45,«»)
OP_FD(45,«»)
OP_FDCB(45,«»)
OP_ED(45,«»)

	|| LD	B,(HL)
	|| B <- (HL)
OPCODE(46,«
	LOHI	ebc
	FETCHB	ehl,ebc
	HILO	ebc
	»)
				|nok

OP_DD(46,«»)
OP_CB(46,«»)
OP_DDCB(46,«»)
OP_FD(46,«»)
OP_FDCB(46,«»)
OP_ED(46,«»)

	|| LD	B,A
	|| B <- A
OPCODE(47,«
	LOHI	ebc
	move.b	eaf,ebc
	HILO	ebc
	»)
				|nok

OP_DD(47,«»)
OP_CB(47,«»)
OP_DDCB(47,«»)
OP_FD(47,«»)
OP_FDCB(47,«»)
OP_ED(47,«»)

	|| LD	C,B
	|| C <- B
OPCODE(48,«
	move.w	ebc,-(sp)
	move.b	(sp),ebc
	|| XXX emfasten?
	addq.l #2,sp
	»)
				|nok

OP_DD(48,«»)
OP_CB(48,«»)
OP_DDCB(48,«»)
OP_FD(48,«»)
OP_FDCB(48,«»)

	|| IN	C,(C)
OP_ED(48,«
	move.b	ebc,d0
	jsr	port_in
	move.b	d1,ebc
	»)

	|| LD	C,C
OPCODE(49,«
	move.b	ebc,ebc
	»)
				|nok

OP_DD(49,«»)
OP_CB(49,«»)
OP_DDCB(49,«»)
OP_FD(49,«»)
OP_FDCB(49,«»)

	|| OUT	(C),C
OP_ED(49,«
	move.b	ebc,d0
	move.b	ebc,d1
	jsr	port_out
	»)
				|nok

	|| LD	C,D
OPCODE(4a,«
	move.w	ede,-(sp)
	move.b	(sp),ebc
	|| XXX emfasten?
	addq.l #2,sp
	»)
				|nok

OP_DD(4a,«»)
OP_CB(4a,«»)
OP_DDCB(4a,«»)
OP_FD(4a,«»)
OP_FDCB(4a,«»)
OP_ED(4a,«»)

	|| LD	C,E
OPCODE(4b,«
	move.b	ebc,ede
	»)
				|nok

OP_DD(4b,«»)
OP_CB(4b,«»)
OP_DDCB(4b,«»)
OP_FD(4b,«»)
OP_FDCB(4b,«»)
OP_ED(4b,«»)

	|| LD	C,H
OPCODE(4c,«
	LOHI	ehl
	move.b	ebc,ehl
	HILO	ehl
	»)
				|nok

OP_DD(4c,«»)
OP_CB(4c,«»)
OP_DDCB(4c,«»)
OP_FD(4c,«»)
OP_FDCB(4c,«»)
OP_ED(4c,«»)

	|| LD	C,L
OPCODE(4d,«
	move.b	ebc,ehl
	»)
				|nok

OP_DD(4d,«»)
OP_CB(4d,«»)
OP_DDCB(4d,«»)
OP_FD(4d,«»)
OP_FDCB(4d,«»)
OP_ED(4d,«»)

	|| LD	C,(HL)
	|| C <- (HL)
OPCODE(4e,«
	FETCHB	ehl,ebc
	»)
				|nok

OP_DD(4e,«»)
OP_CB(4e,«»)
OP_DDCB(4e,«»)
OP_FD(4e,«»)
OP_FDCB(4e,«»)
OP_ED(4e,«»)

	|| LD	C,A
OPCODE(4f,«
	move.b	eaf,ebc
	»)
				|nok

OP_DD(4f,«»)
OP_CB(4f,«»)
OP_DDCB(4f,«»)
OP_FD(4f,«»)
OP_FDCB(4f,«»)
OP_ED(4f,«»)

| faster (slightly bigger) if we abuse sp again, something along the lines of (UNTESTED)
| move.w ebc,-(sp)   | 8, 2
| move.w ede,-(sp)   | 8, 2
| move.b 2(sp),(sp) | 16, 4
| move.w (sp)+,ede   | 8, 2
| addq.l #2,sp      | 8, 2
	|| LD	D,B
OPCODE(50,«
	LOHI	ebc
	LOHI	ede
	move.b	ebc,ede
	HILO	ebc
	HILO	ede
	»)
				|nok

OP_DD(50,«»)
OP_CB(50,«»)
OP_DDCB(50,«»)
OP_FD(50,«»)
OP_FDCB(50,«»)

	|| IN	D,(C)
OP_ED(50,«
	move.b	ebc,d0
	jsr	port_in
	LOHI	ede
	move.b	d1,ede
	HILO	ede
	»)

	|| LD	D,C
OPCODE(51,«
	LOHI	ede
	move.b	ebc,ede
	HILO	ede
	»)
				|nok

OP_DD(51,«»)
OP_CB(51,«»)
OP_DDCB(51,«»)
OP_FD(51,«»)
OP_FDCB(51,«»)

	|| OUT	(C),D
OP_ED(51,«
	move.b	ebc,d0
	LOHI	ede
	move.b	ede,d1
	HILO	ede
	jsr	port_out
	»)

	|| LD	D,D
OPCODE(52,«
	»)
				|nok

OP_DD(52,«»)
OP_CB(52,«»)
OP_DDCB(52,«»)
OP_FD(52,«»)
OP_FDCB(52,«»)
OP_ED(52,«»)

	|| LD	D,E
OPCODE(53,«
	andi.w	#$00ff,ede
	move.b	ede,d1
	lsl	#8,d1
	or.w	d1,ede
	»)
				|nok

OP_DD(53,«»)
OP_CB(53,«»)
OP_DDCB(53,«»)
OP_FD(53,«»)
OP_FDCB(53,«»)
OP_ED(53,«»)

	|| LD	D,H
OPCODE(54,«
	LOHI	ede		| 4
	LOHI	ehl		| 4
	move.b	ehl,ede		| 4
	HILO	ede		| 4
	HILO	ehl		| 4
	»,20)
				|nok
				|20 cycles

OP_DD(54,«»)
OP_CB(54,«»)
OP_DDCB(54,«»)
OP_FD(54,«»)
OP_FDCB(54,«»)
OP_ED(54,«»)

	|| LD	D,L
OPCODE(55,«
	LOHI	ede
	move.b	ehl,ede
	HILO	ede
	»)
				|nok

OP_DD(55,«»)
OP_CB(55,«»)
OP_DDCB(55,«»)
OP_FD(55,«»)
OP_FDCB(55,«»)
OP_ED(55,«»)

	|| LD	D,(HL)
	|| D <- (HL)
OPCODE(56,«
	LOHI	ede
	FETCHB	ehl,ede
	HILO	ede
	»)
				|nok

OP_DD(56,«»)
OP_CB(56,«»)
OP_DDCB(56,«»)
OP_FD(56,«»)
OP_FDCB(56,«»)
OP_ED(56,«»)

	|| LD	D,A
OPCODE(57,«
	LOHI	ede
	move.b	eaf,ede
	HILO	ede
	»)
				|nok

OP_DD(57,«»)
OP_CB(57,«»)
OP_DDCB(57,«»)
OP_FD(57,«»)
OP_FDCB(57,«»)
OP_ED(57,«»)

	|| LD	E,B
OPCODE(58,«
	LOHI	ebc
	move.b	ebc,ede
	HILO	ebc
	»)
				|nok

OP_DD(58,«»)
OP_CB(58,«»)
OP_DDCB(58,«»)
OP_FD(58,«»)
OP_FDCB(58,«»)

	|| IN	E,(C)
OP_ED(58,«
	move.b	ebc,d0
	jsr	port_in
	move.b	d1,ede
	»)

	|| LD	E,C
OPCODE(59,«
	move.b	ebc,ede
	»)
				|nok

OP_DD(59,«»)
OP_CB(59,«»)
OP_DDCB(59,«»)
OP_FD(59,«»)
OP_FDCB(59,«»)

	|| OUT	(C),E
OP_ED(59,«
	move.b	ebc,d0
	move.b	ede,d1
	jsr	port_out
	»)
				|nok

	|| LD	E,D
OPCODE(5a,«
	andi.w	#$ff00,ede	| 8/4
	move.b	ede,d1		| 4/2
	lsr.w	#8,d1		|22/2
	or.w	d1,ede		| 4/2
	»,38,,2)
				|nok

OP_DD(5a,«»)
OP_CB(5a,«»)
OP_DDCB(5a,«»)
OP_FD(5a,«»)
OP_FDCB(5a,«»)
OP_ED(5a,«»)

	|| LD	E,E
OPCODE(5b,«
	move.b	ede,ede
	»)
				|nok

OP_DD(5b,«»)
OP_CB(5b,«»)
OP_DDCB(5b,«»)
OP_FD(5b,«»)
OP_FDCB(5b,«»)
OP_ED(5b,«»)

	|| LD	E,H
OPCODE(5c,«
	LOHI	ehl
	move.b	ede,ehl
	HILO	ehl
	»)
				|nok

OP_DD(5c,«»)
OP_CB(5c,«»)
OP_DDCB(5c,«»)
OP_FD(5c,«»)
OP_FDCB(5c,«»)
OP_ED(5c,«»)

	|| LD	E,L
OPCODE(5d,«
	move.b	ede,ehl
	»)
				|nok

OP_DD(5d,«»)
OP_CB(5d,«»)
OP_DDCB(5d,«»)
OP_FD(5d,«»)
OP_FDCB(5d,«»)
OP_ED(5d,«»)

	|| LD	E,(HL)
OPCODE(5e,«
	FETCHB	ehl,d1
	»)
				|nok

OP_DD(5e,«»)
OP_CB(5e,«»)
OP_DDCB(5e,«»)
OP_FD(5e,«»)
OP_FDCB(5e,«»)
OP_ED(5e,«»)

	|| LD	E,A
OPCODE(5f,«
	move.b	ede,eaf
	»)
				|nok

OP_DD(5f,«»)
OP_CB(5f,«»)
OP_DDCB(5f,«»)
OP_FD(5f,«»)
OP_FDCB(5f,«»)
OP_ED(5f,«»)

	|| LD	H,B
OPCODE(60,«
	LOHI	ebc
	LOHI	ehl
	move.b	ehl,ebc
	HILO	ebc
	HILO	ehl
	»)
				|nok

OP_DD(60,«»)
OP_CB(60,«»)
OP_DDCB(60,«»)
OP_FD(60,«»)
OP_FDCB(60,«»)

	|| IN	H,(C)
OP_ED(60,«
	move.b	ebc,d0
	jsr	port_in
	LOHI	ehl
	move.b	d1,ehl
	HILO	ehl
	»)

	|| LD	H,C
OPCODE(61,«
	LOHI	ehl
	move.b	ebc,ehl
	HILO	ehl
	»)
				|nok

OP_DD(61,«»)
OP_CB(61,«»)
OP_DDCB(61,«»)
OP_FD(61,«»)
OP_FDCB(61,«»)

	|| OUT	(C),H
OP_ED(61,«
	move.b	ebc,d0
	LOHI	ehl
	move.b	ehl,d1
	HILO	ehl
	jsr	port_out
	»)

	|| LD	H,D
OPCODE(62,«
	LOHI	ede
	LOHI	ehl
	move.b	ede,ehl
	HILO	ede
	HILO	ehl
	»)
				|nok

OP_DD(62,«»)
OP_CB(62,«»)
OP_DDCB(62,«»)
OP_FD(62,«»)
OP_FDCB(62,«»)
OP_ED(62,«»)

	|| LD	H,E
OPCODE(63,«
	LOHI	ehl
	move.b	ede,ehl
	HILO	ehl
	»)
				|nok

OP_DD(63,«»)
OP_CB(63,«»)
OP_DDCB(63,«»)
OP_FD(63,«»)
OP_FDCB(63,«»)
OP_ED(63,«»)

	|| LD	H,H
OPCODE(64,«
	LOHI	ehl
	move.b	ehl,ehl
	HILO	ehl
	»)
				|nok

OP_DD(64,«»)
OP_CB(64,«»)
OP_DDCB(64,«»)
OP_FD(64,«»)
OP_FDCB(64,«»)
OP_ED(64,«»)

	|| LD	H,L
	|| H <- L
OPCODE(65,«
	move.b	ehl,d1
	LOHI	ehl
	move.b	d1,ehl
	HILO	ehl
	»)
				|nok

OP_DD(65,«»)
OP_CB(65,«»)
OP_DDCB(65,«»)
OP_FD(65,«»)
OP_FDCB(65,«»)
OP_ED(65,«»)

	|| LD	H,(HL)
OPCODE(66,«
	FETCHB	ehl,d1
	LOHI	ehl
	move.b	d1,ehl
	HILO	ehl
	»)
				|nok

OP_DD(66,«»)
OP_CB(66,«»)
OP_DDCB(66,«»)
OP_FD(66,«»)
OP_FDCB(66,«»)
OP_ED(66,«»)

	|| LD	H,A
OPCODE(67,«
	LOHI	ehl
	move.b	eaf,ehl
	HILO	ehl
	»)
				|nok

OP_DD(67,«»)
OP_CB(67,«»)
OP_DDCB(67,«»)
OP_FD(67,«»)
OP_FDCB(67,«»)
OP_ED(67,«»)

	|| LD	L,B
OPCODE(68,«
	LOHI	ebc
	move.b	ebc,ehl
	HILO	ebc
	»)
				|nok

OP_DD(68,«»)
OP_CB(68,«»)
OP_DDCB(68,«»)
OP_FD(68,«»)
OP_FDCB(68,«»)

	|| IN	L,(C)
OP_ED(68,«
	move.b	ebc,d0
	jsr	port_in
	move.b	d1,ehl
	»)

	|| LD	L,C
OPCODE(69,«
	move.b	ebc,ehl
	»)
				|nok

OP_DD(69,«»)
OP_CB(69,«»)
OP_DDCB(69,«»)
OP_FD(69,«»)
OP_FDCB(69,«»)

	|| OUT	(C),L
OP_ED(69,«
	move.b	ebc,d0
	move.b	ehl,d1
	jsr	port_out
	»)

	|| LD	L,D
OPCODE(6a,«
	LOHI	ede
	move.b	ede,ehl
	HILO	ede
	»)
				|nok

OP_DD(6a,«»)
OP_CB(6a,«»)
OP_DDCB(6a,«»)
OP_FD(6a,«»)
OP_FDCB(6a,«»)
OP_ED(6a,«»)

	|| LD	L,E
OPCODE(6b,«
	move.b	ede,ehl
	»)
				|nok

OP_DD(6b,«»)
OP_CB(6b,«»)
OP_DDCB(6b,«»)
OP_FD(6b,«»)
OP_FDCB(6b,«»)
OP_ED(6b,«»)

	|| LD	L,H
OPCODE(6c,«
	move.b	ehl,d1
	LOHI	d1
	move.b	d1,ehl
	»)
				|nok

OP_DD(6c,«»)
OP_CB(6c,«»)
OP_DDCB(6c,«»)
OP_FD(6c,«»)
OP_FDCB(6c,«»)
OP_ED(6c,«»)

	|| LD	L,L
OPCODE(6d,«
	move.b	ehl,ehl
	»)
				|nok

OP_DD(6d,«»)
OP_CB(6d,«»)
OP_DDCB(6d,«»)
OP_FD(6d,«»)
OP_FDCB(6d,«»)
OP_ED(6d,«»)

	|| LD	L,(HL)
	|| L <- (HL)
OPCODE(6e,«
	FETCHB	ehl,ehl
	»)
				|nok

OP_DD(6e,«»)
OP_CB(6e,«»)
OP_DDCB(6e,«»)
OP_FD(6e,«»)
OP_FDCB(6e,«»)
OP_ED(6e,«»)

	|| LD	L,A
OPCODE(6f,«
	move.b	eaf,ehl
	»)
				|nok

OP_DD(6f,«»)
OP_CB(6f,«»)
OP_DDCB(6f,«»)
OP_FD(6f,«»)
OP_FDCB(6f,«»)
OP_ED(6f,«»)

	|| LD	(HL),B
OPCODE(70,«
	LOHI	ebc
	PUTB	ehl,ebc
	HILO	ebc
	»)
				|nok

OP_DD(70,«»)
OP_CB(70,«»)
OP_DDCB(70,«»)
OP_FD(70,«»)
OP_FDCB(70,«»)
OP_ED(70,«»)

	|| LD	(HL),C
OPCODE(71,«
	PUTB	ehl,ebc
	»)
				|nok

OP_DD(71,«»)
OP_CB(71,«»)
OP_DDCB(71,«»)
OP_FD(71,«»)
OP_FDCB(71,«»)
OP_ED(71,«»)

	|| LD	(HL),D
OPCODE(72,«
	LOHI	ede
	PUTB	ehl,ede
	HILO	ede
	»)
				|nok

OP_DD(72,«»)
OP_CB(72,«»)
OP_DDCB(72,«»)
OP_FD(72,«»)
OP_FDCB(72,«»)
OP_ED(72,«»)

	|| LD	(HL),E
OPCODE(73,«
	PUTB	ehl,ede
	»)
				|nok

OP_DD(73,«»)
OP_CB(73,«»)
OP_DDCB(73,«»)
OP_FD(73,«»)
OP_FDCB(73,«»)
OP_ED(73,«»)

	|| LD	(HL),H
OPCODE(74,«
	move.w	ehl,d1
	HILO	d1
	PUTB	d1,ehl
	»)
				|nok

OP_DD(74,«»)
OP_CB(74,«»)
OP_DDCB(74,«»)
OP_FD(74,«»)
OP_FDCB(74,«»)
OP_ED(74,«»)

	|| LD	(HL),L
OPCODE(75,«
	move.b	ehl,d1
	PUTB	d1,ehl
	»)
				|nok

OP_DD(75,«»)
OP_CB(75,«»)
OP_DDCB(75,«»)
OP_FD(75,«»)
OP_FDCB(75,«»)
OP_ED(75,«»)

	|| HALT
	|| XXX do this
OPCODE(76,«
	bra	emu_op_76
	»)
				|nok

OP_DD(76,«»)
OP_CB(76,«»)
OP_DDCB(76,«»)
OP_FD(76,«»)
OP_FDCB(76,«»)
OP_ED(76,«»)

	|| LD	(HL),A
OPCODE(77,«
	PUTB	eaf,ehl
	»)
				|nok

OP_DD(77,«»)
OP_CB(77,«»)
OP_DDCB(77,«»)
OP_FD(77,«»)
OP_FDCB(77,«»)
OP_ED(77,«»)

	|| LD	A,B
OPCODE(78,«
	move.w	ebc,d1
	LOHI	d1
	move.b	d1,eaf
	»)
				|nok

OP_DD(78,«»)
OP_CB(78,«»)
OP_DDCB(78,«»)
OP_FD(78,«»)
OP_FDCB(78,«»)

	|| IN	A,(C)
OP_ED(78,«
	move.b	ebc,d0
	jsr	port_in
	move.b	d1,eaf
	»)
				|nok

	|| LD	A,C
OPCODE(79,«
	move.b	ebc,eaf
	»)
				|nok

OP_DD(79,«»)
OP_CB(79,«»)
OP_DDCB(79,«»)
OP_FD(79,«»)
OP_FDCB(79,«»)

	|| OUT	(C),A
OP_ED(79,«
	move.b	ebc,d0
	move.b	eaf,d1
	jsr	port_out
	»)
				|nok

	|| LD	A,D
OPCODE(7a,«
	move.w	ede,d1
	LOHI	d1
	move.b	d1,eaf
	»)
				|nok

OP_DD(7a,«»)
OP_CB(7a,«»)
OP_DDCB(7a,«»)
OP_FD(7a,«»)
OP_FDCB(7a,«»)
OP_ED(7a,«»)

	|| LD	A,E
OPCODE(7b,«
	move.b	ede,eaf
	»)
				|nok

OP_DD(7b,«»)
OP_CB(7b,«»)
OP_DDCB(7b,«»)
OP_FD(7b,«»)
OP_FDCB(7b,«»)
OP_ED(7b,«»)

	|| LD	A,H
OPCODE(7c,«
	move.w	ehl,d1
	LOHI	d1
	move.b	d1,eaf
	»)
				|nok

OP_DD(7c,«»)
OP_CB(7c,«»)
OP_DDCB(7c,«»)
OP_FD(7c,«»)
OP_FDCB(7c,«»)
OP_ED(7c,«»)

	|| LD	A,L
OPCODE(7d,«
	move.b	ehl,eaf
	»)
				|nok

OP_DD(7d,«»)
OP_CB(7d,«»)
OP_DDCB(7d,«»)
OP_FD(7d,«»)
OP_FDCB(7d,«»)
OP_ED(7d,«»)

	|| LD	A,(HL)
	|| A <- (HL)
OPCODE(7e,«
	FETCHB	ehl,eaf
	»)

OP_DD(7e,«»)
OP_CB(7e,«»)
OP_DDCB(7e,«»)
OP_FD(7e,«»)
OP_FDCB(7e,«»)
OP_ED(7e,«»)

	|| LD	A,A
OPCODE(7f,«
	»)
				|nok

OP_DD(7f,«»)
OP_CB(7f,«»)
OP_DDCB(7f,«»)
OP_FD(7f,«»)
OP_FDCB(7f,«»)
OP_ED(7f,«»)



	|| Do an ADD \2,\1
.macro	F_ADD_B	src dest		| 14 bytes?
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_add
	move.b	d1,\dest
	ENDM

	|| ADD	A,B
OPCODE(80,«
	LOHI	ebc
	F_ADD_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(80,«»)
OP_CB(80,«»)
OP_DDCB(80,«»)
OP_FD(80,«»)
OP_FDCB(80,«»)
OP_ED(80,«»)

	|| ADD	A,C
OPCODE(81,«
	F_ADD_B	ebc,eaf
	»)
				|nok

OP_DD(81,«»)
OP_CB(81,«»)
OP_DDCB(81,«»)
OP_FD(81,«»)
OP_FDCB(81,«»)
OP_ED(81,«»)

	|| ADD	A,D
OPCODE(82,«
	LOHI	ede
	F_ADD_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(82,«»)
OP_CB(82,«»)
OP_DDCB(82,«»)
OP_FD(82,«»)
OP_FDCB(82,«»)
OP_ED(82,«»)

	|| ADD	A,E
OPCODE(83,«
	F_ADD_B	ede,eaf
	»)
				|nok

OP_DD(83,«»)
OP_CB(83,«»)
OP_DDCB(83,«»)
OP_FD(83,«»)
OP_FDCB(83,«»)
OP_ED(83,«»)

	|| ADD	A,H
OPCODE(84,«
	LOHI	ehl
	F_ADD_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(84,«»)
OP_CB(84,«»)
OP_DDCB(84,«»)
OP_FD(84,«»)
OP_FDCB(84,«»)
OP_ED(84,«»)

	|| ADD	A,L
OPCODE(85,«
	F_ADD_B	ehl,eaf
	»)
				|nok

OP_DD(85,«»)
OP_CB(85,«»)
OP_DDCB(85,«»)
OP_FD(85,«»)
OP_FDCB(85,«»)
OP_ED(85,«»)

	|| ADD	A,(HL)
	|| XXX size?
OPCODE(86,«
	FETCHB	ehl,d2
	F_ADD_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(86,«»)
OP_CB(86,«»)
OP_DDCB(86,«»)
OP_FD(86,«»)
OP_FDCB(86,«»)
OP_ED(86,«»)

	|| ADD	A,A
OPCODE(87,«
	F_ADD_B	eaf,eaf
	»)
				|nok

OP_DD(87,«»)
OP_CB(87,«»)
OP_DDCB(87,«»)
OP_FD(87,«»)
OP_FDCB(87,«»)
OP_ED(87,«»)



	|| Do an ADC \2,\1
.macro	F_ADC_B	src dest	| S34
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_adc
	move.b	d1,\dest
	ENDM

	|| ADC	A,B
	|| A <- A + B + (carry)
OPCODE(88,«
	LOHI	ebc
	F_ADC_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(88,«»)
OP_CB(88,«»)
OP_DDCB(88,«»)
OP_FD(88,«»)
OP_FDCB(88,«»)
OP_ED(88,«»)

	|| ADC	A,C
	|| A <- A + C + (carry)
OPCODE(89,«
	F_ADC_B	ebc,eaf
	»)
				|nok

OP_DD(89,«»)
OP_CB(89,«»)
OP_DDCB(89,«»)
OP_FD(89,«»)
OP_FDCB(89,«»)
OP_ED(89,«»)

	|| ADC	A,D
OPCODE(8a,«
	LOHI	ede
	F_ADC_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(8a,«»)
OP_CB(8a,«»)
OP_DDCB(8a,«»)
OP_FD(8a,«»)
OP_FDCB(8a,«»)
OP_ED(8a,«»)

	|| ADC	A,E
	|| A <- A + E + carry
OPCODE(8b,«
	F_ADC_B	ede,eaf
	»)
				|nok

OP_DD(8b,«»)
OP_CB(8b,«»)
OP_DDCB(8b,«»)
OP_FD(8b,«»)
OP_FDCB(8b,«»)
OP_ED(8b,«»)

	|| ADC	A,H
OPCODE(8c,«
	LOHI	eaf
	F_ADC_B	ehl,eaf
	HILO	eaf
	»)
				|nok

OP_DD(8c,«»)
OP_CB(8c,«»)
OP_DDCB(8c,«»)
OP_FD(8c,«»)
OP_FDCB(8c,«»)
OP_ED(8c,«»)

	|| ADC	A,L
OPCODE(8d,«
	F_ADC_B	ehl,eaf
	»)
				|nok

OP_DD(8d,«»)
OP_CB(8d,«»)
OP_DDCB(8d,«»)
OP_FD(8d,«»)
OP_FDCB(8d,«»)
OP_ED(8d,«»)

	|| ADC	A,(HL)
OPCODE(8e,«
	FETCHB	ehl,d2
	F_ADC_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(8e,«»)
OP_CB(8e,«»)
OP_DDCB(8e,«»)
OP_FD(8e,«»)
OP_FDCB(8e,«»)
OP_ED(8e,«»)

	|| ADC	A,A
OPCODE(8f,«
	F_ADC_B	eaf,eaf
	»)
				|nok

OP_DD(8f,«»)
OP_CB(8f,«»)
OP_DDCB(8f,«»)
OP_FD(8f,«»)
OP_FDCB(8f,«»)
OP_ED(8f,«»)





	|| Do a SUB \2,\1
.macro	F_SUB_B	src dest
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_sub
	move.b	d1,\dest
	ENDM

	|| SUB	A,B
OPCODE(90,«
	LOHI	ebc
	F_SUB_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(90,«»)
OP_CB(90,«»)
OP_DDCB(90,«»)
OP_FD(90,«»)
OP_FDCB(90,«»)
OP_ED(90,«»)

	|| SUB	A,C
OPCODE(91,«
	F_SUB_B	ebc,eaf
	»)
				|nok

OP_DD(91,«»)
OP_CB(91,«»)
OP_DDCB(91,«»)
OP_FD(91,«»)
OP_FDCB(91,«»)
OP_ED(91,«»)

	|| SUB	A,D
OPCODE(92,«
	LOHI	ede
	F_SUB_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(92,«»)
OP_CB(92,«»)
OP_DDCB(92,«»)
OP_FD(92,«»)
OP_FDCB(92,«»)
OP_ED(92,«»)

	|| SUB	A,E
OPCODE(93,«
	F_SUB_B	ede,eaf
	»)
				|nok

OP_DD(93,«»)
OP_CB(93,«»)
OP_DDCB(93,«»)
OP_FD(93,«»)
OP_FDCB(93,«»)
OP_ED(93,«»)

	|| SUB	A,H
OPCODE(94,«
	LOHI	ehl
	F_SUB_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(94,«»)
OP_CB(94,«»)
OP_DDCB(94,«»)
OP_FD(94,«»)
OP_FDCB(94,«»)
OP_ED(94,«»)

	|| SUB	A,L
OPCODE(95,«
	F_SUB_B	ehl,eaf
	»)

OP_DD(95,«»)
OP_CB(95,«»)
OP_DDCB(95,«»)
OP_FD(95,«»)
OP_FDCB(95,«»)
OP_ED(95,«»)

	|| SUB	A,(HL)
OPCODE(96,«
	FETCHB	ehl,d2
	F_SUB_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(96,«»)
OP_CB(96,«»)
OP_DDCB(96,«»)
OP_FD(96,«»)
OP_FDCB(96,«»)
OP_ED(96,«»)

	|| SUB	A,A
OPCODE(97,«
	F_SUB_B	eaf,eaf
	»)
				|nok

OP_DD(97,«»)
OP_CB(97,«»)
OP_DDCB(97,«»)
OP_FD(97,«»)
OP_FDCB(97,«»)
OP_ED(97,«»)




	|| Do a SBC \2,\1
.macro	F_SBC_B	src dest
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_sbc
	move.b	d1,\dest
.endm

	|| SBC	A,B
OPCODE(98,«
	LOHI	ebc
	F_SBC_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(98,«»)
OP_CB(98,«»)
OP_DDCB(98,«»)
OP_FD(98,«»)
OP_FDCB(98,«»)
OP_ED(98,«»)

	|| SBC	A,C
OPCODE(99,«
	F_SBC_B	ebc,eaf
	»)
				|nok

OP_DD(99,«»)
OP_CB(99,«»)
OP_DDCB(99,«»)
OP_FD(99,«»)
OP_FDCB(99,«»)
OP_ED(99,«»)

	|| SBC	A,D
OPCODE(9a,«
	LOHI	ede
	F_SBC_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(9a,«»)
OP_CB(9a,«»)
OP_DDCB(9a,«»)
OP_FD(9a,«»)
OP_FDCB(9a,«»)
OP_ED(9a,«»)

	|| SBC	A,E
OPCODE(9b,«
	F_SBC_B	ede,eaf
	»)
				|nok

OP_DD(9b,«»)
OP_CB(9b,«»)
OP_DDCB(9b,«»)
OP_FD(9b,«»)
OP_FDCB(9b,«»)
OP_ED(9b,«»)

	|| SBC	A,H
OPCODE(9c,«
	LOHI	ehl
	F_SBC_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(9c,«»)
OP_CB(9c,«»)
OP_DDCB(9c,«»)
OP_FD(9c,«»)
OP_FDCB(9c,«»)
OP_ED(9c,«»)

	|| SBC	A,L
OPCODE(9d,«
	F_SBC_B	ehl,eaf
	»)
				|nok

OP_DD(9d,«»)
OP_CB(9d,«»)
OP_DDCB(9d,«»)
OP_FD(9d,«»)
OP_FDCB(9d,«»)
OP_ED(9d,«»)

	|| SBC	A,(HL)
OPCODE(9e,«
	FETCHB	ehl,d2
	F_SBC_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(9e,«»)
OP_CB(9e,«»)
OP_DDCB(9e,«»)
OP_FD(9e,«»)
OP_FDCB(9e,«»)
OP_ED(9e,«»)

	|| SBC	A,A
OPCODE(9f,«
	F_SBC_B	eaf,eaf
	»)
				|nok





.macro	F_AND_B	src dest
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_and
	move.b	d1,\dest
.endm

OP_DD(9f,«»)
OP_CB(9f,«»)
OP_DDCB(9f,«»)
OP_FD(9f,«»)
OP_FDCB(9f,«»)
OP_ED(9f,«»)

	|| AND	B
OPCODE(a0,«
	LOHI	ebc
	F_AND_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(a0,«»)
OP_CB(a0,«»)
OP_DDCB(a0,«»)
OP_FD(a0,«»)
OP_FDCB(a0,«»)
OP_ED(a0,«»)

	|| AND	C
OPCODE(a1,«
	F_AND_B	ebc,eaf
	»)

OP_DD(a1,«»)
OP_CB(a1,«»)
OP_DDCB(a1,«»)
OP_FD(a1,«»)
OP_FDCB(a1,«»)
OP_ED(a1,«»)

	|| AND	D
OPCODE(a2,«
	LOHI	ede
	F_AND_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(a2,«»)
OP_CB(a2,«»)
OP_DDCB(a2,«»)
OP_FD(a2,«»)
OP_FDCB(a2,«»)
OP_ED(a2,«»)

	|| AND	E
OPCODE(a3,«
	F_AND_B	ede,eaf
	»)
				|nok

OP_DD(a3,«»)
OP_CB(a3,«»)
OP_DDCB(a3,«»)
OP_FD(a3,«»)
OP_FDCB(a3,«»)
OP_ED(a3,«»)

	|| AND	H
OPCODE(a4,«
	LOHI	ehl
	F_AND_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(a4,«»)
OP_CB(a4,«»)
OP_DDCB(a4,«»)
OP_FD(a4,«»)
OP_FDCB(a4,«»)
OP_ED(a4,«»)

	|| AND	L
OPCODE(a5,«
	F_AND_B	ehl,eaf
	»)
				|nok

OP_DD(a5,«»)
OP_CB(a5,«»)
OP_DDCB(a5,«»)
OP_FD(a5,«»)
OP_FDCB(a5,«»)
OP_ED(a5,«»)

	|| AND	(HL)
OPCODE(a6,«
	FETCHB	ehl,d2
	F_AND_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(a6,«»)
OP_CB(a6,«»)
OP_DDCB(a6,«»)
OP_FD(a6,«»)
OP_FDCB(a6,«»)
OP_ED(a6,«»)

	|| AND	A
	|| SPEED ... It's probably not necessary to run this faster.
OPCODE(a7,«
	F_AND_B	eaf,eaf
	»)
				|nok





.macro	F_XOR_B	src dest
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_xor
	move.b	d1,\dest
	ENDM

OP_DD(a7,«»)
OP_CB(a7,«»)
OP_DDCB(a7,«»)
OP_FD(a7,«»)
OP_FDCB(a7,«»)
OP_ED(a7,«»)

	|| XOR	B
OPCODE(a8,«
	LOHI	ebc
	F_XOR_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(a8,«»)
OP_CB(a8,«»)
OP_DDCB(a8,«»)
OP_FD(a8,«»)
OP_FDCB(a8,«»)
OP_ED(a8,«»)

	|| XOR	C
OPCODE(a9,«
	F_XOR_B	ebc,eaf
	»)
				|nok

OP_DD(a9,«»)
OP_CB(a9,«»)
OP_DDCB(a9,«»)
OP_FD(a9,«»)
OP_FDCB(a9,«»)
OP_ED(a9,«»)

	|| XOR	D
OPCODE(aa,«
	LOHI	ede
	F_XOR_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(aa,«»)
OP_CB(aa,«»)
OP_DDCB(aa,«»)
OP_FD(aa,«»)
OP_FDCB(aa,«»)
OP_ED(aa,«»)

	|| XOR	E
OPCODE(ab,«
	F_XOR_B	ede,eaf
	»)
				|nok

OP_DD(ab,«»)
OP_CB(ab,«»)
OP_DDCB(ab,«»)
OP_FD(ab,«»)
OP_FDCB(ab,«»)
OP_ED(ab,«»)

	|| XOR	H
OPCODE(ac,«
	LOHI	ehl
	F_XOR_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(ac,«»)
OP_CB(ac,«»)
OP_DDCB(ac,«»)
OP_FD(ac,«»)
OP_FDCB(ac,«»)
OP_ED(ac,«»)

	|| XOR	L
OPCODE(ad,«
	F_XOR_B	ehl,eaf
	»)
				|nok

OP_DD(ad,«»)
OP_CB(ad,«»)
OP_DDCB(ad,«»)
OP_FD(ad,«»)
OP_FDCB(ad,«»)
OP_ED(ad,«»)

	|| XOR	(HL)
OPCODE(ae,«
	FETCHB	ehl,d2
	F_XOR_B	d2,eaf
	PUTB	d2,ehl
	»)
				|nok

OP_DD(ae,«»)
OP_CB(ae,«»)
OP_DDCB(ae,«»)
OP_FD(ae,«»)
OP_FDCB(ae,«»)
OP_ED(ae,«»)

	|| XOR	A
OPCODE(af,«
	F_XOR_B	eaf,eaf
	|| XXX
	»)
				|nok





.macro	F_OR_B	src dest
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_or
	move.b	d1,\dest
.endm

OP_DD(af,«»)
OP_CB(af,«»)
OP_DDCB(af,«»)
OP_FD(af,«»)
OP_FDCB(af,«»)
OP_ED(af,«»)

	|| OR	B
OPCODE(b0,«
	LOHI	ebc
	F_OR_B	ebc,eaf
	HILO	ebc
	»)
				|nok

OP_DD(b0,«»)
OP_CB(b0,«»)
OP_DDCB(b0,«»)
OP_FD(b0,«»)
OP_FDCB(b0,«»)
OP_ED(b0,«»)

	|| OR	C
OPCODE(b1,«
	F_OR_B	ebc,eaf
	»)
				|nok

OP_DD(b1,«»)
OP_CB(b1,«»)
OP_DDCB(b1,«»)
OP_FD(b1,«»)
OP_FDCB(b1,«»)
OP_ED(b1,«»)

	|| OR	D
OPCODE(b2,«
	LOHI	ede
	F_OR_B	ede,eaf
	HILO	ede
	»)
				|nok

OP_DD(b2,«»)
OP_CB(b2,«»)
OP_DDCB(b2,«»)
OP_FD(b2,«»)
OP_FDCB(b2,«»)
OP_ED(b2,«»)

	|| OR	E
OPCODE(b3,«
	F_OR_B	ede,eaf
	»)
				|nok

OP_DD(b3,«»)
OP_CB(b3,«»)
OP_DDCB(b3,«»)
OP_FD(b3,«»)
OP_FDCB(b3,«»)
OP_ED(b3,«»)

	|| OR	H
OPCODE(b4,«
	LOHI	ehl
	F_OR_B	ehl,eaf
	HILO	ehl
	»)
				|nok

OP_DD(b4,«»)
OP_CB(b4,«»)
OP_DDCB(b4,«»)
OP_FD(b4,«»)
OP_FDCB(b4,«»)
OP_ED(b4,«»)

	|| OR	L
OPCODE(b5,«
	F_OR_B	ehl,eaf
	»)
				|nok

OP_DD(b5,«»)
OP_CB(b5,«»)
OP_DDCB(b5,«»)
OP_FD(b5,«»)
OP_FDCB(b5,«»)
OP_ED(b5,«»)

	|| OR	(HL)
OPCODE(b6,«
	|| SPEED unnecessary move
	FETCHB	ehl,d2
	F_OR_B	d2,eaf
	»)
				|nok

OPCODE(b7,«
OP_DD(b6,«»)
OP_CB(b6,«»)
OP_DDCB(b6,«»)
OP_FD(b6,«»)
OP_FDCB(b6,«»)
OP_ED(b6,«»)

	|| OR	A
	F_OR_B	eaf,eaf
	»)
				|nok





	|| COMPARE instruction
	|| Tests the argument against A
.macro	F_CP_B	src dest
	|| XXX deal with \2 or \1 being d1 or d0
	move.b	\dest,d1
	move.b	\src,d0
	jsr	alu_cp
	|| no result to save
.endm

OP_DD(b7,«»)
OP_CB(b7,«»)
OP_DDCB(b7,«»)
OP_FD(b7,«»)
OP_FDCB(b7,«»)
OP_ED(b7,«»)

	|| CP	B
OPCODE(b8,«
	move.w	ebc,d2
	LOHI	d2
	F_CP_B	d2,eaf
	»)
				|nok

OP_DD(b8,«»)
OP_CB(b8,«»)
OP_DDCB(b8,«»)
OP_FD(b8,«»)
OP_FDCB(b8,«»)
OP_ED(b8,«»)

	|| CP	C
OPCODE(b9,«
	F_CP_B	ebc,eaf
	»)
				|nok

OP_DD(b9,«»)
OP_CB(b9,«»)
OP_DDCB(b9,«»)
OP_FD(b9,«»)
OP_FDCB(b9,«»)
OP_ED(b9,«»)

	|| CP	D
OPCODE(ba,«
	move.w	ede,d2
	LOHI	d2
	F_CP_B	d2,eaf
	»)
				|nok

OP_DD(ba,«»)
OP_CB(ba,«»)
OP_DDCB(ba,«»)
OP_FD(ba,«»)
OP_FDCB(ba,«»)
OP_ED(ba,«»)

	|| CP	E
OPCODE(bb,«
	F_CP_B	ede,eaf
	»)
				|nok

OP_DD(bb,«»)
OP_CB(bb,«»)
OP_DDCB(bb,«»)
OP_FD(bb,«»)
OP_FDCB(bb,«»)
OP_ED(bb,«»)

	|| CP	H
OPCODE(bc,«
	move.w	ehl,d2
	LOHI	d2
	F_CP_B	d2,eaf
	»)
				|nok

OP_DD(bc,«»)
OP_CB(bc,«»)
OP_DDCB(bc,«»)
OP_FD(bc,«»)
OP_FDCB(bc,«»)
OP_ED(bc,«»)

	|| CP	L
OPCODE(bd,«
	F_CP_B	ehl,eaf
	»)
				|nok

OP_DD(bd,«»)
OP_CB(bd,«»)
OP_DDCB(bd,«»)
OP_FD(bd,«»)
OP_FDCB(bd,«»)
OP_ED(bd,«»)

	|| CP	(HL)
OPCODE(be,«
	FETCHB	ehl,d2
	F_CP_B	d2,eaf
	|| no result to store
	»)
				|nok

OP_DD(be,«»)
OP_CB(be,«»)
OP_DDCB(be,«»)
OP_FD(be,«»)
OP_FDCB(be,«»)
OP_ED(be,«»)

	|| CP	A
OPCODE(bf,«
	F_CP_B	eaf,eaf
	»)

OP_DD(bf,«»)
OP_CB(bf,«»)
OP_DDCB(bf,«»)
OP_FD(bf,«»)
OP_FDCB(bf,«»)
OP_ED(bf,«»)

	|| RET	NZ
	|| if ~Z
	||   PCl <- (SP)
	||   PCh <- (SP+1)
	||   SP <- (SP+2)
OPCODE(c0,«
	jsr	f_norm_z
	|| SPEED inline RET
	beq	emu_op_c9	| RET
	»)
				|nok

OP_DD(c0,«»)
OP_CB(c0,«»)
OP_DDCB(c0,«»)
OP_FD(c0,«»)
OP_FDCB(c0,«»)
OP_ED(c0,«»)

	|| POP	BC
	|| Pops a word into BC
OPCODE(c1,«			| S10 T
	POPW	ebc
	»)
				|nok

OP_DD(c1,«»)
OP_CB(c1,«»)
OP_DDCB(c1,«»)
OP_FD(c1,«»)
OP_FDCB(c1,«»)
OP_ED(c1,«»)

	|| JP	NZ,immed.w
	|| if ~Z
	||   PC <- immed.w
OPCODE(c2,«
	jsr	f_norm_z
	bne	local(continue)
	jmp	emu_op_c3	| shame this has to be a long jump
local(continue):
	add.l	#2,epc
	»)
				|nok

OP_DD(c2,«»)
OP_CB(c2,«»)
OP_DDCB(c2,«»)
OP_FD(c2,«»)
OP_FDCB(c2,«»)
OP_ED(c2,«»)

	|| JP	immed.w
	|| PC <- immed.w
OPCODE(c3,«
	FETCHWI	d1
	jsr	deref
	movea.l	a0,epc
	»,36,,12)

OP_DD(c3,«»)
OP_CB(c3,«»)
OP_DDCB(c3,«»)
OP_FD(c3,«»)
OP_FDCB(c3,«»)
OP_ED(c3,«»)

	|| CALL	NZ,immed.w
	|| If ~Z, CALL immed.w
OPCODE(c4,«
	jsr	f_norm_z
	|| CALL (emu_op_cd) will run HOLD_INTS again. This doesn't
	|| matter with the current implementation because HOLD_INTS
	|| simply sets a bit.
	beq	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OP_DD(c4,«»)
OP_CB(c4,«»)
OP_DDCB(c4,«»)
OP_FD(c4,«»)
OP_FDCB(c4,«»)
OP_ED(c4,«»)

	|| PUSH	BC
OPCODE(c5,«
	PUSHW	ebc
	»)
				|nok

OP_DD(c5,«»)
OP_CB(c5,«»)
OP_DDCB(c5,«»)
OP_FD(c5,«»)
OP_FDCB(c5,«»)
OP_ED(c5,«»)

	|| ADD	A,immed.b
OPCODE(c6,«
	FETCHBI	d1
	F_ADD_B	d1,eaf
	»)
				|nok

OP_DD(c6,«»)
OP_CB(c6,«»)
OP_DDCB(c6,«»)
OP_FD(c6,«»)
OP_FDCB(c6,«»)
OP_ED(c6,«»)

	|| RST	&0
	||  == CALL 0
	|| XXX check
OPCODE(c7,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$00,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(c7,«»)
OP_CB(c7,«»)
OP_DDCB(c7,«»)
OP_FD(c7,«»)
OP_FDCB(c7,«»)
OP_ED(c7,«»)

	|| RET	Z
OPCODE(c8,«
	jsr	f_norm_z
	beq	local(continue)
	jmp	emu_op_c9	| shame this has to be a long jump
local(continue):
	»)
				|nok

OP_DD(c8,«»)
OP_CB(c8,«»)
OP_DDCB(c8,«»)
OP_FD(c8,«»)
OP_FDCB(c8,«»)
OP_ED(c8,«»)

	|| RET
	|| PCl <- (SP)
	|| PCh <- (SP+1)	POPW
	|| SP <- (SP+2)
OPCODE(c9,«
	POPW	d1
	jsr	deref
	movea.l	a0,epc
	»)
				|nok

OP_DD(c9,«»)
OP_CB(c9,«»)
OP_DDCB(c9,«»)
OP_FD(c9,«»)
OP_FDCB(c9,«»)
OP_ED(c9,«»)

	|| JP	Z,immed.w
	|| If Z, jump
OPCODE(ca,«
	jsr	f_norm_z
	bne	emu_op_c3
	add.l	#2,epc
	»)
				|nok
OP_DD(ca,«»)
OP_CB(ca,«»)
OP_DDCB(ca,«»)
OP_FD(ca,«»)
OP_FDCB(ca,«»)
OP_ED(ca,«»)

	|| prefix
OPCODE(cb,«
	movea.w	emu_op_undo_cb(pc),a2
	»)
				|nok

OP_DD(cb,«»)
OP_CB(cb,«»)
OP_DDCB(cb,«»)
OP_FD(cb,«»)
OP_FDCB(cb,«»)
OP_ED(cb,«»)

	|| CALL	Z,immed.w
OPCODE(cc,«
	jsr	f_norm_z
	beq	local(continue)
	jmp	emu_op_cd
local(continue):
	add.l	#2,epc
	»)
				|nok

OP_DD(cc,«»)
OP_CB(cc,«»)
OP_DDCB(cc,«»)
OP_FD(cc,«»)
OP_FDCB(cc,«»)
OP_ED(cc,«»)

	|| CALL	immed.w
	|| (Like JSR on 68k)
	||  (SP-1) <- PCh
	||  (SP-2) <- PCl
	||  SP <- SP - 2
	||  PC <- address
OPCODE(cd,«
	move.l	epc,a0
	jsr	underef		| d0 has PC
	add.w	#2,d0
	PUSHW	d0
	bra	emu_op_c3	| JP
	»)

OP_DD(cd,«»)
OP_CB(cd,«»)
OP_DDCB(cd,«»)
OP_FD(cd,«»)
OP_FDCB(cd,«»)
OP_ED(cd,«»)

	|| ADC	A,immed.b
OPCODE(ce,«
	FETCHWI	d1
	F_ADC_B	d1,eaf
	»)
				|nok

OP_DD(ce,«»)
OP_CB(ce,«»)
OP_DDCB(ce,«»)
OP_FD(ce,«»)
OP_FDCB(ce,«»)
OP_ED(ce,«»)

	|| RST	&08
	||  == CALL 8
OPCODE(cf,«
	move.l	epc,a0
	jsr	underef		| d0 has PC
	PUSHW	d0
	move.w	#$08,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(cf,«»)
OP_CB(cf,«»)
OP_DDCB(cf,«»)
OP_FD(cf,«»)
OP_FDCB(cf,«»)
OP_ED(cf,«»)

	|| RET	NC
OPCODE(d0,«
	jsr	f_norm_c
	beq	emu_op_c9
	»)
				|nok

OP_DD(d0,«»)
OP_CB(d0,«»)
OP_DDCB(d0,«»)
OP_FD(d0,«»)
OP_FDCB(d0,«»)
OP_ED(d0,«»)

	|| POP	DE
OPCODE(d1,«
	POPW	ede
	»)
				|nok

OP_DD(d1,«»)
OP_CB(d1,«»)
OP_DDCB(d1,«»)
OP_FD(d1,«»)
OP_FDCB(d1,«»)
OP_ED(d1,«»)

	|| JP	NC,immed.w
OPCODE(d2,«
	jsr	f_norm_c
	beq	emu_op_c3
	add.l	#2,epc
	»)

OP_DD(d2,«»)
OP_CB(d2,«»)
OP_DDCB(d2,«»)
OP_FD(d2,«»)
OP_FDCB(d2,«»)
OP_ED(d2,«»)

	|| OUT	immed.b,A
OPCODE(d3,«
	move.b	eaf,d1
	FETCHBI	d0
	jsr	port_out
	»)
				|nok

OP_DD(d3,«»)
OP_CB(d3,«»)
OP_DDCB(d3,«»)
OP_FD(d3,«»)
OP_FDCB(d3,«»)
OP_ED(d3,«»)

	|| CALL	NC,immed.w
OPCODE(d4,«
	jsr	f_norm_c
	beq	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OP_DD(d4,«»)
OP_CB(d4,«»)
OP_DDCB(d4,«»)
OP_FD(d4,«»)
OP_FDCB(d4,«»)
OP_ED(d4,«»)

	|| PUSH	DE
OPCODE(d5,«
	PUSHW	ede
	»)
				|nok

OP_DD(d5,«»)
OP_CB(d5,«»)
OP_DDCB(d5,«»)
OP_FD(d5,«»)
OP_FDCB(d5,«»)
OP_ED(d5,«»)

	|| SUB	A,immed.b
OPCODE(d6,«
	FETCHBI	d1
	F_SUB_B	eaf,d1
	»)
				|nok

OP_DD(d6,«»)
OP_CB(d6,«»)
OP_DDCB(d6,«»)
OP_FD(d6,«»)
OP_FDCB(d6,«»)
OP_ED(d6,«»)

	|| RST	&10
	||  == CALL 10
OPCODE(d7,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$10,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(d7,«»)
OP_CB(d7,«»)
OP_DDCB(d7,«»)
OP_FD(d7,«»)
OP_FDCB(d7,«»)
OP_ED(d7,«»)

	|| RET	C
OPCODE(d8,«
	jsr	f_norm_c
	bne	emu_op_c9
	»)
				|nok

OP_DD(d8,«»)
OP_CB(d8,«»)
OP_DDCB(d8,«»)
OP_FD(d8,«»)
OP_FDCB(d8,«»)
OP_ED(d8,«»)

	|| EXX
OPCODE(d9,«
	swap	ebc
	swap	ede
	swap	ehl
	»)
				|nok

OP_DD(d9,«»)
OP_CB(d9,«»)
OP_DDCB(d9,«»)
OP_FD(d9,«»)
OP_FDCB(d9,«»)
OP_ED(d9,«»)

	|| JP	C,immed.w
OPCODE(da,«
	jsr	f_norm_c
	bne	emu_op_c3
	»)
				|nok

OP_DD(da,«»)
OP_CB(da,«»)
OP_DDCB(da,«»)
OP_FD(da,«»)
OP_FDCB(da,«»)
OP_ED(da,«»)

	|| IN	A,immed.b
OPCODE(db,«
	move.b	eaf,d1
	FETCHBI	d0
	jsr	port_in
	»)
				|nok

OP_DD(db,«»)
OP_CB(db,«»)
OP_DDCB(db,«»)
OP_FD(db,«»)
OP_FDCB(db,«»)
OP_ED(db,«»)

	|| CALL	C,immed.w
OPCODE(dc,«
	jsr	f_norm_c
	bne	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OPCODE(dd,«			| prefix
	movea.w		emu_op_undo_dd(pc),a2
	»)

OP_DD(dc,«»)
OP_CB(dc,«»)
OP_DDCB(dc,«»)
OP_FD(dc,«»)
OP_FDCB(dc,«»)
OP_ED(dc,«»)

	|| SBC	A,immed.b
OPCODE(de,«
	FETCHWI	d1
	F_SBC_B	d1,eaf
	»)
				|nok

OP_DD(dd,«»)
OP_CB(dd,«»)
OP_DDCB(dd,«»)
OP_FD(dd,«»)
OP_FDCB(dd,«»)
OP_ED(dd,«»)

	|| RST	&18
	||  == CALL 18
OPCODE(df,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$18,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(de,«»)
OP_CB(de,«»)
OP_DDCB(de,«»)
OP_FD(de,«»)
OP_FDCB(de,«»)
OP_ED(de,«»)

	|| RET	PO
	|| If parity odd (P zero), return
OPCODE(e0,«
	jsr	f_norm_pv
	beq	emu_op_c9
	»)
				|nok

OP_DD(df,«»)
OP_CB(df,«»)
OP_DDCB(df,«»)
OP_FD(df,«»)
OP_FDCB(df,«»)
OP_ED(df,«»)

	|| POP	HL
OPCODE(e1,«
	POPW	ehl
	»)
				|nok

OP_DD(e0,«»)
OP_CB(e0,«»)
OP_DDCB(e0,«»)
OP_FD(e0,«»)
OP_FDCB(e0,«»)
OP_ED(e0,«»)

	|| JP	PO,immed.w
OPCODE(e2,«
	jsr	f_norm_pv
	beq	emu_op_c3
	add.l	#2,epc
	»)
				|nok

OP_DD(e1,«»)
OP_CB(e1,«»)
OP_DDCB(e1,«»)
OP_FD(e1,«»)
OP_FDCB(e1,«»)
OP_ED(e1,«»)

	|| EX	(SP),HL
	|| Exchange
OPCODE(e3,«
	POPW	d1
	PUSHW	ehl
	move.w	d1,ehl
	»)
				|nok

OP_DD(e2,«»)
OP_CB(e2,«»)
OP_DDCB(e2,«»)
OP_FD(e2,«»)
OP_FDCB(e2,«»)
OP_ED(e2,«»)

	|| CALL	PO,immed.w
	|| if parity odd (P=0), call
OPCODE(e4,«
	jsr	f_norm_pv
	beq	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OP_DD(e3,«»)
OP_CB(e3,«»)
OP_DDCB(e3,«»)
OP_FD(e3,«»)
OP_FDCB(e3,«»)
OP_ED(e3,«»)

	|| PUSH	HL
OPCODE(e5,«
	PUSHW	ehl
	»)
				|nok

OP_DD(e4,«»)
OP_CB(e4,«»)
OP_DDCB(e4,«»)
OP_FD(e4,«»)
OP_FDCB(e4,«»)
OP_ED(e4,«»)

	|| AND	immed.b
OPCODE(e6,«
	FETCHBI	d1
	F_AND_B	d1,eaf
	»)
				|nok

OP_DD(e5,«»)
OP_CB(e5,«»)
OP_DDCB(e5,«»)
OP_FD(e5,«»)
OP_FDCB(e5,«»)
OP_ED(e5,«»)

	|| RST	&20
	||  == CALL 20
OPCODE(e7,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$20,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(e6,«»)
OP_CB(e6,«»)
OP_DDCB(e6,«»)
OP_FD(e6,«»)
OP_FDCB(e6,«»)
OP_ED(e6,«»)

	|| RET	PE
	|| If parity odd (P zero), return
OPCODE(e8,«
	jsr	f_norm_pv
	bne	emu_op_c9
	»)
				|nok

OP_DD(e7,«»)
OP_CB(e7,«»)
OP_DDCB(e7,«»)
OP_FD(e7,«»)
OP_FDCB(e7,«»)
OP_ED(e7,«»)

	|| JP	(HL)
OPCODE(e9,«
	FETCHB	ehl,d1
	jsr	deref
	movea.l	a0,epc
	»)
				|nok

OP_DD(e8,«»)
OP_CB(e8,«»)
OP_DDCB(e8,«»)
OP_FD(e8,«»)
OP_FDCB(e8,«»)
OP_ED(e8,«»)

	|| JP	PE,immed.w
OPCODE(ea,«
	jsr	f_norm_pv
	bne	emu_op_c3
	add.l	#2,epc
	»)
				|nok

OP_DD(e9,«»)
OP_CB(e9,«»)
OP_DDCB(e9,«»)
OP_FD(e9,«»)
OP_FDCB(e9,«»)
OP_ED(e9,«»)

	|| EX	DE,HL
OPCODE(eb,«
	exg.w	ede,ehl
	»)
				|nok

OP_DD(ea,«»)
OP_CB(ea,«»)
OP_DDCB(ea,«»)
OP_FD(ea,«»)
OP_FDCB(ea,«»)
OP_ED(ea,«»)

	|| CALL	PE,immed.w
	|| If parity even (P=1), call
OPCODE(ec,«
	jsr	f_norm_c
	bne	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OP_DD(eb,«»)
OP_CB(eb,«»)
OP_DDCB(eb,«»)
OP_FD(eb,«»)
OP_FDCB(eb,«»)
OP_ED(eb,«»)

	|| XXX this probably ought to hold interrupts too
OPCODE(ed,«			| prefix
	movea.w	emu_op_undo_ed(pc),a2
	»)
				|nok

OP_DD(ec,«»)
OP_CB(ec,«»)
OP_DDCB(ec,«»)
OP_FD(ec,«»)
OP_FDCB(ec,«»)
OP_ED(ec,«»)

	|| XOR	immed.b
OPCODE(ee,«
	FETCHBI	d1
	F_XOR_B	d1,eaf
	»)
				|nok

OP_DD(ed,«»)
OP_CB(ed,«»)
OP_DDCB(ed,«»)
OP_FD(ed,«»)
OP_FDCB(ed,«»)
OP_ED(ed,«»)

	|| RST	&28
	||  == CALL 28
OPCODE(ef,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$28,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(ee,«»)
OP_CB(ee,«»)
OP_DDCB(ee,«»)
OP_FD(ee,«»)
OP_FDCB(ee,«»)
OP_ED(ee,«»)

	|| RET	P
	|| Return if Positive
OPCODE(f0,«
	jsr	f_norm_sign
	beq	emu_op_c9	| RET
	»)
				|nok

OP_DD(ef,«»)
OP_CB(ef,«»)
OP_DDCB(ef,«»)
OP_FD(ef,«»)
OP_FDCB(ef,«»)
OP_ED(ef,«»)

	|| POP	AF
	|| SPEED this can be made faster ...
	|| XXX AF
OPCODE(f1,«
	POPW	eaf
	move.w	eaf,(flag_byte-flag_storage)(a3)
	move.b	#$ff,(flag_valid-flag_storage)(a3)
	»)
				|nok

OP_DD(f0,«»)
OP_CB(f0,«»)
OP_DDCB(f0,«»)
OP_FD(f0,«»)
OP_FDCB(f0,«»)
OP_ED(f0,«»)

	|| JP	P,immed.w
OPCODE(f2,«
	jsr	f_norm_sign
	beq	emu_op_c3	| JP
	add.l	#2,epc
	»)
				|nok

OPCODE(f3,«
OP_DD(f1,«»)
OP_CB(f1,«»)
OP_DDCB(f1,«»)
OP_FD(f1,«»)
OP_FDCB(f1,«»)
OP_ED(f1,«»)

	|| DI
	jsr	ints_stop
	»)

OP_DD(f2,«»)
OP_CB(f2,«»)
OP_DDCB(f2,«»)
OP_FD(f2,«»)
OP_FDCB(f2,«»)
OP_ED(f2,«»)

	|| CALL	P,&0000
	|| Call if positive (S=0)
OPCODE(f4,«
	jsr	f_norm_sign
	beq	emu_op_cd
	»)
				|nok

OP_DD(f3,«»)
OP_CB(f3,«»)
OP_DDCB(f3,«»)
OP_FD(f3,«»)
OP_FDCB(f3,«»)
OP_ED(f3,«»)

	|| PUSH	AF
OPCODE(f5,«
	jsr	flags_normalize
	LOHI	eaf
	move.b	(flag_byte),eaf
	|| XXX wrong, af is not normalized by flags_normalize?
	HILO	eaf
	PUSHW	eaf
	»)
				|nok

OP_DD(f5,«»)
OP_CB(f5,«»)
OP_DDCB(f5,«»)
OP_FD(f5,«»)
OP_FDCB(f5,«»)
OP_ED(f5,«»)

	|| OR	immed.b
OPCODE(f6,«
	FETCHBI	d1
	F_OR_B	d1,eaf
	»)
				|nok

OP_DD(f6,«»)
OP_CB(f6,«»)
OP_DDCB(f6,«»)
OP_FD(f6,«»)
OP_FDCB(f6,«»)
OP_ED(f6,«»)

	|| RST	&30
	||  == CALL 30
OPCODE(f7,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$30,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(f7,«»)
OP_CB(f7,«»)
OP_DDCB(f7,«»)
OP_FD(f7,«»)
OP_FDCB(f7,«»)
OP_ED(f7,«»)

	|| RET	M
	|| Return if Sign == 1, minus
OPCODE(f8,«
	jsr	f_norm_sign
	bne	emu_op_c9	| RET
	»)
				|nok

OP_DD(f8,«»)
OP_CB(f8,«»)
OP_DDCB(f8,«»)
OP_FD(f8,«»)
OP_FDCB(f8,«»)
OP_ED(f8,«»)

	|| LD	SP,HL
	|| SP <- HL
OPCODE(f9,«
	move.w	ehl,d1
	jsr	deref
	movea.l	a0,esp
	»)
				|nok

OP_DD(f9,«»)
OP_CB(f9,«»)
OP_DDCB(f9,«»)
OP_FD(f9,«»)
OP_FDCB(f9,«»)
OP_ED(f9,«»)

	|| JP	M,immed.w
OPCODE(fa,«
	jsr	f_norm_sign
	bne	emu_op_c3	| JP
	add.l	#2,epc
	»)
				|nok

OP_DD(fa,«»)
OP_CB(fa,«»)
OP_DDCB(fa,«»)
OP_FD(fa,«»)
OP_FDCB(fa,«»)
OP_ED(fa,«»)

	|| EI
OPCODE(fb,«
	jsr	ints_start
	»)
				|nok

OP_DD(fb,«»)
OP_CB(fb,«»)
OP_DDCB(fb,«»)
OP_FD(fb,«»)
OP_FDCB(fb,«»)
OP_ED(fb,«»)

	|| CALL	M,immed.w
	|| Call if minus (S=1)
OPCODE(fc,«
	jsr	f_norm_sign
	bne	emu_op_cd
	add.l	#2,epc
	»)
				|nok

OP_DD(fc,«»)
OP_CB(fc,«»)
OP_DDCB(fc,«»)
OP_FD(fc,«»)
OP_FDCB(fc,«»)
OP_ED(fc,«»)

	|| swap IY, HL
OPCODE(fd,«			| prefix
	movea.w	emu_op_undo_fd(pc),a2
	»)

OP_DD(fd,«»)
OP_CB(fd,«»)
OP_DDCB(fd,«»)
OP_FD(fd,«»)
OP_FDCB(fd,«»)
OP_ED(fd,«»)

	|| CP	immed.b
OPCODE(fe,«
	FETCHBI	d1
	F_CP_B	d1,eaf
	»)
				|nok

OP_DD(fe,«»)
OP_CB(fe,«»)
OP_DDCB(fe,«»)
OP_FD(fe,«»)
OP_FDCB(fe,«»)
OP_ED(fe,«»)

	|| RST	&38
	||  == CALL 38
OPCODE(ff,«
	move.l	epc,a0
	jsr	underef
	PUSHW	d0
	move.w	#$38,d0
	jsr	deref
	move.l	a0,epc
	»)
				|nok

OP_DD(ff,«»)
OP_CB(ff,«»)
OP_DDCB(ff,«»)
OP_FD(ff,«»)
OP_FDCB(ff,«»)
OP_ED(ff,«»)