Index: trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp
===================================================================
--- trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp	(revision 206)
+++ trunk/abdev/BasicCompiler32/NumOpe_Arithmetic.cpp	(revision 225)
@@ -1,3 +1,5 @@
 #include "stdafx.h"
+
+#include <Compiler.h>
 
 #include "../BasicCompiler_Common/common.h"
@@ -10,41 +12,41 @@
 	if(type[sp-1]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 		//fistp qword ptr[esp]
-		op_fistp_ptr_esp( sizeof(_int64) );
+		compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		//pop ecx
-		op_pop(REG_ECX);
+		compiler.codeGenerator.op_pop(REG_ECX);
 	}
 	else if(type[sp-1]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		//fistp qword ptr[esp]
-		op_fistp_ptr_esp( sizeof(_int64) );
+		compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		//pop ecx
-		op_pop(REG_ECX);
+		compiler.codeGenerator.op_pop(REG_ECX);
 	}
 	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		//pop ecx
-		op_pop(REG_ECX);
+		compiler.codeGenerator.op_pop(REG_ECX);
 	}
 	else{
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		if(IsSignedType(type[sp-1])){
@@ -53,5 +55,5 @@
 				
 			//cdq
-			op_cdq();
+			compiler.codeGenerator.op_cdq();
 		}
 		else{
@@ -60,14 +62,12 @@
 
 			//xor edx,edx
-			op_zero_reg(REG_EDX);
+			compiler.codeGenerator.op_zero_reg(REG_EDX);
 		}
 
 		//mov ebx,eax
-		OpBuffer[obp++]=(char)0x8B;
-		OpBuffer[obp++]=(char)0xD8;
+		compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
 
 		//mov ecx,edx
-		OpBuffer[obp++]=(char)0x8B;
-		OpBuffer[obp++]=(char)0xCA;
+		compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
 	}
 
@@ -75,41 +75,41 @@
 	if(type[sp-2]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 		//fistp qword ptr[esp]
-		op_fistp_ptr_esp( sizeof(_int64) );
+		compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//pop edx
-		op_pop(REG_EDX);
+		compiler.codeGenerator.op_pop(REG_EDX);
 	}
 	else if(type[sp-2]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		//fistp qword ptr[esp]
-		op_fistp_ptr_esp( sizeof(_int64) );
+		compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//pop edx
-		op_pop(REG_EDX);
+		compiler.codeGenerator.op_pop(REG_EDX);
 	}
 	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//pop edx
-		op_pop(REG_EDX);
+		compiler.codeGenerator.op_pop(REG_EDX);
 	}
 	else{
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		if(IsSignedType(type[sp-2])){
@@ -118,5 +118,5 @@
 				
 			//cdq
-			op_cdq();
+			compiler.codeGenerator.op_cdq();
 		}
 		else{
@@ -125,5 +125,5 @@
 
 			//xor edx,edx
-			op_zero_reg(REG_EDX);
+			compiler.codeGenerator.op_zero_reg(REG_EDX);
 		}
 	}
@@ -136,14 +136,14 @@
 
 	//push ecx
-	op_push(REG_ECX);
+	compiler.codeGenerator.op_push(REG_ECX);
 
 	//push ebx
-	op_push(REG_EBX);
+	compiler.codeGenerator.op_push(REG_EBX);
 
 	//push edx
-	op_push(REG_EDX);
+	compiler.codeGenerator.op_push(REG_EDX);
 
 	//push eax
-	op_push(REG_EAX);
+	compiler.codeGenerator.op_push(REG_EAX);
 }
 
@@ -167,15 +167,15 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 			//add esp,8
-			op_add_esp(8);
+			compiler.codeGenerator.op_add_esp(8);
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//add esp,4
-			op_add_esp(4);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
 		}
 		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
@@ -183,8 +183,8 @@
 
 			//fild qword ptr[esp]
-			op_fld_ptr_esp(DEF_INT64);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 
 			//add esp,8
