/** VGB: portable GameBoy emulator ***************************/
/**                                                         **/
/**                   CPUFunctions.c                        **/
/**                                                         **/
/** This file contains implementation for the main table of **/
/** Z80 commands.                                           **/
/**                                                         **/
/** Copyright (C) Matthias Bethke 1995                      **/
/** Based on the file Codes.h from the original VGB         **/
/** distribution by Marat Fayzullin                         **/
/**     You are not allowed to distribute this software     **/
/**     commercially. Please, notify me, if you make any    **/
/**     changes to this file.                               **/
/*************************************************************/

#include "GB.h"
#include "Z80_Defs.h"

#define f_DJNZ f_UNIMPLEMENTED
#define f_HALT f_UNIMPLEMENTED
#define f_OUTA f_UNIMPLEMENTED
#define f_INA f_UNIMPLEMENTED
#define f_EX_DE_HL f_UNIMPLEMENTED
#define f_PFX f_UNIMPLEMENTED
#define f_PFX_CB f_UNIMPLEMENTED
#define f_PFX_DD f_UNIMPLEMENTED
#define f_PFX_ED f_UNIMPLEMENTED
#define f_PFX_FD f_UNIMPLEMENTED
#define f_CALL_P f_UNIMPLEMENTED
#define f_CALL_M f_UNIMPLEMENTED
#define f_CALL_PE f_UNIMPLEMENTED
#define f_CALL_PO f_UNIMPLEMENTED

extern byte I;
extern pair J;
extern reg R;
extern byte *RAM;
extern word Cnt;

void f_EX_AF_AF(void)
{
  J.B.l=*(RAM+(R.PC.W++));
  J.B.h=*(RAM+(R.PC.W++));
  M_WRMEM(J.W,R.SP.B.l);J.W++;
  M_WRMEM(J.W,R.SP.B.h);
}

void f_LD_xWORD_HL(void) { M_WRMEM(R.HL.W++,R.AF.B.h);}
void f_LD_HL_xWORD(void) { R.AF.B.h=*(RAM+(R.HL.W++));}

void f_LD_xWORD_A(void) { M_WRMEM(R.HL.W--,R.AF.B.h);}
void f_LD_A_xWORD(void) { R.AF.B.h=*(RAM+(R.HL.W--));}

void f_EXX(void) { R.IFF|=0x01;M_RET;}

void f_RET_PO(void) { M_WRMEM(0xFF00+*(RAM+(R.PC.W++)),R.AF.B.h);}
void f_JP_PO(void) { M_WRMEM(0xFF00+R.BC.B.l,R.AF.B.h);}
void f_RET_PE(void) { R.SP.W+=*(offset *)(RAM+(R.PC.W++));}
void f_JP_PE(void)
{
  J.B.l=*(RAM+(R.PC.W++));
  J.B.h=*(RAM+(R.PC.W++));
  M_WRMEM(J.W,R.AF.B.h);
}

void f_RET_P(void) { R.AF.B.h=*(RAM+0xFF00+*(RAM+(R.PC.W++)));}
void f_JP_P(void) { R.AF.B.h=*(RAM+0xFF00+R.BC.B.l);}
void f_RET_M(void) { R.HL.W=R.SP.W+*(offset *)(RAM+(R.PC.W++));}
void f_JP_M(void)
{
  J.B.l=*(RAM+(R.PC.W++));
  J.B.h=*(RAM+(R.PC.W++));
  R.AF.B.h=*(RAM+J.W);
}

void f_JR_NZ(void) {if(R.AF.B.l&Z_FLAG)  R.PC.W++; else { M_JR; } }
void f_JR_NC(void) {if(R.AF.B.l&C_FLAG)  R.PC.W++; else { M_JR; } }
void f_JR_Z(void) { if(R.AF.B.l&Z_FLAG)  { M_JR; } else R.PC.W++; }
void f_JR_C(void) { if(R.AF.B.l&C_FLAG)  { M_JR; } else R.PC.W++; }

