Added disassembler

5 files changed, 2444 insertions, 18 deletions

diff --git a/Makefile b/Makefile
index 961b9f5..12c228f 100644
--- a/Makefile
+++ b/Makefile
@@ -18,7 +18,7 @@
 # 
 # -------------------------------------------------------------------------
 # 
-# $Id: Makefile,v 1.2 2006-08-20 22:31:42 ianc Exp $
+# $Id: Makefile,v 1.3 2006-08-21 00:01:01 ianc Exp $
 # 
 
 # This CFLAGS assumes that gcc is being used.
@@ -27,14 +27,21 @@
 #
 CFLAGS	=	-Wall -Werror -pedantic -ansi -O2 -finline-functions
 
+# Remove this to disable the disassembler (saving some memory)
+#
+CFLAGS	+=	-DENABLE_DISASSEM
+
+
 TARGET	=	emma
 
 SOURCE	=	z80.c \
-		z80_decode \
+		z80_decode.c \
+		z80_dis.c \
 		emma.c
 
 OBJECTS	=	z80.o \
 		z80_decode.o \
+		z80_dis.o \
 		emma.o 
 
 all: $(TARGET) emucpm.hex
@@ -54,13 +61,12 @@ depend:
 
 # DO NOT DELETE THIS LINE -- make depend depends on it
 
-z80.o: /usr/include/stddef.h /usr/include/sys/cdefs.h
+z80.o: /usr/include/stdlib.h /usr/include/sys/cdefs.h
 z80.o: /usr/include/sys/_null.h /usr/include/sys/_types.h
-z80.o: /usr/include/machine/_types.h /usr/include/stdlib.h
-z80.o: /usr/include/stdio.h /usr/include/string.h /usr/include/strings.h
-z80.o: /usr/include/ctype.h /usr/include/_ctype.h /usr/include/runetype.h
-z80.o: /usr/include/limits.h /usr/include/sys/limits.h
-z80.o: /usr/include/machine/_limits.h /usr/include/sys/syslimits.h z80.h
+z80.o: /usr/include/machine/_types.h z80.h z80_private.h
+z80_decode.o: /usr/include/stdlib.h /usr/include/sys/cdefs.h
+z80_decode.o: /usr/include/sys/_null.h /usr/include/sys/_types.h
+z80_decode.o: /usr/include/machine/_types.h z80.h z80_private.h
 emma.o: /usr/include/stdlib.h /usr/include/sys/cdefs.h
 emma.o: /usr/include/sys/_null.h /usr/include/sys/_types.h
 emma.o: /usr/include/machine/_types.h /usr/include/stdio.h
diff --git a/z80.c b/z80.c
index 11e466b..0b74bf5 100644
--- a/z80.c
+++ b/z80.c
@@ -29,6 +29,7 @@
 
 */
 #include <stdlib.h>
+#include <string.h>
 
 #include "z80.h"
 #include "z80_private.h"
@@ -310,13 +311,32 @@ Z80Val Z80Cycles(Z80 *cpu)
 }
 
 
-const char *Z80Disassemble(Z80 *cpu, Z80Word *addr)
+const char *Z80Disassemble(Z80 *cpu, Z80Word *pc)
 {
-#ifdef Z80_DISASSEMBLER_ENABLED
-    (*addr)+=4;
-    return "NO DISASSEMBLER";
+#ifdef ENABLE_DISASSEM
+    static char s[80];
+    Z80Word opc,npc;
+    Z80Byte op;
+    int f;
+
+    opc=*pc;
+    op=Z80_Dis_FetchByte(cpu,pc);
+    dis_opcode_z80[op](cpu,op,pc);
+    npc=*pc;
+
+    strcpy(s,Z80_Dis_Printf("%-5s",Z80_Dis_GetOp()));
+    strcat(s,Z80_Dis_Printf("%-40s ;",Z80_Dis_GetArg()));
+
+    for(f=0;f<5 && opc!=npc;f++)
+	strcat(s,Z80_Dis_Printf(" %.2x",(int)cpu->memory[opc++]));
+
+    if (opc!=npc)
+	for(f=1;f<3;f++)
+	    s[strlen(s)-f]='.';
+
+    return s;
 #else
-    (*addr)+=4;
+    (*pc)+=4;
     return "NO DISASSEMBLER";
 #endif
 }
diff --git a/z80.h b/z80.h
index 745ee48..05557f4 100644
--- a/z80.h
+++ b/z80.h
@@ -33,10 +33,6 @@
 /* ---------------------------------------- TYPES
 */
 
-/* Remove this to disable the disassembler (saving some memory)
-*/
-#define Z80_DISASSEMBLER_ENABLED
-
 /* The processor
 */
 struct Z80;