-			op_add_esp(8);
+			compiler.codeGenerator.op_add_esp(8);
 		}
 		else{
@@ -192,21 +192,21 @@
 
 			//fild dword ptr[esp]
-			op_fld_ptr_esp(DEF_LONG);
-
-			//add esp,4
-			op_add_esp(4);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
 		}
 
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 		}
 		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
 			//64ビット整数値
-			op_fld_ptr_esp(DEF_INT64);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 		}
 		else{
@@ -214,5 +214,5 @@
 
 			//fild dword ptr[esp]
-			op_fld_ptr_esp(DEF_LONG);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 		}
 
@@ -220,5 +220,5 @@
 			if(AnswerType==DEF_SINGLE){
 				//add esp,4
-				op_add_esp(4);
+				compiler.codeGenerator.op_add_esp(4);
 			}
 		}
@@ -226,5 +226,5 @@
 			if(AnswerType==DEF_DOUBLE){
 				//sub esp,4
-				op_sub_esp(4);
+				compiler.codeGenerator.op_sub_esp(4);
 			}
 		}
@@ -232,29 +232,31 @@
 		if(idCalc==CALC_ADDITION){
 			//faddp st(1),st
-			OpBuffer[obp++]=(char)0xDE;
-			OpBuffer[obp++]=(char)0xC1;
+			compiler.codeGenerator.PutOld(
+				(char)0xDE,
+				(char)0xC1
+			);
 		}
 		else if(idCalc==CALC_SUBTRACTION){
 			//fsubrp st(1),st
-			OpBuffer[obp++]=(char)0xDE;
-			OpBuffer[obp++]=(char)0xE1;
+			compiler.codeGenerator.PutOld(
+				(char)0xDE,
+				(char)0xE1
+			);
 		}
 		else if(idCalc==CALC_PRODUCT){
 			//fmulp st(1),st
-			OpBuffer[obp++]=(char)0xDE;
-			OpBuffer[obp++]=(char)0xC9;
+			compiler.codeGenerator.PutOld(
+				(char)0xDE,
+				(char)0xC9
+			);
 		}
 
 		if(AnswerType==DEF_DOUBLE){
 			//fstp qword ptr[esp]
-			OpBuffer[obp++]=(char)0xDD;
-			OpBuffer[obp++]=(char)0x1C;
-			OpBuffer[obp++]=(char)0x24;
+			compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
 		}
 		else{
 			//fstp dword ptr[esp]
-			OpBuffer[obp++]=(char)0xD9;
-			OpBuffer[obp++]=(char)0x1C;
-			OpBuffer[obp++]=(char)0x24;
+			compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
 		}
 	}
@@ -273,11 +275,11 @@
 			//call _allmul
 			extern const UserProc *pSub_allmul;
-			op_call(pSub_allmul);
+			compiler.codeGenerator.op_call(pSub_allmul);
 
 			//push edx
-			op_push(REG_EDX);
+			compiler.codeGenerator.op_push(REG_EDX);
 
 			//push eax
-			op_push(REG_EAX);
+			compiler.codeGenerator.op_push(REG_EAX);
 		}
 		else{
@@ -286,8 +288,8 @@
 
 				//pop ebx
-				op_pop(REG_EBX);
+				compiler.codeGenerator.op_pop(REG_EBX);
 
 				//pop ecx
-				op_pop(REG_ECX);
+				compiler.codeGenerator.op_pop(REG_ECX);
 			}
 			else{
@@ -295,5 +297,5 @@
 
 				//pop eax
-				op_pop(REG_EAX);
+				compiler.codeGenerator.op_pop(REG_EAX);
 
 				if(IsSignedType(type[sp-1])){
@@ -302,5 +304,5 @@
 					
 					//cdq
-					op_cdq();
+					compiler.codeGenerator.op_cdq();
 				}
 				else{
@@ -309,14 +311,12 @@
 
 					//xor edx,edx
-					op_zero_reg(REG_EDX);
+					compiler.codeGenerator.op_zero_reg(REG_EDX);
 				}
 
 				//mov ebx,eax
-				OpBuffer[obp++]=(char)0x8B;
-				OpBuffer[obp++]=(char)0xD8;
+				compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );
 
 				//mov ecx,edx