void f_JP_NZ(void) {if(R.AF.B.l&Z_FLAG)  R.PC.W+=2; else { M_JP; }  }
void f_JP_NC(void) {if(R.AF.B.l&C_FLAG)  R.PC.W+=2; else { M_JP; }  }
void f_JP_Z(void) { if(R.AF.B.l&Z_FLAG)  { M_JP; }  else R.PC.W+=2; }
void f_JP_C(void) { if(R.AF.B.l&C_FLAG)  { M_JP; }  else R.PC.W+=2; }

void f_RET_NZ(void) {   if(!(R.AF.B.l&Z_FLAG))  { M_RET; }  }
void f_RET_NC(void) {   if(!(R.AF.B.l&C_FLAG))  { M_RET; }  }
void f_RET_Z(void) {if(R.AF.B.l&Z_FLAG)     { M_RET; }  }
void f_RET_C(void) {if(R.AF.B.l&C_FLAG)     { M_RET; }  }

void f_CALL_NZ(void) {  if(R.AF.B.l&Z_FLAG)  R.PC.W+=2;  else { M_CALL; } }
void f_CALL_NC(void) {  if(R.AF.B.l&C_FLAG)  R.PC.W+=2;  else { M_CALL; } }
void f_CALL_Z(void) {   if(R.AF.B.l&Z_FLAG)  { M_CALL; } else R.PC.W+=2;  }
void f_CALL_C(void) {   if(R.AF.B.l&C_FLAG)  { M_CALL; } else R.PC.W+=2;  }

void f_ADD_B(void) {M_ADD(R.BC.B.h);}
void f_ADD_C(void) {M_ADD(R.BC.B.l);}
void f_ADD_D(void) {M_ADD(R.DE.B.h);}
void f_ADD_E(void) {M_ADD(R.DE.B.l);}
void f_ADD_H(void) {M_ADD(R.HL.B.h);}
void f_ADD_L(void) {M_ADD(R.HL.B.l);}
void f_ADD_A(void) {M_ADD(R.AF.B.h);}
void f_ADD_xHL(void) {  I=*(RAM+R.HL.W);M_ADD(I);}
void f_ADD_BYTE(void) { I=*(RAM+(R.PC.W++));M_ADD(I);}

void f_SUB_B(void) {M_SUB(R.BC.B.h);}
void f_SUB_C(void) {M_SUB(R.BC.B.l);}
void f_SUB_D(void) {M_SUB(R.DE.B.h);}
void f_SUB_E(void) {M_SUB(R.DE.B.l);}
void f_SUB_H(void) {M_SUB(R.HL.B.h);}
void f_SUB_L(void) {M_SUB(R.HL.B.l);}
void f_SUB_A(void) {R.AF.B.h=0;R.AF.B.l=N_FLAG|Z_FLAG;}
void f_SUB_xHL(void) {  I=*(RAM+R.HL.W);M_SUB(I);}
void f_SUB_BYTE(void) { I=*(RAM+(R.PC.W++));M_SUB(I);}

void f_AND_B(void) {M_AND(R.BC.B.h);}
void f_AND_C(void) {M_AND(R.BC.B.l);}
void f_AND_D(void) {M_AND(R.DE.B.h);}
void f_AND_E(void) {M_AND(R.DE.B.l);}
void f_AND_H(void) {M_AND(R.HL.B.h);}
void f_AND_L(void) {M_AND(R.HL.B.l);}
void f_AND_A(void) {M_AND(R.AF.B.h);}
void f_AND_xHL(void) {  I=*(RAM+R.HL.W);M_AND(I);}
void f_AND_BYTE(void) { I=*(RAM+(R.PC.W++));M_AND(I);}

