#include "stdafx.h"
#include "IWzASM.h"
#include "VMOp/VMOpCPU.h"


struct sMETHOD_REGISTER_HANDLER;

//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
// Àӽà ÄÚµå ¼±¾ð
#undef ADD_IWzASM_HANDLER
#define ADD_IWzASM_HANDLER( codeASM, dataSIZE )	\
	WzRET_T		HANDLER_WzASM_##codeASM( WzASM_EIP& rEIP, uREG_NODE* pNODE )

//#define CALL_IWzASM_HANDLER( codeASM, dataSIZE )	\
//	HANDLER_WzASM_##codeASM( rEIP, pNODE )

ADD_IWzASM_HANDLER(	MOV_EAX_HASH			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EAX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EAX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = pNODE->EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EAX_PTR				, sizeof(WzPTR)	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.PTR = pNODE->PTR;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EBX_HASH			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EBX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EBX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EBX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = pNODE->EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MOV_EBX_PTR				, sizeof(WzPTR)	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.PTR = pNODE->PTR;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	MOV_EAX_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = rREGISTER.EBX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = rREGISTER.ECX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = rREGISTER.EDX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EBX_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = rREGISTER.EAX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EBX_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = rREGISTER.ECX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EBX_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = rREGISTER.EDX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ECX_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = rREGISTER.EAX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ECX_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = rREGISTER.EBX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ECX_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = rREGISTER.EDX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDX_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = rREGISTER.EAX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDX_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = rREGISTER.EBX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDX_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = rREGISTER.ECX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = rREGISTER.ERP;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EBX_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = rREGISTER.ERP;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ECX_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = rREGISTER.ERP;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDX_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = rREGISTER.ERP;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ERP_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = rREGISTER.EAX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = rREGISTER.EBX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = rREGISTER.ECX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = rREGISTER.EDX;
	return sRET::SUCCESS;;
}


//////////////////////////////////////////////////////////////////////////


ADD_IWzASM_HANDLER(	MOV_EAX0_B1			, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = pNODE->L;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_B1			, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = pNODE->L;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_B1			, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = pNODE->L;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_B1			, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = pNODE->L;
	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MOV_EAX0_B2			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_B2			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_B2			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_B2			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = pNODE->X;
	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MOV_EAX0_B4			, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = pNODE->EX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_B4			, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = pNODE->EX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_B4			, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = pNODE->EX;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_B4			, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = pNODE->EX;
	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MOV_EAX0_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = pNODE->X;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = pNODE->X;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_PTR			, sizeof(WzPTR) )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].PTR = pNODE->PTR;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_PTR			, sizeof(WzPTR) )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].PTR = pNODE->PTR;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_PTR			, sizeof(WzPTR) )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].PTR = pNODE->PTR;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_PTR			, sizeof(WzPTR) )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].PTR = pNODE->PTR;
	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA4B1		, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BYTE array[4];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	rEAX.EXA[3].EX = array[3];

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA4B2		, 8 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[4];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	rEAX.EXA[3].EX = array[3];

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA4B4		, 16 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;


	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = pNODE->EXA[0].EX;
	rEAX.EXA[1].EX = pNODE->EXA[1].EX;
	rEAX.EXA[2].EX = pNODE->EXA[2].EX;
	rEAX.EXA[3].EX = pNODE->EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA4HS		, 8 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[4];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	rEAX.EXA[3].EX = array[3];

	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MOV_EAX_EXA3B1		, 3 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BYTE array[3];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA3B2		, 6 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[3];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA3B4		, 12 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	DWORD array[3];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = pNODE->EXA[0].EX;
	rEAX.EXA[1].EX = pNODE->EXA[1].EX;
	rEAX.EXA[2].EX = pNODE->EXA[2].EX;
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA3HS		, 6 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[3];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	rEAX.EXA[2].EX = array[2];
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MOV_EAX_EXA2B1		, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BYTE array[2];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	//rEAX.EXA[2].EX = 0;
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA2B2		, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[2];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	//rEAX.EXA[2].EX = 0;
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA2B4		, 8 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	DWORD array[2];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = pNODE->EXA[0].EX;
	rEAX.EXA[1].EX = pNODE->EXA[1].EX;
	//rEAX.EXA[2].EX = 0;
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX_EXA2HS		, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD array[2];
	CopyMemory( array, pNODE, sizeof(array) );
	uREG_NODE& rEAX = rREGISTER.EAX;
	rEAX.EXA[0].EX = array[0];
	rEAX.EXA[1].EX = array[1];
	//rEAX.EXA[2].EX = 0;
	//rEAX.EXA[3].EX = 0;

	return sRET::SUCCESS;;
}