-				OpBuffer[obp++]=(char)0x8B;
-				OpBuffer[obp++]=(char)0xCA;
+				compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EDX );
 			}
 
@@ -326,25 +326,33 @@
 				if(idCalc==CALC_ADDITION){
 					//add dword ptr[esp],ebx
-					OpBuffer[obp++]=(char)0x01;
-					OpBuffer[obp++]=(char)0x1C;
-					OpBuffer[obp++]=(char)0x24;
+					compiler.codeGenerator.PutOld(
+						(char)0x01,
+						(char)0x1C,
+						(char)0x24
+					);
 
 					//adc dword ptr[esp+sizeof(long)],ecx
-					OpBuffer[obp++]=(char)0x11;
-					OpBuffer[obp++]=(char)0x4C;
-					OpBuffer[obp++]=(char)0x24;
-					OpBuffer[obp++]=(char)0x04;
+					compiler.codeGenerator.PutOld(
+						(char)0x11,
+						(char)0x4C,
+						(char)0x24,
+						(char)0x04
+					);
 				}
 				else if(idCalc==CALC_SUBTRACTION){
 					//sub dword ptr[esp],ebx
-					OpBuffer[obp++]=(char)0x29;
-					OpBuffer[obp++]=(char)0x1C;
-					OpBuffer[obp++]=(char)0x24;
+					compiler.codeGenerator.PutOld(
+						(char)0x29,
+						(char)0x1C,
+						(char)0x24
+					);
 
 					//sbb dword ptr[esp+sizeof(long)],ecx
-					OpBuffer[obp++]=(char)0x19;
-					OpBuffer[obp++]=(char)0x4C;
-					OpBuffer[obp++]=(char)0x24;
-					OpBuffer[obp++]=(char)0x04;
+					compiler.codeGenerator.PutOld(
+						(char)0x19,
+						(char)0x4C,
+						(char)0x24,
+						(char)0x04
+					);
 				}
 			}
@@ -353,5 +361,5 @@
 
 				//pop eax
-				op_pop(REG_EAX);
+				compiler.codeGenerator.op_pop(REG_EAX);
 
 				if(IsSignedType(type[sp-2])){
@@ -360,5 +368,5 @@
 
 					//cdq
-					op_cdq();
+					compiler.codeGenerator.op_cdq();
 				}
 				else{
@@ -367,31 +375,27 @@
 
 					//xor edx,edx
-					op_zero_reg(REG_EDX);
+					compiler.codeGenerator.op_zero_reg(REG_EDX);
 				}
 
 				if(idCalc==CALC_ADDITION){
 					//add ebx,eax
-					OpBuffer[obp++]=(char)0x03;
-					OpBuffer[obp++]=(char)0xD8;
+					compiler.codeGenerator.op_add_RR( REG_EBX, REG_EAX );
 
 					//adc ecx,edx
-					OpBuffer[obp++]=(char)0x13;
-					OpBuffer[obp++]=(char)0xCA;
+					compiler.codeGenerator.op_adc_RR( REG_ECX, REG_EDX );
 				}
 				else if(idCalc==CALC_SUBTRACTION){
 					//sub ebx,eax
-					OpBuffer[obp++]=(char)0x2B;
-					OpBuffer[obp++]=(char)0xC3;
+					compiler.codeGenerator.op_sub_RR( REG_EBX, REG_EAX );
 
 					//sbb ecx,edx
-					OpBuffer[obp++]=(char)0x1B;
-					OpBuffer[obp++]=(char)0xD1;
+					compiler.codeGenerator.op_sub_RR( REG_ECX, REG_EDX );
 				}
 
 				//push ecx