void f_OR_B(void) { M_OR(R.BC.B.h);}
void f_OR_C(void) { M_OR(R.BC.B.l);}
void f_OR_D(void) { M_OR(R.DE.B.h);}
void f_OR_E(void) { M_OR(R.DE.B.l);}
void f_OR_H(void) { M_OR(R.HL.B.h);}
void f_OR_L(void) { M_OR(R.HL.B.l);}
void f_OR_A(void) { M_OR(R.AF.B.h);}
void f_OR_xHL(void) {   I=*(RAM+R.HL.W);M_OR(I);}
void f_OR_BYTE(void) {  I=*(RAM+(R.PC.W++));M_OR(I);}

void f_ADC_B(void) {M_ADC(R.BC.B.h);}
void f_ADC_C(void) {M_ADC(R.BC.B.l);}
void f_ADC_D(void) {M_ADC(R.DE.B.h);}
void f_ADC_E(void) {M_ADC(R.DE.B.l);}
void f_ADC_H(void) {M_ADC(R.HL.B.h);}
void f_ADC_L(void) {M_ADC(R.HL.B.l);}
void f_ADC_A(void) {M_ADC(R.AF.B.h);}
void f_ADC_xHL(void) {  I=*(RAM+R.HL.W);M_ADC(I);}
void f_ADC_BYTE(void) { I=*(RAM+(R.PC.W++));M_ADC(I);}

void f_SBC_B(void) {M_SBC(R.BC.B.h);}
void f_SBC_C(void) {M_SBC(R.BC.B.l);}
void f_SBC_D(void) {M_SBC(R.DE.B.h);}
void f_SBC_E(void) {M_SBC(R.DE.B.l);}
void f_SBC_H(void) {M_SBC(R.HL.B.h);}
void f_SBC_L(void) {M_SBC(R.HL.B.l);}
void f_SBC_A(void) {M_SBC(R.AF.B.h);}
void f_SBC_xHL(void) {  I=*(RAM+R.HL.W);M_SBC(I);}
void f_SBC_BYTE(void) { I=*(RAM+(R.PC.W++));M_SBC(I);}

void f_XOR_B(void) {M_XOR(R.BC.B.h);}
void f_XOR_C(void) {M_XOR(R.BC.B.l);}
void f_XOR_D(void) {M_XOR(R.DE.B.h);}
void f_XOR_E(void) {M_XOR(R.DE.B.l);}
void f_XOR_H(void) {M_XOR(R.HL.B.h);}
void f_XOR_L(void) {M_XOR(R.HL.B.l);}
void f_XOR_A(void) {R.AF.B.h=0;R.AF.B.l=Z_FLAG;}
void f_XOR_xHL(void) {  I=*(RAM+R.HL.W);M_XOR(I);}
void f_XOR_BYTE(void) { I=*(RAM+(R.PC.W++));M_XOR(I);}

void f_CP_B(void) { M_CP(R.BC.B.h);}
void f_CP_C(void) { M_CP(R.BC.B.l);}
void f_CP_D(void) { M_CP(R.DE.B.h);}
void f_CP_E(void) { M_CP(R.DE.B.l);}
void f_CP_H(void) { M_CP(R.HL.B.h);}
void f_CP_L(void) { M_CP(R.HL.B.l);}
void f_CP_A(void) { R.AF.B.l=N_FLAG|Z_FLAG;}
void f_CP_xHL(void) {   I=*(RAM+R.HL.W);M_CP(I);}
void f_CP_BYTE(void) {  I=*(RAM+(R.PC.W++));M_CP(I);}
               
void f_LD_BC_WORD(void) { M_LDWORD(BC);}
void f_LD_DE_WORD(void) { M_LDWORD(DE);}
void f_LD_HL_WORD(void) { M_LDWORD(HL);}
void f_LD_SP_WORD(void) { M_LDWORD(SP);}

void f_LD_PC_HL(void) { R.PC.W=R.HL.W;}
void f_LD_SP_HL(void) { R.SP.W=R.HL.W;}
void f_LD_A_xBC(void) { R.AF.B.h=*(RAM+R.BC.W);}
void f_LD_A_xDE(void) { R.AF.B.h=*(RAM+R.DE.W);}