//////////////////////////////////////////////////////////////////////////
ADD_IWzASM_HANDLER(	MOV_EAX0_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX0_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_ERP0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.ERP.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_ERP1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.ERP.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_ERP2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.ERP.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX0_ERP3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[0].EX = rREGISTER.ERP.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX1_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_ERP0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.ERP.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_ERP1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.ERP.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_ERP2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.ERP.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX1_ERP3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[1].EX = rREGISTER.ERP.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX2_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_ERP0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.ERP.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_ERP1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.ERP.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_ERP2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.ERP.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX2_ERP3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[2].EX = rREGISTER.ERP.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EAX3_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_ERP0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.ERP.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_ERP1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.ERP.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_ERP2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.ERP.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX3_ERP3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EXA[3].EX = rREGISTER.ERP.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ERP0_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP0_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ERP1_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP1_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[1].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ERP2_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP2_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[2].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_ERP3_EAX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EAX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EAX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EAX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EAX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EAX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EAX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EAX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EBX0			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EBX.EXA[0].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EBX1			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EBX.EXA[1].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EBX2			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EBX.EXA[2].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP3_EBX3			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[3].EX = rREGISTER.EBX.EXA[3].EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EAX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = rREGISTER.EOP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EBX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = rREGISTER.EOP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ECX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = rREGISTER.EOP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = rREGISTER.EOP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERP_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = rREGISTER.EOP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = rREGISTER.EAX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = rREGISTER.EBX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = rREGISTER.ECX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = rREGISTER.EDX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = rREGISTER.ERP;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EOP_OFF				, 4 )
{
	// EOP1 = sCAL(OP,DT)
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP.EXA[1].EOPC = pNODE->EOPC;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EFP_EAX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = rREGISTER.EAX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EFP_EBX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = rREGISTER.EBX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EFP_ECX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = rREGISTER.ECX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EFP_EDX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = rREGISTER.EDX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EFP_ERP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = rREGISTER.ERP;

	return sRET::SUCCESS;;
}

///


ADD_IWzASM_HANDLER(	MOV_EAXE_EABCDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERPE_EABCDX		, 0);
	CALL_IWzASM_HANDLER(MOV_EAX_ERP			, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EBXE_EABCDX	, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERPE_EABCDX		, 0);
	CALL_IWzASM_HANDLER(MOV_EBX_ERP			, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ECXE_EABCDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERPE_EABCDX		, 0);
	CALL_IWzASM_HANDLER(MOV_ECX_ERP			, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EDXE_EABCDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERPE_EABCDX		, 0);
	CALL_IWzASM_HANDLER(MOV_EDX_ERP			, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_ERPE_EABCDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EXA[0].EX = rREGISTER.EAX.EX;
	rREGISTER.ERP.EXA[1].EX = rREGISTER.EBX.EX;
	rREGISTER.ERP.EXA[2].EX = rREGISTER.ECX.EX;
	rREGISTER.ERP.EXA[3].EX = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOV_EABCDX_EAXE			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERP_EAX			, 0);
	CALL_IWzASM_HANDLER(MOV_EABCDX_ERPE		, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EABCDX_EBXE			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERP_EBX			, 0);
	CALL_IWzASM_HANDLER(MOV_EABCDX_ERPE		, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EABCDX_ECXE			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERP_ECX			, 0);
	CALL_IWzASM_HANDLER(MOV_EABCDX_ERPE		, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EABCDX_EDXE			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(MOV_ERP_EDX			, 0);
	CALL_IWzASM_HANDLER(MOV_EABCDX_ERPE		, 0);

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOV_EABCDX_ERPE			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = rREGISTER.ERP.EXA[0].EX;
	rREGISTER.EBX.EX = rREGISTER.ERP.EXA[1].EX;
	rREGISTER.ECX.EX = rREGISTER.ERP.EXA[2].EX;
	rREGISTER.EDX.EX = rREGISTER.ERP.EXA[3].EX;

	return sRET::SUCCESS;;
}

//////////////////////////////////////////////////////////////////////////