-				op_push(REG_ECX);
+				compiler.codeGenerator.op_push(REG_ECX);
 
 				//push ebx
-				op_push(REG_EBX);
+				compiler.codeGenerator.op_push(REG_EBX);
 			}
 		}
@@ -403,33 +407,27 @@
 
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		if(idCalc==CALC_ADDITION){
 			//add eax,ebx
-			OpBuffer[obp++]=(char)0x03;
-			OpBuffer[obp++]=(char)0xC3;
+			compiler.codeGenerator.op_add_RR( REG_EAX, REG_EBX );
 		}
 		else if(idCalc==CALC_SUBTRACTION){
 			//sub eax,ebx
-			OpBuffer[obp++]=(char)0x2B;
-			OpBuffer[obp++]=(char)0xC3;
+			compiler.codeGenerator.op_sub_RR( REG_EAX, REG_EBX );
 		}
 		else if(idCalc==CALC_PRODUCT){
 			//imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
-			OpBuffer[obp++]=(char)0x0F;
-			OpBuffer[obp++]=(char)0xAF;
-			OpBuffer[obp++]=(char)0xC3;
+			compiler.codeGenerator.op_imul_RR( REG_EAX, REG_EBX );
 		}
 
 		//mov dword ptr[esp],eax
-		OpBuffer[obp++]=(char)0x89;
-		OpBuffer[obp++]=(char)0x04;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
 	}
 
@@ -463,5 +461,5 @@
 			//call _aullrem
 			extern const UserProc *pSub_aullrem;
-			op_call(pSub_aullrem);
+			compiler.codeGenerator.op_call(pSub_aullrem);
 		}
 		else{
@@ -470,12 +468,12 @@
 			//call _allrem
 			extern const UserProc *pSub_allrem;
-			op_call(pSub_allrem);
+			compiler.codeGenerator.op_call(pSub_allrem);
 		}
 
 		//push edx
-		op_push(REG_EDX);
+		compiler.codeGenerator.op_push(REG_EDX);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		sp--;
@@ -490,68 +488,64 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
 			//xor edx,edx
-			op_zero_reg(REG_EDX);
+			compiler.codeGenerator.op_zero_reg(REG_EDX);
 
 			//div ebx (eax=eax/ebx...edx)
-			OpBuffer[obp++]=(char)0xF7;
-			OpBuffer[obp++]=(char)0xF3;
+			compiler.codeGenerator.op_div_R( REG_EBX );
 		}
 		else{
 			//cdq
-			op_cdq();
+			compiler.codeGenerator.op_cdq();
 
 			//idiv ebx (eax=eax/ebx...edx)
-			OpBuffer[obp++]=(char)0xF7;
-			OpBuffer[obp++]=(char)0xFB;
+			compiler.codeGenerator.op_idiv_R( REG_EBX );
 		}
 
 		//mov dword ptr[esp],edx
-		OpBuffer[obp++]=(char)0x89;
-		OpBuffer[obp++]=(char)0x14;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EDX, REG_ESP, 0, MOD_BASE );
 
 		sp--;
@@ -581,15 +575,15 @@
 	if(type[sp-1]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 		//add esp,8
-		op_add_esp(8);
+		compiler.codeGenerator.op_add_esp(8);
 	}
 	else if(type[sp-1]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 	}
 	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
@@ -597,42 +591,40 @@
 
 		//fild qword ptr[esp]
-		op_fld_ptr_esp(DEF_INT64);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 
 		//add esp,8
-		op_add_esp(8);
+		compiler.codeGenerator.op_add_esp(8);
 	}
 	else if(type[sp-1]==DEF_DWORD){
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//push 0
-		op_push_V(0);
+		compiler.codeGenerator.op_push_V(0);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		//fild qword ptr[esp]
-		OpBuffer[obp++]=(char)0xDF;
-		OpBuffer[obp++]=(char)0x2C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 
 		//add esp,8
-		op_add_esp(8);
+		compiler.codeGenerator.op_add_esp(8);
 	}
 	else{
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 	}
 
 	if(type[sp-2]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 	}
 	else if(type[sp-2]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 	}
 	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