void f_ADD_HL_BC(void) {  M_ADDW(HL,BC);}
void f_ADD_HL_DE(void) {  M_ADDW(HL,DE);}
void f_ADD_HL_HL(void) {  M_ADDW(HL,HL);}
void f_ADD_HL_SP(void) {  M_ADDW(HL,SP);}

void f_DEC_BC(void) {   R.BC.W--;}
void f_DEC_DE(void) {   R.DE.W--;}
void f_DEC_HL(void) {   R.HL.W--;}
void f_DEC_SP(void) {   R.SP.W--;}

void f_INC_BC(void) {   R.BC.W++;}
void f_INC_DE(void) {   R.DE.W++;}
void f_INC_HL(void) {   R.HL.W++;}
void f_INC_SP(void) {   R.SP.W++;}

void f_DEC_B(void) {M_DEC(R.BC.B.h);}
void f_DEC_C(void) {M_DEC(R.BC.B.l);}
void f_DEC_D(void) {M_DEC(R.DE.B.h);}
void f_DEC_E(void) {M_DEC(R.DE.B.l);}
void f_DEC_H(void) {M_DEC(R.HL.B.h);}
void f_DEC_L(void) {M_DEC(R.HL.B.l);}
void f_DEC_A(void) {M_DEC(R.AF.B.h);}
void f_DEC_xHL(void) {  I=*(RAM+R.HL.W);M_DEC(I);M_WRMEM(R.HL.W,I);}

void f_INC_B(void) {M_INC(R.BC.B.h);}
void f_INC_C(void) {M_INC(R.BC.B.l);}
void f_INC_D(void) {M_INC(R.DE.B.h);}
void f_INC_E(void) {M_INC(R.DE.B.l);}
void f_INC_H(void) {M_INC(R.HL.B.h);}
void f_INC_L(void) {M_INC(R.HL.B.l);}
void f_INC_A(void) {M_INC(R.AF.B.h);}
void f_INC_xHL(void) {  I=*(RAM+R.HL.W);M_INC(I);M_WRMEM(R.HL.W,I);}

void f_RLCA(void)
{
  I=R.AF.B.h&0x80? C_FLAG:0;
  R.AF.B.h=(R.AF.B.h<<1)|I;
  R.AF.B.l=(R.AF.B.l&~(C_FLAG|N_FLAG|H_FLAG))|I;
}
void f_RLA(void)
{
  I=R.AF.B.h&0x80? C_FLAG:0;
  R.AF.B.h=(R.AF.B.h<<1)|(R.AF.B.l&C_FLAG);
  R.AF.B.l=(R.AF.B.l&~(C_FLAG|N_FLAG|H_FLAG))|I;
}
void f_RRCA(void)
{
  I=R.AF.B.h&0x01;
  R.AF.B.h=(R.AF.B.h>>1)|(I? 0x80:0);
  R.AF.B.l=(R.AF.B.l&~(C_FLAG|N_FLAG|H_FLAG))|I; 
}
void f_RRA(void)
{
  I=R.AF.B.h&0x01;
  R.AF.B.h=(R.AF.B.h>>1)|(R.AF.B.l&C_FLAG? 0x80:0);
  R.AF.B.l=(R.AF.B.l&~(C_FLAG|N_FLAG|H_FLAG))|I;
}

void f_RST00(void) {M_RST(0x0000);}
void f_RST08(void) {M_RST(0x0008);}
void f_RST10(void) {M_RST(0x0010);}
void f_RST18(void) {M_RST(0x0018);}
void f_RST20(void) {M_RST(0x0020);}
void f_RST28(void) {M_RST(0x0028);}
void f_RST30(void) {M_RST(0x0030);}
void f_RST38(void) {M_RST(0x0038);}