ADD_IWzASM_HANDLER(	MOVP_EAX_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRD = rREGISTER.EBX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRW = rREGISTER.EBX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRB = rREGISTER.EBX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRD = rREGISTER.ECX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRW = rREGISTER.ECX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRB = rREGISTER.ECX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRD = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRW = rREGISTER.EDX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRB = rREGISTER.EDX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRD = rREGISTER.ERP.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRW = rREGISTER.ERP.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EAX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EAX.PTRB = rREGISTER.ERP.L;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVP_EBX_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRD = rREGISTER.EAX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRW = rREGISTER.EAX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRB = rREGISTER.EAX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRD = rREGISTER.ECX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRW = rREGISTER.ECX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRB = rREGISTER.ECX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRD = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRW = rREGISTER.EDX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRB = rREGISTER.EDX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRD = rREGISTER.ERP.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRW = rREGISTER.ERP.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EBX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EBX.PTRB = rREGISTER.ERP.L;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVP_ECX_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRD = rREGISTER.EAX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRW = rREGISTER.EAX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRB = rREGISTER.EAX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRD = rREGISTER.EBX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRW = rREGISTER.EBX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRB = rREGISTER.EBX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRD = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRW = rREGISTER.EDX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRB = rREGISTER.EDX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRD = rREGISTER.ERP.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRW = rREGISTER.ERP.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ECX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ECX.PTRB = rREGISTER.ERP.L;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVP_EDX_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRD = rREGISTER.EAX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRW = rREGISTER.EAX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRB = rREGISTER.EAX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRD = rREGISTER.EBX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRW = rREGISTER.EBX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRB = rREGISTER.EBX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRD = rREGISTER.ECX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRW = rREGISTER.ECX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRB = rREGISTER.ECX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRD = rREGISTER.ERP.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRW = rREGISTER.ERP.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EDX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EDX.PTRB = rREGISTER.ERP.L;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVP_ERP_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRD = rREGISTER.EAX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRW = rREGISTER.EAX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRB = rREGISTER.EAX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRD = rREGISTER.EBX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRW = rREGISTER.EBX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRB = rREGISTER.EBX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRD = rREGISTER.ECX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRW = rREGISTER.ECX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRB = rREGISTER.ECX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRD = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRW = rREGISTER.EDX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_ERP_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.ERP.PTRB = rREGISTER.EDX.L;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVP_EOP_B1				, 1 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = pNODE->L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_B2				, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = pNODE->X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = pNODE->EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = rREGISTER.EAX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = rREGISTER.EAX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = rREGISTER.EAX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = rREGISTER.EBX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = rREGISTER.EBX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = rREGISTER.EBX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = rREGISTER.ECX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = rREGISTER.ECX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = rREGISTER.ECX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = rREGISTER.EDX.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = rREGISTER.EDX.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = rREGISTER.EDX.L;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRD = rREGISTER.ERP.EX;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRW = rREGISTER.ERP.X;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVP_EOP_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	*rREGISTER.EOP.PTRB = rREGISTER.ERP.L;

	return sRET::SUCCESS;;
}

//////////////////////////////////////////////////////////////////////////

ADD_IWzASM_HANDLER(	MOVX_EAX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EAX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EAX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EAX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EBX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EBX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EBX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ECX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ECX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ECX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EDX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EDX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ERP.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ERP.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.ERP.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EAX_EOP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = *rREGISTER.EOP.PTRD;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVX_EBX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EAX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EAX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EAX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EBX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EBX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EBX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ECX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ECX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ECX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EDX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EDX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ERP.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ERP.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.ERP.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EBX_EOP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX = *rREGISTER.EOP.PTRD;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVX_ECX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EAX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EAX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EAX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EBX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EBX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EBX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ECX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ECX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ECX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EDX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EDX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ERP.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ERP.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.ERP.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_ECX_EOP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX = *rREGISTER.EOP.PTRD;

	return sRET::SUCCESS;;
}


ADD_IWzASM_HANDLER(	MOVX_EDX_EAX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EAX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_AX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EAX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_AL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EAX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_EBX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EBX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_BX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EBX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_BL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EBX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_ECX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ECX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_CX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ECX.PTRW;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_CL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ECX.PTRB;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_EDX			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_DX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_DL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EDX.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_ERP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ERP.PTRD;

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_PX				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ERP.PTRW;

		return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_PL				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.ERP.PTRB;

		return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	MOVX_EDX_EOP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX = *rREGISTER.EOP.PTRD;

	return sRET::SUCCESS;;
}

//////////////////////////////////////////////////////////////////////////