@@ -640,24 +632,22 @@
 
 		//fild qword ptr[esp]
-		op_fld_ptr_esp(DEF_INT64);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 	}
 	else if(type[sp-2]==DEF_DWORD){
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//push 0
-		op_push_V(0);
+		compiler.codeGenerator.op_push_V(0);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		//fild qword ptr[esp]
-		OpBuffer[obp++]=(char)0xDF;
-		OpBuffer[obp++]=(char)0x2C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 	}
 	else{	//Long
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 	}
                                                             //↓ここだけ例外DWord
@@ -665,5 +655,5 @@
 		if(AnswerType==DEF_SINGLE){
 			//add esp,4
-			op_add_esp(4);
+			compiler.codeGenerator.op_add_esp(4);
 		}
 	}
@@ -671,18 +661,18 @@
 		if(AnswerType==DEF_DOUBLE){
 			//sub esp,4
-			op_sub_esp(4);
+			compiler.codeGenerator.op_sub_esp(4);
 		}
 	}
 
 	//fdivrp st(1),st
-	OpBuffer[obp++]=(char)0xDE;
-	OpBuffer[obp++]=(char)0xF1;
+	compiler.codeGenerator.PutOld(
+		(char)0xDE,
+		(char)0xF1
+	);
 
 	sp--;
 	if(AnswerType==DEF_DOUBLE){
 		//fstp qword ptr[esp]
-		OpBuffer[obp++]=(char)0xDD;
-		OpBuffer[obp++]=(char)0x1C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
 
 		type[sp-1]=DEF_DOUBLE;
@@ -690,7 +680,5 @@
 	else{
 		//fstp dword ptr[esp]
-		OpBuffer[obp++]=(char)0xD9;
-		OpBuffer[obp++]=(char)0x1C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
 
 		type[sp-1]=DEF_SINGLE;
@@ -723,5 +711,5 @@
 			//call _aulldiv
 			extern const UserProc *pSub_aulldiv;
-			op_call(pSub_aulldiv);
+			compiler.codeGenerator.op_call(pSub_aulldiv);
 		}
 		else{
@@ -730,12 +718,12 @@
 			//call _alldiv
 			extern const UserProc *pSub_alldiv;
-			op_call(pSub_alldiv);
+			compiler.codeGenerator.op_call(pSub_alldiv);
 		}
 
 		//push edx
-		op_push(REG_EDX);
+		compiler.codeGenerator.op_push(REG_EDX);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		sp--;
@@ -750,46 +738,46 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop ebx
-		op_pop(REG_EBX);
+		compiler.codeGenerator.op_pop(REG_EBX);
 
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)||
@@ -797,23 +785,19 @@
 			(type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
 			//xor edx,edx
-			op_zero_reg(REG_EDX);
+			compiler.codeGenerator.op_zero_reg(REG_EDX);
 
 			//div ebx (eax=eax/ebx...edx)
-			OpBuffer[obp++]=(char)0xF7;
-			OpBuffer[obp++]=(char)0xF3;
+			compiler.codeGenerator.op_div_R( REG_EBX );
 		}
 		else{
 			//cdq
-			op_cdq();
+			compiler.codeGenerator.op_cdq();
 
 			//idiv ebx (eax=eax/ebx...edx)
-			OpBuffer[obp++]=(char)0xF7;
-			OpBuffer[obp++]=(char)0xFB;
+			compiler.codeGenerator.op_idiv_R( REG_EBX );
 		}
 
 		//mov dword ptr[esp],eax
-		OpBuffer[obp++]=(char)0x89;
-		OpBuffer[obp++]=(char)0x04;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
 
 		sp--;