diff --git a/z80_dis.c b/z80_dis.c
new file mode 100644
index 0000000..79bcd14
--- /dev/null
+++ b/z80_dis.c
@@ -0,0 +1,2381 @@
+/*
+
+    z80 - Z80 Emulator
+
+    Copyright (C) 2006  Ian Cowburn <ianc@noddybox.co.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    -------------------------------------------------------------------------
+
+    $Id$
+
+*/
+static const char ident[]="$Id$";
+
+#ifdef ENABLE_DISASSEM
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "z80.h"
+#include "z80_private.h"
+
+
+static Z80Relative	cb_off;
+
+/* ---------------------------------------- SHARED ROUTINES
+*/
+static const char *z80_dis_reg8[]={"b","c","d","e","h","l","(hl)","a"};
+static const char *z80_dis_reg16[]={"bc","de","hl","sp"};
+static const char *z80_dis_condition[]={"nz","z","nc","c","po","pe","p","m"};
+
+static const char *dis_op;
+static const char *dis_arg;
+
+const char *Z80_Dis_Printf(const char *format, ...)
+{
+    static int p=0;
+    static char s[16][80];
+    va_list arg;
+
+    va_start(arg,format);
+    p=(p+1)%16;
+    vsprintf(s[p],format,arg);
+    va_end(arg);
+
+    return s[p];
+}
+
+
+Z80Byte Z80_Dis_FetchByte(Z80 *cpu, Z80Word *pc)
+{
+    return cpu->memory[(*pc)++];
+}
+
+
+Z80Word Z80_Dis_FetchWord(Z80 *cpu, Z80Word *pc)
+{
+    Z80Byte l,h;
+
+    l=Z80_Dis_FetchByte(cpu,pc);
+    h=Z80_Dis_FetchByte(cpu,pc);
+
+    return ((Z80Word)h<<8)|l;
+}
+
+
+void Z80_Dis_Set(const char *op, const char *arg)
+{
+    dis_op=op;
+    dis_arg=arg;
+}
+
+
+const char *Z80_Dis_GetOp(void)
+{
+    return dis_op ? dis_op : "";
+}
+
+
+const char *Z80_Dis_GetArg(void)
+{
+    return dis_arg ? dis_arg : "";
+}
+
+
+
+/* ---------------------------------------- CB xx BYTE OPCODES
+*/
+static void DIS_RLC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("rlc",reg);
+}
+
+static void DIS_RRC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("rrc",reg);
+}
+
+static void DIS_RL_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("rl",reg);
+}
+
+static void DIS_RR_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("rr",reg);
+}
+
+static void DIS_SLA_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("sla",reg);
+}
+
+static void DIS_SRA_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("sra",reg);
+}
+
+static void DIS_SLL_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("sll",reg);
+}
+
+static void DIS_SRL_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("srl",reg);
+}
+
+static void DIS_BIT_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+    int bit;
+
+    reg=z80_dis_reg8[op%8];
+    bit=(op-0x40)/8;
+    Z80_Dis_Set("bit",Z80_Dis_Printf("%d,%s",bit,reg));
+}
+
+static void DIS_RES_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+    int bit;
+
+    reg=z80_dis_reg8[op%8];
+    bit=(op-0x80)/8;
+    Z80_Dis_Set("res",Z80_Dis_Printf("%d,%s",bit,reg));
+}
+
+static void DIS_SET_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+    int bit;
+
+    reg=z80_dis_reg8[op%8];
+    bit=(op-0xc0)/8;
+    Z80_Dis_Set("set",Z80_Dis_Printf("%d,%s",bit,reg));
+}
+
+/* ---------------------------------------- DD OPCODES
+*/
+
+static const char *IX_RelStr(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    static char s[80];
+    Z80Relative r;
+
+    r=(Z80Relative)Z80_Dis_FetchByte(z80,pc);
+
+    if (r<0)
+	sprintf(s,"(ix-$%.2x)",-r);
+    else
+	sprintf(s,"(ix+$%.2x)",r);
+
+    return(s);
+}
+
+
+static const char *IX_RelStrCB(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    static char s[80];
+    Z80Relative r;
+
+    r=(Z80Relative)cb_off;
+
+    if (r<0)
+	sprintf(s,"(ix-$%.2x)",-r);
+    else
+	sprintf(s,"(ix+$%.2x)",r);
+
+    return(s);
+}
+
+
+static const char *XR8(Z80 *z80, int reg, Z80Word *pc)
+{
+    switch(reg)
+    	{
+	case 0:
+	    return("b");
+	    break;
+	case 1:
+	    return("c");
+	    break;
+	case 2:
+	    return("d");
+	    break;
+	case 3:
+	    return("e");
+	    break;
+	case 4:
+	    return("ixh");
+	    break;
+	case 5:
+	    return("ixl");
+	    break;
+	case 6:
+	    return(IX_RelStr(z80,0,pc));
+	    break;
+	case 7:
+	    return("a");
+	    break;
+	default:
+	    return(Z80_Dis_Printf("BUG %d",reg));
+	    break;
+	}
+}
+
+static void DIS_DD_NOP(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    dis_opcode_z80[op](z80,op,pc);
+}
+
+static void DIS_ADD_IX_BC(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","ix,bc");
+}
+ 
+static void DIS_ADD_IX_DE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","ix,de");
+}
+
+static void DIS_LD_IX_WORD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("ix,$%.4x",Z80_Dis_FetchWord(z80,pc)));
+}
+
+static void DIS_LD_ADDR_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+
+    Z80_Dis_Set("ld",Z80_Dis_Printf("($%.4x),ix",w));
+}
+
+static void DIS_INC_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","ix");
+}
+
+static void DIS_INC_IXH(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","ixh");
+}
+
+static void DIS_DEC_IXH(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","ixh");
+}
+
+static void DIS_LD_IXH_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("ixh,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_ADD_IX_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","ix,ix");
+}
+
+static void DIS_LD_IX_ADDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("ix,($%.4x)",w));
+}
+
+static void DIS_DEC_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","ix");
+}
+
+static void DIS_INC_IXL(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","ixl");
+}
+
+static void DIS_DEC_IXL(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","ixl");
+}
+
+static void DIS_LD_IXL_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("ixl,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+ 
+static void DIS_INC_IIX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc",Z80_Dis_Printf("%s",IX_RelStr(z80,op,pc)));
+}
+
+static void DIS_DEC_IIX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec",Z80_Dis_Printf("%s",IX_RelStr(z80,op,pc)));
+}
+
+static void DIS_LD_IIX_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *rel;
+    int b;
+
+    rel=IX_RelStr(z80,op,pc);
+    b=Z80_Dis_FetchByte(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,$%.2x",rel,b));
+}
+
+
+static void DIS_ADD_IX_SP(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","ix,sp");
+}
+ 
+static void DIS_XLD_R8_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int src_r,dest_r;
+    const char *src,*dest;
+
+    dest_r=(op-0x40)/8;
+    src_r=op%8;
+
+    /* IX can't be used as source and destination when reading z80ory
+    */
+    if (dest_r==6)
+    	{
+	dest=XR8(z80,dest_r,pc);
+	src=z80_dis_reg8[src_r];
+	}
+    else if (((dest_r==4)||(dest_r==5))&&(src_r==6))
+    	{
+	dest=z80_dis_reg8[dest_r];
+	src=XR8(z80,src_r,pc);
+	}
+    else
+	{
+	dest=XR8(z80,dest_r,pc);
+	src=XR8(z80,src_r,pc);
+	}
+
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,%s",dest,src));
+}
+
+static void DIS_XADD_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add",Z80_Dis_Printf("a,%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XADC_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("adc",Z80_Dis_Printf("a,%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XSUB_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sub",Z80_Dis_Printf("a,%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XSBC_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sbc",Z80_Dis_Printf("a,%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XAND_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("and",Z80_Dis_Printf("%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XXOR_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("xor",Z80_Dis_Printf("%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_X_OR_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("or",Z80_Dis_Printf("%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_XCP_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cp",Z80_Dis_Printf("%s",XR8(z80,(op%8),pc)));
+}
+
+static void DIS_POP_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("pop","ix");
+}
+
+static void DIS_EX_ISP_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ex","(sp),ix");
+}
+
+static void DIS_PUSH_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("push","ix");
+}
+
+static void DIS_JP_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("jp","(ix)");
+}
+ 
+static void DIS_LD_SP_IX(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","sp,ix");
+}
+
+static void DIS_DD_CB_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    cb_off=(Z80Relative)Z80_Dis_FetchByte(z80,pc);
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_DD_CB_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_DD_DD_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_DD_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_DD_ED_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_ED_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_DD_FD_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_FD_opcode[nop](z80,nop,pc);
+}
+
+
+/* ---------------------------------------- DD CB OPCODES
+*/
+
+static void DIS_RLC_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rlc",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+	{
+        Z80_Dis_Set("rlc",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+	}
+}
+
+static void DIS_RRC_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rrc",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rrc",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RL_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rl",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rl",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RR_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rr",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rr",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SLA_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sla",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sla",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SRA_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sra",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sra",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SRL_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("srl",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("srl",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SLL_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sll",Z80_Dis_Printf("%s",IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sll",Z80_Dis_Printf("%s[%s]",IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_BIT_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0x40)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("bit",Z80_Dis_Printf("%d,%s",bit,IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("bit",Z80_Dis_Printf("%d,%s[%s]",bit,IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RES_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0x80)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("res",Z80_Dis_Printf("%d,%s",bit,IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("res",Z80_Dis_Printf("%d,%s[%s]",bit,IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SET_IX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0xc0)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("set",Z80_Dis_Printf("%d,%s",bit,IX_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("set",Z80_Dis_Printf("%d,%s[%s]",bit,IX_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+
+/* ---------------------------------------- ED OPCODES
+*/
+
+static const char *ER8(int reg)
+{
+    switch(reg)
+    	{
+	case 0:
+	    return("b");
+	    break;
+	case 1:
+	    return("c");
+	    break;
+	case 2:
+	    return("d");
+	    break;
+	case 3:
+	    return("e");
+	    break;
+	case 4:
+	    return("h");
+	    break;
+	case 5:
+	    return("l");
+	    break;
+	case 6:
+	    return("0");
+	    break;
+	case 7:
+	    return("a");
+	    break;
+	}
+
+    return "?";
+}
+
+/* Assumes illegal ED ops are being used for break points
+*/
+static void DIS_ED_NOP(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("brk",Z80_Dis_Printf("$%.2x",op));
+}
+
+static void DIS_IN_R8_C(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("in",Z80_Dis_Printf("%s,(c)",ER8((op-0x40)/8)));
+}
+
+static void DIS_OUT_C_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("out",Z80_Dis_Printf("(c),%s",ER8((op-0x40)/8)));
+}
+
+static void DIS_SBC_HL_R16(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sbc",Z80_Dis_Printf("hl,%s",z80_dis_reg16[(op-0x40)/16]));
+}
+
+static void DIS_ED_LD_ADDR_R16(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("($%.4x),%s",w,z80_dis_reg16[(op-0x40)/16]));
+}
+
+static void DIS_NEG(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("neg",NULL);
+}
+
+static void DIS_RETN(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("retn",NULL);
+}
+
+static void DIS_IM_0(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("im","0");
+}
+
+static void DIS_LD_I_A(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","i,a");
+}
+
+static void DIS_ADC_HL_R16(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("adc",Z80_Dis_Printf("hl,%s",z80_dis_reg16[(op-0x40)/16]));
+}
+
+static void DIS_ED_LD_R16_ADDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,($%.4x)",z80_dis_reg16[(op-0x40)/16],w));
+}
+
+static void DIS_RETI(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("reti",NULL);
+}
+
+static void DIS_LD_R_A(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","r,a");
+}
+
+static void DIS_IM_1(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("im","1");
+}
+
+static void DIS_LD_A_I(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","a,i");
+}
+
+static void DIS_IM_2(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("im","2");
+}
+
+static void DIS_LD_A_R(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","a,r");
+}
+
+static void DIS_RRD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rrd",NULL);
+}
+
+static void DIS_RLD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rld",NULL);
+}
+
+static void DIS_LDI(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ldi",NULL);
+}
+
+static void DIS_CPI(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cpi",NULL);
+}
+
+static void DIS_INI(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ini",NULL);
+}
+
+static void DIS_OUTI(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("outi",NULL);
+}
+
+static void DIS_LDD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ldd",NULL);
+}
+
+static void DIS_CPD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cpd",NULL);
+}
+
+static void DIS_IND(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ind",NULL);
+}
+
+static void DIS_OUTD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("outd",NULL);
+}
+
+static void DIS_LDIR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ldir",NULL);
+}
+
+static void DIS_CPIR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cpir",NULL);
+}
+
+static void DIS_INIR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inir",NULL);
+}
+
+static void DIS_OTIR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("otir",NULL);
+}
+
+static void DIS_LDDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("lddr",NULL);
+}
+
+static void DIS_CPDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cpdr",NULL);
+}
+
+static void DIS_INDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("indr",NULL);
+}
+
+static void DIS_OTDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("otdr",NULL);
+}
+
+
+/* ---------------------------------------- FD OPCODES
+*/
+
+static const char *IY_RelStr(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    static char s[80];
+    Z80Relative r;
+
+    r=(Z80Relative)Z80_Dis_FetchByte(z80,pc);
+
+    if (r<0)
+	sprintf(s,"(iy-$%.2x)",-r);
+    else
+	sprintf(s,"(iy+$%.2x)",r);
+
+    return(s);
+}
+
+
+static const char *IY_RelStrCB(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    static char s[80];
+    Z80Relative r;
+
+    r=(Z80Relative)cb_off;
+
+    if (r<0)
+	sprintf(s,"(iy-$%.2x)",-r);
+    else
+	sprintf(s,"(iy+$%.2x)",r);
+
+    return(s);
+}
+
+
+static const char *YR8(Z80 *z80, int reg, Z80Word *pc)
+{
+    switch(reg)
+    	{
+	case 0:
+	    return("b");
+	    break;
+	case 1:
+	    return("c");
+	    break;
+	case 2:
+	    return("d");
+	    break;
+	case 3:
+	    return("e");
+	    break;
+	case 4:
+	    return("iyh");
+	    break;
+	case 5:
+	    return("iyl");
+	    break;
+	case 6:
+	    return(IY_RelStr(z80,0,pc));
+	    break;
+	case 7:
+	    return("a");
+	    break;
+	default:
+	    return(Z80_Dis_Printf("BUG %d",reg));
+	    break;
+	}
+}
+
+static void DIS_FD_NOP(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    dis_opcode_z80[op](z80,op,pc);
+}
+
+static void DIS_ADD_IY_BC(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","iy,bc");
+}
+ 
+static void DIS_ADD_IY_DE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","iy,de");
+}
+
+static void DIS_LD_IY_WORD(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("iy,$%.4x",Z80_Dis_FetchWord(z80,pc)));
+}
+
+static void DIS_LD_ADDR_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("($%.4x),iy",w));
+}
+
+static void DIS_INC_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","iy");
+}
+
+static void DIS_INC_IYH(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","iyh");
+}
+
+static void DIS_DEC_IYH(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","iyh");
+}
+
+static void DIS_LD_IYH_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("iyh,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_ADD_IY_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","iy,iy");
+}
+
+static void DIS_LD_IY_ADDR(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("iy,($%.4x)",w));
+}
+
+static void DIS_DEC_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","iy");
+}
+
+static void DIS_INC_IYL(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc","iyl");
+}
+
+static void DIS_DEC_IYL(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec","iyl");
+}
+
+static void DIS_LD_IYL_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld",Z80_Dis_Printf("iyl,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+ 
+static void DIS_INC_IIY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("inc",Z80_Dis_Printf("%s",IY_RelStr(z80,op,pc)));
+}
+
+static void DIS_DEC_IIY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("dec",Z80_Dis_Printf("%s",IY_RelStr(z80,op,pc)));
+}
+
+static void DIS_LD_IIY_BYTE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *rel;
+    int b;
+
+    rel=IY_RelStr(z80,op,pc);
+    b=Z80_Dis_FetchByte(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,$%.2x",rel,b));
+}
+
+
+static void DIS_ADD_IY_SP(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add","iy,sp");
+}
+ 
+static void DIS_YLD_R8_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int src_r,dest_r;
+    const char *src,*dest;
+
+    dest_r=(op-0x40)/8;
+    src_r=op%8;
+
+    /* IY can't be used as source and destination when reading z80ory
+    */
+    if (dest_r==6)
+	{
+	dest=YR8(z80,dest_r,pc);
+	src=z80_dis_reg8[src_r];
+	}
+    else if (((dest_r==4)||(dest_r==5))&&(src_r==6))
+	{
+	dest=z80_dis_reg8[dest_r];
+	src=YR8(z80,src_r,pc);
+	}
+    else
+	{
+	dest=YR8(z80,dest_r,pc);
+	src=YR8(z80,src_r,pc);
+	}
+
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,%s",dest,src));
+}
+
+static void DIS_YADD_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add",Z80_Dis_Printf("a,%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YADC_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("adc",Z80_Dis_Printf("a,%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YSUB_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sub",Z80_Dis_Printf("a,%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YSBC_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sbc",Z80_Dis_Printf("a,%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YAND_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("and",Z80_Dis_Printf("%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YYOR_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("xor",Z80_Dis_Printf("%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_Y_OR_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("or",Z80_Dis_Printf("%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_YCP_R8(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cp",Z80_Dis_Printf("%s",YR8(z80,(op%8),pc)));
+}
+
+static void DIS_POP_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("pop","iy");
+}
+
+static void DIS_EY_ISP_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ex","(sp),iy");
+}
+
+static void DIS_PUSH_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("push","iy");
+}
+
+static void DIS_JP_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("jp","(iy)");
+}
+ 
+static void DIS_LD_SP_IY(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","sp,iy");
+}
+
+static void DIS_FD_CB_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    cb_off=(Z80Relative)Z80_Dis_FetchByte(z80,pc);
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_FD_CB_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_FD_DD_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_DD_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_FD_ED_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_ED_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_FD_FD_DECODE(Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_FD_opcode[nop](z80,nop,pc);
+}
+
+
+/* ---------------------------------------- FD CB OPCODES
+*/
+
+static void DIS_RLC_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rlc",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rlc",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RRC_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rrc",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rrc",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RL_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rl",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rl",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RR_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("rr",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("rr",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SLA_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sla",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sla",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SRA_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sra",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sra",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SRL_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("srl",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("srl",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SLL_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+
+    reg=(op%8);
+
+    if (reg==6)
+        Z80_Dis_Set("sll",Z80_Dis_Printf("%s",IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("sll",Z80_Dis_Printf("%s[%s]",IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_BIT_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0x40)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("bit",Z80_Dis_Printf("%d,%s",bit,IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("bit",Z80_Dis_Printf("%d,%s[%s]",bit,IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_RES_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0x80)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("res",Z80_Dis_Printf("%d,%s",bit,IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("res",Z80_Dis_Printf("%d,%s[%s]",bit,IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+static void DIS_SET_IY (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int reg;
+    int bit;
+
+    reg=(op%8);
+    bit=(op-0xc0)/8;
+
+    if (reg==6)
+        Z80_Dis_Set("set",Z80_Dis_Printf("%d,%s",bit,IY_RelStrCB(z80,op,pc)));
+    else
+        Z80_Dis_Set("set",Z80_Dis_Printf("%d,%s[%s]",bit,IY_RelStrCB(z80,op,pc),z80_dis_reg8[reg]));
+}
+
+
+/* ---------------------------------------- SINGLE BYTE OPCODES
+*/
+static void DIS_NOP (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("nop",NULL);
+}
+
+static void DIS_LD_R16_WORD (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,$%.4x",reg,Z80_Dis_FetchWord(z80,pc)));
+}
+
+static void DIS_LD_R16_A (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("ld",Z80_Dis_Printf("(%s),a",reg));
+}
+
+static void DIS_INC_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("inc",reg);
+}
+
+static void DIS_INC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[(op&0x38)/0x8];
+    Z80_Dis_Set("inc",reg);
+}
+
+static void DIS_DEC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[(op&0x38)/0x8];
+    Z80_Dis_Set("dec",reg);
+}
+
+static void DIS_LD_R8_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[(op&0x38)/0x8];
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,$%.2x",reg,Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_RLCA (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rlca",NULL);
+}
+
+static void DIS_EX_AF_AF (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ex","af,af'");
+}
+
+static void DIS_ADD_HL_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("add",Z80_Dis_Printf("hl,%s",reg));
+}
+
+static void DIS_LD_A_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("ld",Z80_Dis_Printf("a,(%s)",reg));
+}
+
+static void DIS_DEC_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op&0x30)/0x10];
+    Z80_Dis_Set("dec",reg);
+}
+
+static void DIS_RRCA (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rrca",NULL);
+}
+
+static void DIS_DJNZ (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word new;
+
+    new=*pc+(Z80Relative)z80->memory[*pc]+1;
+    (*pc)++;
+    Z80_Dis_Set("djnz",Z80_Dis_Printf("$%.4x",new));
+}
+
+static void DIS_RLA (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rla",NULL);
+}
+
+static void DIS_JR (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word new;
+
+    new=*pc+(Z80Relative)z80->memory[*pc]+1;
+    (*pc)++;
+
+    Z80_Dis_Set("jr",Z80_Dis_Printf("$%.4x",new));
+}
+
+static void DIS_RRA (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("rra",NULL);
+}
+
+static void DIS_JR_CO (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *con;
+    Z80Word new;
+
+    con=z80_dis_condition[(op-0x20)/8];
+    new=*pc+(Z80Relative)z80->memory[*pc]+1;
+    (*pc)++;
+
+    Z80_Dis_Set("jr",Z80_Dis_Printf("%s,$%.4x",con,new));
+}
+
+static void DIS_LD_ADDR_HL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("($%.4x),hl",w));
+}
+
+static void DIS_DAA (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("daa",NULL);
+}
+
+static void DIS_LD_HL_ADDR (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("hl,($%.4x)",w));
+}
+
+static void DIS_CPL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cpl",NULL);
+}
+
+static void DIS_LD_ADDR_A (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("($%.4x),a",w));
+}
+
+static void DIS_SCF (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("scf",NULL);
+}
+
+static void DIS_LD_A_ADDR (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("ld",Z80_Dis_Printf("a,($%.4x)",w));
+}
+
+static void DIS_CCF (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ccf",NULL);
+}
+
+static void DIS_LD_R8_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *src,*dest;
+
+    dest=z80_dis_reg8[(op-0x40)/8];
+    src=z80_dis_reg8[op%8];
+    Z80_Dis_Set("ld",Z80_Dis_Printf("%s,%s",dest,src));
+}
+
+static void DIS_HALT (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("halt",NULL);
+}
+
+static void DIS_ADD_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("add",Z80_Dis_Printf("a,%s",reg));
+}
+
+static void DIS_ADC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("adc",Z80_Dis_Printf("a,%s",reg));
+}
+
+static void DIS_SUB_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("sub",Z80_Dis_Printf("a,%s",reg));
+}
+
+static void DIS_SBC_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("sbc",Z80_Dis_Printf("a,%s",reg));
+}
+
+static void DIS_AND_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("and",Z80_Dis_Printf("%s",reg));
+}
+
+static void DIS_XOR_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("xor",Z80_Dis_Printf("%s",reg));
+}
+
+static void DIS_OR_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("or",Z80_Dis_Printf("%s",reg));
+}
+
+static void DIS_CP_R8 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg8[op%8];
+    Z80_Dis_Set("cp",Z80_Dis_Printf("%s",reg));
+}
+
+
+static void DIS_RET_CO (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *con;
+
+    con=z80_dis_condition[(op-0xc0)/8];
+    Z80_Dis_Set("ret",con);
+}
+
+static void DIS_POP_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op-0xc0)/16];
+
+    if (!strcmp(reg,"sp"))
+    	reg="af";
+
+    Z80_Dis_Set("pop",reg);
+}
+
+static void DIS_JP (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("jp",Z80_Dis_Printf("$%.4x",w));
+}
+
+static void DIS_PUSH_R16 (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *reg;
+
+    reg=z80_dis_reg16[(op-0xc0)/16];
+
+    if (!strcmp(reg,"sp"))
+    	reg="af";
+
+    Z80_Dis_Set("push",reg);
+}
+
+static void DIS_ADD_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("add",Z80_Dis_Printf("a,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_RST (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int add;
+
+    add=(op&0x3f)-7;
+    Z80_Dis_Set("rst",Z80_Dis_Printf("%.2xh",add));
+}
+
+static void DIS_RET (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ret",NULL);
+}
+
+static void DIS_JP_CO (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *con;
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    con=z80_dis_condition[(op-0xc0)/8];
+    Z80_Dis_Set("jp",Z80_Dis_Printf("%s,$%.4x",con,w));
+}
+
+static void DIS_CB_DECODE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_CB_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_CALL_CO (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    const char *con;
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    con=z80_dis_condition[(op-0xc0)/8];
+    Z80_Dis_Set("call",Z80_Dis_Printf("%s,$%.4x",con,w));
+}
+
+static void DIS_CALL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80Word w;
+
+    w=Z80_Dis_FetchWord(z80,pc);
+    Z80_Dis_Set("call",Z80_Dis_Printf("$%.4x",w));
+}
+
+static void DIS_ADC_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("adc",Z80_Dis_Printf("a,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_OUT_BYTE_A (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("out",Z80_Dis_Printf("($%.2x),a",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_SUB_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sub",Z80_Dis_Printf("a,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_EXX (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("exx",NULL);
+}
+
+static void DIS_IN_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("in",Z80_Dis_Printf("a,($%.2x)",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_DD_DECODE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_DD_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_SBC_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("sbc",Z80_Dis_Printf("a,$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+
+static void DIS_EX_ISP_HL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ex","(sp),hl");
+}
+
+static void DIS_AND_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("and",Z80_Dis_Printf("$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_JP_HL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("jp","(hl)");
+}
+
+static void DIS_EX_DE_HL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ex","de,hl");
+}
+
+static void DIS_ED_DECODE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_ED_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_XOR_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("xor",Z80_Dis_Printf("$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_DI (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("di",NULL);
+}
+
+static void DIS_OR_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("or",Z80_Dis_Printf("$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+static void DIS_LD_SP_HL (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ld","sp,hl");
+}
+
+static void DIS_EI (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("ei",NULL);
+}
+
+static void DIS_FD_DECODE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    int nop;
+
+    nop=Z80_Dis_FetchByte(z80,pc);
+    dis_FD_opcode[nop](z80,nop,pc);
+}
+
+static void DIS_CP_A_BYTE (Z80 *z80, Z80Byte op, Z80Word *pc)
+{
+    Z80_Dis_Set("cp",Z80_Dis_Printf("$%.2x",Z80_Dis_FetchByte(z80,pc)));
+}
+
+
+/* ---------------------------------------- TABLES
+*/
+
+/* CB opcodes
+*/
+DIS_OP_CALLBACK	dis_CB_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_RLC_R8,  DIS_RLC_R8,    DIS_RLC_R8,    DIS_RLC_R8,
+/* 0x04 - 0x07 */    DIS_RLC_R8,  DIS_RLC_R8,    DIS_RLC_R8,    DIS_RLC_R8,
+/* 0x08 - 0x0b */    DIS_RRC_R8,  DIS_RRC_R8,    DIS_RRC_R8,    DIS_RRC_R8,
+/* 0x0c - 0x0f */    DIS_RRC_R8,  DIS_RRC_R8,    DIS_RRC_R8,    DIS_RRC_R8,
+
+/* 0x10 - 0x13 */    DIS_RL_R8,  DIS_RL_R8,    DIS_RL_R8,    DIS_RL_R8,  
+/* 0x14 - 0x17 */    DIS_RL_R8,  DIS_RL_R8,    DIS_RL_R8,    DIS_RL_R8,
+/* 0x18 - 0x1b */    DIS_RR_R8,  DIS_RR_R8,    DIS_RR_R8,    DIS_RR_R8,  
+/* 0x1c - 0x1f */    DIS_RR_R8,  DIS_RR_R8,    DIS_RR_R8,    DIS_RR_R8,
+
+/* 0x20 - 0x23 */    DIS_SLA_R8,  DIS_SLA_R8,    DIS_SLA_R8,    DIS_SLA_R8,
+/* 0x24 - 0x27 */    DIS_SLA_R8,  DIS_SLA_R8,    DIS_SLA_R8,    DIS_SLA_R8,
+/* 0x28 - 0x2b */    DIS_SRA_R8,  DIS_SRA_R8,    DIS_SRA_R8,    DIS_SRA_R8,
+/* 0x2c - 0x2f */    DIS_SRA_R8,  DIS_SRA_R8,    DIS_SRA_R8,    DIS_SRA_R8,
+
+/* 0x30 - 0x33 */    DIS_SLL_R8,  DIS_SLL_R8,    DIS_SLL_R8,    DIS_SLL_R8,
+/* 0x34 - 0x37 */    DIS_SLL_R8,  DIS_SLL_R8,    DIS_SLL_R8,    DIS_SLL_R8,
+/* 0x38 - 0x3b */    DIS_SRL_R8,  DIS_SRL_R8,    DIS_SRL_R8,    DIS_SRL_R8,
+/* 0x3c - 0x3f */    DIS_SRL_R8,  DIS_SRL_R8,    DIS_SRL_R8,    DIS_SRL_R8,
+
+/* 0x40 - 0x43 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x44 - 0x47 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x48 - 0x4b */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x4c - 0x4f */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+
+/* 0x50 - 0x53 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x54 - 0x57 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x58 - 0x5b */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x5c - 0x5f */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+
+/* 0x60 - 0x63 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x64 - 0x67 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x68 - 0x6b */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x6c - 0x6f */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+
+/* 0x70 - 0x73 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x74 - 0x77 */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x78 - 0x7b */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+/* 0x7c - 0x7f */    DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,  DIS_BIT_R8,
+
+/* 0x80 - 0x83 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x84 - 0x87 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x88 - 0x8b */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x8c - 0x8f */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+
+/* 0x90 - 0x93 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x94 - 0x97 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x98 - 0x9b */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0x9c - 0x9f */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+
+/* 0xa0 - 0xa3 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xa4 - 0xa7 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xa8 - 0xab */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xac - 0xaf */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+
+/* 0xb0 - 0xb3 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xb4 - 0xb7 */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xb8 - 0xbb */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+/* 0xbc - 0xbf */    DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,  DIS_RES_R8,
+
+/* 0xc0 - 0xc3 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xc4 - 0xc7 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xc8 - 0xcb */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xcc - 0xcf */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+
+/* 0xd0 - 0xd3 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xd4 - 0xd7 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xd8 - 0xdb */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xdc - 0xdf */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+
+/* 0xe0 - 0xe3 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xe4 - 0xe7 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xe8 - 0xeb */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xec - 0xef */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+
+/* 0xf0 - 0xf3 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xf4 - 0xf7 */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xf8 - 0xfb */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+/* 0xfc - 0xff */    DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,  DIS_SET_R8,
+        };
+
+/* DIS_DD opcodes
+*/
+DIS_OP_CALLBACK	dis_DD_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x04 - 0x07 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x08 - 0x0b */    DIS_DD_NOP,	DIS_ADD_IX_BC,	DIS_DD_NOP,		DIS_DD_NOP,	
+/* 0x0c - 0x0f */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,		
+
+/* 0x10 - 0x13 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x14 - 0x17 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x18 - 0x1b */    DIS_DD_NOP,	DIS_ADD_IX_DE,	DIS_DD_NOP,		DIS_DD_NOP,	
+/* 0x1c - 0x1f */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,		
+
+/* 0x20 - 0x23 */    DIS_DD_NOP,	DIS_LD_IX_WORD,	DIS_LD_ADDR_IX,	DIS_INC_IX,
+/* 0x24 - 0x27 */    DIS_INC_IXH,	DIS_DEC_IXH,	DIS_LD_IXH_BYTE,	DIS_DD_NOP,
+/* 0x28 - 0x2b */    DIS_DD_NOP,	DIS_ADD_IX_IX,	DIS_LD_IX_ADDR,	DIS_DEC_IX,
+/* 0x2c - 0x2f */    DIS_INC_IXL,	DIS_DEC_IXL,	DIS_LD_IXL_BYTE,	DIS_DD_NOP,
+
+/* 0x30 - 0x33 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x34 - 0x37 */    DIS_INC_IIX,	DIS_DEC_IIX,	DIS_LD_IIX_BYTE,	DIS_DD_NOP,
+/* 0x38 - 0x3b */    DIS_DD_NOP,	DIS_ADD_IX_SP,	DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x3c - 0x3f */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+
+/* 0x40 - 0x43 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x44 - 0x47 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,
+/* 0x48 - 0x4b */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x4c - 0x4f */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,
+
+/* 0x50 - 0x53 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x54 - 0x57 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,
+/* 0x58 - 0x5b */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x5c - 0x5f */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,
+
+/* 0x60 - 0x63 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,
+/* 0x64 - 0x67 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,
+/* 0x68 - 0x6b */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,
+/* 0x6c - 0x6f */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,
+
+/* 0x70 - 0x73 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,
+/* 0x74 - 0x77 */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,		DIS_XLD_R8_R8,
+/* 0x78 - 0x7b */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x7c - 0x7f */    DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_XLD_R8_R8,	DIS_DD_NOP,
+
+/* 0x80 - 0x83 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x84 - 0x87 */    DIS_XADD_R8,	DIS_XADD_R8,	DIS_XADD_R8,	DIS_DD_NOP,
+/* 0x88 - 0x8b */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x8c - 0x8f */    DIS_XADC_R8,	DIS_XADC_R8,	DIS_XADC_R8,	DIS_DD_NOP,
+
+/* 0x90 - 0x93 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x94 - 0x97 */    DIS_XSUB_R8,	DIS_XSUB_R8,	DIS_XSUB_R8,	DIS_DD_NOP,
+/* 0x98 - 0x9b */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0x9c - 0x9f */    DIS_XSBC_R8,	DIS_XSBC_R8,	DIS_XSBC_R8,	DIS_DD_NOP,
+
+/* 0xa0 - 0xa3 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xa4 - 0xa7 */    DIS_XAND_R8,	DIS_XAND_R8,	DIS_XAND_R8,	DIS_DD_NOP,
+/* 0xa8 - 0xab */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xac - 0xaf */    DIS_XXOR_R8,	DIS_XXOR_R8,	DIS_XXOR_R8,	DIS_DD_NOP,
+
+/* 0xb0 - 0xb3 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xb4 - 0xb7 */    DIS_X_OR_R8,	DIS_X_OR_R8,	DIS_X_OR_R8,	DIS_DD_NOP,
+/* 0xb8 - 0xbb */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xbc - 0xbf */    DIS_XCP_R8,	DIS_XCP_R8,		DIS_XCP_R8,		DIS_DD_NOP,
+
+/* 0xc0 - 0xc3 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xc4 - 0xc7 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xc8 - 0xcb */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_CB_DECODE,
+/* 0xcc - 0xcf */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+
+/* 0xd0 - 0xd3 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xd4 - 0xd7 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xd8 - 0xdb */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xdc - 0xdf */    DIS_DD_NOP,	DIS_DD_DD_DECODE,	DIS_DD_NOP,		DIS_DD_NOP,
+
+/* 0xe0 - 0xe3 */    DIS_DD_NOP,	DIS_POP_IX,		DIS_DD_NOP,		DIS_EX_ISP_IX,
+/* 0xe4 - 0xe7 */    DIS_DD_NOP,	DIS_PUSH_IX,	DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xe8 - 0xeb */    DIS_DD_NOP,	DIS_JP_IX,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xec - 0xef */    DIS_DD_NOP,	DIS_DD_ED_DECODE,	DIS_DD_NOP,		DIS_DD_NOP,
+
+/* 0xf0 - 0xf3 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xf4 - 0xf7 */    DIS_DD_NOP,	DIS_DD_NOP,		DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xf8 - 0xfb */    DIS_DD_NOP,	DIS_LD_SP_IX,	DIS_DD_NOP,		DIS_DD_NOP,
+/* 0xfc - 0xff */    DIS_DD_NOP,	DIS_DD_FD_DECODE,	DIS_DD_NOP,		DIS_DD_NOP,
+		    };
+
+
+/* DIS_DD DIS_CB opcodes
+*/
+DIS_OP_CALLBACK	dis_DD_CB_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_RLC_IX,	DIS_RLC_IX,		DIS_RLC_IX,		DIS_RLC_IX,
+/* 0x04 - 0x07 */    DIS_RLC_IX,	DIS_RLC_IX,		DIS_RLC_IX,		DIS_RLC_IX,
+/* 0x08 - 0x0b */    DIS_RRC_IX,	DIS_RRC_IX,		DIS_RRC_IX,		DIS_RRC_IX,
+/* 0x0c - 0x0f */    DIS_RRC_IX,	DIS_RRC_IX,		DIS_RRC_IX,		DIS_RRC_IX,
+
+/* 0x10 - 0x13 */    DIS_RL_IX,	DIS_RL_IX,		DIS_RL_IX,		DIS_RL_IX,	
+/* 0x14 - 0x17 */    DIS_RL_IX,	DIS_RL_IX,		DIS_RL_IX,		DIS_RL_IX,
+/* 0x18 - 0x1b */    DIS_RR_IX,	DIS_RR_IX,		DIS_RR_IX,		DIS_RR_IX,	
+/* 0x1c - 0x1f */    DIS_RR_IX,	DIS_RR_IX,		DIS_RR_IX,		DIS_RR_IX,
+
+/* 0x20 - 0x23 */    DIS_SLA_IX,	DIS_SLA_IX,		DIS_SLA_IX,		DIS_SLA_IX,
+/* 0x24 - 0x27 */    DIS_SLA_IX,	DIS_SLA_IX,		DIS_SLA_IX,		DIS_SLA_IX,
+/* 0x28 - 0x2b */    DIS_SRA_IX,	DIS_SRA_IX,		DIS_SRA_IX,		DIS_SRA_IX,
+/* 0x2c - 0x2f */    DIS_SRA_IX,	DIS_SRA_IX,		DIS_SRA_IX,		DIS_SRA_IX,
+
+/* 0x30 - 0x33 */    DIS_SLL_IX,	DIS_SLL_IX,		DIS_SLL_IX,		DIS_SLL_IX,
+/* 0x34 - 0x37 */    DIS_SLL_IX,	DIS_SLL_IX,		DIS_SLL_IX,		DIS_SLL_IX,
+/* 0x38 - 0x3b */    DIS_SRL_IX,	DIS_SRL_IX,		DIS_SRL_IX,		DIS_SRL_IX,
+/* 0x3c - 0x3f */    DIS_SRL_IX,	DIS_SRL_IX,		DIS_SRL_IX,		DIS_SRL_IX,
+
+/* 0x40 - 0x43 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x44 - 0x47 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x48 - 0x4b */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x4c - 0x4f */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+
+/* 0x50 - 0x53 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x54 - 0x57 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x58 - 0x5b */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x5c - 0x5f */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+
+/* 0x60 - 0x63 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x64 - 0x67 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x68 - 0x6b */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x6c - 0x6f */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+
+/* 0x70 - 0x73 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x74 - 0x77 */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x78 - 0x7b */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+/* 0x7c - 0x7f */    DIS_BIT_IX,DIS_BIT_IX,	DIS_BIT_IX,	DIS_BIT_IX,
+
+/* 0x80 - 0x83 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x84 - 0x87 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x88 - 0x8b */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x8c - 0x8f */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+
+/* 0x90 - 0x93 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x94 - 0x97 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x98 - 0x9b */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0x9c - 0x9f */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+
+/* 0xa0 - 0xa3 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xa4 - 0xa7 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xa8 - 0xab */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xac - 0xaf */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+
+/* 0xb0 - 0xb3 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xb4 - 0xb7 */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xb8 - 0xbb */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+/* 0xbc - 0xbf */    DIS_RES_IX,DIS_RES_IX,	DIS_RES_IX,	DIS_RES_IX,
+
+/* 0xc0 - 0xc3 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xc4 - 0xc7 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xc8 - 0xcb */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xcc - 0xcf */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+
+/* 0xd0 - 0xd3 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xd4 - 0xd7 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xd8 - 0xdb */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xdc - 0xdf */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+
+/* 0xe0 - 0xe3 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xe4 - 0xe7 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xe8 - 0xeb */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xec - 0xef */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+
+/* 0xf0 - 0xf3 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xf4 - 0xf7 */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xf8 - 0xfb */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+/* 0xfc - 0xff */    DIS_SET_IX,DIS_SET_IX,	DIS_SET_IX,	DIS_SET_IX,
+		    };
+
+/* DIS_ED opcodes
+*/
+DIS_OP_CALLBACK	dis_ED_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x04 - 0x07 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x08 - 0x0b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x0c - 0x0f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0x10 - 0x13 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x14 - 0x17 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x18 - 0x1b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x1c - 0x1f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0x20 - 0x23 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x24 - 0x27 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x28 - 0x2b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x2c - 0x2f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0x30 - 0x33 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x34 - 0x37 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x38 - 0x3b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x3c - 0x3f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0x40 - 0x43 */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_SBC_HL_R16,	DIS_ED_LD_ADDR_R16,
+/* 0x44 - 0x47 */    DIS_NEG,	DIS_RETN,		DIS_IM_0,		DIS_LD_I_A,
+/* 0x48 - 0x4b */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_ADC_HL_R16,	DIS_ED_LD_R16_ADDR,
+/* 0x4c - 0x4f */    DIS_NEG,	DIS_RETI,		DIS_IM_0,		DIS_LD_R_A,
+
+/* 0x50 - 0x53 */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_SBC_HL_R16,	DIS_ED_LD_ADDR_R16,
+/* 0x54 - 0x57 */    DIS_NEG,	DIS_RETN,		DIS_IM_1,		DIS_LD_A_I,
+/* 0x58 - 0x5b */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_ADC_HL_R16,	DIS_ED_LD_R16_ADDR,
+/* 0x5c - 0x5f */    DIS_NEG,	DIS_RETI,		DIS_IM_2,		DIS_LD_A_R,
+
+/* 0x60 - 0x63 */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_SBC_HL_R16,	DIS_ED_LD_ADDR_R16,
+/* 0x64 - 0x67 */    DIS_NEG,	DIS_RETN,		DIS_IM_0,		DIS_RRD,
+/* 0x68 - 0x6b */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_ADC_HL_R16,	DIS_ED_LD_R16_ADDR,
+/* 0x6c - 0x6f */    DIS_NEG,	DIS_RETI,		DIS_IM_0,		DIS_RLD,
+
+/* 0x70 - 0x73 */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_SBC_HL_R16,	DIS_ED_LD_ADDR_R16,
+/* 0x74 - 0x77 */    DIS_NEG,	DIS_RETN,		DIS_IM_1,		DIS_ED_NOP,
+/* 0x78 - 0x7b */    DIS_IN_R8_C,	DIS_OUT_C_R8,	DIS_ADC_HL_R16,	DIS_ED_LD_R16_ADDR,
+/* 0x7c - 0x7f */    DIS_NEG,	DIS_RETI,		DIS_IM_2,		DIS_ED_NOP,
+
+/* 0x80 - 0x83 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x84 - 0x87 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x88 - 0x8b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x8c - 0x8f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0x90 - 0x93 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x94 - 0x97 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0x98 - 0x9b */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0x9c - 0x9f */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xa0 - 0xa3 */    DIS_LDI,	DIS_CPI,		DIS_INI,		DIS_OUTI,
+/* 0xa4 - 0xa7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xa8 - 0xab */    DIS_LDD,	DIS_CPD,		DIS_IND,		DIS_OUTD,	
+/* 0xac - 0xaf */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xb0 - 0xb3 */    DIS_LDIR,	DIS_CPIR,		DIS_INIR,		DIS_OTIR,
+/* 0xb4 - 0xb7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xb8 - 0xbb */    DIS_LDDR,	DIS_CPDR,		DIS_INDR,		DIS_OTDR,	
+/* 0xbc - 0xbf */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xc0 - 0xc3 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xc4 - 0xc7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xc8 - 0xcb */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0xcc - 0xcf */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xd0 - 0xd3 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xd4 - 0xd7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xd8 - 0xdb */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0xdc - 0xdf */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xe0 - 0xe3 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xe4 - 0xe7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xe8 - 0xeb */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0xec - 0xef */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+
+/* 0xf0 - 0xf3 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xf4 - 0xf7 */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,
+/* 0xf8 - 0xfb */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,	
+/* 0xfc - 0xff */    DIS_ED_NOP,	DIS_ED_NOP,		DIS_ED_NOP,		DIS_ED_NOP,		
+		    };
+
+/* DIS_FD opcodes
+*/
+DIS_OP_CALLBACK	dis_FD_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x04 - 0x07 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x08 - 0x0b */    DIS_FD_NOP,	DIS_ADD_IY_BC,	DIS_FD_NOP,		DIS_FD_NOP,	
+/* 0x0c - 0x0f */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,		
+
+/* 0x10 - 0x13 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x14 - 0x17 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x18 - 0x1b */    DIS_FD_NOP,	DIS_ADD_IY_DE,	DIS_FD_NOP,		DIS_FD_NOP,	
+/* 0x1c - 0x1f */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,		
+
+/* 0x20 - 0x23 */    DIS_FD_NOP,	DIS_LD_IY_WORD,	DIS_LD_ADDR_IY,	DIS_INC_IY,
+/* 0x24 - 0x27 */    DIS_INC_IYH,	DIS_DEC_IYH,	DIS_LD_IYH_BYTE,	DIS_FD_NOP,
+/* 0x28 - 0x2b */    DIS_FD_NOP,	DIS_ADD_IY_IY,	DIS_LD_IY_ADDR,	DIS_DEC_IY,
+/* 0x2c - 0x2f */    DIS_INC_IYL,	DIS_DEC_IYL,	DIS_LD_IYL_BYTE,	DIS_FD_NOP,
+
+/* 0x30 - 0x33 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x34 - 0x37 */    DIS_INC_IIY,	DIS_DEC_IIY,	DIS_LD_IIY_BYTE,	DIS_FD_NOP,
+/* 0x38 - 0x3b */    DIS_FD_NOP,	DIS_ADD_IY_SP,	DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x3c - 0x3f */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+
+/* 0x40 - 0x43 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x44 - 0x47 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,
+/* 0x48 - 0x4b */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x4c - 0x4f */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,
+
+/* 0x50 - 0x53 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x54 - 0x57 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,
+/* 0x58 - 0x5b */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x5c - 0x5f */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,
+
+/* 0x60 - 0x63 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,
+/* 0x64 - 0x67 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,
+/* 0x68 - 0x6b */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,
+/* 0x6c - 0x6f */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,
+
+/* 0x70 - 0x73 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,
+/* 0x74 - 0x77 */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,		DIS_YLD_R8_R8,
+/* 0x78 - 0x7b */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x7c - 0x7f */    DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_YLD_R8_R8,	DIS_FD_NOP,
+
+/* 0x80 - 0x83 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x84 - 0x87 */    DIS_YADD_R8,	DIS_YADD_R8,	DIS_YADD_R8,	DIS_FD_NOP,
+/* 0x88 - 0x8b */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x8c - 0x8f */    DIS_YADC_R8,	DIS_YADC_R8,	DIS_YADC_R8,	DIS_FD_NOP,
+
+/* 0x90 - 0x93 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x94 - 0x97 */    DIS_YSUB_R8,	DIS_YSUB_R8,	DIS_YSUB_R8,	DIS_FD_NOP,
+/* 0x98 - 0x9b */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0x9c - 0x9f */    DIS_YSBC_R8,	DIS_YSBC_R8,	DIS_YSBC_R8,	DIS_FD_NOP,
+
+/* 0xa0 - 0xa3 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xa4 - 0xa7 */    DIS_YAND_R8,	DIS_YAND_R8,	DIS_YAND_R8,	DIS_FD_NOP,
+/* 0xa8 - 0xab */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xac - 0xaf */    DIS_YYOR_R8,	DIS_YYOR_R8,	DIS_YYOR_R8,	DIS_FD_NOP,
+
+/* 0xb0 - 0xb3 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xb4 - 0xb7 */    DIS_Y_OR_R8,	DIS_Y_OR_R8,	DIS_Y_OR_R8,	DIS_FD_NOP,
+/* 0xb8 - 0xbb */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xbc - 0xbf */    DIS_YCP_R8,	DIS_YCP_R8,		DIS_YCP_R8,		DIS_FD_NOP,
+
+/* 0xc0 - 0xc3 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xc4 - 0xc7 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xc8 - 0xcb */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_CB_DECODE,
+/* 0xcc - 0xcf */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+
+/* 0xd0 - 0xd3 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xd4 - 0xd7 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xd8 - 0xdb */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xdc - 0xdf */    DIS_FD_NOP,	DIS_FD_DD_DECODE,	DIS_FD_NOP,		DIS_FD_NOP,
+
+/* 0xe0 - 0xe3 */    DIS_FD_NOP,	DIS_POP_IY,		DIS_FD_NOP,		DIS_EY_ISP_IY,
+/* 0xe4 - 0xe7 */    DIS_FD_NOP,	DIS_PUSH_IY,	DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xe8 - 0xeb */    DIS_FD_NOP,	DIS_JP_IY,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xec - 0xef */    DIS_FD_NOP,	DIS_FD_ED_DECODE,	DIS_FD_NOP,		DIS_FD_NOP,
+
+/* 0xf0 - 0xf3 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xf4 - 0xf7 */    DIS_FD_NOP,	DIS_FD_NOP,		DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xf8 - 0xfb */    DIS_FD_NOP,	DIS_LD_SP_IY,	DIS_FD_NOP,		DIS_FD_NOP,
+/* 0xfc - 0xff */    DIS_FD_NOP,	DIS_FD_FD_DECODE,	DIS_FD_NOP,		DIS_FD_NOP,
+		    };
+
+
+/* DIS_FD DIS_CB opcodes
+*/
+DIS_OP_CALLBACK	dis_FD_CB_opcode[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_RLC_IY,	DIS_RLC_IY,		DIS_RLC_IY,		DIS_RLC_IY,
+/* 0x04 - 0x07 */    DIS_RLC_IY,	DIS_RLC_IY,		DIS_RLC_IY,		DIS_RLC_IY,
+/* 0x08 - 0x0b */    DIS_RRC_IY,	DIS_RRC_IY,		DIS_RRC_IY,		DIS_RRC_IY,
+/* 0x0c - 0x0f */    DIS_RRC_IY,	DIS_RRC_IY,		DIS_RRC_IY,		DIS_RRC_IY,
+
+/* 0x10 - 0x13 */    DIS_RL_IY,	DIS_RL_IY,		DIS_RL_IY,		DIS_RL_IY,	
+/* 0x14 - 0x17 */    DIS_RL_IY,	DIS_RL_IY,		DIS_RL_IY,		DIS_RL_IY,
+/* 0x18 - 0x1b */    DIS_RR_IY,	DIS_RR_IY,		DIS_RR_IY,		DIS_RR_IY,	
+/* 0x1c - 0x1f */    DIS_RR_IY,	DIS_RR_IY,		DIS_RR_IY,		DIS_RR_IY,
+
+/* 0x20 - 0x23 */    DIS_SLA_IY,	DIS_SLA_IY,		DIS_SLA_IY,		DIS_SLA_IY,
+/* 0x24 - 0x27 */    DIS_SLA_IY,	DIS_SLA_IY,		DIS_SLA_IY,		DIS_SLA_IY,
+/* 0x28 - 0x2b */    DIS_SRA_IY,	DIS_SRA_IY,		DIS_SRA_IY,		DIS_SRA_IY,
+/* 0x2c - 0x2f */    DIS_SRA_IY,	DIS_SRA_IY,		DIS_SRA_IY,		DIS_SRA_IY,
+
+/* 0x30 - 0x33 */    DIS_SLL_IY,	DIS_SLL_IY,		DIS_SLL_IY,		DIS_SLL_IY,
+/* 0x34 - 0x37 */    DIS_SLL_IY,	DIS_SLL_IY,		DIS_SLL_IY,		DIS_SLL_IY,
+/* 0x38 - 0x3b */    DIS_SRL_IY,	DIS_SRL_IY,		DIS_SRL_IY,		DIS_SRL_IY,
+/* 0x3c - 0x3f */    DIS_SRL_IY,	DIS_SRL_IY,		DIS_SRL_IY,		DIS_SRL_IY,
+
+/* 0x40 - 0x43 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x44 - 0x47 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x48 - 0x4b */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x4c - 0x4f */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+
+/* 0x50 - 0x53 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x54 - 0x57 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x58 - 0x5b */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x5c - 0x5f */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+
+/* 0x60 - 0x63 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x64 - 0x67 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x68 - 0x6b */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x6c - 0x6f */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+
+/* 0x70 - 0x73 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x74 - 0x77 */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x78 - 0x7b */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+/* 0x7c - 0x7f */    DIS_BIT_IY,DIS_BIT_IY,	DIS_BIT_IY,	DIS_BIT_IY,
+
+/* 0x80 - 0x83 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x84 - 0x87 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x88 - 0x8b */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x8c - 0x8f */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+
+/* 0x90 - 0x93 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x94 - 0x97 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x98 - 0x9b */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0x9c - 0x9f */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+
+/* 0xa0 - 0xa3 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xa4 - 0xa7 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xa8 - 0xab */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xac - 0xaf */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+
+/* 0xb0 - 0xb3 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xb4 - 0xb7 */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xb8 - 0xbb */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+/* 0xbc - 0xbf */    DIS_RES_IY,DIS_RES_IY,	DIS_RES_IY,	DIS_RES_IY,
+
+/* 0xc0 - 0xc3 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xc4 - 0xc7 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xc8 - 0xcb */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xcc - 0xcf */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+
+/* 0xd0 - 0xd3 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xd4 - 0xd7 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xd8 - 0xdb */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xdc - 0xdf */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+
+/* 0xe0 - 0xe3 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xe4 - 0xe7 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xe8 - 0xeb */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xec - 0xef */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+
+/* 0xf0 - 0xf3 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xf4 - 0xf7 */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xf8 - 0xfb */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+/* 0xfc - 0xff */    DIS_SET_IY,DIS_SET_IY,	DIS_SET_IY,	DIS_SET_IY,
+		    };
+
+/* DIS_First/single byte opcodes
+*/
+DIS_OP_CALLBACK	dis_opcode_z80[0x100]=
+		    {
+/* 0x00 - 0x03 */    DIS_NOP,	DIS_LD_R16_WORD,	DIS_LD_R16_A,	DIS_INC_R16,
+/* 0x04 - 0x07 */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_RLCA,
+/* 0x08 - 0x0b */    DIS_EX_AF_AF,	DIS_ADD_HL_R16,	DIS_LD_A_R16,	DIS_DEC_R16,	
+/* 0x0c - 0x0f */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_RRCA,		
+
+/* 0x10 - 0x13 */    DIS_DJNZ,	DIS_LD_R16_WORD,	DIS_LD_R16_A,	DIS_INC_R16,
+/* 0x14 - 0x17 */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_RLA,
+/* 0x18 - 0x1b */    DIS_JR,	DIS_ADD_HL_R16,	DIS_LD_A_R16,	DIS_DEC_R16,	
+/* 0x1c - 0x1f */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_RRA,		
+
+/* 0x20 - 0x23 */    DIS_JR_CO,	DIS_LD_R16_WORD,	DIS_LD_ADDR_HL,	DIS_INC_R16,
+/* 0x24 - 0x27 */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_DAA,
+/* 0x28 - 0x2b */    DIS_JR_CO,	DIS_ADD_HL_R16,	DIS_LD_HL_ADDR,	DIS_DEC_R16,	
+/* 0x2c - 0x2f */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_CPL,		
+
+/* 0x30 - 0x33 */    DIS_JR_CO,	DIS_LD_R16_WORD,	DIS_LD_ADDR_A,	DIS_INC_R16,
+/* 0x34 - 0x37 */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_SCF,
+/* 0x38 - 0x3b */    DIS_JR_CO,	DIS_ADD_HL_R16,	DIS_LD_A_ADDR,	DIS_DEC_R16,	
+/* 0x3c - 0x3f */    DIS_INC_R8,	DIS_DEC_R8,		DIS_LD_R8_BYTE,	DIS_CCF,		
+
+/* 0x40 - 0x43 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x44 - 0x47 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x48 - 0x4b */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x4c - 0x4f */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+
+/* 0x50 - 0x53 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x54 - 0x57 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x58 - 0x5b */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x5c - 0x5f */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+
+/* 0x60 - 0x63 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x64 - 0x67 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x68 - 0x6b */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x6c - 0x6f */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+
+/* 0x70 - 0x73 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x74 - 0x77 */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_HALT,		DIS_LD_R8_R8,
+/* 0x78 - 0x7b */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+/* 0x7c - 0x7f */    DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,	DIS_LD_R8_R8,
+
+/* 0x80 - 0x83 */    DIS_ADD_R8,	DIS_ADD_R8,		DIS_ADD_R8,		DIS_ADD_R8,
+/* 0x84 - 0x87 */    DIS_ADD_R8,	DIS_ADD_R8,		DIS_ADD_R8,		DIS_ADD_R8,
+/* 0x88 - 0x8b */    DIS_ADC_R8,	DIS_ADC_R8,		DIS_ADC_R8,		DIS_ADC_R8,
+/* 0x8c - 0x8f */    DIS_ADC_R8,	DIS_ADC_R8,		DIS_ADC_R8,		DIS_ADC_R8,
+
+/* 0x90 - 0x93 */    DIS_SUB_R8,	DIS_SUB_R8,		DIS_SUB_R8,		DIS_SUB_R8,
+/* 0x94 - 0x97 */    DIS_SUB_R8,	DIS_SUB_R8,		DIS_SUB_R8,		DIS_SUB_R8,
+/* 0x98 - 0x9b */    DIS_SBC_R8,	DIS_SBC_R8,		DIS_SBC_R8,		DIS_SBC_R8,
+/* 0x9c - 0x9f */    DIS_SBC_R8,	DIS_SBC_R8,		DIS_SBC_R8,		DIS_SBC_R8,
+
+/* 0xa0 - 0xa3 */    DIS_AND_R8,	DIS_AND_R8,		DIS_AND_R8,		DIS_AND_R8,
+/* 0xa4 - 0xa7 */    DIS_AND_R8,	DIS_AND_R8,		DIS_AND_R8,		DIS_AND_R8,
+/* 0xa8 - 0xab */    DIS_XOR_R8,	DIS_XOR_R8,		DIS_XOR_R8,		DIS_XOR_R8,
+/* 0xac - 0xaf */    DIS_XOR_R8,	DIS_XOR_R8,		DIS_XOR_R8,		DIS_XOR_R8,
+
+/* 0xb0 - 0xb3 */    DIS_OR_R8,	DIS_OR_R8,		DIS_OR_R8,		DIS_OR_R8,
+/* 0xb4 - 0xb7 */    DIS_OR_R8,	DIS_OR_R8,		DIS_OR_R8,		DIS_OR_R8,
+/* 0xb8 - 0xbb */    DIS_CP_R8,	DIS_CP_R8,		DIS_CP_R8,		DIS_CP_R8,
+/* 0xbc - 0xbf */    DIS_CP_R8,	DIS_CP_R8,		DIS_CP_R8,		DIS_CP_R8,
+
+/* 0xc0 - 0xc3 */    DIS_RET_CO,	DIS_POP_R16,	DIS_JP_CO,		DIS_JP,
+/* 0xc4 - 0xc7 */    DIS_CALL_CO,	DIS_PUSH_R16,	DIS_ADD_A_BYTE,	DIS_RST,
+/* 0xc8 - 0xcb */    DIS_RET_CO,	DIS_RET,		DIS_JP_CO,		DIS_CB_DECODE,
+/* 0xcc - 0xcf */    DIS_CALL_CO,	DIS_CALL,		DIS_ADC_A_BYTE,	DIS_RST,
+
+/* 0xd0 - 0xd3 */    DIS_RET_CO,	DIS_POP_R16,	DIS_JP_CO,		DIS_OUT_BYTE_A,
+/* 0xd4 - 0xd7 */    DIS_CALL_CO,	DIS_PUSH_R16,	DIS_SUB_A_BYTE,	DIS_RST,
+/* 0xd8 - 0xdb */    DIS_RET_CO,	DIS_EXX,		DIS_JP_CO,		DIS_IN_A_BYTE,
+/* 0xdc - 0xdf */    DIS_CALL_CO,	DIS_DD_DECODE,	DIS_SBC_A_BYTE,	DIS_RST,
+
+/* 0xe0 - 0xe3 */    DIS_RET_CO,	DIS_POP_R16,	DIS_JP_CO,		DIS_EX_ISP_HL,
+/* 0xe4 - 0xe7 */    DIS_CALL_CO,	DIS_PUSH_R16,	DIS_AND_A_BYTE,	DIS_RST,
+/* 0xe8 - 0xeb */    DIS_RET_CO,	DIS_JP_HL,		DIS_JP_CO,		DIS_EX_DE_HL,
+/* 0xec - 0xef */    DIS_CALL_CO,	DIS_ED_DECODE,	DIS_XOR_A_BYTE,	DIS_RST,
+
+/* 0xf0 - 0xf3 */    DIS_RET_CO,	DIS_POP_R16,	DIS_JP_CO,		DIS_DI,
+/* 0xf4 - 0xf7 */    DIS_CALL_CO,	DIS_PUSH_R16,	DIS_OR_A_BYTE,	DIS_RST,
+/* 0xf8 - 0xfb */    DIS_RET_CO,	DIS_LD_SP_HL,	DIS_JP_CO,		DIS_EI,
+/* 0xfc - 0xff */    DIS_CALL_CO,	DIS_FD_DECODE,	DIS_CP_A_BYTE,	DIS_RST,
+		    };
+
+
+#endif
+
+/* END OF FILE */
diff --git a/z80_private.h b/z80_private.h
index 32ce91f..ae0ec8c 100644
--- a/z80_private.h
+++ b/z80_private.h
@@ -227,6 +227,29 @@ void Z80_Decode(Z80 *cpu, Z80Byte opcode);
 void Z80_InitialiseInternals(void);
 
 