ADD_IWzASM_HANDLER(	PUSH_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EAX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EBX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.ECX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EDX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_ERP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.ERP );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_EFP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EFP );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_EOP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EOP );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	PUSH_GPR				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.StoreGPR( VM_REGISTER );
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	PUSH_EABCDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.Push( rREGISTER.EDX );
	VM_STACK.Push( rREGISTER.ECX );
	VM_STACK.Push( rREGISTER.EBX );
	VM_STACK.Push( rREGISTER.EAX );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	PUSH_B1				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uARG;
	uARG.EX = pNODE->L;
	VM_STACK.Push( uARG );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	PUSH_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uARG;
	uARG.EX = pNODE->X;
	VM_STACK.Push( uARG );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	PUSH_B4				, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uARG;
	uARG.EX = pNODE->EX;
	VM_STACK.Push( uARG );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	PUSH_HASH				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uARG;
	uARG.EX = pNODE->X;
	VM_STACK.Push( uARG );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	POP_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_EBX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_ECX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_EDX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_ERP					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_EFP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EFP = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_EOP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP = VM_STACK.Pop();
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	POP_GPR					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_STACK.LoadGPR( VM_REGISTER );
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	POP_EABCDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX = VM_STACK.Pop();
	rREGISTER.EBX = VM_STACK.Pop();
	rREGISTER.ECX = VM_STACK.Pop();
	rREGISTER.EDX = VM_STACK.Pop();

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	CLR_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX ^= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLR_EBX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX ^= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLR_ECX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX ^= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLR_EDX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX ^= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLR_ERP					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ERP.EX ^= rREGISTER.ERP.EX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	CLR_EOP					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.EOP), sizeof(rREGISTER.EOP) );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	CLR_EABCDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(	CLR_EAX			, 0	);
	CALL_IWzASM_HANDLER(	CLR_EBX			, 0	);
	CALL_IWzASM_HANDLER(	CLR_ECX			, 0	);
	CALL_IWzASM_HANDLER(	CLR_EDX			, 0	);

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLRA_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.EAX), sizeof(rREGISTER.EAX) );

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CLRA_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.EBX), sizeof(rREGISTER.EBX) );

	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	CLRA_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.ECX), sizeof(rREGISTER.ECX) );

	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	CLRA_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.EDX), sizeof(rREGISTER.EDX) );

	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	CLRA_ERP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.ERP), sizeof(rREGISTER.ERP) );

	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	CLRA_EOP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	ZeroMemory( &(rREGISTER.EOP), sizeof(rREGISTER.EOP) );

	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	CLRA_EABCDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	CALL_IWzASM_HANDLER(	CLRA_EAX		, 0	);
	CALL_IWzASM_HANDLER(	CLRA_EBX		, 0	);
	CALL_IWzASM_HANDLER(	CLRA_ECX		, 0	);
	CALL_IWzASM_HANDLER(	CLRA_EDX		, 0	);

	return sRET::SUCCESS;;
};



ADD_IWzASM_HANDLER(	XOR_EAX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX ^= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	XOR_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX ^= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	XOR_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX ^= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	XOR_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX ^= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};