void f_PUSH_BC(void) { M_PUSH(BC);}
void f_PUSH_DE(void) { M_PUSH(DE);}
void f_PUSH_HL(void) { M_PUSH(HL);}
void f_PUSH_AF(void) { M_PUSH(AF);}

void f_POP_BC(void) { M_POP(BC);}
void f_POP_DE(void) { M_POP(DE);}
void f_POP_HL(void) { M_POP(HL);}
void f_POP_AF(void) { M_POP(AF);}

void f_JP(void) { M_JP;}
void f_JR(void) { M_JR;}
void f_CALL(void) { M_CALL;}
void f_RET(void) { M_RET;}
void f_SCF(void) { S(C_FLAG);R(N_FLAG|H_FLAG);}
void f_CPL(void) { R.AF.B.h=~R.AF.B.h;S(N_FLAG|H_FLAG);}
void f_CCF(void) { R.AF.B.l^=C_FLAG;R(N_FLAG);}
void f_NOP(void) { }
void f_EI(void) { R.IFF|=0x01;}
void f_DI(void) { R.IFF&=0xFE;}

void f_LD_B_B(void) { R.BC.B.h=R.BC.B.h;}
void f_LD_C_B(void) { R.BC.B.l=R.BC.B.h;}
void f_LD_D_B(void) { R.DE.B.h=R.BC.B.h;}
void f_LD_E_B(void) { R.DE.B.l=R.BC.B.h;}
void f_LD_H_B(void) { R.HL.B.h=R.BC.B.h;}
void f_LD_L_B(void) { R.HL.B.l=R.BC.B.h;}
void f_LD_A_B(void) { R.AF.B.h=R.BC.B.h;}
void f_LD_xHL_B(void) { M_WRMEM(R.HL.W,R.BC.B.h);}

void f_LD_B_C(void) { R.BC.B.h=R.BC.B.l;}
void f_LD_C_C(void) { R.BC.B.l=R.BC.B.l;}
void f_LD_D_C(void) { R.DE.B.h=R.BC.B.l;}
void f_LD_E_C(void) { R.DE.B.l=R.BC.B.l;}
void f_LD_H_C(void) { R.HL.B.h=R.BC.B.l;}
void f_LD_L_C(void) { R.HL.B.l=R.BC.B.l;}
void f_LD_A_C(void) { R.AF.B.h=R.BC.B.l;}
void f_LD_xHL_C(void) { M_WRMEM(R.HL.W,R.BC.B.l);}

void f_LD_B_D(void) { R.BC.B.h=R.DE.B.h;}
void f_LD_C_D(void) { R.BC.B.l=R.DE.B.h;}
void f_LD_D_D(void) { R.DE.B.h=R.DE.B.h;}
void f_LD_E_D(void) { R.DE.B.l=R.DE.B.h;}
void f_LD_H_D(void) { R.HL.B.h=R.DE.B.h;}
void f_LD_L_D(void) { R.HL.B.l=R.DE.B.h;}
void f_LD_A_D(void) { R.AF.B.h=R.DE.B.h;}
void f_LD_xHL_D(void) { M_WRMEM(R.HL.W,R.DE.B.h);}

void f_LD_B_E(void) { R.BC.B.h=R.DE.B.l;}
void f_LD_C_E(void) { R.BC.B.l=R.DE.B.l;}
void f_LD_D_E(void) { R.DE.B.h=R.DE.B.l;}
void f_LD_E_E(void) { R.DE.B.l=R.DE.B.l;}
void f_LD_H_E(void) { R.HL.B.h=R.DE.B.l;}
void f_LD_L_E(void) { R.HL.B.l=R.DE.B.l;}
void f_LD_A_E(void) { R.AF.B.h=R.DE.B.l;}
void f_LD_xHL_E(void) { M_WRMEM(R.HL.W,R.DE.B.l);}