-#endif
+/* ---------------------------------------- DISASSEMBLY
+*/
+#ifdef ENABLE_DISASSEM
+typedef void		(*DIS_OP_CALLBACK)(Z80 *z80, Z80Byte op, Z80Word *pc);
+
+extern DIS_OP_CALLBACK	dis_CB_opcode[];
+extern DIS_OP_CALLBACK	dis_DD_opcode[];
+extern DIS_OP_CALLBACK	dis_DD_CB_opcode[];
+extern DIS_OP_CALLBACK	dis_ED_opcode[];
+extern DIS_OP_CALLBACK	dis_FD_opcode[];
+extern DIS_OP_CALLBACK	dis_FD_CB_opcode[];
+extern DIS_OP_CALLBACK	dis_opcode_z80[];
+
+const char	*Z80_Dis_Printf(const char *format, ...);
+
+Z80Byte		Z80_Dis_FetchByte(Z80 *cpu, Z80Word *pc);
+Z80Word		Z80_Dis_FetchWord(Z80 *cpu, Z80Word *pc);
+
+void		Z80_Dis_Set(const char *op, const char *arg);
+const char	*Z80_Dis_GetOp(void);
+const char	*Z80_Dis_GetArg(void);
+#endif	/* ENABLE_DISASSEM */
+
+#endif	/* Z80_PRIVATE_H */
 
 /* END OF FILE */