ADD_IWzASM_HANDLER(	AND_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX &= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	AND_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX &= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	AND_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX &= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	OR_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX |= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	OR_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX |= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	OR_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX |= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	NOT_EAX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = !rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	NOT_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = !rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	NOT_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = !rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	NOT_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = !rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMPL_EAX_EAX			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = ~rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMPL_EAX_EBX			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = ~rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMPL_EAX_ECX			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = ~rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMPL_EAX_EDX			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX = ~rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	SHR_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX >>= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHR_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX >>= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHR_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX >>= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHR_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX >>= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHL_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX <<= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHL_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX <<= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHL_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX <<= rREGISTER.ECX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SHL_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX <<= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

#define CALC_RORB_IDX(idx)	( ((idx)+1) % 4 )
ADD_IWzASM_HANDLER(	RORB_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EAX.EXA[CALC_RORB_IDX(3)];
	rREGISTER.EAX.EXA[CALC_RORB_IDX(3)] = rREGISTER.EAX.EXA[3];
	rREGISTER.EAX.EXA[CALC_RORB_IDX(2)] = rREGISTER.EAX.EXA[2];
	rREGISTER.EAX.EXA[CALC_RORB_IDX(1)] = rREGISTER.EAX.EXA[1];
	rREGISTER.EAX.EXA[CALC_RORB_IDX(0)] = rBK;

	return sRET::SUCCESS;
}


ADD_IWzASM_HANDLER(	RORB_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EBX.EXA[CALC_RORB_IDX(3)];
	rREGISTER.EBX.EXA[CALC_RORB_IDX(3)] = rREGISTER.EBX.EXA[3];
	rREGISTER.EBX.EXA[CALC_RORB_IDX(2)] = rREGISTER.EBX.EXA[2];
	rREGISTER.EBX.EXA[CALC_RORB_IDX(1)] = rREGISTER.EBX.EXA[1];
	rREGISTER.EBX.EXA[CALC_RORB_IDX(0)] = rBK;

	return sRET::SUCCESS;
}


ADD_IWzASM_HANDLER(	RORB_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.ECX.EXA[CALC_RORB_IDX(3)];
	rREGISTER.ECX.EXA[CALC_RORB_IDX(3)] = rREGISTER.ECX.EXA[3];
	rREGISTER.ECX.EXA[CALC_RORB_IDX(2)] = rREGISTER.ECX.EXA[2];
	rREGISTER.ECX.EXA[CALC_RORB_IDX(1)] = rREGISTER.ECX.EXA[1];
	rREGISTER.ECX.EXA[CALC_RORB_IDX(0)] = rBK;

	return sRET::SUCCESS;
}


ADD_IWzASM_HANDLER(	RORB_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EDX.EXA[CALC_RORB_IDX(3)];
	rREGISTER.EDX.EXA[CALC_RORB_IDX(3)] = rREGISTER.EDX.EXA[3];
	rREGISTER.EDX.EXA[CALC_RORB_IDX(2)] = rREGISTER.EDX.EXA[2];
	rREGISTER.EDX.EXA[CALC_RORB_IDX(1)] = rREGISTER.EDX.EXA[1];
	rREGISTER.EDX.EXA[CALC_RORB_IDX(0)] = rBK;

	return sRET::SUCCESS;
}

#define CALC_ROLB_IDX(idx)	( ((idx)+3) % 4 )

ADD_IWzASM_HANDLER(	ROLB_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EAX.EXA[3];
	rREGISTER.EAX.EXA[CALC_ROLB_IDX(0)] = rREGISTER.EAX.EXA[0];
	rREGISTER.EAX.EXA[CALC_ROLB_IDX(1)] = rREGISTER.EAX.EXA[1];
	rREGISTER.EAX.EXA[CALC_ROLB_IDX(2)] = rREGISTER.EAX.EXA[2];
	rREGISTER.EAX.EXA[CALC_ROLB_IDX(3)] = rBK;

	return sRET::SUCCESS;
}
ADD_IWzASM_HANDLER(	ROLB_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EBX.EXA[3];
	rREGISTER.EBX.EXA[CALC_ROLB_IDX(0)] = rREGISTER.EBX.EXA[0];
	rREGISTER.EBX.EXA[CALC_ROLB_IDX(1)] = rREGISTER.EBX.EXA[1];
	rREGISTER.EBX.EXA[CALC_ROLB_IDX(2)] = rREGISTER.EBX.EXA[2];
	rREGISTER.EBX.EXA[CALC_ROLB_IDX(3)] = rBK;

	return sRET::SUCCESS;
}
ADD_IWzASM_HANDLER(	ROLB_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.ECX.EXA[3];
	rREGISTER.ECX.EXA[CALC_ROLB_IDX(0)] = rREGISTER.ECX.EXA[0];
	rREGISTER.ECX.EXA[CALC_ROLB_IDX(1)] = rREGISTER.ECX.EXA[1];
	rREGISTER.ECX.EXA[CALC_ROLB_IDX(2)] = rREGISTER.ECX.EXA[2];
	rREGISTER.ECX.EXA[CALC_ROLB_IDX(3)] = rBK;

	return sRET::SUCCESS;
}
ADD_IWzASM_HANDLER(	ROLB_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uCONV rBK = rREGISTER.EDX.EXA[3];
	rREGISTER.EDX.EXA[CALC_ROLB_IDX(0)] = rREGISTER.EDX.EXA[0];
	rREGISTER.EDX.EXA[CALC_ROLB_IDX(1)] = rREGISTER.EDX.EXA[1];
	rREGISTER.EDX.EXA[CALC_ROLB_IDX(2)] = rREGISTER.EDX.EXA[2];
	rREGISTER.EDX.EXA[CALC_ROLB_IDX(3)] = rBK;

	return sRET::SUCCESS;
}


ADD_IWzASM_HANDLER(	ADD_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX += rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX += rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX += pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EAX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX += pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EAX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX += pNODE->EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EBX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX += rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EBX_B1				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX += pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EBX_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX += pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_EBX_B4				, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX += pNODE->EX;
	return sRET::SUCCESS;;
};



ADD_IWzASM_HANDLER(	ADD_ECX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX += rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_ECX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX += rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_ECX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX += rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	ADD_ECX_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX += pNODE->X;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	ADD_EDX_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX += pNODE->X;
	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	SUB_ECX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX -= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	SUB_ECX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX -= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	SUB_ECX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX -= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	MUL_ECX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX *= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_ECX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX *= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_ECX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX *= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	DIV_ECX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX /= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_ECX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX /= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_ECX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX /= rREGISTER.EDX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	SUB_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX -= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX -= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX -= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EAX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX -= pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EAX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX -= pNODE->EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EBX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX -= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EBX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX -= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EBX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX -= pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_EBX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EBX.EX -= pNODE->EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	SUB_ECX_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.ECX.EX -= pNODE->X;
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	SUB_EDX_B2				, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EDX.EX -= pNODE->X;
	return sRET::SUCCESS;;
}



ADD_IWzASM_HANDLER(	MUL_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX *= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX *= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX *= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_EAX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX *= pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MUL_EAX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX *= pNODE->EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	DIV_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX /= rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX /= rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_EAX_B1			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX /= pNODE->L;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_EAX_B2			, 2	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX /= pNODE->X;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DIV_EAX_B4			, 4	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EAX.EX /= pNODE->EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	INC_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	++rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	INC_EBX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	++rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	DEC_EAX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	--rREGISTER.EAX.EX;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	DEC_EBX					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	--rREGISTER.EBX.EX;
	return sRET::SUCCESS;;
};


ADD_IWzASM_HANDLER(	TEST_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET =
		(rREGISTER.EAX.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	TEST_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = 
		(rREGISTER.EBX.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	TEST_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = 
		(rREGISTER.ECX.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	TEST_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = 
		(rREGISTER.EDX.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	TEST_ERP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = 
		(rREGISTER.ERP.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	TEST_EOP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = 
		(rREGISTER.EOP.EX != 0) ? sREG_NODE_BITS::RET_NOTZERO : sREG_NODE_BITS::RET_ZERO;
	return sRET::SUCCESS;;
};

//////////////////////////////////////////////////////////////////////////

static sREG_NODE_BITS::eCMP		ComapreResult( DWORD dw1, DWORD dw2 )
{
	if( dw1 == dw2 )
		return sREG_NODE_BITS::EQUAL;
	else if( dw1 < dw2 )
		return sREG_NODE_BITS::BELOW;

	return sREG_NODE_BITS::ABOVE;
}

static VOID						JumpAddress( WzASM_EIP& rEIP, WORD jCODE, BOOL bRET )
{
	if( bRET )
	{
		OPW_T* ptr = rEIP.FindAddress( jCODE );
		if( ptr )
		{
			rEIP.OP.OFFSET.JMP( ptr );// .OffsetPtr() = (BYTE*)ptr;
		}
	}
	else
		rEIP.OP.OFFSET.INC( 0 );
}

ADD_IWzASM_HANDLER(	CMP_EAX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, rREGISTER.EBX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_ECX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, rREGISTER.ECX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, rREGISTER.EDX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_ERP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, rREGISTER.ERP.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_EAX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, rREGISTER.EAX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_EBX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, rREGISTER.EBX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_EDX				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, rREGISTER.EDX.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_ERP				, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, rREGISTER.ERP.EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_B1			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, pNODE->EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_B2			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, pNODE->X );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_EAX_B4			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.EAX.EX, pNODE->L );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_B1			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, pNODE->EX );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_B2			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, pNODE->X );
	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	CMP_ECX_B4			, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	VM_EFL.FLAG.TEST_RET = ComapreResult( rREGISTER.ECX.EX, pNODE->L );
	return sRET::SUCCESS;;
};


static BOOL		FindJumpMark( OPB_T bJmpMark, OPW_T& rwCODE )
{
	WzASM_VMCore& rCORE = VMCORE_INTERFACE;
	WzASM_VMCore::JAT_MATCH_IT itFIND = rCORE.JAT_MATCH_TABLE().find( bJmpMark );
	if( itFIND != rCORE.JAT_MATCH_TABLE().end() )
	{
		WzASM_VMCore::sJAT_MATCH*& rpMATCH = itFIND->second;
		rwCODE = rpMATCH->ASMOP;
		return TRUE;
	}

	return FALSE;
}

ADD_IWzASM_HANDLER(	JZEROEQUAL				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET == sREG_NODE_BITS::RET_ZERO )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JZERONOTEQUAL			, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET == sREG_NODE_BITS::RET_NOTZERO )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JBELOW					, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET == sREG_NODE_BITS::BELOW )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JNOTBELOW				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET != sREG_NODE_BITS::BELOW )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JABOVE					, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET == sREG_NODE_BITS::ABOVE )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JNOTABOVE				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET != sREG_NODE_BITS::ABOVE )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JEQUAL					, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET == sREG_NODE_BITS::EQUAL )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
}