void f_LD_B_H(void) { R.BC.B.h=R.HL.B.h;}
void f_LD_C_H(void) { R.BC.B.l=R.HL.B.h;}
void f_LD_D_H(void) { R.DE.B.h=R.HL.B.h;}
void f_LD_E_H(void) { R.DE.B.l=R.HL.B.h;}
void f_LD_H_H(void) { R.HL.B.h=R.HL.B.h;}
void f_LD_L_H(void) { R.HL.B.l=R.HL.B.h;}
void f_LD_A_H(void) { R.AF.B.h=R.HL.B.h;}
void f_LD_xHL_H(void) { M_WRMEM(R.HL.W,R.HL.B.h);}

void f_LD_B_L(void) { R.BC.B.h=R.HL.B.l;}
void f_LD_C_L(void) { R.BC.B.l=R.HL.B.l;}
void f_LD_D_L(void) { R.DE.B.h=R.HL.B.l;}
void f_LD_E_L(void) { R.DE.B.l=R.HL.B.l;}
void f_LD_H_L(void) { R.HL.B.h=R.HL.B.l;}
void f_LD_L_L(void) { R.HL.B.l=R.HL.B.l;}
void f_LD_A_L(void) { R.AF.B.h=R.HL.B.l;}
void f_LD_xHL_L(void) { M_WRMEM(R.HL.W,R.HL.B.l);}

void f_LD_B_A(void) { R.BC.B.h=R.AF.B.h;}
void f_LD_C_A(void) { R.BC.B.l=R.AF.B.h;}
void f_LD_D_A(void) { R.DE.B.h=R.AF.B.h;}
void f_LD_E_A(void) { R.DE.B.l=R.AF.B.h;}
void f_LD_H_A(void) { R.HL.B.h=R.AF.B.h;}
void f_LD_L_A(void) { R.HL.B.l=R.AF.B.h;}
void f_LD_A_A(void) { R.AF.B.h=R.AF.B.h;}
void f_LD_xHL_A(void) { M_WRMEM(R.HL.W,R.AF.B.h);}

void f_LD_xBC_A(void) { M_WRMEM(R.BC.W,R.AF.B.h);}
void f_LD_xDE_A(void) { M_WRMEM(R.DE.W,R.AF.B.h);}

void f_LD_B_xHL(void) {R.BC.B.h=*(RAM+R.HL.W);}
void f_LD_C_xHL(void) {R.BC.B.l=*(RAM+R.HL.W);}
void f_LD_D_xHL(void) {R.DE.B.h=*(RAM+R.HL.W);}
void f_LD_E_xHL(void) {R.DE.B.l=*(RAM+R.HL.W);}
void f_LD_H_xHL(void) {R.HL.B.h=*(RAM+R.HL.W);}
void f_LD_L_xHL(void) {R.HL.B.l=*(RAM+R.HL.W);}
void f_LD_A_xHL(void) {R.AF.B.h=*(RAM+R.HL.W);}

void f_LD_B_BYTE(void) { R.BC.B.h=*(RAM+(R.PC.W++));}
void f_LD_C_BYTE(void) { R.BC.B.l=*(RAM+(R.PC.W++));}
void f_LD_D_BYTE(void) { R.DE.B.h=*(RAM+(R.PC.W++));}
void f_LD_E_BYTE(void) { R.DE.B.l=*(RAM+(R.PC.W++));}
void f_LD_H_BYTE(void) { R.HL.B.h=*(RAM+(R.PC.W++));}
void f_LD_L_BYTE(void) { R.HL.B.l=*(RAM+(R.PC.W++));}
void f_LD_A_BYTE(void) { R.AF.B.h=*(RAM+(R.PC.W++));}
void f_LD_xHL_BYTE(void) { I=*(RAM+(R.PC.W++));M_WRMEM(R.HL.W,I);}

void f_EX_HL_xSP(void)
{
  J.B.l=*(RAM+R.SP.W);M_WRMEM(R.SP.W,R.HL.B.l);R.SP.W++;
  J.B.h=*(RAM+R.SP.W);M_WRMEM(R.SP.W,R.HL.B.h);R.SP.W--;
  R.HL.W=J.W;
}