@@ -833,71 +817,67 @@
 	if(type[sp-1]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 		//push -1
-		op_push_V(-1);
+		compiler.codeGenerator.op_push_V(-1);
 
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 
 		//fmulp st(1),st
-		OpBuffer[obp++]=(char)0xDE;
-		OpBuffer[obp++]=(char)0xC9;
+		compiler.codeGenerator.PutOld(
+			(char)0xDE,
+			(char)0xC9
+		);
 
 		//fstp qword ptr[esp]
-		OpBuffer[obp++]=(char)0xDD;
-		OpBuffer[obp++]=(char)0x1C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
 	}
 	else if(type[sp-1]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//push -1
-		op_push_V(-1);
+		compiler.codeGenerator.op_push_V(-1);
 
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 
 		//fmulp st(1),st
-		OpBuffer[obp++]=(char)0xDE;
-		OpBuffer[obp++]=(char)0xC9;
+		compiler.codeGenerator.PutOld(
+			(char)0xDE,
+			(char)0xC9
+		);
 
 		//fstp dword ptr[esp]
-		OpBuffer[obp++]=(char)0xD9;
-		OpBuffer[obp++]=(char)0x1C;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_fstp_basereg( DEF_SINGLE, REG_ESP );
 	}
 	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//neg eax
-		OpBuffer[obp++]=(char)0xF7;
-		OpBuffer[obp++]=(char)0xD8;
+		compiler.codeGenerator.op_neg( REG_EAX );
 
 		//pop edx
-		op_pop(REG_EDX);
+		compiler.codeGenerator.op_pop(REG_EDX);
 
 		//adc edx,0
-		OpBuffer[obp++]=(char)0x83;
-		OpBuffer[obp++]=(char)0xD2;
-		OpBuffer[obp++]=(char)0x00;
+		compiler.codeGenerator.op_adc_RV8(REG_EDX,0);
 
 		//neg edx
-		OpBuffer[obp++]=(char)0xF7;
-		OpBuffer[obp++]=(char)0xDA;
+		compiler.codeGenerator.op_neg( REG_EDX );
 
 		//push edx
-		op_push(REG_EDX);
+		compiler.codeGenerator.op_push(REG_EDX);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		type[sp-1]=DEF_INT64;	//QWordはInt64へ
@@ -905,13 +885,11 @@
 	else if(IsWholeNumberType(type[sp-1])){
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//imul eax,-1
-		OpBuffer[obp++]=(char)0x6B;
-		OpBuffer[obp++]=(char)0xC0;
-		OpBuffer[obp++]=(char)0xFF;
+		compiler.codeGenerator.op_imul_RV8( REG_EAX, -1 );
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		type[sp-1]=GetSignedType(type[sp-1]);
@@ -929,15 +907,15 @@
 	if(type[sp-1]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 		//add esp,8
-		op_add_esp(8);
+		compiler.codeGenerator.op_add_esp(8);
 	}
 	else if(type[sp-1]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 	}
 	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
@@ -945,8 +923,8 @@
 
 		//fild qword ptr[esp]
-		op_fld_ptr_esp(DEF_INT64);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 
 		//add esp,8
-		op_add_esp(8);
+		compiler.codeGenerator.op_add_esp(8);
 	}
 	else{
@@ -954,20 +932,20 @@
 
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 
 		//add esp,4
-		op_add_esp(4);
+		compiler.codeGenerator.op_add_esp(4);
 	}
 
 	if(type[sp-2]==DEF_DOUBLE){
 		//fld qword ptr[esp]
-		op_fld_ptr_esp(DEF_DOUBLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 	}
 	else if(type[sp-2]==DEF_SINGLE){
 		//fld dword ptr[esp]
-		op_fld_ptr_esp(DEF_SINGLE);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 	}
 	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
@@ -975,5 +953,5 @@
 
 		//fild qword ptr[esp]
-		op_fld_ptr_esp(DEF_INT64);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
 	}
 	else{
@@ -981,35 +959,28 @@
 
 		//fild dword ptr[esp]
-		op_fld_ptr_esp(DEF_LONG);
+		compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 	}
 
 	//sub esp,8