ADD_IWzASM_HANDLER(	JNOTEQUAL				, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	BOOL bRET = FALSE;
	if( VM_EFL.FLAG.TEST_RET != sREG_NODE_BITS::EQUAL )
		bRET = TRUE;

	OPW_T wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		JumpAddress( rEIP, wCODE, bRET );
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
}

ADD_IWzASM_HANDLER(	JUMP					, 1	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WORD wCODE;
	if( FindJumpMark( pNODE->L, wCODE ) )
	{
		OPW_T* ptr = rEIP.FindAddress( wCODE );
		if( ptr )
		{
			rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
			return sRET::SUCCESS;;
		}
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP1					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK01 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP2					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK02 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP3					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK03 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP4					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK04 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP5					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK05 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP6					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK06 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP7					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK07 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP8					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK08 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP9					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK09 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP10					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK10 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP11					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK11 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP12					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK12 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP13					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK13 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP14					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK14 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP15					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK15 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP16					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK16 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP17					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK17 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP18					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK18 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	JUMP19					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	OPW_T* ptr = rEIP.FindAddress( IWzASM::MARK19 );
	if( ptr )
	{
		rEIP.OP.OFFSET.JMP( ptr );//rEIP.OP.OffsetPtr() = (BYTE*)ptr;
		return sRET::SUCCESS;;
	}
	return sRET::FAIL;
};



//ADD_IWzASM_HANDLER(	LEA_ECX					, 0 )
//{
//	DEBUGGING_OUTPUT();
//	sREGISTER_BLK& rREGISTER = VM_REGISTER;
//	WzASM_STACK& rSTACK = VM_STACK;
//
//	rREGISTER.ECX = rEIP.REF.Find( rREGISTER.EAX.X );
//	return sRET::SUCCESS;;
//};
//
//ADD_IWzASM_HANDLER(	LEA_ECX_HASH			, 2 )
//{
//	DEBUGGING_OUTPUT();
//	sREGISTER_BLK& rREGISTER = VM_REGISTER;
//	WzASM_STACK& rSTACK = VM_STACK;
//
//	rREGISTER.ECX = rEIP.REF.Find( pNODE->X );
//	return sRET::SUCCESS;;
//};
//
//ADD_IWzASM_HANDLER(	LEA_EDX					, 0 )
//{
//	DEBUGGING_OUTPUT();
//	sREGISTER_BLK& rREGISTER = VM_REGISTER;
//	WzASM_STACK& rSTACK = VM_STACK;
//
//	rREGISTER.EDX = rEIP.REF.Find( rREGISTER.EAX.X );
//	return sRET::SUCCESS;;
//};
//
//ADD_IWzASM_HANDLER(	LEA_EDX_HASH			, 2 )
//{
//	DEBUGGING_OUTPUT();
//	sREGISTER_BLK& rREGISTER = VM_REGISTER;
//	WzASM_STACK& rSTACK = VM_STACK;
//
//	rREGISTER.EDX = rEIP.REF.Find( pNODE->X );
//	return sRET::SUCCESS;;
//};

ADD_IWzASM_HANDLER(	LEA_EFP_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	WzASM_VMCore& VMCORE = VMCORE_INTERFACE;

	WzASM_VMCore::IBF_HASH_MAP_IT itFIND = VMCORE.IBF_TABLE().find( pNODE->X );
	if( itFIND != VMCORE.IBF_TABLE().end() )
	{
		rREGISTER.EFP.EXA[sARG::ARG0].PTR = itFIND->second;
		return sRET::SUCCESS;;
	}

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	LEA_REF_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	IWzASM_PROC uRES = VMCORE_INTERFACE.FindGResHandlerInfo( pNODE->X );
	rEIP.Register_REF( uRES );

	if( NULL == uRES.RESFUNC )
		return sRET::FAIL;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	LEA_EAX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	// (WAVERIX)(NOTE)
	//	- DT SIZE°¡ 0À̸é, DT PTRÀº ÀÌÀü °ªÀ» À¯ÁöÇÑ´Ù.
	//	À¯¿ëÇÒ ¼öµµ ÀÖ°í, À§ÇèÇÒ ¼öµµ ÀÖ´Ù.
	rREGISTER.EAX.PTRB = rREGISTER.EOP.EXA[sARG::ARG0].PTRB;
	cOFF& rCAL = rREGISTER.EOP.EXA[sARG::ARG1].EOPC;

	if( cOFF::ADD == rCAL.OP )
		return CALL_IWzASM_HANDLER( ADD_EAX_B2,	2 );
	if( cOFF::SUB == rCAL.OP )
		return CALL_IWzASM_HANDLER( SUB_EAX_B2,	2 );
	if( cOFF::NONE == rCAL.OP )
		return sRET::SUCCESS;;

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	LEA_EBX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;


	rREGISTER.EBX.PTRB = rREGISTER.EOP.EXA[sARG::ARG0].PTRB;
	cOFF& rCAL = rREGISTER.EOP.EXA[sARG::ARG1].EOPC;

	if( cOFF::ADD == rCAL.OP )
		return CALL_IWzASM_HANDLER( ADD_EBX_B2,	2 );
	if( cOFF::SUB == rCAL.OP )
		return CALL_IWzASM_HANDLER( SUB_EBX_B2,	2 );
	if( cOFF::NONE == rCAL.OP )
		return sRET::SUCCESS;;

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	LEA_ECX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;


	rREGISTER.ECX.PTRB = rREGISTER.EOP.EXA[sARG::ARG0].PTRB;
	cOFF& rCAL = rREGISTER.EOP.EXA[sARG::ARG1].EOPC;

	if( cOFF::ADD == rCAL.OP )
		return CALL_IWzASM_HANDLER( ADD_ECX_B2,	2 );
	if( cOFF::SUB == rCAL.OP )
		return CALL_IWzASM_HANDLER( SUB_ECX_B2,	2 );
	if( cOFF::NONE == rCAL.OP )
		return sRET::SUCCESS;;

	return sRET::FAIL;
};


ADD_IWzASM_HANDLER(	LEA_EDX_EOP				, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;


	rREGISTER.EDX.PTRB = rREGISTER.EOP.EXA[sARG::ARG0].PTRB;
	cOFF& rCAL = rREGISTER.EOP.EXA[sARG::ARG1].EOPC;

	if( cOFF::ADD == rCAL.OP )
		return CALL_IWzASM_HANDLER( ADD_EDX_B2,	2 );
	if( cOFF::SUB == rCAL.OP )
		return CALL_IWzASM_HANDLER( SUB_EDX_B2,	2 );
	if( cOFF::NONE == rCAL.OP )
		return sRET::SUCCESS;;

	return sRET::FAIL;
};

ADD_IWzASM_HANDLER(	LEA_EOP_HASH			, 2 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	NOT_IMPLEMENTATION();
	//rREGISTER.EOP.EXA[sARG::ARG0].PTR = pNODE->EXA[sARG::ARG0].PTR;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	LEA_EOP_B4				, 4 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;


	// Ãß°¡ ¿¬»ê ¸í·É¾î¸¸ ·Îµù
	rREGISTER.EOP.EXA[sARG::ARG1].EX = pNODE->EXA[sARG::ARG1].EX;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	LEA_EOP_HASHB4			, 6 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	NOT_IMPLEMENTATION();

	//rREGISTER.EOP.EXA[sARG::ARG0].PTR = pNODE->EXA[sARG::ARG0].PTR;
	rREGISTER.EOP.EXA[sARG::ARG1].EX = pNODE->EXA[sARG::ARG1].EX;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	LEA_EOP_EXA2B4			, 8 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	rREGISTER.EOP.EXA[sARG::ARG0].PTR = pNODE->EXA[sARG::ARG0].PTR;
	rREGISTER.EOP.EXA[sARG::ARG1].EX = pNODE->EXA[sARG::ARG1].EX;

	return sRET::SUCCESS;;
};



//
//	GAME RESOURCE FUNCTION --
//		ÇØ´ç ÀÎÀÚ´Â ECX¿¡ ÁÖ¾îÁø ÇÔ¼ö Æ÷ÀÎÅÍ(16)¿Í ½ºÅÿ¡ ÇÒ´çµÈ °ª Çϳª¸¦ ÀÔ·ÂÇؼ­ È£ÃâÇÑ´Ù.
ADD_IWzASM_HANDLER(	CALL_RC					, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uNode = VM_STACK.Pop();
	rREGISTER.ERP = rEIP.REF.RESFUNC( &uNode );
	//rREGISTER.ERP.CONV =	rEIP.REF.QueryByHandlerFN( rREGISTER.ECX.FN_FN, uNode.CONV );
	return sRET::SUCCESS;;
};

////
////	GAME RESOURCE FUNCTION --
////		ÇØ´ç ÀÎÀÚ´Â ECX¿¡ ÁÖ¾îÁø ÇÔ¼ö Æ÷ÀÎÅÍ(16)¸¦ È£ÃâÇÑ´Ù.
//ADD_IWzASM_HANDLER(	CALL_RD					, 0 )
//{
//	DEBUGGING_OUTPUT();
//	sREGISTER_BLK& rREGISTER = VM_REGISTER;
//	WzASM_STACK& rSTACK = VM_STACK;
//
//	NOT_IMPLEMENTATION();
//	//rREGISTER.ERP.CONV =	rEIP.REF.QueryByHandlerDT( rREGISTER.ECX.FN_DT );
//	return sRET::SUCCESS;;
//};

ADD_IWzASM_HANDLER(	CALL_IBF				, sizeof(WzPTR) )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uNODE = VM_STACK.Pop();
	rREGISTER.ERP.CONV =	pNODE->FN_IB( &uNODE );
	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	CALL_IBF_EFP			, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	uREG_NODE uNODE = VM_STACK.Pop();
	rREGISTER.ERP.CONV =	rREGISTER.EFP.FN_IB( &uNODE );

	return sRET::SUCCESS;;
}

ADD_IWzASM_HANDLER(	RET						, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::RETURN;
};


ADD_IWzASM_HANDLER(	MARK01					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK02					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK03					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK04					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK05					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK06					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK07					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK08					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK09					, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK10					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK11					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK12					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK13					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK14					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK15					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK16					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK17					, 0	)
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK18					, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};

ADD_IWzASM_HANDLER(	MARK19					, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};



ADD_IWzASM_HANDLER(	NOP						, 0 )
{
	DEBUGGING_OUTPUT();
	sREGISTER_BLK& rREGISTER = VM_REGISTER;
	WzASM_STACK& rSTACK = VM_STACK;

	return sRET::SUCCESS;;
};