void f_DAA(void)
{
  J.B.h=R.AF.B.h&0x0F;
  J.W=(R.AF.B.l&N_FLAG)?
  (
    (R.AF.B.l&C_FLAG)?
      (((R.AF.B.l&H_FLAG)? 0x9A00:0xA000)+C_FLAG):
      ((R.AF.B.l&H_FLAG)? 0xFA00:0x0000)
  )
  :
  (
    (R.AF.B.l&C_FLAG)?
      (((R.AF.B.l&H_FLAG)? 0x6600:((J.B.h<0x0A)? 0x6000:0x6600))+C_FLAG):
      (
        (R.AF.B.l&H_FLAG)?
          ((R.AF.B.h<0xA0)? 0x0600:(0x6600+C_FLAG)):
          (
            (J.B.h<0x0A)? 
              ((R.AF.B.h<0xA0)? 0x0000:(0x6000+C_FLAG)): 
	      ((R.AF.B.h<0x90)? 0x0600:(0x6600+C_FLAG))
          )
      )
  );
  R.AF.B.h+=J.B.h;
  FLAGS(R.AF.B.h,J.B.l|(R.AF.B.l&N_FLAG));
}

void f_UNIMPLEMENTED(void) {} /* dummy function for unimplemented opcodes */

void (*(JumpTab[]))(void) =
{
  &f_NOP,&f_LD_BC_WORD,&f_LD_xBC_A,&f_INC_BC,&f_INC_B,&f_DEC_B,&f_LD_B_BYTE,&f_RLCA,
  &f_EX_AF_AF,&f_ADD_HL_BC,&f_LD_A_xBC,&f_DEC_BC,&f_INC_C,&f_DEC_C,&f_LD_C_BYTE,&f_RRCA,
  &f_DJNZ,&f_LD_DE_WORD,&f_LD_xDE_A,&f_INC_DE,&f_INC_D,&f_DEC_D,&f_LD_D_BYTE,&f_RLA,
  &f_JR,&f_ADD_HL_DE,&f_LD_A_xDE,&f_DEC_DE,&f_INC_E,&f_DEC_E,&f_LD_E_BYTE,&f_RRA,
  &f_JR_NZ,&f_LD_HL_WORD,&f_LD_xWORD_HL,&f_INC_HL,&f_INC_H,&f_DEC_H,&f_LD_H_BYTE,&f_DAA,
  &f_JR_Z,&f_ADD_HL_HL,&f_LD_HL_xWORD,&f_DEC_HL,&f_INC_L,&f_DEC_L,&f_LD_L_BYTE,&f_CPL,
  &f_JR_NC,&f_LD_SP_WORD,&f_LD_xWORD_A,&f_INC_SP,&f_INC_xHL,&f_DEC_xHL,&f_LD_xHL_BYTE,&f_SCF,
  &f_JR_C,&f_ADD_HL_SP,&f_LD_A_xWORD,&f_DEC_SP,&f_INC_A,&f_DEC_A,&f_LD_A_BYTE,&f_CCF,
  &f_LD_B_B,&f_LD_B_C,&f_LD_B_D,&f_LD_B_E,&f_LD_B_H,&f_LD_B_L,&f_LD_B_xHL,&f_LD_B_A,
  &f_LD_C_B,&f_LD_C_C,&f_LD_C_D,&f_LD_C_E,&f_LD_C_H,&f_LD_C_L,&f_LD_C_xHL,&f_LD_C_A,
  &f_LD_D_B,&f_LD_D_C,&f_LD_D_D,&f_LD_D_E,&f_LD_D_H,&f_LD_D_L,&f_LD_D_xHL,&f_LD_D_A,
  &f_LD_E_B,&f_LD_E_C,&f_LD_E_D,&f_LD_E_E,&f_LD_E_H,&f_LD_E_L,&f_LD_E_xHL,&f_LD_E_A,
  &f_LD_H_B,&f_LD_H_C,&f_LD_H_D,&f_LD_H_E,&f_LD_H_H,&f_LD_H_L,&f_LD_H_xHL,&f_LD_H_A,
  &f_LD_L_B,&f_LD_L_C,&f_LD_L_D,&f_LD_L_E,&f_LD_L_H,&f_LD_L_L,&f_LD_L_xHL,&f_LD_L_A,
  &f_LD_xHL_B,&f_LD_xHL_C,&f_LD_xHL_D,&f_LD_xHL_E,&f_LD_xHL_H,&f_LD_xHL_L,&f_HALT,&f_LD_xHL_A,
  &f_LD_A_B,&f_LD_A_C,&f_LD_A_D,&f_LD_A_E,&f_LD_A_H,&f_LD_A_L,&f_LD_A_xHL,&f_LD_A_A,
  &f_ADD_B,&f_ADD_C,&f_ADD_D,&f_ADD_E,&f_ADD_H,&f_ADD_L,&f_ADD_xHL,&f_ADD_A,
  &f_ADC_B,&f_ADC_C,&f_ADC_D,&f_ADC_E,&f_ADC_H,&f_ADC_L,&f_ADC_xHL,&f_ADC_A,
  &f_SUB_B,&f_SUB_C,&f_SUB_D,&f_SUB_E,&f_SUB_H,&f_SUB_L,&f_SUB_xHL,&f_SUB_A,
  &f_SBC_B,&f_SBC_C,&f_SBC_D,&f_SBC_E,&f_SBC_H,&f_SBC_L,&f_SBC_xHL,&f_SBC_A,
  &f_AND_B,&f_AND_C,&f_AND_D,&f_AND_E,&f_AND_H,&f_AND_L,&f_AND_xHL,&f_AND_A,
  &f_XOR_B,&f_XOR_C,&f_XOR_D,&f_XOR_E,&f_XOR_H,&f_XOR_L,&f_XOR_xHL,&f_XOR_A,
  &f_OR_B,&f_OR_C,&f_OR_D,&f_OR_E,&f_OR_H,&f_OR_L,&f_OR_xHL,&f_OR_A,
  &f_CP_B,&f_CP_C,&f_CP_D,&f_CP_E,&f_CP_H,&f_CP_L,&f_CP_xHL,&f_CP_A,
  &f_RET_NZ,&f_POP_BC,&f_JP_NZ,&f_JP,&f_CALL_NZ,&f_PUSH_BC,&f_ADD_BYTE,&f_RST00,
  &f_RET_Z,&f_RET,&f_JP_Z,&f_PFX_CB,&f_CALL_Z,&f_CALL,&f_ADC_BYTE,&f_RST08,
  &f_RET_NC,&f_POP_DE,&f_JP_NC,&f_OUTA,&f_CALL_NC,&f_PUSH_DE,&f_SUB_BYTE,&f_RST10,
  &f_RET_C,&f_EXX,&f_JP_C,&f_INA,&f_CALL_C,&f_PFX_DD,&f_SBC_BYTE,&f_RST18,
  &f_RET_PO,&f_POP_HL,&f_JP_PO,&f_EX_HL_xSP,&f_CALL_PO,&f_PUSH_HL,&f_AND_BYTE,&f_RST20,
  &f_RET_PE,&f_LD_PC_HL,&f_JP_PE,&f_EX_DE_HL,&f_CALL_PE,&f_PFX_ED,&f_XOR_BYTE,&f_RST28,
  &f_RET_P,&f_POP_AF,&f_JP_P,&f_DI,&f_CALL_P,&f_PUSH_AF,&f_OR_BYTE,&f_RST30,
  &f_RET_M,&f_LD_SP_HL,&f_JP_M,&f_EI,&f_CALL_M,&f_PFX_FD,&f_CP_BYTE,&f_RST38
};