-	op_sub_esp(8);
+	compiler.codeGenerator.op_sub_esp(8);
 
 	//fstp qword ptr[esp]
-	OpBuffer[obp++]=(char)0xDD;
-	OpBuffer[obp++]=(char)0x1C;
-	OpBuffer[obp++]=(char)0x24;
+	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
 
 	//fstp qword ptr[esp+8]
-	OpBuffer[obp++]=(char)0xDD;
-	OpBuffer[obp++]=(char)0x5C;
-	OpBuffer[obp++]=(char)0x24;
-	OpBuffer[obp++]=(char)0x08;
+	compiler.codeGenerator.op_fstp_base_offset(DEF_DOUBLE,REG_ESP,8);
 
 	//call pow
 	extern const UserProc *pSub_pow;
-	op_call(pSub_pow);
+	compiler.codeGenerator.op_call(pSub_pow);
 
 	//sub esp,8
-	op_sub_esp(8);
+	compiler.codeGenerator.op_sub_esp(8);
 
 	//fstp qword ptr[esp]
-	OpBuffer[obp++]=(char)0xDD;
-	OpBuffer[obp++]=(char)0x1C;
-	OpBuffer[obp++]=(char)0x24;
+	compiler.codeGenerator.op_fstp_basereg( DEF_DOUBLE, REG_ESP );
 
 	sp--;
@@ -1067,35 +1038,35 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 			//pop ecx
-			op_pop(REG_ECX);
-
-			//add esp,4
-			op_add_esp(4);
-		}
-		else{
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_pop(REG_ECX);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+		}
+		else{
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 
@@ -1103,41 +1074,41 @@
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 			//fistp qword ptr[esp]
-			op_fistp_ptr_esp( sizeof(_int64) );
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 			//sub esp,4
-			op_sub_esp(4);
+			compiler.codeGenerator.op_sub_esp(4);
 
 			//fistp qword ptr[esp]
-			op_fistp_ptr_esp( sizeof(_int64) );
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else{
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			if(IsSignedType(type[sp-2])){
@@ -1146,5 +1117,5 @@
 					
 				//cdq
-				op_cdq();
+				compiler.codeGenerator.op_cdq();
 			}
 			else{
@@ -1153,5 +1124,5 @@
 
 				//xor edx,edx
-				op_zero_reg(REG_EDX);
+				compiler.codeGenerator.op_zero_reg(REG_EDX);
 			}
 		}
@@ -1159,11 +1130,11 @@
 		//call _allshl
 		extern const UserProc *pSub_allshl;
-		op_call(pSub_allshl);
+		compiler.codeGenerator.op_call(pSub_allshl);
 
 		//push edx
-		op_push(REG_EDX);
+		compiler.codeGenerator.op_push(REG_EDX);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		sp--;
@@ -1177,69 +1148,69 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 			//pop ecx
-			op_pop(REG_ECX);
-
-			//add esp,4
-			op_add_esp(4);
-		}
-		else{
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_pop(REG_ECX);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+		}
+		else{
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		//shl eax,cl
-		OpBuffer[obp++]=(char)0xD3;
-		OpBuffer[obp++]=(char)0xE0;
+		compiler.codeGenerator.PutOld(
+			(char)0xD3,
+			(char)0xE0
+		);
 
 		//mov dword ptr[esp],eax
-		OpBuffer[obp++]=(char)0x89;
-		OpBuffer[obp++]=(char)0x04;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
 
 		sp--;
@@ -1269,35 +1240,35 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 			//pop ecx
-			op_pop(REG_ECX);
-
-			//add esp,4
-			op_add_esp(4);
-		}
-		else{
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_pop(REG_ECX);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+		}
+		else{
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 
@@ -1305,41 +1276,41 @@
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
 
 			//fistp qword ptr[esp]
-			op_fistp_ptr_esp( sizeof(_int64) );
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
 
 			//sub esp,4
-			op_sub_esp(4);
+			compiler.codeGenerator.op_sub_esp(4);
 
 			//fistp qword ptr[esp]
-			op_fistp_ptr_esp( sizeof(_int64) );
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(_int64) );
 
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			//pop edx
-			op_pop(REG_EDX);
+			compiler.codeGenerator.op_pop(REG_EDX);
 		}
 		else{
 			//pop eax
-			op_pop(REG_EAX);
+			compiler.codeGenerator.op_pop(REG_EAX);
 
 			if(IsSignedType(type[sp-2])){
@@ -1348,5 +1319,5 @@
 
 				//cdq
-				op_cdq();
+				compiler.codeGenerator.op_cdq();
 			}
 			else{
@@ -1355,5 +1326,5 @@
 
 				//xor edx,edx
-				op_zero_reg(REG_EDX);
+				compiler.codeGenerator.op_zero_reg(REG_EDX);
 			}
 		}
@@ -1364,5 +1335,5 @@
 			//call _aullshr
 			extern const UserProc *pSub_aullshr;
-			op_call(pSub_aullshr);
+			compiler.codeGenerator.op_call(pSub_aullshr);
 		}
 		else{
@@ -1371,12 +1342,12 @@
 			//call _allshr
 			extern const UserProc *pSub_allshr;
-			op_call(pSub_allshr);
+			compiler.codeGenerator.op_call(pSub_allshr);
 		}
 
 		//push edx
-		op_push(REG_EDX);
+		compiler.codeGenerator.op_push(REG_EDX);
 
 		//push eax
-		op_push(REG_EAX);
+		compiler.codeGenerator.op_push(REG_EAX);
 
 		sp--;
@@ -1390,76 +1361,78 @@
 		if(type[sp-1]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
-
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
+
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
 			//pop ecx
-			op_pop(REG_ECX);
-
-			//add esp,4
-			op_add_esp(4);
-		}
-		else{
-			//pop ecx
-			op_pop(REG_ECX);
+			compiler.codeGenerator.op_pop(REG_ECX);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+		}
+		else{
+			//pop ecx
+			compiler.codeGenerator.op_pop(REG_ECX);
 		}
 
 		if(type[sp-2]==DEF_DOUBLE){
 			//fld qword ptr[esp]
-			op_fld_ptr_esp(DEF_DOUBLE);
-
-			//add esp,4
-			op_add_esp(4);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
+
+			//add esp,4
+			compiler.codeGenerator.op_add_esp(4);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 		else if(type[sp-2]==DEF_SINGLE){
 			//fld dword ptr[esp]
-			op_fld_ptr_esp(DEF_SINGLE);
-
-			//fistp dword ptr[esp]
-			op_fistp_ptr_esp( sizeof(long) );
+			compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
+
+			//fistp dword ptr[esp]
+			compiler.codeGenerator.op_fistp_ptr_esp( sizeof(long) );
 		}
 
 		//pop eax
-		op_pop(REG_EAX);
+		compiler.codeGenerator.op_pop(REG_EAX);
 
 		//sub esp,4
-		op_sub_esp(4);
+		compiler.codeGenerator.op_sub_esp(4);
 
 		if(type[sp-2]==DEF_DWORD){
 			//shr eax,cl
-			OpBuffer[obp++]=(char)0xD3;
-			OpBuffer[obp++]=(char)0xE8;
+			compiler.codeGenerator.PutOld(
+				(char)0xD3,
+				(char)0xE8
+			);
 		}
 		else{
 			//sar eax,cl
-			OpBuffer[obp++]=(char)0xD3;
-			OpBuffer[obp++]=(char)0xF8;
+			compiler.codeGenerator.PutOld(
+				(char)0xD3,
+				(char)0xF8
+			);
 		}
 
 		//mov dword ptr[esp],eax
-		OpBuffer[obp++]=(char)0x89;
-		OpBuffer[obp++]=(char)0x04;
-		OpBuffer[obp++]=(char)0x24;
+		compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
 
 		sp--;
